diff --git a/applications/utilities/mesh/conversion/fluent3DMeshToFoam/Make/options b/applications/utilities/mesh/conversion/fluent3DMeshToFoam/Make/options
index 70c838b774..525acf8e56 100644
--- a/applications/utilities/mesh/conversion/fluent3DMeshToFoam/Make/options
+++ b/applications/utilities/mesh/conversion/fluent3DMeshToFoam/Make/options
@@ -1,7 +1,9 @@
 EXE_INC = \
     -I$(LIB_SRC)/meshTools/lnInclude \
-    -I$(LIB_SRC)/dynamicMesh/lnInclude
+    -I$(LIB_SRC)/dynamicMesh/lnInclude \
+    -I$(LIB_SRC)/conversion/lnInclude
 
 EXE_LIBS = \
     -lmeshTools \
-    -ldynamicMesh
+    -ldynamicMesh \
+    -lconversion
diff --git a/applications/utilities/mesh/conversion/fluent3DMeshToFoam/fluent3DMeshToFoam.L b/applications/utilities/mesh/conversion/fluent3DMeshToFoam/fluent3DMeshToFoam.L
index 4f92ff17ad..929947b68f 100644
--- a/applications/utilities/mesh/conversion/fluent3DMeshToFoam/fluent3DMeshToFoam.L
+++ b/applications/utilities/mesh/conversion/fluent3DMeshToFoam/fluent3DMeshToFoam.L
@@ -38,10 +38,11 @@ License
 #include "polyMeshZipUpCells.H"
 #include "wallPolyPatch.H"
 #include "symmetryPolyPatch.H"
-#include "oldCyclicPolyPatch.H"
+#include "mergedCyclicPolyPatch.H"
 #include "Swap.H"
 #include "IFstream.H"
 #include "readHexLabel.H"
+#include "polyMeshUnMergeCyclics.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -769,6 +770,12 @@ int main(int argc, char *argv[])
         "geometry scaling factor - default is 1"
     );
     argList::addOption
+    (
+        "includedAngle",
+        "angle",
+        "feature angle with which to split cyclics"
+    );
+    argList::addOption
     (
         "ignoreCellGroups",
         "names",
@@ -901,16 +908,13 @@ int main(int argc, char *argv[])
     fluentToFoamType.insert("interface", polyPatch::typeName);
     fluentToFoamType.insert("internal", polyPatch::typeName);
     fluentToFoamType.insert("solid", polyPatch::typeName);
-    fluentToFoamType.insert("fan", oldCyclicPolyPatch::typeName);
-    fluentToFoamType.insert("radiator", polyPatch::typeName);
-    fluentToFoamType.insert("porous-jump", polyPatch::typeName);
 
-    //- Periodic halves map directly into split cyclics. The problem is the
-    //  initial matching since we require knowledge of the transformation.
-    //  It is ok if the periodics are already ordered. We should read the
-    //  periodic shadow faces section (section 18) to give use the ordering
-    //  For now just disable.
-    // fluentToFoamType.insert("periodic", cyclicPolyPatch::typeName);
+    fluentToFoamType.insert("fan", mergedCyclicPolyPatch::typeName);
+    fluentToFoamType.insert("radiator", mergedCyclicPolyPatch::typeName);
+    fluentToFoamType.insert("porous-jump", mergedCyclicPolyPatch::typeName);
+
+    fluentToFoamType.insert("periodic", cyclicPolyPatch::typeName);
+    fluentToFoamType.insert("shadow", cyclicPolyPatch::typeName);
 
 
     // Foam patch type for Fluent zone type
@@ -919,6 +923,8 @@ int main(int argc, char *argv[])
     HashSet<word> fluentGroupToFoamPatch;
     fluentGroupToFoamPatch.insert("wall");
     fluentGroupToFoamPatch.insert("fan");
+    fluentGroupToFoamPatch.insert("radiator");
+    fluentGroupToFoamPatch.insert("porous-jump");
 
 
     // Create initial empty polyMesh
@@ -1023,6 +1029,76 @@ int main(int argc, char *argv[])
     faceZoneIDs.shrink();
 
 
+    // Pair up cyclics
+    // ~~~~~~~~~~~~~~~
+
+    labelList nbrPatchis(patchIDs.size(), -1);
+    forAll(patchIDs, patchi)
+    {
+        const label zonei = faceGroupZoneID[patchIDs[patchi]];
+        const word& name = groupName[zonei];
+        const word& type = groupType[zonei];
+
+        HashTable<word>::const_iterator iter = fluentToFoamType.find(type);
+
+        if (iter != fluentToFoamType.end())
+        {
+            if
+            (
+                iter() == cyclicPolyPatch::typeName
+             && nbrPatchis[patchi] == -1
+            )
+            {
+                // This is one half of a pair of patches defining a cyclic
+                // interface. Find the neighbouring patch.
+
+                forAll(patchIDs, nbrPatchi)
+                {
+                    const label nbrZonei = faceGroupZoneID[patchIDs[nbrPatchi]];
+                    const word& nbrName = groupName[nbrZonei];
+                    const word& nbrType = groupType[nbrZonei];
+
+                    HashTable<word>::const_iterator nbrIter =
+                    fluentToFoamType.find(nbrType);
+
+                    if (nbrIter != fluentToFoamType.end())
+                    {
+                        if
+                        (
+                            nbrIter() == cyclicPolyPatch::typeName
+                         && nbrPatchis[nbrPatchi] == -1
+                        )
+                        {
+                            // The neighbour must have a different type
+                            // (periodic =/= shadow) and its name must share a
+                            // prefix with the patch.
+
+                            if
+                            (
+                                nbrType != type
+                             && nbrName(min(name.size(), nbrName.size()))
+                             == name(min(name.size(), nbrName.size()))
+                            )
+                            {
+                                nbrPatchis[nbrPatchi] = patchi;
+                                nbrPatchis[patchi] = nbrPatchi;
+                                break;
+                            }
+                        }
+                    }
+                }
+
+                if (nbrPatchis[patchi] == -1)
+                {
+                    FatalErrorInFunction
+                        << "Could not find neighbour patch for " << type
+                        << " patch " << name << exit(FatalError);
+                }
+            }
+        }
+    }
+
+
     // Add empty patches
     // ~~~~~~~~~~~~~~~~~
 
@@ -1031,7 +1107,7 @@ int main(int argc, char *argv[])
 
     forAll(patchIDs, patchi)
     {
-        label zoneID = faceGroupZoneID[patchIDs[patchi] ];
+        const label zoneID = faceGroupZoneID[patchIDs[patchi]];
         word name = groupName[zoneID];
         const word& type = groupType[zoneID];
 
@@ -1047,32 +1123,11 @@ int main(int argc, char *argv[])
 
         if (iter != fluentToFoamType.end())
         {
-            // See if we have a periodic and can derive the other side.
-            word nbrPatchName;
             if (iter() == cyclicPolyPatch::typeName)
             {
-                // Periodic
-                size_t n = name.rfind("-SIDE-1");
-
-                if (n != string::npos)
-                {
-                    nbrPatchName = name.substr(0, n) + "-SIDE-2";
-                }
-                else
-                {
-                    n = name.rfind("-SIDE-2");
-                    if (n != string::npos)
-                    {
-                        nbrPatchName = name.substr(0, n) + "-SIDE-1";
-                    }
-                }
-            }
-
-            if (nbrPatchName.size())
-            {
-                Info<< "Adding cyclicPolyPatch for Fluent zone " << name
-                    << " with neighbour patch " << nbrPatchName
-                    << endl;
+                const label nbrPatchi = nbrPatchis[patchi];
+                const label nbrZoneID = faceGroupZoneID[patchIDs[nbrPatchi]];
+                const word nbrName = groupName[nbrZoneID];
 
                 newPatches[patchi] = new cyclicPolyPatch
                 (
@@ -1082,8 +1137,7 @@ int main(int argc, char *argv[])
                     patchi,
                     mesh.boundaryMesh(),
                     cyclicPolyPatch::typeName,
-                    nbrPatchName,
-                    cyclicPolyPatch::NOORDERING
+                    nbrName
                 );
             }
             else
@@ -1101,9 +1155,6 @@ int main(int argc, char *argv[])
         }
         else
         {
-            Info<< "Adding polyPatch for unknown Fluent type " << type
-                << endl;
-
             newPatches[patchi] = new polyPatch
             (
                 name,
@@ -1342,6 +1393,7 @@ int main(int argc, char *argv[])
                     );
                 }
             }
+
             // Mark face as being done
             owner[facei] = -1;
         }
@@ -1411,6 +1463,16 @@ int main(int argc, char *argv[])
         polyMeshZipUpCells(mesh);
     }
 
+    // Un-merge any merged cyclics
+    if (args.optionFound("includedAngle"))
+    {
+        polyMeshUnMergeCyclics(mesh, args.optionRead<scalar>("includedAngle"));
+    }
+    else
+    {
+        polyMeshUnMergeCyclics(mesh);
+    }
+
     mesh.setInstance(runTime.constant());
 
     // Set the precision of the points data to 10
diff --git a/applications/utilities/mesh/conversion/kivaToFoam/Make/options b/applications/utilities/mesh/conversion/kivaToFoam/Make/options
index e69de29bb2..9cc80f6d26 100644
--- a/applications/utilities/mesh/conversion/kivaToFoam/Make/options
+++ b/applications/utilities/mesh/conversion/kivaToFoam/Make/options
@@ -0,0 +1,7 @@
+EXE_INC = \
+    -I$(LIB_SRC)/dynamicMesh/lnInclude \
+    -I$(LIB_SRC)/conversion/lnInclude
+
+EXE_LIBS = \
+    -ldynamicMesh \
+    -lconversion
diff --git a/applications/utilities/mesh/conversion/kivaToFoam/kivaToFoam.C b/applications/utilities/mesh/conversion/kivaToFoam/kivaToFoam.C
index 52316509ec..c47b0e3ff2 100644
--- a/applications/utilities/mesh/conversion/kivaToFoam/kivaToFoam.C
+++ b/applications/utilities/mesh/conversion/kivaToFoam/kivaToFoam.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-2020 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -41,7 +41,8 @@ Description
 #include "wallPolyPatch.H"
 #include "symmetryPolyPatch.H"
 #include "wedgePolyPatch.H"
-#include "oldCyclicPolyPatch.H"
+#include "mergedCyclicPolyPatch.H"
+#include "polyMeshUnMergeCyclics.H"
 #include "unitConversion.H"
 
 using namespace Foam;
diff --git a/applications/utilities/mesh/conversion/kivaToFoam/readKivaGrid.H b/applications/utilities/mesh/conversion/kivaToFoam/readKivaGrid.H
index 46e1c924a8..0f9eea28c1 100644
--- a/applications/utilities/mesh/conversion/kivaToFoam/readKivaGrid.H
+++ b/applications/utilities/mesh/conversion/kivaToFoam/readKivaGrid.H
@@ -196,7 +196,7 @@ const word* kivaPatchTypes[nBCs] =
     &polyPatch::typeName,
     &polyPatch::typeName,
     &symmetryPolyPatch::typeName,
-    &oldCyclicPolyPatch::typeName
+    &mergedCyclicPolyPatch::typeName
 };
 
 enum patchTypeNames
@@ -574,6 +574,9 @@ polyMesh pShapeMesh
     defaultFacesType
 );
 
+// Un-merge any merged cyclics
+polyMeshUnMergeCyclics(pShapeMesh);
+
 Info << "Writing polyMesh" << endl;
 pShapeMesh.write();
 
diff --git a/applications/utilities/mesh/conversion/sammToFoam/Make/options b/applications/utilities/mesh/conversion/sammToFoam/Make/options
index e69de29bb2..9cc80f6d26 100644
--- a/applications/utilities/mesh/conversion/sammToFoam/Make/options
+++ b/applications/utilities/mesh/conversion/sammToFoam/Make/options
@@ -0,0 +1,7 @@
+EXE_INC = \
+    -I$(LIB_SRC)/dynamicMesh/lnInclude \
+    -I$(LIB_SRC)/conversion/lnInclude
+
+EXE_LIBS = \
+    -ldynamicMesh \
+    -lconversion
diff --git a/applications/utilities/mesh/conversion/sammToFoam/readBoundary.C b/applications/utilities/mesh/conversion/sammToFoam/readBoundary.C
index 4f0e6c29f2..5453c942a2 100644
--- a/applications/utilities/mesh/conversion/sammToFoam/readBoundary.C
+++ b/applications/utilities/mesh/conversion/sammToFoam/readBoundary.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-2020 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -29,7 +29,7 @@ Description
 #include "sammMesh.H"
 #include "Time.H"
 #include "wallPolyPatch.H"
-#include "oldCyclicPolyPatch.H"
+#include "mergedCyclicPolyPatch.H"
 #include "symmetryPolyPatch.H"
 #include "preservePatchTypes.H"
 #include "IFstream.H"
@@ -206,9 +206,7 @@ void Foam::sammMesh::readBoundary()
             }
             else if (patchType == "CYCL")
             {
-                // incorrect. should be cyclicPatch but this
-                // requires info on connected faces.
-                patchTypes_[patchLabel] = oldCyclicPolyPatch::typeName;
+                patchTypes_[patchLabel] = mergedCyclicPolyPatch::typeName;
             }
             else
             {
diff --git a/applications/utilities/mesh/conversion/sammToFoam/writeMesh.C b/applications/utilities/mesh/conversion/sammToFoam/writeMesh.C
index 0d2e2dddcf..3c8dc00f5f 100644
--- a/applications/utilities/mesh/conversion/sammToFoam/writeMesh.C
+++ b/applications/utilities/mesh/conversion/sammToFoam/writeMesh.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2019 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -29,6 +29,7 @@ Description
 #include "sammMesh.H"
 #include "Time.H"
 #include "polyMesh.H"
+#include "polyMeshUnMergeCyclics.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -56,6 +57,8 @@ void Foam::sammMesh::writeMesh()
             patchPhysicalTypes_
         );
 
+        polyMeshUnMergeCyclics(pShapeMesh);
+
         Info<< "Writing polyMesh" << endl;
         pShapeMesh.write();
     }
@@ -82,6 +85,8 @@ void Foam::sammMesh::writeMesh()
 
         pMesh.addPatches(polyBoundaryPatches(pMesh));
 
+        polyMeshUnMergeCyclics(pMesh);
+
         Info<< "Writing polyMesh" << endl;
         pMesh.write();
     }
diff --git a/applications/utilities/mesh/conversion/star3ToFoam/Make/options b/applications/utilities/mesh/conversion/star3ToFoam/Make/options
index 3dbc679a10..b4a6830ff5 100644
--- a/applications/utilities/mesh/conversion/star3ToFoam/Make/options
+++ b/applications/utilities/mesh/conversion/star3ToFoam/Make/options
@@ -4,4 +4,10 @@ EXE_INC = \
     /* -DDEBUG_COUPLE_INTERSECTION */ \
     /* -DDEBUG_RIGHT_HAND_WALK */ \
     /* -DDEBUG_FACE_ORDERING */ \
-    /* -DDEBUG_COUPLE_PROJECTION */
+    /* -DDEBUG_COUPLE_PROJECTION */ \
+    -I$(LIB_SRC)/dynamicMesh/lnInclude \
+    -I$(LIB_SRC)/conversion/lnInclude
+
+EXE_LIBS = \
+    -ldynamicMesh \
+    -lconversion
diff --git a/applications/utilities/mesh/conversion/star3ToFoam/readBoundary.C b/applications/utilities/mesh/conversion/star3ToFoam/readBoundary.C
index ddd9b04b74..2859fc41f4 100644
--- a/applications/utilities/mesh/conversion/star3ToFoam/readBoundary.C
+++ b/applications/utilities/mesh/conversion/star3ToFoam/readBoundary.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-2020 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -29,7 +29,7 @@ Description
 #include "starMesh.H"
 #include "Time.H"
 #include "wallPolyPatch.H"
-#include "oldCyclicPolyPatch.H"
+#include "mergedCyclicPolyPatch.H"
 #include "symmetryPolyPatch.H"
 #include "preservePatchTypes.H"
 #include "IFstream.H"
@@ -204,9 +204,7 @@ void Foam::starMesh::readBoundary()
             }
             else if (patchType == "CYCL")
             {
-                // incorrect. should be cyclicPatch but this
-                // requires info on connected faces.
-                patchTypes_[patchLabel] = oldCyclicPolyPatch::typeName;
+                patchTypes_[patchLabel] = mergedCyclicPolyPatch::typeName;
             }
             else
             {
diff --git a/applications/utilities/mesh/conversion/star3ToFoam/writeMesh.C b/applications/utilities/mesh/conversion/star3ToFoam/writeMesh.C
index 3865db5f30..a9bd02818e 100644
--- a/applications/utilities/mesh/conversion/star3ToFoam/writeMesh.C
+++ b/applications/utilities/mesh/conversion/star3ToFoam/writeMesh.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2019 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -29,6 +29,7 @@ Description
 #include "starMesh.H"
 #include "Time.H"
 #include "polyMesh.H"
+#include "polyMeshUnMergeCyclics.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -60,6 +61,8 @@ void Foam::starMesh::writeMesh()
             patchPhysicalTypes_
         );
 
+        polyMeshUnMergeCyclics(pShapeMesh);
+
         Info<< "Writing polyMesh" << endl;
         pShapeMesh.write();
     }
@@ -89,6 +92,8 @@ void Foam::starMesh::writeMesh()
         // adding patches also checks the mesh
         pMesh.addPatches(polyBoundaryPatches(pMesh));
 
+        polyMeshUnMergeCyclics(pMesh);
+
         Info<< "Writing polyMesh" << endl;
         pMesh.write();
     }
diff --git a/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshIO.C b/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshIO.C
index e5928a6421..49baee1372 100644
--- a/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshIO.C
+++ b/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshIO.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2012-2019 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2012-2020 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -437,8 +437,7 @@ Foam::autoPtr<Foam::fvMesh> Foam::conformalVoronoiMesh::createDummyMesh
                 patchi,
                 mesh.boundaryMesh(),
                 patchDicts[patchi].lookup<label>("myProcNo"),
-                patchDicts[patchi].lookup<label>("neighbProcNo"),
-                coupledPolyPatch::COINCIDENTFULLMATCH
+                patchDicts[patchi].lookup<label>("neighbProcNo")
             );
         }
         else
diff --git a/applications/utilities/mesh/manipulation/createPatch/createPatch.C b/applications/utilities/mesh/manipulation/createPatch/createPatch.C
index 8f97b4a133..56ecd4f428 100644
--- a/applications/utilities/mesh/manipulation/createPatch/createPatch.C
+++ b/applications/utilities/mesh/manipulation/createPatch/createPatch.C
@@ -360,7 +360,11 @@ void syncPoints
                 if (procPatch.transform().transformsPosition())
                 {
                     hasTransformation = true;
-                    procPatch.transform().transformPosition(nbrPatchInfo);
+                    procPatch.transform().transformPosition
+                    (
+                        nbrPatchInfo,
+                        nbrPatchInfo
+                    );
                 }
 
                 const labelList& meshPts = procPatch.meshPoints();
@@ -405,7 +409,11 @@ void syncPoints
             if (cycPatch.transform().transformsPosition())
             {
                 hasTransformation = true;
-                cycPatch.transform().invTransformPosition(patchPoints);
+                cycPatch.transform().invTransformPosition
+                (
+                    patchPoints,
+                    patchPoints
+                );
             }
 
             forAll(coupledPoints, i)
diff --git a/applications/utilities/parallelProcessing/decomposePar/domainDecomposition.C b/applications/utilities/parallelProcessing/decomposePar/domainDecomposition.C
index 0f0c8f5e68..1f838b026b 100644
--- a/applications/utilities/parallelProcessing/decomposePar/domainDecomposition.C
+++ b/applications/utilities/parallelProcessing/decomposePar/domainDecomposition.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2019 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -495,8 +495,7 @@ bool Foam::domainDecomposition::writeDecomposition(const bool decomposeSets)
                             procMesh.boundaryMesh(),
                             proci,
                             curNeighbourProcessors[procPatchi],
-                            pcPatch.name(),
-                            pcPatch.ordering()
+                            pcPatch.name()
                         );
                 }
 
diff --git a/src/Allwmake b/src/Allwmake
index b12a0eb867..63c3eb2f31 100755
--- a/src/Allwmake
+++ b/src/Allwmake
@@ -40,12 +40,12 @@ wmake $targetType lagrangian/basic
 wmake $targetType lagrangian/distributionModels
 wmake $targetType genericPatchFields
 
-wmake $targetType conversion
 wmake $targetType mesh/extrudeModel
 wmake $targetType dynamicMesh
-wmake $targetType sampling
 wmake $targetType dynamicFvMesh
 wmake $targetType topoChangerFvMesh
+wmake $targetType conversion
+wmake $targetType sampling
 
 # Compile scotchDecomp, metisDecomp etc.
 parallel/Allwmake $targetType $*
diff --git a/src/OpenFOAM/Make/files b/src/OpenFOAM/Make/files
index cd3992d39c..a4acd62ded 100644
--- a/src/OpenFOAM/Make/files
+++ b/src/OpenFOAM/Make/files
@@ -472,7 +472,6 @@ constraintPolyPatches = $(polyPatches)/constraint
 $(constraintPolyPatches)/cyclic/cyclicTransform.C
 $(constraintPolyPatches)/cyclic/cyclicPolyPatch.C
 $(constraintPolyPatches)/cyclicSlip/cyclicSlipPolyPatch.C
-$(constraintPolyPatches)/oldCyclic/oldCyclicPolyPatch.C
 $(constraintPolyPatches)/empty/emptyPolyPatch.C
 $(constraintPolyPatches)/processorCyclic/processorCyclicPolyPatch.C
 $(constraintPolyPatches)/processor/processorPolyPatch.C
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.C b/src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.C
index b78c1db1ea..4aadf1129c 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.C
@@ -35,164 +35,562 @@ namespace Foam
     defineTypeNameAndDebug(coupledPolyPatch, 0);
 
     const scalar coupledPolyPatch::defaultMatchTol_ = 1e-4;
+}
 
-    template<>
-    const char* NamedEnum<coupledPolyPatch::orderingType, 3>::names[] =
+
+// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
+
+bool Foam::coupledPolyPatch::walk
+(
+    const primitivePatch& pp,
+    const bool direction,
+    const label seedFacei,
+    const label seedFacePointi,
+    labelList& faceMap,
+    labelList& facePointMap,
+    label& mapFacei,
+    autoPtr<labelListList>& walks
+) const
+{
+    // Initialisation
+    label facei = seedFacei, facePointi = seedFacePointi;
+    faceMap[facei] = mapFacei;
+    facePointMap[facei] = facePointi;
+    bool changed = facei != mapFacei || facePointi != 0;
+    ++ mapFacei;
+    if (walks.valid())
     {
-        "unknown",
-        "coincidentFullMatch",
-        "noOrdering"
-    };
+        walks->append(labelList(1, facei));
+    }
 
-    const NamedEnum<coupledPolyPatch::orderingType, 3>
-        coupledPolyPatch::orderingTypeNames;
+    // Walk the patch until we get back to the seed face and point
+    do
+    {
+        // Get the next point and edge around the current face
+        const label facePointi1 =
+            direction
+          ? pp[facei].fcIndex(facePointi)
+          : pp[facei].rcIndex(facePointi);
+        const label faceEdgei = direction ? facePointi : facePointi1;
+
+        // Get the edge and the faces connected to the edge
+        const label edgei = pp.faceEdges()[facei][faceEdgei];
+        const labelList edgeFaces = pp.edgeFaces()[edgei];
+
+        // Test if this is an edge the walk *can* cross
+        if (edgeFaces.size() == 2)
+        {
+            // This edge is manifold (i.e., the number of connected faces is
+            // 2), so it is permitted for the walk to cross it. Get the face
+            // connected to the other side of the edge that we may want to walk
+            // into.
+            const label facej = edgeFaces[edgeFaces[0] == facei];
+            const label facePointj = pp[facej].which(pp[facei][facePointi]);
+
+            // Test if this is an edge the walk *should* cross
+            if (faceMap[facej] == -1)
+            {
+                // The connected face has not been visited, so walk into it and
+                // set its ordering in the map, its point and visited status
+                facei = facej;
+                facePointi = facePointj;
+                faceMap[facei] = mapFacei;
+                facePointMap[facei] = facePointi;
+                changed = changed || facei != mapFacei || facePointi != 0;
+                ++ mapFacei;
+            }
+            else if (facePointMap[facei] != facePointi1 || facei == seedFacei)
+            {
+                // The connected face has been visited, but there are more
+                // edges to consider on the current face, so move to the next
+                // face point
+                facePointi = facePointi1;
+            }
+            else
+            {
+                // The connected face has been visited, and there are no more
+                // edges to consider on the current face, so backtrack to the
+                // previous face in the walk
+                facei = facej;
+                facePointi = facePointj;
+            }
+
+            // Add to the walk, if that information is being stored
+            if (walks.valid() && walks->last().last() != facei)
+            {
+                walks->last().append(facei);
+            }
+        }
+        else
+        {
+            // This edge is non-manifold (i.e., the number of connected faces
+            // does not equal 2), so it is considered a boundary to the walk.
+            // Move on to the next point around the current face.
+            facePointi = facePointi1;
+        }
+    }
+    while (facei != seedFacei || facePointi != seedFacePointi);
+
+    return changed;
 }
 
 
 // * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
-void Foam::coupledPolyPatch::writeOBJ(Ostream& os, const point& pt)
+void Foam::coupledPolyPatch::writeOBJ
+(
+    const fileName& name,
+    const primitivePatch& pp
+)
 {
-    os << "v " << pt.x() << ' ' << pt.y() << ' ' << pt.z() << endl;
+    OFstream os(name);
+
+    forAll(pp.localPoints(), pointi)
+    {
+        const point& p = pp.localPoints()[pointi];
+        os << "v " << p.x() << ' ' << p.y() << ' ' << p.z() << endl;
+    }
+
+    forAll(pp.localFaces(), facei)
+    {
+        const face& f = pp.localFaces()[facei];
+        os << 'f';
+        forAll(f, fi)
+        {
+            os << ' ' << f[fi] + 1;
+        }
+        os << endl;
+    }
+}
+
+void Foam::coupledPolyPatch::writeOBJ
+(
+    const fileName& name,
+    const pointField& points0,
+    const pointField& points1
+)
+{
+    OFstream os(name);
+
+    forAll(points0, pointi)
+    {
+        const point& p0 = points0[pointi];
+        const point& p1 = points1[pointi];
+        os  << "v " << p0.x() << ' ' << p0.y() << ' ' << p0.z() << endl
+            << "v " << p1.x() << ' ' << p1.y() << ' ' << p1.z() << endl
+            << "l " << 2*pointi << ' ' << 2*pointi + 1 << endl;
+    }
 }
 
 
 void Foam::coupledPolyPatch::writeOBJ
 (
-    Ostream& os,
+    const fileName& name,
     const pointField& points,
-    const labelList& pointLabels
+    const labelListList& paths
 )
 {
-    forAll(pointLabels, i)
+    OFstream os(name);
+
+    forAll(points, pointi)
     {
-        writeOBJ(os, points[pointLabels[i]]);
+        const point& c = points[pointi];
+        os << "v " << c.x() << ' '<< c.y() << ' ' << c.z() << endl;
+    }
+
+    forAll(paths, pathi)
+    {
+        for (label pathj = 0; pathj < paths[pathi].size() - 1; ++ pathj)
+        {
+            os  << "l " << paths[pathi][pathj] + 1 << ' '
+                << paths[pathi][pathj + 1] + 1 << endl;
+        }
     }
 }
 
 
-void Foam::coupledPolyPatch::writeOBJ
+void Foam::coupledPolyPatch::initOrder
 (
-    Ostream& os,
-    const point& p0,
-    const point& p1,
-    label& vertI
-)
+    ownToNbrOrderData& ownToNbr,
+    autoPtr<ownToNbrDebugOrderData>& ownToNbrDebugPtr,
+    const primitivePatch& pp
+) const
 {
-    writeOBJ(os, p0);
-    vertI++;
-
-    writeOBJ(os, p1);
-    vertI++;
-
-    os  << "l " << vertI-1 << ' ' << vertI << nl;
-}
-
-
-void Foam::coupledPolyPatch::writeOBJ
-(
-    const fileName& fName,
-    const UList<face>& faces,
-    const pointField& points
-)
-{
-    OFstream os(fName);
-
-    Map<label> foamToObj(4*faces.size());
-
-    label vertI = 0;
-
-    forAll(faces, i)
+    if (owner())
     {
-        const face& f = faces[i];
+        // Generate the connected regions
+        label nRegions = 0;
+        labelList faceRegionis(pp.size(), -1);
 
-        forAll(f, fp)
+        label seedFacei = 0;
+
+        labelList faceMap(pp.size(), -1);
+        labelList facePointMap(pp.size(), -1);
+        label mapFacei = 0;
+        autoPtr<labelListList> walks(nullptr);
+
+        while (mapFacei < pp.size())
         {
-            if (foamToObj.insert(f[fp], vertI))
+            walk
+            (
+                pp,
+                owner(),
+                seedFacei,
+                0,
+                faceMap,
+                facePointMap,
+                mapFacei,
+                walks
+            );
+
+            forAll(pp, facei)
             {
-                writeOBJ(os, points[f[fp]]);
-                vertI++;
-            }
-        }
-
-        os << 'l';
-        forAll(f, fp)
-        {
-            os << ' ' << foamToObj[f[fp]]+1;
-        }
-        os << ' ' << foamToObj[f[0]]+1 << nl;
-    }
-}
-
-
-Foam::pointField Foam::coupledPolyPatch::getAnchorPoints
-(
-    const UList<face>& faces,
-    const pointField& points,
-    const orderingType ordering
-)
-{
-    pointField anchors(faces.size());
-
-    if (ordering != COINCIDENTFULLMATCH)
-    {
-        // Return the first point
-        forAll(faces, facei)
-        {
-            anchors[facei] = points[faces[facei][0]];
-        }
-    }
-    else
-    {
-        // Make anchor point unique
-        forAll(faces, facei)
-        {
-            const face& f = faces[facei];
-
-            bool unique = true;
-
-            forAll(f, fp1)
-            {
-                const point& p1 = points[f[fp1]];
-
-                unique = true;
-
-                for (label fp2 = 0; fp2 < f.size(); ++fp2)
+                if (faceRegionis[facei] == -1 && faceMap[facei] != -1)
                 {
-                    if (f[fp1] == f[fp2])
-                    {
-                        continue;
-                    }
-
-                    const point& p2 = points[f[fp2]];
-
-                    // TODO: Change to a tolerance and possibly select closest
-                    // point to the origin
-                    if (p1 == p2)
-                    {
-                        unique = false;
-                        break;
-                    }
+                    faceRegionis[facei] = nRegions;
                 }
+            }
 
-                if (unique)
+            ++ nRegions;
+
+            forAll(pp, facei)
+            {
+                if (faceMap[facei] == -1)
                 {
-                    anchors[facei] = p1;
+                    seedFacei = facei;
                     break;
                 }
             }
+        }
 
-            if (!unique)
+        // Generate the face tolerances
+        //
+        // !!! It is possble that a different metric would be more appropriate
+        // for this method than the tolerance that was developed when all faces
+        // were being geometrically compared
+        //
+        const scalarField tols(calcFaceTol(pp, pp.points(), pp.faceCentres()));
+
+        // Get the face with the largest tolerance in each region as the seed
+        // and store its index in the (self) ordering data
+        ownToOwnOrderDataPtr_ = new ownToOwnOrderData();
+        ownToOwnOrderDataPtr_->seedFaceis = labelList(nRegions, -1);
+        scalarList maxTols(nRegions, -vGreat);
+        forAll(pp, facei)
+        {
+            const label regioni = faceRegionis[facei];
+
+            if (tols[facei] > maxTols[regioni])
             {
-                anchors[facei] = points[faces[facei][0]];
+                ownToOwnOrderDataPtr_->seedFaceis[regioni] = facei;
+                maxTols[regioni] = tols[facei];
+            }
+        }
+
+        // Get the points of each seed face and store them in the neighbour
+        // ordering data
+        ownToNbr.seedFacePoints = List<pointField>(nRegions, pointField());
+        forAll(ownToOwnOrderDataPtr_->seedFaceis, regioni)
+        {
+            const face& f = pp[ownToOwnOrderDataPtr_->seedFaceis[regioni]];
+            ownToNbr.seedFacePoints[regioni] =
+                transform().invTransformPosition(f.points(pp.points()));
+        }
+
+        // Get debug data
+        if (ownToNbrDebugPtr.valid())
+        {
+            ownToNbrDebugPtr = new ownToNbrDebugOrderData();
+            ownToNbrDebugPtr->nFaces = pp.size();
+            ownToNbrDebugPtr->nPoints = pp.nPoints();
+            ownToNbrDebugPtr->nEdges = pp.nEdges();
+            ownToNbrDebugPtr->nInternalEdges = pp.nInternalEdges();
+        }
+    }
+}
+
+
+bool Foam::coupledPolyPatch::order
+(
+    const ownToNbrOrderData& ownToNbr,
+    const autoPtr<ownToNbrDebugOrderData>& ownToNbrDebugPtr,
+    const primitivePatch& pp,
+    labelList& faceMap,
+    labelList& rotation
+) const
+{
+    // Determine the seed faces and face points
+    labelList seedFaceis, seedFacePointis;
+    if (owner())
+    {
+        seedFaceis = ownToOwnOrderDataPtr_->seedFaceis;
+        ownToOwnOrderDataPtr_.clear();
+
+        seedFacePointis.resize(seedFaceis.size(), 0);
+    }
+    else
+    {
+        const List<pointField> ownerSeedFacePoints(ownToNbr.seedFacePoints);
+
+        seedFaceis.resize(ownerSeedFacePoints.size());
+        seedFacePointis.resize(ownerSeedFacePoints.size());
+
+        // Check the element counts
+        if (ownToNbrDebugPtr.valid())
+        {
+            const label ownerNFaces = ownToNbrDebugPtr->nFaces;
+            const label ownerNPoints = ownToNbrDebugPtr->nPoints;
+            const label ownerNEdges = ownToNbrDebugPtr->nEdges;
+            const label ownerNInternalEdges = ownToNbrDebugPtr->nInternalEdges;
+            if (pp.size() != ownerNFaces)
+            {
+                SeriousErrorInFunction<< "The patch " << name() << " has "
+                    << pp.size() << " faces whilst it's neighbour has "
+                    << ownerNFaces << endl;
+            }
+            if (pp.nPoints() != ownerNPoints)
+            {
+                SeriousErrorInFunction<< "The patch " << name() << " has "
+                    << pp.nPoints() << " points whilst it's neighbour has "
+                    << ownerNPoints << endl;
+            }
+            if (pp.nEdges() != ownerNEdges)
+            {
+                SeriousErrorInFunction<< "The patch " << name() << " has "
+                    << pp.nEdges() << " edges whilst it's neighbour has "
+                    << ownerNEdges << endl;
+            }
+            if (pp.nInternalEdges() != ownerNInternalEdges)
+            {
+                SeriousErrorInFunction<< "The patch " << name() << " has "
+                    << pp.nInternalEdges() << " internal edges whilst it's "
+                    << "neighbour has " << ownerNInternalEdges << endl;
+            }
+        }
+
+        // Do geometric testing to determine the faces that match those sent
+        // over from the opposite patch
+        forAll(ownerSeedFacePoints, regioni)
+        {
+            const pointField& ownerFacePts = ownerSeedFacePoints[regioni];
+
+            // The seed face and face-point are the ones which give the smallest
+            // total displacement between all corresponding points. Note that
+            // owner and neighbour point order is reversed.
+            scalar minSumSqrDisplacement = vGreat;
+            forAll(pp, facei)
+            {
+                const pointField facePts = pp[facei].points(pp.points());
+
+                if (facePts.size() != ownerFacePts.size()) continue;
+
+                forAll(facePts, facePointi)
+                {
+                    const scalar sumSqrDisplacement =
+                        sum
+                        (
+                            magSqr
+                            (
+                                rotateList(reverseList(facePts), facePointi + 1)
+                              - ownerFacePts
+                            )
+                        );
+                    if (sumSqrDisplacement < minSumSqrDisplacement)
+                    {
+                        seedFaceis[regioni] = facei;
+                        seedFacePointis[regioni] = facePointi;
+                        minSumSqrDisplacement = sumSqrDisplacement;
+                    }
+                }
+            }
+
+            // Check and report if the min displacement is large
+            const scalar seedFaceTol =
+                calcFaceTol
+                (
+                    faceList(1, pp[seedFaceis[regioni]]),
+                    pp.points(),
+                    pointField(1, pp.faceCentres()[seedFaceis[regioni]])
+                ).first();
+            if (minSumSqrDisplacement > seedFaceTol)
+            {
+                FatalErrorInFunction
+                    << "The root-sum-square displacement between the points of "
+                    << "the seed face and the best matching face (#"
+                    << seedFaceis[regioni] << ") on patch " << name()
+                    << " is " << sqrt(minSumSqrDisplacement) << "."
+                    << nl
+                    << "This is greater than the match tolerance of "
+                    << seedFaceTol << " for this face."
+                    << nl
+                    << "Check that the patches are conformal and that any "
+                    << "transformations defined between them are correct"
+                    << nl
+                    << "It might be possible to fix this problem by increasing "
+                    << "the \"matchTolerance\" setting for this patch in the "
+                    << "boundary file."
+                    << nl
+                    << "Re-run with the \"coupled\" debug flag set for more "
+                    << "information."
+                    << exit(FatalError);
             }
         }
     }
 
-    return anchors;
+    // Walk the patch from the seeds
+    bool changed = false;
+    faceMap = -1;
+    labelList facePointMap(pp.size(), -1);
+    label mapFacei = 0;
+    autoPtr<labelListList> walks(debug ? new labelListList() : nullptr);
+    forAll(seedFaceis, regioni)
+    {
+        changed =
+            walk
+            (
+                pp,
+                owner(),
+                seedFaceis[regioni],
+                seedFacePointis[regioni],
+                faceMap,
+                facePointMap,
+                mapFacei,
+                walks
+            )
+         || changed;
+    }
+
+    // Write out the patch
+    if (debug)
+    {
+        Pout<< "Writing patch " << name() << " to " << name() + ".obj" << endl;
+        writeOBJ(name() + ".obj", pp);
+    }
+
+    // Write out the walk
+    if (debug)
+    {
+        Pout<< "Writing patch " << name() << " walks to "
+            << name() + "Walk.obj" << endl;
+        writeOBJ(name() + "Walk.obj", pp.faceCentres(), walks());
+    }
+
+    // Check that all faces have been visited exactly once
+    bool badWalk = mapFacei != pp.size();
+    forAll(pp, facei)
+    {
+        badWalk = badWalk || facePointMap[facei] == -1;
+    }
+    if (badWalk)
+    {
+        FatalErrorInFunction
+            << "The ordering walk did not hit every face exactly once"
+            << exit(FatalError);
+    }
+
+    // Construct the rotations from the face point map
+    forAll(pp, facei)
+    {
+        rotation[facei] =
+            (pp[facei].size() - facePointMap[facei]) % pp[facei].size();
+    }
+
+    // Map the rotations
+    //
+    // !!! The rotation list appears to be indexed by the new face label,
+    // rather than the old one. For sanity's sake the ordering code above
+    // indexes everything consistently with the old face label. This means the
+    // rotations need mapping to the new indices.
+    //
+    UIndirectList<label>(rotation, faceMap) = labelList(rotation);
+
+    return changed;
 }
 
 
+// * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * * * * //
+
+Foam::coupledPolyPatch::coupledPolyPatch
+(
+    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),
+    matchTolerance_(defaultMatchTol_),
+    ownToOwnOrderDataPtr_(nullptr)
+{}
+
+
+Foam::coupledPolyPatch::coupledPolyPatch
+(
+    const word& name,
+    const dictionary& dict,
+    const label index,
+    const polyBoundaryMesh& bm,
+    const word& patchType
+)
+:
+    polyPatch(name, dict, index, bm, patchType),
+    matchTolerance_(dict.lookupOrDefault("matchTolerance", defaultMatchTol_)),
+    ownToOwnOrderDataPtr_(nullptr)
+{}
+
+
+Foam::coupledPolyPatch::coupledPolyPatch
+(
+    const coupledPolyPatch& pp,
+    const polyBoundaryMesh& bm
+)
+:
+    polyPatch(pp, bm),
+    matchTolerance_(pp.matchTolerance_),
+    ownToOwnOrderDataPtr_(nullptr)
+{}
+
+
+Foam::coupledPolyPatch::coupledPolyPatch
+(
+    const coupledPolyPatch& pp,
+    const polyBoundaryMesh& bm,
+    const label index,
+    const label newSize,
+    const label newStart
+)
+:
+    polyPatch(pp, bm, index, newSize, newStart),
+    matchTolerance_(pp.matchTolerance_),
+    ownToOwnOrderDataPtr_(nullptr)
+{}
+
+
+Foam::coupledPolyPatch::coupledPolyPatch
+(
+    const coupledPolyPatch& pp,
+    const polyBoundaryMesh& bm,
+    const label index,
+    const labelUList& mapAddressing,
+    const label newStart
+)
+:
+    polyPatch(pp, bm, index, mapAddressing, newStart),
+    matchTolerance_(pp.matchTolerance_),
+    ownToOwnOrderDataPtr_(nullptr)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::coupledPolyPatch::~coupledPolyPatch()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
 Foam::scalarField Foam::coupledPolyPatch::calcFaceTol
 (
     const UList<face>& faces,
@@ -233,155 +631,62 @@ Foam::scalarField Foam::coupledPolyPatch::calcFaceTol
 }
 
 
-Foam::label Foam::coupledPolyPatch::getRotation
-(
-    const pointField& points,
-    const face& f,
-    const point& anchor,
-    const scalar tol
-)
-{
-    label anchorFp = -1;
-    scalar minDistSqr = great;
-
-    forAll(f, fp)
-    {
-        scalar distSqr = magSqr(anchor - points[f[fp]]);
-
-        if (distSqr < minDistSqr)
-        {
-            minDistSqr = distSqr;
-            anchorFp = fp;
-        }
-    }
-
-    if (anchorFp == -1 || Foam::sqrt(minDistSqr) > tol)
-    {
-        return -1;
-    }
-    else
-    {
-        // Check that anchor is unique.
-        forAll(f, fp)
-        {
-            scalar distSqr = magSqr(anchor - points[f[fp]]);
-
-            if (distSqr == minDistSqr && fp != anchorFp)
-            {
-                WarningInFunction
-                    << "Cannot determine unique anchor point on face "
-                    << UIndirectList<point>(points, f)
-                    << endl
-                    << "Both at index " << anchorFp << " and " << fp
-                    << " the vertices have the same distance "
-                    << Foam::sqrt(minDistSqr)
-                    << " to the anchor " << anchor
-                    << ". Continuing but results might be wrong."
-                    << nl << endl;
-            }
-        }
-
-        // Positive rotation
-        return (f.size() - anchorFp) % f.size();
-    }
-}
-
-
-// * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * * * * //
-
-Foam::coupledPolyPatch::coupledPolyPatch
-(
-    const word& name,
-    const label size,
-    const label start,
-    const label index,
-    const polyBoundaryMesh& bm,
-    const word& patchType,
-    const orderingType ordering
-)
-:
-    polyPatch(name, size, start, index, bm, patchType),
-    matchTolerance_(defaultMatchTol_),
-    ordering_(ordering)
-{}
-
-
-Foam::coupledPolyPatch::coupledPolyPatch
-(
-    const word& name,
-    const dictionary& dict,
-    const label index,
-    const polyBoundaryMesh& bm,
-    const word& patchType,
-    const orderingType ordering
-)
-:
-    polyPatch(name, dict, index, bm, patchType),
-    matchTolerance_(dict.lookupOrDefault("matchTolerance", defaultMatchTol_)),
-    ordering_
-    (
-        dict.found("ordering")
-      ? orderingTypeNames.read(dict.lookup("ordering"))
-      : ordering
-    )
-{}
-
-
-Foam::coupledPolyPatch::coupledPolyPatch
-(
-    const coupledPolyPatch& pp,
-    const polyBoundaryMesh& bm
-)
-:
-    polyPatch(pp, bm),
-    matchTolerance_(pp.matchTolerance_),
-    ordering_(UNKNOWN)
-{}
-
-
-Foam::coupledPolyPatch::coupledPolyPatch
-(
-    const coupledPolyPatch& pp,
-    const polyBoundaryMesh& bm,
-    const label index,
-    const label newSize,
-    const label newStart
-)
-:
-    polyPatch(pp, bm, index, newSize, newStart),
-    matchTolerance_(pp.matchTolerance_),
-    ordering_(UNKNOWN)
-{}
-
-
-Foam::coupledPolyPatch::coupledPolyPatch
-(
-    const coupledPolyPatch& pp,
-    const polyBoundaryMesh& bm,
-    const label index,
-    const labelUList& mapAddressing,
-    const label newStart
-)
-:
-    polyPatch(pp, bm, index, mapAddressing, newStart),
-    matchTolerance_(pp.matchTolerance_),
-    ordering_(UNKNOWN)
-{}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-Foam::coupledPolyPatch::~coupledPolyPatch()
-{}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
 void Foam::coupledPolyPatch::write(Ostream& os) const
 {
     polyPatch::write(os);
     writeEntry(os, "matchTolerance", matchTolerance_);
-    writeEntry(os, "ordering", orderingTypeNames[ordering_]);
+}
+
+
+// * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
+
+Foam::Istream& Foam::operator>>
+(
+    Istream& is,
+    coupledPolyPatch::ownToNbrOrderData& ownToNbr
+)
+{
+    is >> ownToNbr.seedFacePoints;
+    return is;
+}
+
+
+Foam::Ostream& Foam::operator<<
+(
+    Ostream& os,
+    const coupledPolyPatch::ownToNbrOrderData& ownToNbr
+)
+{
+    os << ownToNbr.seedFacePoints;
+    return os;
+}
+
+
+Foam::Istream& Foam::operator>>
+(
+    Istream& is,
+    coupledPolyPatch::ownToNbrDebugOrderData& ownToNbrDebug
+)
+{
+    is  >> ownToNbrDebug.nFaces
+        >> ownToNbrDebug.nPoints
+        >> ownToNbrDebug.nEdges
+        >> ownToNbrDebug.nInternalEdges;
+    return is;
+}
+
+
+Foam::Ostream& Foam::operator<<
+(
+    Ostream& os,
+    const coupledPolyPatch::ownToNbrDebugOrderData& ownToNbrDebug
+)
+{
+    os  << ownToNbrDebug.nFaces
+        << ownToNbrDebug.nPoints
+        << ownToNbrDebug.nEdges
+        << ownToNbrDebug.nInternalEdges;
+    return os;
 }
 
 
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.H b/src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.H
index b4bc385e5f..890bbcf3dc 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.H
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.H
@@ -54,21 +54,58 @@ class coupledPolyPatch
 :
     public polyPatch
 {
-public:
+private:
 
-    enum orderingType
-    {
-        UNKNOWN,            // Unspecified -> automatic ordering
-        COINCIDENTFULLMATCH,// Assume no transforms
-                            // and check the points in faces match
-        NOORDERING          // Unspecified -> no automatic ordering
-    };
+    // Private Member Functions
 
-    static const NamedEnum<orderingType, 3> orderingTypeNames;
+        //- Walk the given primitive patch. Starts at the given seed face and
+        //  point within that face. Traverses through the next available
+        //  manifold edge to an as yet unvisited face. Stores the order in
+        //  which faces are visited and the point/edge through which they are
+        //  first walked into. Direction reverses the order in which face-edges
+        //  are considered. For two conformal patches, with the same seed face
+        //  and point, the maps are guaranteed to match. They can therefore be
+        //  used for ordering purposes. This can also be used to identify
+        //  contiguous regions of the patch.
+        bool walk
+        (
+            const primitivePatch& pp,
+            const bool direction,
+            const label seedFacei,
+            const label seedFacePointi,
+            labelList& faceMap,
+            labelList& facePointMap,
+            label& mapFacei,
+            autoPtr<labelListList>& walks
+        ) const;
 
 
 protected:
 
+    // Protected Classes
+
+        //- Data to pass from owner.initOrder to owner.order
+        struct ownToOwnOrderData
+        {
+            labelList seedFaceis;
+        };
+
+        //- Data to pass from owner.initOrder to nbr.order
+        struct ownToNbrOrderData
+        {
+            List<pointField> seedFacePoints;
+        };
+
+        //- Data to pass from owner.initOrder to nbr.order if debugging
+        struct ownToNbrDebugOrderData
+        {
+            label nFaces;
+            label nPoints;
+            label nEdges;
+            label nInternalEdges;
+        };
+
+
     // Protected Data
 
         //- Default matching tolerance
@@ -77,12 +114,10 @@ protected:
         //- Local matching tolerance
         const scalar matchTolerance_;
 
-        //- Type of ordering
-        orderingType ordering_;
+        //- Data to pass from owner.initOrder to owner.order
+        mutable autoPtr<ownToOwnOrderData> ownToOwnOrderDataPtr_;
 
 
-protected:
-
     // Protected Member Functions
 
         //- Initialise the calculation of the patch geometry
@@ -103,46 +138,52 @@ protected:
         //- Update of the patch topology
         virtual void updateMesh(PstreamBuffers&) = 0;
 
-        //- Write point in OBJ format
-        static void writeOBJ(Ostream& os, const point& pt);
-
-        //- Write selected points in OBJ format
-        static void writeOBJ(Ostream&, const pointField&, const labelList&);
-
-        //- Write patch
+        //- Write a patch in OBJ format
         static void writeOBJ
         (
             const fileName&,
-            const UList<face>&,
+            const primitivePatch&
+        );
+
+        //- Write lines between two lists of points in OBJ format
+        static void writeOBJ
+        (
+            const fileName&,
+            const pointField&,
             const pointField&
         );
 
-        //- Write edge in OBJ format
+        //- Write a set of paths in OBJ format
         static void writeOBJ
         (
-            Ostream& os,
-            const point& p0,
-            const point& p1,
-            label& vertI
-        );
-
-        //- Get a unique anchor point for all faces
-        static pointField getAnchorPoints
-        (
-            const UList<face>&,
+            const fileName&,
             const pointField&,
-            const orderingType
+            const labelListList&
         );
 
-        //- Get the number of vertices face f needs to be rotated such that
-        //  its f[0] point aligns with given anchor (within tol).
-        static label getRotation
+        //- Initialise ordering for the given primitivePatch. Fills the
+        //  referenced data structures, but leaves transferring them to the
+        //  opposite patch to the caller.
+        virtual void initOrder
         (
-            const pointField& points,
-            const face& f,
-            const point& anchor,
-            const scalar tol
-        );
+            ownToNbrOrderData& ownToNbr,
+            autoPtr<ownToNbrDebugOrderData>& ownToNbrDebugPtr,
+            const primitivePatch&
+        ) const;
+
+        //- Return new ordering for the given primitivePatch.
+        //  Ordering is -faceMap: for every face
+        //  index of the new face -rotation:for every new face the clockwise
+        //  shift of the original face. Return false if nothing changes
+        //  (faceMap is identity, rotation is 0), true otherwise.
+        virtual bool order
+        (
+            const ownToNbrOrderData& ownToNbr,
+            const autoPtr<ownToNbrDebugOrderData>& ownToNbrDebugPtr,
+            const primitivePatch&,
+            labelList& faceMap,
+            labelList& rotation
+        ) const;
 
 
 public:
@@ -161,8 +202,7 @@ public:
             const label start,
             const label index,
             const polyBoundaryMesh& bm,
-            const word& patchType,
-            const orderingType ordering
+            const word& patchType
         );
 
         //- Construct from dictionary
@@ -172,8 +212,7 @@ public:
             const dictionary& dict,
             const label index,
             const polyBoundaryMesh& bm,
-            const word& patchType,
-            const orderingType ordering = UNKNOWN
+            const word& patchType
         );
 
         //- Construct as copy, resetting the boundary mesh
@@ -224,15 +263,10 @@ public:
                 return !owner();
             }
 
-            //- Type of ordering
-            virtual orderingType ordering() const
-            {
-                return ordering_;
-            }
-
             //- Return transformation between the coupled patches
             virtual const transformer& transform() const = 0;
 
+            //- Return the matching tolerance
             scalar matchTolerance() const
             {
                 return matchTolerance_;
@@ -283,9 +317,23 @@ public:
 
         //- Write the polyPatch data as a dictionary
         virtual void write(Ostream&) const;
+
+
+    // IOstream Operators
+
+        friend Istream& operator>>(Istream&, ownToNbrOrderData&);
+        friend Ostream& operator<<(Ostream&, const ownToNbrOrderData&);
+        friend Istream& operator>>(Istream&, ownToNbrDebugOrderData&);
+        friend Ostream& operator<<(Ostream&, const ownToNbrDebugOrderData&);
 };
 
 
+Istream& operator>>(Istream&, coupledPolyPatch::ownToNbrOrderData&);
+Ostream& operator<<(Ostream&, const coupledPolyPatch::ownToNbrOrderData&);
+Istream& operator>>(Istream&, coupledPolyPatch::ownToNbrDebugOrderData&);
+Ostream& operator<<(Ostream&, const coupledPolyPatch::ownToNbrDebugOrderData&);
+
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicPolyPatch.C b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicPolyPatch.C
index e958c17dc7..9e8fa97256 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicPolyPatch.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicPolyPatch.C
@@ -47,699 +47,101 @@ namespace Foam
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// * * * * * * * * * * * *  Protected Member Functions * * * * * * * * * * * //
 
-void Foam::cyclicPolyPatch::calcTransformTensors
-(
-    const vectorField& thisPatchCtrs,
-    const vectorField& nbrPatchCtrs,
-    const vectorField& thisPatchNormals,
-    const vectorField& nbrPatchNormals,
-    const scalarField& smallDist,
-    const scalar absTol,
-    const orderingType ordering,
-    const transformTypes transform
-) const
+void Foam::cyclicPolyPatch::initGeometry(PstreamBuffers& pBufs)
 {
-    if (debug)
-    {
-        Pout<< "coupledPolyPatch::calcTransformTensors : " << name() << endl
-            << "    transform:" << transformTypeNames[transform] << nl
-            << "    (half)size:" << thisPatchCtrs.size() << nl
-            << "    absTol:" << absTol << nl
-            << "    smallDist min:" << min(smallDist) << nl
-            << "    smallDist max:" << max(smallDist) << nl
-            << "    sum(mag(thisPatchNormals & nbrPatchNormals)):"
-            << sum(mag(thisPatchNormals & nbrPatchNormals)) << endl;
-    }
-
-    // Tolerance calculation.
-    // - normal calculation: assume absTol is the absolute error in a
-    // single normal/transformation calculation. Consists both of numerical
-    // precision (on the order of small and of writing precision
-    // (from e.g. decomposition)
-    // Then the overall error of summing the normals is sqrt(size())*absTol
-    // - separation calculation: pass in from the outside an allowable error.
-
-    if (thisPatchCtrs.size() == 0)
-    {
-        // Dummy geometry. Assume non-separated, parallel.
-        transform_ = transformer();
-    }
-    else
-    {
-        scalar error = absTol*Foam::sqrt(1.0*thisPatchCtrs.size());
-
-        if (debug)
-        {
-            Pout<< "    error:" << error << endl;
-        }
-
-        if
-        (
-            transform == ROTATIONAL
-         || (
-                transform != TRANSLATIONAL
-             && ordering != COINCIDENTFULLMATCH
-             && (
-                    sum(mag(thisPatchNormals & nbrPatchNormals))
-                  < thisPatchCtrs.size() - error
-                )
-            )
-        )
-        {
-            // Type is rotation or unknown and normals not aligned
-
-            tensorField forwardT(thisPatchCtrs.size());
-            tensorField reverseT(thisPatchCtrs.size());
-
-            forAll(forwardT, facei)
-            {
-                forwardT[facei] = rotationTensor
-                (
-                    -nbrPatchNormals[facei],
-                    thisPatchNormals[facei]
-                );
-
-                reverseT[facei] = rotationTensor
-                (
-                    thisPatchNormals[facei],
-                    -nbrPatchNormals[facei]
-                );
-            }
-
-            if (sum(mag(forwardT - forwardT[0])) > error)
-            {
-                Pout<< "--> FOAM Warning : "
-                    << " Variation in rotation greater than"
-                    << " local tolerance " << error << endl;
-            }
-
-            transform_ = transformer(forwardT[0]);
-        }
-        else
-        {
-            // Translational or (unknown and normals aligned)
-
-            // Three situations:
-            // - separation is zero. No separation.
-            // - separation is same. Single separation vector.
-            // - separation differs per face -> error.
-
-            // Check for different separation per face
-            bool sameSeparation = true;
-            bool doneWarning = false;
-
-            const vectorField separation(thisPatchCtrs - nbrPatchCtrs);
-
-            forAll(separation, facei)
-            {
-                const scalar smallSqr = sqr(smallDist[facei]);
-
-                // Check if separation differing w.r.t. face 0.
-                if (magSqr(separation[facei] - separation[0]) > smallSqr)
-                {
-                    sameSeparation = false;
-
-                    if (!doneWarning && debug)
-                    {
-                        doneWarning = true;
-
-                        Pout<< "    separation " << separation[facei]
-                            << " at " << facei
-                            << " differs from separation[0] " << separation[0]
-                            << " by more than local tolerance "
-                            << smallDist[facei]
-                            << ". Assuming non-uniform separation." << endl;
-                    }
-                }
-            }
-
-            if (sameSeparation)
-            {
-                // Check for zero separation
-                if (mag(separation[0]) < smallDist[0])
-                {
-                    if (debug)
-                    {
-                        Pout<< "    separation " << mag(separation[0])
-                            << " less than local tolerance " << smallDist[0]
-                            << ". Assuming zero separation." << endl;
-                    }
-
-                    transform_ = transformer();
-                }
-                else
-                {
-                    if (debug)
-                    {
-                        Pout<< "    separation " << mag(separation[0])
-                            << " more than local tolerance " << smallDist[0]
-                            << ". Assuming uniform separation." << endl;
-                    }
-
-                    transform_ = transformer(separation[0]);
-                }
-            }
-            else
-            {
-                Pout<< "--> FOAM Warning : "
-                    << " Variation in separation greater than"
-                    << " local tolerance " << smallDist[0] << endl;
-
-                transform_ = transformer(separation[0]);
-            }
-        }
-    }
+    polyPatch::initGeometry(pBufs);
 }
 
 
-Foam::label Foam::cyclicPolyPatch::findMaxArea
+void Foam::cyclicPolyPatch::initGeometry
 (
-    const pointField& points,
-    const faceList& faces
+    const primitivePatch& referPatch,
+    pointField& nbrCtrs,
+    vectorField& nbrAreas,
+    pointField& nbrCc
+)
+{}
+
+
+void Foam::cyclicPolyPatch::calcGeometry(PstreamBuffers& pBufs)
+{
+    calcGeometry
+    (
+        *this,
+        faceCentres(),
+        faceAreas(),
+        faceCellCentres(),
+        nbrPatch().faceCentres(),
+        nbrPatch().faceAreas(),
+        nbrPatch().faceCellCentres()
+    );
+}
+
+
+void Foam::cyclicPolyPatch::calcGeometry
+(
+    const primitivePatch& referPatch,
+    const pointField& thisCtrs,
+    const vectorField& thisAreas,
+    const pointField& thisCc,
+    const pointField& nbrCtrs,
+    const vectorField& nbrAreas,
+    const pointField& nbrCc
 )
 {
-    label maxI = -1;
-    scalar maxAreaSqr = -great;
-
-    forAll(faces, facei)
-    {
-        scalar areaSqr = magSqr(faces[facei].area(points));
-
-        if (areaSqr > maxAreaSqr)
-        {
-            maxAreaSqr = areaSqr;
-            maxI = facei;
-        }
-    }
-    return maxI;
-}
-
-
-void Foam::cyclicPolyPatch::calcTransforms()
-{
-    if (size())
-    {
-        // thisPatch
-        const cyclicPolyPatch& thisPatch = *this;
-        vectorField thisPatchAreas(thisPatch.size());
-        forAll(thisPatch, facei)
-        {
-            thisPatchAreas[facei] = thisPatch[facei].area(thisPatch.points());
-        }
-
-        // nbrPatch
-        const cyclicPolyPatch& nbrPatch = this->nbrPatch();
-        vectorField nbrPatchAreas(nbrPatch.size());
-        forAll(nbrPatch, facei)
-        {
-            nbrPatchAreas[facei] = nbrPatch[facei].area(nbrPatch.points());
-        }
-
-        calcTransforms
+    static_cast<cyclicTransform&>(*this) =
+        cyclicTransform
         (
-            thisPatch,
-            thisPatch.faceCentres(),
-            thisPatchAreas,
-            nbrPatch.faceCentres(),
-            nbrPatchAreas
+            name(),
+            thisCtrs,
+            thisAreas,
+            *this,
+            nbrPatchName(),
+            nbrCtrs,
+            nbrAreas,
+            nbrPatch(),
+            matchTolerance()
         );
-    }
 }
 
 
-void Foam::cyclicPolyPatch::calcTransforms
+void Foam::cyclicPolyPatch::initMovePoints
 (
-    const primitivePatch& thisPatch,
-    const pointField& thisPatchCtrs,
-    const vectorField& thisPatchAreas,
-    const pointField& nbrPatchCtrs,
-    const vectorField& nbrPatchAreas
+    PstreamBuffers& pBufs,
+    const pointField& p
 )
 {
-    if (debug && owner())
-    {
-        fileName casePath(boundaryMesh().mesh().time().path());
-        {
-            fileName nm0(casePath/name()+"_faces.obj");
-            Pout<< "cyclicPolyPatch::calcTransforms : Writing " << name()
-                << " faces to OBJ file " << nm0 << endl;
-            writeOBJ(nm0, thisPatch, thisPatch.points());
-        }
-        const cyclicPolyPatch& nbrPatch = this->nbrPatch();
-        {
-            fileName nm1(casePath/nbrPatch.name()+"_faces.obj");
-            Pout<< "cyclicPolyPatch::calcTransforms : Writing "
-                << nbrPatch.name()
-                << " faces to OBJ file " << nm1 << endl;
-            writeOBJ(nm1, nbrPatch, nbrPatch.points());
-        }
-        {
-            OFstream str(casePath/name()+"_to_" + nbrPatch.name() + ".obj");
-            label vertI = 0;
-            Pout<< "cyclicPolyPatch::calcTransforms :"
-                << " Writing coupled face centres as lines to " << str.name()
-                << endl;
-            forAll(thisPatchCtrs, i)
-            {
-                const point& p0 = thisPatchCtrs[i];
-                str << "v " << p0.x() << ' ' << p0.y() << ' ' << p0.z() << nl;
-                vertI++;
-                const point& p1 = nbrPatchCtrs[i];
-                str << "v " << p1.x() << ' ' << p1.y() << ' ' << p1.z() << nl;
-                vertI++;
-                str << "l " << vertI-1 << ' ' << vertI << nl;
-            }
-        }
-    }
-
-
-    // Some sanity checks
-
-    if (thisPatchCtrs.size() != nbrPatchCtrs.size())
-    {
-        FatalErrorInFunction
-            << "For patch " << name()
-            << " there are " << thisPatchCtrs.size()
-            << " face centres, for the neighbour patch " << nbrPatch().name()
-            << " there are " << nbrPatchCtrs.size()
-            << exit(FatalError);
-    }
-
-    if (transformType() != nbrPatch().transformType())
-    {
-        FatalErrorInFunction
-            << "Patch " << name()
-            << " has transform type " << transformTypeNames[transformType()]
-            << ", neighbour patch " << nbrPatchName()
-            << " has transform type "
-            << nbrPatch().transformTypeNames[nbrPatch().transformType()]
-            << exit(FatalError);
-    }
-
-
-    // Calculate transformation tensors
-
-    if (thisPatchCtrs.size() > 0)
-    {
-        vectorField thisPatchNormals(thisPatchAreas.size());
-        vectorField nbrPatchNormals(nbrPatchAreas.size());
-
-        scalar maxAreaDiff = -great;
-        label maxAreaFacei = -1;
-
-        forAll(thisPatch, facei)
-        {
-            scalar magSf = mag(thisPatchAreas[facei]);
-            scalar nbrMagSf = mag(nbrPatchAreas[facei]);
-            scalar avSf = (magSf + nbrMagSf)/2.0;
-
-            if (magSf < rootVSmall && nbrMagSf < rootVSmall)
-            {
-                // Undetermined normal. Use dummy normal to force separation
-                // check. (note use of sqrt(vSmall) since that is how mag
-                // scales)
-                thisPatchNormals[facei] = point(1, 0, 0);
-                nbrPatchNormals[facei] = thisPatchNormals[facei];
-            }
-            else
-            {
-                scalar areaDiff = mag(magSf - nbrMagSf)/avSf;
-
-                if (areaDiff > maxAreaDiff)
-                {
-                    maxAreaDiff = areaDiff;
-                    maxAreaFacei = facei;
-                }
-
-                if (areaDiff > matchTolerance())
-                {
-                    FatalErrorInFunction
-                        << "face " << facei
-                        << " area does not match neighbour by "
-                        << 100*areaDiff
-                        << "% -- possible face ordering problem." << endl
-                        << "patch:" << name()
-                        << " my area:" << magSf
-                        << " neighbour area:" << nbrMagSf
-                        << " matching tolerance:" << matchTolerance()
-                         << endl
-                        << "Mesh face:" << start()+facei
-                        << " fc:" << thisPatchCtrs[facei]
-                        << endl
-                        << "Neighbour fc:" << nbrPatchCtrs[facei]
-                        << endl
-                        << "If you are certain your matching is correct"
-                        << " you can increase the 'matchTolerance' setting"
-                        << " in the patch dictionary in the boundary file."
-                        << endl
-                        << "Rerun with cyclic debug flag set"
-                        << " for more information." << exit(FatalError);
-                }
-                else
-                {
-                    thisPatchNormals[facei] = thisPatchAreas[facei] / magSf;
-                    nbrPatchNormals[facei] = nbrPatchAreas[facei] / nbrMagSf;
-                }
-            }
-        }
-
-
-        // Print area match
-        if (debug)
-        {
-            Pout<< "cyclicPolyPatch::calcTransforms :"
-                << " patch:" << name()
-                << " Max area error:" << 100*maxAreaDiff << "% at face:"
-                << maxAreaFacei << " at:" << thisPatchCtrs[maxAreaFacei]
-                << " coupled face at:" << nbrPatchCtrs[maxAreaFacei]
-                << endl;
-        }
-
-
-        // Calculate transformation
-
-        if (transformType() == ROTATIONAL)
-        {
-            // Calculate using the given rotation axis and centre. Do not
-            // use calculated normals.
-            vector n0 = findFaceMaxRadius(thisPatchCtrs);
-            vector n1 = -findFaceMaxRadius(nbrPatchCtrs);
-            n0 /= mag(n0) + vSmall;
-            n1 /= mag(n1) + vSmall;
-
-            if (debug)
-            {
-                scalar theta = radToDeg(acos(n0 & n1));
-
-                Pout<< "cyclicPolyPatch::calcTransforms :"
-                    << " patch:" << name()
-                    << " Specified rotation :"
-                    << " n0:" << n0 << " n1:" << n1
-                    << " swept angle: " << theta << " [deg]"
-                    << endl;
-            }
-
-            // Extended tensor from two local coordinate systems calculated
-            // using normal and rotation axis
-            const tensor E0
-            (
-                rotationAxis_,
-                (n0 ^ rotationAxis_),
-                n0
-            );
-            const tensor E1
-            (
-                rotationAxis_,
-                (-n1 ^ rotationAxis_),
-                -n1
-            );
-
-            const tensor revT(E1.T() & E0);
-
-            if (mag(rotationCentre_) > small)
-            {
-                transform_ = transformer
-                (
-                    (revT.T() - I) & rotationCentre_,
-                    revT.T()
-                );
-            }
-            else
-            {
-                transform_ = transformer(revT.T());
-            }
-        }
-        else if (transformType() == TRANSLATIONAL)
-        {
-            if (debug)
-            {
-                Pout<< "cyclicPolyPatch::calcTransforms :"
-                    << " patch:" << name()
-                    << " Specified separation vector : "
-                    << separation_ << endl;
-            }
-
-            const scalarField thisPatchTols
-            (
-                matchTolerance()
-               *calcFaceTol
-                (
-                    thisPatch,
-                    thisPatch.points(),
-                    static_cast<const pointField&>(thisPatchCtrs)
-                )
-            );
-
-            // Check that separation vectors are same.
-            const scalar avgTol = average(thisPatchTols);
-            if
-            (
-                mag(separation_ + nbrPatch().separation_) > avgTol
-            )
-            {
-                WarningInFunction
-                    << "Specified separation vector " << separation_
-                    << " differs by that of neighbouring patch "
-                    << nbrPatch().separation_
-                    << " by more than tolerance " << avgTol << endl
-                    << "patch:" << name()
-                    << " neighbour:" << nbrPatchName()
-                    << endl;
-            }
-
-            // Set transformation
-            transform_ = transformer(separation_);
-        }
-        else
-        {
-            const scalarField thisPatchTols
-            (
-                matchTolerance()
-               *calcFaceTol
-                (
-                    thisPatch,
-                    thisPatch.points(),
-                    static_cast<const pointField&>(thisPatchCtrs)
-                )
-            );
-
-            calcTransformTensors
-            (
-                thisPatchCtrs,
-                nbrPatchCtrs,
-                thisPatchNormals,
-                nbrPatchNormals,
-                thisPatchTols,
-                matchTolerance(),
-                ordering(),
-                transformType()
-            );
-        }
-    }
+    polyPatch::initMovePoints(pBufs, p);
 }
 
 
-void Foam::cyclicPolyPatch::getCentresAndAnchors
+void Foam::cyclicPolyPatch::movePoints
 (
-    const primitivePatch& pp0,
-    const primitivePatch& pp1,
-
-    pointField& thisPatchCtrs,
-    pointField& nbrPatchCtrs,
-    pointField& anchors0,
-    scalarField& tols
-) const
+    PstreamBuffers& pBufs,
+    const pointField& p
+)
 {
-    // Get geometric data on both halves.
-    thisPatchCtrs = pp0.faceCentres();
-    anchors0 = getAnchorPoints(pp0, pp0.points(), ordering());
-    nbrPatchCtrs = pp1.faceCentres();
-
-    if (debug)
-    {
-        Pout<< "cyclicPolyPatch::getCentresAndAnchors :"
-            << " patch:" << name() << nl
-            << "thisPatch untransformed faceCentres (avg) : "
-            << gAverage(thisPatchCtrs) << nl
-            << "nbrPatch untransformed faceCentres (avg) : "
-            << gAverage(nbrPatchCtrs) << endl;
-    }
-
-    if (thisPatchCtrs.size())
-    {
-        switch (transformType())
-        {
-            case ROTATIONAL:
-            {
-                vector n0 = findFaceMaxRadius(thisPatchCtrs);
-                vector n1 = -findFaceMaxRadius(nbrPatchCtrs);
-                n0 /= mag(n0) + vSmall;
-                n1 /= mag(n1) + vSmall;
-
-                if (debug)
-                {
-                    scalar theta = radToDeg(acos(n0 & n1));
-
-                    Pout<< "cyclicPolyPatch::getCentresAndAnchors :"
-                        << " patch:" << name()
-                        << " Specified rotation :"
-                        << " n0:" << n0 << " n1:" << n1
-                        << " swept angle: " << theta << " [deg]"
-                        << endl;
-                }
-
-                // Extended tensor from two local coordinate systems calculated
-                // using normal and rotation axis
-                const tensor E0
-                (
-                    rotationAxis_,
-                    (n0 ^ rotationAxis_),
-                    n0
-                );
-                const tensor E1
-                (
-                    rotationAxis_,
-                    (-n1 ^ rotationAxis_),
-                    -n1
-                );
-                const tensor revT(E1.T() & E0);
-
-                // Rotation
-                forAll(thisPatchCtrs, facei)
-                {
-                    thisPatchCtrs[facei] =
-                        Foam::transform
-                        (
-                            revT,
-                            thisPatchCtrs[facei] - rotationCentre_
-                        )
-                      + rotationCentre_;
-                    anchors0[facei] =
-                        Foam::transform
-                        (
-                            revT,
-                            anchors0[facei] - rotationCentre_
-                        )
-                      + rotationCentre_;
-                }
-
-                break;
-            }
-            case TRANSLATIONAL:
-            {
-                // Transform 0 points.
-
-                if (debug)
-                {
-                    Pout<< "cyclicPolyPatch::getCentresAndAnchors :"
-                        << " patch:" << name()
-                        << "Specified translation : " << separation_
-                        << endl;
-                }
-
-                thisPatchCtrs += separation_;
-                anchors0 += separation_;
-                break;
-            }
-            default:
-            {
-                // Assumes that cyclic is rotational. This is also the initial
-                // condition for patches without faces.
-
-                // Determine the face with max area on both halves. These
-                // two faces are used to determine the transformation tensors
-                const label max0I = findMaxArea(pp0.points(), pp0);
-                const vector n0 = pp0[max0I].normal(pp0.points());
-
-                const label max1I = findMaxArea(pp1.points(), pp1);
-                const vector n1 = pp1[max1I].normal(pp1.points());
-
-                if (mag(n0 & n1) < 1-matchTolerance())
-                {
-                    if (debug)
-                    {
-                        Pout<< "cyclicPolyPatch::getCentresAndAnchors :"
-                            << " patch:" << name()
-                            << " Detected rotation :"
-                            << " n0:" << n0 << " n1:" << n1 << endl;
-                    }
-
-                    // Rotation (around origin)
-                    const tensor revT(rotationTensor(n0, -n1));
-
-                    // Rotation
-                    forAll(thisPatchCtrs, facei)
-                    {
-                        thisPatchCtrs[facei] = Foam::transform
-                        (
-                            revT,
-                            thisPatchCtrs[facei]
-                        );
-                        anchors0[facei] = Foam::transform
-                        (
-                            revT,
-                            anchors0[facei]
-                        );
-                    }
-                }
-                else
-                {
-                    // Parallel translation. Get average of all used points.
-
-                    const point ctr0(sum(pp0.localPoints())/pp0.nPoints());
-                    const point ctr1(sum(pp1.localPoints())/pp1.nPoints());
-
-                    if (debug)
-                    {
-                        Pout<< "cyclicPolyPatch::getCentresAndAnchors :"
-                            << " patch:" << name()
-                            << " Detected translation :"
-                            << " n0:" << n0 << " n1:" << n1
-                            << " ctr0:" << ctr0 << " ctr1:" << ctr1 << endl;
-                    }
-
-                    thisPatchCtrs += ctr1 - ctr0;
-                    anchors0 += ctr1 - ctr0;
-                }
-                break;
-            }
-        }
-    }
-
-    // Calculate typical distance per face
-    tols = matchTolerance()*calcFaceTol(pp1, pp1.points(), nbrPatchCtrs);
+    polyPatch::movePoints(pBufs, p);
 }
 
 
-Foam::vector Foam::cyclicPolyPatch::findFaceMaxRadius
-(
-    const pointField& faceCentres
-) const
+void Foam::cyclicPolyPatch::initUpdateMesh(PstreamBuffers& pBufs)
 {
-    // Determine a face furthest away from the axis
-
-    const vectorField n((faceCentres - rotationCentre_) ^ rotationAxis_);
-
-    const scalarField magRadSqr(magSqr(n));
-
-    label facei = findMax(magRadSqr);
-
-    if (debug)
-    {
-        Info<< "findFaceMaxRadius(const pointField&) : patch: " << name() << nl
-            << "    rotFace  = " << facei << nl
-            << "    point    = " << faceCentres[facei] << nl
-            << "    distance = " << Foam::sqrt(magRadSqr[facei])
-            << endl;
-    }
-
-    return n[facei];
+    polyPatch::initUpdateMesh(pBufs);
 }
 
 
-// * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * * * * //
+void Foam::cyclicPolyPatch::updateMesh(PstreamBuffers& pBufs)
+{
+    polyPatch::updateMesh(pBufs);
+    deleteDemandDrivenData(coupledPointsPtr_);
+    deleteDemandDrivenData(coupledEdgesPtr_);
+}
+
+
+// * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * //
 
 Foam::cyclicPolyPatch::cyclicPolyPatch
 (
@@ -748,17 +150,17 @@ Foam::cyclicPolyPatch::cyclicPolyPatch
     const label start,
     const label index,
     const polyBoundaryMesh& bm,
-    const word& patchType,
-    const orderingType ordering
+    const word& patchType
 )
 :
-    coupledPolyPatch(name, size, start, index, bm, patchType, ordering),
+    coupledPolyPatch(name, size, start, index, bm, patchType),
+    cyclicTransform(false),
     nbrPatchName_(word::null),
     nbrPatchID_(-1),
-    rotationAxis_(Zero),
-    rotationCentre_(Zero),
     coupledPointsPtr_(nullptr),
-    coupledEdgesPtr_(nullptr)
+    coupledEdgesPtr_(nullptr),
+    ownToNbrOrderDataPtr_(nullptr),
+    ownToNbrDebugOrderDataPtr_(nullptr)
 {
     // Neighbour patch might not be valid yet so no transformation
     // calculation possible.
@@ -773,17 +175,17 @@ Foam::cyclicPolyPatch::cyclicPolyPatch
     const label index,
     const polyBoundaryMesh& bm,
     const word& patchType,
-    const word& nbrPatchName,
-    const orderingType ordering
+    const word& nbrPatchName
 )
 :
-    coupledPolyPatch(name, size, start, index, bm, patchType, ordering),
+    coupledPolyPatch(name, size, start, index, bm, patchType),
+    cyclicTransform(false),
     nbrPatchName_(nbrPatchName),
     nbrPatchID_(-1),
-    rotationAxis_(Zero),
-    rotationCentre_(Zero),
     coupledPointsPtr_(nullptr),
-    coupledEdgesPtr_(nullptr)
+    coupledEdgesPtr_(nullptr),
+    ownToNbrOrderDataPtr_(nullptr),
+    ownToNbrDebugOrderDataPtr_(nullptr)
 {
     // Neighbour patch might not be valid yet so no transformation
     // calculation possible.
@@ -796,19 +198,18 @@ Foam::cyclicPolyPatch::cyclicPolyPatch
     const dictionary& dict,
     const label index,
     const polyBoundaryMesh& bm,
-    const word& patchType,
-    const orderingType ordering
+    const word& patchType
 )
 :
-    coupledPolyPatch(name, dict, index, bm, patchType, ordering),
-    cyclicTransform(dict),
+    coupledPolyPatch(name, dict, index, bm, patchType),
+    cyclicTransform(dict, false),
     nbrPatchName_(dict.lookupOrDefault("neighbourPatch", word::null)),
     coupleGroup_(dict),
     nbrPatchID_(-1),
-    rotationAxis_(Zero),
-    rotationCentre_(Zero),
     coupledPointsPtr_(nullptr),
-    coupledEdgesPtr_(nullptr)
+    coupledEdgesPtr_(nullptr),
+    ownToNbrOrderDataPtr_(nullptr),
+    ownToNbrDebugOrderDataPtr_(nullptr)
 {
     if (nbrPatchName_ == word::null && !coupleGroup_.valid())
     {
@@ -829,36 +230,6 @@ Foam::cyclicPolyPatch::cyclicPolyPatch
             << exit(FatalIOError);
     }
 
-    switch (transformType())
-    {
-        case ROTATIONAL:
-        {
-            dict.lookup("rotationAxis") >> rotationAxis_;
-            dict.lookup("rotationCentre") >> rotationCentre_;
-
-            scalar magRot = mag(rotationAxis_);
-            if (magRot < small)
-            {
-                FatalIOErrorInFunction(dict)
-                    << "Illegal rotationAxis " << rotationAxis_ << endl
-                    << "Please supply a non-zero vector."
-                    << exit(FatalIOError);
-            }
-            rotationAxis_ /= magRot;
-
-            break;
-        }
-        case TRANSLATIONAL:
-        {
-            dict.lookup("separation") >> separation_;
-            break;
-        }
-        default:
-        {
-            // no additional info required
-        }
-    }
-
     // Neighbour patch might not be valid yet so no transformation
     // calculation possible.
 }
@@ -875,10 +246,10 @@ Foam::cyclicPolyPatch::cyclicPolyPatch
     nbrPatchName_(pp.nbrPatchName_),
     coupleGroup_(pp.coupleGroup_),
     nbrPatchID_(-1),
-    rotationAxis_(pp.rotationAxis_),
-    rotationCentre_(pp.rotationCentre_),
     coupledPointsPtr_(nullptr),
-    coupledEdgesPtr_(nullptr)
+    coupledEdgesPtr_(nullptr),
+    ownToNbrOrderDataPtr_(nullptr),
+    ownToNbrDebugOrderDataPtr_(nullptr)
 {
     // Neighbour patch might not be valid yet so no transformation
     // calculation possible.
@@ -900,10 +271,10 @@ Foam::cyclicPolyPatch::cyclicPolyPatch
     nbrPatchName_(neiName),
     coupleGroup_(pp.coupleGroup_),
     nbrPatchID_(-1),
-    rotationAxis_(pp.rotationAxis_),
-    rotationCentre_(pp.rotationCentre_),
     coupledPointsPtr_(nullptr),
-    coupledEdgesPtr_(nullptr)
+    coupledEdgesPtr_(nullptr),
+    ownToNbrOrderDataPtr_(nullptr),
+    ownToNbrDebugOrderDataPtr_(nullptr)
 {
     if (neiName == name())
     {
@@ -932,10 +303,10 @@ Foam::cyclicPolyPatch::cyclicPolyPatch
     nbrPatchName_(pp.nbrPatchName_),
     coupleGroup_(pp.coupleGroup_),
     nbrPatchID_(-1),
-    rotationAxis_(pp.rotationAxis_),
-    rotationCentre_(pp.rotationCentre_),
     coupledPointsPtr_(nullptr),
-    coupledEdgesPtr_(nullptr)
+    coupledEdgesPtr_(nullptr),
+    ownToNbrOrderDataPtr_(nullptr),
+    ownToNbrDebugOrderDataPtr_(nullptr)
 {}
 
 
@@ -998,94 +369,6 @@ Foam::label Foam::cyclicPolyPatch::nbrPatchID() const
 }
 
 
-void Foam::cyclicPolyPatch::initGeometry(PstreamBuffers& pBufs)
-{
-    polyPatch::initGeometry(pBufs);
-}
-
-
-void Foam::cyclicPolyPatch::initGeometry
-(
-    const primitivePatch& referPatch,
-    pointField& nbrCtrs,
-    vectorField& nbrAreas,
-    pointField& nbrCc
-)
-{}
-
-
-void Foam::cyclicPolyPatch::calcGeometry
-(
-    const primitivePatch& referPatch,
-    const pointField& thisCtrs,
-    const vectorField& thisAreas,
-    const pointField& thisCc,
-    const pointField& nbrCtrs,
-    const vectorField& nbrAreas,
-    const pointField& nbrCc
-)
-{
-    calcTransforms
-    (
-        referPatch,
-        thisCtrs,
-        thisAreas,
-        nbrCtrs,
-        nbrAreas
-    );
-}
-
-
-void Foam::cyclicPolyPatch::calcGeometry(PstreamBuffers& pBufs)
-{
-    calcGeometry
-    (
-        *this,
-        faceCentres(),
-        faceAreas(),
-        faceCellCentres(),
-        nbrPatch().faceCentres(),
-        nbrPatch().faceAreas(),
-        nbrPatch().faceCellCentres()
-    );
-}
-
-
-void Foam::cyclicPolyPatch::initMovePoints
-(
-    PstreamBuffers& pBufs,
-    const pointField& p
-)
-{
-    polyPatch::initMovePoints(pBufs, p);
-}
-
-
-void Foam::cyclicPolyPatch::movePoints
-(
-    PstreamBuffers& pBufs,
-    const pointField& p
-)
-{
-    polyPatch::movePoints(pBufs, p);
-    calcTransforms();
-}
-
-
-void Foam::cyclicPolyPatch::initUpdateMesh(PstreamBuffers& pBufs)
-{
-    polyPatch::initUpdateMesh(pBufs);
-}
-
-
-void Foam::cyclicPolyPatch::updateMesh(PstreamBuffers& pBufs)
-{
-    polyPatch::updateMesh(pBufs);
-    deleteDemandDrivenData(coupledPointsPtr_);
-    deleteDemandDrivenData(coupledEdgesPtr_);
-}
-
-
 const Foam::edgeList& Foam::cyclicPolyPatch::coupledPoints() const
 {
     if (!coupledPointsPtr_)
@@ -1312,17 +595,25 @@ void Foam::cyclicPolyPatch::initOrder
     const primitivePatch& pp
 ) const
 {
+    if (empty())
+    {
+        return;
+    }
+
     if (owner())
     {
-        // Save patch for use in non-owner side ordering. Equivalent to
-        // processorPolyPatch using OPstream.
-        ownerPatchPtr_.reset
+        ownToNbrOrderDataPtr_ = new ownToNbrOrderData();
+
+        if (coupledPolyPatch::debug)
+        {
+            ownToNbrDebugOrderDataPtr_ = new ownToNbrDebugOrderData();
+        }
+
+        coupledPolyPatch::initOrder
         (
-            new primitivePatch
-            (
-                pp,
-                pp.points()
-            )
+            ownToNbrOrderDataPtr_(),
+            ownToNbrDebugOrderDataPtr_,
+            pp
         );
     }
 }
@@ -1336,186 +627,34 @@ bool Foam::cyclicPolyPatch::order
     labelList& rotation
 ) const
 {
-    if (debug)
+    if (empty())
     {
-        Pout<< "order : of " << pp.size()
-            << " faces of patch:" << name()
-            << " neighbour:" << nbrPatchName()
-            << endl;
-    }
-    faceMap.setSize(pp.size());
-    faceMap = -1;
-
-    rotation.setSize(pp.size());
-    rotation = 0;
-
-    if (ordering() == NOORDERING)
-    {
-        // No faces, nothing to change.
         return false;
     }
 
-    if (owner())
-    {
-        // Do nothing (i.e. identical mapping, zero rotation).
-        // See comment at top.
-        forAll(faceMap, patchFacei)
-        {
-            faceMap[patchFacei] = patchFacei;
-        }
+    // Use dummy ownToNbr data if this is the owner, as they will not be used
+    static ownToNbrOrderData ownToNbrNull;
+    static autoPtr<ownToNbrDebugOrderData> ownToNbrDebugNull(nullptr);
 
-        return false;
-    }
-    else
-    {
-        // Get stored geometry from initOrder invocation of owner.
-        const primitivePatch& pp0 = nbrPatch().ownerPatchPtr_();
+    const ownToNbrOrderData& ownToNbr =
+        owner()
+      ? ownToNbrNull
+      : nbrPatch().ownToNbrOrderDataPtr_();
 
-        // Get geometric quantities
-        pointField thisPatchCtrs, nbrPatchCtrs, anchors0;
-        scalarField tols;
-        getCentresAndAnchors
+    const autoPtr<ownToNbrDebugOrderData>& ownToNbrDebugPtr =
+        owner()
+      ? ownToNbrDebugNull
+      : nbrPatch().ownToNbrDebugOrderDataPtr_;
+
+    return
+        coupledPolyPatch::order
         (
-            pp0,
+            ownToNbr,
+            ownToNbrDebugPtr,
             pp,
-
-            thisPatchCtrs,
-            nbrPatchCtrs,
-            anchors0,
-            tols
+            faceMap,
+            rotation
         );
-
-        if (debug)
-        {
-            Pout<< "thisPatch transformed faceCentres (avg)   : "
-                << gAverage(thisPatchCtrs) << nl
-                << "nbrPatch untransformed faceCentres (avg) : "
-                << gAverage(nbrPatchCtrs) << endl;
-        }
-
-        // Geometric match of face centre vectors
-        bool matchedAll = matchPoints
-        (
-            nbrPatchCtrs,
-            thisPatchCtrs,
-            tols,
-            true,
-            faceMap
-        );
-
-        if (!matchedAll || debug)
-        {
-            // Dump halves
-            fileName nm0
-            (
-                boundaryMesh().mesh().time().path()
-               /nbrPatch().name()+"_faces.obj"
-            );
-            Pout<< "cyclicPolyPatch::order : Writing neighbour"
-                << " faces to OBJ file " << nm0 << endl;
-            writeOBJ(nm0, pp0, pp0.points());
-
-            fileName nm1
-            (
-                boundaryMesh().mesh().time().path()
-               /name()+"_faces.obj"
-            );
-            Pout<< "cyclicPolyPatch::order : Writing my"
-                << " faces to OBJ file " << nm1 << endl;
-            writeOBJ(nm1, pp, pp.points());
-
-            OFstream ccStr
-            (
-                boundaryMesh().mesh().time().path()
-               /name() + "_faceCentres.obj"
-            );
-            Pout<< "cyclicPolyPatch::order : "
-                << "Dumping currently found cyclic match as lines between"
-                << " corresponding face centres to file " << ccStr.name()
-                << endl;
-
-            // Recalculate untransformed face centres
-            // pointField rawthisPatchCtrs =
-            //    calcFaceCentres(thisPatchFaces, pp.points());
-            label vertI = 0;
-
-            forAll(nbrPatchCtrs, i)
-            {
-                if (faceMap[i] != -1)
-                {
-                    // Write edge between c1 and c0
-                    const point& c0 = thisPatchCtrs[faceMap[i]];
-                    const point& c1 = nbrPatchCtrs[i];
-                    writeOBJ(ccStr, c0, c1, vertI);
-                }
-            }
-        }
-
-        if (!matchedAll)
-        {
-            SeriousErrorInFunction
-                << "Patch:" << name() << " : "
-                << "Cannot match vectors to faces on both sides of patch"
-                << endl
-                << "    Perhaps your faces do not match?"
-                << " The obj files written contain the current match." << endl
-                << "    Continuing with incorrect face ordering from now on!"
-                << endl;
-
-                return false;
-        }
-
-
-        // Set rotation.
-        forAll(faceMap, oldFacei)
-        {
-            // The face f will be at newFacei (after morphing) and we want its
-            // anchorPoint (= f[0]) to align with the anchorpoint for the
-            // corresponding face on the other side.
-
-            label newFacei = faceMap[oldFacei];
-
-            const point& wantedAnchor = anchors0[newFacei];
-
-            rotation[newFacei] = getRotation
-            (
-                pp.points(),
-                pp[oldFacei],
-                wantedAnchor,
-                tols[oldFacei]
-            );
-
-            if (rotation[newFacei] == -1)
-            {
-                SeriousErrorInFunction
-                    << "in patch " << name()
-                    << " : "
-                    << "Cannot find point on face " << pp[oldFacei]
-                    << " with vertices "
-                    << IndirectList<point>(pp.points(), pp[oldFacei])()
-                    << " that matches point " << wantedAnchor
-                    << " when matching the halves of processor patch " << name()
-                    << "Continuing with incorrect face ordering from now on!"
-                    << endl;
-
-                return false;
-            }
-        }
-
-        ownerPatchPtr_.clear();
-
-        // Return false if no change necessary, true otherwise.
-
-        forAll(faceMap, facei)
-        {
-            if (faceMap[facei] != facei || rotation[facei] != 0)
-            {
-                return true;
-            }
-        }
-
-        return false;
-    }
 }
 
 
@@ -1531,25 +670,6 @@ void Foam::cyclicPolyPatch::write(Ostream& os) const
     coupleGroup_.write(os);
 
     cyclicTransform::write(os);
-
-    switch (transformType())
-    {
-        case ROTATIONAL:
-        {
-            writeEntry(os, "rotationAxis", rotationAxis_);
-            writeEntry(os, "rotationCentre", rotationCentre_);
-            break;
-        }
-        case TRANSLATIONAL:
-        {
-            writeEntry(os, "separation", separation_);
-            break;
-        }
-        default:
-        {
-            // no additional info to write
-        }
-    }
 }
 
 
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicPolyPatch.H b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicPolyPatch.H
index 4ce4576ff1..84169796f8 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicPolyPatch.H
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicPolyPatch.H
@@ -78,21 +78,6 @@ class cyclicPolyPatch
         //- Index of cyclic neighbour patch
         mutable label nbrPatchID_;
 
-        // Specified transformation
-
-            // For translation
-
-                //- Offset vector from one side of the cyclic to the other
-                vector separation_;
-
-            // For rotation
-
-                //- Axis of rotation for rotational cyclics
-                vector rotationAxis_;
-
-                //- Point on axis of rotation for rotational cyclics
-                point rotationCentre_;
-
         //- List of edges formed from connected points. e[0] is the point on
         //  this patch, e[1] the corresponding point on the cyclic neighbour.
         mutable edgeList* coupledPointsPtr_;
@@ -101,66 +86,17 @@ class cyclicPolyPatch
         //  e[1] the corresponding edge on the cyclic neigbour
         mutable edgeList* coupledEdgesPtr_;
 
-        //- Temporary storage of owner side patch during ordering.
-        mutable autoPtr<primitivePatch> ownerPatchPtr_;
+        //- Data to pass from owner.initOrder to nbr.order
+        mutable autoPtr<ownToNbrOrderData> ownToNbrOrderDataPtr_;
 
-
-    // Private Member Functions
-
-        //- Calculate the transformation tensors
-        //  smallDist : matching distance per face
-        //  absTol    : absolute error in normal
-        //  if orderingType = unknown it first tries rotational, then
-        //  translational transform
-        void calcTransformTensors
-        (
-            const vectorField& thisPatchCtrs,
-            const vectorField& nbrPatchCtrs,
-            const vectorField& thisPatchNormals,
-            const vectorField& nbrPatchNormals,
-            const scalarField& smallDist,
-            const scalar absTol,
-            const orderingType = UNKNOWN,
-            const transformTypes = UNSPECIFIED
-        ) const;
-
-        //- Find amongst selected faces the one with the largest area
-        static label findMaxArea(const pointField&, const faceList&);
-
-        void calcTransforms
-        (
-            const primitivePatch& thisPatch,
-            const pointField& thisPatchCtrs,
-            const vectorField& thisPatchAreas,
-            const pointField& nbrPatchCtrs,
-            const vectorField& nbrPatchAreas
-        );
-
-        // Face ordering
-
-            // Transform the points of this patch so they align with those of
-            // the cyclic neighbour
-            void getCentresAndAnchors
-            (
-                const primitivePatch& thisPatch,
-                const primitivePatch& nbrPatch,
-                pointField& thisPatchCtrs,
-                pointField& nbrPatchCtrs,
-                pointField& anchors,
-                scalarField& tols
-            ) const;
-
-            //- Return normal of face at max distance from rotation axis
-            vector findFaceMaxRadius(const pointField& faceCentres) const;
+        //- Data to pass from owner.initOrder to nbr.order if debugging
+        mutable autoPtr<ownToNbrDebugOrderData> ownToNbrDebugOrderDataPtr_;
 
 
 protected:
 
     // Protected Member functions
 
-        //- Recalculate the transformation tensors
-        virtual void calcTransforms();
-
         //- Initialise the calculation of the patch geometry
         virtual void initGeometry(PstreamBuffers&);
 
@@ -220,8 +156,7 @@ public:
             const label start,
             const label index,
             const polyBoundaryMesh& bm,
-            const word& patchType,
-            const orderingType defaultOrdering = UNKNOWN
+            const word& patchType
         );
 
         //- Construct from components
@@ -233,8 +168,7 @@ public:
             const label index,
             const polyBoundaryMesh& bm,
             const word& patchType,
-            const word& nbrPatchName,
-            const orderingType ordering
+            const word& nbrPatchName
         );
 
         //- Construct from dictionary
@@ -244,8 +178,7 @@ public:
             const dictionary& dict,
             const label index,
             const polyBoundaryMesh& bm,
-            const word& patchType,
-            const orderingType ordering = UNKNOWN
+            const word& patchType
         );
 
         //- Construct as copy, resetting the boundary mesh
@@ -364,17 +297,16 @@ public:
             return cyclicTransform::transform();
         }
 
-
-        // Transformation
-
+        //- For a given patch face index, return the corresponding index of the
+        //  face on the neighbour
         label transformGlobalFace(const label facei) const
         {
-            label offset = facei-start();
+            label offset = facei - start();
             label neiStart = nbrPatch().start();
 
             if (offset >= 0 && offset < size())
             {
-                return neiStart+offset;
+                return neiStart + offset;
             }
             else
             {
@@ -385,19 +317,6 @@ public:
             }
         }
 
-        //- Axis of rotation for rotational cyclics
-        const vector& rotationAxis() const
-        {
-            return rotationAxis_;
-        }
-
-        //- Point on axis of rotation for rotational cyclics
-        const point& rotationCentre() const
-        {
-            return rotationCentre_;
-        }
-
-
         //- Initialize ordering for primitivePatch. Does not
         //  refer to *this (except for name() and type() etc.)
         virtual void initOrder(PstreamBuffers&, const primitivePatch&) const;
@@ -415,7 +334,6 @@ public:
             labelList& rotation
         ) const;
 
-
         //- Write the polyPatch data as a dictionary
         virtual void write(Ostream&) const;
 };
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicTransform.C b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicTransform.C
index f0fced3cb7..dd45704ca5 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicTransform.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicTransform.C
@@ -24,6 +24,8 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "cyclicTransform.H"
+#include "unitConversion.H"
+#include "IOmanip.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -40,25 +42,390 @@ namespace Foam
 
     const NamedEnum<cyclicTransform::transformTypes, 4>
         cyclicTransform::transformTypeNames;
+
+    defineTypeNameAndDebug(cyclicTransform, 0);
 }
 
 
-// * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-Foam::cyclicTransform::cyclicTransform()
+void Foam::cyclicTransform::update()
+{
+    if (!transformComplete_)
+    {
+        return;
+    }
+
+    switch (transformType_)
+    {
+        case UNSPECIFIED:
+            break;
+
+        case NONE:
+            transform_ = transformer();
+            break;
+
+        case ROTATIONAL:
+            if (rotationAngle_ == 0)
+            {
+                transform_ = transformer();
+            }
+            else
+            {
+                const tensor R =
+                    quaternion(rotationAxis_, degToRad(rotationAngle_)).R();
+
+                if (mag(rotationCentre_) == 0)
+                {
+                    transform_ = transformer(R);
+                }
+                else
+                {
+                    const vector t = rotationCentre_ - (R & rotationCentre_);
+
+                    transform_ = transformer(t, R);
+                }
+            }
+            break;
+
+        case TRANSLATIONAL:
+            if (mag(separation_) == 0)
+            {
+                transform_ = transformer();
+            }
+            else
+            {
+                transform_ = transformer(separation_);
+            }
+            break;
+    }
+}
+
+
+bool Foam::cyclicTransform::set
+(
+    const cyclicTransform& t,
+    const scalar lengthScale,
+    const scalar matchTolerance
+)
+{
+    // If the supplied transform is unspecified then there is nothing to do
+    if (t.transformType_ == UNSPECIFIED)
+    {
+        return true;
+    }
+
+    // If this transform is specified then we need to check that it is
+    // compatible with the supplied transform
+    if (transformType_ != UNSPECIFIED)
+    {
+        // If the transforms are of different types then they are incompatible
+        if (transformType_ != t.transformType_)
+        {
+            return false;
+        }
+
+        // Length-tolerance
+        const scalar lengthTolerance = lengthScale*matchTolerance;
+
+        // If the transforms are both rotational then the axes must be in the
+        // same direction, the centre points must lie on the same line, and the
+        // angles (if available) must be opposing.
+        if (transformType_ == ROTATIONAL)
+        {
+            const scalar dot = rotationAxis_ & t.rotationAxis_;
+
+            if (mag(dot) < 1 - matchTolerance)
+            {
+                return false;
+            }
+
+            if
+            (
+                (rotationAxis_ & (rotationCentre_ - t.rotationCentre_))
+              > lengthTolerance
+            )
+            {
+                return false;
+            }
+
+            if (transformComplete_ && t.transformComplete_)
+            {
+                if
+                (
+                    mag(degToRad(rotationAngle_ - sign(dot)*t.rotationAngle_))
+                  > matchTolerance
+                )
+                {
+                    return false;
+                }
+            }
+        }
+
+        // If the transforms are both translational then the separations must
+        // be opposing
+        if (transformType_ == TRANSLATIONAL)
+        {
+            if (transformComplete_ && t.transformComplete_)
+            {
+                if (mag(separation_ - t.separation_) > lengthTolerance)
+                {
+                    return false;
+                }
+            }
+        }
+    }
+
+    // If the supplied transform is more complete then overwrite this with it
+    if (!transformComplete_ && t.transformComplete_)
+    {
+        *this = t;
+    }
+
+    return true;
+}
+
+
+// * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * //
+
+Foam::cyclicTransform::cyclicTransform
+(
+    const bool defaultIsNone
+)
 :
-    transformType_(UNSPECIFIED)
+    transformType_(defaultIsNone ? NONE : UNSPECIFIED),
+    rotationAxis_(vector::uniform(NaN)),
+    rotationCentre_(vector::uniform(NaN)),
+    rotationAngle_(NaN),
+    separation_(vector::uniform(NaN)),
+    transformComplete_(transformType_ == NONE),
+    transform_()
 {}
 
 
-Foam::cyclicTransform::cyclicTransform(const dictionary& dict)
+Foam::cyclicTransform::cyclicTransform
+(
+    const dictionary& dict,
+    const bool defaultIsNone
+)
 :
     transformType_
     (
         dict.found("transformType")
       ? transformTypeNames.read(dict.lookup("transformType"))
-      : UNSPECIFIED
+      : (defaultIsNone ? NONE : UNSPECIFIED)
+    ),
+    rotationAxis_
+    (
+        transformType_ == ROTATIONAL
+      ? normalised(dict.lookup<vector>("rotationAxis"))
+      : vector::uniform(NaN)
+    ),
+    rotationCentre_
+    (
+        transformType_ == ROTATIONAL
+      ? dict.lookup<point>("rotationCentre")
+      : point::uniform(NaN)
+    ),
+    rotationAngle_(dict.lookupOrDefault<scalar>("rotationAngle", NaN)),
+    separation_
+    (
+        transformType_ == TRANSLATIONAL
+      ? dict.lookup<vector>("separation")
+      : vector::uniform(NaN)
+    ),
+    transformComplete_
+    (
+        transformType_ == NONE
+     || (transformType_ == ROTATIONAL && dict.found("rotationAngle"))
+     || (transformType_ == TRANSLATIONAL && dict.found("separation"))
+    ),
+    transform_(vector::uniform(NaN), tensor::uniform(NaN))
+{
+    if (transformComplete_)
+    {
+        update();
+    }
+}
+
+
+Foam::cyclicTransform::cyclicTransform
+(
+    const word& name,
+    const vectorField& areas,
+    const cyclicTransform& transform,
+    const word& nbrName,
+    const cyclicTransform& nbrTransform,
+    const scalar matchTolerance
+)
+:
+    cyclicTransform(transform)
+{
+    // Calculate the total (vector) areas for the supplied patch data
+    const vector area = sum(areas);
+
+    // Calculate patch length scales
+    const scalar lengthScale = sqrt(mag(area));
+
+    // Copy as much data from the neighbour as possible
+    if (!transformComplete_ && nbrTransform.transformType_ != UNSPECIFIED)
+    {
+        if (!set(inv(nbrTransform), lengthScale, matchTolerance))
+        {
+            FatalErrorInFunction
+                << "Patch " << name
+                << " and neighbour patch " << nbrName
+                << " have incompatible transforms:" << nl << nl << incrIndent;
+
+            FatalErrorInFunction
+                << indent << name << nl << indent << token::BEGIN_BLOCK << nl
+                << incrIndent;
+
+            cyclicTransform::write(FatalError);
+
+            FatalErrorInFunction
+                << decrIndent << indent << token::END_BLOCK << nl << nl;
+
+            FatalErrorInFunction
+                << indent << nbrName << nl << indent << token::BEGIN_BLOCK << nl
+                << incrIndent;
+
+            nbrTransform.write(FatalError);
+
+            FatalErrorInFunction
+                << decrIndent << indent << token::END_BLOCK << nl << nl;
+
+            FatalErrorInFunction
+                << decrIndent << exit(FatalError);
+        }
+    }
+}
+
+
+Foam::cyclicTransform::cyclicTransform
+(
+    const word& name,
+    const pointField& ctrs,
+    const vectorField& areas,
+    const cyclicTransform& transform,
+    const word& nbrName,
+    const pointField& nbrCtrs,
+    const vectorField& nbrAreas,
+    const cyclicTransform& nbrTransform,
+    const scalar matchTolerance
+)
+:
+    cyclicTransform
+    (
+        name,
+        areas,
+        transform,
+        nbrName,
+        nbrTransform,
+        matchTolerance
     )
+{
+    // If there is no geometry from which to calculate the transform then
+    // nothing can be calculated
+    if (areas.size() == 0 || nbrAreas.size() == 0) return;
+
+    // Calculate the total (vector) areas for the supplied patch data
+    const vector area = sum(areas);
+    const vector nbrArea = sum(nbrAreas);
+
+    // Calculate patch length scales
+    const scalar lengthScale = sqrt(mag(area));
+
+    // Calculate the centroids for the supplied patch data
+    const scalarField magAreas(mag(areas));
+    const scalarField magNbrAreas(mag(nbrAreas));
+    const point ctr = sum(ctrs*magAreas)/sum(magAreas);
+    const point nbrCtr = sum(nbrCtrs*magNbrAreas)/sum(magNbrAreas);
+
+    // Calculate the transformation from the patch geometry
+    if (!transformComplete_)
+    {
+        // Calculate the average patch normals
+        const vector normal = normalised(area);
+        const vector nbrNormal = normalised(nbrArea);
+        const vector cross = normal ^ nbrNormal;
+
+        // Calculate the angle and distance separations
+        const scalar theta = acos(- min(max(normal & nbrNormal, -1), 1));
+        const vector delta = ctr - nbrCtr;
+
+        // If the transformation is not known then we need to detect the type
+        // and calculate all the properties that define it.
+        if (transformType_ == UNSPECIFIED)
+        {
+            transformType_ =
+                mag(theta) > rootSmall
+              ? ROTATIONAL
+              : mag(delta) > lengthScale*rootSmall
+              ? TRANSLATIONAL
+              : NONE;
+
+            if (transformType_ == ROTATIONAL)
+            {
+                rotationAxis_ = normalised(cross);
+
+                const tensor T(normal, nbrNormal, rotationAxis_);
+
+                rotationCentre_ =
+                    inv(T) & vector(normal & ctr, nbrNormal & nbrCtr, 0);
+            }
+
+            // Fall through to angle and separation calculations below
+        }
+
+        // If the transformation is known to be rotational, then the axis and
+        // centre are already defined. Just set the angle.
+        if (transformType_ == ROTATIONAL)
+        {
+            rotationAngle_ = sign(cross & rotationAxis_)*radToDeg(theta);
+        }
+
+        // If the transformation is known to be translational then just
+        // calculate the separation.
+        if (transformType_ == TRANSLATIONAL)
+        {
+            separation_ = delta;
+        }
+
+        // Update the transform object
+        transformComplete_ = true;
+        update();
+    }
+
+    // Check the transformation is correct to within the matching tolerance
+    const point nbrCtrT =
+        transform_.transformPosition(nbrCtr);
+
+    const scalar ctrNbrCtrTDistance = mag(ctr - nbrCtrT);
+
+    if (ctrNbrCtrTDistance > lengthScale*matchTolerance)
+    {
+        FatalErrorInFunction
+            << "The distance between the centre of patch " << name
+            << " and the transformed centre of patch " << nbrName << " is "
+            << ctrNbrCtrTDistance << "."
+            << nl
+            << "This is greater than the match tolerance of "
+            << lengthScale*matchTolerance << " for the patch."
+            << nl
+            << "Check that the patches are geometrically similar and that any "
+            << "transformations defined between them are correct"
+            << nl
+            << "It might be possible to fix this problem by increasing the "
+            << "\"matchTolerance\" setting for this patch in the boundary "
+            << exit(FatalError);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cyclicTransform::~cyclicTransform()
 {}
 
 
@@ -66,7 +433,97 @@ Foam::cyclicTransform::cyclicTransform(const dictionary& dict)
 
 void Foam::cyclicTransform::write(Ostream& os) const
 {
-    writeEntry(os, "transformType", transformTypeNames[transformType_]);
+    const label oldPrecision = os.precision();
+
+    os.precision(16);
+
+    if (transformType_ != UNSPECIFIED)
+    {
+        writeEntry(os, "transformType", transformTypeNames[transformType_]);
+    }
+
+    if (transformType_ == ROTATIONAL)
+    {
+        writeEntry(os, "rotationAxis", rotationAxis_);
+        writeEntry(os, "rotationCentre", rotationCentre_);
+
+        if (transformComplete_)
+        {
+            writeEntry(os, "rotationAngle", rotationAngle_);
+        }
+    }
+
+    if (transformType_ == TRANSLATIONAL)
+    {
+        if (transformComplete_)
+        {
+            writeEntry(os, "separation", separation_);
+        }
+    }
+
+    os.precision(oldPrecision);
+}
+
+
+// * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
+
+Foam::cyclicTransform Foam::operator&
+(
+    const transformer& t,
+    const cyclicTransform& c0
+)
+{
+    cyclicTransform c1(c0);
+
+    if (c1.transformType_ == cyclicTransform::ROTATIONAL)
+    {
+        c1.rotationAxis_ = normalised(t.transform(c1.rotationAxis_));
+        c1.rotationCentre_ = t.transformPosition(c1.rotationCentre_);
+    }
+
+    if (c1.transformType_ == cyclicTransform::TRANSLATIONAL)
+    {
+        if (c1.transformComplete_)
+        {
+            c1.separation_ = t.transform(c1.separation_);
+        }
+    }
+
+    if (c1.transformComplete_)
+    {
+        c1.update();
+    }
+
+    return c1;
+}
+
+
+Foam::cyclicTransform Foam::inv(const cyclicTransform& c0)
+{
+    cyclicTransform c1(c0);
+
+    if (c1.transformType_ == cyclicTransform::ROTATIONAL)
+    {
+        if (c1.transformComplete_)
+        {
+            c1.rotationAngle_ = - c1.rotationAngle_;
+        }
+    }
+
+    if (c1.transformType_ == cyclicTransform::TRANSLATIONAL)
+    {
+        if (c1.transformComplete_)
+        {
+            c1.separation_ = - c1.separation_;
+        }
+    }
+
+    if (c1.transformComplete_)
+    {
+        c1.update();
+    }
+
+    return c1;
 }
 
 
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicTransform.H b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicTransform.H
index c9961b5eb4..9b59fab7bd 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicTransform.H
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicTransform.H
@@ -65,25 +65,95 @@ public:
 
 private:
 
+    // Private Data
+
         //- Type of transformation
         transformTypes transformType_;
 
+        //- Axis of rotation
+        vector rotationAxis_;
 
-protected:
+        //- Centre of rotation
+        point rotationCentre_;
 
-        //- Transformation between the coupled patches
-        mutable transformer transform_;
+        //- Rotation angle
+        scalar rotationAngle_;
+
+        //- Separation vector
+        vector separation_;
+
+        //- Is the transformation specification complete, or do some parts of
+        //  the above data still need to be computed from the patch geometry?
+        bool transformComplete_;
+
+        //- Generic transformer object
+        transformer transform_;
+
+
+    // Private Member Functions
+
+        //- Re-calculate the transformer object from the other data if possible
+        void update();
+
+        //- Set the transform to that supplied. Return true if the
+        //  transformations are compatible. Used for copying transformation
+        //  data from the neighbour patch.
+        bool set
+        (
+            const cyclicTransform& t,
+            const scalar lengthScale,
+            const scalar matchTolerance
+        );
 
 
 public:
 
+    //- Runtime type information
+    TypeName("cyclicTransform");
+
+
     // Constructors
 
-        // Unspecified tranformation
-        cyclicTransform();
+        // Transformation set as UNSPECIFIED or NONE
+        cyclicTransform(const bool defaultIsNone);
 
         // Transformation read from dictionary
-        cyclicTransform(const dictionary& dict);
+        cyclicTransform(const dictionary& dict, const bool defaultIsNone);
+
+        //- Construct from coupled patch data. Copies from the supplied
+        //  transform and neighbour transform. Suitable for
+        //  geometrically dissimilar patches.
+        cyclicTransform
+        (
+            const word& name,
+            const vectorField& areas,
+            const cyclicTransform& transform,
+            const word& nbrName,
+            const cyclicTransform& nbrTransform,
+            const scalar matchTolerance
+        );
+
+        //- Construct from coupled patch data. Copies from the supplied
+        //  transform and neighbour transform, then tries to determine missing
+        //  parts of the transformation automatically from the patch geometry.
+        //  Suitable for geometrically similar patches only.
+        cyclicTransform
+        (
+            const word& name,
+            const pointField& ctrs,
+            const vectorField& areas,
+            const cyclicTransform& transform,
+            const word& nbrName,
+            const pointField& nbrCtrs,
+            const vectorField& nbrAreas,
+            const cyclicTransform& nbrTransform,
+            const scalar matchTolerance
+        );
+
+
+
+    // Destructor
+    virtual ~cyclicTransform();
 
 
     // Member Functions
@@ -96,18 +166,46 @@ public:
                 return transformType_;
             }
 
+            //- Is the transform fully specified?
+            bool transformComplete() const
+            {
+                return transformComplete_;
+            }
+
             //- Return transformation between the coupled patches
             const transformer& transform() const
             {
+                if (!transformComplete_)
+                {
+                    FatalErrorInFunction
+                        << "The transformation has not been fully specified or "
+                        << "calculated" << exit(FatalError);
+                }
                 return transform_;
             }
 
 
-        //- Write the polyPatch data as a dictionary
+        //- Write the data to a dictionary
         void write(Ostream& os) const;
+
+
+        // Global Operators
+
+            friend cyclicTransform operator&
+            (
+                const transformer& t,
+                const cyclicTransform& c
+            );
+
+            friend cyclicTransform inv(const cyclicTransform& c);
 };
 
 
+cyclicTransform operator&(const transformer& t, const cyclicTransform& c);
+
+cyclicTransform inv(const cyclicTransform& c);
+
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclicSlip/cyclicSlipPolyPatch.H b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclicSlip/cyclicSlipPolyPatch.H
index 808a95dd69..dc8e5f46c2 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclicSlip/cyclicSlipPolyPatch.H
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclicSlip/cyclicSlipPolyPatch.H
@@ -68,11 +68,10 @@ public:
             const label start,
             const label index,
             const polyBoundaryMesh& bm,
-            const word& patchType,
-            const orderingType ordering = UNKNOWN
+            const word& patchType
         )
         :
-            cyclicPolyPatch(name, size, start, index, bm, patchType, ordering)
+            cyclicPolyPatch(name, size, start, index, bm, patchType)
         {}
 
         //- Construct from dictionary
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/oldCyclic/oldCyclicPolyPatch.C b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/oldCyclic/oldCyclicPolyPatch.C
deleted file mode 100644
index 42207b8363..0000000000
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/oldCyclic/oldCyclicPolyPatch.C
+++ /dev/null
@@ -1,1238 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 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 "oldCyclicPolyPatch.H"
-#include "addToRunTimeSelectionTable.H"
-#include "polyBoundaryMesh.H"
-#include "polyMesh.H"
-#include "demandDrivenData.H"
-#include "OFstream.H"
-#include "patchZones.H"
-#include "matchPoints.H"
-#include "Time.H"
-#include "cyclicPolyPatch.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-namespace Foam
-{
-    defineTypeNameAndDebug(oldCyclicPolyPatch, 0);
-
-    addToRunTimeSelectionTable(polyPatch, oldCyclicPolyPatch, word);
-    addToRunTimeSelectionTable(polyPatch, oldCyclicPolyPatch, dictionary);
-}
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-Foam::pointField Foam::oldCyclicPolyPatch::calcFaceCentres
-(
-    const UList<face>& faces,
-    const pointField& points
-)
-{
-    pointField ctrs(faces.size());
-
-    forAll(faces, facei)
-    {
-        ctrs[facei] = faces[facei].centre(points);
-    }
-
-    return ctrs;
-}
-
-
-Foam::pointField Foam::oldCyclicPolyPatch::getAnchorPoints
-(
-    const UList<face>& faces,
-    const pointField& points
-)
-{
-    pointField anchors(faces.size());
-
-    forAll(faces, facei)
-    {
-        anchors[facei] = points[faces[facei][0]];
-    }
-
-    return anchors;
-}
-
-
-Foam::label Foam::oldCyclicPolyPatch::findMaxArea
-(
-    const pointField& points,
-    const faceList& faces
-)
-{
-    label maxI = -1;
-    scalar maxAreaSqr = -great;
-
-    forAll(faces, facei)
-    {
-        scalar areaSqr = magSqr(faces[facei].area(points));
-
-        if (areaSqr > maxAreaSqr)
-        {
-            maxAreaSqr = areaSqr;
-            maxI = facei;
-        }
-    }
-    return maxI;
-}
-
-
-bool Foam::oldCyclicPolyPatch::getGeometricHalves
-(
-    const primitivePatch& pp,
-    labelList& half0ToPatch,
-    labelList& half1ToPatch
-) const
-{
-    // Get geometric zones of patch by looking at normals.
-    // Method 1: any edge with sharpish angle is edge between two halves.
-    //           (this will handle e.g. wedge geometries).
-    //           Also two fully disconnected regions will be handled this way.
-    // Method 2: sort faces into two halves based on face normal.
-
-    // Calculate normals
-    const vectorField& faceNormals = pp.faceNormals();
-
-    // Find edges with sharp angles.
-    boolList regionEdge(pp.nEdges(), false);
-
-    const labelListList& edgeFaces = pp.edgeFaces();
-
-    label nRegionEdges = 0;
-
-    forAll(edgeFaces, edgeI)
-    {
-        const labelList& eFaces = edgeFaces[edgeI];
-
-        // Check manifold edges for sharp angle.
-        // (Non-manifold already handled by patchZones)
-        if (eFaces.size() == 2)
-        {
-            if ((faceNormals[eFaces[0]] & faceNormals[eFaces[1]])< featureCos_)
-            {
-                regionEdge[edgeI] = true;
-
-                nRegionEdges++;
-            }
-        }
-    }
-
-
-    // For every face determine zone it is connected to (without crossing
-    // any regionEdge)
-    patchZones ppZones(pp, regionEdge);
-
-    if (debug)
-    {
-        Pout<< "oldCyclicPolyPatch::getGeometricHalves : "
-            << "Found " << nRegionEdges << " edges on patch " << name()
-            << " where the cos of the angle between two connected faces"
-            << " was less than " << featureCos_ << nl
-            << "Patch divided by these and by single sides edges into "
-            << ppZones.nZones() << " parts." << endl;
-
-
-        // Dumping zones to obj files.
-
-        labelList nZoneFaces(ppZones.nZones());
-
-        for (label zoneI = 0; zoneI < ppZones.nZones(); zoneI++)
-        {
-            OFstream stream
-            (
-                boundaryMesh().mesh().time().path()
-               /name()+"_zone_"+Foam::name(zoneI)+".obj"
-            );
-            Pout<< "oldCyclicPolyPatch::getGeometricHalves : Writing zone "
-                << zoneI << " face centres to OBJ file " << stream.name()
-                << endl;
-
-            labelList zoneFaces(findIndices(ppZones, zoneI));
-
-            forAll(zoneFaces, i)
-            {
-                writeOBJ(stream, pp[zoneFaces[i]].centre(pp.points()));
-            }
-
-            nZoneFaces[zoneI] = zoneFaces.size();
-        }
-    }
-
-
-    if (ppZones.nZones() == 2)
-    {
-        half0ToPatch = findIndices(ppZones, 0);
-        half1ToPatch = findIndices(ppZones, 1);
-    }
-    else
-    {
-        if (debug)
-        {
-            Pout<< "oldCyclicPolyPatch::getGeometricHalves :"
-                << " falling back to face-normal comparison" << endl;
-        }
-        label n0Faces = 0;
-        half0ToPatch.setSize(pp.size());
-
-        label n1Faces = 0;
-        half1ToPatch.setSize(pp.size());
-
-        // Compare to face 0 normal.
-        forAll(faceNormals, facei)
-        {
-            if ((faceNormals[facei] & faceNormals[0]) > 0)
-            {
-                half0ToPatch[n0Faces++] = facei;
-            }
-            else
-            {
-                half1ToPatch[n1Faces++] = facei;
-            }
-        }
-        half0ToPatch.setSize(n0Faces);
-        half1ToPatch.setSize(n1Faces);
-
-        if (debug)
-        {
-            Pout<< "oldCyclicPolyPatch::getGeometricHalves :"
-                << " Number of faces per zone:("
-                << n0Faces << ' ' << n1Faces << ')' << endl;
-        }
-    }
-
-    if (half0ToPatch.size() != half1ToPatch.size())
-    {
-        fileName casePath(boundaryMesh().mesh().time().path());
-
-        // Dump halves
-        {
-            fileName nm0(casePath/name()+"_half0_faces.obj");
-            Pout<< "oldCyclicPolyPatch::getGeometricHalves : Writing half0"
-                << " faces to OBJ file " << nm0 << endl;
-            writeOBJ(nm0, UIndirectList<face>(pp, half0ToPatch)(), pp.points());
-
-            fileName nm1(casePath/name()+"_half1_faces.obj");
-            Pout<< "oldCyclicPolyPatch::getGeometricHalves : Writing half1"
-                << " faces to OBJ file " << nm1 << endl;
-            writeOBJ(nm1, UIndirectList<face>(pp, half1ToPatch)(), pp.points());
-        }
-
-        // Dump face centres
-        {
-            OFstream str0(casePath/name()+"_half0.obj");
-            Pout<< "oldCyclicPolyPatch::getGeometricHalves : Writing half0"
-                << " face centres to OBJ file " << str0.name() << endl;
-
-            forAll(half0ToPatch, i)
-            {
-                writeOBJ(str0, pp[half0ToPatch[i]].centre(pp.points()));
-            }
-
-            OFstream str1(casePath/name()+"_half1.obj");
-            Pout<< "oldCyclicPolyPatch::getGeometricHalves : Writing half1"
-                << " face centres to OBJ file " << str1.name() << endl;
-            forAll(half1ToPatch, i)
-            {
-                writeOBJ(str1, pp[half1ToPatch[i]].centre(pp.points()));
-            }
-        }
-
-        SeriousErrorInFunction
-            << "Patch " << name() << " gets decomposed in two zones of"
-            << "inequal size: " << half0ToPatch.size()
-            << " and " << half1ToPatch.size() << endl
-            << "This means that the patch is either not two separate regions"
-            << " or one region where the angle between the different regions"
-            << " is not sufficiently sharp." << endl
-            << "Please adapt the featureCos setting." << endl
-            << "Continuing with incorrect face ordering from now on!" << endl;
-
-        return false;
-    }
-    else
-    {
-        return true;
-    }
-}
-
-
-void Foam::oldCyclicPolyPatch::getCentresAndAnchors
-(
-    const primitivePatch& pp,
-    const faceList& half0Faces,
-    const faceList& half1Faces,
-
-    pointField& ppPoints,
-    pointField& half0Ctrs,
-    pointField& half1Ctrs,
-    pointField& anchors0,
-    scalarField& tols
-) const
-{
-    // Get geometric data on both halves.
-    half0Ctrs = calcFaceCentres(half0Faces, pp.points());
-    anchors0 = getAnchorPoints(half0Faces, pp.points());
-    half1Ctrs = calcFaceCentres(half1Faces, pp.points());
-
-    switch (transformType())
-    {
-        case ROTATIONAL:
-        {
-            label face0 = getConsistentRotationFace(half0Ctrs);
-            label face1 = getConsistentRotationFace(half1Ctrs);
-
-            vector n0 = ((half0Ctrs[face0] - rotationCentre_) ^ rotationAxis_);
-            vector n1 = ((half1Ctrs[face1] - rotationCentre_) ^ -rotationAxis_);
-            n0 /= mag(n0) + vSmall;
-            n1 /= mag(n1) + vSmall;
-
-            if (debug)
-            {
-                Pout<< "oldCyclicPolyPatch::getCentresAndAnchors :"
-                    << " Specified rotation :"
-                    << " n0:" << n0 << " n1:" << n1 << endl;
-            }
-
-            // Rotation (around origin)
-            const tensor reverseT(rotationTensor(n0, -n1));
-
-            // Rotation
-            forAll(half0Ctrs, facei)
-            {
-                half0Ctrs[facei] = Foam::transform(reverseT, half0Ctrs[facei]);
-                anchors0[facei] = Foam::transform(reverseT, anchors0[facei]);
-            }
-
-            ppPoints = Foam::transform(reverseT, pp.points());
-
-            break;
-        }
-        default:
-        {
-            // Assumes that cyclic is planar. This is also the initial
-            // condition for patches without faces.
-
-            // Determine the face with max area on both halves. These
-            // two faces are used to determine the transformation tensors
-            const label max0I = findMaxArea(pp.points(), half0Faces);
-            const vector n0 = half0Faces[max0I].normal(pp.points());
-
-            const label max1I = findMaxArea(pp.points(), half1Faces);
-            const vector n1 = half1Faces[max1I].normal(pp.points());
-
-            if (mag(n0 & n1) < 1-matchTolerance())
-            {
-                if (debug)
-                {
-                    Pout<< "oldCyclicPolyPatch::getCentresAndAnchors :"
-                        << " Detected rotation :"
-                        << " n0:" << n0 << " n1:" << n1 << endl;
-                }
-
-                // Rotation (around origin)
-                const tensor reverseT(rotationTensor(n0, -n1));
-
-                // Rotation
-                forAll(half0Ctrs, facei)
-                {
-                    half0Ctrs[facei] = Foam::transform
-                    (
-                        reverseT,
-                        half0Ctrs[facei]
-                    );
-                    anchors0[facei] = Foam::transform
-                    (
-                        reverseT,
-                        anchors0[facei]
-                    );
-                }
-                ppPoints = Foam::transform(reverseT, pp.points());
-            }
-            else
-            {
-                // Parallel translation. Get average of all used points.
-
-                primitiveFacePatch half0(half0Faces, pp.points());
-                const pointField& half0Pts = half0.localPoints();
-                const point ctr0(sum(half0Pts)/half0Pts.size());
-
-                primitiveFacePatch half1(half1Faces, pp.points());
-                const pointField& half1Pts = half1.localPoints();
-                const point ctr1(sum(half1Pts)/half1Pts.size());
-
-                if (debug)
-                {
-                    Pout<< "oldCyclicPolyPatch::getCentresAndAnchors :"
-                        << " Detected translation :"
-                        << " n0:" << n0 << " n1:" << n1
-                        << " ctr0:" << ctr0 << " ctr1:" << ctr1 << endl;
-                }
-
-                half0Ctrs += ctr1 - ctr0;
-                anchors0 += ctr1 - ctr0;
-                ppPoints = pp.points() + ctr1 - ctr0;
-            }
-            break;
-        }
-    }
-
-
-    // Calculate typical distance per face
-    tols = matchTolerance()*calcFaceTol(half1Faces, pp.points(), half1Ctrs);
-}
-
-
-bool Foam::oldCyclicPolyPatch::matchAnchors
-(
-    const bool report,
-    const primitivePatch& pp,
-    const labelList& half0ToPatch,
-    const pointField& anchors0,
-
-    const labelList& half1ToPatch,
-    const faceList& half1Faces,
-    const labelList& from1To0,
-
-    const scalarField& tols,
-
-    labelList& faceMap,
-    labelList& rotation
-) const
-{
-    // Set faceMap such that half0 faces get first and corresponding half1
-    // faces last.
-
-    forAll(half0ToPatch, half0Facei)
-    {
-        // Label in original patch
-        label patchFacei = half0ToPatch[half0Facei];
-
-        faceMap[patchFacei] = half0Facei;
-
-        // No rotation
-        rotation[patchFacei] = 0;
-    }
-
-    bool fullMatch = true;
-
-    forAll(from1To0, half1Facei)
-    {
-        label patchFacei = half1ToPatch[half1Facei];
-
-        // This face has to match the corresponding one on half0.
-        label half0Facei = from1To0[half1Facei];
-
-        label newFacei = half0Facei + pp.size()/2;
-
-        faceMap[patchFacei] = newFacei;
-
-        // Rotate patchFacei such that its f[0] aligns with that of
-        // the corresponding face
-        // (which after shuffling will be at position half0Facei)
-
-        const point& wantedAnchor = anchors0[half0Facei];
-
-        rotation[newFacei] = getRotation
-        (
-            pp.points(),
-            half1Faces[half1Facei],
-            wantedAnchor,
-            tols[half1Facei]
-        );
-
-        if (rotation[newFacei] == -1)
-        {
-            fullMatch = false;
-
-            if (report)
-            {
-                const face& f = half1Faces[half1Facei];
-                SeriousErrorInFunction
-                    << "Patch:" << name() << " : "
-                    << "Cannot find point on face " << f
-                    << " with vertices:"
-                    << UIndirectList<point>(pp.points(), f)()
-                    << " that matches point " << wantedAnchor
-                    << " when matching the halves of cyclic patch " << name()
-                    << endl
-                    << "Continuing with incorrect face ordering from now on!"
-                    << endl;
-            }
-        }
-    }
-    return fullMatch;
-}
-
-
-Foam::label Foam::oldCyclicPolyPatch::getConsistentRotationFace
-(
-    const pointField& faceCentres
-) const
-{
-    const scalarField magRadSqr
-    (
-        magSqr((faceCentres - rotationCentre_) ^ rotationAxis_)
-    );
-    scalarField axisLen
-    (
-        (faceCentres - rotationCentre_) & rotationAxis_
-    );
-    axisLen = axisLen - min(axisLen);
-    const scalarField magLenSqr
-    (
-        magRadSqr + axisLen*axisLen
-    );
-
-    label rotFace = -1;
-    scalar maxMagLenSqr = -great;
-    scalar maxMagRadSqr = -great;
-    forAll(faceCentres, i)
-    {
-        if (magLenSqr[i] >= maxMagLenSqr)
-        {
-            if (magRadSqr[i] > maxMagRadSqr)
-            {
-                rotFace = i;
-                maxMagLenSqr = magLenSqr[i];
-                maxMagRadSqr = magRadSqr[i];
-            }
-        }
-    }
-
-    if (debug)
-    {
-        Info<< "getConsistentRotationFace(const pointField&)" << nl
-            << "    rotFace = " << rotFace << nl
-            << "    point =  " << faceCentres[rotFace] << endl;
-    }
-
-    return rotFace;
-}
-
-
-// * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * * * * //
-
-Foam::oldCyclicPolyPatch::oldCyclicPolyPatch
-(
-    const word& name,
-    const label size,
-    const label start,
-    const label index,
-    const polyBoundaryMesh& bm,
-    const word& patchType,
-    const orderingType ordering
-)
-:
-    coupledPolyPatch(name, size, start, index, bm, patchType, ordering),
-    featureCos_(0.9),
-    rotationAxis_(Zero),
-    rotationCentre_(Zero)
-{}
-
-
-Foam::oldCyclicPolyPatch::oldCyclicPolyPatch
-(
-    const word& name,
-    const dictionary& dict,
-    const label index,
-    const polyBoundaryMesh& bm,
-    const word& patchType
-)
-:
-    coupledPolyPatch(name, dict, index, bm, patchType),
-    cyclicTransform(dict),
-    featureCos_(0.9),
-    rotationAxis_(Zero),
-    rotationCentre_(Zero)
-{
-    if (dict.found("neighbourPatch"))
-    {
-        FatalIOErrorInFunction
-        (
-            dict
-        )   << "Found \"neighbourPatch\" entry when reading cyclic patch "
-            << name << endl
-            << "Is this mesh already with split cyclics?" << endl
-            << "If so run a newer version that supports it"
-            << ", if not comment out the \"neighbourPatch\" entry and re-run"
-            << exit(FatalIOError);
-    }
-
-    dict.readIfPresent("featureCos", featureCos_);
-
-    switch (transformType())
-    {
-        case ROTATIONAL:
-        {
-            dict.lookup("rotationAxis") >> rotationAxis_;
-            dict.lookup("rotationCentre") >> rotationCentre_;
-            break;
-        }
-        case TRANSLATIONAL:
-        {
-            dict.lookup("separation") >> separation_;
-            break;
-        }
-        default:
-        {
-            // no additional info required
-        }
-    }
-}
-
-
-Foam::oldCyclicPolyPatch::oldCyclicPolyPatch
-(
-    const oldCyclicPolyPatch& pp,
-    const polyBoundaryMesh& bm
-)
-:
-    coupledPolyPatch(pp, bm),
-    cyclicTransform(pp),
-    featureCos_(pp.featureCos_),
-    rotationAxis_(pp.rotationAxis_),
-    rotationCentre_(pp.rotationCentre_)
-{}
-
-
-Foam::oldCyclicPolyPatch::oldCyclicPolyPatch
-(
-    const oldCyclicPolyPatch& pp,
-    const polyBoundaryMesh& bm,
-    const label index,
-    const label newSize,
-    const label newStart
-)
-:
-    coupledPolyPatch(pp, bm, index, newSize, newStart),
-    cyclicTransform(pp),
-    featureCos_(pp.featureCos_),
-    rotationAxis_(pp.rotationAxis_),
-    rotationCentre_(pp.rotationCentre_)
-{}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-Foam::oldCyclicPolyPatch::~oldCyclicPolyPatch()
-{}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-void Foam::oldCyclicPolyPatch::initGeometry(PstreamBuffers& pBufs)
-{
-    polyPatch::initGeometry(pBufs);
-}
-
-
-void Foam::oldCyclicPolyPatch::calcGeometry
-(
-    const primitivePatch& referPatch,
-    const pointField& thisCtrs,
-    const vectorField& thisAreas,
-    const pointField& thisCc,
-    const pointField& nbrCtrs,
-    const vectorField& nbrAreas,
-    const pointField& nbrCc
-)
-{}
-
-
-void Foam::oldCyclicPolyPatch::calcGeometry(PstreamBuffers& pBufs)
-{}
-
-
-void Foam::oldCyclicPolyPatch::initMovePoints
-(
-    PstreamBuffers& pBufs,
-    const pointField& p
-)
-{
-    polyPatch::initMovePoints(pBufs, p);
-}
-
-
-void Foam::oldCyclicPolyPatch::movePoints
-(
-    PstreamBuffers& pBufs,
-    const pointField& p
-)
-{
-    polyPatch::movePoints(pBufs, p);
-}
-
-
-void Foam::oldCyclicPolyPatch::initUpdateMesh(PstreamBuffers& pBufs)
-{
-    polyPatch::initUpdateMesh(pBufs);
-}
-
-
-void Foam::oldCyclicPolyPatch::updateMesh(PstreamBuffers& pBufs)
-{
-    polyPatch::updateMesh(pBufs);
-}
-
-
-void Foam::oldCyclicPolyPatch::initOrder
-(
-    PstreamBuffers&,
-    const primitivePatch& pp
-) const
-{}
-
-
-//  Return new ordering. Ordering is -faceMap: for every face index
-//  the new face -rotation:for every new face the clockwise shift
-//  of the original face. Return false if nothing changes (faceMap
-//  is identity, rotation is 0)
-bool Foam::oldCyclicPolyPatch::order
-(
-    PstreamBuffers&,
-    const primitivePatch& pp,
-    labelList& faceMap,
-    labelList& rotation
-) const
-{
-    faceMap.setSize(pp.size());
-    faceMap = -1;
-
-    rotation.setSize(pp.size());
-    rotation = 0;
-
-    if (pp.empty())
-    {
-        // No faces, nothing to change.
-        return false;
-    }
-
-    if (pp.size()&1)
-    {
-        FatalErrorInFunction
-            << "Size of cyclic " << name() << " should be a multiple of 2"
-            << ". It is " << pp.size() << abort(FatalError);
-    }
-
-    label halfSize = pp.size()/2;
-
-    // Supplied primitivePatch already with new points.
-    // Cyclics are limited to one transformation tensor
-    // currently anyway (i.e. straight plane) so should not be too big a
-    // problem.
-
-
-    // Indices of faces on half0
-    labelList half0ToPatch;
-    // Indices of faces on half1
-    labelList half1ToPatch;
-
-
-    // 1. Test if already correctly oriented by starting from trivial ordering.
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    half0ToPatch = identity(halfSize);
-    half1ToPatch = half0ToPatch + halfSize;
-
-    // Get faces
-    faceList half0Faces(UIndirectList<face>(pp, half0ToPatch));
-    faceList half1Faces(UIndirectList<face>(pp, half1ToPatch));
-
-    // Get geometric quantities
-    pointField half0Ctrs, half1Ctrs, anchors0, ppPoints;
-    scalarField tols;
-    getCentresAndAnchors
-    (
-        pp,
-        half0Faces,
-        half1Faces,
-
-        ppPoints,
-        half0Ctrs,
-        half1Ctrs,
-        anchors0,
-        tols
-    );
-
-    // Geometric match of face centre vectors
-    labelList from1To0;
-    bool matchedAll = matchPoints
-    (
-        half1Ctrs,
-        half0Ctrs,
-        tols,
-        false,
-        from1To0
-    );
-
-    if (debug)
-    {
-        Pout<< "oldCyclicPolyPatch::order : test if already ordered:"
-            << matchedAll << endl;
-
-        // Dump halves
-        fileName nm0("match1_"+name()+"_half0_faces.obj");
-        Pout<< "oldCyclicPolyPatch::order : Writing half0"
-            << " faces to OBJ file " << nm0 << endl;
-        writeOBJ(nm0, half0Faces, ppPoints);
-
-        fileName nm1("match1_"+name()+"_half1_faces.obj");
-        Pout<< "oldCyclicPolyPatch::order : Writing half1"
-            << " faces to OBJ file " << nm1 << endl;
-        writeOBJ(nm1, half1Faces, pp.points());
-
-        OFstream ccStr
-        (
-            boundaryMesh().mesh().time().path()
-           /"match1_"+ name() + "_faceCentres.obj"
-        );
-        Pout<< "oldCyclicPolyPatch::order : "
-            << "Dumping currently found cyclic match as lines between"
-            << " corresponding face centres to file " << ccStr.name()
-            << endl;
-
-        // Recalculate untransformed face centres
-        // pointField rawHalf0Ctrs = calcFaceCentres(half0Faces, pp.points());
-        label vertI = 0;
-
-        forAll(half1Ctrs, i)
-        {
-            // if (from1To0[i] != -1)
-            {
-                // Write edge between c1 and c0
-                // const point& c0 = rawHalf0Ctrs[from1To0[i]];
-                // const point& c0 = half0Ctrs[from1To0[i]];
-                const point& c0 = half0Ctrs[i];
-                const point& c1 = half1Ctrs[i];
-                writeOBJ(ccStr, c0, c1, vertI);
-            }
-        }
-    }
-
-
-    // 2. Ordered in pairs (so 0,1 coupled and 2,3 etc.)
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    if (!matchedAll)
-    {
-        label facei = 0;
-        for (label i = 0; i < halfSize; i++)
-        {
-            half0ToPatch[i] = facei++;
-            half1ToPatch[i] = facei++;
-        }
-
-        // And redo all matching
-        half0Faces = UIndirectList<face>(pp, half0ToPatch);
-        half1Faces = UIndirectList<face>(pp, half1ToPatch);
-
-        getCentresAndAnchors
-        (
-            pp,
-            half0Faces,
-            half1Faces,
-
-            ppPoints,
-            half0Ctrs,
-            half1Ctrs,
-            anchors0,
-            tols
-        );
-
-        // Geometric match of face centre vectors
-        matchedAll = matchPoints
-        (
-            half1Ctrs,
-            half0Ctrs,
-            tols,
-            false,
-            from1To0
-        );
-
-        if (debug)
-        {
-            Pout<< "oldCyclicPolyPatch::order : test if pairwise ordered:"
-                << matchedAll << endl;
-            // Dump halves
-            fileName nm0("match2_"+name()+"_half0_faces.obj");
-            Pout<< "oldCyclicPolyPatch::order : Writing half0"
-                << " faces to OBJ file " << nm0 << endl;
-            writeOBJ(nm0, half0Faces, ppPoints);
-
-            fileName nm1("match2_"+name()+"_half1_faces.obj");
-            Pout<< "oldCyclicPolyPatch::order : Writing half1"
-                << " faces to OBJ file " << nm1 << endl;
-            writeOBJ(nm1, half1Faces, pp.points());
-
-            OFstream ccStr
-            (
-                boundaryMesh().mesh().time().path()
-               /"match2_"+name()+"_faceCentres.obj"
-            );
-            Pout<< "oldCyclicPolyPatch::order : "
-                << "Dumping currently found cyclic match as lines between"
-                << " corresponding face centres to file " << ccStr.name()
-                << endl;
-
-            // Recalculate untransformed face centres
-            label vertI = 0;
-
-            forAll(half1Ctrs, i)
-            {
-                if (from1To0[i] != -1)
-                {
-                    // Write edge between c1 and c0
-                    const point& c0 = half0Ctrs[from1To0[i]];
-                    const point& c1 = half1Ctrs[i];
-                    writeOBJ(ccStr, c0, c1, vertI);
-                }
-            }
-        }
-    }
-
-
-    // 3. Baffles(coincident faces) converted into cyclics (e.g. jump)
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    if (!matchedAll)
-    {
-        label baffleI = 0;
-
-        forAll(pp, facei)
-        {
-            const face& f = pp.localFaces()[facei];
-            const labelList& pFaces = pp.pointFaces()[f[0]];
-
-            label matchedFacei = -1;
-
-            forAll(pFaces, i)
-            {
-                label otherFacei = pFaces[i];
-
-                if (otherFacei > facei)
-                {
-                    const face& otherF = pp.localFaces()[otherFacei];
-
-                    // Note: might pick up two similar oriented faces
-                    //       (but that is illegal anyway)
-                    if (f == otherF)
-                    {
-                        matchedFacei = otherFacei;
-                        break;
-                    }
-                }
-            }
-
-            if (matchedFacei != -1)
-            {
-                half0ToPatch[baffleI] = facei;
-                half1ToPatch[baffleI] = matchedFacei;
-                baffleI++;
-            }
-        }
-
-        if (baffleI == halfSize)
-        {
-            // And redo all matching
-            half0Faces = UIndirectList<face>(pp, half0ToPatch);
-            half1Faces = UIndirectList<face>(pp, half1ToPatch);
-
-            getCentresAndAnchors
-            (
-                pp,
-                half0Faces,
-                half1Faces,
-
-                ppPoints,
-                half0Ctrs,
-                half1Ctrs,
-                anchors0,
-                tols
-            );
-
-            // Geometric match of face centre vectors
-            matchedAll = matchPoints
-            (
-                half1Ctrs,
-                half0Ctrs,
-                tols,
-                false,
-                from1To0
-            );
-
-            if (debug)
-            {
-                Pout<< "oldCyclicPolyPatch::order : test if baffles:"
-                    << matchedAll << endl;
-                // Dump halves
-                fileName nm0("match3_"+name()+"_half0_faces.obj");
-                Pout<< "oldCyclicPolyPatch::order : Writing half0"
-                    << " faces to OBJ file " << nm0 << endl;
-                writeOBJ(nm0, half0Faces, ppPoints);
-
-                fileName nm1("match3_"+name()+"_half1_faces.obj");
-                Pout<< "oldCyclicPolyPatch::order : Writing half1"
-                    << " faces to OBJ file " << nm1 << endl;
-                writeOBJ(nm1, half1Faces, pp.points());
-
-                OFstream ccStr
-                (
-                    boundaryMesh().mesh().time().path()
-                   /"match3_"+ name() + "_faceCentres.obj"
-                );
-                Pout<< "oldCyclicPolyPatch::order : "
-                    << "Dumping currently found cyclic match as lines between"
-                    << " corresponding face centres to file " << ccStr.name()
-                    << endl;
-
-                // Recalculate untransformed face centres
-                label vertI = 0;
-
-                forAll(half1Ctrs, i)
-                {
-                    if (from1To0[i] != -1)
-                    {
-                        // Write edge between c1 and c0
-                        const point& c0 = half0Ctrs[from1To0[i]];
-                        const point& c1 = half1Ctrs[i];
-                        writeOBJ(ccStr, c0, c1, vertI);
-                    }
-                }
-            }
-        }
-    }
-
-
-    // 4. Automatic geometric ordering
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    if (!matchedAll)
-    {
-        // Split faces according to feature angle or topology
-        bool okSplit = getGeometricHalves(pp, half0ToPatch, half1ToPatch);
-
-        if (!okSplit)
-        {
-            // Did not split into two equal parts.
-            return false;
-        }
-
-        // And redo all matching
-        half0Faces = UIndirectList<face>(pp, half0ToPatch);
-        half1Faces = UIndirectList<face>(pp, half1ToPatch);
-
-        getCentresAndAnchors
-        (
-            pp,
-            half0Faces,
-            half1Faces,
-
-            ppPoints,
-            half0Ctrs,
-            half1Ctrs,
-            anchors0,
-            tols
-        );
-
-        // Geometric match of face centre vectors
-        matchedAll = matchPoints
-        (
-            half1Ctrs,
-            half0Ctrs,
-            tols,
-            false,
-            from1To0
-        );
-
-        if (debug)
-        {
-            Pout<< "oldCyclicPolyPatch::order : automatic ordering result:"
-                << matchedAll << endl;
-            // Dump halves
-            fileName nm0("match4_"+name()+"_half0_faces.obj");
-            Pout<< "oldCyclicPolyPatch::order : Writing half0"
-                << " faces to OBJ file " << nm0 << endl;
-            writeOBJ(nm0, half0Faces, ppPoints);
-
-            fileName nm1("match4_"+name()+"_half1_faces.obj");
-            Pout<< "oldCyclicPolyPatch::order : Writing half1"
-                << " faces to OBJ file " << nm1 << endl;
-            writeOBJ(nm1, half1Faces, pp.points());
-
-            OFstream ccStr
-            (
-                boundaryMesh().mesh().time().path()
-               /"match4_"+ name() + "_faceCentres.obj"
-            );
-            Pout<< "oldCyclicPolyPatch::order : "
-                << "Dumping currently found cyclic match as lines between"
-                << " corresponding face centres to file " << ccStr.name()
-                << endl;
-
-            // Recalculate untransformed face centres
-            label vertI = 0;
-
-            forAll(half1Ctrs, i)
-            {
-                if (from1To0[i] != -1)
-                {
-                    // Write edge between c1 and c0
-                    const point& c0 = half0Ctrs[from1To0[i]];
-                    const point& c1 = half1Ctrs[i];
-                    writeOBJ(ccStr, c0, c1, vertI);
-                }
-            }
-        }
-    }
-
-
-    if (!matchedAll || debug)
-    {
-        // Dump halves
-        fileName nm0(name()+"_half0_faces.obj");
-        Pout<< "oldCyclicPolyPatch::order : Writing half0"
-            << " faces to OBJ file " << nm0 << endl;
-        writeOBJ(nm0, half0Faces, pp.points());
-
-        fileName nm1(name()+"_half1_faces.obj");
-        Pout<< "oldCyclicPolyPatch::order : Writing half1"
-            << " faces to OBJ file " << nm1 << endl;
-        writeOBJ(nm1, half1Faces, pp.points());
-
-        OFstream ccStr
-        (
-            boundaryMesh().mesh().time().path()
-           /name() + "_faceCentres.obj"
-        );
-        Pout<< "oldCyclicPolyPatch::order : "
-            << "Dumping currently found cyclic match as lines between"
-            << " corresponding face centres to file " << ccStr.name()
-            << endl;
-
-        // Recalculate untransformed face centres
-        // pointField rawHalf0Ctrs = calcFaceCentres(half0Faces, pp.points());
-        label vertI = 0;
-
-        forAll(half1Ctrs, i)
-        {
-            if (from1To0[i] != -1)
-            {
-                // Write edge between c1 and c0
-                // const point& c0 = rawHalf0Ctrs[from1To0[i]];
-                const point& c0 = half0Ctrs[from1To0[i]];
-                const point& c1 = half1Ctrs[i];
-                writeOBJ(ccStr, c0, c1, vertI);
-            }
-        }
-    }
-
-
-    if (!matchedAll)
-    {
-        SeriousErrorInFunction
-            << "Patch:" << name() << " : "
-            << "Cannot match vectors to faces on both sides of patch" << endl
-            << "    Perhaps your faces do not match?"
-            << " The obj files written contain the current match." << endl
-            << "    Continuing with incorrect face ordering from now on!"
-            << endl;
-
-            return false;
-    }
-
-
-    // Set faceMap such that half0 faces get first and corresponding half1
-    // faces last.
-    matchAnchors
-    (
-        true,                   // report if anchor matching error
-        pp,
-        half0ToPatch,
-        anchors0,
-        half1ToPatch,
-        half1Faces,
-        from1To0,
-        tols,
-        faceMap,
-        rotation
-    );
-
-    // Return false if no change necessary, true otherwise.
-
-    forAll(faceMap, facei)
-    {
-        if (faceMap[facei] != facei || rotation[facei] != 0)
-        {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-
-void Foam::oldCyclicPolyPatch::write(Ostream& os) const
-{
-    // Replacement of polyPatch::write to write 'cyclic' instead of type():
-    writeEntry(os, "type", cyclicPolyPatch::typeName);
-    patchIdentifier::write(os);
-    writeEntry(os, "nFaces", size());
-    writeEntry(os, "startFace", start());
-
-    writeEntry(os, "featureCos", featureCos_);
-
-    cyclicTransform::write(os);
-
-    switch (transformType())
-    {
-        case ROTATIONAL:
-        {
-            writeEntry(os, "rotationAxis", rotationAxis_);
-            writeEntry(os, "rotationCentre", rotationCentre_);
-            break;
-        }
-        case TRANSLATIONAL:
-        {
-            writeEntry(os, "separation", separation_);
-            break;
-        }
-        default:
-        {
-            // no additional info to write
-        }
-    }
-
-    WarningInFunction
-        << "Please run foamUpgradeCyclics to convert these old-style"
-        << " cyclics into two separate cyclics patches."
-        << endl;
-}
-
-
-// ************************************************************************* //
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/oldCyclic/oldCyclicPolyPatch.H b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/oldCyclic/oldCyclicPolyPatch.H
deleted file mode 100644
index d2dd57d5aa..0000000000
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/oldCyclic/oldCyclicPolyPatch.H
+++ /dev/null
@@ -1,305 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 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::oldCyclicPolyPatch
-
-Description
-    'old' style cyclic polyPatch with all faces in single patch. Does ordering
-    but cannot be used to run. Writes 'type cyclic' so foamUpgradeCyclics
-    can be run afterwards.
-    Used to get cyclics from mesh converters that assume cyclics in single
-    patch (e.g. fluent3DMeshToFoam)
-
-SourceFiles
-    oldCyclicPolyPatch.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef oldCyclicPolyPatch_H
-#define oldCyclicPolyPatch_H
-
-#include "coupledPolyPatch.H"
-#include "cyclicTransform.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-/*---------------------------------------------------------------------------*\
-                      Class oldCyclicPolyPatch Declaration
-\*---------------------------------------------------------------------------*/
-
-class oldCyclicPolyPatch
-:
-    public coupledPolyPatch,
-    public cyclicTransform
-{
-    // Private Data
-
-        //- Morph:angle between normals of neighbouring faces.
-        //  Used to split cyclic into halves.
-        scalar featureCos_;
-
-        // For translation
-
-            //- Offset vector from one side of the cyclic to the other
-            vector separation_;
-
-        // For rotation
-
-            //- Axis of rotation for rotational cyclics
-            vector rotationAxis_;
-
-            //- Point on axis of rotation for rotational cyclics
-            point rotationCentre_;
-
-
-    // Private Member Functions
-
-        //- Find amongst selected faces the one with the largest area
-        static label findMaxArea(const pointField&, const faceList&);
-
-        void calcTransforms();
-
-        //- Calculate face centres
-        static pointField calcFaceCentres
-        (
-            const UList<face>&,
-            const pointField&
-        );
-
-        //- Get f[0] for all faces
-        static pointField getAnchorPoints
-        (
-            const UList<face>&,
-            const pointField&
-        );
-
-        // Face ordering
-
-            //- Find the two parts of the faces of pp using feature edges.
-            //  Returns true if successful.
-            bool getGeometricHalves
-            (
-                const primitivePatch&,
-                labelList&,
-                labelList&
-            ) const;
-
-            //- Calculate geometric factors of the two halves.
-            void getCentresAndAnchors
-            (
-                const primitivePatch&,
-                const faceList& half0Faces,
-                const faceList& half1Faces,
-
-                pointField& ppPoints,
-                pointField& half0Ctrs,
-                pointField& half1Ctrs,
-                pointField& anchors0,
-                scalarField& tols
-            ) const;
-
-            //- Given matched faces matches the anchor point. Sets faceMap,
-            //  rotation. Returns true if all matched.
-            bool matchAnchors
-            (
-                const bool report,
-                const primitivePatch&,
-                const labelList&,
-                const pointField&,
-                const labelList&,
-                const faceList&,
-                const labelList&,
-                const scalarField&,
-
-                labelList& faceMap,
-                labelList& rotation
-            ) const;
-
-            //- For rotational cases, try to find a unique face on each side
-            //  of the cyclic.
-            label getConsistentRotationFace
-            (
-                const pointField& faceCentres
-            ) const;
-
-
-protected:
-
-    // Protected Member functions
-
-        //- Initialise the calculation of the patch geometry
-        virtual void initGeometry(PstreamBuffers&);
-
-        //- Calculate the patch geometry
-        virtual void calcGeometry(PstreamBuffers&);
-
-        //- Initialise the patches for moving points
-        virtual void initMovePoints(PstreamBuffers&, const pointField&);
-
-        //- Correct patches after moving points
-        virtual void movePoints(PstreamBuffers&, const pointField&);
-
-        //- Initialise the update of the patch topology
-        virtual void initUpdateMesh(PstreamBuffers&);
-
-        //- Update of the patch topology
-        virtual void updateMesh(PstreamBuffers&);
-
-public:
-
-    //- Runtime type information
-    TypeName("oldCyclic");
-
-
-    // Constructors
-
-        //- Construct from components
-        oldCyclicPolyPatch
-        (
-            const word& name,
-            const label size,
-            const label start,
-            const label index,
-            const polyBoundaryMesh& bm,
-            const word& patchType,
-            const orderingType ordering = UNKNOWN
-        );
-
-        //- Construct from dictionary
-        oldCyclicPolyPatch
-        (
-            const word& name,
-            const dictionary& dict,
-            const label index,
-            const polyBoundaryMesh& bm,
-            const word& patchType
-        );
-
-        //- Construct as copy, resetting the boundary mesh
-        oldCyclicPolyPatch(const oldCyclicPolyPatch&, const polyBoundaryMesh&);
-
-        //- Construct given the original patch and resetting the
-        //  face list and boundary mesh information
-        oldCyclicPolyPatch
-        (
-            const oldCyclicPolyPatch& pp,
-            const polyBoundaryMesh& bm,
-            const label index,
-            const label newSize,
-            const label newStart
-        );
-
-        //- Construct and return a clone, resetting the boundary mesh
-        virtual autoPtr<polyPatch> clone(const polyBoundaryMesh& bm) const
-        {
-            return autoPtr<polyPatch>(new oldCyclicPolyPatch(*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 oldCyclicPolyPatch(*this, bm, index, newSize, newStart)
-            );
-        }
-
-
-    // Destructor
-
-        virtual ~oldCyclicPolyPatch();
-
-
-    // Member Functions
-
-        //- Does this side own the patch ?
-        virtual bool owner() const
-        {
-            NotImplemented;
-            return true;
-        }
-
-        //- Return transformation between the coupled patches
-        virtual const transformer& transform() const
-        {
-            return cyclicTransform::transform();
-        }
-
-        //- Calculate the patch geometry
-        virtual void calcGeometry
-        (
-            const primitivePatch& referPatch,
-            const pointField& thisCtrs,
-            const vectorField& thisAreas,
-            const pointField& thisCc,
-            const pointField& nbrCtrs,
-            const vectorField& nbrAreas,
-            const pointField& nbrCc
-        );
-
-        //- Initialize ordering for primitivePatch. Does not
-        //  refer to *this (except for name() and type() etc.)
-        virtual void initOrder
-        (
-            PstreamBuffers&,
-            const primitivePatch&
-        ) const;
-
-        //- Return new ordering for primitivePatch.
-        //  Ordering is -faceMap: for every face
-        //  index of the new face -rotation:for every new face the clockwise
-        //  shift of the original face. Return false if nothing changes
-        //  (faceMap is identity, rotation is 0), true otherwise.
-        virtual bool order
-        (
-            PstreamBuffers&,
-            const primitivePatch&,
-            labelList& faceMap,
-            labelList& rotation
-        ) const;
-
-        //- Write the polyPatch data as a dictionary
-        virtual void write(Ostream&) const;
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.C b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.C
index a3233682bc..1a19aec85e 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.C
@@ -55,11 +55,10 @@ Foam::processorPolyPatch::processorPolyPatch
     const polyBoundaryMesh& bm,
     const int myProcNo,
     const int neighbProcNo,
-    const orderingType ordering,
     const word& patchType
 )
 :
-    coupledPolyPatch(name, size, start, index, bm, patchType, ordering),
+    coupledPolyPatch(name, size, start, index, bm, patchType),
     myProcNo_(myProcNo),
     neighbProcNo_(neighbProcNo),
     neighbFaceCentres_(),
@@ -76,7 +75,6 @@ Foam::processorPolyPatch::processorPolyPatch
     const polyBoundaryMesh& bm,
     const int myProcNo,
     const int neighbProcNo,
-    const orderingType ordering,
     const word& patchType
 )
 :
@@ -87,8 +85,7 @@ Foam::processorPolyPatch::processorPolyPatch
         start,
         index,
         bm,
-        patchType,
-        ordering
+        patchType
     ),
     myProcNo_(myProcNo),
     neighbProcNo_(neighbProcNo),
@@ -247,38 +244,27 @@ void Foam::processorPolyPatch::calcGeometry(PstreamBuffers& pBufs)
             }
             else if (mag(magSf - nbrMagSf) > matchTolerance()*sqr(tols[facei]))
             {
-                fileName nm
+                const fileName patchOBJName
                 (
-                    boundaryMesh().mesh().time().path()
-                   /name()+"_faces.obj"
+                    boundaryMesh().mesh().time().path()/name() + "_faces.obj"
                 );
 
                 Pout<< "processorPolyPatch::calcGeometry : Writing my "
-                    << size()
-                    << " faces to OBJ file " << nm << endl;
+                    << size() << " faces to " << patchOBJName << endl;
 
-                writeOBJ(nm, *this, points());
+                writeOBJ(patchOBJName, *this);
 
-                OFstream ccStr
+                const fileName centresOBJName
                 (
-                    boundaryMesh().mesh().time().path()
-                    /name() + "_faceCentresConnections.obj"
+                    boundaryMesh().mesh().time().path()/name()
+                  + "_faceCentresConnections.obj"
                 );
 
                 Pout<< "processorPolyPatch::calcGeometry :"
-                    << " Dumping cell centre lines between"
-                    << " corresponding face centres to OBJ file" << ccStr.name()
-                    << endl;
+                    << " Dumping lines between corresponding face centres to "
+                    << centresOBJName.name() << endl;
 
-                label vertI = 0;
-
-                forAll(faceCentres(), facej)
-                {
-                    const point& c0 = neighbFaceCentres_[facej];
-                    const point& c1 = faceCentres()[facej];
-
-                    writeOBJ(ccStr, c0, c1, vertI);
-                }
+                writeOBJ(centresOBJName, neighbFaceCentres_, faceCentres());
 
                 FatalErrorInFunction
                     << "face " << facei << " area does not match neighbour by "
@@ -521,190 +507,38 @@ void Foam::processorPolyPatch::initOrder
     const primitivePatch& pp
 ) const
 {
-    if
-    (
-        !Pstream::parRun()
-     || ordering() == NOORDERING
-    )
+    if (!Pstream::parRun())
     {
         return;
     }
 
-    if (debug)
-    {
-        fileName nm
-        (
-            boundaryMesh().mesh().time().path()
-           /name()+"_faces.obj"
-        );
-        Pout<< "processorPolyPatch::order : Writing my " << pp.size()
-            << " faces to OBJ file " << nm << endl;
-        writeOBJ(nm, pp, pp.points());
-
-        // Calculate my face centres
-        const pointField& fc = pp.faceCentres();
-
-        OFstream localStr
-        (
-            boundaryMesh().mesh().time().path()
-           /name() + "_localFaceCentres.obj"
-        );
-        Pout<< "processorPolyPatch::order : "
-            << "Dumping " << fc.size()
-            << " local faceCentres to " << localStr.name() << endl;
-
-        forAll(fc, facei)
-        {
-            writeOBJ(localStr, fc[facei]);
-        }
-    }
-
     if (owner())
     {
-        if (ordering() == COINCIDENTFULLMATCH)
+        ownToNbrOrderData ownToNbr;
+        autoPtr<ownToNbrDebugOrderData> ownToNbrDebugPtr
+        (
+            coupledPolyPatch::debug
+          ? new ownToNbrDebugOrderData()
+          : nullptr
+        );
+
+        coupledPolyPatch::initOrder
+        (
+            ownToNbr,
+            ownToNbrDebugPtr,
+            pp
+        );
+
+        UOPstream toNeighbour(neighbProcNo(), pBufs);
+        toNeighbour << ownToNbr;
+        if (coupledPolyPatch::debug)
         {
-            // Pass the patch points and faces across
-            UOPstream toNeighbour(neighbProcNo(), pBufs);
-            toNeighbour << pp.localPoints()
-                        << pp.localFaces();
-        }
-        else
-        {
-            const pointField& ppPoints = pp.points();
-
-            pointField anchors(getAnchorPoints(pp, ppPoints, ordering()));
-
-            // Get the average of the points of each face. This is needed in
-            // case the face centroid calculation is incorrect due to the face
-            // having a very high aspect ratio.
-            pointField facePointAverages(pp.size(), Zero);
-            forAll(pp, fI)
-            {
-                const labelList& facePoints = pp[fI];
-
-                forAll(facePoints, pI)
-                {
-                    facePointAverages[fI] += ppPoints[facePoints[pI]];
-                }
-
-                facePointAverages[fI] /= facePoints.size();
-            }
-
-            // Now send all info over to the neighbour
-            UOPstream toNeighbour(neighbProcNo(), pBufs);
-            toNeighbour << pp.faceCentres() << pp.faceNormals()
-                        << anchors << facePointAverages;
+            toNeighbour << ownToNbrDebugPtr();
         }
     }
 }
 
 
-Foam::label Foam::processorPolyPatch::matchFace
-(
-    const face& a,
-    const pointField& aPts,
-    const face& b,
-    const pointField& bPts,
-    const bool sameOrientation,
-    const scalar absTolSqr,
-    scalar& matchDistSqr
-)
-{
-    if (a.size() != b.size())
-    {
-        return -1;
-    }
-
-    CirculatorBase::direction circulateDirection =
-        CirculatorBase::direction::clockwise;
-
-    if (!sameOrientation)
-    {
-        circulateDirection = CirculatorBase::direction::anticlockwise;
-    }
-
-    label matchFp = -1;
-
-    scalar closestMatchDistSqr = sqr(great);
-
-    ConstCirculator<face> aCirc(a);
-    ConstCirculator<face> bCirc(b);
-
-    do
-    {
-        const scalar diffSqr = magSqr(aPts[aCirc()] - bPts[bCirc()]);
-
-        if (diffSqr < absTolSqr)
-        {
-            // Found a matching point. Set the fulcrum of b to the iterator
-            ConstCirculator<face> bCirc2 = bCirc;
-            ++aCirc;
-
-            bCirc2.setFulcrumToIterator();
-
-            if (!sameOrientation)
-            {
-                --bCirc2;
-            }
-            else
-            {
-                ++bCirc2;
-            }
-
-            matchDistSqr = diffSqr;
-
-            do
-            {
-                const scalar diffSqr2 = magSqr(aPts[aCirc()] - bPts[bCirc2()]);
-
-                if (diffSqr2 > absTolSqr)
-                {
-                    // No match.
-                    break;
-                }
-
-                matchDistSqr += diffSqr2;
-            }
-            while
-            (
-                aCirc.circulate(CirculatorBase::direction::clockwise),
-                bCirc2.circulate(circulateDirection)
-            );
-
-            if (!aCirc.circulate())
-            {
-                if (matchDistSqr < closestMatchDistSqr)
-                {
-                    closestMatchDistSqr = matchDistSqr;
-
-                    if (!sameOrientation)
-                    {
-                        matchFp = a.size() - bCirc.nRotations();
-                    }
-                    else
-                    {
-                        matchFp = bCirc.nRotations();
-                    }
-
-                    if (closestMatchDistSqr == 0)
-                    {
-                        break;
-                    }
-                }
-            }
-
-            // Reset aCirc
-            aCirc.setIteratorToFulcrum();
-        }
-
-    } while (bCirc.circulate(circulateDirection));
-
-    matchDistSqr = closestMatchDistSqr;
-
-    return matchFp;
-}
-
-
 bool Foam::processorPolyPatch::order
 (
     PstreamBuffers& pBufs,
@@ -713,387 +547,38 @@ bool Foam::processorPolyPatch::order
     labelList& rotation
 ) const
 {
-    // Note: we only get the faces that originate from internal faces.
-
-    if
-    (
-        !Pstream::parRun()
-     || ordering() == NOORDERING
-    )
+    if (!Pstream::parRun())
     {
         return false;
     }
 
-    faceMap.setSize(pp.size());
-    faceMap = -1;
+    ownToNbrOrderData ownToNbr;
+    autoPtr<ownToNbrDebugOrderData> ownToNbrDebugPtr
+    (
+        coupledPolyPatch::debug
+      ? new ownToNbrDebugOrderData()
+      : nullptr
+    );
 
-    rotation.setSize(pp.size());
-    rotation = 0;
-
-    bool change = false;
-
-    if (owner())
+    if (!owner())
     {
-        // Do nothing (i.e. identical mapping, zero rotation).
-        // See comment at top.
-        forAll(faceMap, patchFacei)
+        UIPstream fromOwner(neighbProcNo(), pBufs);
+        fromOwner >> ownToNbr;
+        if (coupledPolyPatch::debug)
         {
-            faceMap[patchFacei] = patchFacei;
+            fromOwner >> ownToNbrDebugPtr();
         }
-
-        if (ordering() != COINCIDENTFULLMATCH)
-        {
-            const pointField& ppPoints = pp.points();
-
-            pointField anchors(getAnchorPoints(pp, ppPoints, ordering()));
-
-            // Calculate typical distance from face centre
-            scalarField tols
-            (
-                matchTolerance()*calcFaceTol(pp, pp.points(), pp.faceCentres())
-            );
-
-            forAll(faceMap, patchFacei)
-            {
-                const point& wantedAnchor = anchors[patchFacei];
-
-                rotation[patchFacei] = getRotation
-                (
-                    ppPoints,
-                    pp[patchFacei],
-                    wantedAnchor,
-                    tols[patchFacei]
-                );
-
-                if (rotation[patchFacei] > 0)
-                {
-                    change = true;
-                }
-            }
-        }
-
-        return change;
     }
-    else
-    {
-        // Calculate the absolute matching tolerance
-        scalarField tols
+
+    return
+        coupledPolyPatch::order
         (
-            matchTolerance()*calcFaceTol(pp, pp.points(), pp.faceCentres())
+            ownToNbr,
+            ownToNbrDebugPtr,
+            pp,
+            faceMap,
+            rotation
         );
-
-        if (ordering() == COINCIDENTFULLMATCH)
-        {
-            vectorField masterPts;
-            faceList masterFaces;
-
-            {
-                UIPstream fromNeighbour(neighbProcNo(), pBufs);
-                fromNeighbour >> masterPts >> masterFaces;
-            }
-
-            const pointField& localPts = pp.localPoints();
-            const faceList& localFaces = pp.localFaces();
-
-            label nMatches = 0;
-
-            forAll(pp, lFacei)
-            {
-                const face& localFace = localFaces[lFacei];
-                label faceRotation = -1;
-
-                const scalar absTolSqr = sqr(tols[lFacei]);
-
-                scalar closestMatchDistSqr = sqr(great);
-                scalar matchDistSqr = sqr(great);
-                label closestFaceMatch = -1;
-                label closestFaceRotation = -1;
-
-                forAll(masterFaces, mFacei)
-                {
-                    const face& masterFace = masterFaces[mFacei];
-
-                    faceRotation = matchFace
-                    (
-                        localFace,
-                        localPts,
-                        masterFace,
-                        masterPts,
-                        false,
-                        absTolSqr,
-                        matchDistSqr
-                    );
-
-                    if
-                    (
-                        faceRotation != -1
-                     && matchDistSqr < closestMatchDistSqr
-                    )
-                    {
-                        closestMatchDistSqr = matchDistSqr;
-                        closestFaceMatch = mFacei;
-                        closestFaceRotation = faceRotation;
-                    }
-
-                    if (closestMatchDistSqr == 0)
-                    {
-                        break;
-                    }
-                }
-
-                if
-                (
-                    closestFaceRotation != -1
-                 && closestMatchDistSqr < absTolSqr
-                )
-                {
-                    faceMap[lFacei] = closestFaceMatch;
-
-                    rotation[lFacei] = closestFaceRotation;
-
-                    if (lFacei != closestFaceMatch || closestFaceRotation > 0)
-                    {
-                        change = true;
-                    }
-
-                    nMatches++;
-                }
-                else
-                {
-                    Pout<< "Number of matches = " << nMatches << " / "
-                        << pp.size() << endl;
-
-                    pointField pts(localFace.size());
-                    forAll(localFace, pI)
-                    {
-                        const label localPtI = localFace[pI];
-                        pts[pI] = localPts[localPtI];
-                    }
-
-                    FatalErrorInFunction
-                        << "No match for face " << localFace << nl << pts
-                        << abort(FatalError);
-                }
-            }
-
-            return change;
-        }
-        else
-        {
-            vectorField masterCtrs;
-            vectorField masterNormals;
-            vectorField masterAnchors;
-            vectorField masterFacePointAverages;
-
-            // Receive data from neighbour
-            {
-                UIPstream fromNeighbour(neighbProcNo(), pBufs);
-                fromNeighbour >> masterCtrs >> masterNormals
-                              >> masterAnchors >> masterFacePointAverages;
-            }
-
-            if (debug || masterCtrs.size() != pp.size())
-            {
-                {
-                    OFstream nbrStr
-                    (
-                        boundaryMesh().mesh().time().path()
-                       /name() + "_nbrFaceCentres.obj"
-                    );
-                    Pout<< "processorPolyPatch::order : "
-                        << "Dumping neighbour faceCentres to " << nbrStr.name()
-                        << endl;
-                    forAll(masterCtrs, facei)
-                    {
-                        writeOBJ(nbrStr, masterCtrs[facei]);
-                    }
-                }
-
-                if (masterCtrs.size() != pp.size())
-                {
-                    FatalErrorInFunction
-                        << "in patch:" << name() << " : "
-                        << "Local size of patch is " << pp.size() << " (faces)."
-                        << endl
-                        << "Received from neighbour " << masterCtrs.size()
-                        << " faceCentres!"
-                        << abort(FatalError);
-                }
-            }
-
-            // Geometric match of face centre vectors
-            // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-            // 1. Try existing ordering and transformation
-            bool matchedAll = matchPoints
-            (
-                pp.faceCentres(),
-                masterCtrs,
-                pp.faceNormals(),
-                masterNormals,
-                tols,
-                false,
-                faceMap
-            );
-
-            // Try using face point average for matching
-            if (!matchedAll)
-            {
-                const pointField& ppPoints = pp.points();
-
-                pointField facePointAverages(pp.size(), Zero);
-                forAll(pp, fI)
-                {
-                    const labelList& facePoints = pp[fI];
-
-                    forAll(facePoints, pI)
-                    {
-                        facePointAverages[fI] += ppPoints[facePoints[pI]];
-                    }
-
-                    facePointAverages[fI] /= facePoints.size();
-                }
-
-                scalarField tols2
-                (
-                    calcFaceTol(pp, pp.points(), facePointAverages)
-                );
-
-                labelList faceMap2(faceMap.size(), -1);
-                matchedAll = matchPoints
-                (
-                    facePointAverages,
-                    masterFacePointAverages,
-                    pp.faceNormals(),
-                    masterNormals,
-                    tols2,
-                    true,
-                    faceMap2
-                );
-
-                forAll(faceMap, oldFacei)
-                {
-                    if (faceMap[oldFacei] == -1)
-                    {
-                        faceMap[oldFacei] = faceMap2[oldFacei];
-                    }
-                }
-
-                matchedAll = true;
-
-                forAll(faceMap, oldFacei)
-                {
-                    if (faceMap[oldFacei] == -1)
-                    {
-                        matchedAll = false;
-                    }
-                }
-            }
-
-            if (!matchedAll || debug)
-            {
-                // Dump faces
-                fileName str
-                (
-                    boundaryMesh().mesh().time().path()
-                   /name() + "_faces.obj"
-                );
-                Pout<< "processorPolyPatch::order :"
-                    << " Writing faces to OBJ file " << str.name() << endl;
-                writeOBJ(str, pp, pp.points());
-
-                OFstream ccStr
-                (
-                    boundaryMesh().mesh().time().path()
-                   /name() + "_faceCentresConnections.obj"
-                );
-
-                Pout<< "processorPolyPatch::order :"
-                    << " Dumping newly found match as lines between"
-                    << " corresponding face centres to OBJ file "
-                    << ccStr.name()
-                    << endl;
-
-                label vertI = 0;
-
-                forAll(pp.faceCentres(), facei)
-                {
-                    label masterFacei = faceMap[facei];
-
-                    if (masterFacei != -1)
-                    {
-                        const point& c0 = masterCtrs[masterFacei];
-                        const point& c1 = pp.faceCentres()[facei];
-                        writeOBJ(ccStr, c0, c1, vertI);
-                    }
-                }
-            }
-
-            if (!matchedAll)
-            {
-                SeriousErrorInFunction
-                    << "in patch:" << name() << " : "
-                    << "Cannot match vectors to faces on both sides of patch"
-                    << endl
-                    << "    masterCtrs[0]:" << masterCtrs[0] << endl
-                    << "    ctrs[0]:" << pp.faceCentres()[0] << endl
-                    << "    Check your topology changes or maybe you have"
-                    << " multiple separated (from cyclics) processor patches"
-                    << endl
-                    << "    Continuing with incorrect face ordering from now on"
-                    << endl;
-
-                return false;
-            }
-
-            // Set rotation.
-            forAll(faceMap, oldFacei)
-            {
-                // The face f will be at newFacei (after morphing) and we want
-                // its anchorPoint (= f[0]) to align with the anchorpoint for
-                // the corresponding face on the other side.
-
-                label newFacei = faceMap[oldFacei];
-
-                const point& wantedAnchor = masterAnchors[newFacei];
-
-                rotation[newFacei] = getRotation
-                (
-                    pp.points(),
-                    pp[oldFacei],
-                    wantedAnchor,
-                    tols[oldFacei]
-                );
-
-                if (rotation[newFacei] == -1)
-                {
-                    SeriousErrorInFunction
-                        << "in patch " << name()
-                        << " : "
-                        << "Cannot find point on face " << pp[oldFacei]
-                        << " with vertices "
-                        << UIndirectList<point>(pp.points(), pp[oldFacei])()
-                        << " that matches point " << wantedAnchor
-                        << " when matching the halves of processor patch "
-                        << name()
-                        << "Continuing with incorrect face ordering from now on"
-                        << endl;
-
-                    return false;
-                }
-            }
-
-            forAll(faceMap, facei)
-            {
-                if (faceMap[facei] != facei || rotation[facei] != 0)
-                {
-                    return true;
-                }
-            }
-
-            return false;
-        }
-    }
 }
 
 
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.H b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.H
index b37c39900d..a871dfbc36 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.H
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.H
@@ -93,7 +93,6 @@ protected:
             const polyBoundaryMesh& bm,
             const int myProcNo,
             const int neighbProcNo,
-            const orderingType defaultOrdering = UNKNOWN,
             const word& patchType = typeName
         );
 
@@ -152,7 +151,6 @@ public:
             const polyBoundaryMesh& bm,
             const int myProcNo,
             const int neighbProcNo,
-            const orderingType ordering = UNKNOWN,
             const word& patchType = typeName
         );
 
@@ -340,21 +338,6 @@ public:
         //  refer to *this (except for name() and type() etc.)
         virtual void initOrder(PstreamBuffers&, const primitivePatch&) const;
 
-        //- Returns rotation.
-        //    -1 : no match
-        //     0 : match
-        //    >0 : match if rotated clockwise by this amount
-        static label matchFace
-        (
-            const face& localFace,
-            const pointField& localPts,
-            const face& masterFace,
-            const pointField& masterPts,
-            const bool sameOrientation,
-            const scalar absTolSqr,
-            scalar& matchDistSqr
-        );
-
         //- Return new ordering for primitivePatch.
         //  Ordering is -faceMap: for every face
         //  index of the new face -rotation:for every new face the clockwise
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.C b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.C
index 9109509bd9..e54d72464f 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.C
@@ -48,7 +48,6 @@ Foam::processorCyclicPolyPatch::processorCyclicPolyPatch
     const int myProcNo,
     const int neighbProcNo,
     const word& referPatchName,
-    const orderingType ordering,
     const word& patchType
 )
 :
@@ -61,7 +60,6 @@ Foam::processorCyclicPolyPatch::processorCyclicPolyPatch
         bm,
         myProcNo,
         neighbProcNo,
-        ordering,
         patchType
     ),
     referPatchName_(referPatchName),
@@ -237,29 +235,11 @@ void Foam::processorCyclicPolyPatch::calcGeometry(PstreamBuffers& pBufs)
 
     if (Pstream::parRun())
     {
-        cyclicPolyPatch& pp = const_cast<cyclicPolyPatch&>(referPatch());
-
-        pp.calcTransformTensors
-        (
-            faceCentres(),
-            neighbFaceCentres(),
-            faceAreas()/mag(faceAreas()),
-            neighbFaceAreas()/mag(neighbFaceAreas()),
-            matchTolerance()*calcFaceTol(*this, points(), faceCentres()),
-            matchTolerance(),
-            ordering(),
-            transformType()
-        );
-
-        // Where do we store the calculated transformation?
-        // - on the processor patch?
-        // - on the underlying cyclic patch?
-        // - or do we not auto-calculate the transformation but
-        //   have option of reading it.
-
         // Update underlying cyclic halves. Need to do both since only one
         // half might be present as a processorCyclic.
 
+        cyclicPolyPatch& pp = const_cast<cyclicPolyPatch&>(referPatch());
+
         pp.calcGeometry
         (
             *this,
@@ -325,7 +305,6 @@ void Foam::processorCyclicPolyPatch::initOrder
     const primitivePatch& pp
 ) const
 {
-    // For now use the same algorithm as processorPolyPatch
     processorPolyPatch::initOrder(pBufs, pp);
 }
 
@@ -338,7 +317,6 @@ bool Foam::processorCyclicPolyPatch::order
     labelList& rotation
 ) const
 {
-    // For now use the same algorithm as processorPolyPatch
     return processorPolyPatch::order(pBufs, pp, faceMap, rotation);
 }
 
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.H b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.H
index 13d2012f5d..1d5d3bdd4b 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.H
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.H
@@ -122,7 +122,6 @@ public:
             const int myProcNo,
             const int neighbProcNo,
             const word& referPatchName,
-            const orderingType ordering = UNKNOWN,
             const word& patchType = typeName
         );
 
@@ -329,7 +328,7 @@ public:
         //- Return transformation between the coupled patches
         virtual const transformer& transform() const
         {
-            return referPatch().transform_;
+            return referPatch().transform();
         }
 
         //- Initialize ordering for primitivePatch. Does not
diff --git a/src/conversion/Make/files b/src/conversion/Make/files
index 7c5a0aa91c..484f1878fe 100644
--- a/src/conversion/Make/files
+++ b/src/conversion/Make/files
@@ -6,6 +6,9 @@ ensight/part/ensightPartCells.C
 ensight/part/ensightPartFaces.C
 ensight/part/ensightParts.C
 
+mergedCyclic/mergedCyclicPolyPatch.C
+mergedCyclic/polyMeshUnMergeCyclics.C
+
 meshTables/boundaryRegion.C
 meshTables/cellTable.C
 
diff --git a/src/conversion/Make/options b/src/conversion/Make/options
index 4ff461186c..44e39e5196 100644
--- a/src/conversion/Make/options
+++ b/src/conversion/Make/options
@@ -1,9 +1,11 @@
 EXE_INC = \
     -I$(LIB_SRC)/fileFormats/lnInclude \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/dynamicMesh/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude
 
 LIB_LIBS = \
     -lfileFormats \
     -lfiniteVolume \
+    -ldynamicMesh \
     -lmeshTools
diff --git a/src/conversion/mergedCyclic/mergedCyclicPolyPatch.C b/src/conversion/mergedCyclic/mergedCyclicPolyPatch.C
new file mode 100644
index 0000000000..915c485d14
--- /dev/null
+++ b/src/conversion/mergedCyclic/mergedCyclicPolyPatch.C
@@ -0,0 +1,104 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2020 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 "mergedCyclicPolyPatch.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(mergedCyclicPolyPatch, 0);
+
+    addToRunTimeSelectionTable(polyPatch, mergedCyclicPolyPatch, word);
+    addToRunTimeSelectionTable(polyPatch, mergedCyclicPolyPatch, dictionary);
+}
+
+// * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * * * * //
+
+Foam::mergedCyclicPolyPatch::mergedCyclicPolyPatch
+(
+    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)
+{}
+
+
+Foam::mergedCyclicPolyPatch::mergedCyclicPolyPatch
+(
+    const word& name,
+    const dictionary& dict,
+    const label index,
+    const polyBoundaryMesh& bm,
+    const word& patchType
+)
+:
+    polyPatch(name, dict, index, bm, patchType)
+{}
+
+
+Foam::mergedCyclicPolyPatch::mergedCyclicPolyPatch
+(
+    const mergedCyclicPolyPatch& pp,
+    const polyBoundaryMesh& bm
+)
+:
+    polyPatch(pp, bm)
+{}
+
+
+Foam::mergedCyclicPolyPatch::mergedCyclicPolyPatch
+(
+    const mergedCyclicPolyPatch& pp,
+    const polyBoundaryMesh& bm,
+    const label index,
+    const label newSize,
+    const label newStart
+)
+:
+    polyPatch(pp, bm, index, newSize, newStart)
+{}
+
+
+Foam::mergedCyclicPolyPatch::mergedCyclicPolyPatch
+(
+    const mergedCyclicPolyPatch& pp,
+    const polyBoundaryMesh& bm,
+    const label index,
+    const labelUList& mapAddressing,
+    const label newStart
+)
+:
+    polyPatch(pp, bm, index, mapAddressing, newStart)
+{}
+
+
+// ************************************************************************* //
diff --git a/src/conversion/mergedCyclic/mergedCyclicPolyPatch.H b/src/conversion/mergedCyclic/mergedCyclicPolyPatch.H
new file mode 100644
index 0000000000..d45c9fbaa1
--- /dev/null
+++ b/src/conversion/mergedCyclic/mergedCyclicPolyPatch.H
@@ -0,0 +1,170 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2020 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::mergedCyclicPolyPatch
+
+Description
+    Placeholder for two patches describing a cyclic interface. Used in mesh
+    conversion processes involving formats in which both halves of a cyclic
+    interface are stored on the same patch.
+
+See also
+    Foam::polyMeshUnMergeCyclics
+
+SourceFiles
+    mergedCyclicPolyPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef mergedCyclicPolyPatch_H
+#define mergedCyclicPolyPatch_H
+
+#include "polyPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                      Class mergedCyclicPolyPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class mergedCyclicPolyPatch
+:
+    public polyPatch
+{
+public:
+
+    //- Runtime type information
+    TypeName("mergedCyclic");
+
+
+    // Constructors
+
+        //- Construct from components
+        mergedCyclicPolyPatch
+        (
+            const word& name,
+            const label size,
+            const label start,
+            const label index,
+            const polyBoundaryMesh& bm,
+            const word& patchType
+        );
+
+        //- Construct from dictionary
+        mergedCyclicPolyPatch
+        (
+            const word& name,
+            const dictionary& dict,
+            const label index,
+            const polyBoundaryMesh& bm,
+            const word& patchType
+        );
+
+        //- Construct as copy, resetting the boundary mesh
+        mergedCyclicPolyPatch
+        (
+            const mergedCyclicPolyPatch&,
+            const polyBoundaryMesh&
+        );
+
+        //- Construct given the original patch and resetting the
+        //  face list and boundary mesh information
+        mergedCyclicPolyPatch
+        (
+            const mergedCyclicPolyPatch& pp,
+            const polyBoundaryMesh& bm,
+            const label index,
+            const label newSize,
+            const label newStart
+        );
+
+        //- Construct given the original patch and a map
+        mergedCyclicPolyPatch
+        (
+            const mergedCyclicPolyPatch& 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 mergedCyclicPolyPatch(*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 mergedCyclicPolyPatch(*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 mergedCyclicPolyPatch
+                (
+                    *this,
+                    bm,
+                    index,
+                    mapAddressing,
+                    newStart
+                )
+            );
+        }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/conversion/mergedCyclic/polyMeshUnMergeCyclics.C b/src/conversion/mergedCyclic/polyMeshUnMergeCyclics.C
new file mode 100644
index 0000000000..f5b98450b1
--- /dev/null
+++ b/src/conversion/mergedCyclic/polyMeshUnMergeCyclics.C
@@ -0,0 +1,311 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2020 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 "polyMeshUnMergeCyclics.H"
+#include "cyclicPolyPatch.H"
+#include "mergedCyclicPolyPatch.H"
+#include "polyTopoChange.H"
+#include "unitConversion.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+labelList primitivePatchGetZones
+(
+    const primitivePatch& pp,
+    const scalar includedAngle
+)
+{
+    const scalar minCos = Foam::cos(degToRad(180.0 - includedAngle));
+
+    const labelListList& edgeFaces = pp.edgeFaces();
+    const labelListList& faceEdges = pp.faceEdges();
+    const vectorField& faceNormals = pp.faceNormals();
+
+    // Working arrays
+    labelList facePrev(pp.size(), -1);
+    labelList faceEdge0(pp.size(), -1);
+    labelList faceEdgeFace0(pp.size(), -1);
+
+    // The resulting set of zones
+    labelList faceZones(pp.size(), -1);
+
+    // The current zone being populated
+    label zonei = 0;
+
+    // The starting face of the current zone
+    label facei0 = 0;
+
+    // While there are faces to consider
+    while (facei0 < faceZones.size())
+    {
+        label facei = facei0;
+        label faceEdgei = 0;
+        label faceEdgeFacei = 0;
+
+        faceZones[facei] = zonei;
+
+        do
+        {
+            // Find the connected edge and face
+            const label edgei = faceEdges[facei][faceEdgei];
+            const label facej = edgeFaces[edgei][faceEdgeFacei];
+
+            // Find the corresponding position within the other face
+            const label faceEdgej = findIndex(faceEdges[facej], edgei);
+            const label faceEdgeFacej = findIndex(edgeFaces[edgei], facej);
+
+            if
+            (
+                faceZones[facej] == zonei
+             || (faceNormals[facei] & faceNormals[facej]) < minCos
+             || face::compare(pp[facei], pp[facej]) == -1
+             || edge::compare
+                (
+                    pp[facei].faceEdge(faceEdgei),
+                    pp[facej].faceEdge(faceEdgej)
+                ) != -1
+            )
+            {
+                // Move to the next face for this edge
+                faceEdgeFacei = edgeFaces[edgei].fcIndex(faceEdgeFacei);
+
+                // If wrapped around, move to the next edge on the face
+                if (faceEdgeFacei == 0)
+                {
+                    faceEdgei = faceEdges[facei].fcIndex(faceEdgei);
+                }
+
+                // If back at the start then backtrack to the previous face
+                if
+                (
+                    faceEdgei == faceEdge0[facei]
+                 && faceEdgeFacei == faceEdgeFace0[facei]
+                )
+                {
+                    facei = facePrev[facei];
+                    faceEdgei = faceEdge0[facei];
+                    faceEdgeFacei = faceEdgeFace0[facei];
+                }
+            }
+            else
+            {
+                // Move into the next face
+                faceZones[facej] = zonei;
+                facePrev[facej] = facei;
+                facei = facej;
+
+                // Set the starting position within this face
+                faceEdgei = faceEdge0[facej] = faceEdgej;
+                faceEdgeFacei = faceEdgeFace0[facej] = faceEdgeFacej;
+            }
+        }
+        while (facei != facei0 || faceEdgei != 0 || faceEdgeFacei != 0);
+
+        // Get the next zone and starting face
+        ++ zonei;
+        while (facei0 < faceZones.size() && faceZones[facei0] != -1)
+        {
+            ++ facei0;
+        }
+    }
+
+    return faceZones;
+}
+
+
+boolList primitivePatchGetHalves
+(
+    const primitivePatch& pp,
+    const scalar includedAngle
+)
+{
+    const labelList faceZones(primitivePatchGetZones(pp, includedAngle));
+
+    // If the number of zones is not two, then the split has failed
+    // !!! To improve the robustness of this in the presence of non-planar
+    // cyclics we would have to find pairs of zones that all share the same
+    // transformation. We would still fail if the number of zones were odd.
+    if (findMin(faceZones) != 0 && findMax(faceZones) != 1)
+    {
+        FatalErrorInFunction
+            << "Patch did not divide into halves based on topology and an "
+            << "included angle of " << includedAngle << " degrees"
+            << exit(FatalError);
+    }
+
+    // Convert the zone labels into bools describing which half each face is in
+    boolList faceHalves(pp.size());
+    forAll(faceHalves, facei)
+    {
+        faceHalves[facei] = faceZones[facei] == 1;
+    }
+
+    return faceHalves;
+}
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+void Foam::polyMeshUnMergeCyclics(polyMesh& mesh, const scalar includedAngle)
+{
+    // Add cyclic patches. Clone all the existing patches into a new list, and
+    // add two additional empty cyclic patches for each merged-cyclic. Then
+    // re-patch the mesh
+    DynamicList<polyPatch*> patches;
+
+    forAll(mesh.boundaryMesh(), patchi)
+    {
+        const polyPatch& pp = mesh.boundaryMesh()[patchi];
+        patches.append
+        (
+            pp.clone
+            (
+                mesh.boundaryMesh(),
+                patches.size(),
+                pp.size(),
+                pp.start()
+            ).ptr()
+        );
+    }
+
+    bool hasMergedCyclics = false;
+    labelList patchHalf0(mesh.boundaryMesh().size(), -1);
+    labelList patchHalf1(mesh.boundaryMesh().size(), -1);
+
+    forAll(mesh.boundaryMesh(), patchi)
+    {
+        const polyPatch& pp = mesh.boundaryMesh()[patchi];
+        if (isA<mergedCyclicPolyPatch>(pp))
+        {
+            hasMergedCyclics = true;
+
+            patchHalf0[patchi] = patches.size();
+
+            patches.append
+            (
+                new cyclicPolyPatch
+                (
+                    pp.name() + "-half-0",
+                    0,
+                    mesh.nFaces(),
+                    patches.size(),
+                    mesh.boundaryMesh(),
+                    cyclicPolyPatch::typeName,
+                    pp.name() + "-half-1"
+                )
+            );
+
+            patchHalf1[patchi] = patches.size();
+
+            patches.append
+            (
+                new cyclicPolyPatch
+                (
+                    pp.name() + "-half-1",
+                    0,
+                    mesh.nFaces(),
+                    patches.size(),
+                    mesh.boundaryMesh(),
+                    cyclicPolyPatch::typeName,
+                    pp.name() + "-half-0"
+                )
+            );
+        }
+    }
+
+    if (!hasMergedCyclics)
+    {
+        return;
+    }
+
+    mesh.removeBoundary();
+    mesh.addPatches(patches);
+
+    // Move faces from the merged cyclics to the pairs of cyclic patches
+    polyTopoChange meshMod(mesh, false);
+    forAll(mesh.boundaryMesh(), patchi)
+    {
+        const polyPatch& pp = mesh.boundaryMesh()[patchi];
+        if (isA<mergedCyclicPolyPatch>(pp))
+        {
+            const boolList patchFaceHalves
+            (
+                primitivePatchGetHalves(pp, includedAngle)
+            );
+
+            forAll(pp, patchFacei)
+            {
+                const label facei = pp.start() + patchFacei;
+
+                meshMod.modifyFace
+                (
+                    mesh.faces()[facei],
+                    facei,
+                    mesh.faceOwner()[facei],
+                    -1,
+                    false,
+                    patchFaceHalves[patchFacei]
+                  ? patchHalf0[patchi]
+                  : patchHalf1[patchi],
+                    -1,
+                    false
+                );
+            }
+        }
+    }
+    autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh, false);
+
+    // Remove the (now) empty merged cyclic patches. Copy everything except the
+    // merged cyclics into a patch list and use this then re-patch the mesh.
+    patches.clear();
+
+    forAll(mesh.boundaryMesh(), patchi)
+    {
+        const polyPatch& pp = mesh.boundaryMesh()[patchi];
+        if (!isA<mergedCyclicPolyPatch>(pp))
+        {
+            patches.append
+            (
+                pp.clone
+                (
+                    mesh.boundaryMesh(),
+                    patches.size(),
+                    pp.size(),
+                    pp.start()
+                ).ptr()
+            );
+        }
+    }
+
+    mesh.removeBoundary();
+    mesh.addPatches(patches);
+}
+
+
+// ************************************************************************* //
diff --git a/src/conversion/mergedCyclic/polyMeshUnMergeCyclics.H b/src/conversion/mergedCyclic/polyMeshUnMergeCyclics.H
new file mode 100644
index 0000000000..986a081fe5
--- /dev/null
+++ b/src/conversion/mergedCyclic/polyMeshUnMergeCyclics.H
@@ -0,0 +1,51 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2020 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 polyMeshUnMergeCyclics_H
+#define polyMeshUnMergeCyclics_H
+
+#include "polyMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+//- Find all patches of type "mergedCyclic" in the given mesh and split them
+//  into two "standard" cyclics, using the given included angle to
+//  geometrically separate the halves if they meet at an angle at the axis
+void polyMeshUnMergeCyclics(polyMesh& mesh, const scalar includedAngle=165);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/conversion/meshReader/meshReader.C b/src/conversion/meshReader/meshReader.C
index 7ff0f54fed..b8fd7a6987 100644
--- a/src/conversion/meshReader/meshReader.C
+++ b/src/conversion/meshReader/meshReader.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2019 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -30,6 +30,7 @@ License
 #include "emptyPolyPatch.H"
 #include "cellModeller.H"
 #include "demandDrivenData.H"
+#include "polyMeshUnMergeCyclics.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -150,6 +151,9 @@ Foam::autoPtr<Foam::polyMesh> Foam::meshReader::mesh
     // adding patches also checks the mesh
     mesh().addPatches(polyBoundaryPatches(mesh));
 
+    // Un-merge any merged cyclics
+    polyMeshUnMergeCyclics(mesh());
+
     warnDuplicates("boundaries", mesh().boundaryMesh().names());
 
     addCellZones(mesh());
diff --git a/src/conversion/meshReader/starcd/STARCDMeshReader.C b/src/conversion/meshReader/starcd/STARCDMeshReader.C
index 567f2eb761..be4d68da26 100644
--- a/src/conversion/meshReader/starcd/STARCDMeshReader.C
+++ b/src/conversion/meshReader/starcd/STARCDMeshReader.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2019 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -24,7 +24,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "STARCDMeshReader.H"
-#include "oldCyclicPolyPatch.H"
+#include "mergedCyclicPolyPatch.H"
 #include "emptyPolyPatch.H"
 #include "wallPolyPatch.H"
 #include "symmetryPolyPatch.H"
@@ -945,16 +945,12 @@ void Foam::meshReaders::STARCD::readBoundary(const fileName& inputName)
         }
         else if (origType == "cyclic")
         {
-            // incorrect. should be cyclicPatch but this
-            // requires info on connected faces.
-            patchTypes_[patchi] = oldCyclicPolyPatch::typeName;
+            patchTypes_[patchi] = mergedCyclicPolyPatch::typeName;
             patchPhysicalTypes_[patchi] = patchTypes_[patchi];
         }
         else if (origType == "baffle")
         {
-            // incorrect. tag the patch until we get proper support.
-            // set physical type to a canonical "baffle"
-            patchTypes_[patchi] = emptyPolyPatch::typeName;
+            patchTypes_[patchi] = mergedCyclicPolyPatch::typeName;
             patchPhysicalTypes_[patchi] = "baffle";
         }
         else
diff --git a/src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C b/src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C
index 57fd4236cf..9003009bee 100644
--- a/src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C
+++ b/src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2019 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -1244,8 +1244,7 @@ void Foam::fvMeshDistribute::addProcPatches
                         mesh_.boundaryMesh(),
                         Pstream::myProcNo(),
                         proci,
-                        pcPatch.name(),
-                        pcPatch.ordering()
+                        pcPatch.name()
                     );
 
                     procPatchID[proci].insert
diff --git a/src/mesh/blockMesh/blockMesh/blockMesh.C b/src/mesh/blockMesh/blockMesh/blockMesh.C
index 83725138aa..364cfdcaa0 100644
--- a/src/mesh/blockMesh/blockMesh/blockMesh.C
+++ b/src/mesh/blockMesh/blockMesh/blockMesh.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2019 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -25,6 +25,7 @@ License
 
 #include "blockMesh.H"
 #include "Time.H"
+#include "cyclicTransform.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -127,11 +128,22 @@ Foam::PtrList<Foam::dictionary> Foam::blockMesh::patchDicts() const
 
     forAll(patchTopologies, patchi)
     {
+        autoPtr<polyPatch> ppPtr =
+            patchTopologies[patchi].clone(topology().boundaryMesh());
+
+        if (isA<cyclicTransform>(ppPtr()))
+        {
+            refCast<cyclicTransform>(ppPtr()) =
+                transformer(scaleFactor_*tensor::I)
+              & refCast<cyclicTransform>(ppPtr());
+        }
+
         OStringStream os;
-        patchTopologies[patchi].write(os);
+        ppPtr->write(os);
         IStringStream is(os.str());
         patchDicts.set(patchi, new dictionary(is));
     }
+
     return patchDicts;
 }
 
@@ -181,18 +193,6 @@ Foam::wordList Foam::blockMesh::patchNames() const
 }
 
 
-//Foam::wordList Foam::blockMesh::patchTypes() const
-//{
-//    return topology().boundaryMesh().types();
-//}
-//
-//
-//Foam::wordList Foam::blockMesh::patchPhysicalTypes() const
-//{
-//    return topology().boundaryMesh().physicalTypes();
-//}
-
-
 Foam::label Foam::blockMesh::numZonedBlocks() const
 {
     label num = 0;
diff --git a/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatch.C b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatch.C
index 8459f0ead5..609d24002e 100644
--- a/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatch.C
+++ b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatch.C
@@ -204,8 +204,7 @@ Foam::cyclicACMIPolyPatch::cyclicACMIPolyPatch
     const label start,
     const label index,
     const polyBoundaryMesh& bm,
-    const word& patchType,
-    const orderingType ordering
+    const word& patchType
 )
 :
     cyclicAMIPolyPatch
@@ -216,7 +215,6 @@ Foam::cyclicACMIPolyPatch::cyclicACMIPolyPatch
         index,
         bm,
         patchType,
-        ordering,
         false,
         AMIInterpolation::imPartialFaceAreaWeight
     ),
@@ -433,16 +431,16 @@ void Foam::cyclicACMIPolyPatch::calcGeometry
     const pointField& nbrCc
 )
 {
-    cyclicAMIPolyPatch::calcGeometry
-    (
-        referPatch,
-        thisCtrs,
-        thisAreas,
-        thisCc,
-        nbrCtrs,
-        nbrAreas,
-        nbrCc
-    );
+    static_cast<cyclicTransform&>(*this) =
+        cyclicTransform
+        (
+            name(),
+            thisAreas,
+            *this,
+            nbrPatchName(),
+            nbrPatch(),
+            matchTolerance()
+        );
 }
 
 
diff --git a/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatch.H b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatch.H
index 75b92c3054..aafd8fe40d 100644
--- a/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatch.H
+++ b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatch.H
@@ -109,8 +109,7 @@ public:
             const label start,
             const label index,
             const polyBoundaryMesh& bm,
-            const word& patchType,
-            const orderingType ordering = UNKNOWN
+            const word& patchType
         );
 
         //- Construct from dictionary
diff --git a/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
index e0b47f563e..98aeb2c256 100644
--- a/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
+++ b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
@@ -40,247 +40,6 @@ namespace Foam
 }
 
 
-// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
-
-Foam::vector Foam::cyclicAMIPolyPatch::findFaceNormalMaxRadius
-(
-    const pointField& faceCentres
-) const
-{
-    // Determine a face furthest away from the axis
-
-    const vectorField n((faceCentres - rotationCentre_) ^ rotationAxis_);
-
-    const scalarField magRadSqr(magSqr(n));
-
-    label facei = findMax(magRadSqr);
-
-    if (debug)
-    {
-        Info<< "findFaceMaxRadius(const pointField&) : patch: " << name() << nl
-            << "    rotFace  = " << facei << nl
-            << "    point    = " << faceCentres[facei] << nl
-            << "    distance = " << Foam::sqrt(magRadSqr[facei])
-            << endl;
-    }
-
-    return n[facei];
-}
-
-
-void Foam::cyclicAMIPolyPatch::calcTransforms
-(
-    const primitivePatch& thisPatch,
-    const pointField& thisPatchCtrs,
-    const vectorField& thisPatchAreas,
-    const pointField& nbrPatchCtrs,
-    const vectorField& nbrPatchAreas
-)
-{
-    if (transformType() != nbrPatch().transformType())
-    {
-        FatalErrorInFunction
-            << "Patch " << name()
-            << " has transform type " << transformTypeNames[transformType()]
-            << ", neighbour patch " << nbrPatchName()
-            << " has transform type "
-            << nbrPatch().transformTypeNames[nbrPatch().transformType()]
-            << exit(FatalError);
-    }
-
-
-    // Calculate transformation tensors
-
-    switch (transformType())
-    {
-        case ROTATIONAL:
-        {
-            tensor revT = Zero;
-
-            if (rotationAngleDefined_)
-            {
-                const tensor T(rotationAxis_*rotationAxis_);
-
-                const tensor S
-                (
-                    0, -rotationAxis_.z(), rotationAxis_.y(),
-                    rotationAxis_.z(), 0, -rotationAxis_.x(),
-                    -rotationAxis_.y(), rotationAxis_.x(), 0
-                );
-
-                const tensor revTPos
-                (
-                    T
-                  + cos(rotationAngle_)*(tensor::I - T)
-                  + sin(rotationAngle_)*S
-                );
-
-                const tensor revTNeg
-                (
-                    T
-                  + cos(-rotationAngle_)*(tensor::I - T)
-                  + sin(-rotationAngle_)*S
-                );
-
-                // Check - assume correct angle when difference in face areas
-                // is the smallest
-                const vector transformedAreaPos = gSum(nbrPatchAreas & revTPos);
-                const vector transformedAreaNeg = gSum(nbrPatchAreas & revTNeg);
-                const vector area0 = gSum(thisPatchAreas);
-                const scalar magArea0 = mag(area0) + rootVSmall;
-
-                // Areas have opposite sign, so sum should be zero when correct
-                // rotation applied
-                const scalar errorPos = mag(transformedAreaPos + area0);
-                const scalar errorNeg = mag(transformedAreaNeg + area0);
-
-                const scalar normErrorPos = errorPos/magArea0;
-                const scalar normErrorNeg = errorNeg/magArea0;
-
-                if (errorPos > errorNeg && normErrorNeg < matchTolerance())
-                {
-                    revT = revTNeg;
-                    rotationAngle_ *= -1;
-                }
-                else
-                {
-                    revT = revTPos;
-                }
-
-                const scalar areaError = min(normErrorPos, normErrorNeg);
-
-                if (areaError > matchTolerance())
-                {
-                    WarningInFunction
-                        << "Patch areas are not consistent within "
-                        << 100*matchTolerance()
-                        << " % indicating a possible error in the specified "
-                        << "angle of rotation" << nl
-                        << "    owner patch     : " << name() << nl
-                        << "    neighbour patch : " << nbrPatch().name()
-                        << nl
-                        << "    angle           : "
-                        << radToDeg(rotationAngle_) << " deg" << nl
-                        << "    area error      : " << 100*areaError << " %"
-                        << "    match tolerance : " <<  matchTolerance()
-                        << endl;
-                }
-
-                if (debug)
-                {
-                    scalar theta = radToDeg(rotationAngle_);
-
-                    Pout<< "cyclicAMIPolyPatch::calcTransforms: patch:"
-                        << name()
-                        << " Specified rotation:"
-                        << " swept angle: " << theta << " [deg]"
-                        << " reverse transform: " << revT
-                        << endl;
-                }
-            }
-            else
-            {
-                point n0 = Zero;
-                point n1 = Zero;
-                if (thisPatchCtrs.size())
-                {
-                    n0 = findFaceNormalMaxRadius(thisPatchCtrs);
-                }
-                if (nbrPatchCtrs.size())
-                {
-                    n1 = -findFaceNormalMaxRadius(nbrPatchCtrs);
-                }
-
-                reduce(n0, maxMagSqrOp<point>());
-                reduce(n1, maxMagSqrOp<point>());
-
-                n0 /= mag(n0) + vSmall;
-                n1 /= mag(n1) + vSmall;
-
-                // Extended tensor from two local coordinate systems calculated
-                // using normal and rotation axis
-                const tensor E0
-                (
-                    rotationAxis_,
-                    (n0 ^ rotationAxis_),
-                    n0
-                );
-                const tensor E1
-                (
-                    rotationAxis_,
-                    (-n1 ^ rotationAxis_),
-                    -n1
-                );
-                revT = E1.T() & E0;
-
-                if (debug)
-                {
-                    scalar theta = radToDeg(acos(-(n0 & n1)));
-
-                    Pout<< "cyclicAMIPolyPatch::calcTransforms: patch:"
-                        << name()
-                        << " Specified rotation:"
-                        << " n0:" << n0 << " n1:" << n1
-                        << " swept angle: " << theta << " [deg]"
-                        << " reverse transform: " << revT
-                        << endl;
-                }
-            }
-
-            separation_ = Zero;
-
-            if (mag(rotationCentre_) > small)
-            {
-                transform_ = transformer
-                (
-                    (I - revT.T()) & rotationCentre_,
-                    revT.T()
-                );
-            }
-            else
-            {
-                transform_ = transformer(revT.T());
-            }
-
-            break;
-        }
-        case TRANSLATIONAL:
-        {
-            if (debug)
-            {
-                Pout<< "cyclicAMIPolyPatch::calcTransforms : patch:" << name()
-                    << " Specified translation : " << separation_
-                    << endl;
-            }
-
-            transform_ = transformer(separation_);
-
-            break;
-        }
-        default:
-        {
-            if (debug)
-            {
-                Pout<< "patch:" << name()
-                    << " Assuming cyclic AMI pairs are colocated" << endl;
-            }
-
-            separation_ = Zero;
-
-            transform_ = transformer();
-
-            break;
-        }
-    }
-
-    if (debug)
-    {
-        Pout<< "patch: " << name() << nl
-            << "    transform = " << transform() << nl << endl;
-    }
-}
-
-
 // * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * * //
 
 void Foam::cyclicAMIPolyPatch::resetAMI() const
@@ -357,39 +116,6 @@ void Foam::cyclicAMIPolyPatch::resetAMI() const
 }
 
 
-void Foam::cyclicAMIPolyPatch::calcTransforms()
-{
-    const cyclicAMIPolyPatch& thisPatch = *this;
-    vectorField thisPatchAreas(thisPatch.size());
-    forAll(thisPatch, facei)
-    {
-        thisPatchAreas[facei] = thisPatch[facei].area(thisPatch.points());
-    }
-
-    const cyclicAMIPolyPatch& nbrPatch = this->nbrPatch();
-    vectorField nbrPatchAreas(nbrPatch.size());
-    forAll(nbrPatch, facei)
-    {
-        nbrPatchAreas[facei] = nbrPatch[facei].area(nbrPatch.points());
-    }
-
-    calcTransforms
-    (
-        thisPatch,
-        thisPatch.faceCentres(),
-        thisPatchAreas,
-        nbrPatch.faceCentres(),
-        nbrPatchAreas
-    );
-
-    if (debug)
-    {
-        Pout<< "calcTransforms() : patch: " << name() << nl
-            << "    transform = " << transform() << nl << endl;
-    }
-}
-
-
 void Foam::cyclicAMIPolyPatch::initGeometry(PstreamBuffers& pBufs)
 {
     // Clear the invalid AMIs and transforms
@@ -439,8 +165,6 @@ void Foam::cyclicAMIPolyPatch::movePoints
 )
 {
     polyPatch::movePoints(pBufs, p);
-
-    calcTransforms();
 }
 
 
@@ -480,18 +204,14 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
     const label index,
     const polyBoundaryMesh& bm,
     const word& patchType,
-    const orderingType ordering,
     const bool AMIRequireMatch,
     const AMIInterpolation::interpolationMethod AMIMethod
 )
 :
-    coupledPolyPatch(name, size, start, index, bm, patchType, ordering),
+    coupledPolyPatch(name, size, start, index, bm, patchType),
+    cyclicTransform(true),
     nbrPatchName_(word::null),
     nbrPatchID_(-1),
-    rotationAxis_(Zero),
-    rotationCentre_(point::zero),
-    rotationAngleDefined_(false),
-    rotationAngle_(0.0),
     AMIs_(),
     AMITransforms_(),
     AMIReverse_(false),
@@ -518,14 +238,10 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
 )
 :
     coupledPolyPatch(name, dict, index, bm, patchType),
-    cyclicTransform(dict),
+    cyclicTransform(dict, true),
     nbrPatchName_(dict.lookupOrDefault<word>("neighbourPatch", "")),
     coupleGroup_(dict),
     nbrPatchID_(-1),
-    rotationAxis_(Zero),
-    rotationCentre_(point::zero),
-    rotationAngleDefined_(false),
-    rotationAngle_(0.0),
     AMIs_(),
     AMITransforms_(),
     AMIReverse_(dict.lookupOrDefault<bool>("flipNormals", false)),
@@ -562,49 +278,6 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
             << exit(FatalIOError);
     }
 
-    switch (transformType())
-    {
-        case ROTATIONAL:
-        {
-            dict.lookup("rotationAxis") >> rotationAxis_;
-            dict.lookup("rotationCentre") >> rotationCentre_;
-            if (dict.readIfPresent("rotationAngle", rotationAngle_))
-            {
-                rotationAngleDefined_ = true;
-                rotationAngle_ = degToRad(rotationAngle_);
-
-                if (debug)
-                {
-                    Info<< "rotationAngle: " << rotationAngle_ << " [rad]"
-                        <<  endl;
-                }
-            }
-
-            scalar magRot = mag(rotationAxis_);
-            if (magRot < small)
-            {
-                FatalIOErrorInFunction
-                (
-                    dict
-                )   << "Illegal rotationAxis " << rotationAxis_ << endl
-                    << "Please supply a non-zero vector."
-                    << exit(FatalIOError);
-            }
-            rotationAxis_ /= magRot;
-
-            break;
-        }
-        case TRANSLATIONAL:
-        {
-            dict.lookup("separation") >> separation_;
-            break;
-        }
-        default:
-        {
-            // No additional info required
-        }
-    }
-
     // Neighbour patch might not be valid yet so no transformation
     // calculation possible
 }
@@ -617,13 +290,10 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
 )
 :
     coupledPolyPatch(pp, bm),
+    cyclicTransform(pp),
     nbrPatchName_(pp.nbrPatchName_),
     coupleGroup_(pp.coupleGroup_),
     nbrPatchID_(-1),
-    rotationAxis_(pp.rotationAxis_),
-    rotationCentre_(pp.rotationCentre_),
-    rotationAngleDefined_(pp.rotationAngleDefined_),
-    rotationAngle_(pp.rotationAngle_),
     AMIs_(),
     AMITransforms_(),
     AMIReverse_(pp.AMIReverse_),
@@ -653,10 +323,6 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
     nbrPatchName_(nbrPatchName),
     coupleGroup_(pp.coupleGroup_),
     nbrPatchID_(-1),
-    rotationAxis_(pp.rotationAxis_),
-    rotationCentre_(pp.rotationCentre_),
-    rotationAngleDefined_(pp.rotationAngleDefined_),
-    rotationAngle_(pp.rotationAngle_),
     AMIs_(),
     AMITransforms_(),
     AMIReverse_(pp.AMIReverse_),
@@ -693,10 +359,6 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
     nbrPatchName_(pp.nbrPatchName_),
     coupleGroup_(pp.coupleGroup_),
     nbrPatchID_(-1),
-    rotationAxis_(pp.rotationAxis_),
-    rotationCentre_(pp.rotationCentre_),
-    rotationAngleDefined_(pp.rotationAngleDefined_),
-    rotationAngle_(pp.rotationAngle_),
     AMIs_(),
     AMITransforms_(),
     AMIReverse_(pp.AMIReverse_),
@@ -924,14 +586,39 @@ void Foam::cyclicAMIPolyPatch::calcGeometry
     const pointField& nbrCc
 )
 {
-    calcTransforms
+    if
     (
-        referPatch,
-        thisCtrs,
-        thisAreas,
-        nbrCtrs,
-        nbrAreas
-    );
+        !Pstream::parRun()
+     && !this->boundaryMesh().mesh().time().processorCase()
+    )
+    {
+        static_cast<cyclicTransform&>(*this) =
+            cyclicTransform
+            (
+                name(),
+                thisCtrs,
+                thisAreas,
+                *this,
+                nbrPatchName(),
+                nbrCtrs,
+                nbrAreas,
+                nbrPatch(),
+                matchTolerance()
+            );
+    }
+    else
+    {
+        static_cast<cyclicTransform&>(*this) =
+            cyclicTransform
+            (
+                name(),
+                thisAreas,
+                *this,
+                nbrPatchName(),
+                nbrPatch(),
+                matchTolerance()
+            );
+    }
 }
 
 
@@ -1048,31 +735,6 @@ void Foam::cyclicAMIPolyPatch::write(Ostream& os) const
 
     cyclicTransform::write(os);
 
-    switch (transformType())
-    {
-        case ROTATIONAL:
-        {
-            writeEntry(os, "rotationAxis", rotationAxis_);
-            writeEntry(os, "rotationCentre", rotationCentre_);
-
-            if (rotationAngleDefined_)
-            {
-                writeEntry(os, "rotationAngle", radToDeg(rotationAngle_));
-            }
-
-            break;
-        }
-        case TRANSLATIONAL:
-        {
-            writeEntry(os, "separation", separation_);
-            break;
-        }
-        default:
-        {
-            // No additional info to write
-        }
-    }
-
     if (AMIReverse_)
     {
         writeEntry(os, "flipNormals", AMIReverse_);
diff --git a/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
index 79aae226b3..84ba7b9d13 100644
--- a/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
+++ b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
@@ -55,21 +55,6 @@ class cyclicAMIPolyPatch
     public coupledPolyPatch,
     public cyclicTransform
 {
-    // Private Member Functions
-
-        //- Return normal of face at max distance from rotation axis
-        vector findFaceNormalMaxRadius(const pointField& faceCentres) const;
-
-        void calcTransforms
-        (
-            const primitivePatch& thisPatch,
-            const pointField& thisPatchCtrs,
-            const vectorField& thisPatchAreas,
-            const pointField& neiPatchCtrs,
-            const vectorField& neiPatchAreas
-        );
-
-
 protected:
 
     // Protected data
@@ -83,27 +68,6 @@ protected:
         //- Index of cyclic neighbour patch
         mutable label nbrPatchID_;
 
-        // Specified transformation
-
-            // For translation
-
-                //- Offset vector from one side of the cyclic to the other
-                vector separation_;
-
-            // For rotation
-
-                //- Axis of rotation for rotational cyclics
-                vector rotationAxis_;
-
-                //- Point on axis of rotation for rotational cyclics
-                point rotationCentre_;
-
-                //- Flag to show whether the rotation angle is defined
-                bool rotationAngleDefined_;
-
-                //- Rotation angle
-                scalar rotationAngle_;
-
         //- AMI interpolation classes
         mutable PtrList<AMIInterpolation> AMIs_;
 
@@ -134,9 +98,6 @@ protected:
         //- Reset the AMI interpolator
         virtual void resetAMI() const;
 
-        //- Recalculate the transformation tensors
-        virtual void calcTransforms();
-
         //- Initialise the calculation of the patch geometry
         virtual void initGeometry(PstreamBuffers&);
 
@@ -176,7 +137,6 @@ public:
             const label index,
             const polyBoundaryMesh& bm,
             const word& patchType,
-            const orderingType ordering = UNKNOWN,
             const bool AMIRequireMatch = true,
             const AMIInterpolation::interpolationMethod AMIMethod =
                 AMIInterpolation::imFaceAreaWeight
@@ -329,12 +289,6 @@ public:
                 return cyclicTransform::transform();
             }
 
-            //- Axis of rotation for rotational cyclic AMI
-            inline const vector& rotationAxis() const;
-
-            //- Point on axis of rotation for rotational cyclic AMI
-            inline const point& rotationCentre() const;
-
 
         // Interpolations
 
diff --git a/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H
index 458dfb4b4a..c4f044463c 100644
--- a/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H
+++ b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H
@@ -38,16 +38,4 @@ inline const Foam::word& Foam::cyclicAMIPolyPatch::nbrPatchName() const
 }
 
 
-inline const Foam::vector& Foam::cyclicAMIPolyPatch::rotationAxis() const
-{
-    return rotationAxis_;
-}
-
-
-inline const Foam::point& Foam::cyclicAMIPolyPatch::rotationCentre() const
-{
-    return rotationCentre_;
-}
-
-
 // ************************************************************************* //
diff --git a/src/meshTools/AMIInterpolation/patches/cyclicRepeatAMI/cyclicRepeatAMIPolyPatch/cyclicRepeatAMIPolyPatch.C b/src/meshTools/AMIInterpolation/patches/cyclicRepeatAMI/cyclicRepeatAMIPolyPatch/cyclicRepeatAMIPolyPatch.C
index 6f975b2c67..91c513c0f5 100644
--- a/src/meshTools/AMIInterpolation/patches/cyclicRepeatAMI/cyclicRepeatAMIPolyPatch/cyclicRepeatAMIPolyPatch.C
+++ b/src/meshTools/AMIInterpolation/patches/cyclicRepeatAMI/cyclicRepeatAMIPolyPatch/cyclicRepeatAMIPolyPatch.C
@@ -294,8 +294,7 @@ Foam::cyclicRepeatAMIPolyPatch::cyclicRepeatAMIPolyPatch
     const label start,
     const label index,
     const polyBoundaryMesh& bm,
-    const word& patchType,
-    const orderingType ordering
+    const word& patchType
 )
 :
     cyclicAMIPolyPatch
@@ -306,7 +305,6 @@ Foam::cyclicRepeatAMIPolyPatch::cyclicRepeatAMIPolyPatch
         index,
         bm,
         patchType,
-        ordering,
         false,
         AMIInterpolation::imFaceAreaWeight
     ),
@@ -463,6 +461,30 @@ Foam::cyclicRepeatAMIPolyPatch::nbrWeightsSum() const
 }
 
 
+void Foam::cyclicRepeatAMIPolyPatch::calcGeometry
+(
+    const primitivePatch& referPatch,
+    const pointField& thisCtrs,
+    const vectorField& thisAreas,
+    const pointField& thisCc,
+    const pointField& nbrCtrs,
+    const vectorField& nbrAreas,
+    const pointField& nbrCc
+)
+{
+    static_cast<cyclicTransform&>(*this) =
+        cyclicTransform
+        (
+            name(),
+            thisAreas,
+            *this,
+            nbrPatchName(),
+            nbrPatch(),
+            matchTolerance()
+        );
+}
+
+
 void Foam::cyclicRepeatAMIPolyPatch::write(Ostream& os) const
 {
     cyclicAMIPolyPatch::write(os);
diff --git a/src/meshTools/AMIInterpolation/patches/cyclicRepeatAMI/cyclicRepeatAMIPolyPatch/cyclicRepeatAMIPolyPatch.H b/src/meshTools/AMIInterpolation/patches/cyclicRepeatAMI/cyclicRepeatAMIPolyPatch/cyclicRepeatAMIPolyPatch.H
index 46fb8c8e80..bb70e0b8f4 100644
--- a/src/meshTools/AMIInterpolation/patches/cyclicRepeatAMI/cyclicRepeatAMIPolyPatch/cyclicRepeatAMIPolyPatch.H
+++ b/src/meshTools/AMIInterpolation/patches/cyclicRepeatAMI/cyclicRepeatAMIPolyPatch/cyclicRepeatAMIPolyPatch.H
@@ -85,8 +85,7 @@ public:
             const label start,
             const label index,
             const polyBoundaryMesh& bm,
-            const word& patchType,
-            const orderingType ordering = UNKNOWN
+            const word& patchType
         );
 
         //- Construct from dictionary
@@ -210,6 +209,18 @@ public:
             virtual const scalarField& nbrWeightsSum() const;
 
 
+        //- Calculate the patch geometry
+        virtual void calcGeometry
+        (
+            const primitivePatch& referPatch,
+            const pointField& thisCtrs,
+            const vectorField& thisAreas,
+            const pointField& thisCc,
+            const pointField& nbrCtrs,
+            const vectorField& nbrAreas,
+            const pointField& nbrCc
+        );
+
         //- Write the polyPatch data as a dictionary
         virtual void write(Ostream&) const;
 };
diff --git a/tutorials/combustion/PDRFoam/flamePropagationWithObstacles/system/blockMeshDict b/tutorials/combustion/PDRFoam/flamePropagationWithObstacles/system/blockMeshDict
index 009d31f648..fc57c3e2b8 100644
--- a/tutorials/combustion/PDRFoam/flamePropagationWithObstacles/system/blockMeshDict
+++ b/tutorials/combustion/PDRFoam/flamePropagationWithObstacles/system/blockMeshDict
@@ -256,6 +256,7 @@ boundary
         type cyclic;
         neighbourPatch  baffleCyclic_half1;
         faces ();
+        transformType none;
     }
 
     baffleCyclic_half1
@@ -263,6 +264,7 @@ boundary
         type cyclic;
         neighbourPatch  baffleCyclic_half0;
         faces ();
+        transformType none;
     }
 );