diff --git a/applications/test/fvMeshStitcher/Make/files b/applications/test/fvMeshStitcher/Make/files
new file mode 100644
index 0000000000..013d3aa8e8
--- /dev/null
+++ b/applications/test/fvMeshStitcher/Make/files
@@ -0,0 +1,3 @@
+Test-fvMeshStitcher.C
+
+EXE = $(FOAM_USER_APPBIN)/Test-fvMeshStitcher
diff --git a/applications/test/fvMeshStitcher/Make/options b/applications/test/fvMeshStitcher/Make/options
new file mode 100644
index 0000000000..fbb5bf176c
--- /dev/null
+++ b/applications/test/fvMeshStitcher/Make/options
@@ -0,0 +1,9 @@
+EXE_INC = \
+    -I$(LIB_SRC)/fileFormats/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude
+
+EXE_LIBS = \
+    -lfileFormats \
+    -lfiniteVolume \
+    -lmeshTools
diff --git a/applications/test/fvMeshStitcher/Test-fvMeshStitcher.C b/applications/test/fvMeshStitcher/Test-fvMeshStitcher.C
new file mode 100644
index 0000000000..2518c4e7f7
--- /dev/null
+++ b/applications/test/fvMeshStitcher/Test-fvMeshStitcher.C
@@ -0,0 +1,78 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "fvMesh.H"
+#include "Time.H"
+#include "timeSelector.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+using namespace Foam;
+
+int main(int argc, char *argv[])
+{
+    Foam::argList::addBoolOption("write", "write mesh/results files");
+    #include "addOverwriteOption.H"
+    #include "addRegionOption.H"
+
+    #include "setRootCase.H"
+    #include "createTime.H"
+    runTime.functionObjects().off();
+    #include "createNamedMesh.H"
+
+    const bool write = args.optionFound("write");
+    const bool overwrite = args.optionFound("overwrite");
+
+    if (write || overwrite)
+    {
+        const word oldInstance = mesh.pointsInstance();
+
+        mesh.setInstance(runTime.timeName());
+
+        // Set the precision of the points data to 10
+        IOstream::defaultPrecision(max(10u, IOstream::defaultPrecision()));
+
+        if (!overwrite)
+        {
+            runTime++;
+        }
+        else
+        {
+            mesh.setInstance(oldInstance);
+        }
+
+        // Write resulting mesh
+        Info<< "Writing mesh to " << runTime.timeName() << nl << endl;
+        mesh.write();
+    }
+
+    Info<< "End" << nl << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //
diff --git a/applications/test/patchToPatch/Make/files b/applications/test/patchToPatch/Make/files
new file mode 100644
index 0000000000..af75781c67
--- /dev/null
+++ b/applications/test/patchToPatch/Make/files
@@ -0,0 +1,3 @@
+Test-patchToPatch.C
+
+EXE = $(FOAM_USER_APPBIN)/Test-patchToPatch
diff --git a/applications/test/patchToPatch/Make/options b/applications/test/patchToPatch/Make/options
new file mode 100644
index 0000000000..d820876f44
--- /dev/null
+++ b/applications/test/patchToPatch/Make/options
@@ -0,0 +1,7 @@
+EXE_INC = \
+    -I$(LIB_SRC)/fileFormats/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude
+
+EXE_LIBS = \
+    -lfileFormats \
+    -lmeshTools
diff --git a/applications/test/patchToPatch/Test-patchToPatch.C b/applications/test/patchToPatch/Test-patchToPatch.C
new file mode 100644
index 0000000000..a25f9930fb
--- /dev/null
+++ b/applications/test/patchToPatch/Test-patchToPatch.C
@@ -0,0 +1,77 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "AMIInterpolation.H"
+#include "cpuTime.H"
+#include "patchToPatch.H"
+#include "polyMesh.H"
+#include "Time.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+using namespace Foam;
+
+
+int main(int argc, char *argv[])
+{
+    argList::validArgs.append("source");
+    argList::validArgs.append("target");
+    argList::validArgs.append("method");
+
+    #include "setRootCase.H"
+    #include "createTime.H"
+    #include "createPolyMesh.H"
+
+    const polyPatch& srcPatch = mesh.boundaryMesh()[args[1]];
+    const polyPatch& tgtPatch = mesh.boundaryMesh()[args[2]];
+    const word& method = args[3];
+
+    cpuTime time;
+
+    /*
+    AMIInterpolation(srcPatch, tgtPatch, faceAreaIntersect::tmMesh);
+
+    Info<< nl << "AMI" << ": Completed in "
+        << time.cpuTimeIncrement() << " s" << nl << endl;
+    */
+
+    patchToPatch::New(method, false)->update
+    (
+        srcPatch,
+        srcPatch.pointNormals(),
+        tgtPatch
+    );
+
+    Info<< nl << patchToPatch::typeName << ": Completed in "
+        << time.cpuTimeIncrement() << " s" << nl << endl;
+
+    Info<< "End" << nl << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //
diff --git a/applications/test/volPointInterpolation/Test-volPointInterpolation.C b/applications/test/volPointInterpolation/Test-volPointInterpolation.C
index 3d06e2f764..799c39ec2e 100644
--- a/applications/test/volPointInterpolation/Test-volPointInterpolation.C
+++ b/applications/test/volPointInterpolation/Test-volPointInterpolation.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -27,45 +27,45 @@ Application
 \*---------------------------------------------------------------------------*/
 
 #include "fvCFD.H"
+#include "timeSelector.H"
 #include "volPointInterpolation.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+template<class Type>
+bool interpolate(const fvMesh& mesh, const word& name)
+{
+    typeIOobject<VolField<Type>> io
+    (
+        name,
+        mesh.time().timeName(),
+        mesh,
+        IOobject::MUST_READ
+    );
+
+    if (!io.headerOk()) return false;
+
+    Info<< "Reading field " << name << nl << endl;
+
+    const VolField<Type> vf(io, mesh);
+    const PointField<Type> pf(volPointInterpolation::New(mesh).interpolate(vf));
+
+    Info<< "Writing field " << pf.name() << nl << endl;
+
+    return pf.write();
+}
+
+
 int main(int argc, char *argv[])
 {
+    argList::validArgs.append("field");
+
+    Foam::timeSelector::addOptions();
     #include "setRootCase.H"
-
     #include "createTime.H"
+    Foam::instantList timeDirs = Foam::timeSelector::select0(runTime, args);
     #include "createMesh.H"
 
-    Info<< "Reading field p\n" << endl;
-    volScalarField p
-    (
-        IOobject
-        (
-            "p",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
-
-    Info<< "Reading field U\n" << endl;
-    volVectorField U
-    (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
-
     const pointMesh& pMesh = pointMesh::New(mesh);
     const pointBoundaryMesh& pbm = pMesh.boundary();
 
@@ -78,21 +78,31 @@ int main(int argc, char *argv[])
             << endl;
     }
 
-    const volPointInterpolation& pInterp = volPointInterpolation::New(mesh);
+    const word name = args.argRead<word>(1);
 
-
-    pointScalarField pp(pInterp.interpolate(p));
-    Info<< pp.name() << " boundary" << endl;
-    forAll(pp.boundaryField(), patchi)
+    forAll(timeDirs, timei)
     {
-        Info<< pbm[patchi].name() << " coupled="
-            << pp.boundaryField()[patchi].coupled()<< endl;
+        runTime.setTime(timeDirs[timei], timei);
+
+        Info<< "Time = " << runTime.userTimeName() << endl;
+
+        mesh.readUpdate();
+
+        if
+        (
+            !interpolate<scalar>(mesh, name)
+         && !interpolate<vector>(mesh, name)
+         && !interpolate<sphericalTensor>(mesh, name)
+         && !interpolate<symmTensor>(mesh, name)
+         && !interpolate<tensor>(mesh, name)
+        )
+        {
+            WarningInFunction
+                << "Could not find field " << name << nl << endl;
+        }
     }
 
-    pp.write();
-
-    pointVectorField pU(pInterp.interpolate(U));
-    pU.write();
+    Info<< "End\n" << endl;
 
     return 0;
 }
diff --git a/applications/utilities/mesh/manipulation/createNonConformalCouples/Make/files b/applications/utilities/mesh/manipulation/createNonConformalCouples/Make/files
new file mode 100644
index 0000000000..e35a967698
--- /dev/null
+++ b/applications/utilities/mesh/manipulation/createNonConformalCouples/Make/files
@@ -0,0 +1,3 @@
+createNonConformalCouples.C
+
+EXE = $(FOAM_APPBIN)/createNonConformalCouples
diff --git a/applications/utilities/mesh/manipulation/createNonConformalCouples/Make/options b/applications/utilities/mesh/manipulation/createNonConformalCouples/Make/options
new file mode 100644
index 0000000000..9b8c3dea8c
--- /dev/null
+++ b/applications/utilities/mesh/manipulation/createNonConformalCouples/Make/options
@@ -0,0 +1,9 @@
+EXE_INC = \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/dynamicMesh/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude
+
+EXE_LIBS = \
+    -lfiniteVolume \
+    -ldynamicMesh \
+    -lmeshTools
diff --git a/applications/utilities/mesh/manipulation/createNonConformalCouples/createNonConformalCouples.C b/applications/utilities/mesh/manipulation/createNonConformalCouples/createNonConformalCouples.C
new file mode 100644
index 0000000000..c92776a9d9
--- /dev/null
+++ b/applications/utilities/mesh/manipulation/createNonConformalCouples/createNonConformalCouples.C
@@ -0,0 +1,377 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Application
+    createNonConformalCouples
+
+Description
+    Utility to create non-conformal couples between non-coupled patches.
+
+Usage
+    \b createNonConformalCouples <patch1> <patch2>
+
+Note
+    If run with two arguments, these arguments specify the patches between
+    which a single couple is to be created. The resulting couple will not have
+    a transformation.
+
+Usage
+    \b createNonConformalCouples
+
+Note
+    If run without arguments then settings are read from a \b
+    system/createNonConformalCouplesDict dictionary (or from a different
+    dictionary specified by the \b -dict option). This dictionary can specify
+    the creation of multiple couples and/or couples with transformations.
+
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "fvMeshStitchersStationary.H"
+#include "nonConformalCyclicPolyPatch.H"
+#include "nonConformalErrorPolyPatch.H"
+#include "nonConformalProcessorCyclicPolyPatch.H"
+#include "polyMesh.H"
+#include "processorPolyPatch.H"
+#include "systemDict.H"
+#include "Time.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+void createNonConformalCouples
+(
+    fvMesh& mesh,
+    const List<Pair<word>>& patchNames,
+    const wordList& cyclicNames,
+    const List<cyclicTransform>& transforms
+)
+{
+    const polyBoundaryMesh& patches = mesh.boundaryMesh();
+
+    List<polyPatch*> newPatches;
+
+    // Find the first processor patch and face
+    label firstProcPatchi = patches.size(), firstProcFacei = mesh.nFaces();
+    forAll(patches, patchi)
+    {
+        const polyPatch& pp = patches[patchi];
+
+        if (isA<processorPolyPatch>(pp) && firstProcPatchi == patches.size())
+        {
+            firstProcPatchi = patchi;
+            firstProcFacei = pp.start();
+        }
+
+        if (!isA<processorPolyPatch>(pp) && firstProcPatchi != patches.size())
+        {
+            FatalErrorInFunction
+                << "Processor patches do not follow boundary patches"
+                << exit(FatalError);
+        }
+    }
+
+    // Clone the non-processor patches
+    for (label patchi = 0; patchi < firstProcPatchi; ++ patchi)
+    {
+        const polyPatch& pp = patches[patchi];
+
+        newPatches.append
+        (
+            pp.clone(patches, patchi, pp.size(), pp.start()).ptr()
+        );
+    }
+
+    // Convenience function to generate patch names for the owner or neighbour
+    auto nccPatchNames = [&](const label i)
+    {
+        return
+            Pair<word>
+            (
+                cyclicNames[i] + "_on_" + patchNames[i][0],
+                cyclicNames[i] + "_on_" + patchNames[i][1]
+            );
+    };
+
+    // Add the cyclic patches
+    forAll(patchNames, i)
+    {
+        Info<< indent << "Adding "
+            << nonConformalCyclicPolyPatch::typeName
+            << " interfaces between patches: " << incrIndent << nl
+            << indent << patchNames[i] << decrIndent << nl
+            << indent << "Named:" << incrIndent << nl
+            << indent << Pair<word>(nccPatchNames(i)) << decrIndent << nl
+            << indent << "With transform: " << incrIndent << nl;
+        transforms[i].write(Info);
+        Info<< decrIndent << nl;
+
+        newPatches.append
+        (
+            new nonConformalCyclicPolyPatch
+            (
+                nccPatchNames(i)[0],
+                0,
+                firstProcFacei,
+                newPatches.size(),
+                patches,
+                nonConformalCyclicPolyPatch::typeName,
+                nccPatchNames(i)[1],
+                patchNames[i][0],
+                transforms[i]
+            )
+        );
+        newPatches.append
+        (
+            new nonConformalCyclicPolyPatch
+            (
+                nccPatchNames(i)[1],
+                0,
+                firstProcFacei,
+                newPatches.size(),
+                patches,
+                nonConformalCyclicPolyPatch::typeName,
+                nccPatchNames(i)[0],
+                patchNames[i][1],
+                inv(transforms[i])
+            )
+        );
+    }
+
+    // Add the error patches. Note there is only one for each source patch,
+    // regardless of how many interfaces are attached to that patch.
+    auto appendErrorPatches = [&](const bool owner)
+    {
+        wordHashSet patchANames;
+        forAll(patchNames, i)
+        {
+            patchANames.insert(patchNames[i][!owner]);
+        }
+        forAllConstIter(wordHashSet, patchANames, iter)
+        {
+            newPatches.append
+            (
+                new nonConformalErrorPolyPatch
+                (
+                    nonConformalErrorPolyPatch::typeName + "_on_" + iter.key(),
+                    0,
+                    firstProcFacei,
+                    newPatches.size(),
+                    patches,
+                    nonConformalErrorPolyPatch::typeName,
+                    iter.key()
+                )
+            );
+        }
+    };
+    appendErrorPatches(true);
+    appendErrorPatches(false);
+
+    // Clone the processor patches
+    for (label patchi = firstProcPatchi; patchi < patches.size(); ++ patchi)
+    {
+        const polyPatch& pp = patches[patchi];
+
+        newPatches.append
+        (
+            pp.clone(patches, newPatches.size(), pp.size(), pp.start()).ptr()
+        );
+    }
+
+    // Add the processor cyclic patches
+    if (Pstream::parRun())
+    {
+        forAll(patchNames, i)
+        {
+            const polyPatch& patch1 = patches[patchNames[i][0]];
+            const polyPatch& patch2 = patches[patchNames[i][1]];
+
+            boolList procHasPatch1(Pstream::nProcs(), false);
+            procHasPatch1[Pstream::myProcNo()] = !patch1.empty();
+            Pstream::gatherList(procHasPatch1);
+            Pstream::scatterList(procHasPatch1);
+
+            boolList procHasPatch2(Pstream::nProcs(), false);
+            procHasPatch2[Pstream::myProcNo()] = !patch2.empty();
+            Pstream::gatherList(procHasPatch2);
+            Pstream::scatterList(procHasPatch2);
+
+            // Multiple cyclic interfaces must be ordered in a specific way for
+            // processor communication to function correctly.
+            //
+            // A communication that is sent from the cyclic owner is received
+            // on the cyclic neighbour and vice versa. Therefore, in a coupled
+            // pair of processors if one sends the owner first the other must
+            // receive the neighbour first.
+            //
+            // We ensure the above by ordering the patches so that for the
+            // lower indexed processor the owner interface comes first, and for
+            // the higher indexed processor the neighbour comes first.
+
+            auto appendProcPatches = [&](const bool owner, const bool first)
+            {
+                const boolList& procHasPatchA =
+                    owner ? procHasPatch1 : procHasPatch2;
+                const boolList& procHasPatchB =
+                    owner ? procHasPatch2 : procHasPatch1;
+
+                if (procHasPatchA[Pstream::myProcNo()])
+                {
+                    forAll(procHasPatchB, proci)
+                    {
+                        if
+                        (
+                            (
+                                (first && proci < Pstream::myProcNo())
+                             || (!first && proci > Pstream::myProcNo())
+                            )
+                         && procHasPatchB[proci]
+                        )
+                        {
+                            newPatches.append
+                            (
+                                new nonConformalProcessorCyclicPolyPatch
+                                (
+                                    0,
+                                    mesh.nFaces(),
+                                    newPatches.size(),
+                                    patches,
+                                    Pstream::myProcNo(),
+                                    proci,
+                                    nccPatchNames(i)[!owner],
+                                    patchNames[i][!owner]
+                                )
+                            );
+                        }
+                    }
+                }
+            };
+
+            appendProcPatches(true, true);
+            appendProcPatches(false, true);
+            appendProcPatches(false, false);
+            appendProcPatches(true, false);
+        }
+    }
+
+    // Re-patch the mesh
+    mesh.removeFvBoundary();
+    mesh.addFvPatches(newPatches);
+}
+
+
+int main(int argc, char *argv[])
+{
+    #include "addOverwriteOption.H"
+    #include "addRegionOption.H"
+    #include "addDictOption.H"
+
+    const bool haveArgs = argList::hasArgs(argc, argv);
+    if (haveArgs)
+    {
+        argList::validArgs.append("patch1");
+        argList::validArgs.append("patch2");
+    }
+
+    #include "setRootCase.H"
+    #include "createTime.H"
+    runTime.functionObjects().off();
+
+    // Get the patches between which to create interfaces and the associated
+    // transformations. If there are arguments then read the patch names from
+    // the arguments and assume an identity transformation. If not, then load
+    // the system dictionary and read potentially multiple pairs of patches and
+    // associated transformations.
+    List<Pair<word>> patchNames;
+    wordList cyclicNames;
+    List<cyclicTransform> transforms;
+    if (haveArgs)
+    {
+        patchNames.append(Pair<word>(args[1], args[2]));
+        cyclicNames.append(nonConformalCyclicPolyPatch::typeName);
+        transforms.append(cyclicTransform(true));
+    }
+    else
+    {
+        static const word dictName("createNonConformalCouplesDict");
+
+        IOdictionary dict(systemDict(dictName, args, runTime));
+
+        forAllConstIter(dictionary, dict, iter)
+        {
+            patchNames.append(iter().dict().lookup<Pair<word>>("patches"));
+            cyclicNames.append(iter().dict().dictName());
+            transforms.append(cyclicTransform(iter().dict(), true));
+        }
+    }
+
+    Foam::word meshRegionName = polyMesh::defaultRegion;
+    args.optionReadIfPresent("region", meshRegionName);
+
+    const bool overwrite = args.optionFound("overwrite");
+
+    #include "createNamedMesh.H"
+
+    const word oldInstance = mesh.pointsInstance();
+
+    // Make sure the mesh is not connected before couples are added
+    fvMeshStitchers::stationary stitcher(mesh);
+    stitcher.disconnect(false, false);
+
+    createNonConformalCouples
+    (
+        mesh,
+        patchNames,
+        cyclicNames,
+        transforms
+    );
+
+    // Connect the mesh so that the new stitching topology gets written out
+    stitcher.connect(false, false);
+
+    mesh.setInstance(runTime.timeName());
+
+    // Set the precision of the points data to 10
+    IOstream::defaultPrecision(max(10u, IOstream::defaultPrecision()));
+
+    if (!overwrite)
+    {
+        runTime++;
+    }
+    else
+    {
+        mesh.setInstance(oldInstance);
+    }
+
+    // Write resulting mesh
+    Info<< "Writing mesh to " << runTime.timeName() << nl << endl;
+    mesh.write();
+
+    Info<< "End\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/parallelProcessing/decomposePar/Make/files b/applications/utilities/parallelProcessing/decomposePar/Make/files
index 077cbe902a..e5f8107a96 100644
--- a/applications/utilities/parallelProcessing/decomposePar/Make/files
+++ b/applications/utilities/parallelProcessing/decomposePar/Make/files
@@ -1,5 +1,4 @@
 decomposePar.C
-domainDecomposition.C
 dimFieldDecomposer.C
 fvFieldDecomposer.C
 pointFieldDecomposer.C
diff --git a/applications/utilities/parallelProcessing/decomposePar/Make/options b/applications/utilities/parallelProcessing/decomposePar/Make/options
index ca546847e5..75d78ebfd1 100644
--- a/applications/utilities/parallelProcessing/decomposePar/Make/options
+++ b/applications/utilities/parallelProcessing/decomposePar/Make/options
@@ -1,14 +1,16 @@
 EXE_INC = \
-    -I$(LIB_SRC)/parallel/decompose/decompositionMethods/lnInclude \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
-    -I$(LIB_SRC)/dynamicMesh/lnInclude \
-    -I$(LIB_SRC)/lagrangian/basic/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/parallel/parallel/lnInclude \
+    -I$(LIB_SRC)/parallel/decompose/decompositionMethods/lnInclude \
+    -I$(LIB_SRC)/lagrangian/basic/lnInclude \
     -I$(LIB_SRC)/regionModels/regionModel/lnInclude
 
 EXE_LIBS = \
-    -ldynamicMesh \
-    -lgenericPatchFields \
-    -ldecompositionMethods -L$(FOAM_LIBBIN)/dummy -lmetisDecomp -lscotchDecomp \
+    -lfiniteVolume \
+    -lmeshTools\
+    -lparallel \
+    -ldecompositionMethods \
     -llagrangian \
-    -lregionModels
+    -lregionModels \
+    -lgenericPatchFields
diff --git a/applications/utilities/parallelProcessing/decomposePar/decomposePar.C b/applications/utilities/parallelProcessing/decomposePar/decomposePar.C
index 5f6bae24c7..c30621ee51 100644
--- a/applications/utilities/parallelProcessing/decomposePar/decomposePar.C
+++ b/applications/utilities/parallelProcessing/decomposePar/decomposePar.C
@@ -79,6 +79,7 @@ Usage
 
 \*---------------------------------------------------------------------------*/
 
+#include "processorRunTimes.H"
 #include "domainDecomposition.H"
 #include "decompositionMethod.H"
 #include "argList.H"
@@ -114,14 +115,12 @@ namespace Foam
 void decomposeUniform
 (
     const bool copyUniform,
-    const domainDecomposition& decomposition,
-    const Time& processorDb,
+    const bool distributeUniform,
+    const Time& runTime,
+    const Time& procRunTime,
     const word& regionDir = word::null
 )
 {
-    const Time& runTime = decomposition.mesh().time();
-
-    // Any uniform data to copy/link?
     const fileName uniformDir(regionDir/"uniform");
 
     if (fileHandler().isDir(runTime.timePath()/uniformDir))
@@ -131,9 +130,9 @@ void decomposeUniform
             << endl;
 
         const fileName timePath =
-            fileHandler().filePath(processorDb.timePath());
+            fileHandler().filePath(procRunTime.timePath());
 
-        if (copyUniform || decomposition.distributed())
+        if (copyUniform || distributeUniform)
         {
             if (!fileHandler().exists(timePath/uniformDir))
             {
@@ -171,9 +170,9 @@ void decomposeUniform
 }
 
 
-void writeDecomposition(const domainDecomposition& decomposition)
+void writeDecomposition(const domainDecomposition& meshes)
 {
-    const labelList& procIds = decomposition.cellToProc();
+    const labelList& procIds = meshes.cellToProc();
 
     // Write the decomposition as labelList for use with 'manual'
     // decomposition method.
@@ -182,8 +181,8 @@ void writeDecomposition(const domainDecomposition& decomposition)
         IOobject
         (
             "cellDecomposition",
-            decomposition.mesh().facesInstance(),
-            decomposition.mesh(),
+            meshes.completeMesh().facesInstance(),
+            meshes.completeMesh(),
             IOobject::NO_READ,
             IOobject::NO_WRITE,
             false
@@ -203,12 +202,12 @@ void writeDecomposition(const domainDecomposition& decomposition)
         IOobject
         (
             "cellDist",
-            decomposition.mesh().time().timeName(),
-            decomposition.mesh(),
+            meshes.completeMesh().time().timeName(),
+            meshes.completeMesh(),
             IOobject::NO_READ,
             IOobject::AUTO_WRITE
         ),
-        decomposition.mesh(),
+        meshes.completeMesh(),
         dimless,
         scalarField(scalarList(procIds))
     );
@@ -309,18 +308,20 @@ int main(int argc, char *argv[])
     }
 
     // Set time from database
-    #include "createTime.H"
+    Info<< "Create time\n" << endl;
+    processorRunTimes runTimes(Foam::Time::controlDictName, args);
 
     // Allow override of time
-    instantList times = timeSelector::selectIfPresent(runTime, args);
+    const instantList times = runTimes.selectComplete(args);
 
     // Get region names
-    const wordList regionNames(selectRegionNames(args, runTime));
+    const wordList regionNames =
+        selectRegionNames(args, runTimes.completeTime());
 
     // Handle existing decomposition directories
     {
         // Determine the processor count from the directories
-        label nProcs = fileHandler().nProcs(runTime.path());
+        label nProcs = fileHandler().nProcs(runTimes.completeTime().path());
 
         if (forceOverwrite)
         {
@@ -339,7 +340,7 @@ int main(int argc, char *argv[])
             (
                 fileHandler().readDir
                 (
-                    runTime.path(),
+                    runTimes.completeTime().path(),
                     fileType::directory
                 )
             );
@@ -379,12 +380,17 @@ int main(int argc, char *argv[])
                 << " domains, use the -force option or manually" << nl
                 << "remove processor directories before decomposing. e.g.,"
                 << nl
-                << "    rm -rf " << runTime.path().c_str() << "/processor*"
+                << "    rm -rf " << runTimes.completeTime().path().c_str()
+                << "/processor*"
                 << nl
                 << exit(FatalError);
         }
     }
 
+    // Get the decomposition dictionary
+    const dictionary decomposeParDict =
+        decompositionMethod::decomposeParDict(runTimes.completeTime());
+
     // Decompose all regions
     forAll(regionNames, regioni)
     {
@@ -394,12 +400,12 @@ int main(int argc, char *argv[])
         Info<< "\n\nDecomposing mesh " << regionName << nl << endl;
 
         // Determine the existing processor count directly
-        label nProcs = fileHandler().nProcs(runTime.path(), regionDir);
+        const label nProcs =
+            fileHandler().nProcs(runTimes.completeTime().path(), regionDir);
 
         // Get requested numberOfSubdomains
         const label nDomains =
-            decompositionMethod::decomposeParDict(runTime)
-           .lookup<label>("numberOfSubdomains");
+            decomposeParDict.lookup<label>("numberOfSubdomains");
 
         // Give file handler a chance to determine the output directory
         const_cast<fileOperation&>(fileHandler()).setNProcs(nDomains);
@@ -421,74 +427,70 @@ int main(int argc, char *argv[])
             Info<< "Using existing processor directories" << nl;
         }
 
-        Info<< "Create mesh" << endl;
-        fvMesh mesh
-        (
-            IOobject
-            (
-                regionName,
-                runTime.timeName(),
-                runTime,
-                IOobject::NO_READ,
-                IOobject::NO_WRITE,
-                false
-            ),
-            false
-        );
+        // Get flag to determine whether or not to distribute uniform data
+        const label distributeUniform =
+            decomposeParDict.lookupOrDefault<bool>("distributed", false);
 
-        // Create decomposition
-        domainDecomposition decomposition(mesh);
+        // Create meshes
+        Info<< "Create mesh" << endl;
+        domainDecomposition meshes(runTimes, regionName);
+        meshes.readComplete();
 
         // Read or generate a decomposition as necessary
         if (decomposeFieldsOnly)
         {
-            decomposition.read();
+            meshes.readProcs();
+            if (!copyZero)
+            {
+                meshes.readAddressing();
+                meshes.readUpdate();
+            }
         }
         else
         {
-            decomposition.decompose();
-            decomposition.write(decomposeSets);
-            if (writeCellDist)
-            {
-                writeDecomposition(decomposition);
-            }
+            meshes.decompose();
+            meshes.writeProcs(decomposeSets);
+            if (writeCellDist) writeDecomposition(meshes);
             fileHandler().flush();
         }
 
         // Field maps. These are preserved if decomposing multiple times.
         PtrList<fvFieldDecomposer> fieldDecomposerList
         (
-            decomposition.nProcs()
+            meshes.nProcs()
         );
         PtrList<dimFieldDecomposer> dimFieldDecomposerList
         (
-            decomposition.nProcs()
+            meshes.nProcs()
         );
         PtrList<pointFieldDecomposer> pointFieldDecomposerList
         (
-            decomposition.nProcs()
+            meshes.nProcs()
         );
 
         // Loop over all times
         forAll(times, timeI)
         {
             // Set the time
-            runTime.setTime(times[timeI], timeI);
-            decomposition.setTime(times[timeI], timeI);
+            runTimes.setTime(times[timeI], timeI);
 
-            Info<< "Time = " << runTime.userTimeName() << endl;
+            Info<< "Time = " << runTimes.completeTime().userTimeName() << endl;
 
-            // Update the mesh
-            const fvMesh::readUpdateState state = mesh.readUpdate();
+            // Update the meshes, if necessary
+            fvMesh::readUpdateState state = fvMesh::UNCHANGED;
+            if (!decomposeFieldsOnly || !copyZero)
+            {
+                state = meshes.readUpdate();
+            }
 
-            // Update the decomposition
+            // Write the mesh out, if necessary
             if (decomposeFieldsOnly)
             {
-                decomposition.readUpdate();
+                // Nothing to do
             }
             else if (state == fvMesh::POINTS_MOVED)
             {
-                decomposition.writePoints();
+                meshes.writeProcs(false);
             }
             else if
             (
@@ -496,12 +498,9 @@ int main(int argc, char *argv[])
              || state == fvMesh::TOPO_PATCH_CHANGE
             )
             {
-                decomposition.decompose();
-                decomposition.write(decomposeSets);
-                if (writeCellDist)
-                {
-                    writeDecomposition(decomposition);
-                }
+                meshes.writeProcs(decomposeSets);
+                if (writeCellDist) writeDecomposition(meshes);
+                fileHandler().flush();
             }
 
             // Clear the field maps if there has been topology change
@@ -511,7 +510,7 @@ int main(int argc, char *argv[])
              || state == fvMesh::TOPO_PATCH_CHANGE
             )
             {
-                for (label proci = 0; proci < decomposition.nProcs(); proci++)
+                for (label proci = 0; proci < meshes.nProcs(); proci++)
                 {
                     fieldDecomposerList.set(proci, nullptr);
                     dimFieldDecomposerList.set(proci, nullptr);
@@ -528,43 +527,38 @@ int main(int argc, char *argv[])
             {
                 // Copy the field files from the <time> directory to the
                 // processor*/<time> directories without altering them
+                const fileName completeTimePath =
+                    runTimes.completeTime().timePath();
 
-                fileName prevTimePath;
-                for (label proci = 0; proci < decomposition.nProcs(); proci++)
+                fileName prevProcTimePath;
+                for (label proci = 0; proci < meshes.nProcs(); proci++)
                 {
-                    Time processorDb
-                    (
-                        Time::controlDictName,
-                        args.rootPath(),
-                        args.caseName()
-                       /fileName(word("processor") + name(proci))
-                    );
-                    processorDb.setTime(runTime);
+                    const Time& procRunTime =
+                        meshes.procMeshes()[proci].time();
 
-                    if (fileHandler().isDir(runTime.timePath()))
+                    if (fileHandler().isDir(completeTimePath))
                     {
-                        const fileName timePath
+                        const fileName procTimePath
                         (
                             fileHandler().objectPath
                             (
                                 IOobject
                                 (
                                     "",
-                                    processorDb.timeName(),
-                                    processorDb
+                                    procRunTime.timeName(),
+                                    procRunTime
                                 ),
                                 word::null
                             )
                         );
 
-                        if (timePath != prevTimePath)
+                        if (procTimePath != prevProcTimePath)
                         {
                             Info<< "Processor " << proci
-                                << ": copying " << runTime.timePath() << nl
-                                << " to " << timePath << endl;
-                            fileHandler().cp(runTime.timePath(), timePath);
-
-                            prevTimePath = timePath;
+                                << ": copying " << completeTimePath << nl
+                                << " to " << procTimePath << endl;
+                            fileHandler().cp(completeTimePath, procTimePath);
+                            prevProcTimePath = procTimePath;
                         }
                     }
                 }
@@ -574,49 +568,73 @@ int main(int argc, char *argv[])
                 // Decompose the fields
 
                 // Search for list of objects for this time
-                IOobjectList objects(mesh, runTime.timeName());
+                IOobjectList objects
+                (
+                    meshes.completeMesh(),
+                    runTimes.completeTime().timeName()
+                );
 
                 // Construct the vol fields
                 PtrList<volScalarField> volScalarFields;
-                readFields(mesh, objects, volScalarFields);
+                readFields(meshes.completeMesh(), objects, volScalarFields);
                 PtrList<volVectorField> volVectorFields;
-                readFields(mesh, objects, volVectorFields);
+                readFields(meshes.completeMesh(), objects, volVectorFields);
                 PtrList<volSphericalTensorField> volSphericalTensorFields;
-                readFields(mesh, objects, volSphericalTensorFields);
+                readFields
+                (
+                    meshes.completeMesh(),
+                    objects,
+                    volSphericalTensorFields
+                );
                 PtrList<volSymmTensorField> volSymmTensorFields;
-                readFields(mesh, objects, volSymmTensorFields);
+                readFields(meshes.completeMesh(), objects, volSymmTensorFields);
                 PtrList<volTensorField> volTensorFields;
-                readFields(mesh, objects, volTensorFields);
+                readFields(meshes.completeMesh(), objects, volTensorFields);
 
                 // Construct the dimensioned fields
                 PtrList<DimensionedField<scalar, volMesh>> dimScalarFields;
-                readFields(mesh, objects, dimScalarFields);
+                readFields(meshes.completeMesh(), objects, dimScalarFields);
                 PtrList<DimensionedField<vector, volMesh>> dimVectorFields;
-                readFields(mesh, objects, dimVectorFields);
+                readFields(meshes.completeMesh(), objects, dimVectorFields);
                 PtrList<DimensionedField<sphericalTensor, volMesh>>
                     dimSphericalTensorFields;
-                readFields(mesh, objects, dimSphericalTensorFields);
+                readFields
+                (
+                    meshes.completeMesh(),
+                    objects,
+                    dimSphericalTensorFields
+                );
                 PtrList<DimensionedField<symmTensor, volMesh>>
                     dimSymmTensorFields;
-                readFields(mesh, objects, dimSymmTensorFields);
+                readFields(meshes.completeMesh(), objects, dimSymmTensorFields);
                 PtrList<DimensionedField<tensor, volMesh>> dimTensorFields;
-                readFields(mesh, objects, dimTensorFields);
+                readFields(meshes.completeMesh(), objects, dimTensorFields);
 
                 // Construct the surface fields
                 PtrList<surfaceScalarField> surfaceScalarFields;
-                readFields(mesh, objects, surfaceScalarFields);
+                readFields(meshes.completeMesh(), objects, surfaceScalarFields);
                 PtrList<surfaceVectorField> surfaceVectorFields;
-                readFields(mesh, objects, surfaceVectorFields);
+                readFields(meshes.completeMesh(), objects, surfaceVectorFields);
                 PtrList<surfaceSphericalTensorField>
                     surfaceSphericalTensorFields;
-                readFields(mesh, objects, surfaceSphericalTensorFields);
+                readFields
+                (
+                    meshes.completeMesh(),
+                    objects,
+                    surfaceSphericalTensorFields
+                );
                 PtrList<surfaceSymmTensorField> surfaceSymmTensorFields;
-                readFields(mesh, objects, surfaceSymmTensorFields);
+                readFields
+                (
+                    meshes.completeMesh(),
+                    objects,
+                    surfaceSymmTensorFields
+                );
                 PtrList<surfaceTensorField> surfaceTensorFields;
-                readFields(mesh, objects, surfaceTensorFields);
+                readFields(meshes.completeMesh(), objects, surfaceTensorFields);
 
                 // Construct the point fields
-                const pointMesh& pMesh = pointMesh::New(mesh);
+                const pointMesh& pMesh = pointMesh::New(meshes.completeMesh());
                 PtrList<pointScalarField> pointScalarFields;
                 readFields(pMesh, objects, pointScalarFields);
                 PtrList<pointVectorField> pointVectorFields;
@@ -633,7 +651,7 @@ int main(int argc, char *argv[])
                 (
                     fileHandler().readDir
                     (
-                        runTime.timePath()/cloud::prefix,
+                        runTimes.completeTime().timePath()/cloud::prefix,
                         fileType::directory
                     )
                 );
@@ -672,8 +690,8 @@ int main(int argc, char *argv[])
                 {
                     IOobjectList sprayObjs
                     (
-                        mesh,
-                        runTime.timeName(),
+                        meshes.completeMesh(),
+                        runTimes.completeTime().timeName(),
                         cloud::prefix/cloudDirs[i],
                         IOobject::MUST_READ,
                         IOobject::NO_WRITE,
@@ -695,7 +713,7 @@ int main(int argc, char *argv[])
                             cloudI,
                             new Cloud<indexedParticle>
                             (
-                                mesh,
+                                meshes.completeMesh(),
                                 cloudDirs[i],
                                 false
                             )
@@ -707,7 +725,7 @@ int main(int argc, char *argv[])
                             cloudI,
                             new List<SLList<indexedParticle*>*>
                             (
-                                mesh.nCells(),
+                                meshes.completeMesh().nCells(),
                                 static_cast<SLList<indexedParticle*>*>(nullptr)
                             )
                         );
@@ -726,7 +744,11 @@ int main(int argc, char *argv[])
                             label celli = iter().cell();
 
                             // Check
-                            if (celli < 0 || celli >= mesh.nCells())
+                            if
+                            (
+                                celli < 0
+                             || celli >= meshes.completeMesh().nCells()
+                            )
                             {
                                 FatalErrorInFunction
                                     << "Illegal cell number " << celli
@@ -735,10 +757,11 @@ int main(int argc, char *argv[])
                                     << " at position "
                                     << iter().position() << nl
                                     << "Cell number should be between 0 and "
-                                    << mesh.nCells()-1 << nl
+                                    << meshes.completeMesh().nCells()-1 << nl
                                     << "On this mesh the particle should"
                                     << " be in cell "
-                                    << mesh.findCell(iter().position())
+                                    << meshes.completeMesh().findCell
+                                       (iter().position())
                                     << exit(FatalError);
                             }
 
@@ -754,8 +777,8 @@ int main(int argc, char *argv[])
                         // Read fields
                         IOobjectList lagrangianObjects
                         (
-                            mesh,
-                            runTime.timeName(),
+                            meshes.completeMesh(),
+                            runTimes.completeTime().timeName(),
                             cloud::prefix/cloudDirs[cloudI],
                             IOobject::MUST_READ,
                             IOobject::NO_WRITE,
@@ -856,7 +879,7 @@ int main(int argc, char *argv[])
                 Info<< endl;
 
                 // split the fields over processors
-                for (label proci = 0; proci < decomposition.nProcs(); proci++)
+                for (label proci = 0; proci < meshes.nProcs(); proci++)
                 {
                     Info<< "Processor " << proci << ": field transfer" << endl;
 
@@ -869,10 +892,11 @@ int main(int argc, char *argv[])
                                 proci,
                                 new fvFieldDecomposer
                                 (
-                                    mesh,
-                                    decomposition.procMeshes()[proci],
-                                    decomposition.procFaceAddressing()[proci],
-                                    decomposition.procCellAddressing()[proci]
+                                    meshes.completeMesh(),
+                                    meshes.procMeshes()[proci],
+                                    meshes.procFaceAddressing()[proci],
+                                    meshes.procCellAddressing()[proci],
+                                    meshes.procFaceAddressingBf()[proci]
                                 )
                             );
                         }
@@ -916,10 +940,10 @@ int main(int argc, char *argv[])
                                 proci,
                                 new dimFieldDecomposer
                                 (
-                                    mesh,
-                                    decomposition.procMeshes()[proci],
-                                    decomposition.procFaceAddressing()[proci],
-                                    decomposition.procCellAddressing()[proci]
+                                    meshes.completeMesh(),
+                                    meshes.procMeshes()[proci],
+                                    meshes.procFaceAddressing()[proci],
+                                    meshes.procCellAddressing()[proci]
                                 )
                             );
                         }
@@ -949,7 +973,7 @@ int main(int argc, char *argv[])
                     )
                     {
                         const pointMesh& procPMesh =
-                            pointMesh::New(decomposition.procMeshes()[proci]);
+                            pointMesh::New(meshes.procMeshes()[proci]);
 
                         if (!pointFieldDecomposerList.set(proci))
                         {
@@ -960,7 +984,7 @@ int main(int argc, char *argv[])
                                 (
                                     pMesh,
                                     procPMesh,
-                                    decomposition.procPointAddressing()[proci]
+                                    meshes.procPointAddressing()[proci]
                                 )
                             );
                         }
@@ -989,10 +1013,10 @@ int main(int argc, char *argv[])
                         {
                             lagrangianFieldDecomposer fieldDecomposer
                             (
-                                mesh,
-                                decomposition.procMeshes()[proci],
-                                decomposition.procFaceAddressing()[proci],
-                                decomposition.procCellAddressing()[proci],
+                                meshes.completeMesh(),
+                                meshes.procMeshes()[proci],
+                                meshes.procFaceAddressing()[proci],
+                                meshes.procCellAddressing()[proci],
                                 cloudDirs[cloudI],
                                 lagrangianPositions[cloudI],
                                 cellParticles[cloudI]
@@ -1069,8 +1093,9 @@ int main(int argc, char *argv[])
                     decomposeUniform
                     (
                         copyUniform,
-                        decomposition,
-                        decomposition.procMeshes()[proci].time(),
+                        distributeUniform,
+                        runTimes.completeTime(),
+                        meshes.procMeshes()[proci].time(),
                         regionDir
                     );
 
@@ -1082,8 +1107,9 @@ int main(int argc, char *argv[])
                         decomposeUniform
                         (
                             copyUniform,
-                            decomposition,
-                            decomposition.procMeshes()[proci].time()
+                            distributeUniform,
+                            runTimes.completeTime(),
+                            meshes.procMeshes()[proci].time()
                         );
                     }
                 }
diff --git a/applications/utilities/parallelProcessing/decomposePar/fvFieldDecomposer.C b/applications/utilities/parallelProcessing/decomposePar/fvFieldDecomposer.C
index c4d2135e3f..61005c2fe7 100644
--- a/applications/utilities/parallelProcessing/decomposePar/fvFieldDecomposer.C
+++ b/applications/utilities/parallelProcessing/decomposePar/fvFieldDecomposer.C
@@ -25,95 +25,38 @@ License
 
 #include "fvFieldDecomposer.H"
 
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-Foam::labelList Foam::fvFieldDecomposer::patchFieldDecomposer::alignAddressing
+Foam::label Foam::fvFieldDecomposer::completePatchID
 (
-    const labelUList& addressingSlice,
-    const label addressingOffset
+    const label procPatchi
 ) const
 {
-    labelList addressing(addressingSlice.size());
+    const fvPatch& procPatch = procMesh_.boundary()[procPatchi];
 
-    forAll(addressing, i)
+    if (procPatchi < completeMesh_.boundary().size())
     {
-        // Subtract one to align addressing.
-        addressing[i] = addressingSlice[i] - (addressingOffset + 1);
+        return procPatchi;
+    }
+    else if (isA<processorCyclicFvPatch>(procPatch))
+    {
+        return refCast<const processorCyclicFvPatch>(procPatch).referPatchID();
+    }
+    else
+    {
+        return -1;
     }
-
-    return addressing;
 }
 
 
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
 Foam::fvFieldDecomposer::patchFieldDecomposer::patchFieldDecomposer
 (
-    const labelUList& addressingSlice,
-    const label addressingOffset
+    const labelUList& addressing
 )
 :
-    labelList(alignAddressing(addressingSlice, addressingOffset)),
-    directFvPatchFieldMapper(static_cast<const labelList&>(*this))
-{}
-
-
-Foam::labelList Foam::fvFieldDecomposer::processorVolPatchFieldDecomposer::
-alignAddressing
-(
-    const fvMesh& mesh,
-    const labelUList& addressingSlice
-) const
-{
-    labelList addressing(addressingSlice.size());
-
-    const labelList& own = mesh.faceOwner();
-    const labelList& neighb = mesh.faceNeighbour();
-
-    forAll(addressing, i)
-    {
-        // Subtract one to align addressing.
-        label ai = mag(addressingSlice[i]) - 1;
-
-        if (ai < neighb.size())
-        {
-            // This is a regular face. it has been an internal face
-            // of the original mesh and now it has become a face
-            // on the parallel boundary.
-            // Give face the value of the neighbour.
-
-            if (addressingSlice[i] >= 0)
-            {
-                // I have the owner so use the neighbour value
-                addressing[i] = neighb[ai];
-            }
-            else
-            {
-                addressing[i] = own[ai];
-            }
-        }
-        else
-        {
-            // This is a face that used to be on a cyclic boundary
-            // but has now become a parallel patch face. I cannot
-            // do the interpolation properly (I would need to look
-            // up the different (face) list of data), so I will
-            // just grab the value from the owner cell
-
-            addressing[i] = own[ai];
-        }
-    }
-
-    return addressing;
-}
-
-
-Foam::fvFieldDecomposer::processorVolPatchFieldDecomposer::
-processorVolPatchFieldDecomposer
-(
-    const fvMesh& mesh,
-    const labelUList& addressingSlice
-)
-:
-    labelList(alignAddressing(mesh, addressingSlice)),
+    labelList(mag(addressing) - 1),
     directFvPatchFieldMapper(static_cast<const labelList&>(*this))
 {}
 
@@ -123,34 +66,22 @@ Foam::fvFieldDecomposer::fvFieldDecomposer
     const fvMesh& completeMesh,
     const fvMesh& procMesh,
     const labelList& faceAddressing,
-    const labelList& cellAddressing
+    const labelList& cellAddressing,
+    const surfaceLabelField::Boundary& faceAddressingBf
 )
 :
     completeMesh_(completeMesh),
     procMesh_(procMesh),
     faceAddressing_(faceAddressing),
     cellAddressing_(cellAddressing),
-    patchFieldDecomposers_(procMesh_.boundary().size()),
-    processorVolPatchFieldDecomposers_(procMesh_.boundary().size())
+    faceAddressingBf_(faceAddressingBf),
+    patchFieldDecomposers_(procMesh_.boundary().size())
 {
     forAll(procMesh_.boundary(), procPatchi)
     {
-        const fvPatch& procPatch = procMesh.boundary()[procPatchi];
+        const label completePatchi = completePatchID(procPatchi);
 
-        // Determine the index of the corresponding complete patch
-        label completePatchi = -1;
-        if (procPatchi < completeMesh_.boundary().size())
-        {
-            completePatchi = procPatchi;
-        }
-        else if (isA<processorCyclicFvPatch>(procPatch))
-        {
-            completePatchi =
-                refCast<const processorCyclicPolyPatch>
-                (procPatch.patch()).referPatchID();
-        }
-
-        // If there is a corresponding complete patch, then create a mapper
+        // If there is a corresponding complete patch then create a patch mapper
         if (completePatchi >= 0)
         {
             patchFieldDecomposers_.set
@@ -158,22 +89,7 @@ Foam::fvFieldDecomposer::fvFieldDecomposer
                 procPatchi,
                 new patchFieldDecomposer
                 (
-                    procPatch.patchSlice(faceAddressing_),
-                    completeMesh_.boundaryMesh()[completePatchi].start()
-                )
-            );
-        }
-
-        // If this is a processor patch then create a processor mapper
-        if (procPatchi >= completeMesh_.boundary().size())
-        {
-            processorVolPatchFieldDecomposers_.set
-            (
-                procPatchi,
-                new processorVolPatchFieldDecomposer
-                (
-                    completeMesh_,
-                    procPatch.patchSlice(faceAddressing_)
+                    faceAddressingBf[completePatchi]
                 )
             );
         }
diff --git a/applications/utilities/parallelProcessing/decomposePar/fvFieldDecomposer.H b/applications/utilities/parallelProcessing/decomposePar/fvFieldDecomposer.H
index 14353de445..8b1ddfc73d 100644
--- a/applications/utilities/parallelProcessing/decomposePar/fvFieldDecomposer.H
+++ b/applications/utilities/parallelProcessing/decomposePar/fvFieldDecomposer.H
@@ -63,52 +63,12 @@ public:
             public labelList,
             public directFvPatchFieldMapper
         {
-            // Private Member Functions
-
-                labelList alignAddressing
-                (
-                    const labelUList& addressingSlice,
-                    const label addressingOffset
-                ) const;
-
-
         public:
 
             // Constructors
 
                 //- Construct given addressing
-                patchFieldDecomposer
-                (
-                    const labelUList& addressingSlice,
-                    const label addressingOffset
-                );
-        };
-
-        //- Processor patch field decomposer class. Maps either owner or
-        //  neighbour data (no interpolate anymore - processorFvPatchField
-        //  holds neighbour data)
-        class processorVolPatchFieldDecomposer
-        :
-            public labelList,
-            public directFvPatchFieldMapper
-        {
-            // Private Member Functions
-
-                labelList alignAddressing
-                (
-                    const fvMesh& mesh,
-                    const labelUList& addressingSlice
-                ) const;
-
-
-        public:
-
-            //- Construct given addressing
-            processorVolPatchFieldDecomposer
-            (
-                const fvMesh& mesh,
-                const labelUList& addressingSlice
-            );
+                patchFieldDecomposer(const labelUList& addressing);
         };
 
 
@@ -128,23 +88,35 @@ private:
         //- Reference to cell addressing
         const labelList& cellAddressing_;
 
+        //- Reference to face addressing boundary field
+        const surfaceLabelField::Boundary& faceAddressingBf_;
+
         //- List of patch field decomposers
         PtrList<patchFieldDecomposer> patchFieldDecomposers_;
 
-        //- ...
-        PtrList<processorVolPatchFieldDecomposer>
-            processorVolPatchFieldDecomposers_;
-
 
     // Private Member Functions
 
-        //- Helper: map & optionally flip a (face) field
+        //- Convert a processor patch to the corresponding complete patch index
+        label completePatchID(const label procPatchi) const;
+
+        //- Map cell values to faces
         template<class Type>
-        static tmp<Field<Type>> mapField
+        static tmp<Field<Type>> mapCellToFace
+        (
+            const labelUList& owner,
+            const labelUList& neighbour,
+            const Field<Type>& field,
+            const labelUList& addressing
+        );
+
+        //- Map face values to faces
+        template<class Type>
+        static tmp<Field<Type>> mapFaceToFace
         (
             const Field<Type>& field,
-            const labelUList& mapAndSign,
-            const bool applyFlip
+            const labelUList& addressing,
+            const bool isFlux
         );
 
 
@@ -158,7 +130,8 @@ public:
             const fvMesh& completeMesh,
             const fvMesh& procMesh,
             const labelList& faceAddressing,
-            const labelList& cellAddressing
+            const labelList& cellAddressing,
+            const surfaceLabelField::Boundary& faceAddressingBf
         );
 
         //- Disallow default bitwise copy construction
diff --git a/applications/utilities/parallelProcessing/decomposePar/fvFieldDecomposerDecomposeFields.C b/applications/utilities/parallelProcessing/decomposePar/fvFieldDecomposerDecomposeFields.C
index acc808e5a7..210c00dc88 100644
--- a/applications/utilities/parallelProcessing/decomposePar/fvFieldDecomposerDecomposeFields.C
+++ b/applications/utilities/parallelProcessing/decomposePar/fvFieldDecomposerDecomposeFields.C
@@ -33,35 +33,50 @@ License
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 template<class Type>
-Foam::tmp<Foam::Field<Type>> Foam::fvFieldDecomposer::mapField
+Foam::tmp<Foam::Field<Type>> Foam::fvFieldDecomposer::mapCellToFace
 (
+    const labelUList& owner,
+    const labelUList& neighbour,
     const Field<Type>& field,
-    const labelUList& mapAndSign,
-    const bool applyFlip
+    const labelUList& addressing
 )
 {
-    tmp<Field<Type>> tfld(new Field<Type>(mapAndSign.size()));
+    tmp<Field<Type>> tfld(new Field<Type>(addressing.size()));
     Field<Type>& fld = tfld.ref();
 
-    if (applyFlip)
+    forAll(addressing, i)
     {
-        forAll(mapAndSign, i)
-        {
-            if (mapAndSign[i] < 0)
-            {
-                fld[i] = -field[-mapAndSign[i] - 1];
-            }
-            else
-            {
-                fld[i] = field[mapAndSign[i] - 1];
-            }
-        }
+        fld[i] =
+            field
+            [
+                addressing[i] > 0
+              ? neighbour[addressing[i] - 1]
+              : owner[- addressing[i] + 1]
+            ];
     }
-    else
+
+    return tfld;
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type>> Foam::fvFieldDecomposer::mapFaceToFace
+(
+    const Field<Type>& field,
+    const labelUList& addressing,
+    const bool isFlux
+)
+{
+    tmp<Field<Type>> tfld(new Field<Type>(addressing.size()));
+    Field<Type>& fld = tfld.ref();
+
+    forAll(addressing, i)
     {
-        // Ignore face flipping
-        fld.map(field, mag(mapAndSign) - 1);
+        fld[i] =
+            (isFlux && addressing[i] < 0 ? -1 : +1)
+           *field[mag(addressing[i]) - 1];
     }
+
     return tfld;
 }
 
@@ -74,9 +89,8 @@ Foam::fvFieldDecomposer::decomposeField
     const bool allowUnknownPatchFields
 ) const
 {
-    // 1. Create the complete field with dummy patch fields
+    // Create dummy patch fields
     PtrList<fvPatchField<Type>> patchFields(procMesh_.boundary().size());
-
     forAll(procMesh_.boundary(), procPatchi)
     {
         patchFields.set
@@ -91,7 +105,7 @@ Foam::fvFieldDecomposer::decomposeField
         );
     }
 
-    // Create the field for the processor
+    // Create the processor field with the dummy patch fields
     tmp<GeometricField<Type, fvPatchField, volMesh>> tresF
     (
         new GeometricField<Type, fvPatchField, volMesh>
@@ -113,35 +127,17 @@ Foam::fvFieldDecomposer::decomposeField
     );
     GeometricField<Type, fvPatchField, volMesh>& resF = tresF.ref();
 
-
-    // 2. Change the fvPatchFields to the correct type using a mapper
-    //  constructor (with reference to the now correct internal field)
-
+    // Change the patch fields to the correct type using a mapper constructor
+    // (with reference to the now correct internal field)
     typename GeometricField<Type, fvPatchField, volMesh>::
         Boundary& bf = resF.boundaryFieldRef();
-
     forAll(bf, procPatchi)
     {
         const fvPatch& procPatch = procMesh_.boundary()[procPatchi];
 
-        // Determine the index of the corresponding complete patch
-        label completePatchi = -1;
-        if (procPatchi < completeMesh_.boundary().size())
-        {
-            completePatchi = procPatchi;
-        }
-        else if (isA<processorCyclicFvPatch>(procPatch))
-        {
-            const label referPatchi =
-                refCast<const processorCyclicPolyPatch>
-                (procPatch.patch()).referPatchID();
-            if (field.boundaryField()[referPatchi].overridesConstraint())
-            {
-                completePatchi = referPatchi;
-            }
-        }
+        const label completePatchi = completePatchID(procPatchi);
 
-        if (completePatchi != -1)
+        if (completePatchi == procPatchi)
         {
             bf.set
             (
@@ -157,6 +153,10 @@ Foam::fvFieldDecomposer::decomposeField
         }
         else if (isA<processorCyclicFvPatch>(procPatch))
         {
+            const label nbrCompletePatchi =
+                refCast<const processorCyclicFvPatch>(procPatch)
+               .referPatch().nbrPatchID();
+
             bf.set
             (
                 procPatchi,
@@ -164,9 +164,12 @@ Foam::fvFieldDecomposer::decomposeField
                 (
                     procPatch,
                     resF(),
-                    processorVolPatchFieldDecomposers_[procPatchi]
+                    mapCellToFace
                     (
-                        field.primitiveField()
+                        labelUList(),
+                        completeMesh_.lduAddr().patchAddr(nbrCompletePatchi),
+                        field.primitiveField(),
+                        faceAddressingBf_[procPatchi]
                     )
                 )
             );
@@ -180,9 +183,12 @@ Foam::fvFieldDecomposer::decomposeField
                 (
                     procPatch,
                     resF(),
-                    processorVolPatchFieldDecomposers_[procPatchi]
+                    mapCellToFace
                     (
-                        field.primitiveField()
+                        completeMesh_.owner(),
+                        completeMesh_.neighbour(),
+                        field.primitiveField(),
+                        faceAddressingBf_[procPatchi]
                     )
                 )
             );
@@ -206,7 +212,6 @@ Foam::fvFieldDecomposer::decomposeField
         }
     }
 
-    // Create the field for the processor
     return tresF;
 }
 
@@ -218,34 +223,14 @@ Foam::fvFieldDecomposer::decomposeField
     const GeometricField<Type, fvsPatchField, surfaceMesh>& field
 ) const
 {
-    // Problem with addressing when a processor patch picks up both internal
-    // faces and faces from cyclic boundaries. This is a bit of a hack, but
-    // I cannot find a better solution without making the internal storage
-    // mechanism for surfaceFields correspond to the one of faces in polyMesh
-    // (i.e. using slices)
-    Field<Type> allFaceField(field.mesh().nFaces());
+    const SubList<label> faceAddressingIf
+    (
+        faceAddressing_,
+        procMesh_.nInternalFaces()
+    );
 
-    forAll(field.primitiveField(), i)
-    {
-        allFaceField[i] = field.primitiveField()[i];
-    }
-
-    forAll(field.boundaryField(), patchi)
-    {
-        const Field<Type> & p = field.boundaryField()[patchi];
-
-        const label patchStart = field.mesh().boundaryMesh()[patchi].start();
-
-        forAll(p, i)
-        {
-            allFaceField[patchStart + i] = p[i];
-        }
-    }
-
-
-    // 1. Create the complete field with dummy patch fields
+    // Create dummy patch fields
     PtrList<fvsPatchField<Type>> patchFields(procMesh_.boundary().size());
-
     forAll(procMesh_.boundary(), procPatchi)
     {
         patchFields.set
@@ -260,6 +245,7 @@ Foam::fvFieldDecomposer::decomposeField
         );
     }
 
+    // Create the processor field with the dummy patch fields
     tmp<GeometricField<Type, fvsPatchField, surfaceMesh>> tresF
     (
         new GeometricField<Type, fvsPatchField, surfaceMesh>
@@ -275,14 +261,10 @@ Foam::fvFieldDecomposer::decomposeField
             ),
             procMesh_,
             field.dimensions(),
-            mapField
+            mapFaceToFace
             (
                 field,
-                labelList::subList
-                (
-                    faceAddressing_,
-                    procMesh_.nInternalFaces()
-                ),
+                faceAddressingIf,
                 isFlux(field)
             ),
             patchFields
@@ -290,18 +272,17 @@ Foam::fvFieldDecomposer::decomposeField
     );
     GeometricField<Type, fvsPatchField, surfaceMesh>& resF = tresF.ref();
 
-
-    // 2. Change the fvsPatchFields to the correct type using a mapper
-    //  constructor (with reference to the now correct internal field)
-
+    // Change the patch fields to the correct type using a mapper constructor
+    // (with reference to the now correct internal field)
     typename GeometricField<Type, fvsPatchField, surfaceMesh>::
         Boundary& bf = resF.boundaryFieldRef();
-
     forAll(procMesh_.boundary(), procPatchi)
     {
         const fvPatch& procPatch = procMesh_.boundary()[procPatchi];
 
-        if (procPatchi < completeMesh_.boundary().size())
+        const label completePatchi = completePatchID(procPatchi);
+
+        if (completePatchi == procPatchi)
         {
             bf.set
             (
@@ -317,7 +298,6 @@ Foam::fvFieldDecomposer::decomposeField
         }
         else if (isA<processorCyclicFvPatch>(procPatch))
         {
-            // Do our own mapping. Avoids a lot of mapping complexity.
             bf.set
             (
                 procPatchi,
@@ -325,10 +305,10 @@ Foam::fvFieldDecomposer::decomposeField
                 (
                     procPatch,
                     resF(),
-                    mapField
+                    mapFaceToFace
                     (
-                        allFaceField,
-                        procPatch.patchSlice(faceAddressing_),
+                        field.boundaryField()[completePatchi],
+                        faceAddressingBf_[procPatchi],
                         isFlux(field)
                     )
                 )
@@ -336,7 +316,6 @@ Foam::fvFieldDecomposer::decomposeField
         }
         else if (isA<processorFvPatch>(procPatch))
         {
-            // Do our own mapping. Avoids a lot of mapping complexity.
             bf.set
             (
                 procPatchi,
@@ -344,10 +323,10 @@ Foam::fvFieldDecomposer::decomposeField
                 (
                     procPatch,
                     resF(),
-                    mapField
+                    mapFaceToFace
                     (
-                        allFaceField,
-                        procPatch.patchSlice(faceAddressing_),
+                        field.primitiveField(),
+                        faceAddressingBf_[procPatchi],
                         isFlux(field)
                     )
                 )
@@ -360,7 +339,6 @@ Foam::fvFieldDecomposer::decomposeField
         }
     }
 
-    // Create the field for the processor
     return tresF;
 }
 
diff --git a/applications/utilities/parallelProcessing/reconstructPar/Make/files b/applications/utilities/parallelProcessing/reconstructPar/Make/files
index 37acabe62d..b0c0918a4b 100644
--- a/applications/utilities/parallelProcessing/reconstructPar/Make/files
+++ b/applications/utilities/parallelProcessing/reconstructPar/Make/files
@@ -1,3 +1,6 @@
 reconstructPar.C
+fvFieldReconstructor.C
+pointFieldReconstructor.C
+reconstructLagrangianPositions.C
 
 EXE = $(FOAM_APPBIN)/reconstructPar
diff --git a/applications/utilities/parallelProcessing/reconstructPar/Make/options b/applications/utilities/parallelProcessing/reconstructPar/Make/options
index 1ebb8c02d3..40c6a86df5 100644
--- a/applications/utilities/parallelProcessing/reconstructPar/Make/options
+++ b/applications/utilities/parallelProcessing/reconstructPar/Make/options
@@ -1,16 +1,14 @@
 EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
-    -I$(LIB_SRC)/lagrangian/basic/lnInclude \
-    -I$(LIB_SRC)/dynamicMesh/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
-    -I$(LIB_SRC)/parallel/reconstruct/reconstruct/lnInclude \
+    -I$(LIB_SRC)/parallel/parallel/lnInclude \
+    -I$(LIB_SRC)/lagrangian/basic/lnInclude \
     -I$(LIB_SRC)/regionModels/regionModel/lnInclude
 
 EXE_LIBS = \
     -lfiniteVolume \
-    -lgenericPatchFields \
-    -llagrangian \
-    -ldynamicMesh \
     -lmeshTools \
-    -lreconstruct \
-    -lregionModels
+    -lparallel \
+    -llagrangian \
+    -lregionModels \
+    -lgenericPatchFields
diff --git a/applications/utilities/parallelProcessing/reconstructPar/checkFaceAddressingComp.H b/applications/utilities/parallelProcessing/reconstructPar/checkFaceAddressingComp.H
deleted file mode 100644
index 0c2378b349..0000000000
--- a/applications/utilities/parallelProcessing/reconstructPar/checkFaceAddressingComp.H
+++ /dev/null
@@ -1,48 +0,0 @@
-{
-    // Foam version 2.1 changes the addressing of faces in faceProcAddressing
-    // The following code checks and modifies the addressing for cases where
-    // the decomposition has been done with the foam2.0 and earlier tools, but
-    // the reconstruction is attempted with version 2.1 or later
-
-    label minFaceIndex = labelMax;
-
-    PtrList<labelIOList>& faceProcAddressing = procMeshes.faceProcAddressing();
-
-    forAll(faceProcAddressing, proci)
-    {
-        const labelList& curFaceAddr = faceProcAddressing[proci];
-
-        forAll(curFaceAddr, facei)
-        {
-            if (mag(curFaceAddr[facei]) < minFaceIndex)
-            {
-                minFaceIndex = mag(curFaceAddr[facei]);
-            }
-        }
-    }
-
-    if (minFaceIndex < 1)
-    {
-        WarningInFunction
-            << "parallel decomposition addressing." << endl
-            << "It looks like you are trying to reconstruct the case "
-            << "decomposed with an earlier version of FOAM, which could\n"
-            << "potentially cause compatibility problems.  The code will "
-            << "attempt to update the addressing automatically; in case of\n"
-            << "failure, please repeat the decomposition of the case using "
-            << "the current version fo decomposePar"
-            << endl;
-
-        forAll(faceProcAddressing, proci)
-        {
-            labelList& curFaceAddr = faceProcAddressing[proci];
-
-            forAll(curFaceAddr, facei)
-            {
-                curFaceAddr[facei] += sign(curFaceAddr[facei]);
-            }
-
-            faceProcAddressing[proci].write();
-        }
-    }
-}
diff --git a/src/parallel/reconstruct/reconstruct/fvFieldReconstructor.C b/applications/utilities/parallelProcessing/reconstructPar/fvFieldReconstructor.C
similarity index 73%
rename from src/parallel/reconstruct/reconstruct/fvFieldReconstructor.C
rename to applications/utilities/parallelProcessing/reconstructPar/fvFieldReconstructor.C
index 0541f4f8bc..fb713410f5 100644
--- a/src/parallel/reconstruct/reconstruct/fvFieldReconstructor.C
+++ b/applications/utilities/parallelProcessing/reconstructPar/fvFieldReconstructor.C
@@ -24,26 +24,55 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "fvFieldReconstructor.H"
+#include "processorCyclicFvPatch.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+Foam::label Foam::fvFieldReconstructor::completePatchID
+(
+    const label proci,
+    const label procPatchi
+) const
+{
+    const fvPatch& procPatch = procMeshes_[proci].boundary()[procPatchi];
+
+    if (procPatchi < completeMesh_.boundary().size())
+    {
+        return procPatchi;
+    }
+    else if (isA<processorCyclicFvPatch>(procPatch))
+    {
+        return refCast<const processorCyclicFvPatch>(procPatch).referPatchID();
+    }
+    else
+    {
+        return -1;
+    }
+}
+
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 Foam::fvFieldReconstructor::fvFieldReconstructor
 (
-    fvMesh& mesh,
+    const fvMesh& completeMesh,
     const PtrList<fvMesh>& procMeshes,
-    const PtrList<labelIOList>& faceProcAddressing,
-    const PtrList<labelIOList>& cellProcAddressing
+    const labelListList& faceProcAddressing,
+    const labelListList& cellProcAddressing,
+    const PtrList<surfaceLabelField::Boundary>& faceProcAddressingBf
 )
 :
-    mesh_(mesh),
+    completeMesh_(completeMesh),
     procMeshes_(procMeshes),
     faceProcAddressing_(faceProcAddressing),
     cellProcAddressing_(cellProcAddressing),
+    faceProcAddressingBf_(faceProcAddressingBf),
     nReconstructed_(0)
 {
     forAll(procMeshes_, proci)
     {
         const fvMesh& procMesh = procMeshes_[proci];
+
         if
         (
             faceProcAddressing[proci].size() != procMesh.nFaces()
diff --git a/src/parallel/reconstruct/reconstruct/fvFieldReconstructor.H b/applications/utilities/parallelProcessing/reconstructPar/fvFieldReconstructor.H
similarity index 86%
rename from src/parallel/reconstruct/reconstruct/fvFieldReconstructor.H
rename to applications/utilities/parallelProcessing/reconstructPar/fvFieldReconstructor.H
index 20c799c958..1bc66623b6 100644
--- a/src/parallel/reconstruct/reconstruct/fvFieldReconstructor.H
+++ b/applications/utilities/parallelProcessing/reconstructPar/fvFieldReconstructor.H
@@ -37,7 +37,7 @@ SourceFiles
 #define fvFieldReconstructor_H
 
 #include "PtrList.H"
-#include "fvMesh.H"
+#include "surfaceFields.H"
 #include "IOobjectList.H"
 #include "fvPatchFieldMapper.H"
 #include "setSizeFieldMapper.H"
@@ -58,21 +58,40 @@ class fvFieldReconstructor
     // Private Data
 
         //- Reconstructed mesh reference
-        fvMesh& mesh_;
+        const fvMesh& completeMesh_;
 
         //- List of processor meshes
         const PtrList<fvMesh>& procMeshes_;
 
         //- List of processor face addressing lists
-        const PtrList<labelIOList>& faceProcAddressing_;
+        const labelListList& faceProcAddressing_;
 
         //- List of processor cell addressing lists
-        const PtrList<labelIOList>& cellProcAddressing_;
+        const labelListList& cellProcAddressing_;
+
+        //- Boundary field of face addressing
+        const PtrList<surfaceLabelField::Boundary>& faceProcAddressingBf_;
 
         //- Number of fields reconstructed
         label nReconstructed_;
 
 
+    // Private Member Functions
+
+        //- Convert a processor patch to the corresponding complete patch index
+        label completePatchID(const label proci, const label procPatchi) const;
+
+        //- ...
+        template<class Type>
+        static void rmapFaceToFace
+        (
+            Field<Type>& toField,
+            const Field<Type>& fromField,
+            const labelUList& addressing,
+            const bool isFlux
+        );
+
+
 public:
 
         //- Mapper for sizing only - does not do any actual mapping.
@@ -98,10 +117,11 @@ public:
         //- Construct from components
         fvFieldReconstructor
         (
-            fvMesh& mesh,
+            const fvMesh& mesh,
             const PtrList<fvMesh>& procMeshes,
-            const PtrList<labelIOList>& faceProcAddressing,
-            const PtrList<labelIOList>& cellProcAddressing
+            const labelListList& faceProcAddressing,
+            const labelListList& cellProcAddressing,
+            const PtrList<surfaceLabelField::Boundary>& faceProcAddressingBf
         );
 
         //- Disallow default bitwise copy construction
diff --git a/src/parallel/reconstruct/reconstruct/fvFieldReconstructorReconstructFields.C b/applications/utilities/parallelProcessing/reconstructPar/fvFieldReconstructorReconstructFields.C
similarity index 51%
rename from src/parallel/reconstruct/reconstruct/fvFieldReconstructorReconstructFields.C
rename to applications/utilities/parallelProcessing/reconstructPar/fvFieldReconstructorReconstructFields.C
index 50b0bf6823..faef572bc3 100644
--- a/src/parallel/reconstruct/reconstruct/fvFieldReconstructorReconstructFields.C
+++ b/applications/utilities/parallelProcessing/reconstructPar/fvFieldReconstructorReconstructFields.C
@@ -30,6 +30,26 @@ License
 #include "emptyFvPatch.H"
 #include "emptyFvPatchField.H"
 #include "emptyFvsPatchField.H"
+#include "processorCyclicFvPatch.H"
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+void Foam::fvFieldReconstructor::rmapFaceToFace
+(
+    Field<Type>& toField,
+    const Field<Type>& fromField,
+    const labelUList& addressing,
+    const bool isFlux
+)
+{
+    forAll(addressing, i)
+    {
+        toField[mag(addressing[i]) - 1] =
+            (isFlux && addressing[i] < 0 ? -1 : +1)*fromField[i];
+    }
+}
+
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
@@ -42,7 +62,7 @@ Foam::fvFieldReconstructor::reconstructFvVolumeInternalField
 ) const
 {
     // Create the internalField
-    Field<Type> internalField(mesh_.nCells());
+    Field<Type> internalField(completeMesh_.nCells());
 
     forAll(procMeshes_, proci)
     {
@@ -61,7 +81,7 @@ Foam::fvFieldReconstructor::reconstructFvVolumeInternalField
         new DimensionedField<Type, volMesh>
         (
             fieldIoObject,
-            mesh_,
+            completeMesh_,
             procFields[0].dimensions(),
             internalField
         )
@@ -76,11 +96,8 @@ Foam::fvFieldReconstructor::reconstructFvVolumeInternalField
     const IOobject& fieldIoObject
 ) const
 {
-    // Read the field for all the processors
-    PtrList<DimensionedField<Type, volMesh>> procFields
-    (
-        procMeshes_.size()
-    );
+    PtrList<DimensionedField<Type, volMesh>>
+        procFields(procMeshes_.size());
 
     forAll(procMeshes_, proci)
     {
@@ -103,14 +120,13 @@ Foam::fvFieldReconstructor::reconstructFvVolumeInternalField
         );
     }
 
-
     return reconstructFvVolumeInternalField
     (
         IOobject
         (
             fieldIoObject.name(),
-            mesh_.time().timeName(),
-            mesh_,
+            completeMesh_.time().timeName(),
+            completeMesh_,
             IOobject::NO_READ,
             IOobject::NO_WRITE,
             false
@@ -129,10 +145,10 @@ Foam::fvFieldReconstructor::reconstructFvVolumeField
 ) const
 {
     // Create the internalField
-    Field<Type> internalField(mesh_.nCells());
+    Field<Type> internalField(completeMesh_.nCells());
 
     // Create the patch fields
-    PtrList<fvPatchField<Type>> patchFields(mesh_.boundary().size());
+    PtrList<fvPatchField<Type>> patchFields(completeMesh_.boundary().size());
 
     forAll(procFields, proci)
     {
@@ -147,150 +163,71 @@ Foam::fvFieldReconstructor::reconstructFvVolumeField
         );
 
         // Set the boundary patch values in the reconstructed field
-        forAll(procField.boundaryField(), patchi)
+        forAll(procField.boundaryField(), procPatchi)
         {
-            // Get patch index of the original patch
-            const label curBPatch =
-                patchi < mesh_.boundary().size() ? patchi : -1;
+            const fvPatch& procPatch =
+                procMeshes_[proci].boundary()[procPatchi];
 
-            // Get addressing slice for this patch
-            const labelList::subList cp =
-                procField.mesh().boundary()[patchi].patchSlice
-                (
-                    faceProcAddressing_[proci]
-                );
+            const label completePatchi = completePatchID(proci, procPatchi);
 
-            // check if the boundary patch is not a processor patch
-            if (curBPatch != -1)
+            if (completePatchi == procPatchi)
             {
-                // Regular patch. Fast looping
-
-                if (!patchFields(curBPatch))
+                if (!patchFields(completePatchi))
                 {
                     patchFields.set
                     (
-                        curBPatch,
+                        completePatchi,
                         fvPatchField<Type>::New
                         (
-                            procField.boundaryField()[patchi],
-                            mesh_.boundary()[curBPatch],
+                            procField.boundaryField()[procPatchi],
+                            completeMesh_.boundary()[completePatchi],
                             DimensionedField<Type, volMesh>::null(),
                             fvPatchFieldReconstructor
                             (
-                                mesh_.boundary()[curBPatch].size()
+                                completeMesh_.boundary()[completePatchi].size()
                             )
                         )
                     );
                 }
 
-                const label curPatchStart =
-                    mesh_.boundaryMesh()[curBPatch].start();
-
-                labelList reverseAddressing(cp.size());
-
-                forAll(cp, facei)
-                {
-                    // Check
-                    if (cp[facei] <= 0)
-                    {
-                        FatalErrorInFunction
-                            << "Processor " << proci
-                            << " patch "
-                            << procField.mesh().boundary()[patchi].name()
-                            << " face " << facei
-                            << " originates from reversed face since "
-                            << cp[facei]
-                            << exit(FatalError);
-                    }
-
-                    // Subtract one to take into account offsets for
-                    // face direction.
-                    reverseAddressing[facei] = cp[facei] - 1 - curPatchStart;
-                }
-
-
-                patchFields[curBPatch].rmap
+                patchFields[completePatchi].rmap
                 (
-                    procField.boundaryField()[patchi],
-                    reverseAddressing
+                    procField.boundaryField()[procPatchi],
+                    faceProcAddressingBf_[proci][procPatchi] - 1
                 );
             }
-            else
+            else if (isA<processorCyclicFvPatch>(procPatch))
             {
-                const Field<Type>& curProcPatch =
-                    procField.boundaryField()[patchi];
-
-                // In processor patches, there's a mix of internal faces (some
-                // of them turned) and possible cyclics. Slow loop
-                forAll(cp, facei)
+                if (!patchFields(completePatchi))
                 {
-                    // Subtract one to take into account offsets for
-                    // face direction.
-                    label curF = cp[facei] - 1;
-
-                    // Is the face on the boundary?
-                    if (curF >= mesh_.nInternalFaces())
-                    {
-                        label curBPatch = mesh_.boundaryMesh().whichPatch(curF);
-
-                        if (!patchFields(curBPatch))
-                        {
-                            patchFields.set
-                            (
-                                curBPatch,
-                                fvPatchField<Type>::New
-                                (
-                                    mesh_.boundary()[curBPatch].type(),
-                                    mesh_.boundary()[curBPatch],
-                                    DimensionedField<Type, volMesh>::null()
-                                )
-                            );
-                        }
-
-                        // add the face
-                        label curPatchFace =
-                            mesh_.boundaryMesh()
-                                [curBPatch].whichFace(curF);
-
-                        patchFields[curBPatch][curPatchFace] =
-                            curProcPatch[facei];
-                    }
+                    patchFields.set
+                    (
+                        completePatchi,
+                        fvPatchField<Type>::New
+                        (
+                            completeMesh_.boundary()[completePatchi].type(),
+                            completeMesh_.boundary()[completePatchi],
+                            DimensionedField<Type, volMesh>::null()
+                        )
+                    );
                 }
+
+                patchFields[completePatchi].rmap
+                (
+                    procField.boundaryField()[procPatchi],
+                    faceProcAddressingBf_[proci][procPatchi] - 1
+                );
             }
         }
     }
 
-    forAll(mesh_.boundary(), patchi)
-    {
-        // add empty patches
-        if
-        (
-            isType<emptyFvPatch>(mesh_.boundary()[patchi])
-         && !patchFields(patchi)
-        )
-        {
-            patchFields.set
-            (
-                patchi,
-                fvPatchField<Type>::New
-                (
-                    emptyFvPatchField<Type>::typeName,
-                    mesh_.boundary()[patchi],
-                    DimensionedField<Type, volMesh>::null()
-                )
-            );
-        }
-    }
-
-
-    // Now construct and write the field
-    // setting the internalField and patchFields
+    // Construct and return the field
     return tmp<GeometricField<Type, fvPatchField, volMesh>>
     (
         new GeometricField<Type, fvPatchField, volMesh>
         (
             fieldIoObject,
-            mesh_,
+            completeMesh_,
             procFields[0].dimensions(),
             internalField,
             patchFields
@@ -306,11 +243,8 @@ Foam::fvFieldReconstructor::reconstructFvVolumeField
     const IOobject& fieldIoObject
 ) const
 {
-    // Read the field for all the processors
-    PtrList<GeometricField<Type, fvPatchField, volMesh>> procFields
-    (
-        procMeshes_.size()
-    );
+    PtrList<GeometricField<Type, fvPatchField, volMesh>>
+        procFields(procMeshes_.size());
 
     forAll(procMeshes_, proci)
     {
@@ -338,8 +272,8 @@ Foam::fvFieldReconstructor::reconstructFvVolumeField
         IOobject
         (
             fieldIoObject.name(),
-            mesh_.time().timeName(),
-            mesh_,
+            completeMesh_.time().timeName(),
+            completeMesh_,
             IOobject::NO_READ,
             IOobject::NO_WRITE,
             false
@@ -358,194 +292,105 @@ Foam::fvFieldReconstructor::reconstructFvSurfaceField
 ) const
 {
     // Create the internalField
-    Field<Type> internalField(mesh_.nInternalFaces());
+    Field<Type> internalField(completeMesh_.nInternalFaces());
 
     // Create the patch fields
-    PtrList<fvsPatchField<Type>> patchFields(mesh_.boundary().size());
-
+    PtrList<fvsPatchField<Type>> patchFields(completeMesh_.boundary().size());
 
     forAll(procMeshes_, proci)
     {
         const GeometricField<Type, fvsPatchField, surfaceMesh>& procField =
             procFields[proci];
 
-        // Set the face values in the reconstructed field
-
-        if (pTraits<Type>::nComponents == 1)
-        {
-            // Assume all scalar surfaceFields are oriented flux fields
-            const labelList& faceMap = faceProcAddressing_[proci];
-
-            // Correctly oriented copy of internal field
-            Field<Type> procInternalField(procField.primitiveField());
-
-            // Addressing into original field
-            // It is necessary to create a copy of the addressing array to
-            // take care of the face direction offset trick.
-            labelList curAddr(procInternalField.size());
-
-            forAll(procInternalField, i)
-            {
-                curAddr[i] = mag(faceMap[i]) - 1;
-                if (faceMap[i] < 0)
-                {
-                    procInternalField[i] = -procInternalField[i];
-                }
-            }
-
-            // Map
-            internalField.rmap(procInternalField, curAddr);
-        }
-        else
-        {
-            // Map
-            internalField.rmap
+        // Set the internal face values in the reconstructed field
+        rmapFaceToFace
+        (
+            internalField,
+            procField.primitiveField(),
+            SubList<label>
             (
-                procField.primitiveField(),
-                mag(labelField(faceProcAddressing_[proci])) - 1
-            );
-        }
+                faceProcAddressing_[proci],
+                procMeshes_[proci].nInternalFaces()
+            ),
+            isFlux(procFields[proci])
+        );
 
         // Set the boundary patch values in the reconstructed field
-        forAll(procField.boundaryField(), patchi)
+        forAll(procField.boundaryField(), procPatchi)
         {
-            // Get patch index of the original patch
-            const label curBPatch =
-                patchi < mesh_.boundary().size() ? patchi : -1;
+            const fvPatch& procPatch =
+                procMeshes_[proci].boundary()[procPatchi];
 
-            // Get addressing slice for this patch
-            const labelList::subList cp =
-                procMeshes_[proci].boundary()[patchi].patchSlice
-                (
-                    faceProcAddressing_[proci]
-                );
+            const label completePatchi = completePatchID(proci, procPatchi);
 
-            // check if the boundary patch is not a processor patch
-            if (curBPatch != -1)
+            if (completePatchi == procPatchi)
             {
-                // Regular patch. Fast looping
-
-                if (!patchFields(curBPatch))
+                if (!patchFields(completePatchi))
                 {
                     patchFields.set
                     (
-                        curBPatch,
+                        completePatchi,
                         fvsPatchField<Type>::New
                         (
-                            procField.boundaryField()[patchi],
-                            mesh_.boundary()[curBPatch],
+                            procField.boundaryField()[procPatchi],
+                            completeMesh_.boundary()[completePatchi],
                             DimensionedField<Type, surfaceMesh>::null(),
                             fvPatchFieldReconstructor
                             (
-                                mesh_.boundary()[curBPatch].size()
+                                completeMesh_.boundary()[completePatchi].size()
                             )
                         )
                     );
                 }
 
-                const label curPatchStart =
-                    mesh_.boundaryMesh()[curBPatch].start();
-
-                labelList reverseAddressing(cp.size());
-
-                forAll(cp, facei)
-                {
-                    // Subtract one to take into account offsets for
-                    // face direction.
-                    reverseAddressing[facei] = cp[facei] - 1 - curPatchStart;
-                }
-
-                patchFields[curBPatch].rmap
+                patchFields[completePatchi].rmap
                 (
-                    procField.boundaryField()[patchi],
-                    reverseAddressing
+                    procField.boundaryField()[procPatchi],
+                    faceProcAddressingBf_[proci][procPatchi] - 1
                 );
             }
-            else
+            else if (isA<processorCyclicFvPatch>(procPatch))
             {
-                const Field<Type>& curProcPatch =
-                    procField.boundaryField()[patchi];
-
-                // In processor patches, there's a mix of internal faces (some
-                // of them turned) and possible cyclics. Slow loop
-                forAll(cp, facei)
+                if (!patchFields(completePatchi))
                 {
-                    label curF = cp[facei] - 1;
-
-                    // Is the face turned the right side round
-                    if (curF >= 0)
-                    {
-                        // Is the face on the boundary?
-                        if (curF >= mesh_.nInternalFaces())
-                        {
-                            label curBPatch =
-                                mesh_.boundaryMesh().whichPatch(curF);
-
-                            if (!patchFields(curBPatch))
-                            {
-                                patchFields.set
-                                (
-                                    curBPatch,
-                                    fvsPatchField<Type>::New
-                                    (
-                                        mesh_.boundary()[curBPatch].type(),
-                                        mesh_.boundary()[curBPatch],
-                                        DimensionedField<Type, surfaceMesh>
-                                           ::null()
-                                    )
-                                );
-                            }
-
-                            // add the face
-                            label curPatchFace =
-                                mesh_.boundaryMesh()
-                                [curBPatch].whichFace(curF);
-
-                            patchFields[curBPatch][curPatchFace] =
-                                curProcPatch[facei];
-                        }
-                        else
-                        {
-                            // Internal face
-                            internalField[curF] = curProcPatch[facei];
-                        }
-                    }
+                    patchFields.set
+                    (
+                        completePatchi,
+                        fvsPatchField<Type>::New
+                        (
+                            completeMesh_.boundary()[completePatchi].type(),
+                            completeMesh_.boundary()[completePatchi],
+                            DimensionedField<Type, surfaceMesh>::null()
+                        )
+                    );
                 }
+
+                patchFields[completePatchi].rmap
+                (
+                    procField.boundaryField()[procPatchi],
+                    faceProcAddressingBf_[proci][procPatchi] - 1
+                );
+            }
+            else if (isA<processorFvPatch>(procPatch))
+            {
+                rmapFaceToFace
+                (
+                    internalField,
+                    procField.boundaryField()[procPatchi],
+                    faceProcAddressingBf_[proci][procPatchi],
+                    isFlux(procFields[proci])
+                );
             }
         }
     }
 
-    forAll(mesh_.boundary(), patchi)
-    {
-        // add empty patches
-        if
-        (
-            isType<emptyFvPatch>(mesh_.boundary()[patchi])
-         && !patchFields(patchi)
-        )
-        {
-            patchFields.set
-            (
-                patchi,
-                fvsPatchField<Type>::New
-                (
-                    emptyFvsPatchField<Type>::typeName,
-                    mesh_.boundary()[patchi],
-                    DimensionedField<Type, surfaceMesh>::null()
-                )
-            );
-        }
-    }
-
-
-    // Now construct and write the field
-    // setting the internalField and patchFields
+    // Construct and return the field
     return tmp<GeometricField<Type, fvsPatchField, surfaceMesh>>
     (
         new GeometricField<Type, fvsPatchField, surfaceMesh>
         (
             fieldIoObject,
-            mesh_,
+            completeMesh_,
             procFields[0].dimensions(),
             internalField,
             patchFields
@@ -561,11 +406,8 @@ Foam::fvFieldReconstructor::reconstructFvSurfaceField
     const IOobject& fieldIoObject
 ) const
 {
-    // Read the field for all the processors
-    PtrList<GeometricField<Type, fvsPatchField, surfaceMesh>> procFields
-    (
-        procMeshes_.size()
-    );
+    PtrList<GeometricField<Type, fvsPatchField, surfaceMesh>>
+        procFields(procMeshes_.size());
 
     forAll(procMeshes_, proci)
     {
@@ -593,8 +435,8 @@ Foam::fvFieldReconstructor::reconstructFvSurfaceField
         IOobject
         (
             fieldIoObject.name(),
-            mesh_.time().timeName(),
-            mesh_,
+            completeMesh_.time().timeName(),
+            completeMesh_,
             IOobject::NO_READ,
             IOobject::NO_WRITE,
             false
diff --git a/src/parallel/reconstruct/reconstruct/pointFieldReconstructor.C b/applications/utilities/parallelProcessing/reconstructPar/pointFieldReconstructor.C
similarity index 91%
rename from src/parallel/reconstruct/reconstruct/pointFieldReconstructor.C
rename to applications/utilities/parallelProcessing/reconstructPar/pointFieldReconstructor.C
index 2feb95568a..c1c4abaeaf 100644
--- a/src/parallel/reconstruct/reconstruct/pointFieldReconstructor.C
+++ b/applications/utilities/parallelProcessing/reconstructPar/pointFieldReconstructor.C
@@ -29,19 +29,19 @@ License
 
 Foam::pointFieldReconstructor::pointFieldReconstructor
 (
-    const pointMesh& mesh,
+    const pointMesh& completeMesh,
     const PtrList<pointMesh>& procMeshes,
-    const PtrList<labelIOList>& pointProcAddressing
+    const labelListList& pointProcAddressing
 )
 :
-    mesh_(mesh),
+    completeMesh_(completeMesh),
     procMeshes_(procMeshes),
     pointProcAddressing_(pointProcAddressing),
     patchPointAddressing_(procMeshes.size()),
     nReconstructed_(0)
 {
     // Inverse-addressing of the patch point labels.
-    labelList pointMap(mesh_.size(), -1);
+    labelList pointMap(completeMesh_.size(), -1);
 
     // Create the pointPatch addressing
     forAll(procMeshes_, proci)
@@ -52,13 +52,13 @@ Foam::pointFieldReconstructor::pointFieldReconstructor
 
         forAll(procMesh.boundary(), patchi)
         {
-            if (patchi < mesh_.boundary().size())
+            if (patchi < completeMesh_.boundary().size())
             {
                 labelList& procPatchAddr = patchPointAddressing_[proci][patchi];
                 procPatchAddr.setSize(procMesh.boundary()[patchi].size(), -1);
 
                 const labelList& patchPointLabels =
-                    mesh_.boundary()[patchi].meshPoints();
+                    completeMesh_.boundary()[patchi].meshPoints();
 
                 // Create the inverse-addressing of the patch point labels.
                 forAll(patchPointLabels, pointi)
diff --git a/src/parallel/reconstruct/reconstruct/pointFieldReconstructor.H b/applications/utilities/parallelProcessing/reconstructPar/pointFieldReconstructor.H
similarity index 96%
rename from src/parallel/reconstruct/reconstruct/pointFieldReconstructor.H
rename to applications/utilities/parallelProcessing/reconstructPar/pointFieldReconstructor.H
index 0fd370815b..153dafe6f1 100644
--- a/src/parallel/reconstruct/reconstruct/pointFieldReconstructor.H
+++ b/applications/utilities/parallelProcessing/reconstructPar/pointFieldReconstructor.H
@@ -55,13 +55,13 @@ class pointFieldReconstructor
     // Private Data
 
         //- Reconstructed mesh reference
-        const pointMesh& mesh_;
+        const pointMesh& completeMesh_;
 
         //- List of processor meshes
         const PtrList<pointMesh>& procMeshes_;
 
         //- List of processor point addressing lists
-        const PtrList<labelIOList>& pointProcAddressing_;
+        const labelListList& pointProcAddressing_;
 
         //- Point patch addressing
         labelListListList patchPointAddressing_;
@@ -97,7 +97,7 @@ public:
         (
             const pointMesh& mesh,
             const PtrList<pointMesh>& procMeshes,
-            const PtrList<labelIOList>& pointProcAddressing
+            const labelListList& pointProcAddressing
         );
 
         //- Disallow default bitwise copy construction
diff --git a/src/parallel/reconstruct/reconstruct/pointFieldReconstructorReconstructFields.C b/applications/utilities/parallelProcessing/reconstructPar/pointFieldReconstructorReconstructFields.C
similarity index 91%
rename from src/parallel/reconstruct/reconstruct/pointFieldReconstructorReconstructFields.C
rename to applications/utilities/parallelProcessing/reconstructPar/pointFieldReconstructorReconstructFields.C
index 4c69af50b2..b7bc6a7503 100644
--- a/src/parallel/reconstruct/reconstruct/pointFieldReconstructorReconstructFields.C
+++ b/applications/utilities/parallelProcessing/reconstructPar/pointFieldReconstructorReconstructFields.C
@@ -59,10 +59,10 @@ Foam::pointFieldReconstructor::reconstructField(const IOobject& fieldIoObject)
 
 
     // Create the internalField
-    Field<Type> internalField(mesh_.size());
+    Field<Type> internalField(completeMesh_.size());
 
     // Create the patch fields
-    PtrList<pointPatchField<Type>> patchFields(mesh_.boundary().size());
+    PtrList<pointPatchField<Type>> patchFields(completeMesh_.boundary().size());
 
 
     forAll(procMeshes_, proci)
@@ -85,7 +85,7 @@ Foam::pointFieldReconstructor::reconstructField(const IOobject& fieldIoObject)
         {
             // Get patch index of the original patch
             const label curBPatch =
-                patchi < mesh_.boundary().size() ? patchi : -1;
+                patchi < completeMesh_.boundary().size() ? patchi : -1;
 
             // check if the boundary patch is not a processor patch
             if (curBPatch != -1)
@@ -97,11 +97,11 @@ Foam::pointFieldReconstructor::reconstructField(const IOobject& fieldIoObject)
                         pointPatchField<Type>::New
                         (
                             procField.boundaryField()[patchi],
-                            mesh_.boundary()[curBPatch],
+                            completeMesh_.boundary()[curBPatch],
                             DimensionedField<Type, pointMesh>::null(),
                             pointPatchFieldReconstructor
                             (
-                                mesh_.boundary()[curBPatch].size()
+                                completeMesh_.boundary()[curBPatch].size()
                             )
                         )
                     );
@@ -125,12 +125,12 @@ Foam::pointFieldReconstructor::reconstructField(const IOobject& fieldIoObject)
             IOobject
             (
                 fieldIoObject.name(),
-                mesh_().time().timeName(),
-                mesh_(),
+                completeMesh_().time().timeName(),
+                completeMesh_(),
                 IOobject::NO_READ,
                 IOobject::NO_WRITE
             ),
-            mesh_,
+            completeMesh_,
             procFields[0].dimensions(),
             internalField,
             patchFields
diff --git a/src/parallel/reconstruct/reconstruct/reconstructLagrangian.H b/applications/utilities/parallelProcessing/reconstructPar/reconstructLagrangian.H
similarity index 94%
rename from src/parallel/reconstruct/reconstruct/reconstructLagrangian.H
rename to applications/utilities/parallelProcessing/reconstructPar/reconstructLagrangian.H
index ce3945d976..80626cf13a 100644
--- a/src/parallel/reconstruct/reconstruct/reconstructLagrangian.H
+++ b/applications/utilities/parallelProcessing/reconstructPar/reconstructLagrangian.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -53,8 +53,8 @@ void reconstructLagrangianPositions
     const polyMesh& mesh,
     const word& cloudName,
     const PtrList<fvMesh>& meshes,
-    const PtrList<labelIOList>& faceProcAddressing,
-    const PtrList<labelIOList>& cellProcAddressing
+    const labelListList& faceProcAddressing,
+    const labelListList& cellProcAddressing
 );
 
 
diff --git a/src/parallel/reconstruct/reconstruct/reconstructLagrangianFields.C b/applications/utilities/parallelProcessing/reconstructPar/reconstructLagrangianFields.C
similarity index 99%
rename from src/parallel/reconstruct/reconstruct/reconstructLagrangianFields.C
rename to applications/utilities/parallelProcessing/reconstructPar/reconstructLagrangianFields.C
index 8a904f230b..5adf9ab01a 100644
--- a/src/parallel/reconstruct/reconstruct/reconstructLagrangianFields.C
+++ b/applications/utilities/parallelProcessing/reconstructPar/reconstructLagrangianFields.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2021 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/parallel/reconstruct/reconstruct/reconstructLagrangianPositions.C b/applications/utilities/parallelProcessing/reconstructPar/reconstructLagrangianPositions.C
similarity index 94%
rename from src/parallel/reconstruct/reconstruct/reconstructLagrangianPositions.C
rename to applications/utilities/parallelProcessing/reconstructPar/reconstructLagrangianPositions.C
index 12e2896dfc..a6fae4e05d 100644
--- a/src/parallel/reconstruct/reconstruct/reconstructLagrangianPositions.C
+++ b/applications/utilities/parallelProcessing/reconstructPar/reconstructLagrangianPositions.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -34,8 +34,8 @@ void Foam::reconstructLagrangianPositions
     const polyMesh& mesh,
     const word& cloudName,
     const PtrList<fvMesh>& meshes,
-    const PtrList<labelIOList>& faceProcAddressing,
-    const PtrList<labelIOList>& cellProcAddressing
+    const labelListList& faceProcAddressing,
+    const labelListList& cellProcAddressing
 )
 {
     passiveParticleCloud lagrangianPositions
diff --git a/applications/utilities/parallelProcessing/reconstructPar/reconstructPar.C b/applications/utilities/parallelProcessing/reconstructPar/reconstructPar.C
index 41bd761e12..945e65fbc7 100644
--- a/applications/utilities/parallelProcessing/reconstructPar/reconstructPar.C
+++ b/applications/utilities/parallelProcessing/reconstructPar/reconstructPar.C
@@ -32,21 +32,15 @@ Description
 
 #include "argList.H"
 #include "timeSelector.H"
-
 #include "fvCFD.H"
 #include "IOobjectList.H"
-#include "processorMeshes.H"
+#include "processorRunTimes.H"
+#include "domainDecomposition.H"
 #include "regionProperties.H"
 #include "fvFieldReconstructor.H"
 #include "pointFieldReconstructor.H"
 #include "reconstructLagrangian.H"
 
-#include "cellSet.H"
-#include "faceSet.H"
-#include "pointSet.H"
-
-#include "hexRef8Data.H"
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
@@ -120,7 +114,6 @@ int main(int argc, char *argv[])
     );
 
     #include "setRootCase.H"
-    #include "createTime.H"
 
     HashSet<word> selectedFields;
     if (args.optionFound("fields"))
@@ -144,7 +137,6 @@ int main(int argc, char *argv[])
             << nl << endl;
     }
 
-
     const bool noReconstructSets = args.optionFound("noSets");
 
     if (noReconstructSets)
@@ -153,7 +145,6 @@ int main(int argc, char *argv[])
             << nl << endl;
     }
 
-
     HashSet<word> selectedLagrangianFields;
     if (args.optionFound("lagrangianFields"))
     {
@@ -168,12 +159,20 @@ int main(int argc, char *argv[])
         args.optionLookup("lagrangianFields")() >> selectedLagrangianFields;
     }
 
-    const wordList regionNames(selectRegionNames(args, runTime));
+    // Set time from database
+    Info<< "Create time\n" << endl;
+    processorRunTimes runTimes(Foam::Time::controlDictName, args);
+
+    // Allow override of time
+    const instantList times = runTimes.selectProc(args);
+
+    // Get region names
+    const wordList regionNames =
+        selectRegionNames(args, runTimes.procTimes()[0]);
 
     // Determine the processor count
     const label nProcs =
         fileHandler().nProcs(args.path(), regionDir(regionNames[0]));
-
     if (!nProcs)
     {
         FatalErrorInFunction
@@ -184,38 +183,12 @@ int main(int argc, char *argv[])
     // Warn fileHandler of number of processors
     const_cast<fileOperation&>(fileHandler()).setNProcs(nProcs);
 
-    // Create the processor databases
-    PtrList<Time> databases(nProcs);
-
-    forAll(databases, proci)
-    {
-        databases.set
-        (
-            proci,
-            new Time
-            (
-                Time::controlDictName,
-                args.rootPath(),
-                args.caseName()/fileName(word("processor") + name(proci))
-            )
-        );
-    }
-
-    // Use the times list from the master processor
-    // and select a subset based on the command-line options
-    instantList timeDirs = timeSelector::select
-    (
-        databases[0].times(),
-        args
-    );
-
     // Note that we do not set the runTime time so it is still the
     // one set through the controlDict. The -time option
     // only affects the selected set of times from processor0.
     // - can be illogical
     // + any point motion handled through mesh.readUpdate
-
-    if (timeDirs.empty())
+    if (times.empty())
     {
         WarningInFunction << "No times selected" << endl;
         exit(1);
@@ -226,130 +199,76 @@ int main(int argc, char *argv[])
     instantList masterTimeDirs;
     if (newTimes)
     {
-        masterTimeDirs = runTime.times();
+        masterTimeDirs = runTimes.completeTime().times();
     }
-
     HashSet<word> masterTimeDirSet(2*masterTimeDirs.size());
     forAll(masterTimeDirs, i)
     {
         masterTimeDirSet.insert(masterTimeDirs[i].name());
     }
-
     if
     (
         newTimes
      && regionNames.size() == 1
      && regionNames[0] == fvMesh::defaultRegion
-     && haveAllTimes(masterTimeDirSet, timeDirs)
+     && haveAllTimes(masterTimeDirSet, times)
     )
     {
         Info<< "All times already reconstructed.\n\nEnd\n" << endl;
         return 0;
     }
 
-    // Set all times on processor meshes equal to reconstructed mesh
-    forAll(databases, proci)
-    {
-        databases[proci].setTime(runTime);
-    }
-
+    // Reconstruct all regions
     forAll(regionNames, regioni)
     {
         const word& regionName = regionNames[regioni];
         const word& regionDir = Foam::regionDir(regionName);
 
-        Info<< "\n\nReconstructing fields for mesh " << regionName << nl
-            << endl;
-
-        fvMesh mesh
-        (
-            IOobject
-            (
-                regionName,
-                runTime.timeName(),
-                runTime,
-                IOobject::MUST_READ
-            ),
-            false
-        );
-
-
-        // Read all meshes and addressing to reconstructed mesh
-        processorMeshes procMeshes(databases, regionName);
-
-
-        // Check face addressing for meshes that have been decomposed
-        // with a very old foam version
-        #include "checkFaceAddressingComp.H"
+        // Create meshes
+        Info<< "\n\nReconstructing fields for mesh " << regionName
+            << nl << endl;
+        domainDecomposition meshes(runTimes, regionName);
+        meshes.readComplete();
+        meshes.readProcs();
+        meshes.readAddressing();
+        meshes.readUpdate();
 
         // Loop over all times
-        forAll(timeDirs, timei)
+        forAll(times, timei)
         {
-            if (newTimes && masterTimeDirSet.found(timeDirs[timei].name()))
+            if (newTimes && masterTimeDirSet.found(times[timei].name()))
             {
-                Info<< "Skipping time " << timeDirs[timei].name()
+                Info<< "Skipping time " << times[timei].name()
                     << endl << endl;
                 continue;
             }
 
+            // Set the time
+            runTimes.setTime(times[timei], timei);
 
-            // Set time for global database
-            runTime.setTime(timeDirs[timei], timei);
+            Info<< "Time = " << runTimes.completeTime().userTimeName()
+                << nl << endl;
 
-            Info<< "Time = " << runTime.userTimeName() << endl << endl;
-
-            // Set time for all databases
-            forAll(databases, proci)
+            // Update the meshes
+            const fvMesh::readUpdateState state = meshes.readUpdate();
+            if (state == fvMesh::POINTS_MOVED)
             {
-                databases[proci].setTime(timeDirs[timei], timei);
+                meshes.writeComplete(false);
             }
-
-            // Check if any new meshes need to be read.
-            fvMesh::readUpdateState meshStat = mesh.readUpdate();
-            fvMesh::readUpdateState procStat = procMeshes.readUpdate();
             if
             (
-                meshStat != procStat
-
-                // Allowed status difference. Mesh has moved in parallel, but
-                // the change has not yet been reconstructed.
-             && !(
-                    meshStat == fvMesh::UNCHANGED
-                 && procStat == fvMesh::POINTS_MOVED
-                )
-
-                // Allowed status difference. Mesh has changed topology in both
-                // cases, and this has lead to new processor interfaces
-                // (probably). These interfaces are compatible with a
-                // reconstructed mesh in which patches have not changed.
-             && !(
-                    meshStat == fvMesh::TOPO_CHANGE
-                 && procStat == fvMesh::TOPO_PATCH_CHANGE
-                )
+                state == fvMesh::TOPO_CHANGE
+             || state == fvMesh::TOPO_PATCH_CHANGE
             )
             {
-                WarningInFunction
-                    << "readUpdate for the reconstructed mesh:"
-                    << meshStat << nl
-                    << "readUpdate for the processor meshes  :"
-                    << procStat << nl
-                    << "These should be equal or your addressing"
-                    << " might be incorrect."
-                    << " Please check your time directories for any "
-                    << "mesh directories." << endl;
-            }
-
-            // Reconstruct and write the points for moving mesh cases
-            if (procStat == fvMesh::POINTS_MOVED)
-            {
-                procMeshes.reconstructPoints(mesh);
+                meshes.writeComplete(!noReconstructSets);
             }
 
             // Get list of objects from processor0 database
             IOobjectList objects
             (
-                procMeshes.meshes()[0],
-                databases[0].timeName()
+                meshes.procMeshes()[0],
+                runTimes.procTimes()[0].timeName()
             );
 
             if (!noFields)
@@ -359,10 +278,11 @@ int main(int argc, char *argv[])
 
                 fvFieldReconstructor fvReconstructor
                 (
-                    mesh,
-                    procMeshes.meshes(),
-                    procMeshes.faceProcAddressing(),
-                    procMeshes.cellProcAddressing()
+                    meshes.completeMesh(),
+                    meshes.procMeshes(),
+                    meshes.procFaceAddressing(),
+                    meshes.procCellAddressing(),
+                    meshes.procFaceAddressingBf()
                 );
 
                 fvReconstructor.reconstructFvVolumeInternalFields<scalar>
@@ -454,23 +374,23 @@ int main(int argc, char *argv[])
             {
                 Info<< "Reconstructing point fields" << nl << endl;
 
-                const pointMesh& pMesh = pointMesh::New(mesh);
-                PtrList<pointMesh> pMeshes(procMeshes.meshes().size());
-
-                forAll(pMeshes, proci)
+                const pointMesh& completePMesh =
+                    pointMesh::New(meshes.completeMesh());
+                PtrList<pointMesh> procPMeshes(nProcs);
+                forAll(procPMeshes, proci)
                 {
-                    pMeshes.set
+                    procPMeshes.set
                     (
                         proci,
-                        new pointMesh(procMeshes.meshes()[proci])
+                        new pointMesh(meshes.procMeshes()[proci])
                     );
                 }
 
                 pointFieldReconstructor pointReconstructor
                 (
-                    pMesh,
-                    pMeshes,
-                    procMeshes.pointProcAddressing()
+                    completePMesh,
+                    procPMeshes,
+                    meshes.procPointAddressing()
                 );
 
                 pointReconstructor.reconstructFields<scalar>
@@ -517,15 +437,15 @@ int main(int argc, char *argv[])
             {
                 HashTable<IOobjectList> cloudObjects;
 
-                forAll(databases, proci)
+                forAll(runTimes.procTimes(), proci)
                 {
                     fileName lagrangianDir
                     (
                         fileHandler().filePath
                         (
-                            databases[proci].timePath()
-                          / regionDir
-                          / cloud::prefix
+                            runTimes.procTimes()[proci].timePath()
+                           /regionDir
+                           /cloud::prefix
                         )
                     );
 
@@ -551,8 +471,8 @@ int main(int argc, char *argv[])
                             // Do local scan for valid cloud objects
                             IOobjectList sprayObjs
                             (
-                                procMeshes.meshes()[proci],
-                                databases[proci].timeName(),
+                                meshes.procMeshes()[proci],
+                                runTimes.procTimes()[proci].timeName(),
                                 cloud::prefix/cloudDirs[i]
                             );
 
@@ -567,16 +487,13 @@ int main(int argc, char *argv[])
                     }
                 }
 
-
                 if (cloudObjects.size())
                 {
                     // Pass2: reconstruct the cloud
                     forAllConstIter(HashTable<IOobjectList>, cloudObjects, iter)
                     {
-                        const word cloudName = string::validate<word>
-                        (
-                            iter.key()
-                        );
+                        const word cloudName =
+                            string::validate<word>(iter.key());
 
                         // Objects (on arbitrary processor)
                         const IOobjectList& sprayObjs = iter();
@@ -586,105 +503,105 @@ int main(int argc, char *argv[])
 
                         reconstructLagrangianPositions
                         (
-                            mesh,
+                            meshes.completeMesh(),
                             cloudName,
-                            procMeshes.meshes(),
-                            procMeshes.faceProcAddressing(),
-                            procMeshes.cellProcAddressing()
+                            meshes.procMeshes(),
+                            meshes.procFaceAddressing(),
+                            meshes.procCellAddressing()
                         );
                         reconstructLagrangianFields<label>
                         (
                             cloudName,
-                            mesh,
-                            procMeshes.meshes(),
+                            meshes.completeMesh(),
+                            meshes.procMeshes(),
                             sprayObjs,
                             selectedLagrangianFields
                         );
                         reconstructLagrangianFieldFields<label>
                         (
                             cloudName,
-                            mesh,
-                            procMeshes.meshes(),
+                            meshes.completeMesh(),
+                            meshes.procMeshes(),
                             sprayObjs,
                             selectedLagrangianFields
                         );
                         reconstructLagrangianFields<scalar>
                         (
                             cloudName,
-                            mesh,
-                            procMeshes.meshes(),
+                            meshes.completeMesh(),
+                            meshes.procMeshes(),
                             sprayObjs,
                             selectedLagrangianFields
                         );
                         reconstructLagrangianFieldFields<scalar>
                         (
                             cloudName,
-                            mesh,
-                            procMeshes.meshes(),
+                            meshes.completeMesh(),
+                            meshes.procMeshes(),
                             sprayObjs,
                             selectedLagrangianFields
                         );
                         reconstructLagrangianFields<vector>
                         (
                             cloudName,
-                            mesh,
-                            procMeshes.meshes(),
+                            meshes.completeMesh(),
+                            meshes.procMeshes(),
                             sprayObjs,
                             selectedLagrangianFields
                         );
                         reconstructLagrangianFieldFields<vector>
                         (
                             cloudName,
-                            mesh,
-                            procMeshes.meshes(),
+                            meshes.completeMesh(),
+                            meshes.procMeshes(),
                             sprayObjs,
                             selectedLagrangianFields
                         );
                         reconstructLagrangianFields<sphericalTensor>
                         (
                             cloudName,
-                            mesh,
-                            procMeshes.meshes(),
+                            meshes.completeMesh(),
+                            meshes.procMeshes(),
                             sprayObjs,
                             selectedLagrangianFields
                         );
                         reconstructLagrangianFieldFields<sphericalTensor>
                         (
                             cloudName,
-                            mesh,
-                            procMeshes.meshes(),
+                            meshes.completeMesh(),
+                            meshes.procMeshes(),
                             sprayObjs,
                             selectedLagrangianFields
                         );
                         reconstructLagrangianFields<symmTensor>
                         (
                             cloudName,
-                            mesh,
-                            procMeshes.meshes(),
+                            meshes.completeMesh(),
+                            meshes.procMeshes(),
                             sprayObjs,
                             selectedLagrangianFields
                         );
                         reconstructLagrangianFieldFields<symmTensor>
                         (
                             cloudName,
-                            mesh,
-                            procMeshes.meshes(),
+                            meshes.completeMesh(),
+                            meshes.procMeshes(),
                             sprayObjs,
                             selectedLagrangianFields
                         );
                         reconstructLagrangianFields<tensor>
                         (
                             cloudName,
-                            mesh,
-                            procMeshes.meshes(),
+                            meshes.completeMesh(),
+                            meshes.procMeshes(),
                             sprayObjs,
                             selectedLagrangianFields
                         );
                         reconstructLagrangianFieldFields<tensor>
                         (
                             cloudName,
-                            mesh,
-                            procMeshes.meshes(),
+                            meshes.completeMesh(),
+                            meshes.procMeshes(),
                             sprayObjs,
                             selectedLagrangianFields
                         );
@@ -696,278 +613,6 @@ int main(int argc, char *argv[])
                 }
             }
 
-
-            if (!noReconstructSets)
-            {
-                // Scan to find all sets
-                HashTable<label> cSetNames;
-                HashTable<label> fSetNames;
-                HashTable<label> pSetNames;
-
-                forAll(procMeshes.meshes(), proci)
-                {
-                    const fvMesh& procMesh = procMeshes.meshes()[proci];
-
-                    // Note: look at sets in current time only or between
-                    // mesh and current time?. For now current time. This will
-                    // miss out on sets in intermediate times that have not
-                    // been reconstructed.
-                    IOobjectList objects
-                    (
-                        procMesh,
-                        databases[0].timeName(),    // procMesh.facesInstance()
-                        polyMesh::meshSubDir/"sets"
-                    );
-
-                    IOobjectList cSets(objects.lookupClass(cellSet::typeName));
-                    forAllConstIter(IOobjectList, cSets, iter)
-                    {
-                        cSetNames.insert(iter.key(), cSetNames.size());
-                    }
-
-                    IOobjectList fSets(objects.lookupClass(faceSet::typeName));
-                    forAllConstIter(IOobjectList, fSets, iter)
-                    {
-                        fSetNames.insert(iter.key(), fSetNames.size());
-                    }
-                    IOobjectList pSets(objects.lookupClass(pointSet::typeName));
-                    forAllConstIter(IOobjectList, pSets, iter)
-                    {
-                        pSetNames.insert(iter.key(), pSetNames.size());
-                    }
-                }
-
-                if (cSetNames.size() || fSetNames.size() || pSetNames.size())
-                {
-                    // Construct all sets
-                    PtrList<cellSet> cellSets(cSetNames.size());
-                    PtrList<faceSet> faceSets(fSetNames.size());
-                    PtrList<pointSet> pointSets(pSetNames.size());
-
-                    Info<< "Reconstructing sets:" << endl;
-                    if (cSetNames.size())
-                    {
-                        Info<< "    cellSets "
-                            << cSetNames.sortedToc() << endl;
-                    }
-                    if (fSetNames.size())
-                    {
-                        Info<< "    faceSets "
-                            << fSetNames.sortedToc() << endl;
-                    }
-                    if (pSetNames.size())
-                    {
-                        Info<< "    pointSets "
-                            << pSetNames.sortedToc() << endl;
-                    }
-
-                    // Load sets
-                    forAll(procMeshes.meshes(), proci)
-                    {
-                        const fvMesh& procMesh = procMeshes.meshes()[proci];
-
-                        IOobjectList objects
-                        (
-                            procMesh,
-                            databases[0].timeName(),
-                            polyMesh::meshSubDir/"sets"
-                        );
-
-                        // cellSets
-                        const labelList& cellMap =
-                            procMeshes.cellProcAddressing()[proci];
-
-                        IOobjectList cSets
-                        (
-                            objects.lookupClass(cellSet::typeName)
-                        );
-
-                        forAllConstIter(IOobjectList, cSets, iter)
-                        {
-                            // Load cellSet
-                            const cellSet procSet(*iter());
-                            label setI = cSetNames[iter.key()];
-                            if (!cellSets.set(setI))
-                            {
-                                cellSets.set
-                                (
-                                    setI,
-                                    new cellSet
-                                    (
-                                        mesh,
-                                        iter.key(),
-                                        procSet.size()
-                                    )
-                                );
-                            }
-                            cellSet& cSet = cellSets[setI];
-                            cSet.instance() = runTime.timeName();
-
-                            forAllConstIter(cellSet, procSet, iter)
-                            {
-                                cSet.insert(cellMap[iter.key()]);
-                            }
-                        }
-
-                        // faceSets
-                        const labelList& faceMap =
-                        procMeshes.faceProcAddressing()[proci];
-
-                        IOobjectList fSets
-                        (
-                            objects.lookupClass(faceSet::typeName)
-                        );
-
-                        forAllConstIter(IOobjectList, fSets, iter)
-                        {
-                            // Load faceSet
-                            const faceSet procSet(*iter());
-                            label setI = fSetNames[iter.key()];
-                            if (!faceSets.set(setI))
-                            {
-                                faceSets.set
-                                (
-                                    setI,
-                                    new faceSet
-                                    (
-                                        mesh,
-                                        iter.key(),
-                                        procSet.size()
-                                    )
-                                );
-                            }
-                            faceSet& fSet = faceSets[setI];
-                            fSet.instance() = runTime.timeName();
-
-                            forAllConstIter(faceSet, procSet, iter)
-                            {
-                                fSet.insert(mag(faceMap[iter.key()])-1);
-                            }
-                        }
-                        // pointSets
-                        const labelList& pointMap =
-                            procMeshes.pointProcAddressing()[proci];
-
-                        IOobjectList pSets
-                        (
-                            objects.lookupClass(pointSet::typeName)
-                        );
-                        forAllConstIter(IOobjectList, pSets, iter)
-                        {
-                            // Load pointSet
-                            const pointSet propSet(*iter());
-                            label setI = pSetNames[iter.key()];
-                            if (!pointSets.set(setI))
-                            {
-                                pointSets.set
-                                (
-                                    setI,
-                                    new pointSet
-                                    (
-                                        mesh,
-                                        iter.key(),
-                                        propSet.size()
-                                    )
-                                );
-                            }
-                            pointSet& pSet = pointSets[setI];
-                            pSet.instance() = runTime.timeName();
-
-                            forAllConstIter(pointSet, propSet, iter)
-                            {
-                                pSet.insert(pointMap[iter.key()]);
-                            }
-                        }
-                    }
-
-                    // Write sets
-                    forAll(cellSets, i)
-                    {
-                        cellSets[i].write();
-                    }
-                    forAll(faceSets, i)
-                    {
-                        faceSets[i].write();
-                    }
-                    forAll(pointSets, i)
-                    {
-                        pointSets[i].write();
-                    }
-                }
-            }
-
-
-            // Reconstruct refinement data
-            {
-                PtrList<hexRef8Data> procData(procMeshes.meshes().size());
-
-                forAll(procMeshes.meshes(), procI)
-                {
-                    const fvMesh& procMesh = procMeshes.meshes()[procI];
-
-                    procData.set
-                    (
-                        procI,
-                        new hexRef8Data
-                        (
-                            IOobject
-                            (
-                                "dummy",
-                                procMesh.time().timeName(),
-                                polyMesh::meshSubDir,
-                                procMesh,
-                                IOobject::READ_IF_PRESENT,
-                                IOobject::NO_WRITE,
-                                false
-                            )
-                        )
-                    );
-                }
-
-                // Combine individual parts
-
-                const PtrList<labelIOList>& cellAddr =
-                    procMeshes.cellProcAddressing();
-
-                UPtrList<const labelList> cellMaps(cellAddr.size());
-                forAll(cellAddr, i)
-                {
-                    cellMaps.set(i, &cellAddr[i]);
-                }
-
-                const PtrList<labelIOList>& pointAddr =
-                    procMeshes.pointProcAddressing();
-
-                UPtrList<const labelList> pointMaps(pointAddr.size());
-                forAll(pointAddr, i)
-                {
-                    pointMaps.set(i, &pointAddr[i]);
-                }
-
-                UPtrList<const hexRef8Data> procRefs(procData.size());
-                forAll(procData, i)
-                {
-                    procRefs.set(i, &procData[i]);
-                }
-
-                hexRef8Data
-                (
-                    IOobject
-                    (
-                        "dummy",
-                        mesh.time().timeName(),
-                        polyMesh::meshSubDir,
-                        mesh,
-                        IOobject::NO_READ,
-                        IOobject::NO_WRITE,
-                        false
-                    ),
-                    cellMaps,
-                    pointMaps,
-                    procRefs
-                ).write();
-            }
-
             // If there is a "uniform" directory in the time region
             // directory copy from the master processor
             {
@@ -975,13 +620,17 @@ int main(int argc, char *argv[])
                 (
                     fileHandler().filePath
                     (
-                        databases[0].timePath()/regionDir/"uniform"
+                        runTimes.procTimes()[0].timePath()/regionDir/"uniform"
                     )
                 );
 
                 if (!uniformDir0.empty() && fileHandler().isDir(uniformDir0))
                 {
-                    fileHandler().cp(uniformDir0, runTime.timePath()/regionDir);
+                    fileHandler().cp
+                    (
+                        uniformDir0,
+                        runTimes.completeTime().timePath()/regionDir
+                    );
                 }
             }
 
@@ -993,13 +642,17 @@ int main(int argc, char *argv[])
                 (
                     fileHandler().filePath
                     (
-                        databases[0].timePath()/"uniform"
+                        runTimes.procTimes()[0].timePath()/"uniform"
                     )
                 );
 
                 if (!uniformDir0.empty() && fileHandler().isDir(uniformDir0))
                 {
-                    fileHandler().cp(uniformDir0, runTime.timePath());
+                    fileHandler().cp
+                    (
+                        uniformDir0,
+                        runTimes.completeTime().timePath()
+                    );
                 }
             }
         }
diff --git a/applications/utilities/preProcessing/setFields/setFields.C b/applications/utilities/preProcessing/setFields/setFields.C
index 6f91d0c1ff..a98d81b309 100644
--- a/applications/utilities/preProcessing/setFields/setFields.C
+++ b/applications/utilities/preProcessing/setFields/setFields.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2021 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -34,6 +34,8 @@ Description
 #include "faceSet.H"
 #include "volFields.H"
 #include "systemDict.H"
+#include "processorFvPatch.H"
+#include "CompactListList.H"
 
 using namespace Foam;
 
@@ -231,72 +233,96 @@ bool setFaceFieldType
             << fieldHeader.headerClassName()
             << " " << fieldName << endl;
 
+        // Read the field
         fieldType field(fieldHeader, mesh);
+        typename fieldType::Boundary& fieldBf = field.boundaryFieldRef();
 
+        // Read the value
         const Type& value = pTraits<Type>(fieldValueStream);
 
-        // Create flat list of selected faces and their value.
-        Field<Type> allBoundaryValues(mesh.nFaces()-mesh.nInternalFaces());
-        forAll(field.boundaryField(), patchi)
+        // Determine the number of non-processor patches
+        label nNonProcPatches = 0;
+        forAll(fieldBf, patchi)
         {
-            SubField<Type>
-            (
-                allBoundaryValues,
-                field.boundaryField()[patchi].size(),
-                field.boundaryField()[patchi].patch().start()
-              - mesh.nInternalFaces()
-            ) = field.boundaryField()[patchi];
+            nNonProcPatches = patchi;
+            if (isA<processorFvPatch>(mesh.boundary()[patchi]))
+            {
+                break;
+            }
         }
 
-        // Override
-        bool hasWarned = false;
-        labelList nChanged
+        // Create a copy of the boundary field
+        typename fieldType::Boundary fieldBfCopy
         (
-            returnReduce(field.boundaryField().size(), maxOp<label>()),
-            0
+            fieldType::Internal::null(),
+            fieldBf
         );
+
+        // Loop selected faces and set values in the copied boundary field
+        bool haveWarnedInternal = false, haveWarnedProc = false;
+        labelList nonProcPatchNChangedFaces(nNonProcPatches, 0);
         forAll(selectedFaces, i)
         {
-            label facei = selectedFaces[i];
+            const label facei = selectedFaces[i];
+
             if (mesh.isInternalFace(facei))
             {
-                if (!hasWarned)
+                if (!haveWarnedInternal)
                 {
-                    hasWarned = true;
                     WarningInFunction
                         << "Ignoring internal face " << facei
                         << ". Suppressing further warnings." << endl;
+                    haveWarnedInternal = true;
                 }
             }
             else
             {
-                label bFacei = facei-mesh.nInternalFaces();
-                allBoundaryValues[bFacei] = value;
-                nChanged[mesh.boundaryMesh().patchID()[bFacei]]++;
+                const labelUList patches =
+                    mesh.polyBFacePatches()[facei - mesh.nInternalFaces()];
+                const labelUList patchFaces =
+                    mesh.polyBFacePatchFaces()[facei - mesh.nInternalFaces()];
+
+                forAll(patches, i)
+                {
+                    if (patches[i] >= nNonProcPatches)
+                    {
+                        if (!haveWarnedProc)
+                        {
+                            WarningInFunction
+                                << "Ignoring face " << patchFaces[i]
+                                << " of processor patch " << patches[i]
+                                << ". Suppressing further warnings." << endl;
+                            haveWarnedProc = true;
+                        }
+                    }
+                    else
+                    {
+                        fieldBfCopy[patches[i]][patchFaces[i]] = value;
+                        nonProcPatchNChangedFaces[patches[i]] ++;
+                    }
+                }
             }
         }
+        Pstream::listCombineGather
+        (
+            nonProcPatchNChangedFaces,
+            plusEqOp<label>()
+        );
+        Pstream::listCombineScatter
+        (
+            nonProcPatchNChangedFaces
+        );
 
-        Pstream::listCombineGather(nChanged, plusEqOp<label>());
-        Pstream::listCombineScatter(nChanged);
-
-        typename GeometricField<Type, fvPatchField, volMesh>::
-            Boundary& fieldBf = field.boundaryFieldRef();
-
-        // Reassign.
-        forAll(field.boundaryField(), patchi)
+        // Reassign boundary values
+        forAll(nonProcPatchNChangedFaces, patchi)
         {
-            if (nChanged[patchi] > 0)
+            if (nonProcPatchNChangedFaces[patchi] > 0)
             {
                 Info<< "    On patch "
                     << field.boundaryField()[patchi].patch().name()
-                    << " set " << nChanged[patchi] << " values" << endl;
-                fieldBf[patchi] == SubField<Type>
-                (
-                    allBoundaryValues,
-                    fieldBf[patchi].size(),
-                    fieldBf[patchi].patch().start()
-                  - mesh.nInternalFaces()
-                );
+                    << " set " << nonProcPatchNChangedFaces[patchi]
+                    << " values" << endl;
+                fieldBf[patchi] == fieldBfCopy[patchi];
             }
         }
 
diff --git a/bin/tools/CleanFunctions b/bin/tools/CleanFunctions
index ba35b77933..32a9a85f86 100644
--- a/bin/tools/CleanFunctions
+++ b/bin/tools/CleanFunctions
@@ -2,7 +2,7 @@
 # =========                 |
 # \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
 #  \\    /   O peration     | Website:  https://openfoam.org
-#   \\  /    A nd           | Copyright (C) 2011-2021 OpenFOAM Foundation
+#   \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
 #    \\/     M anipulation  |
 #------------------------------------------------------------------------------
 # License
@@ -47,6 +47,7 @@ cleanCase()
     for d in constant 0
     do
         rm -rf $d/polyMesh     $d/*/polyMesh \
+               $d/fvMesh       $d/*/fvMesh \
                $d/cellToRegion $d/*/cellToRegion \
                $d/cellLevel*   $d/pointLevel* \
                $d/cellDist     $d/cellDecomposition
diff --git a/etc/caseDicts/annotated/createNonConformalCouplesDict b/etc/caseDicts/annotated/createNonConformalCouplesDict
new file mode 100644
index 0000000000..e989214fd5
--- /dev/null
+++ b/etc/caseDicts/annotated/createNonConformalCouplesDict
@@ -0,0 +1,69 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Version:  dev
+     \\/     M anipulation  |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      createNonConformalCouplesDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Each couple has its own entry in this file. Entries take the following form:
+
+/*
+// Unique name used to generate the name of the coupled patches
+<name>
+{
+    // Name of the two patches between which to create the coupling
+    patches     (<patch1> <patch2>);
+
+    // Type of the transformation; "none", "rotational", or "translational"
+    transform   <transformType>;
+
+    // Additional transformation settings (if any)
+    ...
+}
+*/
+
+
+// Examples:
+
+// Create a non-conformal couple with no transformation
+nonConformalCouple_none
+{
+    patches         (nonCouple1 nonCouple2);
+    transform       none;
+}
+
+// Create a non-conformal couple with a 30 degree rotational transformation
+nonConformalCouple_30deg
+{
+    patches         (nonCoupleBehind nonCoupleAhead);
+    transform       rotational;
+    rotationAxis    (-1 0 0);
+    rotationCentre  (0 0 0);
+    rotationAngle   30;
+}
+
+// Create a non-conformal couple with a 2 metre translational transformation
+nonConformalCouple_2m
+{
+    patches         (nonCoupleBack nonCoupleFront);
+    transform       translational;
+    separation      (0 2 0);
+}
+
+
+// Note that in rare cases it may be appropriate to create multiple couplings
+// between the same two patches. That can be achieved with multiple entries
+// with the same patches specified. See the
+// incompressible/pimpleFoam/RAS/impeller tutorial for an example of this.
+
+
+// ************************************************************************* //
diff --git a/etc/caseDicts/annotated/decomposeParDict b/etc/caseDicts/annotated/decomposeParDict
index 0b0fcace11..5a8ce5fb8d 100644
--- a/etc/caseDicts/annotated/decomposeParDict
+++ b/etc/caseDicts/annotated/decomposeParDict
@@ -37,10 +37,9 @@ constraints
 
    preservePatches
    {
-       //- Keep owner and neighbour on same processor for faces in patches
-       //  (only makes sense for cyclic patches. Not suitable for e.g.
-       //   cyclicAMI since these are not coupled on the patch level. Use
-       //   singleProcessorFaceSets for those)
+       //- Keep owner and neighbour on same processor for faces in patches. Can
+       //  be used to prevent a cyclic patch from being decomposed into
+       //  multiple processor cyclics.
        type    preservePatches;
        patches (".*");
    }
@@ -48,12 +47,12 @@ constraints
    singleProcessorFaceSets
    {
        //- Keep all of faceSet on a single processor. This puts all cells
-       //  connected with a point, edge or face on the same processor.
+       //  connected with a point, edge or face on the same processor
        //  (just having face connected cells might not guarantee a balanced
-       //  decomposition)
-       // The processor can be -1 (the decompositionMethod chooses the
-       // processor for a good load balance) or explicitly provided (upsets
-       // balance)
+       //  decomposition). If processor index is set to -1, the decomposition
+       //  method chooses the processor to which the face set is decomposed.
+       //  This is likely to create a better balance than if the processor
+       //  index is explicitly specified.
        type    singleProcessorFaceSets;
        singleProcessorFaceSets ((f1 -1));
    }
diff --git a/etc/caseDicts/mesh/manipulation/AMI/createPatchDict b/etc/caseDicts/mesh/manipulation/AMI/createPatchDict
deleted file mode 100644
index a72a7491fc..0000000000
--- a/etc/caseDicts/mesh/manipulation/AMI/createPatchDict
+++ /dev/null
@@ -1,54 +0,0 @@
-/*--------------------------------*- C++ -*----------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Version:  dev
-     \\/     M anipulation  |
-\*---------------------------------------------------------------------------*/
-FoamFile
-{
-    format      ascii;
-    class       dictionary;
-    object      createPatchDict;
-}
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-pointSync false;
-
-// AMI created from internal boundary with cylinder and cylinder_slave patches
-
-masterAMI
-{
-    name            AMI1;
-    patchInfo
-    {
-        type            cyclicAMI;
-        matchTolerance  0.0001;
-        neighbourPatch  AMI2;
-    }
-    constructFrom patches;
-    patches (cylinder);
-}
-
-patches
-(
-    // master AMI patch
-    {
-        $masterAMI;
-    }
-
-    // slave AMI patch
-    {
-        $masterAMI;
-        name            AMI2;
-        patchInfo
-        {
-            neighbourPatch  AMI1;
-        }
-        patches (cylinder_slave);
-    }
-);
-
-
-// ************************************************************************* //
diff --git a/etc/caseDicts/mesh/manipulation/AMI/createBafflesDict b/etc/caseDicts/mesh/manipulation/NCC/createBafflesDict
similarity index 56%
rename from etc/caseDicts/mesh/manipulation/AMI/createBafflesDict
rename to etc/caseDicts/mesh/manipulation/NCC/createBafflesDict
index 03f2cc99a8..1cba027a90 100644
--- a/etc/caseDicts/mesh/manipulation/AMI/createBafflesDict
+++ b/etc/caseDicts/mesh/manipulation/NCC/createBafflesDict
@@ -13,11 +13,18 @@ FoamFile
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+// Whether to convert internal faces only (so leave boundary faces intact).
+// This is only relevant if your face selection type can pick up boundary
+// faces.
 internalFacesOnly true;
 
+// Example creating two opposing patches named "nonCouple1" and "nonCouple2",
+// both of which are included in the "nonCouple" group. These patches can then
+// be coupled afterwards by calling "createNonConformalCouples -overwrite
+// nonCouple1 nonCouple2".
 baffles
 {
-    baffleFaces
+    rotating
     {
         type        faceZone;
         zoneName    rotatingZone;
@@ -26,16 +33,15 @@ baffles
         {
             master
             {
-                name            AMI1;
-                type            cyclicAMI;
-                neighbourPatch  AMI2;
+                name            nonCouple1;
+                type            patch;
+                inGroups        (nonCouple);
             }
             slave
             {
-                $master;
-                name            AMI2;
-                type            cyclicAMI;
-                neighbourPatch  AMI1;
+                name            nonCouple2;
+                type            patch;
+                inGroups        (nonCouple);
             }
         }
     }
diff --git a/etc/caseDicts/setConstraintTypes b/etc/caseDicts/setConstraintTypes
index 244fa27d53..aa9cb01593 100644
--- a/etc/caseDicts/setConstraintTypes
+++ b/etc/caseDicts/setConstraintTypes
@@ -27,9 +27,21 @@ cyclicSlip
     type  cyclicSlip;
 }
 
-conformalCoupled
+nonConformalCyclic
 {
-    type  conformalCoupled;
+    type  nonConformalCyclic;
+    value $internalField;
+}
+
+nonConformalError
+{
+    type  nonConformalError;
+}
+
+nonConformalProcessorCyclic
+{
+    type  nonConformalProcessorCyclic;
+    value $internalField;
 }
 
 empty
diff --git a/src/Allwmake b/src/Allwmake
index a411ae3027..bcc574e2d5 100755
--- a/src/Allwmake
+++ b/src/Allwmake
@@ -49,6 +49,7 @@ parallel/Allwmake $targetType $*
 wmake $targetType conversion
 wmake $targetType sampling
 
+wmake $targetType fvMeshStitchers
 wmake $targetType fvMeshMovers
 fvMeshTopoChangers/Allwmake $targetType $*
 wmake $targetType fvMeshDistributors
diff --git a/src/MomentumTransportModels/momentumTransportModels/LES/LESdeltas/vanDriestDelta/vanDriestDelta.C b/src/MomentumTransportModels/momentumTransportModels/LES/LESdeltas/vanDriestDelta/vanDriestDelta.C
index 5d482ac9ef..32db9f17d1 100644
--- a/src/MomentumTransportModels/momentumTransportModels/LES/LESdeltas/vanDriestDelta/vanDriestDelta.C
+++ b/src/MomentumTransportModels/momentumTransportModels/LES/LESdeltas/vanDriestDelta/vanDriestDelta.C
@@ -91,6 +91,7 @@ void Foam::LESModels::vanDriestDelta::calcDelta()
     (
         mesh,
         mesh.boundaryMesh().findPatchIDs<wallPolyPatch>(),
+        minWallFaceFraction_,
         2, // <-- roughly equivalent to old point-cell corrections
         y,
         yStar,
@@ -156,6 +157,14 @@ Foam::LESModels::vanDriestDelta::vanDriestDelta
             "yPlusCutOff",
             500
         )
+    ),
+    minWallFaceFraction_
+    (
+        dict.optionalSubDict(type() + "Coeffs").lookupOrDefault<scalar>
+        (
+            "minWallFaceFraction",
+            0.1
+        )
     )
 {
     delta_ = geometricDelta_();
diff --git a/src/MomentumTransportModels/momentumTransportModels/LES/LESdeltas/vanDriestDelta/vanDriestDelta.H b/src/MomentumTransportModels/momentumTransportModels/LES/LESdeltas/vanDriestDelta/vanDriestDelta.H
index c8734c57cd..bae666df3f 100644
--- a/src/MomentumTransportModels/momentumTransportModels/LES/LESdeltas/vanDriestDelta/vanDriestDelta.H
+++ b/src/MomentumTransportModels/momentumTransportModels/LES/LESdeltas/vanDriestDelta/vanDriestDelta.H
@@ -61,6 +61,7 @@ class vanDriestDelta
         scalar Cdelta_;
         label calcInterval_;
         scalar yPlusCutOff_;
+        scalar minWallFaceFraction_;
 
 
     // Private Member Functions
diff --git a/src/MomentumTransportModels/momentumTransportModels/derivedFvPatchFields/wallFunctions/epsilonWallFunctions/epsilonWallFunction/epsilonWallFunctionFvPatchScalarField.C b/src/MomentumTransportModels/momentumTransportModels/derivedFvPatchFields/wallFunctions/epsilonWallFunctions/epsilonWallFunction/epsilonWallFunctionFvPatchScalarField.C
index beae11d27f..6ed103bd3d 100644
--- a/src/MomentumTransportModels/momentumTransportModels/derivedFvPatchFields/wallFunctions/epsilonWallFunctions/epsilonWallFunction/epsilonWallFunctionFvPatchScalarField.C
+++ b/src/MomentumTransportModels/momentumTransportModels/derivedFvPatchFields/wallFunctions/epsilonWallFunctions/epsilonWallFunction/epsilonWallFunctionFvPatchScalarField.C
@@ -31,7 +31,7 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-Foam::scalar Foam::epsilonWallFunctionFvPatchScalarField::tolerance_ = 1e-5;
+Foam::scalar Foam::epsilonWallFunctionFvPatchScalarField::tolerance_ = 1e-1;
 
 // * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
 
@@ -368,85 +368,35 @@ void Foam::epsilonWallFunctionFvPatchScalarField::updateCoeffs()
     const scalarField& epsilon0 = this->epsilon();
 
     typedef DimensionedField<scalar, volMesh> FieldType;
-
     FieldType& G =
         const_cast<FieldType&>
         (
             db().lookupObject<FieldType>(turbModel.GName())
         );
-
-    FieldType& epsilon = const_cast<FieldType&>(internalField());
-
-    forAll(*this, facei)
-    {
-        label celli = patch().faceCells()[facei];
-
-        G[celli] = G0[celli];
-        epsilon[celli] = epsilon0[celli];
-    }
-
-    fvPatchField<scalar>::updateCoeffs();
-}
-
-
-void Foam::epsilonWallFunctionFvPatchScalarField::updateWeightedCoeffs
-(
-    const scalarField& weights
-)
-{
-    if (updated())
-    {
-        return;
-    }
-
-    const momentumTransportModel& turbModel =
-        db().lookupObject<momentumTransportModel>
-        (
-            IOobject::groupName
-            (
-                momentumTransportModel::typeName,
-                internalField().group()
-            )
-        );
-
-    setMaster();
-
-    if (patch().index() == master_)
-    {
-        createAveragingWeights();
-        calculateTurbulenceFields(turbModel, G(true), epsilon(true));
-    }
-
-    const scalarField& G0 = this->G();
-    const scalarField& epsilon0 = this->epsilon();
-
-    typedef DimensionedField<scalar, volMesh> FieldType;
-
-    FieldType& G =
+    FieldType& epsilon =
         const_cast<FieldType&>
         (
-            db().lookupObject<FieldType>(turbModel.GName())
+            internalField()
         );
 
-    FieldType& epsilon = const_cast<FieldType&>(internalField());
-
-    scalarField& epsilonf = *this;
-
-    // Only set the values if the weights are > tolerance
+    scalarField weights(patch().magSf()/patch().patch().magFaceAreas());
     forAll(weights, facei)
     {
-        scalar w = weights[facei];
-
-        if (w > tolerance_)
-        {
-            label celli = patch().faceCells()[facei];
-
-            G[celli] = (1.0 - w)*G[celli] + w*G0[celli];
-            epsilon[celli] = (1.0 - w)*epsilon[celli] + w*epsilon0[celli];
-            epsilonf[facei] = epsilon[celli];
-        }
+        scalar& w = weights[facei];
+        w = w <= tolerance_ ? 0 : (w - tolerance_)/(1 - tolerance_);
     }
 
+    forAll(weights, facei)
+    {
+        const scalar w = weights[facei];
+        const label celli = patch().faceCells()[facei];
+
+        G[celli] = (1 - w)*G[celli] + w*G0[celli];
+        epsilon[celli] = (1 - w)*epsilon[celli] + w*epsilon0[celli];
+    }
+
+    this->operator==(scalarField(epsilon, patch().faceCells()));
+
     fvPatchField<scalar>::updateCoeffs();
 }
 
@@ -461,59 +411,20 @@ void Foam::epsilonWallFunctionFvPatchScalarField::manipulateMatrix
         return;
     }
 
-    matrix.setValues(patch().faceCells(), patchInternalField()());
-
-    fvPatchField<scalar>::manipulateMatrix(matrix);
-}
-
-
-void Foam::epsilonWallFunctionFvPatchScalarField::manipulateMatrix
-(
-    fvMatrix<scalar>& matrix,
-    const Field<scalar>& weights
-)
-{
-    if (manipulatedMatrix())
-    {
-        return;
-    }
-
-    DynamicList<label> constraintCells(weights.size());
-    DynamicList<scalar> constraintEpsilon(weights.size());
-    const labelUList& faceCells = patch().faceCells();
-
-    const DimensionedField<scalar, volMesh>& epsilon
-        = internalField();
-
-    label nConstrainedCells = 0;
-
+    const scalarField& epsilon0 = this->epsilon();
 
+    scalarField weights(patch().magSf()/patch().patch().magFaceAreas());
     forAll(weights, facei)
     {
-        // Only set the values if the weights are > tolerance
-        if (weights[facei] > tolerance_)
-        {
-            nConstrainedCells++;
-
-            label celli = faceCells[facei];
-
-            constraintCells.append(celli);
-            constraintEpsilon.append(epsilon[celli]);
-        }
-    }
-
-    if (debug)
-    {
-        Pout<< "Patch: " << patch().name()
-            << ": number of constrained cells = " << nConstrainedCells
-            << " out of " << patch().size()
-            << endl;
+        scalar& w = weights[facei];
+        w = w <= tolerance_ ? 0 : (w - tolerance_)/(1 - tolerance_);
     }
 
     matrix.setValues
     (
-        constraintCells,
-        scalarField(constraintEpsilon)
+        patch().faceCells(),
+        UIndirectList<scalar>(epsilon0, patch().faceCells()),
+        weights
     );
 
     fvPatchField<scalar>::manipulateMatrix(matrix);
diff --git a/src/MomentumTransportModels/momentumTransportModels/derivedFvPatchFields/wallFunctions/epsilonWallFunctions/epsilonWallFunction/epsilonWallFunctionFvPatchScalarField.H b/src/MomentumTransportModels/momentumTransportModels/derivedFvPatchFields/wallFunctions/epsilonWallFunctions/epsilonWallFunction/epsilonWallFunctionFvPatchScalarField.H
index cde14c5390..dbe4719438 100644
--- a/src/MomentumTransportModels/momentumTransportModels/derivedFvPatchFields/wallFunctions/epsilonWallFunctions/epsilonWallFunction/epsilonWallFunctionFvPatchScalarField.H
+++ b/src/MomentumTransportModels/momentumTransportModels/derivedFvPatchFields/wallFunctions/epsilonWallFunctions/epsilonWallFunction/epsilonWallFunctionFvPatchScalarField.H
@@ -226,18 +226,8 @@ public:
             //- Update the coefficients associated with the patch field
             virtual void updateCoeffs();
 
-            //- Update the coefficients associated with the patch field
-            virtual void updateWeightedCoeffs(const scalarField& weights);
-
             //- Manipulate matrix
             virtual void manipulateMatrix(fvMatrix<scalar>& matrix);
-
-            //- Manipulate matrix with given weights
-            virtual void manipulateMatrix
-            (
-                fvMatrix<scalar>& matrix,
-                const scalarField& weights
-            );
 };
 
 
diff --git a/src/MomentumTransportModels/momentumTransportModels/derivedFvPatchFields/wallFunctions/omegaWallFunctions/omegaWallFunction/omegaWallFunctionFvPatchScalarField.C b/src/MomentumTransportModels/momentumTransportModels/derivedFvPatchFields/wallFunctions/omegaWallFunctions/omegaWallFunction/omegaWallFunctionFvPatchScalarField.C
index cda7d30f26..423aef9f18 100644
--- a/src/MomentumTransportModels/momentumTransportModels/derivedFvPatchFields/wallFunctions/omegaWallFunctions/omegaWallFunction/omegaWallFunctionFvPatchScalarField.C
+++ b/src/MomentumTransportModels/momentumTransportModels/derivedFvPatchFields/wallFunctions/omegaWallFunctions/omegaWallFunction/omegaWallFunctionFvPatchScalarField.C
@@ -36,7 +36,7 @@ namespace Foam
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-scalar omegaWallFunctionFvPatchScalarField::tolerance_ = 1e-5;
+scalar omegaWallFunctionFvPatchScalarField::tolerance_ = 1e-1;
 
 // * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
@@ -415,77 +415,30 @@ void omegaWallFunctionFvPatchScalarField::updateCoeffs()
         (
             db().lookupObject<FieldType>(turbModel.GName())
         );
-
-    FieldType& omega = const_cast<FieldType&>(internalField());
-
-    forAll(*this, facei)
-    {
-        label celli = patch().faceCells()[facei];
-
-        G[celli] = G0[celli];
-        omega[celli] = omega0[celli];
-    }
-
-    fvPatchField<scalar>::updateCoeffs();
-}
-
-
-void omegaWallFunctionFvPatchScalarField::updateWeightedCoeffs
-(
-    const scalarField& weights
-)
-{
-    if (updated())
-    {
-        return;
-    }
-
-    const momentumTransportModel& turbModel =
-        db().lookupObject<momentumTransportModel>
-        (
-            IOobject::groupName
-            (
-                momentumTransportModel::typeName,
-                internalField().group()
-            )
-        );
-
-    setMaster();
-
-    if (patch().index() == master_)
-    {
-        createAveragingWeights();
-        calculateTurbulenceFields(turbModel, G(true), omega(true));
-    }
-
-    const scalarField& G0 = this->G();
-    const scalarField& omega0 = this->omega();
-
-    FieldType& G =
+    FieldType& omega =
         const_cast<FieldType&>
         (
-            db().lookupObject<FieldType>(turbModel.GName())
+            internalField()
         );
 
-    FieldType& omega = const_cast<FieldType&>(internalField());
-
-    scalarField& omegaf = *this;
-
-    // only set the values if the weights are > tolerance
+    scalarField weights(patch().magSf()/patch().patch().magFaceAreas());
     forAll(weights, facei)
     {
-        scalar w = weights[facei];
-
-        if (w > tolerance_)
-        {
-            label celli = patch().faceCells()[facei];
-
-            G[celli] = (1.0 - w)*G[celli] + w*G0[celli];
-            omega[celli] = (1.0 - w)*omega[celli] + w*omega0[celli];
-            omegaf[facei] = omega[celli];
-        }
+        scalar& w = weights[facei];
+        w = w <= tolerance_ ? 0 : (w - tolerance_)/(1 - tolerance_);
     }
 
+    forAll(weights, facei)
+    {
+        const scalar w = weights[facei];
+        const label celli = patch().faceCells()[facei];
+
+        G[celli] = (1 - w)*G[celli] + w*G0[celli];
+        omega[celli] = (1 - w)*omega[celli] + w*omega0[celli];
+    }
+
+    this->operator==(scalarField(omega, patch().faceCells()));
+
     fvPatchField<scalar>::updateCoeffs();
 }
 
@@ -500,59 +453,20 @@ void omegaWallFunctionFvPatchScalarField::manipulateMatrix
         return;
     }
 
-    matrix.setValues(patch().faceCells(), patchInternalField()());
-
-    fvPatchField<scalar>::manipulateMatrix(matrix);
-}
-
-
-void omegaWallFunctionFvPatchScalarField::manipulateMatrix
-(
-    fvMatrix<scalar>& matrix,
-    const Field<scalar>& weights
-)
-{
-    if (manipulatedMatrix())
-    {
-        return;
-    }
-
-    DynamicList<label> constraintCells(weights.size());
-    DynamicList<scalar> constraintomega(weights.size());
-    const labelUList& faceCells = patch().faceCells();
-
-    const DimensionedField<scalar, volMesh>& omega
-        = internalField();
-
-    label nConstrainedCells = 0;
-
+    const scalarField& omega0 = this->omega();
 
+    scalarField weights(patch().magSf()/patch().patch().magFaceAreas());
     forAll(weights, facei)
     {
-        // only set the values if the weights are > tolerance
-        if (weights[facei] > tolerance_)
-        {
-            nConstrainedCells++;
-
-            label celli = faceCells[facei];
-
-            constraintCells.append(celli);
-            constraintomega.append(omega[celli]);
-        }
-    }
-
-    if (debug)
-    {
-        Pout<< "Patch: " << patch().name()
-            << ": number of constrained cells = " << nConstrainedCells
-            << " out of " << patch().size()
-            << endl;
+        scalar& w = weights[facei];
+        w = w <= tolerance_ ? 0 : (w - tolerance_)/(1 - tolerance_);
     }
 
     matrix.setValues
     (
-        constraintCells,
-        scalarField(constraintomega)
+        patch().faceCells(),
+        UIndirectList<scalar>(omega0, patch().faceCells()),
+        weights
     );
 
     fvPatchField<scalar>::manipulateMatrix(matrix);
diff --git a/src/MomentumTransportModels/momentumTransportModels/derivedFvPatchFields/wallFunctions/omegaWallFunctions/omegaWallFunction/omegaWallFunctionFvPatchScalarField.H b/src/MomentumTransportModels/momentumTransportModels/derivedFvPatchFields/wallFunctions/omegaWallFunctions/omegaWallFunction/omegaWallFunctionFvPatchScalarField.H
index 0c380d0f95..d07c5a38d0 100644
--- a/src/MomentumTransportModels/momentumTransportModels/derivedFvPatchFields/wallFunctions/omegaWallFunctions/omegaWallFunction/omegaWallFunctionFvPatchScalarField.H
+++ b/src/MomentumTransportModels/momentumTransportModels/derivedFvPatchFields/wallFunctions/omegaWallFunctions/omegaWallFunction/omegaWallFunctionFvPatchScalarField.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -229,19 +229,9 @@ public:
             //- Update the coefficients associated with the patch field
             virtual void updateCoeffs();
 
-            //- Update the coefficients associated with the patch field
-            virtual void updateWeightedCoeffs(const scalarField& weights);
-
             //- Manipulate matrix
             virtual void manipulateMatrix(fvMatrix<scalar>& matrix);
 
-            //- Manipulate matrix with given weights
-            virtual void manipulateMatrix
-            (
-                fvMatrix<scalar>& matrix,
-                const scalarField& weights
-            );
-
 
         // I-O
 
diff --git a/src/MomentumTransportModels/phaseCompressible/derivedFvPatchFields/wallFunctions/epsilonWallFunctions/epsilonmWallFunction/epsilonmWallFunctionFvPatchScalarField.C b/src/MomentumTransportModels/phaseCompressible/derivedFvPatchFields/wallFunctions/epsilonWallFunctions/epsilonmWallFunction/epsilonmWallFunctionFvPatchScalarField.C
index a53afb96cb..39f2b2ca8d 100644
--- a/src/MomentumTransportModels/phaseCompressible/derivedFvPatchFields/wallFunctions/epsilonWallFunctions/epsilonmWallFunction/epsilonmWallFunctionFvPatchScalarField.C
+++ b/src/MomentumTransportModels/phaseCompressible/derivedFvPatchFields/wallFunctions/epsilonWallFunctions/epsilonmWallFunction/epsilonmWallFunctionFvPatchScalarField.C
@@ -29,7 +29,7 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-Foam::scalar Foam::epsilonmWallFunctionFvPatchScalarField::tolerance_ = 1e-5;
+Foam::scalar Foam::epsilonmWallFunctionFvPatchScalarField::tolerance_ = 1e-1;
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
@@ -96,59 +96,20 @@ void Foam::epsilonmWallFunctionFvPatchScalarField::manipulateMatrix
         return;
     }
 
-    matrix.setValues(patch().faceCells(), patchInternalField()());
-
-    fvPatchField<scalar>::manipulateMatrix(matrix);
-}
-
-
-void Foam::epsilonmWallFunctionFvPatchScalarField::manipulateMatrix
-(
-    fvMatrix<scalar>& matrix,
-    const Field<scalar>& weights
-)
-{
-    if (manipulatedMatrix())
-    {
-        return;
-    }
-
-    DynamicList<label> constraintCells(weights.size());
-    DynamicList<scalar> constraintEpsilon(weights.size());
-    const labelUList& faceCells = patch().faceCells();
-
-    const DimensionedField<scalar, volMesh>& epsilon
-        = internalField();
-
-    label nConstrainedCells = 0;
-
+    const DimensionedField<scalar, volMesh>& epsilon = internalField();
 
+    scalarField weights(patch().magSf()/patch().patch().magFaceAreas());
     forAll(weights, facei)
     {
-        // Only set the values if the weights are > tolerance
-        if (weights[facei] > tolerance_)
-        {
-            nConstrainedCells++;
-
-            label celli = faceCells[facei];
-
-            constraintCells.append(celli);
-            constraintEpsilon.append(epsilon[celli]);
-        }
-    }
-
-    if (debug)
-    {
-        Pout<< "Patch: " << patch().name()
-            << ": number of constrained cells = " << nConstrainedCells
-            << " out of " << patch().size()
-            << endl;
+        scalar& w = weights[facei];
+        w = w <= tolerance_ ? 0 : (w - tolerance_)/(1 - tolerance_);
     }
 
     matrix.setValues
     (
-        constraintCells,
-        scalarField(constraintEpsilon)
+        patch().faceCells(),
+        UIndirectList<scalar>(epsilon, patch().faceCells()),
+        weights
     );
 
     fvPatchField<scalar>::manipulateMatrix(matrix);
diff --git a/src/MomentumTransportModels/phaseCompressible/derivedFvPatchFields/wallFunctions/epsilonWallFunctions/epsilonmWallFunction/epsilonmWallFunctionFvPatchScalarField.H b/src/MomentumTransportModels/phaseCompressible/derivedFvPatchFields/wallFunctions/epsilonWallFunctions/epsilonmWallFunction/epsilonmWallFunctionFvPatchScalarField.H
index c8105a6992..19988bdb84 100644
--- a/src/MomentumTransportModels/phaseCompressible/derivedFvPatchFields/wallFunctions/epsilonWallFunctions/epsilonmWallFunction/epsilonmWallFunctionFvPatchScalarField.H
+++ b/src/MomentumTransportModels/phaseCompressible/derivedFvPatchFields/wallFunctions/epsilonWallFunctions/epsilonmWallFunction/epsilonmWallFunctionFvPatchScalarField.H
@@ -128,13 +128,6 @@ public:
 
             //- Manipulate matrix
             virtual void manipulateMatrix(fvMatrix<scalar>& matrix);
-
-            //- Manipulate matrix with given weights
-            virtual void manipulateMatrix
-            (
-                fvMatrix<scalar>& matrix,
-                const scalarField& weights
-            );
 };
 
 
diff --git a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricBoundaryField.C b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricBoundaryField.C
index 92f49b7f0c..269d355ec3 100644
--- a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricBoundaryField.C
+++ b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricBoundaryField.C
@@ -472,8 +472,11 @@ boundaryInternalField() const
 {
     tmp<GeometricBoundaryField<Type, PatchField, GeoMesh>> tresult
     (
-        GeometricField<Type, PatchField, GeoMesh>::Internal::null(),
-        *this
+        new GeometricBoundaryField<Type, PatchField, GeoMesh>
+        (
+            GeometricField<Type, PatchField, GeoMesh>::Internal::null(),
+            *this
+        )
     );
 
     GeometricBoundaryField<Type, PatchField, GeoMesh>& result = tresult.ref();
@@ -686,6 +689,17 @@ void Foam::GeometricBoundaryField<Type, PatchField, GeoMesh>::operator=
 }
 
 
+template<class Type, template<class> class PatchField, class GeoMesh>
+template<template<class> class OtherPatchField>
+void Foam::GeometricBoundaryField<Type, PatchField, GeoMesh>::operator=
+(
+    const FieldField<OtherPatchField, Type>& ptff
+)
+{
+    FieldField<PatchField, Type>::operator=(ptff);
+}
+
+
 template<class Type, template<class> class PatchField, class GeoMesh>
 void Foam::GeometricBoundaryField<Type, PatchField, GeoMesh>::
 operator=
@@ -724,6 +738,21 @@ operator==
 }
 
 
+template<class Type, template<class> class PatchField, class GeoMesh>
+template<template<class> class OtherPatchField>
+void Foam::GeometricBoundaryField<Type, PatchField, GeoMesh>::
+operator==
+(
+    const FieldField<OtherPatchField, Type>& ptff
+)
+{
+    forAll((*this), patchi)
+    {
+        this->operator[](patchi) == ptff[patchi];
+    }
+}
+
+
 template<class Type, template<class> class PatchField, class GeoMesh>
 void Foam::GeometricBoundaryField<Type, PatchField, GeoMesh>::operator==
 (
diff --git a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricBoundaryField.H b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricBoundaryField.H
index 0144d40cba..3ccd762659 100644
--- a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricBoundaryField.H
+++ b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricBoundaryField.H
@@ -182,6 +182,10 @@ public:
         //- Assignment to FieldField<PatchField, Type>
         void operator=(const FieldField<PatchField, Type>&);
 
+        //- Assignment to FieldField<OtherPatchField, Type>
+        template<template<class> class OtherPatchField>
+        void operator=(const FieldField<OtherPatchField, Type>&);
+
         //- Assignment to Type
         void operator=(const Type&);
 
@@ -193,6 +197,10 @@ public:
         //- Forced assignment to FieldField<PatchField, Type>
         void operator==(const FieldField<PatchField, Type>&);
 
+        //- Forced assignment to FieldField<OtherPatchField, Type>
+        template<template<class> class OtherPatchField>
+        void operator==(const FieldField<OtherPatchField, Type>&);
+
         //- Forced assignment to Type
         void operator==(const Type&);
 };
diff --git a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricField.C b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricField.C
index 520ff52bf7..f817151107 100644
--- a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricField.C
+++ b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricField.C
@@ -736,6 +736,30 @@ Foam::GeometricField<Type, PatchField, GeoMesh>::clone() const
 }
 
 
+template<class Type, template<class> class PatchField, class GeoMesh>
+Foam::tmp<Foam::GeometricField<Type, PatchField, GeoMesh>>
+Foam::GeometricField<Type, PatchField, GeoMesh>::cloneUnSliced() const
+{
+    return tmp<GeometricField<Type, PatchField, GeoMesh>>
+    (
+        new GeometricField<Type, PatchField, GeoMesh>
+        (
+            IOobject
+            (
+                this->name(),
+                this->mesh().thisDb().time().timeName(),
+                this->mesh().thisDb(),
+                IOobject::NO_READ,
+                IOobject::NO_WRITE,
+                false
+            ),
+            *this,
+            GeometricField<Type, PatchField, GeoMesh>::Patch::calculatedType()
+        )
+    );
+}
+
+
 template<class Type, template<class> class PatchField, class GeoMesh>
 Foam::tmp<Foam::GeometricField<Type, PatchField, GeoMesh>>
 Foam::GeometricField<Type, PatchField, GeoMesh>::New
diff --git a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricField.H b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricField.H
index dfaa8c77c8..a5f1b35fbb 100644
--- a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricField.H
+++ b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricField.H
@@ -292,6 +292,9 @@ public:
         //- Clone
         tmp<GeometricField<Type, PatchField, GeoMesh>> clone() const;
 
+        //- Clone un-sliced
+        tmp<GeometricField<Type, PatchField, GeoMesh>> cloneUnSliced() const;
+
         //- Return a temporary field constructed from name,
         //  internal field and list of patch fields
         static tmp<GeometricField<Type, PatchField, GeoMesh>> New
diff --git a/src/OpenFOAM/fields/pointPatchFields/basic/coupled/coupledPointPatchField.H b/src/OpenFOAM/fields/pointPatchFields/basic/coupled/coupledPointPatchField.H
index 76eb74779f..119e1599c7 100644
--- a/src/OpenFOAM/fields/pointPatchFields/basic/coupled/coupledPointPatchField.H
+++ b/src/OpenFOAM/fields/pointPatchFields/basic/coupled/coupledPointPatchField.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -109,28 +109,6 @@ public:
             {
                 return true;
             }
-
-            //- Evaluate the patch field
-            virtual void evaluate
-            (
-                const Pstream::commsTypes commsType =
-                    Pstream::commsTypes::blocking
-            ) = 0;
-
-            //- Initialise swap of patch point values
-            virtual void initSwapAddSeparated
-            (
-                const Pstream::commsTypes,
-                Field<Type>&
-            ) const
-            {}
-
-            //- Complete swap of patch point values and add to local values
-            virtual void swapAddSeparated
-            (
-                const Pstream::commsTypes,
-                Field<Type>&
-            ) const = 0;
 };
 
 
diff --git a/src/OpenFOAM/fields/pointPatchFields/constraint/cyclic/cyclicPointPatchField.C b/src/OpenFOAM/fields/pointPatchFields/constraint/cyclic/cyclicPointPatchField.C
index 3060682be8..8cf2b24c69 100644
--- a/src/OpenFOAM/fields/pointPatchFields/constraint/cyclic/cyclicPointPatchField.C
+++ b/src/OpenFOAM/fields/pointPatchFields/constraint/cyclic/cyclicPointPatchField.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -101,68 +101,4 @@ Foam::cyclicPointPatchField<Type>::cyclicPointPatchField
 {}
 
 
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-template<class Type>
-void Foam::cyclicPointPatchField<Type>::swapAddSeparated
-(
-    const Pstream::commsTypes,
-    Field<Type>& pField
-) const
-{
-    // Get neighbouring pointPatch
-    const cyclicPointPatch& nbrPatch = cyclicPatch_.nbrPatch();
-
-    if (cyclicPatch_.cyclicPatch().owner())
-    {
-        // We inplace modify pField. To prevent the other side (which gets
-        // evaluated at a later date) using already changed values we do
-        // all swaps on the side that gets evaluated first.
-
-        // Get neighbouring pointPatchField
-        const GeometricField<Type, pointPatchField, pointMesh>& fld =
-            refCast<const GeometricField<Type, pointPatchField, pointMesh>>
-            (
-                this->internalField()
-            );
-
-        const cyclicPointPatchField<Type>& nbr =
-            refCast<const cyclicPointPatchField<Type>>
-            (
-                fld.boundaryField()[nbrPatch.index()]
-            );
-
-
-        Field<Type> pf(this->patchInternalField(pField));
-        Field<Type> nbrPf(nbr.patchInternalField(pField));
-
-        const edgeList& pairs = cyclicPatch_.transformPairs();
-
-        if (transform().template transforms<Type>())
-        {
-            // Transform both sides.
-            forAll(pairs, pairi)
-            {
-                label pointi = pairs[pairi][0];
-                label nbrPointi = pairs[pairi][1];
-
-                Type tmp = pf[pointi];
-                pf[pointi] = transform().transform(nbrPf[nbrPointi]);
-                nbrPf[nbrPointi] = transform().invTransform(tmp);
-            }
-        }
-        else
-        {
-            forAll(pairs, pairi)
-            {
-                Swap(pf[pairs[pairi][0]], nbrPf[pairs[pairi][1]]);
-            }
-        }
-
-        this->addToInternalField(pField, pf);
-        nbr.addToInternalField(pField, nbrPf);
-    }
-}
-
-
 // ************************************************************************* //
diff --git a/src/OpenFOAM/fields/pointPatchFields/constraint/cyclic/cyclicPointPatchField.H b/src/OpenFOAM/fields/pointPatchFields/constraint/cyclic/cyclicPointPatchField.H
index be057b74fc..e749241420 100644
--- a/src/OpenFOAM/fields/pointPatchFields/constraint/cyclic/cyclicPointPatchField.H
+++ b/src/OpenFOAM/fields/pointPatchFields/constraint/cyclic/cyclicPointPatchField.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2021 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -133,13 +133,6 @@ public:
                     Pstream::commsTypes::blocking
             )
             {}
-
-            //- Complete swap of patch point values and add to local values
-            virtual void swapAddSeparated
-            (
-                const Pstream::commsTypes commsType,
-                Field<Type>&
-            ) const;
 };
 
 
diff --git a/src/OpenFOAM/fields/pointPatchFields/constraint/processor/processorPointPatchField.H b/src/OpenFOAM/fields/pointPatchFields/constraint/processor/processorPointPatchField.H
index 2a6ca6ba0e..a569dcfdca 100644
--- a/src/OpenFOAM/fields/pointPatchFields/constraint/processor/processorPointPatchField.H
+++ b/src/OpenFOAM/fields/pointPatchFields/constraint/processor/processorPointPatchField.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2021 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -144,14 +144,6 @@ public:
                     Pstream::commsTypes::blocking
             )
             {}
-
-            //- Assume processor patch always collocated
-            virtual void swapAddSeparated
-            (
-                const Pstream::commsTypes commsType,
-                Field<Type>&
-            ) const
-            {}
 };
 
 
diff --git a/src/OpenFOAM/fields/pointPatchFields/constraint/processorCyclic/processorCyclicPointPatchField.C b/src/OpenFOAM/fields/pointPatchFields/constraint/processorCyclic/processorCyclicPointPatchField.C
index f71ae934d4..9b09de7a70 100644
--- a/src/OpenFOAM/fields/pointPatchFields/constraint/processorCyclic/processorCyclicPointPatchField.C
+++ b/src/OpenFOAM/fields/pointPatchFields/constraint/processorCyclic/processorCyclicPointPatchField.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -91,87 +91,4 @@ Foam::processorCyclicPointPatchField<Type>::~processorCyclicPointPatchField()
 {}
 
 
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-template<class Type>
-void Foam::processorCyclicPointPatchField<Type>::initSwapAddSeparated
-(
-    const Pstream::commsTypes commsType,
-    Field<Type>& pField
-) const
-{
-    if (Pstream::parRun())
-    {
-        // Get internal field into correct order for opposite side
-        Field<Type> pf
-        (
-            this->patchInternalField
-            (
-                pField,
-                procPatch_.reverseMeshPoints()
-            )
-        );
-
-        if (commsType == Pstream::commsTypes::nonBlocking)
-        {
-            receiveBuf_.setSize(pf.size());
-            IPstream::read
-            (
-                commsType,
-                procPatch_.neighbProcNo(),
-                reinterpret_cast<char*>(receiveBuf_.begin()),
-                receiveBuf_.byteSize(),
-                procPatch_.tag(),
-                procPatch_.comm()
-            );
-        }
-        OPstream::write
-        (
-            commsType,
-            procPatch_.neighbProcNo(),
-            reinterpret_cast<const char*>(pf.begin()),
-            pf.byteSize(),
-            procPatch_.tag(),
-            procPatch_.comm()
-        );
-    }
-}
-
-
-template<class Type>
-void Foam::processorCyclicPointPatchField<Type>::swapAddSeparated
-(
-    const Pstream::commsTypes commsType,
-    Field<Type>& pField
-) const
-{
-    if (Pstream::parRun())
-    {
-        // If nonblocking data has already been received into receiveBuf_
-        if (commsType != Pstream::commsTypes::nonBlocking)
-        {
-            receiveBuf_.setSize(this->size());
-            IPstream::read
-            (
-                commsType,
-                procPatch_.neighbProcNo(),
-                reinterpret_cast<char*>(receiveBuf_.begin()),
-                receiveBuf_.byteSize(),
-                procPatch_.tag(),
-                procPatch_.comm()
-            );
-        }
-
-        procPatch_.procCyclicPolyPatch().transform().transform
-        (
-            receiveBuf_,
-            receiveBuf_
-        );
-
-        // All points are separated
-        this->addToInternalField(pField, receiveBuf_);
-    }
-}
-
-
 // ************************************************************************* //
diff --git a/src/OpenFOAM/fields/pointPatchFields/constraint/processorCyclic/processorCyclicPointPatchField.H b/src/OpenFOAM/fields/pointPatchFields/constraint/processorCyclic/processorCyclicPointPatchField.H
index cdcc7f021e..0ecef4fe69 100644
--- a/src/OpenFOAM/fields/pointPatchFields/constraint/processorCyclic/processorCyclicPointPatchField.H
+++ b/src/OpenFOAM/fields/pointPatchFields/constraint/processorCyclic/processorCyclicPointPatchField.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -148,20 +148,6 @@ public:
                     Pstream::commsTypes::blocking
             )
             {}
-
-            //- Initialise swap of non-collocated patch point values
-            virtual void initSwapAddSeparated
-            (
-                const Pstream::commsTypes commsType,
-                Field<Type>&
-            ) const;
-
-            //- Complete swap of patch point values and add to local values
-            virtual void swapAddSeparated
-            (
-                const Pstream::commsTypes commsType,
-                Field<Type>&
-            ) const;
 };
 
 
diff --git a/src/OpenFOAM/global/argList/argList.C b/src/OpenFOAM/global/argList/argList.C
index 5d169491a9..8e6517b681 100644
--- a/src/OpenFOAM/global/argList/argList.C
+++ b/src/OpenFOAM/global/argList/argList.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2021 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -295,6 +295,20 @@ bool Foam::argList::postProcess(int argc, char *argv[])
 }
 
 
+bool Foam::argList::hasArgs(int argc, char *argv[])
+{
+    for (int i=1; i<argc; i++)
+    {
+        if (argv[i][0] != '-')
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
 // Convert argv -> args_
diff --git a/src/OpenFOAM/global/argList/argList.H b/src/OpenFOAM/global/argList/argList.H
index 04082bc36d..813e4bfbdd 100644
--- a/src/OpenFOAM/global/argList/argList.H
+++ b/src/OpenFOAM/global/argList/argList.H
@@ -368,6 +368,9 @@ public:
             //- Return true if the post-processing option is specified
             static bool postProcess(int argc, char *argv[]);
 
+            //- Return true if there are arguments
+            static bool hasArgs(int argc, char *argv[]);
+
             //- Set option directly (use with caution)
             //  An option with an empty param is a bool option.
             //  Not all valid options can also be set: eg, -case, -roots, ...
diff --git a/src/OpenFOAM/matrices/LduMatrix/LduMatrix/SolverPerformance.C b/src/OpenFOAM/matrices/LduMatrix/LduMatrix/SolverPerformance.C
index cb11badded..7558735f4d 100644
--- a/src/OpenFOAM/matrices/LduMatrix/LduMatrix/SolverPerformance.C
+++ b/src/OpenFOAM/matrices/LduMatrix/LduMatrix/SolverPerformance.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -102,12 +102,12 @@ void Foam::SolverPerformance<Type>::print
     {
         if (pTraits<Type>::nComponents == 1)
         {
-            os  << solverName_ << ":  Solving for " << fieldName_;
+            os  << indent << solverName_ << ":  Solving for " << fieldName_;
 
         }
         else
         {
-            os  << solverName_ << ":  Solving for "
+            os  << indent << solverName_ << ":  Solving for "
                 << word(fieldName_ + pTraits<Type>::componentNames[cmpt]);
         }
 
diff --git a/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/interfaceFields/cyclicGAMGInterfaceField/cyclicGAMGInterfaceField.C b/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/interfaceFields/cyclicGAMGInterfaceField/cyclicGAMGInterfaceField.C
index f8cf44ad02..6a67a70fd6 100644
--- a/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/interfaceFields/cyclicGAMGInterfaceField/cyclicGAMGInterfaceField.C
+++ b/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/interfaceFields/cyclicGAMGInterfaceField/cyclicGAMGInterfaceField.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -60,6 +60,22 @@ namespace Foam
         lduInterfaceField,
         cyclicSlip
     );
+
+    // Add under name nonConformalCyclic
+    addNamedToRunTimeSelectionTable
+    (
+        GAMGInterfaceField,
+        cyclicGAMGInterfaceField,
+        lduInterface,
+        nonConformalCyclic
+    );
+    addNamedToRunTimeSelectionTable
+    (
+        GAMGInterfaceField,
+        cyclicGAMGInterfaceField,
+        lduInterfaceField,
+        nonConformalCyclic
+    );
 }
 
 
diff --git a/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/interfaceFields/processorCyclicGAMGInterfaceField/processorCyclicGAMGInterfaceField.C b/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/interfaceFields/processorCyclicGAMGInterfaceField/processorCyclicGAMGInterfaceField.C
index 627b854241..e01a6f78b4 100644
--- a/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/interfaceFields/processorCyclicGAMGInterfaceField/processorCyclicGAMGInterfaceField.C
+++ b/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/interfaceFields/processorCyclicGAMGInterfaceField/processorCyclicGAMGInterfaceField.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -44,6 +44,22 @@ namespace Foam
         processorCyclicGAMGInterfaceField,
         lduInterfaceField
     );
+
+    // Add under name nonConformalProcessorCyclic
+    addNamedToRunTimeSelectionTable
+    (
+        GAMGInterfaceField,
+        processorCyclicGAMGInterfaceField,
+        lduInterface,
+        nonConformalProcessorCyclic
+    );
+    addNamedToRunTimeSelectionTable
+    (
+        GAMGInterfaceField,
+        processorCyclicGAMGInterfaceField,
+        lduInterfaceField,
+        nonConformalProcessorCyclic
+    );
 }
 
 
diff --git a/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/interfaces/cyclicGAMGInterface/cyclicGAMGInterface.C b/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/interfaces/cyclicGAMGInterface/cyclicGAMGInterface.C
index 3160fc46e8..abce503d93 100644
--- a/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/interfaces/cyclicGAMGInterface/cyclicGAMGInterface.C
+++ b/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/interfaces/cyclicGAMGInterface/cyclicGAMGInterface.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -46,7 +46,6 @@ namespace Foam
         Istream
     );
 
-
     // Add under name cyclicSlip
     addNamedToRunTimeSelectionTable
     (
@@ -62,6 +61,22 @@ namespace Foam
         Istream,
         cyclicSlip
     );
+
+    // Add under name nonConformalCyclic
+    addNamedToRunTimeSelectionTable
+    (
+        GAMGInterface,
+        cyclicGAMGInterface,
+        lduInterface,
+        nonConformalCyclic
+    );
+    addNamedToRunTimeSelectionTable
+    (
+        GAMGInterface,
+        cyclicGAMGInterface,
+        Istream,
+        nonConformalCyclic
+    );
 }
 
 
diff --git a/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/interfaces/processorCyclicGAMGInterface/processorCyclicGAMGInterface.C b/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/interfaces/processorCyclicGAMGInterface/processorCyclicGAMGInterface.C
index 6087b03737..58028484c1 100644
--- a/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/interfaces/processorCyclicGAMGInterface/processorCyclicGAMGInterface.C
+++ b/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/interfaces/processorCyclicGAMGInterface/processorCyclicGAMGInterface.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -44,6 +44,22 @@ namespace Foam
         processorCyclicGAMGInterface,
         Istream
     );
+
+    // Add under name nonConformalProcessorCyclic
+    addNamedToRunTimeSelectionTable
+    (
+        GAMGInterface,
+        processorCyclicGAMGInterface,
+        lduInterface,
+        nonConformalProcessorCyclic
+    );
+    addNamedToRunTimeSelectionTable
+    (
+        GAMGInterface,
+        processorCyclicGAMGInterface,
+        Istream,
+        nonConformalProcessorCyclic
+    );
 }
 
 
diff --git a/src/OpenFOAM/matrices/solution/solution.C b/src/OpenFOAM/matrices/solution/solution.C
index 12739b621a..6e60001ee0 100644
--- a/src/OpenFOAM/matrices/solution/solution.C
+++ b/src/OpenFOAM/matrices/solution/solution.C
@@ -131,12 +131,7 @@ Foam::solution::solution
             dictName,
             obr.time().system(),
             obr,
-            (
-                obr.readOpt() == IOobject::MUST_READ
-             || obr.readOpt() == IOobject::READ_IF_PRESENT
-              ? IOobject::MUST_READ_IF_MODIFIED
-              : obr.readOpt()
-            ),
+            IOobject::MUST_READ_IF_MODIFIED,
             IOobject::NO_WRITE
         )
     ),
@@ -148,15 +143,7 @@ Foam::solution::solution
     eqnRelaxDefault_(0),
     solvers_(dictionary::null)
 {
-    if
-    (
-        readOpt() == IOobject::MUST_READ
-     || readOpt() == IOobject::MUST_READ_IF_MODIFIED
-     || (readOpt() == IOobject::READ_IF_PRESENT && headerOk())
-    )
-    {
-        read(dict());
-    }
+    read(dict());
 }
 
 
diff --git a/src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/processor/processorPointPatch.H b/src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/processor/processorPointPatch.H
index 9598672114..3369fa0a73 100644
--- a/src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/processor/processorPointPatch.H
+++ b/src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/processor/processorPointPatch.H
@@ -151,15 +151,8 @@ public:
             return !isMaster();
         }
 
-        //- Return the underlying processorPolyPatch
-        const processorPolyPatch& procPolyPatch() const
-        {
-            return procPolyPatch_;
-        }
-
         //- Return mesh points in the correct order for the receiving side
         const labelList& reverseMeshPoints() const;
-
 };
 
 
diff --git a/src/OpenFOAM/meshes/polyMesh/polyBoundaryMesh/polyBoundaryMesh.C b/src/OpenFOAM/meshes/polyMesh/polyBoundaryMesh/polyBoundaryMesh.C
index 6a80f59854..685fd9f9ee 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyBoundaryMesh/polyBoundaryMesh.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyBoundaryMesh/polyBoundaryMesh.C
@@ -431,6 +431,35 @@ const Foam::labelList& Foam::polyBoundaryMesh::patchID() const
 }
 
 
+const Foam::labelList& Foam::polyBoundaryMesh::patchFaceID() const
+{
+    if (!patchFaceIDPtr_.valid())
+    {
+        patchFaceIDPtr_.reset
+        (
+            new labelList
+            (
+                mesh_.nFaces()
+              - mesh_.nInternalFaces()
+            )
+        );
+        labelList& patchFaceID = patchFaceIDPtr_();
+
+        const polyBoundaryMesh& bm = *this;
+
+        forAll(bm, patchi)
+        {
+            label bFacei = bm[patchi].start() - mesh_.nInternalFaces();
+            forAll(bm[patchi], i)
+            {
+                patchFaceID[bFacei++] = i;
+            }
+        }
+    }
+    return patchFaceIDPtr_();
+}
+
+
 const Foam::HashTable<Foam::labelList, Foam::word>&
 Foam::polyBoundaryMesh::groupPatchIDs() const
 {
diff --git a/src/OpenFOAM/meshes/polyMesh/polyBoundaryMesh/polyBoundaryMesh.H b/src/OpenFOAM/meshes/polyMesh/polyBoundaryMesh/polyBoundaryMesh.H
index 037e97dbb2..b5211defa1 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyBoundaryMesh/polyBoundaryMesh.H
+++ b/src/OpenFOAM/meshes/polyMesh/polyBoundaryMesh/polyBoundaryMesh.H
@@ -70,6 +70,8 @@ class polyBoundaryMesh
 
         mutable autoPtr<labelList> patchIDPtr_;
 
+        mutable autoPtr<labelList> patchFaceIDPtr_;
+
         mutable autoPtr<HashTable<labelList, word>> groupPatchIDsPtr_;
 
         //- Edges of neighbouring patches
@@ -183,6 +185,9 @@ public:
         //- Per boundary face label the patch index
         const labelList& patchID() const;
 
+        //- Per boundary face label the patch face index
+        const labelList& patchFaceID() const;
+
         //- Per patch group the patch indices
         const HashTable<labelList, word>& groupPatchIDs() const;
 
diff --git a/src/OpenFOAM/meshes/polyMesh/polyMesh.H b/src/OpenFOAM/meshes/polyMesh/polyMesh.H
index 5f6dd6f3c3..d3312ccfd7 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyMesh.H
+++ b/src/OpenFOAM/meshes/polyMesh/polyMesh.H
@@ -403,6 +403,9 @@ public:
             //- Set the instance for mesh files
             void setInstance(const fileName&);
 
+            //- Set the instance for the points files
+            void setPointsInstance(const fileName&);
+
 
         // Access
 
diff --git a/src/OpenFOAM/meshes/polyMesh/polyMeshIO.C b/src/OpenFOAM/meshes/polyMesh/polyMeshIO.C
index fbc63abfe0..5a4ad08056 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyMeshIO.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyMeshIO.C
@@ -68,6 +68,24 @@ void Foam::polyMesh::setInstance(const fileName& inst)
 }
 
 
+void Foam::polyMesh::setPointsInstance(const fileName& inst)
+{
+    if (debug)
+    {
+        InfoInFunction << "Resetting file instance to " << inst << endl;
+    }
+
+    points_.writeOpt() = IOobject::AUTO_WRITE;
+    points_.instance() = inst;
+
+    if (tetBasePtIsPtr_.valid())
+    {
+        tetBasePtIsPtr_->writeOpt() = IOobject::AUTO_WRITE;
+        tetBasePtIsPtr_->instance() = inst;
+    }
+}
+
+
 Foam::polyMesh::readUpdateState Foam::polyMesh::readUpdate()
 {
     if (debug)
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.C b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.C
index 3507a6765c..520c15067e 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.C
@@ -39,6 +39,36 @@ namespace Foam
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
+Foam::processorCyclicPolyPatch::processorCyclicPolyPatch
+(
+    const word& name,
+    const label size,
+    const label start,
+    const label index,
+    const polyBoundaryMesh& bm,
+    const int myProcNo,
+    const int neighbProcNo,
+    const word& referPatchName,
+    const word& patchType
+)
+:
+    processorPolyPatch
+    (
+        name,
+        size,
+        start,
+        index,
+        bm,
+        myProcNo,
+        neighbProcNo,
+        patchType
+    ),
+    referPatchName_(referPatchName),
+    tag_(-1),
+    referPatchID_(-1)
+{}
+
+
 Foam::processorCyclicPolyPatch::processorCyclicPolyPatch
 (
     const label size,
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.H b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.H
index 5c3c3ff2c2..2831ac21b2 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.H
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.H
@@ -67,6 +67,23 @@ class processorCyclicPolyPatch
 
 protected:
 
+    // Protected constructors
+
+        //- Construct from components with specified name
+        processorCyclicPolyPatch
+        (
+            const word& name,
+            const label size,
+            const label start,
+            const label index,
+            const polyBoundaryMesh& bm,
+            const int myProcNo,
+            const int neighbProcNo,
+            const word& referPatchName,
+            const word& patchType = typeName
+        );
+
+
     // Protected Member functions
 
         //- Initialise the calculation of the patch geometry
@@ -245,7 +262,7 @@ public:
             const polyBoundaryMesh& bm
         );
 
-        //- Referring patchID.
+        //- Return the referring patchID
         label referPatchID() const
         {
             if (referPatchID_ == -1)
@@ -266,6 +283,7 @@ public:
             return referPatchID_;
         }
 
+        //- Return a reference to the referring patch
         const cyclicPolyPatch& referPatch() const
         {
             const polyPatch& pp = this->boundaryMesh()[referPatchID()];
diff --git a/src/dynamicMesh/fvMeshSubset/fvMeshSubset.C b/src/dynamicMesh/fvMeshSubset/fvMeshSubset.C
index f2e80e116d..a8d007a13a 100644
--- a/src/dynamicMesh/fvMeshSubset/fvMeshSubset.C
+++ b/src/dynamicMesh/fvMeshSubset/fvMeshSubset.C
@@ -39,6 +39,14 @@ Description
 #include "polyTopoChange.H"
 #include "polyTopoChangeMap.H"
 
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(fvMeshSubset, 0);
+}
+
+
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
 bool Foam::fvMeshSubset::checkCellSubset() const
@@ -264,7 +272,7 @@ void Foam::fvMeshSubset::doCoupledPatches
         reduce(nUncoupled, sumOp<label>());
     }
 
-    if (nUncoupled > 0)
+    if (debug && nUncoupled > 0)
     {
         Info<< "Uncoupled " << nUncoupled << " faces on coupled patches. "
             << "(processorPolyPatch, cyclicPolyPatch)" << endl;
@@ -473,6 +481,12 @@ Foam::fvMeshSubset::fvMeshSubset(const fvMesh& baseMesh)
 {}
 
 
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::fvMeshSubset::~fvMeshSubset()
+{}
+
+
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 void Foam::fvMeshSubset::setCellSubset
diff --git a/src/dynamicMesh/fvMeshSubset/fvMeshSubset.H b/src/dynamicMesh/fvMeshSubset/fvMeshSubset.H
index 7641460e6e..0820cb053d 100644
--- a/src/dynamicMesh/fvMeshSubset/fvMeshSubset.H
+++ b/src/dynamicMesh/fvMeshSubset/fvMeshSubset.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2021 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -137,6 +137,10 @@ class fvMeshSubset
 
 public:
 
+    //- Runtime type information
+    TypeName("fvMeshSubset");
+
+
     // Constructors
 
         //- Construct given a mesh to subset
@@ -146,6 +150,10 @@ public:
         fvMeshSubset(const fvMeshSubset&) = delete;
 
 
+    //- Destructor
+    virtual ~fvMeshSubset();
+
+
     // Member Functions
 
         // Edit
diff --git a/src/finiteVolume/Make/files b/src/finiteVolume/Make/files
index d40837f061..6a412ef5f4 100644
--- a/src/finiteVolume/Make/files
+++ b/src/finiteVolume/Make/files
@@ -31,6 +31,11 @@ $(constraintFvPatches)/symmetryPlane/symmetryPlaneFvPatch.C
 $(constraintFvPatches)/symmetry/symmetryFvPatch.C
 $(constraintFvPatches)/wedge/wedgeFvPatch.C
 $(constraintFvPatches)/internal/internalFvPatch.C
+$(constraintFvPatches)/nonConformal/nonConformalFvPatch.C
+$(constraintFvPatches)/nonConformalCoupled/nonConformalCoupledFvPatch.C
+$(constraintFvPatches)/nonConformalCyclic/nonConformalCyclicFvPatch.C
+$(constraintFvPatches)/nonConformalError/nonConformalErrorFvPatch.C
+$(constraintFvPatches)/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvPatch.C
 
 derivedFvPatches = $(fvPatches)/derived
 $(derivedFvPatches)/wall/wallFvPatch.C
@@ -115,6 +120,12 @@ $(fvMeshMovers)/fvMeshMover/fvMeshMover.C
 $(fvMeshMovers)/fvMeshMover/fvMeshMoverNew.C
 $(fvMeshMovers)/none/fvMeshMoversNone.C
 
+fvMeshStitchers = fvMesh/fvMeshStitchers
+
+$(fvMeshStitchers)/fvMeshStitcher/fvMeshStitcher.C
+$(fvMeshStitchers)/fvMeshStitcher/fvMeshStitcherNew.C
+$(fvMeshStitchers)/stationary/fvMeshStitchersStationary.C
+
 functionObjects/fvMeshFunctionObject/fvMeshFunctionObject.C
 functionObjects/volRegion/volRegion.C
 
@@ -153,6 +164,9 @@ $(constraintFvPatchFields)/symmetry/symmetryFvPatchFields.C
 $(constraintFvPatchFields)/wedge/wedgeFvPatchFields.C
 $(constraintFvPatchFields)/wedge/wedgeFvPatchScalarField.C
 $(constraintFvPatchFields)/internal/internalFvPatchFields.C
+$(constraintFvPatchFields)/nonConformalCyclic/nonConformalCyclicFvPatchFields.C
+$(constraintFvPatchFields)/nonConformalError/nonConformalErrorFvPatchFields.C
+$(constraintFvPatchFields)/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvPatchFields.C
 
 derivedFvPatchFields = $(fvPatchFields)/derived
 $(derivedFvPatchFields)/activeBaffleVelocity/activeBaffleVelocityFvPatchVectorField.C
@@ -250,6 +264,7 @@ $(fvsPatchFields)/fvsPatchField/fvsPatchFields.C
 
 basicFvsPatchFields = $(fvsPatchFields)/basic
 $(basicFvsPatchFields)/calculated/calculatedFvsPatchFields.C
+$(basicFvsPatchFields)/nonConformalCalculated/nonConformalCalculatedFvsPatchFields.C
 $(basicFvsPatchFields)/coupled/coupledFvsPatchFields.C
 $(basicFvsPatchFields)/fixedValue/fixedValueFvsPatchFields.C
 $(basicFvsPatchFields)/sliced/slicedFvsPatchFields.C
@@ -267,6 +282,9 @@ $(constraintFvsPatchFields)/symmetryPlane/symmetryPlaneFvsPatchFields.C
 $(constraintFvsPatchFields)/symmetry/symmetryFvsPatchFields.C
 $(constraintFvsPatchFields)/wedge/wedgeFvsPatchFields.C
 $(constraintFvsPatchFields)/internal/internalFvsPatchFields.C
+$(constraintFvsPatchFields)/nonConformalCyclic/nonConformalCyclicFvsPatchFields.C
+$(constraintFvsPatchFields)/nonConformalError/nonConformalErrorFvsPatchFields.C
+$(constraintFvsPatchFields)/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvsPatchFields.C
 
 fields/volFields/volFields.C
 fields/surfaceFields/surfaceFields.C
diff --git a/src/finiteVolume/algorithms/FvFaceCellWave/FvFaceCellWave.C b/src/finiteVolume/algorithms/FvFaceCellWave/FvFaceCellWave.C
index b7bacbf7a7..0b73472635 100644
--- a/src/finiteVolume/algorithms/FvFaceCellWave/FvFaceCellWave.C
+++ b/src/finiteVolume/algorithms/FvFaceCellWave/FvFaceCellWave.C
@@ -27,6 +27,7 @@ License
 #include "processorFvPatch.H"
 #include "cyclicFvPatch.H"
 #include "cyclicAMIFvPatch.H"
+#include "CompactListList.H"
 #include "OPstream.H"
 #include "IPstream.H"
 #include "PstreamReduceOps.H"
@@ -850,9 +851,9 @@ Foam::label Foam::FvFaceCellWave<Type, TrackingData>::faceToCell()
     const labelList& owner = mesh_.owner();
     const labelList& neighbour = mesh_.neighbour();
 
-    forAll(changedPatchAndFaces_, i)
+    forAll(changedPatchAndFaces_, changedFacei)
     {
-        const labelPair& patchAndFacei = changedPatchAndFaces_[i];
+        const labelPair& patchAndFacei = changedPatchAndFaces_[changedFacei];
         const label patchi = patchAndFacei.first();
         const label facei = patchAndFacei.second();
 
@@ -929,9 +930,9 @@ Foam::label Foam::FvFaceCellWave<Type, TrackingData>::cellToFace()
 {
     const cellList& cells = mesh_.cells();
 
-    forAll(changedCells_, i)
+    forAll(changedCells_, changedCelli)
     {
-        const label celli = changedCells_[i];
+        const label celli = changedCells_[changedCelli];
 
         if (!cellChanged_[celli])
         {
@@ -946,35 +947,39 @@ Foam::label Foam::FvFaceCellWave<Type, TrackingData>::cellToFace()
         forAll(cells[celli], cellFacei)
         {
             // Get the patch (if any) and face index
-            label patchi, facei;
-            const label polyFacei = cells[celli][cellFacei];
+            label polyFacei = cells[celli][cellFacei];
+
+            // Get the FV patches and faces associated with this poly face
+            labelUList patches, faces;
             if (polyFacei < mesh_.nInternalFaces())
             {
-                patchi = -1;
-                facei = polyFacei;
+                static label noPatchi = -1;
+                patches.shallowCopy(labelUList(&noPatchi, 1));
+                faces.shallowCopy(labelUList(&polyFacei, 1));
             }
             else
             {
                 const label polyBFacei = polyFacei - mesh_.nInternalFaces();
-                patchi = mesh_.boundaryMesh().patchID()[polyBFacei];
-                facei = polyFacei - mesh_.boundaryMesh()[patchi].start();
+                patches.shallowCopy(mesh_.polyBFacePatches()[polyBFacei]);
+                faces.shallowCopy(mesh_.polyBFacePatchFaces()[polyBFacei]);
             }
 
-            // If connected to an empty patch then skip this face
-            if (patchi != -1 && !mesh_.boundary()[patchi].size()) continue;
-
-            Type& connectedInfo = faceInfo({patchi, facei});
-
-            if (!connectedInfo.equal(info, td_))
+            // Propagate into the connected FV faces
+            forAll(patches, i)
             {
-                updateFace
-                (
-                    {patchi, facei},
-                    celli,
-                    info,
-                    propagationTol_,
-                    connectedInfo
-                );
+                Type& connectedInfo = faceInfo({patches[i], faces[i]});
+
+                if (!connectedInfo.equal(info, td_))
+                {
+                    updateFace
+                    (
+                        {patches[i], faces[i]},
+                        celli,
+                        info,
+                        propagationTol_,
+                        connectedInfo
+                    );
+                }
             }
         }
 
diff --git a/src/finiteVolume/fields/fvPatchFields/basic/coupled/coupledFvPatchField.H b/src/finiteVolume/fields/fvPatchFields/basic/coupled/coupledFvPatchField.H
index 96a1a68b72..b36b678a07 100644
--- a/src/finiteVolume/fields/fvPatchFields/basic/coupled/coupledFvPatchField.H
+++ b/src/finiteVolume/fields/fvPatchFields/basic/coupled/coupledFvPatchField.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -126,7 +126,11 @@ public:
             }
 
             //- Return neighbour field of internal field
-            virtual tmp<Field<Type>> patchNeighbourField() const = 0;
+            virtual tmp<Field<Type>> patchNeighbourField
+            (
+                const Pstream::commsTypes commsType =
+                    Pstream::commsTypes::blocking
+            ) const = 0;
 
 
         // Evaluation functions
diff --git a/src/finiteVolume/fields/fvPatchFields/basic/sliced/slicedFvPatchField.C b/src/finiteVolume/fields/fvPatchFields/basic/sliced/slicedFvPatchField.C
index c4eb124097..5926306f07 100644
--- a/src/finiteVolume/fields/fvPatchFields/basic/sliced/slicedFvPatchField.C
+++ b/src/finiteVolume/fields/fvPatchFields/basic/sliced/slicedFvPatchField.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -112,46 +112,6 @@ void Foam::slicedFvPatchField<Type>::updateCoeffs()
 }
 
 
-template<class Type>
-Foam::tmp<Foam::Field<Type>>
-Foam::slicedFvPatchField<Type>::patchInternalField() const
-{
-    NotImplemented;
-
-    return Field<Type>::null();
-}
-
-
-template<class Type>
-void Foam::slicedFvPatchField<Type>::patchInternalField(Field<Type>&) const
-{
-    NotImplemented;
-}
-
-
-template<class Type>
-Foam::tmp<Foam::Field<Type>>
-Foam::slicedFvPatchField<Type>::patchNeighbourField
-(
-    const Field<Type>& iField
-) const
-{
-    NotImplemented;
-
-    return Field<Type>::null();
-}
-
-
-template<class Type>
-Foam::tmp<Foam::Field<Type>>
-Foam::slicedFvPatchField<Type>::patchNeighbourField() const
-{
-    NotImplemented;
-
-    return Field<Type>::null();
-}
-
-
 template<class Type>
 Foam::tmp<Foam::Field<Type>>
 Foam::slicedFvPatchField<Type>::valueInternalCoeffs
diff --git a/src/finiteVolume/fields/fvPatchFields/basic/sliced/slicedFvPatchField.H b/src/finiteVolume/fields/fvPatchFields/basic/sliced/slicedFvPatchField.H
index 6ea8f03535..516c658dcb 100644
--- a/src/finiteVolume/fields/fvPatchFields/basic/sliced/slicedFvPatchField.H
+++ b/src/finiteVolume/fields/fvPatchFields/basic/sliced/slicedFvPatchField.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2021 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -134,22 +134,6 @@ public:
             //  Sets Updated to true
             virtual void updateCoeffs();
 
-            //- Return internal field next to patch as patch field
-            virtual tmp<Field<Type>> patchInternalField() const;
-
-            //- Return internal field next to patch as patch field
-            virtual void patchInternalField(Field<Type>&) const;
-
-            //- Return neighbour coupled given internal cell data
-            virtual tmp<Field<Type>> patchNeighbourField
-            (
-                const Field<Type>& iField
-            ) const;
-
-            //- Return patchField of the values on the patch or on the
-            //  opposite patch
-            virtual tmp<Field<Type>> patchNeighbourField() const;
-
             //- Initialise the evaluation of the patch field
             virtual void initEvaluate
             (
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/cyclic/cyclicFvPatchField.C b/src/finiteVolume/fields/fvPatchFields/constraint/cyclic/cyclicFvPatchField.C
index 1ea0ae8578..91565765d8 100644
--- a/src/finiteVolume/fields/fvPatchFields/constraint/cyclic/cyclicFvPatchField.C
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/cyclic/cyclicFvPatchField.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2021 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -110,7 +110,10 @@ Foam::cyclicFvPatchField<Type>::cyclicFvPatchField
 
 template<class Type>
 Foam::tmp<Foam::Field<Type>>
-Foam::cyclicFvPatchField<Type>::patchNeighbourField() const
+Foam::cyclicFvPatchField<Type>::patchNeighbourField
+(
+    const Pstream::commsTypes
+) const
 {
     const Field<Type>& iField = this->primitiveField();
     const labelUList& nbrFaceCells =
@@ -119,7 +122,6 @@ Foam::cyclicFvPatchField<Type>::patchNeighbourField() const
     tmp<Field<Type>> tpnf(new Field<Type>(this->size()));
     Field<Type>& pnf = tpnf.ref();
 
-
     forAll(pnf, facei)
     {
         pnf[facei] = transform().transform(iField[nbrFaceCells[facei]]);
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/cyclic/cyclicFvPatchField.H b/src/finiteVolume/fields/fvPatchFields/constraint/cyclic/cyclicFvPatchField.H
index 5bfc89a39b..1f02c47af6 100644
--- a/src/finiteVolume/fields/fvPatchFields/constraint/cyclic/cyclicFvPatchField.H
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/cyclic/cyclicFvPatchField.H
@@ -144,7 +144,10 @@ public:
         // Evaluation functions
 
             //- Return neighbour coupled internal cell data
-            tmp<Field<Type>> patchNeighbourField() const;
+            virtual tmp<Field<Type>> patchNeighbourField
+            (
+                const Pstream::commsTypes commsType
+            ) const;
 
             //- Return reference to neighbour patchField
             const cyclicFvPatchField<Type>& nbrPatchField() const;
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchField.C b/src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchField.C
index 329005520f..fa8c4d1909 100644
--- a/src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchField.C
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchField.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2013-2018 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2013-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -45,35 +45,4 @@ Foam::cyclicACMIFvPatchField<Type>::nonOverlapPatchField() const
 }
 
 
-template<class Type>
-void Foam::cyclicACMIFvPatchField<Type>::manipulateMatrix
-(
-    fvMatrix<Type>& matrix
-)
-{
-    const scalarField& mask = cyclicACMIPatch().cyclicACMIPatch().mask();
-
-    // nothing to be done by the AMI, but re-direct to non-overlap patch
-    // with non-overlap patch weights
-    const fvPatchField<Type>& npf = nonOverlapPatchField();
-
-    const_cast<fvPatchField<Type>&>(npf).manipulateMatrix(matrix, 1.0 - mask);
-}
-
-
-template<class Type>
-void Foam::cyclicACMIFvPatchField<Type>::updateCoeffs()
-{
-    // Update non-overlap patch - some will implement updateCoeffs, and
-    // others will implement evaluate
-
-    // Pass in (1 - mask) to give non-overlap patch the chance to do
-    // manipulation of non-face based data
-
-    const scalarField& mask = cyclicACMIPatch().cyclicACMIPatch().mask();
-    const fvPatchField<Type>& npf = nonOverlapPatchField();
-    const_cast<fvPatchField<Type>&>(npf).updateWeightedCoeffs(1.0 - mask);
-}
-
-
 // ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchField.H b/src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchField.H
index 8bafb0367d..5bb8ab3e0b 100644
--- a/src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchField.H
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchField.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2013-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2013-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -125,12 +125,6 @@ public:
 
             //- Return reference to non-overlapping patchField
             const fvPatchField<Type>& nonOverlapPatchField() const;
-
-            //- Manipulate matrix
-            virtual void manipulateMatrix(fvMatrix<Type>& matrix);
-
-            //- Update the coefficients associated with the patch field
-            virtual void updateCoeffs();
 };
 
 
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/cyclicAMI/cyclicAMIFvPatchField.C b/src/finiteVolume/fields/fvPatchFields/constraint/cyclicAMI/cyclicAMIFvPatchField.C
index dce3aebfde..c0552c2534 100644
--- a/src/finiteVolume/fields/fvPatchFields/constraint/cyclicAMI/cyclicAMIFvPatchField.C
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/cyclicAMI/cyclicAMIFvPatchField.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -126,7 +126,10 @@ bool Foam::cyclicAMIFvPatchField<Type>::coupled() const
 
 template<class Type>
 Foam::tmp<Foam::Field<Type>>
-Foam::cyclicAMIFvPatchField<Type>::patchNeighbourField() const
+Foam::cyclicAMIFvPatchField<Type>::patchNeighbourField
+(
+    const Pstream::commsTypes
+) const
 {
     const Field<Type>& iField = this->primitiveField();
     const labelUList& nbrFaceCells =
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/cyclicAMI/cyclicAMIFvPatchField.H b/src/finiteVolume/fields/fvPatchFields/constraint/cyclicAMI/cyclicAMIFvPatchField.H
index a1de2e845e..3a56449a66 100644
--- a/src/finiteVolume/fields/fvPatchFields/constraint/cyclicAMI/cyclicAMIFvPatchField.H
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/cyclicAMI/cyclicAMIFvPatchField.H
@@ -152,7 +152,10 @@ public:
             virtual bool coupled() const;
 
             //- Return neighbour coupled internal cell data
-            virtual tmp<Field<Type>> patchNeighbourField() const;
+            virtual tmp<Field<Type>> patchNeighbourField
+            (
+                const Pstream::commsTypes
+            ) const;
 
             //- Return reference to neighbour patchField
             const cyclicAMIFvPatchField<Type>& nbrPatchField() const;
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/jumpCyclic/jumpCyclicFvPatchField.C b/src/finiteVolume/fields/fvPatchFields/constraint/jumpCyclic/jumpCyclicFvPatchField.C
index b0452a277d..a6db40e2fe 100644
--- a/src/finiteVolume/fields/fvPatchFields/constraint/jumpCyclic/jumpCyclicFvPatchField.C
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/jumpCyclic/jumpCyclicFvPatchField.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2021 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -81,7 +81,10 @@ Foam::jumpCyclicFvPatchField<Type>::jumpCyclicFvPatchField
 
 template<class Type>
 Foam::tmp<Foam::Field<Type>>
-Foam::jumpCyclicFvPatchField<Type>::patchNeighbourField() const
+Foam::jumpCyclicFvPatchField<Type>::patchNeighbourField
+(
+    const Pstream::commsTypes
+) const
 {
     const Field<Type>& iField = this->primitiveField();
     const labelUList& nbrFaceCells =
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/jumpCyclic/jumpCyclicFvPatchField.H b/src/finiteVolume/fields/fvPatchFields/constraint/jumpCyclic/jumpCyclicFvPatchField.H
index b46dd8464b..3dfb7f5e9c 100644
--- a/src/finiteVolume/fields/fvPatchFields/constraint/jumpCyclic/jumpCyclicFvPatchField.H
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/jumpCyclic/jumpCyclicFvPatchField.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -116,7 +116,10 @@ public:
         // Evaluation functions
 
             //- Return neighbour coupled given internal cell data
-            tmp<Field<Type>> patchNeighbourField() const;
+            virtual tmp<Field<Type>> patchNeighbourField
+            (
+                const Pstream::commsTypes
+            ) const;
 
             //- Update result field based on interface functionality
             virtual void updateInterfaceMatrix
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/jumpCyclicAMI/jumpCyclicAMIFvPatchField.C b/src/finiteVolume/fields/fvPatchFields/constraint/jumpCyclicAMI/jumpCyclicAMIFvPatchField.C
index 47e547ce2e..4598f5c25a 100644
--- a/src/finiteVolume/fields/fvPatchFields/constraint/jumpCyclicAMI/jumpCyclicAMIFvPatchField.C
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/jumpCyclicAMI/jumpCyclicAMIFvPatchField.C
@@ -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-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -82,7 +82,10 @@ Foam::jumpCyclicAMIFvPatchField<Type>::jumpCyclicAMIFvPatchField
 
 template<class Type>
 Foam::tmp<Foam::Field<Type>>
-Foam::jumpCyclicAMIFvPatchField<Type>::patchNeighbourField() const
+Foam::jumpCyclicAMIFvPatchField<Type>::patchNeighbourField
+(
+    const Pstream::commsTypes
+) const
 {
     const Field<Type>& iField = this->primitiveField();
     const labelUList& nbrFaceCells =
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/jumpCyclicAMI/jumpCyclicAMIFvPatchField.H b/src/finiteVolume/fields/fvPatchFields/constraint/jumpCyclicAMI/jumpCyclicAMIFvPatchField.H
index bf1e24dc84..86885dace5 100644
--- a/src/finiteVolume/fields/fvPatchFields/constraint/jumpCyclicAMI/jumpCyclicAMIFvPatchField.H
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/jumpCyclicAMI/jumpCyclicAMIFvPatchField.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2012-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2012-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -122,7 +122,10 @@ public:
         // Evaluation functions
 
             //- Return neighbour coupled given internal cell data
-            tmp<Field<Type>> patchNeighbourField() const;
+            virtual tmp<Field<Type>> patchNeighbourField
+            (
+                const Pstream::commsTypes
+            ) const;
 
             //- Update result field based on interface functionality
             virtual void updateInterfaceMatrix
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvPatchField.C b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvPatchField.C
new file mode 100644
index 0000000000..027954402f
--- /dev/null
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvPatchField.C
@@ -0,0 +1,82 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalCyclicFvPatchField.H"
+#include "transformField.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::nonConformalCyclicFvPatchField<Type>::nonConformalCyclicFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF
+)
+:
+    cyclicFvPatchField<Type>(p, iF),
+    nonConformalCyclicFvPatch_(refCast<const nonConformalCyclicFvPatch>(p))
+{}
+
+
+template<class Type>
+Foam::nonConformalCyclicFvPatchField<Type>::nonConformalCyclicFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+    const dictionary& dict
+)
+:
+    cyclicFvPatchField<Type>(p, iF, dict),
+    nonConformalCyclicFvPatch_(refCast<const nonConformalCyclicFvPatch>(p))
+{}
+
+
+template<class Type>
+Foam::nonConformalCyclicFvPatchField<Type>::nonConformalCyclicFvPatchField
+(
+    const nonConformalCyclicFvPatchField<Type>& ptf,
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+    const fvPatchFieldMapper& mapper
+)
+:
+    cyclicFvPatchField<Type>(ptf, p, iF, mapper),
+    nonConformalCyclicFvPatch_(refCast<const nonConformalCyclicFvPatch>(p))
+{}
+
+
+template<class Type>
+Foam::nonConformalCyclicFvPatchField<Type>::nonConformalCyclicFvPatchField
+(
+    const nonConformalCyclicFvPatchField<Type>& ptf,
+    const DimensionedField<Type, volMesh>& iF
+)
+:
+    cyclicFvPatchField<Type>(ptf, iF),
+    nonConformalCyclicFvPatch_(ptf.nonConformalCyclicFvPatch_)
+{}
+
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvPatchField.H b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvPatchField.H
new file mode 100644
index 0000000000..a91bf344cf
--- /dev/null
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvPatchField.H
@@ -0,0 +1,150 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonConformalCyclicFvPatchField
+
+Description
+    This boundary condition enforces a non-conformal cyclic condition between a
+    pair of boundaries.
+
+Usage
+    Example of the boundary condition specification:
+    \verbatim
+    <patchName>
+    {
+        type            nonConformalCyclic;
+    }
+    \endverbatim
+
+Note
+    The patches must be topologically similar, i.e. if the owner patch is
+    transformed to the neighbour patch, the patches should be identical (or
+    very similar).
+
+SourceFiles
+    nonConformalCyclicFvPatchField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalCyclicFvPatchField_H
+#define nonConformalCyclicFvPatchField_H
+
+#include "cyclicFvPatchField.H"
+#include "nonConformalCyclicFvPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                   Class nonConformalCyclicFvPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class nonConformalCyclicFvPatchField
+:
+    public cyclicFvPatchField<Type>
+{
+    // Private Data
+
+        //- Reference to the fvPatch
+        const nonConformalCyclicFvPatch& nonConformalCyclicFvPatch_;
+
+
+public:
+
+    //- Runtime type information
+    TypeName(nonConformalCyclicFvPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        nonConformalCyclicFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        nonConformalCyclicFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given nonConformalCyclicFvPatchField onto a
+        //  new patch
+        nonConformalCyclicFvPatchField
+        (
+            const nonConformalCyclicFvPatchField<Type>&,
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+            const fvPatchFieldMapper&
+        );
+
+        //- Disallow copy without setting internal field reference
+        nonConformalCyclicFvPatchField
+        (
+            const nonConformalCyclicFvPatchField<Type>&
+        ) = delete;
+
+        //- Copy constructor setting internal field reference
+        nonConformalCyclicFvPatchField
+        (
+            const nonConformalCyclicFvPatchField<Type>&,
+            const DimensionedField<Type, volMesh>&
+        );
+
+        //- Construct and return a clone setting internal field reference
+        virtual tmp<fvPatchField<Type>> clone
+        (
+            const DimensionedField<Type, volMesh>& iF
+        ) const
+        {
+            return tmp<fvPatchField<Type>>
+            (
+                new nonConformalCyclicFvPatchField<Type>(*this, iF)
+            );
+        }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "nonConformalCyclicFvPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvPatchFields.C b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvPatchFields.C
new file mode 100644
index 0000000000..c81a8f7c6e
--- /dev/null
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvPatchFields.C
@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalCyclicFvPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
+#include "volFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makePatchFields(nonConformalCyclic);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvPatchFields.H b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvPatchFields.H
new file mode 100644
index 0000000000..46acecbc28
--- /dev/null
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvPatchFields.H
@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalCyclicFvPatchFields_H
+#define nonConformalCyclicFvPatchFields_H
+
+#include "nonConformalCyclicFvPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makePatchTypeFieldTypedefs(nonConformalCyclic);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvPatchFieldsFwd.H b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvPatchFieldsFwd.H
new file mode 100644
index 0000000000..8db8f15fd2
--- /dev/null
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvPatchFieldsFwd.H
@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalCyclicFvPatchFieldsFwd_H
+#define nonConformalCyclicFvPatchFieldsFwd_H
+
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type> class nonConformalCyclicFvPatchField;
+
+makePatchTypeFieldTypedefs(nonConformalCyclic);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalError/nonConformalErrorFvPatchField.C b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalError/nonConformalErrorFvPatchField.C
new file mode 100644
index 0000000000..18dc033fcb
--- /dev/null
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalError/nonConformalErrorFvPatchField.C
@@ -0,0 +1,82 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalErrorFvPatchField.H"
+#include "transformField.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::nonConformalErrorFvPatchField<Type>::nonConformalErrorFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF
+)
+:
+    zeroGradientFvPatchField<Type>(p, iF),
+    nonConformalErrorFvPatch_(refCast<const nonConformalErrorFvPatch>(p))
+{}
+
+
+template<class Type>
+Foam::nonConformalErrorFvPatchField<Type>::nonConformalErrorFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+    const dictionary& dict
+)
+:
+    zeroGradientFvPatchField<Type>(p, iF, dict),
+    nonConformalErrorFvPatch_(refCast<const nonConformalErrorFvPatch>(p))
+{}
+
+
+template<class Type>
+Foam::nonConformalErrorFvPatchField<Type>::nonConformalErrorFvPatchField
+(
+    const nonConformalErrorFvPatchField<Type>& ptf,
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+    const fvPatchFieldMapper& mapper
+)
+:
+    zeroGradientFvPatchField<Type>(ptf, p, iF, mapper),
+    nonConformalErrorFvPatch_(refCast<const nonConformalErrorFvPatch>(p))
+{}
+
+
+template<class Type>
+Foam::nonConformalErrorFvPatchField<Type>::nonConformalErrorFvPatchField
+(
+    const nonConformalErrorFvPatchField<Type>& ptf,
+    const DimensionedField<Type, volMesh>& iF
+)
+:
+    zeroGradientFvPatchField<Type>(ptf, iF),
+    nonConformalErrorFvPatch_(ptf.nonConformalErrorFvPatch_)
+{}
+
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalError/nonConformalErrorFvPatchField.H b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalError/nonConformalErrorFvPatchField.H
new file mode 100644
index 0000000000..c66a98ed73
--- /dev/null
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalError/nonConformalErrorFvPatchField.H
@@ -0,0 +1,144 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonConformalErrorFvPatchField
+
+Description
+    This boundary condition enforces a non-conformal error condition.
+
+Usage
+    Example of the boundary condition specification:
+    \verbatim
+    <patchName>
+    {
+        type            nonConformalError;
+    }
+    \endverbatim
+
+SourceFiles
+    nonConformalErrorFvPatchField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalErrorFvPatchField_H
+#define nonConformalErrorFvPatchField_H
+
+#include "zeroGradientFvPatchField.H"
+#include "nonConformalErrorFvPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                   Class nonConformalErrorFvPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class nonConformalErrorFvPatchField
+:
+    public zeroGradientFvPatchField<Type>
+{
+    // Private Data
+
+        //- Reference to the fvPatch
+        const nonConformalErrorFvPatch& nonConformalErrorFvPatch_;
+
+
+public:
+
+    //- Runtime type information
+    TypeName(nonConformalErrorFvPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        nonConformalErrorFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        nonConformalErrorFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given nonConformalErrorFvPatchField onto a
+        //  new patch
+        nonConformalErrorFvPatchField
+        (
+            const nonConformalErrorFvPatchField<Type>&,
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+            const fvPatchFieldMapper&
+        );
+
+        //- Disallow copy without setting internal field reference
+        nonConformalErrorFvPatchField
+        (
+            const nonConformalErrorFvPatchField<Type>&
+        ) = delete;
+
+        //- Copy constructor setting internal field reference
+        nonConformalErrorFvPatchField
+        (
+            const nonConformalErrorFvPatchField<Type>&,
+            const DimensionedField<Type, volMesh>&
+        );
+
+        //- Construct and return a clone setting internal field reference
+        virtual tmp<fvPatchField<Type>> clone
+        (
+            const DimensionedField<Type, volMesh>& iF
+        ) const
+        {
+            return tmp<fvPatchField<Type>>
+            (
+                new nonConformalErrorFvPatchField<Type>(*this, iF)
+            );
+        }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "nonConformalErrorFvPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalError/nonConformalErrorFvPatchFields.C b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalError/nonConformalErrorFvPatchFields.C
new file mode 100644
index 0000000000..cc7980e571
--- /dev/null
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalError/nonConformalErrorFvPatchFields.C
@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalErrorFvPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
+#include "volFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makePatchFields(nonConformalError);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalError/nonConformalErrorFvPatchFields.H b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalError/nonConformalErrorFvPatchFields.H
new file mode 100644
index 0000000000..1e3e9e81a4
--- /dev/null
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalError/nonConformalErrorFvPatchFields.H
@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalErrorFvPatchFields_H
+#define nonConformalErrorFvPatchFields_H
+
+#include "nonConformalErrorFvPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makePatchTypeFieldTypedefs(nonConformalError);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalError/nonConformalErrorFvPatchFieldsFwd.H b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalError/nonConformalErrorFvPatchFieldsFwd.H
new file mode 100644
index 0000000000..d861c062af
--- /dev/null
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalError/nonConformalErrorFvPatchFieldsFwd.H
@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalErrorFvPatchFieldsFwd_H
+#define nonConformalErrorFvPatchFieldsFwd_H
+
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type> class nonConformalErrorFvPatchField;
+
+makePatchTypeFieldTypedefs(nonConformalError);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvPatchField.C b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvPatchField.C
new file mode 100644
index 0000000000..6a5c3f58f8
--- /dev/null
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvPatchField.C
@@ -0,0 +1,110 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalProcessorCyclicFvPatchField.H"
+#include "nonConformalProcessorCyclicFvPatch.H"
+#include "demandDrivenData.H"
+#include "transformField.H"
+
+// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::nonConformalProcessorCyclicFvPatchField<Type>::
+nonConformalProcessorCyclicFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF
+)
+:
+    processorCyclicFvPatchField<Type>(p, iF),
+    procPatch_(refCast<const nonConformalProcessorCyclicFvPatch>(p))
+{}
+
+
+template<class Type>
+Foam::nonConformalProcessorCyclicFvPatchField<Type>::
+nonConformalProcessorCyclicFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+    const dictionary& dict
+)
+:
+    processorCyclicFvPatchField<Type>(p, iF, dict),
+    procPatch_(refCast<const nonConformalProcessorCyclicFvPatch>(p))
+{}
+
+
+template<class Type>
+Foam::nonConformalProcessorCyclicFvPatchField<Type>::
+nonConformalProcessorCyclicFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+    const Field<Type>& f
+)
+:
+    processorCyclicFvPatchField<Type>(p, iF, f),
+    procPatch_(refCast<const nonConformalProcessorCyclicFvPatch>(p))
+{}
+
+
+template<class Type>
+Foam::nonConformalProcessorCyclicFvPatchField<Type>::
+nonConformalProcessorCyclicFvPatchField
+(
+    const nonConformalProcessorCyclicFvPatchField<Type>& ptf,
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+    const fvPatchFieldMapper& mapper
+)
+:
+    processorCyclicFvPatchField<Type>(ptf, p, iF, mapper),
+    procPatch_(refCast<const nonConformalProcessorCyclicFvPatch>(p))
+{}
+
+
+template<class Type>
+Foam::nonConformalProcessorCyclicFvPatchField<Type>::
+nonConformalProcessorCyclicFvPatchField
+(
+    const nonConformalProcessorCyclicFvPatchField<Type>& ptf,
+    const DimensionedField<Type, volMesh>& iF
+)
+:
+    processorCyclicFvPatchField<Type>(ptf, iF),
+    procPatch_(refCast<const nonConformalProcessorCyclicFvPatch>(ptf.patch()))
+{}
+
+
+// * * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::nonConformalProcessorCyclicFvPatchField<Type>::
+~nonConformalProcessorCyclicFvPatchField()
+{}
+
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvPatchField.H b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvPatchField.H
new file mode 100644
index 0000000000..b0c73d19ed
--- /dev/null
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvPatchField.H
@@ -0,0 +1,180 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonConformalProcessorCyclicFvPatchField
+
+Description
+    This boundary condition enables processor communication across cyclic
+    patches.
+
+Usage
+    Example of the boundary condition specification:
+    \verbatim
+    <patchName>
+    {
+        type            nonConformalProcessorCyclic;
+    }
+    \endverbatim
+
+See also
+    Foam::processorCyclicFvPatchField
+
+SourceFiles
+    nonConformalProcessorCyclicFvPatchField.C
+    nonConformalProcessorCyclicFvPatchFields.H
+    nonConformalProcessorCyclicFvPatchFields.C
+    nonConformalProcessorCyclicFvPatchFieldsFwd.H
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalProcessorCyclicFvPatchField_H
+#define nonConformalProcessorCyclicFvPatchField_H
+
+#include "nonConformalProcessorCyclicFvPatch.H"
+#include "processorCyclicFvPatchField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+             Class nonConformalProcessorCyclicFvPatchField Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class nonConformalProcessorCyclicFvPatchField
+:
+    public processorCyclicFvPatchField<Type>
+{
+    // Private Data
+
+        //- Local reference cast into the processor patch
+        const nonConformalProcessorCyclicFvPatch& procPatch_;
+
+
+public:
+
+    //- Runtime type information
+    TypeName(nonConformalProcessorCyclicFvPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        nonConformalProcessorCyclicFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&
+        );
+
+        //- Construct from patch and internal field and patch field
+        nonConformalProcessorCyclicFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+            const Field<Type>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        nonConformalProcessorCyclicFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given nonConformalProcessorCyclicFvPatchField
+        //  onto a new patch
+        nonConformalProcessorCyclicFvPatchField
+        (
+            const nonConformalProcessorCyclicFvPatchField<Type>&,
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+            const fvPatchFieldMapper&
+        );
+
+        //- Disallow copy without setting internal field reference
+        nonConformalProcessorCyclicFvPatchField
+        (
+            const nonConformalProcessorCyclicFvPatchField<Type>&
+        ) = delete;
+
+        //- Copy constructor setting internal field reference
+        nonConformalProcessorCyclicFvPatchField
+        (
+            const nonConformalProcessorCyclicFvPatchField<Type>&,
+            const DimensionedField<Type, volMesh>&
+        );
+
+        //- Construct and return a clone setting internal field reference
+        virtual tmp<fvPatchField<Type>> clone
+        (
+            const DimensionedField<Type, volMesh>& iF
+        ) const
+        {
+            return tmp<fvPatchField<Type>>
+            (
+                new nonConformalProcessorCyclicFvPatchField<Type>(*this, iF)
+            );
+        }
+
+
+    //- Destructor
+    virtual ~nonConformalProcessorCyclicFvPatchField();
+
+
+    // Member Functions
+
+        // Access
+
+            //- Return transformation between the coupled patches
+            virtual const transformer& transform() const
+            {
+                return procPatch_.transform();
+            }
+
+            //- Return rank of component for transform
+            virtual int rank() const
+            {
+                return pTraits<Type>::rank;
+            }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "nonConformalProcessorCyclicFvPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvPatchFields.C b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvPatchFields.C
new file mode 100644
index 0000000000..a4717471be
--- /dev/null
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvPatchFields.C
@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalProcessorCyclicFvPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
+#include "volFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makePatchFields(nonConformalProcessorCyclic);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvPatchFields.H b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvPatchFields.H
new file mode 100644
index 0000000000..e5e1bbd34f
--- /dev/null
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvPatchFields.H
@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalProcessorCyclicFvPatchFields_H
+#define nonConformalProcessorCyclicFvPatchFields_H
+
+#include "nonConformalProcessorCyclicFvPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makePatchTypeFieldTypedefs(nonConformalProcessorCyclic);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvPatchFieldsFwd.H b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvPatchFieldsFwd.H
new file mode 100644
index 0000000000..c856d26694
--- /dev/null
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvPatchFieldsFwd.H
@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalProcessorCyclicFvPatchFieldsFwd_H
+#define nonConformalProcessorCyclicFvPatchFieldsFwd_H
+
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type> class nonConformalProcessorCyclicFvPatchField;
+
+makePatchTypeFieldTypedefs(nonConformalProcessorCyclic);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/processor/processorFvPatchField.C b/src/finiteVolume/fields/fvPatchFields/constraint/processor/processorFvPatchField.C
index 3ae92b18b6..fed19dc935 100644
--- a/src/finiteVolume/fields/fvPatchFields/constraint/processor/processorFvPatchField.C
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/processor/processorFvPatchField.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -177,7 +177,10 @@ Foam::processorFvPatchField<Type>::~processorFvPatchField()
 
 template<class Type>
 Foam::tmp<Foam::Field<Type>>
-Foam::processorFvPatchField<Type>::patchNeighbourField() const
+Foam::processorFvPatchField<Type>::patchNeighbourField
+(
+    const Pstream::commsTypes
+) const
 {
     if (debug && !this->ready())
     {
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/processor/processorFvPatchField.H b/src/finiteVolume/fields/fvPatchFields/constraint/processor/processorFvPatchField.H
index a4d5e7b29f..b6d600d5e0 100644
--- a/src/finiteVolume/fields/fvPatchFields/constraint/processor/processorFvPatchField.H
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/processor/processorFvPatchField.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -173,7 +173,10 @@ public:
             }
 
             //- Return neighbour field given internal field
-            virtual tmp<Field<Type>> patchNeighbourField() const;
+            virtual tmp<Field<Type>> patchNeighbourField
+            (
+                const Pstream::commsTypes
+            ) const;
 
 
         // Evaluation functions
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/processorCyclic/processorCyclicFvPatchField.C b/src/finiteVolume/fields/fvPatchFields/constraint/processorCyclic/processorCyclicFvPatchField.C
index 0f61618851..6c45b59269 100644
--- a/src/finiteVolume/fields/fvPatchFields/constraint/processorCyclic/processorCyclicFvPatchField.C
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/processorCyclic/processorCyclicFvPatchField.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -53,7 +53,7 @@ Foam::processorCyclicFvPatchField<Type>::processorCyclicFvPatchField
     processorFvPatchField<Type>(p, iF, dict),
     procPatch_(refCast<const processorCyclicFvPatch>(p))
 {
-    if (!isType<processorCyclicFvPatch>(p))
+    if (!isA<processorCyclicFvPatch>(p))
     {
         FatalIOErrorInFunction
         (
@@ -100,7 +100,7 @@ Foam::processorCyclicFvPatchField<Type>::processorCyclicFvPatchField
     processorFvPatchField<Type>(ptf, p, iF, mapper),
     procPatch_(refCast<const processorCyclicFvPatch>(p))
 {
-    if (!isType<processorCyclicFvPatch>(this->patch()))
+    if (!isA<processorCyclicFvPatch>(this->patch()))
     {
         FatalErrorInFunction
             << "' not constraint type '" << typeName << "'"
diff --git a/src/finiteVolume/fields/fvPatchFields/fvPatchField/fvPatchField.C b/src/finiteVolume/fields/fvPatchFields/fvPatchField/fvPatchField.C
index 59b331c069..35b0bc685e 100644
--- a/src/finiteVolume/fields/fvPatchFields/fvPatchField/fvPatchField.C
+++ b/src/finiteVolume/fields/fvPatchFields/fvPatchField/fvPatchField.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2021 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -212,19 +212,6 @@ void Foam::fvPatchField<Type>::updateCoeffs()
 }
 
 
-template<class Type>
-void Foam::fvPatchField<Type>::updateWeightedCoeffs(const scalarField& weights)
-{
-    // Default behaviour ignores the weights
-    if (!updated_)
-    {
-        updateCoeffs();
-
-        updated_ = true;
-    }
-}
-
-
 template<class Type>
 void Foam::fvPatchField<Type>::evaluate(const Pstream::commsTypes)
 {
@@ -245,17 +232,6 @@ void Foam::fvPatchField<Type>::manipulateMatrix(fvMatrix<Type>& matrix)
 }
 
 
-template<class Type>
-void Foam::fvPatchField<Type>::manipulateMatrix
-(
-    fvMatrix<Type>& matrix,
-    const scalarField& weights
-)
-{
-    manipulatedMatrix_ = true;
-}
-
-
 template<class Type>
 void Foam::fvPatchField<Type>::write(Ostream& os) const
 {
diff --git a/src/finiteVolume/fields/fvPatchFields/fvPatchField/fvPatchField.H b/src/finiteVolume/fields/fvPatchFields/fvPatchField/fvPatchField.H
index b871193a0b..36eae7382b 100644
--- a/src/finiteVolume/fields/fvPatchFields/fvPatchField/fvPatchField.H
+++ b/src/finiteVolume/fields/fvPatchFields/fvPatchField/fvPatchField.H
@@ -396,20 +396,27 @@ public:
             //  Sets Updated to true
             virtual void updateCoeffs();
 
-            //- Update the coefficients associated with the patch field
-            //  with a weight field (0..1). This weight field is usually
-            //  provided as the amount of geometric overlap for 'duplicate'
-            //  patches. Sets Updated to true
-            virtual void updateWeightedCoeffs(const scalarField& weights);
-
             //- Return internal field next to patch as patch field
             virtual tmp<Field<Type>> patchInternalField() const;
 
             //- Return internal field next to patch as patch field
             virtual void patchInternalField(Field<Type>&) const;
 
+            //- Initialise return of the patchField on the opposite patch of a
+            //  coupled patch
+            virtual void initPatchNeighbourField
+            (
+                const Pstream::commsTypes commsType =
+                    Pstream::commsTypes::blocking
+            ) const
+            {}
+
             //- Return patchField on the opposite patch of a coupled patch
-            virtual tmp<Field<Type>> patchNeighbourField() const
+            virtual tmp<Field<Type>> patchNeighbourField
+            (
+                const Pstream::commsTypes commsType =
+                    Pstream::commsTypes::blocking
+            ) const
             {
                 NotImplemented;
                 return *this;
@@ -493,17 +500,9 @@ public:
                 return *this;
             }
 
-
             //- Manipulate matrix
             virtual void manipulateMatrix(fvMatrix<Type>& matrix);
 
-            //- Manipulate matrix with given weights
-            virtual void manipulateMatrix
-            (
-                fvMatrix<Type>& matrix,
-                const scalarField& weights
-            );
-
 
         // I-O
 
diff --git a/src/finiteVolume/fields/fvsPatchFields/basic/coupled/coupledFvsPatchFields.C b/src/finiteVolume/fields/fvsPatchFields/basic/coupled/coupledFvsPatchFields.C
index e7a0756682..6f424d6416 100644
--- a/src/finiteVolume/fields/fvsPatchFields/basic/coupled/coupledFvsPatchFields.C
+++ b/src/finiteVolume/fields/fvsPatchFields/basic/coupled/coupledFvsPatchFields.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -34,6 +34,7 @@ namespace Foam
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
+makeFvsPatchFieldTypeName(label, coupled);
 makeFvsPatchFieldTypeNames(coupled);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/finiteVolume/fields/fvsPatchFields/basic/coupled/coupledFvsPatchFields.H b/src/finiteVolume/fields/fvsPatchFields/basic/coupled/coupledFvsPatchFields.H
index b68aa2162a..216c27496f 100644
--- a/src/finiteVolume/fields/fvsPatchFields/basic/coupled/coupledFvsPatchFields.H
+++ b/src/finiteVolume/fields/fvsPatchFields/basic/coupled/coupledFvsPatchFields.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -36,6 +36,7 @@ namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+makeFvsPatchTypeFieldTypedef(label, coupled);
 makeFvsPatchTypeFieldTypedefs(coupled);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/finiteVolume/fields/fvsPatchFields/basic/nonConformalCalculated/nonConformalCalculatedFvsPatchField.C b/src/finiteVolume/fields/fvsPatchFields/basic/nonConformalCalculated/nonConformalCalculatedFvsPatchField.C
new file mode 100644
index 0000000000..cfded8a10d
--- /dev/null
+++ b/src/finiteVolume/fields/fvsPatchFields/basic/nonConformalCalculated/nonConformalCalculatedFvsPatchField.C
@@ -0,0 +1,98 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalCalculatedFvsPatchField.H"
+#include "fvPatchFieldMapper.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::nonConformalCalculatedFvsPatchField<Type>::
+nonConformalCalculatedFvsPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, surfaceMesh>& iF
+)
+:
+    fvsPatchField<Type>(p, iF)
+{}
+
+
+template<class Type>
+Foam::nonConformalCalculatedFvsPatchField<Type>::
+nonConformalCalculatedFvsPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, surfaceMesh>& iF,
+    const dictionary& dict
+)
+:
+    fvsPatchField<Type>
+    (
+        p,
+        iF,
+        Field<Type>("value", dict, dict.lookup<label>("size"))
+    )
+{}
+
+
+template<class Type>
+Foam::nonConformalCalculatedFvsPatchField<Type>::
+nonConformalCalculatedFvsPatchField
+(
+    const nonConformalCalculatedFvsPatchField<Type>& ptf,
+    const fvPatch& p,
+    const DimensionedField<Type, surfaceMesh>& iF,
+    const fvPatchFieldMapper& mapper
+)
+:
+    fvsPatchField<Type>(ptf, p, iF, mapper)
+{}
+
+
+template<class Type>
+Foam::nonConformalCalculatedFvsPatchField<Type>::
+nonConformalCalculatedFvsPatchField
+(
+    const nonConformalCalculatedFvsPatchField<Type>& ptf,
+    const DimensionedField<Type, surfaceMesh>& iF
+)
+:
+    fvsPatchField<Type>(ptf, iF)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+void Foam::nonConformalCalculatedFvsPatchField<Type>::write(Ostream& os) const
+{
+    fvsPatchField<Type>::write(os);
+
+    writeEntry(os, "size", this->size());
+}
+
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvsPatchFields/basic/nonConformalCalculated/nonConformalCalculatedFvsPatchField.H b/src/finiteVolume/fields/fvsPatchFields/basic/nonConformalCalculated/nonConformalCalculatedFvsPatchField.H
new file mode 100644
index 0000000000..8ebe6d5227
--- /dev/null
+++ b/src/finiteVolume/fields/fvsPatchFields/basic/nonConformalCalculated/nonConformalCalculatedFvsPatchField.H
@@ -0,0 +1,145 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonConformalCalculatedFvsPatchField
+
+Description
+    Foam::nonConformalCalculatedFvsPatchField
+
+SourceFiles
+    nonConformalCalculatedFvsPatchField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalCalculatedFvsPatchField_H
+#define nonConformalCalculatedFvsPatchField_H
+
+#include "fvsPatchField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                     Class nonConformalCalculatedFvsPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class nonConformalCalculatedFvsPatchField
+:
+    public fvsPatchField<Type>
+{
+
+public:
+
+    //- Runtime type information
+    TypeName("nonConformalCalculated");
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        nonConformalCalculatedFvsPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, surfaceMesh>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        nonConformalCalculatedFvsPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, surfaceMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given patchField<Type> onto a new patch
+        nonConformalCalculatedFvsPatchField
+        (
+            const nonConformalCalculatedFvsPatchField<Type>&,
+            const fvPatch&,
+            const DimensionedField<Type, surfaceMesh>&,
+            const fvPatchFieldMapper&
+        );
+
+        //- Disallow copy without setting internal field reference
+        nonConformalCalculatedFvsPatchField
+        (
+            const nonConformalCalculatedFvsPatchField<Type>&
+        ) = delete;
+
+        //- Copy constructor setting internal field reference
+        nonConformalCalculatedFvsPatchField
+        (
+            const nonConformalCalculatedFvsPatchField<Type>&,
+            const DimensionedField<Type, surfaceMesh>&
+        );
+
+        //- Construct and return a clone setting internal field reference
+        virtual tmp<fvsPatchField<Type>> clone
+        (
+            const DimensionedField<Type, surfaceMesh>& iF
+        ) const
+        {
+            return tmp<fvsPatchField<Type>>
+            (
+                new nonConformalCalculatedFvsPatchField<Type>(*this, iF)
+            );
+        }
+
+
+    // Member Functions
+
+        // Attributes
+
+            //- Return true if this patch field fixes a value.
+            //  Needed to check if a level has to be specified while solving
+            //  Poissons equations.
+            virtual bool fixesValue() const
+            {
+                return true;
+            }
+
+
+        //- Write
+        virtual void write(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "nonConformalCalculatedFvsPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvsPatchFields/basic/nonConformalCalculated/nonConformalCalculatedFvsPatchFields.C b/src/finiteVolume/fields/fvsPatchFields/basic/nonConformalCalculated/nonConformalCalculatedFvsPatchFields.C
new file mode 100644
index 0000000000..0a9c36d901
--- /dev/null
+++ b/src/finiteVolume/fields/fvsPatchFields/basic/nonConformalCalculated/nonConformalCalculatedFvsPatchFields.C
@@ -0,0 +1,44 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalCalculatedFvsPatchFields.H"
+#include "fvsPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makeTemplateFvsPatchTypeField(label, nonConformalCalculated);
+makeFvsPatchFields(nonConformalCalculated);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvsPatchFields/basic/nonConformalCalculated/nonConformalCalculatedFvsPatchFields.H b/src/finiteVolume/fields/fvsPatchFields/basic/nonConformalCalculated/nonConformalCalculatedFvsPatchFields.H
new file mode 100644
index 0000000000..1763961b13
--- /dev/null
+++ b/src/finiteVolume/fields/fvsPatchFields/basic/nonConformalCalculated/nonConformalCalculatedFvsPatchFields.H
@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalCalculatedFvsPatchFields_H
+#define nonConformalCalculatedFvsPatchFields_H
+
+#include "nonConformalCalculatedFvsPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makeFvsPatchTypeFieldTypedef(label, nonConformalCalculated);
+makeFvsPatchTypeFieldTypedefs(nonConformalCalculated);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvsPatchFields/basic/nonConformalCalculated/nonConformalCalculatedFvsPatchFieldsFwd.H b/src/finiteVolume/fields/fvsPatchFields/basic/nonConformalCalculated/nonConformalCalculatedFvsPatchFieldsFwd.H
new file mode 100644
index 0000000000..c5073723f8
--- /dev/null
+++ b/src/finiteVolume/fields/fvsPatchFields/basic/nonConformalCalculated/nonConformalCalculatedFvsPatchFieldsFwd.H
@@ -0,0 +1,56 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+InClass
+    Foam::nonConformalCalculatedFvsPatchField
+
+Description
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalCalculatedFvsPatchFieldsFwd_H
+#define nonConformalCalculatedFvsPatchFieldsFwd_H
+
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type> class nonConformalCalculatedFvsPatchField;
+
+makeFvsPatchTypeFieldTypedef(label, nonConformalCalculated);
+makeFvsPatchTypeFieldTypedefs(nonConformalCalculated);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvsPatchFields/constraint/cyclic/cyclicFvsPatchFields.C b/src/finiteVolume/fields/fvsPatchFields/constraint/cyclic/cyclicFvsPatchFields.C
index 12bad4c673..a98ba21175 100644
--- a/src/finiteVolume/fields/fvsPatchFields/constraint/cyclic/cyclicFvsPatchFields.C
+++ b/src/finiteVolume/fields/fvsPatchFields/constraint/cyclic/cyclicFvsPatchFields.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -34,6 +34,7 @@ namespace Foam
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
+makeTemplateFvsPatchTypeField(label, cyclic);
 makeFvsPatchFields(cyclic);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/finiteVolume/fields/fvsPatchFields/constraint/cyclic/cyclicFvsPatchFields.H b/src/finiteVolume/fields/fvsPatchFields/constraint/cyclic/cyclicFvsPatchFields.H
index cddee3bb55..9849370eb7 100644
--- a/src/finiteVolume/fields/fvsPatchFields/constraint/cyclic/cyclicFvsPatchFields.H
+++ b/src/finiteVolume/fields/fvsPatchFields/constraint/cyclic/cyclicFvsPatchFields.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -36,6 +36,7 @@ namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+makeFvsPatchTypeFieldTypedef(label, cyclic);
 makeFvsPatchTypeFieldTypedefs(cyclic);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvsPatchField.C b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvsPatchField.C
new file mode 100644
index 0000000000..e0a6cd3d13
--- /dev/null
+++ b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvsPatchField.C
@@ -0,0 +1,100 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalCyclicFvsPatchField.H"
+#include "fvPatchFieldMapper.H"
+#include "surfaceMesh.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::nonConformalCyclicFvsPatchField<Type>::nonConformalCyclicFvsPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, surfaceMesh>& iF
+)
+:
+    cyclicFvsPatchField<Type>(p, iF)
+{}
+
+
+template<class Type>
+Foam::nonConformalCyclicFvsPatchField<Type>::nonConformalCyclicFvsPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, surfaceMesh>& iF,
+    const dictionary& dict
+)
+:
+    cyclicFvsPatchField<Type>(p, iF, dict)
+{
+    if (!isType<nonConformalCyclicFvPatch>(p))
+    {
+        FatalIOErrorInFunction
+        (
+            dict
+        )   << "patch " << this->patch().index() << " not "
+            << nonConformalCyclicFvPatch::typeName << " type. "
+            << "Patch type = " << p.type()
+            << exit(FatalIOError);
+    }
+}
+
+
+template<class Type>
+Foam::nonConformalCyclicFvsPatchField<Type>::nonConformalCyclicFvsPatchField
+(
+    const nonConformalCyclicFvsPatchField<Type>& ptf,
+    const fvPatch& p,
+    const DimensionedField<Type, surfaceMesh>& iF,
+    const fvPatchFieldMapper& mapper
+)
+:
+    cyclicFvsPatchField<Type>(ptf, p, iF, mapper)
+{
+    if (!isType<nonConformalCyclicFvPatch>(this->patch()))
+    {
+        FatalErrorInFunction
+            << "Field type does not correspond to patch type for patch "
+            << this->patch().index() << "." << endl
+            << "Field type: " << typeName << endl
+            << "Patch type: " << this->patch().type()
+            << exit(FatalError);
+    }
+}
+
+
+template<class Type>
+Foam::nonConformalCyclicFvsPatchField<Type>::nonConformalCyclicFvsPatchField
+(
+    const nonConformalCyclicFvsPatchField<Type>& ptf,
+    const DimensionedField<Type, surfaceMesh>& iF
+)
+:
+    cyclicFvsPatchField<Type>(ptf, iF)
+{}
+
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvsPatchField.H b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvsPatchField.H
new file mode 100644
index 0000000000..af1f3b1fb1
--- /dev/null
+++ b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvsPatchField.H
@@ -0,0 +1,131 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonConformalCyclicFvsPatchField
+
+Description
+    Constraint fvsPatchField for nonConformalCyclic couplings.
+
+SourceFiles
+    nonConformalCyclicFvsPatchField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalCyclicFvsPatchField_H
+#define nonConformalCyclicFvsPatchField_H
+
+#include "cyclicFvsPatchField.H"
+#include "nonConformalCyclicFvPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                        Class nonConformalCyclicFvsPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class nonConformalCyclicFvsPatchField
+:
+    public cyclicFvsPatchField<Type>
+{
+
+public:
+
+    //- Runtime type information
+    TypeName(nonConformalCyclicFvPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from patch and nonConformalCyclic field
+        nonConformalCyclicFvsPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, surfaceMesh>&
+        );
+
+        //- Construct from patch, nonConformalCyclic field and dictionary
+        nonConformalCyclicFvsPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, surfaceMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given nonConformalCyclicFvsPatchField onto a
+        //  new patch
+        nonConformalCyclicFvsPatchField
+        (
+            const nonConformalCyclicFvsPatchField<Type>&,
+            const fvPatch&,
+            const DimensionedField<Type, surfaceMesh>&,
+            const fvPatchFieldMapper&
+        );
+
+        //- Disallow copy without setting nonConformalCyclic field reference
+        nonConformalCyclicFvsPatchField
+        (
+            const nonConformalCyclicFvsPatchField<Type>&
+        ) = delete;
+
+        //- Copy constructor setting nonConformalCyclic field reference
+        nonConformalCyclicFvsPatchField
+        (
+            const nonConformalCyclicFvsPatchField<Type>&,
+            const DimensionedField<Type, surfaceMesh>&
+        );
+
+        //- Construct and return a clone setting nonConformalCyclic field
+        //  reference
+        virtual tmp<fvsPatchField<Type>> clone
+        (
+            const DimensionedField<Type, surfaceMesh>& iF
+        ) const
+        {
+            return tmp<fvsPatchField<Type>>
+            (
+                new nonConformalCyclicFvsPatchField<Type>(*this, iF)
+            );
+        }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "nonConformalCyclicFvsPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvsPatchFields.C b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvsPatchFields.C
new file mode 100644
index 0000000000..83a679f987
--- /dev/null
+++ b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvsPatchFields.C
@@ -0,0 +1,44 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalCyclicFvsPatchFields.H"
+#include "fvsPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makeTemplateFvsPatchTypeField(label, nonConformalCyclic);
+makeFvsPatchFields(nonConformalCyclic);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvsPatchFields.H b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvsPatchFields.H
new file mode 100644
index 0000000000..e181d7fd8d
--- /dev/null
+++ b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvsPatchFields.H
@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalCyclicFvsPatchFields_H
+#define nonConformalCyclicFvsPatchFields_H
+
+#include "nonConformalCyclicFvsPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makeFvsPatchTypeFieldTypedef(label, nonConformalCyclic);
+makeFvsPatchTypeFieldTypedefs(nonConformalCyclic);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvsPatchFieldsFwd.H b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvsPatchFieldsFwd.H
new file mode 100644
index 0000000000..a6f53efd21
--- /dev/null
+++ b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalCyclic/nonConformalCyclicFvsPatchFieldsFwd.H
@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalCyclicFvsPatchFieldsFwd_H
+#define nonConformalCyclicFvsPatchFieldsFwd_H
+
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type> class nonConformalCyclicFvsPatchField;
+
+makeFvsPatchTypeFieldTypedefs(nonConformalCyclic);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalError/nonConformalErrorFvsPatchField.C b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalError/nonConformalErrorFvsPatchField.C
new file mode 100644
index 0000000000..1f7af58bfa
--- /dev/null
+++ b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalError/nonConformalErrorFvsPatchField.C
@@ -0,0 +1,100 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalErrorFvsPatchField.H"
+#include "fvPatchFieldMapper.H"
+#include "surfaceMesh.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::nonConformalErrorFvsPatchField<Type>::nonConformalErrorFvsPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, surfaceMesh>& iF
+)
+:
+    fvsPatchField<Type>(p, iF)
+{}
+
+
+template<class Type>
+Foam::nonConformalErrorFvsPatchField<Type>::nonConformalErrorFvsPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, surfaceMesh>& iF,
+    const dictionary& dict
+)
+:
+    fvsPatchField<Type>(p, iF, Field<Type>("value", dict, p.size()))
+{
+    if (!isType<nonConformalErrorFvPatch>(p))
+    {
+        FatalIOErrorInFunction
+        (
+            dict
+        )   << "patch " << this->patch().index() << " not "
+            << nonConformalErrorFvPatch::typeName << " type. "
+            << "Patch type = " << p.type()
+            << exit(FatalIOError);
+    }
+}
+
+
+template<class Type>
+Foam::nonConformalErrorFvsPatchField<Type>::nonConformalErrorFvsPatchField
+(
+    const nonConformalErrorFvsPatchField<Type>& ptf,
+    const fvPatch& p,
+    const DimensionedField<Type, surfaceMesh>& iF,
+    const fvPatchFieldMapper& mapper
+)
+:
+    fvsPatchField<Type>(ptf, p, iF, mapper)
+{
+    if (!isType<nonConformalErrorFvPatch>(this->patch()))
+    {
+        FatalErrorInFunction
+            << "Field type does not correspond to patch type for patch "
+            << this->patch().index() << "." << endl
+            << "Field type: " << typeName << endl
+            << "Patch type: " << this->patch().type()
+            << exit(FatalError);
+    }
+}
+
+
+template<class Type>
+Foam::nonConformalErrorFvsPatchField<Type>::nonConformalErrorFvsPatchField
+(
+    const nonConformalErrorFvsPatchField<Type>& ptf,
+    const DimensionedField<Type, surfaceMesh>& iF
+)
+:
+    fvsPatchField<Type>(ptf, iF)
+{}
+
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalError/nonConformalErrorFvsPatchField.H b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalError/nonConformalErrorFvsPatchField.H
new file mode 100644
index 0000000000..40fcc8a8f1
--- /dev/null
+++ b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalError/nonConformalErrorFvsPatchField.H
@@ -0,0 +1,131 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonConformalErrorFvsPatchField
+
+Description
+    Constraint fvsPatchField for nonConformalError couplings.
+
+SourceFiles
+    nonConformalErrorFvsPatchField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalErrorFvsPatchField_H
+#define nonConformalErrorFvsPatchField_H
+
+#include "fvsPatchField.H"
+#include "nonConformalErrorFvPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                        Class nonConformalErrorFvsPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class nonConformalErrorFvsPatchField
+:
+    public fvsPatchField<Type>
+{
+
+public:
+
+    //- Runtime type information
+    TypeName(nonConformalErrorFvPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from patch and nonConformalError field
+        nonConformalErrorFvsPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, surfaceMesh>&
+        );
+
+        //- Construct from patch, nonConformalError field and dictionary
+        nonConformalErrorFvsPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, surfaceMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given nonConformalErrorFvsPatchField onto a
+        //  new patch
+        nonConformalErrorFvsPatchField
+        (
+            const nonConformalErrorFvsPatchField<Type>&,
+            const fvPatch&,
+            const DimensionedField<Type, surfaceMesh>&,
+            const fvPatchFieldMapper&
+        );
+
+        //- Disallow copy without setting nonConformalError field reference
+        nonConformalErrorFvsPatchField
+        (
+            const nonConformalErrorFvsPatchField<Type>&
+        ) = delete;
+
+        //- Copy constructor setting nonConformalError field reference
+        nonConformalErrorFvsPatchField
+        (
+            const nonConformalErrorFvsPatchField<Type>&,
+            const DimensionedField<Type, surfaceMesh>&
+        );
+
+        //- Construct and return a clone setting nonConformalError field
+        //  reference
+        virtual tmp<fvsPatchField<Type>> clone
+        (
+            const DimensionedField<Type, surfaceMesh>& iF
+        ) const
+        {
+            return tmp<fvsPatchField<Type>>
+            (
+                new nonConformalErrorFvsPatchField<Type>(*this, iF)
+            );
+        }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "nonConformalErrorFvsPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalError/nonConformalErrorFvsPatchFields.C b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalError/nonConformalErrorFvsPatchFields.C
new file mode 100644
index 0000000000..2fa8f581e0
--- /dev/null
+++ b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalError/nonConformalErrorFvsPatchFields.C
@@ -0,0 +1,44 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalErrorFvsPatchFields.H"
+#include "fvsPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makeTemplateFvsPatchTypeField(label, nonConformalError);
+makeFvsPatchFields(nonConformalError);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalError/nonConformalErrorFvsPatchFields.H b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalError/nonConformalErrorFvsPatchFields.H
new file mode 100644
index 0000000000..fbea9e6fca
--- /dev/null
+++ b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalError/nonConformalErrorFvsPatchFields.H
@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalErrorFvsPatchFields_H
+#define nonConformalErrorFvsPatchFields_H
+
+#include "nonConformalErrorFvsPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makeFvsPatchTypeFieldTypedef(label, nonConformalError);
+makeFvsPatchTypeFieldTypedefs(nonConformalError);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalError/nonConformalErrorFvsPatchFieldsFwd.H b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalError/nonConformalErrorFvsPatchFieldsFwd.H
new file mode 100644
index 0000000000..5452bf20d5
--- /dev/null
+++ b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalError/nonConformalErrorFvsPatchFieldsFwd.H
@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalErrorFvsPatchFieldsFwd_H
+#define nonConformalErrorFvsPatchFieldsFwd_H
+
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type> class nonConformalErrorFvsPatchField;
+
+makeFvsPatchTypeFieldTypedefs(nonConformalError);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvsPatchField.C b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvsPatchField.C
new file mode 100644
index 0000000000..812adec611
--- /dev/null
+++ b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvsPatchField.C
@@ -0,0 +1,107 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalProcessorCyclicFvsPatchField.H"
+
+// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::nonConformalProcessorCyclicFvsPatchField<Type>::
+nonConformalProcessorCyclicFvsPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, surfaceMesh>& iF
+)
+:
+    processorCyclicFvsPatchField<Type>(p, iF),
+    procPatch_(refCast<const nonConformalProcessorCyclicFvPatch>(p))
+{}
+
+
+template<class Type>
+Foam::nonConformalProcessorCyclicFvsPatchField<Type>::
+nonConformalProcessorCyclicFvsPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, surfaceMesh>& iF,
+    const Field<Type>& f
+)
+:
+    processorCyclicFvsPatchField<Type>(p, iF, f),
+    procPatch_(refCast<const nonConformalProcessorCyclicFvPatch>(p))
+{}
+
+
+template<class Type>
+Foam::nonConformalProcessorCyclicFvsPatchField<Type>::
+nonConformalProcessorCyclicFvsPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, surfaceMesh>& iF,
+    const dictionary& dict
+)
+:
+    processorCyclicFvsPatchField<Type>(p, iF, dict),
+    procPatch_(refCast<const nonConformalProcessorCyclicFvPatch>(p))
+{}
+
+
+template<class Type>
+Foam::nonConformalProcessorCyclicFvsPatchField<Type>::
+nonConformalProcessorCyclicFvsPatchField
+(
+    const nonConformalProcessorCyclicFvsPatchField<Type>& ptf,
+    const fvPatch& p,
+    const DimensionedField<Type, surfaceMesh>& iF,
+    const fvPatchFieldMapper& mapper
+)
+:
+    processorCyclicFvsPatchField<Type>(ptf, p, iF, mapper),
+    procPatch_(refCast<const nonConformalProcessorCyclicFvPatch>(p))
+{}
+
+
+template<class Type>
+Foam::nonConformalProcessorCyclicFvsPatchField<Type>::
+nonConformalProcessorCyclicFvsPatchField
+(
+    const nonConformalProcessorCyclicFvsPatchField<Type>& ptf,
+    const DimensionedField<Type, surfaceMesh>& iF
+)
+:
+    processorCyclicFvsPatchField<Type>(ptf, iF),
+    procPatch_(refCast<const nonConformalProcessorCyclicFvPatch>(ptf.patch()))
+{}
+
+
+// * * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::nonConformalProcessorCyclicFvsPatchField<Type>::
+~nonConformalProcessorCyclicFvsPatchField()
+{}
+
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvsPatchField.H b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvsPatchField.H
new file mode 100644
index 0000000000..64033ec437
--- /dev/null
+++ b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvsPatchField.H
@@ -0,0 +1,147 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonConformalProcessorCyclicFvsPatchField
+
+Description
+    Foam::nonConformalProcessorCyclicFvsPatchField
+
+SourceFiles
+    nonConformalProcessorCyclicFvsPatchField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalProcessorCyclicFvsPatchField_H
+#define nonConformalProcessorCyclicFvsPatchField_H
+
+#include "nonConformalProcessorCyclicFvPatch.H"
+#include "processorCyclicFvsPatchField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+               Class nonConformalProcessorCyclicFvsPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class nonConformalProcessorCyclicFvsPatchField
+:
+    public processorCyclicFvsPatchField<Type>
+{
+    // Private Data
+
+        //- Local reference cast into the processor patch
+        const nonConformalProcessorCyclicFvPatch& procPatch_;
+
+
+public:
+
+    //- Runtime type information
+    TypeName(nonConformalProcessorCyclicFvPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        nonConformalProcessorCyclicFvsPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, surfaceMesh>&
+        );
+
+        //- Construct from patch and internal field and patch field
+        nonConformalProcessorCyclicFvsPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, surfaceMesh>&,
+            const Field<Type>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        nonConformalProcessorCyclicFvsPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, surfaceMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given nonConformalProcessorCyclicFvsPatchField
+        //  onto a new patch
+        nonConformalProcessorCyclicFvsPatchField
+        (
+            const nonConformalProcessorCyclicFvsPatchField<Type>&,
+            const fvPatch&,
+            const DimensionedField<Type, surfaceMesh>&,
+            const fvPatchFieldMapper&
+        );
+
+        //- Disallow copy without setting internal field reference
+        nonConformalProcessorCyclicFvsPatchField
+        (
+            const nonConformalProcessorCyclicFvsPatchField<Type>&
+        ) = delete;
+
+        //- Copy constructor setting internal field reference
+        nonConformalProcessorCyclicFvsPatchField
+        (
+            const nonConformalProcessorCyclicFvsPatchField<Type>&,
+            const DimensionedField<Type, surfaceMesh>&
+        );
+
+        //- Construct and return a clone setting internal field reference
+        virtual tmp<fvsPatchField<Type>> clone
+        (
+            const DimensionedField<Type, surfaceMesh>& iF
+        ) const
+        {
+            return tmp<fvsPatchField<Type>>
+            (
+                new nonConformalProcessorCyclicFvsPatchField<Type>(*this, iF)
+            );
+        }
+
+
+    //- Destructor
+    virtual ~nonConformalProcessorCyclicFvsPatchField();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "nonConformalProcessorCyclicFvsPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvsPatchFields.C b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvsPatchFields.C
new file mode 100644
index 0000000000..e5537213d5
--- /dev/null
+++ b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvsPatchFields.C
@@ -0,0 +1,44 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalProcessorCyclicFvsPatchFields.H"
+#include "fvsPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makeTemplateFvsPatchTypeField(label, nonConformalProcessorCyclic);
+makeFvsPatchFields(nonConformalProcessorCyclic);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvsPatchFields.H b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvsPatchFields.H
new file mode 100644
index 0000000000..78b6866e57
--- /dev/null
+++ b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvsPatchFields.H
@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalProcessorCyclicFvsPatchFields_H
+#define nonConformalProcessorCyclicFvsPatchFields_H
+
+#include "nonConformalProcessorCyclicFvsPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makeFvsPatchTypeFieldTypedef(label, nonConformalProcessorCyclic);
+makeFvsPatchTypeFieldTypedefs(nonConformalProcessorCyclic);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvsPatchFieldsFwd.H b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvsPatchFieldsFwd.H
new file mode 100644
index 0000000000..54c933a065
--- /dev/null
+++ b/src/finiteVolume/fields/fvsPatchFields/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvsPatchFieldsFwd.H
@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalProcessorCyclicFvsPatchFieldsFwd_H
+#define nonConformalProcessorCyclicFvsPatchFieldsFwd_H
+
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type> class nonConformalProcessorCyclicFvsPatchField;
+
+makeFvsPatchTypeFieldTypedefs(nonConformalProcessorCyclic);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvsPatchFields/constraint/processor/processorFvsPatchFields.C b/src/finiteVolume/fields/fvsPatchFields/constraint/processor/processorFvsPatchFields.C
index babd2a19ae..5ab8585312 100644
--- a/src/finiteVolume/fields/fvsPatchFields/constraint/processor/processorFvsPatchFields.C
+++ b/src/finiteVolume/fields/fvsPatchFields/constraint/processor/processorFvsPatchFields.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -34,6 +34,7 @@ namespace Foam
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
+makeTemplateFvsPatchTypeField(label, processor);
 makeFvsPatchFields(processor);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/finiteVolume/fields/fvsPatchFields/constraint/processor/processorFvsPatchFields.H b/src/finiteVolume/fields/fvsPatchFields/constraint/processor/processorFvsPatchFields.H
index 7d98703897..8bbecc4122 100644
--- a/src/finiteVolume/fields/fvsPatchFields/constraint/processor/processorFvsPatchFields.H
+++ b/src/finiteVolume/fields/fvsPatchFields/constraint/processor/processorFvsPatchFields.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -36,6 +36,7 @@ namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+makeFvsPatchTypeFieldTypedef(label, processor);
 makeFvsPatchTypeFieldTypedefs(processor);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/finiteVolume/fields/fvsPatchFields/constraint/processorCyclic/processorCyclicFvsPatchField.C b/src/finiteVolume/fields/fvsPatchFields/constraint/processorCyclic/processorCyclicFvsPatchField.C
index 6b5ecba06f..6f2bd69a57 100644
--- a/src/finiteVolume/fields/fvsPatchFields/constraint/processorCyclic/processorCyclicFvsPatchField.C
+++ b/src/finiteVolume/fields/fvsPatchFields/constraint/processorCyclic/processorCyclicFvsPatchField.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2021 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -63,7 +63,7 @@ Foam::processorCyclicFvsPatchField<Type>::processorCyclicFvsPatchField
     processorFvsPatchField<Type>(p, iF, dict),
     procPatch_(refCast<const processorCyclicFvPatch>(p))
 {
-    if (!isType<processorCyclicFvPatch>(p))
+    if (!isA<processorCyclicFvPatch>(p))
     {
         FatalIOErrorInFunction
         (
@@ -87,7 +87,7 @@ Foam::processorCyclicFvsPatchField<Type>::processorCyclicFvsPatchField
     processorFvsPatchField<Type>(ptf, p, iF, mapper),
     procPatch_(refCast<const processorCyclicFvPatch>(p))
 {
-    if (!isType<processorCyclicFvPatch>(this->patch()))
+    if (!isA<processorCyclicFvPatch>(this->patch()))
     {
         FatalErrorInFunction
             << "Field type does not correspond to patch type for patch "
diff --git a/src/finiteVolume/fields/fvsPatchFields/constraint/processorCyclic/processorCyclicFvsPatchFields.C b/src/finiteVolume/fields/fvsPatchFields/constraint/processorCyclic/processorCyclicFvsPatchFields.C
index 9253d5e70e..ca4ff72634 100644
--- a/src/finiteVolume/fields/fvsPatchFields/constraint/processorCyclic/processorCyclicFvsPatchFields.C
+++ b/src/finiteVolume/fields/fvsPatchFields/constraint/processorCyclic/processorCyclicFvsPatchFields.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -34,6 +34,7 @@ namespace Foam
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
+makeTemplateFvsPatchTypeField(label, processorCyclic);
 makeFvsPatchFields(processorCyclic);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/finiteVolume/fields/fvsPatchFields/constraint/processorCyclic/processorCyclicFvsPatchFields.H b/src/finiteVolume/fields/fvsPatchFields/constraint/processorCyclic/processorCyclicFvsPatchFields.H
index d4ef4f4852..40765164f0 100644
--- a/src/finiteVolume/fields/fvsPatchFields/constraint/processorCyclic/processorCyclicFvsPatchFields.H
+++ b/src/finiteVolume/fields/fvsPatchFields/constraint/processorCyclic/processorCyclicFvsPatchFields.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -36,6 +36,7 @@ namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+makeFvsPatchTypeFieldTypedef(label, processorCyclic);
 makeFvsPatchTypeFieldTypedefs(processorCyclic);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/finiteVolume/finiteVolume/fvSchemes/fvSchemes.C b/src/finiteVolume/finiteVolume/fvSchemes/fvSchemes.C
index 44cc92b139..749f887cd4 100644
--- a/src/finiteVolume/finiteVolume/fvSchemes/fvSchemes.C
+++ b/src/finiteVolume/finiteVolume/fvSchemes/fvSchemes.C
@@ -204,12 +204,7 @@ Foam::fvSchemes::fvSchemes(const objectRegistry& obr)
             "fvSchemes",
             obr.time().system(),
             obr,
-            (
-                obr.readOpt() == IOobject::MUST_READ
-             || obr.readOpt() == IOobject::READ_IF_PRESENT
-              ? IOobject::MUST_READ_IF_MODIFIED
-              : obr.readOpt()
-            ),
+            IOobject::MUST_READ_IF_MODIFIED,
             IOobject::NO_WRITE
         )
     ),
@@ -315,15 +310,7 @@ Foam::fvSchemes::fvSchemes(const objectRegistry& obr)
     defaultFluxRequired_(false),
     steady_(false)
 {
-    if
-    (
-        readOpt() == IOobject::MUST_READ
-     || readOpt() == IOobject::MUST_READ_IF_MODIFIED
-     || (readOpt() == IOobject::READ_IF_PRESENT && headerOk())
-    )
-    {
-        read(dict());
-    }
+    read(dict());
 }
 
 
diff --git a/src/finiteVolume/fvMatrices/fvMatrix/fvMatrix.C b/src/finiteVolume/fvMatrices/fvMatrix/fvMatrix.C
index a54bd22062..d084a204d8 100644
--- a/src/finiteVolume/fvMatrices/fvMatrix/fvMatrix.C
+++ b/src/finiteVolume/fvMatrices/fvMatrix/fvMatrix.C
@@ -29,6 +29,7 @@ License
 #include "extrapolatedCalculatedFvPatchFields.H"
 #include "coupledFvPatchFields.H"
 #include "UIndirectList.H"
+#include "UCompactListList.H"
 #include "fvmDdt.H"
 
 // * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
@@ -235,18 +236,17 @@ void Foam::fvMatrix<Type>::setValue
             }
             else
             {
-                label patchi = mesh.boundaryMesh().whichPatch(facei);
+                const label bFacei = facei - mesh.nInternalFaces();
 
-                if (internalCoeffs_[patchi].size())
+                const labelUList patches =
+                    mesh.polyBFacePatches()[bFacei];
+                const labelUList patchFaces =
+                    mesh.polyBFacePatchFaces()[bFacei];
+
+                forAll(patches, i)
                 {
-                    label patchFacei =
-                        mesh.boundaryMesh()[patchi].whichFace(facei);
-
-                    internalCoeffs_[patchi][patchFacei] =
-                        Zero;
-
-                    boundaryCoeffs_[patchi][patchFacei] =
-                        Zero;
+                    internalCoeffs_[patches[i]][patchFaces[i]] = Zero;
+                    boundaryCoeffs_[patches[i]][patchFaces[i]] = Zero;
                 }
             }
         }
diff --git a/src/finiteVolume/fvMesh/fvMesh.C b/src/finiteVolume/fvMesh/fvMesh.C
index d30924740f..3d16577d7e 100644
--- a/src/finiteVolume/fvMesh/fvMesh.C
+++ b/src/finiteVolume/fvMesh/fvMesh.C
@@ -35,6 +35,9 @@ License
 #include "fvMeshTopoChanger.H"
 #include "fvMeshDistributor.H"
 #include "fvMeshMover.H"
+#include "fvMeshStitcher.H"
+#include "nonConformalFvPatch.H"
+#include "nonConformalCalculatedFvsPatchFields.H"
 #include "polyTopoChangeMap.H"
 #include "MapFvFields.H"
 #include "fvMeshMapper.H"
@@ -43,8 +46,12 @@ License
 #include "MapPointField.H"
 #include "mapClouds.H"
 #include "MeshObject.H"
+#include "HashPtrTable.H"
+#include "CompactListList.H"
 
 #include "fvcSurfaceIntegrate.H"
+#include "fvcReconstruct.H"
+#include "surfaceInterpolate.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -78,9 +85,13 @@ void Foam::fvMesh::clearGeomNotOldVol()
     >(*this);
 
     deleteDemandDrivenData(VPtr_);
+    deleteDemandDrivenData(SfSlicePtr_);
     deleteDemandDrivenData(SfPtr_);
+    deleteDemandDrivenData(magSfSlicePtr_);
     deleteDemandDrivenData(magSfPtr_);
+    deleteDemandDrivenData(CSlicePtr_);
     deleteDemandDrivenData(CPtr_);
+    deleteDemandDrivenData(CfSlicePtr_);
     deleteDemandDrivenData(CfPtr_);
 }
 
@@ -88,10 +99,10 @@ void Foam::fvMesh::clearGeomNotOldVol()
 void Foam::fvMesh::updateGeomNotOldVol()
 {
     bool haveV = (VPtr_ != nullptr);
-    bool haveSf = (SfPtr_ != nullptr);
-    bool haveMagSf = (magSfPtr_ != nullptr);
-    bool haveCP = (CPtr_ != nullptr);
-    bool haveCf = (CfPtr_ != nullptr);
+    bool haveSf = (SfSlicePtr_ != nullptr || SfPtr_ != nullptr);
+    bool haveMagSf = (magSfSlicePtr_ != nullptr || magSfPtr_ != nullptr);
+    bool haveCP = (CSlicePtr_ != nullptr || CPtr_ != nullptr);
+    bool haveCf = (CfSlicePtr_ != nullptr || CfPtr_ != nullptr);
 
     clearGeomNotOldVol();
 
@@ -128,6 +139,7 @@ void Foam::fvMesh::clearGeom()
 
     clearGeomNotOldVol();
 
+    deleteDemandDrivenData(phiPtr_);
     deleteDemandDrivenData(V0Ptr_);
     deleteDemandDrivenData(V00Ptr_);
 
@@ -171,7 +183,14 @@ void Foam::fvMesh::clearAddressing(const bool isMeshUpdate)
         meshObject::clear<fvMesh, TopologicalMeshObject>(*this);
         meshObject::clear<lduMesh, TopologicalMeshObject>(*this);
     }
+
     deleteDemandDrivenData(lduPtr_);
+    deleteDemandDrivenData(polyFacesBfPtr_);
+    deleteDemandDrivenData(polyBFaceOffsetsPtr_);
+    deleteDemandDrivenData(polyBFaceOffsetPatchesPtr_);
+    deleteDemandDrivenData(polyBFaceOffsetPatchFacesPtr_);
+    deleteDemandDrivenData(polyBFacePatchesPtr_);
+    deleteDemandDrivenData(polyBFacePatchFacesPtr_);
 }
 
 
@@ -242,17 +261,49 @@ void Foam::fvMesh::storeOldVol(const scalarField& V)
 void Foam::fvMesh::clearOut()
 {
     clearGeom();
+
     surfaceInterpolation::clearOut();
 
     clearAddressing();
 
-    // Clear mesh motion flux
-    deleteDemandDrivenData(phiPtr_);
-
     polyMesh::clearOut();
 }
 
 
+Foam::wordList Foam::fvMesh::polyFacesPatchTypes() const
+{
+    wordList wantedPatchTypes
+    (
+        boundary().size(),
+        calculatedFvsPatchLabelField::typeName
+    );
+
+    forAll(boundary(), patchi)
+    {
+        const fvPatch& fvp = boundary()[patchi];
+
+        if (isA<nonConformalFvPatch>(fvp))
+        {
+            wantedPatchTypes[patchi] =
+                nonConformalCalculatedFvsPatchLabelField::typeName;
+        }
+    }
+
+    return wantedPatchTypes;
+}
+
+
+Foam::surfaceLabelField::Boundary& Foam::fvMesh::polyFacesBfRef()
+{
+    if (!polyFacesBfPtr_)
+    {
+        polyFacesBf();
+    }
+
+    return *polyFacesBfPtr_;
+}
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 Foam::fvMesh::fvMesh(const IOobject& io, const bool changers)
@@ -261,17 +312,28 @@ Foam::fvMesh::fvMesh(const IOobject& io, const bool changers)
     surfaceInterpolation(*this),
     data(static_cast<const objectRegistry&>(*this)),
     boundary_(*this, boundaryMesh()),
+    stitcher_(fvMeshStitcher::New(*this, changers)),
     topoChanger_(nullptr),
     distributor_(nullptr),
     mover_(nullptr),
     lduPtr_(nullptr),
+    polyFacesBfPtr_(nullptr),
+    polyBFaceOffsetsPtr_(nullptr),
+    polyBFaceOffsetPatchesPtr_(nullptr),
+    polyBFaceOffsetPatchFacesPtr_(nullptr),
+    polyBFacePatchesPtr_(nullptr),
+    polyBFacePatchFacesPtr_(nullptr),
     curTimeIndex_(time().timeIndex()),
     VPtr_(nullptr),
     V0Ptr_(nullptr),
     V00Ptr_(nullptr),
+    SfSlicePtr_(nullptr),
     SfPtr_(nullptr),
+    magSfSlicePtr_(nullptr),
     magSfPtr_(nullptr),
+    CSlicePtr_(nullptr),
     CPtr_(nullptr),
+    CfSlicePtr_(nullptr),
     CfPtr_(nullptr),
     phiPtr_(nullptr)
 {
@@ -280,6 +342,9 @@ Foam::fvMesh::fvMesh(const IOobject& io, const bool changers)
         Pout<< FUNCTION_NAME << "Constructing fvMesh from IOobject" << endl;
     }
 
+    // Stitch or Re-stitch if necessary
+    stitcher_->connect(false, changers);
+
     // Construct changers
     if (changers)
     {
@@ -357,17 +422,28 @@ Foam::fvMesh::fvMesh
     surfaceInterpolation(*this),
     data(static_cast<const objectRegistry&>(*this)),
     boundary_(*this, boundaryMesh()),
+    stitcher_(nullptr),
     topoChanger_(nullptr),
     distributor_(nullptr),
     mover_(nullptr),
     lduPtr_(nullptr),
+    polyFacesBfPtr_(nullptr),
+    polyBFaceOffsetsPtr_(nullptr),
+    polyBFaceOffsetPatchesPtr_(nullptr),
+    polyBFaceOffsetPatchFacesPtr_(nullptr),
+    polyBFacePatchesPtr_(nullptr),
+    polyBFacePatchFacesPtr_(nullptr),
     curTimeIndex_(time().timeIndex()),
     VPtr_(nullptr),
     V0Ptr_(nullptr),
     V00Ptr_(nullptr),
+    SfSlicePtr_(nullptr),
     SfPtr_(nullptr),
+    magSfSlicePtr_(nullptr),
     magSfPtr_(nullptr),
+    CSlicePtr_(nullptr),
     CPtr_(nullptr),
+    CfSlicePtr_(nullptr),
     CfPtr_(nullptr),
     phiPtr_(nullptr)
 {
@@ -400,17 +476,28 @@ Foam::fvMesh::fvMesh
     surfaceInterpolation(*this),
     data(static_cast<const objectRegistry&>(*this)),
     boundary_(*this, boundaryMesh()),
+    stitcher_(nullptr),
     topoChanger_(nullptr),
     distributor_(nullptr),
     mover_(nullptr),
     lduPtr_(nullptr),
+    polyFacesBfPtr_(nullptr),
+    polyBFaceOffsetsPtr_(nullptr),
+    polyBFaceOffsetPatchesPtr_(nullptr),
+    polyBFaceOffsetPatchFacesPtr_(nullptr),
+    polyBFacePatchesPtr_(nullptr),
+    polyBFacePatchFacesPtr_(nullptr),
     curTimeIndex_(time().timeIndex()),
     VPtr_(nullptr),
     V0Ptr_(nullptr),
     V00Ptr_(nullptr),
+    SfSlicePtr_(nullptr),
     SfPtr_(nullptr),
+    magSfSlicePtr_(nullptr),
     magSfPtr_(nullptr),
+    CSlicePtr_(nullptr),
     CPtr_(nullptr),
+    CfSlicePtr_(nullptr),
     CfPtr_(nullptr),
     phiPtr_(nullptr)
 {
@@ -441,17 +528,28 @@ Foam::fvMesh::fvMesh
     surfaceInterpolation(*this),
     data(static_cast<const objectRegistry&>(*this)),
     boundary_(*this),
+    stitcher_(nullptr),
     topoChanger_(nullptr),
     distributor_(nullptr),
     mover_(nullptr),
     lduPtr_(nullptr),
+    polyFacesBfPtr_(nullptr),
+    polyBFaceOffsetsPtr_(nullptr),
+    polyBFaceOffsetPatchesPtr_(nullptr),
+    polyBFaceOffsetPatchFacesPtr_(nullptr),
+    polyBFacePatchesPtr_(nullptr),
+    polyBFacePatchFacesPtr_(nullptr),
     curTimeIndex_(time().timeIndex()),
     VPtr_(nullptr),
     V0Ptr_(nullptr),
     V00Ptr_(nullptr),
+    SfSlicePtr_(nullptr),
     SfPtr_(nullptr),
+    magSfSlicePtr_(nullptr),
     magSfPtr_(nullptr),
+    CSlicePtr_(nullptr),
     CPtr_(nullptr),
+    CfSlicePtr_(nullptr),
     CfPtr_(nullptr),
     phiPtr_(nullptr)
 {
@@ -480,6 +578,8 @@ bool Foam::fvMesh::dynamic() const
 
 bool Foam::fvMesh::update()
 {
+    if (!conformal()) stitcher_->disconnect(true, true);
+
     bool updated = false;
 
     const bool hasV00 = V00Ptr_;
@@ -518,10 +618,14 @@ bool Foam::fvMesh::update()
 
 bool Foam::fvMesh::move()
 {
+    if (!conformal()) stitcher_->disconnect(true, true);
+
     const bool moved = mover_->update();
 
     curTimeIndex_ = time().timeIndex();
 
+    stitcher_->connect(true, true);
+
     return moved;
 }
 
@@ -606,6 +710,11 @@ Foam::polyMesh::readUpdateState Foam::fvMesh::readUpdate()
 
     polyMesh::readUpdateState state = polyMesh::readUpdate();
 
+    if (stitcher_.valid() && state != polyMesh::UNCHANGED)
+    {
+        stitcher_->disconnect(false, false);
+    }
+
     if (state == polyMesh::TOPO_PATCH_CHANGE)
     {
         if (debug)
@@ -643,6 +752,11 @@ Foam::polyMesh::readUpdateState Foam::fvMesh::readUpdate()
         }
     }
 
+    if (stitcher_.valid() && state != polyMesh::UNCHANGED)
+    {
+        stitcher_->connect(false, false);
+    }
+
     return state;
 }
 
@@ -664,6 +778,146 @@ const Foam::lduAddressing& Foam::fvMesh::lduAddr() const
 }
 
 
+bool Foam::fvMesh::conformal() const
+{
+    return !(polyFacesBfPtr_ && SfPtr_);
+}
+
+
+Foam::IOobject Foam::fvMesh::polyFacesBfIO(const IOobject::readOption r) const
+{
+    return
+        IOobject
+        (
+            "polyFaces",
+            pointsInstance(),
+            typeName,
+            *this,
+            r,
+            IOobject::NO_WRITE,
+            false
+        );
+}
+
+
+const Foam::surfaceLabelField::Boundary& Foam::fvMesh::polyFacesBf() const
+{
+    if (!polyFacesBfPtr_)
+    {
+        polyFacesBfPtr_ =
+            new surfaceLabelField::Boundary
+            (
+                boundary(),
+                surfaceLabelField::null(),
+                polyFacesPatchTypes(),
+                boundaryMesh().types()
+            );
+
+        forAll(boundary(), patchi)
+        {
+            const polyPatch& pp = boundaryMesh()[patchi];
+            (*polyFacesBfPtr_)[patchi] =
+                labelList(identity(pp.size()) + pp.start());
+        }
+    }
+
+    return *polyFacesBfPtr_;
+}
+
+
+const Foam::UCompactListList<Foam::label>&
+Foam::fvMesh::polyBFacePatches() const
+{
+    if (!polyBFacePatchesPtr_)
+    {
+        const label nPolyBFaces = nFaces() - nInternalFaces();
+
+        // Count face-poly-bFaces to get the offsets
+        polyBFaceOffsetsPtr_ = new labelList(nPolyBFaces + 1, 0);
+        labelList& offsets = *polyBFaceOffsetsPtr_;
+        forAll(boundary(), patchi)
+        {
+            forAll(boundary()[patchi], patchFacei)
+            {
+                const label polyBFacei =
+                    (
+                        polyFacesBfPtr_
+                      ? (*polyFacesBfPtr_)[patchi][patchFacei]
+                      : boundary()[patchi].start() + patchFacei
+                    )
+                  - nInternalFaces();
+                offsets[polyBFacei + 1] ++;
+            }
+        }
+        for (label polyBFacei = 0; polyBFacei < nPolyBFaces; ++ polyBFacei)
+        {
+            offsets[polyBFacei + 1] += offsets[polyBFacei];
+        }
+
+        // Set the poly-bFace patches and patch-faces, using the offsets as
+        // counters
+        polyBFaceOffsetPatchesPtr_ = new labelList(offsets.last());
+        polyBFaceOffsetPatchFacesPtr_ = new labelList(offsets.last());
+        labelUList& patches = *polyBFaceOffsetPatchesPtr_;
+        labelUList& patchFaces = *polyBFaceOffsetPatchFacesPtr_;
+        forAll(boundary(), patchi)
+        {
+            forAll(boundary()[patchi], patchFacei)
+            {
+                const label polyBFacei =
+                    (
+                        polyFacesBfPtr_
+                      ? (*polyFacesBfPtr_)[patchi][patchFacei]
+                      : boundary()[patchi].start() + patchFacei
+                    )
+                  - nInternalFaces();
+                patches[offsets[polyBFacei]] = patchi;
+                patchFaces[offsets[polyBFacei]] = patchFacei;
+                offsets[polyBFacei] ++;
+            }
+        }
+
+        // Restore the offsets by removing the count
+        for
+        (
+            label polyBFacei = nPolyBFaces - 1;
+            polyBFacei >= 0;
+            -- polyBFacei
+        )
+        {
+            offsets[polyBFacei + 1] = offsets[polyBFacei];
+        }
+        offsets[0] = 0;
+
+        // List-lists
+        polyBFacePatchesPtr_ =
+            new UCompactListList<label>(offsets, patches);
+        polyBFacePatchFacesPtr_ =
+            new UCompactListList<label>(offsets, patchFaces);
+    }
+
+    return *polyBFacePatchesPtr_;
+}
+
+
+const Foam::UCompactListList<Foam::label>&
+Foam::fvMesh::polyBFacePatchFaces() const
+{
+    if (!polyBFacePatchFacesPtr_)
+    {
+        polyBFacePatches();
+    }
+
+    return *polyBFacePatchFacesPtr_;
+}
+
+
+const Foam::fvMeshStitcher& Foam::fvMesh::stitcher() const
+{
+    return stitcher_();
+}
+
+
 const Foam::fvMeshTopoChanger& Foam::fvMesh::topoChanger() const
 {
     return topoChanger_();
@@ -990,6 +1244,117 @@ void Foam::fvMesh::distribute(const polyDistributionMap& map)
 }
 
 
+void Foam::fvMesh::conform()
+{
+    // Clear the geometry fields
+    clearGeomNotOldVol();
+
+    // Clear the current volume and other geometry factors
+    surfaceInterpolation::clearOut();
+
+    // Clear any non-updateable addressing
+    clearAddressing(true);
+}
+
+
+void Foam::fvMesh::unconform
+(
+    const surfaceLabelField::Boundary& polyFacesBf,
+    const surfaceVectorField& Sf,
+    const surfaceVectorField& Cf,
+    const surfaceScalarField& phi,
+    const bool sync
+)
+{
+    // Clear the geometry fields
+    clearGeomNotOldVol();
+
+    // Clear the current volume and other geometry factors
+    surfaceInterpolation::clearOut();
+
+    // Clear any non-updateable addressing
+    clearAddressing(true);
+
+    // Create non-sliced copies of geometry fields
+    SfRef();
+    magSfRef();
+    CRef();
+    CfRef();
+
+    // Set the topology
+    polyFacesBfRef() == polyFacesBf;
+
+    // Set the face geometry
+    SfRef() == Sf;
+    magSfRef() == mag(Sf);
+    CRef().boundaryFieldRef() == Cf.boundaryField();
+    CfRef() == Cf;
+
+    // Communicate processor-coupled cell geometry. Cell-centre processor patch
+    // fields must contain the (transformed) cell-centre locations on the other
+    // side of the coupling. This is so that non-conformal patches can
+    // construct weights and deltas without reference to the poly mesh
+    // geometry.
+    //
+    // Note that the initEvaluate/evaluate communication does a transformation,
+    // but it is wrong in this instance. A vector field gets transformed as if
+    // it were a displacement, but the cell-centres need a positional
+    // transformation. That's why there's the un-transform and re-transform bit
+    // below just after the evaluate call.
+    //
+    // This transform handling is a bit of a hack. It would be nicer to have a
+    // field attribute which identifies a field as needing a positional
+    // transformation, and for it to apply automatically within the coupled
+    // patch field. However, at the moment, the cell centres field is the only
+    // vol-field containing an absolute position, so the hack is functionally
+    // sufficient for now.
+    if (sync && (Pstream::parRun() || !time().processorCase()))
+    {
+        volVectorField::Boundary& CBf = CRef().boundaryFieldRef();
+
+        const label nReq = Pstream::nRequests();
+
+        forAll(CBf, patchi)
+        {
+            if (isA<processorFvPatch>(CBf[patchi].patch()))
+            {
+                CBf[patchi].initEvaluate(Pstream::defaultCommsType);
+            }
+        }
+
+        if
+        (
+            Pstream::parRun()
+         && Pstream::defaultCommsType == Pstream::commsTypes::nonBlocking
+        )
+        {
+            Pstream::waitRequests(nReq);
+        }
+
+        forAll(CBf, patchi)
+        {
+            if (isA<processorFvPatch>(CBf[patchi].patch()))
+            {
+                CBf[patchi].evaluate(Pstream::defaultCommsType);
+
+                const transformer& t =
+                    refCast<const processorFvPatch>(CBf[patchi].patch())
+                   .transform();
+
+                t.invTransform(CBf[patchi], CBf[patchi]);
+                t.transformPosition(CBf[patchi], CBf[patchi]);
+            }
+        }
+    }
+
+    // Modify the mesh fluxes, if necessary
+    if (notNull(phi) && phiPtr_)
+    {
+        phiRef() == phi;
+    }
+}
+
+
 void Foam::fvMesh::addPatch
 (
     const label insertPatchi,
@@ -1156,9 +1521,36 @@ bool Foam::fvMesh::writeObject
 ) const
 {
     bool ok = true;
+
+    if (!conformal())
+    {
+        // Create a full surface field with the polyFacesBf boundary field then
+        // overwrite all conformal faces with an index of -1 to save disk space
+
+        surfaceLabelField polyFaces
+        (
+            polyFacesBfIO(IOobject::NO_READ),
+            *this,
+            dimless,
+            labelField(nInternalFaces(), -1),
+            *polyFacesBfPtr_
+        );
+
+        forAll(boundary(), patchi)
+        {
+            const fvPatch& fvp = boundary()[patchi];
+            if (!isA<nonConformalFvPatch>(fvp))
+            {
+                polyFaces.boundaryFieldRef()[patchi] = -1;
+            }
+        }
+
+        ok = ok & polyFaces.write(write);
+    }
+
     if (phiPtr_)
     {
-        ok = phiPtr_->write(write);
+        ok = ok && phiPtr_->write(write);
     }
 
     // Write V0 only if V00 exists
diff --git a/src/finiteVolume/fvMesh/fvMesh.H b/src/finiteVolume/fvMesh/fvMesh.H
index 4314c14f25..6e26de07d7 100644
--- a/src/finiteVolume/fvMesh/fvMesh.H
+++ b/src/finiteVolume/fvMesh/fvMesh.H
@@ -70,12 +70,19 @@ namespace Foam
 {
 
 class fvMeshLduAddressing;
+class fvMeshStitcher;
 class fvMeshTopoChanger;
 class fvMeshDistributor;
 class fvMeshMover;
 class volMesh;
 class polyDistributionMap;
 
+template<class Type, template<class> class PatchField, class GeoMesh>
+class GeometricBoundaryField;
+
+template<class Type>
+class UCompactListList;
+
 /*---------------------------------------------------------------------------*\
                            Class fvMesh Declaration
 \*---------------------------------------------------------------------------*/
@@ -87,11 +94,16 @@ class fvMesh
     public surfaceInterpolation,
     public data
 {
+private:
+
     // Private Data
 
         //- Boundary mesh
         fvBoundaryMesh boundary_;
 
+        //- The stitcher function class
+        autoPtr<fvMeshStitcher> stitcher_;
+
         //- The topo-changer function class
         autoPtr<fvMeshTopoChanger> topoChanger_;
 
@@ -104,8 +116,28 @@ class fvMesh
 
     // Demand-driven data
 
+        //- Matrix addressing
         mutable fvMeshLduAddressing* lduPtr_;
 
+        //- Face-poly-face addressing
+        mutable GeometricBoundaryField<label, fvsPatchField, surfaceMesh>*
+            polyFacesBfPtr_;
+
+        //- Offsets for poly-bFace-patch and patch-face addressing
+        mutable labelList* polyBFaceOffsetsPtr_;
+
+        //- Poly-bFace-patch addressing
+        mutable labelList* polyBFaceOffsetPatchesPtr_;
+
+        //- Poly-bFace-patch-face addressing
+        mutable labelList* polyBFaceOffsetPatchFacesPtr_;
+
+        //- Poly-bFace-patch addressing
+        mutable UCompactListList<label>* polyBFacePatchesPtr_;
+
+        //- Poly-bFace-patch-face addressing
+        mutable UCompactListList<label>* polyBFacePatchFacesPtr_;
+
         //- Current time index for cell volumes
         //  Note.  The whole mechanism will be replaced once the
         //  dimensionedField is created and the dimensionedField
@@ -122,16 +154,28 @@ class fvMesh
         mutable DimensionedField<scalar, volMesh>* V00Ptr_;
 
         //- Face area vectors
-        mutable slicedSurfaceVectorField* SfPtr_;
+        mutable slicedSurfaceVectorField* SfSlicePtr_;
+
+        //- Face area vectors
+        mutable surfaceVectorField* SfPtr_;
 
         //- Mag face area vectors
-        mutable slicedSurfaceScalarField* magSfPtr_;
+        mutable slicedSurfaceScalarField* magSfSlicePtr_;
+
+        //- Mag face area vectors
+        mutable surfaceScalarField* magSfPtr_;
 
         //- Cell centres
-        mutable slicedVolVectorField* CPtr_;
+        mutable slicedVolVectorField* CSlicePtr_;
+
+        //- Cell centres
+        mutable volVectorField* CPtr_;
 
         //- Face centres
-        mutable slicedSurfaceVectorField* CfPtr_;
+        mutable slicedSurfaceVectorField* CfSlicePtr_;
+
+        //- Face centres
+        mutable surfaceVectorField* CfPtr_;
 
         //- Face motion fluxes
         mutable surfaceScalarField* phiPtr_;
@@ -164,14 +208,51 @@ class fvMesh
             void storeOldVol(const scalarField&);
 
 
+       // Make topological data
+
+            //- Get the patch types for the poly faces field
+            wordList polyFacesPatchTypes() const;
+
+            //- Modify face-poly-face addressing
+            GeometricBoundaryField<label, fvsPatchField, surfaceMesh>&
+                polyFacesBfRef();
+
+
        // Make geometric data
 
+            //- Make the face area vectors
             void makeSf() const;
+
+            //- Make the mag face area vectors
             void makeMagSf() const;
 
+            //- Make the cell centres
             void makeC() const;
+
+            //- Make the face centres
             void makeCf() const;
 
+            //- Modify old-time cell volumes
+            DimensionedField<scalar, volMesh>& V0Ref();
+
+            //- Modify old-old-time cell volumes
+            DimensionedField<scalar, volMesh>& V00Ref();
+
+            //- Modify cell face area vectors
+            surfaceVectorField& SfRef();
+
+            //- Modify cell face area magnitudes
+            surfaceScalarField& magSfRef();
+
+            //- Modify cell centres
+            volVectorField& CRef();
+
+            //- Modify face centres
+            surfaceVectorField& CfRef();
+
+            //- Modify cell face motion fluxes
+            surfaceScalarField& phiRef();
+
 
 public:
 
@@ -305,6 +386,25 @@ public:
                 return lduAddr().upperAddr();
             }
 
+            //- Return whether the fvMesh is conformal with the polyMesh
+            bool conformal() const;
+
+            //- Get the poly faces IO object
+            IOobject polyFacesBfIO(IOobject::readOption r) const;
+
+            //- Return face-poly-face addressing
+            const GeometricBoundaryField<label, fvsPatchField, surfaceMesh>&
+                polyFacesBf() const;
+
+            //- Return poly-bFace-patch addressing
+            const UCompactListList<label>& polyBFacePatches() const;
+
+            //- Return poly-bFace-patch-face addressing
+            const UCompactListList<label>& polyBFacePatchFaces() const;
+
+            //- Return the stitcher function class
+            const fvMeshStitcher& stitcher() const;
+
             //- Return the topo-changer function class
             const fvMeshTopoChanger& topoChanger() const;
 
@@ -320,15 +420,9 @@ public:
             //- Return old-time cell volumes
             const DimensionedField<scalar, volMesh>& V0() const;
 
-            //- Access old-time cell volumes
-            DimensionedField<scalar, volMesh>& V0Ref();
-
             //- Return old-old-time cell volumes
             const DimensionedField<scalar, volMesh>& V00() const;
 
-            //- Access old-old-time cell volumes
-            DimensionedField<scalar, volMesh>& V00Ref();
-
             //- Return sub-cycle cell volumes
             tmp<DimensionedField<scalar, volMesh>> Vsc() const;
 
@@ -341,10 +435,10 @@ public:
             //- Return cell face area magnitudes
             const surfaceScalarField& magSf() const;
 
-            //- Return cell centres as volVectorField
+            //- Return cell centres
             const volVectorField& C() const;
 
-            //- Return face centres as surfaceVectorField
+            //- Return face centres
             const surfaceVectorField& Cf() const;
 
             //- Return face deltas as surfaceVectorField
@@ -353,9 +447,6 @@ public:
             //- Return cell face motion fluxes
             const surfaceScalarField& phi() const;
 
-            //- Access cell face motion fluxes
-            surfaceScalarField& phiRef();
-
             //- Return a labelType of valid component indicators
             //  1 : valid (solved)
             // -1 : invalid (not solved)
@@ -396,6 +487,21 @@ public:
             //- Move points, returns volumes swept by faces in motion
             virtual tmp<scalarField> movePoints(const pointField&);
 
+            //- Conform the fvMesh to the polyMesh
+            void conform();
+
+            //- Unconform the fvMesh from the polyMesh
+            void unconform
+            (
+                const GeometricBoundaryField<label, fvsPatchField, surfaceMesh>&
+                    polyFacesBf,
+                const surfaceVectorField& Sf,
+                const surfaceVectorField& Cf,
+                const surfaceScalarField& phi =
+                    NullObjectRef<surfaceScalarField>(),
+                const bool sync = true
+            );
+
             //- Map all fields in time using given map.
             virtual void mapFields(const polyTopoChangeMap& map);
 
diff --git a/src/finiteVolume/fvMesh/fvMeshGeometry.C b/src/finiteVolume/fvMesh/fvMeshGeometry.C
index 8d394bc3df..b69996bb39 100644
--- a/src/finiteVolume/fvMesh/fvMeshGeometry.C
+++ b/src/finiteVolume/fvMesh/fvMeshGeometry.C
@@ -44,14 +44,14 @@ void Foam::fvMesh::makeSf() const
 
     // It is an error to attempt to recalculate
     // if the pointer is already set
-    if (SfPtr_)
+    if (SfSlicePtr_ || SfPtr_)
     {
         FatalErrorInFunction
             << "face areas already exist"
             << abort(FatalError);
     }
 
-    SfPtr_ = new slicedSurfaceVectorField
+    SfSlicePtr_ = new slicedSurfaceVectorField
     (
         IOobject
         (
@@ -79,14 +79,14 @@ void Foam::fvMesh::makeMagSf() const
 
     // It is an error to attempt to recalculate
     // if the pointer is already set
-    if (magSfPtr_)
+    if (magSfSlicePtr_ || magSfPtr_)
     {
         FatalErrorInFunction
             << "mag face areas already exist"
             << abort(FatalError);
     }
 
-    magSfPtr_ = new slicedSurfaceScalarField
+    magSfSlicePtr_ = new slicedSurfaceScalarField
     (
         IOobject
         (
@@ -114,7 +114,7 @@ void Foam::fvMesh::makeC() const
 
     // It is an error to attempt to recalculate
     // if the pointer is already set
-    if (CPtr_)
+    if (CSlicePtr_ || CPtr_)
     {
         FatalErrorInFunction
             << "cell centres already exist"
@@ -123,7 +123,7 @@ void Foam::fvMesh::makeC() const
 
     // Construct as slices. Only preserve processor (not e.g. cyclic)
 
-    CPtr_ = new slicedVolVectorField
+    CSlicePtr_ = new slicedVolVectorField
     (
         IOobject
         (
@@ -154,14 +154,14 @@ void Foam::fvMesh::makeCf() const
 
     // It is an error to attempt to recalculate
     // if the pointer is already set
-    if (CfPtr_)
+    if (CfSlicePtr_ || CfPtr_)
     {
         FatalErrorInFunction
             << "face centres already exist"
             << abort(FatalError);
     }
 
-    CfPtr_ = new slicedSurfaceVectorField
+    CfSlicePtr_ = new slicedSurfaceVectorField
     (
         IOobject
         (
@@ -180,6 +180,82 @@ void Foam::fvMesh::makeCf() const
 }
 
 
+Foam::volScalarField::Internal& Foam::fvMesh::V0Ref()
+{
+    if (!V0Ptr_)
+    {
+        FatalErrorInFunction
+            << "V0 is not available"
+            << abort(FatalError);
+    }
+
+    return *V0Ptr_;
+}
+
+
+Foam::volScalarField::Internal& Foam::fvMesh::V00Ref()
+{
+    if (!V00Ptr_)
+    {
+        V00();
+    }
+
+    return *V00Ptr_;
+}
+
+
+Foam::surfaceVectorField& Foam::fvMesh::SfRef()
+{
+    if (!SfPtr_)
+    {
+        SfPtr_ = Sf().cloneUnSliced().ptr();
+
+        deleteDemandDrivenData(SfSlicePtr_);
+    }
+
+    return *SfPtr_;
+}
+
+
+Foam::surfaceScalarField& Foam::fvMesh::magSfRef()
+{
+    if (!magSfPtr_)
+    {
+        magSfPtr_ = magSf().cloneUnSliced().ptr();
+
+        deleteDemandDrivenData(magSfSlicePtr_);
+    }
+
+    return *magSfPtr_;
+}
+
+
+Foam::volVectorField& Foam::fvMesh::CRef()
+{
+    if (!CPtr_)
+    {
+        CPtr_ = C().cloneUnSliced().ptr();
+
+        deleteDemandDrivenData(CSlicePtr_);
+    }
+
+    return *CPtr_;
+}
+
+
+Foam::surfaceVectorField& Foam::fvMesh::CfRef()
+{
+    if (!CfPtr_)
+    {
+        CfPtr_ = Cf().cloneUnSliced().ptr();
+
+        deleteDemandDrivenData(CfSlicePtr_);
+    }
+
+    return *CfPtr_;
+}
+
+
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 const Foam::volScalarField::Internal& Foam::fvMesh::V() const
@@ -226,19 +302,6 @@ const Foam::volScalarField::Internal& Foam::fvMesh::V0() const
 }
 
 
-Foam::volScalarField::Internal& Foam::fvMesh::V0Ref()
-{
-    if (!V0Ptr_)
-    {
-        FatalErrorInFunction
-            << "V0 is not available"
-            << abort(FatalError);
-    }
-
-    return *V0Ptr_;
-}
-
-
 const Foam::volScalarField::Internal& Foam::fvMesh::V00() const
 {
     if (!V00Ptr_)
@@ -267,17 +330,6 @@ const Foam::volScalarField::Internal& Foam::fvMesh::V00() const
 }
 
 
-Foam::volScalarField::Internal& Foam::fvMesh::V00Ref()
-{
-    if (!V00Ptr_)
-    {
-        V00();
-    }
-
-    return *V00Ptr_;
-}
-
-
 Foam::tmp<Foam::volScalarField::Internal>
 Foam::fvMesh::Vsc() const
 {
@@ -339,45 +391,65 @@ Foam::fvMesh::Vsc0() const
 
 const Foam::surfaceVectorField& Foam::fvMesh::Sf() const
 {
-    if (!SfPtr_)
+    if (SfPtr_)
+    {
+        return *SfPtr_;
+    }
+
+    if (!SfSlicePtr_)
     {
         makeSf();
     }
 
-    return *SfPtr_;
+    return *SfSlicePtr_;
 }
 
 
 const Foam::surfaceScalarField& Foam::fvMesh::magSf() const
 {
-    if (!magSfPtr_)
+    if (magSfPtr_)
+    {
+        return *magSfPtr_;
+    }
+
+    if (!magSfSlicePtr_)
     {
         makeMagSf();
     }
 
-    return *magSfPtr_;
+    return *magSfSlicePtr_;
 }
 
 
 const Foam::volVectorField& Foam::fvMesh::C() const
 {
-    if (!CPtr_)
+    if (CPtr_)
+    {
+        return *CPtr_;
+    }
+
+    if (!CSlicePtr_)
     {
         makeC();
     }
 
-    return *CPtr_;
+    return *CSlicePtr_;
 }
 
 
 const Foam::surfaceVectorField& Foam::fvMesh::Cf() const
 {
-    if (!CfPtr_)
+    if (CfPtr_)
+    {
+        return *CfPtr_;
+    }
+
+    if (!CfSlicePtr_)
     {
         makeCf();
     }
 
-    return *CfPtr_;
+    return *CfSlicePtr_;
 }
 
 
diff --git a/src/finiteVolume/fvMesh/fvMeshStitchers/fvMeshStitcher/fvMeshStitcher.C b/src/finiteVolume/fvMesh/fvMeshStitchers/fvMeshStitcher/fvMeshStitcher.C
new file mode 100644
index 0000000000..3f849afcca
--- /dev/null
+++ b/src/finiteVolume/fvMesh/fvMeshStitchers/fvMeshStitcher/fvMeshStitcher.C
@@ -0,0 +1,1481 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fvMeshStitcher.H"
+#include "globalIndex.H"
+#include "fvcSurfaceIntegrate.H"
+#include "MeshObject.H"
+#include "syncTools.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+template<class FaceList, class PointField>
+edge meshEdge
+(
+    const PrimitivePatch<FaceList, PointField>& p,
+    const label edgei
+)
+{
+    return edge
+    (
+        p.meshPoints()[p.edges()[edgei][0]],
+        p.meshPoints()[p.edges()[edgei][1]]
+    );
+}
+
+}
+
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(fvMeshStitcher, 0);
+    defineRunTimeSelectionTable(fvMeshStitcher, fvMesh);
+}
+
+
+const Foam::word Foam::fvMeshStitcher::nccFieldPrefix_ =
+    fvMeshStitcher::typeName + ":";
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::fvMeshStitcher::intersectNonConformalCyclic
+(
+    const nonConformalCyclicFvPatch& nccFvp,
+    surfaceLabelField::Boundary& polyFacesBf,
+    const tmp<surfaceLabelField::Boundary>& tOrigFacesNbrBf,
+    const tmp<surfaceVectorField::Boundary>& tOrigSfNbrBf,
+    const tmp<surfaceVectorField::Boundary>& tOrigCfNbrBf,
+    surfaceVectorField::Boundary& SfBf,
+    surfaceVectorField::Boundary& CfBf,
+    List<part>& origEdgeParts
+)
+{
+    const nonConformalCyclicFvPatch& nbrNccFvp = nccFvp.nbrPatch();
+
+    // Alias the original poly patches
+    const polyPatch& origPp = nccFvp.origPatch().patch();
+    const polyPatch& nbrOrigPp = nbrNccFvp.origPatch().patch();
+
+    // Get the indices of the non-conformal patches
+    labelList patchis(Pstream::nProcs(), -1);
+    labelList nbrPatchis(Pstream::nProcs(), -1);
+    patchis[Pstream::myProcNo()] = nccFvp.index();
+    nbrPatchis[Pstream::myProcNo()] = nbrNccFvp.index();
+    forAll(mesh_.boundary(), patchj)
+    {
+        const fvPatch& fvp = mesh_.boundary()[patchj];
+
+        if (isA<nonConformalProcessorCyclicFvPatch>(fvp))
+        {
+            const nonConformalProcessorCyclicFvPatch& ncpcFvp =
+                refCast<const nonConformalProcessorCyclicFvPatch>(fvp);
+
+            if (ncpcFvp.referPatchID() == nccFvp.index())
+            {
+                patchis[ncpcFvp.neighbProcNo()] = patchj;
+            }
+            if (ncpcFvp.referPatchID() == nbrNccFvp.index())
+            {
+                nbrPatchis[ncpcFvp.neighbProcNo()] = patchj;
+            }
+        }
+    }
+
+    // Get the intersection geometry
+    const patchToPatches::intersection& intersection =
+        nccFvp.nonConformalCyclicPatch().intersection();
+
+    // Unpack the patchToPatch addressing into lists of indices (fixed lists of
+    // 3 labels; owner face, neighbour face, couple index). These will be used
+    // to create the non-conformal faces, so sort them to make sure the
+    // non-conformal interfaces are ordered.
+    auto procFacesToIndices = []
+    (
+        const List<List<patchToPatch::procFace>>& faceOtherProcFaces,
+        const bool owner
+    )
+    {
+        // Compute interface sizes
+        labelList is(Pstream::nProcs(), 0);
+        forAll(faceOtherProcFaces, facei)
+        {
+            forAll(faceOtherProcFaces[facei], i)
+            {
+                const patchToPatch::procFace& otherProcFacei =
+                    faceOtherProcFaces[facei][i];
+
+                is[otherProcFacei.proci] ++;
+            }
+        }
+
+        // Allocate the indices
+        List<List<FixedList<label, 3>>> indices(Pstream::nProcs());
+        forAll(indices, proci)
+        {
+            indices[proci].resize(is[proci]);
+        }
+
+        // Set the indices
+        is = 0;
+        forAll(faceOtherProcFaces, facei)
+        {
+            forAll(faceOtherProcFaces[facei], i)
+            {
+                const patchToPatch::procFace& otherProcFacei =
+                    faceOtherProcFaces[facei][i];
+
+                FixedList<label, 3>& index =
+                    indices[otherProcFacei.proci][is[otherProcFacei.proci] ++];
+
+                index = {facei, otherProcFacei.facei, i};
+
+                if (!owner) Swap(index[0], index[1]);
+            }
+        }
+
+        // Sort to ensure ordering
+        forAll(indices, proci)
+        {
+            sort(indices[proci]);
+        }
+
+        return indices;
+    };
+
+    List<List<FixedList<label, 3>>> indices =
+        procFacesToIndices(intersection.srcTgtProcFaces(), true);
+
+    List<List<FixedList<label, 3>>> nbrIndices =
+        procFacesToIndices(intersection.tgtSrcProcFaces(), false);
+
+    // If addressing has been provided, then modify the indices to match. When
+    // a coupling has to be added, the couple index is set to -1. This
+    // indicates that there is no geometry in the patchToPatch engine for this
+    // coupling, and for a small stabilisation value to be used instead.
+    auto matchIndices = [&polyFacesBf, &tOrigFacesNbrBf]
+    (
+        List<List<FixedList<label, 3>>>& indices,
+        const nonConformalCyclicFvPatch& nccFvp,
+        const polyPatch& origPp,
+        const labelList& patchis,
+        const bool owner
+    )
+    {
+        const surfaceLabelField::Boundary& origFacesNbrBf = tOrigFacesNbrBf();
+
+        // Create what the indices should be
+        List<List<FixedList<label, 3>>> indicesRef(indices.size());
+        forAll(indices, proci)
+        {
+            const label patchi = patchis[proci];
+
+            if (patchi != -1)
+            {
+                indicesRef[proci].resize(polyFacesBf[patchi].size());
+
+                forAll(polyFacesBf[patchi], patchFacei)
+                {
+                    FixedList<label, 3>& indexRef =
+                        indicesRef[proci][patchFacei];
+
+                    indexRef =
+                        {
+                            polyFacesBf[patchi][patchFacei] - origPp.start(),
+                            origFacesNbrBf[patchi][patchFacei],
+                            -1
+                        };
+
+                    if (!owner) Swap(indexRef[0], indexRef[1]);
+                }
+            }
+        }
+
+        // Populate the indices with the index of the coupling
+        label nCouplesRemoved = 0, nCouplesAdded = 0;
+        forAll(indices, proci)
+        {
+            const label patchi = patchis[proci];
+
+            if (patchi != -1)
+            {
+                label patchFacei = 0, i = 0;
+
+                while
+                (
+                    patchFacei < polyFacesBf[patchi].size()
+                 && i < indices[proci].size()
+                )
+                {
+                    const FixedList<label, 3> index
+                    ({
+                        indices[proci][i][0],
+                        indices[proci][i][1],
+                        -1
+                    });
+
+                    FixedList<label, 3>& indexRef =
+                        indicesRef[proci][patchFacei];
+
+                    if (index < indexRef)
+                    {
+                        nCouplesRemoved ++;
+                        i ++;
+                    }
+                    else if (index == indexRef)
+                    {
+                        indexRef[2] = indices[proci][i][2];
+                        patchFacei ++;
+                        i ++;
+                    }
+                    else // (index > indexRef)
+                    {
+                        nCouplesAdded ++;
+                        patchFacei ++;
+                    }
+                }
+
+                nCouplesRemoved +=
+                    min(indices[proci].size() - i, 0);
+                nCouplesAdded +=
+                    min(polyFacesBf[patchi].size() - patchFacei, 0);
+            }
+        }
+
+        // Report if changes have been made
+        reduce(nCouplesRemoved, sumOp<label>());
+        reduce(nCouplesAdded, sumOp<label>());
+        if ((nCouplesRemoved || nCouplesAdded) && nccFvp.owner())
+        {
+            Info<< indent << nCouplesRemoved << '/' << nCouplesAdded
+                << " small couplings removed/added to " << nccFvp.name()
+                << endl;
+        }
+
+        // Set the indices to the correct values
+        Swap(indices, indicesRef);
+    };
+
+    if (tOrigFacesNbrBf.valid())
+    {
+        matchIndices(indices, nccFvp, origPp, patchis, true);
+
+        matchIndices(nbrIndices, nbrNccFvp, nbrOrigPp, nbrPatchis, false);
+    }
+
+    // Create couplings by transferring geometry from the original to the
+    // non-conformal patches
+    auto createCouplings =
+    [
+        &polyFacesBf,
+        &tOrigSfNbrBf,
+        &tOrigCfNbrBf,
+        &SfBf,
+        &CfBf
+    ]
+    (
+        const List<List<FixedList<label, 3>>>& indices,
+        const List<DynamicList<couple>>& couples,
+        const nonConformalCyclicFvPatch& nccFvp,
+        const polyPatch& origPp,
+        const labelList& patchis,
+        const bool owner
+    )
+    {
+        forAll(patchis, proci)
+        {
+            const label patchi = patchis[proci];
+            const label patchSize = indices[proci].size();
+
+            if (patchi == -1 && patchSize)
+            {
+                FatalErrorInFunction
+                    << "Intersection generated coupling through "
+                    << nccFvp.name() << " between processes "
+                    << Pstream::myProcNo() << " and " << proci
+                    << " but a corresponding processor interface was not found"
+                    << exit(FatalError);
+            }
+
+            if (patchi != -1)
+            {
+                polyFacesBf[patchi].resize(patchSize);
+                SfBf[patchi].resize(patchSize);
+                CfBf[patchi].resize(patchSize);
+
+                forAll(indices[proci], patchFacei)
+                {
+                    const label origFacei = indices[proci][patchFacei][!owner];
+                    const label i = indices[proci][patchFacei][2];
+
+                    polyFacesBf[patchi][patchFacei] =
+                        origFacei + origPp.start();
+
+                    couple c;
+                    if (i != -1)
+                    {
+                        c = couples[origFacei][i];
+                    }
+                    else
+                    {
+                        c =
+                            couple
+                            (
+                                part
+                                (
+                                    small*origPp.faceAreas()[origFacei],
+                                    origPp.faceCentres()[origFacei]
+                                ),
+                                part
+                                (
+                                    small*tOrigSfNbrBf()[patchi][patchFacei],
+                                    tOrigCfNbrBf()[patchi][patchFacei]
+                                )
+                            );
+                    }
+                    if (!owner)
+                    {
+                        c.nbr = c;
+                    }
+
+                    SfBf[patchi][patchFacei] = c.nbr.area;
+                    CfBf[patchi][patchFacei] = c.nbr.centre;
+
+                    part origP
+                    (
+                        SfBf[origPp.index()][origFacei],
+                        CfBf[origPp.index()][origFacei]
+                    );
+                    origP -= c;
+
+                    SfBf[origPp.index()][origFacei] = origP.area;
+                    CfBf[origPp.index()][origFacei] = origP.centre;
+                }
+            }
+        }
+    };
+
+    createCouplings
+    (
+        indices,
+        intersection.srcCouples(),
+        nccFvp,
+        origPp,
+        patchis,
+        true
+    );
+
+    createCouplings
+    (
+        nbrIndices,
+        intersection.tgtCouples(),
+        nbrNccFvp,
+        nbrOrigPp,
+        nbrPatchis,
+        false
+    );
+
+    // Add error geometry to the original patches
+    forAll(intersection.srcErrorParts(), origFacei)
+    {
+        part origP
+        (
+            SfBf[origPp.index()][origFacei],
+            CfBf[origPp.index()][origFacei]
+        );
+        origP += intersection.srcErrorParts()[origFacei];
+
+        SfBf[origPp.index()][origFacei] = origP.area;
+        CfBf[origPp.index()][origFacei] = origP.centre;
+    }
+
+    // Store the orig edge parts
+    forAll(intersection.srcEdgeParts(), origEdgei)
+    {
+        origEdgeParts[origEdgei] += intersection.srcEdgeParts()[origEdgei];
+    }
+}
+
+
+Foam::List<Foam::patchToPatches::intersection::part>
+Foam::fvMeshStitcher::calculateOwnerOrigBoundaryEdgeParts
+(
+    const List<List<part>>& patchEdgeParts
+)
+{
+    const polyBoundaryMesh& pbMesh = mesh_.boundaryMesh();
+
+    const nonConformalBoundary& ncb = nonConformalBoundary::New(mesh_);
+    const labelList& ownerOrigBoundaryPointMeshPoint =
+        ncb.ownerOrigBoundaryPointMeshPoint();
+    const labelList& ownerOrigBoundaryEdgeMeshEdge =
+        ncb.ownerOrigBoundaryEdgeMeshEdge();
+    const edgeList& ownerOrigBoundaryEdges = ncb.ownerOrigBoundaryEdges();
+    const edgeList& ownerOrigBoundaryMeshEdges =
+        ncb.ownerOrigBoundaryMeshEdges();
+
+    // Sum up boundary edge parts, being careful with signs
+    labelList ownerOrigBoundaryEdgeNParts(ownerOrigBoundaryEdges.size(), 0);
+    List<part> ownerOrigBoundaryEdgeParts(ownerOrigBoundaryEdges.size());
+    forAll(patchEdgeParts, patchi)
+    {
+        if (patchEdgeParts[patchi].empty()) continue;
+
+        const polyPatch& patch = pbMesh[patchi];
+
+        const labelList& patchEdgeOwnerOrigBoundaryEdges =
+            ncb.patchEdgeOwnerOrigBoundaryEdges(patchi);
+
+        forAll(patchEdgeParts[patchi], patchEdgei)
+        {
+            const label ownerOrigBoundaryEdgei =
+                patchEdgeOwnerOrigBoundaryEdges[patchEdgei];
+
+            const label sign =
+                edge::compare
+                (
+                    meshEdge(patch, patchEdgei),
+                    ownerOrigBoundaryMeshEdges[ownerOrigBoundaryEdgei]
+                );
+
+            const part& pU = patchEdgeParts[patchi][patchEdgei];
+            const part p = sign > 0 ? pU : -pU;
+
+            ownerOrigBoundaryEdgeNParts[ownerOrigBoundaryEdgei] ++;
+            ownerOrigBoundaryEdgeParts[ownerOrigBoundaryEdgei] += p;
+        }
+    }
+
+    // Give every point in the all boundary a global unique index
+    const globalIndex globalOwnerOrigBoundaryPoints
+    (
+        ownerOrigBoundaryPointMeshPoint.size()
+    );
+    labelList ownerOrigBoundaryPointIndices
+    (
+        ownerOrigBoundaryPointMeshPoint.size()
+    );
+    forAll(ownerOrigBoundaryPointIndices, ownerOrigBoundaryPointi)
+    {
+        ownerOrigBoundaryPointIndices[ownerOrigBoundaryPointi] =
+            globalOwnerOrigBoundaryPoints.toGlobal(ownerOrigBoundaryPointi);
+    }
+    syncTools::syncPointList
+    (
+        mesh_,
+        ownerOrigBoundaryPointMeshPoint,
+        ownerOrigBoundaryPointIndices,
+        minEqOp<label>(),
+        labelMax
+    );
+
+    // Synchronise the sign of the edge parts so that they can be
+    // meaningfully summed. This is done using the sign of the global point
+    // indices; if they are not in order, then reverse the part area.
+    forAll(ownerOrigBoundaryEdgeParts, ownerOrigBoundaryEdgei)
+    {
+        const edge& e = ownerOrigBoundaryEdges[ownerOrigBoundaryEdgei];
+
+        if
+        (
+            ownerOrigBoundaryPointIndices[e.start()]
+          > ownerOrigBoundaryPointIndices[e.end()])
+        {
+            ownerOrigBoundaryEdgeParts[ownerOrigBoundaryEdgei] =
+                - ownerOrigBoundaryEdgeParts[ownerOrigBoundaryEdgei];
+        }
+    }
+
+    // Average the boundary edge parts across couplings
+    syncTools::syncEdgeList
+    (
+        mesh_,
+        ownerOrigBoundaryEdgeMeshEdge,
+        ownerOrigBoundaryEdgeNParts,
+        plusEqOp<label>(),
+        0
+    );
+    syncTools::syncEdgeList
+    (
+        mesh_,
+        ownerOrigBoundaryEdgeMeshEdge,
+        ownerOrigBoundaryEdgeParts,
+        plusEqOp<part>(),
+        part(),
+        []
+        (
+            const transformer& vt,
+            const bool forward,
+            List<part>& fld
+        )
+        {
+            if (forward)
+            {
+                forAll(fld, i)
+                {
+                    if (magSqr(fld[i].area) != 0)
+                    {
+                        fld[i].area = vt.transform(fld[i].area);
+                        fld[i].centre = vt.transformPosition(fld[i].centre);
+                    }
+                }
+            }
+            else
+            {
+                forAll(fld, i)
+                {
+                    if (magSqr(fld[i].area) != 0)
+                    {
+                        fld[i].area = vt.invTransform(fld[i].area);
+                        fld[i].centre = vt.invTransformPosition(fld[i].centre);
+                    }
+                }
+            }
+        }
+    );
+    forAll(ownerOrigBoundaryEdgeParts, ownerOrigBoundaryEdgei)
+    {
+        if (ownerOrigBoundaryEdgeNParts[ownerOrigBoundaryEdgei] != 0)
+        {
+            ownerOrigBoundaryEdgeParts[ownerOrigBoundaryEdgei].area /=
+                ownerOrigBoundaryEdgeNParts[ownerOrigBoundaryEdgei];
+        }
+    }
+
+    // Put the edge parts back to their original orientations
+    forAll(ownerOrigBoundaryEdgeParts, ownerOrigBoundaryEdgei)
+    {
+        const edge& e = ownerOrigBoundaryEdges[ownerOrigBoundaryEdgei];
+
+        if
+        (
+            ownerOrigBoundaryPointIndices[e.start()]
+          > ownerOrigBoundaryPointIndices[e.end()]
+        )
+        {
+            ownerOrigBoundaryEdgeParts[ownerOrigBoundaryEdgei] =
+                - ownerOrigBoundaryEdgeParts[ownerOrigBoundaryEdgei];
+        }
+    }
+
+    return ownerOrigBoundaryEdgeParts;
+}
+
+
+
+void Foam::fvMeshStitcher::applyOwnerOrigBoundaryEdgeParts
+(
+    surfaceVectorField& SfSf,
+    surfaceVectorField& CfSf,
+    const List<part>& ownerOrigBoundaryEdgeParts
+)
+{
+    const polyBoundaryMesh& pbMesh = mesh_.boundaryMesh();
+
+    const nonConformalBoundary& ncb = nonConformalBoundary::New(mesh_);
+    const labelList ownerOrigPatchIDs = ncb.ownerOrigPatchIDs();
+    const labelList& ownerOrigBoundaryEdgeMeshEdge =
+        ncb.ownerOrigBoundaryEdgeMeshEdge();
+    const edgeList& ownerOrigBoundaryMeshEdges =
+        ncb.ownerOrigBoundaryMeshEdges();
+
+    boolList patchIsOwnerOrig(pbMesh.size(), false);
+    UIndirectList<bool>(patchIsOwnerOrig, ownerOrigPatchIDs) = true;
+
+    // Count the number of original faces attached to each boundary edge
+    labelList ownerOrigBoundaryEdgeNOrigFaces
+    (
+        ownerOrigBoundaryEdgeMeshEdge.size(),
+        0
+    );
+    forAll(ownerOrigBoundaryEdgeMeshEdge, ownerOrigBoundaryEdgei)
+    {
+        const label meshEdgei =
+            ownerOrigBoundaryEdgeMeshEdge[ownerOrigBoundaryEdgei];
+
+        forAll(mesh_.edgeFaces()[meshEdgei], edgeFacei)
+        {
+            const label facei = mesh_.edgeFaces()[meshEdgei][edgeFacei];
+
+            const label patchi =
+                mesh_.isInternalFace(facei)
+              ? -1 : pbMesh.patchID()[facei - mesh_.nInternalFaces()];
+
+            if (patchi != -1 && patchIsOwnerOrig[patchi])
+            {
+                ownerOrigBoundaryEdgeNOrigFaces[ownerOrigBoundaryEdgei] ++;
+            }
+        }
+    }
+
+    // Synchronise the boundary edge original face count
+    syncTools::syncEdgeList
+    (
+        mesh_,
+        ownerOrigBoundaryEdgeMeshEdge,
+        ownerOrigBoundaryEdgeNOrigFaces,
+        plusEqOp<label>(),
+        0
+    );
+
+    // If debugging, check that face changes are in sync
+    tmp<surfaceLabelField> tChanged =
+        debug
+      ? surfaceLabelField::New("changed", mesh_, dimensioned<label>(dimless, 0))
+      : tmp<surfaceLabelField>(nullptr);
+
+    // Modify faces connected to the boundary edges
+    forAll(ownerOrigBoundaryEdgeMeshEdge, ownerOrigBoundaryEdgei)
+    {
+        const label meshEdgei =
+            ownerOrigBoundaryEdgeMeshEdge[ownerOrigBoundaryEdgei];
+
+        const part& ownerOrigBoundaryEdgeP =
+            ownerOrigBoundaryEdgeParts[ownerOrigBoundaryEdgei];
+
+        switch (ownerOrigBoundaryEdgeNOrigFaces[ownerOrigBoundaryEdgei])
+        {
+            case 0:
+            {
+                continue;
+            }
+
+            // If this edge is connected to just one original face then add any
+            // edge area into that face
+            case 1:
+            {
+                label origFacei = -1, origPatchi = -1, origPatchFacei = -1;
+                forAll(mesh_.edgeFaces()[meshEdgei], edgeFacei)
+                {
+                    const label facei = mesh_.edgeFaces()[meshEdgei][edgeFacei];
+
+                    const label patchi =
+                        mesh_.isInternalFace(facei)
+                      ? -1 : pbMesh.patchID()[facei - mesh_.nInternalFaces()];
+
+                    if (patchi != -1 && patchIsOwnerOrig[patchi])
+                    {
+                        origFacei = facei;
+                        origPatchi = patchi;
+                        origPatchFacei = facei - pbMesh[patchi].start();
+                        break;
+                    }
+                }
+
+                if (origFacei != -1)
+                {
+                    vector& area =
+                        SfSf.boundaryFieldRef()[origPatchi][origPatchFacei];
+                    point& centre =
+                        CfSf.boundaryFieldRef()[origPatchi][origPatchFacei];
+
+                    const label sign =
+                        mesh_.faces()[origFacei].edgeDirection
+                        (
+                            ownerOrigBoundaryMeshEdges[ownerOrigBoundaryEdgei]
+                        );
+
+                    part p(area, centre);
+                    p +=
+                        sign > 0
+                      ? ownerOrigBoundaryEdgeP
+                      : -ownerOrigBoundaryEdgeP;
+
+                    area = p.area;
+                    centre = p.centre;
+
+                    if (debug)
+                    {
+                        tChanged->boundaryFieldRef()
+                            [origPatchi][origPatchFacei] = label(1);
+                    }
+                }
+
+                break;
+            }
+
+            // If this edge is connected to two original faces then add any
+            // edge area into non-original connected faces
+            case 2:
+            {
+                forAll(mesh_.edgeFaces()[meshEdgei], edgeFacei)
+                {
+                    const label facei = mesh_.edgeFaces()[meshEdgei][edgeFacei];
+
+                    const label patchi =
+                        mesh_.isInternalFace(facei)
+                      ? -1 : pbMesh.patchID()[facei - mesh_.nInternalFaces()];
+
+                    if (patchi != -1 && patchIsOwnerOrig[patchi])
+                    {
+                        continue;
+                    }
+
+                    const label patchFacei =
+                        patchi == -1 ? -1 : facei - pbMesh[patchi].start();
+
+                    vector& area =
+                        patchi == -1
+                      ? SfSf[facei]
+                      : SfSf.boundaryFieldRef()[patchi][patchFacei];
+                    point& centre =
+                        patchi == -1
+                      ? CfSf[facei]
+                      : CfSf.boundaryFieldRef()[patchi][patchFacei];
+
+                    const label sign =
+                        mesh_.faces()[facei].edgeDirection
+                        (
+                            ownerOrigBoundaryMeshEdges[ownerOrigBoundaryEdgei]
+                        );
+
+                    part p(area, centre);
+                    p +=
+                        sign < 0
+                      ? ownerOrigBoundaryEdgeP
+                      : -ownerOrigBoundaryEdgeP;
+
+                    area = p.area;
+                    centre = p.centre;
+
+                    if (debug && patchi != -1)
+                    {
+                        tChanged->boundaryFieldRef()
+                            [patchi][patchFacei] = label(1);
+                    }
+                }
+
+                break;
+            }
+
+            default:
+            {
+                FatalErrorInFunction
+                    << "Boundary is not manifold"
+                    << exit(FatalError);
+            }
+        }
+    }
+
+    // If debugging, check that face changes are in sync
+    if (debug)
+    {
+        const surfaceLabelField::Boundary& changedBf =
+            tChanged->boundaryField();
+
+        const surfaceLabelField::Boundary changedNbrBf
+        (
+            surfaceLabelField::null(),
+            changedBf.boundaryNeighbourField()
+        );
+
+        bool synchronised = true;
+
+        forAll(changedBf, patchi)
+        {
+            const fvsPatchLabelField& changedPf = changedBf[patchi];
+            const fvsPatchLabelField& changedNbrPf = changedNbrBf[patchi];
+
+            if (!isA<processorFvPatch>(changedPf.patch())) continue;
+
+            forAll(changedPf, patchFacei)
+            {
+                if (changedPf[patchFacei] != changedNbrPf[patchFacei])
+                {
+                    const label facei =
+                        changedPf.patch().start() + patchFacei;
+
+                    FatalErrorInFunction
+                        << "Face not synchronised with centre at "
+                        << mesh_.faceCentres()[facei] << endl;
+
+                    synchronised = false;
+                }
+            }
+        }
+
+        if (!synchronised)
+        {
+            FatalErrorInFunction
+                << exit(FatalError);
+        }
+    }
+}
+
+
+void Foam::fvMeshStitcher::stabiliseOrigPatchFaces
+(
+    surfaceVectorField::Boundary& SfBf,
+    surfaceVectorField::Boundary& CfBf
+)
+{
+    const nonConformalBoundary& ncb = nonConformalBoundary::New(mesh_);
+    const labelList allOrigPatchIDs = ncb.allOrigPatchIDs();
+
+    forAll(allOrigPatchIDs, i)
+    {
+        const label origPatchi = allOrigPatchIDs[i];
+        const polyPatch& origPp = mesh_.boundaryMesh()[origPatchi];
+
+        forAll(origPp, origPatchFacei)
+        {
+            part p
+            (
+                SfBf[origPatchi][origPatchFacei],
+                CfBf[origPatchi][origPatchFacei]
+            );
+
+            const part smallP
+            (
+                small*origPp.faceAreas()[origPatchFacei],
+                origPp.faceCentres()[origPatchFacei]
+            );
+
+            p += smallP;
+
+            SfBf[origPatchi][origPatchFacei] = p.area;
+            CfBf[origPatchi][origPatchFacei] = p.centre;
+        }
+    }
+}
+
+
+void Foam::fvMeshStitcher::intersectNonConformalCyclics
+(
+    surfaceLabelField::Boundary& polyFacesBf,
+    const tmp<surfaceLabelField::Boundary>& tOrigFacesNbrBf,
+    const tmp<surfaceVectorField::Boundary>& tOrigSfNbrBf,
+    const tmp<surfaceVectorField::Boundary>& tOrigCfNbrBf,
+    surfaceVectorField& SfSf,
+    surfaceVectorField& CfSf
+)
+{
+    const polyBoundaryMesh& pbMesh = mesh_.boundaryMesh();
+
+    const nonConformalBoundary& ncb = nonConformalBoundary::New(mesh_);
+    const labelList ownerOrigPatchIDs = ncb.ownerOrigPatchIDs();
+
+    // Alias the boundary geometry fields
+    surfaceVectorField::Boundary& SfBf = SfSf.boundaryFieldRef();
+    surfaceVectorField::Boundary& CfBf = CfSf.boundaryFieldRef();
+
+    // Create storage for and initialise the edge parts of source patches
+    List<List<part>> patchEdgeParts(mesh_.boundary().size());
+    forAll(ownerOrigPatchIDs, i)
+    {
+        const label origPatchi = ownerOrigPatchIDs[i];
+
+        patchEdgeParts[origPatchi].resize
+        (
+            mesh_.boundaryMesh()[origPatchi].nEdges(),
+            part(Zero)
+        );
+    }
+
+    // Do the intersections
+    forAll(mesh_.boundary(), patchi)
+    {
+        const fvPatch& fvp = mesh_.boundary()[patchi];
+
+        if (!isA<nonConformalCyclicFvPatch>(fvp)) continue;
+
+        const nonConformalCyclicFvPatch& nccFvp =
+            refCast<const nonConformalCyclicFvPatch>(fvp);
+
+        if (!nccFvp.owner()) continue;
+
+        intersectNonConformalCyclic
+        (
+            nccFvp,
+            polyFacesBf,
+            tOrigFacesNbrBf,
+            tOrigSfNbrBf,
+            tOrigCfNbrBf,
+            SfBf,
+            CfBf,
+            patchEdgeParts[nccFvp.origPatchID()]
+        );
+    }
+
+    // Construct the boundary edge geometry
+    List<part> ownerOrigBoundaryEdgeParts =
+        calculateOwnerOrigBoundaryEdgeParts(patchEdgeParts);
+
+    // Add the difference between patch edge parts and all boundary
+    // edge parts to the adjacent patch faces. This is an error part.
+    forAll(ownerOrigPatchIDs, i)
+    {
+        const label origPatchi = ownerOrigPatchIDs[i];
+        const polyPatch& origPatch = pbMesh[origPatchi];
+
+        const labelList& origPatchEdgeOwnerOrigBoundaryEdges =
+            ncb.patchEdgeOwnerOrigBoundaryEdges(origPatchi);
+
+        forAll(patchEdgeParts[origPatchi], origPatchEdgei)
+        {
+            const label ownerOrigBoundaryEdgei =
+                origPatchEdgeOwnerOrigBoundaryEdges[origPatchEdgei];
+
+            part errorP =
+                patchEdgeParts[origPatchi][origPatchEdgei];
+            errorP -= ownerOrigBoundaryEdgeParts[ownerOrigBoundaryEdgei];
+
+            forAll(origPatch.edgeFaces()[origPatchEdgei], patchEdgeFacei)
+            {
+                const label patchFacei =
+                    origPatch.edgeFaces()[origPatchEdgei][patchEdgeFacei];
+
+                part p
+                (
+                    SfBf[origPatchi][patchFacei],
+                    CfBf[origPatchi][patchFacei]
+                );
+                p += errorP;
+
+                SfBf[origPatchi][patchFacei] = p.area;
+                CfBf[origPatchi][patchFacei] = p.centre;
+            }
+        }
+    }
+
+    // Use the boundary edge geometry to correct all edge-connected faces
+    applyOwnerOrigBoundaryEdgeParts(SfSf, CfSf, ownerOrigBoundaryEdgeParts);
+
+    // Stabilise
+    stabiliseOrigPatchFaces(SfBf, CfBf);
+}
+
+
+template<class NonConformalFvPatch>
+inline void Foam::fvMeshStitcher::createNonConformalStabilisationGeometry
+(
+    const surfaceLabelField::Boundary& polyFacesBf,
+    surfaceVectorField& SfSf,
+    surfaceVectorField& CfSf
+)
+{
+    // Alias the boundary geometry fields
+    surfaceVectorField::Boundary& SfBf = SfSf.boundaryFieldRef();
+    surfaceVectorField::Boundary& CfBf = CfSf.boundaryFieldRef();
+
+    // Create small stabilisation geometry
+    forAll(mesh_.boundary(), patchi)
+    {
+        const fvPatch& fvp = mesh_.boundary()[patchi];
+
+        if (!isA<NonConformalFvPatch>(fvp)) continue;
+
+        const polyPatch& origPp =
+            refCast<const nonConformalFvPatch>(fvp).origPatch().patch();
+
+        SfBf[patchi] ==
+            vectorField
+            (
+                small*origPp.faceAreas(),
+                polyFacesBf[patchi] - origPp.start()
+            );
+        CfBf[patchi] ==
+            vectorField
+            (
+                origPp.faceCentres(),
+                polyFacesBf[patchi] - origPp.start()
+            );
+    }
+}
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+Foam::tmp<Foam::DimensionedField<Foam::scalar, Foam::volMesh>>
+Foam::fvMeshStitcher::openness() const
+{
+    return
+        mag(fvc::surfaceIntegrate(mesh_.Sf()))()*mesh_.V()
+       /max
+        (
+            mag(fvc::surfaceSum(cmptMag(mesh_.Sf())))(),
+            (small*sqr(cbrt(mesh_.V())))()
+        )();
+}
+
+
+Foam::tmp<Foam::DimensionedField<Foam::scalar, Foam::volMesh>>
+Foam::fvMeshStitcher::volumeConservationError
+(
+    const surfaceScalarField& meshPhi
+) const
+{
+    return
+        fvc::surfaceIntegrate(meshPhi*mesh_.time().deltaT())()
+      - (mesh_.V() - mesh_.V0())/mesh_.V();
+}
+
+
+Foam::tmp<Foam::DimensionedField<Foam::scalar, Foam::volMesh>>
+Foam::fvMeshStitcher::volumeConservationError() const
+{
+    return volumeConservationError(mesh_.phi());
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::fvMeshStitcher::fvMeshStitcher(fvMesh& mesh)
+:
+    mesh_(mesh)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::fvMeshStitcher::~fvMeshStitcher()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool Foam::fvMeshStitcher::stitches() const
+{
+    forAll(mesh_.boundary(), patchi)
+    {
+        if (isA<nonConformalFvPatch>(mesh_.boundary()[patchi]))
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+
+void Foam::fvMeshStitcher::updateMesh(const polyTopoChangeMap&)
+{}
+
+
+void Foam::fvMeshStitcher::movePoints()
+{}
+
+
+bool Foam::fvMeshStitcher::disconnect
+(
+    const bool changing,
+    const bool geometric
+)
+{
+    if (!stitches() || (changing && !mesh_.dynamic()))
+    {
+        return false;
+    }
+
+    // Is this mesh coupled?
+    const bool coupled = Pstream::parRun() || !mesh_.time().processorCase();
+
+    if (coupled && geometric)
+    {
+        Info<< indent << typeName << ": Disconnecting" << incrIndent << endl;
+    }
+
+    // Pre-conform surface fields. This splits the original and cyclic parts of
+    // the interface fields into separate boundary fields, with both sets of
+    // values store on the original faces. The original field overwrites the
+    // existing boundary values, whilst the cyclic field is stored as a
+    // separate field for use later.
+    preConformSurfaceFields();
+
+    // Undo all non-conformal changes and clear all geometry and topology
+    mesh_.conform();
+
+    // Resize all the affected patch fields
+    resizePatchFields<VolField>();
+    resizePatchFields<SurfaceField>();
+
+    // Prevent hangs caused by processor cyclic patches using mesh geometry
+    mesh_.deltaCoeffs();
+
+    meshObject::movePoints<fvMesh>(mesh_);
+    meshObject::movePoints<lduMesh>(mesh_);
+
+    if (coupled && geometric)
+    {
+        const volScalarField::Internal o(openness());
+        Info<< indent << "Cell min/avg/max openness = "
+            << gMin(o) << '/' << gAverage(o) << '/' << gMax(o) << endl;
+
+        if (mesh_.moving())
+        {
+            const volScalarField::Internal vce(volumeConservationError());
+            Info<< indent << "Cell min/avg/max volume conservation error = "
+                << gMin(vce) << '/' << gAverage(vce) << '/' << gMax(vce)
+                << endl;
+        }
+    }
+
+    if (coupled && geometric)
+    {
+        Info<< decrIndent;
+    }
+
+    return true;
+}
+
+
+bool Foam::fvMeshStitcher::connect
+(
+    const bool changing,
+    const bool geometric
+)
+{
+    if (!stitches() || (changing && !mesh_.dynamic()))
+    {
+        return false;
+    }
+
+    // Is this mesh coupled?
+    const bool coupled = Pstream::parRun() || !mesh_.time().processorCase();
+
+    // Create a copy of the conformal poly face addressing
+    surfaceLabelField::Boundary polyFacesBf
+    (
+        surfaceLabelField::null(),
+        mesh_.polyFacesBf()
+    );
+
+    // If starting up then load topology from disk, if it is available
+    bool haveTopology = false;
+    tmp<surfaceLabelField::Boundary> tOrigFacesNbrBf;
+    tmp<surfaceVectorField::Boundary> tOrigSfNbrBf;
+    tmp<surfaceVectorField::Boundary> tOrigCfNbrBf;
+    if (!changing)
+    {
+        const IOobject polyFacesBfIO(mesh_.polyFacesBfIO(IOobject::MUST_READ));
+
+        if (fileHandler().isFile(polyFacesBfIO.objectPath(false)))
+        {
+            haveTopology = true;
+
+            // Read the boundary field but then set default values for conformal
+            // patches as these patches will have had a uniform invalid index
+            // set in order to save disk space
+            surfaceLabelField::Boundary polyFacesBfRead
+            (
+                surfaceLabelField::null(),
+                surfaceLabelField(polyFacesBfIO, mesh_).boundaryField()
+            );
+            forAll(mesh_.boundary(), patchi)
+            {
+                if (isA<nonConformalFvPatch>(mesh_.boundary()[patchi]))
+                {
+                    polyFacesBf[patchi] = polyFacesBfRead[patchi];
+                }
+            }
+
+            // If coupled, also create a boundary field of the original patch
+            // indices on the neighbouring interface
+            if (coupled)
+            {
+                surfaceLabelField origFaces
+                (
+                    surfaceLabelField::New
+                    (
+                        "origFaces",
+                        mesh_,
+                        dimensioned<label>(dimless, -1)
+                    )
+                );
+                surfaceVectorField origSf("origSf", mesh_.Sf());
+                surfaceVectorField origCf("origCf", mesh_.Cf());
+
+                forAll(mesh_.boundary(), patchi)
+                {
+                    const fvPatch& fvp = mesh_.boundary()[patchi];
+
+                    if (!isA<nonConformalFvPatch>(fvp)) continue;
+
+                    const nonConformalFvPatch& ncFvp =
+                        refCast<const nonConformalFvPatch>(fvp);
+
+                    origFaces.boundaryFieldRef()[patchi] =
+                        polyFacesBf[patchi] - ncFvp.origPatch().start();
+                    origSf.boundaryFieldRef()[patchi] =
+                        vectorField(mesh_.faceAreas(), polyFacesBf[patchi]);
+                    origCf.boundaryFieldRef()[patchi] =
+                        pointField(mesh_.faceCentres(), polyFacesBf[patchi]);
+                }
+
+                tOrigFacesNbrBf =
+                    new surfaceLabelField::Boundary
+                    (
+                        surfaceLabelField::null(),
+                        origFaces.boundaryField().boundaryNeighbourField()
+                    );
+                tOrigSfNbrBf =
+                    new surfaceVectorField::Boundary
+                    (
+                        surfaceVectorField::null(),
+                        origSf.boundaryField().boundaryNeighbourField()
+                    );
+                tOrigCfNbrBf =
+                    new surfaceVectorField::Boundary
+                    (
+                        surfaceVectorField::null(),
+                        origCf.boundaryField().boundaryNeighbourField()
+                    );
+
+                // See note in fvMesh::unconform regarding the transformation
+                // of cell centres. The same applies here.
+                forAll(tOrigCfNbrBf(), patchi)
+                {
+                    fvsPatchVectorField& Cfp = tOrigCfNbrBf.ref()[patchi];
+                    if (Cfp.patch().coupled())
+                    {
+                        const transformer& t =
+                            refCast<const coupledFvPatch>(Cfp.patch())
+                           .transform();
+                        t.invTransform(Cfp, Cfp);
+                        t.transformPosition(Cfp, Cfp);
+                    }
+                }
+            }
+        }
+    }
+
+    // Access all the intersections in advance. Makes the log nicer.
+    if (coupled && (geometric || !haveTopology))
+    {
+        forAll(mesh_.boundary(), patchi)
+        {
+            const fvPatch& fvp = mesh_.boundary()[patchi];
+
+            if (!isA<nonConformalCyclicFvPatch>(fvp)) continue;
+
+            const nonConformalCyclicFvPatch& nccFvp =
+                refCast<const nonConformalCyclicFvPatch>(fvp);
+
+            if (!nccFvp.owner()) continue;
+
+            nccFvp.nonConformalCyclicPatch().intersection();
+        }
+    }
+
+    if (coupled && (geometric || !haveTopology))
+    {
+        Info<< indent << typeName << ": Connecting" << incrIndent << endl;
+    }
+
+    // Create copies of geometry fields to be modified
+    surfaceVectorField Sf(mesh_.Sf().cloneUnSliced()());
+    surfaceVectorField Cf(mesh_.Cf().cloneUnSliced()());
+
+    // Construct non-conformal geometry
+    if (coupled && (geometric || !haveTopology))
+    {
+        // Do the intersection and create the non-conformal cyclic faces
+        intersectNonConformalCyclics
+        (
+            polyFacesBf,
+            tOrigFacesNbrBf,
+            tOrigSfNbrBf,
+            tOrigCfNbrBf,
+            Sf,
+            Cf
+        );
+
+        // Create stabilisation geometry on any error faces specified in the
+        // addressing
+        createNonConformalStabilisationGeometry<nonConformalErrorFvPatch>
+        (
+            polyFacesBf,
+            Sf,
+            Cf
+        );
+    }
+    else
+    {
+        // If not coupled, then create stabilisation geometry on all
+        // non-conformal faces specified in the addressing
+        createNonConformalStabilisationGeometry<nonConformalFvPatch>
+        (
+            polyFacesBf,
+            Sf,
+            Cf
+        );
+    }
+
+    // If the mesh is moving then create any additional non-conformal geometry
+    // necessary to correct the mesh fluxes
+    if (mesh_.moving())
+    {
+        initCorrectMeshPhi(polyFacesBf, Sf, Cf);
+    }
+
+    // Make the mesh non-conformal
+    mesh_.unconform(polyFacesBf, Sf, Cf);
+
+    // Store all old-time fields. If we don't do this then we risk triggering a
+    // store in the middle of mapping and potentially overwriting a mapped
+    // old-time field with a not-yet-mapped new-time field.
+    storeOldTimeFields<VolField>();
+    storeOldTimeFields<SurfaceField>();
+
+    // Resize all the affected patch fields
+    resizePatchFields<VolField>();
+    resizePatchFields<SurfaceField>();
+
+    // If the mesh is moving then correct the mesh fluxes
+    if (mesh_.moving())
+    {
+        correctMeshPhi(polyFacesBf, Sf, Cf);
+    }
+
+    // Post-non-conform surface fields. This reconstructs the original and
+    // cyclic parts of the interface fields from separate original and cyclic
+    // parts. The original part was store in the same field, whilst the cyclic
+    // part was separately registered.
+    postNonConformSurfaceFields();
+
+    // Volume fields are assumed to be intensive. So, the value on a face which
+    // has changed in size can be retained without modification. New faces need
+    // values to be set. This is done by evaluating all the nonConformalCoupled
+    // patch fields.
+    evaluateVolFields();
+
+    // Prevent hangs caused by processor cyclic patches using mesh geometry
+    mesh_.deltaCoeffs();
+
+    meshObject::movePoints<fvMesh>(mesh_);
+    meshObject::movePoints<lduMesh>(mesh_);
+
+    if (coupled && geometric)
+    {
+        const volScalarField::Internal o(openness());
+        Info<< indent << "Cell min/avg/max openness = "
+            << gMin(o) << '/' << gAverage(o) << '/' << gMax(o) << endl;
+
+        if (mesh_.moving())
+        {
+            const volScalarField::Internal vce(volumeConservationError());
+            Info<< indent << "Cell min/avg/max volume conservation error = "
+                << gMin(vce) << '/' << gAverage(vce) << '/' << gMax(vce)
+                << endl;
+        }
+
+        if (mesh_.moving())
+        {
+            // Create a boundary field of the imbalance between the mesh fluxes
+            // on either side of interfaces (like phiErrorb above)
+            surfaceScalarField::Boundary mfe
+            (
+                surfaceScalarField::Internal::null(),
+                mesh_.phi().boundaryField()
+            );
+            mfe += mesh_.phi().boundaryField().boundaryNeighbourField();
+
+            // Determine the number of non-processor patches
+            label nNonProcPatches = 0;
+            forAll(mesh_.boundary(), patchi)
+            {
+                const fvPatch& fvp = mesh_.boundary()[patchi];
+
+                if (!isA<processorFvPatch>(fvp))
+                {
+                    if (nNonProcPatches != patchi)
+                    {
+                        FatalErrorInFunction
+                            << "Processor patches do not follow non-processor "
+                            << "patches" << exit(FatalError);
+                    }
+
+                    nNonProcPatches ++;
+                }
+            }
+
+            // Work out the min, avg and max error for all non-conformal
+            // cyclics, including any errors on referred processor cyclics
+            scalarField minMfe(nNonProcPatches, vGreat);
+            scalarField sumMfe(nNonProcPatches, 0), nSumMfe(nNonProcPatches, 0);
+            scalarField maxMfe(nNonProcPatches, -vGreat);
+            forAll(mfe, patchi)
+            {
+                const fvPatch& fvp = mesh_.boundary()[patchi];
+
+                const label nccPatchi =
+                    isA<nonConformalCyclicFvPatch>(fvp)
+                  ? refCast<const nonConformalCyclicFvPatch>(fvp)
+                   .index()
+                  : isA<nonConformalProcessorCyclicFvPatch>(fvp)
+                  ? refCast<const nonConformalProcessorCyclicFvPatch>(fvp)
+                   .referPatchID()
+                  : -1;
+
+                if (nccPatchi != -1)
+                {
+                    minMfe[nccPatchi] =
+                        min(minMfe[nccPatchi], min(mfe[patchi]));
+                    sumMfe[nccPatchi] += sum(mfe[patchi]);
+                    nSumMfe[nccPatchi] += mfe[patchi].size();
+                    maxMfe[nccPatchi] =
+                        max(maxMfe[nccPatchi], max(mfe[patchi]));
+                }
+            }
+            reduce(minMfe, minOp<scalarField>());
+            reduce(sumMfe, sumOp<scalarField>());
+            reduce(nSumMfe, sumOp<scalarField>());
+            reduce(maxMfe, maxOp<scalarField>());
+
+            // Report
+            forAll(minMfe, patchi)
+            {
+                const fvPatch& fvp = mesh_.boundary()[patchi];
+
+                if
+                (
+                    isA<nonConformalCyclicFvPatch>(fvp)
+                 && refCast<const nonConformalCyclicFvPatch>(fvp).owner()
+                )
+                {
+                    Info<< indent << fvp.name()
+                        << " min/avg/max mesh flux error = " << minMfe[patchi]
+                        << '/' << sumMfe[patchi]/(nSumMfe[patchi] + vSmall)
+                        << '/' << maxMfe[patchi] << endl;
+                }
+            }
+        }
+    }
+
+    if (coupled && (geometric || !haveTopology))
+    {
+        Info<< decrIndent;
+    }
+
+    return true;
+}
+
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvMeshStitchers/fvMeshStitcher/fvMeshStitcher.H b/src/finiteVolume/fvMesh/fvMeshStitchers/fvMeshStitcher/fvMeshStitcher.H
new file mode 100644
index 0000000000..32ec0ab06c
--- /dev/null
+++ b/src/finiteVolume/fvMesh/fvMeshStitchers/fvMeshStitcher/fvMeshStitcher.H
@@ -0,0 +1,405 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::fvMeshStitcher
+
+Description
+    Mesh manipulator that uses the intersection provided by the cyclic
+    non-conformal poly patches to create non-conformal finite volume
+    interfaces.
+
+SourceFiles
+    fvMeshStitcher.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef fvMeshStitcher_H
+#define fvMeshStitcher_H
+
+#include "fvMesh.H"
+#include "intersectionPatchToPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class nonConformalCyclicFvPatch;
+
+/*---------------------------------------------------------------------------*\
+                        Class fvMeshStitcher Declaration
+\*---------------------------------------------------------------------------*/
+
+class fvMeshStitcher
+{
+protected:
+
+    // Protected Typedefs
+
+        //- Alias for surface boundary fields to reduce verbosity of method
+        //  definitions below
+        template<class Type>
+        using SurfaceFieldBoundary =
+            GeometricBoundaryField<Type, fvsPatchField, surfaceMesh>;
+
+        //- Alias the patchToPatch intersection part struct
+        using part = patchToPatches::intersection::part;
+
+        //- Alias the patchToPatch intersection couple struct
+        using couple = patchToPatches::intersection::couple;
+
+
+private:
+
+    // Private Static Data
+
+        //- Prefix applied to the names of non-conformal fields which are
+        //  stored for mapping purposes
+        static const word nccFieldPrefix_;
+
+
+    // Private Data
+
+        //- Non-const fvMesh reference to allow update
+        fvMesh& mesh_;
+
+
+    // Private Member Functions
+
+        // Intersection
+
+            //- Perform intersections for the given non-conformal interface
+            void intersectNonConformalCyclic
+            (
+                const nonConformalCyclicFvPatch& nccFvp,
+                SurfaceFieldBoundary<label>& polyFacesBf,
+                const tmp<SurfaceFieldBoundary<label>>& tOrigFacesNbrBf,
+                const tmp<SurfaceFieldBoundary<vector>>& tOrigSfNbrBf,
+                const tmp<SurfaceFieldBoundary<point>>& tOrigCfNbrBf,
+                SurfaceFieldBoundary<vector>& SfBf,
+                SurfaceFieldBoundary<vector>& CfBf,
+                List<part>& origEdgeParts
+            );
+
+            //- Convert per-patch lists of edge parts into a single
+            //  owner-orig-boundary list of edge parts that can be applied to
+            //  the mesh
+            List<part> calculateOwnerOrigBoundaryEdgeParts
+            (
+                const List<List<part>>& patchEdgeParts
+            );
+
+            //- Apply a list of owner-orig-boundary edge parts to
+            //  non-orig-patch faces (both internal and boundary)
+            void applyOwnerOrigBoundaryEdgeParts
+            (
+                surfaceVectorField& SfSf,
+                surfaceVectorField& CfSf,
+                const List<part>& ownerOrigBoundaryEdgeParts
+            );
+
+            //- Stabilise the faces that have had non-conformal coupled parts
+            //  cut out from them
+            void stabiliseOrigPatchFaces
+            (
+                SurfaceFieldBoundary<vector>& SfBf,
+                SurfaceFieldBoundary<vector>& CfBf
+            );
+
+            //- Perform intersections for all non-conformal interfaces
+            void intersectNonConformalCyclics
+            (
+                SurfaceFieldBoundary<label>& polyFacesBf,
+                const tmp<SurfaceFieldBoundary<label>>& tOrigFacesNbrBf,
+                const tmp<SurfaceFieldBoundary<vector>>& tOrigSfNbrBf,
+                const tmp<SurfaceFieldBoundary<point>>& tOrigCfNbrBf,
+                surfaceVectorField& SfSf,
+                surfaceVectorField& CfSf
+            );
+
+            //- Apply the given non-conformal topology (polyFacesBf) to the
+            //  face geometry fields for the given patch type. Just set small
+            //  stabilisation values. Don't actually do any cutting. Used for
+            //  initialisation, or in situations when cutting cannot be done
+            //  (e.g., when post processing a processor case).
+            template<class NonConformalFvPatch>
+            inline void createNonConformalStabilisationGeometry
+            (
+                const SurfaceFieldBoundary<label>& polyFacesBf,
+                surfaceVectorField& SfSf,
+                surfaceVectorField& CfSf
+            );
+
+
+        // Motion
+
+            //- Return whether or not this stitcher supports a changing mesh
+            virtual bool changing() const = 0;
+
+            //- Initialise correction of the mesh fluxes
+            virtual void initCorrectMeshPhi
+            (
+                SurfaceFieldBoundary<label>& polyFacesBf,
+                surfaceVectorField& SfSf,
+                surfaceVectorField& CfSf
+            ) = 0;
+
+            //- Correct the mesh fluxes
+            virtual void correctMeshPhi
+            (
+                const SurfaceFieldBoundary<label>& polyFacesBf,
+                surfaceVectorField& SfSf,
+                surfaceVectorField& CfSf
+            ) = 0;
+
+
+        // Field Mapping
+
+            //- Store old times for all fields of a given type and class
+            template<class Type, template<class> class GeoField>
+            void storeOldTimeFields();
+
+            //- Store old times for all fields of a given class
+            template<template<class> class GeoField>
+            void storeOldTimeFields();
+
+            //- Resize the patch fields of a given type and class to match the
+            //  mesh
+            template<class Type, template<class> class GeoField>
+            void resizePatchFields();
+
+            //- Resize the patch fields of a given class to match the mesh
+            template<template<class> class GeoField>
+            void resizePatchFields();
+
+            //- Pre-conform surface fields of a given type by separating NCC
+            //  and original parts of non-conformal couplings and storing them
+            //  in the database as separate fields
+            template<class Type>
+            void preConformSurfaceFields();
+
+            //- Pre-conform surface fields by separating NCC and original
+            //  parts of non-conformal couplings and storing them in the
+            //  database as separate fields
+            inline void preConformSurfaceFields();
+
+            //- Post-non-conform surface fields of a given type by looking up
+            //  NCC and original parts of non-conformal couplings and combining
+            //  them into a single non-conformal boundary field
+            template<class Type>
+            void postNonConformSurfaceFields();
+
+            //- Post-non-conform surface fields by looking up NCC and
+            //  original parts of non-conformal couplings and combining them
+            //  into a single non-conformal boundary field
+            inline void postNonConformSurfaceFields();
+
+            //- Evaluate all non-conformal vol patch fields of a given type
+            template<class Type>
+            void evaluateVolFields();
+
+            //- Evaluate all non-conformal vol patch fields
+            inline void evaluateVolFields();
+
+
+protected:
+
+    // Protected Member Functions
+
+        // Field Mapping
+
+            //- Reverse-map sum the values of a field
+            template<class Type>
+            static tmp<Field<Type>> fieldRMapSum
+            (
+                const Field<Type>& f,
+                const label size,
+                const labelUList& addr
+            );
+
+            //- Reverse-map sum the values of a field
+            template<class Type>
+            static tmp<Field<Type>> fieldRMapSum
+            (
+                const tmp<Field<Type>>& f,
+                const label size,
+                const labelUList& addr
+            );
+
+            //- Return the total non-conformal area associated with each
+            //  original face
+            inline tmp<SurfaceFieldBoundary<scalar>> getOrigNccMagSfb() const;
+
+            //- Extract the non-conformal-coupled parts of the boundary field
+            //  and store it on the conformal faces
+            template<class Type>
+            tmp<SurfaceFieldBoundary<Type>> conformalNccBoundaryField
+            (
+                const SurfaceFieldBoundary<Type>& fieldb
+            ) const;
+
+            //- Extract the original parts of the boundary field and store it
+            //  on the conformal faces
+            template<class Type>
+            tmp<SurfaceFieldBoundary<Type>> conformalOrigBoundaryField
+            (
+                const SurfaceFieldBoundary<Type>& fieldb
+            ) const;
+
+            //- Combine non-conformal-coupled and original parts of the
+            //  boundary field from the conformal faces to construct the
+            //  complete non-conformal boundary field
+            template<class Type>
+            tmp<SurfaceFieldBoundary<Type>> nonConformalBoundaryField
+            (
+                const SurfaceFieldBoundary<Type>& nccFieldb,
+                const SurfaceFieldBoundary<Type>& origFieldb
+            ) const;
+
+            //- Synchronise the boundary field by combining corresponding
+            //  values across couplings with the given weightings
+            template<class Type>
+            tmp<SurfaceFieldBoundary<Type>> synchronisedBoundaryField
+            (
+                const SurfaceFieldBoundary<Type>& fieldb,
+                const bool flip,
+                const scalar ownerWeight,
+                const scalar neighbourWeight
+            ) const;
+
+            //- Synchronise the boundary field by combining corresponding
+            //  values across couplings with equal weightings
+            template<class Type>
+            tmp<SurfaceFieldBoundary<Type>> synchronisedBoundaryField
+            (
+                const SurfaceFieldBoundary<Type>& fieldb
+            ) const;
+
+
+        // Checking
+
+            //- Return the non-dimensional cell openness for debugging/checking
+            tmp<DimensionedField<scalar, volMesh>> openness() const;
+
+            //- Return the non-dimensional cell openness for debugging/checking
+            tmp<DimensionedField<scalar, volMesh>> volumeConservationError
+            (
+                const surfaceScalarField& meshPhi
+            ) const;
+
+            //- Return the non-dimensional cell openness for debugging/checking
+            tmp<DimensionedField<scalar, volMesh>> volumeConservationError
+            (
+            ) const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("fvMeshStitcher");
+
+
+    // Declare run-time constructor selection table
+
+        declareRunTimeSelectionTable
+        (
+            autoPtr,
+            fvMeshStitcher,
+            fvMesh,
+            (fvMesh& mesh),
+            (mesh)
+        );
+
+
+    // Constructors
+
+        //- Construct from fvMesh
+        explicit fvMeshStitcher(fvMesh&);
+
+        //- Disallow default bitwise copy construction
+        fvMeshStitcher(const fvMeshStitcher&) = delete;
+
+
+    // Selectors
+
+        //- Select, construct and return the fvMeshStitcher
+        static autoPtr<fvMeshStitcher> New(fvMesh&, const bool changing);
+
+
+    //- Destructor
+    virtual ~fvMeshStitcher();
+
+
+    // Member Functions
+
+        //- Return the fvMesh
+        fvMesh& mesh()
+        {
+            return mesh_;
+        }
+
+        //- Does this stitcher do anything?
+        bool stitches() const;
+
+        //- Update local data for topology changes
+        virtual void updateMesh(const polyTopoChangeMap&);
+
+        //- Update local data for mesh motion
+        virtual void movePoints();
+
+        //- Disconnect the mesh by removing faces from the nonConformalCyclics
+        virtual bool disconnect(const bool changing, const bool geometric);
+
+        //- Connect the mesh by adding faces into the nonConformalCyclics
+        virtual bool connect(const bool changing, const bool geometric);
+
+        //- Write the mover state
+        virtual bool write(const bool write = true) const
+        {
+            return true;
+        }
+
+
+    // Member Operators
+
+        //- Disallow default bitwise assignment
+        void operator=(const fvMeshStitcher&) = delete;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "fvMeshStitcherTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvMeshStitchers/fvMeshStitcher/fvMeshStitcherNew.C b/src/finiteVolume/fvMesh/fvMeshStitchers/fvMeshStitcher/fvMeshStitcherNew.C
new file mode 100644
index 0000000000..a40ff804c0
--- /dev/null
+++ b/src/finiteVolume/fvMesh/fvMeshStitchers/fvMeshStitcher/fvMeshStitcherNew.C
@@ -0,0 +1,97 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fvMeshStitcher.H"
+
+// * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * * //
+
+Foam::autoPtr<Foam::fvMeshStitcher> Foam::fvMeshStitcher::New
+(
+    fvMesh& mesh,
+    const bool changing
+)
+{
+    typeIOobject<IOdictionary> dictHeader
+    (
+        IOobject
+        (
+            "dynamicMeshDict",
+            mesh.time().constant(),
+            mesh.dbDir(),
+            mesh,
+            IOobject::READ_IF_PRESENT,
+            IOobject::NO_WRITE,
+            false
+        )
+    );
+
+    if (changing && dictHeader.headerOk())
+    {
+        IOdictionary dict(dictHeader);
+
+        forAllConstIter(dictionary, dict, iter)
+        {
+            if (!iter().isDict()) continue;
+
+            const dictionary& changerDict = iter().dict();
+
+            if (!changerDict.found("libs")) continue;
+
+            libs.open
+            (
+                changerDict,
+                "libs",
+                fvMeshConstructorTablePtr_
+            );
+        }
+    }
+
+    forAllConstIter
+    (
+        fvMeshConstructorTable,
+        *fvMeshConstructorTablePtr_,
+        cstrIter
+    )
+    {
+        autoPtr<fvMeshStitcher> stitcherPtr(cstrIter()(mesh));
+
+        if (stitcherPtr->changing() == (changing && dictHeader.headerOk()))
+        {
+            return stitcherPtr;
+        }
+    }
+
+    FatalErrorInFunction
+        << typeName << " for " << (changing ? "" : "non-")
+        << "changing mesh not found " << nl << nl
+        << "Valid " << typeName << "s are : " << endl
+        << fvMeshConstructorTablePtr_->toc()
+        << exit(FatalError);
+
+    return autoPtr<fvMeshStitcher>(nullptr);
+}
+
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvMeshStitchers/fvMeshStitcher/fvMeshStitcherTemplates.C b/src/finiteVolume/fvMesh/fvMeshStitchers/fvMeshStitcher/fvMeshStitcherTemplates.C
new file mode 100644
index 0000000000..0c73be9bab
--- /dev/null
+++ b/src/finiteVolume/fvMesh/fvMeshStitchers/fvMeshStitcher/fvMeshStitcherTemplates.C
@@ -0,0 +1,737 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Description
+    Perform mapping of finite volume fields required by stitching.
+
+\*---------------------------------------------------------------------------*/
+
+#include "volFields.H"
+#include "surfaceFields.H"
+#include "fvPatchFieldMapper.H"
+#include "fvMeshStitcher.H"
+#include "setSizeFieldMapper.H"
+#include "nonConformalBoundary.H"
+#include "nonConformalCyclicFvPatch.H"
+#include "nonConformalProcessorCyclicFvPatch.H"
+#include "nonConformalErrorFvPatch.H"
+#include "processorFvPatch.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class Type, template<class> class GeoField>
+void Foam::fvMeshStitcher::storeOldTimeFields()
+{
+    HashTable<GeoField<Type>*> fields(mesh_.lookupClass<GeoField<Type>>());
+    forAllIter(typename HashTable<GeoField<Type>*>, fields, iter)
+    {
+        iter()->storeOldTimes();
+    }
+}
+
+
+template<template<class> class GeoField>
+void Foam::fvMeshStitcher::storeOldTimeFields()
+{
+    #define StoreOldTimeFields(Type, nullArg) \
+        storeOldTimeFields<Type, GeoField>();
+    FOR_ALL_FIELD_TYPES(StoreOldTimeFields);
+    #undef StoreOldTimeFields
+}
+
+
+template<class Type, template<class> class GeoField>
+void Foam::fvMeshStitcher::resizePatchFields()
+{
+    struct fvPatchFieldSetSizer
+    :
+        public fvPatchFieldMapper,
+        public setSizeFieldMapper
+    {
+        fvPatchFieldSetSizer(const label size)
+        :
+            setSizeFieldMapper(size)
+        {}
+    };
+
+    HashTable<GeoField<Type>*> fields(mesh_.lookupClass<GeoField<Type>>());
+    forAllIter(typename HashTable<GeoField<Type>*>, fields, iter)
+    {
+        forAll(mesh_.boundary(), patchi)
+        {
+            typename GeoField<Type>::Patch& pf =
+                iter()->boundaryFieldRef()[patchi];
+
+            if (isA<nonConformalFvPatch>(pf.patch()))
+            {
+                pf.autoMap(fvPatchFieldSetSizer(pf.patch().size()));
+            }
+        }
+    }
+}
+
+
+template<template<class> class GeoField>
+void Foam::fvMeshStitcher::resizePatchFields()
+{
+    #define ResizePatchFields(Type, nullArg) \
+        resizePatchFields<Type, GeoField>();
+    FOR_ALL_FIELD_TYPES(ResizePatchFields);
+    #undef ResizePatchFields
+}
+
+
+template<class Type>
+void Foam::fvMeshStitcher::preConformSurfaceFields()
+{
+    HashTable<SurfaceField<Type>*> fields
+    (
+        mesh_.lookupClass<SurfaceField<Type>>()
+    );
+
+    const surfaceScalarField* phiPtr =
+        mesh_.foundObject<surfaceScalarField>("meshPhi")
+      ? &mesh_.lookupObject<surfaceScalarField>("meshPhi")
+      : nullptr;
+    const surfaceScalarField* phi0Ptr =
+        mesh_.foundObject<surfaceScalarField>("meshPhi_0")
+      ? &mesh_.lookupObject<surfaceScalarField>("meshPhi_0")
+      : nullptr;
+
+    forAllIter(typename HashTable<SurfaceField<Type>*>, fields, iter)
+    {
+        SurfaceField<Type>& field = *iter();
+
+        if
+        (
+            &field == static_cast<const regIOobject*>(phiPtr)
+         || &field == static_cast<const regIOobject*>(phi0Ptr)
+        ) continue;
+
+        autoPtr<SurfaceField<Type>> nccFieldPtr
+        (
+            new SurfaceField<Type>
+            (
+                IOobject
+                (
+                    nccFieldPrefix_ + field.name(),
+                    mesh_.time().timeName(),
+                    mesh_
+                ),
+                field
+            )
+        );
+
+        nccFieldPtr->boundaryFieldRef() =
+            conformalNccBoundaryField<Type>(field.boundaryField());
+
+        field.boundaryFieldRef() =
+            conformalOrigBoundaryField<Type>(field.boundaryField());
+
+        nccFieldPtr.ptr()->store();
+    }
+}
+
+
+inline void Foam::fvMeshStitcher::preConformSurfaceFields()
+{
+    #define PreConformSurfaceFields(Type, nullArg) \
+        preConformSurfaceFields<Type>();
+    FOR_ALL_FIELD_TYPES(PreConformSurfaceFields);
+    #undef PreConformSurfaceFields
+}
+
+
+template<class Type>
+void Foam::fvMeshStitcher::postNonConformSurfaceFields()
+{
+    HashTable<SurfaceField<Type>*> fields
+    (
+        mesh_.lookupClass<SurfaceField<Type>>()
+    );
+
+    const surfaceScalarField* phiPtr =
+        mesh_.foundObject<surfaceScalarField>("meshPhi")
+      ? &mesh_.lookupObject<surfaceScalarField>("meshPhi")
+      : nullptr;
+    const surfaceScalarField* phi0Ptr =
+        mesh_.foundObject<surfaceScalarField>("meshPhi_0")
+      ? &mesh_.lookupObject<surfaceScalarField>("meshPhi_0")
+      : nullptr;
+
+    forAllIter(typename HashTable<SurfaceField<Type>*>, fields, iter)
+    {
+        if (iter.key()(nccFieldPrefix_.size()) == nccFieldPrefix_) continue;
+
+        SurfaceField<Type>& field = *iter();
+
+        if
+        (
+            &field == static_cast<const regIOobject*>(phiPtr)
+         || &field == static_cast<const regIOobject*>(phi0Ptr)
+        ) continue;
+
+        const word nccFieldName = nccFieldPrefix_ + field.name();
+
+        const SurfaceField<Type>& nccField =
+            mesh_.lookupObject<SurfaceField<Type>>(nccFieldName);
+
+        field.boundaryFieldRef() =
+            nonConformalBoundaryField<Type>
+            (
+                nccField.boundaryField(),
+                field.boundaryField()
+            );
+
+        field.boundaryFieldRef() =
+            synchronisedBoundaryField<Type>(field.boundaryField());
+    }
+
+    // Remove NCC fields after all fields have been mapped. This is so that
+    // old-time fields aren't removed by current-time fields in advance of the
+    // old-time field being mapped.
+    forAllIter(typename HashTable<SurfaceField<Type>*>, fields, iter)
+    {
+        if (iter.key()(nccFieldPrefix_.size()) == nccFieldPrefix_) continue;
+
+        SurfaceField<Type>& field = *iter();
+
+        if
+        (
+            &field == static_cast<const regIOobject*>(phiPtr)
+         || &field == static_cast<const regIOobject*>(phi0Ptr)
+        ) continue;
+
+        const word nccFieldName = nccFieldPrefix_ + field.name();
+
+        // If the NCC field isn't here, then it is assumed to be an old-time
+        // field that got removed when the current-time field was removed
+        if (!mesh_.foundObject<SurfaceField<Type>>(nccFieldName)) continue;
+
+        SurfaceField<Type>& nccField =
+            mesh_.lookupObjectRef<SurfaceField<Type>>(nccFieldName);
+
+        nccField.checkOut();
+    }
+}
+
+
+inline void Foam::fvMeshStitcher::postNonConformSurfaceFields()
+{
+    #define PostNonConformSurfaceFields(Type, nullArg) \
+        postNonConformSurfaceFields<Type>();
+    FOR_ALL_FIELD_TYPES(PostNonConformSurfaceFields);
+    #undef PostNonConformSurfaceFields
+}
+
+
+template<class Type>
+void Foam::fvMeshStitcher::evaluateVolFields()
+{
+    HashTable<VolField<Type>*> fields(mesh_.lookupClass<VolField<Type>>());
+    forAllIter(typename HashTable<VolField<Type>*>, fields, iter)
+    {
+        const label nReq = Pstream::nRequests();
+
+        forAll(mesh_.boundary(), patchi)
+        {
+            typename VolField<Type>::Patch& pf =
+                iter()->boundaryFieldRef()[patchi];
+
+            if (isA<nonConformalFvPatch>(pf.patch()))
+            {
+                pf.initEvaluate(Pstream::defaultCommsType);
+            }
+        }
+
+        if
+        (
+            Pstream::parRun()
+         && Pstream::defaultCommsType == Pstream::commsTypes::nonBlocking
+        )
+        {
+            Pstream::waitRequests(nReq);
+        }
+
+        forAll(mesh_.boundary(), patchi)
+        {
+            typename VolField<Type>::Patch& pf =
+                iter()->boundaryFieldRef()[patchi];
+
+            if (isA<nonConformalFvPatch>(pf.patch()))
+            {
+                pf.evaluate(Pstream::defaultCommsType);
+            }
+        }
+    }
+}
+
+
+inline void Foam::fvMeshStitcher::evaluateVolFields()
+{
+    #define EvaluateVolFields(Type, nullArg) \
+        evaluateVolFields<Type>();
+    FOR_ALL_FIELD_TYPES(EvaluateVolFields);
+    #undef EvaluateVolFields
+}
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+template<class Type>
+Foam::tmp<Foam::Field<Type>> Foam::fvMeshStitcher::fieldRMapSum
+(
+    const Field<Type>& f,
+    const label size,
+    const labelUList& addr
+)
+{
+    tmp<Field<Type>> tresult(new Field<Type>(size, Zero));
+    forAll(addr, i)
+    {
+        tresult.ref()[addr[i]] += f[i];
+    }
+    return tresult;
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type>> Foam::fvMeshStitcher::fieldRMapSum
+(
+    const tmp<Field<Type>>& f,
+    const label size,
+    const labelUList& addr
+)
+{
+    tmp<Field<Type>> tresult = fieldRMapSum(f(), size, addr);
+    f.clear();
+    return tresult;
+}
+
+
+inline Foam::tmp<Foam::surfaceScalarField::Boundary>
+Foam::fvMeshStitcher::getOrigNccMagSfb() const
+{
+    const fvBoundaryMesh& fvbm = mesh_.boundary();
+
+    const surfaceScalarField::Boundary& magSfb =
+        fvbm.mesh().magSf().boundaryField();
+
+    tmp<surfaceScalarField::Boundary> tOrigNccMagSfb
+    (
+        new surfaceScalarField::Boundary
+        (
+            fvbm,
+            surfaceScalarField::Internal::null(),
+            calculatedFvPatchField<scalar>::typeName
+        )
+    );
+
+    surfaceScalarField::Boundary& origNccMagSfb = tOrigNccMagSfb.ref();
+
+    origNccMagSfb == 0;
+
+    forAll(fvbm, nccPatchi)
+    {
+        const fvPatch& fvp = fvbm[nccPatchi];
+
+        if (isA<nonConformalCoupledFvPatch>(fvp))
+        {
+            const nonConformalCoupledFvPatch& nccFvp =
+                refCast<const nonConformalCoupledFvPatch>(fvp);
+
+            const label origPatchi = nccFvp.origPatchID();
+            const fvPatch& origFvp = nccFvp.origPatch();
+
+            const labelList nccOrigPatchFace =
+                nccFvp.polyFaces() - origFvp.start();
+
+            origNccMagSfb[origPatchi] +=
+                fieldRMapSum
+                (
+                    magSfb[nccPatchi],
+                    origFvp.size(),
+                    nccOrigPatchFace
+                );
+        }
+    }
+
+    return tOrigNccMagSfb;
+}
+
+
+template<class Type>
+Foam::tmp<Foam::fvMeshStitcher::SurfaceFieldBoundary<Type>>
+Foam::fvMeshStitcher::conformalNccBoundaryField
+(
+    const SurfaceFieldBoundary<Type>& fieldb
+) const
+{
+    const bool isFluxField = isFlux(fieldb[0].internalField());
+
+    const fvBoundaryMesh& fvbm = fieldb[0].patch().boundaryMesh();
+
+    const surfaceScalarField::Boundary& magSfb =
+        fvbm.mesh().magSf().boundaryField();
+
+    tmp<SurfaceFieldBoundary<Type>> tnccFieldb
+    (
+        new SurfaceFieldBoundary<Type>
+        (
+            SurfaceField<Type>::Internal::null(),
+            fieldb
+        )
+    );
+
+    SurfaceFieldBoundary<Type>& nccFieldb = tnccFieldb.ref();
+
+    nccFieldb == pTraits<Type>::zero;
+
+    const surfaceScalarField::Boundary origNccMagSfb
+    (
+        surfaceScalarField::Internal::null(),
+        getOrigNccMagSfb()
+    );
+
+    // Accumulate the non-conformal parts of the field into the original faces
+    forAll(fvbm, nccPatchi)
+    {
+        const fvPatch& fvp = fvbm[nccPatchi];
+
+        if (isA<nonConformalCoupledFvPatch>(fvp))
+        {
+            const nonConformalCoupledFvPatch& nccFvp =
+                refCast<const nonConformalCoupledFvPatch>(fvbm[nccPatchi]);
+
+            const label origPatchi = nccFvp.origPatchID();
+            const fvPatch& origFvp = nccFvp.origPatch();
+
+            const labelList nccOrigPatchFace =
+                nccFvp.polyFaces() - origFvp.start();
+
+            // If this is a flux then sum
+            if (isFluxField)
+            {
+                nccFieldb[origPatchi] +=
+                    fieldRMapSum
+                    (
+                        fieldb[nccPatchi],
+                        origFvp.size(),
+                        nccOrigPatchFace
+                    );
+            }
+
+            // If not a flux then do an area-weighted sum
+            else
+            {
+                nccFieldb[origPatchi] +=
+                    fieldRMapSum
+                    (
+                        fieldb[nccPatchi]*magSfb[nccPatchi],
+                        origFvp.size(),
+                        nccOrigPatchFace
+                    );
+            }
+        }
+    }
+
+    const labelList origPatchIDs =
+        nonConformalBoundary::New(mesh_).allOrigPatchIDs();
+
+    // Scale or average as appropriate
+    forAll(origPatchIDs, i)
+    {
+        const label origPatchi = origPatchIDs[i];
+
+        // If this is a flux then scale to the total size of the face
+        if (isFluxField)
+        {
+            const scalarField origSumMagSf
+            (
+                magSfb[origPatchi] + origNccMagSfb[origPatchi]
+            );
+
+            nccFieldb[origPatchi] *=
+                origSumMagSf
+               /max(origNccMagSfb[origPatchi], small*origSumMagSf);
+        }
+
+        // If this is not a flux then convert to an area-weighted average
+        else
+        {
+            nccFieldb[origPatchi] /=
+                max(origNccMagSfb[origPatchi], vSmall);
+        }
+    }
+
+    return tnccFieldb;
+}
+
+
+template<class Type>
+Foam::tmp<Foam::fvMeshStitcher::SurfaceFieldBoundary<Type>>
+Foam::fvMeshStitcher::conformalOrigBoundaryField
+(
+    const SurfaceFieldBoundary<Type>& fieldb
+) const
+{
+    const bool isFluxField = isFlux(fieldb[0].internalField());
+
+    const fvBoundaryMesh& fvbm = fieldb[0].patch().boundaryMesh();
+
+    const surfaceScalarField::Boundary& magSfb =
+        fvbm.mesh().magSf().boundaryField();
+
+    tmp<SurfaceFieldBoundary<Type>> torigFieldb
+    (
+        new SurfaceFieldBoundary<Type>
+        (
+            SurfaceField<Type>::Internal::null(),
+            fieldb
+        )
+    );
+
+    // If this is a flux then scale up to the total face areas
+    if (isFluxField)
+    {
+        const surfaceScalarField::Boundary origNccMagSfb
+        (
+            surfaceScalarField::Internal::null(),
+            getOrigNccMagSfb()
+        );
+
+        SurfaceFieldBoundary<Type>& origFieldb = torigFieldb.ref();
+
+        const labelList origPatchIDs =
+            nonConformalBoundary::New(mesh_).allOrigPatchIDs();
+
+        forAll(origPatchIDs, i)
+        {
+            const label origPatchi = origPatchIDs[i];
+
+            const scalarField origSumMagSf
+            (
+                magSfb[origPatchi] + origNccMagSfb[origPatchi]
+            );
+
+            origFieldb[origPatchi] *=
+                origSumMagSf
+               /max(magSfb[origPatchi], small*origSumMagSf);
+        }
+    }
+
+    return torigFieldb;
+}
+
+
+template<class Type>
+Foam::tmp<Foam::fvMeshStitcher::SurfaceFieldBoundary<Type>>
+Foam::fvMeshStitcher::nonConformalBoundaryField
+(
+    const SurfaceFieldBoundary<Type>& nccFieldb,
+    const SurfaceFieldBoundary<Type>& origFieldb
+) const
+{
+    const bool isFluxField = isFlux(origFieldb[0].internalField());
+
+    const fvBoundaryMesh& fvbm = origFieldb[0].patch().boundaryMesh();
+
+    const surfaceScalarField::Boundary& magSfb =
+        fvbm.mesh().magSf().boundaryField();
+
+    tmp<SurfaceFieldBoundary<Type>> tfieldb
+    (
+        new SurfaceFieldBoundary<Type>
+        (
+            SurfaceField<Type>::Internal::null(),
+            origFieldb
+        )
+    );
+
+    SurfaceFieldBoundary<Type>& fieldb = tfieldb.ref();
+
+    // Set the coupled values
+    forAll(fvbm, nccPatchi)
+    {
+        const fvPatch& fvp = fvbm[nccPatchi];
+
+        if (isA<nonConformalCoupledFvPatch>(fvp))
+        {
+            const nonConformalCoupledFvPatch& nccFvp =
+                refCast<const nonConformalCoupledFvPatch>(fvp);
+
+            const label origPatchi = nccFvp.origPatchID();
+            const fvPatch& origFvp = nccFvp.origPatch();
+
+            const labelList nccOrigPatchFace =
+                nccFvp.polyFaces() - origFvp.start();
+
+            // Set the cyclic values
+            fieldb[nccPatchi] =
+                Field<Type>(nccFieldb[origPatchi], nccOrigPatchFace);
+        }
+    }
+
+    // If a flux then scale down to the part face area
+    if (isFluxField)
+    {
+        const surfaceScalarField::Boundary origNccMagSfb
+        (
+            surfaceScalarField::Internal::null(),
+            getOrigNccMagSfb()
+        );
+
+        forAll(fvbm, nccPatchi)
+        {
+            const fvPatch& fvp = fvbm[nccPatchi];
+
+            if (isA<nonConformalCoupledFvPatch>(fvp))
+            {
+                const nonConformalCoupledFvPatch& nccFvp =
+                    refCast<const nonConformalCoupledFvPatch>(fvp);
+
+                const label origPatchi = nccFvp.origPatchID();
+                const fvPatch& origFvp = nccFvp.origPatch();
+
+                const labelList nccOrigPatchFace =
+                    nccFvp.polyFaces() - origFvp.start();
+
+                const scalarField origSumMagSf
+                (
+                    magSfb[origPatchi] + origNccMagSfb[origPatchi]
+                );
+                const scalarField nccSumMagSf(origSumMagSf, nccOrigPatchFace);
+
+                fieldb[nccPatchi] *= magSfb[nccPatchi]/nccSumMagSf;
+
+                if (!isA<processorFvPatch>(fvp))
+                {
+                    fieldb[origPatchi] *= magSfb[origPatchi]/origSumMagSf;
+                }
+            }
+        }
+    }
+
+    // Set error values
+    forAll(fvbm, patchi)
+    {
+        const fvPatch& fvp = fvbm[patchi];
+
+        if (isA<nonConformalErrorFvPatch>(fvp))
+        {
+            const label errorPatchi = patchi;
+
+            const nonConformalErrorFvPatch& errorFvp =
+                refCast<const nonConformalErrorFvPatch>(fvp);
+
+            const label origPatchi = errorFvp.origPatchID();
+            const fvPatch& origFvp = errorFvp.origPatch();
+
+            const labelList errorOrigPatchFace =
+                errorFvp.polyFaces() - origFvp.start();
+
+            if (isFluxField)
+            {
+                fieldb[errorPatchi] = Zero;
+            }
+            else
+            {
+                fieldb[errorPatchi] =
+                    Field<Type>(origFieldb[origPatchi], errorOrigPatchFace);
+            }
+        }
+    }
+
+    return tfieldb;
+}
+
+
+template<class Type>
+Foam::tmp<Foam::fvMeshStitcher::SurfaceFieldBoundary<Type>>
+Foam::fvMeshStitcher::synchronisedBoundaryField
+(
+    const SurfaceFieldBoundary<Type>& fieldb,
+    const bool flip,
+    const scalar ownerWeight,
+    const scalar neighbourWeight
+) const
+{
+    const fvBoundaryMesh& fvbm = fieldb[0].patch().boundaryMesh();
+
+    tmp<SurfaceFieldBoundary<Type>> tsyncFieldb
+    (
+        new SurfaceFieldBoundary<Type>
+        (
+            SurfaceField<Type>::Internal::null(),
+            fieldb
+        )
+    );
+
+    SurfaceFieldBoundary<Type>& syncFieldb = tsyncFieldb.ref();
+
+    SurfaceFieldBoundary<Type> fieldbNbr
+    (
+        SurfaceField<Type>::Internal::null(),
+        fieldb.boundaryNeighbourField()
+    );
+
+    forAll(fvbm, patchi)
+    {
+        const fvPatch& fvp = fvbm[patchi];
+
+        if (fvp.coupled())
+        {
+            const coupledFvPatch& cfvp = refCast<const coupledFvPatch>(fvp);
+
+            const scalar w = cfvp.owner() ? ownerWeight : neighbourWeight;
+            const scalar v = cfvp.owner() ? neighbourWeight : ownerWeight;
+
+            syncFieldb[patchi] =
+                w*syncFieldb[patchi] + (flip ? -v : +v)*fieldbNbr[patchi];
+        }
+    }
+
+    return tsyncFieldb;
+}
+
+
+template<class Type>
+Foam::tmp<Foam::fvMeshStitcher::SurfaceFieldBoundary<Type>>
+Foam::fvMeshStitcher::synchronisedBoundaryField
+(
+    const SurfaceFieldBoundary<Type>& fieldb
+) const
+{
+    const bool isFluxField = isFlux(fieldb[0].internalField());
+
+    return synchronisedBoundaryField<Type>
+    (
+        fieldb,
+        isFluxField,
+        0.5,
+        0.5
+    );
+}
+
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvMeshStitchers/stationary/fvMeshStitchersStationary.C b/src/finiteVolume/fvMesh/fvMeshStitchers/stationary/fvMeshStitchersStationary.C
new file mode 100644
index 0000000000..07b79c2ec6
--- /dev/null
+++ b/src/finiteVolume/fvMesh/fvMeshStitchers/stationary/fvMeshStitchersStationary.C
@@ -0,0 +1,79 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fvMeshStitchersStationary.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace fvMeshStitchers
+{
+    defineTypeNameAndDebug(stationary, 0);
+    addToRunTimeSelectionTable(fvMeshStitcher, stationary, fvMesh);
+}
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::fvMeshStitchers::stationary::initCorrectMeshPhi
+(
+    surfaceLabelField::Boundary& polyFacesBf,
+    surfaceVectorField& SfSf,
+    surfaceVectorField& CfSf
+)
+{
+    NotImplemented;
+}
+
+
+void Foam::fvMeshStitchers::stationary::correctMeshPhi
+(
+    const surfaceLabelField::Boundary& polyFacesBf,
+    surfaceVectorField& SfSf,
+    surfaceVectorField& CfSf
+)
+{
+    NotImplemented;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::fvMeshStitchers::stationary::stationary(fvMesh& mesh)
+:
+    fvMeshStitcher(mesh)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::fvMeshStitchers::stationary::~stationary()
+{}
+
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvMeshStitchers/stationary/fvMeshStitchersStationary.H b/src/finiteVolume/fvMesh/fvMeshStitchers/stationary/fvMeshStitchersStationary.H
new file mode 100644
index 0000000000..29c24b7b63
--- /dev/null
+++ b/src/finiteVolume/fvMesh/fvMeshStitchers/stationary/fvMeshStitchersStationary.H
@@ -0,0 +1,106 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::fvMeshStitchers::stationary
+
+Description
+    Mesh stitcher for stationary meshes
+
+SourceFiles
+    fvMeshStitchersStationary.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef fvMeshStitchersStationary_H
+#define fvMeshStitchersStationary_H
+
+#include "fvMeshStitcher.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace fvMeshStitchers
+{
+
+/*---------------------------------------------------------------------------*\
+                Class fvMeshStitchers::stationary Declaration
+\*---------------------------------------------------------------------------*/
+
+class stationary
+:
+    public fvMeshStitcher
+{
+    // Private Member Functions
+
+        //- Return whether or not this stitcher supports a changing mesh
+        virtual bool changing() const
+        {
+            return false;
+        }
+
+        //- Initialise correction of the mesh fluxes
+        virtual void initCorrectMeshPhi
+        (
+            SurfaceFieldBoundary<label>& polyFacesBf,
+            surfaceVectorField& SfSf,
+            surfaceVectorField& CfSf
+        );
+
+        //- Correct the mesh fluxes
+        virtual void correctMeshPhi
+        (
+            const SurfaceFieldBoundary<label>& polyFacesBf,
+            surfaceVectorField& SfSf,
+            surfaceVectorField& CfSf
+        );
+
+
+public:
+
+    //- Runtime type information
+    TypeName("stationary");
+
+
+    // Constructors
+
+        //- Construct from fvMesh
+        explicit stationary(fvMesh&);
+
+
+    //- Destructor
+    virtual ~stationary();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace fvMeshStitchers
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvPatches/basic/coupled/coupledFvPatch.C b/src/finiteVolume/fvMesh/fvPatches/basic/coupled/coupledFvPatch.C
index 6959a45d81..25c15395bf 100644
--- a/src/finiteVolume/fvMesh/fvPatches/basic/coupled/coupledFvPatch.C
+++ b/src/finiteVolume/fvMesh/fvPatches/basic/coupled/coupledFvPatch.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -39,6 +39,61 @@ Foam::coupledFvPatch::~coupledFvPatch()
 {}
 
 
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+void Foam::coupledFvPatch::makeWeights
+(
+    scalarField& w,
+    const vectorField& nbrSf,
+    const vectorField& nbrDelta
+) const
+{
+    const vectorField delta(coupledFvPatch::delta());
+
+    const scalarField nfDelta(nf() & delta);
+
+    const scalarField nbrNfDelta((nbrSf/(mag(nbrSf) + vSmall)) & nbrDelta);
+
+    forAll(delta, facei)
+    {
+        const scalar ndoi = nfDelta[facei];
+        const scalar ndni = nbrNfDelta[facei];
+        const scalar ndi = ndoi + ndni;
+
+        if (ndni/vGreat < ndi)
+        {
+            w[facei] = ndni/ndi;
+        }
+        else
+        {
+            const scalar doi = mag(delta[facei]);
+            const scalar dni = mag(nbrDelta[facei]);
+            const scalar di = doi + dni;
+
+            w[facei] = dni/di;
+        }
+    }
+}
+
+
+Foam::tmp<Foam::vectorField> Foam::coupledFvPatch::delta
+(
+    const vectorField& nbrDelta
+) const
+{
+    if (transform().transforms())
+    {
+        return
+            coupledFvPatch::delta()
+          - transform().transform(nbrDelta);
+    }
+    else
+    {
+        return coupledFvPatch::delta() - nbrDelta;
+    }
+}
+
+
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 Foam::tmp<Foam::vectorField> Foam::coupledFvPatch::delta() const
diff --git a/src/finiteVolume/fvMesh/fvPatches/basic/coupled/coupledFvPatch.H b/src/finiteVolume/fvMesh/fvPatches/basic/coupled/coupledFvPatch.H
index e2227077cb..fa2f89b886 100644
--- a/src/finiteVolume/fvMesh/fvPatches/basic/coupled/coupledFvPatch.H
+++ b/src/finiteVolume/fvMesh/fvPatches/basic/coupled/coupledFvPatch.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -63,8 +63,26 @@ protected:
 
     // Protected Member Functions
 
+protected:
+
+    // Protected Member functions
+
         //- Make patch weighting factors
-        virtual void makeWeights(scalarField&) const = 0;
+        void makeWeights
+        (
+            scalarField& w,
+            const vectorField& nbrSf,
+            const vectorField& nbrDelta
+        ) const;
+
+        //- Make patch weighting factors
+        virtual void makeWeights(scalarField& w) const = 0;
+
+        //- Return delta (P to N) vectors across coupled patch
+        tmp<vectorField> delta
+        (
+            const vectorField& nbrDelta
+        ) const;
 
 
 public:
@@ -100,6 +118,18 @@ public:
                 return coupledPolyPatch_.coupled();
             }
 
+            //- Does this side own the patch ?
+            virtual bool owner() const
+            {
+                return coupledPolyPatch_.owner();
+            }
+
+            //- Does the coupled side own the patch ?
+            virtual bool neighbour() const
+            {
+                return !owner();
+            }
+
             //- Return transformation between the coupled patches
             virtual const transformer& transform() const = 0;
 
diff --git a/src/finiteVolume/fvMesh/fvPatches/constraint/cyclic/cyclicFvPatch.C b/src/finiteVolume/fvMesh/fvPatches/constraint/cyclic/cyclicFvPatch.C
index 1d3550bbe6..9ef7df1eac 100644
--- a/src/finiteVolume/fvMesh/fvPatches/constraint/cyclic/cyclicFvPatch.C
+++ b/src/finiteVolume/fvMesh/fvPatches/constraint/cyclic/cyclicFvPatch.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -37,71 +37,24 @@ namespace Foam
 }
 
 
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
 void Foam::cyclicFvPatch::makeWeights(scalarField& w) const
 {
-    const cyclicFvPatch& nbrPatch = neighbFvPatch();
-
-    const vectorField delta(coupledFvPatch::delta());
-    const vectorField nbrDelta(nbrPatch.coupledFvPatch::delta());
-
-    const scalarField nfDelta(nf() & delta);
-    const scalarField nbrNfDelta(nbrPatch.nf() & nbrDelta);
-
-    forAll(delta, facei)
-    {
-        const scalar ndoi = nfDelta[facei];
-        const scalar ndni = nbrNfDelta[facei];
-        const scalar ndi = ndoi + ndni;
-
-        if (ndni/vGreat < ndi)
-        {
-            w[facei] = ndni/ndi;
-        }
-        else
-        {
-            const scalar doi = mag(delta[facei]);
-            const scalar dni = mag(nbrDelta[facei]);
-            const scalar di = doi + dni;
-
-            w[facei] = dni/di;
-        }
-    }
+    coupledFvPatch::makeWeights
+    (
+        w,
+        nbrPatch().Sf(),
+        nbrPatch().coupledFvPatch::delta()
+    );
 }
 
 
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
 Foam::tmp<Foam::vectorField> Foam::cyclicFvPatch::delta() const
 {
-    const vectorField patchD(coupledFvPatch::delta());
-    const vectorField nbrPatchD(neighbFvPatch().coupledFvPatch::delta());
-
-    tmp<vectorField> tpdv(new vectorField(patchD.size()));
-    vectorField& pdv = tpdv.ref();
-
-    // To the transformation if necessary
-    if (transform().transforms())
-    {
-        forAll(patchD, facei)
-        {
-            vector ddi = patchD[facei];
-            vector dni = nbrPatchD[facei];
-
-            pdv[facei] = ddi - transform().transform(dni);
-        }
-    }
-    else
-    {
-        forAll(patchD, facei)
-        {
-            vector ddi = patchD[facei];
-            vector dni = nbrPatchD[facei];
-
-            pdv[facei] = ddi - dni;
-        }
-    }
-
-    return tpdv;
+    return coupledFvPatch::delta(nbrPatch().coupledFvPatch::delta());
 }
 
 
diff --git a/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformal/nonConformalFvPatch.C b/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformal/nonConformalFvPatch.C
new file mode 100644
index 0000000000..ecab0e5fa3
--- /dev/null
+++ b/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformal/nonConformalFvPatch.C
@@ -0,0 +1,127 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalFvPatch.H"
+#include "surfaceFields.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(nonConformalFvPatch, 0);
+}
+
+
+// * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * //
+
+Foam::nonConformalFvPatch::nonConformalFvPatch
+(
+    const fvPatch& patch
+)
+:
+    patch_(patch),
+    nonConformalPolyPatch_(refCast<const nonConformalPolyPatch>(patch.patch())),
+    faceCells_()
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::nonConformalFvPatch::~nonConformalFvPatch()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+const Foam::nonConformalPolyPatch&
+Foam::nonConformalFvPatch::nonConformalPatch() const
+{
+    return nonConformalPolyPatch_;
+}
+
+
+const Foam::word& Foam::nonConformalFvPatch::origPatchName() const
+{
+    return nonConformalPolyPatch_.origPatchName();
+}
+
+
+Foam::label Foam::nonConformalFvPatch::origPatchID() const
+{
+    return nonConformalPolyPatch_.origPatchID();
+}
+
+
+const Foam::fvPatch& Foam::nonConformalFvPatch::origPatch() const
+{
+    return patch_.boundaryMesh()[origPatchID()];
+}
+
+
+const Foam::labelList& Foam::nonConformalFvPatch::polyFaces() const
+{
+    const fvMesh& mesh = patch_.boundaryMesh().mesh();
+
+    return
+        mesh.conformal()
+      ? labelList::null()
+      : mesh.polyFacesBf()[patch_.index()];
+}
+
+
+Foam::label Foam::nonConformalFvPatch::start() const
+{
+    if (size())
+    {
+        FatalErrorInFunction
+            << "The start face is not defined for a " << typeName
+            << " patch with a non-zero number of faces"
+            << exit(FatalError);
+    }
+
+    return patch_.patch().start();
+}
+
+
+Foam::label Foam::nonConformalFvPatch::size() const
+{
+    return polyFaces().size();
+}
+
+
+const Foam::labelUList& Foam::nonConformalFvPatch::faceCells() const
+{
+    // !!! This needs an update mechanism, rather than re-calculating the
+    // face-cells every time
+
+    const fvMesh& mesh = patch_.boundaryMesh().mesh();
+
+    faceCells_ = UIndirectList<label>(mesh.faceOwner(), polyFaces());
+
+    return faceCells_;
+}
+
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformal/nonConformalFvPatch.H b/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformal/nonConformalFvPatch.H
new file mode 100644
index 0000000000..e2768377b6
--- /dev/null
+++ b/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformal/nonConformalFvPatch.H
@@ -0,0 +1,126 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonConformalFvPatch
+
+Description
+    Non-conformal FV patch. Provides the necessary interface for a FV patch
+    which does not conform to the underlying poly mesh. The non-conformal
+    geometry and topology are held in the fvMesh, and are generated by the
+    fvMeshStitcher. This class just provides access to this data.
+
+See also
+    Foam::fvMesh
+    Foam::fvMeshStitcher
+
+SourceFiles
+    nonConformalFvPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalFvPatch_H
+#define nonConformalFvPatch_H
+
+#include "fvPatch.H"
+#include "nonConformalPolyPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                  Class nonConformalFvPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class nonConformalFvPatch
+{
+    // Private Data
+
+        //- Reference to the fvPatch
+        const fvPatch& patch_;
+
+        //- Reference to the polyPatch
+        const nonConformalPolyPatch& nonConformalPolyPatch_;
+
+        //- Face-cells
+        mutable labelList faceCells_;
+
+
+public:
+
+    //- Runtime type information
+    TypeName(nonConformalPolyPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from a patch
+        nonConformalFvPatch(const fvPatch& patch);
+
+
+    //- Destructor
+    virtual ~nonConformalFvPatch();
+
+
+    // Member Functions
+
+        // Access
+
+            //- Return the reference to the polyPatch
+            const nonConformalPolyPatch& nonConformalPatch() const;
+
+            //- Original patch name
+            const word& origPatchName() const;
+
+            //- Original patch ID
+            label origPatchID() const;
+
+            //- Original patch
+            const fvPatch& origPatch() const;
+
+            //- Return face face-poly-faces
+            const labelList& polyFaces() const;
+
+            //- Return the start label of this patch in the polyMesh face list.
+            //  Raises an error unless the patch is empty.
+            virtual label start() const;
+
+            //- Return the size
+            virtual label size() const;
+
+            //- Return the face-cells
+            virtual const labelUList& faceCells() const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformalCoupled/nonConformalCoupledFvPatch.C b/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformalCoupled/nonConformalCoupledFvPatch.C
new file mode 100644
index 0000000000..f26c4bd538
--- /dev/null
+++ b/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformalCoupled/nonConformalCoupledFvPatch.C
@@ -0,0 +1,154 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalCoupledFvPatch.H"
+#include "nonConformalErrorFvPatch.H"
+#include "addToRunTimeSelectionTable.H"
+#include "fvMesh.H"
+#include "transform.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(nonConformalCoupledFvPatch, 0);
+}
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+void Foam::nonConformalCoupledFvPatch::makeWeights
+(
+    scalarField& w,
+    const vectorField& nbrSf,
+    const vectorField& nbrDelta
+) const
+{
+    const vectorField delta(patch_.coupledFvPatch::delta());
+
+    const scalarField nfDelta(patch_.nf() & delta);
+
+    const scalarField nbrNfDelta((nbrSf/(mag(nbrSf) + vSmall)) & nbrDelta);
+
+    forAll(delta, facei)
+    {
+        const scalar ndoi = nfDelta[facei];
+        const scalar ndni = nbrNfDelta[facei];
+        const scalar ndi = ndoi + ndni;
+
+        // !!! Note this is a different form of stabilisation compared to
+        // coupledFvPatch. This is necessary to prevent negative weights on
+        // very small faces. Should this also be the standard form of
+        // stabilisation in coupledFvPatch and in surfaceInterpolation?
+
+        if (ndoi > vSmall && ndni > vSmall)
+        {
+            w[facei] = ndni/ndi;
+        }
+        else
+        {
+            const scalar doi = mag(delta[facei]);
+            const scalar dni = mag(nbrDelta[facei]);
+            const scalar di = doi + dni;
+
+            w[facei] = dni/di;
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * //
+
+Foam::nonConformalCoupledFvPatch::nonConformalCoupledFvPatch
+(
+    const fvPatch& patch
+)
+:
+    nonConformalFvPatch(patch),
+    patch_(refCast<const coupledFvPatch>(patch)),
+    nonConformalCoupledPolyPatch_
+    (
+        refCast<const nonConformalCoupledPolyPatch>(patch.patch())
+    )
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::nonConformalCoupledFvPatch::~nonConformalCoupledFvPatch()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+const Foam::nonConformalCoupledPolyPatch&
+Foam::nonConformalCoupledFvPatch::nonConformalCoupledPatch() const
+{
+    return nonConformalCoupledPolyPatch_;
+}
+
+
+bool Foam::nonConformalCoupledFvPatch::owner() const
+{
+    return nonConformalCoupledPolyPatch_.owner();
+}
+
+
+bool Foam::nonConformalCoupledFvPatch::neighbour() const
+{
+    return nonConformalCoupledPolyPatch_.neighbour();
+}
+
+
+const Foam::transformer& Foam::nonConformalCoupledFvPatch::transform() const
+{
+    return nonConformalCoupledPolyPatch_.transform();
+}
+
+
+const Foam::word& Foam::nonConformalCoupledFvPatch::errorPatchName() const
+{
+    return nonConformalCoupledPolyPatch_.errorPatchName();
+}
+
+
+Foam::label Foam::nonConformalCoupledFvPatch::errorPatchID() const
+{
+    return nonConformalCoupledPolyPatch_.errorPatchID();
+}
+
+
+const Foam::nonConformalErrorFvPatch&
+Foam::nonConformalCoupledFvPatch::errorPatch() const
+{
+    return
+        refCast<const nonConformalErrorFvPatch>
+        (
+            patch_.boundaryMesh()[errorPatchID()]
+        );
+}
+
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformalCoupled/nonConformalCoupledFvPatch.H b/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformalCoupled/nonConformalCoupledFvPatch.H
new file mode 100644
index 0000000000..bf2ff71377
--- /dev/null
+++ b/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformalCoupled/nonConformalCoupledFvPatch.H
@@ -0,0 +1,136 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonConformalCoupledFvPatch
+
+Description
+    Non-conformal coupled FV patch. As nonConformalFvPatch, but is also coupled
+    to another non-conformal patch.
+
+See also
+    Foam::nonConformalCoupledPolyPatch
+    Foam::nonConformalFvPatch
+
+SourceFiles
+    nonConformalCoupledFvPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalCoupledFvPatch_H
+#define nonConformalCoupledFvPatch_H
+
+#include "cyclicFvPatch.H"
+#include "nonConformalCoupledPolyPatch.H"
+#include "nonConformalFvPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class nonConformalErrorFvPatch;
+
+/*---------------------------------------------------------------------------*\
+                  Class nonConformalCoupledFvPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class nonConformalCoupledFvPatch
+:
+    public nonConformalFvPatch
+{
+    // Private Data
+
+        //- Reference to the fvPatch
+        const coupledFvPatch& patch_;
+
+        //- Reference to the polyPatch
+        const nonConformalCoupledPolyPatch& nonConformalCoupledPolyPatch_;
+
+
+protected:
+
+    // Protected Member functions
+
+        //- Make patch weighting factors
+        void makeWeights
+        (
+            scalarField& w,
+            const vectorField& nbrSf,
+            const vectorField& nbrDelta
+        ) const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName(nonConformalCoupledPolyPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from a patch
+        nonConformalCoupledFvPatch(const fvPatch& patch);
+
+
+    //- Destructor
+    virtual ~nonConformalCoupledFvPatch();
+
+
+    // Member Functions
+
+        // Access
+
+            //- Return the reference to the polyPatch
+            const nonConformalCoupledPolyPatch&
+                nonConformalCoupledPatch() const;
+
+            //- Does this side own the patch?
+            bool owner() const;
+
+            //- Does the coupled side own the patch?
+            bool neighbour() const;
+
+            //- Return transformation between the coupled patches
+            const transformer& transform() const;
+
+            //- Error patch name
+            const word& errorPatchName() const;
+
+            //- Error patch ID
+            label errorPatchID() const;
+
+            //- Error patch
+            const nonConformalErrorFvPatch& errorPatch() const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformalCyclic/nonConformalCyclicFvPatch.C b/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformalCyclic/nonConformalCyclicFvPatch.C
new file mode 100644
index 0000000000..e9854d9fca
--- /dev/null
+++ b/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformalCyclic/nonConformalCyclicFvPatch.C
@@ -0,0 +1,124 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalCyclicFvPatch.H"
+#include "nonConformalErrorFvPatch.H"
+#include "addToRunTimeSelectionTable.H"
+#include "fvMesh.H"
+#include "transform.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(nonConformalCyclicFvPatch, 0);
+    addToRunTimeSelectionTable(fvPatch, nonConformalCyclicFvPatch, polyPatch);
+}
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+void Foam::nonConformalCyclicFvPatch::makeWeights(scalarField& w) const
+{
+    nonConformalCoupledFvPatch::makeWeights
+    (
+        w,
+        nbrPatch().Sf(),
+        nbrPatch().coupledFvPatch::delta()
+    );
+}
+
+
+// * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * //
+
+Foam::nonConformalCyclicFvPatch::nonConformalCyclicFvPatch
+(
+    const polyPatch& patch,
+    const fvBoundaryMesh& bm
+)
+:
+    cyclicFvPatch(patch, bm),
+    nonConformalCoupledFvPatch(static_cast<const fvPatch&>(*this)),
+    nonConformalCyclicPolyPatch_
+    (
+        refCast<const nonConformalCyclicPolyPatch>(patch)
+    )
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::nonConformalCyclicFvPatch::~nonConformalCyclicFvPatch()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+const Foam::nonConformalCyclicPolyPatch&
+Foam::nonConformalCyclicFvPatch::nonConformalCyclicPatch() const
+{
+    return nonConformalCyclicPolyPatch_;
+}
+
+
+const Foam::nonConformalCyclicFvPatch&
+Foam::nonConformalCyclicFvPatch::nbrPatch() const
+{
+    return refCast<const nonConformalCyclicFvPatch>(cyclicFvPatch::nbrPatch());
+}
+
+
+Foam::label Foam::nonConformalCyclicFvPatch::start() const
+{
+    return nonConformalFvPatch::start();
+}
+
+
+Foam::label Foam::nonConformalCyclicFvPatch::size() const
+{
+    return nonConformalFvPatch::size();
+}
+
+
+bool Foam::nonConformalCyclicFvPatch::coupled() const
+{
+    return true;
+}
+
+
+const Foam::labelUList& Foam::nonConformalCyclicFvPatch::faceCells() const
+{
+    return nonConformalFvPatch::faceCells();
+}
+
+
+Foam::tmp<Foam::vectorField>
+Foam::nonConformalCyclicFvPatch::delta() const
+{
+    return coupledFvPatch::delta(nbrPatch().coupledFvPatch::delta());
+}
+
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformalCyclic/nonConformalCyclicFvPatch.H b/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformalCyclic/nonConformalCyclicFvPatch.H
new file mode 100644
index 0000000000..5c519714c4
--- /dev/null
+++ b/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformalCyclic/nonConformalCyclicFvPatch.H
@@ -0,0 +1,145 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonConformalCyclicFvPatch
+
+Description
+    Non-conformal cyclic FV patch. As nonConformalCoupledFvPatch, but the
+    neighbouring patch is local and known and is made available by this class.
+
+See also
+    Foam::nonConformalCyclicPolyPatch
+    Foam::nonConformalCoupledFvPatch
+
+SourceFiles
+    nonConformalCyclicFvPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalCyclicFvPatch_H
+#define nonConformalCyclicFvPatch_H
+
+#include "cyclicFvPatch.H"
+#include "nonConformalCyclicPolyPatch.H"
+#include "nonConformalCoupledFvPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class nonConformalErrorFvPatch;
+
+/*---------------------------------------------------------------------------*\
+                  Class nonConformalCyclicFvPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class nonConformalCyclicFvPatch
+:
+    public cyclicFvPatch,
+    public nonConformalCoupledFvPatch
+{
+    // Private Data
+
+        //- Reference to the polyPatch
+        const nonConformalCyclicPolyPatch& nonConformalCyclicPolyPatch_;
+
+
+protected:
+
+    // Protected Member functions
+
+        //- Make patch weighting factors
+        void makeWeights(scalarField&) const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName(nonConformalCyclicPolyPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from polyPatch and fvBoundaryMesh
+        nonConformalCyclicFvPatch
+        (
+            const polyPatch& patch,
+            const fvBoundaryMesh& bm
+        );
+
+
+    //- Destructor
+    virtual ~nonConformalCyclicFvPatch();
+
+
+    // Member Functions
+
+        // Access
+
+            //- Poly patch
+            const nonConformalCyclicPolyPatch& nonConformalCyclicPatch() const;
+
+            //- Neighbour patch
+            const nonConformalCyclicFvPatch& nbrPatch() const;
+
+            //- ...
+            using cyclicFvPatch::owner;
+
+            //- ...
+            using cyclicFvPatch::neighbour;
+
+            //- ...
+            using cyclicFvPatch::transform;
+
+            //- Is this patch coupled? Returns true. For NCC patches the poly
+            //  mesh is considered non-coupled whilst the finite volume mesh is
+            //  considered coupled.
+            virtual bool coupled() const;
+
+            //- Return the start label of this patch in the polyMesh face list.
+            //  Raises an error unless the patch is empty.
+            virtual label start() const;
+
+            //- Return the size
+            virtual label size() const;
+
+            //- Return the face-cells
+            virtual const labelUList& faceCells() const;
+
+
+        //- Return delta (P to N) vectors across coupled patch
+        virtual tmp<vectorField> delta() const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformalError/nonConformalErrorFvPatch.C b/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformalError/nonConformalErrorFvPatch.C
new file mode 100644
index 0000000000..0a62daa267
--- /dev/null
+++ b/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformalError/nonConformalErrorFvPatch.C
@@ -0,0 +1,92 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalErrorFvPatch.H"
+#include "nonConformalCyclicFvPatch.H"
+#include "addToRunTimeSelectionTable.H"
+#include "fvMesh.H"
+#include "transform.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(nonConformalErrorFvPatch, 0);
+    addToRunTimeSelectionTable(fvPatch, nonConformalErrorFvPatch, polyPatch);
+}
+
+
+// * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * //
+
+Foam::nonConformalErrorFvPatch::nonConformalErrorFvPatch
+(
+    const polyPatch& patch,
+    const fvBoundaryMesh& bm
+)
+:
+    fvPatch(patch, bm),
+    nonConformalFvPatch(static_cast<const fvPatch&>(*this))
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::nonConformalErrorFvPatch::~nonConformalErrorFvPatch()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+const Foam::labelList& Foam::nonConformalErrorFvPatch::polyFaces() const
+{
+    return nonConformalFvPatch::polyFaces();
+}
+
+
+Foam::label Foam::nonConformalErrorFvPatch::start() const
+{
+    return nonConformalFvPatch::start();
+}
+
+
+Foam::label Foam::nonConformalErrorFvPatch::size() const
+{
+    return nonConformalFvPatch::size();
+}
+
+
+const Foam::labelUList& Foam::nonConformalErrorFvPatch::faceCells() const
+{
+    return nonConformalFvPatch::faceCells();
+}
+
+
+Foam::tmp<Foam::vectorField> Foam::nonConformalErrorFvPatch::delta() const
+{
+    return Cf() - Cn();
+}
+
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformalError/nonConformalErrorFvPatch.H b/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformalError/nonConformalErrorFvPatch.H
new file mode 100644
index 0000000000..b5c27baa07
--- /dev/null
+++ b/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformalError/nonConformalErrorFvPatch.H
@@ -0,0 +1,118 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonConformalErrorFvPatch
+
+Description
+    Non-conformal error FV patch. As nonConformalFvPatch. This patch is a
+    non-coupled non-conformal patch which is used to manage the errors created
+    during the construction of a non-conformal coupled interface. Every patch
+    used as the original patch of the owner side of a non-conformal coupled
+    interface must also have an associated error patch.
+
+See also
+    Foam::nonConformalFvPatch
+
+SourceFiles
+    nonConformalErrorFvPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalErrorFvPatch_H
+#define nonConformalErrorFvPatch_H
+
+#include "fvPatch.H"
+#include "nonConformalErrorPolyPatch.H"
+#include "nonConformalFvPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                  Class nonConformalErrorFvPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class nonConformalErrorFvPatch
+:
+    public fvPatch,
+    public nonConformalFvPatch
+{
+public:
+
+    //- Runtime type information
+    TypeName(nonConformalErrorPolyPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from polyPatch and fvBoundaryMesh
+        nonConformalErrorFvPatch
+        (
+            const polyPatch& patch,
+            const fvBoundaryMesh& bm
+        );
+
+
+    //- Destructor
+    virtual ~nonConformalErrorFvPatch();
+
+
+    // Member Functions
+
+        // Access
+
+            //- Return face face-poly-faces
+            const labelList& polyFaces() const;
+
+            //- Return the start label of this patch in the polyMesh face list.
+            //  Raises an error unless the patch is empty.
+            virtual label start() const;
+
+            //- Return the size
+            virtual label size() const;
+
+            //- Return the face-cells
+            virtual const labelUList& faceCells() const;
+
+            //- Return delta vectors. It doesn't really matter what these are,
+            //  this is an error patch after all, they just have to be
+            //  stable/non-zero. The standard formulation in fvPatch is not
+            //  stable because it depends on the face normal, which for an
+            //  error face is arbitrary. So, we use the same as for coupled
+            //  patches; the vector between the cell and the face centres.
+            virtual tmp<vectorField> delta() const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvPatch.C b/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvPatch.C
new file mode 100644
index 0000000000..e11354bb2e
--- /dev/null
+++ b/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvPatch.C
@@ -0,0 +1,143 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalProcessorCyclicFvPatch.H"
+#include "addToRunTimeSelectionTable.H"
+#include "volFields.H"
+#include "surfaceFields.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(nonConformalProcessorCyclicFvPatch, 0);
+    addToRunTimeSelectionTable
+    (
+        fvPatch,
+        nonConformalProcessorCyclicFvPatch,
+        polyPatch
+    );
+}
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+void Foam::nonConformalProcessorCyclicFvPatch::makeWeights(scalarField& w) const
+{
+    if (Pstream::parRun())
+    {
+        nonConformalCoupledFvPatch::makeWeights
+        (
+            w,
+          - boundaryMesh().mesh().Sf().boundaryField()[index()],
+            boundaryMesh().mesh().Cf().boundaryField()[index()]
+          - boundaryMesh().mesh().C().boundaryField()[index()]
+        );
+    }
+    else
+    {
+        w = 1;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * //
+
+Foam::nonConformalProcessorCyclicFvPatch::nonConformalProcessorCyclicFvPatch
+(
+    const polyPatch& patch,
+    const fvBoundaryMesh& bm
+)
+:
+    processorCyclicFvPatch(patch, bm),
+    nonConformalCoupledFvPatch(static_cast<const fvPatch&>(*this)),
+    nonConformalProcessorCyclicPolyPatch_
+    (
+        refCast<const nonConformalProcessorCyclicPolyPatch>(patch)
+    )
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::nonConformalProcessorCyclicFvPatch::~nonConformalProcessorCyclicFvPatch()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+const Foam::nonConformalProcessorCyclicPolyPatch&
+Foam::nonConformalProcessorCyclicFvPatch::
+nonConformalProcessorCyclicPatch() const
+{
+    return nonConformalProcessorCyclicPolyPatch_;
+}
+
+
+Foam::label Foam::nonConformalProcessorCyclicFvPatch::start() const
+{
+    return nonConformalFvPatch::start();
+}
+
+
+Foam::label Foam::nonConformalProcessorCyclicFvPatch::size() const
+{
+    return nonConformalFvPatch::size();
+}
+
+
+bool Foam::nonConformalProcessorCyclicFvPatch::coupled() const
+{
+    return Pstream::parRun();
+}
+
+
+const Foam::labelUList&
+Foam::nonConformalProcessorCyclicFvPatch::faceCells() const
+{
+    return nonConformalFvPatch::faceCells();
+}
+
+
+Foam::tmp<Foam::vectorField>
+Foam::nonConformalProcessorCyclicFvPatch::delta() const
+{
+    if (Pstream::parRun())
+    {
+        return
+            coupledFvPatch::delta
+            (
+                boundaryMesh().mesh().Cf().boundaryField()[index()]
+              - boundaryMesh().mesh().C().boundaryField()[index()]
+            );
+    }
+    else
+    {
+        return coupledFvPatch::delta();
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvPatch.H b/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvPatch.H
new file mode 100644
index 0000000000..a59209b609
--- /dev/null
+++ b/src/finiteVolume/fvMesh/fvPatches/constraint/nonConformalProcessorCyclic/nonConformalProcessorCyclicFvPatch.H
@@ -0,0 +1,142 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonConformalProcessorCyclicFvPatch
+
+Description
+    Non-conformal processor cyclic FV patch. As nonConformalCyclicFvPatch,
+    but the neighbouring patch is on a different processor.
+
+See also
+    Foam::nonConformalProcessorCyclicPolyPatch
+    Foam::nonConformalCyclicFvPatch
+
+SourceFiles
+    nonConformalProcessorCyclicFvPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalProcessorCyclicFvPatch_H
+#define nonConformalProcessorCyclicFvPatch_H
+
+#include "processorCyclicFvPatch.H"
+#include "nonConformalProcessorCyclicPolyPatch.H"
+#include "nonConformalCoupledFvPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                Class nonConformalProcessorCyclicFvPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class nonConformalProcessorCyclicFvPatch
+:
+    public processorCyclicFvPatch,
+    public nonConformalCoupledFvPatch
+{
+    // Private Data
+
+        //- Reference to the polyPatch
+        const nonConformalProcessorCyclicPolyPatch&
+            nonConformalProcessorCyclicPolyPatch_;
+
+
+protected:
+
+    // Protected Member functions
+
+        //- Make patch weighting factors
+        virtual void makeWeights(scalarField& w) const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName(nonConformalProcessorCyclicPolyPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from components
+        nonConformalProcessorCyclicFvPatch
+        (
+            const polyPatch& patch,
+            const fvBoundaryMesh& bm
+        );
+
+
+    //- Destructor
+    virtual ~nonConformalProcessorCyclicFvPatch();
+
+
+    // Member Functions
+
+        // Access
+
+            //- Poly patch
+            const nonConformalProcessorCyclicPolyPatch&
+                nonConformalProcessorCyclicPatch() const;
+
+            //- ...
+            using processorCyclicFvPatch::owner;
+
+            //- ...
+            using processorCyclicFvPatch::neighbour;
+
+            //- ...
+            using processorCyclicFvPatch::transform;
+
+            //- Is this patch coupled? Returns true. For NCC patches the poly
+            //  mesh is considered non-coupled whilst the finite volume mesh is
+            //  considered coupled.
+            virtual bool coupled() const;
+
+            //- Return the start label of this patch in the polyMesh face list.
+            //  Raises an error unless the patch is empty.
+            virtual label start() const;
+
+            //- Return the size
+            virtual label size() const;
+
+            //- Return the face-cells
+            virtual const labelUList& faceCells() const;
+
+
+        //- Return delta (P to N) vectors across coupled patch
+        virtual tmp<vectorField> delta() const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvPatches/constraint/processor/processorFvPatch.C b/src/finiteVolume/fvMesh/fvPatches/constraint/processor/processorFvPatch.C
index 01e30851f6..a157f81012 100644
--- a/src/finiteVolume/fvMesh/fvPatches/constraint/processor/processorFvPatch.C
+++ b/src/finiteVolume/fvMesh/fvPatches/constraint/processor/processorFvPatch.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -36,82 +36,39 @@ namespace Foam
 }
 
 
-// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
 void Foam::processorFvPatch::makeWeights(scalarField& w) const
 {
     if (Pstream::parRun())
     {
-        const vectorField delta(coupledFvPatch::delta());
-
-        // The face normals point in the opposite direction on the other side
-        const vectorField nbrDelta
+        coupledFvPatch::makeWeights
         (
+            w,
+            procPolyPatch_.neighbFaceAreas(),
             procPolyPatch_.neighbFaceCentres()
           - procPolyPatch_.neighbFaceCellCentres()
         );
-
-        const scalarField nfDelta(nf() & delta);
-
-        const scalarField nbrNfDelta
-        (
-            (
-                procPolyPatch_.neighbFaceAreas()
-               /(mag(procPolyPatch_.neighbFaceAreas()) + vSmall)
-            ) & nbrDelta
-        );
-
-        forAll(delta, facei)
-        {
-            const scalar ndoi = nfDelta[facei];
-            const scalar ndni = nbrNfDelta[facei];
-            const scalar ndi = ndoi + ndni;
-
-            if (ndni/vGreat < ndi)
-            {
-                w[facei] = ndni/ndi;
-            }
-            else
-            {
-                const scalar doi = mag(delta[facei]);
-                const scalar dni = mag(nbrDelta[facei]);
-                const scalar di = doi + dni;
-
-                w[facei] = dni/di;
-            }
-        }
     }
     else
     {
-        w = 1.0;
+        w = 1;
     }
 }
 
 
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
 Foam::tmp<Foam::vectorField> Foam::processorFvPatch::delta() const
 {
     if (Pstream::parRun())
     {
-        // To the transformation if necessary
-        if (transform().transforms())
-        {
-            return
-                coupledFvPatch::delta()
-               -transform().transform
-                (
-                    procPolyPatch_.neighbFaceCentres()
-                  - procPolyPatch_.neighbFaceCellCentres()
-                );
-        }
-        else
-        {
-            return
-                coupledFvPatch::delta()
-              - (
-                    procPolyPatch_.neighbFaceCentres()
-                  - procPolyPatch_.neighbFaceCellCentres()
-                );
-        }
+        return
+            coupledFvPatch::delta
+            (
+                procPolyPatch_.neighbFaceCentres()
+              - procPolyPatch_.neighbFaceCellCentres()
+            );
     }
     else
     {
diff --git a/src/finiteVolume/fvMesh/fvPatches/constraint/processor/processorFvPatch.H b/src/finiteVolume/fvMesh/fvPatches/constraint/processor/processorFvPatch.H
index 0a2441bda6..9758cf1014 100644
--- a/src/finiteVolume/fvMesh/fvPatches/constraint/processor/processorFvPatch.H
+++ b/src/finiteVolume/fvMesh/fvPatches/constraint/processor/processorFvPatch.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -63,7 +63,7 @@ protected:
     // Protected Member functions
 
         //- Make patch weighting factors
-        void makeWeights(scalarField&) const;
+        virtual void makeWeights(scalarField& w) const;
 
 
 public:
@@ -121,11 +121,6 @@ public:
             }
         }
 
-        const processorPolyPatch& procPolyPatch() const
-        {
-            return procPolyPatch_;
-        }
-
         //- Return transformation between the coupled patches
         virtual const transformer& transform() const
         {
diff --git a/src/finiteVolume/fvMesh/fvPatches/constraint/processorCyclic/processorCyclicFvPatch.H b/src/finiteVolume/fvMesh/fvPatches/constraint/processorCyclic/processorCyclicFvPatch.H
index ea193640ce..4a2c8e079b 100644
--- a/src/finiteVolume/fvMesh/fvPatches/constraint/processorCyclic/processorCyclicFvPatch.H
+++ b/src/finiteVolume/fvMesh/fvPatches/constraint/processorCyclic/processorCyclicFvPatch.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -37,6 +37,7 @@ SourceFiles
 
 #include "processorCyclicPolyPatch.H"
 #include "processorFvPatch.H"
+#include "cyclicFvPatch.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -80,9 +81,17 @@ public:
             return procPolyPatch_.tag();
         }
 
-        const processorCyclicPolyPatch& procPolyPatch() const
+        //- Return the referring patch ID
+        label referPatchID() const
         {
-            return procPolyPatch_;
+            return procPolyPatch_.referPatchID();
+        }
+
+        //- Return a reference to the referring patch
+        const cyclicFvPatch& referPatch() const
+        {
+            const fvPatch& fvp = this->boundaryMesh()[referPatchID()];
+            return refCast<const cyclicFvPatch>(fvp);
         }
 
         //- Return transformation between the coupled patches
diff --git a/src/finiteVolume/fvMesh/fvPatches/fvPatch/fvPatch.C b/src/finiteVolume/fvMesh/fvPatches/fvPatch/fvPatch.C
index aba753520a..7bc02132e3 100644
--- a/src/finiteVolume/fvMesh/fvPatches/fvPatch/fvPatch.C
+++ b/src/finiteVolume/fvMesh/fvPatches/fvPatch/fvPatch.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/finiteVolume/fvMesh/fvPatches/fvPatch/fvPatch.H b/src/finiteVolume/fvMesh/fvPatches/fvPatch/fvPatch.H
index eb40910d15..260fefdaff 100644
--- a/src/finiteVolume/fvMesh/fvPatches/fvPatch/fvPatch.H
+++ b/src/finiteVolume/fvMesh/fvPatches/fvPatch/fvPatch.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -41,6 +41,7 @@ SourceFiles
 #include "SubList.H"
 #include "typeInfo.H"
 #include "tmp.H"
+#include "tmpNrc.H"
 #include "primitiveFields.H"
 #include "SubField.H"
 #include "fvPatchFieldsFwd.H"
@@ -133,7 +134,7 @@ public:
 
     // Member Functions
 
-    // Access
+        // Access
 
             //- Return the polyPatch
             const polyPatch& patch() const
diff --git a/src/finiteVolume/fvMesh/wallDist/fvPatchDistWave/fvPatchDistWave.C b/src/finiteVolume/fvMesh/wallDist/fvPatchDistWave/fvPatchDistWave.C
index 5bb37e65cc..48516da7b4 100644
--- a/src/finiteVolume/fvMesh/wallDist/fvPatchDistWave/fvPatchDistWave.C
+++ b/src/finiteVolume/fvMesh/wallDist/fvPatchDistWave/fvPatchDistWave.C
@@ -24,13 +24,15 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "fvPatchDistWave.H"
+#include "nonConformalFvPatch.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 Foam::List<Foam::labelPair> Foam::fvPatchDistWave::getChangedPatchAndFaces
 (
     const fvMesh& mesh,
-    const labelHashSet& patchIDs
+    const labelHashSet& patchIDs,
+    const scalar minFaceFraction
 )
 {
     label nChangedFaces = 0;
@@ -40,20 +42,35 @@ Foam::List<Foam::labelPair> Foam::fvPatchDistWave::getChangedPatchAndFaces
     }
 
     List<labelPair> changedPatchAndFaces(nChangedFaces);
-    label changedFacei = 0;
 
+    label changedFacei = 0;
     forAllConstIter(labelHashSet, patchIDs, iter)
     {
         const label patchi = iter.key();
         const fvPatch& patch = mesh.boundary()[patchi];
 
+        if (isA<nonConformalFvPatch>(patch))
+        {
+            FatalErrorInFunction
+                << "Cannot initialise a patch distance wave from a "
+                << "non-conformal patch" << exit(FatalError);
+        }
+
         forAll(patch, patchFacei)
         {
+            const scalar faceFraction =
+                patch.magSf()[patchFacei]
+               /patch.patch().magFaceAreas()[patchFacei];
+
+            if (faceFraction < minFaceFraction) continue;
+
             changedPatchAndFaces[changedFacei] = labelPair(patchi, patchFacei);
             changedFacei++;
         }
     }
 
+    changedPatchAndFaces.resize(changedFacei);
+
     return changedPatchAndFaces;
 }
 
diff --git a/src/finiteVolume/fvMesh/wallDist/fvPatchDistWave/fvPatchDistWave.H b/src/finiteVolume/fvMesh/wallDist/fvPatchDistWave/fvPatchDistWave.H
index 4554f348a8..96d4010bb8 100644
--- a/src/finiteVolume/fvMesh/wallDist/fvPatchDistWave/fvPatchDistWave.H
+++ b/src/finiteVolume/fvMesh/wallDist/fvPatchDistWave/fvPatchDistWave.H
@@ -54,7 +54,8 @@ namespace fvPatchDistWave
 List<labelPair> getChangedPatchAndFaces
 (
     const fvMesh& mesh,
-    const labelHashSet& patchIDs
+    const labelHashSet& patchIDs,
+    const scalar minFaceFraction
 );
 
 //- Wave distance (and maybe additional) data from faces. If nCorrections is
@@ -87,6 +88,7 @@ label calculate
 (
     const fvMesh& mesh,
     const labelHashSet& patchIDs,
+    const scalar minFaceFraction,
     GeometricField<scalar, PatchField, GeoMesh>& distance
 );
 
@@ -96,6 +98,7 @@ void correct
 (
     const fvMesh& mesh,
     const labelHashSet& patchIDs,
+    const scalar minFaceFraction,
     const label nCorrections,
     GeometricField<scalar, PatchField, GeoMesh>& distance
 );
@@ -106,6 +109,7 @@ label calculateAndCorrect
 (
     const fvMesh& mesh,
     const labelHashSet& patchIDs,
+    const scalar minFaceFraction,
     const label nCorrections,
     GeometricField<scalar, PatchField, GeoMesh>& distance
 );
@@ -122,6 +126,7 @@ label calculate
 (
     const fvMesh& mesh,
     const labelHashSet& patchIDs,
+    const scalar minFaceFraction,
     GeometricField<scalar, PatchField, GeoMesh>& distance,
     GeometricField
         <typename WallInfoData<wallPoint>::dataType, PatchField, GeoMesh>&
@@ -142,6 +147,7 @@ void correct
 (
     const fvMesh& mesh,
     const labelHashSet& patchIDs,
+    const scalar minFaceFraction,
     const label nCorrections,
     GeometricField<scalar, PatchField, GeoMesh>& distance,
     GeometricField
@@ -163,6 +169,7 @@ label calculateAndCorrect
 (
     const fvMesh& mesh,
     const labelHashSet& patchIDs,
+    const scalar minFaceFraction,
     const label nCorrections,
     GeometricField<scalar, PatchField, GeoMesh>& distance,
     GeometricField
diff --git a/src/finiteVolume/fvMesh/wallDist/fvPatchDistWave/fvPatchDistWaveTemplates.C b/src/finiteVolume/fvMesh/wallDist/fvPatchDistWave/fvPatchDistWaveTemplates.C
index 13d1e68d95..2c801507f4 100644
--- a/src/finiteVolume/fvMesh/wallDist/fvPatchDistWave/fvPatchDistWaveTemplates.C
+++ b/src/finiteVolume/fvMesh/wallDist/fvPatchDistWave/fvPatchDistWaveTemplates.C
@@ -201,6 +201,7 @@ Foam::label Foam::fvPatchDistWave::calculate
 (
     const fvMesh& mesh,
     const labelHashSet& patchIDs,
+    const scalar minFaceFraction,
     GeometricField<scalar, PatchField, GeoMesh>& distance
 )
 {
@@ -208,7 +209,7 @@ Foam::label Foam::fvPatchDistWave::calculate
         wave<FvWallInfo<wallPoint>>
         (
             mesh,
-            getChangedPatchAndFaces(mesh, patchIDs),
+            getChangedPatchAndFaces(mesh, patchIDs, minFaceFraction),
             -1,
             distance,
             FvFaceCellWave<FvWallInfo<wallPoint>>::defaultTrackingData_
@@ -221,6 +222,7 @@ void Foam::fvPatchDistWave::correct
 (
     const fvMesh& mesh,
     const labelHashSet& patchIDs,
+    const scalar minFaceFraction,
     const label nCorrections,
     GeometricField<scalar, PatchField, GeoMesh>& distance
 )
@@ -228,7 +230,7 @@ void Foam::fvPatchDistWave::correct
     wave<FvWallInfo<wallFace>>
     (
         mesh,
-        getChangedPatchAndFaces(mesh, patchIDs),
+        getChangedPatchAndFaces(mesh, patchIDs, minFaceFraction),
         nCorrections,
         distance,
         FvFaceCellWave<FvWallInfo<wallFace>>::defaultTrackingData_
@@ -241,12 +243,13 @@ Foam::label Foam::fvPatchDistWave::calculateAndCorrect
 (
     const fvMesh& mesh,
     const labelHashSet& patchIDs,
+    const scalar minFaceFraction,
     const label nCorrections,
     GeometricField<scalar, PatchField, GeoMesh>& distance
 )
 {
     const List<labelPair> changedPatchAndFaces =
-        getChangedPatchAndFaces(mesh, patchIDs);
+        getChangedPatchAndFaces(mesh, patchIDs, minFaceFraction);
 
     const label nUnset =
         wave<FvWallInfo<wallPoint>>
@@ -282,6 +285,7 @@ Foam::label Foam::fvPatchDistWave::calculate
 (
     const fvMesh& mesh,
     const labelHashSet& patchIDs,
+    const scalar minFaceFraction,
     GeometricField<scalar, PatchField, GeoMesh>& distance,
     GeometricField
         <typename WallInfoData<wallPoint>::dataType, PatchField, GeoMesh>&
@@ -293,7 +297,7 @@ Foam::label Foam::fvPatchDistWave::calculate
         wave<WallInfoData<wallPoint>, TrackingData>
         (
             mesh,
-            getChangedPatchAndFaces(mesh, patchIDs),
+            getChangedPatchAndFaces(mesh, patchIDs, minFaceFraction),
             -1,
             distance,
             td,
@@ -313,6 +317,7 @@ void Foam::fvPatchDistWave::correct
 (
     const fvMesh& mesh,
     const labelHashSet& patchIDs,
+    const scalar minFaceFraction,
     const label nCorrections,
     GeometricField<scalar, PatchField, GeoMesh>& distance,
     GeometricField
@@ -324,7 +329,7 @@ void Foam::fvPatchDistWave::correct
     wave<WallInfoData<wallFace>, TrackingData>
     (
         mesh,
-        getChangedPatchAndFaces(mesh, patchIDs),
+        getChangedPatchAndFaces(mesh, patchIDs, minFaceFraction),
         nCorrections,
         distance,
         td,
@@ -344,6 +349,7 @@ Foam::label Foam::fvPatchDistWave::calculateAndCorrect
 (
     const fvMesh& mesh,
     const labelHashSet& patchIDs,
+    const scalar minFaceFraction,
     const label nCorrections,
     GeometricField<scalar, PatchField, GeoMesh>& distance,
     GeometricField
@@ -353,7 +359,7 @@ Foam::label Foam::fvPatchDistWave::calculateAndCorrect
 )
 {
     const List<labelPair> changedPatchAndFaces =
-        getChangedPatchAndFaces(mesh, patchIDs);
+        getChangedPatchAndFaces(mesh, patchIDs, minFaceFraction);
 
     const label nUnset =
         wave<WallInfoData<wallPoint>, TrackingData>
diff --git a/src/finiteVolume/fvMesh/wallDist/nearWallDist/nearWallDist.C b/src/finiteVolume/fvMesh/wallDist/nearWallDist/nearWallDist.C
index 7dde316129..6177a4b3fe 100644
--- a/src/finiteVolume/fvMesh/wallDist/nearWallDist/nearWallDist.C
+++ b/src/finiteVolume/fvMesh/wallDist/nearWallDist/nearWallDist.C
@@ -65,6 +65,7 @@ void Foam::nearWallDist::correct()
     (
         mesh(),
         mesh().boundaryMesh().findPatchIDs<wallPolyPatch>(),
+        -vGreat,
         2,
         yVf
     );
@@ -106,6 +107,8 @@ Foam::nearWallDist::~nearWallDist()
 
 bool Foam::nearWallDist::movePoints()
 {
+    resize();
+
     correct();
     return true;
 }
diff --git a/src/finiteVolume/fvMesh/wallDist/patchDistMethods/meshWave/meshWavePatchDistMethod.C b/src/finiteVolume/fvMesh/wallDist/patchDistMethods/meshWave/meshWavePatchDistMethod.C
index 2437170b37..ea0d6f750b 100644
--- a/src/finiteVolume/fvMesh/wallDist/patchDistMethods/meshWave/meshWavePatchDistMethod.C
+++ b/src/finiteVolume/fvMesh/wallDist/patchDistMethods/meshWave/meshWavePatchDistMethod.C
@@ -52,7 +52,8 @@ Foam::patchDistMethods::meshWave::meshWave
 )
 :
     patchDistMethod(mesh, patchIDs),
-    nCorrectors_(dict.lookupOrDefault<label>("nCorrectors", 2))
+    nCorrectors_(dict.lookupOrDefault<label>("nCorrectors", 2)),
+    minFaceFraction_(dict.lookupOrDefault<scalar>("minFaceFraction", 1e-1))
 {}
 
 
@@ -60,11 +61,13 @@ Foam::patchDistMethods::meshWave::meshWave
 (
     const fvMesh& mesh,
     const labelHashSet& patchIDs,
-    const label nCorrectors
+    const label nCorrectors,
+    const scalar minFaceFraction
 )
 :
     patchDistMethod(mesh, patchIDs),
-    nCorrectors_(nCorrectors)
+    nCorrectors_(nCorrectors),
+    minFaceFraction_(minFaceFraction)
 {}
 
 
@@ -79,6 +82,7 @@ bool Foam::patchDistMethods::meshWave::correct(volScalarField& y)
         (
             mesh_,
             patchIDs_,
+            minFaceFraction_,
             nCorrectors_,
             y
         );
@@ -103,6 +107,7 @@ bool Foam::patchDistMethods::meshWave::correct
         (
             mesh_,
             patchIDs_,
+            minFaceFraction_,
             nCorrectors_,
             y,
             n
diff --git a/src/finiteVolume/fvMesh/wallDist/patchDistMethods/meshWave/meshWavePatchDistMethod.H b/src/finiteVolume/fvMesh/wallDist/patchDistMethods/meshWave/meshWavePatchDistMethod.H
index c26aae1701..8e739e8091 100644
--- a/src/finiteVolume/fvMesh/wallDist/patchDistMethods/meshWave/meshWavePatchDistMethod.H
+++ b/src/finiteVolume/fvMesh/wallDist/patchDistMethods/meshWave/meshWavePatchDistMethod.H
@@ -83,6 +83,10 @@ class meshWave
         //- Do accurate distance calculation for near-wall cells.
         const label nCorrectors_;
 
+        //- Minimum fraction of a poly face considered to be a valid location
+        //  from which to measure distance
+        const scalar minFaceFraction_;
+
 
 public:
 
@@ -107,7 +111,8 @@ public:
         (
             const fvMesh& mesh,
             const labelHashSet& patchIDs,
-            const label nCorrectors = 2
+            const label nCorrectors = 2,
+            const scalar minFaceFraction = 1e-1
         );
 
         //- Disallow default bitwise copy construction
diff --git a/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolation.C b/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolation.C
index b2cfd1268a..09334df0b1 100644
--- a/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolation.C
+++ b/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolation.C
@@ -30,6 +30,8 @@ License
 #include "demandDrivenData.H"
 #include "pointConstraints.H"
 #include "surfaceFields.H"
+#include "syncTools.H"
+#include "cpuTime.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -41,205 +43,6 @@ namespace Foam
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-void Foam::volPointInterpolation::calcBoundaryAddressing()
-{
-    if (debug)
-    {
-        Pout<< "volPointInterpolation::calcBoundaryAddressing() : "
-            << "constructing boundary addressing"
-            << endl;
-    }
-
-    boundaryPtr_.reset
-    (
-        new primitivePatch
-        (
-            SubList<face>
-            (
-                mesh().faces(),
-                mesh().nFaces()-mesh().nInternalFaces(),
-                mesh().nInternalFaces()
-            ),
-            mesh().points()
-        )
-    );
-    const primitivePatch& boundary = boundaryPtr_();
-
-    boundaryIsPatchFace_.setSize(boundary.size());
-    boundaryIsPatchFace_ = false;
-
-    isPatchPoint_.setSize(mesh().nPoints());
-    isPatchPoint_ = false;
-
-    const polyBoundaryMesh& pbm = mesh().boundaryMesh();
-
-    // Get precalculated volField only so we can use coupled() tests for
-    // cyclicAMI
-    const surfaceScalarField& magSf = mesh().magSf();
-
-    forAll(pbm, patchi)
-    {
-        const polyPatch& pp = pbm[patchi];
-
-        if
-        (
-            !isA<emptyPolyPatch>(pp)
-         && !magSf.boundaryField()[patchi].coupled()
-        )
-        {
-            label bFacei = pp.start()-mesh().nInternalFaces();
-
-            forAll(pp, i)
-            {
-                boundaryIsPatchFace_[bFacei] = true;
-
-                const face& f = boundary[bFacei++];
-
-                forAll(f, fp)
-                {
-                    isPatchPoint_[f[fp]] = true;
-                }
-            }
-        }
-    }
-
-    // Make sure point status is synchronised so even processor that holds
-    // no face of a certain patch still can have boundary points marked.
-    if (debug)
-    {
-        boolList oldData(isPatchPoint_);
-
-        pointConstraints::syncUntransformedData
-        (
-            mesh(),
-            isPatchPoint_,
-            orEqOp<bool>()
-        );
-
-        forAll(isPatchPoint_, pointi)
-        {
-            if (isPatchPoint_[pointi] != oldData[pointi])
-            {
-                Pout<< "volPointInterpolation::calcBoundaryAddressing():"
-                    << " added dangling mesh point:" << pointi
-                    << " at:" << mesh().points()[pointi]
-                    << endl;
-            }
-        }
-
-        label nPatchFace = 0;
-        forAll(boundaryIsPatchFace_, i)
-        {
-            if (boundaryIsPatchFace_[i])
-            {
-                nPatchFace++;
-            }
-        }
-        label nPatchPoint = 0;
-        forAll(isPatchPoint_, i)
-        {
-            if (isPatchPoint_[i])
-            {
-                nPatchPoint++;
-            }
-        }
-        Pout<< "boundary:" << nl
-            << "    faces :" << boundary.size() << nl
-            << "    of which on proper patch:" << nPatchFace << nl
-            << "    points:" << boundary.nPoints() << nl
-            << "    of which on proper patch:" << nPatchPoint << endl;
-    }
-}
-
-
-void Foam::volPointInterpolation::makeInternalWeights(scalarField& sumWeights)
-{
-    if (debug)
-    {
-        Pout<< "volPointInterpolation::makeInternalWeights() : "
-            << "constructing weighting factors for internal and non-coupled"
-            << " points." << endl;
-    }
-
-    const pointField& points = mesh().points();
-    const labelListList& pointCells = mesh().pointCells();
-    const vectorField& cellCentres = mesh().cellCentres();
-
-    // Allocate storage for weighting factors
-    pointWeights_.clear();
-    pointWeights_.setSize(points.size());
-
-    // Calculate inverse distances between cell centres and points
-    // and store in weighting factor array
-    forAll(points, pointi)
-    {
-        if (!isPatchPoint_[pointi])
-        {
-            const labelList& pcp = pointCells[pointi];
-
-            scalarList& pw = pointWeights_[pointi];
-            pw.setSize(pcp.size());
-
-            forAll(pcp, pointCelli)
-            {
-                pw[pointCelli] =
-                    1.0/mag(points[pointi] - cellCentres[pcp[pointCelli]]);
-
-                sumWeights[pointi] += pw[pointCelli];
-            }
-        }
-    }
-}
-
-
-void Foam::volPointInterpolation::makeBoundaryWeights(scalarField& sumWeights)
-{
-    if (debug)
-    {
-        Pout<< "volPointInterpolation::makeBoundaryWeights() : "
-            << "constructing weighting factors for boundary points." << endl;
-    }
-
-    const pointField& points = mesh().points();
-    const pointField& faceCentres = mesh().faceCentres();
-
-    const primitivePatch& boundary = boundaryPtr_();
-
-    boundaryPointWeights_.clear();
-    boundaryPointWeights_.setSize(boundary.meshPoints().size());
-
-    forAll(boundary.meshPoints(), i)
-    {
-        label pointi = boundary.meshPoints()[i];
-
-        if (isPatchPoint_[pointi])
-        {
-            const labelList& pFaces = boundary.pointFaces()[i];
-
-            scalarList& pw = boundaryPointWeights_[i];
-            pw.setSize(pFaces.size());
-
-            sumWeights[pointi] = 0.0;
-
-            forAll(pFaces, i)
-            {
-                if (boundaryIsPatchFace_[pFaces[i]])
-                {
-                    label facei = mesh().nInternalFaces() + pFaces[i];
-
-                    pw[i] = 1.0/mag(points[pointi] - faceCentres[facei]);
-                    sumWeights[pointi] += pw[i];
-                }
-                else
-                {
-                    pw[i] = 0.0;
-                }
-            }
-        }
-    }
-}
-
-
 void Foam::volPointInterpolation::makeWeights()
 {
     if (debug)
@@ -249,11 +52,205 @@ void Foam::volPointInterpolation::makeWeights()
             << endl;
     }
 
+    const pointField& points = mesh().points();
+    const labelListList& pointCells = mesh().pointCells();
+    const polyBoundaryMesh& pbm = mesh().boundaryMesh();
+    const fvBoundaryMesh& fvbm = mesh().boundary();
+
     // Update addressing over all boundary faces
-    calcBoundaryAddressing();
+    boundaryPtr_.reset
+    (
+        new primitivePatch
+        (
+            SubList<face>
+            (
+                mesh().faces(),
+                mesh().nFaces() - mesh().nInternalFaces(),
+                mesh().nInternalFaces()
+            ),
+            mesh().points()
+        )
+    );
+    const primitivePatch& boundary = boundaryPtr_();
 
+    // Allocate storage for weighting factors
+    pointWeights_.clear();
+    pointWeights_.setSize(points.size());
+    boundaryPointWeights_.clear();
+    boundaryPointWeights_.setSize(boundary.meshPoints().size());
+    boundaryPointNbrWeights_.clear();
+    boundaryPointNbrWeights_.setSize(boundary.meshPoints().size());
 
-    // Running sum of weights
+    // Cache calls to patch coupled flags
+    boolList isCoupledPolyPatch(pbm.size(), false);
+    boolList isCoupledFvPatch(fvbm.size(), false);
+    forAll(isCoupledFvPatch, patchi)
+    {
+        isCoupledPolyPatch[patchi] = pbm[patchi].coupled();
+        isCoupledFvPatch[patchi] = fvbm[patchi].coupled();
+    }
+
+    // Determine the factor to which a point has its values set by adjacent
+    // boundary faces, rather than connected cells
+    scalarList pointBoundaryFactor(mesh().nPoints(), Zero);
+    forAll(boundary.meshPoints(), bPointi)
+    {
+        const label pointi = boundary.meshPoints()[bPointi];
+
+        const labelList& pFaces = boundary.pointFaces()[bPointi];
+
+        forAll(pFaces, pPointFacei)
+        {
+            // Poly indices
+            const label patchi = pbm.patchID()[pFaces[pPointFacei]];
+            const label patchFacei = pbm.patchFaceID()[pFaces[pPointFacei]];
+
+            // FV indices
+            const labelUList patches =
+                mesh().polyBFacePatches()[pFaces[pPointFacei]];
+            const labelUList patchFaces =
+                mesh().polyBFacePatchFaces()[pFaces[pPointFacei]];
+
+            scalar nonCoupledMagSf = 0;
+            forAll(patches, i)
+            {
+                if
+                (
+                    !isCoupledPolyPatch[patches[i]]
+                 && !isCoupledFvPatch[patches[i]]
+                )
+                {
+                    nonCoupledMagSf += fvbm[patches[i]].magSf()[patchFaces[i]];
+                }
+            }
+
+            pointBoundaryFactor[pointi] =
+                max
+                (
+                    pointBoundaryFactor[pointi],
+                    nonCoupledMagSf/pbm[patchi].magFaceAreas()[patchFacei]
+                );
+        }
+    }
+    syncTools::syncPointList
+    (
+        mesh(),
+        pointBoundaryFactor,
+        maxEqOp<scalar>(),
+        scalar(0)
+    );
+
+    // Calculate inverse distances between cell centres and points
+    // and store in the weighting factor array
+    forAll(points, pointi)
+    {
+        if (pointBoundaryFactor[pointi] > 1 - rootSmall) continue;
+
+        pointWeights_[pointi].setSize(pointCells[pointi].size());
+
+        const scalar f = pointBoundaryFactor[pointi];
+
+        forAll(pointCells[pointi], pointCelli)
+        {
+            const label celli = pointCells[pointi][pointCelli];
+
+            pointWeights_[pointi][pointCelli] =
+                (1 - f)/mag(points[pointi] - mesh().C()[celli]);
+        }
+    }
+
+    // Get the cell centres on the other side of coupled boundaries
+    typename volVectorField::Boundary CBnf
+    (
+        mesh().boundary(),
+        volVectorField::Internal::null(),
+        calculatedFvPatchField<vector>::typeName
+    );
+    forAll(fvbm, patchi)
+    {
+        if
+        (
+            !isCoupledPolyPatch[patchi]
+         && isCoupledFvPatch[patchi]
+        )
+        {
+            CBnf[patchi] = fvbm[patchi].Cn() + fvbm[patchi].delta();
+        }
+    }
+
+    // Calculate inverse distanced between boundary face centres and points and
+    // store in the boundary weighting factor arrays
+    forAll(boundary.meshPoints(), bPointi)
+    {
+        const label pointi = boundary.meshPoints()[bPointi];
+
+        const labelList& pFaces = boundary.pointFaces()[bPointi];
+
+        boundaryPointWeights_[bPointi].resize(pFaces.size());
+        boundaryPointNbrWeights_[bPointi].resize(pFaces.size());
+
+        forAll(pFaces, bPointFacei)
+        {
+            // Poly indices
+            const label patchi = pbm.patchID()[pFaces[bPointFacei]];
+            const label patchFacei = pbm.patchFaceID()[pFaces[bPointFacei]];
+
+            // FV indices
+            const labelUList patches =
+                mesh().polyBFacePatches()[pFaces[bPointFacei]];
+            const labelUList patchFaces =
+                mesh().polyBFacePatchFaces()[pFaces[bPointFacei]];
+
+            boundaryPointWeights_[bPointi][bPointFacei].resize
+            (
+                patches.size(),
+                0
+            );
+            boundaryPointNbrWeights_[bPointi][bPointFacei].resize
+            (
+                patches.size(),
+                0
+            );
+
+            forAll(patches, i)
+            {
+                const scalar a =
+                    fvbm[patches[i]].magSf()[patchFaces[i]]
+                   /pbm[patchi].magFaceAreas()[patchFacei];
+
+                const scalar f = pointBoundaryFactor[pointi];
+
+                // If FV coupled only, add a weight to the neighbouring cell.
+                // This is necessary because point synchronisation will not sum
+                // the contributions across this interface as would be the case
+                // with a poly coupled interface.
+                if
+                (
+                    !isCoupledPolyPatch[patches[i]]
+                 && isCoupledFvPatch[patches[i]]
+                )
+                {
+                    const point C = CBnf[patches[i]][patchFaces[i]];
+                    boundaryPointNbrWeights_[bPointi][bPointFacei][i] =
+                        (1 - f)*a/mag(points[pointi] - C);
+                }
+
+                // If not coupled, add a weight to the boundary value
+                if
+                (
+                    !isCoupledPolyPatch[patches[i]]
+                 && !isCoupledFvPatch[patches[i]]
+                )
+                {
+                    const point Cf = fvbm[patches[i]].Cf()[patchFaces[i]];
+                    boundaryPointWeights_[bPointi][bPointFacei][i] =
+                        f*a/mag(points[pointi] - Cf);
+                }
+            }
+        }
+    }
+
+    // Construct a sum of weights
     pointScalarField sumWeights
     (
         IOobject
@@ -266,81 +263,60 @@ void Foam::volPointInterpolation::makeWeights()
         dimensionedScalar(dimless, 0)
     );
 
+    // Add the internal weights
+    forAll(pointWeights_, pointi)
+    {
+        forAll(pointWeights_[pointi], i)
+        {
+            sumWeights[pointi] += pointWeights_[pointi][i];
+        }
+    }
 
-    // Create internal weights; add to sumWeights
-    makeInternalWeights(sumWeights);
+    // Add the boundary weights
+    forAll(boundary.meshPoints(), bPointi)
+    {
+        const label pointi = boundary.meshPoints()[bPointi];
+        forAll(boundaryPointWeights_[bPointi], i)
+        {
+            forAll(boundaryPointWeights_[bPointi][i], j)
+            {
+                sumWeights[pointi] += boundaryPointWeights_[bPointi][i][j];
+                sumWeights[pointi] += boundaryPointNbrWeights_[bPointi][i][j];
+            }
+        }
+    }
 
-
-    // Create boundary weights; override sumWeights
-    makeBoundaryWeights(sumWeights);
-
-
-    // forAll(boundary.meshPoints(), i)
-    //{
-    //    label pointi = boundary.meshPoints()[i];
-    //
-    //    if (isPatchPoint_[pointi])
-    //    {
-    //        Pout<< "Calculated Weight at boundary point:" << i
-    //            << " at:" << mesh().points()[pointi]
-    //            << " sumWeight:" << sumWeights[pointi]
-    //            << " from:" << boundaryPointWeights_[i]
-    //            << endl;
-    //    }
-    //}
-
-
-    // Sum collocated contributions
-    pointConstraints::syncUntransformedData
+    // Synchronise over conformal couplings
+    syncTools::syncPointList
     (
         mesh(),
         sumWeights,
-        plusEqOp<scalar>()
+        plusEqOp<scalar>(),
+        scalar(0)
     );
 
-    // And add separated contributions
-    addSeparated(sumWeights);
-
-    // Push master data to slaves. It is possible (not sure how often) for
-    // a coupled point to have its master on a different patch so
-    // to make sure just push master data to slaves. Reuse the syncPointData
-    // structure.
-    pushUntransformedData(sumWeights);
-
-
     // Normalise internal weights
     forAll(pointWeights_, pointi)
     {
-        scalarList& pw = pointWeights_[pointi];
-        // Note:pw only sized for !isPatchPoint
-        forAll(pw, i)
+        forAll(pointWeights_[pointi], i)
         {
-            pw[i] /= sumWeights[pointi];
+            pointWeights_[pointi][i] /= sumWeights[pointi];
         }
     }
 
     // Normalise boundary weights
-    const primitivePatch& boundary = boundaryPtr_();
-
-    forAll(boundary.meshPoints(), i)
+    forAll(boundary.meshPoints(), bPointi)
     {
-        label pointi = boundary.meshPoints()[i];
-
-        scalarList& pw = boundaryPointWeights_[i];
-        // Note:pw only sized for isPatchPoint
-        forAll(pw, i)
+        const label pointi = boundary.meshPoints()[bPointi];
+        forAll(boundaryPointWeights_[bPointi], i)
         {
-            pw[i] /= sumWeights[pointi];
+            forAll(boundaryPointWeights_[bPointi][i], j)
+            {
+                boundaryPointWeights_[bPointi][i][j] /= sumWeights[pointi];
+                boundaryPointNbrWeights_[bPointi][i][j] /= sumWeights[pointi];
+            }
         }
     }
-
-
-    if (debug)
-    {
-        Pout<< "volPointInterpolation::makeWeights() : "
-            << "finished constructing weighting factors"
-            << endl;
-    }
 }
 
 
@@ -394,15 +370,10 @@ void Foam::volPointInterpolation::interpolateDisplacement
     pointVectorField& pf
 ) const
 {
-    interpolateInternalField(vf, pf);
-
-    // Interpolate to the patches but no constraints
-    interpolateBoundaryField(vf, pf);
+    interpolateUnconstrained(vf, pf);
 
     // Apply displacement constraints
-    const pointConstraints& pcs = pointConstraints::New(pf.mesh());
-
-    pcs.constrainDisplacement(pf, false);
+    pointConstraints::New(pf.mesh()).constrainDisplacement(pf);
 }
 
 
diff --git a/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolation.H b/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolation.H
index 1191329e03..6191f3ebd2 100644
--- a/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolation.H
+++ b/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolation.H
@@ -30,7 +30,7 @@ Description
 
 SourceFiles
     volPointInterpolation.C
-    volPointInterpolate.C
+    volPointInterpolationTemplates.C
 
 \*---------------------------------------------------------------------------*/
 
@@ -60,56 +60,21 @@ class volPointInterpolation
         //- Interpolation scheme weighting factor array.
         scalarListList pointWeights_;
 
+        //- Boundary addressing
+        autoPtr<primitivePatch> boundaryPtr_;
 
-        // Boundary handling
+        //- Per boundary point the weights per pointFaces.
+        List<scalarListList> boundaryPointWeights_;
 
-            //- Boundary addressing
-            autoPtr<primitivePatch> boundaryPtr_;
-
-            //- Per boundary face whether is on non-coupled patch
-            boolList boundaryIsPatchFace_;
-
-            //- Per mesh(!) point whether is on non-coupled patch (on any
-            //  processor)
-            boolList isPatchPoint_;
-
-            //- Per boundary point the weights per pointFaces.
-            scalarListList boundaryPointWeights_;
+        //- Per boundary point the weights per pointFaces.
+        List<scalarListList> boundaryPointNbrWeights_;
 
 
     // Private Member Functions
 
-        //- Construct addressing over all boundary faces
-        void calcBoundaryAddressing();
-
-        //- Make weights for internal and coupled-only boundarypoints
-        void makeInternalWeights(scalarField& sumWeights);
-
-        //- Make weights for points on uncoupled patches
-        void makeBoundaryWeights(scalarField& sumWeights);
-
         //- Construct all point weighting factors
         void makeWeights();
 
-        //- Helper: push master point data to collocated points
-        template<class Type>
-        void pushUntransformedData(List<Type>&) const;
-
-        //- Get boundary field in same order as boundary faces. Field is
-        //  zero on all coupled and empty patches
-        template<class Type>
-        tmp<Field<Type>> flatBoundaryField
-        (
-            const GeometricField<Type, fvPatchField, volMesh>& vf
-        ) const;
-
-        //- Add separated contributions
-        template<class Type>
-        void addSeparated
-        (
-            GeometricField<Type, pointPatchField, pointMesh>&
-        ) const;
-
 
 public:
 
@@ -163,58 +128,18 @@ public:
             const tmp<GeometricField<Type, fvPatchField, volMesh>>&
         ) const;
 
-        //- Interpolate volField using inverse distance weighting
-        //  returning pointField with the same patchField types. Assigns
-        //  to any fixedValue boundary conditions to make them consistent
-        //  with internal field
-        template<class Type>
-        tmp<GeometricField<Type, pointPatchField, pointMesh>> interpolate
-        (
-            const GeometricField<Type, fvPatchField, volMesh>&,
-            const wordList& patchFieldTypes
-        ) const;
-
-        //- Interpolate tmp<volField> using inverse distance weighting
-        //  returning pointField with the same patchField types. Assigns
-        //  to any fixedValue boundary conditions to make them consistent
-        //  with internal field
-        template<class Type>
-        tmp<GeometricField<Type, pointPatchField, pointMesh>> interpolate
-        (
-            const tmp<GeometricField<Type, fvPatchField, volMesh>>&,
-            const wordList& patchFieldTypes
-        ) const;
-
 
         // Low level
 
-            //- Interpolate internal field from volField to pointField
+            //- Interpolate from volField to pointField
             //  using inverse distance weighting
             template<class Type>
-            void interpolateInternalField
+            void interpolateUnconstrained
             (
                 const GeometricField<Type, fvPatchField, volMesh>&,
                 GeometricField<Type, pointPatchField, pointMesh>&
             ) const;
 
-            //- Interpolate boundary field without applying constraints/boundary
-            //  conditions
-            template<class Type>
-            void interpolateBoundaryField
-            (
-                const GeometricField<Type, fvPatchField, volMesh>& vf,
-                GeometricField<Type, pointPatchField, pointMesh>& pf
-            ) const;
-
-            //- Interpolate boundary with constraints/boundary conditions
-            template<class Type>
-            void interpolateBoundaryField
-            (
-                const GeometricField<Type, fvPatchField, volMesh>& vf,
-                GeometricField<Type, pointPatchField, pointMesh>& pf,
-                const bool overrideFixedValue
-            ) const;
-
             //- Interpolate from volField to pointField
             //  using inverse distance weighting
             template<class Type>
@@ -225,7 +150,7 @@ public:
             ) const;
 
             //- Interpolate volField using inverse distance weighting
-            //  returning pointField with name. Optionally caches
+            //  returning pointField with name. Optionally caches.
             template<class Type>
             tmp<GeometricField<Type, pointPatchField, pointMesh>> interpolate
             (
@@ -260,7 +185,7 @@ public:
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #ifdef NoRepository
-    #include "volPointInterpolate.C"
+    #include "volPointInterpolationTemplates.C"
 #endif
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolationTemplates.C b/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolationTemplates.C
new file mode 100644
index 0000000000..0f77670711
--- /dev/null
+++ b/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolationTemplates.C
@@ -0,0 +1,269 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "volPointInterpolation.H"
+#include "volFields.H"
+#include "pointFields.H"
+#include "surfaceFields.H"
+#include "emptyFvPatch.H"
+#include "coupledPointPatchField.H"
+#include "pointConstraints.H"
+#include "UCompactListList.H"
+#include "syncTools.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type>
+void Foam::volPointInterpolation::interpolateUnconstrained
+(
+    const GeometricField<Type, fvPatchField, volMesh>& vf,
+    GeometricField<Type, pointPatchField, pointMesh>& pf
+) const
+{
+    if (debug)
+    {
+        Pout<< "volPointInterpolation::interpolateUnconstrained("
+            << "const GeometricField<Type, fvPatchField, volMesh>&, "
+            << "GeometricField<Type, pointPatchField, pointMesh>&) : "
+            << "interpolating field from cells to points"
+            << endl;
+    }
+
+    const labelListList& pointCells = mesh().pointCells();
+    const polyBoundaryMesh& pbm = mesh().boundaryMesh();
+    const fvBoundaryMesh& fvbm = mesh().boundary();
+
+    const primitivePatch& boundary = boundaryPtr_();
+
+    // Cache calls to patch coupled flags
+    boolList isCoupledPolyPatch(pbm.size(), false);
+    boolList isCoupledFvPatch(fvbm.size(), false);
+    forAll(isCoupledFvPatch, patchi)
+    {
+        isCoupledPolyPatch[patchi] = pbm[patchi].coupled();
+        isCoupledFvPatch[patchi] = fvbm[patchi].coupled();
+    }
+
+    pf = Zero;
+
+    // Interpolate from the cells
+    forAll(pointWeights_, pointi)
+    {
+        forAll(pointWeights_[pointi], pointCelli)
+        {
+            const label celli = pointCells[pointi][pointCelli];
+
+            pf[pointi] += pointWeights_[pointi][pointCelli]*vf[celli];
+        }
+    }
+
+    // Get the boundary neighbour field
+    const typename GeometricField<Type, fvPatchField, volMesh>::Boundary vfBnf
+    (
+        GeometricField<Type, fvPatchField, volMesh>::null(),
+        vf.boundaryField().boundaryNeighbourField()
+    );
+
+    // Interpolate from the boundary faces
+    forAll(boundaryPointWeights_, bPointi)
+    {
+        const label pointi = boundary.meshPoints()[bPointi];
+
+        const labelList& pFaces = boundary.pointFaces()[bPointi];
+
+        forAll(boundaryPointWeights_[bPointi], bPointFacei)
+        {
+            // FV indices
+            const labelUList patches =
+                mesh().polyBFacePatches()[pFaces[bPointFacei]];
+            const labelUList patchFaces =
+                mesh().polyBFacePatchFaces()[pFaces[bPointFacei]];
+
+            forAll(boundaryPointWeights_[bPointi][bPointFacei], i)
+            {
+                // If FV coupled only, add the neighbouring cell value
+                if
+                (
+                    !isCoupledPolyPatch[patches[i]]
+                 && isCoupledFvPatch[patches[i]]
+                )
+                {
+                    pf[pointi] +=
+                        boundaryPointNbrWeights_[bPointi][bPointFacei][i]
+                       *vfBnf[patches[i]][patchFaces[i]];
+                }
+
+                // If not coupled, add a weight to the boundary value
+                if
+                (
+                    !isCoupledPolyPatch[patches[i]]
+                 && !isCoupledFvPatch[patches[i]]
+                )
+                {
+                    pf[pointi] +=
+                        boundaryPointWeights_[bPointi][bPointFacei][i]
+                       *vf.boundaryField()[patches[i]][patchFaces[i]];
+                }
+            }
+        }
+    }
+
+    // Synchronise
+    syncTools::syncPointList(mesh(), pf, plusEqOp<Type>(), pTraits<Type>::zero);
+}
+
+
+template<class Type>
+void Foam::volPointInterpolation::interpolate
+(
+    const GeometricField<Type, fvPatchField, volMesh>& vf,
+    GeometricField<Type, pointPatchField, pointMesh>& pf
+) const
+{
+    interpolateUnconstrained(vf, pf);
+
+    // Apply constraints
+    pointConstraints::New(pf.mesh()).constrain(pf);
+}
+
+
+template<class Type>
+Foam::tmp<Foam::GeometricField<Type, Foam::pointPatchField, Foam::pointMesh>>
+Foam::volPointInterpolation::interpolate
+(
+    const GeometricField<Type, fvPatchField, volMesh>& vf,
+    const word& name,
+    const bool cache
+) const
+{
+    typedef GeometricField<Type, pointPatchField, pointMesh> PointFieldType;
+
+    const pointMesh& pm = pointMesh::New(vf.mesh());
+    const objectRegistry& db = pm.thisDb();
+
+    if (!cache || vf.mesh().changing())
+    {
+        // Delete any old occurrences to avoid double registration
+        if (db.objectRegistry::template foundObject<PointFieldType>(name))
+        {
+            PointFieldType& pf =
+                db.objectRegistry::template lookupObjectRef<PointFieldType>
+                (
+                    name
+                );
+
+            if (pf.ownedByRegistry())
+            {
+                solution::cachePrintMessage("Deleting", name, vf);
+                pf.release();
+                delete &pf;
+            }
+        }
+
+        tmp<GeometricField<Type, pointPatchField, pointMesh>> tpf
+        (
+            GeometricField<Type, pointPatchField, pointMesh>::New
+            (
+                name,
+                pm,
+                vf.dimensions()
+            )
+        );
+
+        interpolate(vf, tpf.ref());
+
+        return tpf;
+    }
+    else
+    {
+        if (!db.objectRegistry::template foundObject<PointFieldType>(name))
+        {
+            solution::cachePrintMessage("Calculating and caching", name, vf);
+            tmp<PointFieldType> tpf = interpolate(vf, name, false);
+            PointFieldType* pfPtr = tpf.ptr();
+            regIOobject::store(pfPtr);
+            return *pfPtr;
+        }
+        else
+        {
+            PointFieldType& pf =
+                db.objectRegistry::template lookupObjectRef<PointFieldType>
+                (
+                    name
+                );
+
+            if (pf.upToDate(vf))
+            {
+                solution::cachePrintMessage("Reusing", name, vf);
+                return pf;
+            }
+            else
+            {
+                solution::cachePrintMessage("Deleting", name, vf);
+                pf.release();
+                delete &pf;
+
+                solution::cachePrintMessage("Recalculating", name, vf);
+                tmp<PointFieldType> tpf = interpolate(vf, name, false);
+
+                solution::cachePrintMessage("Storing", name, vf);
+                PointFieldType* pfPtr = tpf.ptr();
+                regIOobject::store(pfPtr);
+
+                return *pfPtr;
+            }
+        }
+    }
+}
+
+
+template<class Type>
+Foam::tmp<Foam::GeometricField<Type, Foam::pointPatchField, Foam::pointMesh>>
+Foam::volPointInterpolation::interpolate
+(
+    const GeometricField<Type, fvPatchField, volMesh>& vf
+) const
+{
+    return interpolate(vf, "volPointInterpolate(" + vf.name() + ')', false);
+}
+
+
+template<class Type>
+Foam::tmp<Foam::GeometricField<Type, Foam::pointPatchField, Foam::pointMesh>>
+Foam::volPointInterpolation::interpolate
+(
+    const tmp<GeometricField<Type, fvPatchField, volMesh>>& tvf
+) const
+{
+    tmp<GeometricField<Type, pointPatchField, pointMesh>> tpf =
+        interpolate(tvf());
+
+    tvf.clear();
+
+    return tpf;
+}
+
+
+// ************************************************************************* //
diff --git a/src/functionObjects/field/nearWallFields/findCellParticle.C b/src/functionObjects/field/nearWallFields/findCellParticle.C
index 5fe97a6e7b..2c73389bab 100644
--- a/src/functionObjects/field/nearWallFields/findCellParticle.C
+++ b/src/functionObjects/field/nearWallFields/findCellParticle.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2013-2018 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2013-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -103,16 +103,16 @@ bool Foam::findCellParticle::move
     const scalar maxTrackLen
 )
 {
-    td.switchProcessor = false;
     td.keepParticle = true;
+    td.sendToProc = -1;
 
-    while (td.keepParticle && !td.switchProcessor && stepFraction() < 1)
+    while (td.keepParticle && td.sendToProc == -1 && stepFraction() < 1)
     {
         const scalar f = 1 - stepFraction();
         trackToAndHitFace(f*displacement_, f, cloud, td);
     }
 
-    if (!td.switchProcessor)
+    if (td.sendToProc == -1)
     {
         // Hit endpoint or patch. If patch hit could do fancy stuff but just
         // to use the patch point is good enough for now.
@@ -124,12 +124,6 @@ bool Foam::findCellParticle::move
 }
 
 
-bool Foam::findCellParticle::hitPatch(Cloud<findCellParticle>&, trackingData&)
-{
-    return false;
-}
-
-
 void Foam::findCellParticle::hitWedgePatch
 (
     Cloud<findCellParticle>&,
@@ -215,12 +209,21 @@ void Foam::findCellParticle::hitCyclicRepeatAMIPatch
 
 void Foam::findCellParticle::hitProcessorPatch
 (
-    Cloud<findCellParticle>&,
+    Cloud<findCellParticle>& cloud,
     trackingData& td
 )
 {
-    // Remove particle
-    td.switchProcessor = true;
+    const processorPolyPatch& ppp =
+        static_cast<const processorPolyPatch&>(mesh().boundaryMesh()[patch()]);
+
+    if (ppp.transform().transforms())
+    {
+        td.keepParticle = false;
+    }
+    else
+    {
+        particle::hitProcessorPatch(cloud, td);
+    }
 }
 
 
diff --git a/src/functionObjects/field/nearWallFields/findCellParticle.H b/src/functionObjects/field/nearWallFields/findCellParticle.H
index a5fb4f4fac..0222b76498 100644
--- a/src/functionObjects/field/nearWallFields/findCellParticle.H
+++ b/src/functionObjects/field/nearWallFields/findCellParticle.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2013-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2013-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -208,10 +208,6 @@ public:
             //- Track all particles to their end point
             bool move(Cloud<findCellParticle>&, trackingData&, const scalar);
 
-            //- Overridable function to handle the particle hitting a patch
-            //  Executed before other patch-hitting functions
-            bool hitPatch(Cloud<findCellParticle>&, trackingData&);
-
             //- Overridable function to handle the particle hitting a wedge
             void hitWedgePatch(Cloud<findCellParticle>&, trackingData&);
 
diff --git a/src/functionObjects/field/streamlines/streamlinesParticle.C b/src/functionObjects/field/streamlines/streamlinesParticle.C
index 76fcb51086..aaf77f648b 100644
--- a/src/functionObjects/field/streamlines/streamlinesParticle.C
+++ b/src/functionObjects/field/streamlines/streamlinesParticle.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2021 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -209,12 +209,12 @@ bool Foam::streamlinesParticle::move
     const scalar
 )
 {
-    td.switchProcessor = false;
     td.keepParticle = true;
+    td.sendToProc = -1;
 
     const scalar maxDt = mesh().bounds().mag();
 
-    while (td.keepParticle && !td.switchProcessor && lifeTime_ > 0)
+    while (td.keepParticle && td.sendToProc == -1 && lifeTime_ > 0)
     {
         scalar dt = maxDt;
 
@@ -274,7 +274,7 @@ bool Foam::streamlinesParticle::move
                *dt
                *(1 - trackToAndHitFace(dt*U, 0, cloud, td));
 
-            if (!td.keepParticle || td.switchProcessor || lifeTime_ == 0)
+            if (!td.keepParticle || td.sendToProc != -1 || lifeTime_ == 0)
             {
                 break;
             }
@@ -322,13 +322,6 @@ bool Foam::streamlinesParticle::move
 }
 
 
-bool Foam::streamlinesParticle::hitPatch(streamlinesCloud&, trackingData&)
-{
-    // Disable generic patch interaction
-    return false;
-}
-
-
 void Foam::streamlinesParticle::hitWedgePatch
 (
     streamlinesCloud&,
@@ -430,9 +423,35 @@ void Foam::streamlinesParticle::hitCyclicRepeatAMIPatch
 }
 
 
+bool Foam::streamlinesParticle::hitNonConformalCyclicPatch
+(
+    const vector& displacement,
+    const scalar fraction,
+    const label patchi,
+    streamlinesCloud& cloud,
+    trackingData& td
+)
+{
+    // Move across the cyclic
+    const bool result =
+        particle::hitNonConformalCyclicPatch
+        (
+            displacement,
+            fraction,
+            patchi,
+            cloud,
+            td
+        );
+
+    // End this track
+    if (result) endTrack(td);
+
+    return result;
+}
+
 void Foam::streamlinesParticle::hitProcessorPatch
 (
-    streamlinesCloud&,
+    streamlinesCloud& cloud,
     trackingData& td
 )
 {
@@ -445,8 +464,7 @@ void Foam::streamlinesParticle::hitProcessorPatch
         endTrack(td);
     }
 
-    // Switch processor
-    td.switchProcessor = true;
+    particle::hitProcessorPatch(cloud, td);
 }
 
 
diff --git a/src/functionObjects/field/streamlines/streamlinesParticle.H b/src/functionObjects/field/streamlines/streamlinesParticle.H
index 44e81492dc..6462be8715 100644
--- a/src/functionObjects/field/streamlines/streamlinesParticle.H
+++ b/src/functionObjects/field/streamlines/streamlinesParticle.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2021 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -258,10 +258,6 @@ public:
             //- Track all particles to their end point
             bool move(streamlinesCloud&, trackingData&, const scalar);
 
-            //- Overridable function to handle the particle hitting a patch
-            //  Executed before other patch-hitting functions
-            bool hitPatch(streamlinesCloud&, trackingData&);
-
             //- Overridable function to handle the particle hitting a wedge
             void hitWedgePatch(streamlinesCloud&, trackingData&);
 
@@ -306,8 +302,19 @@ public:
                 trackingData&
             );
 
+            //- Overridable function to handle the particle hitting an
+            //  nonConformalCyclicPolyPatch
+            bool hitNonConformalCyclicPatch
+            (
+                const vector& displacement,
+                const scalar fraction,
+                const label patchi,
+                streamlinesCloud& cloud,
+                trackingData& td
+            );
+
             //- Overridable function to handle the particle hitting a
-            //- processorPatch
+            //  processorPatch
             void hitProcessorPatch(streamlinesCloud&, trackingData&);
 
             //- Overridable function to handle the particle hitting a wallPatch
diff --git a/src/fvMeshDistributors/Make/options b/src/fvMeshDistributors/Make/options
index 8bec7b534e..59e43dacbc 100644
--- a/src/fvMeshDistributors/Make/options
+++ b/src/fvMeshDistributors/Make/options
@@ -11,4 +11,5 @@ LIB_LIBS = \
     -ltriSurface \
     -lmeshTools \
     -ldynamicMesh \
-    -lfiniteVolume
+    -lfiniteVolume \
+    -lfvMeshStitchers
diff --git a/src/fvMeshMovers/Make/options b/src/fvMeshMovers/Make/options
index 4f7629e350..c40a00bb28 100644
--- a/src/fvMeshMovers/Make/options
+++ b/src/fvMeshMovers/Make/options
@@ -6,4 +6,5 @@ EXE_INC = \
 LIB_LIBS = \
     -ldynamicMesh \
     -lfiniteVolume \
-    -lmeshTools
+    -lmeshTools \
+    -lfvMeshStitchers
diff --git a/src/fvMeshStitchers/Make/files b/src/fvMeshStitchers/Make/files
new file mode 100644
index 0000000000..c58b73476c
--- /dev/null
+++ b/src/fvMeshStitchers/Make/files
@@ -0,0 +1,3 @@
+moving/fvMeshStitchersMoving.C
+
+LIB = $(FOAM_LIBBIN)/libfvMeshStitchers
diff --git a/src/fvMeshStitchers/Make/options b/src/fvMeshStitchers/Make/options
new file mode 100644
index 0000000000..4f7629e350
--- /dev/null
+++ b/src/fvMeshStitchers/Make/options
@@ -0,0 +1,9 @@
+EXE_INC = \
+    -I$(LIB_SRC)/dynamicMesh/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude
+
+LIB_LIBS = \
+    -ldynamicMesh \
+    -lfiniteVolume \
+    -lmeshTools
diff --git a/src/fvMeshStitchers/moving/fvMeshStitchersMoving.C b/src/fvMeshStitchers/moving/fvMeshStitchersMoving.C
new file mode 100644
index 0000000000..6f1a05e58c
--- /dev/null
+++ b/src/fvMeshStitchers/moving/fvMeshStitchersMoving.C
@@ -0,0 +1,1075 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fvMeshStitchersMoving.H"
+#include "fvMeshSubset.H"
+#include "fvmLaplacian.H"
+#include "movingWallVelocityFvPatchVectorField.H"
+#include "movingWallSlipVelocityFvPatchVectorField.H"
+#include "regionSplit.H"
+#include "solutionControl.H"
+#include "syncTools.H"
+#include "zeroGradientFvPatchField.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+template<class Type>
+inline List<Type> repeat(const UList<Type>& a, const UList<Type>& b)
+{
+    List<Type> result(a.size() + b.size());
+    forAll(a, i)
+    {
+        result[2*i] = a[i];
+        result[2*i + 1] = b[i];
+    }
+    return result;
+}
+
+
+template<class Type>
+inline List<Type> repeat(const UList<Type>& l)
+{
+    return repeat(l, l);
+}
+
+
+struct layerAndWeight
+{
+    label layer;
+    scalar weight;
+
+    static const layerAndWeight min, max;
+
+    typedef nil cmptType;
+
+    friend bool operator==(const layerAndWeight& a, const layerAndWeight& b)
+    {
+        return a.layer == b.layer && a.weight == b.weight;
+    }
+
+    friend bool operator!=(const layerAndWeight& a, const layerAndWeight& b)
+    {
+        return !(a == b);
+    }
+
+    friend Ostream& operator<<(Ostream& os, const layerAndWeight& l)
+    {
+        return os << l.layer << token::SPACE << l.weight;
+    }
+
+    friend Istream& operator>>(Istream& is, layerAndWeight& l)
+    {
+        return is >> l.layer >> l.weight;
+    }
+};
+
+
+const layerAndWeight layerAndWeight::min({-labelMax, NaN});
+
+
+const layerAndWeight layerAndWeight::max({labelMax, NaN});
+
+
+layerAndWeight max(const layerAndWeight& a, const layerAndWeight& b)
+{
+    return a.layer > b.layer ? a : b;
+}
+
+
+layerAndWeight min(const layerAndWeight& a, const layerAndWeight& b)
+{
+    return a.layer < b.layer ? a : b;
+}
+
+
+}
+
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace fvMeshStitchers
+{
+    defineTypeNameAndDebug(moving, 0);
+    addToRunTimeSelectionTable(fvMeshStitcher, moving, fvMesh);
+}
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::fvMeshStitchers::moving::initCorrectMeshPhi
+(
+    surfaceLabelField::Boundary& polyFacesBf,
+    surfaceVectorField& SfSf,
+    surfaceVectorField& CfSf
+)
+{
+    const nonConformalBoundary& ncb = nonConformalBoundary::New(mesh());
+    const labelList origPatchIDs = ncb.allOrigPatchIDs();
+    const labelList errorPatchIDs = ncb.allErrorPatchIDs();
+
+    forAll(origPatchIDs, i)
+    {
+        const label origPatchi = origPatchIDs[i];
+        const polyPatch& origPp = mesh().boundaryMesh()[origPatchi];
+
+        const label errorPatchi = errorPatchIDs[i];
+
+        polyFacesBf[errorPatchi] =
+            repeat((identity(origPp.size()) + origPp.start())());
+
+        SfSf.boundaryFieldRef()[errorPatchi] =
+            repeat
+            (
+                (rootVSmall*origPp.faceNormals())(),
+                (-rootVSmall*origPp.faceNormals())()
+            );
+        CfSf.boundaryFieldRef()[errorPatchi] =
+            repeat(origPp.faceCentres());
+    }
+}
+
+
+Foam::labelHashSet Foam::fvMeshStitchers::moving::ownerCoupledCellSet()
+{
+    const nonConformalBoundary& ncb = nonConformalBoundary::New(mesh());
+
+    // For every boundary face, count how many owner-orig faces it is connected
+    // to (will be 1 or 0)
+    labelList bFaceNSet(mesh().nFaces() - mesh().nInternalFaces(), 0);
+    forAll(mesh().boundary(), nccPatchi)
+    {
+        const fvPatch& fvp = mesh().boundary()[nccPatchi];
+
+        if (!isA<nonConformalCoupledFvPatch>(fvp)) continue;
+
+        const nonConformalCoupledFvPatch& nccFvp =
+            refCast<const nonConformalCoupledFvPatch>(fvp);
+
+        if (!nccFvp.owner()) continue;
+
+        forAll(nccFvp, nccPatchFacei)
+        {
+            bFaceNSet
+            [
+                mesh().polyFacesBf()[nccPatchi][nccPatchFacei]
+              - mesh().nInternalFaces()
+            ] = 1;
+        }
+    }
+
+    // For every boundary edge, count how many owner-orig faces it is connected
+    // to (should be 0, 1 or 2)
+    labelList ownerOrigBoundaryEdgeNSet
+    (
+        ncb.ownerOrigBoundaryEdgeMeshEdge().size(),
+        0
+    );
+    forAll(ncb.ownerOrigBoundaryEdgeMeshEdge(), ownerOrigBoundaryEdgei)
+    {
+        const label meshEdgei =
+            ncb.ownerOrigBoundaryEdgeMeshEdge()[ownerOrigBoundaryEdgei];
+
+        forAll(mesh().edgeFaces()[meshEdgei], edgeFacei)
+        {
+            const label facei = mesh().edgeFaces()[meshEdgei][edgeFacei];
+
+            if (mesh().isInternalFace(facei)) continue;
+
+            const label bFacei = facei - mesh().nInternalFaces();
+
+            if (bFaceNSet[bFacei])
+            {
+                ownerOrigBoundaryEdgeNSet[ownerOrigBoundaryEdgei] += 1;
+            }
+        }
+    }
+    syncTools::syncEdgeList
+    (
+        mesh(),
+        ncb.ownerOrigBoundaryEdgeMeshEdge(),
+        ownerOrigBoundaryEdgeNSet,
+        plusEqOp<label>(),
+        0
+    );
+
+    // Isolate the cells that are edge connected to the owner patches. This
+    // will form the sub-mesh in which the correction is computed.
+    labelHashSet set;
+    forAll(ncb.ownerOrigBoundaryEdgeMeshEdge(), ownerOrigBoundaryEdgei)
+    {
+        if (ownerOrigBoundaryEdgeNSet[ownerOrigBoundaryEdgei] < 2) continue;
+
+        const label meshEdgei =
+            ncb.ownerOrigBoundaryEdgeMeshEdge()[ownerOrigBoundaryEdgei];
+
+        forAll(mesh().edgeFaces()[meshEdgei], edgeFacei)
+        {
+            const label facei = mesh().edgeFaces()[meshEdgei][edgeFacei];
+
+            set.insert(mesh().faceOwner()[facei]);
+
+            if (facei < mesh().nInternalFaces())
+            {
+                set.insert(mesh().faceNeighbour()[facei]);
+            }
+        }
+    }
+
+    return set;
+}
+
+
+void Foam::fvMeshStitchers::moving::internalFaceCorrectMeshPhi
+(
+    surfaceScalarField& phi
+)
+{
+    const surfaceScalarField::Boundary& magSfBf =
+        mesh().magSf().boundaryField();
+
+    surfaceScalarField::Boundary& phiBf = phi.boundaryFieldRef();
+
+    // Step 1: Construct some boundary information
+
+    // For each boundary face mark if it is an owner orig face and sum the total
+    // non-conformal coupled area if so
+    boolList bFaceIsOwnerOrig(mesh().nFaces() - mesh().nInternalFaces(), false);
+    scalarList bFaceNccMagSf(mesh().nFaces() - mesh().nInternalFaces(), Zero);
+    forAll(mesh().boundary(), nccPatchi)
+    {
+        const fvPatch& fvp = mesh().boundary()[nccPatchi];
+
+        if (!isA<nonConformalCoupledFvPatch>(fvp)) continue;
+
+        const nonConformalCoupledFvPatch& nccFvp =
+            refCast<const nonConformalCoupledFvPatch>(fvp);
+
+        if (!nccFvp.owner()) continue;
+
+        forAll(nccFvp, nccPatchFacei)
+        {
+            const label bFacei =
+                nccFvp.polyFaces()[nccPatchFacei] - mesh().nInternalFaces();
+
+            bFaceIsOwnerOrig[bFacei] = true;
+            bFaceNccMagSf[bFacei] += magSfBf[nccPatchi][nccPatchFacei];
+        }
+    }
+
+    // Step 2: Construct a sub-mesh for all cells that are connected to the
+    // owner patches.
+
+    // Isolate the cells that are edge connected to the owner patches. This
+    // will form the sub-mesh in which the correction is computed.
+    labelHashSet subCellSet = ownerCoupledCellSet();
+
+    // Create a mesh for the cells that are edge connected to coupled faces
+    // of the owner patches. This is where the correction will be computed.
+    fvMeshSubset subsetter(mesh());
+    subsetter.setLargeCellSubset(ownerCoupledCellSet());
+    const fvMesh& subMesh = subsetter.subMesh();
+
+    // Determine the disconnected regions of the sub mesh
+    const regionSplit subMeshRegions(subMesh);
+    const label subNRegions = subMeshRegions.nRegions();
+
+    // Map from mesh boundary face to sub-mesh region
+    labelList bFaceSubRegion(mesh().nFaces() - mesh().nInternalFaces(), -1);
+    forAll(subsetter.faceMap(), subFacei)
+    {
+        const label facei = subsetter.faceMap()[subFacei];
+
+        if (mesh().isInternalFace(facei)) continue;
+
+        const label bFacei = facei - mesh().nInternalFaces();
+
+        bFaceSubRegion[bFacei] =
+            subMeshRegions[subMesh.faceOwner()[subFacei]];
+    }
+
+    // Get a single reference cell for each region
+    labelList subMeshRegionRefCells(subNRegions, -1);
+    {
+        static const label proci = Pstream::myProcNo();
+
+        labelList subMeshRegionRefProcs(subNRegions, labelMax);
+        forAll(subMeshRegions, subCelli)
+        {
+            subMeshRegionRefProcs[subMeshRegions[subCelli]] = proci;
+        }
+        reduce(subMeshRegionRefProcs, minOp<labelList>());
+
+        forAll(subMeshRegions, subCelli)
+        {
+            if
+            (
+                subMeshRegionRefProcs[subMeshRegions[subCelli]] == proci
+             && subMeshRegionRefCells[subMeshRegions[subCelli]] == -1
+            )
+            {
+                subMeshRegionRefCells[subMeshRegions[subCelli]] = subCelli;
+            }
+        }
+    }
+
+    // Step 3: Synchronise the flux across the interfaces
+
+    // Create a synchronised mesh flux for the coupled patches. Set both sides
+    // to the neighbour value so that all the error is on the owner side.
+    surfaceScalarField::Boundary syncPhiBf
+    (
+        surfaceScalarField::Internal::null(),
+        synchronisedBoundaryField<scalar>(phiBf, true, 0, 1)
+    );
+
+    // Determine the total mesh flux error and area magnitude for each region
+    scalarField regionPhiError(subNRegions, 0);
+    scalarField regionMagSf(subNRegions, vSmall);
+    forAll(phiBf, nccPatchi)
+    {
+        const fvPatch& fvp = mesh().boundary()[nccPatchi];
+
+        if (!isA<nonConformalCoupledFvPatch>(fvp)) continue;
+
+        const nonConformalCoupledFvPatch& nccFvp =
+            refCast<const nonConformalCoupledFvPatch>(fvp);
+
+        if (!nccFvp.owner()) continue;
+
+        forAll(nccFvp, nccPatchFacei)
+        {
+            const label subRegioni =
+                bFaceSubRegion
+                [
+                    mesh().polyFacesBf()[nccPatchi][nccPatchFacei]
+                  - mesh().nInternalFaces()
+                ];
+
+            regionPhiError[subRegioni] +=
+                syncPhiBf[nccPatchi][nccPatchFacei]
+              - phiBf[nccPatchi][nccPatchFacei];
+
+            regionMagSf[subRegioni] +=
+                magSfBf[nccPatchi][nccPatchFacei];
+        }
+    }
+    reduce(regionPhiError, sumOp<scalarField>());
+    reduce(regionMagSf, sumOp<scalarField>());
+
+    // Synchronise the mesh fluxes, but offset so that the total flux for each
+    // region is the same as for the non-synchronised mesh fluxes
+    forAll(phiBf, nccPatchi)
+    {
+        const fvPatch& fvp = mesh().boundary()[nccPatchi];
+
+        if (!isA<nonConformalCoupledFvPatch>(fvp)) continue;
+
+        const nonConformalCoupledFvPatch& nccFvp =
+            refCast<const nonConformalCoupledFvPatch>(fvp);
+
+        if (!nccFvp.owner()) continue;
+
+        forAll(nccFvp, nccPatchFacei)
+        {
+            const label subRegioni =
+                bFaceSubRegion
+                [
+                    mesh().polyFacesBf()[nccPatchi][nccPatchFacei]
+                  - mesh().nInternalFaces()
+                ];
+
+            phiBf[nccPatchi][nccPatchFacei] =
+                syncPhiBf[nccPatchi][nccPatchFacei]
+              - magSfBf[nccPatchi][nccPatchFacei]
+               /regionMagSf[subRegioni]
+               *regionPhiError[subRegioni];
+        }
+    }
+
+    // Step 4: Set up a system on the sub-mesh with which to solve for a flux
+    // that corrects the volume conservation error in the cells connected to
+    // synchronised faces
+
+    // Map volumes to the sub mesh
+    const volScalarField::Internal subV(subsetter.interpolate(mesh().V()));
+    const volScalarField::Internal subV0(subsetter.interpolate(mesh().V0()));
+
+    // Map mesh flux to the sub mesh, accumulating when a face is split into
+    // multiple non-conformal parts
+    surfaceScalarField subPhi
+    (
+        surfaceScalarField::New
+        (
+            "phi",
+            subMesh,
+            dimensionedScalar(dimVolume/dimTime, 0)
+        )
+    );
+    forAll(subPhi, subFacei)
+    {
+        const label facei = subsetter.faceMap()[subFacei];
+
+        subPhi[subFacei] = phi[facei];
+    }
+    forAll(subPhi.boundaryField(), subPatchi)
+    {
+        const fvPatch& subFvp = subPhi.boundaryField()[subPatchi].patch();
+
+        forAll(subPhi.boundaryField()[subPatchi], subPatchFacei)
+        {
+            const label subFacei = subFvp.start() + subPatchFacei;
+            const label facei = subsetter.faceMap()[subFacei];
+
+            if (mesh().isInternalFace(facei))
+            {
+                const label s = sign(subsetter.faceFlipMap()[subFacei]);
+
+                subPhi.boundaryFieldRef()[subPatchi][subPatchFacei] =
+                    s*phi[facei];
+            }
+            else
+            {
+                const label bFacei = facei - mesh().nInternalFaces();
+
+                const labelUList patches =
+                    mesh().polyBFacePatches()[bFacei];
+                const labelUList patchFaces =
+                    mesh().polyBFacePatchFaces()[bFacei];
+
+                forAll(patches, i)
+                {
+                    subPhi.boundaryFieldRef()[subPatchi][subPatchFacei] +=
+                        phiBf[patches[i]][patchFaces[i]];
+                }
+            }
+        }
+    }
+
+    // Calculate the volume conservation error for the sub mesh
+    const volScalarField::Internal subVce
+    (
+        fvc::surfaceIntegrate(subPhi*subMesh.time().deltaT())()
+      - (subV - subV0)/subV
+    );
+
+    // Construct boundary conditions for the sub-mesh potential. Zero gradient
+    // is used for all non-constraint boundaries (i.e., this is a closed
+    // domain) and for exposed internal faces, which therefore require a patch
+    // type override
+    wordList MeshPhiPatchTypes(subMesh.boundary().size());
+    forAll(subMesh.boundary(), patchi)
+    {
+        const fvPatch& subFvp = subMesh.boundary()[patchi];
+        MeshPhiPatchTypes[patchi] =
+            polyPatch::constraintType(subFvp.type())
+         && !isA<internalFvPatch>(subFvp)
+          ? subFvp.type()
+          : zeroGradientFvPatchField<scalar>::typeName;
+    }
+
+    // Solve
+    volScalarField MeshPhi
+    (
+        IOobject
+        (
+            "MeshPhi",
+            subMesh.time().timeName(),
+            subMesh,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        subMesh,
+        dimensionedScalar(dimArea, 0),
+        MeshPhiPatchTypes,
+        subMesh.boundaryMesh().types()
+    );
+
+    subMesh.schemes().setFluxRequired(MeshPhi.name());
+
+    fvScalarMatrix MeshPhiEqn
+    (
+        fvm::laplacian(MeshPhi) + subVce
+    );
+
+    forAll(subMeshRegionRefCells, i)
+    {
+        MeshPhiEqn.setReference(subMeshRegionRefCells[i], 0);
+    }
+
+    MeshPhiEqn.solve();
+
+    // Create a correction for the sub-mesh face fluxes
+    surfaceScalarField subDeltaPhi(MeshPhiEqn.flux()/mesh().time().deltaT());
+
+    // Step 5: Currently, the computed correction fixes the volume conservation
+    // error to the level of the solve tolerance. We would rather the volume
+    // conservation error be at round off and the error be in the mismatch
+    // across the couplings, as the mismatch will be fixed later when area and
+    // mesh flux is added to the error faces. So, here, we correct the
+    // correction (!) by propagating the error from the cells furthest from the
+    // interface back to the interface. This process is wave-like, but the
+    // sub-mesh is thin, so it should only require 1 or 2 iterations.
+
+    // Initialise layers and weights
+    List<layerAndWeight> subFaceLayerAndWeight(subMesh.nFaces(), {-1, NaN});
+    List<layerAndWeight> subCellLayerAndWeight(subMesh.nCells(), {-1, Zero});
+    forAll(subMesh.boundary(), subPatchi)
+    {
+        const fvPatch& subFvp = subMesh.boundary()[subPatchi];
+
+        if (subFvp.coupled()) continue;
+
+        forAll(subFvp, subPatchFacei)
+        {
+            const label subFacei = subFvp.start() + subPatchFacei;
+            const label facei = subsetter.faceMap()[subFacei];
+            const label bFacei = facei - mesh().nInternalFaces();
+
+            if (bFacei >= 0 && bFaceIsOwnerOrig[bFacei])
+            {
+                subFaceLayerAndWeight[subFacei] = {0, bFaceNccMagSf[bFacei]};
+            }
+        }
+    }
+
+    // Create layers and weights by waving from owner-orig faces
+    while (gMin(subFaceLayerAndWeight).layer < 0)
+    {
+        // Face to cell
+        List<layerAndWeight> subCellLayerAndWeight0(subCellLayerAndWeight);
+        forAll(subMesh.faces(), subFacei)
+        {
+            if (subFaceLayerAndWeight[subFacei].layer != -1)
+            {
+                const label subOwnCelli = subMesh.faceOwner()[subFacei];
+                if (subCellLayerAndWeight0[subOwnCelli].layer == -1)
+                {
+                    subCellLayerAndWeight[subOwnCelli].layer =
+                        subFaceLayerAndWeight[subFacei].layer + 1;
+                    subCellLayerAndWeight[subOwnCelli].weight +=
+                        subFaceLayerAndWeight[subFacei].weight;
+                }
+
+                if (!subMesh.isInternalFace(subFacei)) continue;
+
+                const label subNbrCelli = subMesh.faceNeighbour()[subFacei];
+                if (subCellLayerAndWeight0[subNbrCelli].layer == -1)
+                {
+                    subCellLayerAndWeight[subNbrCelli].layer =
+                        subFaceLayerAndWeight[subFacei].layer + 1;
+                    subCellLayerAndWeight[subNbrCelli].weight +=
+                        subFaceLayerAndWeight[subFacei].weight;
+                }
+            }
+        }
+
+        // Cell to face
+        List<layerAndWeight> subFaceLayerAndWeight0(subFaceLayerAndWeight);
+        forAll(subMesh.cells(), subCelli)
+        {
+            if (subCellLayerAndWeight[subCelli].layer != -1)
+            {
+                forAll(subMesh.cells()[subCelli], subCellFacei)
+                {
+                    const label subFacei =
+                        subMesh.cells()[subCelli][subCellFacei];
+                    if (subFaceLayerAndWeight0[subFacei].layer == -1)
+                    {
+                        subFaceLayerAndWeight[subFacei].layer =
+                            subCellLayerAndWeight[subCelli].layer + 1;
+                        subFaceLayerAndWeight[subFacei].weight =
+                            subCellLayerAndWeight[subCelli].weight;
+                    }
+                }
+            }
+        }
+
+        // Synchronise
+        SubList<layerAndWeight> subBFaceLayerAndWeight
+        (
+            subFaceLayerAndWeight,
+            subMesh.nFaces() - subMesh.nInternalFaces(),
+            subMesh.nInternalFaces()
+        );
+        syncTools::syncBoundaryFaceList
+        (
+            subMesh,
+            subBFaceLayerAndWeight,
+            maxEqOp<layerAndWeight>(),
+            [](const coupledPolyPatch&, List<layerAndWeight>&){}
+        );
+    }
+
+    // Function to extract a value from a surface field given a face index
+    auto subFaceValue = [&subMesh]
+    (
+        surfaceScalarField& sf,
+        const label subFacei
+    ) -> scalar&
+    {
+        const label subBFacei =
+            subMesh.isInternalFace(subFacei)
+          ? -1 : subFacei -  subMesh.nInternalFaces();
+        const label subPatchi =
+            subMesh.isInternalFace(subFacei)
+          ? -1 : subMesh.boundaryMesh().patchID()[subBFacei];
+        const label subPatchFacei =
+            subMesh.isInternalFace(subFacei)
+          ? -1 : subFacei - subMesh.boundaryMesh()[subPatchi].start();
+
+        return
+            subMesh.isInternalFace(subFacei)
+          ? sf[subFacei]
+          : sf.boundaryFieldRef()[subPatchi][subPatchFacei];
+    };
+
+    // Correct volume conservation error by waving back to the owner-orig faces
+    for
+    (
+        label cellLayeri = gMax(subCellLayerAndWeight).layer;
+        cellLayeri > 0;
+        cellLayeri -= 2
+    )
+    {
+        const surfaceScalarField subDeltaPhi0(subDeltaPhi);
+
+        forAll(subMesh.cells(), subCelli)
+        {
+            if (subCellLayerAndWeight[subCelli].layer != cellLayeri) continue;
+
+            // Compute the error for this cell
+            scalar deltaV = subV[subCelli] - subV0[subCelli];
+            forAll(subV.mesh().cells()[subCelli], subCellFacei)
+            {
+                const label subFacei =
+                    subV.mesh().cells()[subCelli][subCellFacei];
+                const bool o = subV.mesh().faceOwner()[subFacei] == subCelli;
+
+                deltaV -=
+                    (
+                        subFaceValue(subPhi, subFacei)
+                      + subFaceValue(subDeltaPhi, subFacei)
+                    )
+                   *(o ? +1 : -1);
+            }
+
+            // Push the error onto the lower-layered faces
+            forAll(subMesh.cells()[subCelli], subCellFacei)
+            {
+                const label subFacei =
+                    subMesh.cells()[subCelli][subCellFacei];
+                const bool o = subMesh.faceOwner()[subFacei] == subCelli;
+                const scalar w =
+                    subFaceLayerAndWeight[subFacei].weight
+                   /subCellLayerAndWeight[subCelli].weight;
+
+                if
+                (
+                    subCellLayerAndWeight[subCelli].layer
+                  > subFaceLayerAndWeight[subFacei].layer
+                )
+                {
+                    subFaceValue(subDeltaPhi, subFacei) +=
+                        deltaV*w*(o ? +1 : -1);
+                }
+            }
+        }
+
+        // Synchronise
+        const surfaceScalarField::Boundary dSubDeltaPhiNbrBf
+        (
+            surfaceScalarField::Internal::null(),
+            (subDeltaPhi - subDeltaPhi0)()
+           .boundaryField()
+           .boundaryNeighbourField()
+        );
+        forAll(subMesh.boundary(), subPatchi)
+        {
+            const fvPatch& subFvp = subMesh.boundary()[subPatchi];
+
+            if (subFvp.coupled())
+            {
+                subDeltaPhi.boundaryFieldRef()[subPatchi] -=
+                    dSubDeltaPhiNbrBf[subPatchi];
+            }
+        }
+    }
+
+    // Step 6: Apply the corrections to the mesh flux
+
+    // Correct the internal mesh face fluxes
+    forAll(subPhi, subFacei)
+    {
+        phi[subsetter.faceMap()[subFacei]] =
+            subPhi[subFacei] + subDeltaPhi[subFacei];
+    }
+
+    // Map the sub-mesh flux changes to the conformal mesh boundary
+    surfaceScalarField::Boundary deltaPhiBf
+    (
+        mesh().boundary(),
+        surfaceScalarField::Internal::null(),
+        calculatedFvPatchField<scalar>::typeName
+    );
+    deltaPhiBf = 0;
+    forAll(subMesh.boundary(), subPatchi)
+    {
+        const label patchi = subsetter.patchMap()[subPatchi];
+
+        if (patchi == -1) continue;
+
+        const fvPatch& subFvp = subMesh.boundary()[subPatchi];
+        const fvPatch& fvp = mesh().boundary()[patchi];
+
+        const bool coupled = subFvp.coupled();
+
+        forAll(subMesh.boundary()[subPatchi], subPatchFacei)
+        {
+            const label facei =
+                subsetter.faceMap()[subFvp.start() + subPatchFacei];
+
+            const label patchFacei = facei - fvp.start();
+
+            if (coupled)
+            {
+                deltaPhiBf[patchi][patchFacei] =
+                    subPhi.boundaryField()[subPatchi][subPatchFacei]
+                  + subDeltaPhi.boundaryField()[subPatchi][subPatchFacei]
+                  - phiBf[patchi][patchFacei];
+            }
+            else
+            {
+                deltaPhiBf[patchi][patchFacei] =
+                    subDeltaPhi.boundaryField()[subPatchi][subPatchFacei];
+            }
+        }
+    }
+
+    // Move the changes from the owner-orig to the non-conformal coupled faces
+    forAll(mesh().boundary(), nccPatchi)
+    {
+        const fvPatch& fvp = mesh().boundary()[nccPatchi];
+
+        if (!isA<nonConformalCoupledFvPatch>(fvp)) continue;
+
+        const nonConformalCoupledFvPatch& nccFvp =
+            refCast<const nonConformalCoupledFvPatch>(fvp);
+
+        if (!nccFvp.owner()) continue;
+
+        const label origPatchi = nccFvp.origPatchID();
+        const fvPatch& origFvp = nccFvp.origPatch();
+
+        forAll(nccFvp, nccPatchFacei)
+        {
+            const label bFacei =
+                nccFvp.polyFaces()[nccPatchFacei] - mesh().nInternalFaces();
+
+            const label origPatchFacei =
+                nccFvp.polyFaces()[nccPatchFacei] - origFvp.start();
+
+            const scalar deltaPhi =
+                magSfBf[nccPatchi][nccPatchFacei]
+               /bFaceNccMagSf[bFacei]
+               *deltaPhiBf[origPatchi][origPatchFacei];
+
+            deltaPhiBf[nccPatchi][nccPatchFacei] = deltaPhi;
+        }
+    }
+    forAll(mesh().boundary(), nccPatchi)
+    {
+        const fvPatch& fvp = mesh().boundary()[nccPatchi];
+
+        if (!isA<nonConformalCoupledFvPatch>(fvp)) continue;
+
+        const nonConformalCoupledFvPatch& nccFvp =
+            refCast<const nonConformalCoupledFvPatch>(fvp);
+
+        if (!nccFvp.owner()) continue;
+
+        const label origPatchi = nccFvp.origPatchID();
+        const fvPatch& origFvp = nccFvp.origPatch();
+
+        forAll(nccFvp, nccPatchFacei)
+        {
+            const label origPatchFacei =
+                nccFvp.polyFaces()[nccPatchFacei] - origFvp.start();
+
+            deltaPhiBf[origPatchi][origPatchFacei] = 0;
+        }
+    }
+
+    // Correct the boundary mesh face fluxes
+    phiBf += deltaPhiBf;
+}
+
+
+void Foam::fvMeshStitchers::moving::errorFaceCorrectMeshPhi
+(
+    const surfaceLabelField::Boundary& polyFacesBf,
+    surfaceVectorField& SfSf,
+    surfaceVectorField& CfSf,
+    surfaceScalarField& phi
+)
+{
+    const nonConformalBoundary& ncb = nonConformalBoundary::New(mesh());
+    const labelList origPatchIDs = ncb.allOrigPatchIDs();
+    const labelList errorPatchIDs = ncb.allErrorPatchIDs();
+
+    // Synchronise the mesh fluxes on both sides of coupled patches. Store
+    // the change made to the mesh flux as an error.
+    tmp<surfaceScalarField::Boundary> tphib =
+        synchronisedBoundaryField<scalar>(phi.boundaryField());
+    surfaceScalarField::Boundary phiErrorb
+    (
+        surfaceScalarField::Internal::null(),
+        phi.boundaryField()
+    );
+    phiErrorb = phi.boundaryField() - tphib();
+    phi.boundaryFieldRef() = tphib;
+
+    // Add the mesh flux error into the error patch so that the mesh fluxes
+    // and volume changes still match
+    forAll(mesh().boundary(), nccPatchi)
+    {
+        const fvPatch& fvp = mesh().boundary()[nccPatchi];
+
+        if (isA<nonConformalCoupledFvPatch>(fvp))
+        {
+            const nonConformalCoupledFvPatch& nccFvp =
+                refCast<const nonConformalCoupledFvPatch>(fvp);
+
+            const label origPatchi = nccFvp.origPatchID();
+            const polyPatch& origPp = mesh().boundaryMesh()[origPatchi];
+
+            const label errorPatchi = nccFvp.errorPatchID();
+
+            forAll(nccFvp, nccPatchFacei)
+            {
+                const label origPatchFacei =
+                    nccFvp.polyFaces()[nccPatchFacei] - origPp.start();
+
+                const label errorPatchFacei0 = 2*origPatchFacei;
+                const label errorPatchFacei1 = 2*origPatchFacei + 1;
+
+                fvsPatchField<scalar>& phip =
+                    phi.boundaryFieldRef()[errorPatchi];
+                phip[errorPatchFacei0] +=
+                    phiErrorb[nccPatchi][nccPatchFacei]/2;
+                phip[errorPatchFacei1] +=
+                    phiErrorb[nccPatchi][nccPatchFacei]/2;
+            }
+        }
+    }
+
+    // Create a boundary field with a mesh velocity magnitude. Take the
+    // maximum mesh velocity on either side of non-conformal-coupled faces,
+    // and then average that into the original faces. This means even
+    // stationary original faces have a velocity magnitude stored that is
+    // representative of the interface motion.
+    tmp<surfaceScalarField> tnccMeshMagUf =
+        surfaceScalarField::New
+        (
+            "nccMeshMagUf",
+            mesh(),
+            dimensionedScalar(dimVelocity, Zero)
+        );
+    surfaceScalarField::Boundary& tnccMeshMagUfb =
+        tnccMeshMagUf.ref().boundaryFieldRef();
+    forAll(mesh().boundary(), nccPatchi)
+    {
+        const fvPatch& fvp = mesh().boundary()[nccPatchi];
+
+        if (isA<nonConformalCoupledFvPatch>(fvp))
+        {
+            const nonConformalCoupledFvPatch& nccFvp =
+                refCast<const nonConformalCoupledFvPatch>(fvp);
+
+            const fvPatch& origFvp = nccFvp.origPatch();
+
+            forAll(nccFvp, nccPatchFacei)
+            {
+                const label origPatchFacei =
+                    nccFvp.polyFaces()[nccPatchFacei]
+                  - origFvp.start();
+
+                const point& origC =
+                    origFvp.patch().faceCentres()[origPatchFacei];
+                const point origC0 =
+                    origFvp.patch()[origPatchFacei]
+                   .centre(mesh().oldPoints());
+
+                tnccMeshMagUfb[nccPatchi][nccPatchFacei] =
+                    mag(origC - origC0)/mesh().time().deltaTValue();
+            }
+        }
+    }
+    tnccMeshMagUfb =
+        max
+        (
+            tnccMeshMagUfb,
+            tnccMeshMagUfb.boundaryNeighbourField()()
+        );
+    surfaceScalarField::Boundary meshMagUfb
+    (
+        surfaceScalarField::Internal::null(),
+        conformalNccBoundaryField<scalar>(tnccMeshMagUfb)
+    );
+    tnccMeshMagUf.clear();
+
+    // Resize the error patch faces so that mesh flux divided by area
+    // results in a velocity equal to the mesh velocity of the original
+    // patch face
+    forAll(origPatchIDs, i)
+    {
+        const label origPatchi = origPatchIDs[i];
+        const polyPatch& origPp = mesh().boundaryMesh()[origPatchi];
+
+        const label errorPatchi = errorPatchIDs[i];
+
+        forAll(origPp, origPatchFacei)
+        {
+            const label errorPatchFacei0 = 2*origPatchFacei;
+            const label errorPatchFacei1 = 2*origPatchFacei + 1;
+
+            const vector errorSf =
+                origPp.faceNormals()[origPatchFacei]
+               *phi.boundaryField()[errorPatchi][errorPatchFacei0]
+               /max(meshMagUfb[origPatchi][origPatchFacei], vSmall);
+
+            fvsPatchField<vector>& Sfp =
+                SfSf.boundaryFieldRef()[errorPatchi];
+            Sfp[errorPatchFacei0] += errorSf;
+            Sfp[errorPatchFacei1] -= errorSf;
+        }
+    }
+
+    // Wherever we find a movingWall-type boundary condition on an original
+    // patch, override the corresponding error patch condition to
+    // movingWallSlipVelocity
+    HashTable<volVectorField*> fields(mesh().lookupClass<volVectorField>());
+    forAllIter(typename HashTable<volVectorField*>, fields, iter)
+    {
+        typename volVectorField::Boundary& Ub = iter()->boundaryFieldRef();
+
+        forAll(origPatchIDs, i)
+        {
+            const label origPatchi = origPatchIDs[i];
+
+            typename volVectorField::Patch& origUp = Ub[origPatchi];
+
+            if
+            (
+                isA<movingWallVelocityFvPatchVectorField>(origUp)
+             || isA<movingWallSlipVelocityFvPatchVectorField>(origUp)
+            )
+            {
+                const label errorPatchi = errorPatchIDs[i];
+
+                Ub.set
+                (
+                    errorPatchi,
+                    new movingWallSlipVelocityFvPatchVectorField
+                    (
+                        mesh().boundary()[errorPatchi],
+                        *iter()
+                    )
+                );
+            }
+        }
+    }
+}
+
+
+void Foam::fvMeshStitchers::moving::correctMeshPhi
+(
+    const surfaceLabelField::Boundary& polyFacesBf,
+    surfaceVectorField& SfSf,
+    surfaceVectorField& CfSf
+)
+{
+    // Make a copy of the mesh flux
+    surfaceScalarField phi(mesh().phi());
+
+    // Set mesh fluxes on the original and cyclic faces as a proportion of
+    // the area taken from the old original faces
+    phi.boundaryFieldRef() =
+        nonConformalBoundaryField<scalar>
+        (
+            phi.boundaryField(),
+            phi.boundaryField()
+        );
+
+    // Do the same for the old time flux
+    phi.oldTime().boundaryFieldRef() =
+        nonConformalBoundaryField<scalar>
+        (
+            phi.oldTime().boundaryField(),
+            phi.oldTime().boundaryField()
+        );
+
+    // Correct the mesh flux error by modifying values on the internal
+    // faces that are edge-connected to the owner orig patches
+    if
+    (
+        mesh().foundObject<solutionControl>(solutionControl::typeName)
+     && mesh().lookupObject<solutionControl>(solutionControl::typeName)
+       .dict().lookup<Switch>("correctMeshPhi")
+    )
+    {
+        internalFaceCorrectMeshPhi(phi);
+    }
+
+    // Correct the mesh flux error by adding flux and area to the error
+    // patch faces
+    errorFaceCorrectMeshPhi(polyFacesBf, SfSf, CfSf, phi);
+
+    // Update the mesh properties
+    mesh().unconform(polyFacesBf, SfSf, CfSf, phi);
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::fvMeshStitchers::moving::moving(fvMesh& mesh)
+:
+    fvMeshStitcher(mesh)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::fvMeshStitchers::moving::~moving()
+{}
+
+
+// ************************************************************************* //
diff --git a/src/fvMeshStitchers/moving/fvMeshStitchersMoving.H b/src/fvMeshStitchers/moving/fvMeshStitchersMoving.H
new file mode 100644
index 0000000000..dfae26b591
--- /dev/null
+++ b/src/fvMeshStitchers/moving/fvMeshStitchersMoving.H
@@ -0,0 +1,148 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::fvMeshStitchers::moving
+
+Description
+    Mesh stitcher for movng meshes
+
+SourceFiles
+    fvMeshStitchersMoving.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef fvMeshStitchersMoving_H
+#define fvMeshStitchersMoving_H
+
+#include "fvMeshStitcher.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace fvMeshStitchers
+{
+
+/*---------------------------------------------------------------------------*\
+                Class fvMeshStitchers::moving Declaration
+\*---------------------------------------------------------------------------*/
+
+class moving
+:
+    public fvMeshStitcher
+{
+    // Private Member Functions
+
+        //- Return whether or not this stitcher supports a changing mesh
+        virtual bool changing() const
+        {
+            return true;
+        }
+
+        //- Initialise correction of the mesh fluxes. Create two error faces
+        //  for every original face. These are initialised to have small
+        //  opposing areas for stabilisation purposes. They will later be
+        //  enlarged and given mesh fluxes by errorFaceCorrectMeshPhi.
+        virtual void initCorrectMeshPhi
+        (
+            SurfaceFieldBoundary<label>& polyFacesBf,
+            surfaceVectorField& SfSf,
+            surfaceVectorField& CfSf
+        );
+
+        //- Get a set of all the cells that are edge-connected to the
+        //  owner-orig patches. This is the sub-set in which mesh phi gets
+        //  corrected.
+        labelHashSet ownerCoupledCellSet();
+
+        // Correct the mismatch in mesh flux across non-conformal couplings by
+        // synchronising as much as possible without affecting the total volume
+        // change. Synchronise asymmetrically, so that the owner patch takes
+        // the neighbour value. Doing this creates a volume conservation error
+        // in the owner-adjacent cells. Remove this by solving for a potential
+        // to correct the mesh fluxes across the faces that are edge-connected
+        // to the owner patches.
+        //
+        // This process creates a very smooth and well behaved result. It
+        // cannot fully correct the mesh flux mismatch if the error does not
+        // globally conserve volume. In that case, errorFaceCorrectMeshPhi is
+        // also needed. Doing this correction first, however, vastly reduces
+        // the noise introduced by errorFaceCorrectMeshPhi.
+        //
+        void internalFaceCorrectMeshPhi(surfaceScalarField& phi);
+
+        //- Correct the mismatch in the mesh flux by synchronising
+        //  symmetrically across across non-conformal couplings. Compensate for
+        //  any error that this creates by enlarging and adding mesh flux to
+        //  the error faces.
+        //
+        //  This correction procedure can result in significant noise being
+        //  introduced to the system. This is compensated by doing
+        //  internalFaceCorrectMeshPhi first, which acts to smooth and reduce
+        //  (and sometimes remove entirely) changes to the error faces.
+        //
+        void errorFaceCorrectMeshPhi
+        (
+            const SurfaceFieldBoundary<label>& polyFacesBf,
+            surfaceVectorField& SfSf,
+            surfaceVectorField& CfSf,
+            surfaceScalarField& phi
+        );
+
+        //- Correct the mesh fluxes
+        virtual void correctMeshPhi
+        (
+            const SurfaceFieldBoundary<label>& polyFacesBf,
+            surfaceVectorField& SfSf,
+            surfaceVectorField& CfSf
+        );
+
+
+public:
+
+    //- Runtime type information
+    TypeName("moving");
+
+
+    // Constructors
+
+        //- Construct from fvMesh
+        explicit moving(fvMesh&);
+
+
+    //- Destructor
+    virtual ~moving();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace fvMeshStitchers
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/fvMeshTopoChangers/Make/options b/src/fvMeshTopoChangers/Make/options
index 966b56964d..c452440ec0 100644
--- a/src/fvMeshTopoChangers/Make/options
+++ b/src/fvMeshTopoChangers/Make/options
@@ -8,4 +8,5 @@ LIB_LIBS = \
     -ltriSurface \
     -lmeshTools \
     -ldynamicMesh \
-    -lfiniteVolume
+    -lfiniteVolume \
+    -lfvMeshStitchers
diff --git a/src/fvMotionSolver/motionDiffusivity/inverseDistance/inverseDistanceDiffusivity.C b/src/fvMotionSolver/motionDiffusivity/inverseDistance/inverseDistanceDiffusivity.C
index 0766c1829c..bc9d0b6e8c 100644
--- a/src/fvMotionSolver/motionDiffusivity/inverseDistance/inverseDistanceDiffusivity.C
+++ b/src/fvMotionSolver/motionDiffusivity/inverseDistance/inverseDistanceDiffusivity.C
@@ -88,6 +88,7 @@ Foam::inverseDistanceDiffusivity::operator()() const
         (
             mesh(),
             mesh().boundaryMesh().patchSet(patchNames_),
+            -vGreat,
             y
         );
     }
diff --git a/src/fvMotionSolver/motionDiffusivity/inverseFaceDistance/inverseFaceDistanceDiffusivity.C b/src/fvMotionSolver/motionDiffusivity/inverseFaceDistance/inverseFaceDistanceDiffusivity.C
index 1d4ead34d6..217b2cc210 100644
--- a/src/fvMotionSolver/motionDiffusivity/inverseFaceDistance/inverseFaceDistanceDiffusivity.C
+++ b/src/fvMotionSolver/motionDiffusivity/inverseFaceDistance/inverseFaceDistanceDiffusivity.C
@@ -87,6 +87,7 @@ Foam::inverseFaceDistanceDiffusivity::operator()() const
         (
             mesh(),
             patchIDs,
+            -vGreat,
             y
         );
 
diff --git a/src/lagrangian/DSMC/parcels/Templates/DSMCParcel/DSMCParcel.C b/src/lagrangian/DSMC/parcels/Templates/DSMCParcel/DSMCParcel.C
index fe94cef5cb..31311935a5 100644
--- a/src/lagrangian/DSMC/parcels/Templates/DSMCParcel/DSMCParcel.C
+++ b/src/lagrangian/DSMC/parcels/Templates/DSMCParcel/DSMCParcel.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -40,8 +40,8 @@ bool Foam::DSMCParcel<ParcelType>::move
     typename TrackCloudType::parcelType& p =
         static_cast<typename TrackCloudType::parcelType&>(*this);
 
-    td.switchProcessor = false;
     td.keepParticle = true;
+    td.sendToProc = -1;
 
     const polyMesh& mesh = cloud.pMesh();
 
@@ -51,7 +51,7 @@ bool Foam::DSMCParcel<ParcelType>::move
     // needs to retain its 3D value for collision purposes.
     vector Utracking = U_;
 
-    while (td.keepParticle && !td.switchProcessor && p.stepFraction() < 1)
+    while (td.keepParticle && td.sendToProc == -1 && p.stepFraction() < 1)
     {
         Utracking = U_;
 
@@ -70,26 +70,6 @@ bool Foam::DSMCParcel<ParcelType>::move
 }
 
 
-template<class ParcelType>
-template<class TrackCloudType>
-bool Foam::DSMCParcel<ParcelType>::hitPatch(TrackCloudType&, trackingData&)
-{
-    return false;
-}
-
-
-template<class ParcelType>
-template<class TrackCloudType>
-void Foam::DSMCParcel<ParcelType>::hitProcessorPatch
-(
-    TrackCloudType&,
-    trackingData& td
-)
-{
-    td.switchProcessor = true;
-}
-
-
 template<class ParcelType>
 template<class TrackCloudType>
 void Foam::DSMCParcel<ParcelType>::hitWallPatch
diff --git a/src/lagrangian/DSMC/parcels/Templates/DSMCParcel/DSMCParcel.H b/src/lagrangian/DSMC/parcels/Templates/DSMCParcel/DSMCParcel.H
index 70d89b3a85..d2f6e6b5b7 100644
--- a/src/lagrangian/DSMC/parcels/Templates/DSMCParcel/DSMCParcel.H
+++ b/src/lagrangian/DSMC/parcels/Templates/DSMCParcel/DSMCParcel.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -259,16 +259,6 @@ public:
 
         // Patch interactions
 
-            //- Overridable function to handle the particle hitting a patch
-            //  Executed before other patch-hitting functions
-            template<class TrackCloudType>
-            bool hitPatch(TrackCloudType&, trackingData&);
-
-            //- Overridable function to handle the particle hitting a
-            //  processorPatch
-            template<class TrackCloudType>
-            void hitProcessorPatch(TrackCloudType&, trackingData&);
-
             //- Overridable function to handle the particle hitting a wallPatch
             template<class TrackCloudType>
             void hitWallPatch(TrackCloudType&, trackingData&);
diff --git a/src/lagrangian/basic/Cloud/Cloud.C b/src/lagrangian/basic/Cloud/Cloud.C
index b5a4a7d388..fdc17f3093 100644
--- a/src/lagrangian/basic/Cloud/Cloud.C
+++ b/src/lagrangian/basic/Cloud/Cloud.C
@@ -32,6 +32,7 @@ License
 #include "OFstream.H"
 #include "wallPolyPatch.H"
 #include "cyclicAMIPolyPatch.H"
+#include "nonConformalCyclicPolyPatch.H"
 
 // * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
 
@@ -61,6 +62,125 @@ void Foam::Cloud<ParticleType>::checkPatches() const
 }
 
 
+template<class ParticleType>
+Foam::labelList Foam::Cloud<ParticleType>::patchNbrProc
+(
+    const polyMesh& pMesh
+)
+{
+    const polyBoundaryMesh& pbm = pMesh.boundaryMesh();
+
+    labelList result(pbm.size(), -1);
+
+    if (Pstream::parRun())
+    {
+        forAll(pbm, patchi)
+        {
+            if (isA<processorPolyPatch>(pbm[patchi]))
+            {
+                const processorPolyPatch& ppp =
+                    refCast<const processorPolyPatch>(pbm[patchi]);
+
+                result[patchi] = ppp.neighbProcNo();
+            }
+        }
+    }
+
+    return result;
+}
+
+
+template<class ParticleType>
+Foam::labelList Foam::Cloud<ParticleType>::patchNbrProcPatch
+(
+    const polyMesh& pMesh
+)
+{
+    const polyBoundaryMesh& pbm = pMesh.boundaryMesh();
+
+    labelList result(pbm.size(), -1);
+
+    if (Pstream::parRun())
+    {
+        PstreamBuffers pBufs(Pstream::commsTypes::nonBlocking);
+
+        forAll(pbm, patchi)
+        {
+            if (isA<processorPolyPatch>(pbm[patchi]))
+            {
+                const processorPolyPatch& ppp =
+                    refCast<const processorPolyPatch>(pbm[patchi]);
+
+                UOPstream(ppp.neighbProcNo(), pBufs)()
+                  << ppp.index();
+            }
+        }
+
+        pBufs.finishedSends();
+
+        forAll(pbm, patchi)
+        {
+            if (isA<processorPolyPatch>(pbm[patchi]))
+            {
+                const processorPolyPatch& ppp =
+                    refCast<const processorPolyPatch>(pbm[patchi]);
+
+                UIPstream(ppp.neighbProcNo(), pBufs)()
+                  >> result[patchi];
+            }
+        }
+    }
+
+    return result;
+}
+
+
+template<class ParticleType>
+Foam::labelListList Foam::Cloud<ParticleType>::patchNonConformalCyclicPatches
+(
+    const polyMesh& pMesh
+)
+{
+    const polyBoundaryMesh& pbm = pMesh.boundaryMesh();
+
+    labelListList result(pbm.size(), labelList());
+
+    forAll(pbm, patchi)
+    {
+        if (isA<nonConformalCyclicPolyPatch>(pbm[patchi]))
+        {
+            const nonConformalCyclicPolyPatch& nccPp =
+                refCast<const nonConformalCyclicPolyPatch>(pbm[patchi]);
+
+            result[nccPp.origPatchID()].append(patchi);
+        }
+    }
+
+    return result;
+}
+
+
+template<class ParticleType>
+void Foam::Cloud<ParticleType>::storeRays() const
+{
+    const polyBoundaryMesh& pbm = polyMesh_.boundaryMesh();
+
+    forAll(patchNonConformalCyclicPatches_, patchi)
+    {
+        forAll(patchNonConformalCyclicPatches_[patchi], i)
+        {
+            const label nccPatchi =
+                patchNonConformalCyclicPatches_[patchi][i];
+
+            const nonConformalCyclicPolyPatch& nccPp =
+                refCast<const nonConformalCyclicPolyPatch>(pbm[nccPatchi]);
+
+            if (nccPp.owner()) nccPp.rays();
+        }
+    }
+}
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class ParticleType>
@@ -74,6 +194,9 @@ Foam::Cloud<ParticleType>::Cloud
     cloud(pMesh, cloudName),
     IDLList<ParticleType>(),
     polyMesh_(pMesh),
+    patchNbrProc_(patchNbrProc(pMesh)),
+    patchNbrProcPatch_(patchNbrProcPatch(pMesh)),
+    patchNonConformalCyclicPatches_(patchNonConformalCyclicPatches(pMesh)),
     globalPositionsPtr_()
 {
     checkPatches();
@@ -145,26 +268,11 @@ void Foam::Cloud<ParticleType>::move
     const scalar trackTime
 )
 {
-    const polyBoundaryMesh& pbm = pMesh().boundaryMesh();
-    const globalMeshData& pData = polyMesh_.globalData();
+    // Clear the global positions as these are about to change
+    globalPositionsPtr_.clear();
 
-    // Which patches are processor patches
-    const labelList& procPatches = pData.processorPatches();
-
-    // Indexing of equivalent patch on neighbour processor into the
-    // procPatches list on the neighbour
-    const labelList& procPatchNeighbours = pData.processorPatchNeighbours();
-
-    // Which processors this processor is connected to
-    const labelList& neighbourProcs = pData.procNbrProcs()[Pstream::myProcNo()];
-
-    // Indexing from the processor number into the neighbourProcs list
-    labelList neighbourProcIndices(Pstream::nProcs(), -1);
-
-    forAll(neighbourProcs, i)
-    {
-        neighbourProcIndices[neighbourProcs[i]] = i;
-    }
+    // Ensure rays are available for non conformal transfers
+    storeRays();
 
     // Initialise the stepFraction moved for the particles
     forAllIter(typename Cloud<ParticleType>, *this, pIter)
@@ -172,28 +280,21 @@ void Foam::Cloud<ParticleType>::move
         pIter().reset(0);
     }
 
-    // List of lists of particles to be transferred for all of the
-    // neighbour processors
-    List<IDLList<ParticleType>> particleTransferLists(neighbourProcs.size());
-
-    // List of destination processorPatches indices for all of the
-    // neighbour processors
-    List<DynamicList<label>> patchIndexTransferLists(neighbourProcs.size());
-
-    // Allocate transfer buffers
+    // Create transfer buffers
     PstreamBuffers pBufs(Pstream::commsTypes::nonBlocking);
 
-    // Clear the global positions as there are about to change
-    globalPositionsPtr_.clear();
+    // Create lists of particles and patch indices to transfer
+    List<IDLList<ParticleType>> sendParticles(Pstream::nProcs());
+    List<DynamicList<label>> sendPatchIndices(Pstream::nProcs());
 
     // While there are particles to transfer
     while (true)
     {
         // Clear the transfer lists
-        particleTransferLists = IDLList<ParticleType>();
-        forAll(patchIndexTransferLists, i)
+        forAll(sendParticles, proci)
         {
-            patchIndexTransferLists[i].clear();
+            sendParticles[proci].clear();
+            sendPatchIndices[proci].clear();
         }
 
         // Loop over all particles
@@ -205,18 +306,12 @@ void Foam::Cloud<ParticleType>::move
             bool keepParticle = p.move(cloud, td, trackTime);
 
             // If the particle is to be kept
-            // (i.e. it hasn't passed through an inlet or outlet)
             if (keepParticle)
             {
-                if (td.switchProcessor)
+                if (td.sendToProc != -1)
                 {
                     #ifdef FULLDEBUG
-                    if
-                    (
-                        !Pstream::parRun()
-                     || !p.onBoundaryFace()
-                     || procPatchNeighbours[p.patch()] < 0
-                    )
+                    if (!Pstream::parRun() || !p.onBoundaryFace())
                     {
                         FatalErrorInFunction
                             << "Switch processor flag is true when no parallel "
@@ -225,24 +320,11 @@ void Foam::Cloud<ParticleType>::move
                     }
                     #endif
 
-                    const label patchi = p.patch();
+                    p.prepareForParallelTransfer(td);
 
-                    const label n = neighbourProcIndices
-                    [
-                        refCast<const processorPolyPatch>
-                        (
-                            pbm[patchi]
-                        ).neighbProcNo()
-                    ];
+                    sendParticles[td.sendToProc].append(this->remove(&p));
 
-                    p.prepareForParallelTransfer();
-
-                    particleTransferLists[n].append(this->remove(&p));
-
-                    patchIndexTransferLists[n].append
-                    (
-                        procPatchNeighbours[patchi]
-                    );
+                    sendPatchIndices[td.sendToProc].append(td.sendToPatch);
                 }
             }
             else
@@ -251,67 +333,56 @@ void Foam::Cloud<ParticleType>::move
             }
         }
 
+        // If running in serial then everything has been moved, so finish
         if (!Pstream::parRun())
         {
             break;
         }
 
-
         // Clear transfer buffers
         pBufs.clear();
 
         // Stream into send buffers
-        forAll(particleTransferLists, i)
+        forAll(sendParticles, proci)
         {
-            if (particleTransferLists[i].size())
+            if (sendParticles[proci].size())
             {
-                UOPstream particleStream
-                (
-                    neighbourProcs[i],
-                    pBufs
-                );
+                UOPstream particleStream(proci, pBufs);
 
                 particleStream
-                    << patchIndexTransferLists[i]
-                    << particleTransferLists[i];
+                    << sendPatchIndices[proci]
+                    << sendParticles[proci];
             }
         }
 
+        // Start sending. Sets number of bytes transferred.
+        labelList receiveSizes(Pstream::nProcs());
+        pBufs.finishedSends(receiveSizes);
 
-        // Start sending. Sets number of bytes transferred
-        labelList allNTrans(Pstream::nProcs());
-        pBufs.finishedSends(allNTrans);
-
-
+        // Determine if any particles were transferred. If not, then finish.
         bool transferred = false;
-
-        forAll(allNTrans, i)
+        forAll(receiveSizes, proci)
         {
-            if (allNTrans[i])
+            if (receiveSizes[proci])
             {
                 transferred = true;
                 break;
             }
         }
         reduce(transferred, orOp<bool>());
-
         if (!transferred)
         {
             break;
         }
 
-        // Retrieve from receive buffers
-        forAll(neighbourProcs, i)
+        // Retrieve from receive buffers and add into the cloud
+        forAll(receiveSizes, proci)
         {
-            label neighbProci = neighbourProcs[i];
-
-            label nRec = allNTrans[neighbProci];
-
-            if (nRec)
+            if (receiveSizes[proci])
             {
-                UIPstream particleStream(neighbProci, pBufs);
+                UIPstream particleStream(proci, pBufs);
 
-                labelList receivePatchIndex(particleStream);
+                const labelList receivePatchIndices(particleStream);
 
                 IDLList<ParticleType> newParticles
                 (
@@ -319,17 +390,19 @@ void Foam::Cloud<ParticleType>::move
                     typename ParticleType::iNew(polyMesh_)
                 );
 
-                label pI = 0;
+                label i = 0;
 
-                forAllIter(typename Cloud<ParticleType>, newParticles, newpIter)
+                forAllIter(typename Cloud<ParticleType>, newParticles, iter)
                 {
-                    ParticleType& newp = newpIter();
+                    const label patchi = receivePatchIndices[i ++];
 
-                    label patchi = procPatches[receivePatchIndex[pI++]];
+                    ParticleType& p = iter();
 
-                    newp.correctAfterParallelTransfer(patchi, td);
+                    td.sendToPatch = patchi;
 
-                    addParticle(newParticles.remove(&newp));
+                    p.correctAfterParallelTransfer(td);
+
+                    addParticle(newParticles.remove(&p));
                 }
             }
         }
diff --git a/src/lagrangian/basic/Cloud/Cloud.H b/src/lagrangian/basic/Cloud/Cloud.H
index 4cc603aad4..ace6e28ecd 100644
--- a/src/lagrangian/basic/Cloud/Cloud.H
+++ b/src/lagrangian/basic/Cloud/Cloud.H
@@ -78,6 +78,16 @@ class Cloud
         //- Reference to the mesh
         const polyMesh& polyMesh_;
 
+        //- Map from patch index to the neighbouring processor index
+        const labelList patchNbrProc_;
+
+        //- Map from patch index to the corresponding patch index on the
+        //  neighbouring processor
+        const labelList patchNbrProcPatch_;
+
+        //- Map from patch index to connected non-conformal cyclics
+        const labelListList patchNonConformalCyclicPatches_;
+
         //- Temporary storage for the global particle positions
         mutable autoPtr<vectorField> globalPositionsPtr_;
 
@@ -96,6 +106,19 @@ class Cloud
         //- Write cloud properties dictionary
         void writeCloudUniformProperties() const;
 
+        //- Map from patch index to the neighbouring processor index
+        static labelList patchNbrProc(const polyMesh&);
+
+        //- Map from patch index to the corresponding patch index on the
+        //  neighbouring processor
+        static labelList patchNbrProcPatch(const polyMesh&);
+
+        //- Map from patch index to connected non-conformal cyclics
+        static labelListList patchNonConformalCyclicPatches(const polyMesh&);
+
+        //- Store rays necessary for non conformal cyclic transfer
+        void storeRays() const;
+
 
 public:
 
@@ -145,6 +168,25 @@ public:
                 return polyMesh_;
             }
 
+            //- Map from patch index to the neighbouring processor index
+            const labelList& patchNbrProc() const
+            {
+                return patchNbrProc_;
+            }
+
+            //- Map from patch index to the corresponding patch index on the
+            //  neighbouring processor
+            const labelList& patchNbrProcPatch() const
+            {
+                return patchNbrProcPatch_;
+            }
+
+            //- Return map from patch index to connected non-conformal cyclics
+            const labelListList& patchNonConformalCyclicPatches() const
+            {
+                return patchNonConformalCyclicPatches_;
+            }
+
             //- Return the number of particles in the cloud
             label size() const
             {
diff --git a/src/lagrangian/basic/Cloud/CloudIO.C b/src/lagrangian/basic/Cloud/CloudIO.C
index ee665d2799..841ef24552 100644
--- a/src/lagrangian/basic/Cloud/CloudIO.C
+++ b/src/lagrangian/basic/Cloud/CloudIO.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2021 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -149,6 +149,9 @@ Foam::Cloud<ParticleType>::Cloud
 :
     cloud(pMesh, cloudName),
     polyMesh_(pMesh),
+    patchNbrProc_(patchNbrProc(pMesh)),
+    patchNbrProcPatch_(patchNbrProcPatch(pMesh)),
+    patchNonConformalCyclicPatches_(patchNonConformalCyclicPatches(pMesh)),
     globalPositionsPtr_()
 {
     checkPatches();
diff --git a/src/lagrangian/basic/particle/particle.C b/src/lagrangian/basic/particle/particle.C
index 1bf886d38c..37ce942771 100644
--- a/src/lagrangian/basic/particle/particle.C
+++ b/src/lagrangian/basic/particle/particle.C
@@ -1065,21 +1065,58 @@ void Foam::particle::transformProperties(const transformer&)
 {}
 
 
-void Foam::particle::prepareForParallelTransfer()
-{
-    // Convert the face index to be local to the processor patch
-    facei_ = mesh_.boundaryMesh()[patch()].whichFace(facei_);
-}
-
-
-void Foam::particle::correctAfterParallelTransfer
+void Foam::particle::prepareForParallelTransfer
 (
-    const label patchi,
     trackingData& td
 )
 {
-    const coupledPolyPatch& ppp =
-        refCast<const coupledPolyPatch>(mesh_.boundaryMesh()[patchi]);
+    if (td.sendFromPatch == patch())
+    {
+        prepareForProcessorTransfer(td);
+    }
+    else
+    {
+        prepareForNonConformalCyclicTransfer
+        (
+            td.sendFromPatch,
+            td.sendToPatchFace
+        );
+    }
+}
+
+
+void Foam::particle::correctAfterParallelTransfer(trackingData& td)
+{
+    const polyPatch& pp = mesh_.boundaryMesh()[td.sendToPatch];
+
+    if (isA<processorPolyPatch>(pp))
+    {
+        correctAfterProcessorTransfer(td);
+    }
+    else if (isA<nonConformalCyclicPolyPatch>(pp))
+    {
+        correctAfterNonConformalCyclicTransfer(td.sendToPatch);
+    }
+    else
+    {
+        FatalErrorInFunction
+            << "Transfer patch type not recognised"
+            << exit(FatalError);
+    }
+}
+
+
+void Foam::particle::prepareForProcessorTransfer(trackingData& td)
+{
+    // Store the local patch face in the face index
+    facei_ = td.sendToPatchFace;
+}
+
+
+void Foam::particle::correctAfterProcessorTransfer(trackingData& td)
+{
+    const processorPolyPatch& ppp =
+        refCast<const processorPolyPatch>(mesh_.boundaryMesh()[td.sendToPatch]);
 
     if (ppp.transform().transformsPosition())
     {
@@ -1091,18 +1128,85 @@ void Foam::particle::correctAfterParallelTransfer
     facei_ += ppp.start();
     tetFacei_ = facei_;
 
-    // Faces either side of a coupled patch are numbered in opposite directions
-    // as their normals both point away from their connected cells. The tet
-    // point therefore counts in the opposite direction from the base point.
+    // Faces either side of a coupled patch are numbered in opposite
+    // directions as their normals both point away from their connected
+    // cells. The tet point therefore counts in the opposite direction from
+    // the base point.
     tetPti_ = mesh_.faces()[tetFacei_].size() - 1 - tetPti_;
 
-    // Reflect to account for the change of triangle orientation in the new cell
+    // Reflect to account for the change of tri orientation in the new cell
     reflect();
 
-    // Note that the position does not need transforming explicitly. The face-
-    // triangle on the receive patch is the transformation of the one on the
-    // send patch, so whilst the barycentric coordinates remain the same, the
-    // change of triangle implicitly transforms the position.
+    // Note that the position does not need transforming explicitly. The
+    // face-triangle on the receive patch is the transformation of the one
+    // on the send patch, so whilst the barycentric coordinates remain the
+    // same, the change of triangle implicitly transforms the position.
+}
+
+
+void Foam::particle::prepareForNonConformalCyclicTransfer
+(
+    const label sendFromPatch,
+    const label sendToPatchFace
+)
+{
+    const nonConformalCyclicPolyPatch& nccpp =
+        static_cast<const nonConformalCyclicPolyPatch&>
+        (mesh_.boundaryMesh()[sendFromPatch]);
+
+    // Get the transformed position
+    const vector pos = nccpp.transform().invTransformPosition(position());
+
+    // Store the position in the barycentric data
+    coordinates_ = barycentric(1 - cmptSum(pos), pos.x(), pos.y(), pos.z());
+
+    // Break the topology
+    celli_ = -1;
+    tetFacei_ = -1;
+    tetPti_ = -1;
+
+    // Store the local patch face in the face index
+    facei_ = sendToPatchFace;
+
+    // Transform the properties
+    if (nccpp.transform().transformsPosition())
+    {
+        transformProperties(nccpp.nbrPatch().transform());
+    }
+}
+
+
+void Foam::particle::correctAfterNonConformalCyclicTransfer
+(
+    const label sendToPatch
+)
+{
+    const nonConformalCyclicPolyPatch& nccpp =
+        static_cast<const nonConformalCyclicPolyPatch&>
+        (mesh_.boundaryMesh()[sendToPatch]);
+
+    // Get the position from the barycentric data
+    const vector receivePos
+    (
+        coordinates_.b(),
+        coordinates_.c(),
+        coordinates_.d()
+    );
+
+    // Locate the particle on the receiving side
+    locate
+    (
+        receivePos,
+        mesh_.faceOwner()[facei_ + nccpp.origPatch().start()],
+        false,
+        "Particle crossed between " + nonConformalCyclicPolyPatch::typeName +
+        " patches " + nccpp.name() + " and " + nccpp.nbrPatch().name() +
+        " to a location outside of the mesh."
+    );
+
+    // The particle must remain associated with a face for the tracking to
+    // register as incomplete
+    facei_ = tetFacei_;
 }
 
 
@@ -1118,7 +1222,6 @@ void Foam::particle::prepareForInteractionListReferral
     celli_ = -1;
     tetFacei_ = -1;
     tetPti_ = -1;
-    facei_ = -1;
 
     // Store the position in the barycentric data
     coordinates_ = barycentric(1 - cmptSum(pos), pos.x(), pos.y(), pos.z());
@@ -1140,7 +1243,6 @@ void Foam::particle::correctAfterInteractionListReferral(const label celli)
     celli_ = celli;
     tetFacei_ = mesh_.cells()[celli_][0];
     tetPti_ = 1;
-    facei_ = -1;
 
     // Get the reverse transform and directly set the coordinates from the
     // position. This isn't likely to be correct; the particle is probably not
diff --git a/src/lagrangian/basic/particle/particle.H b/src/lagrangian/basic/particle/particle.H
index bba2eeea71..4f88c3ceb2 100644
--- a/src/lagrangian/basic/particle/particle.H
+++ b/src/lagrangian/basic/particle/particle.H
@@ -106,16 +106,32 @@ public:
 
         // Public data
 
-            //- Flag to switch processor
-            bool switchProcessor;
-
             //- Flag to indicate whether to keep particle (false = delete)
             bool keepParticle;
 
+            //- Processor to send the particle to. -1 indicates that this
+            //  particle is not to be transferred.
+            label sendToProc;
+
+            //- Patch from which to send the particle
+            label sendFromPatch;
+
+            //- Patch to which to send the particle
+            label sendToPatch;
+
+            //- Patch face to which to send the particle
+            label sendToPatchFace;
+
 
         // Constructor
         template <class TrackCloudType>
         trackingData(const TrackCloudType& cloud)
+        :
+            keepParticle(false),
+            sendToProc(-1),
+            sendFromPatch(-1),
+            sendToPatch(-1),
+            sendToPatchFace(-1)
         {}
     };
 
@@ -353,6 +369,18 @@ protected:
             trackingData& td
         );
 
+        //- Overridable function to handle the particle hitting an
+        //  nonConformalCyclicPolyPatch
+        template<class TrackCloudType>
+        bool hitNonConformalCyclicPatch
+        (
+            const vector& displacement,
+            const scalar fraction,
+            const label patchi,
+            TrackCloudType& cloud,
+            trackingData& td
+        );
+
         //- Overridable function to handle the particle hitting a processorPatch
         template<class TrackCloudType>
         void hitProcessorPatch(TrackCloudType&, trackingData&);
@@ -637,27 +665,53 @@ public:
         virtual void transformProperties(const transformer&);
 
 
-    // Parallel transfer
+    // Transfers
 
-        //- Convert global addressing to the processor patch local equivalents
-        void prepareForParallelTransfer();
+        //- Make changes prior to a parallel transfer. Runs either processor or
+        //  nonConformalCyclic variant below.
+        void prepareForParallelTransfer(trackingData& td);
 
-        //- Convert processor patch addressing to the global equivalents
-        //  and set the celli to the face-neighbour
-        void correctAfterParallelTransfer(const label patchi, trackingData& td);
+        //- Make changes following a parallel transfer. Runs either processor
+        //  or nonConformalCyclic variant below.
+        void correctAfterParallelTransfer(trackingData& td);
+
+        //- Make changes prior to a transfer across a processor boundary.
+        //  Stores the local patch face index (in facei_) so that the mesh face
+        //  index can be determined on the other side.
+        void prepareForProcessorTransfer(trackingData& td);
+
+        //- Make changes following a transfer across a processor boundary.
+        //  Converts the stored patch index to a mesh index. Accounts for
+        //  the receiving face being reversed relative to the sending face.
+        void correctAfterProcessorTransfer(trackingData& td);
+
+        //- Make changes prior to a transfer across a non conformal cyclic
+        //  boundary. Stores the receiving patch face (in facei_). Breaks the
+        //  topology and stores the cartesian position.
+        void prepareForNonConformalCyclicTransfer
+        (
+            const label sendToPatch,
+            const label sendToPatchFace
+        );
+
+        //- Make changes following a transfer across a non conformal cyclic
+        //  boundary. Locates the particle using the stored face index and
+        //  cartesian position.
+        void correctAfterNonConformalCyclicTransfer(const label sendToPatch);
 
 
     // Interaction list referral
 
-        //- Break the topology and store the particle position so that the
+        //- Break the topology and store the cartesian position so that the
         //  particle can be referred.
         void prepareForInteractionListReferral
         (
             const transformer& transform
         );
 
-        //- Correct the topology after referral. The particle may still be
-        //  outside the stored tet and therefore not track-able.
+        //- Correct the topology after referral. Locates the particle relative
+        //  to a nearby cell/tet. The particle may end up outside this cell/tet
+        //  and cannot therefore be tracked.
         void correctAfterInteractionListReferral(const label celli);
 
 
diff --git a/src/lagrangian/basic/particle/particleTemplates.C b/src/lagrangian/basic/particle/particleTemplates.C
index a2367a1275..3ad79ace70 100644
--- a/src/lagrangian/basic/particle/particleTemplates.C
+++ b/src/lagrangian/basic/particle/particleTemplates.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2021 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -30,6 +30,7 @@ License
 #include "cyclicAMIPolyPatch.H"
 #include "cyclicACMIPolyPatch.H"
 #include "cyclicRepeatAMIPolyPatch.H"
+#include "nonConformalCyclicPolyPatch.H"
 #include "processorPolyPatch.H"
 #include "symmetryPlanePolyPatch.H"
 #include "symmetryPolyPatch.H"
@@ -156,6 +157,24 @@ void Foam::particle::hitFaceNoChangeToMasterPatch
     }
     else if (onBoundaryFace())
     {
+        forAll(cloud.patchNonConformalCyclicPatches()[p.patch()], i)
+        {
+            if
+            (
+                p.hitNonConformalCyclicPatch
+                (
+                    displacement,
+                    fraction,
+                    cloud.patchNonConformalCyclicPatches()[p.patch()][i],
+                    cloud,
+                    ttd
+                )
+            )
+            {
+                return;
+            }
+        }
+
         if (!p.hitPatch(cloud, ttd))
         {
             const polyPatch& patch = mesh_.boundaryMesh()[p.patch()];
@@ -478,8 +497,77 @@ void Foam::particle::hitCyclicRepeatAMIPatch
 
 
 template<class TrackCloudType>
-void Foam::particle::hitProcessorPatch(TrackCloudType&, trackingData&)
-{}
+bool Foam::particle::hitNonConformalCyclicPatch
+(
+    const vector& displacement,
+    const scalar fraction,
+    const label patchi,
+    TrackCloudType& cloud,
+    trackingData& td
+)
+{
+    const nonConformalCyclicPolyPatch& nccpp =
+        static_cast<const nonConformalCyclicPolyPatch&>
+        (mesh_.boundaryMesh()[patchi]);
+
+    const point sendPos = this->position();
+
+    // Get the send patch data
+    vector sendNormal, sendDisplacement;
+    patchData(sendNormal, sendDisplacement);
+
+    // Project the particle through the non-conformal patch
+    point receivePos;
+    const patchToPatch::procFace receiveProcFace =
+        nccpp.ray
+        (
+            stepFractionSpan()[0] + stepFraction_*stepFractionSpan()[1],
+            nccpp.origPatch().whichFace(facei_),
+            sendPos,
+            displacement - fraction*sendDisplacement,
+            receivePos
+        );
+
+    // If we didn't hit anything then this particle is assumed to project to
+    // the orig patch, or another different non-conformal patch. Return, so
+    // these can be tried.
+    if (receiveProcFace.proci == -1) return false;
+
+    // If we are transferring between processes then mark as such and return.
+    // The cloud will handle all processor transfers as a single batch.
+    if (receiveProcFace.proci != Pstream::myProcNo())
+    {
+        td.sendFromPatch = nccpp.index();
+        td.sendToProc = receiveProcFace.proci;
+        td.sendToPatch = nccpp.nbrPatchID();
+        td.sendToPatchFace = receiveProcFace.facei;
+
+        return true;
+    }
+
+    // If both sides are on the same process, then do the local transfer
+    prepareForNonConformalCyclicTransfer
+    (
+        nccpp.index(),
+        receiveProcFace.facei
+    );
+    correctAfterNonConformalCyclicTransfer
+    (
+        nccpp.nbrPatchID()
+    );
+
+    return true;
+}
+
+
+template<class TrackCloudType>
+void Foam::particle::hitProcessorPatch(TrackCloudType& cloud, trackingData& td)
+{
+    td.sendToProc = cloud.patchNbrProc()[patch()];
+    td.sendFromPatch = patch();
+    td.sendToPatch = cloud.patchNbrProcPatch()[patch()];
+    td.sendToPatchFace = mesh().boundaryMesh()[patch()].whichFace(face());
+}
 
 
 template<class TrackCloudType>
diff --git a/src/lagrangian/molecularDynamics/molecule/molecule/molecule.C b/src/lagrangian/molecularDynamics/molecule/molecule/molecule.C
index 4f865bc255..37967fb0db 100644
--- a/src/lagrangian/molecularDynamics/molecule/molecule/molecule.C
+++ b/src/lagrangian/molecularDynamics/molecule/molecule/molecule.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -72,8 +72,8 @@ bool Foam::molecule::move
     const scalar trackTime
 )
 {
-    td.switchProcessor = false;
     td.keepParticle = true;
+    td.sendToProc = -1;
 
     const constantProperties& constProps(cloud.constProps(id_));
 
@@ -90,7 +90,7 @@ bool Foam::molecule::move
     {
         // Leapfrog tracking part
 
-        while (td.keepParticle && !td.switchProcessor && stepFraction() < 1)
+        while (td.keepParticle && td.sendToProc == -1 && stepFraction() < 1)
         {
             const scalar f = 1 - stepFraction();
             trackToAndHitFace(f*trackTime*v_, f, cloud, td);
@@ -227,18 +227,6 @@ void Foam::molecule::setSiteSizes(label size)
 }
 
 
-bool Foam::molecule::hitPatch(moleculeCloud&, trackingData&)
-{
-    return false;
-}
-
-
-void Foam::molecule::hitProcessorPatch(moleculeCloud&, trackingData& td)
-{
-    td.switchProcessor = true;
-}
-
-
 void Foam::molecule::hitWallPatch(moleculeCloud&, trackingData&)
 {
     const vector nw = normal();
diff --git a/src/lagrangian/molecularDynamics/molecule/molecule/molecule.H b/src/lagrangian/molecularDynamics/molecule/molecule/molecule.H
index 5acc000cf1..45a505d923 100644
--- a/src/lagrangian/molecularDynamics/molecule/molecule/molecule.H
+++ b/src/lagrangian/molecularDynamics/molecule/molecule/molecule.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -384,13 +384,6 @@ public:
 
     // Member Operators
 
-        //- Overridable function to handle the particle hitting a patch
-        //  Executed before other patch-hitting functions
-        bool hitPatch(moleculeCloud& cloud, trackingData& td);
-
-        //- Overridable function to handle the particle hitting a processorPatch
-        void hitProcessorPatch(moleculeCloud& cloud, trackingData& td);
-
         //- Overridable function to handle the particle hitting a wallPatch
         void hitWallPatch(moleculeCloud& cloud, trackingData& td);
 
diff --git a/src/lagrangian/parcel/parcels/Templates/CollidingParcel/CollidingParcel.C b/src/lagrangian/parcel/parcels/Templates/CollidingParcel/CollidingParcel.C
index 08bc7d2c09..ddf75c92f8 100644
--- a/src/lagrangian/parcel/parcels/Templates/CollidingParcel/CollidingParcel.C
+++ b/src/lagrangian/parcel/parcels/Templates/CollidingParcel/CollidingParcel.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -82,7 +82,7 @@ bool Foam::CollidingParcel<ParcelType>::move
             p.angularMomentum() += 0.5*trackTime*p.torque();
 
             td.keepParticle = true;
-            td.switchProcessor = false;
+            td.sendToProc = -1;
 
             break;
         }
diff --git a/src/lagrangian/parcel/parcels/Templates/MPPICParcel/MPPICParcel.C b/src/lagrangian/parcel/parcels/Templates/MPPICParcel/MPPICParcel.C
index 8668c0022e..4eeb19d691 100644
--- a/src/lagrangian/parcel/parcels/Templates/MPPICParcel/MPPICParcel.C
+++ b/src/lagrangian/parcel/parcels/Templates/MPPICParcel/MPPICParcel.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2013-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2013-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -78,7 +78,7 @@ bool Foam::MPPICParcel<ParcelType>::move
                 cloud.dampingModel().velocityCorrection(p, trackTime);
 
             td.keepParticle = true;
-            td.switchProcessor = false;
+            td.sendToProc = -1;
 
             break;
         }
@@ -88,7 +88,7 @@ bool Foam::MPPICParcel<ParcelType>::move
                 cloud.packingModel().velocityCorrection(p, trackTime);
 
             td.keepParticle = true;
-            td.switchProcessor = false;
+            td.sendToProc = -1;
 
             break;
         }
diff --git a/src/lagrangian/parcel/parcels/Templates/MomentumParcel/MomentumParcel.C b/src/lagrangian/parcel/parcels/Templates/MomentumParcel/MomentumParcel.C
index 34e78908a3..6e5448ea38 100644
--- a/src/lagrangian/parcel/parcels/Templates/MomentumParcel/MomentumParcel.C
+++ b/src/lagrangian/parcel/parcels/Templates/MomentumParcel/MomentumParcel.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2021 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -287,13 +287,13 @@ bool Foam::MomentumParcel<ParcelType>::move
     typename TrackCloudType::parcelType::trackingData& ttd =
         static_cast<typename TrackCloudType::parcelType::trackingData&>(td);
 
-    ttd.switchProcessor = false;
     ttd.keepParticle = true;
+    td.sendToProc = -1;
 
     const scalarField& cellLengthScale = cloud.cellLengthScale();
     const scalar maxCo = cloud.solution().maxCo();
 
-    while (ttd.keepParticle && !ttd.switchProcessor && p.stepFraction() < 1)
+    while (ttd.keepParticle && ttd.sendToProc == -1 && p.stepFraction() < 1)
     {
         // Cache the current position, cell and step-fraction
         const point start = p.position();
@@ -401,18 +401,6 @@ bool Foam::MomentumParcel<ParcelType>::hitPatch
 }
 
 
-template<class ParcelType>
-template<class TrackCloudType>
-void Foam::MomentumParcel<ParcelType>::hitProcessorPatch
-(
-    TrackCloudType&,
-    trackingData& td
-)
-{
-    td.switchProcessor = true;
-}
-
-
 template<class ParcelType>
 template<class TrackCloudType>
 void Foam::MomentumParcel<ParcelType>::hitWallPatch
diff --git a/src/lagrangian/parcel/parcels/Templates/MomentumParcel/MomentumParcel.H b/src/lagrangian/parcel/parcels/Templates/MomentumParcel/MomentumParcel.H
index 738f0860d2..95a387d67c 100644
--- a/src/lagrangian/parcel/parcels/Templates/MomentumParcel/MomentumParcel.H
+++ b/src/lagrangian/parcel/parcels/Templates/MomentumParcel/MomentumParcel.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -584,11 +584,6 @@ public:
             template<class TrackCloudType>
             bool hitPatch(TrackCloudType& cloud, trackingData& td);
 
-            //- Overridable function to handle the particle hitting a
-            //  processorPatch
-            template<class TrackCloudType>
-            void hitProcessorPatch(TrackCloudType& cloud, trackingData& td);
-
             //- Overridable function to handle the particle hitting a wallPatch
             template<class TrackCloudType>
             void hitWallPatch(TrackCloudType& cloud, trackingData& td);
diff --git a/src/lagrangian/solidParticle/solidParticle.C b/src/lagrangian/solidParticle/solidParticle.C
index fe720fa9bb..3ccbc5f368 100644
--- a/src/lagrangian/solidParticle/solidParticle.C
+++ b/src/lagrangian/solidParticle/solidParticle.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -42,10 +42,10 @@ bool Foam::solidParticle::move
     const scalar trackTime
 )
 {
-    td.switchProcessor = false;
     td.keepParticle = true;
+    td.sendToProc = -1;
 
-    while (td.keepParticle && !td.switchProcessor && stepFraction() < 1)
+    while (td.keepParticle && td.sendToProc == -1 && stepFraction() < 1)
     {
         if (debug)
         {
@@ -87,22 +87,6 @@ bool Foam::solidParticle::move
 }
 
 
-bool Foam::solidParticle::hitPatch(solidParticleCloud&, trackingData&)
-{
-    return false;
-}
-
-
-void Foam::solidParticle::hitProcessorPatch
-(
-    solidParticleCloud&,
-    trackingData& td
-)
-{
-    td.switchProcessor = true;
-}
-
-
 void Foam::solidParticle::hitWallPatch(solidParticleCloud& cloud, trackingData&)
 {
     const vector nw = normal();
diff --git a/src/lagrangian/solidParticle/solidParticle.H b/src/lagrangian/solidParticle/solidParticle.H
index cff9d114e1..6217cf404f 100644
--- a/src/lagrangian/solidParticle/solidParticle.H
+++ b/src/lagrangian/solidParticle/solidParticle.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -199,14 +199,6 @@ public:
 
         // Patch interactions
 
-            //- Overridable function to handle the particle hitting a patch
-            //  Executed before other patch-hitting functions
-            bool hitPatch(solidParticleCloud& cloud, trackingData& td);
-
-            //- Overridable function to handle the particle hitting a
-            //  processorPatch
-            void hitProcessorPatch(solidParticleCloud& cloud, trackingData& td);
-
             //- Overridable function to handle the particle hitting a wallPatch
             void hitWallPatch(solidParticleCloud& cloud, trackingData& td);
 
diff --git a/src/mesh/snappyHexMesh/trackedParticle/trackedParticle.C b/src/mesh/snappyHexMesh/trackedParticle/trackedParticle.C
index 564f779eb2..b86397f0ac 100644
--- a/src/mesh/snappyHexMesh/trackedParticle/trackedParticle.C
+++ b/src/mesh/snappyHexMesh/trackedParticle/trackedParticle.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2021 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -122,24 +122,22 @@ bool Foam::trackedParticle::move
     const scalar trackTime
 )
 {
-    td.switchProcessor = false;
-
     scalar tEnd = (1.0 - stepFraction())*trackTime;
 
     if (tEnd <= small && onBoundaryFace())
     {
-        // This is a hack to handle particles reaching their endpoint
-        // on a processor boundary. If the endpoint is on a processor face
-        // it currently gets transferred backwards and forwards infinitely.
-
-        // Remove the particle
+        // This is a hack to handle particles reaching their endpoint on a
+        // processor boundary. This prevents a particle being endlessly
+        // transferred backwards and forwards across the interface.
         td.keepParticle = false;
+        td.sendToProc = -1;
     }
     else
     {
         td.keepParticle = true;
+        td.sendToProc = -1;
 
-        while (td.keepParticle && !td.switchProcessor && stepFraction() < 1)
+        while (td.keepParticle && td.sendToProc == -1 && stepFraction() < 1)
         {
             // mark visited cell with max level.
             td.maxLevel_[cell()] = max(td.maxLevel_[cell()], level_);
@@ -154,12 +152,6 @@ bool Foam::trackedParticle::move
 }
 
 
-bool Foam::trackedParticle::hitPatch(Cloud<trackedParticle>&, trackingData&)
-{
-    return false;
-}
-
-
 void Foam::trackedParticle::hitWedgePatch
 (
     Cloud<trackedParticle>&,
@@ -243,17 +235,6 @@ void Foam::trackedParticle::hitCyclicRepeatAMIPatch
 }
 
 
-void Foam::trackedParticle::hitProcessorPatch
-(
-    Cloud<trackedParticle>&,
-    trackingData& td
-)
-{
-    // Move to different processor
-    td.switchProcessor = true;
-}
-
-
 void Foam::trackedParticle::hitWallPatch
 (
     Cloud<trackedParticle>&,
@@ -265,21 +246,15 @@ void Foam::trackedParticle::hitWallPatch
 }
 
 
-void Foam::trackedParticle::correctAfterParallelTransfer
-(
-    const label patchi,
-    trackingData& td
-)
+void Foam::trackedParticle::correctAfterParallelTransfer(trackingData& td)
 {
-    particle::correctAfterParallelTransfer(patchi, td);
+    particle::correctAfterParallelTransfer(td);
 
-    label edgei = k();
+    // Mark edge we are currently on (if any). This was set on the sending
+    // processor but has not yet been set on the receiving side.
+    const label feati = i(), edgei = k();
     if (edgei != -1)
     {
-        label feati = i();
-
-        // Mark edge we're currently on (was set on sending processor but not
-        // receiving sender)
         td.featureEdgeVisited_[feati].set(edgei, 1u);
     }
 }
diff --git a/src/mesh/snappyHexMesh/trackedParticle/trackedParticle.H b/src/mesh/snappyHexMesh/trackedParticle/trackedParticle.H
index 57056d9241..5a2f893e8c 100644
--- a/src/mesh/snappyHexMesh/trackedParticle/trackedParticle.H
+++ b/src/mesh/snappyHexMesh/trackedParticle/trackedParticle.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2021 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -240,10 +240,6 @@ public:
             //- Track all particles to their end point
             bool move(Cloud<trackedParticle>&, trackingData&, const scalar);
 
-            //- Overridable function to handle the particle hitting a patch
-            //  Executed before other patch-hitting functions
-            bool hitPatch(Cloud<trackedParticle>&, trackingData&);
-
             //- Overridable function to handle the particle hitting a wedge
             void hitWedgePatch(Cloud<trackedParticle>&, trackingData&);
 
@@ -286,16 +282,12 @@ public:
                 trackingData&
             );
 
-            //- Overridable function to handle the particle hitting a
-            //- processorPatch
-            void hitProcessorPatch(Cloud<trackedParticle>&, trackingData&);
-
             //- Overridable function to handle the particle hitting a wallPatch
             void hitWallPatch(Cloud<trackedParticle>&, trackingData&);
 
-            //- Convert processor patch addressing to the global equivalents
-            //  and set the celli to the face-neighbour
-            void correctAfterParallelTransfer(const label, trackingData&);
+            //- Do corrections to the particle and tracking data following a
+            //  transfer between processors
+            void correctAfterParallelTransfer(trackingData&);
 
 
     // Ostream Operator
diff --git a/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatchField/cyclicAMIPointPatchField.C b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatchField/cyclicAMIPointPatchField.C
index 98a020424a..d5e5de4993 100644
--- a/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatchField/cyclicAMIPointPatchField.C
+++ b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatchField/cyclicAMIPointPatchField.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -118,108 +118,4 @@ bool Foam::cyclicAMIPointPatchField<Type>::coupled() const
 }
 
 
-template<class Type>
-void Foam::cyclicAMIPointPatchField<Type>::swapAddSeparated
-(
-    const Pstream::commsTypes,
-    Field<Type>& pField
-) const
-{
-    if (cyclicAMIPatch_.cyclicAMIPatch().owner())
-    {
-        // We inplace modify pField. To prevent the other side (which gets
-        // evaluated at a later date) using already changed values we do
-        // all swaps on the side that gets evaluated first.
-
-        // Get neighbouring pointPatch
-        const cyclicAMIPointPatch& nbrPatch = cyclicAMIPatch_.nbrPatch();
-
-        // Get neighbouring pointPatchField
-        const GeometricField<Type, pointPatchField, pointMesh>& fld =
-            refCast<const GeometricField<Type, pointPatchField, pointMesh>>
-            (
-                this->internalField()
-            );
-
-        const cyclicAMIPointPatchField<Type>& nbr =
-            refCast<const cyclicAMIPointPatchField<Type>>
-            (
-                fld.boundaryField()[nbrPatch.index()]
-            );
-
-
-        Field<Type> ptFld(this->patchInternalField(pField));
-        Field<Type> nbrPtFld(nbr.patchInternalField(pField));
-
-        transform().invTransform(ptFld, ptFld);
-        transform().transform(nbrPtFld, nbrPtFld);
-
-        // convert point field to face field, AMI interpolate, then
-        // face back to point
-        {
-            // add neighbour side contribution to owner
-            Field<Type> nbrFcFld(nbrPpi().pointToFaceInterpolate(nbrPtFld));
-
-            // interpolate to owner
-            if (cyclicAMIPatch_.cyclicAMIPatch().applyLowWeightCorrection())
-            {
-                Field<Type> fcFld(ppi().pointToFaceInterpolate(ptFld));
-
-                nbrFcFld =
-                    cyclicAMIPatch_.cyclicAMIPatch().interpolate
-                    (
-                        nbrFcFld,
-                        fcFld
-                    );
-            }
-            else
-            {
-                nbrFcFld =
-                    cyclicAMIPatch_.cyclicAMIPatch().interpolate(nbrFcFld);
-            }
-
-            // add to internal field
-            this->addToInternalField
-            (
-                pField,
-                ppi().faceToPointInterpolate(nbrFcFld)()
-            );
-        }
-
-        {
-            // add owner side contribution to neighbour
-            Field<Type> fcFld(ppi().pointToFaceInterpolate(ptFld));
-
-            // interpolate to neighbour
-            if (cyclicAMIPatch_.cyclicAMIPatch().applyLowWeightCorrection())
-            {
-                Field<Type> nbrFcFld(nbrPpi().pointToFaceInterpolate(nbrPtFld));
-
-                fcFld =
-                    cyclicAMIPatch_.cyclicAMIPatch().nbrPatch().interpolate
-                    (
-                        fcFld,
-                        nbrFcFld
-                    );
-            }
-            else
-            {
-                fcFld =
-                    cyclicAMIPatch_.cyclicAMIPatch().nbrPatch().interpolate
-                    (
-                        fcFld
-                    );
-            }
-
-            // add to internal field
-            nbr.addToInternalField
-            (
-                pField,
-                nbrPpi().faceToPointInterpolate(fcFld)()
-            );
-        }
-    }
-}
-
-
 // ************************************************************************* //
diff --git a/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatchField/cyclicAMIPointPatchField.H b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatchField/cyclicAMIPointPatchField.H
index 69b135e59f..c893ac4669 100644
--- a/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatchField/cyclicAMIPointPatchField.H
+++ b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatchField/cyclicAMIPointPatchField.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2021 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -182,13 +182,6 @@ public:
                     Pstream::commsTypes::blocking
             )
             {}
-
-            //- Complete swap of patch point values and add to local values
-            virtual void swapAddSeparated
-            (
-                const Pstream::commsTypes commsType,
-                Field<Type>&
-            ) const;
 };
 
 
diff --git a/src/meshTools/Make/files b/src/meshTools/Make/files
index 317a015345..b484ca5de1 100644
--- a/src/meshTools/Make/files
+++ b/src/meshTools/Make/files
@@ -261,6 +261,7 @@ patchToPatch/patchToPatch/patchToPatchParallelOps.C
 patchToPatch/nearest/nearestPatchToPatch.C
 patchToPatch/inverseDistance/inverseDistancePatchToPatch.C
 patchToPatch/intersection/intersectionPatchToPatch.C
+patchToPatch/rays/raysPatchToPatch.C
 
 mappedPatches/mappedPolyPatch/mappedPatchBase.C
 mappedPatches/mappedPolyPatch/mappedPolyPatch.C
@@ -279,4 +280,20 @@ tetOverlapVolume/tetOverlapVolume.C
 triIntersect/triIntersect.C
 triIntersect/triIntersectLocationIO.C
 
+nonConformal/polyPatches/nonConformal/nonConformalPolyPatch.C
+nonConformal/polyPatches/nonConformalCoupled/nonConformalCoupledPolyPatch.C
+nonConformal/polyPatches/nonConformalCyclic/nonConformalCyclicPolyPatch.C
+nonConformal/polyPatches/nonConformalError/nonConformalErrorPolyPatch.C
+nonConformal/polyPatches/nonConformalProcessorCyclic/nonConformalProcessorCyclicPolyPatch.C
+
+nonConformal/pointPatches/nonConformalCyclic/nonConformalCyclicPointPatch.C
+nonConformal/pointPatches/nonConformalError/nonConformalErrorPointPatch.C
+nonConformal/pointPatches/nonConformalProcessorCyclic/nonConformalProcessorCyclicPointPatch.C
+
+nonConformal/pointPatchFields/nonConformalCyclic/nonConformalCyclicPointPatchFields.C
+nonConformal/pointPatchFields/nonConformalError/nonConformalErrorPointPatchFields.C
+nonConformal/pointPatchFields/nonConformalProcessorCyclic/nonConformalProcessorCyclicPointPatchFields.C
+
+nonConformalBoundary/nonConformalBoundary.C
+
 LIB = $(FOAM_LIBBIN)/libmeshTools
diff --git a/src/meshTools/nonConformal/pointPatchFields/nonConformalCyclic/nonConformalCyclicPointPatchField.C b/src/meshTools/nonConformal/pointPatchFields/nonConformalCyclic/nonConformalCyclicPointPatchField.C
new file mode 100644
index 0000000000..0d6dbc6efd
--- /dev/null
+++ b/src/meshTools/nonConformal/pointPatchFields/nonConformalCyclic/nonConformalCyclicPointPatchField.C
@@ -0,0 +1,98 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalCyclicPointPatchField.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::nonConformalCyclicPointPatchField<Type>::nonConformalCyclicPointPatchField
+(
+    const pointPatch& p,
+    const DimensionedField<Type, pointMesh>& iF
+)
+:
+    pointPatchField<Type>(p, iF)
+{}
+
+
+template<class Type>
+Foam::nonConformalCyclicPointPatchField<Type>::nonConformalCyclicPointPatchField
+(
+    const pointPatch& p,
+    const DimensionedField<Type, pointMesh>& iF,
+    const dictionary& dict
+)
+:
+    pointPatchField<Type>(p, iF, dict)
+{
+    if (!isType<nonConformalCyclicPointPatch>(p))
+    {
+        FatalIOErrorInFunction
+        (
+            dict
+        )   << "patch " << this->patch().index() << " not "
+            << nonConformalCyclicPointPatch::typeName << " type. "
+            << "Patch type = " << p.type()
+            << exit(FatalIOError);
+    }
+}
+
+
+template<class Type>
+Foam::nonConformalCyclicPointPatchField<Type>::nonConformalCyclicPointPatchField
+(
+    const nonConformalCyclicPointPatchField<Type>& ptf,
+    const pointPatch& p,
+    const DimensionedField<Type, pointMesh>& iF,
+    const pointPatchFieldMapper& mapper
+)
+:
+    pointPatchField<Type>(ptf, p, iF, mapper)
+{
+    if (!isType<nonConformalCyclicPointPatch>(this->patch()))
+    {
+        FatalErrorInFunction
+            << "Field type does not correspond to patch type for patch "
+            << this->patch().index() << "." << endl
+            << "Field type: " << typeName << endl
+            << "Patch type: " << this->patch().type()
+            << exit(FatalError);
+    }
+}
+
+
+template<class Type>
+Foam::nonConformalCyclicPointPatchField<Type>::nonConformalCyclicPointPatchField
+(
+    const nonConformalCyclicPointPatchField<Type>& ptf,
+    const DimensionedField<Type, pointMesh>& iF
+)
+:
+    pointPatchField<Type>(ptf, iF)
+{}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformal/pointPatchFields/nonConformalCyclic/nonConformalCyclicPointPatchField.H b/src/meshTools/nonConformal/pointPatchFields/nonConformalCyclic/nonConformalCyclicPointPatchField.H
new file mode 100644
index 0000000000..7ae47f83d8
--- /dev/null
+++ b/src/meshTools/nonConformal/pointPatchFields/nonConformalCyclic/nonConformalCyclicPointPatchField.H
@@ -0,0 +1,128 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonConformalCyclicPointPatchField
+
+Description
+    Constraint pointPatchField for nonConformalCyclic couplings.
+
+SourceFiles
+    nonConformalCyclicPointPatchField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalCyclicPointPatchField_H
+#define nonConformalCyclicPointPatchField_H
+
+#include "pointPatchField.H"
+#include "nonConformalCyclicPointPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                   Class nonConformalCyclicPointPatchField Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class nonConformalCyclicPointPatchField
+:
+    public pointPatchField<Type>
+{
+
+public:
+
+    //- Runtime type information
+    TypeName(nonConformalCyclicPointPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from patch and nonConformalCyclic field
+        nonConformalCyclicPointPatchField
+        (
+            const pointPatch&,
+            const DimensionedField<Type, pointMesh>&
+        );
+
+        //- Construct from patch, nonConformalCyclic field and dictionary
+        nonConformalCyclicPointPatchField
+        (
+            const pointPatch&,
+            const DimensionedField<Type, pointMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given patchField<Type> onto a new patch
+        nonConformalCyclicPointPatchField
+        (
+            const nonConformalCyclicPointPatchField<Type>&,
+            const pointPatch&,
+            const DimensionedField<Type, pointMesh>&,
+            const pointPatchFieldMapper&
+        );
+
+        //- Construct as copy setting nonConformalCyclic field reference
+        nonConformalCyclicPointPatchField
+        (
+            const nonConformalCyclicPointPatchField<Type>&,
+            const DimensionedField<Type, pointMesh>&
+        );
+
+        //- Construct and return a clone setting nonConformalCyclic field
+        //  reference
+        virtual autoPtr<pointPatchField<Type>> clone
+        (
+            const DimensionedField<Type, pointMesh>& iF
+        ) const
+        {
+            return autoPtr<pointPatchField<Type>>
+            (
+                new nonConformalCyclicPointPatchField<Type>
+                (
+                    *this,
+                    iF
+                )
+            );
+        }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "nonConformalCyclicPointPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformal/pointPatchFields/nonConformalCyclic/nonConformalCyclicPointPatchFields.C b/src/meshTools/nonConformal/pointPatchFields/nonConformalCyclic/nonConformalCyclicPointPatchFields.C
new file mode 100644
index 0000000000..1fae7404cf
--- /dev/null
+++ b/src/meshTools/nonConformal/pointPatchFields/nonConformalCyclic/nonConformalCyclicPointPatchFields.C
@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalCyclicPointPatchFields.H"
+#include "pointPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makePointPatchFields(nonConformalCyclic);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformal/pointPatchFields/nonConformalCyclic/nonConformalCyclicPointPatchFields.H b/src/meshTools/nonConformal/pointPatchFields/nonConformalCyclic/nonConformalCyclicPointPatchFields.H
new file mode 100644
index 0000000000..34381b723f
--- /dev/null
+++ b/src/meshTools/nonConformal/pointPatchFields/nonConformalCyclic/nonConformalCyclicPointPatchFields.H
@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalCyclicPointPatchFields_H
+#define nonConformalCyclicPointPatchFields_H
+
+#include "nonConformalCyclicPointPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makePointPatchFieldTypedefs(nonConformalCyclic);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformal/pointPatchFields/nonConformalError/nonConformalErrorPointPatchField.C b/src/meshTools/nonConformal/pointPatchFields/nonConformalError/nonConformalErrorPointPatchField.C
new file mode 100644
index 0000000000..47c1bf4695
--- /dev/null
+++ b/src/meshTools/nonConformal/pointPatchFields/nonConformalError/nonConformalErrorPointPatchField.C
@@ -0,0 +1,98 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalErrorPointPatchField.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::nonConformalErrorPointPatchField<Type>::nonConformalErrorPointPatchField
+(
+    const pointPatch& p,
+    const DimensionedField<Type, pointMesh>& iF
+)
+:
+    pointPatchField<Type>(p, iF)
+{}
+
+
+template<class Type>
+Foam::nonConformalErrorPointPatchField<Type>::nonConformalErrorPointPatchField
+(
+    const pointPatch& p,
+    const DimensionedField<Type, pointMesh>& iF,
+    const dictionary& dict
+)
+:
+    pointPatchField<Type>(p, iF, dict)
+{
+    if (!isType<nonConformalErrorPointPatch>(p))
+    {
+        FatalIOErrorInFunction
+        (
+            dict
+        )   << "patch " << this->patch().index() << " not "
+            << nonConformalErrorPointPatch::typeName << " type. "
+            << "Patch type = " << p.type()
+            << exit(FatalIOError);
+    }
+}
+
+
+template<class Type>
+Foam::nonConformalErrorPointPatchField<Type>::nonConformalErrorPointPatchField
+(
+    const nonConformalErrorPointPatchField<Type>& ptf,
+    const pointPatch& p,
+    const DimensionedField<Type, pointMesh>& iF,
+    const pointPatchFieldMapper& mapper
+)
+:
+    pointPatchField<Type>(ptf, p, iF, mapper)
+{
+    if (!isType<nonConformalErrorPointPatch>(this->patch()))
+    {
+        FatalErrorInFunction
+            << "Field type does not correspond to patch type for patch "
+            << this->patch().index() << "." << endl
+            << "Field type: " << typeName << endl
+            << "Patch type: " << this->patch().type()
+            << exit(FatalError);
+    }
+}
+
+
+template<class Type>
+Foam::nonConformalErrorPointPatchField<Type>::nonConformalErrorPointPatchField
+(
+    const nonConformalErrorPointPatchField<Type>& ptf,
+    const DimensionedField<Type, pointMesh>& iF
+)
+:
+    pointPatchField<Type>(ptf, iF)
+{}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformal/pointPatchFields/nonConformalError/nonConformalErrorPointPatchField.H b/src/meshTools/nonConformal/pointPatchFields/nonConformalError/nonConformalErrorPointPatchField.H
new file mode 100644
index 0000000000..5f1d68afa9
--- /dev/null
+++ b/src/meshTools/nonConformal/pointPatchFields/nonConformalError/nonConformalErrorPointPatchField.H
@@ -0,0 +1,128 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonConformalErrorPointPatchField
+
+Description
+    Constraint pointPatchField for nonConformalError patches.
+
+SourceFiles
+    nonConformalErrorPointPatchField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalErrorPointPatchField_H
+#define nonConformalErrorPointPatchField_H
+
+#include "pointPatchField.H"
+#include "nonConformalErrorPointPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                   Class nonConformalErrorPointPatchField Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class nonConformalErrorPointPatchField
+:
+    public pointPatchField<Type>
+{
+
+public:
+
+    //- Runtime type information
+    TypeName(nonConformalErrorPointPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from patch and nonConformalError field
+        nonConformalErrorPointPatchField
+        (
+            const pointPatch&,
+            const DimensionedField<Type, pointMesh>&
+        );
+
+        //- Construct from patch, nonConformalError field and dictionary
+        nonConformalErrorPointPatchField
+        (
+            const pointPatch&,
+            const DimensionedField<Type, pointMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given patchField<Type> onto a new patch
+        nonConformalErrorPointPatchField
+        (
+            const nonConformalErrorPointPatchField<Type>&,
+            const pointPatch&,
+            const DimensionedField<Type, pointMesh>&,
+            const pointPatchFieldMapper&
+        );
+
+        //- Construct as copy setting nonConformalError field reference
+        nonConformalErrorPointPatchField
+        (
+            const nonConformalErrorPointPatchField<Type>&,
+            const DimensionedField<Type, pointMesh>&
+        );
+
+        //- Construct and return a clone setting nonConformalError field
+        //  reference
+        virtual autoPtr<pointPatchField<Type>> clone
+        (
+            const DimensionedField<Type, pointMesh>& iF
+        ) const
+        {
+            return autoPtr<pointPatchField<Type>>
+            (
+                new nonConformalErrorPointPatchField<Type>
+                (
+                    *this,
+                    iF
+                )
+            );
+        }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "nonConformalErrorPointPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformal/pointPatchFields/nonConformalError/nonConformalErrorPointPatchFields.C b/src/meshTools/nonConformal/pointPatchFields/nonConformalError/nonConformalErrorPointPatchFields.C
new file mode 100644
index 0000000000..95dcd42085
--- /dev/null
+++ b/src/meshTools/nonConformal/pointPatchFields/nonConformalError/nonConformalErrorPointPatchFields.C
@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalErrorPointPatchFields.H"
+#include "pointPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makePointPatchFields(nonConformalError);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformal/pointPatchFields/nonConformalError/nonConformalErrorPointPatchFields.H b/src/meshTools/nonConformal/pointPatchFields/nonConformalError/nonConformalErrorPointPatchFields.H
new file mode 100644
index 0000000000..63829f44ed
--- /dev/null
+++ b/src/meshTools/nonConformal/pointPatchFields/nonConformalError/nonConformalErrorPointPatchFields.H
@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalErrorPointPatchFields_H
+#define nonConformalErrorPointPatchFields_H
+
+#include "nonConformalErrorPointPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makePointPatchFieldTypedefs(nonConformalError);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformal/pointPatchFields/nonConformalProcessorCyclic/nonConformalProcessorCyclicPointPatchField.C b/src/meshTools/nonConformal/pointPatchFields/nonConformalProcessorCyclic/nonConformalProcessorCyclicPointPatchField.C
new file mode 100644
index 0000000000..ce362dbac2
--- /dev/null
+++ b/src/meshTools/nonConformal/pointPatchFields/nonConformalProcessorCyclic/nonConformalProcessorCyclicPointPatchField.C
@@ -0,0 +1,102 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalProcessorCyclicPointPatchField.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::nonConformalProcessorCyclicPointPatchField<Type>::
+nonConformalProcessorCyclicPointPatchField
+(
+    const pointPatch& p,
+    const DimensionedField<Type, pointMesh>& iF
+)
+:
+    pointPatchField<Type>(p, iF)
+{}
+
+
+template<class Type>
+Foam::nonConformalProcessorCyclicPointPatchField<Type>::
+nonConformalProcessorCyclicPointPatchField
+(
+    const pointPatch& p,
+    const DimensionedField<Type, pointMesh>& iF,
+    const dictionary& dict
+)
+:
+    pointPatchField<Type>(p, iF, dict)
+{
+    if (!isType<nonConformalProcessorCyclicPointPatch>(p))
+    {
+        FatalIOErrorInFunction
+        (
+            dict
+        )   << "patch " << this->patch().index() << " not "
+            << nonConformalProcessorCyclicPointPatch::typeName << " type. "
+            << "Patch type = " << p.type()
+            << exit(FatalIOError);
+    }
+}
+
+
+template<class Type>
+Foam::nonConformalProcessorCyclicPointPatchField<Type>::
+nonConformalProcessorCyclicPointPatchField
+(
+    const nonConformalProcessorCyclicPointPatchField<Type>& ptf,
+    const pointPatch& p,
+    const DimensionedField<Type, pointMesh>& iF,
+    const pointPatchFieldMapper& mapper
+)
+:
+    pointPatchField<Type>(ptf, p, iF, mapper)
+{
+    if (!isType<nonConformalProcessorCyclicPointPatch>(this->patch()))
+    {
+        FatalErrorInFunction
+            << "Field type does not correspond to patch type for patch "
+            << this->patch().index() << "." << endl
+            << "Field type: " << typeName << endl
+            << "Patch type: " << this->patch().type()
+            << exit(FatalError);
+    }
+}
+
+
+template<class Type>
+Foam::nonConformalProcessorCyclicPointPatchField<Type>::
+nonConformalProcessorCyclicPointPatchField
+(
+    const nonConformalProcessorCyclicPointPatchField<Type>& ptf,
+    const DimensionedField<Type, pointMesh>& iF
+)
+:
+    pointPatchField<Type>(ptf, iF)
+{}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformal/pointPatchFields/nonConformalProcessorCyclic/nonConformalProcessorCyclicPointPatchField.H b/src/meshTools/nonConformal/pointPatchFields/nonConformalProcessorCyclic/nonConformalProcessorCyclicPointPatchField.H
new file mode 100644
index 0000000000..84423c70a9
--- /dev/null
+++ b/src/meshTools/nonConformal/pointPatchFields/nonConformalProcessorCyclic/nonConformalProcessorCyclicPointPatchField.H
@@ -0,0 +1,129 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonConformalProcessorCyclicPointPatchField
+
+Description
+    Constraint pointPatchField for nonConformalProcessorCyclic couplings.
+
+SourceFiles
+    nonConformalProcessorCyclicPointPatchField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalProcessorCyclicPointPatchField_H
+#define nonConformalProcessorCyclicPointPatchField_H
+
+#include "pointPatchField.H"
+#include "nonConformalProcessorCyclicPointPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                   Class nonConformalProcessorCyclicPointPatchField Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class nonConformalProcessorCyclicPointPatchField
+:
+    public pointPatchField<Type>
+{
+public:
+
+    //- Runtime type information
+    TypeName(nonConformalProcessorCyclicPointPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from patch and nonConformalProcessorCyclic field
+        nonConformalProcessorCyclicPointPatchField
+        (
+            const pointPatch&,
+            const DimensionedField<Type, pointMesh>&
+        );
+
+        //- Construct from patch, nonConformalProcessorCyclic field and
+        //  dictionary
+        nonConformalProcessorCyclicPointPatchField
+        (
+            const pointPatch&,
+            const DimensionedField<Type, pointMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given patchField<Type> onto a new patch
+        nonConformalProcessorCyclicPointPatchField
+        (
+            const nonConformalProcessorCyclicPointPatchField<Type>&,
+            const pointPatch&,
+            const DimensionedField<Type, pointMesh>&,
+            const pointPatchFieldMapper&
+        );
+
+        //- Construct as copy setting nonConformalProcessorCyclic field
+        //  reference
+        nonConformalProcessorCyclicPointPatchField
+        (
+            const nonConformalProcessorCyclicPointPatchField<Type>&,
+            const DimensionedField<Type, pointMesh>&
+        );
+
+        //- Construct and return a clone setting nonConformalProcessorCyclic
+        //  field reference
+        virtual autoPtr<pointPatchField<Type>> clone
+        (
+            const DimensionedField<Type, pointMesh>& iF
+        ) const
+        {
+            return autoPtr<pointPatchField<Type>>
+            (
+                new nonConformalProcessorCyclicPointPatchField<Type>
+                (
+                    *this,
+                    iF
+                )
+            );
+        }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "nonConformalProcessorCyclicPointPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformal/pointPatchFields/nonConformalProcessorCyclic/nonConformalProcessorCyclicPointPatchFields.C b/src/meshTools/nonConformal/pointPatchFields/nonConformalProcessorCyclic/nonConformalProcessorCyclicPointPatchFields.C
new file mode 100644
index 0000000000..54740bd5c2
--- /dev/null
+++ b/src/meshTools/nonConformal/pointPatchFields/nonConformalProcessorCyclic/nonConformalProcessorCyclicPointPatchFields.C
@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalProcessorCyclicPointPatchFields.H"
+#include "pointPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makePointPatchFields(nonConformalProcessorCyclic);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformal/pointPatchFields/nonConformalProcessorCyclic/nonConformalProcessorCyclicPointPatchFields.H b/src/meshTools/nonConformal/pointPatchFields/nonConformalProcessorCyclic/nonConformalProcessorCyclicPointPatchFields.H
new file mode 100644
index 0000000000..762feffd38
--- /dev/null
+++ b/src/meshTools/nonConformal/pointPatchFields/nonConformalProcessorCyclic/nonConformalProcessorCyclicPointPatchFields.H
@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalProcessorCyclicPointPatchFields_H
+#define nonConformalProcessorCyclicPointPatchFields_H
+
+#include "nonConformalProcessorCyclicPointPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makePointPatchFieldTypedefs(nonConformalProcessorCyclic);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformal/pointPatches/nonConformalCyclic/nonConformalCyclicPointPatch.C b/src/meshTools/nonConformal/pointPatches/nonConformalCyclic/nonConformalCyclicPointPatch.C
new file mode 100644
index 0000000000..5501550725
--- /dev/null
+++ b/src/meshTools/nonConformal/pointPatches/nonConformalCyclic/nonConformalCyclicPointPatch.C
@@ -0,0 +1,48 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalCyclicPointPatch.H"
+#include "pointConstraint.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(nonConformalCyclicPointPatch, 0);
+
+    // Add the patch constructor functions to the hash tables
+    addToRunTimeSelectionTable
+    (
+        facePointPatch,
+        nonConformalCyclicPointPatch,
+        polyPatch
+    );
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformal/pointPatches/nonConformalCyclic/nonConformalCyclicPointPatch.H b/src/meshTools/nonConformal/pointPatches/nonConformalCyclic/nonConformalCyclicPointPatch.H
new file mode 100644
index 0000000000..330ad7d238
--- /dev/null
+++ b/src/meshTools/nonConformal/pointPatches/nonConformalCyclic/nonConformalCyclicPointPatch.H
@@ -0,0 +1,86 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonConformalCyclicPointPatch
+
+Description
+    Constraint patch for nonConformalCyclic couplings.
+
+SourceFiles
+    nonConformalCyclicPointPatch.C
+
+See also
+    nonConformalCyclicPlanePointPatch
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalCyclicPointPatch_H
+#define nonConformalCyclicPointPatch_H
+
+#include "facePointPatch.H"
+#include "nonConformalCyclicPolyPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                     Class nonConformalCyclicPointPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class nonConformalCyclicPointPatch
+:
+    public facePointPatch
+{
+
+public:
+
+    //- Runtime type information
+    TypeName(nonConformalCyclicPolyPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from polyPatch
+        nonConformalCyclicPointPatch
+        (
+            const polyPatch& patch,
+            const pointBoundaryMesh& bm
+        )
+        :
+            facePointPatch(patch, bm)
+        {}
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformal/pointPatches/nonConformalError/nonConformalErrorPointPatch.C b/src/meshTools/nonConformal/pointPatches/nonConformalError/nonConformalErrorPointPatch.C
new file mode 100644
index 0000000000..8b2ab93ef5
--- /dev/null
+++ b/src/meshTools/nonConformal/pointPatches/nonConformalError/nonConformalErrorPointPatch.C
@@ -0,0 +1,48 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalErrorPointPatch.H"
+#include "pointConstraint.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(nonConformalErrorPointPatch, 0);
+
+    // Add the patch constructor functions to the hash tables
+    addToRunTimeSelectionTable
+    (
+        facePointPatch,
+        nonConformalErrorPointPatch,
+        polyPatch
+    );
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformal/pointPatches/nonConformalError/nonConformalErrorPointPatch.H b/src/meshTools/nonConformal/pointPatches/nonConformalError/nonConformalErrorPointPatch.H
new file mode 100644
index 0000000000..0087e38b9a
--- /dev/null
+++ b/src/meshTools/nonConformal/pointPatches/nonConformalError/nonConformalErrorPointPatch.H
@@ -0,0 +1,86 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonConformalErrorPointPatch
+
+Description
+    Constraint patch for errors associated with nonConformalCyclic couplings.
+
+SourceFiles
+    nonConformalErrorPointPatch.C
+
+See also
+    nonConformalErrorPlanePointPatch
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalErrorPointPatch_H
+#define nonConformalErrorPointPatch_H
+
+#include "facePointPatch.H"
+#include "nonConformalErrorPolyPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                     Class nonConformalErrorPointPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class nonConformalErrorPointPatch
+:
+    public facePointPatch
+{
+
+public:
+
+    //- Runtime type information
+    TypeName(nonConformalErrorPolyPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from polyPatch
+        nonConformalErrorPointPatch
+        (
+            const polyPatch& patch,
+            const pointBoundaryMesh& bm
+        )
+        :
+            facePointPatch(patch, bm)
+        {}
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformal/pointPatches/nonConformalProcessorCyclic/nonConformalProcessorCyclicPointPatch.C b/src/meshTools/nonConformal/pointPatches/nonConformalProcessorCyclic/nonConformalProcessorCyclicPointPatch.C
new file mode 100644
index 0000000000..10e84eba10
--- /dev/null
+++ b/src/meshTools/nonConformal/pointPatches/nonConformalProcessorCyclic/nonConformalProcessorCyclicPointPatch.C
@@ -0,0 +1,45 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalProcessorCyclicPointPatch.H"
+#include "pointConstraint.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(nonConformalProcessorCyclicPointPatch, 0);
+
+    addToRunTimeSelectionTable
+    (
+        facePointPatch,
+        nonConformalProcessorCyclicPointPatch,
+        polyPatch
+    );
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformal/pointPatches/nonConformalProcessorCyclic/nonConformalProcessorCyclicPointPatch.H b/src/meshTools/nonConformal/pointPatches/nonConformalProcessorCyclic/nonConformalProcessorCyclicPointPatch.H
new file mode 100644
index 0000000000..ed6b967452
--- /dev/null
+++ b/src/meshTools/nonConformal/pointPatches/nonConformalProcessorCyclic/nonConformalProcessorCyclicPointPatch.H
@@ -0,0 +1,83 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonConformalProcessorCyclicPointPatch
+
+Description
+    Constraint patch for nonConformalProcessorCyclic couplings.
+
+SourceFiles
+    nonConformalProcessorCyclicPointPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalProcessorCyclicPointPatch_H
+#define nonConformalProcessorCyclicPointPatch_H
+
+#include "facePointPatch.H"
+#include "nonConformalProcessorCyclicPolyPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+            Class nonConformalProcessorCyclicPointPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class nonConformalProcessorCyclicPointPatch
+:
+    public facePointPatch
+{
+
+public:
+
+    //- Runtime type information
+    TypeName(nonConformalProcessorCyclicPolyPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from polyPatch
+        nonConformalProcessorCyclicPointPatch
+        (
+            const polyPatch& patch,
+            const pointBoundaryMesh& bm
+        )
+        :
+            facePointPatch(patch, bm)
+        {}
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformal/polyPatches/nonConformal/nonConformalPolyPatch.C b/src/meshTools/nonConformal/polyPatches/nonConformal/nonConformalPolyPatch.C
new file mode 100644
index 0000000000..490f745aa7
--- /dev/null
+++ b/src/meshTools/nonConformal/polyPatches/nonConformal/nonConformalPolyPatch.C
@@ -0,0 +1,191 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalPolyPatch.H"
+#include "polyMesh.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(nonConformalPolyPatch, 0);
+}
+
+
+// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
+
+void Foam::nonConformalPolyPatch::validateSize() const
+{
+    if (patch_.size() != 0)
+    {
+        FatalErrorInFunction
+            << "Patch " << patch_.name() << " has " << patch_.size()
+            << " faces. Patches of type " << patch_.type()
+            << " must have zero faces." << exit(FatalError);
+    }
+}
+
+
+// * * * * * * * * * * * *  Protected Member Functions * * * * * * * * * * * //
+
+void Foam::nonConformalPolyPatch::rename(const wordList& newNames)
+{
+    if (origPatchID_ != -1)
+    {
+        origPatchName_ = newNames[origPatchID_];
+    }
+    else
+    {
+        FatalErrorInFunction
+            << "Cannot rename " << nonConformalPolyPatch::typeName
+            << " without the original patch index"
+            << exit(FatalError);
+    }
+}
+
+
+void Foam::nonConformalPolyPatch::reorder(const labelUList& newToOldIndex)
+{
+    if (origPatchID_ != -1)
+    {
+        origPatchID_ = findIndex(newToOldIndex, origPatchID_);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * //
+
+Foam::nonConformalPolyPatch::nonConformalPolyPatch(const polyPatch& patch)
+:
+    patch_(patch),
+    origPatchName_(word::null),
+    origPatchID_(-1)
+{
+    validateSize();
+}
+
+
+Foam::nonConformalPolyPatch::nonConformalPolyPatch
+(
+    const polyPatch& patch,
+    const word& origPatchName
+)
+:
+    patch_(patch),
+    origPatchName_(origPatchName),
+    origPatchID_(-1)
+{
+    validateSize();
+}
+
+
+Foam::nonConformalPolyPatch::nonConformalPolyPatch
+(
+    const polyPatch& patch,
+    const dictionary& dict
+)
+:
+    patch_(patch),
+    origPatchName_(dict.lookup<word>("originalPatch")),
+    origPatchID_(-1)
+{
+    validateSize();
+}
+
+
+Foam::nonConformalPolyPatch::nonConformalPolyPatch
+(
+    const nonConformalPolyPatch& patch
+)
+:
+    patch_(patch.patch_),
+    origPatchName_(patch.origPatchName_),
+    origPatchID_(-1)
+{
+    validateSize();
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::nonConformalPolyPatch::~nonConformalPolyPatch()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+const Foam::word& Foam::nonConformalPolyPatch::origPatchName() const
+{
+    return origPatchName_;
+}
+
+
+Foam::label Foam::nonConformalPolyPatch::origPatchID() const
+{
+    if (origPatchID_ == -1)
+    {
+        origPatchID_ = patch_.boundaryMesh().findPatchID(origPatchName());
+
+        if (origPatchID_ == -1)
+        {
+            FatalErrorInFunction
+                << "Illegal neighbourPatch name " << origPatchName()
+                << endl << "Valid patch names are "
+                << patch_.boundaryMesh().names()
+                << exit(FatalError);
+        }
+
+        const polyPatch& p = patch_.boundaryMesh()[origPatchID_];
+
+        if (isA<nonConformalPolyPatch>(p))
+        {
+            FatalErrorInFunction
+                << "The originalPatch for the "
+                << patch_.type() << " patch " << patch_.name() << " is "
+                << p.name() << " which is also of "
+                << nonConformalPolyPatch::typeName << " type. This is not "
+                << "allowed. The originalPatch must be of a non-"
+                << nonConformalPolyPatch::typeName << " type."
+                << exit(FatalError);
+        }
+    }
+
+    return origPatchID_;
+}
+
+
+const Foam::polyPatch& Foam::nonConformalPolyPatch::origPatch() const
+{
+    return patch_.boundaryMesh()[origPatchID()];
+}
+
+
+void Foam::nonConformalPolyPatch::write(Ostream& os) const
+{
+    writeEntry(os, "originalPatch", origPatchName_);
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformal/polyPatches/nonConformal/nonConformalPolyPatch.H b/src/meshTools/nonConformal/polyPatches/nonConformal/nonConformalPolyPatch.H
new file mode 100644
index 0000000000..18f63f3261
--- /dev/null
+++ b/src/meshTools/nonConformal/polyPatches/nonConformal/nonConformalPolyPatch.H
@@ -0,0 +1,138 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonConformalPolyPatch
+
+Description
+    Non-conformal poly patch. This patch is a placeholder and must have no
+    faces. This patch is linked to an "original" patch. Other parts of the code
+    (i.e., finite volume) will use this patch to create non-empty patches that
+    do not conform to the poly mesh.
+
+SourceFiles
+    nonConformalPolyPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalPolyPatch_H
+#define nonConformalPolyPatch_H
+
+#include "cyclicPolyPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                 Class nonConformalPolyPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class nonConformalPolyPatch
+{
+private:
+
+    // Private
+
+        //- Reference to the polyPatch
+        const polyPatch& patch_;
+
+        //- Name of the patch from which this patch originates
+        mutable word origPatchName_;
+
+        //- Index of the patch from which this patch originates
+        mutable label origPatchID_;
+
+
+    // Private Member Functions
+
+        //- Validate the size of the patch
+        void validateSize() const;
+
+
+protected:
+
+    // Protected Member Functions
+
+        //- Reset the patch name
+        virtual void rename(const wordList& newNames);
+
+        //- Reset the patch index
+        virtual void reorder(const labelUList& newToOldIndex);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("nonConformal");
+
+
+    // Constructors
+
+        //- Construct from a patch
+        nonConformalPolyPatch(const polyPatch& patch);
+
+        //- Construct from a patch and an original patch name
+        nonConformalPolyPatch
+        (
+            const polyPatch& patch,
+            const word& origPatchName
+        );
+
+        //- Construct from a patch and a dictionary
+        nonConformalPolyPatch(const polyPatch& patch, const dictionary& dict);
+
+        //- Construct from a non-conformal patch
+        nonConformalPolyPatch(const nonConformalPolyPatch& patch);
+
+
+    //- Destructor
+    virtual ~nonConformalPolyPatch();
+
+
+    // Member Functions
+
+        //- Original patch name
+        const word& origPatchName() const;
+
+        //- Original patchID
+        label origPatchID() const;
+
+        //- Original patch
+        const polyPatch& origPatch() const;
+
+        //- Write the polyPatch data as a dictionary
+        virtual void write(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformal/polyPatches/nonConformalCoupled/nonConformalCoupledPolyPatch.C b/src/meshTools/nonConformal/polyPatches/nonConformalCoupled/nonConformalCoupledPolyPatch.C
new file mode 100644
index 0000000000..cbe7d71ced
--- /dev/null
+++ b/src/meshTools/nonConformal/polyPatches/nonConformalCoupled/nonConformalCoupledPolyPatch.C
@@ -0,0 +1,196 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalCoupledPolyPatch.H"
+#include "nonConformalErrorPolyPatch.H"
+#include "polyMesh.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(nonConformalCoupledPolyPatch, 0);
+}
+
+
+// * * * * * * * * * * * *  Protected Member Functions * * * * * * * * * * * //
+
+void Foam::nonConformalCoupledPolyPatch::rename(const wordList& newNames)
+{
+    nonConformalPolyPatch::rename(newNames);
+
+    errorPatchName_ = word::null;
+    errorPatchID_ = -1;
+}
+
+
+void Foam::nonConformalCoupledPolyPatch::reorder
+(
+    const labelUList& newToOldIndex
+)
+{
+    nonConformalPolyPatch::reorder(newToOldIndex);
+
+    errorPatchName_ = word::null;
+    errorPatchID_ = -1;
+}
+
+
+// * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * //
+
+Foam::nonConformalCoupledPolyPatch::nonConformalCoupledPolyPatch
+(
+    const polyPatch& patch
+)
+:
+    nonConformalPolyPatch(patch),
+    patch_(refCast<const coupledPolyPatch>(patch)),
+    errorPatchName_(word::null),
+    errorPatchID_(-1)
+{}
+
+
+Foam::nonConformalCoupledPolyPatch::nonConformalCoupledPolyPatch
+(
+    const polyPatch& patch,
+    const word& origPatchName
+)
+:
+    nonConformalPolyPatch(patch, origPatchName),
+    patch_(refCast<const coupledPolyPatch>(patch)),
+    errorPatchName_(word::null),
+    errorPatchID_(-1)
+{}
+
+
+Foam::nonConformalCoupledPolyPatch::nonConformalCoupledPolyPatch
+(
+    const polyPatch& patch,
+    const dictionary& dict
+)
+:
+    nonConformalPolyPatch(patch, dict),
+    patch_(refCast<const coupledPolyPatch>(patch)),
+    errorPatchName_(word::null),
+    errorPatchID_(-1)
+{}
+
+
+Foam::nonConformalCoupledPolyPatch::nonConformalCoupledPolyPatch
+(
+    const nonConformalCoupledPolyPatch& patch
+)
+:
+    nonConformalPolyPatch(patch),
+    patch_(refCast<const coupledPolyPatch>(patch)),
+    errorPatchName_(word::null),
+    errorPatchID_(-1)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::nonConformalCoupledPolyPatch::~nonConformalCoupledPolyPatch()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool Foam::nonConformalCoupledPolyPatch::owner() const
+{
+    return patch_.owner();
+}
+
+
+bool Foam::nonConformalCoupledPolyPatch::neighbour() const
+{
+    return patch_.neighbour();
+}
+
+
+const Foam::transformer& Foam::nonConformalCoupledPolyPatch::transform() const
+{
+    return patch_.transform();
+}
+
+
+const Foam::word& Foam::nonConformalCoupledPolyPatch::errorPatchName() const
+{
+    return patch_.boundaryMesh()[errorPatchID()].name();
+}
+
+
+Foam::label Foam::nonConformalCoupledPolyPatch::errorPatchID() const
+{
+    if (errorPatchID_ == -1)
+    {
+        forAll(patch_.boundaryMesh(), patchi)
+        {
+            const polyPatch& p = patch_.boundaryMesh()[patchi];
+
+            if
+            (
+                isA<nonConformalErrorPolyPatch>(p)
+             && refCast<const nonConformalErrorPolyPatch>(p).origPatchID()
+             == origPatchID()
+            )
+            {
+                errorPatchID_ = patchi;
+                break;
+            }
+        }
+    }
+
+    if (errorPatchID_ == -1)
+    {
+        FatalErrorInFunction
+            << "No error patch of type "
+            << nonConformalErrorPolyPatch::typeName
+            << " defined for patch " << origPatchName()
+            << exit(FatalError);
+    }
+
+    return errorPatchID_;
+}
+
+
+const Foam::nonConformalErrorPolyPatch&
+Foam::nonConformalCoupledPolyPatch::errorPatch() const
+{
+    return
+        refCast<const nonConformalErrorPolyPatch>
+        (
+            patch_.boundaryMesh()[errorPatchID()]
+        );
+}
+
+
+void Foam::nonConformalCoupledPolyPatch::write(Ostream& os) const
+{
+    nonConformalPolyPatch::write(os);
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformal/polyPatches/nonConformalCoupled/nonConformalCoupledPolyPatch.H b/src/meshTools/nonConformal/polyPatches/nonConformalCoupled/nonConformalCoupledPolyPatch.H
new file mode 100644
index 0000000000..2bbb582193
--- /dev/null
+++ b/src/meshTools/nonConformal/polyPatches/nonConformalCoupled/nonConformalCoupledPolyPatch.H
@@ -0,0 +1,154 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonConformalCoupledPolyPatch
+
+Description
+    Non-conformal coupled poly patch. As nonConformalPolyPatch, but this patch
+    is coupled to another non-conformal patch. Information about the
+    owner/neighbour relationship and transformation are made available by this
+    class. Also, this patch allows access to the error patch.
+
+See also
+    Foam::nonConformalPolyPatch
+    Foam::nonConformalErrorPolyPatch
+
+SourceFiles
+    nonConformalCoupledPolyPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalCoupledPolyPatch_H
+#define nonConformalCoupledPolyPatch_H
+
+#include "cyclicPolyPatch.H"
+#include "nonConformalPolyPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class nonConformalErrorPolyPatch;
+
+/*---------------------------------------------------------------------------*\
+                 Class nonConformalCoupledPolyPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class nonConformalCoupledPolyPatch
+:
+    public nonConformalPolyPatch
+{
+private:
+
+    // Private
+
+        //- Reference to the coupled polyPatch
+        const coupledPolyPatch& patch_;
+
+        //- Name of the error patch associated with this cyclic
+        mutable word errorPatchName_;
+
+        //- Index of the error patch associated with this cyclic
+        mutable label errorPatchID_;
+
+
+protected:
+
+    // Protected Member Functions
+
+        //- Reset the patch name
+        virtual void rename(const wordList& newNames);
+
+        //- Reset the patch index
+        virtual void reorder(const labelUList& newToOldIndex);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("nonConformalCoupled");
+
+
+    // Constructors
+
+        //- Construct from a patch
+        nonConformalCoupledPolyPatch(const polyPatch& patch);
+
+        //- Construct from a patch and an original patch name
+        nonConformalCoupledPolyPatch
+        (
+            const polyPatch& patch,
+            const word& origPatchName
+        );
+
+        //- Construct from a patch and a dictionary
+        nonConformalCoupledPolyPatch
+        (
+            const polyPatch& patch,
+            const dictionary& dict
+        );
+
+        //- Construct from a non-conformal coupled patch
+        nonConformalCoupledPolyPatch(const nonConformalCoupledPolyPatch& patch);
+
+
+    //- Destructor
+    virtual ~nonConformalCoupledPolyPatch();
+
+
+    // Member Functions
+
+        //- Does this side own the patch?
+        bool owner() const;
+
+        //- Does the coupled side own the patch?
+        bool neighbour() const;
+
+        //- Return transformation between the coupled patches
+        const transformer& transform() const;
+
+        //- Error patch name
+        const word& errorPatchName() const;
+
+        //- Error patchID
+        label errorPatchID() const;
+
+        //- Error patch
+        const nonConformalErrorPolyPatch& errorPatch() const;
+
+        //- Write the polyPatch data as a dictionary
+        virtual void write(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformal/polyPatches/nonConformalCyclic/nonConformalCyclicPolyPatch.C b/src/meshTools/nonConformal/polyPatches/nonConformalCyclic/nonConformalCyclicPolyPatch.C
new file mode 100644
index 0000000000..9ff07e78b9
--- /dev/null
+++ b/src/meshTools/nonConformal/polyPatches/nonConformalCyclic/nonConformalCyclicPolyPatch.C
@@ -0,0 +1,397 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalCyclicPolyPatch.H"
+#include "nonConformalErrorPolyPatch.H"
+#include "addToRunTimeSelectionTable.H"
+#include "polyBoundaryMesh.H"
+#include "polyMesh.H"
+#include "SubField.H"
+#include "nonConformalBoundary.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(nonConformalCyclicPolyPatch, 0);
+
+    addToRunTimeSelectionTable(polyPatch, nonConformalCyclicPolyPatch, word);
+    addToRunTimeSelectionTable
+    (
+        polyPatch,
+        nonConformalCyclicPolyPatch,
+        dictionary
+    );
+}
+
+
+// * * * * * * * * * * * *  Protected Member Functions * * * * * * * * * * * //
+
+void Foam::nonConformalCyclicPolyPatch::initCalcGeometry(PstreamBuffers& pBufs)
+{
+    cyclicPolyPatch::initCalcGeometry(pBufs);
+    intersectionIsValid_ = false;
+    raysIsValid_ = false;
+}
+
+
+void Foam::nonConformalCyclicPolyPatch::calcGeometry(PstreamBuffers& pBufs)
+{
+    static_cast<cyclicTransform&>(*this) =
+        cyclicTransform
+        (
+            name(),
+            origPatch().faceAreas(),
+            *this,
+            nbrPatchName(),
+            nbrPatch(),
+            matchTolerance()
+        );
+}
+
+
+void Foam::nonConformalCyclicPolyPatch::initMovePoints
+(
+    PstreamBuffers& pBufs,
+    const pointField& p
+)
+{
+    cyclicPolyPatch::initMovePoints(pBufs, p);
+    intersectionIsValid_ = false;
+    raysIsValid_ = false;
+}
+
+
+void Foam::nonConformalCyclicPolyPatch::initTopoChange(PstreamBuffers& pBufs)
+{
+    cyclicPolyPatch::initTopoChange(pBufs);
+    intersectionIsValid_ = false;
+    raysIsValid_ = false;
+}
+
+
+void Foam::nonConformalCyclicPolyPatch::clearGeom()
+{
+    cyclicPolyPatch::clearGeom();
+    intersectionIsValid_ = false;
+    raysIsValid_ = false;
+}
+
+
+void Foam::nonConformalCyclicPolyPatch::rename(const wordList& newNames)
+{
+    cyclicPolyPatch::rename(newNames);
+    nonConformalCoupledPolyPatch::rename(newNames);
+}
+
+
+void Foam::nonConformalCyclicPolyPatch::reorder(const labelUList& newToOldIndex)
+{
+    cyclicPolyPatch::reorder(newToOldIndex);
+    nonConformalCoupledPolyPatch::reorder(newToOldIndex);
+}
+
+
+// * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * //
+
+Foam::nonConformalCyclicPolyPatch::nonConformalCyclicPolyPatch
+(
+    const word& name,
+    const label size,
+    const label start,
+    const label index,
+    const polyBoundaryMesh& bm,
+    const word& patchType
+)
+:
+    cyclicPolyPatch(name, size, start, index, bm, patchType),
+    nonConformalCoupledPolyPatch(static_cast<const polyPatch&>(*this)),
+    intersectionIsValid_(false),
+    intersection_(false),
+    raysIsValid_(false),
+    rays_(false)
+{}
+
+
+Foam::nonConformalCyclicPolyPatch::nonConformalCyclicPolyPatch
+(
+    const word& name,
+    const label size,
+    const label start,
+    const label index,
+    const polyBoundaryMesh& bm,
+    const word& patchType,
+    const word& nbrPatchName,
+    const word& origPatchName,
+    const cyclicTransform& transform
+)
+:
+    cyclicPolyPatch
+    (
+        name,
+        size,
+        start,
+        index,
+        bm,
+        patchType,
+        nbrPatchName,
+        transform
+    ),
+    nonConformalCoupledPolyPatch
+    (
+        static_cast<const polyPatch&>(*this),
+        origPatchName
+    ),
+    intersectionIsValid_(false),
+    intersection_(false),
+    raysIsValid_(false),
+    rays_(false)
+{}
+
+
+Foam::nonConformalCyclicPolyPatch::nonConformalCyclicPolyPatch
+(
+    const word& name,
+    const dictionary& dict,
+    const label index,
+    const polyBoundaryMesh& bm,
+    const word& patchType
+)
+:
+    cyclicPolyPatch(name, dict, index, bm, patchType, true),
+    nonConformalCoupledPolyPatch(static_cast<const polyPatch&>(*this), dict),
+    intersectionIsValid_(false),
+    intersection_(false),
+    raysIsValid_(false),
+    rays_(false)
+{}
+
+
+Foam::nonConformalCyclicPolyPatch::nonConformalCyclicPolyPatch
+(
+    const nonConformalCyclicPolyPatch& pp,
+    const polyBoundaryMesh& bm
+)
+:
+    cyclicPolyPatch(pp, bm),
+    nonConformalCoupledPolyPatch
+    (
+        static_cast<const nonConformalCoupledPolyPatch&>(pp)
+    ),
+    intersectionIsValid_(false),
+    intersection_(false),
+    raysIsValid_(false),
+    rays_(false)
+{}
+
+
+Foam::nonConformalCyclicPolyPatch::nonConformalCyclicPolyPatch
+(
+    const nonConformalCyclicPolyPatch& pp,
+    const polyBoundaryMesh& bm,
+    const label index,
+    const label newSize,
+    const label newStart,
+    const word& nbrPatchName,
+    const word& origPatchName
+)
+:
+    cyclicPolyPatch(pp, bm, index, newSize, newStart, nbrPatchName),
+    nonConformalCoupledPolyPatch
+    (
+        static_cast<const polyPatch&>(*this),
+        origPatchName
+    ),
+    intersectionIsValid_(false),
+    intersection_(false),
+    raysIsValid_(false),
+    rays_(false)
+{}
+
+
+Foam::nonConformalCyclicPolyPatch::nonConformalCyclicPolyPatch
+(
+    const nonConformalCyclicPolyPatch& pp,
+    const polyBoundaryMesh& bm,
+    const label index,
+    const labelUList& mapAddressing,
+    const label newStart
+)
+:
+    cyclicPolyPatch(pp, bm, index, mapAddressing, newStart),
+    nonConformalCoupledPolyPatch
+    (
+        static_cast<const nonConformalCoupledPolyPatch&>(pp)
+    ),
+    intersectionIsValid_(false),
+    intersection_(false),
+    raysIsValid_(false),
+    rays_(false)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::nonConformalCyclicPolyPatch::~nonConformalCyclicPolyPatch()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+const Foam::nonConformalCyclicPolyPatch&
+Foam::nonConformalCyclicPolyPatch::nbrPatch() const
+{
+    return
+        refCast<const nonConformalCyclicPolyPatch>
+        (
+            cyclicPolyPatch::nbrPatch()
+        );
+}
+
+
+bool Foam::nonConformalCyclicPolyPatch::coupled() const
+{
+    return false;
+}
+
+
+const Foam::patchToPatches::intersection&
+Foam::nonConformalCyclicPolyPatch::intersection() const
+{
+    if (!owner())
+    {
+        FatalErrorInFunction
+            << "The non-conformal cyclic intersection is only available to "
+            << "the owner patch" << abort(FatalError);
+    }
+
+    if (!intersectionIsValid_)
+    {
+        const polyMesh& mesh = boundaryMesh().mesh();
+
+        const nonConformalBoundary& ncb = nonConformalBoundary::New(mesh);
+
+        intersection_.update
+        (
+            origPatch(),
+            ncb.patchPointNormals(origPatchID()),
+            nbrPatch().origPatch(),
+            transform()
+        );
+
+        intersectionIsValid_ = true;
+    }
+
+    return intersection_;
+}
+
+
+const Foam::patchToPatches::rays&
+Foam::nonConformalCyclicPolyPatch::rays() const
+{
+    if (!owner())
+    {
+        FatalErrorInFunction
+            << "The non-conformal cyclic rays is only available to "
+            << "the owner patch" << abort(FatalError);
+    }
+
+    if (!raysIsValid_)
+    {
+        const polyMesh& mesh = boundaryMesh().mesh();
+
+        const nonConformalBoundary& ncb = nonConformalBoundary::New(mesh);
+
+        rays_.update
+        (
+            primitiveOldTimePatch
+            (
+                origPatch(),
+                mesh.points(),
+                mesh.oldPoints()
+            ),
+            ncb.patchPointNormals(origPatchID()),
+            ncb.patchPointNormals0(origPatchID()),
+            primitiveOldTimePatch
+            (
+                nbrPatch().origPatch(),
+                mesh.points(),
+                mesh.oldPoints()
+            ),
+            transform()
+        );
+
+        raysIsValid_ = true;
+    }
+
+    return rays_;
+}
+
+
+Foam::patchToPatch::procFace Foam::nonConformalCyclicPolyPatch::ray
+(
+    const scalar fraction,
+    const label origFacei,
+    const vector& p,
+    const vector& n,
+    point& nbrP
+) const
+{
+    const polyMesh& mesh = boundaryMesh().mesh();
+
+    const nonConformalCyclicPolyPatch& ownerPatch =
+        owner() ? *this : nbrPatch();
+
+    auto ownerRaysMethod =
+        owner()
+      ? &patchToPatches::rays::srcToTgtRay
+      : &patchToPatches::rays::tgtToSrcRay;
+
+    return
+        (ownerPatch.rays().*ownerRaysMethod)
+        (
+            primitiveOldTimePatch
+            (
+                nbrPatch().origPatch(),
+                mesh.points(),
+                mesh.oldPoints()
+            ),
+            fraction,
+            origFacei,
+            transform().invTransformPosition(p),
+            transform().invTransform(n),
+            nbrP
+        );
+}
+
+
+void Foam::nonConformalCyclicPolyPatch::write(Ostream& os) const
+{
+    cyclicPolyPatch::write(os);
+    nonConformalCoupledPolyPatch::write(os);
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformal/polyPatches/nonConformalCyclic/nonConformalCyclicPolyPatch.H b/src/meshTools/nonConformal/polyPatches/nonConformalCyclic/nonConformalCyclicPolyPatch.H
new file mode 100644
index 0000000000..2a5e7e92c0
--- /dev/null
+++ b/src/meshTools/nonConformal/polyPatches/nonConformalCyclic/nonConformalCyclicPolyPatch.H
@@ -0,0 +1,285 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonConformalCyclicPolyPatch
+
+Description
+    Non-conformal cyclic poly patch. As nonConformalCoupledPolyPatch, but the
+    neighbouring patch is local and known and is made available by this class.
+
+See also
+    Foam::nonConformalCoupledPolyPatch
+
+SourceFiles
+    nonConformalCyclicPolyPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalCyclicPolyPatch_H
+#define nonConformalCyclicPolyPatch_H
+
+#include "cyclicPolyPatch.H"
+#include "nonConformalCoupledPolyPatch.H"
+#include "intersectionPatchToPatch.H"
+#include "raysPatchToPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                 Class nonConformalCyclicPolyPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class nonConformalCyclicPolyPatch
+:
+    public cyclicPolyPatch,
+    public nonConformalCoupledPolyPatch
+{
+protected:
+
+    // Protected data
+
+        //- Is the intersection engine up to date?
+        mutable bool intersectionIsValid_;
+
+        //- Patch-to-patch intersection engine
+        mutable patchToPatches::intersection intersection_;
+
+        //- Is the intersection engine up to date?
+        mutable bool raysIsValid_;
+
+        //- Patch-to-patch intersection engine
+        mutable patchToPatches::rays rays_;
+
+
+    // Protected Member Functions
+
+        //- Initialise the calculation of the patch geometry
+        virtual void initCalcGeometry(PstreamBuffers&);
+
+        //- Calculate the patch geometry
+        virtual void calcGeometry(PstreamBuffers&);
+
+        //- Initialise the patches for moving points
+        virtual void initMovePoints(PstreamBuffers& pBufs, const pointField&);
+
+        //- Initialise the update of the patch topology
+        virtual void initTopoChange(PstreamBuffers&);
+
+        //- Clear geometry
+        virtual void clearGeom();
+
+        //- Reset the patch name
+        virtual void rename(const wordList& newNames);
+
+        //- Reset the patch index
+        virtual void reorder(const labelUList& newToOldIndex);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("nonConformalCyclic");
+
+
+    // Constructors
+
+        //- Construct from components
+        nonConformalCyclicPolyPatch
+        (
+            const word& name,
+            const label size,
+            const label start,
+            const label index,
+            const polyBoundaryMesh& bm,
+            const word& patchType
+        );
+
+        //- Construct from components
+        nonConformalCyclicPolyPatch
+        (
+            const word& name,
+            const label size,
+            const label start,
+            const label index,
+            const polyBoundaryMesh& bm,
+            const word& patchType,
+            const word& nbrPatchName,
+            const word& origPatchName,
+            const cyclicTransform& transform=cyclicTransform(true)
+        );
+
+        //- Construct from dictionary
+        nonConformalCyclicPolyPatch
+        (
+            const word& name,
+            const dictionary& dict,
+            const label index,
+            const polyBoundaryMesh& bm,
+            const word& patchType
+        );
+
+        //- Construct as copy, resetting the boundary mesh
+        nonConformalCyclicPolyPatch
+        (
+            const nonConformalCyclicPolyPatch&,
+            const polyBoundaryMesh&
+        );
+
+        //- Construct given the original patch and resetting the
+        //  face list and boundary mesh information
+        nonConformalCyclicPolyPatch
+        (
+            const nonConformalCyclicPolyPatch& pp,
+            const polyBoundaryMesh& bm,
+            const label index,
+            const label newSize,
+            const label newStart,
+            const word& nbrPatchName,
+            const word& origPatchName
+        );
+
+        //- Construct given the original patch and a map
+        nonConformalCyclicPolyPatch
+        (
+            const nonConformalCyclicPolyPatch& pp,
+            const polyBoundaryMesh& bm,
+            const label index,
+            const labelUList& mapAddressing,
+            const label newStart
+        );
+
+        //- Construct and return a clone, resetting the boundary mesh
+        virtual autoPtr<polyPatch> clone(const polyBoundaryMesh& bm) const
+        {
+            return autoPtr<polyPatch>
+            (
+                new nonConformalCyclicPolyPatch(*this, bm)
+            );
+        }
+
+        //- Construct and return a clone, resetting the face list
+        //  and boundary mesh
+        virtual autoPtr<polyPatch> clone
+        (
+            const polyBoundaryMesh& bm,
+            const label index,
+            const label newSize,
+            const label newStart
+        ) const
+        {
+            return autoPtr<polyPatch>
+            (
+                new nonConformalCyclicPolyPatch
+                (
+                    *this,
+                    bm,
+                    index,
+                    newSize,
+                    newStart,
+                    nbrPatchName(),
+                    origPatchName()
+                )
+            );
+        }
+
+        //- Construct and return a clone, resetting the face list
+        //  and boundary mesh
+        virtual autoPtr<polyPatch> clone
+        (
+            const polyBoundaryMesh& bm,
+            const label index,
+            const labelUList& mapAddressing,
+            const label newStart
+        ) const
+        {
+            return autoPtr<polyPatch>
+            (
+                new nonConformalCyclicPolyPatch
+                (
+                    *this,
+                    bm,
+                    index,
+                    mapAddressing,
+                    newStart
+                )
+            );
+        }
+
+
+    //- Destructor
+    virtual ~nonConformalCyclicPolyPatch();
+
+
+    // Member Functions
+
+        //- Neighbour patch
+        const nonConformalCyclicPolyPatch& nbrPatch() const;
+
+        //- Inherit the cyclic owner method
+        using cyclicPolyPatch::owner;
+
+        //- Inherit the cyclic neighbour method
+        using cyclicPolyPatch::neighbour;
+
+        //- Inherit the cyclic transform method
+        using cyclicPolyPatch::transform;
+
+        //- Is this patch coupled? Returns false. For NCC patches the poly
+        //  mesh is considered non-coupled whilst the finite volume mesh is
+        //  considered coupled.
+        virtual bool coupled() const;
+
+        //- Access the intersection engine
+        const patchToPatches::intersection& intersection() const;
+
+        //- Access the rays engine
+        const patchToPatches::rays& rays() const;
+
+        //- Compute a ray intersection across the coupling
+        patchToPatch::procFace ray
+        (
+            const scalar fraction,
+            const label origFacei,
+            const vector& p,
+            const vector& n,
+            point& nbrP
+        ) const;
+
+        //- Write the polyPatch data as a dictionary
+        virtual void write(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformal/polyPatches/nonConformalError/nonConformalErrorPolyPatch.C b/src/meshTools/nonConformal/polyPatches/nonConformalError/nonConformalErrorPolyPatch.C
new file mode 100644
index 0000000000..2b10da836d
--- /dev/null
+++ b/src/meshTools/nonConformal/polyPatches/nonConformalError/nonConformalErrorPolyPatch.C
@@ -0,0 +1,164 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalErrorPolyPatch.H"
+#include "addToRunTimeSelectionTable.H"
+#include "polyBoundaryMesh.H"
+#include "polyMesh.H"
+#include "SubField.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(nonConformalErrorPolyPatch, 0);
+
+    addToRunTimeSelectionTable(polyPatch, nonConformalErrorPolyPatch, word);
+    addToRunTimeSelectionTable
+    (
+        polyPatch,
+        nonConformalErrorPolyPatch,
+        dictionary
+    );
+}
+
+
+// * * * * * * * * * * * *  Protected Member Functions * * * * * * * * * * * //
+
+void Foam::nonConformalErrorPolyPatch::rename(const wordList& newNames)
+{
+    nonConformalPolyPatch::rename(newNames);
+}
+
+
+void Foam::nonConformalErrorPolyPatch::reorder(const labelUList& newToOldIndex)
+{
+    nonConformalPolyPatch::reorder(newToOldIndex);
+}
+
+
+// * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * //
+
+Foam::nonConformalErrorPolyPatch::nonConformalErrorPolyPatch
+(
+    const word& name,
+    const label size,
+    const label start,
+    const label index,
+    const polyBoundaryMesh& bm,
+    const word& patchType
+)
+:
+    polyPatch(name, size, start, index, bm, patchType),
+    nonConformalPolyPatch(static_cast<const polyPatch&>(*this))
+{}
+
+
+Foam::nonConformalErrorPolyPatch::nonConformalErrorPolyPatch
+(
+    const word& name,
+    const label size,
+    const label start,
+    const label index,
+    const polyBoundaryMesh& bm,
+    const word& patchType,
+    const word& origPatchName
+)
+:
+    polyPatch(name, size, start, index, bm, patchType),
+    nonConformalPolyPatch(static_cast<const polyPatch&>(*this), origPatchName)
+{}
+
+
+Foam::nonConformalErrorPolyPatch::nonConformalErrorPolyPatch
+(
+    const word& name,
+    const dictionary& dict,
+    const label index,
+    const polyBoundaryMesh& bm,
+    const word& patchType
+)
+:
+    polyPatch(name, dict, index, bm, patchType),
+    nonConformalPolyPatch(static_cast<const polyPatch&>(*this), dict)
+{}
+
+
+Foam::nonConformalErrorPolyPatch::nonConformalErrorPolyPatch
+(
+    const nonConformalErrorPolyPatch& pp,
+    const polyBoundaryMesh& bm
+)
+:
+    polyPatch(pp, bm),
+    nonConformalPolyPatch(static_cast<const nonConformalPolyPatch&>(pp))
+{}
+
+
+Foam::nonConformalErrorPolyPatch::nonConformalErrorPolyPatch
+(
+    const nonConformalErrorPolyPatch& pp,
+    const polyBoundaryMesh& bm,
+    const label index,
+    const label newSize,
+    const label newStart,
+    const word& origPatchName
+)
+:
+    polyPatch(pp, bm, index, newSize, newStart),
+    nonConformalPolyPatch(static_cast<const polyPatch&>(pp), origPatchName)
+{}
+
+
+Foam::nonConformalErrorPolyPatch::nonConformalErrorPolyPatch
+(
+    const nonConformalErrorPolyPatch& pp,
+    const polyBoundaryMesh& bm,
+    const label index,
+    const labelUList& mapAddressing,
+    const label newStart
+)
+:
+    polyPatch(pp, bm, index, mapAddressing, newStart),
+    nonConformalPolyPatch(static_cast<const nonConformalPolyPatch&>(pp))
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::nonConformalErrorPolyPatch::~nonConformalErrorPolyPatch()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::nonConformalErrorPolyPatch::write(Ostream& os) const
+{
+    polyPatch::write(os);
+    nonConformalPolyPatch::write(os);
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformal/polyPatches/nonConformalError/nonConformalErrorPolyPatch.H b/src/meshTools/nonConformal/polyPatches/nonConformalError/nonConformalErrorPolyPatch.H
new file mode 100644
index 0000000000..e7cc9e3bec
--- /dev/null
+++ b/src/meshTools/nonConformal/polyPatches/nonConformalError/nonConformalErrorPolyPatch.H
@@ -0,0 +1,221 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonConformalErrorPolyPatch
+
+Description
+    Non-conformal error poly patch. As nonConformalPolyPatch. This patch is a
+    non-coupled non-conformal patch which is used to manage the errors created
+    during the construction of a non-conformal coupled interface. Every patch
+    used as the original patch of the owner side of a non-conformal coupled
+    interface must also have an associated error patch.
+
+See also
+    Foam::nonConformalPolyPatch
+
+SourceFiles
+    nonConformalErrorPolyPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalErrorPolyPatch_H
+#define nonConformalErrorPolyPatch_H
+
+#include "polyPatch.H"
+#include "nonConformalPolyPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class nonConformalCyclicPolyPatch;
+
+/*---------------------------------------------------------------------------*\
+                 Class nonConformalErrorPolyPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class nonConformalErrorPolyPatch
+:
+    public polyPatch,
+    public nonConformalPolyPatch
+{
+protected:
+
+    // Protected Member Functions
+
+        //- Reset the patch name
+        virtual void rename(const wordList& newNames);
+
+        //- Reset the patch index
+        virtual void reorder(const labelUList& newToOldIndex);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("nonConformalError");
+
+
+    // Constructors
+
+        //- Construct from components
+        nonConformalErrorPolyPatch
+        (
+            const word& name,
+            const label size,
+            const label start,
+            const label index,
+            const polyBoundaryMesh& bm,
+            const word& patchType
+        );
+
+        //- Construct from components
+        nonConformalErrorPolyPatch
+        (
+            const word& name,
+            const label size,
+            const label start,
+            const label index,
+            const polyBoundaryMesh& bm,
+            const word& patchType,
+            const word& origPatchName
+        );
+
+        //- Construct from dictionary
+        nonConformalErrorPolyPatch
+        (
+            const word& name,
+            const dictionary& dict,
+            const label index,
+            const polyBoundaryMesh& bm,
+            const word& patchType
+        );
+
+        //- Construct as copy, resetting the boundary mesh
+        nonConformalErrorPolyPatch
+        (
+            const nonConformalErrorPolyPatch&,
+            const polyBoundaryMesh&
+        );
+
+        //- Construct given the original patch and resetting the
+        //  face list and boundary mesh information
+        nonConformalErrorPolyPatch
+        (
+            const nonConformalErrorPolyPatch& pp,
+            const polyBoundaryMesh& bm,
+            const label index,
+            const label newSize,
+            const label newStart,
+            const word& origPatchName
+        );
+
+        //- Construct given the original patch and a map
+        nonConformalErrorPolyPatch
+        (
+            const nonConformalErrorPolyPatch& pp,
+            const polyBoundaryMesh& bm,
+            const label index,
+            const labelUList& mapAddressing,
+            const label newStart
+        );
+
+        //- Construct and return a clone, resetting the boundary mesh
+        virtual autoPtr<polyPatch> clone(const polyBoundaryMesh& bm) const
+        {
+            return autoPtr<polyPatch>
+            (
+                new nonConformalErrorPolyPatch(*this, bm)
+            );
+        }
+
+        //- Construct and return a clone, resetting the face list
+        //  and boundary mesh
+        virtual autoPtr<polyPatch> clone
+        (
+            const polyBoundaryMesh& bm,
+            const label index,
+            const label newSize,
+            const label newStart
+        ) const
+        {
+            return autoPtr<polyPatch>
+            (
+                new nonConformalErrorPolyPatch
+                (
+                    *this,
+                    bm,
+                    index,
+                    newSize,
+                    newStart,
+                    origPatchName()
+                )
+            );
+        }
+
+        //- Construct and return a clone, resetting the face list
+        //  and boundary mesh
+        virtual autoPtr<polyPatch> clone
+        (
+            const polyBoundaryMesh& bm,
+            const label index,
+            const labelUList& mapAddressing,
+            const label newStart
+        ) const
+        {
+            return autoPtr<polyPatch>
+            (
+                new nonConformalErrorPolyPatch
+                (
+                    *this,
+                    bm,
+                    index,
+                    mapAddressing,
+                    newStart
+                )
+            );
+        }
+
+
+    //- Destructor
+    virtual ~nonConformalErrorPolyPatch();
+
+
+    // Member Functions
+
+        //- Write the polyPatch data as a dictionary
+        virtual void write(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformal/polyPatches/nonConformalProcessorCyclic/nonConformalProcessorCyclicPolyPatch.C b/src/meshTools/nonConformal/polyPatches/nonConformalProcessorCyclic/nonConformalProcessorCyclicPolyPatch.C
new file mode 100644
index 0000000000..d8a34d00ef
--- /dev/null
+++ b/src/meshTools/nonConformal/polyPatches/nonConformalProcessorCyclic/nonConformalProcessorCyclicPolyPatch.C
@@ -0,0 +1,188 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalProcessorCyclicPolyPatch.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(nonConformalProcessorCyclicPolyPatch, 0);
+    addToRunTimeSelectionTable
+    (
+        polyPatch,
+        nonConformalProcessorCyclicPolyPatch,
+        dictionary
+    );
+}
+
+// * * * * * * * * * * * *  Protected Member Functions * * * * * * * * * * * //
+
+void Foam::nonConformalProcessorCyclicPolyPatch::rename
+(
+    const wordList& newNames
+)
+{
+    processorCyclicPolyPatch::rename(newNames);
+    nonConformalCoupledPolyPatch::rename(newNames);
+}
+
+
+void Foam::nonConformalProcessorCyclicPolyPatch::reorder
+(
+    const labelUList& newToOldIndex
+)
+{
+    processorCyclicPolyPatch::reorder(newToOldIndex);
+    nonConformalCoupledPolyPatch::reorder(newToOldIndex);
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::nonConformalProcessorCyclicPolyPatch::
+nonConformalProcessorCyclicPolyPatch
+(
+    const label size,
+    const label start,
+    const label index,
+    const polyBoundaryMesh& bm,
+    const int myProcNo,
+    const int neighbProcNo,
+    const word& referPatchName,
+    const word& origPatchName,
+    const word& patchType
+)
+:
+    processorCyclicPolyPatch
+    (
+        newName(referPatchName, myProcNo, neighbProcNo),
+        size,
+        start,
+        index,
+        bm,
+        myProcNo,
+        neighbProcNo,
+        referPatchName,
+        patchType
+    ),
+    nonConformalCoupledPolyPatch
+    (
+        static_cast<const polyPatch&>(*this),
+        origPatchName
+    )
+{}
+
+
+Foam::nonConformalProcessorCyclicPolyPatch::
+nonConformalProcessorCyclicPolyPatch
+(
+    const word& name,
+    const dictionary& dict,
+    const label index,
+    const polyBoundaryMesh& bm,
+    const word& patchType
+)
+:
+    processorCyclicPolyPatch(name, dict, index, bm, patchType),
+    nonConformalCoupledPolyPatch(static_cast<const polyPatch&>(*this), dict)
+{}
+
+
+Foam::nonConformalProcessorCyclicPolyPatch::
+nonConformalProcessorCyclicPolyPatch
+(
+    const nonConformalProcessorCyclicPolyPatch& pp,
+    const polyBoundaryMesh& bm
+)
+:
+    processorCyclicPolyPatch(pp, bm),
+    nonConformalCoupledPolyPatch
+    (
+        static_cast<const nonConformalCoupledPolyPatch&>(pp)
+    )
+{}
+
+
+Foam::nonConformalProcessorCyclicPolyPatch::
+nonConformalProcessorCyclicPolyPatch
+(
+    const nonConformalProcessorCyclicPolyPatch& pp,
+    const polyBoundaryMesh& bm,
+    const label index,
+    const label newSize,
+    const label newStart
+)
+:
+    processorCyclicPolyPatch(pp, bm, index, newSize, newStart),
+    nonConformalCoupledPolyPatch
+    (
+        static_cast<const nonConformalCoupledPolyPatch&>(pp)
+    )
+{}
+
+
+Foam::nonConformalProcessorCyclicPolyPatch::
+nonConformalProcessorCyclicPolyPatch
+(
+    const nonConformalProcessorCyclicPolyPatch& pp,
+    const polyBoundaryMesh& bm,
+    const label index,
+    const labelUList& mapAddressing,
+    const label newStart
+)
+:
+    processorCyclicPolyPatch(pp, bm, index, mapAddressing, newStart),
+    nonConformalCoupledPolyPatch
+    (
+        static_cast<const nonConformalCoupledPolyPatch&>(pp)
+    )
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::nonConformalProcessorCyclicPolyPatch::
+~nonConformalProcessorCyclicPolyPatch()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool Foam::nonConformalProcessorCyclicPolyPatch::coupled() const
+{
+    return false;
+}
+
+
+void Foam::nonConformalProcessorCyclicPolyPatch::write(Ostream& os) const
+{
+    processorCyclicPolyPatch::write(os);
+    nonConformalCoupledPolyPatch::write(os);
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformal/polyPatches/nonConformalProcessorCyclic/nonConformalProcessorCyclicPolyPatch.H b/src/meshTools/nonConformal/polyPatches/nonConformalProcessorCyclic/nonConformalProcessorCyclicPolyPatch.H
new file mode 100644
index 0000000000..a7ad79cbb6
--- /dev/null
+++ b/src/meshTools/nonConformal/polyPatches/nonConformalProcessorCyclic/nonConformalProcessorCyclicPolyPatch.H
@@ -0,0 +1,226 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonConformalProcessorCyclicPolyPatch
+
+Description
+    Non-conformal processor cyclic poly patch. As nonConformalCyclicPolyPatch,
+    but the neighbouring patch is on a different processor.
+
+See also
+    Foam::nonConformalCyclicPatch
+
+SourceFiles
+    nonConformalProcessorCyclicPolyPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalProcessorCyclicPolyPatch_H
+#define nonConformalProcessorCyclicPolyPatch_H
+
+#include "processorCyclicPolyPatch.H"
+#include "nonConformalCyclicPolyPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                  Class nonConformalProcessorCyclicPolyPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class nonConformalProcessorCyclicPolyPatch
+:
+    public processorCyclicPolyPatch,
+    public nonConformalCoupledPolyPatch
+{
+protected:
+
+    // Protected Member Functions
+
+        //- Reset the patch name
+        virtual void rename(const wordList& newNames);
+
+        //- Reset the patch index
+        virtual void reorder(const labelUList& newToOldIndex);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("nonConformalProcessorCyclic");
+
+
+    // Constructors
+
+        //- Construct from components
+        nonConformalProcessorCyclicPolyPatch
+        (
+            const label size,
+            const label start,
+            const label index,
+            const polyBoundaryMesh& bm,
+            const int myProcNo,
+            const int neighbProcNo,
+            const word& referPatchName,
+            const word& origPatchName,
+            const word& patchType = typeName
+        );
+
+        //- Construct from dictionary
+        nonConformalProcessorCyclicPolyPatch
+        (
+            const word& name,
+            const dictionary& dict,
+            const label index,
+            const polyBoundaryMesh&,
+            const word& patchType
+        );
+
+        //- Construct as copy, resetting the boundary mesh
+        nonConformalProcessorCyclicPolyPatch
+        (
+            const nonConformalProcessorCyclicPolyPatch&,
+            const polyBoundaryMesh&
+        );
+
+        //- Construct as given the original patch and resetting the
+        //  face list and boundary mesh information
+        nonConformalProcessorCyclicPolyPatch
+        (
+            const nonConformalProcessorCyclicPolyPatch& pp,
+            const polyBoundaryMesh& bm,
+            const label index,
+            const label newSize,
+            const label newStart
+        );
+
+        //- Construct given the original patch and a map
+        nonConformalProcessorCyclicPolyPatch
+        (
+            const nonConformalProcessorCyclicPolyPatch& pp,
+            const polyBoundaryMesh& bm,
+            const label index,
+            const labelUList& mapAddressing,
+            const label newStart
+        );
+
+        //- Construct and return a clone, resetting the boundary mesh
+        virtual autoPtr<polyPatch> clone(const polyBoundaryMesh& bm) const
+        {
+            return autoPtr<polyPatch>
+            (
+                new nonConformalProcessorCyclicPolyPatch(*this, bm)
+            );
+        }
+
+        //- Construct and return a clone, resetting the face list
+        //  and boundary mesh
+        virtual autoPtr<polyPatch> clone
+        (
+            const polyBoundaryMesh& bm,
+            const label index,
+            const label newSize,
+            const label newStart
+        ) const
+        {
+            return autoPtr<polyPatch>
+            (
+                new nonConformalProcessorCyclicPolyPatch
+                (
+                    *this,
+                    bm,
+                    index,
+                    newSize,
+                    newStart
+                )
+            );
+        }
+
+        //- Construct and return a clone, resetting the face list
+        //  and boundary mesh
+        virtual autoPtr<polyPatch> clone
+        (
+            const polyBoundaryMesh& bm,
+            const label index,
+            const labelUList& mapAddressing,
+            const label newStart
+        ) const
+        {
+            return autoPtr<polyPatch>
+            (
+                new nonConformalProcessorCyclicPolyPatch
+                (
+                    *this,
+                    bm,
+                    index,
+                    mapAddressing,
+                    newStart
+                )
+            );
+        }
+
+
+    // Destructor
+    virtual ~nonConformalProcessorCyclicPolyPatch();
+
+
+    // Member Functions
+
+        //- Get the referred patch
+        const nonConformalCyclicPolyPatch& referPatch() const
+        {
+            const polyPatch& pp = this->boundaryMesh()[referPatchID()];
+            return refCast<const nonConformalCyclicPolyPatch>(pp);
+        }
+
+        //- Inherit the processor cyclic owner method
+        using processorCyclicPolyPatch::owner;
+
+        //- Inherit the processor cyclic neighbour method
+        using processorCyclicPolyPatch::neighbour;
+
+        //- Inherit the processor cyclic transform method
+        using processorCyclicPolyPatch::transform;
+
+        //- Is this patch coupled? Returns false. For NCC patches the poly
+        //  mesh is considered non-coupled whilst the finite volume mesh is
+        //  considered coupled.
+        virtual bool coupled() const;
+
+        //- Write the polyPatch data as a dictionary
+        virtual void write(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformalBoundary/nonConformalBoundary.C b/src/meshTools/nonConformalBoundary/nonConformalBoundary.C
new file mode 100644
index 0000000000..2f57f33b62
--- /dev/null
+++ b/src/meshTools/nonConformalBoundary/nonConformalBoundary.C
@@ -0,0 +1,640 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonConformalBoundary.H"
+#include "nonConformalCoupledPolyPatch.H"
+#include "nonConformalErrorPolyPatch.H"
+#include "syncTools.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+template<class FaceList, class PointField>
+edge meshEdge
+(
+    const PrimitivePatch<FaceList, PointField>& p,
+    const label edgei
+)
+{
+    return edge
+    (
+        p.meshPoints()[p.edges()[edgei][0]],
+        p.meshPoints()[p.edges()[edgei][1]]
+    );
+}
+
+}
+
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(nonConformalBoundary, 0);
+}
+
+
+// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
+
+Foam::indirectPrimitivePatch
+Foam::nonConformalBoundary::boundary(const labelList& patches) const
+{
+    DynamicList<label> faces;
+    forAll(patches, i)
+    {
+        const polyPatch& pp = mesh_.boundaryMesh()[patches[i]];
+
+        faces.append(identity(pp.size()) + pp.start());
+    }
+
+    return
+        indirectPrimitivePatch
+        (
+            IndirectList<face>(mesh_.faces(), faces),
+            mesh_.points()
+        );
+}
+
+
+const Foam::labelList&
+Foam::nonConformalBoundary::meshPointOwnerOrigBoundaryPoint() const
+{
+    if (!meshPointOwnerOrigBoundaryPointPtr_.valid())
+    {
+        meshPointOwnerOrigBoundaryPointPtr_.set
+        (
+            new labelList(mesh_.nPoints(), -1)
+        );
+
+        forAll(ownerOrigBoundary_.meshPoints(), ownerOrigBoundaryPointi)
+        {
+            meshPointOwnerOrigBoundaryPointPtr_()
+                [ownerOrigBoundary_.meshPoints()[ownerOrigBoundaryPointi]] =
+                ownerOrigBoundaryPointi;
+        }
+    }
+
+    return meshPointOwnerOrigBoundaryPointPtr_();
+}
+
+
+const Foam::vectorField&
+Foam::nonConformalBoundary::ownerOrigBoundaryPointNormals() const
+{
+    if (!ownerOrigBoundaryPointNormalsPtr_.valid())
+    {
+        const faceList& faces = ownerOrigBoundary_.localFaces();
+        const vectorField faceNormals = ownerOrigBoundary_.faceNormals();
+
+        vectorField pointNormals(ownerOrigBoundary_.nPoints(), Zero);
+
+        forAll(faces, facei)
+        {
+            forAll(faces[facei], facePointi)
+            {
+                pointNormals[faces[facei][facePointi]] += faceNormals[facei];
+            }
+        }
+
+        syncTools::syncPointList
+        (
+            mesh_,
+            ownerOrigBoundary_.meshPoints(),
+            pointNormals,
+            plusEqOp<vector>(),
+            vector::zero
+        );
+
+        ownerOrigBoundaryPointNormalsPtr_.set
+        (
+            (pointNormals/(mag(pointNormals) + vSmall)).ptr()
+        );
+    }
+
+    return ownerOrigBoundaryPointNormalsPtr_();
+}
+
+
+const Foam::vectorField&
+Foam::nonConformalBoundary::ownerOrigBoundaryPointNormals0() const
+{
+    if (!ownerOrigBoundaryPointNormals0Ptr_.valid())
+    {
+        const faceList& faces = ownerOrigBoundary_.localFaces();
+
+        vectorField pointNormals(ownerOrigBoundary_.nPoints(), Zero);
+
+        forAll(faces, facei)
+        {
+            forAll(faces[facei], facePointi)
+            {
+                pointNormals[faces[facei][facePointi]] +=
+                    faces[facei].normal(mesh_.oldPoints());
+            }
+        }
+
+        syncTools::syncPointList
+        (
+            mesh_,
+            ownerOrigBoundary_.meshPoints(),
+            pointNormals,
+            plusEqOp<vector>(),
+            vector::zero
+        );
+
+        ownerOrigBoundaryPointNormals0Ptr_.set
+        (
+            (pointNormals/(mag(pointNormals) + vSmall)).ptr()
+        );
+    }
+
+    return ownerOrigBoundaryPointNormals0Ptr_();
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::nonConformalBoundary::nonConformalBoundary(const polyMesh& mesh)
+:
+    MeshObject<polyMesh, MoveableMeshObject, nonConformalBoundary>(mesh),
+    ownerOrigBoundary_(boundary(ownerOrigPatchIDs())),
+    meshPointOwnerOrigBoundaryPointPtr_(nullptr),
+    ownerOrigBoundaryPointMeshPointPtr_(nullptr),
+    ownerOrigBoundaryEdgeMeshEdgePtr_(nullptr),
+    ownerOrigBoundaryEdgesPtr_(nullptr),
+    ownerOrigBoundaryMeshEdgesPtr_(nullptr),
+    patchPointOwnerOrigBoundaryPointsPtr_(mesh.boundaryMesh().size()),
+    patchEdgeOwnerOrigBoundaryEdgesPtr_(mesh.boundaryMesh().size()),
+    ownerOrigBoundaryPointNormalsPtr_(nullptr)
+{
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::nonConformalBoundary::~nonConformalBoundary()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+bool Foam::nonConformalBoundary::movePoints()
+{
+    ownerOrigBoundary_.clearGeom();
+
+    ownerOrigBoundaryPointNormalsPtr_.clear();
+
+    return true;
+}
+
+
+Foam::labelList Foam::nonConformalBoundary::nonConformalNonCoupledPatchIDs
+(
+    const label side,
+    label (nonConformalCoupledPolyPatch::*method)() const
+) const
+{
+    const polyBoundaryMesh& pbm = mesh_.boundaryMesh();
+
+    labelHashSet origPatchIDTable;
+    DynamicList<label> nonCoupledPatchIDs(pbm.size());
+
+    forAll(pbm, nccPatchi)
+    {
+        const polyPatch& pp = pbm[nccPatchi];
+
+        if (isA<nonConformalCoupledPolyPatch>(pp))
+        {
+            const nonConformalCoupledPolyPatch& nccPp =
+                refCast<const nonConformalCoupledPolyPatch>(pbm[nccPatchi]);
+
+            if (side == 1 && !nccPp.owner()) continue;
+
+            if (side == -1 && !nccPp.neighbour()) continue;
+
+            if (origPatchIDTable.found(nccPp.origPatchID())) continue;
+
+            origPatchIDTable.insert(nccPp.origPatchID());
+            nonCoupledPatchIDs.append((nccPp.*method)());
+        }
+    }
+
+    labelList result;
+    result.transfer(nonCoupledPatchIDs);
+    return result;
+}
+
+
+Foam::labelList Foam::nonConformalBoundary::allOrigPatchIDs() const
+{
+    auto method = &nonConformalCoupledPolyPatch::origPatchID;
+    return nonConformalNonCoupledPatchIDs(0, method);
+}
+
+
+Foam::labelList Foam::nonConformalBoundary::allErrorPatchIDs() const
+{
+    auto method = &nonConformalCoupledPolyPatch::errorPatchID;
+    return nonConformalNonCoupledPatchIDs(0, method);
+}
+
+
+Foam::labelList Foam::nonConformalBoundary::ownerOrigPatchIDs() const
+{
+    auto method = &nonConformalCoupledPolyPatch::origPatchID;
+    return nonConformalNonCoupledPatchIDs(1, method);
+}
+
+
+Foam::labelList Foam::nonConformalBoundary::ownerErrorPatchIDs() const
+{
+    auto method = &nonConformalCoupledPolyPatch::errorPatchID;
+    return nonConformalNonCoupledPatchIDs(1, method);
+}
+
+
+const Foam::labelList&
+Foam::nonConformalBoundary::ownerOrigBoundaryPointMeshPoint() const
+{
+    if (!ownerOrigBoundaryPointMeshPointPtr_.valid())
+    {
+        ownerOrigBoundaryPointMeshPointPtr_.set
+        (
+            new labelList(ownerOrigBoundary_.meshPoints())
+        );
+
+        // ...
+        meshPointOwnerOrigBoundaryPoint();
+        labelList& map = meshPointOwnerOrigBoundaryPointPtr_();
+
+        // ...
+        label ownerOrigBoundaryPointi = ownerOrigBoundary_.nPoints();
+        DynamicList<label> remotePoints;
+
+        // ...
+        for
+        (
+            label ownerOrigBoundaryEdgei = ownerOrigBoundary_.nEdges();
+            ownerOrigBoundaryEdgei < ownerOrigBoundaryEdgeMeshEdge().size();
+            ++ ownerOrigBoundaryEdgei
+        )
+        {
+            const label meshEdgei =
+                ownerOrigBoundaryEdgeMeshEdge()[ownerOrigBoundaryEdgei];
+
+            const edge& e = mesh_.edges()[meshEdgei];
+
+            forAll(e, i)
+            {
+                const label meshPointi = e[i];
+
+                if (map[meshPointi] == -1)
+                {
+                    map[meshPointi] = ownerOrigBoundaryPointi ++;
+                    remotePoints.append(meshPointi);
+                }
+            }
+        }
+
+        // ...
+        ownerOrigBoundaryPointMeshPointPtr_->append(remotePoints);
+    }
+
+    return ownerOrigBoundaryPointMeshPointPtr_();
+}
+
+
+const Foam::labelList&
+Foam::nonConformalBoundary::ownerOrigBoundaryEdgeMeshEdge() const
+{
+    if (!ownerOrigBoundaryEdgeMeshEdgePtr_.valid())
+    {
+        // Create boundary of all owner-orig and proc patches
+        labelList ownerOrigAndProcPatchIDs = this->ownerOrigPatchIDs();
+        forAll(mesh_.boundaryMesh(), patchi)
+        {
+            if (isA<processorPolyPatch>(mesh_.boundaryMesh()[patchi]))
+            {
+                ownerOrigAndProcPatchIDs.append(patchi);
+            }
+        }
+        const indirectPrimitivePatch ownerOrigAndProcBoundary
+        (
+            boundary(ownerOrigAndProcPatchIDs)
+        );
+
+        // Create the mesh edge mapping for the owner-orig-and-proc boundary
+        labelList ownerOrigAndProcBoundaryMeshEdges
+        (
+            ownerOrigAndProcBoundary.meshEdges
+            (
+                mesh_.edges(),
+                mesh_.pointEdges()
+            )
+        );
+
+        // Map from owner-orig to owner-orig-and-proc edge
+        const labelList map =
+            primitivePatch
+            (
+                SubList<face>
+                (
+                    ownerOrigAndProcBoundary.localFaces(),
+                    ownerOrigBoundary_.size()
+                ),
+                ownerOrigAndProcBoundary.localPoints()
+            )
+           .meshEdges
+            (
+                ownerOrigAndProcBoundary.edges(),
+                ownerOrigAndProcBoundary.pointEdges()
+            );
+
+        // Initialise the mapping for the owner-orig boundary. Note, this only
+        // connects edges that are part of the local owner-orig boundary. Edges
+        // that are connected to the owner-orig boundary on a different process
+        // are added below.
+        ownerOrigBoundaryEdgeMeshEdgePtr_.set
+        (
+            new labelList
+            (
+                labelField(ownerOrigAndProcBoundaryMeshEdges, map)
+            )
+        );
+
+        // Create a reverse map from owner-orig-and-proc to owner-orig edge
+        labelList rMap(ownerOrigAndProcBoundary.nEdges(), -1);
+        forAll(map, i)
+        {
+            rMap[map[i]] = i;
+        }
+
+        // Synchronise
+        syncTools::syncEdgeList
+        (
+            mesh_,
+            ownerOrigAndProcBoundaryMeshEdges,
+            rMap,
+            maxEqOp<label>(),
+            -1
+        );
+
+        // Remove all local indexing from the map
+        forAll(map, i)
+        {
+            rMap[map[i]] = -1;
+        }
+
+        // Any valid rMap entries now refer to edges that are remotely
+        // connected to the owner-orig boundary. Append them to the addressing.
+        DynamicList<label> remoteMeshEdges;
+        forAll(rMap, i)
+        {
+            if (rMap[i] != -1)
+            {
+                remoteMeshEdges.append(ownerOrigAndProcBoundaryMeshEdges[i]);
+            }
+        }
+
+        ownerOrigBoundaryEdgeMeshEdgePtr_->append(remoteMeshEdges);
+    }
+
+    return ownerOrigBoundaryEdgeMeshEdgePtr_();
+}
+
+
+const Foam::edgeList&
+Foam::nonConformalBoundary::ownerOrigBoundaryEdges() const
+{
+    if (!ownerOrigBoundaryEdgesPtr_.valid())
+    {
+        ownerOrigBoundaryEdgesPtr_.set
+        (
+            new edgeList(ownerOrigBoundary_.edges())
+        );
+
+        const labelList& map = meshPointOwnerOrigBoundaryPoint();
+
+        DynamicList<edge> remoteEdges;
+
+        for
+        (
+            label ownerOrigBoundaryEdgei = ownerOrigBoundary_.nEdges();
+            ownerOrigBoundaryEdgei < ownerOrigBoundaryEdgeMeshEdge().size();
+            ++ ownerOrigBoundaryEdgei
+        )
+        {
+            const label meshEdgei =
+                ownerOrigBoundaryEdgeMeshEdge()[ownerOrigBoundaryEdgei];
+
+            const edge& e = mesh_.edges()[meshEdgei];
+
+            remoteEdges.append(edge(map[e.start()], map[e.end()]));
+        }
+
+        ownerOrigBoundaryEdgesPtr_->append(remoteEdges);
+    }
+
+    return ownerOrigBoundaryEdgesPtr_();
+}
+
+
+const Foam::edgeList&
+Foam::nonConformalBoundary::ownerOrigBoundaryMeshEdges() const
+{
+    if (!ownerOrigBoundaryMeshEdgesPtr_.valid())
+    {
+        const edgeList& edges = ownerOrigBoundaryEdges();
+
+        const labelList& pointMeshPoint =
+            ownerOrigBoundaryPointMeshPoint();
+
+        ownerOrigBoundaryMeshEdgesPtr_.set
+        (
+            new edgeList(edges.size())
+        );
+
+        forAll(edges, edgei)
+        {
+            ownerOrigBoundaryMeshEdgesPtr_()[edgei] =
+                edge
+                (
+                    pointMeshPoint[edges[edgei].start()],
+                    pointMeshPoint[edges[edgei].end()]
+                );
+        }
+    }
+
+    return ownerOrigBoundaryMeshEdgesPtr_();
+}
+
+
+const Foam::labelList&
+Foam::nonConformalBoundary::patchPointOwnerOrigBoundaryPoints
+(
+    const label patchi
+) const
+{
+    if (!patchPointOwnerOrigBoundaryPointsPtr_.set(patchi))
+    {
+        const polyPatch& pp = mesh_.boundaryMesh()[patchi];
+
+        const faceList patchOwnerOrigBoundaryLocalFaces
+        (
+            renumber
+            (
+                meshPointOwnerOrigBoundaryPoint(),
+                static_cast<const faceList&>(pp)
+            )
+        );
+
+        const primitivePatch ownerOrigBoundaryLocalPatch
+        (
+            SubList<face>(patchOwnerOrigBoundaryLocalFaces, pp.size()),
+            ownerOrigBoundary_.localPoints()
+        );
+
+        patchPointOwnerOrigBoundaryPointsPtr_.set
+        (
+            patchi,
+            new labelList(ownerOrigBoundaryLocalPatch.meshPoints())
+        );
+
+        patchEdgeOwnerOrigBoundaryEdgesPtr_.set
+        (
+            patchi,
+            new labelList
+            (
+                ownerOrigBoundaryLocalPatch.meshEdges
+                (
+                    ownerOrigBoundary_.edges(),
+                    ownerOrigBoundary_.pointEdges()
+                )
+            )
+        );
+
+        // Check the addressing is valid
+        if (debug)
+        {
+            const labelList& ppPointOwnerOrigBoundaryPoints =
+                patchPointOwnerOrigBoundaryPointsPtr_[patchi];
+
+            forAll(pp.meshPoints(), ppPointi)
+            {
+                const label ownerOrigBoundaryPointi =
+                    ppPointOwnerOrigBoundaryPoints[ppPointi];
+
+                if
+                (
+                    pp.meshPoints()[ppPointi]
+                 != ownerOrigBoundary_.meshPoints()[ownerOrigBoundaryPointi]
+                )
+                {
+                    FatalErrorInFunction
+                        << "Patch point does not match all boundary point"
+                        << exit(FatalError);
+                }
+            }
+
+            const labelList& ppEdgeOwnerOrigBoundaryEdges =
+                patchEdgeOwnerOrigBoundaryEdgesPtr_[patchi];
+
+            forAll(pp.edges(), ppEdgei)
+            {
+                const label ownerOrigBoundaryEdgei =
+                    ppEdgeOwnerOrigBoundaryEdges[ppEdgei];
+
+                if
+                (
+                    meshEdge(pp, ppEdgei)
+                 != meshEdge(ownerOrigBoundary_, ownerOrigBoundaryEdgei)
+                )
+                {
+                    FatalErrorInFunction
+                        << "Patch edge does not match all boundary edge"
+                        << exit(FatalError);
+                }
+            }
+        }
+    }
+
+    return patchPointOwnerOrigBoundaryPointsPtr_[patchi];
+}
+
+
+const Foam::labelList&
+Foam::nonConformalBoundary::patchEdgeOwnerOrigBoundaryEdges
+(
+    const label patchi
+) const
+{
+    if (!patchEdgeOwnerOrigBoundaryEdgesPtr_.set(patchi))
+    {
+        patchPointOwnerOrigBoundaryPoints(patchi);
+    }
+
+    return patchEdgeOwnerOrigBoundaryEdgesPtr_[patchi];
+}
+
+
+Foam::tmp<Foam::vectorField>
+Foam::nonConformalBoundary::patchPointNormals(const label patchi) const
+{
+    return
+        tmp<vectorField>
+        (
+            new vectorField
+            (
+                UIndirectList<vector>
+                (
+                    ownerOrigBoundaryPointNormals(),
+                    patchPointOwnerOrigBoundaryPoints(patchi)
+                )
+            )
+        );
+}
+
+
+Foam::tmp<Foam::vectorField>
+Foam::nonConformalBoundary::patchPointNormals0(const label patchi) const
+{
+    return
+        tmp<vectorField>
+        (
+            new vectorField
+            (
+                UIndirectList<vector>
+                (
+                    ownerOrigBoundaryPointNormals0(),
+                    patchPointOwnerOrigBoundaryPoints(patchi)
+                )
+            )
+        );
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/nonConformalBoundary/nonConformalBoundary.H b/src/meshTools/nonConformalBoundary/nonConformalBoundary.H
new file mode 100644
index 0000000000..3cb60f3b92
--- /dev/null
+++ b/src/meshTools/nonConformalBoundary/nonConformalBoundary.H
@@ -0,0 +1,196 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonConformalBoundary
+
+Description
+    Mesh object that stores an all boundary patch and mapping to and from it
+    and the mesh and the individual patches
+
+SourceFiles
+    nonConformalBoundary.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonConformalBoundary_H
+#define nonConformalBoundary_H
+
+#include "MeshObject.H"
+#include "polyMesh.H"
+#include "indirectPrimitivePatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class nonConformalCoupledPolyPatch;
+
+/*---------------------------------------------------------------------------*\
+                          Class nonConformalBoundary Declaration
+\*---------------------------------------------------------------------------*/
+
+class nonConformalBoundary
+:
+    public MeshObject<polyMesh, MoveableMeshObject, nonConformalBoundary>
+{
+    // Private Data
+
+        //- Primitive patch of the owner-orig boundary
+        indirectPrimitivePatch ownerOrigBoundary_;
+
+        //- A map from owner-orig boundary point to mesh point
+        mutable autoPtr<labelList> meshPointOwnerOrigBoundaryPointPtr_;
+
+        //- A map from owner-orig boundary point to mesh point
+        mutable autoPtr<labelList> ownerOrigBoundaryPointMeshPointPtr_;
+
+        //- A map from owner-orig boundary edge to mesh edge
+        mutable autoPtr<labelList> ownerOrigBoundaryEdgeMeshEdgePtr_;
+
+        //- Owner-orig boundary edges, referring to boundary points
+        mutable autoPtr<edgeList> ownerOrigBoundaryEdgesPtr_;
+
+        //- Owner-orig boundary edges, referring to mesh points
+        mutable autoPtr<edgeList> ownerOrigBoundaryMeshEdgesPtr_;
+
+        //- A map from patch point to owner-orig boundary points
+        mutable PtrList<labelList> patchPointOwnerOrigBoundaryPointsPtr_;
+
+        //- A map from patch edge to owner-orig boundary edge
+        mutable PtrList<labelList> patchEdgeOwnerOrigBoundaryEdgesPtr_;
+
+        //- Point normals for the owner-orig boundary
+        mutable autoPtr<vectorField> ownerOrigBoundaryPointNormalsPtr_;
+
+        //- Old point normals for the owner-orig boundary
+        mutable autoPtr<vectorField> ownerOrigBoundaryPointNormals0Ptr_;
+
+
+    // Private Member Functions
+
+        //- Construct a boundary for the given patch set
+        indirectPrimitivePatch boundary(const labelList& patches) const;
+
+        //- Get a map from mesh point to owner-orig boundary points. Non
+        //  owner-orig boundary points are indicated by the value -1.
+        const labelList& meshPointOwnerOrigBoundaryPoint() const;
+
+        //- Get point normals for the owner-orig boundary
+        const vectorField& ownerOrigBoundaryPointNormals() const;
+
+        //- Get old point normals for the owner-orig boundary
+        const vectorField& ownerOrigBoundaryPointNormals0() const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("nonConformalBoundary");
+
+
+    // Constructors
+
+        //- Construct from a mesh
+        nonConformalBoundary(const polyMesh& mesh);
+
+        //- Disallow default bitwise copy construction
+        nonConformalBoundary(const nonConformalBoundary&) = delete;
+
+
+    //- Destructor
+    ~nonConformalBoundary();
+
+
+    // Member Functions
+
+        //- Update for mesh motion
+        virtual bool movePoints();
+
+        //- Return a list of non-conformal non-coupled patch indices
+        labelList nonConformalNonCoupledPatchIDs
+        (
+            const label side,
+            label (nonConformalCoupledPolyPatch::*method)() const
+        ) const;
+
+        //- Return a list of the orig patch indices
+        labelList allOrigPatchIDs() const;
+
+        //- Return a list of the error patch indices
+        labelList allErrorPatchIDs() const;
+
+        //- Return a list of the owner-orig patch indices
+        labelList ownerOrigPatchIDs() const;
+
+        //- Return a list of the owner error patch indices
+        labelList ownerErrorPatchIDs() const;
+
+        //- Get a map from owner-orig boundary point to mesh point
+        const labelList& ownerOrigBoundaryPointMeshPoint() const;
+
+        //- Get a map from owner-orig boundary edge to mesh edge
+        const labelList& ownerOrigBoundaryEdgeMeshEdge() const;
+
+        //- Get the owner-orig boundary edges, referring to boundary points
+        const edgeList& ownerOrigBoundaryEdges() const;
+
+        //- Get the owner-orig boundary edges, referring to mesh points
+        const edgeList& ownerOrigBoundaryMeshEdges() const;
+
+        //- Get a map from patch point to owner-orig boundary point
+        const labelList& patchPointOwnerOrigBoundaryPoints
+        (
+            const label patchi
+        ) const;
+
+        //- Get a map from patch edge to owner-orig boundary edge
+        const labelList& patchEdgeOwnerOrigBoundaryEdges
+        (
+            const label patchi
+        ) const;
+
+        //- Get parallel consistent point normals for the patch
+        tmp<vectorField> patchPointNormals(const label patchi) const;
+
+        //- Get parallel consistent old-time point normals for the patch
+        tmp<vectorField> patchPointNormals0(const label patchi) const;
+
+
+    // Member Operators
+
+        //- Disallow default bitwise assignment
+        void operator=(const nonConformalBoundary&) = delete;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/parallel/Allwmake b/src/parallel/Allwmake
index a588a2b796..e5062a5d0d 100755
--- a/src/parallel/Allwmake
+++ b/src/parallel/Allwmake
@@ -5,7 +5,7 @@ cd ${0%/*} || exit 1    # Run from this directory
 . $WM_PROJECT_DIR/wmake/scripts/AllwmakeParseArguments
 
 decompose/Allwmake $targetType $*
-reconstruct/Allwmake $targetType $*
+wmake $targetType parallel
 wmake $targetType distributed
 
 #------------------------------------------------------------------------------
diff --git a/src/parallel/parallel/Make/files b/src/parallel/parallel/Make/files
new file mode 100644
index 0000000000..aa49671549
--- /dev/null
+++ b/src/parallel/parallel/Make/files
@@ -0,0 +1,6 @@
+processorRunTimes.C
+domainDecomposition.C
+domainDecompositionDecompose.C
+domainDecompositionReconstruct.C
+
+LIB = $(FOAM_LIBBIN)/libparallel
diff --git a/src/parallel/parallel/Make/options b/src/parallel/parallel/Make/options
new file mode 100644
index 0000000000..5bc023c831
--- /dev/null
+++ b/src/parallel/parallel/Make/options
@@ -0,0 +1,11 @@
+EXE_INC = \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/parallel/decompose/decompositionMethods/lnInclude \
+    -I$(LIB_SRC)/dynamicMesh/lnInclude
+
+LIB_LIBS = \
+    -lfiniteVolume \
+    -lmeshTools \
+    -ldecompositionMethods -L$(FOAM_LIBBIN)/dummy -lmetisDecomp -lscotchDecomp \
+    -ldynamicMesh
diff --git a/src/parallel/parallel/domainDecomposition.C b/src/parallel/parallel/domainDecomposition.C
new file mode 100644
index 0000000000..8312927f5d
--- /dev/null
+++ b/src/parallel/parallel/domainDecomposition.C
@@ -0,0 +1,1679 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "domainDecomposition.H"
+#include "decompositionMethod.H"
+#include "IOobjectList.H"
+#include "cellSet.H"
+#include "faceSet.H"
+#include "pointSet.H"
+#include "hexRef8Data.H"
+#include "cyclicFvPatch.H"
+#include "processorCyclicFvPatch.H"
+#include "nonConformalCyclicFvPatch.H"
+#include "nonConformalProcessorCyclicFvPatch.H"
+#include "nonConformalErrorFvPatch.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(domainDecomposition, 0);
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::domainDecomposition::decomposePoints()
+{
+    for (label proci = 0; proci < nProcs(); proci++)
+    {
+        fvMesh& procMesh = procMeshes_[proci];
+
+        const label pointsCompare =
+            compareInstances
+            (
+                completeMesh().pointsInstance(),
+                procMeshes_[proci].pointsInstance()
+            );
+
+        if (pointsCompare == -1)
+        {
+            procMesh.movePoints
+            (
+                pointField
+                (
+                    completeMesh().points(),
+                    procPointAddressing_[proci]
+                )
+            );
+            procMesh.moving(false);
+        }
+    }
+}
+
+
+void Foam::domainDecomposition::reconstructPoints()
+{
+    const label pointsCompare =
+        compareInstances
+        (
+            completeMesh().pointsInstance(),
+            procMeshes_[0].pointsInstance()
+        );
+
+    if (pointsCompare == 1)
+    {
+        pointField completePoints(completeMesh().nPoints());
+
+        for (label proci = 0; proci < nProcs(); proci++)
+        {
+            const fvMesh& procMesh = procMeshes_[proci];
+
+            completePoints.rmap(procMesh.points(), procPointAddressing_[proci]);
+        }
+
+        completeMesh_->movePoints(completePoints);
+        completeMesh_->moving(false);
+    }
+}
+
+
+bool Foam::domainDecomposition::completeConformal() const
+{
+    return completeMesh().conformal();
+}
+
+
+bool Foam::domainDecomposition::procsConformal() const
+{
+    forAll(procMeshes_, proci)
+    {
+        if (!procMeshes_[proci].conformal())
+        {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+
+void Foam::domainDecomposition::unconform()
+{
+    // ...
+    auto checkNonConformalCoupledPatchOrdering = []
+    (
+        const labelPair& procs,
+        const fvPatch& fvp,
+        const fvPatch& nbrFvp,
+        const labelList& polyFacesPf,
+        const labelList& nbrPolyFacesPf
+    )
+    {
+        if (fvp.size() != nbrFvp.size())
+        {
+            FatalErrorInFunction
+                << "Coupled patches " << fvp.name() << " and "
+                << nbrFvp.name() << " are not the same size"
+                << exit(FatalError);
+        }
+
+        if (fvp.size())
+        {
+            for (label i = 1; i < fvp.size(); ++ i)
+            {
+                if
+                (
+                    polyFacesPf[i - 1] > polyFacesPf[i]
+                  ? true
+                  : polyFacesPf[i - 1] == polyFacesPf[i]
+                  ? nbrPolyFacesPf[i - 1] >= nbrPolyFacesPf[i]
+                  : false
+                )
+                {
+                    FatalErrorInFunction
+                        << "Coupled patches " << fvp.name()
+                        << " and " << nbrFvp.name()
+                        << " are not in order";
+
+                    if (procs[0] == procs[1])
+                    {
+                        FatalErrorInFunction
+                            << " on process #" << procs[0];
+                    }
+
+                    FatalErrorInFunction
+                        << exit(FatalError);
+                }
+            }
+        }
+
+        InfoInFunction
+            << "Coupled patches " << fvp.name()
+            << " and " << nbrFvp.name()
+            << " are in order" << endl;
+    };
+
+    // ...
+    auto checkNonConformalErrorPatchOrdering = []
+    (
+        const label& proci,
+        const fvPatch& fvp,
+        const labelList& polyFacesPf
+    )
+    {
+        if (fvp.size())
+        {
+            for (label i = 1; i < fvp.size(); ++ i)
+            {
+                if (polyFacesPf[i - 1] > polyFacesPf[i])
+                {
+                    FatalErrorInFunction
+                        << "Error patch " << fvp.name()
+                        << " is not in order";
+
+                    if (proci > 0)
+                    {
+                        FatalErrorInFunction
+                            << " on process #" << proci;
+                    }
+
+                    FatalErrorInFunction
+                        << exit(FatalError);
+                }
+            }
+        }
+
+        InfoInFunction
+            << "Error patch " << fvp.name()
+            << " is in order" << endl;
+    };
+
+    if (completeConformal() && procsConformal())
+    {
+        // Nothing to do
+    }
+    else if (!completeConformal() && procsConformal())
+    {
+        // Construct the reverse of proc-face-face addressing
+        labelList faceProcFace(completeMesh().nFaces(), -labelMax);
+        forAll(procMeshes_, proci)
+        {
+            forAll(procFaceAddressing()[proci], procFacei)
+            {
+                const label facei =
+                    mag(procFaceAddressing()[proci][procFacei]) - 1;
+
+                faceProcFace[facei] =
+                    faceProcFace[facei] == -labelMax ? procFacei : -1;
+            }
+        }
+
+        // Map the polyFacesBf from the complete to the processor meshes and
+        // unconform the processor meshes. Set dummy data for the face
+        // geometry. This should not be used during decomposition.
+        forAll(procMeshes_, proci)
+        {
+            fvMesh& procMesh = procMeshes_[proci];
+
+            const surfaceLabelField::Boundary& faceAddressingBf =
+                procFaceAddressingBf()[proci];
+
+            surfaceLabelField::Boundary polyFacesBf
+            (
+                surfaceLabelField::null(),
+                procMesh.polyFacesBf()
+            );
+            surfaceVectorField Sf(procMesh.Sf().cloneUnSliced());
+            surfaceVectorField Cf(procMesh.Cf().cloneUnSliced());
+
+            forAll(procMesh.boundary(), procNccPatchi)
+            {
+                const fvPatch& fvp = procMesh.boundary()[procNccPatchi];
+
+                if (isA<nonConformalFvPatch>(fvp))
+                {
+                    const label completeNccPatchi =
+                        isA<processorCyclicFvPatch>(fvp)
+                      ? refCast<const processorCyclicFvPatch>(fvp)
+                       .referPatchID()
+                      : procNccPatchi;
+
+                    polyFacesBf[procNccPatchi] =
+                        labelField
+                        (
+                            faceProcFace,
+                            labelField
+                            (
+                                completeMesh().polyFacesBf()[completeNccPatchi],
+                                mag(faceAddressingBf[procNccPatchi]) - 1
+                            )
+                        );
+
+                    const label size = polyFacesBf[procNccPatchi].size();
+
+                    Sf.boundaryFieldRef()[procNccPatchi].resize(size, Zero);
+                    Cf.boundaryFieldRef()[procNccPatchi].resize(size, Zero);
+                }
+            }
+
+            procMesh.unconform
+            (
+                polyFacesBf,
+                Sf,
+                Cf,
+                NullObjectRef<surfaceScalarField>(),
+                false
+            );
+        }
+
+        // Check ordering
+        if (debug)
+        {
+            forAll(procMeshes_, proci)
+            {
+                forAll(procMeshes_[proci].boundary(), patchi)
+                {
+                    const fvPatch& fvp =
+                        procMeshes_[proci].boundary()[patchi];
+
+                    // Coupled patches
+                    if
+                    (
+                        isA<nonConformalCoupledFvPatch>(fvp)
+                     && refCast<const nonConformalCoupledFvPatch>(fvp).owner()
+                    )
+                    {
+                        const label nccPatchi = patchi;
+
+                        label nbrProci = -1, nbrNccPatchi = -1;
+                        if (isA<cyclicFvPatch>(fvp))
+                        {
+                            nbrProci = proci;
+                            nbrNccPatchi =
+                                refCast<const cyclicFvPatch>(fvp).nbrPatchID();
+                        }
+                        else if (isA<processorCyclicFvPatch>(fvp))
+                        {
+                            typedef processorCyclicFvPatch PcFvp;
+
+                            const PcFvp& pcFvp = refCast<const PcFvp>(fvp);
+
+                            nbrProci = pcFvp.neighbProcNo();
+
+                            const fvBoundaryMesh& nbrFvPatches =
+                                procMeshes_[nbrProci].boundary();
+
+                            forAll(nbrFvPatches, nbrNccPatchj)
+                            {
+                                const fvPatch& nbrFvp =
+                                    nbrFvPatches[nbrNccPatchj];
+
+                                if (isA<PcFvp>(nbrFvp))
+                                {
+                                    const PcFvp& nbrPcFvp =
+                                        refCast<const PcFvp>(nbrFvp);
+
+                                    if
+                                    (
+                                        nbrPcFvp.neighbProcNo()
+                                     == proci
+                                     && nbrPcFvp.referPatchID()
+                                     == pcFvp.referPatch().nbrPatchID()
+                                    )
+                                    {
+                                        nbrNccPatchi = nbrNccPatchj;
+                                        break;
+                                    }
+                                }
+                            }
+
+                            if (nbrNccPatchi == -1)
+                            {
+                                FatalErrorInFunction
+                                    << "Opposite processor patch not found for "
+                                    << "patch " << fvp.name() << " on proc #"
+                                    << proci << exit(FatalError);
+                            }
+                        }
+                        else
+                        {
+                            FatalErrorInFunction
+                                << "Non-conformal-coupled type not recognised "
+                                << "for patch " << fvp.name() << " on proc #"
+                                << proci << exit(FatalError);
+                        }
+
+                        checkNonConformalCoupledPatchOrdering
+                        (
+                            {proci, nbrProci},
+                            procMeshes_[proci].boundary()[nccPatchi],
+                            procMeshes_[nbrProci].boundary()[nbrNccPatchi],
+                            procMeshes_[proci].polyFacesBf()[nccPatchi],
+                            procMeshes_[nbrProci].polyFacesBf()[nbrNccPatchi]
+                        );
+                    }
+
+                    // Error patches
+                    if (isA<nonConformalErrorFvPatch>(fvp))
+                    {
+                        const label ncePatchi = patchi;
+
+                        checkNonConformalErrorPatchOrdering
+                        (
+                            proci,
+                            procMeshes_[proci].boundary()[ncePatchi],
+                            procMeshes_[proci].polyFacesBf()[ncePatchi]
+                        );
+                    }
+                }
+            }
+        }
+    }
+    else if (completeConformal() && !procsConformal())
+    {
+        // Map the polyFacesBf from the processor to the complete meshes and
+        // unconform the complete mesh. Set dummy data for the face
+        // geometry. This should not be used during decomposition.
+        surfaceLabelField::Boundary polyFacesBf
+        (
+            surfaceLabelField::null(),
+            completeMesh().polyFacesBf()
+        );
+        surfaceVectorField Sf(completeMesh().Sf().cloneUnSliced());
+        surfaceVectorField Cf(completeMesh().Cf().cloneUnSliced());
+
+        forAll(procMeshes_, proci)
+        {
+            const fvMesh& procMesh = procMeshes_[proci];
+
+            const surfaceLabelField::Boundary& faceAddressingBf =
+                procFaceAddressingBf()[proci];
+
+            forAll(procMesh.boundary(), procNccPatchi)
+            {
+                const fvPatch& fvp = procMesh.boundary()[procNccPatchi];
+
+                if (isA<nonConformalFvPatch>(fvp))
+                {
+                    const label completeNccPatchi =
+                        isA<processorCyclicFvPatch>(fvp)
+                      ? refCast<const processorCyclicFvPatch>(fvp)
+                       .referPatchID()
+                      : procNccPatchi;
+
+                    const label size =
+                        max
+                        (
+                            max(mag(faceAddressingBf[procNccPatchi])),
+                            polyFacesBf[completeNccPatchi].size()
+                        );
+
+                    polyFacesBf[completeNccPatchi].resize(size, -1);
+                    Sf.boundaryFieldRef()[completeNccPatchi].resize(size, Zero);
+                    Cf.boundaryFieldRef()[completeNccPatchi].resize(size, Zero);
+
+                    polyFacesBf[completeNccPatchi].labelField::rmap
+                    (
+                        mag
+                        (
+                            labelField
+                            (
+                                procFaceAddressing_[proci],
+                                procMesh.polyFacesBf()[procNccPatchi]
+                            )
+                        ) - 1,
+                        mag(faceAddressingBf[procNccPatchi]) - 1
+                    );
+                }
+            }
+        }
+
+        completeMesh_->unconform
+        (
+            polyFacesBf,
+            Sf,
+            Cf,
+            NullObjectRef<surfaceScalarField>(),
+            false
+        );
+
+        // Check ordering
+        if (debug)
+        {
+            forAll(completeMesh().boundary(), patchi)
+            {
+                const fvPatch& fvp = completeMesh().boundary()[patchi];
+
+                // Coupled patches
+                if
+                (
+                    isA<nonConformalCyclicFvPatch>(fvp)
+                 && refCast<const nonConformalCoupledFvPatch>(fvp).owner()
+                )
+                {
+                    const label nccPatchi = patchi;
+
+                    const label nbrNccPatchi =
+                        refCast<const nonConformalCyclicFvPatch>(fvp)
+                       .nbrPatchID();
+
+                    checkNonConformalCoupledPatchOrdering
+                    (
+                        {-labelMax, labelMax},
+                        completeMesh().boundary()[nccPatchi],
+                        completeMesh().boundary()[nbrNccPatchi],
+                        completeMesh().polyFacesBf()[nccPatchi],
+                        completeMesh().polyFacesBf()[nbrNccPatchi]
+                    );
+                }
+
+                // Error patches
+                if (isA<nonConformalErrorFvPatch>(fvp))
+                {
+                    const label ncePatchi = patchi;
+
+                    checkNonConformalErrorPatchOrdering
+                    (
+                        -labelMax,
+                        completeMesh().boundary()[ncePatchi],
+                        completeMesh().polyFacesBf()[ncePatchi]
+                    );
+                }
+            }
+        }
+    }
+    else // if (!completeConformal() && !procsConformal())
+    {
+        // Assume everything is consistent and do nothing
+    }
+}
+
+
+Foam::label Foam::domainDecomposition::compareInstances
+(
+    const fileName& a,
+    const fileName& b
+) const
+{
+    const word& constant = runTimes_.completeTime().constant();
+
+    if (a == constant && b == constant) return 0;
+
+    if (a == constant) return +1;
+
+    if (b == constant) return -1;
+
+    const scalar aValue = instant(a).value();
+    const scalar bValue = instant(b).value();
+
+    if (aValue < bValue) return +1;
+
+    if (aValue > bValue) return -1;
+
+    return 0;
+}
+
+
+void Foam::domainDecomposition::validateComplete() const
+{
+    if (!completeMesh_.valid())
+    {
+        FatalErrorInFunction
+            << "Complete data requested but complete mesh has not been "
+            << "generated or read" << exit(FatalError);
+    }
+}
+
+
+void Foam::domainDecomposition::validateProcs() const
+{
+    if (!procMeshes_.set(0))
+    {
+        FatalErrorInFunction
+            << "Decomposed data requested but decomposed mesh has not been "
+            << "generated or read" << exit(FatalError);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::domainDecomposition::domainDecomposition
+(
+    const processorRunTimes& runTimes,
+    const word& regionName
+)
+:
+    runTimes_(runTimes),
+    regionName_(regionName),
+    completeMesh_(nullptr),
+    procMeshes_(nProcs()),
+    procPointAddressing_(nProcs()),
+    procFaceAddressing_(nProcs()),
+    procCellAddressing_(nProcs()),
+    procFaceAddressingBf_()
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::domainDecomposition::~domainDecomposition()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::domainDecomposition::readComplete()
+{
+    completeMesh_.reset
+    (
+        new fvMesh
+        (
+            IOobject
+            (
+                regionName_,
+                runTimes_.completeTime().timeName(),
+                runTimes_.completeTime(),
+                IOobject::NO_READ,
+                IOobject::NO_WRITE,
+                false
+            ),
+            false
+        )
+    );
+}
+
+
+void Foam::domainDecomposition::readProcs()
+{
+    for (label proci = 0; proci < nProcs(); proci++)
+    {
+        procMeshes_.set
+        (
+            proci,
+            new fvMesh
+            (
+                IOobject
+                (
+                    regionName_,
+                    runTimes_.procTimes()[proci].timeName(),
+                    runTimes_.procTimes()[proci],
+                    IOobject::NO_READ,
+                    IOobject::NO_WRITE,
+                    false
+                ),
+                false
+            )
+        );
+    }
+}
+
+
+void Foam::domainDecomposition::readAddressing()
+{
+    for (label proci = 0; proci < nProcs(); proci++)
+    {
+        const fvMesh& procMesh = procMeshes_[proci];
+
+        procPointAddressing_[proci] =
+            labelIOList
+            (
+                IOobject
+                (
+                    "pointProcAddressing",
+                    procMesh.facesInstance(),
+                    procMesh.meshSubDir,
+                    procMesh,
+                    IOobject::MUST_READ,
+                    IOobject::NO_WRITE,
+                    false
+                )
+            );
+
+        procFaceAddressing_[proci] =
+            labelIOList
+            (
+                IOobject
+                (
+                    "faceProcAddressing",
+                    procMesh.facesInstance(),
+                    procMesh.meshSubDir,
+                    procMesh,
+                    IOobject::MUST_READ,
+                    IOobject::NO_WRITE,
+                    false
+                )
+            );
+
+        procCellAddressing_[proci] =
+            labelIOList
+            (
+                IOobject
+                (
+                    "cellProcAddressing",
+                    procMesh.facesInstance(),
+                    procMesh.meshSubDir,
+                    procMesh,
+                    IOobject::MUST_READ,
+                    IOobject::NO_WRITE,
+                    false
+                )
+            );
+    }
+}
+
+
+Foam::fvMesh::readUpdateState Foam::domainDecomposition::readUpdate()
+{
+    validateComplete();
+    validateProcs();
+
+    // Do read-update on all meshes
+    fvMesh::readUpdateState stat = completeMesh_->readUpdate();
+    forAll(runTimes_.procTimes(), proci)
+    {
+        fvMesh::readUpdateState procStat = procMeshes_[proci].readUpdate();
+        if (procStat > stat)
+        {
+            stat = procStat;
+        }
+    }
+
+    const label facesCompare =
+        compareInstances
+        (
+            completeMesh().facesInstance(),
+            procMeshes_[0].facesInstance()
+        );
+
+    const label pointsCompare =
+        compareInstances
+        (
+            completeMesh().pointsInstance(),
+            procMeshes_[0].pointsInstance()
+        );
+
+    // If the complete mesh has newer topology then we need to decompose
+    if (facesCompare == -1)
+    {
+        decompose();
+    }
+
+    // If the processor meshes have newer topology then we need to reconstruct
+    if (facesCompare == +1)
+    {
+        reconstruct();
+    }
+
+    // If there has been matching topology change then re-read the addressing
+    if (facesCompare == 0 && stat >= fvMesh::TOPO_CHANGE)
+    {
+        procFaceAddressingBf_.clear();
+        readAddressing();
+    }
+
+    // If non conformal meshes have changed then clear the finite volume
+    // addressing
+    if
+    (
+        (!completeConformal() || !procsConformal())
+     && stat != fvMesh::UNCHANGED
+    )
+    {
+        procFaceAddressingBf_.clear();
+    }
+
+    // If the complete mesh has newer points then we need to update the
+    // processor points and we might need to re-unconform the processor meshes
+    if (pointsCompare == -1)
+    {
+        if (!procsConformal())
+        {
+            forAll(procMeshes_, proci) procMeshes_[proci].conform();
+            decomposePoints();
+            unconform();
+        }
+        else
+        {
+            decomposePoints();
+        }
+    }
+
+    // If the processor meshes have newer points then we need to update the
+    // complete points and we might need to re-unconform the complete mesh
+    if (pointsCompare == +1)
+    {
+        if (!completeConformal())
+        {
+            completeMesh_->conform();
+            reconstructPoints();
+            unconform();
+        }
+        else
+        {
+            reconstructPoints();
+        }
+    }
+
+    return stat;
+}
+
+
+Foam::labelList Foam::domainDecomposition::cellToProc() const
+{
+    labelList result(completeMesh().nCells());
+
+    forAll(procCellAddressing_, proci)
+    {
+        forAll(procCellAddressing_[proci], procCelli)
+        {
+            result[procCellAddressing_[proci][procCelli]] = proci;
+        }
+    }
+
+    return result;
+}
+
+
+const Foam::PtrList<Foam::surfaceLabelField::Boundary>&
+Foam::domainDecomposition::procFaceAddressingBf() const
+{
+    validateComplete();
+    validateProcs();
+
+    if (procFaceAddressingBf_.empty())
+    {
+        // Construct cell-to-proc addressing (this is a bit wasteful, as it been
+        // available before but was thrown away)
+        const labelList cellToProc(this->cellToProc());
+
+        // Map from reference patch and processors to the interface patch
+        typedef HashTable<label, labelPair, Hash<labelPair>> labelPairTable;
+        List<labelPairTable> refPatchProcPatchTable
+        (
+            completeMesh().boundary().size()
+        );
+        forAll(procMeshes_, proci)
+        {
+            const fvMesh& procMesh = procMeshes_[proci];
+
+            forAll(procMesh.boundary(), procPatchi)
+            {
+                const fvPatch& fvp = procMesh.boundary()[procPatchi];
+
+                if (isA<cyclicFvPatch>(fvp))
+                {
+                    refPatchProcPatchTable[procPatchi].insert
+                    (
+                        labelPair(proci, proci),
+                        procPatchi
+                    );
+                }
+                else if (isA<processorCyclicFvPatch>(fvp))
+                {
+                    const processorCyclicFvPatch& pcFvp =
+                        refCast<const processorCyclicFvPatch>(fvp);
+
+                    refPatchProcPatchTable[pcFvp.referPatchID()].insert
+                    (
+                        labelPair(proci, pcFvp.neighbProcNo()),
+                        procPatchi
+                    );
+                }
+            }
+        }
+
+        // Build non-conformal finite volume face addressing for each processor
+        List<List<DynamicList<label>>>
+            nonConformalProcFaceAddressingBf(nProcs());
+        forAll(nonConformalProcFaceAddressingBf, proci)
+        {
+            nonConformalProcFaceAddressingBf[proci].resize
+            (
+                procMeshes_[proci].boundary().size()
+            );
+        }
+        if (completeMesh().conformal() && procMeshes_[0].conformal())
+        {
+            // Nothing to do
+        }
+        else if (!completeMesh().conformal())
+        {
+            // Decompose non-conformal addressing
+            const surfaceLabelField::Boundary& polyFacesBf =
+                completeMesh().polyFacesBf();
+
+            // Cyclic patches
+            forAll(completeMesh().boundary(), nccPatchi)
+            {
+                const fvPatch& fvp = completeMesh().boundary()[nccPatchi];
+
+                if (!isA<nonConformalCyclicFvPatch>(fvp)) continue;
+
+                const nonConformalCyclicFvPatch& nccFvp =
+                    refCast<const nonConformalCyclicFvPatch>(fvp);
+
+                if (!nccFvp.owner()) continue;
+
+                const label nccNbrPatchi = nccFvp.nbrPatchID();
+
+                forAll(polyFacesBf[nccPatchi], nccPatchFacei)
+                {
+                    const label facei = polyFacesBf[nccPatchi][nccPatchFacei];
+                    const label celli = completeMesh().faceOwner()[facei];
+                    const label proci = cellToProc[celli];
+
+                    const label nbrFacei =
+                        polyFacesBf[nccNbrPatchi][nccPatchFacei];
+                    const label nbrCelli =
+                        completeMesh().faceOwner()[nbrFacei];
+                    const label nbrProci = cellToProc[nbrCelli];
+
+                    const label procNccPatchi =
+                        refPatchProcPatchTable
+                        [nccPatchi][labelPair(proci, nbrProci)];
+                    const label nbrProcNccPatchi =
+                        refPatchProcPatchTable
+                        [nccNbrPatchi][labelPair(nbrProci, proci)];
+
+                    nonConformalProcFaceAddressingBf[proci][procNccPatchi]
+                       .append(nccPatchFacei + 1);
+                    nonConformalProcFaceAddressingBf[nbrProci][nbrProcNccPatchi]
+                       .append(nccPatchFacei + 1);
+                }
+            }
+
+            // Error patches
+            forAll(completeMesh().boundary(), ncePatchi)
+            {
+                const fvPatch& fvp = completeMesh().boundary()[ncePatchi];
+
+                if (!isA<nonConformalErrorFvPatch>(fvp)) continue;
+
+                forAll(polyFacesBf[ncePatchi], ncePatchFacei)
+                {
+                    const label facei = polyFacesBf[ncePatchi][ncePatchFacei];
+                    const label celli = completeMesh().faceOwner()[facei];
+                    const label proci = cellToProc[celli];
+
+                    nonConformalProcFaceAddressingBf[proci][ncePatchi]
+                       .append(ncePatchFacei + 1);
+                }
+            }
+        }
+        else // if (!procMeshes_[0].conformal())
+        {
+            // Reconstruct non-conformal addressing
+
+            // Cyclic patches
+            forAll(completeMesh().boundary(), nccPatchi)
+            {
+                const fvPatch& fvp = completeMesh().boundary()[nccPatchi];
+
+                if (!isA<nonConformalCyclicFvPatch>(fvp)) continue;
+
+                const nonConformalCyclicFvPatch& nccFvp =
+                    refCast<const nonConformalCyclicFvPatch>(fvp);
+
+                if (!nccFvp.owner()) continue;
+
+                const label nccNbrPatchi = nccFvp.nbrPatchID();
+
+                label count = 0;
+                labelPairTable procCounts;
+                forAllConstIter
+                (
+                    labelPairTable,
+                    refPatchProcPatchTable[nccPatchi],
+                    iter
+                )
+                {
+                    procCounts.insert(iter.key(), 0);
+                }
+
+                while (true)
+                {
+                    labelPair procNbrProc(labelMax, labelMax);
+                    labelPair faceNbrFace(labelMax, labelMax);
+
+                    forAllConstIter(labelPairTable, procCounts, iter)
+                    {
+                        const label proci = iter.key().first();
+                        const label nbrProci = iter.key().second();
+
+                        const labelPair procNbrProcStar(proci, nbrProci);
+                        const labelPair nbrProcProcStar(nbrProci, proci);
+
+                        const label procNccPatchi =
+                            refPatchProcPatchTable
+                            [nccPatchi][procNbrProcStar];
+                        const label nbrProcNccPatchi =
+                            refPatchProcPatchTable
+                            [nccNbrPatchi][nbrProcProcStar];
+
+                        const label size =
+                            procMeshes_[proci]
+                           .polyFacesBf()[procNccPatchi]
+                           .size();
+
+                        if (iter() >= size) continue;
+
+                        const label procFacei =
+                            procMeshes_[proci].polyFacesBf()
+                            [procNccPatchi][iter()];
+                        const label nbrProcFacei =
+                            procMeshes_[nbrProci].polyFacesBf()
+                            [nbrProcNccPatchi][iter()];
+
+                        const labelPair faceNbrFaceStar
+                        (
+                            procFaceAddressing_[proci][procFacei] - 1,
+                            procFaceAddressing_[nbrProci][nbrProcFacei] - 1
+                        );
+
+                        if (faceNbrFace > faceNbrFaceStar)
+                        {
+                            procNbrProc = procNbrProcStar;
+                            faceNbrFace = faceNbrFaceStar;
+                        }
+                    }
+
+                    if (faceNbrFace == labelPair(labelMax, labelMax))
+                    {
+                        break;
+                    }
+                    else
+                    {
+                        const label proci = procNbrProc.first();
+                        const label nbrProci = procNbrProc.second();
+
+                        const labelPair nbrProcProc(nbrProci, proci);
+
+                        const label procNccPatchi =
+                            refPatchProcPatchTable[nccPatchi][procNbrProc];
+                        const label nbrProcNccPatchi =
+                            refPatchProcPatchTable[nccNbrPatchi][nbrProcProc];
+
+                        nonConformalProcFaceAddressingBf
+                            [proci][procNccPatchi].append(count + 1);
+                        nonConformalProcFaceAddressingBf
+                            [nbrProci][nbrProcNccPatchi].append(count + 1);
+
+                        count ++;
+                        procCounts[procNbrProc] ++;
+                    }
+                }
+            }
+
+            // Error patches
+            forAll(completeMesh().boundary(), ncePatchi)
+            {
+                const fvPatch& fvp = completeMesh().boundary()[ncePatchi];
+
+                if (!isA<nonConformalErrorFvPatch>(fvp)) continue;
+
+                label count = 0;
+                labelList procCounts(nProcs(), 0);
+
+                while (true)
+                {
+                    label facei = labelMax, proci = labelMax;
+
+                    forAll(procCounts, procStari)
+                    {
+                        const label size =
+                            procMeshes_[procStari]
+                           .polyFacesBf()[ncePatchi]
+                           .size();
+
+                        if (procCounts[procStari] >= size) continue;
+
+                        const label procFacei =
+                            procMeshes_[procStari].polyFacesBf()
+                            [ncePatchi][procCounts[procStari]];
+
+                        const label faceStari =
+                            procFaceAddressing_[procStari][procFacei] - 1;
+
+                        if (facei > faceStari)
+                        {
+                            facei = faceStari;
+                            proci = procStari;
+                        }
+                    }
+
+                    if (facei == labelMax)
+                    {
+                        break;
+                    }
+                    else
+                    {
+                        nonConformalProcFaceAddressingBf
+                            [proci][ncePatchi].append(count + 1);
+
+                        count ++;
+                        procCounts[proci] ++;
+                    }
+                }
+            }
+        }
+
+        // Build finite volume face addressing boundary fields
+        procFaceAddressingBf_.resize(nProcs());
+        forAll(procMeshes_, proci)
+        {
+            const fvMesh& procMesh = procMeshes_[proci];
+
+            procFaceAddressingBf_.set
+            (
+                proci,
+                new surfaceLabelField::Boundary
+                (
+                    procMesh.boundary(),
+                    surfaceLabelField::null(),
+                    calculatedFvsPatchLabelField::typeName
+                )
+            );
+
+            forAll(procMesh.boundary(), procPatchi)
+            {
+                const fvPatch& fvp = procMesh.boundary()[procPatchi];
+
+                if (isA<nonConformalFvPatch>(fvp))
+                {
+                    procFaceAddressingBf_[proci][procPatchi] =
+                        nonConformalProcFaceAddressingBf[proci][procPatchi];
+                }
+                else if (isA<processorCyclicFvPatch>(fvp))
+                {
+                    const label completePatchi =
+                        refCast<const processorCyclicFvPatch>(fvp)
+                       .referPatchID();
+
+                    procFaceAddressingBf_[proci][procPatchi] =
+                        mag(fvp.patchSlice(procFaceAddressing_[proci]))
+                      - completeMesh().boundaryMesh()[completePatchi].start();
+                }
+                else if (isA<processorFvPatch>(fvp))
+                {
+                    procFaceAddressingBf_[proci][procPatchi] =
+                        fvp.patchSlice(procFaceAddressing_[proci]);
+                }
+                else
+                {
+                    procFaceAddressingBf_[proci][procPatchi] =
+                        mag(fvp.patchSlice(procFaceAddressing_[proci]))
+                      - completeMesh().boundaryMesh()[procPatchi].start();
+                }
+            }
+        }
+    }
+
+    return procFaceAddressingBf_;
+}
+
+
+void Foam::domainDecomposition::writeCompletePoints() const
+{
+    if (procMeshes_[0].pointsInstance() != procMeshes_[0].facesInstance())
+    {
+        pointField completeFacesInstancePoints(completeMesh().nPoints());
+
+        for (label proci = 0; proci < nProcs(); proci++)
+        {
+            const fvMesh& procMesh = procMeshes_[proci];
+
+            pointIOField procFacesInstancePoints
+            (
+                IOobject
+                (
+                    "points",
+                    procMesh.facesInstance(),
+                    polyMesh::meshSubDir,
+                    procMesh,
+                    IOobject::MUST_READ,
+                    IOobject::NO_WRITE,
+                    false
+                )
+            );
+
+            completeFacesInstancePoints.rmap
+            (
+                procFacesInstancePoints,
+                procPointAddressing_[proci]
+            );
+        }
+
+        pointIOField
+        (
+            IOobject
+            (
+                "points",
+                procMeshes_[0].facesInstance(),
+                polyMesh::meshSubDir,
+                completeMesh(),
+                IOobject::NO_READ,
+                IOobject::NO_WRITE,
+                false
+            ),
+            move(completeFacesInstancePoints)
+        ).write();
+    }
+}
+
+
+void Foam::domainDecomposition::writeProcPoints() const
+{
+    if (completeMesh().pointsInstance() != completeMesh().facesInstance())
+    {
+        pointIOField completeFacesInstancePoints
+        (
+            IOobject
+            (
+                "points",
+                completeMesh().facesInstance(),
+                polyMesh::meshSubDir,
+                completeMesh(),
+                IOobject::MUST_READ,
+                IOobject::NO_WRITE,
+                false
+            )
+        );
+
+        for (label proci = 0; proci < nProcs(); proci++)
+        {
+            const fvMesh& procMesh = procMeshes_[proci];
+
+            pointField procFacesInstancePoints
+            (
+                completeFacesInstancePoints,
+                procPointAddressing_[proci]
+            );
+
+            pointIOField
+            (
+                IOobject
+                (
+                    "points",
+                    completeMesh().facesInstance(),
+                    polyMesh::meshSubDir,
+                    procMesh,
+                    IOobject::NO_READ,
+                    IOobject::NO_WRITE,
+                    false
+                ),
+                move(procFacesInstancePoints)
+            ).write();
+        }
+    }
+}
+
+
+void Foam::domainDecomposition::writeAddressing() const
+{
+    for (label proci = 0; proci < nProcs(); proci++)
+    {
+        const fvMesh& procMesh = procMeshes_[proci];
+
+        labelIOList pointProcAddressing
+        (
+            IOobject
+            (
+                "pointProcAddressing",
+                procMesh.facesInstance(),
+                procMesh.meshSubDir,
+                procMesh,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            procPointAddressing_[proci]
+        );
+        pointProcAddressing.write();
+
+        labelIOList faceProcAddressing
+        (
+            IOobject
+            (
+                "faceProcAddressing",
+                procMesh.facesInstance(),
+                procMesh.meshSubDir,
+                procMesh,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            procFaceAddressing_[proci]
+        );
+        faceProcAddressing.write();
+
+        labelIOList cellProcAddressing
+        (
+            IOobject
+            (
+                "cellProcAddressing",
+                procMesh.facesInstance(),
+                procMesh.meshSubDir,
+                procMesh,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            procCellAddressing_[proci]
+        );
+        cellProcAddressing.write();
+    }
+}
+
+
+void Foam::domainDecomposition::writeComplete(const bool doSets) const
+{
+    // Set the precision of the points data to be min 10
+    IOstream::defaultPrecision(max(10u, IOstream::defaultPrecision()));
+
+    // Write the processor mesh
+    completeMesh().write();
+
+    // Sets
+    if (doSets)
+    {
+        // Scan to find all sets
+        HashTable<label> cSetNames;
+        HashTable<label> fSetNames;
+        HashTable<label> pSetNames;
+        for (label proci = 0; proci < nProcs(); proci++)
+        {
+            const fvMesh& procMesh = procMeshes_[proci];
+
+            IOobjectList objects
+            (
+                procMesh,
+                runTimes_.procTimes()[proci].timeName(),
+                polyMesh::meshSubDir/"sets"
+            );
+
+            IOobjectList cSets(objects.lookupClass(cellSet::typeName));
+            forAllConstIter(IOobjectList, cSets, iter)
+            {
+                cSetNames.insert(iter.key(), cSetNames.size());
+            }
+
+            IOobjectList fSets(objects.lookupClass(faceSet::typeName));
+            forAllConstIter(IOobjectList, fSets, iter)
+            {
+                fSetNames.insert(iter.key(), fSetNames.size());
+            }
+            IOobjectList pSets(objects.lookupClass(pointSet::typeName));
+            forAllConstIter(IOobjectList, pSets, iter)
+            {
+                pSetNames.insert(iter.key(), pSetNames.size());
+            }
+        }
+
+        // Reconstruct all sets
+        if (cSetNames.size() || fSetNames.size() || pSetNames.size())
+        {
+            PtrList<cellSet> cellSets(cSetNames.size());
+            PtrList<faceSet> faceSets(fSetNames.size());
+            PtrList<pointSet> pointSets(pSetNames.size());
+
+            Info<< "Reconstructing sets:" << endl;
+            if (cSetNames.size())
+            {
+                Info<< "    cellSets "
+                    << cSetNames.sortedToc() << endl;
+            }
+            if (fSetNames.size())
+            {
+                Info<< "    faceSets "
+                    << fSetNames.sortedToc() << endl;
+            }
+            if (pSetNames.size())
+            {
+                Info<< "    pointSets "
+                    << pSetNames.sortedToc() << endl;
+            }
+
+            // Load sets
+            for (label proci = 0; proci < nProcs(); proci++)
+            {
+                const fvMesh& procMesh = procMeshes_[proci];
+
+                IOobjectList objects
+                (
+                    procMesh,
+                    runTimes_.procTimes()[proci].timeName(),
+                    polyMesh::meshSubDir/"sets"
+                );
+
+                // cellSets
+                const labelList& cellMap = procCellAddressing()[proci];
+
+                IOobjectList cSets
+                (
+                    objects.lookupClass(cellSet::typeName)
+                );
+
+                forAllConstIter(IOobjectList, cSets, iter)
+                {
+                    // Load cellSet
+                    const cellSet procSet(*iter());
+                    label setI = cSetNames[iter.key()];
+                    if (!cellSets.set(setI))
+                    {
+                        cellSets.set
+                        (
+                            setI,
+                            new cellSet
+                            (
+                                completeMesh(),
+                                iter.key(),
+                                procSet.size()
+                            )
+                        );
+                    }
+                    cellSet& cSet = cellSets[setI];
+                    cSet.instance() = runTimes_.completeTime().timeName();
+
+                    forAllConstIter(cellSet, procSet, iter)
+                    {
+                        cSet.insert(cellMap[iter.key()]);
+                    }
+                }
+
+                // faceSets
+                const labelList& faceMap = procFaceAddressing()[proci];
+
+                IOobjectList fSets
+                (
+                    objects.lookupClass(faceSet::typeName)
+                );
+
+                forAllConstIter(IOobjectList, fSets, iter)
+                {
+                    // Load faceSet
+                    const faceSet procSet(*iter());
+                    label setI = fSetNames[iter.key()];
+                    if (!faceSets.set(setI))
+                    {
+                        faceSets.set
+                        (
+                            setI,
+                            new faceSet
+                            (
+                                completeMesh(),
+                                iter.key(),
+                                procSet.size()
+                            )
+                        );
+                    }
+                    faceSet& fSet = faceSets[setI];
+                    fSet.instance() = runTimes_.completeTime().timeName();
+
+                    forAllConstIter(faceSet, procSet, iter)
+                    {
+                        fSet.insert(mag(faceMap[iter.key()]) - 1);
+                    }
+                }
+
+                // pointSets
+                const labelList& pointMap = procPointAddressing()[proci];
+
+                IOobjectList pSets
+                (
+                    objects.lookupClass(pointSet::typeName)
+                );
+
+                forAllConstIter(IOobjectList, pSets, iter)
+                {
+                    // Load pointSet
+                    const pointSet propSet(*iter());
+                    label setI = pSetNames[iter.key()];
+                    if (!pointSets.set(setI))
+                    {
+                        pointSets.set
+                        (
+                            setI,
+                            new pointSet
+                            (
+                                completeMesh(),
+                                iter.key(),
+                                propSet.size()
+                            )
+                        );
+                    }
+                    pointSet& pSet = pointSets[setI];
+                    pSet.instance() = runTimes_.completeTime().timeName();
+
+                    forAllConstIter(pointSet, propSet, iter)
+                    {
+                        pSet.insert(pointMap[iter.key()]);
+                    }
+                }
+            }
+
+            // Write sets
+            forAll(cellSets, i)
+            {
+                cellSets[i].write();
+            }
+            forAll(faceSets, i)
+            {
+                faceSets[i].write();
+            }
+            forAll(pointSets, i)
+            {
+                pointSets[i].write();
+            }
+        }
+    }
+
+    // Refinement data (if any)
+    UPtrList<const labelList> cellMaps(nProcs());
+    UPtrList<const labelList> pointMaps(nProcs());
+    PtrList<const hexRef8Data> refinementDatas(nProcs());
+    for (label proci = 0; proci < nProcs(); proci++)
+    {
+        const fvMesh& procMesh = procMeshes_[proci];
+
+        cellMaps.set(proci, &procCellAddressing_[proci]);
+        pointMaps.set(proci, &procPointAddressing_[proci]);
+        refinementDatas.set
+        (
+            proci,
+            new hexRef8Data
+            (
+                IOobject
+                (
+                    "dummy",
+                    completeMesh().facesInstance(),
+                    polyMesh::meshSubDir,
+                    procMesh,
+                    IOobject::READ_IF_PRESENT,
+                    IOobject::NO_WRITE,
+                    false
+                )
+            )
+        );
+    }
+    hexRef8Data
+    (
+        IOobject
+        (
+            "dummy",
+            completeMesh().facesInstance(),
+            polyMesh::meshSubDir,
+            completeMesh(),
+            IOobject::NO_READ,
+            IOobject::NO_WRITE,
+            false
+        ),
+        cellMaps,
+        pointMaps,
+        refinementDatas
+    ).write();
+
+    // Write points if pointsInstance differing from facesInstance
+    writeCompletePoints();
+
+    // Write decomposition addressing
+    writeAddressing();
+}
+
+
+void Foam::domainDecomposition::writeProcs(const bool doSets) const
+{
+    // Read sets
+    PtrList<const cellSet> cellSets;
+    PtrList<const faceSet> faceSets;
+    PtrList<const pointSet> pointSets;
+    if (doSets)
+    {
+        IOobjectList objects
+        (
+            completeMesh(),
+            completeMesh().facesInstance(),
+            "polyMesh/sets"
+        );
+        {
+            IOobjectList cSets(objects.lookupClass(cellSet::typeName));
+            forAllConstIter(IOobjectList, cSets, iter)
+            {
+                cellSets.append(new cellSet(*iter()));
+            }
+        }
+        {
+            IOobjectList fSets(objects.lookupClass(faceSet::typeName));
+            forAllConstIter(IOobjectList, fSets, iter)
+            {
+                faceSets.append(new faceSet(*iter()));
+            }
+        }
+        {
+            IOobjectList pSets(objects.lookupClass(pointSet::typeName));
+            forAllConstIter(IOobjectList, pSets, iter)
+            {
+                pointSets.append(new pointSet(*iter()));
+            }
+        }
+    }
+
+    // Read refinement data (if any)
+    hexRef8Data refinementData
+    (
+        IOobject
+        (
+            "dummy",
+            completeMesh().facesInstance(),
+            polyMesh::meshSubDir,
+            completeMesh(),
+            IOobject::READ_IF_PRESENT,
+            IOobject::NO_WRITE,
+            false
+        )
+    );
+
+    // Write out the meshes
+    for (label proci = 0; proci < nProcs(); proci++)
+    {
+        const fvMesh& procMesh = procMeshes_[proci];
+
+        // Set the precision of the points data to be min 10
+        IOstream::defaultPrecision(max(10u, IOstream::defaultPrecision()));
+
+        // Write the processor mesh
+        procMesh.write();
+
+        // Write any sets
+        if (doSets)
+        {
+            forAll(cellSets, i)
+            {
+                const cellSet& cs = cellSets[i];
+                cellSet set(procMesh, cs.name(), cs.size()/nProcs());
+                forAll(procCellAddressing_[proci], i)
+                {
+                    if (cs.found(procCellAddressing_[proci][i]))
+                    {
+                        set.insert(i);
+                    }
+                }
+                set.write();
+            }
+            forAll(faceSets, i)
+            {
+                const faceSet& cs = faceSets[i];
+                faceSet set(procMesh, cs.name(), cs.size()/nProcs());
+                forAll(procFaceAddressing_[proci], i)
+                {
+                    if (cs.found(mag(procFaceAddressing_[proci][i])-1))
+                    {
+                        set.insert(i);
+                    }
+                }
+                set.write();
+            }
+            forAll(pointSets, i)
+            {
+                const pointSet& cs = pointSets[i];
+                pointSet set(procMesh, cs.name(), cs.size()/nProcs());
+                forAll(procPointAddressing_[proci], i)
+                {
+                    if (cs.found(procPointAddressing_[proci][i]))
+                    {
+                        set.insert(i);
+                    }
+                }
+                set.write();
+            }
+        }
+
+        // Write refinement data (if any)
+        hexRef8Data
+        (
+            IOobject
+            (
+                "dummy",
+                completeMesh().facesInstance(),
+                polyMesh::meshSubDir,
+                procMesh,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE,
+                false
+            ),
+            refinementData,
+            procCellAddressing_[proci],
+            procPointAddressing_[proci]
+        ).write();
+    }
+
+    // Write points if pointsInstance differing from facesInstance
+    writeProcPoints();
+
+    // Write decomposition addressing
+    writeAddressing();
+}
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/parallelProcessing/decomposePar/domainDecomposition.H b/src/parallel/parallel/domainDecomposition.H
similarity index 50%
rename from applications/utilities/parallelProcessing/decomposePar/domainDecomposition.H
rename to src/parallel/parallel/domainDecomposition.H
index 2e2de1d2a4..a686002e6d 100644
--- a/applications/utilities/parallelProcessing/decomposePar/domainDecomposition.H
+++ b/src/parallel/parallel/domainDecomposition.H
@@ -37,7 +37,9 @@ SourceFiles
 #define domainDecomposition_H
 
 #include "fvMesh.H"
+#include "processorRunTimes.H"
 #include "volFields.H"
+#include "surfaceFields.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -52,17 +54,17 @@ class domainDecomposition
 {
     // Private Data
 
-        //- Reference to the complete mesh
-        const fvMesh& mesh_;
+        //- Run times
+        const processorRunTimes& runTimes_;
 
-        //- Number of processors in decomposition
-        const label nProcs_;
+        //- Region name
+        const word regionName_;
 
-        //- Optional: points at the facesInstance
-        autoPtr<pointIOField> facesInstancePointsPtr_;
+        //- The complete mesh
+        autoPtr<fvMesh> completeMesh_;
 
-        //- Is the decomposition data to be distributed for each processor
-        bool distributed_;
+        //- The processor meshes
+        PtrList<fvMesh> procMeshes_;
 
 
         // Processor mesh to complete mesh addressing
@@ -78,60 +80,90 @@ class domainDecomposition
             // indices will be incremented by 1 and the decremented as
             // necessary to avoid the problem of face number zero having no
             // sign.
-            List<DynamicList<label>> procFaceAddressing_;
+            labelListList procFaceAddressing_;
 
             //- Labels of cells for each processor
             labelListList procCellAddressing_;
 
 
-        //- Processor times
-        PtrList<Time> procRunTimes_;
+        // Finite volume specific processor to complete mesh addressing
+
+            //- Labels of finite volume faces for each processor boundary
+            //  (constructed on demand)
+            mutable PtrList<surfaceLabelField::Boundary> procFaceAddressingBf_;
 
-        //- Processor meshes
-        PtrList<fvMesh> procMeshes_;
 
 
 
     // Private Member Functions
 
-        //- Call the decomposition method and return the processor index that
-        //  each cell is being distributed to
-        labelList distributeCells();
+        // Decomposition
 
-        //- Mark all elements with value or -2 if occur twice
-        static void mark
-        (
-            const labelList& zoneElems,
-            const label zoneI,
-            labelList& elementToZone
-        );
+            //- Mark all elements with value or -2 if occur twice
+            static void mark
+            (
+                const labelList& zoneElems,
+                const label zoneI,
+                labelList& elementToZone
+            );
 
-        //- Add face to inter-processor patch
-        void addInterProcFace
-        (
-            const label facei,
-            const label ownerProc,
-            const label nbrProc,
-            List<Map<label>>&,
-            List<DynamicList<DynamicList<label>>>&
-        ) const;
+            //- Add face to inter-processor patch
+            void addInterProcFace
+            (
+                const label facei,
+                const label ownerProc,
+                const label nbrProc,
+                const label subPatchID,
+                List<Map<label>>&,
+                List<DynamicList<DynamicList<label>>>&,
+                List<labelListList>&,
+                List<labelListList>&
+            ) const;
 
-        //- Generate sub patch info for processor cyclics
-        template<class BinaryOp>
-        inline void processInterCyclics
-        (
-            const labelList& cellToProc,
-            const polyBoundaryMesh& patches,
-            List<DynamicList<DynamicList<label>>>& interPatchFaces,
-            List<Map<label>>& procNbrToInterPatch,
-            List<labelListList>& subPatchIDs,
-            List<labelListList>& subPatchStarts,
-            bool owner,
-            BinaryOp bop
-        ) const;
+            //- Call the decomposition method and return the processor index
+            //  that each cell is being distributed to
+            labelList distributeCells();
 
-        //- Validate that the decomposition has been generated or read
-        void validate() const;
+            //- Generate sub patch info for processor cyclics
+            template<class BinaryOp>
+            inline void processInterCyclics
+            (
+                const labelList& cellToProc,
+                const polyBoundaryMesh& patches,
+                List<DynamicList<DynamicList<label>>>& interPatchFaces,
+                List<Map<label>>& procNbrToInterPatch,
+                List<labelListList>& subPatchIDs,
+                List<labelListList>& subPatchStarts,
+                bool owner,
+                BinaryOp bop
+            ) const;
+
+
+        //- ...
+        void decomposePoints();
+
+        //- ...
+        void reconstructPoints();
+
+        //- ...
+        bool completeConformal() const;
+
+        //- ...
+        bool procsConformal() const;
+
+        //- If the complete mesh is non-conformal and the processor meshes are
+        //  not, then map the non-conformal addressing across and unconform the
+        //  processor meshes. And vice versa.
+        void unconform();
+
+        //- ...
+        label compareInstances(const fileName& a, const fileName& b) const;
+
+        //- Validate that the complete mesh has been generated or read
+        void validateComplete() const;
+
+        //- Validate that the processor meshes have been generated or read
+        void validateProcs() const;
 
 
 public:
@@ -142,8 +174,12 @@ public:
 
     // Constructors
 
-        //- Construct from reference to fvMesh
-        domainDecomposition(const fvMesh& mesh);
+        //- Construct from processor run times and region name
+        domainDecomposition
+        (
+            const processorRunTimes& procRunTimes,
+            const word& regionName
+        );
 
 
     //- Destructor
@@ -153,80 +189,87 @@ public:
     // Member Functions
 
         //- Access the global mesh
-        const fvMesh& mesh() const
+        const fvMesh& completeMesh() const
         {
-            return mesh_;
+            validateComplete();
+            return completeMesh_();
+        }
+
+        //- Access the processor meshes
+        const PtrList<fvMesh>& procMeshes() const
+        {
+            validateProcs();
+            return procMeshes_;
         }
 
         //- Return the number of processors in the decomposition
         label nProcs() const
         {
-            return nProcs_;
+            return runTimes_.nProcs();
         }
 
-        //- Is the decomposition data to be distributed for each processor?
-        bool distributed() const
-        {
-            return distributed_;
-        }
+        //- ...
+        void readComplete();
+
+        //- ...
+        void readProcs();
+
+        //- ...
+        void readAddressing();
+
+        //- ...
+        fvMesh::readUpdateState readUpdate();
+
+        //- Decompose the complete mesh to create the processor meshes and
+        //  populate the addressing
+        void decompose();
+
+        //- Reconstruct the processor meshes to create the complete mesh and
+        //  populate the addressing
+        void reconstruct();
+
+        //- Return the distribution as an FV field for writing
+        labelList cellToProc() const;
 
         //- Access the labels of points for each processor
         const labelListList& procPointAddressing() const
         {
-            validate();
+            validateProcs();
             return procPointAddressing_;
         }
 
         //- Access the labels of faces for each processor (see notes above)
-        const List<DynamicList<label>>& procFaceAddressing() const
+        const labelListList& procFaceAddressing() const
         {
-            validate();
+            validateProcs();
             return procFaceAddressing_;
         }
 
         //- Access the labels of cells for each processor
         const labelListList& procCellAddressing() const
         {
-            validate();
+            validateProcs();
             return procCellAddressing_;
         }
 
-        //- Return the processor meshes
-        const PtrList<fvMesh>& procMeshes() const
-        {
-            validate();
-            return procMeshes_;
-        }
+        //- Access the labels of faces for each processor (see notes above)
+        const PtrList<surfaceLabelField::Boundary>&
+            procFaceAddressingBf() const;
 
-        //- Generate the decomposition
-        void decompose();
+        //- Write additional points, if necessary
+        void writeCompletePoints() const;
 
-        //- Reset the time
-        void setTime(const instant&, const label newIndex);
-
-        //- Read additional (faceInstance) points, if necessary
-        void readPoints();
-
-        //- Read in the decomposition addressing
-        void readAddressing();
-
-        //- Read in the meshes and the decomposition
-        void read();
-
-        //- Read update the meshes and the decomposition
-        fvMesh::readUpdateState readUpdate();
-
-        //- Return the distribution as an FV field for writing
-        labelList cellToProc() const;
-
-        //- Read additional (faceInstance) points, if necessary
-        void writePoints() const;
+        //- Writ additional points, if necessary
+        void writeProcPoints() const;
 
         //- Write the decomposition addressing
         void writeAddressing() const;
 
         //- Write the decomposed meshes and associated data
-        void write(const bool decomposeSets) const;
+        void writeComplete(const bool doSets) const;
+
+        //- Write the decomposed meshes and associated data
+        void writeProcs(const bool doSets) const;
 };
 
 
diff --git a/applications/utilities/parallelProcessing/decomposePar/domainDecomposition.C b/src/parallel/parallel/domainDecompositionDecompose.C
similarity index 58%
rename from applications/utilities/parallelProcessing/decomposePar/domainDecomposition.C
rename to src/parallel/parallel/domainDecompositionDecompose.C
index 78325723fb..a07c1b9c17 100644
--- a/applications/utilities/parallelProcessing/decomposePar/domainDecomposition.C
+++ b/src/parallel/parallel/domainDecompositionDecompose.C
@@ -25,20 +25,11 @@ License
 
 #include "domainDecomposition.H"
 #include "decompositionMethod.H"
-#include "fvFieldDecomposer.H"
 #include "IOobjectList.H"
-#include "cellSet.H"
-#include "faceSet.H"
-#include "pointSet.H"
-#include "hexRef8Data.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-namespace Foam
-{
-    defineTypeNameAndDebug(domainDecomposition, 0);
-}
-
+#include "cyclicFvPatch.H"
+#include "processorCyclicFvPatch.H"
+#include "nonConformalCyclicFvPatch.H"
+#include "nonConformalProcessorCyclicFvPatch.H"
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
@@ -72,44 +63,69 @@ void Foam::domainDecomposition::addInterProcFace
     const label facei,
     const label ownerProc,
     const label nbrProc,
+    const label subPatchID,
     List<Map<label>>& nbrToInterPatch,
-    List<DynamicList<DynamicList<label>>>& interPatchFaces
+    List<DynamicList<DynamicList<label>>>& interPatchFaces,
+    List<labelListList>& subPatchIDs,
+    List<labelListList>& subPatchStarts
 ) const
 {
-    Map<label>::iterator patchiter = nbrToInterPatch[ownerProc].find(nbrProc);
-
-    // Introduce turning index only for internal faces (are duplicated).
-    label ownerIndex = facei+1;
-    label nbrIndex = -(facei+1);
-
-    if (patchiter != nbrToInterPatch[ownerProc].end())
+    // Create new interproc patches, if they do not already exist
+    label toNbrProcPatchi = -1, toOwnerProcPatchi = -1;
+    if (!nbrToInterPatch[ownerProc].found(nbrProc))
     {
-        // Existing interproc patch. Add to both sides.
-        label toNbrProcPatchi = patchiter();
-        interPatchFaces[ownerProc][toNbrProcPatchi].append(ownerIndex);
+        toNbrProcPatchi = nbrToInterPatch[ownerProc].size();
+        nbrToInterPatch[ownerProc].insert(nbrProc, toNbrProcPatchi);
+        interPatchFaces[ownerProc].append(DynamicList<label>());
+        subPatchIDs[ownerProc].append(labelList(1, subPatchID));
+        subPatchStarts[ownerProc].append(labelList(1, 0));
 
-        if (mesh_.isInternalFace(facei))
+        if (facei != -1 && completeMesh().isInternalFace(facei))
         {
-            label toOwnerProcPatchi = nbrToInterPatch[nbrProc][ownerProc];
-            interPatchFaces[nbrProc][toOwnerProcPatchi].append(nbrIndex);
+            toOwnerProcPatchi = nbrToInterPatch[nbrProc].size();
+            nbrToInterPatch[nbrProc].insert(ownerProc, toOwnerProcPatchi);
+            interPatchFaces[nbrProc].append(DynamicList<label>());
+            subPatchIDs[nbrProc].append(labelList(1, subPatchID));
+            subPatchStarts[nbrProc].append(labelList(1, 0));
         }
     }
     else
     {
-        // Create new interproc patches.
-        label toNbrProcPatchi = nbrToInterPatch[ownerProc].size();
-        nbrToInterPatch[ownerProc].insert(nbrProc, toNbrProcPatchi);
-        DynamicList<label> oneFace;
-        oneFace.append(ownerIndex);
-        interPatchFaces[ownerProc].append(oneFace);
+        toNbrProcPatchi = nbrToInterPatch[ownerProc][nbrProc];
 
-        if (mesh_.isInternalFace(facei))
+        if (facei != -1 && completeMesh().isInternalFace(facei))
         {
-            label toOwnerProcPatchi = nbrToInterPatch[nbrProc].size();
-            nbrToInterPatch[nbrProc].insert(ownerProc, toOwnerProcPatchi);
-            oneFace.clear();
-            oneFace.append(nbrIndex);
-            interPatchFaces[nbrProc].append(oneFace);
+            toOwnerProcPatchi = nbrToInterPatch[nbrProc][ownerProc];
+        }
+    }
+
+    // If the sub patch has changed then add new sub-patch entries
+    if (subPatchIDs[ownerProc][toNbrProcPatchi].last() != subPatchID)
+    {
+        subPatchIDs[ownerProc][toNbrProcPatchi].append(subPatchID);
+        subPatchStarts[ownerProc][toNbrProcPatchi].append
+        (
+            interPatchFaces[ownerProc][toNbrProcPatchi].size()
+        );
+
+        if (facei != -1 && completeMesh().isInternalFace(facei))
+        {
+            subPatchIDs[nbrProc][toOwnerProcPatchi].append(subPatchID);
+            subPatchStarts[nbrProc][toOwnerProcPatchi].append
+            (
+                interPatchFaces[nbrProc][toOwnerProcPatchi].size()
+            );
+        }
+    }
+
+    // Add face to the inter-proc patches. Note use of turning index.
+    if (facei != -1)
+    {
+        interPatchFaces[ownerProc][toNbrProcPatchi].append(facei + 1);
+
+        if (completeMesh().isInternalFace(facei))
+        {
+            interPatchFaces[nbrProc][toOwnerProcPatchi].append(- facei - 1);
         }
     }
 }
@@ -121,10 +137,8 @@ Foam::labelList Foam::domainDecomposition::distributeCells()
 
     cpuTime decompositionTime;
 
-    const dictionary decomposeParDict
-    (
-        decompositionMethod::decomposeParDict(mesh_.time())
-    );
+    const dictionary decomposeParDict =
+        decompositionMethod::decomposeParDict(runTimes_.completeTime());
 
     scalarField cellWeights;
     if (decomposeParDict.found("weightField"))
@@ -136,12 +150,12 @@ Foam::labelList Foam::domainDecomposition::distributeCells()
             IOobject
             (
                 weightName,
-                mesh_.time().timeName(),
-                mesh_,
+                completeMesh().time().timeName(),
+                completeMesh(),
                 IOobject::MUST_READ,
                 IOobject::NO_WRITE
             ),
-            mesh_
+            completeMesh()
         );
         cellWeights = weights.primitiveField();
     }
@@ -149,7 +163,7 @@ Foam::labelList Foam::domainDecomposition::distributeCells()
     const labelList result =
         decompositionMethod::NewDecomposer(decomposeParDict)->decompose
         (
-            mesh_,
+            completeMesh(),
             cellWeights
         );
 
@@ -177,154 +191,84 @@ inline void Foam::domainDecomposition::processInterCyclics
     // Processor boundaries from split cyclics
     forAll(patches, patchi)
     {
-        if (isA<cyclicPolyPatch>(patches[patchi]))
+        if (isA<nonConformalCyclicPolyPatch>(patches[patchi]))
         {
-            const cyclicPolyPatch& pp = refCast<const cyclicPolyPatch>
-            (
-                patches[patchi]
-            );
+            const nonConformalCyclicPolyPatch& nccPp =
+                refCast<const nonConformalCyclicPolyPatch>(patches[patchi]);
 
-            if (pp.owner() != owner)
+            if (nccPp.owner() != owner) continue;
+
+            const polyPatch& origPp = nccPp.origPatch();
+            const polyPatch& nbrOrigPp = nccPp.nbrPatch().origPatch();
+
+            const labelUList& origPatchFaceCells = origPp.faceCells();
+            const labelUList& nbrOrigPatchFaceCells = nbrOrigPp.faceCells();
+
+            // Add all possible interfaces between processors that contain the
+            // original patches
+            forAll(origPatchFaceCells, origFacei)
             {
-                continue;
-            }
+                const label ownerProc =
+                    cellToProc[origPatchFaceCells[origFacei]];
 
-            // cyclic: check opposite side on this processor
-            const labelUList& patchFaceCells = pp.faceCells();
-            const labelUList& nbrPatchFaceCells =
-                pp.nbrPatch().faceCells();
-
-            // Store old sizes. Used to detect which inter-proc patches
-            // have been added to.
-            labelListList oldInterfaceSizes(nProcs_);
-            forAll(oldInterfaceSizes, proci)
-            {
-                labelList& curOldSizes = oldInterfaceSizes[proci];
-
-                curOldSizes.setSize(interPatchFaces[proci].size());
-                forAll(curOldSizes, interI)
+                forAll(nbrOrigPatchFaceCells, nbrOrigFacei)
                 {
-                    curOldSizes[interI] =
-                        interPatchFaces[proci][interI].size();
+                    const label nbrProc =
+                        cellToProc[nbrOrigPatchFaceCells[nbrOrigFacei]];
+
+                    if (bop(ownerProc, nbrProc))
+                    {
+                        addInterProcFace
+                        (
+                            -1,
+                            ownerProc,
+                            nbrProc,
+                            patchi,
+                            procNbrToInterPatch,
+                            interPatchFaces,
+                            subPatchIDs,
+                            subPatchStarts
+                        );
+                    }
                 }
             }
+        }
+        else if (isA<cyclicPolyPatch>(patches[patchi]))
+        {
+            const cyclicPolyPatch& cPp =
+                refCast<const cyclicPolyPatch>(patches[patchi]);
+
+            if (cPp.owner() != owner) continue;
+
+            const labelUList& patchFaceCells = cPp.faceCells();
+            const labelUList& nbrPatchFaceCells = cPp.nbrPatch().faceCells();
 
             // Add faces with different owner and neighbour processors
             forAll(patchFaceCells, facei)
             {
                 const label ownerProc = cellToProc[patchFaceCells[facei]];
                 const label nbrProc = cellToProc[nbrPatchFaceCells[facei]];
+
                 if (bop(ownerProc, nbrProc))
                 {
-                    // inter - processor patch face found.
                     addInterProcFace
                     (
-                        pp.start()+facei,
+                        cPp.start() + facei,
                         ownerProc,
                         nbrProc,
+                        patchi,
                         procNbrToInterPatch,
-                        interPatchFaces
+                        interPatchFaces,
+                        subPatchIDs,
+                        subPatchStarts
                     );
                 }
             }
-
-            // 1. Check if any faces added to existing interfaces
-            forAll(oldInterfaceSizes, proci)
-            {
-                const labelList& curOldSizes = oldInterfaceSizes[proci];
-
-                forAll(curOldSizes, interI)
-                {
-                    label oldSz = curOldSizes[interI];
-                    if (interPatchFaces[proci][interI].size() > oldSz)
-                    {
-                        // Added faces to this interface. Add an entry
-                        subPatchIDs[proci][interI].append(patchi);
-                        subPatchStarts[proci][interI].append(oldSz);
-                    }
-                }
-            }
-
-            // 2. Any new interfaces
-            forAll(subPatchIDs, proci)
-            {
-                label nIntfcs = interPatchFaces[proci].size();
-                subPatchIDs[proci].setSize(nIntfcs, labelList(1, patchi));
-                subPatchStarts[proci].setSize(nIntfcs, labelList(1, label(0)));
-            }
         }
     }
 }
 
 
-void Foam::domainDecomposition::validate() const
-{
-    if (!procMeshes_.set(0))
-    {
-        FatalErrorInFunction
-            << "Decomposition data requested but decomposition has not been "
-            << "generated or read" << exit(FatalError);
-    }
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::domainDecomposition::domainDecomposition
-(
-    const fvMesh& mesh
-)
-:
-    mesh_(mesh),
-    nProcs_
-    (
-        decompositionMethod::decomposeParDict(mesh_.time())
-       .lookup<int>("numberOfSubdomains")
-    ),
-    facesInstancePointsPtr_(nullptr),
-    distributed_(false),
-    procPointAddressing_(nProcs_),
-    procFaceAddressing_(nProcs_),
-    procCellAddressing_(nProcs_),
-    procRunTimes_(nProcs_),
-    procMeshes_(nProcs_)
-{
-    readPoints();
-
-    decompositionMethod::decomposeParDict(mesh_.time()).readIfPresent
-    (
-        "distributed",
-        distributed_
-    );
-
-    // Create root databases for the processors
-    for (label proci = 0; proci < nProcs_; proci++)
-    {
-        procRunTimes_.set
-        (
-            proci,
-            new Time
-            (
-                Time::controlDictName,
-                mesh_.time().rootPath(),
-                mesh_.time().caseName()
-               /fileName(word("processor") + Foam::name(proci)),
-                word("system"),
-                word("constant")
-            )
-        );
-
-        procRunTimes_[proci].setTime(mesh_.time());
-    }
-}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-Foam::domainDecomposition::~domainDecomposition()
-{}
-
-
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 void Foam::domainDecomposition::decompose()
@@ -338,10 +282,10 @@ void Foam::domainDecomposition::decompose()
     Info<< "\nCalculating original mesh data" << endl;
 
     // set references to the original mesh
-    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
-    const faceList& fcs = mesh_.faces();
-    const labelList& owner = mesh_.faceOwner();
-    const labelList& neighbour = mesh_.faceNeighbour();
+    const polyBoundaryMesh& patches = completeMesh().boundaryMesh();
+    const faceList& fcs = completeMesh().faces();
+    const labelList& owner = completeMesh().faceOwner();
+    const labelList& neighbour = completeMesh().faceNeighbour();
 
     // loop through the list of processor labels for the cell and add the
     // cell shape to the list of cells for the appropriate processor
@@ -349,7 +293,7 @@ void Foam::domainDecomposition::decompose()
     Info<< "\nDistributing cells to processors" << endl;
 
     // Cells per processor
-    procCellAddressing_ = invertOneToMany(nProcs_, cellToProc);
+    procCellAddressing_ = invertOneToMany(nProcs(), cellToProc);
 
     Info<< "\nDistributing faces to processors" << endl;
 
@@ -357,31 +301,29 @@ void Foam::domainDecomposition::decompose()
     // First visit all internal faces. If cells at both sides belong to the
     // same processor, the face is an internal face. If they are different,
     // it belongs to both processors.
+    List<DynamicList<label>> dynProcFaceAddressing(nProcs());
 
     // Internal faces
-    forAll(procFaceAddressing_, proci)
-    {
-        procFaceAddressing_[proci].clear();
-    }
     forAll(neighbour, facei)
     {
         if (cellToProc[owner[facei]] == cellToProc[neighbour[facei]])
         {
             // Face internal to processor. Notice no turning index.
-            procFaceAddressing_[cellToProc[owner[facei]]].append(facei+1);
+            dynProcFaceAddressing[cellToProc[owner[facei]]].append(facei+1);
         }
     }
 
     // for all processors, set the size of start index and patch size
     // lists to the number of patches in the mesh
-    labelListList procPatchSize(nProcs_);
-    labelListList procPatchStartIndex(nProcs_);
+    labelListList procPatchSize(nProcs());
+    labelListList procPatchStartIndex(nProcs());
     forAll(procPatchSize, proci)
     {
         procPatchSize[proci].setSize(patches.size());
         procPatchStartIndex[proci].setSize(patches.size());
     }
 
+    // Patch faces
     forAll(patches, patchi)
     {
         // Reset size and start index for all processors
@@ -389,7 +331,7 @@ void Foam::domainDecomposition::decompose()
         {
             procPatchSize[proci][patchi] = 0;
             procPatchStartIndex[proci][patchi] =
-                procFaceAddressing_[proci].size();
+                dynProcFaceAddressing[proci].size();
         }
 
         const label patchStart = patches[patchi].start();
@@ -397,17 +339,16 @@ void Foam::domainDecomposition::decompose()
         if (!isA<cyclicPolyPatch>(patches[patchi]))
         {
             // Normal patch. Add faces to processor where the cell
-            // next to the face lives
+            // next to the face lives.
 
-            const labelUList& patchFaceCells =
-                patches[patchi].faceCells();
+            const labelUList& patchFaceCells = patches[patchi].faceCells();
 
             forAll(patchFaceCells, facei)
             {
                 const label curProc = cellToProc[patchFaceCells[facei]];
 
                 // add the face without turning index
-                procFaceAddressing_[curProc].append(patchStart+facei+1);
+                dynProcFaceAddressing[curProc].append(patchStart+facei+1);
 
                 // increment the number of faces for this patch
                 procPatchSize[curProc][patchi]++;
@@ -415,24 +356,25 @@ void Foam::domainDecomposition::decompose()
         }
         else
         {
-            const cyclicPolyPatch& pp = refCast<const cyclicPolyPatch>
-            (
-                patches[patchi]
-            );
-            // cyclic: check opposite side on this processor
-            const labelUList& patchFaceCells = pp.faceCells();
+            // Cyclic patch. Add if the opposite sides are on the same
+            // processor.
 
-            const labelUList& nbrPatchFaceCells =
-                pp.nbrPatch().faceCells();
+            const cyclicPolyPatch& pp =
+                refCast<const cyclicPolyPatch>(patches[patchi]);
+
+            const labelUList& patchFaceCells = pp.faceCells();
+            const labelUList& nbrPatchFaceCells = pp.nbrPatch().faceCells();
 
             forAll(patchFaceCells, facei)
             {
                 const label curProc = cellToProc[patchFaceCells[facei]];
                 const label nbrProc = cellToProc[nbrPatchFaceCells[facei]];
+
                 if (curProc == nbrProc)
                 {
                     // add the face without turning index
-                    procFaceAddressing_[curProc].append(patchStart+facei+1);
+                    dynProcFaceAddressing[curProc].append(patchStart+facei+1);
+
                     // increment the number of faces for this patch
                     procPatchSize[curProc][patchi]++;
                 }
@@ -444,10 +386,14 @@ void Foam::domainDecomposition::decompose()
 
     // Per processor, from neighbour processor to the inter-processor patch
     // that communicates with that neighbour
-    List<Map<label>> procNbrToInterPatch(nProcs_);
+    List<Map<label>> procNbrToInterPatch(nProcs());
 
     // Per processor the faces per inter-processor patch
-    List<DynamicList<DynamicList<label>>> interPatchFaces(nProcs_);
+    List<DynamicList<DynamicList<label>>> interPatchFaces(nProcs());
+
+    // Sub-patch ID-s and starts for inter-processor patches
+    List<labelListList> subPatchIDs(nProcs());
+    List<labelListList> subPatchStarts(nProcs());
 
     // Processor boundaries from internal faces
     forAll(neighbour, facei)
@@ -463,25 +409,15 @@ void Foam::domainDecomposition::decompose()
                 facei,
                 ownerProc,
                 nbrProc,
-
+                -1,
                 procNbrToInterPatch,
-                interPatchFaces
+                interPatchFaces,
+                subPatchIDs,
+                subPatchStarts
             );
         }
     }
 
-    // Add the proper processor faces to the sub information. For faces
-    // originating from internal faces this is always -1.
-    List<labelListList> subPatchIDs(nProcs_);
-    List<labelListList> subPatchStarts(nProcs_);
-    forAll(interPatchFaces, proci)
-    {
-        label nInterfaces = interPatchFaces[proci].size();
-
-        subPatchIDs[proci].setSize(nInterfaces, labelList(1, label(-1)));
-        subPatchStarts[proci].setSize(nInterfaces, labelList(1, label(0)));
-    }
-
     // Special handling needed for the case that multiple processor cyclic
     // patches are created on each local processor domain, e.g. if a 3x3 case
     // is decomposed using the decomposition:
@@ -502,8 +438,8 @@ void Foam::domainDecomposition::decompose()
     // - the sub-patches are therefore generated in 4 passes of the patch lists
     //   1. add faces from owner patch where local proc i < nbr proc i
     //   2. add faces from nbr patch where local proc i < nbr proc i
-    //   3. add faces from owner patch where local proc i > nbr proc i
-    //   4. add faces from nbr patch where local proc i > nbr proc i
+    //   3. add faces from nbr patch where local proc i > nbr proc i
+    //   4. add faces from owner patch where local proc i > nbr proc i
 
     processInterCyclics
     (
@@ -554,11 +490,11 @@ void Foam::domainDecomposition::decompose()
     );
 
     // Sort inter-proc patch by neighbour
-    labelListList procNeighbourProcessors(nProcs_);
-    labelListList procProcessorPatchSize(nProcs_);
-    labelListList procProcessorPatchStartIndex(nProcs_);
-    List<labelListList> procProcessorPatchSubPatchIDs(nProcs_);
-    List<labelListList> procProcessorPatchSubPatchStarts(nProcs_);
+    labelListList procNeighbourProcessors(nProcs());
+    labelListList procProcessorPatchSize(nProcs());
+    labelListList procProcessorPatchStartIndex(nProcs());
+    List<labelListList> procProcessorPatchSubPatchIDs(nProcs());
+    List<labelListList> procProcessorPatchSubPatchStarts(nProcs());
     labelList order;
     forAll(procNbrToInterPatch, proci)
     {
@@ -588,7 +524,7 @@ void Foam::domainDecomposition::decompose()
             procProcessorPatchSize[proci][i] =
                 curInterPatchFaces[interPatch].size();
             procProcessorPatchStartIndex[proci][i] =
-                procFaceAddressing_[proci].size();
+                dynProcFaceAddressing[proci].size();
 
             // Add size as last element to substarts and transfer
             subPatchStarts[proci][interPatch].append
@@ -610,14 +546,20 @@ void Foam::domainDecomposition::decompose()
 
             forAll(interPatchFaces, j)
             {
-                procFaceAddressing_[proci].append(interPatchFaces[j]);
+                dynProcFaceAddressing[proci].append(interPatchFaces[j]);
             }
 
             interPatchFaces.clearStorage();
         }
 
         curInterPatchFaces.clearStorage();
-        procFaceAddressing_[proci].shrink();
+        dynProcFaceAddressing[proci].shrink();
+    }
+
+    // Transfer face addressing to non-dynamic member data
+    forAll(dynProcFaceAddressing, proci)
+    {
+        procFaceAddressing_[proci].transfer(dynProcFaceAddressing[proci]);
     }
 
     if (debug)
@@ -653,7 +595,10 @@ void Foam::domainDecomposition::decompose()
             }
         }
         Info<< endl;
+    }
 
+    if (debug > 1)
+    {
         forAll(procFaceAddressing_, proci)
         {
             Info<< "Processor:" << proci << endl;
@@ -670,7 +615,7 @@ void Foam::domainDecomposition::decompose()
 
     forAll(procPointAddressing_, proci)
     {
-        boolList pointLabels(mesh_.nPoints(), false);
+        boolList pointLabels(completeMesh().nPoints(), false);
 
         // Get reference to list of used faces
         const labelList& procFaceLabels = procFaceAddressing_[proci];
@@ -719,24 +664,24 @@ void Foam::domainDecomposition::decompose()
     // for the duplicate elements
 
     // Point zones
-    labelList pointToZone(mesh_.points().size(), -1);
-    forAll(mesh_.pointZones(), zoneI)
+    labelList pointToZone(completeMesh().points().size(), -1);
+    forAll(completeMesh().pointZones(), zoneI)
     {
-        mark(mesh_.pointZones()[zoneI], zoneI, pointToZone);
+        mark(completeMesh().pointZones()[zoneI], zoneI, pointToZone);
     }
 
     // Face zones
-    labelList faceToZone(mesh_.faces().size(), -1);
-    forAll(mesh_.faceZones(), zoneI)
+    labelList faceToZone(completeMesh().faces().size(), -1);
+    forAll(completeMesh().faceZones(), zoneI)
     {
-        mark(mesh_.faceZones()[zoneI], zoneI, faceToZone);
+        mark(completeMesh().faceZones()[zoneI], zoneI, faceToZone);
     }
 
     // Cell zones
-    labelList cellToZone(mesh_.nCells(), -1);
-    forAll(mesh_.cellZones(), zoneI)
+    labelList cellToZone(completeMesh().nCells(), -1);
+    forAll(completeMesh().cellZones(), zoneI)
     {
-        mark(mesh_.cellZones()[zoneI], zoneI, cellToZone);
+        mark(completeMesh().cellZones()[zoneI], zoneI, cellToZone);
     }
 
     // Initialise information for reporting
@@ -747,12 +692,12 @@ void Foam::domainDecomposition::decompose()
     label maxProcFaces = 0;
 
     // Generate the meshes
-    for (label proci = 0; proci < nProcs_; proci++)
+    for (label proci = 0; proci < nProcs(); proci++)
     {
         // Create processor points
         const labelList& curPointLabels = procPointAddressing_[proci];
-        const pointField& meshPoints = mesh_.points();
-        labelList pointLookup(mesh_.nPoints(), -1);
+        const pointField& meshPoints = completeMesh().points();
+        labelList pointLookup(completeMesh().nPoints(), -1);
         pointField procPoints(curPointLabels.size());
         forAll(curPointLabels, pointi)
         {
@@ -762,8 +707,8 @@ void Foam::domainDecomposition::decompose()
 
         // Create processor faces
         const labelList& curFaceLabels = procFaceAddressing_[proci];
-        const faceList& meshFaces = mesh_.faces();
-        labelList faceLookup(mesh_.nFaces(), -1);
+        const faceList& meshFaces = completeMesh().faces();
+        labelList faceLookup(completeMesh().nFaces(), -1);
         faceList procFaces(curFaceLabels.size());
         forAll(curFaceLabels, facei)
         {
@@ -799,7 +744,7 @@ void Foam::domainDecomposition::decompose()
 
         // Create processor cells
         const labelList& curCellLabels = procCellAddressing_[proci];
-        const cellList& meshCells = mesh_.cells();
+        const cellList& meshCells = completeMesh().cells();
         cellList procCells(curCellLabels.size());
         forAll(curCellLabels, celli)
         {
@@ -812,63 +757,25 @@ void Foam::domainDecomposition::decompose()
             }
         }
 
-        // Create a processor mesh without a boundary. Two situations:
-        //
-        // - Static and topo-changing cases. Points and faces come from the
-        //   same time/instance. The mesh will get constructed in the same
-        //   instance.
-        //
-        // - Moving mesh cases. Points and faces come from different times. We
-        //   read the points belonging to the faces instance. We then proceed
-        //   as normal. Only at write time will we additionally write the
-        //   current points.
-        //
-        if (mesh_.pointsInstance() != mesh_.facesInstance())
-        {
-            // Construct mesh from facesInstance.
-            pointField facesInstancePoints
+        // Create a processor mesh without a boundary
+        procMeshes_.set
+        (
+            proci,
+            new fvMesh
             (
-                facesInstancePointsPtr_(),
-                curPointLabels
-            );
-
-            procMeshes_.set
-            (
-                proci,
-                new fvMesh
+                IOobject
                 (
-                    IOobject
-                    (
-                        mesh_.polyMesh::name(), // region of undecomposed mesh
-                        mesh_.facesInstance(),
-                        procRunTimes_[proci]
-                    ),
-                    move(facesInstancePoints),
-                    move(procFaces),
-                    move(procCells)
-                )
-            );
-        }
-        else
-        {
-            procMeshes_.set
-            (
-                proci,
-                new fvMesh
-                (
-                    IOobject
-                    (
-                        mesh_.polyMesh::name(), // region of undecomposed mesh
-                        mesh_.facesInstance(),
-                        procRunTimes_[proci]
-                    ),
-                    move(procPoints),
-                    move(procFaces),
-                    move(procCells)
-                )
-            );
-        }
+                    regionName_,
+                    completeMesh().facesInstance(),
+                    runTimes_.procTimes()[proci]
+                ),
+                move(procPoints),
+                move(procFaces),
+                move(procCells)
+            )
+        );
         fvMesh& procMesh = procMeshes_[proci];
+        procMesh.setPointsInstance(completeMesh().pointsInstance());
 
         // Create processor boundary patch information
         const labelList& curPatchSizes = procPatchSize[proci];
@@ -883,7 +790,7 @@ void Foam::domainDecomposition::decompose()
             procProcessorPatchSubPatchIDs[proci];
         const labelListList& curSubStarts =
             procProcessorPatchSubPatchStarts[proci];
-        const polyPatchList& meshPatches = mesh_.boundaryMesh();
+        const polyPatchList& meshPatches = completeMesh().boundaryMesh();
 
         // Count the number of inter-proc patches
         label nInterProcPatches = 0;
@@ -902,29 +809,21 @@ void Foam::domainDecomposition::decompose()
         // Map existing non-proc patches
         forAll(curPatchSizes, patchi)
         {
-            // Get the face labels consistent with the field mapping
-            // (reuse the patch field mappers)
             const polyPatch& meshPatch = meshPatches[patchi];
 
-            fvFieldDecomposer::patchFieldDecomposer patchMapper
-            (
-                SubList<label>
+            procPatches[nPatches] =
+                meshPatch.clone
                 (
-                    curFaceLabels,
-                    curPatchSizes[patchi],
+                    procMesh.boundaryMesh(),
+                    nPatches,
+                    SubList<label>
+                    (
+                        curFaceLabels,
+                        curPatchSizes[patchi],
+                        curPatchStarts[patchi]
+                    ) - 1 - meshPatch.start(),
                     curPatchStarts[patchi]
-                ),
-                meshPatch.start()
-            );
-
-            // Map existing patches
-            procPatches[nPatches] = meshPatch.clone
-            (
-                procMesh.boundaryMesh(),
-                nPatches,
-                patchMapper.addressing(),
-                curPatchStarts[patchi]
-            ).ptr();
+                ).ptr();
 
             nPatches++;
         }
@@ -940,13 +839,13 @@ void Foam::domainDecomposition::decompose()
             forAll(subPatchID, i)
             {
                 const label size =
-                    i < subPatchID.size()-1
+                    i < subPatchID.size() - 1
                   ? subStarts[i+1] - subStarts[i]
                   : curProcessorPatchSizes[procPatchi] - subStarts[i];
 
                 if (subPatchID[i] == -1)
                 {
-                    // From internal faces
+                    // Processor patch from internal faces
                     procPatches[nPatches] =
                         new processorPolyPatch
                         (
@@ -958,11 +857,49 @@ void Foam::domainDecomposition::decompose()
                             curNeighbourProcessors[procPatchi]
                         );
                 }
-                else
+                else if
+                (
+                    isA<nonConformalCyclicPolyPatch>
+                    (
+                        completeMesh().boundaryMesh()[subPatchID[i]]
+                    )
+                )
                 {
-                    const coupledPolyPatch& cpp =
-                        refCast<const coupledPolyPatch>
-                        (mesh_.boundaryMesh()[subPatchID[i]]);
+                    // Non-conformal processor cyclic patch from split
+                    // non-conformal cyclic patch
+                    const nonConformalCyclicPolyPatch& nccPp =
+                        refCast<const nonConformalCyclicPolyPatch>
+                        (
+                            completeMesh().boundaryMesh()[subPatchID[i]]
+                        );
+
+                    procPatches[nPatches] =
+                        new nonConformalProcessorCyclicPolyPatch
+                        (
+                            size,
+                            curStart,
+                            nPatches,
+                            procMesh.boundaryMesh(),
+                            proci,
+                            curNeighbourProcessors[procPatchi],
+                            nccPp.name(),
+                            nccPp.origPatch().name()
+                        );
+                }
+                else if
+                (
+                    isA<cyclicPolyPatch>
+                    (
+                        completeMesh().boundaryMesh()[subPatchID[i]]
+                    )
+                )
+                {
+                    // Processor cyclic patch from split cyclic faces
+                    const cyclicPolyPatch& cPp =
+                        refCast<const cyclicPolyPatch>
+                        (
+                            completeMesh().boundaryMesh()[subPatchID[i]]
+                        );
 
                     procPatches[nPatches] =
                         new processorCyclicPolyPatch
@@ -973,9 +910,15 @@ void Foam::domainDecomposition::decompose()
                             procMesh.boundaryMesh(),
                             proci,
                             curNeighbourProcessors[procPatchi],
-                            cpp.name()
+                            cPp.name()
                         );
                 }
+                else
+                {
+                    FatalErrorInFunction
+                        << "Sub patch ID set for non-cyclic patch type"
+                        << exit(FatalError);
+                }
 
                 curStart += size;
 
@@ -988,7 +931,7 @@ void Foam::domainDecomposition::decompose()
 
         // Create point zones
         {
-            const meshPointZones& pz = mesh_.pointZones();
+            const meshPointZones& pz = completeMesh().pointZones();
 
             // Go through all the zoned points and find out if they
             // belong to a zone.  If so, add it to the zone as
@@ -998,7 +941,7 @@ void Foam::domainDecomposition::decompose()
             // Estimate size
             forAll(zonePoints, zoneI)
             {
-                zonePoints[zoneI].setCapacity(pz[zoneI].size() / nProcs_);
+                zonePoints[zoneI].setCapacity(pz[zoneI].size()/nProcs());
             }
 
             // Use the pointToZone map to find out the single zone (if any),
@@ -1054,7 +997,7 @@ void Foam::domainDecomposition::decompose()
 
         // Create face zones
         {
-            const meshFaceZones& fz = mesh_.faceZones();
+            const meshFaceZones& fz = completeMesh().faceZones();
 
             // Go through all the zoned face and find out if they
             // belong to a zone.  If so, add it to the zone as
@@ -1065,7 +1008,7 @@ void Foam::domainDecomposition::decompose()
             // Estimate size
             forAll(zoneFaces, zoneI)
             {
-                label procSize = fz[zoneI].size() / nProcs_;
+                label procSize = fz[zoneI].size()/nProcs();
 
                 zoneFaces[zoneI].setCapacity(procSize);
                 zoneFaceFlips[zoneI].setCapacity(procSize);
@@ -1148,7 +1091,7 @@ void Foam::domainDecomposition::decompose()
 
         // Create cell zones
         {
-            const meshCellZones& cz = mesh_.cellZones();
+            const meshCellZones& cz = completeMesh().cellZones();
 
             // Go through all the zoned cells and find out if they
             // belong to a zone.  If so, add it to the zone as
@@ -1158,7 +1101,7 @@ void Foam::domainDecomposition::decompose()
             // Estimate size
             forAll(zoneCells, zoneI)
             {
-                zoneCells[zoneI].setCapacity(cz[zoneI].size() / nProcs_);
+                zoneCells[zoneI].setCapacity(cz[zoneI].size()/nProcs());
             }
 
             forAll(curCellLabels, celli)
@@ -1257,9 +1200,9 @@ void Foam::domainDecomposition::decompose()
     }
 
     // Determine the average number of processor elements
-    scalar avgProcCells = scalar(mesh_.nCells())/nProcs_;
-    scalar avgProcPatches = scalar(totProcPatches)/nProcs_;
-    scalar avgProcFaces = scalar(totProcFaces)/nProcs_;
+    scalar avgProcCells = scalar(completeMesh().nCells())/nProcs();
+    scalar avgProcPatches = scalar(totProcPatches)/nProcs();
+    scalar avgProcFaces = scalar(totProcFaces)/nProcs();
 
     // Prevent division by zero in the case of all faces on one processor
     if (totProcPatches == 0)
@@ -1283,393 +1226,9 @@ void Foam::domainDecomposition::decompose()
         << " (" << 100.0*(maxProcFaces-avgProcFaces)/avgProcFaces
         << "% above average " << avgProcFaces << ")" << nl
         << endl;
-}
 
-
-void Foam::domainDecomposition::setTime
-(
-    const instant& inst,
-    const label newIndex
-)
-{
-    for (label proci = 0; proci < nProcs_; proci++)
-    {
-        procRunTimes_[proci].setTime(inst, newIndex);
-    }
-}
-
-
-void Foam::domainDecomposition::readPoints()
-{
-    if (mesh_.pointsInstance() != mesh_.facesInstance())
-    {
-        facesInstancePointsPtr_.reset
-        (
-            new pointIOField
-            (
-                IOobject
-                (
-                    "points",
-                    mesh_.facesInstance(),
-                    polyMesh::meshSubDir,
-                    mesh_,
-                    IOobject::MUST_READ,
-                    IOobject::NO_WRITE,
-                    false
-                )
-            )
-        );
-    }
-}
-
-
-void Foam::domainDecomposition::readAddressing()
-{
-    for (label proci = 0; proci < nProcs_; proci++)
-    {
-        const fvMesh& procMesh = procMeshes_[proci];
-
-        procPointAddressing_[proci] =
-            labelIOList
-            (
-                IOobject
-                (
-                    "pointProcAddressing",
-                    procMesh.facesInstance(),
-                    procMesh.meshSubDir,
-                    procMesh,
-                    IOobject::MUST_READ,
-                    IOobject::NO_WRITE,
-                    false
-                )
-            );
-
-        procFaceAddressing_[proci] =
-            labelIOList
-            (
-                IOobject
-                (
-                    "faceProcAddressing",
-                    procMesh.facesInstance(),
-                    procMesh.meshSubDir,
-                    procMesh,
-                    IOobject::MUST_READ,
-                    IOobject::NO_WRITE,
-                    false
-                )
-            );
-
-        procCellAddressing_[proci] =
-            labelIOList
-            (
-                IOobject
-                (
-                    "cellProcAddressing",
-                    procMesh.facesInstance(),
-                    procMesh.meshSubDir,
-                    procMesh,
-                    IOobject::MUST_READ,
-                    IOobject::NO_WRITE,
-                    false
-                )
-            );
-    }
-}
-
-
-void Foam::domainDecomposition::read()
-{
-    for (label proci = 0; proci < nProcs_; proci++)
-    {
-        procMeshes_.set
-        (
-            proci,
-            new fvMesh
-            (
-                IOobject
-                (
-                    mesh_.polyMesh::name(), // region of undecomposed mesh
-                    procRunTimes_[proci].timeName(),
-                    procRunTimes_[proci]
-                ),
-                false
-            )
-        );
-    }
-
-    readAddressing();
-}
-
-
-Foam::fvMesh::readUpdateState Foam::domainDecomposition::readUpdate()
-{
-    fvMesh::readUpdateState stat = fvMesh::UNCHANGED;
-
-    forAll(procRunTimes_, proci)
-    {
-        fvMesh::readUpdateState procStat = procMeshes_[proci].readUpdate();
-
-        if (procStat > stat)
-        {
-            stat = procStat;
-        }
-    }
-
-    if (mesh_.pointsInstance() != mesh_.facesInstance())
-    {
-        readPoints();
-    }
-    else
-    {
-        facesInstancePointsPtr_.clear();
-    }
-
-    if
-    (
-        stat == fvMesh::TOPO_CHANGE
-     || stat == fvMesh::TOPO_PATCH_CHANGE
-    )
-    {
-        readAddressing();
-    }
-
-    return stat;
-}
-
-
-Foam::labelList Foam::domainDecomposition::cellToProc() const
-{
-    labelList result(mesh_.nCells());
-
-    forAll(procCellAddressing_, proci)
-    {
-        forAll(procCellAddressing_[proci], procCelli)
-        {
-            result[procCellAddressing_[proci][procCelli]] = proci;
-        }
-    }
-
-    return result;
-}
-
-
-void Foam::domainDecomposition::writePoints() const
-{
-    for (label proci = 0; proci < nProcs_; proci++)
-    {
-        const fvMesh& procMesh = procMeshes_[proci];
-
-        if (mesh_.pointsInstance() != mesh_.facesInstance())
-        {
-            pointField procPoints
-            (
-                mesh_.points(),
-                procPointAddressing_[proci]
-            );
-
-            pointIOField pointsInstancePoints
-            (
-                IOobject
-                (
-                    "points",
-                    mesh_.pointsInstance(),
-                    polyMesh::meshSubDir,
-                    procMesh,
-                    IOobject::NO_READ,
-                    IOobject::NO_WRITE,
-                    false
-                ),
-                move(procPoints)
-            );
-
-            pointsInstancePoints.write();
-        }
-    }
-}
-
-
-void Foam::domainDecomposition::writeAddressing() const
-{
-    for (label proci = 0; proci < nProcs_; proci++)
-    {
-        const fvMesh& procMesh = procMeshes_[proci];
-
-        labelIOList pointProcAddressing
-        (
-            IOobject
-            (
-                "pointProcAddressing",
-                procMesh.facesInstance(),
-                procMesh.meshSubDir,
-                procMesh,
-                IOobject::NO_READ,
-                IOobject::NO_WRITE
-            ),
-            procPointAddressing_[proci]
-        );
-        pointProcAddressing.write();
-
-        labelIOList faceProcAddressing
-        (
-            IOobject
-            (
-                "faceProcAddressing",
-                procMesh.facesInstance(),
-                procMesh.meshSubDir,
-                procMesh,
-                IOobject::NO_READ,
-                IOobject::NO_WRITE
-            ),
-            procFaceAddressing_[proci]
-        );
-        faceProcAddressing.write();
-
-        labelIOList cellProcAddressing
-        (
-            IOobject
-            (
-                "cellProcAddressing",
-                procMesh.facesInstance(),
-                procMesh.meshSubDir,
-                procMesh,
-                IOobject::NO_READ,
-                IOobject::NO_WRITE
-            ),
-            procCellAddressing_[proci]
-        );
-        cellProcAddressing.write();
-    }
-}
-
-
-void Foam::domainDecomposition::write(const bool decomposeSets) const
-{
-    validate();
-
-    // Read sets
-    PtrList<const cellSet> cellSets;
-    PtrList<const faceSet> faceSets;
-    PtrList<const pointSet> pointSets;
-    if (decomposeSets)
-    {
-        IOobjectList objects(mesh_, mesh_.facesInstance(), "polyMesh/sets");
-        {
-            IOobjectList cSets(objects.lookupClass(cellSet::typeName));
-            forAllConstIter(IOobjectList, cSets, iter)
-            {
-                cellSets.append(new cellSet(*iter()));
-            }
-        }
-        {
-            IOobjectList fSets(objects.lookupClass(faceSet::typeName));
-            forAllConstIter(IOobjectList, fSets, iter)
-            {
-                faceSets.append(new faceSet(*iter()));
-            }
-        }
-        {
-            IOobjectList pSets(objects.lookupClass(pointSet::typeName));
-            forAllConstIter(IOobjectList, pSets, iter)
-            {
-                pointSets.append(new pointSet(*iter()));
-            }
-        }
-    }
-
-    // Read refinement data (if any)
-    hexRef8Data refinementData
-    (
-        IOobject
-        (
-            "dummy",
-            mesh_.facesInstance(),
-            polyMesh::meshSubDir,
-            mesh_,
-            IOobject::READ_IF_PRESENT,
-            IOobject::NO_WRITE,
-            false
-        )
-    );
-
-    // Write out the meshes
-    for (label proci = 0; proci < nProcs_; proci++)
-    {
-        const fvMesh& procMesh = procMeshes_[proci];
-
-        // Set the precision of the points data to be min 10
-        IOstream::defaultPrecision(max(10u, IOstream::defaultPrecision()));
-
-        // Write the processor mesh
-        procMesh.write();
-
-        // Write any sets
-        if (decomposeSets)
-        {
-            forAll(cellSets, i)
-            {
-                const cellSet& cs = cellSets[i];
-                cellSet set(procMesh, cs.name(), cs.size()/nProcs_);
-                forAll(procCellAddressing_[proci], i)
-                {
-                    if (cs.found(procCellAddressing_[proci][i]))
-                    {
-                        set.insert(i);
-                    }
-                }
-                set.write();
-            }
-            forAll(faceSets, i)
-            {
-                const faceSet& cs = faceSets[i];
-                faceSet set(procMesh, cs.name(), cs.size()/nProcs_);
-                forAll(procFaceAddressing_[proci], i)
-                {
-                    if (cs.found(mag(procFaceAddressing_[proci][i])-1))
-                    {
-                        set.insert(i);
-                    }
-                }
-                set.write();
-            }
-            forAll(pointSets, i)
-            {
-                const pointSet& cs = pointSets[i];
-                pointSet set(procMesh, cs.name(), cs.size()/nProcs_);
-                forAll(procPointAddressing_[proci], i)
-                {
-                    if (cs.found(procPointAddressing_[proci][i]))
-                    {
-                        set.insert(i);
-                    }
-                }
-                set.write();
-            }
-        }
-
-        // Write refinement data (if any)
-        hexRef8Data
-        (
-            IOobject
-            (
-                "dummy",
-                mesh_.facesInstance(),
-                polyMesh::meshSubDir,
-                procMesh,
-                IOobject::NO_READ,
-                IOobject::NO_WRITE,
-                false
-            ),
-            refinementData,
-            procCellAddressing_[proci],
-            procPointAddressing_[proci]
-        ).write();
-    }
-
-    // Write points if pointsInstance differing from facesInstance
-    writePoints();
-
-    // Write decomposition addressing
-    writeAddressing();
+    // Unconform any non-conformal parts of the processor meshes
+    unconform();
 }
 
 
diff --git a/src/parallel/parallel/domainDecompositionReconstruct.C b/src/parallel/parallel/domainDecompositionReconstruct.C
new file mode 100644
index 0000000000..5563894314
--- /dev/null
+++ b/src/parallel/parallel/domainDecompositionReconstruct.C
@@ -0,0 +1,45 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "domainDecomposition.H"
+#include "decompositionMethod.H"
+#include "IOobjectList.H"
+#include "cyclicFvPatch.H"
+#include "processorCyclicFvPatch.H"
+#include "nonConformalCyclicFvPatch.H"
+#include "nonConformalProcessorCyclicFvPatch.H"
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::domainDecomposition::reconstruct()
+{
+    // To-do: The plan is to paste most of reconstructParMesh in here. Then,
+    // reconstructPar could be tinkered with such that it automatically
+    // reconstructs the mesh when necessary.
+    NotImplemented;
+}
+
+
+// ************************************************************************* //
diff --git a/src/parallel/parallel/processorRunTimes.C b/src/parallel/parallel/processorRunTimes.C
new file mode 100644
index 0000000000..05b56a9c37
--- /dev/null
+++ b/src/parallel/parallel/processorRunTimes.C
@@ -0,0 +1,117 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "processorRunTimes.H"
+#include "decompositionMethod.H"
+#include "timeSelector.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::processorRunTimes::processorRunTimes
+(
+    const word& name,
+    const argList& args
+)
+:
+    completeRunTime_(name, args),
+    procRunTimes_
+    (
+        decompositionMethod::decomposeParDict(completeRunTime_)
+       .lookup<int>("numberOfSubdomains")
+    )
+{
+    forAll(procRunTimes_, proci)
+    {
+        procRunTimes_.set
+        (
+            proci,
+            new Time
+            (
+                Time::controlDictName,
+                completeRunTime_.rootPath(),
+                completeRunTime_.caseName()
+               /fileName(word("processor") + Foam::name(proci))
+            )
+        );
+
+        procRunTimes_[proci].setTime(completeRunTime_);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::processorRunTimes::~processorRunTimes()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+void Foam::processorRunTimes::setTime
+(
+    const instant& inst,
+    const label newIndex
+)
+{
+    completeRunTime_.setTime(inst, newIndex);
+
+    forAll(procRunTimes_, proci)
+    {
+        procRunTimes_[proci].setTime(inst, newIndex);
+    }
+}
+
+
+Foam::instantList Foam::processorRunTimes::selectComplete(const argList& args)
+{
+    instantList timeDirs =
+        timeSelector::selectIfPresent(completeRunTime_, args);
+
+    forAll(procRunTimes_, proci)
+    {
+        procRunTimes_[proci].setTime(completeRunTime_);
+    }
+
+    return timeDirs;
+}
+
+
+Foam::instantList Foam::processorRunTimes::selectProc(const argList& args)
+{
+    instantList timeDirs =
+        timeSelector::select0(procRunTimes_[0], args);
+
+    completeRunTime_.setTime(procRunTimes_[0]);
+
+    for (label proci = 1; proci < nProcs(); proci ++)
+    {
+        procRunTimes_[proci].setTime(procRunTimes_[0]);
+    }
+
+    return timeDirs;
+}
+
+
+// ************************************************************************* //
diff --git a/src/parallel/parallel/processorRunTimes.H b/src/parallel/parallel/processorRunTimes.H
new file mode 100644
index 0000000000..3ceff4f2b7
--- /dev/null
+++ b/src/parallel/parallel/processorRunTimes.H
@@ -0,0 +1,111 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::processorRunTimes
+
+Description
+
+SourceFiles
+    processorRunTimes.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef processorRunTimes_H
+#define processorRunTimes_H
+
+#include "Time.H"
+#include "PtrList.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                          Class processorRunTimes Declaration
+\*---------------------------------------------------------------------------*/
+
+class processorRunTimes
+{
+    // Private Data
+
+        //- The complete run time
+        Time completeRunTime_;
+
+        //- Processor run times
+        PtrList<Time> procRunTimes_;
+
+
+public:
+
+    // Constructors
+
+        //- Construct from directory and arguments
+        processorRunTimes(const word& name, const argList& args);
+
+
+    //- Destructor
+    ~processorRunTimes();
+
+
+    // Member Functions
+
+        //- Access the complete run time
+        inline const Time& completeTime() const
+        {
+            return completeRunTime_;
+        }
+
+        //- Access the processor run times
+        inline const PtrList<Time>& procTimes() const
+        {
+            return procRunTimes_;
+        }
+
+        //- Return the number of processors
+        inline label nProcs() const
+        {
+            return procRunTimes_.size();
+        }
+
+        //- Set the time
+        void setTime(const instant& inst, const label newIndex);
+
+        //- Select the time
+        instantList selectComplete(const argList& args);
+
+        //- Select the time
+        instantList selectProc(const argList& args);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/parallel/reconstruct/Allwmake b/src/parallel/reconstruct/Allwmake
deleted file mode 100755
index d9ebb6fc90..0000000000
--- a/src/parallel/reconstruct/Allwmake
+++ /dev/null
@@ -1,9 +0,0 @@
-#!/bin/sh
-cd ${0%/*} || exit 1    # Run from this directory
-
-# Parse arguments for library compilation
-. $WM_PROJECT_DIR/wmake/scripts/AllwmakeParseArguments
-
-wmake $targetType reconstruct
-
-#------------------------------------------------------------------------------
diff --git a/src/parallel/reconstruct/reconstruct/Make/files b/src/parallel/reconstruct/reconstruct/Make/files
deleted file mode 100644
index 64023e9573..0000000000
--- a/src/parallel/reconstruct/reconstruct/Make/files
+++ /dev/null
@@ -1,6 +0,0 @@
-processorMeshes.C
-fvFieldReconstructor.C
-pointFieldReconstructor.C
-reconstructLagrangianPositions.C
-
-LIB = $(FOAM_LIBBIN)/libreconstruct
diff --git a/src/parallel/reconstruct/reconstruct/Make/options b/src/parallel/reconstruct/reconstruct/Make/options
deleted file mode 100644
index 7a728f9dd7..0000000000
--- a/src/parallel/reconstruct/reconstruct/Make/options
+++ /dev/null
@@ -1,9 +0,0 @@
-EXE_INC = \
-    -I$(LIB_SRC)/finiteVolume/lnInclude \
-    -I$(LIB_SRC)/meshTools/lnInclude \
-    -I$(LIB_SRC)/lagrangian/basic/lnInclude
-
-LIB_LIBS = \
-    -lfiniteVolume \
-    -lmeshTools \
-    -llagrangian
diff --git a/src/parallel/reconstruct/reconstruct/processorMeshes.C b/src/parallel/reconstruct/reconstruct/processorMeshes.C
deleted file mode 100644
index dc45a80dd7..0000000000
--- a/src/parallel/reconstruct/reconstruct/processorMeshes.C
+++ /dev/null
@@ -1,223 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "processorMeshes.H"
-#include "Time.H"
-#include "primitiveMesh.H"
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-void Foam::processorMeshes::read()
-{
-    // Make sure to clear (and hence unregister) any previously loaded meshes
-    // and fields
-    forAll(databases_, proci)
-    {
-        cellProcAddressing_.set(proci, nullptr);
-        faceProcAddressing_.set(proci, nullptr);
-        pointProcAddressing_.set(proci, nullptr);
-        meshes_.set(proci, nullptr);
-    }
-
-    forAll(databases_, proci)
-    {
-        meshes_.set
-        (
-            proci,
-            new fvMesh
-            (
-                IOobject
-                (
-                    meshName_,
-                    databases_[proci].timeName(),
-                    databases_[proci]
-                ),
-                false
-            )
-        );
-
-        pointProcAddressing_.set
-        (
-            proci,
-            new labelIOList
-            (
-                IOobject
-                (
-                    "pointProcAddressing",
-                    meshes_[proci].facesInstance(),
-                    meshes_[proci].meshSubDir,
-                    meshes_[proci],
-                    IOobject::MUST_READ,
-                    IOobject::NO_WRITE
-                )
-            )
-        );
-
-        faceProcAddressing_.set
-        (
-            proci,
-            new labelIOList
-            (
-                IOobject
-                (
-                    "faceProcAddressing",
-                    meshes_[proci].facesInstance(),
-                    meshes_[proci].meshSubDir,
-                    meshes_[proci],
-                    IOobject::MUST_READ,
-                    IOobject::NO_WRITE
-                )
-            )
-        );
-
-        cellProcAddressing_.set
-        (
-            proci,
-            new labelIOList
-            (
-                IOobject
-                (
-                    "cellProcAddressing",
-                    meshes_[proci].facesInstance(),
-                    meshes_[proci].meshSubDir,
-                    meshes_[proci],
-                    IOobject::MUST_READ,
-                    IOobject::NO_WRITE
-                )
-            )
-        );
-    }
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::processorMeshes::processorMeshes
-(
-    PtrList<Time>& databases,
-    const word& meshName
-)
-:
-    meshName_(meshName),
-    databases_(databases),
-    meshes_(databases.size()),
-    pointProcAddressing_(databases.size()),
-    faceProcAddressing_(databases.size()),
-    cellProcAddressing_(databases.size())
-{
-    read();
-}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-Foam::fvMesh::readUpdateState Foam::processorMeshes::readUpdate()
-{
-    fvMesh::readUpdateState stat = fvMesh::UNCHANGED;
-
-    forAll(databases_, proci)
-    {
-        // Check if any new meshes need to be read.
-        fvMesh::readUpdateState procStat = meshes_[proci].readUpdate();
-
-        if (procStat > stat)
-        {
-            stat = procStat;
-        }
-    }
-
-    if
-    (
-        stat == fvMesh::TOPO_CHANGE
-     || stat == fvMesh::TOPO_PATCH_CHANGE
-    )
-    {
-        // Reread all meshes and addressing
-        read();
-    }
-
-    return stat;
-}
-
-
-void Foam::processorMeshes::reconstructPoints(fvMesh& mesh)
-{
-    // Read the field for all the processors
-    PtrList<pointIOField> procsPoints(meshes_.size());
-
-    forAll(meshes_, proci)
-    {
-        procsPoints.set
-        (
-            proci,
-            new pointIOField
-            (
-                IOobject
-                (
-                    "points",
-                    meshes_[proci].time().timeName(),
-                    polyMesh::meshSubDir,
-                    meshes_[proci],
-                    IOobject::MUST_READ,
-                    IOobject::NO_WRITE,
-                    false
-                )
-            )
-        );
-    }
-
-    // Create the new points
-    vectorField newPoints(mesh.nPoints());
-
-    forAll(meshes_, proci)
-    {
-        const vectorField& procPoints = procsPoints[proci];
-
-        // Set the cell values in the reconstructed field
-
-        const labelList& pointProcAddressingI = pointProcAddressing_[proci];
-
-        if (pointProcAddressingI.size() != procPoints.size())
-        {
-            FatalErrorInFunction
-                << "problem :"
-                << " pointProcAddressingI:" << pointProcAddressingI.size()
-                << " procPoints:" << procPoints.size()
-                << abort(FatalError);
-        }
-
-        forAll(pointProcAddressingI, pointi)
-        {
-            newPoints[pointProcAddressingI[pointi]] = procPoints[pointi];
-        }
-    }
-
-    mesh.movePoints(newPoints);
-    mesh.moving(false);
-    mesh.write();
-}
-
-
-// ************************************************************************* //
diff --git a/src/parallel/reconstruct/reconstruct/processorMeshes.H b/src/parallel/reconstruct/reconstruct/processorMeshes.H
deleted file mode 100644
index a83c22e260..0000000000
--- a/src/parallel/reconstruct/reconstruct/processorMeshes.H
+++ /dev/null
@@ -1,136 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Class
-    Foam::processorMeshes
-
-Description
-    Container for processor mesh addressing.
-
-SourceFiles
-    processorMeshes.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef processorMeshes_H
-#define processorMeshes_H
-
-#include "PtrList.H"
-#include "fvMesh.H"
-#include "IOobjectList.H"
-#include "labelIOList.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-
-/*---------------------------------------------------------------------------*\
-                       Class processorMeshes Declaration
-\*---------------------------------------------------------------------------*/
-
-class processorMeshes
-{
-    // Private Data
-
-        const word meshName_;
-
-        //- Processor databases
-        PtrList<Time>& databases_;
-
-        //- List of processor meshes
-        PtrList<fvMesh> meshes_;
-
-        //- List of processor point addressing lists
-        PtrList<labelIOList> pointProcAddressing_;
-
-        //- List of processor face addressing lists
-        PtrList<labelIOList> faceProcAddressing_;
-
-        //- List of processor cell addressing lists
-        PtrList<labelIOList> cellProcAddressing_;
-
-
-    // Private Member Functions
-
-        //- Read all meshes
-        void read();
-
-
-public:
-
-    // Constructors
-
-        //- Construct from components
-        processorMeshes(PtrList<Time>& databases, const word& meshName);
-
-        //- Disallow default bitwise copy construction
-        processorMeshes(const processorMeshes&) = delete;
-
-
-    // Member Functions
-
-        //- Update the meshes based on the mesh files saved in time directories
-        fvMesh::readUpdateState readUpdate();
-
-        //- Reconstruct point position after motion in parallel
-        void reconstructPoints(fvMesh&);
-
-        PtrList<fvMesh>& meshes()
-        {
-            return meshes_;
-        }
-
-        const PtrList<labelIOList>& pointProcAddressing() const
-        {
-            return pointProcAddressing_;
-        }
-
-        PtrList<labelIOList>& faceProcAddressing()
-        {
-            return faceProcAddressing_;
-        }
-
-        const PtrList<labelIOList>& cellProcAddressing() const
-        {
-            return cellProcAddressing_;
-        }
-
-
-    // Member Operators
-
-        //- Disallow default bitwise assignment
-        void operator=(const processorMeshes&) = delete;
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/src/sampling/sampledSet/sampledSet/sampledSetParticle.C b/src/sampling/sampledSet/sampledSet/sampledSetParticle.C
index d07c39f071..57a626dda0 100644
--- a/src/sampling/sampledSet/sampledSet/sampledSetParticle.C
+++ b/src/sampling/sampledSet/sampledSet/sampledSetParticle.C
@@ -131,9 +131,9 @@ bool Foam::sampledSetParticle::move
 )
 {
     td.keepParticle = true;
-    td.switchProcessor = false;
+    td.sendToProc = -1;
 
-    while (td.keepParticle && !td.switchProcessor && seti_ < td.set_.size() - 1)
+    while (td.keepParticle && td.sendToProc == -1 && seti_ < td.set_.size() - 1)
     {
         const vector s = td.set_[seti_ + 1] - td.set_[seti_];
         const scalar magS = mag(s);
@@ -180,12 +180,6 @@ bool Foam::sampledSetParticle::move
 }
 
 
-bool Foam::sampledSetParticle::hitPatch(sampledSetCloud&, trackingData&)
-{
-    return false;
-}
-
-
 void Foam::sampledSetParticle::hitWedgePatch
 (
     sampledSetCloud&,
@@ -264,7 +258,7 @@ void Foam::sampledSetParticle::hitCyclicRepeatAMIPatch
 
 void Foam::sampledSetParticle::hitProcessorPatch
 (
-    sampledSetCloud&,
+    sampledSetCloud& cloud,
     trackingData& td
 )
 {
@@ -277,7 +271,7 @@ void Foam::sampledSetParticle::hitProcessorPatch
     }
     else
     {
-        td.switchProcessor = true;
+        particle::hitProcessorPatch(cloud, td);
     }
 }
 
diff --git a/src/sampling/sampledSet/sampledSet/sampledSetParticle.H b/src/sampling/sampledSet/sampledSet/sampledSetParticle.H
index 571ec9d3c7..110adacf45 100644
--- a/src/sampling/sampledSet/sampledSet/sampledSetParticle.H
+++ b/src/sampling/sampledSet/sampledSet/sampledSetParticle.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2021 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2021-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -212,9 +212,6 @@ public:
             //- Track all particles to their end point
             bool move(sampledSetCloud&, trackingData&, const scalar);
 
-            //- Hit a generic patch. Does nothing.
-            bool hitPatch(sampledSetCloud&, trackingData&);
-
             //- Hit a wedge patch. Ends the track.
             void hitWedgePatch(sampledSetCloud&, trackingData&);