diff --git a/applications/utilities/preProcessing/mapFieldsPar/mapFieldsPar.C b/applications/utilities/preProcessing/mapFieldsPar/mapFieldsPar.C
index 3a4ee7068c..020a652c17 100644
--- a/applications/utilities/preProcessing/mapFieldsPar/mapFieldsPar.C
+++ b/applications/utilities/preProcessing/mapFieldsPar/mapFieldsPar.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2023 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -34,7 +34,7 @@ Description
 #include "fvMeshToFvMesh.H"
 #include "mapGeometricFields.H"
 #include "mapClouds.H"
-#include "cellVolumeWeightMethod.H"
+#include "intersectionCellsToCells.H"
 
 using namespace Foam;
 
@@ -56,12 +56,7 @@ void mapConsistentMesh
 
     Info<< nl << "Mapping geometric fields" << endl;
 
-    mapGeometricFields
-    (
-        interp,
-        selectedFields,
-        noLagrangian
-    );
+    mapGeometricFields(interp, wordReList(), selectedFields, noLagrangian);
 
     if (!noLagrangian)
     {
@@ -70,12 +65,12 @@ void mapConsistentMesh
 }
 
 
-void mapSubMesh
+void mapMesh
 (
     const fvMesh& srcMesh,
     const fvMesh& tgtMesh,
     const HashTable<word>& patchMap,
-    const wordList& cuttingPatches,
+    const wordReList& cuttingPatches,
     const word& mapMethod,
     const HashSet<word>& selectedFields,
     const bool noLagrangian
@@ -84,23 +79,11 @@ void mapSubMesh
     Info<< nl << "Creating and mapping fields for time "
         << srcMesh.time().name() << nl << endl;
 
-    fvMeshToFvMesh interp
-    (
-        srcMesh,
-        tgtMesh,
-        mapMethod,
-        patchMap,
-        cuttingPatches
-    );
+    fvMeshToFvMesh interp(srcMesh, tgtMesh, mapMethod, patchMap);
 
     Info<< nl << "Mapping geometric fields" << endl;
 
-    mapGeometricFields
-    (
-        interp,
-        selectedFields,
-        noLagrangian
-    );
+    mapGeometricFields(interp, cuttingPatches, selectedFields, noLagrangian);
 
     if (!noLagrangian)
     {
@@ -194,7 +177,7 @@ int main(int argc, char *argv[])
         args.optionLookupOrDefault<word>
         (
             "mapMethod",
-            cellVolumeWeightMethod::typeName
+            cellsToCellss::intersection::typeName
         )
     );
     Info<< "Mapping method: " << mapMethod << endl;
@@ -210,7 +193,7 @@ int main(int argc, char *argv[])
     #include "createTimes.H"
 
     HashTable<word> patchMap;
-    wordList cuttingPatches;
+    wordReList cuttingPatches;
 
     if (!consistent)
     {
@@ -276,7 +259,7 @@ int main(int argc, char *argv[])
     }
     else
     {
-        mapSubMesh
+        mapMesh
         (
             srcMesh,
             tgtMesh,
diff --git a/applications/utilities/preProcessing/mapFieldsPar/mapGeometricFields.C b/applications/utilities/preProcessing/mapFieldsPar/mapGeometricFields.C
index 40cb4fd77a..68fecf12e3 100644
--- a/applications/utilities/preProcessing/mapFieldsPar/mapGeometricFields.C
+++ b/applications/utilities/preProcessing/mapFieldsPar/mapGeometricFields.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2023 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -35,94 +35,13 @@ License
 namespace Foam
 {
 
-template<class Type>
-void evaluateConstraintTypes(VolField<Type>& fld)
-{
-    typename VolField<Type>::
-        Boundary& fldBf = fld.boundaryFieldRef();
-
-    if
-    (
-        Pstream::defaultCommsType == Pstream::commsTypes::blocking
-     || Pstream::defaultCommsType == Pstream::commsTypes::nonBlocking
-    )
-    {
-        label nReq = Pstream::nRequests();
-
-        forAll(fldBf, patchi)
-        {
-            fvPatchField<Type>& tgtField = fldBf[patchi];
-
-            if
-            (
-                tgtField.type() == tgtField.patch().patch().type()
-             && polyPatch::constraintType(tgtField.patch().patch().type())
-            )
-            {
-                tgtField.initEvaluate(Pstream::defaultCommsType);
-            }
-        }
-
-        // Block for any outstanding requests
-        if
-        (
-            Pstream::parRun()
-         && Pstream::defaultCommsType == Pstream::commsTypes::nonBlocking
-        )
-        {
-            Pstream::waitRequests(nReq);
-        }
-
-        forAll(fldBf, patchi)
-        {
-            fvPatchField<Type>& tgtField = fldBf[patchi];
-
-            if
-            (
-                tgtField.type() == tgtField.patch().patch().type()
-             && polyPatch::constraintType(tgtField.patch().patch().type())
-            )
-            {
-                tgtField.evaluate(Pstream::defaultCommsType);
-            }
-        }
-    }
-    else if (Pstream::defaultCommsType == Pstream::commsTypes::scheduled)
-    {
-        const lduSchedule& patchSchedule =
-            fld.mesh().globalData().patchSchedule();
-
-        forAll(patchSchedule, patchEvali)
-        {
-            label patchi = patchSchedule[patchEvali].patch;
-            fvPatchField<Type>& tgtField = fldBf[patchi];
-
-            if
-            (
-                tgtField.type() == tgtField.patch().patch().type()
-             && polyPatch::constraintType(tgtField.patch().patch().type())
-            )
-            {
-                if (patchSchedule[patchEvali].init)
-                {
-                    tgtField.initEvaluate(Pstream::commsTypes::scheduled);
-                }
-                else
-                {
-                    tgtField.evaluate(Pstream::commsTypes::scheduled);
-                }
-            }
-        }
-    }
-}
-
-
 template<class Type>
 void mapVolTypeFields
 (
-    const IOobjectList& objects,
+    const fvMeshToFvMesh& interp,
+    const wordReList& cuttingPatches,
     const HashSet<word>& selectedFields,
-    const fvMeshToFvMesh& interp
+    const IOobjectList& objects
 )
 {
     const fvMesh& srcMesh = static_cast<const fvMesh&>(interp.srcMesh());
@@ -134,106 +53,95 @@ void mapVolTypeFields
     {
         const word& fieldName = fieldIter()->name();
 
-        if (selectedFields.empty() || selectedFields.found(fieldName))
+        if (!selectedFields.empty() && !selectedFields.found(fieldName))
         {
-            const VolField<Type> fieldSource(*fieldIter(), srcMesh);
+            continue;
+        }
 
-            typeIOobject<VolField<Type>> targetIO
+        const VolField<Type> fieldSource(*fieldIter(), srcMesh);
+
+        typeIOobject<VolField<Type>> targetIO
+        (
+            fieldName,
+            tgtMesh.time().name(),
+            tgtMesh,
+            IOobject::READ_IF_PRESENT
+        );
+
+        // Warnings about inconsistent execution
+        if (targetIO.headerOk() && interp.consistent())
+        {
+            WarningInFunction
+                << "Mapping of field " << fieldName << " will not utilise "
+                << "the corresponding field in the target case, as the map is "
+                << "consistent (i.e., all patches are mapped)" << endl;
+        }
+        if (!targetIO.headerOk() && !interp.consistent())
+        {
+            WarningInFunction
+                << "Cannot map field " << fieldName << " because the "
+                << "map is not consistent (i.e., not all patches are "
+                << "mapped), and there is no corresponding field in "
+                << "the target case" << endl;
+            continue;
+        }
+        if (!targetIO.headerOk() && !cuttingPatches.empty())
+        {
+            WarningInFunction
+                << "Cutting patches will not be used for field " << fieldName
+                << " because no there is no corresponding field in the target "
+                << "case" << endl;
+        }
+
+        if (targetIO.headerOk())
+        {
+            Info<< "    mapping into existing field " << fieldName << endl;
+
+            VolField<Type> fieldTarget(targetIO, tgtMesh);
+
+            fieldTarget.reset
             (
-                fieldName,
-                tgtMesh.time().name(),
-                tgtMesh,
-                IOobject::MUST_READ
+                interp.srcToTgt(fieldSource, fieldTarget, cuttingPatches)
             );
 
-            if (targetIO.headerOk())
-            {
-                Info<< "    interpolating onto existing field "
-                    << fieldName << endl;
-                VolField<Type> fieldTarget(targetIO, tgtMesh);
+            fieldTarget.write();
+        }
+        else
+        {
+            Info<< "    creating new field " << fieldName << endl;
 
-                interp.mapSrcToTgt(fieldSource, fieldTarget);
-
-                evaluateConstraintTypes(fieldTarget);
-
-                fieldTarget.write();
-            }
-            else
-            {
-                Info<< "    creating new field "
-                    << fieldName << endl;
-
-                targetIO.readOpt() = IOobject::NO_READ;
-
-                tmp<VolField<Type>> tfieldTarget
-                (
-                    interp.mapSrcToTgt(fieldSource)
-                );
-
-                VolField<Type> fieldTarget(targetIO, tfieldTarget);
-
-                evaluateConstraintTypes(fieldTarget);
-
-                fieldTarget.write();
-            }
+            VolField<Type>(targetIO, interp.srcToTgt(fieldSource)).write();
         }
     }
 }
 
-
-template<class Type, template<class> class GeoField>
-void unMappedTypeFields(const IOobjectList& objects)
-{
-    IOobjectList fields = objects.lookupClass(GeoField<Type>::typeName);
-
-    forAllConstIter(IOobjectList, fields, fieldIter)
-    {
-        mvBak(fieldIter()->objectPath(false), "unmapped");
-    }
 }
 
-} // End namespace Foam
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 void Foam::mapGeometricFields
 (
     const fvMeshToFvMesh& interp,
+    const wordReList& cuttingPatches,
     const HashSet<word>& selectedFields,
     const bool noLagrangian
 )
 {
+    // Search for list of source objects for this time
     const polyMesh& srcMesh = interp.srcMesh();
-    const polyMesh& tgtMesh = interp.tgtMesh();
+    IOobjectList objects(srcMesh, srcMesh.time().name());
 
-    {
-        // Search for list of source objects for this time
-        IOobjectList objects(srcMesh, srcMesh.time().name());
-
-        // Map the fields
-        #define MapVolTypeFields(Type, nullArg)                                \
-            mapVolTypeFields<Type>                                             \
-            (                                                                  \
-                objects,                                                       \
-                selectedFields,                                                \
-                interp                                                         \
-            );
-        FOR_ALL_FIELD_TYPES(MapVolTypeFields);
-        #undef MapVolTypeFields
-    }
-
-    {
-        // Search for list of target objects for this time
-        IOobjectList objects(tgtMesh, tgtMesh.time().name());
-
-        // Mark surface and point fields as unmapped
-        #define UnMappedTypeFields(Type, GeoField)                             \
-            unMappedTypeFields<Type, GeoField>(objects);
-        FOR_ALL_FIELD_TYPES(UnMappedTypeFields, SurfaceField);
-        FOR_ALL_FIELD_TYPES(UnMappedTypeFields, PointField);
-        #undef UnMappedTypeFields
-    }
+    // Map the fields
+    #define MapVolTypeFields(Type, nullArg)                                    \
+        mapVolTypeFields<Type>                                                 \
+        (                                                                      \
+            interp,                                                            \
+            cuttingPatches,                                                    \
+            selectedFields,                                                    \
+            objects                                                            \
+        );
+    FOR_ALL_FIELD_TYPES(MapVolTypeFields);
+    #undef MapVolTypeFields
 }
 
 
diff --git a/applications/utilities/preProcessing/mapFieldsPar/mapGeometricFields.H b/applications/utilities/preProcessing/mapFieldsPar/mapGeometricFields.H
index 039fadc6a4..cd823f125e 100644
--- a/applications/utilities/preProcessing/mapFieldsPar/mapGeometricFields.H
+++ b/applications/utilities/preProcessing/mapFieldsPar/mapGeometricFields.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2023 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -47,6 +47,7 @@ class fvMeshToFvMesh;
 void mapGeometricFields
 (
     const fvMeshToFvMesh& interp,
+    const wordReList& cuttingPatches,
     const HashSet<word>& selectedFields,
     const bool noLagrangian
 );
diff --git a/src/finiteVolume/Make/files b/src/finiteVolume/Make/files
index 4e299686aa..47bbcbe6be 100644
--- a/src/finiteVolume/Make/files
+++ b/src/finiteVolume/Make/files
@@ -517,5 +517,7 @@ solver/solverNew.C
 
 fvMeshToFvMesh/fvMeshToFvMesh.C
 fvMeshToFvMesh/patchToPatchFvPatchFieldMapper.C
+fvMeshToFvMesh/patchToPatchLeftOverFvPatchFieldMapper.C
+fvMeshToFvMesh/patchToPatchNormalisedFvPatchFieldMapper.C
 
 LIB = $(FOAM_LIBBIN)/libfiniteVolume
diff --git a/src/finiteVolume/fvMeshToFvMesh/fvMeshToFvMesh.H b/src/finiteVolume/fvMeshToFvMesh/fvMeshToFvMesh.H
index 2adcb32383..36f0a88dda 100644
--- a/src/finiteVolume/fvMeshToFvMesh/fvMeshToFvMesh.H
+++ b/src/finiteVolume/fvMeshToFvMesh/fvMeshToFvMesh.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2022-2023 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -50,6 +50,15 @@ class fvMeshToFvMesh
 :
     public meshToMesh
 {
+private:
+
+    // Private Member Functions
+
+        //- Evaluate constraint types for the given vol field
+        template<class Type>
+        static void evaluateConstraintTypes(VolField<Type>& fld);
+
+
 public:
 
     //- Run-time type information
@@ -68,48 +77,47 @@ public:
 
     // Member Functions
 
-        // Evaluation
+        // Interpolation
 
-            // Source-to-target volume field mapping
+            //- Interpolate a source vol field to the target with no left
+            //  over values specified. If the interpolation weight sum is less
+            //  than one for a face then they will be normalised. If the
+            //  interpolation weight sum is zero for a face then that face's
+            //  value will be NaN.
+            template<class Type>
+            tmp<VolField<Type>> srcToTgt
+            (
+                const VolField<Type>& srcFld
+            ) const;
 
-                //- Interpolate a field with a defined operation. Values
-                //  passed in via 'result' are used to initialise the return
-                //  value.
-                template<class Type>
-                void mapSrcToTgt
-                (
-                    const VolField<Type>& field,
-                    VolField<Type>& result
-                ) const;
+            //- Interpolate a source vol field to the target with left over
+            //  values specified. If the interpolation weight sum is less than
+            //  one for a face then the average will include the left over
+            //  value multiplied by one minus the weight sum.
+            template<class Type>
+            tmp<VolField<Type>> srcToTgt
+            (
+                const VolField<Type>& srcFld,
+                const VolField<Type>& leftOverTgtFld,
+                const UList<wordRe>& tgtCuttingPatches
+            ) const;
 
-                //- Interpolate a field with a defined operation. The initial
-                //  values of the result are set to zero.
-                template<class Type>
-                tmp<VolField<Type>> mapSrcToTgt
-                (
-                    const VolField<Type>& field
-                ) const;
+            //- Interpolate a source vol internal field to the target with no
+            //  left over values specified. As the corresponding srcToTgt.
+            template<class Type>
+            tmp<VolInternalField<Type>> srcToTgt
+            (
+                const VolInternalField<Type>& srcFld
+            ) const;
 
-
-            // Source-to-target volume internal field mapping
-
-                //- Interpolate a field with a defined operation. Values
-                //  passed in via 'result' are used to initialise the return
-                //  value.
-                template<class Type>
-                void mapSrcToTgt
-                (
-                    const VolInternalField<Type>& field,
-                    VolInternalField<Type>& result
-                ) const;
-
-                //- Interpolate a field with a defined operation. The initial
-                //  values of the result are set to zero.
-                template<class Type>
-                tmp<VolInternalField<Type>> mapSrcToTgt
-                (
-                    const VolInternalField<Type>& field
-                ) const;
+            //- Interpolate a source vol internal field to the target with left
+            //  over values specified. As the corresponding srcToTgt.
+            template<class Type>
+            tmp<VolInternalField<Type>> srcToTgt
+            (
+                const VolInternalField<Type>& srcFld,
+                const VolInternalField<Type>& leftOverTgtFld
+            ) const;
 };
 
 
diff --git a/src/finiteVolume/fvMeshToFvMesh/fvMeshToFvMeshTemplates.C b/src/finiteVolume/fvMeshToFvMesh/fvMeshToFvMeshTemplates.C
index 252fe70bb7..109ea25ec9 100644
--- a/src/finiteVolume/fvMeshToFvMesh/fvMeshToFvMeshTemplates.C
+++ b/src/finiteVolume/fvMeshToFvMesh/fvMeshToFvMeshTemplates.C
@@ -26,78 +26,105 @@ License
 #include "fvMeshToFvMesh.H"
 #include "directFvPatchFieldMapper.H"
 #include "identityFvPatchFieldMapper.H"
-#include "patchToPatchFvPatchFieldMapper.H"
+#include "patchToPatchNormalisedFvPatchFieldMapper.H"
+#include "patchToPatchLeftOverFvPatchFieldMapper.H"
 
-// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
 template<class Type>
-void Foam::fvMeshToFvMesh::mapSrcToTgt
-(
-    const VolField<Type>& field,
-    VolField<Type>& result
-) const
+void Foam::fvMeshToFvMesh::evaluateConstraintTypes(VolField<Type>& fld)
 {
-    meshToMesh::mapSrcToTgt(field, result.primitiveFieldRef());
+    typename VolField<Type>::Boundary& fldBf = fld.boundaryFieldRef();
 
-    typename VolField<Type>::
-        Boundary& resultBf = result.boundaryFieldRef();
-
-    forAll(srcToTgtPatchIDs(), i)
+    if
+    (
+        Pstream::defaultCommsType == Pstream::commsTypes::blocking
+     || Pstream::defaultCommsType == Pstream::commsTypes::nonBlocking
+    )
     {
-        const label srcPatchi = srcToTgtPatchIDs()[i].first();
-        const label tgtPatchi = srcToTgtPatchIDs()[i].second();
+        label nReq = Pstream::nRequests();
 
-        const fvPatchField<Type>& srcField = field.boundaryField()[srcPatchi];
-        fvPatchField<Type>& tgtField = resultBf[tgtPatchi];
+        forAll(fldBf, patchi)
+        {
+            fvPatchField<Type>& tgtField = fldBf[patchi];
 
-        // Clone and map
-        tmp<fvPatchField<Type>> tnewTgt
-        (
-            fvPatchField<Type>::New
+            if
             (
-                srcField,
-                tgtField.patch(),
-                result(),
-                patchToPatchFvPatchFieldMapper
-                (
-                    srcToTgtPatchToPatches()[i],
-                    true
-                )
+                tgtField.type() == tgtField.patch().patch().type()
+             && polyPatch::constraintType(tgtField.patch().patch().type())
             )
-        );
+            {
+                tgtField.initEvaluate(Pstream::defaultCommsType);
+            }
+        }
 
-        // Transfer all mapped quantities (value and e.g. gradient) onto
-        // tgtField. Value will get overwritten below.
-        tgtField.map(tnewTgt(), identityFvPatchFieldMapper());
+        // Block for any outstanding requests
+        if
+        (
+            Pstream::parRun()
+         && Pstream::defaultCommsType == Pstream::commsTypes::nonBlocking
+        )
+        {
+            Pstream::waitRequests(nReq);
+        }
+
+        forAll(fldBf, patchi)
+        {
+            fvPatchField<Type>& tgtField = fldBf[patchi];
+
+            if
+            (
+                tgtField.type() == tgtField.patch().patch().type()
+             && polyPatch::constraintType(tgtField.patch().patch().type())
+            )
+            {
+                tgtField.evaluate(Pstream::defaultCommsType);
+            }
+        }
     }
-
-    forAll(tgtCuttingPatchIDs(), i)
+    else if (Pstream::defaultCommsType == Pstream::commsTypes::scheduled)
     {
-        const label patchi = tgtCuttingPatchIDs()[i];
-        fvPatchField<Type>& pf = resultBf[patchi];
-        pf == pf.patchInternalField();
+        const lduSchedule& patchSchedule =
+            fld.mesh().globalData().patchSchedule();
+
+        forAll(patchSchedule, patchEvali)
+        {
+            label patchi = patchSchedule[patchEvali].patch;
+            fvPatchField<Type>& tgtField = fldBf[patchi];
+
+            if
+            (
+                tgtField.type() == tgtField.patch().patch().type()
+             && polyPatch::constraintType(tgtField.patch().patch().type())
+            )
+            {
+                if (patchSchedule[patchEvali].init)
+                {
+                    tgtField.initEvaluate(Pstream::commsTypes::scheduled);
+                }
+                else
+                {
+                    tgtField.evaluate(Pstream::commsTypes::scheduled);
+                }
+            }
+        }
     }
 }
 
 
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
 template<class Type>
-Foam::tmp<Foam::VolField<Type>>
-Foam::fvMeshToFvMesh::mapSrcToTgt
+Foam::tmp<Foam::VolField<Type>> Foam::fvMeshToFvMesh::srcToTgt
 (
-    const VolField<Type>& field
+    const VolField<Type>& srcFld
 ) const
 {
     const fvMesh& tgtMesh = static_cast<const fvMesh&>(meshToMesh::tgtMesh());
 
-    const fvBoundaryMesh& tgtBm = tgtMesh.boundary();
-    const typename VolField<Type>::Boundary& srcBfld =
-        field.boundaryField();
-
-    PtrList<fvPatchField<Type>> tgtPatchFields(tgtBm.size());
-
-    // construct tgt boundary patch types as copy of 'field' boundary types
-    // note: this will provide place holders for fields with additional
-    // entries, but these values will need to be reset
+    // Construct target patch fields as copies of source patch fields, but do
+    // not map values yet
+    PtrList<fvPatchField<Type>> tgtPatchFields(tgtMesh.boundary().size());
     forAll(srcToTgtPatchIDs(), i)
     {
         const label srcPatchi = srcToTgtPatchIDs()[i].first();
@@ -110,7 +137,7 @@ Foam::fvMeshToFvMesh::mapSrcToTgt
                 tgtPatchi,
                 fvPatchField<Type>::New
                 (
-                    srcBfld[srcPatchi],
+                    srcFld.boundaryField()[srcPatchi],
                     tgtMesh.boundary()[tgtPatchi],
                     DimensionedField<Type, volMesh>::null(),
                     directFvPatchFieldMapper
@@ -122,13 +149,14 @@ Foam::fvMeshToFvMesh::mapSrcToTgt
         }
     }
 
-    // Any unset tgtPatchFields become calculated
+    // Create calculated patch fields for any unset target patches. Use
+    // fvPatchField<Type>::New to construct these, rather than using the
+    // calculated constructor directly, so that constraints are maintained.
+    labelList tgtPatchFieldIsUnMapped(tgtPatchFields.size(), false);
     forAll(tgtPatchFields, tgtPatchi)
     {
         if (!tgtPatchFields.set(tgtPatchi))
         {
-            // Note: use factory New method instead of direct generation of
-            //       calculated so we keep constraints
             tgtPatchFields.set
             (
                 tgtPatchi,
@@ -139,75 +167,148 @@ Foam::fvMeshToFvMesh::mapSrcToTgt
                     DimensionedField<Type, volMesh>::null()
                 )
             );
+
+            tgtPatchFieldIsUnMapped[tgtPatchi] =
+                polyPatch::constraintType
+                (
+                    tgtMesh.boundary()[tgtPatchi].patch().type()
+                );
         }
     }
 
-    tmp<VolField<Type>> tresult
-    (
-        new VolField<Type>
+    // Construct the result field
+    tmp<VolField<Type>> ttgtFld =
+        VolField<Type>::New
         (
-            IOobject
-            (
-                typedName("interpolate(" + field.name() + ")"),
-                tgtMesh.time().name(),
-                tgtMesh,
-                IOobject::NO_READ,
-                IOobject::NO_WRITE
-            ),
-            tgtMesh,
-            field.dimensions(),
-            Field<Type>(tgtMesh.nCells(), Zero),
+            typedName("interpolate(" + srcFld.name() + ")"),
+            srcToTgt<Type>(srcFld.internalField())(),
             tgtPatchFields
-        )
-    );
+        );
+    typename VolField<Type>::Boundary& tgtBfld =
+        ttgtFld.ref().boundaryFieldRef();
 
-    fvMeshToFvMesh::mapSrcToTgt<Type>(field, tresult.ref());
+    // Mapped patches
+    forAll(srcToTgtPatchIDs(), i)
+    {
+        const label srcPatchi = srcToTgtPatchIDs()[i].first();
+        const label tgtPatchi = srcToTgtPatchIDs()[i].second();
 
-    return tresult;
-}
-
-
-template<class Type>
-void Foam::fvMeshToFvMesh::mapSrcToTgt
-(
-    const VolInternalField<Type>& field,
-    VolInternalField<Type>& result
-) const
-{
-    meshToMesh::mapSrcToTgt(field, result);
-}
-
-
-template<class Type>
-Foam::tmp<Foam::VolInternalField<Type>>
-Foam::fvMeshToFvMesh::mapSrcToTgt
-(
-    const VolInternalField<Type>& field
-) const
-{
-    const fvMesh& tgtMesh = static_cast<const fvMesh&>(meshToMesh::tgtMesh());
-
-    tmp<VolInternalField<Type>> tresult
-    (
-        new VolInternalField<Type>
+        tgtBfld[tgtPatchi].map
         (
-            IOobject
+            srcFld.boundaryField()[srcPatchi],
+            patchToPatchNormalisedFvPatchFieldMapper
             (
-                typedName("interpolate(" + field.name() + ")"),
-                tgtMesh.time().name(),
-                tgtMesh,
-                IOobject::NO_READ,
-                IOobject::NO_WRITE
-            ),
-            tgtMesh,
-            field.dimensions(),
-            Field<Type>(tgtMesh.nCells(), Zero)
-        )
-    );
+                srcToTgtPatchToPatches()[i],
+                true
+            )
+        );
+    }
 
-    fvMeshToFvMesh::mapSrcToTgt<Type>(field, tresult.ref());
+    // Un-mapped patches. Set values to that of the internal cell field.
+    forAll(tgtBfld, patchi)
+    {
+        if (tgtPatchFieldIsUnMapped[patchi])
+        {
+            fvPatchField<Type>& tgtPfld = tgtBfld[patchi];
+            tgtPfld == tgtPfld.patchInternalField();
+        }
+    }
 
-    return tresult;
+    // Evaluate constraints
+    evaluateConstraintTypes(ttgtFld.ref());
+
+    return ttgtFld;
+}
+
+
+template<class Type>
+Foam::tmp<Foam::VolField<Type>> Foam::fvMeshToFvMesh::srcToTgt
+(
+    const VolField<Type>& srcFld,
+    const VolField<Type>& leftOverTgtFld,
+    const UList<wordRe>& tgtCuttingPatchNames
+) const
+{
+    // Construct the result field
+    tmp<VolField<Type>> ttgtFld =
+        VolField<Type>::New
+        (
+            typedName("interpolate(" + srcFld.name() + ")"),
+            srcToTgt<Type>(srcFld.v(), leftOverTgtFld.v())(),
+            leftOverTgtFld.boundaryField()
+        );
+    typename VolField<Type>::Boundary& tgtBfld =
+        ttgtFld.ref().boundaryFieldRef();
+
+    // Mapped patches
+    forAll(srcToTgtPatchIDs(), i)
+    {
+        const label srcPatchi = srcToTgtPatchIDs()[i].first();
+        const label tgtPatchi = srcToTgtPatchIDs()[i].second();
+
+        tgtBfld[tgtPatchi].map
+        (
+            leftOverTgtFld.boundaryField()[tgtPatchi],
+            identityFvPatchFieldMapper()
+        );
+        tgtBfld[tgtPatchi].map
+        (
+            srcFld.boundaryField()[srcPatchi],
+            patchToPatchLeftOverFvPatchFieldMapper
+            (
+                srcToTgtPatchToPatches()[i],
+                true
+            )
+        );
+    }
+
+    // Cutting patches. Set values to that of the internal cell field.
+    const labelHashSet tgtCuttingPatchIDs =
+        leftOverTgtFld.mesh().boundaryMesh().patchSet(tgtCuttingPatchNames);
+    forAllConstIter(labelHashSet, tgtCuttingPatchIDs, iter)
+    {
+        tgtBfld[iter.key()] == tgtBfld[iter.key()].patchInternalField();
+    }
+
+    // Evaluate constraints
+    evaluateConstraintTypes(ttgtFld.ref());
+
+    return ttgtFld;
+}
+
+
+template<class Type>
+Foam::tmp<Foam::VolInternalField<Type>> Foam::fvMeshToFvMesh::srcToTgt
+(
+    const VolInternalField<Type>& srcFld
+) const
+{
+    return
+        VolInternalField<Type>::New
+        (
+            typedName("interpolate(" + srcFld.name() + ")"),
+            static_cast<const fvMesh&>(meshToMesh::tgtMesh()),
+            srcFld.dimensions(),
+            srcToTgtCellsToCells().srcToTgt(srcFld)
+        );
+}
+
+
+template<class Type>
+Foam::tmp<Foam::VolInternalField<Type>> Foam::fvMeshToFvMesh::srcToTgt
+(
+    const VolInternalField<Type>& srcFld,
+    const VolInternalField<Type>& leftOverTgtFld
+) const
+{
+    return
+        VolInternalField<Type>::New
+        (
+            typedName("interpolate(" + srcFld.name() + ")"),
+            static_cast<const fvMesh&>(meshToMesh::tgtMesh()),
+            leftOverTgtFld.dimensions(),
+            srcToTgtCellsToCells().srcToTgt(srcFld, leftOverTgtFld)
+        );
 }
 
 
diff --git a/src/finiteVolume/fvMeshToFvMesh/patchToPatchFvPatchFieldMapper.C b/src/finiteVolume/fvMeshToFvMesh/patchToPatchFvPatchFieldMapper.C
index 9ce743d1c1..53fcea895d 100644
--- a/src/finiteVolume/fvMeshToFvMesh/patchToPatchFvPatchFieldMapper.C
+++ b/src/finiteVolume/fvMeshToFvMesh/patchToPatchFvPatchFieldMapper.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2022-2023 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -27,13 +27,6 @@ License
 
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
-FOR_ALL_FIELD_TYPES
-(
-    IMPLEMENT_FIELD_MAPPER_OPERATOR,
-    patchToPatchFvPatchFieldMapper
-)
-
-
 void Foam::patchToPatchFvPatchFieldMapper::operator()
 (
     Field<label>& f,
diff --git a/src/finiteVolume/fvMeshToFvMesh/patchToPatchFvPatchFieldMapper.H b/src/finiteVolume/fvMeshToFvMesh/patchToPatchFvPatchFieldMapper.H
index 52121f2f91..8885f384a6 100644
--- a/src/finiteVolume/fvMeshToFvMesh/patchToPatchFvPatchFieldMapper.H
+++ b/src/finiteVolume/fvMeshToFvMesh/patchToPatchFvPatchFieldMapper.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2022-2023 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -50,7 +50,9 @@ class patchToPatchFvPatchFieldMapper
 :
     public fvPatchFieldMapper
 {
-    // Private Data
+protected:
+
+    // Protected Data
 
         //- Patch-to-patch mapping engine
         const patchToPatch& pToP_;
@@ -65,17 +67,6 @@ class patchToPatchFvPatchFieldMapper
         bool hasUnmapped_;
 
 
-    // Private Member Functions
-
-        //- Map from one field to another
-        template<class Type>
-        void map(Field<Type>& f, const Field<Type>& mapF) const;
-
-        //- Map a field and return the result as tmp
-        template<class Type>
-        tmp<Field<Type>> map(const Field<Type>& mapF) const;
-
-
 public:
 
     // Constructors
@@ -124,9 +115,6 @@ public:
 
     // Member Operators
 
-        //- Map a field
-        FOR_ALL_FIELD_TYPES(DEFINE_FIELD_MAPPER_OPERATOR, );
-
         //- Map a label field
         DEFINE_FIELD_MAPPER_OPERATOR(label, );
 
diff --git a/src/finiteVolume/fvMeshToFvMesh/patchToPatchFvPatchFieldMapperTemplates.C b/src/finiteVolume/fvMeshToFvMesh/patchToPatchFvPatchFieldMapperTemplates.C
index 4263ab079c..12ee688159 100644
--- a/src/finiteVolume/fvMeshToFvMesh/patchToPatchFvPatchFieldMapperTemplates.C
+++ b/src/finiteVolume/fvMeshToFvMesh/patchToPatchFvPatchFieldMapperTemplates.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2022-2023 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -27,29 +27,6 @@ License
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-template<class Type>
-void Foam::patchToPatchFvPatchFieldMapper::map
-(
-    Field<Type>& f,
-    const Field<Type>& mapF
-) const
-{
-    f = forward_ ? pToP_.srcToTgt(mapF) : pToP_.tgtToSrc(mapF);
-}
-
-
-template<class Type>
-Foam::tmp<Foam::Field<Type>> Foam::patchToPatchFvPatchFieldMapper::map
-(
-    const Field<Type>& mapF
-) const
-{
-    tmp<Field<Type>> tf(new Field<Type>(size_));
-    map(tf.ref(), mapF);
-    return tf;
-}
-
-
 template<class Type>
 void Foam::patchToPatchFvPatchFieldMapper::operator()
 (
@@ -57,7 +34,7 @@ void Foam::patchToPatchFvPatchFieldMapper::operator()
     const tmp<Field<Type>>& tmapF
 ) const
 {
-    map(f, tmapF());
+    operator()(f, tmapF());
     tmapF.clear();
 }
 
@@ -69,7 +46,7 @@ Foam::patchToPatchFvPatchFieldMapper::operator()
     const tmp<Field<Type>>& tmapF
 ) const
 {
-    tmp<Foam::Field<Type>> tf(map(tmapF()));
+    tmp<Foam::Field<Type>> tf(operator()(tmapF()));
     tmapF.clear();
     return tf;
 }
diff --git a/src/finiteVolume/fvMeshToFvMesh/patchToPatchLeftOverFvPatchFieldMapper.C b/src/finiteVolume/fvMeshToFvMesh/patchToPatchLeftOverFvPatchFieldMapper.C
new file mode 100644
index 0000000000..f9db251c68
--- /dev/null
+++ b/src/finiteVolume/fvMeshToFvMesh/patchToPatchLeftOverFvPatchFieldMapper.C
@@ -0,0 +1,37 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2022-2023 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 "patchToPatchLeftOverFvPatchFieldMapper.H"
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+FOR_ALL_FIELD_TYPES
+(
+    IMPLEMENT_FIELD_MAPPER_OPERATOR,
+    patchToPatchLeftOverFvPatchFieldMapper
+)
+
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fvMeshToFvMesh/patchToPatchLeftOverFvPatchFieldMapper.H b/src/finiteVolume/fvMeshToFvMesh/patchToPatchLeftOverFvPatchFieldMapper.H
new file mode 100644
index 0000000000..291bff1e69
--- /dev/null
+++ b/src/finiteVolume/fvMeshToFvMesh/patchToPatchLeftOverFvPatchFieldMapper.H
@@ -0,0 +1,104 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2022-2023 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::patchToPatchLeftOverFvPatchFieldMapper
+
+Description
+    FieldMapper which uses a patchToPatch object to map from another patch. The
+    source patch may be differently decomposed and/or geometrically and
+    topologically different from the target.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef patchToPatchLeftOverFvPatchFieldMapper_H
+#define patchToPatchLeftOverFvPatchFieldMapper_H
+
+#include "patchToPatchFvPatchFieldMapper.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+            Class patchToPatchLeftOverFvPatchFieldMapper Declaration
+\*---------------------------------------------------------------------------*/
+
+class patchToPatchLeftOverFvPatchFieldMapper
+:
+    public patchToPatchFvPatchFieldMapper
+{
+    // Private Member Functions
+
+        //- Map from one field to another
+        template<class Type>
+        void map(Field<Type>& f, const Field<Type>& mapF) const;
+
+        //- Map a field and return the result as tmp
+        template<class Type>
+        tmp<Field<Type>> map(const Field<Type>& mapF) const;
+
+
+public:
+
+    // Constructors
+
+        //- Construct given a patch-to-patch and a mapping direction
+        patchToPatchLeftOverFvPatchFieldMapper
+        (
+            const patchToPatch& pToP,
+            const bool forward
+        )
+        :
+            patchToPatchFvPatchFieldMapper(pToP, forward)
+        {}
+
+
+    //- Destructor
+    virtual ~patchToPatchLeftOverFvPatchFieldMapper()
+    {}
+
+
+    // Member Operators
+
+        //- Map a field
+        FOR_ALL_FIELD_TYPES(DEFINE_FIELD_MAPPER_OPERATOR, );
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "patchToPatchLeftOverFvPatchFieldMapperTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/meshToMesh/calcMethod/meshToMeshMethod/meshToMeshMethodNew.C b/src/finiteVolume/fvMeshToFvMesh/patchToPatchLeftOverFvPatchFieldMapperTemplates.C
similarity index 58%
rename from src/meshTools/meshToMesh/calcMethod/meshToMeshMethod/meshToMeshMethodNew.C
rename to src/finiteVolume/fvMeshToFvMesh/patchToPatchLeftOverFvPatchFieldMapperTemplates.C
index 67c0ebd2ea..d887518024 100644
--- a/src/meshTools/meshToMesh/calcMethod/meshToMeshMethod/meshToMeshMethodNew.C
+++ b/src/finiteVolume/fvMeshToFvMesh/patchToPatchLeftOverFvPatchFieldMapperTemplates.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2013-2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2022-2023 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -23,35 +23,30 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "meshToMeshMethod.H"
+#include "patchToPatchLeftOverFvPatchFieldMapper.H"
 
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-Foam::autoPtr<Foam::meshToMeshMethod> Foam::meshToMeshMethod::New
+template<class Type>
+void Foam::patchToPatchLeftOverFvPatchFieldMapper::map
 (
-    const word& methodName,
-    const polyMesh& src,
-    const polyMesh& tgt
-)
+    Field<Type>& f,
+    const Field<Type>& mapF
+) const
 {
-    if (debug)
-    {
-        Info<< "Selecting meshToMeshMethod " << methodName << endl;
-    }
+    f = forward_ ? pToP_.srcToTgt(mapF, f) : pToP_.tgtToSrc(mapF, f);
+}
 
-    componentsConstructorTable::iterator cstrIter =
-        componentsConstructorTablePtr_->find(methodName);
 
-    if (cstrIter == componentsConstructorTablePtr_->end())
-    {
-        FatalErrorInFunction
-            << "Unknown meshToMesh type "
-            << methodName << nl << nl
-            << "Valid meshToMesh types are:" << nl
-            << componentsConstructorTablePtr_->sortedToc() << exit(FatalError);
-    }
-
-    return autoPtr<meshToMeshMethod>(cstrIter()(src, tgt));
+template<class Type>
+Foam::tmp<Foam::Field<Type>>
+Foam::patchToPatchLeftOverFvPatchFieldMapper::map
+(
+    const Field<Type>& mapF
+) const
+{
+    NotImplemented;
+    return tmp<Field<Type>>(nullptr);
 }
 
 
diff --git a/src/finiteVolume/fvMeshToFvMesh/patchToPatchNormalisedFvPatchFieldMapper.C b/src/finiteVolume/fvMeshToFvMesh/patchToPatchNormalisedFvPatchFieldMapper.C
new file mode 100644
index 0000000000..a4363dfa5f
--- /dev/null
+++ b/src/finiteVolume/fvMeshToFvMesh/patchToPatchNormalisedFvPatchFieldMapper.C
@@ -0,0 +1,37 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2022-2023 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 "patchToPatchNormalisedFvPatchFieldMapper.H"
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+FOR_ALL_FIELD_TYPES
+(
+    IMPLEMENT_FIELD_MAPPER_OPERATOR,
+    patchToPatchNormalisedFvPatchFieldMapper
+)
+
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fvMeshToFvMesh/patchToPatchNormalisedFvPatchFieldMapper.H b/src/finiteVolume/fvMeshToFvMesh/patchToPatchNormalisedFvPatchFieldMapper.H
new file mode 100644
index 0000000000..153e5baaf3
--- /dev/null
+++ b/src/finiteVolume/fvMeshToFvMesh/patchToPatchNormalisedFvPatchFieldMapper.H
@@ -0,0 +1,104 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2022-2023 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::patchToPatchNormalisedFvPatchFieldMapper
+
+Description
+    FieldMapper which uses a patchToPatch object to map from another patch. The
+    source patch may be differently decomposed and/or geometrically and
+    topologically different from the target.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef patchToPatchNormalisedFvPatchFieldMapper_H
+#define patchToPatchNormalisedFvPatchFieldMapper_H
+
+#include "patchToPatchFvPatchFieldMapper.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+            Class patchToPatchNormalisedFvPatchFieldMapper Declaration
+\*---------------------------------------------------------------------------*/
+
+class patchToPatchNormalisedFvPatchFieldMapper
+:
+    public patchToPatchFvPatchFieldMapper
+{
+    // Private Member Functions
+
+        //- Map from one field to another
+        template<class Type>
+        void map(Field<Type>& f, const Field<Type>& mapF) const;
+
+        //- Map a field and return the result as tmp
+        template<class Type>
+        tmp<Field<Type>> map(const Field<Type>& mapF) const;
+
+
+public:
+
+    // Constructors
+
+        //- Construct given a patch-to-patch and a mapping direction
+        patchToPatchNormalisedFvPatchFieldMapper
+        (
+            const patchToPatch& pToP,
+            const bool forward
+        )
+        :
+            patchToPatchFvPatchFieldMapper(pToP, forward)
+        {}
+
+
+    //- Destructor
+    virtual ~patchToPatchNormalisedFvPatchFieldMapper()
+    {}
+
+
+    // Member Operators
+
+        //- Map a field
+        FOR_ALL_FIELD_TYPES(DEFINE_FIELD_MAPPER_OPERATOR, );
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "patchToPatchNormalisedFvPatchFieldMapperTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fvMeshToFvMesh/patchToPatchNormalisedFvPatchFieldMapperTemplates.C b/src/finiteVolume/fvMeshToFvMesh/patchToPatchNormalisedFvPatchFieldMapperTemplates.C
new file mode 100644
index 0000000000..7792df95aa
--- /dev/null
+++ b/src/finiteVolume/fvMeshToFvMesh/patchToPatchNormalisedFvPatchFieldMapperTemplates.C
@@ -0,0 +1,53 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2022-2023 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 "patchToPatchNormalisedFvPatchFieldMapper.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class Type>
+void Foam::patchToPatchNormalisedFvPatchFieldMapper::map
+(
+    Field<Type>& f,
+    const Field<Type>& mapF
+) const
+{
+    f = forward_ ? pToP_.srcToTgt(mapF) : pToP_.tgtToSrc(mapF);
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type>> Foam::patchToPatchNormalisedFvPatchFieldMapper::map
+(
+    const Field<Type>& mapF
+) const
+{
+    tmp<Field<Type>> tf(new Field<Type>(size_));
+    map(tf.ref(), mapF);
+    return tf;
+}
+
+
+// ************************************************************************* //
diff --git a/src/fvMeshTopoChangers/meshToMesh/MeshToMeshMapGeometricFields.H b/src/fvMeshTopoChangers/meshToMesh/MeshToMeshMapGeometricFields.H
index 15fafcb175..51d77aebbc 100644
--- a/src/fvMeshTopoChangers/meshToMesh/MeshToMeshMapGeometricFields.H
+++ b/src/fvMeshTopoChangers/meshToMesh/MeshToMeshMapGeometricFields.H
@@ -46,87 +46,6 @@ Description
 namespace Foam
 {
 
-template<class Type>
-void evaluateConstraintTypes(VolField<Type>& fld)
-{
-    typename VolField<Type>::Boundary& fldBf = fld.boundaryFieldRef();
-
-    if
-    (
-        Pstream::defaultCommsType == Pstream::commsTypes::blocking
-     || Pstream::defaultCommsType == Pstream::commsTypes::nonBlocking
-    )
-    {
-        label nReq = Pstream::nRequests();
-
-        forAll(fldBf, patchi)
-        {
-            fvPatchField<Type>& tgtField = fldBf[patchi];
-
-            if
-            (
-                tgtField.type() == tgtField.patch().patch().type()
-             && polyPatch::constraintType(tgtField.patch().patch().type())
-            )
-            {
-                tgtField.initEvaluate(Pstream::defaultCommsType);
-            }
-        }
-
-        // Block for any outstanding requests
-        if
-        (
-            Pstream::parRun()
-         && Pstream::defaultCommsType == Pstream::commsTypes::nonBlocking
-        )
-        {
-            Pstream::waitRequests(nReq);
-        }
-
-        forAll(fldBf, patchi)
-        {
-            fvPatchField<Type>& tgtField = fldBf[patchi];
-
-            if
-            (
-                tgtField.type() == tgtField.patch().patch().type()
-             && polyPatch::constraintType(tgtField.patch().patch().type())
-            )
-            {
-                tgtField.evaluate(Pstream::defaultCommsType);
-            }
-        }
-    }
-    else if (Pstream::defaultCommsType == Pstream::commsTypes::scheduled)
-    {
-        const lduSchedule& patchSchedule =
-            fld.mesh().globalData().patchSchedule();
-
-        forAll(patchSchedule, patchEvali)
-        {
-            label patchi = patchSchedule[patchEvali].patch;
-            fvPatchField<Type>& tgtField = fldBf[patchi];
-
-            if
-            (
-                tgtField.type() == tgtField.patch().patch().type()
-             && polyPatch::constraintType(tgtField.patch().patch().type())
-            )
-            {
-                if (patchSchedule[patchEvali].init)
-                {
-                    tgtField.initEvaluate(Pstream::commsTypes::scheduled);
-                }
-                else
-                {
-                    tgtField.evaluate(Pstream::commsTypes::scheduled);
-                }
-            }
-        }
-    }
-}
-
-
 template<class Type>
 void MeshToMeshMapVolFields
 (
@@ -169,8 +88,7 @@ void MeshToMeshMapVolFields
     )
     {
         VolField<Type>& field =
-            const_cast<VolField<Type>&>
-            (*fieldIter());
+            const_cast<VolField<Type>&>(*fieldIter());
 
         if (fvMeshToFvMesh::debug)
         {
@@ -178,8 +96,8 @@ void MeshToMeshMapVolFields
                 << endl;
         }
 
-        field.reset(mapper.mapSrcToTgt(field));
-        evaluateConstraintTypes(field);
+        field.reset(mapper.srcToTgt(field));
+
         field.instance() = field.time().name();
     }
 }
@@ -207,8 +125,7 @@ void MeshToMeshMapVolInternalFields
     )
     {
         VolInternalField<Type>& field =
-            const_cast<VolInternalField<Type>&>
-            (*fieldIter());
+            const_cast<VolInternalField<Type>&>(*fieldIter());
 
         if (fvMeshToFvMesh::debug)
         {
@@ -216,7 +133,8 @@ void MeshToMeshMapVolInternalFields
                 << endl;
         }
 
-        field.reset(mapper.mapSrcToTgt<Type>(field));
+        field.reset(mapper.srcToTgt<Type>(field));
+
         field.instance() = field.time().name();
     }
 }
diff --git a/src/fvMeshTopoChangers/meshToMesh/fvMeshTopoChangersMeshToMesh.C b/src/fvMeshTopoChangers/meshToMesh/fvMeshTopoChangersMeshToMesh.C
index 65871da7ea..983f34614e 100644
--- a/src/fvMeshTopoChangers/meshToMesh/fvMeshTopoChangersMeshToMesh.C
+++ b/src/fvMeshTopoChangers/meshToMesh/fvMeshTopoChangersMeshToMesh.C
@@ -30,7 +30,7 @@ License
 #include "pointFields.H"
 #include "meshToMeshAdjustTimeStepFunctionObject.H"
 #include "fvMeshToFvMesh.H"
-#include "cellVolumeWeightMethod.H"
+#include "intersectionCellsToCells.H"
 #include "surfaceToVolVelocity.H"
 #include "MeshToMeshMapGeometricFields.H"
 #include "polyMeshMap.H"
@@ -86,7 +86,6 @@ Foam::fvMeshTopoChangers::meshToMesh::meshToMesh
 :
     fvMeshTopoChanger(mesh),
     dict_(dict),
-    cuttingPatches_(dict.lookupOrDefault("cuttingPatches", wordList::null())),
     times_(dict.lookup("times")),
     timeDelta_(dict.lookup<scalar>("timeDelta")),
     timeIndex_(-1)
@@ -121,8 +120,6 @@ bool Foam::fvMeshTopoChangers::meshToMesh::update()
         );
     }
 
-    bool hasChanged = false;
-
     // Only refine on the first call in a time-step
     if (timeIndex_ != mesh().time().timeIndex())
     {
@@ -130,7 +127,7 @@ bool Foam::fvMeshTopoChangers::meshToMesh::update()
     }
     else
     {
-        return hasChanged;
+        return false;
     }
 
     const scalar userTime = mesh().time().userTimeValue();
@@ -141,8 +138,6 @@ bool Foam::fvMeshTopoChangers::meshToMesh::update()
 
         Info << "Mapping to mesh " << meshDir << endl;
 
-        hasChanged = true;
-
         fvMesh newMesh
         (
             IOobject
@@ -156,52 +151,12 @@ bool Foam::fvMeshTopoChangers::meshToMesh::update()
             fvMesh::stitchType::none
         );
 
-        autoPtr<Foam::fvMeshToFvMesh> mapper;
-
-        // Create mesh-to-mesh mapper with support for cuttingPatches
-        // if specified
-        if (cuttingPatches_.size())
-        {
-            HashSet<word> cuttingPatchTable;
-            forAll(cuttingPatches_, i)
-            {
-                cuttingPatchTable.insert(cuttingPatches_[i]);
-            }
-
-            HashTable<word> patchMap(mesh().boundary().size());
-
-            const polyBoundaryMesh& pbm = mesh().boundaryMesh();
-
-            forAll(pbm, i)
-            {
-                if
-                (
-                    !cuttingPatchTable.found(pbm[i].name())
-                 && !isA<processorPolyPatch>(pbm[i])
-                )
-                {
-                    patchMap.insert(pbm[i].name(), pbm[i].name());
-                }
-            }
-
-            mapper = new Foam::fvMeshToFvMesh
-            (
-                mesh(),
-                newMesh,
-                cellVolumeWeightMethod::typeName,
-                patchMap,
-                cuttingPatches_
-            );
-        }
-        else
-        {
-            mapper = new Foam::fvMeshToFvMesh
-            (
-                mesh(),
-                newMesh,
-                cellVolumeWeightMethod::typeName
-            );
-        }
+        fvMeshToFvMesh mapper
+        (
+            mesh(),
+            newMesh,
+            cellsToCellss::intersection::typeName
+        );
 
         mesh().reset(newMesh);
 
@@ -234,11 +189,16 @@ bool Foam::fvMeshTopoChangers::meshToMesh::update()
         // Interpolate U's to Uf's
         interpolateUfs();
 
-        polyMeshMap map(mesh(), mapper());
-        mesh().mapMesh(map);
-    }
+        polyMeshMap map(mesh(), mapper);
 
-    return hasChanged;
+        mesh().mapMesh(map);
+
+        return true;
+    }
+    else
+    {
+        return false;
+    }
 }
 
 
diff --git a/src/fvMeshTopoChangers/meshToMesh/fvMeshTopoChangersMeshToMesh.H b/src/fvMeshTopoChangers/meshToMesh/fvMeshTopoChangersMeshToMesh.H
index 4888543b8b..f46f8b80ca 100644
--- a/src/fvMeshTopoChangers/meshToMesh/fvMeshTopoChangersMeshToMesh.H
+++ b/src/fvMeshTopoChangers/meshToMesh/fvMeshTopoChangersMeshToMesh.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2022-2023 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -57,10 +57,6 @@ class meshToMesh
         //- Mesh-to-mesh control dictionary
         dictionary dict_;
 
-        //- Optional names of the patches which "cut" the internal mesh
-        //  and hence cannot be mapped from existing patches
-        wordList cuttingPatches_;
-
         //- List of mesh mapping times
         scalarList times_;
 
diff --git a/src/fvModels/interRegion/interRegionHeatTransfer/interRegionHeatTransfer.H b/src/fvModels/interRegion/interRegionHeatTransfer/interRegionHeatTransfer.H
index b8abf5b29a..6d95792df4 100644
--- a/src/fvModels/interRegion/interRegionHeatTransfer/interRegionHeatTransfer.H
+++ b/src/fvModels/interRegion/interRegionHeatTransfer/interRegionHeatTransfer.H
@@ -48,7 +48,7 @@ Usage
 
         nbrRegion       other;
 
-        interpolationMethod cellVolumeWeight;
+        interpolationMethod intersection;
         master          true;
 
         semiImplicit    no;
diff --git a/src/fvModels/interRegion/interRegionModel/interRegionModel.C b/src/fvModels/interRegion/interRegionModel/interRegionModel.C
index f7d6690d3c..a6ac4bbd4d 100644
--- a/src/fvModels/interRegion/interRegionModel/interRegionModel.C
+++ b/src/fvModels/interRegion/interRegionModel/interRegionModel.C
@@ -25,7 +25,7 @@ License
 
 #include "interRegionModel.H"
 #include "fvModels.H"
-#include "directMethod.H"
+#include "matchingCellsToCells.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -55,47 +55,44 @@ void Foam::fv::interRegionModel::readCoeffs()
 }
 
 
-void Foam::fv::interRegionModel::setMapper() const
+const Foam::cellsToCells& Foam::fv::interRegionModel::interpolation() const
 {
-    Info<< incrIndent;
-
-    if (master_)
+    if (!interpolationPtr_.valid())
     {
-        Info<< indent << "- selecting inter region mapping" << endl;
+        Info<< incrIndent;
 
-        if (mesh().name() == nbrMesh().name())
+        if (master_)
         {
-            FatalErrorInFunction
-                << "Inter-region model selected, but local and "
-                << "neighbour regions are the same: " << nl
-                << "    local region: " << mesh().name() << nl
-                << "    secondary region: " << nbrMesh().name() << nl
-                << exit(FatalError);
+            Info<< indent << "- selecting inter region mapping" << endl;
+
+            if (mesh().name() == nbrMesh().name())
+            {
+                FatalErrorInFunction
+                    << "Inter-region model selected, but local and "
+                    << "neighbour regions are the same: " << nl
+                    << "    local region: " << mesh().name() << nl
+                    << "    secondary region: " << nbrMesh().name() << nl
+                    << exit(FatalError);
+            }
+
+            if (mesh().bounds().overlaps(nbrMesh().bounds()))
+            {
+                interpolationPtr_ = cellsToCells::New(interpolationMethod_);
+                interpolationPtr_->update(mesh(), nbrMesh());
+            }
+            else
+            {
+                FatalErrorInFunction
+                    << "regions " << mesh().name() << " and "
+                    << nbrMesh().name() <<  " do not intersect"
+                    << exit(FatalError);
+            }
         }
 
-        if (mesh().bounds().overlaps(nbrMesh().bounds()))
-        {
-            meshInterpPtr_.reset
-            (
-                new meshToMesh
-                (
-                    mesh(),
-                    nbrMesh(),
-                    interpolationMethod_,
-                    false // not interpolating patches
-                )
-            );
-        }
-        else
-        {
-            FatalErrorInFunction
-                << "regions " << mesh().name() << " and "
-                << nbrMesh().name() <<  " do not intersect"
-                << exit(FatalError);
-        }
+        Info<< decrIndent;
     }
 
-    Info<< decrIndent;
+    return interpolationPtr_();
 }
 
 
@@ -140,8 +137,8 @@ Foam::fv::interRegionModel::interRegionModel
     fvModel(name, modelType, mesh, dict),
     master_(false),
     nbrRegionName_(word::null),
-    interpolationMethod_(directMethod::typeName),
-    meshInterpPtr_()
+    interpolationMethod_(cellsToCellss::matching::typeName),
+    interpolationPtr_()
 {
     readCoeffs();
 }
@@ -160,7 +157,7 @@ bool Foam::fv::interRegionModel::read(const dictionary& dict)
     if (fvModel::read(dict))
     {
         readCoeffs();
-        setMapper();
+        interpolationPtr_.clear();
         return true;
     }
     else
diff --git a/src/fvModels/interRegion/interRegionModel/interRegionModel.H b/src/fvModels/interRegion/interRegionModel/interRegionModel.H
index af5ab26700..0a53a0fe89 100644
--- a/src/fvModels/interRegion/interRegionModel/interRegionModel.H
+++ b/src/fvModels/interRegion/interRegionModel/interRegionModel.H
@@ -29,14 +29,12 @@ Description
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef interRegionModel_H
-#define interRegionModel_H
-
 #include "fvModel.H"
 #include "volFields.H"
-#include "autoPtr.H"
-#include "meshToMesh.H"
+#include "cellsToCells.H"
 
+#ifndef interRegionModel_H
+#define interRegionModel_H
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -65,7 +63,7 @@ class interRegionModel
         word interpolationMethod_;
 
         //- Mesh to mesh interpolation object
-        mutable autoPtr<meshToMesh> meshInterpPtr_;
+        mutable autoPtr<cellsToCells> interpolationPtr_;
 
 
     // Private member functions
@@ -73,9 +71,6 @@ class interRegionModel
         //- Non-virtual read
         void readCoeffs();
 
-        //- Set the mesh to mesh interpolation object
-        void setMapper() const;
-
 
 protected:
 
@@ -120,8 +115,8 @@ public:
             //- Return const access to the neighbour mesh
             inline const fvMesh& nbrMesh() const;
 
-            //- Return const access to the mapToMap pointer
-            inline const meshToMesh& meshInterp() const;
+            //- Return const access to the interpolation engine
+            const cellsToCells& interpolation() const;
 
 
         // Interpolation
diff --git a/src/fvModels/interRegion/interRegionModel/interRegionModelI.H b/src/fvModels/interRegion/interRegionModel/interRegionModelI.H
index 078b387661..fa4a425609 100644
--- a/src/fvModels/interRegion/interRegionModel/interRegionModelI.H
+++ b/src/fvModels/interRegion/interRegionModel/interRegionModelI.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2012-2021 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2012-2023 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -23,6 +23,8 @@ License
 
 \*---------------------------------------------------------------------------*/
 
+#include "interRegionModel.H"
+
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 inline bool Foam::fv::interRegionModel::master() const
@@ -43,15 +45,4 @@ inline const Foam::fvMesh& Foam::fv::interRegionModel::nbrMesh() const
 }
 
 
-inline const Foam::meshToMesh& Foam::fv::interRegionModel::meshInterp() const
-{
-    if (!meshInterpPtr_.valid())
-    {
-        setMapper();
-    }
-
-    return meshInterpPtr_();
-}
-
-
 // ************************************************************************* //
diff --git a/src/fvModels/interRegion/interRegionModel/interRegionModelTemplates.C b/src/fvModels/interRegion/interRegionModel/interRegionModelTemplates.C
index 7551c0bd97..ad16e1a907 100644
--- a/src/fvModels/interRegion/interRegionModel/interRegionModelTemplates.C
+++ b/src/fvModels/interRegion/interRegionModel/interRegionModelTemplates.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2023 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -36,11 +36,11 @@ Foam::fv::interRegionModel::interpolate
 {
     if (master())
     {
-        return meshInterp().mapTgtToSrc(field);
+        return interpolation().tgtToSrc(field);
     }
     else
     {
-        return nbrModel().meshInterp().mapSrcToTgt(field);
+        return nbrModel().interpolation().srcToTgt(field);
     }
 }
 
@@ -54,11 +54,11 @@ void Foam::fv::interRegionModel::interpolate
 {
     if (master())
     {
-        meshInterp().mapTgtToSrc(field, result);
+        result = interpolation().tgtToSrc(field, result);
     }
     else
     {
-        nbrModel().meshInterp().mapSrcToTgt(field, result);
+        result = nbrModel().interpolation().srcToTgt(field, result);
     }
 }
 
diff --git a/src/meshTools/Make/files b/src/meshTools/Make/files
index ff5fe65921..9405663c0f 100644
--- a/src/meshTools/Make/files
+++ b/src/meshTools/Make/files
@@ -226,13 +226,13 @@ patchToPatch/inverseDistance/inverseDistancePatchToPatch.C
 patchToPatch/intersection/intersectionPatchToPatch.C
 patchToPatch/rays/raysPatchToPatch.C
 
+cellsToCells/cellsToCells/cellsToCells.C
+cellsToCells/cellsToCells/cellsToCellsParallelOps.C
+cellsToCells/matching/matchingCellsToCells.C
+cellsToCells/nearest/nearestCellsToCells.C
+cellsToCells/intersection/intersectionCellsToCells.C
+
 meshToMesh/meshToMesh.C
-meshToMesh/meshToMeshParallelOps.C
-meshToMesh/calcMethod/meshToMeshMethod/meshToMeshMethod.C
-meshToMesh/calcMethod/meshToMeshMethod/meshToMeshMethodNew.C
-meshToMesh/calcMethod/cellVolumeWeight/cellVolumeWeightMethod.C
-meshToMesh/calcMethod/direct/directMethod.C
-meshToMesh/calcMethod/mapNearest/mapNearestMethod.C
 
 mappedPatches/mappedPatchBase/mappedPatchBase.C
 mappedPatches/mappedPolyPatch/mappedPolyPatch.C
diff --git a/src/meshTools/cellsToCells/cellsToCells/cellsToCells.C b/src/meshTools/cellsToCells/cellsToCells/cellsToCells.C
new file mode 100644
index 0000000000..50d3f2e244
--- /dev/null
+++ b/src/meshTools/cellsToCells/cellsToCells/cellsToCells.C
@@ -0,0 +1,368 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2012-2023 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 "cellsToCells.H"
+#include "globalIndex.H"
+#include "PatchTools.H"
+#include "patchToPatchTools.H"
+#include "emptyPolyPatch.H"
+#include "wedgePolyPatch.H"
+#include "processorPolyPatch.H"
+#include "Time.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(cellsToCells, 0);
+    defineRunTimeSelectionTable(cellsToCells, word);
+}
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+void Foam::cellsToCells::initialise
+(
+    const polyMesh& srcMesh,
+    const polyMesh& tgtMesh
+)
+{
+    srcLocalTgtCells_.setSize(srcMesh.nCells());
+    srcWeights_.setSize(srcMesh.nCells());
+    forAll(srcLocalTgtCells_, srcCelli)
+    {
+        srcLocalTgtCells_[srcCelli].clear();
+        srcWeights_[srcCelli].clear();
+    }
+
+    tgtLocalSrcCells_.setSize(tgtMesh.nCells());
+    tgtWeights_.setSize(tgtMesh.nCells());
+    forAll(tgtLocalSrcCells_, tgtCelli)
+    {
+        tgtLocalSrcCells_[tgtCelli].clear();
+        tgtWeights_[tgtCelli].clear();
+    }
+}
+
+
+Foam::labelList Foam::cellsToCells::maskCells
+(
+    const polyMesh& srcMesh,
+    const polyMesh& tgtMesh
+) const
+{
+    boundBox meshBb
+    (
+        max(srcMesh.bounds().min(), tgtMesh.bounds().min()),
+        min(srcMesh.bounds().max(), tgtMesh.bounds().max())
+    );
+
+    meshBb.inflate(0.01);
+
+    const cellList& srcCells = srcMesh.cells();
+    const faceList& srcFaces = srcMesh.faces();
+    const pointField& srcPts = srcMesh.points();
+
+    DynamicList<label> resultDyn(srcMesh.nCells());
+    forAll(srcCells, srcCelli)
+    {
+        const boundBox cellBb
+        (
+            srcCells[srcCelli].points(srcFaces, srcPts),
+            false
+        );
+
+        if (meshBb.overlaps(cellBb))
+        {
+            resultDyn.append(srcCelli);
+        }
+    }
+
+    labelList result;
+    result.transfer(resultDyn);
+    return result;
+}
+
+
+void Foam::cellsToCells::appendNbrCells
+(
+    const label celli,
+    const polyMesh& mesh,
+    const DynamicList<label>& visitedCells,
+    DynamicList<label>& nbrCells
+) const
+{
+    // Get all cell-cells
+    const labelList& allNbrCells = mesh.cellCells()[celli];
+
+    // Filter out cells already visited
+    forAll(allNbrCells, i)
+    {
+        const label nbrCelli = allNbrCells[i];
+
+        if
+        (
+            findIndex(visitedCells, nbrCelli) == -1
+         && findIndex(nbrCells, nbrCelli) == -1
+        )
+        {
+            nbrCells.append(nbrCelli);
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::cellsToCells::cellsToCells()
+:
+    singleProcess_(-1),
+    srcLocalTgtCells_(),
+    tgtLocalSrcCells_(),
+    srcWeights_(),
+    tgtWeights_(),
+    srcMapPtr_(nullptr),
+    tgtMapPtr_(nullptr),
+    localSrcProcCellsPtr_(nullptr),
+    localTgtProcCellsPtr_(nullptr),
+    localTgtMeshPtr_(nullptr)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cellsToCells::~cellsToCells()
+{}
+
+
+// * * * * * * * * * * * * * * * * Selector  * * * * * * * * * * * * * * * * //
+
+Foam::autoPtr<Foam::cellsToCells> Foam::cellsToCells::New
+(
+    const word& cellsToCellsType
+)
+{
+    wordConstructorTable::iterator cstrIter =
+        wordConstructorTablePtr_->find(cellsToCellsType);
+
+    if (cstrIter == wordConstructorTablePtr_->end())
+    {
+        FatalErrorInFunction
+            << "Unknown " << typeName << " type "
+            << cellsToCellsType << endl << endl
+            << "Valid " << typeName << " types are : " << endl
+            << wordConstructorTablePtr_->sortedToc()
+            << exit(FatalError);
+    }
+
+    return cstrIter()();
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::remote Foam::cellsToCells::srcToTgtPoint
+(
+    const polyMesh& tgtMesh,
+    const label srcCelli,
+    const point& p
+) const
+{
+    forAll(srcLocalTgtCells_[srcCelli], i)
+    {
+        const label tgtCelli = srcLocalTgtCells_[srcCelli][i];
+
+        const polyMesh& localTgtMesh =
+            singleProcess_ == -1 ? localTgtMeshPtr_() : tgtMesh;
+
+        if (localTgtMesh.pointInCell(p, tgtCelli))
+        {
+            return
+                singleProcess_ == -1
+              ? localTgtProcCellsPtr_()[tgtCelli]
+              : remote(Pstream::myProcNo(), tgtCelli);
+        }
+    }
+
+    return remote();
+}
+
+
+Foam::scalar Foam::cellsToCells::update
+(
+    const polyMesh& srcMesh,
+    const polyMesh& tgtMesh
+)
+{
+    cpuTime time;
+
+    // Determine numbers of faces on both sides, report, and quit if either
+    // side is empty
+    const label srcTotalSize = returnReduce(srcMesh.nCells(), sumOp<label>());
+    const label tgtTotalSize = returnReduce(tgtMesh.nCells(), sumOp<label>());
+    if (srcTotalSize == 0 || tgtTotalSize == 0)
+    {
+        return 0;
+    }
+
+    Info<< indent << typeName << ": Calculating couplings between "
+        << srcTotalSize << " source cells and " << tgtTotalSize
+        << " target cells" << incrIndent << endl;
+
+    singleProcess_ =
+        patchToPatchTools::singleProcess
+        (
+            srcMesh.nCells(),
+            tgtMesh.nCells()
+        );
+
+    scalar V = 0;
+
+    if (isSingleProcess())
+    {
+        // Do the intersection
+        V = calculate(srcMesh, tgtMesh);
+
+        // Normalise the weights
+        normalise(srcMesh, srcLocalTgtCells_, srcWeights_);
+        normalise(tgtMesh, tgtLocalSrcCells_, tgtWeights_);
+    }
+    else
+    {
+        // Create the target map of overlapping cells. This map gets remote
+        // parts of the target mesh so that everything needed to compute an
+        // intersection is available locally to the source. Use it to create a
+        // source-local target mesh.
+        tgtMapPtr_ =
+            patchToPatchTools::constructDistributionMap
+            (
+                tgtMeshSendCells(srcMesh, tgtMesh)
+            );
+        localTgtProcCellsPtr_.reset
+        (
+            new List<remote>
+            (
+                distributeMesh
+                (
+                    tgtMapPtr_(),
+                    tgtMesh,
+                    localTgtMeshPtr_
+                )
+            )
+        );
+        const polyMesh& localTgtMesh = localTgtMeshPtr_();
+
+        if (debug > 1)
+        {
+            Pout<< "Writing local target mesh: "
+                << localTgtMesh.name() << endl;
+            localTgtMesh.write();
+        }
+
+        // Do the intersection
+        V = calculate(srcMesh, localTgtMesh);
+
+        // Trim the local target mesh
+        trimLocalTgt();
+
+        if (debug > 1)
+        {
+            Pout<< "Writing trimmed local target mesh: "
+                << localTgtMesh.name() << endl;
+            localTgtMesh.write();
+        }
+
+        // Construct the source map
+        srcMapPtr_ =
+            patchToPatchTools::constructDistributionMap
+            (
+                patchToPatchTools::procSendIndices
+                (
+                    tgtLocalSrcCells_,
+                    localTgtProcCellsPtr_()
+                )
+            );
+        localSrcProcCellsPtr_.reset
+        (
+            new List<remote>
+            (
+                patchToPatchTools::distributeAddressing(srcMapPtr_())
+            )
+        );
+
+        // Collect the addressing on the target
+        patchToPatchTools::rDistributeTgtAddressing
+        (
+            tgtMesh.nCells(),
+            tgtMapPtr_(),
+            localSrcProcCellsPtr_(),
+            tgtLocalSrcCells_
+        );
+
+        // Collect the weights on the target
+        patchToPatchTools::rDistributeListList
+        (
+            tgtMesh.nCells(),
+            tgtMapPtr_(),
+            tgtWeights_
+        );
+
+        // Normalise the weights
+        normalise(srcMesh, srcLocalTgtCells_, srcWeights_);
+        normalise(tgtMesh, tgtLocalSrcCells_, tgtWeights_);
+
+        // Collect volume intersection contributions
+        reduce(V, sumOp<scalar>());
+    }
+
+    label nCouples = 0;
+    forAll(srcLocalTgtCells_, srcCelli)
+    {
+        nCouples += srcLocalTgtCells_[srcCelli].size();
+    }
+    forAll(tgtLocalSrcCells_, tgtCelli)
+    {
+        nCouples += tgtLocalSrcCells_[tgtCelli].size();
+    }
+    reduce(nCouples, sumOp<label>());
+
+    if (nCouples != 0)
+    {
+        Info<< indent << "Overlapping volume = " << V << endl
+            << indent << nCouples << " couplings calculated in "
+            << time.cpuTimeIncrement() << 's' << endl;
+    }
+    else
+    {
+        Info<< indent << "No couplings found" << endl;
+    }
+
+    Info<< decrIndent;
+
+    return V;
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/cellsToCells/cellsToCells/cellsToCells.H b/src/meshTools/cellsToCells/cellsToCells/cellsToCells.H
new file mode 100644
index 0000000000..7a63fb6906
--- /dev/null
+++ b/src/meshTools/cellsToCells/cellsToCells/cellsToCells.H
@@ -0,0 +1,301 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2012-2023 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::cellsToCells
+
+Description
+    Class to calculate interpolative addressing and weights between the cells
+    of two overlapping meshes
+
+SourceFiles
+    cellsToCells.C
+    cellsToCellsParallelOps.C
+    cellsToCellsTemplates.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cellsToCells_H
+#define cellsToCells_H
+
+#include "remote.H"
+#include "distributionMap.H"
+#include "polyMesh.H"
+#include "runTimeSelectionTables.H"
+#include "treeBoundBox.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                         Class cellsToCells Declaration
+\*---------------------------------------------------------------------------*/
+
+class cellsToCells
+{
+protected:
+
+    // Protected Data
+
+        //- Index of processor that holds all of both sides, or -1
+        label singleProcess_;
+
+        //- For each source cell, the coupled local target cells
+        labelListList srcLocalTgtCells_;
+
+        //- For each target cell, the coupled local source cells
+        labelListList tgtLocalSrcCells_;
+
+        //- For each source cell, the coupled target weights
+        scalarListList srcWeights_;
+
+        //- For each target cell, the coupled source weights
+        scalarListList tgtWeights_;
+
+        //- Map from source patch cells to target-local source patch cells
+        autoPtr<distributionMap> srcMapPtr_;
+
+        //- Map from target patch cells to source-local target patch cells
+        autoPtr<distributionMap> tgtMapPtr_;
+
+        //- When running in parallel, a map from local source cell index to
+        //  source processor and cell index
+        autoPtr<List<remote>> localSrcProcCellsPtr_;
+
+        //- When running in parallel, a map from local target cell index to
+        //  target processor and cell index
+        autoPtr<List<remote>> localTgtProcCellsPtr_;
+
+        //- The target mesh, distributed locally to the source
+        autoPtr<polyMesh> localTgtMeshPtr_;
+
+
+    // Protected Member Functions
+
+        // Intersection
+
+            //- Initialise the addressing and weights
+            void initialise
+            (
+                const polyMesh& srcMesh,
+                const polyMesh& tgtMesh
+            );
+
+            //- Calculate the addressing and weights
+            virtual scalar calculate
+            (
+                const polyMesh& srcMesh,
+                const polyMesh& tgtMesh
+            ) = 0;
+
+            //- Normalise the weights for a given mesh
+            virtual void normalise
+            (
+                const polyMesh& mesh,
+                labelListList& localOtherCells,
+                scalarListList& weights
+            ) const = 0;
+
+
+        // Helpers
+
+            //- Return src cell IDs for the overlap region
+            labelList maskCells
+            (
+                const polyMesh& srcMesh,
+                const polyMesh& tgtMesh
+            ) const;
+
+            //- Append target cell neighbour cells to cellIDs list
+            void appendNbrCells
+            (
+                const label tgtCelli,
+                const polyMesh& mesh,
+                const DynamicList<label>& visitedTgtCells,
+                DynamicList<label>& nbrTgtCellIDs
+            ) const;
+
+
+        // Parallel operations
+
+            //- Determine which target cells need to be sent to the source.
+            //  This is done before intersection. Bound boxes are used to
+            //  estimate what cells will intersect.
+            labelListList tgtMeshSendCells
+            (
+                const polyMesh& srcMesh,
+                const polyMesh& tgtMesh
+            ) const;
+
+            //- Distribute a mesh given its distribution map
+            static List<remote> distributeMesh
+            (
+                const distributionMap& map,
+                const polyMesh& mesh,
+                autoPtr<polyMesh>& localMeshPtr
+            );
+
+            //- Trim the local target addressing and mesh so that communication
+            //  from the target to the source is optimised
+            void trimLocalTgt();
+
+
+public:
+
+    //- Run-time type information
+    TypeName("cellsToCells");
+
+
+    //- Declare runtime constructor selection table
+    declareRunTimeSelectionTable
+    (
+        autoPtr,
+        cellsToCells,
+        word,
+        (),
+        ()
+    );
+
+
+    // Constructors
+
+        //- Construct null
+        cellsToCells();
+
+        //- Disallow default bitwise copy construction
+        cellsToCells(const cellsToCells&) = delete;
+
+
+    //- Destructor
+    virtual ~cellsToCells();
+
+
+    // Selector
+
+        //- Select from name
+        static autoPtr<cellsToCells> New(const word& cellsToCellsType);
+
+
+    // Member Functions
+
+        // Access
+
+            //- Index of the processor holding all cells of the cellsToCells,
+            //  or -1 if spread across multiple processors
+            inline label singleProcess() const;
+
+            //- Is this intersection on a single process?
+            inline bool isSingleProcess() const;
+
+
+        // Interpolation
+
+            //- Interpolate a source cell field to the target with no left
+            //  over values specified. If the interpolation weight sum is less
+            //  than one for a face then they will be normalised. If the
+            //  interpolation weight sum is zero for a face then that face's
+            //  value will be NaN.
+            template<class Type>
+            tmp<Field<Type>> srcToTgt(const Field<Type>& srcFld) const;
+
+            //- Interpolate a source cell field to the target with left over
+            //  values specified. If the interpolation weight sum is less than
+            //  one for a face then the average will include the left over
+            //  value multiplied by one minus the weight sum.
+            template<class Type>
+            tmp<Field<Type>> srcToTgt
+            (
+                const Field<Type>& srcFld,
+                const Field<Type>& leftOverTgtFld
+            ) const;
+
+            //- Interpolate a target cell field to the source with no left
+            //  over values specified. As the corresponding srcToTgt.
+            template<class Type>
+            tmp<Field<Type>> tgtToSrc(const Field<Type>& tgtFld) const;
+
+            //- Interpolate a target cell field to the source with left
+            //  over values specified. As the corresponding srcToTgt.
+            template<class Type>
+            tmp<Field<Type>> tgtToSrc
+            (
+                const Field<Type>& tgtFld,
+                const Field<Type>& leftOverSrcFld
+            ) const;
+
+
+        // Source-to-target point finding
+
+            //- Find the target processor and cell associated with a point in a
+            //  source cell. Note that this will only work with derivations
+            //  that fill a cell's stencil with everything that overlaps that
+            //  cell. qt present this is just cellsToCellss::intersection, but
+            //  we might add a cheaper bound-box based method like
+            //  patchToPatches::rays in future.
+            remote srcToTgtPoint
+            (
+                const polyMesh& tgtMesh,
+                const label srcCelli,
+                const point& p
+            ) const;
+
+
+        // Manipulation
+
+            //- Update addressing and weights for the given meshes. Returns the
+            //  overlapping volume (if that is relevant to the method).
+            scalar update
+            (
+                const polyMesh& srcMesh,
+                const polyMesh& tgtMesh
+            );
+
+
+    // Member Operators
+
+        //- Disallow default bitwise assignment
+        void operator=(const cellsToCells&) = delete;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "cellsToCellsI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "cellsToCellsTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/cellsToCells/cellsToCells/cellsToCellsI.H b/src/meshTools/cellsToCells/cellsToCells/cellsToCellsI.H
new file mode 100644
index 0000000000..710564d008
--- /dev/null
+++ b/src/meshTools/cellsToCells/cellsToCells/cellsToCellsI.H
@@ -0,0 +1,42 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2012-2023 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 "cellsToCells.H"
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+inline Foam::label Foam::cellsToCells::singleProcess() const
+{
+    return singleProcess_;
+}
+
+
+inline bool Foam::cellsToCells::isSingleProcess() const
+{
+    return singleProcess_ != -1;
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/meshToMesh/meshToMeshParallelOps.C b/src/meshTools/cellsToCells/cellsToCells/cellsToCellsParallelOps.C
similarity index 97%
rename from src/meshTools/meshToMesh/meshToMeshParallelOps.C
rename to src/meshTools/cellsToCells/cellsToCells/cellsToCellsParallelOps.C
index c08eac53b0..0d84e7d4bc 100644
--- a/src/meshTools/meshToMesh/meshToMeshParallelOps.C
+++ b/src/meshTools/cellsToCells/cellsToCells/cellsToCellsParallelOps.C
@@ -23,16 +23,36 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "meshToMesh.H"
-#include "OFstream.H"
-#include "Time.H"
-#include "globalIndex.H"
+#include "cellsToCells.H"
 #include "processorPolyPatch.H"
 #include "SubField.H"
+#include "Time.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+inline void offset(label& lst, const label o)
+{
+    lst += o;
+}
+
+template<class ListType>
+void offset(ListType& lst, const label o)
+{
+    forAll(lst, i)
+    {
+        offset(lst[i], o);
+    }
+}
+
+}
+
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-Foam::labelListList Foam::meshToMesh::tgtMeshSendCells
+Foam::labelListList Foam::cellsToCells::tgtMeshSendCells
 (
     const polyMesh& srcMesh,
     const polyMesh& tgtMesh
@@ -85,7 +105,7 @@ Foam::labelListList Foam::meshToMesh::tgtMeshSendCells
 }
 
 
-Foam::List<Foam::remote> Foam::meshToMesh::distributeMesh
+Foam::List<Foam::remote> Foam::cellsToCells::distributeMesh
 (
     const distributionMap& map,
     const polyMesh& mesh,
@@ -414,10 +434,7 @@ Foam::List<Foam::remote> Foam::meshToMesh::distributeMesh
             internalFaceOffset[proci]
         );
         slice = SubList<face>(fcs, allNInternalFaces[proci]);
-        forAll(slice, i)
-        {
-            add(slice[i], pointOffset[proci]);
-        }
+        offset(slice, pointOffset[proci]);
 
         SubField<label> ownSlice
         (
@@ -426,7 +443,7 @@ Foam::List<Foam::remote> Foam::meshToMesh::distributeMesh
             internalFaceOffset[proci]
         );
         ownSlice = SubField<label>(faceOs, allNInternalFaces[proci]);
-        add(ownSlice, cellOffset[proci]);
+        offset(ownSlice, cellOffset[proci]);
 
         SubField<label> nbrSlice
         (
@@ -435,7 +452,7 @@ Foam::List<Foam::remote> Foam::meshToMesh::distributeMesh
             internalFaceOffset[proci]
         );
         nbrSlice = SubField<label>(faceNs, allNInternalFaces[proci]);
-        add(nbrSlice, cellOffset[proci]);
+        offset(nbrSlice, cellOffset[proci]);
 
         internalFaceOffset[proci] += allNInternalFaces[proci];
     }
@@ -499,7 +516,7 @@ Foam::List<Foam::remote> Foam::meshToMesh::distributeMesh
                             localFaceNeighbours[localFacei] = newOwn;
                         }
 
-                        add(localFaces[localFacei], pointOffset[proci]);
+                        offset(localFaces[localFacei], pointOffset[proci]);
 
                         // mark with unique value
                         fnd() = -2;
@@ -549,7 +566,7 @@ Foam::List<Foam::remote> Foam::meshToMesh::distributeMesh
                     }
 
                     localFaces[localFacei] = fcs[i];
-                    add(localFaces[localFacei], pointOffset[proci]);
+                    offset(localFaces[localFacei], pointOffset[proci]);
 
                     localFaceOwners[localFacei] = newOwn;
                     localFaceNeighbours[localFacei] = -1;
@@ -568,7 +585,7 @@ Foam::List<Foam::remote> Foam::meshToMesh::distributeMesh
                     const label localFacei = nIntFaces++;
 
                     localFaces[localFacei] = fcs[i];
-                    add(localFaces[localFacei], pointOffset[proci]);
+                    offset(localFaces[localFacei], pointOffset[proci]);
 
                     localFaceOwners[localFacei] = newOwn;
                     localFaceNeighbours[localFacei] = -1;
@@ -617,7 +634,7 @@ Foam::List<Foam::remote> Foam::meshToMesh::distributeMesh
 }
 
 
-void Foam::meshToMesh::trimLocalTgt()
+void Foam::cellsToCells::trimLocalTgt()
 {
     // Determine which local target cells are actually used
     boolList oldLocalTgtCellIsUsed(localTgtProcCellsPtr_().size(), false);
diff --git a/src/meshTools/cellsToCells/cellsToCells/cellsToCellsTemplates.C b/src/meshTools/cellsToCells/cellsToCells/cellsToCellsTemplates.C
new file mode 100644
index 0000000000..a6d3e111b1
--- /dev/null
+++ b/src/meshTools/cellsToCells/cellsToCells/cellsToCellsTemplates.C
@@ -0,0 +1,99 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2012-2023 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 "cellsToCells.H"
+#include "patchToPatchTools.H"
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::tmp<Foam::Field<Type>>
+Foam::cellsToCells::srcToTgt(const Field<Type>& srcFld) const
+{
+    return
+        patchToPatchTools::interpolate
+        (
+            tgtLocalSrcCells_,
+            tgtWeights_,
+            srcMapPtr_,
+            srcFld
+        );
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type>> Foam::cellsToCells::srcToTgt
+(
+    const Field<Type>& srcFld,
+    const Field<Type>& leftOverTgtFld
+) const
+{
+    return
+        patchToPatchTools::interpolate
+        (
+            tgtLocalSrcCells_,
+            tgtWeights_,
+            srcMapPtr_,
+            srcFld,
+            leftOverTgtFld
+        );
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type>>
+Foam::cellsToCells::tgtToSrc(const Field<Type>& tgtFld) const
+{
+    return
+        patchToPatchTools::interpolate
+        (
+            srcLocalTgtCells_,
+            srcWeights_,
+            tgtMapPtr_,
+            tgtFld
+        );
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type>> Foam::cellsToCells::tgtToSrc
+(
+    const Field<Type>& tgtFld,
+    const Field<Type>& leftOverSrcFld
+) const
+{
+    return
+        patchToPatchTools::interpolate
+        (
+            srcLocalTgtCells_,
+            srcWeights_,
+            tgtMapPtr_,
+            tgtFld,
+            leftOverSrcFld
+        );
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/meshToMesh/calcMethod/cellVolumeWeight/cellVolumeWeightMethod.C b/src/meshTools/cellsToCells/intersection/intersectionCellsToCells.C
similarity index 70%
rename from src/meshTools/meshToMesh/calcMethod/cellVolumeWeight/cellVolumeWeightMethod.C
rename to src/meshTools/cellsToCells/intersection/intersectionCellsToCells.C
index 8943b60491..8dc5087809 100644
--- a/src/meshTools/meshToMesh/calcMethod/cellVolumeWeight/cellVolumeWeightMethod.C
+++ b/src/meshTools/cellsToCells/intersection/intersectionCellsToCells.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2013-2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2013-2023 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -23,8 +23,7 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "cellVolumeWeightMethod.H"
-#include "intersectionPatchToPatch.H"
+#include "intersectionCellsToCells.H"
 #include "indexedOctree.H"
 #include "treeDataCell.H"
 #include "tetOverlapVolume.H"
@@ -34,70 +33,64 @@ License
 
 namespace Foam
 {
-    defineTypeNameAndDebug(cellVolumeWeightMethod, 0);
-    addToRunTimeSelectionTable
-    (
-        meshToMeshMethod,
-        cellVolumeWeightMethod,
-        components
-    );
+namespace cellsToCellss
+{
+    defineTypeNameAndDebug(intersection, 0);
+    addToRunTimeSelectionTable(cellsToCells, intersection, word);
+}
 }
 
 
-const Foam::scalar Foam::cellVolumeWeightMethod::tolerance_ = 1e-6;
+const Foam::scalar Foam::cellsToCellss::intersection::tolerance_ = 1e-6;
 
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-bool Foam::cellVolumeWeightMethod::intersect
+bool Foam::cellsToCellss::intersection::intersect
 (
+    const polyMesh& srcMesh,
+    const polyMesh& tgtMesh,
     const label srcCelli,
     const label tgtCelli
 ) const
 {
-    scalar threshold = tolerance_*src_.cellVolumes()[srcCelli];
-
-    tetOverlapVolume overlapEngine;
-
-    treeBoundBox bbTgtCell(tgt_.points(), tgt_.cellPoints()[tgtCelli]);
-
-    return overlapEngine.cellCellOverlapMinDecomp
-    (
-        src_,
-        srcCelli,
-        tgt_,
-        tgtCelli,
-        bbTgtCell,
-        threshold
-    );
+    return
+        tetOverlapVolume().cellCellOverlapMinDecomp
+        (
+            srcMesh,
+            srcCelli,
+            tgtMesh,
+            tgtCelli,
+            treeBoundBox(tgtMesh.points(), tgtMesh.cellPoints()[tgtCelli]),
+            tolerance_*srcMesh.cellVolumes()[srcCelli]
+        );
 }
 
 
-Foam::scalar Foam::cellVolumeWeightMethod::interVol
+Foam::scalar Foam::cellsToCellss::intersection::interVol
 (
+    const polyMesh& srcMesh,
+    const polyMesh& tgtMesh,
     const label srcCelli,
     const label tgtCelli
 ) const
 {
-    tetOverlapVolume overlapEngine;
-
-    treeBoundBox bbTgtCell(tgt_.points(), tgt_.cellPoints()[tgtCelli]);
-
-    scalar vol = overlapEngine.cellCellOverlapVolumeMinDecomp
-    (
-        src_,
-        srcCelli,
-        tgt_,
-        tgtCelli,
-        bbTgtCell
-    );
-
-    return vol;
+    return
+        tetOverlapVolume().cellCellOverlapVolumeMinDecomp
+        (
+            srcMesh,
+            srcCelli,
+            tgtMesh,
+            tgtCelli,
+            treeBoundBox(tgtMesh.points(), tgtMesh.cellPoints()[tgtCelli])
+        );
 }
 
 
-bool Foam::cellVolumeWeightMethod::findInitialSeeds
+bool Foam::cellsToCellss::intersection::findInitialSeeds
 (
+    const polyMesh& srcMesh,
+    const polyMesh& tgtMesh,
     const labelList& srcCellIDs,
     const boolList& mapFlag,
     const label startSeedI,
@@ -105,9 +98,9 @@ bool Foam::cellVolumeWeightMethod::findInitialSeeds
     label& tgtSeedI
 ) const
 {
-    const cellList& srcCells = src_.cells();
-    const faceList& srcFaces = src_.faces();
-    const pointField& srcPts = src_.points();
+    const cellList& srcCells = srcMesh.cells();
+    const faceList& srcFaces = srcMesh.faces();
+    const pointField& srcPts = srcMesh.points();
 
     for (label i = startSeedI; i < srcCellIDs.size(); i++)
     {
@@ -117,7 +110,7 @@ bool Foam::cellVolumeWeightMethod::findInitialSeeds
         {
             const labelList tgtIDs
             (
-                tgt_.cellTree().findBox
+                tgtMesh.cellTree().findBox
                 (
                     treeBoundBox(srcCells[srcI].bb(srcPts, srcFaces))
                 )
@@ -127,7 +120,7 @@ bool Foam::cellVolumeWeightMethod::findInitialSeeds
             {
                 const label tgtI = tgtIDs[j];
 
-                if (intersect(srcI, tgtI))
+                if (intersect(srcMesh, tgtMesh, srcI, tgtI))
                 {
                     srcSeedI = srcI;
                     tgtSeedI = tgtI;
@@ -147,8 +140,10 @@ bool Foam::cellVolumeWeightMethod::findInitialSeeds
 }
 
 
-Foam::scalar Foam::cellVolumeWeightMethod::calculateAddressing
+Foam::scalar Foam::cellsToCellss::intersection::calculateAddressing
 (
+    const polyMesh& srcMesh,
+    const polyMesh& tgtMesh,
     labelListList& srcToTgtCellAddr,
     scalarListList& srcToTgtCellWght,
     labelListList& tgtToSrcCellAddr,
@@ -165,11 +160,11 @@ Foam::scalar Foam::cellVolumeWeightMethod::calculateAddressing
     label srcCelli = srcSeedI;
     label tgtCelli = tgtSeedI;
 
-    List<DynamicList<label>> srcToTgtAddr(src_.nCells());
-    List<DynamicList<scalar>> srcToTgtWght(src_.nCells());
+    List<DynamicList<label>> srcToTgtAddr(srcMesh.nCells());
+    List<DynamicList<scalar>> srcToTgtWght(srcMesh.nCells());
 
-    List<DynamicList<label>> tgtToSrcAddr(tgt_.nCells());
-    List<DynamicList<scalar>> tgtToSrcWght(tgt_.nCells());
+    List<DynamicList<label>> tgtToSrcAddr(tgtMesh.nCells());
+    List<DynamicList<scalar>> tgtToSrcWght(tgtMesh.nCells());
 
     // list of tgt cell neighbour cells
     DynamicList<label> nbrTgtCells(10);
@@ -178,10 +173,10 @@ Foam::scalar Foam::cellVolumeWeightMethod::calculateAddressing
     DynamicList<label> visitedTgtCells(10);
 
     // list to keep track of tgt cells used to seed src cells
-    labelList seedCells(src_.nCells(), -1);
+    labelList seedCells(srcMesh.nCells(), -1);
     seedCells[srcCelli] = tgtCelli;
 
-    const scalarField& srcVol = src_.cellVolumes();
+    const scalarField& srcVol = srcMesh.cellVolumes();
 
     do
     {
@@ -190,14 +185,14 @@ Foam::scalar Foam::cellVolumeWeightMethod::calculateAddressing
 
         // append initial target cell and neighbours
         nbrTgtCells.append(tgtCelli);
-        appendNbrCells(tgtCelli, tgt_, visitedTgtCells, nbrTgtCells);
+        appendNbrCells(tgtCelli, tgtMesh, visitedTgtCells, nbrTgtCells);
 
         do
         {
             tgtCelli = nbrTgtCells.remove();
             visitedTgtCells.append(tgtCelli);
 
-            scalar vol = interVol(srcCelli, tgtCelli);
+            scalar vol = interVol(srcMesh, tgtMesh, srcCelli, tgtCelli);
 
             // accumulate addressing and weights for valid intersection
             if (vol/srcVol[srcCelli] > tolerance_)
@@ -209,7 +204,7 @@ Foam::scalar Foam::cellVolumeWeightMethod::calculateAddressing
                 tgtToSrcAddr[tgtCelli].append(srcCelli);
                 tgtToSrcWght[tgtCelli].append(vol);
 
-                appendNbrCells(tgtCelli, tgt_, visitedTgtCells, nbrTgtCells);
+                appendNbrCells(tgtCelli, tgtMesh, visitedTgtCells, nbrTgtCells);
 
                 // accumulate intersection volume
                 V += vol;
@@ -222,6 +217,8 @@ Foam::scalar Foam::cellVolumeWeightMethod::calculateAddressing
         // find new source seed cell
         setNextCells
         (
+            srcMesh,
+            tgtMesh,
             startSeedI,
             srcCelli,
             tgtCelli,
@@ -250,8 +247,10 @@ Foam::scalar Foam::cellVolumeWeightMethod::calculateAddressing
 }
 
 
-void Foam::cellVolumeWeightMethod::setNextCells
+void Foam::cellsToCellss::intersection::setNextCells
 (
+    const polyMesh& srcMesh,
+    const polyMesh& tgtMesh,
     label& startSeedI,
     label& srcCelli,
     label& tgtCelli,
@@ -261,7 +260,7 @@ void Foam::cellVolumeWeightMethod::setNextCells
     labelList& seedCells
 ) const
 {
-    const labelList& srcNbrCells = src_.cellCells()[srcCelli];
+    const labelList& srcNbrCells = srcMesh.cellCells()[srcCelli];
 
     // set possible seeds for later use by querying all src cell neighbours
     // with all visited target cells
@@ -276,7 +275,7 @@ void Foam::cellVolumeWeightMethod::setNextCells
             {
                 label cellT = visitedCells[j];
 
-                if (intersect(cellS, cellT))
+                if (intersect(srcMesh, tgtMesh, cellS, cellT))
                 {
                     seedCells[cellS] = cellT;
 
@@ -332,6 +331,8 @@ void Foam::cellVolumeWeightMethod::setNextCells
         bool restart =
             findInitialSeeds
             (
+                srcMesh,
+                tgtMesh,
                 srcCellIDs,
                 mapFlag,
                 startSeedI,
@@ -352,68 +353,32 @@ void Foam::cellVolumeWeightMethod::setNextCells
 }
 
 
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
-Foam::cellVolumeWeightMethod::cellVolumeWeightMethod
+Foam::scalar Foam::cellsToCellss::intersection::calculate
 (
-    const polyMesh& src,
-    const polyMesh& tgt
-)
-:
-    meshToMeshMethod(src, tgt)
-{}
-
-
-// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
-
-Foam::cellVolumeWeightMethod::~cellVolumeWeightMethod()
-{}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-const Foam::word& Foam::cellVolumeWeightMethod::patchToPatchMethod() const
-{
-    return patchToPatches::intersection::typeName;
-}
-
-
-Foam::scalar Foam::cellVolumeWeightMethod::calculate
-(
-    labelListList& srcToTgtAddr,
-    scalarListList& srcToTgtWght,
-    labelListList& tgtToSrcAddr,
-    scalarListList& tgtToSrcWght
+    const polyMesh& srcMesh,
+    const polyMesh& tgtMesh
 )
 {
-    bool ok = initialise
-    (
-        srcToTgtAddr,
-        srcToTgtWght,
-        tgtToSrcAddr,
-        tgtToSrcWght
-    );
+    initialise(srcMesh, tgtMesh);
 
-    if (!ok)
-    {
-        return 0;
-    }
+    // Determine (potentially) participating source mesh cells
+    const labelList srcCellIDs(maskCells(srcMesh, tgtMesh));
 
-    // (potentially) participating source mesh cells
-    const labelList srcCellIDs(maskCells());
-
-    // list to keep track of whether src cell can be mapped
-    boolList mapFlag(src_.nCells(), false);
+    // Initialise list to keep track of whether src cell can be mapped
+    boolList mapFlag(srcMesh.nCells(), false);
     UIndirectList<bool>(mapFlag, srcCellIDs) = true;
 
-    // find initial point in tgt mesh
+    // Find initial point in tgt mesh
     label srcSeedI = -1;
     label tgtSeedI = -1;
     label startSeedI = 0;
-
     bool startWalk =
         findInitialSeeds
         (
+            srcMesh,
+            tgtMesh,
             srcCellIDs,
             mapFlag,
             startSeedI,
@@ -423,26 +388,21 @@ Foam::scalar Foam::cellVolumeWeightMethod::calculate
 
     if (startWalk)
     {
-        const scalar V =
+        return
             calculateAddressing
             (
-                srcToTgtAddr,
-                srcToTgtWght,
-                tgtToSrcAddr,
-                tgtToSrcWght,
+                srcMesh,
+                tgtMesh,
+                srcLocalTgtCells_,
+                srcWeights_,
+                tgtLocalSrcCells_,
+                tgtWeights_,
                 srcSeedI,
                 tgtSeedI,
                 srcCellIDs,
                 mapFlag,
                 startSeedI
             );
-
-        if (debug > 1)
-        {
-            writeConnectivity(src_, tgt_, srcToTgtAddr);
-        }
-
-        return V;
     }
     else
     {
@@ -451,7 +411,7 @@ Foam::scalar Foam::cellVolumeWeightMethod::calculate
 }
 
 
-void Foam::cellVolumeWeightMethod::normalise
+void Foam::cellsToCellss::intersection::normalise
 (
     const polyMesh& srcMesh,
     labelListList& srcToTgtAddr,
@@ -472,4 +432,18 @@ void Foam::cellVolumeWeightMethod::normalise
 }
 
 
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::cellsToCellss::intersection::intersection()
+:
+    cellsToCells()
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
+
+Foam::cellsToCellss::intersection::~intersection()
+{}
+
+
 // ************************************************************************* //
diff --git a/src/meshTools/meshToMesh/calcMethod/cellVolumeWeight/cellVolumeWeightMethod.H b/src/meshTools/cellsToCells/intersection/intersectionCellsToCells.H
similarity index 66%
rename from src/meshTools/meshToMesh/calcMethod/cellVolumeWeight/cellVolumeWeightMethod.H
rename to src/meshTools/cellsToCells/intersection/intersectionCellsToCells.H
index 608553c283..5ec06c5700 100644
--- a/src/meshTools/meshToMesh/calcMethod/cellVolumeWeight/cellVolumeWeightMethod.H
+++ b/src/meshTools/cellsToCells/intersection/intersectionCellsToCells.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2013-2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2013-2023 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -22,39 +22,39 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::cellVolumeWeightMethod
+    Foam::cellsToCellss::intersection
 
 Description
-    Cell-volume-weighted mesh-to-mesh interpolation class
-
-    Volume conservative.
+    Intersection-based cells-to-cells interpolation class. Volume conservative.
 
 SourceFiles
-    cellVolumeWeightMethod.C
+    intersectionCellsToCells.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef cellVolumeWeightMethod_H
-#define cellVolumeWeightMethod_H
+#ifndef intersectionCellsToCells_H
+#define intersectionCellsToCells_H
 
-#include "meshToMeshMethod.H"
+#include "cellsToCells.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
+namespace cellsToCellss
+{
 
 /*---------------------------------------------------------------------------*\
-                   Class cellVolumeWeightMethod Declaration
+                        Class intersection Declaration
 \*---------------------------------------------------------------------------*/
 
-class cellVolumeWeightMethod
+class intersection
 :
-    public meshToMeshMethod
+    public cellsToCells
 {
 private:
 
-    // Private static data
+    // Private Static Data
 
         //- Tolerance used in volume overlap calculations
         static const scalar tolerance_;
@@ -63,15 +63,29 @@ private:
     // Private Member Functions
 
         //- Return the true if cells intersect
-        bool intersect(const label srcCelli, const label tgtCelli) const;
+        bool intersect
+        (
+            const polyMesh& srcMesh,
+            const polyMesh& tgtMesh,
+            const label srcCelli,
+            const label tgtCelli
+        ) const;
 
         //- Return the intersection volume between two cells
-        scalar interVol(const label srcCelli, const label tgtCelli) const;
+        scalar interVol
+        (
+            const polyMesh& srcMesh,
+            const polyMesh& tgtMesh,
+            const label srcCelli,
+            const label tgtCelli
+        ) const;
 
         //- Find indices of overlapping cells in src and tgt meshes - returns
         //  true if found a matching pair
         bool findInitialSeeds
         (
+            const polyMesh& srcMesh,
+            const polyMesh& tgtMesh,
             const labelList& srcCellIDs,
             const boolList& mapFlag,
             const label startSeedI,
@@ -82,6 +96,8 @@ private:
         //- Calculate the mesh-to-mesh addressing and weights
         scalar calculateAddressing
         (
+            const polyMesh& srcMesh,
+            const polyMesh& tgtMesh,
             labelListList& srcToTgtCellAddr,
             scalarListList& srcToTgtCellWght,
             labelListList& tgtToSrcCellAddr,
@@ -96,6 +112,8 @@ private:
         //- Set the next cells in the advancing front algorithm
         void setNextCells
         (
+            const polyMesh& srcMesh,
+            const polyMesh& tgtMesh,
             label& startSeedI,
             label& srcCelli,
             label& tgtCelli,
@@ -106,48 +124,48 @@ private:
         ) const;
 
 
+protected:
+
+    // Protected Member Functions
+
+        // Intersection
+
+            //- Calculate the addressing and weights
+            virtual scalar calculate
+            (
+                const polyMesh& srcMesh,
+                const polyMesh& tgtMesh
+            );
+
+            //- Normalise the weights for a given mesh
+            virtual void normalise
+            (
+                const polyMesh& mesh,
+                labelListList& localOtherCells,
+                scalarListList& weights
+            ) const;
+
+
 public:
 
     //- Run-time type information
-    TypeName("cellVolumeWeight");
+    TypeName("intersection");
 
 
     // Constructors
 
-        //- Construct from source and target meshes
-        cellVolumeWeightMethod(const polyMesh& src, const polyMesh& tgt);
+        //- Construct null
+        intersection();
 
 
     //- Destructor
-    virtual ~cellVolumeWeightMethod();
-
-
-    // Member Functions
-
-        //- Get the corresponding patchToPatch method
-        virtual const word& patchToPatchMethod() const;
-
-        //- Calculate addressing and weights
-        virtual scalar calculate
-        (
-            labelListList& srcToTgtAddr,
-            scalarListList& srcToTgtWght,
-            labelListList& tgtToTgtAddr,
-            scalarListList& tgtToTgtWght
-        );
-
-        //- Normalise the weights for a given mesh
-        virtual void normalise
-        (
-            const polyMesh& srcMesh,
-            labelListList& srcToTgtAddr,
-            scalarListList& srcToTgtWght
-        ) const;
+    virtual ~intersection();
 };
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+} // End namespace cellsToCellss
 } // End namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/meshTools/meshToMesh/calcMethod/direct/directMethod.C b/src/meshTools/cellsToCells/matching/matchingCellsToCells.C
similarity index 70%
rename from src/meshTools/meshToMesh/calcMethod/direct/directMethod.C
rename to src/meshTools/cellsToCells/matching/matchingCellsToCells.C
index 0401b45941..b1f6cd5316 100644
--- a/src/meshTools/meshToMesh/calcMethod/direct/directMethod.C
+++ b/src/meshTools/cellsToCells/matching/matchingCellsToCells.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2013-2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2013-2023 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -23,8 +23,7 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "directMethod.H"
-#include "matchingPatchToPatch.H"
+#include "matchingCellsToCells.H"
 #include "indexedOctree.H"
 #include "treeDataCell.H"
 #include "addToRunTimeSelectionTable.H"
@@ -33,30 +32,37 @@ License
 
 namespace Foam
 {
-    defineTypeNameAndDebug(directMethod, 0);
-    addToRunTimeSelectionTable(meshToMeshMethod, directMethod, components);
+namespace cellsToCellss
+{
+    defineTypeNameAndDebug(matching, 0);
+    addToRunTimeSelectionTable(cellsToCells, matching, word);
+}
 }
 
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-bool Foam::directMethod::intersect
+bool Foam::cellsToCellss::matching::intersect
 (
+    const polyMesh& srcMesh,
+    const polyMesh& tgtMesh,
     const label srcCelli,
     const label tgtCelli
 ) const
 {
-    return tgt_.pointInCell
+    return tgtMesh.pointInCell
     (
-        src_.cellCentres()[srcCelli],
+        srcMesh.cellCentres()[srcCelli],
         tgtCelli,
         polyMesh::FACE_PLANES
     );
 }
 
 
-bool Foam::directMethod::findInitialSeeds
+bool Foam::cellsToCellss::matching::findInitialSeeds
 (
+    const polyMesh& srcMesh,
+    const polyMesh& tgtMesh,
     const labelList& srcCellIDs,
     const boolList& mapFlag,
     const label startSeedI,
@@ -64,9 +70,9 @@ bool Foam::directMethod::findInitialSeeds
     label& tgtSeedI
 ) const
 {
-    const cellList& srcCells = src_.cells();
-    const faceList& srcFaces = src_.faces();
-    const pointField& srcPts = src_.points();
+    const cellList& srcCells = srcMesh.cells();
+    const faceList& srcFaces = srcMesh.faces();
+    const pointField& srcPts = srcMesh.points();
 
     for (label i = startSeedI; i < srcCellIDs.size(); i++)
     {
@@ -75,9 +81,9 @@ bool Foam::directMethod::findInitialSeeds
         if (mapFlag[srcI])
         {
             const point srcCtr(srcCells[srcI].centre(srcPts, srcFaces));
-            label tgtI = tgt_.cellTree().findInside(srcCtr);
+            label tgtI = tgtMesh.cellTree().findInside(srcCtr);
 
-            if (tgtI != -1 && intersect(srcI, tgtI))
+            if (tgtI != -1 && intersect(srcMesh, tgtMesh, srcI, tgtI))
             {
                 srcSeedI = srcI;
                 tgtSeedI = tgtI;
@@ -96,8 +102,10 @@ bool Foam::directMethod::findInitialSeeds
 }
 
 
-Foam::scalar Foam::directMethod::calculateAddressing
+Foam::scalar Foam::cellsToCellss::matching::calculateAddressing
 (
+    const polyMesh& srcMesh,
+    const polyMesh& tgtMesh,
     labelListList& srcToTgtCellAddr,
     scalarListList& srcToTgtCellWght,
     labelListList& tgtToSrcCellAddr,
@@ -112,15 +120,15 @@ Foam::scalar Foam::directMethod::calculateAddressing
     scalar V = 0;
 
     // store a list of src cells already mapped
-    labelList srcTgtSeed(src_.nCells(), -1);
+    labelList srcTgtSeed(srcMesh.nCells(), -1);
 
-    List<DynamicList<label>> srcToTgt(src_.nCells());
-    List<DynamicList<label>> tgtToSrc(tgt_.nCells());
+    List<DynamicList<label>> srcToTgt(srcMesh.nCells());
+    List<DynamicList<label>> tgtToSrc(tgtMesh.nCells());
 
     DynamicList<label> srcSeeds(10);
 
-    const scalarField& srcVc = src_.cellVolumes();
-    const scalarField& tgtVc = tgt_.cellVolumes();
+    const scalarField& srcVc = srcMesh.cellVolumes();
+    const scalarField& tgtVc = tgtMesh.cellVolumes();
 
     label srcCelli = srcSeedI;
     label tgtCelli = tgtSeedI;
@@ -140,6 +148,8 @@ Foam::scalar Foam::directMethod::calculateAddressing
         // find new source seed cell
         appendToDirectSeeds
         (
+            srcMesh,
+            tgtMesh,
             mapFlag,
             srcTgtSeed,
             srcSeeds,
@@ -166,8 +176,10 @@ Foam::scalar Foam::directMethod::calculateAddressing
 }
 
 
-void Foam::directMethod::appendToDirectSeeds
+void Foam::cellsToCellss::matching::appendToDirectSeeds
 (
+    const polyMesh& srcMesh,
+    const polyMesh& tgtMesh,
     boolList& mapFlag,
     labelList& srcTgtSeed,
     DynamicList<label>& srcSeeds,
@@ -175,8 +187,8 @@ void Foam::directMethod::appendToDirectSeeds
     label& tgtSeedI
 ) const
 {
-    const labelList& srcNbr = src_.cellCells()[srcSeedI];
-    const labelList& tgtNbr = tgt_.cellCells()[tgtSeedI];
+    const labelList& srcNbr = srcMesh.cellCells()[srcSeedI];
+    const labelList& tgtNbr = tgtMesh.cellCells()[tgtSeedI];
 
     forAll(srcNbr, i)
     {
@@ -192,7 +204,7 @@ void Foam::directMethod::appendToDirectSeeds
             {
                 label tgtI = tgtNbr[j];
 
-                if (intersect(srcI, tgtI))
+                if (intersect(srcMesh, tgtMesh, srcI, tgtI))
                 {
                     // new match - append to lists
                     found = true;
@@ -224,67 +236,32 @@ void Foam::directMethod::appendToDirectSeeds
     }
 }
 
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
-Foam::directMethod::directMethod
+Foam::scalar Foam::cellsToCellss::matching::calculate
 (
-    const polyMesh& src,
-    const polyMesh& tgt
-)
-:
-    meshToMeshMethod(src, tgt)
-{}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-Foam::directMethod::~directMethod()
-{}
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-const Foam::word& Foam::directMethod::patchToPatchMethod() const
-{
-    return patchToPatches::matching::typeName;
-}
-
-
-Foam::scalar Foam::directMethod::calculate
-(
-    labelListList& srcToTgtAddr,
-    scalarListList& srcToTgtWght,
-    labelListList& tgtToSrcAddr,
-    scalarListList& tgtToSrcWght
+    const polyMesh& srcMesh,
+    const polyMesh& tgtMesh
 )
 {
-    bool ok = initialise
-    (
-        srcToTgtAddr,
-        srcToTgtWght,
-        tgtToSrcAddr,
-        tgtToSrcWght
-    );
+    initialise(srcMesh, tgtMesh);
 
-    if (!ok)
-    {
-        return 0;
-    }
+    // Determine (potentially) participating source mesh cells
+    const labelList srcCellIDs(maskCells(srcMesh, tgtMesh));
 
-    // (potentially) participating source mesh cells
-    const labelList srcCellIDs(maskCells());
-
-    // list to keep track of whether src cell can be mapped
-    boolList mapFlag(src_.nCells(), false);
+    // Initialise list to keep track of whether src cell can be mapped
+    boolList mapFlag(srcMesh.nCells(), false);
     UIndirectList<bool>(mapFlag, srcCellIDs) = true;
 
-    // find initial point in tgt mesh
+    // Find initial point in tgt mesh
     label srcSeedI = -1;
     label tgtSeedI = -1;
     label startSeedI = 0;
-
     bool startWalk =
         findInitialSeeds
         (
+            srcMesh,
+            tgtMesh,
             srcCellIDs,
             mapFlag,
             startSeedI,
@@ -294,26 +271,21 @@ Foam::scalar Foam::directMethod::calculate
 
     if (startWalk)
     {
-        const scalar V =
+        return
             calculateAddressing
             (
-                srcToTgtAddr,
-                srcToTgtWght,
-                tgtToSrcAddr,
-                tgtToSrcWght,
+                srcMesh,
+                tgtMesh,
+                srcLocalTgtCells_,
+                srcWeights_,
+                tgtLocalSrcCells_,
+                tgtWeights_,
                 srcSeedI,
                 tgtSeedI,
                 srcCellIDs,
                 mapFlag,
                 startSeedI
             );
-
-        if (debug > 1)
-        {
-            writeConnectivity(src_, tgt_, srcToTgtAddr);
-        }
-
-        return V;
     }
     else
     {
@@ -322,7 +294,7 @@ Foam::scalar Foam::directMethod::calculate
 }
 
 
-void Foam::directMethod::normalise
+void Foam::cellsToCellss::matching::normalise
 (
     const polyMesh& srcMesh,
     labelListList& srcToTgtAddr,
@@ -341,4 +313,18 @@ void Foam::directMethod::normalise
 }
 
 
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::cellsToCellss::matching::matching()
+:
+    cellsToCells()
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cellsToCellss::matching::~matching()
+{}
+
+
 // ************************************************************************* //
diff --git a/src/meshTools/meshToMesh/calcMethod/direct/directMethod.H b/src/meshTools/cellsToCells/matching/matchingCellsToCells.H
similarity index 70%
rename from src/meshTools/meshToMesh/calcMethod/direct/directMethod.H
rename to src/meshTools/cellsToCells/matching/matchingCellsToCells.H
index 7786179e52..f98f224e20 100644
--- a/src/meshTools/meshToMesh/calcMethod/direct/directMethod.H
+++ b/src/meshTools/cellsToCells/matching/matchingCellsToCells.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2013-2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2013-2023 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -22,35 +22,35 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::directMethod
+    Foam::cellsToCellss::matching
 
 Description
-    Direct (one-to-one cell correspondence) mesh-to-mesh interpolation class
-
-    Volume conservative.
+    Matching, one-to-one, cells-to-cells interpolation class.
 
 SourceFiles
-    directMethod.C
+    matchingCellsToCells.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef directMethod_H
-#define directMethod_H
+#ifndef matchingCellsToCells_H
+#define matchingCellsToCells_H
 
-#include "meshToMeshMethod.H"
+#include "cellsToCells.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
+namespace cellsToCellss
+{
 
 /*---------------------------------------------------------------------------*\
-                        Class directMethod Declaration
+                        Class matching Declaration
 \*---------------------------------------------------------------------------*/
 
-class directMethod
+class matching
 :
-    public meshToMeshMethod
+    public cellsToCells
 {
 private:
 
@@ -59,6 +59,8 @@ private:
         //- Return the true if cells intersect
         bool intersect
         (
+            const polyMesh& srcMesh,
+            const polyMesh& tgtMesh,
             const label srcCelli,
             const label tgtCelli
         ) const;
@@ -67,6 +69,8 @@ private:
         //  true if found a matching pair
         bool findInitialSeeds
         (
+            const polyMesh& srcMesh,
+            const polyMesh& tgtMesh,
             const labelList& srcCellIDs,
             const boolList& mapFlag,
             const label startSeedI,
@@ -77,6 +81,8 @@ private:
         //- Calculate the mesh-to-mesh addressing and weights
         scalar calculateAddressing
         (
+            const polyMesh& srcMesh,
+            const polyMesh& tgtMesh,
             labelListList& srcToTgtCellAddr,
             scalarListList& srcToTgtCellWght,
             labelListList& tgtToSrcCellAddr,
@@ -91,6 +97,8 @@ private:
         //- Append to list of src mesh seed indices
         void appendToDirectSeeds
         (
+            const polyMesh& srcMesh,
+            const polyMesh& tgtMesh,
             boolList& mapFlag,
             labelList& srcTgtSeed,
             DynamicList<label>& srcSeeds,
@@ -99,48 +107,48 @@ private:
         ) const;
 
 
+protected:
+
+    // Protected Member Functions
+
+        // Intersection
+
+            //- Calculate the addressing and weights
+            virtual scalar calculate
+            (
+                const polyMesh& srcMesh,
+                const polyMesh& tgtMesh
+            );
+
+            //- Normalise the weights for a given mesh
+            virtual void normalise
+            (
+                const polyMesh& mesh,
+                labelListList& localOtherCells,
+                scalarListList& weights
+            ) const;
+
+
 public:
 
     //- Run-time type information
-    TypeName("direct");
+    TypeName("matching");
 
 
     // Constructors
 
-        //- Construct from source and target meshes
-        directMethod(const polyMesh& src, const polyMesh& tgt);
+        //- Construct null
+        matching();
 
 
     //- Destructor
-    virtual ~directMethod();
-
-
-    // Member Functions
-
-        //- Get the corresponding patchToPatch method
-        virtual const word& patchToPatchMethod() const;
-
-        //- Calculate addressing and weights
-        virtual scalar calculate
-        (
-            labelListList& srcToTgtAddr,
-            scalarListList& srcToTgtWght,
-            labelListList& tgtToTgtAddr,
-            scalarListList& tgtToTgtWght
-        );
-
-        //- Normalise the weights for a given mesh
-        virtual void normalise
-        (
-            const polyMesh& srcMesh,
-            labelListList& srcToTgtAddr,
-            scalarListList& srcToTgtWght
-        ) const;
+    virtual ~matching();
 };
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+} // End namespace cellsToCellss
 } // End namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/meshTools/meshToMesh/calcMethod/mapNearest/mapNearestMethod.C b/src/meshTools/cellsToCells/nearest/nearestCellsToCells.C
similarity index 76%
rename from src/meshTools/meshToMesh/calcMethod/mapNearest/mapNearestMethod.C
rename to src/meshTools/cellsToCells/nearest/nearestCellsToCells.C
index 527c23837d..5d04e24f05 100644
--- a/src/meshTools/meshToMesh/calcMethod/mapNearest/mapNearestMethod.C
+++ b/src/meshTools/cellsToCells/nearest/nearestCellsToCells.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2013-2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2013-2023 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -23,8 +23,7 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "mapNearestMethod.H"
-#include "nearestPatchToPatch.H"
+#include "nearestCellsToCells.H"
 #include "pointIndexHit.H"
 #include "indexedOctree.H"
 #include "treeDataCell.H"
@@ -34,15 +33,20 @@ License
 
 namespace Foam
 {
-    defineTypeNameAndDebug(mapNearestMethod, 0);
-    addToRunTimeSelectionTable(meshToMeshMethod, mapNearestMethod, components);
+namespace cellsToCellss
+{
+    defineTypeNameAndDebug(nearest, 0);
+    addToRunTimeSelectionTable(cellsToCells, nearest, word);
+}
 }
 
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-bool Foam::mapNearestMethod::findInitialSeeds
+bool Foam::cellsToCellss::nearest::findInitialSeeds
 (
+    const polyMesh& srcMesh,
+    const polyMesh& tgtMesh,
     const labelList& srcCellIDs,
     const boolList& mapFlag,
     const label startSeedI,
@@ -50,7 +54,7 @@ bool Foam::mapNearestMethod::findInitialSeeds
     label& tgtSeedI
 ) const
 {
-    const vectorField& srcCcs = src_.cellCentres();
+    const vectorField& srcCcs = srcMesh.cellCentres();
 
     for (label i = startSeedI; i < srcCellIDs.size(); i++)
     {
@@ -60,7 +64,7 @@ bool Foam::mapNearestMethod::findInitialSeeds
         {
             const point& srcCc = srcCcs[srcI];
             pointIndexHit hit =
-                tgt_.cellTree().findNearest(srcCc, great);
+                tgtMesh.cellTree().findNearest(srcCc, great);
 
             if (hit.hit())
             {
@@ -91,8 +95,10 @@ bool Foam::mapNearestMethod::findInitialSeeds
 }
 
 
-Foam::scalar Foam::mapNearestMethod::calculateAddressing
+Foam::scalar Foam::cellsToCellss::nearest::calculateAddressing
 (
+    const polyMesh& srcMesh,
+    const polyMesh& tgtMesh,
     labelListList& srcToTgtCellAddr,
     scalarListList& srcToTgtCellWght,
     labelListList& tgtToSrcCellAddr,
@@ -106,11 +112,11 @@ Foam::scalar Foam::mapNearestMethod::calculateAddressing
 {
     scalar V = 0;
 
-    List<DynamicList<label>> srcToTgt(src_.nCells());
-    List<DynamicList<label>> tgtToSrc(tgt_.nCells());
+    List<DynamicList<label>> srcToTgt(srcMesh.nCells());
+    List<DynamicList<label>> tgtToSrc(tgtMesh.nCells());
 
-    const scalarField& srcVc = src_.cellVolumes();
-    const scalarField& tgtVc = tgt_.cellVolumes();
+    const scalarField& srcVc = srcMesh.cellVolumes();
+    const scalarField& tgtVc = tgtMesh.cellVolumes();
 
     {
         label srcCelli = srcSeedI;
@@ -119,7 +125,7 @@ Foam::scalar Foam::mapNearestMethod::calculateAddressing
         do
         {
             // find nearest tgt cell
-            findNearestCell(src_, tgt_, srcCelli, tgtCelli);
+            findNearestCell(srcMesh, tgtMesh, srcCelli, tgtCelli);
 
            // store src/tgt cell pair
             srcToTgt[srcCelli].append(tgtCelli);
@@ -134,6 +140,8 @@ Foam::scalar Foam::mapNearestMethod::calculateAddressing
             // find new source cell
             setNextNearestCells
             (
+                srcMesh,
+                tgtMesh,
                 startSeedI,
                 srcCelli,
                 tgtCelli,
@@ -146,8 +154,8 @@ Foam::scalar Foam::mapNearestMethod::calculateAddressing
 
     // for the case of multiple source cells per target cell, select the
     // nearest source cell only and discard the others
-    const vectorField& srcCc = src_.cellCentres();
-    const vectorField& tgtCc = tgt_.cellCentres();
+    const vectorField& srcCc = srcMesh.cellCentres();
+    const vectorField& tgtCc = tgtMesh.cellCentres();
 
     forAll(tgtToSrc, targetCelli)
     {
@@ -182,9 +190,10 @@ Foam::scalar Foam::mapNearestMethod::calculateAddressing
     {
         if (tgtToSrc[tgtCelli].empty())
         {
-            label srcCelli = findMappedSrcCell(tgtCelli, tgtToSrc);
+            label srcCelli =
+                findMappedSrcCell(srcMesh, tgtMesh, tgtCelli, tgtToSrc);
 
-            findNearestCell(tgt_, src_, tgtCelli, srcCelli);
+            findNearestCell(tgtMesh, srcMesh, tgtCelli, srcCelli);
 
             tgtToSrc[tgtCelli].append(srcCelli);
         }
@@ -207,7 +216,7 @@ Foam::scalar Foam::mapNearestMethod::calculateAddressing
 }
 
 
-void Foam::mapNearestMethod::findNearestCell
+void Foam::cellsToCellss::nearest::findNearestCell
 (
     const polyMesh& mesh1,
     const polyMesh& mesh2,
@@ -244,8 +253,10 @@ void Foam::mapNearestMethod::findNearestCell
 }
 
 
-void Foam::mapNearestMethod::setNextNearestCells
+void Foam::cellsToCellss::nearest::setNextNearestCells
 (
+    const polyMesh& srcMesh,
+    const polyMesh& tgtMesh,
     label& startSeedI,
     label& srcCelli,
     label& tgtCelli,
@@ -253,7 +264,7 @@ void Foam::mapNearestMethod::setNextNearestCells
     const labelList& srcCellIDs
 ) const
 {
-    const labelList& srcNbr = src_.cellCells()[srcCelli];
+    const labelList& srcNbr = srcMesh.cellCells()[srcCelli];
 
     srcCelli = -1;
     forAll(srcNbr, i)
@@ -276,8 +287,10 @@ void Foam::mapNearestMethod::setNextNearestCells
         }
     }
 
-    (void)findInitialSeeds
+    findInitialSeeds
     (
+        srcMesh,
+        tgtMesh,
         srcCellIDs,
         mapFlag,
         startSeedI,
@@ -287,8 +300,10 @@ void Foam::mapNearestMethod::setNextNearestCells
 }
 
 
-Foam::label Foam::mapNearestMethod::findMappedSrcCell
+Foam::label Foam::cellsToCellss::nearest::findMappedSrcCell
 (
+    const polyMesh& srcMesh,
+    const polyMesh& tgtMesh,
     const label tgtCelli,
     const List<DynamicList<label>>& tgtToSrc
 ) const
@@ -313,7 +328,7 @@ Foam::label Foam::mapNearestMethod::findMappedSrcCell
             }
             else
             {
-                const labelList& nbrCells = tgt_.cellCells()[tgtI];
+                const labelList& nbrCells = tgtMesh.cellCells()[tgtI];
 
                 forAll(nbrCells, i)
                 {
@@ -331,68 +346,32 @@ Foam::label Foam::mapNearestMethod::findMappedSrcCell
 }
 
 
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
-Foam::mapNearestMethod::mapNearestMethod
+Foam::scalar Foam::cellsToCellss::nearest::calculate
 (
-    const polyMesh& src,
-    const polyMesh& tgt
-)
-:
-    meshToMeshMethod(src, tgt)
-{}
-
-
-// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
-
-Foam::mapNearestMethod::~mapNearestMethod()
-{}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-const Foam::word& Foam::mapNearestMethod::patchToPatchMethod() const
-{
-    return patchToPatches::nearest::typeName;
-}
-
-
-Foam::scalar Foam::mapNearestMethod::calculate
-(
-    labelListList& srcToTgtAddr,
-    scalarListList& srcToTgtWght,
-    labelListList& tgtToSrcAddr,
-    scalarListList& tgtToSrcWght
+    const polyMesh& srcMesh,
+    const polyMesh& tgtMesh
 )
 {
-    bool ok = initialise
-    (
-        srcToTgtAddr,
-        srcToTgtWght,
-        tgtToSrcAddr,
-        tgtToSrcWght
-    );
+    initialise(srcMesh, tgtMesh);
 
-    if (!ok)
-    {
-        return 0;
-    }
+    // Determine (potentially) participating source mesh cells
+    const labelList srcCellIDs(maskCells(srcMesh, tgtMesh));
 
-    // (potentially) participating source mesh cells
-    const labelList srcCellIDs(maskCells());
-
-    // list to keep track of whether src cell can be mapped
-    boolList mapFlag(src_.nCells(), false);
+    // Initialise list to keep track of whether src cell can be mapped
+    boolList mapFlag(srcMesh.nCells(), false);
     UIndirectList<bool>(mapFlag, srcCellIDs) = true;
 
-    // find initial point in tgt mesh
+    // Find initial point in tgt mesh
     label srcSeedI = -1;
     label tgtSeedI = -1;
     label startSeedI = 0;
-
     bool startWalk =
         findInitialSeeds
         (
+            srcMesh,
+            tgtMesh,
             srcCellIDs,
             mapFlag,
             startSeedI,
@@ -402,26 +381,21 @@ Foam::scalar Foam::mapNearestMethod::calculate
 
     if (startWalk)
     {
-        const scalar V =
+        return
             calculateAddressing
             (
-                srcToTgtAddr,
-                srcToTgtWght,
-                tgtToSrcAddr,
-                tgtToSrcWght,
+                srcMesh,
+                tgtMesh,
+                srcLocalTgtCells_,
+                srcWeights_,
+                tgtLocalSrcCells_,
+                tgtWeights_,
                 srcSeedI,
                 tgtSeedI,
                 srcCellIDs,
                 mapFlag,
                 startSeedI
             );
-
-        if (debug > 1)
-        {
-            writeConnectivity(src_, tgt_, srcToTgtAddr);
-        }
-
-        return V;
     }
     else
     {
@@ -430,7 +404,7 @@ Foam::scalar Foam::mapNearestMethod::calculate
 }
 
 
-void Foam::mapNearestMethod::normalise
+void Foam::cellsToCellss::nearest::normalise
 (
     const polyMesh& srcMesh,
     labelListList& srcToTgtAddr,
@@ -449,4 +423,18 @@ void Foam::mapNearestMethod::normalise
 }
 
 
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::cellsToCellss::nearest::nearest()
+:
+    cellsToCells()
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
+
+Foam::cellsToCellss::nearest::~nearest()
+{}
+
+
 // ************************************************************************* //
diff --git a/src/meshTools/meshToMesh/calcMethod/mapNearest/mapNearestMethod.H b/src/meshTools/cellsToCells/nearest/nearestCellsToCells.H
similarity index 71%
rename from src/meshTools/meshToMesh/calcMethod/mapNearest/mapNearestMethod.H
rename to src/meshTools/cellsToCells/nearest/nearestCellsToCells.H
index 64e1e834ba..a52bc7873a 100644
--- a/src/meshTools/meshToMesh/calcMethod/mapNearest/mapNearestMethod.H
+++ b/src/meshTools/cellsToCells/nearest/nearestCellsToCells.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2013-2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2013-2023 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -22,39 +22,35 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::mapNearestMethod
+    Foam::cellsToCellss::nearest
 
 Description
-    Map nearest mesh-to-mesh interpolation class
-
-    Not volume conservative.
-    - cells outside other meshes bounding box do not get mapped
-      (initial filtering)
-    - all remaining cells will be mapped (with weight 1!)
-    - so take care when mapping meshes with different bounding boxes!
+    Nearest cells-to-cells interpolation class.
 
 SourceFiles
-    mapNearestMethod.C
+    nearestCellsToCells.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef mapNearestMethod_H
-#define mapNearestMethod_H
+#ifndef nearestCellsToCells_H
+#define nearestCellsToCells_H
 
-#include "meshToMeshMethod.H"
+#include "cellsToCells.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
+namespace cellsToCellss
+{
 
 /*---------------------------------------------------------------------------*\
-                      Class mapNearestMethod Declaration
+                           Class nearest Declaration
 \*---------------------------------------------------------------------------*/
 
-class mapNearestMethod
+class nearest
 :
-    public meshToMeshMethod
+    public cellsToCells
 {
 private:
 
@@ -64,6 +60,8 @@ private:
         //  true if found a matching pair
         bool findInitialSeeds
         (
+            const polyMesh& srcMesh,
+            const polyMesh& tgtMesh,
             const labelList& srcCellIDs,
             const boolList& mapFlag,
             const label startSeedI,
@@ -74,6 +72,8 @@ private:
         //- Calculate the mesh-to-mesh addressing and weights
         scalar calculateAddressing
         (
+            const polyMesh& srcMesh,
+            const polyMesh& tgtMesh,
             labelListList& srcToTgtCellAddr,
             scalarListList& srcToTgtCellWght,
             labelListList& tgtToSrcCellAddr,
@@ -97,6 +97,8 @@ private:
         //- Set the next cells for the marching front algorithm
         void setNextNearestCells
         (
+            const polyMesh& srcMesh,
+            const polyMesh& tgtMesh,
             label& startSeedI,
             label& srcCelli,
             label& tgtCelli,
@@ -107,53 +109,55 @@ private:
         //- Find a source cell mapped to target cell tgtCelli
         label findMappedSrcCell
         (
+            const polyMesh& srcMesh,
+            const polyMesh& tgtMesh,
             const label tgtCelli,
             const List<DynamicList<label>>& tgtToSrc
         ) const;
 
 
+protected:
+
+    // Protected Member Functions
+
+        // Intersection
+
+            //- Calculate the addressing and weights
+            virtual scalar calculate
+            (
+                const polyMesh& srcMesh,
+                const polyMesh& tgtMesh
+            );
+
+            //- Normalise the weights for a given mesh
+            virtual void normalise
+            (
+                const polyMesh& mesh,
+                labelListList& localOtherCells,
+                scalarListList& weights
+            ) const;
+
+
 public:
 
     //- Run-time type information
-    TypeName("mapNearest");
+    TypeName("nearest");
 
 
     // Constructors
 
-        //- Construct from source and target meshes
-        mapNearestMethod(const polyMesh& src, const polyMesh& tgt);
+        //- Construct null
+        nearest();
 
 
     //- Destructor
-    virtual ~mapNearestMethod();
-
-
-    // Member Functions
-
-        //- Get the corresponding patchToPatch method
-        virtual const word& patchToPatchMethod() const;
-
-        //- Calculate addressing and weights
-        virtual scalar calculate
-        (
-            labelListList& srcToTgtAddr,
-            scalarListList& srcToTgtWght,
-            labelListList& tgtToTgtAddr,
-            scalarListList& tgtToTgtWght
-        );
-
-        //- Normalise the weights for a given mesh
-        virtual void normalise
-        (
-            const polyMesh& srcMesh,
-            labelListList& srcToTgtAddr,
-            scalarListList& srcToTgtWght
-        ) const;
+    virtual ~nearest();
 };
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+} // End namespace cellsToCellss
 } // End namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/meshTools/meshToMesh/calcMethod/meshToMeshMethod/meshToMeshMethod.C b/src/meshTools/meshToMesh/calcMethod/meshToMeshMethod/meshToMeshMethod.C
deleted file mode 100644
index d357d3d0f0..0000000000
--- a/src/meshTools/meshToMesh/calcMethod/meshToMeshMethod/meshToMeshMethod.C
+++ /dev/null
@@ -1,184 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2013-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 "HashTable.H"
-#include "meshToMeshMethod.H"
-#include "OFstream.H"
-#include "Time.H"
-#include "treeBoundBox.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-namespace Foam
-{
-    defineTypeNameAndDebug(meshToMeshMethod, 0);
-    defineRunTimeSelectionTable(meshToMeshMethod, components);
-}
-
-
-// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
-
-Foam::labelList Foam::meshToMeshMethod::maskCells() const
-{
-    boundBox intersectBb
-    (
-        max(src_.bounds().min(), tgt_.bounds().min()),
-        min(src_.bounds().max(), tgt_.bounds().max())
-    );
-
-    intersectBb.inflate(0.01);
-
-    const cellList& srcCells = src_.cells();
-    const faceList& srcFaces = src_.faces();
-    const pointField& srcPts = src_.points();
-
-    DynamicList<label> cells(src_.nCells());
-    forAll(srcCells, srcI)
-    {
-        boundBox cellBb(srcCells[srcI].points(srcFaces, srcPts), false);
-        if (intersectBb.overlaps(cellBb))
-        {
-            cells.append(srcI);
-        }
-    }
-
-    if (debug)
-    {
-        Pout<< "participating source mesh cells: " << cells.size() << endl;
-    }
-
-    return move(cells);
-}
-
-
-void Foam::meshToMeshMethod::appendNbrCells
-(
-    const label celli,
-    const polyMesh& mesh,
-    const DynamicList<label>& visitedCells,
-    DynamicList<label>& nbrCellIDs
-) const
-{
-    const labelList& nbrCells = mesh.cellCells()[celli];
-
-    // filter out cells already visited from cell neighbours
-    forAll(nbrCells, i)
-    {
-        label nbrCelli = nbrCells[i];
-
-        if
-        (
-            (findIndex(visitedCells, nbrCelli) == -1)
-         && (findIndex(nbrCellIDs, nbrCelli) == -1)
-        )
-        {
-            nbrCellIDs.append(nbrCelli);
-        }
-    }
-}
-
-
-bool Foam::meshToMeshMethod::initialise
-(
-    labelListList& srcToTgtAddr,
-    scalarListList& srcToTgtWght,
-    labelListList& tgtToSrcAddr,
-    scalarListList& tgtToSrcWght
-) const
-{
-    srcToTgtAddr.setSize(src_.nCells());
-    srcToTgtWght.setSize(src_.nCells());
-    tgtToSrcAddr.setSize(tgt_.nCells());
-    tgtToSrcWght.setSize(tgt_.nCells());
-
-    return src_.nCells() && tgt_.nCells();
-}
-
-
-void Foam::meshToMeshMethod::writeConnectivity
-(
-    const polyMesh& mesh1,
-    const polyMesh& mesh2,
-    const labelListList& mesh1ToMesh2Addr
-) const
-{
-    Pout<< "Source size = " << mesh1.nCells() << endl;
-    Pout<< "Target size = " << mesh2.nCells() << endl;
-
-    word fName("addressing_" + mesh1.name() + "_to_" + mesh2.name());
-
-    if (Pstream::parRun())
-    {
-        fName = fName +  "_proc" + Foam::name(Pstream::myProcNo());
-    }
-
-    OFstream os(src_.time().path()/fName + ".obj");
-
-    label vertI = 0;
-    forAll(mesh1ToMesh2Addr, i)
-    {
-        const labelList& addr = mesh1ToMesh2Addr[i];
-        forAll(addr, j)
-        {
-            label celli = addr[j];
-            const vector& c0 = mesh1.cellCentres()[i];
-
-            const cell& c = mesh2.cells()[celli];
-            const pointField pts(c.points(mesh2.faces(), mesh2.points()));
-            forAll(pts, j)
-            {
-                const point& p = pts[j];
-                os  << "v " << p.x() << ' ' << p.y() << ' ' << p.z() << nl;
-                vertI++;
-                os  << "v " << c0.x() << ' ' << c0.y() << ' ' << c0.z()
-                    << nl;
-                vertI++;
-                os  << "l " << vertI - 1 << ' ' << vertI << nl;
-            }
-        }
-    }
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::meshToMeshMethod::meshToMeshMethod
-(
-    const polyMesh& src,
-    const polyMesh& tgt
-)
-:
-    src_(src),
-    tgt_(tgt)
-{}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-Foam::meshToMeshMethod::~meshToMeshMethod()
-{}
-
-
-// ************************************************************************* //
diff --git a/src/meshTools/meshToMesh/calcMethod/meshToMeshMethod/meshToMeshMethod.H b/src/meshTools/meshToMesh/calcMethod/meshToMeshMethod/meshToMeshMethod.H
deleted file mode 100644
index 3fd64ca093..0000000000
--- a/src/meshTools/meshToMesh/calcMethod/meshToMeshMethod/meshToMeshMethod.H
+++ /dev/null
@@ -1,199 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2013-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::meshToMeshMethod
-
-Description
-    Base class for mesh-to-mesh calculation methods
-
-SourceFiles
-    meshToMeshMethod.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef meshToMeshMethod_H
-#define meshToMeshMethod_H
-
-#include "polyMesh.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-/*---------------------------------------------------------------------------*\
-                      Class meshToMeshMethod Declaration
-\*---------------------------------------------------------------------------*/
-
-class meshToMeshMethod
-{
-    // Private static data
-
-        //- Map from mesh-to-mesh method to patch-to-patch method
-        static HashTable<word> meshToMeshToPatchToPatchMethod_;
-
-
-protected:
-
-    // Protected data
-
-        //- Reference to the source mesh
-        const polyMesh& src_;
-
-        //- Reference to the target mesh
-        const polyMesh& tgt_;
-
-
-    // Protected Member Functions
-
-        //- Return src cell IDs for the overlap region
-        labelList maskCells() const;
-
-        //- Append target cell neighbour cells to cellIDs list
-        void appendNbrCells
-        (
-            const label tgtCelli,
-            const polyMesh& mesh,
-            const DynamicList<label>& visitedTgtCells,
-            DynamicList<label>& nbrTgtCellIDs
-        ) const;
-
-        //- Initialise the arrays used to store the intersection result. Return
-        //  whether or not an intersection is possible.
-        bool initialise
-        (
-            labelListList& srcToTgtAddr,
-            scalarListList& srcToTgtWght,
-            labelListList& tgtToTgtAddr,
-            scalarListList& tgtToTgtWght
-        ) const;
-
-        //- Write the connectivity for debugging
-        void writeConnectivity
-        (
-            const polyMesh& mesh1,
-            const polyMesh& mesh2,
-            const labelListList& mesh1ToMesh2Addr
-        ) const;
-
-
-public:
-
-    //- Run-time type information
-    TypeName("meshToMeshMethod");
-
-
-    //- Declare runtime constructor selection table
-    declareRunTimeSelectionTable
-    (
-        autoPtr,
-        meshToMeshMethod,
-        components,
-        (
-            const polyMesh& src,
-            const polyMesh& tgt
-        ),
-        (src, tgt)
-    );
-
-
-    // Constructors
-
-        //- Construct from source and target meshes
-        meshToMeshMethod(const polyMesh& src, const polyMesh& tgt);
-
-        //- Disallow default bitwise copy construction
-        meshToMeshMethod(const meshToMeshMethod&) = delete;
-
-
-    //- Selector
-    static autoPtr<meshToMeshMethod> New
-    (
-        const word& methodName,
-        const polyMesh& src,
-        const polyMesh& tgt
-    );
-
-
-    //- Destructor
-    virtual ~meshToMeshMethod();
-
-
-    // Member Functions
-
-        //- Get the corresponding patch-to-patch method
-        virtual const word& patchToPatchMethod() const = 0;
-
-
-        // Evaluate
-
-            //- Calculate addressing and weights
-            virtual scalar calculate
-            (
-                labelListList& srcToTgtAddr,
-                scalarListList& srcToTgtWght,
-                labelListList& tgtToTgtAddr,
-                scalarListList& tgtToTgtWght
-            ) = 0;
-
-            //- Normalise the weights for a given mesh
-            virtual void normalise
-            (
-                const polyMesh& srcMesh,
-                labelListList& srcToTgtAddr,
-                scalarListList& srcToTgtWght
-            ) const = 0;
-
-
-        // Access
-
-            //- Return const access to the source mesh
-            inline const polyMesh& src() const
-            {
-                return src_;
-            }
-
-            //- Return const access to the target mesh
-            inline const polyMesh& tgt() const
-            {
-                return tgt_;
-            }
-
-
-    // Member Operators
-
-        //- Disallow default bitwise assignment
-        void operator=(const meshToMeshMethod&) = delete;
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/src/meshTools/meshToMesh/meshToMesh.C b/src/meshTools/meshToMesh/meshToMesh.C
index dd2d6b142e..b31bae7761 100644
--- a/src/meshTools/meshToMesh/meshToMesh.C
+++ b/src/meshTools/meshToMesh/meshToMesh.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2012-2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2012-2023 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -24,12 +24,10 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "meshToMesh.H"
-#include "globalIndex.H"
-#include "meshToMeshMethod.H"
 #include "PatchTools.H"
-#include "patchToPatchTools.H"
+#include "emptyPolyPatch.H"
+#include "wedgePolyPatch.H"
 #include "processorPolyPatch.H"
-#include "Time.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -39,200 +37,25 @@ namespace Foam
 }
 
 
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::scalar Foam::meshToMesh::calculateCellToCells(const word& methodName)
-{
-    Info<< "Creating mesh-to-mesh addressing for " << srcMesh_.name()
-        << " and " << tgtMesh_.name() << " regions using "
-        << methodName << endl;
-
-    singleProcess_ =
-        patchToPatchTools::singleProcess
-        (
-            srcMesh_.nCells(),
-            tgtMesh_.nCells()
-        );
-
-    autoPtr<meshToMeshMethod> methodPtr;
-
-    scalar V = 0;
-
-    if (isSingleProcess())
-    {
-        // Do the intersection
-        methodPtr = meshToMeshMethod::New(methodName, srcMesh_, tgtMesh_);
-        V = methodPtr->calculate
-            (
-                srcLocalTgtCells_,
-                srcWeights_,
-                tgtLocalSrcCells_,
-                tgtWeights_
-            );
-
-        // Normalise the weights
-        methodPtr->normalise(srcMesh_, srcLocalTgtCells_, srcWeights_);
-        methodPtr->normalise(tgtMesh_, tgtLocalSrcCells_, tgtWeights_);
-    }
-    else
-    {
-        // Create the target map of overlapping cells. This map gets remote
-        // parts of the target mesh so that everything needed to compute an
-        // intersection is available locally to the source. Use it to create a
-        // source-local target mesh.
-        tgtMapPtr_ =
-            patchToPatchTools::constructDistributionMap
-            (
-                tgtMeshSendCells(srcMesh_, tgtMesh_)
-            );
-        localTgtProcCellsPtr_.reset
-        (
-            new List<remote>
-            (
-                distributeMesh
-                (
-                    tgtMapPtr_(),
-                    tgtMesh_,
-                    localTgtMeshPtr_
-                )
-            )
-        );
-        const polyMesh& localTgtMesh = localTgtMeshPtr_();
-
-        if (debug > 1)
-        {
-            Pout<< "Writing local target mesh: "
-                << localTgtMesh.name() << endl;
-            localTgtMesh.write();
-        }
-
-        // Do the intersection
-        methodPtr = meshToMeshMethod::New(methodName, srcMesh_, localTgtMesh);
-        V = methodPtr->calculate
-            (
-                srcLocalTgtCells_,
-                srcWeights_,
-                tgtLocalSrcCells_,
-                tgtWeights_
-            );
-
-        // Trim the local target mesh
-        trimLocalTgt();
-
-        if (debug > 1)
-        {
-            Pout<< "Writing trimmed local target mesh: "
-                << localTgtMesh.name() << endl;
-            localTgtMesh.write();
-        }
-
-        // Construct the source map
-        srcMapPtr_ =
-            patchToPatchTools::constructDistributionMap
-            (
-                patchToPatchTools::procSendIndices
-                (
-                    tgtLocalSrcCells_,
-                    localTgtProcCellsPtr_()
-                )
-            );
-        localSrcProcCellsPtr_.reset
-        (
-            new List<remote>
-            (
-                patchToPatchTools::distributeAddressing(srcMapPtr_())
-            )
-        );
-
-        // Collect the addressing on the target
-        patchToPatchTools::rDistributeTgtAddressing
-        (
-            tgtMesh_.nCells(),
-            tgtMapPtr_(),
-            localSrcProcCellsPtr_(),
-            tgtLocalSrcCells_
-        );
-
-        // Collect the weights on the target
-        patchToPatchTools::rDistributeListList
-        (
-            tgtMesh_.nCells(),
-            tgtMapPtr_(),
-            tgtWeights_
-        );
-
-        // Normalise the weights
-        methodPtr->normalise(srcMesh_, srcLocalTgtCells_, srcWeights_);
-        methodPtr->normalise(tgtMesh_, tgtLocalSrcCells_, tgtWeights_);
-
-        // collect volume intersection contributions
-        reduce(V, sumOp<scalar>());
-    }
-
-    Info<< "    Overlap volume: " << V << endl;
-
-    return V;
-}
-
-
-void Foam::meshToMesh::calculatePatchToPatches(const word& methodName)
-{
-    if (!srcToTgtPatchToPatches_.empty())
-    {
-        FatalErrorInFunction
-            << "srcToTgtPatchToPatches already calculated"
-            << exit(FatalError);
-    }
-
-    const word& patchToPatchType =
-        meshToMeshMethod::New
-        (
-            methodName,
-            NullObjectRef<polyMesh>(),
-            NullObjectRef<polyMesh>()
-        )->patchToPatchMethod();
-
-    srcToTgtPatchToPatches_.setSize(srcToTgtPatchIDs_.size());
-
-    forAll(srcToTgtPatchIDs_, i)
-    {
-        const label srcPatchi = srcToTgtPatchIDs_[i].first();
-        const label tgtPatchi = srcToTgtPatchIDs_[i].second();
-
-        const polyPatch& srcPP = srcMesh_.boundaryMesh()[srcPatchi];
-        const polyPatch& tgtPP = tgtMesh_.boundaryMesh()[tgtPatchi];
-
-        Info<< "Creating patchToPatch between source patch "
-            << srcPP.name() << " and target patch " << tgtPP.name()
-            << " using " << patchToPatchType << endl;
-
-        Info<< incrIndent;
-
-        srcToTgtPatchToPatches_.set
-        (
-            i,
-            patchToPatch::New(patchToPatchType, true)
-        );
-
-        srcToTgtPatchToPatches_[i].update
-        (
-            srcPP,
-            PatchTools::pointNormals(srcMesh_, srcPP),
-            tgtPP
-        );
-
-        Info<< decrIndent;
-    }
-}
-
-
-void Foam::meshToMesh::constructNoCuttingPatches
+Foam::meshToMesh::meshToMesh
 (
-    const word& methodName,
-    const bool interpAllPatches
+    const polyMesh& srcMesh,
+    const polyMesh& tgtMesh,
+    const word& engineType,
+    const HashTable<word>& patchMap
 )
+:
+    srcMesh_(srcMesh),
+    tgtMesh_(tgtMesh),
+    srcToTgtCellsToCells_(),
+    srcToTgtPatchIDs_(),
+    srcToTgtPatchToPatches_()
 {
-    if (interpAllPatches)
+    // If no patch map was supplied, then assume a consistent pair of meshes in
+    // which corresponding patches have the same name
+    if (isNull(patchMap))
     {
         DynamicList<labelPair> srcToTgtPatchIDs;
 
@@ -240,10 +63,18 @@ void Foam::meshToMesh::constructNoCuttingPatches
         {
             const polyPatch& srcPp = srcMesh_.boundaryMesh()[srcPatchi];
 
-            // We want to map all the global patches, including constraint
-            // patches (since they might have mappable properties, e.g.
-            // jumpCyclic). We'll fix the value afterwards.
-            if (!isA<processorPolyPatch>(srcPp))
+            // We don't want to map empty or wedge patches, as by definition
+            // these do not hold relevant values. We also don't want to map
+            // processor patches as these are likely to differ between cases.
+            // In general, though, we do want to map constraint patches as they
+            // might have additional mappable properties; e.g., the jump field
+            // of a jump cyclic.
+            if
+            (
+                !isA<emptyPolyPatch>(srcPp)
+             && !isA<wedgePolyPatch>(srcPp)
+             && !isA<processorPolyPatch>(srcPp)
+            )
             {
                 const label tgtPatchi =
                     tgtMesh_.boundaryMesh().findPatchID(srcPp.name());
@@ -265,118 +96,86 @@ void Foam::meshToMesh::constructNoCuttingPatches
         srcToTgtPatchIDs_.transfer(srcToTgtPatchIDs);
     }
 
-    // calculate patch addressing and weights
-    calculatePatchToPatches(methodName);
-
-    // calculate cell addressing and weights
-    calculateCellToCells(methodName);
-}
-
-
-void Foam::meshToMesh::constructFromCuttingPatches
-(
-    const word& methodName,
-    const HashTable<word>& patchMap,
-    const wordList& tgtCuttingPatches
-)
-{
-    srcToTgtPatchIDs_.setSize(patchMap.size());
-    label i = 0;
-    forAllConstIter(HashTable<word>, patchMap, iter)
+    // If a patch mas was supplied then convert it to pairs of patch indices
+    else
     {
-        const word& tgtPatchName = iter.key();
-        const word& srcPatchName = iter();
+        srcToTgtPatchIDs_.setSize(patchMap.size());
+        label i = 0;
+        forAllConstIter(HashTable<word>, patchMap, iter)
+        {
+            const word& tgtPatchName = iter.key();
+            const word& srcPatchName = iter();
 
-        srcToTgtPatchIDs_[i++] =
-            labelPair
-            (
-                srcMesh_.boundaryMesh().findPatchID(srcPatchName),
-                tgtMesh_.boundaryMesh().findPatchID(tgtPatchName)
-            );
+            const label srcPatchi =
+                srcMesh_.boundaryMesh().findPatchID(srcPatchName);
+            const label tgtPatchi =
+                tgtMesh_.boundaryMesh().findPatchID(tgtPatchName);
+
+            if (srcPatchi == -1)
+            {
+                FatalErrorInFunction
+                    << "Patch " << srcPatchName
+                    << " not found in source mesh. "
+                    << "Available source patches are "
+                    << srcMesh_.boundaryMesh().names()
+                    << exit(FatalError);
+            }
+            if (tgtPatchi == -1)
+            {
+                FatalErrorInFunction
+                    << "Patch " << tgtPatchName
+                    << " not found in target mesh. "
+                    << "Available target patches are "
+                    << tgtMesh_.boundaryMesh().names()
+                    << exit(FatalError);
+            }
+
+            srcToTgtPatchIDs_[i ++] = labelPair(srcPatchi, tgtPatchi);
+        }
     }
 
-    // calculate patch addressing and weights
-    calculatePatchToPatches(methodName);
+    // Calculate cell addressing and weights
+    Info<< "Creating cellsToCells between source mesh "
+        << srcMesh_.name() << " and target mesh " << tgtMesh_.name()
+        << " using " << engineType << endl << incrIndent;
 
-    // calculate cell addressing and weights
-    calculateCellToCells(methodName);
+    srcToTgtCellsToCells_ = cellsToCells::New(engineType);
+    srcToTgtCellsToCells_->update(srcMesh_, tgtMesh_);
 
-    // set IDs of cutting patches on target mesh
-    tgtCuttingPatchIDs_.setSize(tgtCuttingPatches.size());
-    forAll(tgtCuttingPatchIDs_, i)
+    Info<< decrIndent;
+
+    // Calculate patch addressing and weights
+    srcToTgtPatchToPatches_.setSize(srcToTgtPatchIDs_.size());
+    forAll(srcToTgtPatchIDs_, i)
     {
-        const word& patchName = tgtCuttingPatches[i];
-        tgtCuttingPatchIDs_[i] = tgtMesh_.boundaryMesh().findPatchID(patchName);
+        const label srcPatchi = srcToTgtPatchIDs_[i].first();
+        const label tgtPatchi = srcToTgtPatchIDs_[i].second();
+
+        const polyPatch& srcPP = srcMesh_.boundaryMesh()[srcPatchi];
+        const polyPatch& tgtPP = tgtMesh_.boundaryMesh()[tgtPatchi];
+
+        Info<< "Creating patchToPatch between source patch "
+            << srcPP.name() << " and target patch " << tgtPP.name()
+            << " using " << engineType << endl << incrIndent;
+
+        srcToTgtPatchToPatches_.set
+        (
+            i,
+            patchToPatch::New(engineType, true)
+        );
+
+        srcToTgtPatchToPatches_[i].update
+        (
+            srcPP,
+            PatchTools::pointNormals(srcMesh_, srcPP),
+            tgtPP
+        );
+
+        Info<< decrIndent;
     }
 }
 
 
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::meshToMesh::meshToMesh
-(
-    const polyMesh& src,
-    const polyMesh& tgt,
-    const word& methodName,
-    bool interpAllPatches
-)
-:
-    srcMesh_(src),
-    tgtMesh_(tgt),
-    srcToTgtPatchIDs_(),
-    srcToTgtPatchToPatches_(),
-    tgtCuttingPatchIDs_(),
-    srcLocalTgtCells_(),
-    tgtLocalSrcCells_(),
-    srcWeights_(),
-    tgtWeights_(),
-    singleProcess_(-1),
-    srcMapPtr_(nullptr),
-    tgtMapPtr_(nullptr),
-    localSrcProcCellsPtr_(nullptr),
-    localTgtProcCellsPtr_(nullptr),
-    localTgtMeshPtr_(nullptr)
-{
-    constructNoCuttingPatches
-    (
-        methodName,
-        interpAllPatches
-    );
-}
-
-
-Foam::meshToMesh::meshToMesh
-(
-    const polyMesh& src,
-    const polyMesh& tgt,
-    const word& methodName,
-    const HashTable<word>& patchMap,
-    const wordList& tgtCuttingPatches
-)
-:
-    srcMesh_(src),
-    tgtMesh_(tgt),
-    srcToTgtPatchIDs_(),
-    srcToTgtPatchToPatches_(),
-    tgtCuttingPatchIDs_(),
-    srcLocalTgtCells_(),
-    tgtLocalSrcCells_(),
-    srcWeights_(),
-    tgtWeights_(),
-    singleProcess_(-1),
-    srcMapPtr_(nullptr),
-    tgtMapPtr_(nullptr),
-    localTgtMeshPtr_(nullptr)
-{
-    constructFromCuttingPatches
-    (
-        methodName,
-        patchMap,
-        tgtCuttingPatches
-    );
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::meshToMesh::~meshToMesh()
@@ -385,29 +184,65 @@ Foam::meshToMesh::~meshToMesh()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+bool Foam::meshToMesh::consistent() const
+{
+    boolList srcPatchIsMapped(srcMesh_.boundaryMesh().size(), false);
+    boolList tgtPatchIsMapped(tgtMesh_.boundaryMesh().size(), false);
+
+    // Mark anything paired as mapped
+    forAll(srcToTgtPatchIDs_, i)
+    {
+        const label srcPatchi = srcToTgtPatchIDs_[i].first();
+        const label tgtPatchi = srcToTgtPatchIDs_[i].second();
+
+        srcPatchIsMapped[srcPatchi] = true;
+        tgtPatchIsMapped[tgtPatchi] = true;
+    }
+
+    // Filter out un-mappable patches
+    forAll(srcMesh_.boundaryMesh(), srcPatchi)
+    {
+        const polyPatch& srcPp = srcMesh_.boundaryMesh()[srcPatchi];
+
+        if
+        (
+            isA<emptyPolyPatch>(srcPp)
+         || isA<wedgePolyPatch>(srcPp)
+         || isA<processorPolyPatch>(srcPp)
+        )
+        {
+            srcPatchIsMapped[srcPp.index()] = true;
+        }
+    }
+    forAll(tgtMesh_.boundaryMesh(), tgtPatchi)
+    {
+        const polyPatch& tgtPp = tgtMesh_.boundaryMesh()[tgtPatchi];
+
+        if
+        (
+            isA<emptyPolyPatch>(tgtPp)
+         || isA<wedgePolyPatch>(tgtPp)
+         || isA<processorPolyPatch>(tgtPp)
+        )
+        {
+            tgtPatchIsMapped[tgtPp.index()] = true;
+        }
+    }
+
+    // Return whether or not everything is mapped
+    return
+        findIndex(srcPatchIsMapped, false) == -1
+     && findIndex(tgtPatchIsMapped, false) == -1;
+}
+
+
 Foam::remote Foam::meshToMesh::srcToTgtPoint
 (
     const label srcCelli,
     const point& p
 ) const
 {
-    forAll(srcLocalTgtCells_[srcCelli], i)
-    {
-        const label tgtCelli = srcLocalTgtCells_[srcCelli][i];
-
-        const polyMesh& tgtMesh =
-            singleProcess_ == -1 ? localTgtMeshPtr_() : tgtMesh_;
-
-        if (tgtMesh.pointInCell(p, tgtCelli))
-        {
-            return
-                singleProcess_ == -1
-              ? localTgtProcCellsPtr_()[tgtCelli]
-              : remote(Pstream::myProcNo(), tgtCelli);
-        }
-    }
-
-    return remote();
+    return srcToTgtCellsToCells_().srcToTgtPoint(tgtMesh_, srcCelli, p);
 }
 
 
diff --git a/src/meshTools/meshToMesh/meshToMesh.H b/src/meshTools/meshToMesh/meshToMesh.H
index ac548e5614..b9848e88a9 100644
--- a/src/meshTools/meshToMesh/meshToMesh.H
+++ b/src/meshTools/meshToMesh/meshToMesh.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2012-2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2012-2023 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -25,17 +25,11 @@ Class
     Foam::meshToMesh
 
 Description
-    Class to calculate the cell-addressing between two overlapping meshes
-
-    Mapping is performed using a run-time selectable interpolation mothod
-
-See also
-    meshToMeshMethod
+    Class to calculate interpolative addressing and weights between the cells
+    and patches of two overlapping meshes
 
 SourceFiles
     meshToMesh.C
-    meshToMeshParallelOps.C
-    meshToMeshTemplates.C
 
 \*---------------------------------------------------------------------------*/
 
@@ -43,10 +37,8 @@ SourceFiles
 #define meshToMesh_H
 
 #include "polyMesh.H"
-#include "boundBox.H"
-#include "distributionMap.H"
-#include "NamedEnum.H"
 #include "patchToPatch.H"
+#include "cellsToCells.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -67,6 +59,9 @@ class meshToMesh
         //- Reference to the target mesh
         const polyMesh& tgtMesh_;
 
+        //- Interpolation engine between source and target cells
+        autoPtr<cellsToCells> srcToTgtCellsToCells_;
+
         //- List of corresponding source and target patches that are to be
         //  mapped to each other
         List<labelPair> srcToTgtPatchIDs_;
@@ -75,93 +70,6 @@ class meshToMesh
         //  target patches
         PtrList<patchToPatch> srcToTgtPatchToPatches_;
 
-        //- Cutting patches whose values are set using a zero-gradient condition
-        labelList tgtCuttingPatchIDs_;
-
-        //- For each source cell, the coupled local target cells
-        labelListList srcLocalTgtCells_;
-
-        //- For each target cell, the coupled local source cells
-        labelListList tgtLocalSrcCells_;
-
-        //- For each source cell, the coupled target weights
-        scalarListList srcWeights_;
-
-        //- For each target cell, the coupled source weights
-        scalarListList tgtWeights_;
-
-        //- Index of processor that holds all of both sides, or -1
-        label singleProcess_;
-
-        //- Map from source patch cells to target-local source patch cells
-        autoPtr<distributionMap> srcMapPtr_;
-
-        //- Map from target patch cells to source-local target patch cells
-        autoPtr<distributionMap> tgtMapPtr_;
-
-        //- When running in parallel, a map from local source cell index to
-        //  source processor and cell index
-        autoPtr<List<remote>> localSrcProcCellsPtr_;
-
-        //- When running in parallel, a map from local target cell index to
-        //  target processor and cell index
-        autoPtr<List<remote>> localTgtProcCellsPtr_;
-
-        //- The target mesh, distributed locally to the source
-        autoPtr<polyMesh> localTgtMeshPtr_;
-
-
-    // Private Member Functions
-
-        //- Helper function to add a constant offset to a list
-        template<class Type>
-        static void add(UList<Type>& fld, const label offset);
-
-        //- Calculate the cell intersections. Returns the overlap volume.
-        scalar calculateCellToCells(const word& methodName);
-
-        //- Calculate patch intersections
-        void calculatePatchToPatches(const word& patchToPatchType);
-
-        //- Constructor helper
-        void constructNoCuttingPatches
-        (
-            const word& methodName,
-            const bool interpAllPatches
-        );
-
-        //- Constructor helper
-        void constructFromCuttingPatches
-        (
-            const word& methodName,
-            const HashTable<word>& patchMap,
-            const wordList& tgtCuttingPatches
-        );
-
-
-        // Parallel operations
-
-            //- Determine which target cells need to be sent to the source.
-            //  This is done before intersection. Bound boxes are used to
-            //  estimate what cells will intersect.
-            labelListList tgtMeshSendCells
-            (
-                const polyMesh& srcMesh,
-                const polyMesh& tgtMesh
-            ) const;
-
-            //- Distribute a mesh given its distribution map
-            static List<remote> distributeMesh
-            (
-                const distributionMap& map,
-                const polyMesh& mesh,
-                autoPtr<polyMesh>& localMeshPtr
-            );
-
-            //- Trim the local target addressing and mesh so that communication
-            //  from the target to the source is optimised
-            void trimLocalTgt();
-
 
 protected:
 
@@ -169,6 +77,9 @@ protected:
 
         // Access
 
+            //- Return the interpolation engine between source and target cells
+            inline const cellsToCells& srcToTgtCellsToCells() const;
+
             //- Return the source patch indices
             inline const List<labelPair>& srcToTgtPatchIDs() const;
 
@@ -176,9 +87,6 @@ protected:
             //  source and target patches
             inline const PtrList<patchToPatch>& srcToTgtPatchToPatches() const;
 
-            //- Return the cutting patch indices
-            inline const labelList& tgtCuttingPatchIDs() const;
-
 
 public:
 
@@ -188,23 +96,15 @@ public:
 
     // Constructors
 
-        //- Construct from source and target meshes, generic mapping methods
+        //- Construct from source and target meshes. If a patchMap is supplied,
+        //  then map between the specified patches. If not, then assume a
+        //  consistent mesh and map all patches 1-to-1.
         meshToMesh
         (
-            const polyMesh& src,
-            const polyMesh& tgt,
-            const word& methodName,
-            const bool interpAllPatches = true
-        );
-
-        //- Construct from source and target meshes, generic mapping methods
-        meshToMesh
-        (
-            const polyMesh& src,
-            const polyMesh& tgt,
-            const word& methodName,
-            const HashTable<word>& patchMap,
-            const wordList& cuttingPatches
+            const polyMesh& srcMesh,
+            const polyMesh& tgtMesh,
+            const word& engineType,
+            const HashTable<word>& patchMap = NullObjectRef<HashTable<word>>()
         );
 
         //- Disallow default bitwise copy construction
@@ -225,63 +125,16 @@ public:
             //- Return const access to the target mesh
             inline const polyMesh& tgtMesh() const;
 
-            //- Index of the processor holding all cells of the meshToMesh,
-            //  or -1 if spread across multiple processors
-            inline label singleProcess() const;
-
-            //- Is this intersection on a single process?
-            inline bool isSingleProcess() const;
+            //- Is the map between consistent meshes? I.e., are all
+            //  (non-processor) patches mapped one-to-one?
+            bool consistent() const;
 
 
-        // Evaluation
+        // Source-to-target point finding
 
-            // Source-to-target field mapping
-
-                //- Map field from src to tgt mesh. Values passed in via
-                //  'result' are used to initialise the return value.
-                template<class Type>
-                void mapSrcToTgt
-                (
-                    const UList<Type>& srcFld,
-                    List<Type>& result
-                ) const;
-
-                //- Return the src field mapped to the tgt mesh. Initial values
-                //  of the result are set to zero.
-                template<class Type>
-                tmp<Field<Type>> mapSrcToTgt(const Field<Type>& srcFld) const;
-
-
-            // Target-to-source field mapping
-
-                //- Map field from tgt to src mesh. Values passed in via
-                //  'result' are used to initialise the return value.
-                template<class Type>
-                void mapTgtToSrc
-                (
-                    const UList<Type>& tgtFld,
-                    List<Type>& result
-                ) const;
-
-                //- Return the tgt field mapped to the src mesh. Initial values
-                //  of the result are set to zero.
-                template<class Type>
-                tmp<Field<Type>> mapTgtToSrc(const Field<Type>& tgtFld) const;
-
-
-            // Source-to-target point finding
-
-                //- Find the target processor and cell associated with a point
-                //  in a source cell. Note that this will only work with
-                //  methods that fill a cell's stencil with everything that
-                //  overlaps that cell. At present this is just
-                //  cellVolumeWeightMethod, but we might add a cheaper
-                //  bound-box based method like patchToPatches::rays in future.
-                remote srcToTgtPoint
-                (
-                    const label srcCelli,
-                    const point& p
-                ) const;
+            //- Find the target processor and cell associated with a point in a
+            //  source cell. See cellsToCells::srcToTgtPoint.
+            remote srcToTgtPoint(const label srcCelli, const point& p) const;
 
 
     // Member Operators
@@ -301,12 +154,6 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#ifdef NoRepository
-    #include "meshToMeshTemplates.C"
-#endif
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
 #endif
 
 // ************************************************************************* //
diff --git a/src/meshTools/meshToMesh/meshToMeshI.H b/src/meshTools/meshToMesh/meshToMeshI.H
index 553cfe0538..91bb7c273e 100644
--- a/src/meshTools/meshToMesh/meshToMeshI.H
+++ b/src/meshTools/meshToMesh/meshToMeshI.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2012-2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2012-2023 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -27,6 +27,12 @@ License
 
 // * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
+inline const Foam::cellsToCells& Foam::meshToMesh::srcToTgtCellsToCells() const
+{
+    return srcToTgtCellsToCells_();
+}
+
+
 inline const Foam::List<Foam::labelPair>&
 Foam::meshToMesh::srcToTgtPatchIDs() const
 {
@@ -41,12 +47,6 @@ Foam::meshToMesh::srcToTgtPatchToPatches() const
 }
 
 
-inline const Foam::labelList& Foam::meshToMesh::tgtCuttingPatchIDs() const
-{
-    return tgtCuttingPatchIDs_;
-}
-
-
 // * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
 
 inline const Foam::polyMesh& Foam::meshToMesh::srcMesh() const
@@ -61,16 +61,4 @@ inline const Foam::polyMesh& Foam::meshToMesh::tgtMesh() const
 }
 
 
-inline Foam::label Foam::meshToMesh::singleProcess() const
-{
-    return singleProcess_;
-}
-
-
-inline bool Foam::meshToMesh::isSingleProcess() const
-{
-    return singleProcess_ != -1;
-}
-
-
 // ************************************************************************* //
diff --git a/src/meshTools/meshToMesh/meshToMeshTemplates.C b/src/meshTools/meshToMesh/meshToMeshTemplates.C
deleted file mode 100644
index 2a3c70a4cb..0000000000
--- a/src/meshTools/meshToMesh/meshToMeshTemplates.C
+++ /dev/null
@@ -1,200 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2012-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 "meshToMesh.H"
-
-// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
-
-template<class Type>
-void Foam::meshToMesh::add
-(
-    UList<Type>& fld,
-    const label offset
-)
-{
-    forAll(fld, i)
-    {
-        fld[i] += offset;
-    }
-}
-
-
-template<class Type>
-void Foam::meshToMesh::mapSrcToTgt
-(
-    const UList<Type>& srcField,
-    List<Type>& result
-) const
-{
-    if (result.size() != tgtLocalSrcCells_.size())
-    {
-        FatalErrorInFunction
-            << "Supplied field size is not equal to target mesh size" << nl
-            << "    source mesh    = " << srcLocalTgtCells_.size() << nl
-            << "    target mesh    = " << tgtLocalSrcCells_.size() << nl
-            << "    supplied field = " << result.size()
-            << abort(FatalError);
-    }
-
-    if (!isSingleProcess())
-    {
-        const distributionMap& map = srcMapPtr_();
-
-        List<Type> work(srcField);
-        map.distribute(work);
-
-        forAll(result, tgtCelli)
-        {
-            if (tgtLocalSrcCells_[tgtCelli].size())
-            {
-                result[tgtCelli] *= (1.0 - sum(tgtWeights_[tgtCelli]));
-                forAll(tgtLocalSrcCells_[tgtCelli], i)
-                {
-                    result[tgtCelli] +=
-                        tgtWeights_[tgtCelli][i]
-                       *work[tgtLocalSrcCells_[tgtCelli][i]];
-                }
-            }
-        }
-    }
-    else
-    {
-        forAll(result, tgtCelli)
-        {
-            if (tgtLocalSrcCells_[tgtCelli].size())
-            {
-                result[tgtCelli] *= (1.0 - sum(tgtWeights_[tgtCelli]));
-                forAll(tgtLocalSrcCells_[tgtCelli], i)
-                {
-                    result[tgtCelli] +=
-                        tgtWeights_[tgtCelli][i]
-                       *srcField[tgtLocalSrcCells_[tgtCelli][i]];
-                }
-            }
-        }
-    }
-}
-
-
-template<class Type>
-Foam::tmp<Foam::Field<Type>> Foam::meshToMesh::mapSrcToTgt
-(
-    const Field<Type>& srcField
-) const
-{
-    tmp<Field<Type>> tresult
-    (
-        new Field<Type>
-        (
-            tgtLocalSrcCells_.size(),
-            Zero
-        )
-    );
-
-    mapSrcToTgt(srcField, tresult.ref());
-
-    return tresult;
-}
-
-
-template<class Type>
-void Foam::meshToMesh::mapTgtToSrc
-(
-    const UList<Type>& tgtField,
-    List<Type>& result
-) const
-{
-    if (result.size() != srcLocalTgtCells_.size())
-    {
-        FatalErrorInFunction
-            << "Supplied field size is not equal to source mesh size" << nl
-            << "    source mesh    = " << srcLocalTgtCells_.size() << nl
-            << "    target mesh    = " << tgtLocalSrcCells_.size() << nl
-            << "    supplied field = " << result.size()
-            << abort(FatalError);
-    }
-
-    if (!isSingleProcess())
-    {
-        const distributionMap& map = tgtMapPtr_();
-
-        List<Type> work(tgtField);
-        map.distribute(work);
-
-        forAll(result, srcCelli)
-        {
-            if (srcLocalTgtCells_[srcCelli].size())
-            {
-                result[srcCelli] *= (1.0 - sum(srcWeights_[srcCelli]));
-                forAll(srcLocalTgtCells_[srcCelli], i)
-                {
-                    result[srcCelli] +=
-                        srcWeights_[srcCelli][i]
-                       *work[srcLocalTgtCells_[srcCelli][i]];
-                }
-            }
-        }
-    }
-    else
-    {
-        forAll(result, srcCelli)
-        {
-            if (srcLocalTgtCells_[srcCelli].size())
-            {
-                result[srcCelli] *= (1.0 - sum(srcWeights_[srcCelli]));
-                forAll(srcLocalTgtCells_[srcCelli], i)
-                {
-                    result[srcCelli] +=
-                        srcWeights_[srcCelli][i]
-                       *tgtField[srcLocalTgtCells_[srcCelli][i]];
-                }
-            }
-        }
-    }
-}
-
-
-template<class Type>
-Foam::tmp<Foam::Field<Type>> Foam::meshToMesh::mapTgtToSrc
-(
-    const Field<Type>& tgtField
-) const
-{
-    tmp<Field<Type>> tresult
-    (
-        new Field<Type>
-        (
-            srcLocalTgtCells_.size(),
-            Zero
-        )
-    );
-
-    mapTgtToSrc(tgtField, tresult.ref());
-
-    return tresult;
-}
-
-
-// ************************************************************************* //
diff --git a/src/meshTools/patchToPatch/intersection/intersectionPatchToPatch.H b/src/meshTools/patchToPatch/intersection/intersectionPatchToPatch.H
index 5c61eb543f..7a9367927b 100644
--- a/src/meshTools/patchToPatch/intersection/intersectionPatchToPatch.H
+++ b/src/meshTools/patchToPatch/intersection/intersectionPatchToPatch.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2021-2023 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -75,7 +75,7 @@ public:
             part()
             :
                 area(Zero),
-                centre(NaN<point>())
+                centre(patchToPatchTools::NaN<point>())
             {}
 
             //- Default construct
diff --git a/src/meshTools/patchToPatch/patchToPatch/patchToPatch.H b/src/meshTools/patchToPatch/patchToPatch/patchToPatch.H
index 681f761638..9585fe3e55 100644
--- a/src/meshTools/patchToPatch/patchToPatch/patchToPatch.H
+++ b/src/meshTools/patchToPatch/patchToPatch/patchToPatch.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2023 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -30,16 +30,17 @@ Description
 SourceFiles
     patchToPatch.C
     patchToPatchParallelOps.C
+    patchToPatchTemplates.C
 
 \*---------------------------------------------------------------------------*/
 
 #ifndef patchToPatch_H
 #define patchToPatch_H
 
+#include "remote.H"
 #include "distributionMap.H"
 #include "primitivePatch.H"
 #include "primitiveOldTimePatch.H"
-#include "remote.H"
 #include "runTimeSelectionTables.H"
 #include "treeBoundBox.H"
 
@@ -254,31 +255,6 @@ protected:
             //- For each target face, the coupled source weights
             virtual tmpNrc<List<DynamicList<scalar>>> tgtWeights() const = 0;
 
-            //- Return a primitive with all components set to NaN
-            template<class Type>
-            static Type NaN();
-
-            //- Interpolate with normalisation
-            template<class Type>
-            static tmp<Field<Type>> interpolate
-            (
-                const List<DynamicList<label>>& localOtherFaces,
-                const List<DynamicList<scalar>>& weights,
-                const autoPtr<distributionMap>& otherMapPtr,
-                const Field<Type>& otherFld
-            );
-
-            //- Interpolate without normalisation
-            template<class Type>
-            static tmp<Field<Type>> interpolate
-            (
-                const List<DynamicList<label>>& localOtherFaces,
-                const List<DynamicList<scalar>>& weights,
-                const autoPtr<distributionMap>& otherMapPtr,
-                const Field<Type>& otherFld,
-                const Field<Type>& leftOverFld
-            );
-
 
 public:
 
diff --git a/src/meshTools/patchToPatch/patchToPatch/patchToPatchParallelOps.C b/src/meshTools/patchToPatch/patchToPatch/patchToPatchParallelOps.C
index e0f82cae20..9bfa91b20f 100644
--- a/src/meshTools/patchToPatch/patchToPatch/patchToPatchParallelOps.C
+++ b/src/meshTools/patchToPatch/patchToPatch/patchToPatchParallelOps.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2023 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -23,9 +23,7 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "autoPtr.H"
 #include "patchToPatch.H"
-#include "treeBoundBoxList.H"
 #include "uindirectPrimitivePatch.H"
 #include "uindirectPrimitiveOldTimePatch.H"
 
@@ -40,11 +38,11 @@ Foam::labelListList Foam::patchToPatch::tgtPatchSendFaces
 ) const
 {
     // Get the bound boxes for the source patch. Just a single box for now.
-    List<treeBoundBoxList> srcPatchProcBbs(Pstream::nProcs());
+    List<List<treeBoundBox>> srcPatchProcBbs(Pstream::nProcs());
     if (srcPatch.size())
     {
         srcPatchProcBbs[Pstream::myProcNo()] =
-            treeBoundBoxList
+            List<treeBoundBox>
             (
                 1,
                 srcBox(srcPatch, srcPointNormals, srcPointNormals0)
@@ -52,7 +50,7 @@ Foam::labelListList Foam::patchToPatch::tgtPatchSendFaces
     }
     else
     {
-        srcPatchProcBbs[Pstream::myProcNo()] = treeBoundBoxList();
+        srcPatchProcBbs[Pstream::myProcNo()] = List<treeBoundBox>();
     }
 
     // Distribute the boxes
diff --git a/src/meshTools/patchToPatch/patchToPatch/patchToPatchTemplates.C b/src/meshTools/patchToPatch/patchToPatch/patchToPatchTemplates.C
index 9d47e64e69..d3e5442e75 100644
--- a/src/meshTools/patchToPatch/patchToPatch/patchToPatchTemplates.C
+++ b/src/meshTools/patchToPatch/patchToPatch/patchToPatchTemplates.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2023 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -24,111 +24,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "patchToPatch.H"
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-template<class Type>
-Type Foam::patchToPatch::NaN()
-{
-    Type result;
-
-    for (direction cmpt = 0; cmpt < pTraits<Type>::nComponents; cmpt++)
-    {
-        setComponent(result, cmpt) = Foam::NaN;
-    }
-
-    return result;
-}
-
-
-template<class Type>
-Foam::tmp<Foam::Field<Type>> Foam::patchToPatch::interpolate
-(
-    const List<DynamicList<label>>& localOtherFaces,
-    const List<DynamicList<scalar>>& weights,
-    const autoPtr<distributionMap>& otherMapPtr,
-    const Field<Type>& otherFld
-)
-{
-    // Distribute the other field if necessary
-    tmp<Field<Type>> tLocalOtherFld;
-    if (otherMapPtr.valid())
-    {
-        tLocalOtherFld = tmp<Field<Type>>(new Field<Type>(otherFld));
-        otherMapPtr->distribute(tLocalOtherFld.ref());
-    }
-    const Field<Type>& localOtherFld =
-        otherMapPtr.valid() ? tLocalOtherFld() : otherFld;
-
-    // Allocate the result
-    tmp<Field<Type>> tFld(new Field<Type>(localOtherFaces.size(), NaN<Type>()));
-    Field<Type>& fld = tFld.ref();
-
-    // Compute the result as a weighted sum
-    forAll(localOtherFaces, facei)
-    {
-        scalar sumW = 0;
-        Type sumWF = Zero;
-
-        forAll(localOtherFaces[facei], i)
-        {
-            const scalar w = weights[facei][i];
-            sumW += w;
-            sumWF += w*localOtherFld[localOtherFaces[facei][i]];
-        }
-
-        if (localOtherFaces[facei].size())
-        {
-            fld[facei] = sumWF/sumW;
-        }
-    }
-
-    return tFld;
-}
-
-template<class Type>
-Foam::tmp<Foam::Field<Type>> Foam::patchToPatch::interpolate
-(
-    const List<DynamicList<label>>& localOtherFaces,
-    const List<DynamicList<scalar>>& weights,
-    const autoPtr<distributionMap>& otherMapPtr,
-    const Field<Type>& otherFld,
-    const Field<Type>& leftOverFld
-)
-{
-    // Distribute the other field if necessary
-    tmp<Field<Type>> tLocalOtherFld;
-    if (otherMapPtr.valid())
-    {
-        tLocalOtherFld = tmp<Field<Type>>(new Field<Type>(otherFld));
-        otherMapPtr->distribute(tLocalOtherFld.ref());
-    }
-    const Field<Type>& localOtherFld =
-        otherMapPtr.valid() ? tLocalOtherFld() : otherFld;
-
-    // Allocate the result
-    tmp<Field<Type>> tFld(new Field<Type>(localOtherFaces.size(), NaN<Type>()));
-    Field<Type>& fld = tFld.ref();
-
-    // Compute the result as a weighted sum
-    forAll(localOtherFaces, facei)
-    {
-        scalar sumW = 0;
-        Type sumWF = Zero;
-
-        forAll(localOtherFaces[facei], i)
-        {
-            const scalar w = weights[facei][i];
-            sumW += w;
-            sumWF += w*localOtherFld[localOtherFaces[facei][i]];
-        }
-
-        fld[facei] = sumWF + (1 - sumW)*leftOverFld[facei];
-    }
-
-    return tFld;
-}
-
+#include "patchToPatchTools.H"
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
@@ -137,10 +33,10 @@ Foam::tmp<Foam::Field<Type>>
 Foam::patchToPatch::srcToTgt(const Field<Type>& srcFld) const
 {
     return
-        interpolate
+        patchToPatchTools::interpolate
         (
             tgtLocalSrcFaces_,
-            tgtWeights(),
+            tgtWeights()(),
             srcMapPtr_,
             srcFld
         );
@@ -155,10 +51,10 @@ Foam::tmp<Foam::Field<Type>> Foam::patchToPatch::srcToTgt
 ) const
 {
     return
-        interpolate
+        patchToPatchTools::interpolate
         (
             tgtLocalSrcFaces_,
-            tgtWeights(),
+            tgtWeights()(),
             srcMapPtr_,
             srcFld,
             leftOverTgtFld
@@ -171,10 +67,10 @@ Foam::tmp<Foam::Field<Type>>
 Foam::patchToPatch::tgtToSrc(const Field<Type>& tgtFld) const
 {
     return
-        interpolate
+        patchToPatchTools::interpolate
         (
             srcLocalTgtFaces_,
-            srcWeights(),
+            srcWeights()(),
             tgtMapPtr_,
             tgtFld
         );
@@ -189,10 +85,10 @@ Foam::tmp<Foam::Field<Type>> Foam::patchToPatch::tgtToSrc
 ) const
 {
     return
-        interpolate
+        patchToPatchTools::interpolate
         (
             srcLocalTgtFaces_,
-            srcWeights(),
+            srcWeights()(),
             tgtMapPtr_,
             tgtFld,
             leftOverSrcFld
diff --git a/src/meshTools/patchToPatchTools/patchToPatchTools.H b/src/meshTools/patchToPatchTools/patchToPatchTools.H
index 613d2497b6..4478d6e2ac 100644
--- a/src/meshTools/patchToPatchTools/patchToPatchTools.H
+++ b/src/meshTools/patchToPatchTools/patchToPatchTools.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2022-2023 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -137,6 +137,31 @@ void rDistributeTgtAddressing
     List<DynamicList<label>>& tgtLocalSrcFaces
 );
 
+//- Return a primitive with all components set to NaN
+template<class Type>
+static Type NaN();
+
+//- Interpolate with normalisation
+template<class Type, class LabelList, class ScalarList>
+static tmp<Field<Type>> interpolate
+(
+    const List<LabelList>& localOtherFaces,
+    const List<ScalarList>& weights,
+    const autoPtr<distributionMap>& otherMapPtr,
+    const Field<Type>& otherFld
+);
+
+//- Interpolate without normalisation
+template<class Type, class LabelList, class ScalarList>
+static tmp<Field<Type>> interpolate
+(
+    const List<LabelList>& localOtherFaces,
+    const List<ScalarList>& weights,
+    const autoPtr<distributionMap>& otherMapPtr,
+    const Field<Type>& otherFld,
+    const Field<Type>& leftOverFld
+);
+
 } // End namespace patchToPatchTools
 } // End namespace Foam
 
diff --git a/src/meshTools/patchToPatchTools/patchToPatchToolsTemplates.C b/src/meshTools/patchToPatchTools/patchToPatchToolsTemplates.C
index 59bf559d65..37cabb2e2c 100644
--- a/src/meshTools/patchToPatchTools/patchToPatchToolsTemplates.C
+++ b/src/meshTools/patchToPatchTools/patchToPatchToolsTemplates.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2022-2023 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -82,4 +82,108 @@ void Foam::patchToPatchTools::rDistributeListList
 }
 
 
+template<class Type>
+Type Foam::patchToPatchTools::NaN()
+{
+    Type result;
+
+    for (direction cmpt = 0; cmpt < pTraits<Type>::nComponents; cmpt++)
+    {
+        setComponent(result, cmpt) = Foam::NaN;
+    }
+
+    return result;
+}
+
+
+template<class Type, class LabelList, class ScalarList>
+Foam::tmp<Foam::Field<Type>> Foam::patchToPatchTools::interpolate
+(
+    const List<LabelList>& localOtherFaces,
+    const List<ScalarList>& weights,
+    const autoPtr<distributionMap>& otherMapPtr,
+    const Field<Type>& otherFld
+)
+{
+    // Distribute the other field if necessary
+    tmp<Field<Type>> tLocalOtherFld;
+    if (otherMapPtr.valid())
+    {
+        tLocalOtherFld = tmp<Field<Type>>(new Field<Type>(otherFld));
+        otherMapPtr->distribute(tLocalOtherFld.ref());
+    }
+    const Field<Type>& localOtherFld =
+        otherMapPtr.valid() ? tLocalOtherFld() : otherFld;
+
+    // Allocate the result
+    tmp<Field<Type>> tFld(new Field<Type>(localOtherFaces.size(), NaN<Type>()));
+    Field<Type>& fld = tFld.ref();
+
+    // Compute the result as a weighted sum
+    forAll(localOtherFaces, facei)
+    {
+        scalar sumW = 0;
+        Type sumWF = Zero;
+
+        forAll(localOtherFaces[facei], i)
+        {
+            const scalar w = weights[facei][i];
+            sumW += w;
+            sumWF += w*localOtherFld[localOtherFaces[facei][i]];
+        }
+
+        if (localOtherFaces[facei].size())
+        {
+            fld[facei] = sumWF/sumW;
+        }
+    }
+
+    return tFld;
+}
+
+
+template<class Type, class LabelList, class ScalarList>
+Foam::tmp<Foam::Field<Type>> Foam::patchToPatchTools::interpolate
+(
+    const List<LabelList>& localOtherFaces,
+    const List<ScalarList>& weights,
+    const autoPtr<distributionMap>& otherMapPtr,
+    const Field<Type>& otherFld,
+    const Field<Type>& leftOverFld
+)
+{
+    // Distribute the other field if necessary
+    tmp<Field<Type>> tLocalOtherFld;
+    if (otherMapPtr.valid())
+    {
+        tLocalOtherFld = tmp<Field<Type>>(new Field<Type>(otherFld));
+        otherMapPtr->distribute(tLocalOtherFld.ref());
+    }
+    const Field<Type>& localOtherFld =
+        otherMapPtr.valid() ? tLocalOtherFld() : otherFld;
+
+    // Allocate the result
+    tmp<Field<Type>> tFld(new Field<Type>(localOtherFaces.size(), NaN<Type>()));
+    Field<Type>& fld = tFld.ref();
+
+    // Compute the result as a weighted sum
+    forAll(localOtherFaces, facei)
+    {
+        scalar sumW = 0;
+        Type sumWF = Zero;
+
+        forAll(localOtherFaces[facei], i)
+        {
+            const scalar w = weights[facei][i];
+            sumW += w;
+            sumWF += w*localOtherFld[localOtherFaces[facei][i]];
+        }
+
+        fld[facei] = sumWF + (1 - sumW)*leftOverFld[facei];
+    }
+
+    return tFld;
+}
+
+
 // ************************************************************************* //
diff --git a/tutorials/modules/CHT/heatExchanger/constant/air/fvModels b/tutorials/modules/CHT/heatExchanger/constant/air/fvModels
index a05a1b1f24..16e3ee07b1 100644
--- a/tutorials/modules/CHT/heatExchanger/constant/air/fvModels
+++ b/tutorials/modules/CHT/heatExchanger/constant/air/fvModels
@@ -21,7 +21,7 @@ airToporous
     nbrRegion       porous;
     master          false;
 
-    interpolationMethod cellVolumeWeight;
+    interpolationMethod intersection;
 
     semiImplicit    no;
 }
@@ -34,7 +34,7 @@ porosityBlockage
     {
         nbrRegion       porous;
 
-        interpolationMethod cellVolumeWeight;
+        interpolationMethod intersection;
 
         type            DarcyForchheimer;
 
diff --git a/tutorials/modules/CHT/heatExchanger/constant/porous/fvModels b/tutorials/modules/CHT/heatExchanger/constant/porous/fvModels
index 737efba956..4e275aac0b 100644
--- a/tutorials/modules/CHT/heatExchanger/constant/porous/fvModels
+++ b/tutorials/modules/CHT/heatExchanger/constant/porous/fvModels
@@ -21,7 +21,7 @@ porousToair
     nbrRegion       air;
     master          true;
 
-    interpolationMethod cellVolumeWeight;
+    interpolationMethod intersection;
 
     semiImplicit    no;