diff --git a/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalMeshData.C b/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalMeshData.C
index 5790d951eb..fd39d1d0f8 100644
--- a/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalMeshData.C
+++ b/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalMeshData.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -30,7 +30,6 @@ License
 #include "processorPolyPatch.H"
 #include "demandDrivenData.H"
 #include "globalPoints.H"
-//#include "geomGlobalPoints.H"
 #include "polyMesh.H"
 #include "mapDistribute.H"
 #include "labelIOList.H"
@@ -38,6 +37,7 @@ License
 #include "mergePoints.H"
 #include "matchPoints.H"
 #include "OFstream.H"
+#include "globalIndexAndTransform.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -117,6 +117,126 @@ void Foam::globalMeshData::initProcAddr()
 }
 
 
+void Foam::globalMeshData::calcSharedPoints() const
+{
+    if
+    (
+        nGlobalPoints_ != -1
+     || sharedPointLabelsPtr_.valid()
+     || sharedPointAddrPtr_.valid()
+    )
+    {
+        FatalErrorIn("globalMeshData::calcSharedPoints()")
+            << "Shared point addressing already done" << abort(FatalError);
+    }
+
+    // Calculate all shared points (exclude points that are only
+    // on two coupled patches). This does all the hard work.
+    globalPoints parallelPoints(mesh_, false, true);
+
+    // Count the number of master points
+    label nMaster = 0;
+    forAll(parallelPoints.pointPoints(), i)
+    {
+        const labelList& pPoints = parallelPoints.pointPoints()[i];
+        const labelList& transPPoints =
+            parallelPoints.transformedPointPoints()[i];
+
+        if (pPoints.size()+transPPoints.size() > 0)
+        {
+            nMaster++;
+        }
+    }
+
+    // Allocate global numbers
+    globalIndex masterNumbering(nMaster);
+
+    nGlobalPoints_ = masterNumbering.size();
+
+
+    // Push master number to slaves
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // 1. Fill master and slave slots
+    nMaster = 0;
+    labelList master(parallelPoints.map().constructSize(), -1);
+    forAll(parallelPoints.pointPoints(), i)
+    {
+        const labelList& pPoints = parallelPoints.pointPoints()[i];
+        const labelList& transPPoints =
+            parallelPoints.transformedPointPoints()[i];
+
+        if (pPoints.size()+transPPoints.size() > 0)
+        {
+            master[i] = masterNumbering.toGlobal(nMaster);
+            forAll(pPoints, j)
+            {
+                master[pPoints[j]] = master[i];
+            }
+            forAll(transPPoints, j)
+            {
+                master[transPPoints[j]] = master[i];
+            }
+            nMaster++;
+        }
+    }
+
+
+    // 2. Push slave slots back to local storage on originating processor
+    // For all the four types of points:
+    // - local master : already set
+    // - local transformed slave point : the reverse transform at
+    //   reverseDistribute will have copied it back to its originating local
+    //   point
+    // - remote untransformed slave point : sent back to originating processor
+    // - remote transformed slave point : the reverse transform will
+    //   copy it back into the remote slot which then gets sent back to
+    //   originating processor
+
+    parallelPoints.map().reverseDistribute
+    (
+        parallelPoints.map().constructSize(),
+        master
+    );
+
+
+    // Collect all points that are a master or refer to a master.
+    nMaster = 0;
+    forAll(parallelPoints.pointPoints(), i)
+    {
+        if (master[i] != -1)
+        {
+            nMaster++;
+        }
+    }
+
+    sharedPointLabelsPtr_.reset(new labelList(nMaster));
+    labelList& sharedPointLabels = sharedPointLabelsPtr_();
+    sharedPointAddrPtr_.reset(new labelList(nMaster));
+    labelList& sharedPointAddr = sharedPointAddrPtr_();
+    nMaster = 0;
+
+    forAll(parallelPoints.pointPoints(), i)
+    {
+        if (master[i] != -1)
+        {
+            // I am master or slave
+            sharedPointLabels[nMaster] = i;
+            sharedPointAddr[nMaster] = master[i];
+            nMaster++;
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< "globalMeshData : nGlobalPoints_:" << nGlobalPoints_ << nl
+            << "globalMeshData : sharedPointLabels_:"
+            << sharedPointLabelsPtr_().size() << nl
+            << "globalMeshData : sharedPointAddr_:"
+            << sharedPointAddrPtr_().size() << endl;
+    }
+}
+
+
 // Given information about locally used edges allocate global shared edges.
 void Foam::globalMeshData::countSharedEdges
 (
@@ -166,7 +286,12 @@ void Foam::globalMeshData::countSharedEdges
 // clusters of shared points)
 void Foam::globalMeshData::calcSharedEdges() const
 {
-    if (nGlobalEdges_ != -1 || sharedEdgeLabelsPtr_ || sharedEdgeAddrPtr_)
+    if
+    (
+        nGlobalEdges_ != -1
+     || sharedEdgeLabelsPtr_.valid()
+     || sharedEdgeAddrPtr_.valid()
+    )
     {
         FatalErrorIn("globalMeshData::calcSharedEdges()")
             << "Shared edge addressing already done" << abort(FatalError);
@@ -370,12 +495,12 @@ void Foam::globalMeshData::calcSharedEdges() const
         }
     }
 
-    sharedEdgeLabelsPtr_ = new labelList();
-    labelList& sharedEdgeLabels = *sharedEdgeLabelsPtr_;
+    sharedEdgeLabelsPtr_.reset(new labelList());
+    labelList& sharedEdgeLabels = sharedEdgeLabelsPtr_();
     sharedEdgeLabels.transfer(dynSharedEdgeLabels);
 
-    sharedEdgeAddrPtr_ = new labelList();
-    labelList& sharedEdgeAddr = *sharedEdgeAddrPtr_;
+    sharedEdgeAddrPtr_.reset(new labelList());
+    labelList& sharedEdgeAddr = sharedEdgeAddrPtr_();
     sharedEdgeAddr.transfer(dynSharedEdgeAddr);
 
     if (debug)
@@ -389,220 +514,41 @@ void Foam::globalMeshData::calcSharedEdges() const
 }
 
 
-// Helper function to count coincident faces. This part used to be
-// in updateMesh but I've had to move it to a separate function
-// because of aliasing optimisation errors in icc9.1 on the
-// Itanium.
-Foam::label Foam::globalMeshData::countCoincidentFaces
-(
-    const scalar tolDim,
-    const vectorField& separationDist
-)
-{
-    label nCoincident = 0;
-
-    forAll(separationDist, faceI)
-    {
-        if (mag(separationDist[faceI]) < tolDim)
-        {
-            // Faces coincide
-            nCoincident++;
-        }
-    }
-    return nCoincident;
-}
-
-
-void Foam::globalMeshData::calcGlobalPointSlaves
-(
-    const globalPoints& globalData,
-    autoPtr<globalIndex>& globalIndicesPtr,
-    autoPtr<labelListList>& globalPointSlavesPtr,
-    autoPtr<mapDistribute>& globalPointSlavesMapPtr
-) const
-{
-    // Create global numbering for coupled points
-    globalIndicesPtr.reset
-    (
-        new globalIndex(globalData.globalIndices())
-    );
-    const globalIndex& globalIndices = globalIndicesPtr();
-
-    // Create master to slave addressing. Empty for slave points.
-    globalPointSlavesPtr.reset
-    (
-        new labelListList(coupledPatch().nPoints())
-    );
-    labelListList& globalPointSlaves = globalPointSlavesPtr();
-
-
-    const Map<label>& meshToProcPoint = globalData.meshToProcPoint();
-
-    forAllConstIter(Map<label>, meshToProcPoint, iter)
-    {
-        label localPointI = iter.key();
-        const labelList& pPoints = globalData.procPoints()[iter()];
-
-        // Am I master?
-        if
-        (
-            globalIndices.isLocal(pPoints[0])
-         && globalIndices.toLocal(pPoints[0]) == localPointI
-        )
-        {
-            labelList& slaves = globalPointSlaves[localPointI];
-            slaves.setSize(pPoints.size()-1);
-            for (label i = 1; i < pPoints.size(); i++)
-            {
-                slaves[i-1] = pPoints[i];
-            }
-        }
-    }
-
-    // Create schedule to get information from slaves onto master
-
-    // Construct compact numbering and distribution map.
-    // Changes globalPointSlaves to be indices into compact data
-
-    List<Map<label> > compactMap(Pstream::nProcs());
-    globalPointSlavesMapPtr.reset
-    (
-        new mapDistribute
-        (
-            globalIndices,
-            globalPointSlaves,
-            compactMap
-        )
-    );
-
-    if (debug)
-    {
-        Pout<< "globalMeshData::calcGlobalPointSlaves(..) :"
-            << " coupled points:" << coupledPatch().nPoints()
-            << " additional remote points:"
-            <<  globalPointSlavesMapPtr().constructSize()
-              - coupledPatch().nPoints()
-            << endl;
-    }
-}
-
-
 void Foam::globalMeshData::calcGlobalPointSlaves() const
 {
     if (debug)
     {
         Pout<< "globalMeshData::calcGlobalPointSlaves() :"
-            << " calculating coupled master to collocated"
-            << " slave point addressing."
+            << " calculating coupled master to slave point addressing."
             << endl;
     }
 
-    // Calculate collocated connected points for master points.
-    globalPoints collocatedGlobalData(mesh_, coupledPatch(), true, false);
+    // Calculate connected points for master points.
+    globalPoints globalData(mesh_, coupledPatch(), true, true);
+    globalPointNumberingPtr_.reset(new globalIndex(globalData.globalIndices()));
 
-    calcGlobalPointSlaves
+    globalPointSlavesPtr_.reset
     (
-        collocatedGlobalData,
-        globalPointNumberingPtr_,
-        globalPointSlavesPtr_,
-        globalPointSlavesMapPtr_
-    );
-}
-
-
-void Foam::globalMeshData::calcGlobalEdgeSlaves
-(
-    const labelListList& pointSlaves,
-    const mapDistribute& pointSlavesMap,
-    const globalIndex& globalEdgeIndices,
-    autoPtr<labelListList>& globalEdgeSlavesPtr,
-    autoPtr<mapDistribute>& globalEdgeSlavesMapPtr
-) const
-{
-    // Coupled point to global coupled edges.
-    labelListList globalPointEdges(pointSlavesMap.constructSize());
-
-    // Create local version
-    const labelListList& pointEdges = coupledPatch().pointEdges();
-    forAll(pointEdges, pointI)
-    {
-        const labelList& pEdges = pointEdges[pointI];
-        labelList& globalPEdges = globalPointEdges[pointI];
-        globalPEdges.setSize(pEdges.size());
-        forAll(pEdges, i)
-        {
-            globalPEdges[i] = globalEdgeIndices.toGlobal(pEdges[i]);
-        }
-    }
-
-    // Pull slave data to master
-    pointSlavesMap.distribute(globalPointEdges);
-
-    // Now check on master if any of my edges are also on slave.
-    // This assumes that if slaves have a coupled edge it is also on
-    // the master (otherwise the mesh would be illegal anyway)
-
-    labelHashSet pointEdgeSet;
-
-    const edgeList& edges = coupledPatch().edges();
-
-    // Create master to slave addressing. Empty for slave edges.
-    globalEdgeSlavesPtr.reset(new labelListList(edges.size()));
-    labelListList& globalEdgeSlaves = globalEdgeSlavesPtr();
-
-    forAll(edges, edgeI)
-    {
-        const edge& e = edges[edgeI];
-        const labelList& slaves0 = pointSlaves[e[0]];
-        const labelList& slaves1 = pointSlaves[e[1]];
-
-        // Check for edges that are in both slaves0 and slaves1.
-        pointEdgeSet.clear();
-        forAll(slaves0, i)
-        {
-            const labelList& connectedEdges = globalPointEdges[slaves0[i]];
-            pointEdgeSet.insert(connectedEdges);
-        }
-        forAll(slaves1, i)
-        {
-            const labelList& connectedEdges = globalPointEdges[slaves1[i]];
-
-            forAll(connectedEdges, j)
-            {
-                label globalEdgeI = connectedEdges[j];
-
-                if (pointEdgeSet.found(globalEdgeI))
-                {
-                    // Found slave edge.
-                    label sz = globalEdgeSlaves[edgeI].size();
-                    globalEdgeSlaves[edgeI].setSize(sz+1);
-                    globalEdgeSlaves[edgeI][sz] = globalEdgeI;
-                }
-            }
-        }
-    }
-
-
-    // Construct map
-    List<Map<label> > compactMap(Pstream::nProcs());
-    globalEdgeSlavesMapPtr.reset
-    (
-        new mapDistribute
+        new labelListList
         (
-            globalEdgeIndices,
-            globalEdgeSlaves,
-            compactMap
+            globalData.pointPoints().xfer()
+        )
+    );
+    globalPointTransformedSlavesPtr_.reset
+    (
+        new labelListList
+        (
+            globalData.transformedPointPoints().xfer()
         )
     );
 
-    if (debug)
-    {
-        Pout<< "globalMeshData::calcGlobalEdgeSlaves() :"
-            << " coupled edge:" << edges.size()
-            << " additional remote edges:"
-            << globalEdgeSlavesMapPtr().constructSize() - edges.size()
-            << endl;
-    }
+    globalPointSlavesMapPtr_.reset
+    (
+        new mapDistribute
+        (
+            globalData.map().xfer()
+        )
+    );
 }
 
 
@@ -611,58 +557,175 @@ void Foam::globalMeshData::calcGlobalEdgeSlaves() const
     if (debug)
     {
         Pout<< "globalMeshData::calcGlobalEdgeSlaves() :"
-            << " calculating coupled master to collocated slave"
-            << " edge addressing." << endl;
+            << " calculating coupled master to slave edge addressing." << endl;
     }
 
     // - Send across connected edges (in global edge addressing)
     // - Check on receiving side whether edge has same slave edge
     //   on both endpoints.
 
-    // Create global numbering for coupled edges
-    const globalIndex& globalIndices = globalEdgeNumbering();
 
-    calcGlobalEdgeSlaves
-    (
-        globalPointSlaves(),
-        globalPointSlavesMap(),
-        globalIndices,
-        globalEdgeSlavesPtr_,
-        globalEdgeSlavesMapPtr_
-    );
-}
+    // Coupled point to global coupled edges.
+    labelListList globalPointEdges(globalPointSlavesMap().constructSize());
 
-
-// Calculate uncoupled boundary faces (without calculating
-// primitiveMesh::pointFaces())
-void Foam::globalMeshData::calcPointBoundaryFaces
-(
-    labelListList& pointBoundaryFaces
-) const
-{
-    const polyBoundaryMesh& bMesh = mesh_.boundaryMesh();
-    const Map<label>& meshPointMap = coupledPatch().meshPointMap();
-
-    // 1. Count
-
-    labelList nPointFaces(coupledPatch().nPoints(), 0);
-
-    forAll(bMesh, patchI)
+    // Create local version
+    const labelListList& pointEdges = coupledPatch().pointEdges();
+    const globalIndex& globalEdgeNumbers = globalEdgeNumbering();
+    forAll(pointEdges, pointI)
     {
-        const polyPatch& pp = bMesh[patchI];
-
-        if (!pp.coupled())
+        const labelList& pEdges = pointEdges[pointI];
+        labelList& globalPEdges = globalPointEdges[pointI];
+        globalPEdges.setSize(pEdges.size());
+        forAll(pEdges, i)
         {
-            forAll(pp, i)
-            {
-                const face& f = pp[i];
+            globalPEdges[i] = globalEdgeNumbers.toGlobal(pEdges[i]);
+        }
+    }
 
-                forAll(f, fp)
+    // Pull slave data to master. Dummy transform.
+    globalPointSlavesMap().distribute(globalPointEdges);
+
+
+    // Now check on master if any of my edges are also on slave.
+    // This assumes that if slaves have a coupled edge it is also on
+    // the master (otherwise the mesh would be illegal anyway)
+
+    // From global edge to slot in distributed data.
+    Map<label> pointEdgeSet;
+
+    const edgeList& edges = coupledPatch().edges();
+    const labelListList& slaves = globalPointSlaves();
+    const labelListList& transformedSlaves = globalPointTransformedSlaves();
+
+    // Create master to slave addressing. Empty for slave edges.
+    // - labelListList to store untransformed elements
+    // - List<labelPair> to store transformed elements
+    globalEdgeSlavesPtr_.reset(new labelListList(edges.size()));
+    labelListList& globalEdgeSlaves = globalEdgeSlavesPtr_();
+    List<labelPairList> transformedEdges(edges.size());
+
+    forAll(edges, edgeI)
+    {
+        const edge& e = edges[edgeI];
+
+        // For this edge check get the pointEdges of the connected points
+        // Any edge in both pointEdges must be connected to this edge.
+
+        // Untransformed
+        // ~~~~~~~~~~~~~
+        {
+            const labelList& slaves0 = slaves[e[0]];
+            const labelList& slaves1 = slaves[e[1]];
+
+            // Check for edges that are in both slaves0 and slaves1.
+            pointEdgeSet.clear();
+            forAll(slaves0, i)
+            {
+                const labelList& connectedEdges = globalPointEdges[slaves0[i]];
+                // Store edges (data on Map not used)
+                forAll(connectedEdges, j)
                 {
-                    Map<label>::const_iterator iter = meshPointMap.find(f[fp]);
-                    if (iter != meshPointMap.end())
+                    pointEdgeSet.insert(connectedEdges[j], slaves0[i]);
+                }
+            }
+            forAll(slaves1, i)
+            {
+                const labelList& connectedEdges = globalPointEdges[slaves1[i]];
+                forAll(connectedEdges, j)
+                {
+                    label globalEdgeI = connectedEdges[j];
+
+                    if (pointEdgeSet.found(globalEdgeI))
                     {
-                        nPointFaces[iter()]++;
+                        // Found slave edge.
+                        label sz = globalEdgeSlaves[edgeI].size();
+                        globalEdgeSlaves[edgeI].setSize(sz+1);
+                        globalEdgeSlaves[edgeI][sz] = globalEdgeI;
+                    }
+                }
+            }
+        }
+
+
+        // Transformed
+        // ~~~~~~~~~~~
+        {
+            // We look at the slots which hold transformed points
+            // So now when we find the edge we can look at which slot
+            // it came from and work out the transform
+
+            const labelList& slaves0 = transformedSlaves[e[0]];
+            const labelList& slaves1 = transformedSlaves[e[1]];
+
+            // Check for edges that are in both slaves0 and slaves1 (and get
+            // to master through the same transform?)
+
+            pointEdgeSet.clear();
+            forAll(slaves0, i)
+            {
+                const labelList& connected = globalPointEdges[slaves0[i]];
+                forAll(connected, j)
+                {
+                    pointEdgeSet.insert(connected[j], slaves0[i]);
+                }
+            }
+            forAll(slaves1, i)
+            {
+                const labelList& connected = globalPointEdges[slaves1[i]];
+                forAll(connected, j)
+                {
+                    label globalEdgeI = connected[j];
+
+                    Map<label>::const_iterator iter = pointEdgeSet.find
+                    (
+                        globalEdgeI
+                    );
+                    if (iter != pointEdgeSet.end())
+                    {
+                        // Found slave edge. Compare both transforms.
+                        // Get the transform by looking at where the point
+                        // slots came from.
+                        label transform0 = findLower
+                        (
+                            globalPointSlavesMap().transformStart(),
+                            iter()+1
+                        );
+                        label transform1 = findLower
+                        (
+                            globalPointSlavesMap().transformStart(),
+                            slaves1[i]+1
+                        );
+                        label mergedTransform =
+                            globalIndexAndTransform::minimumTransformIndex
+                            (
+                                transform0,
+                                transform1
+                            );
+
+                        // Reencode originating edge index and processor
+                        // with new transform.
+                        label procI = globalEdgeNumbers.whichProcID
+                        (
+                            globalEdgeI
+                        );
+
+                        labelPair edgeInfo
+                        (
+                            globalIndexAndTransform::encode
+                            (
+                                procI,
+                                globalEdgeNumbers.toLocal
+                                (
+                                    procI,
+                                    globalEdgeI
+                                ),
+                                mergedTransform
+                            )
+                        );
+
+                        label sz = transformedEdges[edgeI].size();
+                        transformedEdges[edgeI].setSize(sz+1);
+                        transformedEdges[edgeI][sz] = edgeInfo;
                     }
                 }
             }
@@ -670,381 +733,429 @@ void Foam::globalMeshData::calcPointBoundaryFaces
     }
 
 
-    // 2. Size
+    // Construct map
+    globalEdgeTransformedSlavesPtr_.reset(new labelListList());
 
-    pointBoundaryFaces.setSize(coupledPatch().nPoints());
-    forAll(nPointFaces, pointI)
-    {
-        pointBoundaryFaces[pointI].setSize(nPointFaces[pointI]);
-    }
-    nPointFaces = 0;
-
-
-    // 3. Fill
-
-    forAll(bMesh, patchI)
-    {
-        const polyPatch& pp = bMesh[patchI];
-
-        if (!pp.coupled())
-        {
-            forAll(pp, i)
-            {
-                const face& f = pp[i];
-                forAll(f, fp)
-                {
-                    Map<label>::const_iterator iter = meshPointMap.find(f[fp]);
-                    if (iter != meshPointMap.end())
-                    {
-                        label bFaceI = pp.start() + i - mesh_.nInternalFaces();
-                        pointBoundaryFaces[iter()][nPointFaces[iter()]++] =
-                            bFaceI;
-                    }
-                }
-            }
-        }
-    }
-}
-
-
-void Foam::globalMeshData::calcGlobalPointBoundaryFaces() const
-{
-    if (debug)
-    {
-        Pout<< "globalMeshData::calcGlobalPointBoundaryFaces() :"
-            << " calculating coupled point to boundary face addressing."
-            << endl;
-    }
-
-    // Construct local point to (uncoupled)boundaryfaces.
-    labelListList pointBoundaryFaces;
-    calcPointBoundaryFaces(pointBoundaryFaces);
-
-
-    // Global indices for boundary faces
-    globalBoundaryFaceNumberingPtr_.reset
-    (
-        new globalIndex(mesh_.nFaces()-mesh_.nInternalFaces())
-    );
-    globalIndex& globalIndices = globalBoundaryFaceNumberingPtr_();
-
-
-    // Convert local boundary faces to global numbering
-    globalPointBoundaryFacesPtr_.reset
-    (
-        new labelListList(globalPointSlavesMap().constructSize())
-    );
-    labelListList& globalPointBoundaryFaces = globalPointBoundaryFacesPtr_();
-
-    forAll(pointBoundaryFaces, pointI)
-    {
-        const labelList& bFaces = pointBoundaryFaces[pointI];
-        labelList& globalFaces = globalPointBoundaryFaces[pointI];
-        globalFaces.setSize(bFaces.size());
-        forAll(bFaces, i)
-        {
-            globalFaces[i] = globalIndices.toGlobal(bFaces[i]);
-        }
-    }
-
-
-    // Pull slave pointBoundaryFaces to master
-    globalPointSlavesMap().distribute(globalPointBoundaryFaces);
-
-
-    // Merge slave labels into master globalPointBoundaryFaces
-    const labelListList& pointSlaves = globalPointSlaves();
-
-    forAll(pointSlaves, pointI)
-    {
-        const labelList& slaves = pointSlaves[pointI];
-
-        if (slaves.size() > 0)
-        {
-            labelList& myBFaces = globalPointBoundaryFaces[pointI];
-
-            forAll(slaves, i)
-            {
-                const labelList& slaveBFaces =
-                    globalPointBoundaryFaces[slaves[i]];
-
-                // Add all slaveBFaces. Note that need to check for
-                // uniqueness only in case of cyclics.
-
-                label sz = myBFaces.size();
-                myBFaces.setSize(sz+slaveBFaces.size());
-                forAll(slaveBFaces, j)
-                {
-                    label slave = slaveBFaces[j];
-                    if (findIndex(SubList<label>(myBFaces, sz), slave) == -1)
-                    {
-                        myBFaces[sz++] = slave;
-                    }
-                }
-                myBFaces.setSize(sz);
-            }
-        }
-    }
-
-
-    // Copy merged boundaryFaces back from master into slave slot
-    forAll(pointSlaves, pointI)
-    {
-        const labelList& bFaces = globalPointBoundaryFaces[pointI];
-        const labelList& slaves = pointSlaves[pointI];
-
-        forAll(slaves, i)
-        {
-            globalPointBoundaryFaces[slaves[i]] = bFaces;
-        }
-    }
-
-
-    // Sync back to slaves.
-    globalPointSlavesMap().reverseDistribute
-    (
-        coupledPatch().nPoints(),
-        globalPointBoundaryFaces
-    );
-
-
-    // Construct a map to get the face data directly
     List<Map<label> > compactMap(Pstream::nProcs());
-    globalPointBoundaryFacesMapPtr_.reset
+    globalEdgeSlavesMapPtr_.reset
     (
         new mapDistribute
         (
-            globalIndices,
-            globalPointBoundaryFaces,
+            globalEdgeNumbers,
+            globalEdgeSlaves,
+
+            globalTransforms(),
+            transformedEdges,
+            globalEdgeTransformedSlavesPtr_(),
+
             compactMap
         )
     );
 
+
     if (debug)
     {
-        Pout<< "globalMeshData::calcGlobalPointBoundaryFaces() :"
-            << " coupled points:" << coupledPatch().nPoints()
-            << " local boundary faces:" <<  globalIndices.localSize()
-            << " additional remote faces:"
-            <<  globalPointBoundaryFacesMapPtr_().constructSize()
-              - globalIndices.localSize()
+        Pout<< "globalMeshData::calcGlobalEdgeSlaves() :"
+            << " coupled edges:" << edges.size()
+            << " additional coupled edges:"
+            << globalEdgeSlavesMapPtr_().constructSize() - edges.size()
             << endl;
     }
 }
 
 
-void Foam::globalMeshData::calcGlobalPointBoundaryCells() const
-{
-    if (debug)
-    {
-        Pout<< "globalMeshData::calcGlobalPointBoundaryCells() :"
-            << " calculating coupled point to boundary cell addressing."
-            << endl;
-    }
-
-    // Create map of boundary cells and point-cell addressing
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    label bCellI = 0;
-    Map<label> meshCellMap(4*coupledPatch().nPoints());
-    DynamicList<label> cellMap(meshCellMap.size());
-
-    // Create addressing for point to boundary cells (local)
-    labelListList pointBoundaryCells(coupledPatch().nPoints());
-
-    forAll(coupledPatch().meshPoints(), pointI)
-    {
-        label meshPointI = coupledPatch().meshPoints()[pointI];
-        const labelList& pCells = mesh_.pointCells(meshPointI);
-
-        labelList& bCells = pointBoundaryCells[pointI];
-        bCells.setSize(pCells.size());
-
-        forAll(pCells, i)
-        {
-            label cellI = pCells[i];
-            Map<label>::iterator fnd = meshCellMap.find(cellI);
-
-            if (fnd != meshCellMap.end())
-            {
-                bCells[i] = fnd();
-            }
-            else
-            {
-                meshCellMap.insert(cellI, bCellI);
-                cellMap.append(cellI);
-                bCells[i] = bCellI;
-                bCellI++;
-            }
-        }
-    }
+//// Calculate uncoupled boundary faces (without calculating
+//// primitiveMesh::pointFaces())
+//void Foam::globalMeshData::calcPointBoundaryFaces
+//(
+//    labelListList& pointBoundaryFaces
+//) const
+//{
+//    const polyBoundaryMesh& bMesh = mesh_.boundaryMesh();
+//    const Map<label>& meshPointMap = coupledPatch().meshPointMap();
+//
+//    // 1. Count
+//
+//    labelList nPointFaces(coupledPatch().nPoints(), 0);
+//
+//    forAll(bMesh, patchI)
+//    {
+//        const polyPatch& pp = bMesh[patchI];
+//
+//        if (!pp.coupled())
+//        {
+//            forAll(pp, i)
+//            {
+//                const face& f = pp[i];
+//
+//                forAll(f, fp)
+//                {
+//                    Map<label>::const_iterator iter = meshPointMap.find
+//                    (
+//                        f[fp]
+//                    );
+//                    if (iter != meshPointMap.end())
+//                    {
+//                        nPointFaces[iter()]++;
+//                    }
+//                }
+//            }
+//        }
+//    }
+//
+//
+//    // 2. Size
+//
+//    pointBoundaryFaces.setSize(coupledPatch().nPoints());
+//    forAll(nPointFaces, pointI)
+//    {
+//        pointBoundaryFaces[pointI].setSize(nPointFaces[pointI]);
+//    }
+//    nPointFaces = 0;
+//
+//
+//    // 3. Fill
+//
+//    forAll(bMesh, patchI)
+//    {
+//        const polyPatch& pp = bMesh[patchI];
+//
+//        if (!pp.coupled())
+//        {
+//            forAll(pp, i)
+//            {
+//                const face& f = pp[i];
+//                forAll(f, fp)
+//                {
+//                    Map<label>::const_iterator iter = meshPointMap.find
+//                    (
+//                        f[fp]
+//                    );
+//                    if (iter != meshPointMap.end())
+//                    {
+//                        label bFaceI =
+//                             pp.start() + i - mesh_.nInternalFaces();
+//                        pointBoundaryFaces[iter()][nPointFaces[iter()]++] =
+//                            bFaceI;
+//                    }
+//                }
+//            }
+//        }
+//    }
+//}
+//
+//
+//void Foam::globalMeshData::calcGlobalPointBoundaryFaces() const
+//{
+//    if (debug)
+//    {
+//        Pout<< "globalMeshData::calcGlobalPointBoundaryFaces() :"
+//            << " calculating coupled point to boundary face addressing."
+//            << endl;
+//    }
+//
+//    // Construct local point to (uncoupled)boundaryfaces.
+//    labelListList pointBoundaryFaces;
+//    calcPointBoundaryFaces(pointBoundaryFaces);
+//
+//
+//    // Global indices for boundary faces
+//    globalBoundaryFaceNumberingPtr_.reset
+//    (
+//        new globalIndex(mesh_.nFaces()-mesh_.nInternalFaces())
+//    );
+//    globalIndex& globalIndices = globalBoundaryFaceNumberingPtr_();
+//
+//
+//    // Convert local boundary faces to global numbering
+//    globalPointBoundaryFacesPtr_.reset
+//    (
+//        new labelListList(globalPointSlavesMap().constructSize())
+//    );
+//    labelListList& globalPointBoundaryFaces = globalPointBoundaryFacesPtr_();
+//
+//    forAll(pointBoundaryFaces, pointI)
+//    {
+//        const labelList& bFaces = pointBoundaryFaces[pointI];
+//        labelList& globalFaces = globalPointBoundaryFaces[pointI];
+//        globalFaces.setSize(bFaces.size());
+//        forAll(bFaces, i)
+//        {
+//            globalFaces[i] = globalIndices.toGlobal(bFaces[i]);
+//        }
+//    }
+//
+//
+//    // Pull slave pointBoundaryFaces to master
+//    globalPointSlavesMap().distribute
+//    (
+//        globalTransforms(),
+//        globalPointBoundaryFaces
+//    );
+//
+//
+//    // Merge slave labels into master globalPointBoundaryFaces.
+//    // Split into untransformed and transformed values.
+//    const labelListList& pointSlaves = globalPointSlaves();
+//    const labelListList& pointTransformSlaves =
+//        globalPointTransformedSlaves();
+//
+//
+//    List<labelPairList> transformedFaces;
+//
+//
+//    forAll(pointSlaves, pointI)
+//    {
+//        const labelList& slaves = pointSlaves[pointI];
+//
+//        if (slaves.size() > 0)
+//        {
+//            labelList& myBFaces = globalPointBoundaryFaces[pointI];
+//
+//            forAll(slaves, i)
+//            {
+//                const labelList& slaveBFaces =
+//                    globalPointBoundaryFaces[slaves[i]];
+//
+//                // Add all slaveBFaces. Note that need to check for
+//                // uniqueness only in case of cyclics.
+//
+//                label sz = myBFaces.size();
+//                myBFaces.setSize(sz+slaveBFaces.size());
+//                forAll(slaveBFaces, j)
+//                {
+//                    label slave = slaveBFaces[j];
+//                    if (findIndex(SubList<label>(myBFaces, sz), slave) == -1)
+//                    {
+//                        myBFaces[sz++] = slave;
+//                    }
+//                }
+//                myBFaces.setSize(sz);
+//            }
+//        }
+//    }
+//
+//
+//    // Copy merged boundaryFaces back from master into slave slot
+//    forAll(pointSlaves, pointI)
+//    {
+//        const labelList& bFaces = globalPointBoundaryFaces[pointI];
+//        const labelList& slaves = pointSlaves[pointI];
+//
+//        forAll(slaves, i)
+//        {
+//            globalPointBoundaryFaces[slaves[i]] = bFaces;
+//        }
+//    }
+//
+//
+//    // Sync back to slaves.
+//    globalPointSlavesMap().reverseDistribute
+//    (
+//        coupledPatch().nPoints(),
+//        globalPointBoundaryFaces
+//    );
+//
+//
+//    // Construct a map to get the face data directly
+//    List<Map<label> > compactMap(Pstream::nProcs());
+//
+//    globalPointTransformedBoundaryFacesPtr_.reset
+//    (
+//        new labelList(transformedFaces.size())
+//    );
+//
+//    globalPointBoundaryFacesMapPtr_.reset
+//    (
+//        new mapDistribute
+//        (
+//            globalIndices,
+//            globalPointBoundaryFaces,
+//
+//            globalTransforms(),
+//            transformedFaces,
+//            globalPointTransformedBoundaryFacesPtr_,
+//
+//            compactMap
+//        )
+//    );
+//
+//    if (debug)
+//    {
+//        Pout<< "globalMeshData::calcGlobalPointBoundaryFaces() :"
+//            << " coupled points:" << coupledPatch().nPoints()
+//            << " local boundary faces:" <<  globalIndices.localSize()
+//            << " additional coupled faces:"
+//            <<  globalPointBoundaryFacesMapPtr_().constructSize()
+//              - globalIndices.localSize()
+//            << endl;
+//    }
+//}
 
 
-    boundaryCellsPtr_.reset(new labelList());
-    labelList& boundaryCells = boundaryCellsPtr_();
-    boundaryCells.transfer(cellMap.shrink());
-
-
-    // Convert point-cells to global point numbers
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    globalBoundaryCellNumberingPtr_.reset
-    (
-        new globalIndex(boundaryCells.size())
-    );
-    globalIndex& globalIndices = globalBoundaryCellNumberingPtr_();
-
-
-    globalPointBoundaryCellsPtr_.reset
-    (
-        new labelListList(globalPointSlavesMap().constructSize())
-    );
-    labelListList& globalPointBoundaryCells = globalPointBoundaryCellsPtr_();
-
-    forAll(pointBoundaryCells, pointI)
-    {
-        const labelList& pCells = pointBoundaryCells[pointI];
-        labelList& globalCells = globalPointBoundaryCells[pointI];
-        globalCells.setSize(pCells.size());
-        forAll(pCells, i)
-        {
-            globalCells[i] = globalIndices.toGlobal(pCells[i]);
-        }
-    }
-
-
-    // Pull slave pointBoundaryCells to master
-    globalPointSlavesMap().distribute(globalPointBoundaryCells);
-
-
-    // Merge slave labels into master globalPointBoundaryCells
-    const labelListList& pointSlaves = globalPointSlaves();
-
-    forAll(pointSlaves, pointI)
-    {
-        const labelList& slaves = pointSlaves[pointI];
-
-        if (slaves.size() > 0)
-        {
-            labelList& myBCells = globalPointBoundaryCells[pointI];
-
-            forAll(slaves, i)
-            {
-                const labelList& slaveBCells =
-                    globalPointBoundaryCells[slaves[i]];
-
-                // Add all slaveBCells. Note that need to check for
-                // uniqueness only in case of cyclics.
-
-                label sz = myBCells.size();
-                myBCells.setSize(sz+slaveBCells.size());
-                forAll(slaveBCells, j)
-                {
-                    label slave = slaveBCells[j];
-                    if (findIndex(SubList<label>(myBCells, sz), slave) == -1)
-                    {
-                        myBCells[sz++] = slave;
-                    }
-                }
-                myBCells.setSize(sz);
-            }
-        }
-    }
-
-
-    // Copy merged boundaryCells back from master into slave slot
-    forAll(pointSlaves, pointI)
-    {
-        const labelList& bCells = globalPointBoundaryCells[pointI];
-        const labelList& slaves = pointSlaves[pointI];
-
-        forAll(slaves, i)
-        {
-            globalPointBoundaryCells[slaves[i]] = bCells;
-        }
-    }
-
-
-    // Sync back to slaves.
-    globalPointSlavesMap().reverseDistribute
-    (
-        coupledPatch().nPoints(),
-        globalPointBoundaryCells
-    );
-
-
-    // Construct a map to get the cell data directly
-    List<Map<label> > compactMap(Pstream::nProcs());
-    globalPointBoundaryCellsMapPtr_.reset
-    (
-        new mapDistribute
-        (
-            globalIndices,
-            globalPointBoundaryCells,
-            compactMap
-        )
-    );
-
-    if (debug)
-    {
-        Pout<< "globalMeshData::calcGlobalPointBoundaryCells() :"
-            << " coupled points:" << coupledPatch().nPoints()
-            << " local boundary cells:" <<  globalIndices.localSize()
-            << " additional remote cells:"
-            <<  globalPointBoundaryCellsMapPtr_().constructSize()
-              - globalIndices.localSize()
-            << endl;
-    }
-}
-
-
-void Foam::globalMeshData::calcGlobalPointAllSlaves() const
-{
-    if (debug)
-    {
-        Pout<< "globalMeshData::calcGlobalPointAllSlaves() :"
-            << " calculating coupled master to slave point addressing."
-            << endl;
-    }
-
-    // Calculate collocated&non-collocated connected points for master points.
-    globalPoints allGlobalData(mesh_, coupledPatch(), true, true);
-
-    calcGlobalPointSlaves
-    (
-        allGlobalData,
-        globalPointAllNumberingPtr_,
-        globalPointAllSlavesPtr_,
-        globalPointAllSlavesMapPtr_
-    );
-}
-
-
-void Foam::globalMeshData::calcGlobalEdgeAllSlaves() const
-{
-    if (debug)
-    {
-        Pout<< "globalMeshData::calcGlobalEdgeAllSlaves() :"
-            << " calculating coupled master to slave edge addressing."
-            << endl;
-    }
-
-    // - Send across connected edges (in global edge addressing)
-    // - Check on receiving side whether edge has same slave edge
-    //   on both endpoints.
-
-    // Create global numbering for coupled edges
-    const globalIndex& globalIndices = globalEdgeNumbering();
-
-    calcGlobalEdgeSlaves
-    (
-        globalPointAllSlaves(),
-        globalPointAllSlavesMap(),
-        globalIndices,
-        globalEdgeAllSlavesPtr_,
-        globalEdgeAllSlavesMapPtr_
-    );
-}
+//void Foam::globalMeshData::calcGlobalPointBoundaryCells() const
+//{
+//    if (debug)
+//    {
+//        Pout<< "globalMeshData::calcGlobalPointBoundaryCells() :"
+//            << " calculating coupled point to boundary cell addressing."
+//            << endl;
+//    }
+//
+//    // Create map of boundary cells and point-cell addressing
+//    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+//    label bCellI = 0;
+//    Map<label> meshCellMap(4*coupledPatch().nPoints());
+//    DynamicList<label> cellMap(meshCellMap.size());
+//
+//    // Create addressing for point to boundary cells (local)
+//    labelListList pointBoundaryCells(coupledPatch().nPoints());
+//
+//    forAll(coupledPatch().meshPoints(), pointI)
+//    {
+//        label meshPointI = coupledPatch().meshPoints()[pointI];
+//        const labelList& pCells = mesh_.pointCells(meshPointI);
+//
+//        labelList& bCells = pointBoundaryCells[pointI];
+//        bCells.setSize(pCells.size());
+//
+//        forAll(pCells, i)
+//        {
+//            label cellI = pCells[i];
+//            Map<label>::iterator fnd = meshCellMap.find(cellI);
+//
+//            if (fnd != meshCellMap.end())
+//            {
+//                bCells[i] = fnd();
+//            }
+//            else
+//            {
+//                meshCellMap.insert(cellI, bCellI);
+//                cellMap.append(cellI);
+//                bCells[i] = bCellI;
+//                bCellI++;
+//            }
+//        }
+//    }
+//
+//
+//    boundaryCellsPtr_.reset(new labelList());
+//    labelList& boundaryCells = boundaryCellsPtr_();
+//    boundaryCells.transfer(cellMap.shrink());
+//
+//
+//    // Convert point-cells to global point numbers
+//    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+//    globalBoundaryCellNumberingPtr_.reset
+//    (
+//        new globalIndex(boundaryCells.size())
+//    );
+//    globalIndex& globalIndices = globalBoundaryCellNumberingPtr_();
+//
+//
+//    globalPointBoundaryCellsPtr_.reset
+//    (
+//        new labelListList(globalPointSlavesMap().constructSize())
+//    );
+//    labelListList& globalPointBoundaryCells = globalPointBoundaryCellsPtr_();
+//
+//    forAll(pointBoundaryCells, pointI)
+//    {
+//        const labelList& pCells = pointBoundaryCells[pointI];
+//        labelList& globalCells = globalPointBoundaryCells[pointI];
+//        globalCells.setSize(pCells.size());
+//        forAll(pCells, i)
+//        {
+//            globalCells[i] = globalIndices.toGlobal(pCells[i]);
+//        }
+//    }
+//
+//
+//    // Pull slave pointBoundaryCells to master
+//    globalPointSlavesMap().distribute(globalPointBoundaryCells);
+//
+//
+//    // Merge slave labels into master globalPointBoundaryCells
+//    const labelListList& pointSlaves = globalPointSlaves();
+//
+//    forAll(pointSlaves, pointI)
+//    {
+//        const labelList& slaves = pointSlaves[pointI];
+//
+//        if (slaves.size() > 0)
+//        {
+//            labelList& myBCells = globalPointBoundaryCells[pointI];
+//
+//            forAll(slaves, i)
+//            {
+//                const labelList& slaveBCells =
+//                    globalPointBoundaryCells[slaves[i]];
+//
+//                // Add all slaveBCells. Note that need to check for
+//                // uniqueness only in case of cyclics.
+//
+//                label sz = myBCells.size();
+//                myBCells.setSize(sz+slaveBCells.size());
+//                forAll(slaveBCells, j)
+//                {
+//                    label slave = slaveBCells[j];
+//                    if (findIndex(SubList<label>(myBCells, sz), slave) == -1)
+//                    {
+//                        myBCells[sz++] = slave;
+//                    }
+//                }
+//                myBCells.setSize(sz);
+//            }
+//        }
+//    }
+//
+//
+//    // Copy merged boundaryCells back from master into slave slot
+//    forAll(pointSlaves, pointI)
+//    {
+//        const labelList& bCells = globalPointBoundaryCells[pointI];
+//        const labelList& slaves = pointSlaves[pointI];
+//
+//        forAll(slaves, i)
+//        {
+//            globalPointBoundaryCells[slaves[i]] = bCells;
+//        }
+//    }
+//
+//
+//    // Sync back to slaves.
+//    globalPointSlavesMap().reverseDistribute
+//    (
+//        coupledPatch().nPoints(),
+//        globalPointBoundaryCells
+//    );
+//
+//
+//    // Construct a map to get the cell data directly
+//    List<Map<label> > compactMap(Pstream::nProcs());
+//    globalPointBoundaryCellsMapPtr_.reset
+//    (
+//        new mapDistribute
+//        (
+//            globalIndices,
+//            globalPointBoundaryCells,
+//            compactMap
+//        )
+//    );
+//
+//    if (debug)
+//    {
+//        Pout<< "globalMeshData::calcGlobalPointBoundaryCells() :"
+//            << " coupled points:" << coupledPatch().nPoints()
+//            << " local boundary cells:" <<  globalIndices.localSize()
+//            << " additional coupled cells:"
+//            <<  globalPointBoundaryCellsMapPtr_().constructSize()
+//              - globalIndices.localSize()
+//            << endl;
+//    }
+//}
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
@@ -1054,7 +1165,6 @@ Foam::globalMeshData::globalMeshData(const polyMesh& mesh)
 :
     processorTopology(mesh.boundaryMesh()),
     mesh_(mesh),
-    bb_(vector::zero, vector::zero),
     nTotalPoints_(-1),
     nTotalFaces_(-1),
     nTotalCells_(-1),
@@ -1062,8 +1172,8 @@ Foam::globalMeshData::globalMeshData(const polyMesh& mesh)
     processorPatchIndices_(0),
     processorPatchNeighbours_(0),
     nGlobalPoints_(-1),
-    sharedPointLabels_(0),
-    sharedPointAddr_(0),
+    sharedPointLabelsPtr_(NULL),
+    sharedPointAddrPtr_(NULL),
     sharedPointGlobalLabelsPtr_(NULL),
     nGlobalEdges_(-1),
     sharedEdgeLabelsPtr_(NULL),
@@ -1073,42 +1183,6 @@ Foam::globalMeshData::globalMeshData(const polyMesh& mesh)
 }
 
 
-// Read constructor given IOobject and a polyMesh reference
-Foam::globalMeshData::globalMeshData(const IOobject& io, const polyMesh& mesh)
-:
-    processorTopology(mesh.boundaryMesh()),
-    mesh_(mesh),
-    bb_(mesh.points()),
-    nTotalPoints_(-1),
-    nTotalFaces_(-1),
-    nTotalCells_(-1),
-    processorPatches_(0),
-    processorPatchIndices_(0),
-    processorPatchNeighbours_(0),
-    nGlobalPoints_(-1),
-    sharedPointLabels_(0),
-    sharedPointAddr_(0),
-    sharedPointGlobalLabelsPtr_(NULL),
-    nGlobalEdges_(-1),
-    sharedEdgeLabelsPtr_(NULL),
-    sharedEdgeAddrPtr_(NULL)
-{
-    initProcAddr();
-
-    IOdictionary dict(io);
-
-    dict.lookup("nTotalPoints") >> nTotalPoints_;
-    dict.lookup("nTotalFaces") >> nTotalFaces_;
-    dict.lookup("nTotalCells") >> nTotalCells_;
-    dict.lookup("nGlobalPoints") >> nGlobalPoints_;
-    dict.lookup("sharedPointLabels") >> sharedPointLabels_;
-    dict.lookup("sharedPointAddr") >> sharedPointAddr_;
-    labelList sharedPointGlobalLabels(dict.lookup("sharedPointGlobalLabels"));
-
-    sharedPointGlobalLabelsPtr_ = new labelList(sharedPointGlobalLabels);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::globalMeshData::~globalMeshData()
@@ -1119,44 +1193,43 @@ Foam::globalMeshData::~globalMeshData()
 
 void Foam::globalMeshData::clearOut()
 {
-    deleteDemandDrivenData(sharedPointGlobalLabelsPtr_);
-    // Edge
+    // Point
     nGlobalPoints_ = -1;
-    deleteDemandDrivenData(sharedEdgeLabelsPtr_);
-    deleteDemandDrivenData(sharedEdgeAddrPtr_);
+    sharedPointLabelsPtr_.clear();
+    sharedPointAddrPtr_.clear();
+    sharedPointGlobalLabelsPtr_.clear();
 
+    // Edge
+    nGlobalEdges_ = -1;
+    sharedEdgeLabelsPtr_.clear();
+    sharedEdgeAddrPtr_.clear();
+
+    // Coupled patch
     coupledPatchPtr_.clear();
     coupledPatchMeshEdgesPtr_.clear();
     coupledPatchMeshEdgeMapPtr_.clear();
+    globalTransformsPtr_.clear();
 
     // Point
     globalPointNumberingPtr_.clear();
     globalPointSlavesPtr_.clear();
+    globalPointTransformedSlavesPtr_.clear();
     globalPointSlavesMapPtr_.clear();
     // Edge
     globalEdgeNumberingPtr_.clear();
     globalEdgeSlavesPtr_.clear();
+    globalEdgeTransformedSlavesPtr_.clear();
     globalEdgeSlavesMapPtr_.clear();
-    // Face
-    globalBoundaryFaceNumberingPtr_.clear();
-    globalPointBoundaryFacesPtr_.clear();
-    globalPointBoundaryFacesMapPtr_.clear();
-    // Cell
-    boundaryCellsPtr_.clear();
-    globalBoundaryCellNumberingPtr_.clear();
-    globalPointBoundaryCellsPtr_.clear();
-    globalPointBoundaryCellsMapPtr_.clear();
-
-    //- Non-collocated
-
-    // Point
-    globalPointAllNumberingPtr_.clear();
-    globalPointAllSlavesPtr_.clear();
-    globalPointAllSlavesMapPtr_.clear();
-    // Edge
-    globalEdgeAllSlavesPtr_.clear();
-    globalEdgeAllSlavesMapPtr_.clear();
 
+//    // Face
+//    globalBoundaryFaceNumberingPtr_.clear();
+//    globalPointBoundaryFacesPtr_.clear();
+//    globalPointBoundaryFacesMapPtr_.clear();
+//    // Cell
+//    boundaryCellsPtr_.clear();
+//    globalBoundaryCellNumberingPtr_.clear();
+//    globalPointBoundaryCellsPtr_.clear();
+//    globalPointBoundaryCellsMapPtr_.clear();
 }
 
 
@@ -1165,10 +1238,13 @@ void Foam::globalMeshData::clearOut()
 // Return shared point global labels.
 const Foam::labelList& Foam::globalMeshData::sharedPointGlobalLabels() const
 {
-    if (!sharedPointGlobalLabelsPtr_)
+    if (!sharedPointGlobalLabelsPtr_.valid())
     {
-        sharedPointGlobalLabelsPtr_ = new labelList(sharedPointLabels_.size());
-        labelList& sharedPointGlobalLabels = *sharedPointGlobalLabelsPtr_;
+        sharedPointGlobalLabelsPtr_.reset
+        (
+            new labelList(sharedPointLabels().size())
+        );
+        labelList& sharedPointGlobalLabels = sharedPointGlobalLabelsPtr_();
 
         IOobject addrHeader
         (
@@ -1187,10 +1263,12 @@ const Foam::labelList& Foam::globalMeshData::sharedPointGlobalLabels() const
 
             labelIOList pointProcAddressing(addrHeader);
 
-            forAll(sharedPointLabels_, i)
+            const labelList& pointLabels = sharedPointLabels();
+
+            forAll(pointLabels, i)
             {
                 // Get my mesh point
-                label pointI = sharedPointLabels_[i];
+                label pointI = pointLabels[i];
 
                 // Map to mesh point of original mesh
                 sharedPointGlobalLabels[i] = pointProcAddressing[pointI];
@@ -1204,7 +1282,7 @@ const Foam::labelList& Foam::globalMeshData::sharedPointGlobalLabels() const
             sharedPointGlobalLabels = -1;
         }
     }
-    return *sharedPointGlobalLabelsPtr_;
+    return sharedPointGlobalLabelsPtr_();
 }
 
 
@@ -1214,17 +1292,19 @@ Foam::pointField Foam::globalMeshData::sharedPoints() const
     // Get all processors to send their shared points to master.
     // (not very efficient)
 
-    pointField sharedPoints(nGlobalPoints_);
+    pointField sharedPoints(nGlobalPoints());
+    const labelList& pointAddr = sharedPointAddr();
+    const labelList& pointLabels = sharedPointLabels();
 
     if (Pstream::master())
     {
         // Master:
         // insert my own data first
-        forAll(sharedPointLabels_, i)
+        forAll(pointLabels, i)
         {
-            label sharedPointI = sharedPointAddr_[i];
+            label sharedPointI = pointAddr[i];
 
-            sharedPoints[sharedPointI] = mesh_.points()[sharedPointLabels_[i]];
+            sharedPoints[sharedPointI] = mesh_.points()[pointLabels[i]];
         }
 
         // Receive data from slaves and insert
@@ -1274,8 +1354,8 @@ Foam::pointField Foam::globalMeshData::sharedPoints() const
             OPstream toMaster(Pstream::blocking, Pstream::masterNo());
 
             toMaster
-                << sharedPointAddr_
-                << UIndirectList<point>(mesh_.points(), sharedPointLabels_)();
+                << pointAddr
+                << UIndirectList<point>(mesh_.points(), pointLabels)();
         }
 
         // Receive sharedPoints
@@ -1293,20 +1373,13 @@ Foam::pointField Foam::globalMeshData::sharedPoints() const
 Foam::pointField Foam::globalMeshData::geometricSharedPoints() const
 {
     // Get coords of my shared points
-    pointField sharedPoints(sharedPointLabels_.size());
-
-    forAll(sharedPointLabels_, i)
-    {
-        label meshPointI = sharedPointLabels_[i];
-
-        sharedPoints[i] = mesh_.points()[meshPointI];
-    }
+    pointField sharedPoints(mesh_.points(), sharedPointLabels());
 
     // Append from all processors
     combineReduce(sharedPoints, plusEqOp<pointField>());
 
     // Merge tolerance
-    scalar tolDim = matchTol_ * bb_.mag();
+    scalar tolDim = matchTol_ * mesh_.bounds().mag();
 
     // And see how many are unique
     labelList pMap;
@@ -1325,6 +1398,36 @@ Foam::pointField Foam::globalMeshData::geometricSharedPoints() const
 }
 
 
+Foam::label Foam::globalMeshData::nGlobalPoints() const
+{
+    if (nGlobalPoints_ == -1)
+    {
+        calcSharedPoints();
+    }
+    return nGlobalPoints_;
+}
+
+
+const Foam::labelList& Foam::globalMeshData::sharedPointLabels() const
+{
+    if (!sharedPointLabelsPtr_.valid())
+    {
+        calcSharedPoints();
+    }
+    return sharedPointLabelsPtr_();
+}
+
+
+const Foam::labelList& Foam::globalMeshData::sharedPointAddr() const
+{
+    if (!sharedPointAddrPtr_.valid())
+    {
+        calcSharedPoints();
+    }
+    return sharedPointAddrPtr_();
+}
+
+
 Foam::label Foam::globalMeshData::nGlobalEdges() const
 {
     if (nGlobalEdges_ == -1)
@@ -1337,21 +1440,21 @@ Foam::label Foam::globalMeshData::nGlobalEdges() const
 
 const Foam::labelList& Foam::globalMeshData::sharedEdgeLabels() const
 {
-    if (!sharedEdgeLabelsPtr_)
+    if (!sharedEdgeLabelsPtr_.valid())
     {
         calcSharedEdges();
     }
-    return *sharedEdgeLabelsPtr_;
+    return sharedEdgeLabelsPtr_();
 }
 
 
 const Foam::labelList& Foam::globalMeshData::sharedEdgeAddr() const
 {
-    if (!sharedEdgeAddrPtr_)
+    if (!sharedEdgeAddrPtr_.valid())
     {
         calcSharedEdges();
     }
-    return *sharedEdgeAddrPtr_;
+    return sharedEdgeAddrPtr_();
 }
 
 
@@ -1465,6 +1568,17 @@ const Foam::globalIndex& Foam::globalMeshData::globalPointNumbering() const
 }
 
 
+const Foam::globalIndexAndTransform&
+Foam::globalMeshData::globalTransforms() const
+{
+    if (!globalTransformsPtr_.valid())
+    {
+        globalTransformsPtr_.reset(new globalIndexAndTransform(mesh_));
+    }
+    return globalTransformsPtr_();
+}
+
+
 const Foam::labelListList& Foam::globalMeshData::globalPointSlaves() const
 {
     if (!globalPointSlavesPtr_.valid())
@@ -1475,6 +1589,17 @@ const Foam::labelListList& Foam::globalMeshData::globalPointSlaves() const
 }
 
 
+const Foam::labelListList& Foam::globalMeshData::globalPointTransformedSlaves()
+const
+{
+    if (!globalPointTransformedSlavesPtr_.valid())
+    {
+        calcGlobalPointSlaves();
+    }
+    return globalPointTransformedSlavesPtr_();
+}
+
+
 const Foam::mapDistribute& Foam::globalMeshData::globalPointSlavesMap() const
 {
     if (!globalPointSlavesMapPtr_.valid())
@@ -1508,6 +1633,17 @@ const Foam::labelListList& Foam::globalMeshData::globalEdgeSlaves() const
 }
 
 
+const Foam::labelListList& Foam::globalMeshData::globalEdgeTransformedSlaves()
+const
+{
+    if (!globalEdgeTransformedSlavesPtr_.valid())
+    {
+        calcGlobalEdgeSlaves();
+    }
+    return globalEdgeTransformedSlavesPtr_();
+}
+
+
 const Foam::mapDistribute& Foam::globalMeshData::globalEdgeSlavesMap() const
 {
     if (!globalEdgeSlavesMapPtr_.valid())
@@ -1518,135 +1654,6 @@ const Foam::mapDistribute& Foam::globalMeshData::globalEdgeSlavesMap() const
 }
 
 
-const Foam::globalIndex& Foam::globalMeshData::globalBoundaryFaceNumbering()
-const
-{
-    if (!globalBoundaryFaceNumberingPtr_.valid())
-    {
-        calcGlobalPointBoundaryFaces();
-    }
-    return globalBoundaryFaceNumberingPtr_();
-}
-
-
-const Foam::labelListList& Foam::globalMeshData::globalPointBoundaryFaces()
-const
-{
-    if (!globalPointBoundaryFacesPtr_.valid())
-    {
-        calcGlobalPointBoundaryFaces();
-    }
-    return globalPointBoundaryFacesPtr_();
-}
-
-
-const Foam::mapDistribute& Foam::globalMeshData::globalPointBoundaryFacesMap()
-const
-{
-    if (!globalPointBoundaryFacesMapPtr_.valid())
-    {
-        calcGlobalPointBoundaryFaces();
-    }
-    return globalPointBoundaryFacesMapPtr_();
-}
-
-
-const Foam::labelList& Foam::globalMeshData::boundaryCells() const
-{
-    if (!boundaryCellsPtr_.valid())
-    {
-        calcGlobalPointBoundaryCells();
-    }
-    return boundaryCellsPtr_();
-}
-
-
-const Foam::globalIndex& Foam::globalMeshData::globalBoundaryCellNumbering()
-const
-{
-    if (!globalBoundaryCellNumberingPtr_.valid())
-    {
-        calcGlobalPointBoundaryCells();
-    }
-    return globalBoundaryCellNumberingPtr_();
-}
-
-
-const Foam::labelListList& Foam::globalMeshData::globalPointBoundaryCells()
-const
-{
-    if (!globalPointBoundaryCellsPtr_.valid())
-    {
-        calcGlobalPointBoundaryCells();
-    }
-    return globalPointBoundaryCellsPtr_();
-}
-
-
-const Foam::mapDistribute& Foam::globalMeshData::globalPointBoundaryCellsMap()
-const
-{
-    if (!globalPointBoundaryCellsMapPtr_.valid())
-    {
-        calcGlobalPointBoundaryCells();
-    }
-    return globalPointBoundaryCellsMapPtr_();
-}
-
-
-
-// Non-collocated coupled point/edge addressing
-
-const Foam::globalIndex& Foam::globalMeshData::globalPointAllNumbering() const
-{
-    if (!globalPointAllNumberingPtr_.valid())
-    {
-        calcGlobalPointAllSlaves();
-    }
-    return globalPointAllNumberingPtr_();
-}
-
-
-const Foam::labelListList& Foam::globalMeshData::globalPointAllSlaves() const
-{
-    if (!globalPointAllSlavesPtr_.valid())
-    {
-        calcGlobalPointAllSlaves();
-    }
-    return globalPointAllSlavesPtr_();
-}
-
-
-const Foam::mapDistribute& Foam::globalMeshData::globalPointAllSlavesMap() const
-{
-    if (!globalPointAllSlavesMapPtr_.valid())
-    {
-        calcGlobalPointAllSlaves();
-    }
-    return globalPointAllSlavesMapPtr_();
-}
-
-
-const Foam::labelListList& Foam::globalMeshData::globalEdgeAllSlaves() const
-{
-    if (!globalEdgeAllSlavesPtr_.valid())
-    {
-        calcGlobalEdgeAllSlaves();
-    }
-    return globalEdgeAllSlavesPtr_();
-}
-
-
-const Foam::mapDistribute& Foam::globalMeshData::globalEdgeAllSlavesMap() const
-{
-    if (!globalEdgeAllSlavesMapPtr_.valid())
-    {
-        calcGlobalEdgeAllSlaves();
-    }
-    return globalEdgeAllSlavesMapPtr_();
-}
-
-
 Foam::autoPtr<Foam::globalIndex> Foam::globalMeshData::mergePoints
 (
     labelList& pointToGlobal,
@@ -1874,7 +1881,7 @@ Foam::autoPtr<Foam::globalIndex> Foam::globalMeshData::mergePoints
         }
     }
 
-    // Allocate globals for master 
+    // Allocate globals for master
     labelList masterToGlobal(pointSlavesMap.constructSize(), -456);
 
     forAll(masterPoints, i)
@@ -1935,6 +1942,8 @@ void Foam::globalMeshData::movePoints(const pointField& newPoints)
 {
     // Topology does not change and we don't store any geometry so nothing
     // needs to be done.
+    // Only global transformations might change but this is not really
+    // supported.
 }
 
 
@@ -1947,268 +1956,34 @@ void Foam::globalMeshData::updateMesh()
     // Do processor patch addressing
     initProcAddr();
 
-    // Note: boundBox does reduce
-    bb_ = boundBox(mesh_.points());
-
-    scalar tolDim = matchTol_ * bb_.mag();
+    scalar tolDim = matchTol_ * mesh_.bounds().mag();
 
     if (debug)
     {
-        Pout<< "globalMeshData : bb_:" << bb_
-            << " merge dist:" << tolDim << endl;
+        Pout<< "globalMeshData : merge dist:" << tolDim << endl;
     }
 
-
-    // Option 1. Topological
-    {
-        // Calculate all shared points (excluded points that are only
-        // on two coupled patches). This does all the hard work.
-        globalPoints parallelPoints(mesh_, false, true);
-
-        // Copy data out.
-        nGlobalPoints_ = parallelPoints.nGlobalPoints();
-        sharedPointLabels_ = parallelPoints.sharedPointLabels();
-        sharedPointAddr_ = parallelPoints.sharedPointAddr();
-    }
-    //// Option 2. Geometric
-    //{
-    //    // Calculate all shared points. This does all the hard work.
-    //    geomGlobalPoints parallelPoints(mesh_, tolDim);
-    //
-    //    // Copy data out.
-    //    nGlobalPoints_ = parallelPoints.nGlobalPoints();
-    //    sharedPointLabels_ = parallelPoints.sharedPointLabels();
-    //    sharedPointAddr_ = parallelPoints.sharedPointAddr();
-    //
-    //    nGlobalEdges_ = parallelPoints.nGlobalEdges();
-    //    sharedEdgeLabels_ = parallelPoints.sharedEdgeLabels();
-    //    sharedEdgeAddr_ = parallelPoints.sharedEdgeAddr();
-    //}
-
-    if (debug)
-    {
-        Pout<< "globalMeshData : nGlobalPoints_:" << nGlobalPoints_ << nl
-            << "globalMeshData : sharedPointLabels_:"
-            << sharedPointLabels_.size() << nl
-            << "globalMeshData : sharedPointAddr_:"
-            << sharedPointAddr_.size() << endl;
-    }
-
-
-    // Total number of faces. Start off from all faces. Remove coincident
-    // processor faces (on highest numbered processor) before summing.
-    nTotalFaces_ = mesh_.nFaces();
-
-    // Do not count processor-patch faces that are coincident.
-    forAll(processorPatches_, i)
-    {
-        label patchI = processorPatches_[i];
-
-        if (isType<processorPolyPatch>(mesh_.boundaryMesh()[patchI]))
-        {
-            // Normal, unseparated processor patch. Remove duplicates.
-            nTotalFaces_ -= mesh_.boundaryMesh()[patchI].size();
-        }
-    }
-    reduce(nTotalFaces_, sumOp<label>());
+    // Total number of faces.
+    nTotalFaces_ = returnReduce(mesh_.nFaces(), sumOp<label>());
 
     if (debug)
     {
         Pout<< "globalMeshData : nTotalFaces_:" << nTotalFaces_ << endl;
     }
 
-
-    nTotalCells_ = mesh_.nCells();
-    reduce(nTotalCells_, sumOp<label>());
+    nTotalCells_ = returnReduce(mesh_.nCells(), sumOp<label>());
 
     if (debug)
     {
         Pout<< "globalMeshData : nTotalCells_:" << nTotalCells_ << endl;
     }
 
-    nTotalPoints_ = mesh_.nPoints();
-
-    // Correct points for duplicate ones. We have
-    // - points shared between 2 processor patches only. Count only on
-    //   lower numbered processor. Make sure to count only once since points
-    //   can be on multiple patches on the same processor.
-    // - globally shared points.
-
-    if (Pstream::parRun())
-    {
-        const label UNSET = 0;      // not set
-        const label SHARED = 1;     // globally shared
-        const label VISITED = 2;    // corrected for
-
-        // Mark globally shared points
-        PackedList<2> pointStatus(mesh_.nPoints(), UNSET);
-
-        forAll(sharedPointLabels_, i)
-        {
-            label meshPointI = sharedPointLabels_[i];
-
-            pointStatus.set(meshPointI, SHARED);
-        }
-
-        PstreamBuffers pBufs(Pstream::nonBlocking);
-
-        // Send patch local points
-        forAll(processorPatches_, i)
-        {
-            label patchI = processorPatches_[i];
-
-            const processorPolyPatch& procPatch =
-                refCast<const processorPolyPatch>(mesh_.boundaryMesh()[patchI]);
-
-            UOPstream toNeighbour(procPatch.neighbProcNo(), pBufs);
-
-            toNeighbour << procPatch.localPoints();
-        }
-
-        pBufs.finishedSends();
-
-        // Receive patch local points and uncount if coincident (and not shared)
-        forAll(processorPatches_, i)
-        {
-            label patchI = processorPatches_[i];
-
-            const processorPolyPatch& procPatch =
-                refCast<const processorPolyPatch>(mesh_.boundaryMesh()[patchI]);
-
-            UIPstream fromNeighbour(procPatch.neighbProcNo(), pBufs);
-
-            pointField nbrPoints(fromNeighbour);
-
-            if (Pstream::myProcNo() > procPatch.neighbProcNo())
-            {
-                labelList pMap;
-                matchPoints
-                (
-                    procPatch.localPoints(),
-                    nbrPoints,
-                    scalarField(procPatch.nPoints(), tolDim),   // tolerance
-                    false,      // verbosity
-                    pMap        // map from my points to nbrPoints
-                );
-
-                forAll(pMap, patchPointI)
-                {
-                    label meshPointI = procPatch.meshPoints()[patchPointI];
-
-                    label stat = pointStatus.get(meshPointI);
-
-                    if (stat == UNSET)
-                    {
-                        // Mark point as visited so if point is on multiple proc
-                        // patches it only gets uncounted once.
-                        pointStatus.set(meshPointI, VISITED);
-
-                        if (pMap[patchPointI] != -1)
-                        {
-                            // Points share same coordinate so uncount.
-                            nTotalPoints_--;
-                        }
-                    }
-                }
-            }
-        }
-        // Sum all points
-        reduce(nTotalPoints_, sumOp<label>());
-    }
-
-    // nTotalPoints has not been corrected yet for shared points. For these
-    // just collect all their coordinates and count unique ones.
-
-    label mySharedPoints = sharedPointLabels_.size();
-    reduce(mySharedPoints, sumOp<label>());
-
-    // Collect and merge shared points (does parallel communication)
-    pointField geomSharedPoints(geometricSharedPoints());
-    label nGeomSharedPoints = geomSharedPoints.size();
-
-    // Shared points merged down to mergedPoints size.
-    nTotalPoints_ -= mySharedPoints - nGeomSharedPoints;
+    nTotalPoints_ = returnReduce(mesh_.nPoints(), sumOp<label>());
 
     if (debug)
     {
         Pout<< "globalMeshData : nTotalPoints_:" << nTotalPoints_ << endl;
     }
-
-    //
-    // Now we have all info we wanted.
-    // Do some checking (if debug is set)
-    //
-
-    if (debug)
-    {
-        if (Pstream::master())
-        {
-            // We have the geometricSharedPoints already so write them.
-            // Ideally would like to write the networks of connected points as
-            // well but this is harder. (Todo)
-            Pout<< "globalMeshData : writing geometrically separated shared"
-                << " points to geomSharedPoints.obj" << endl;
-
-            OFstream str("geomSharedPoints.obj");
-
-            forAll(geomSharedPoints, i)
-            {
-                const point& pt = geomSharedPoints[i];
-
-                str << "v " << pt.x() << ' ' << pt.y() << ' ' << pt.z()
-                    << nl;
-            }
-        }
-    }
-}
-
-
-// Write data
-bool Foam::globalMeshData::write() const
-{
-    IOdictionary dict
-    (
-        IOobject
-        (
-            "parallelData",
-            mesh_.facesInstance(),
-            mesh_.meshSubDir,
-            mesh_
-        )
-    );
-
-    dict.add("nTotalPoints", nTotalPoints());
-    dict.add("nTotalFaces", nTotalFaces());
-    dict.add("nTotalCells", nTotalCells());
-
-    dict.add("nGlobalPoints", nGlobalPoints());
-    dict.add("sharedPointLabels", sharedPointLabels());
-    dict.add("sharedPointAddr", sharedPointAddr());
-    dict.add("sharedPointGlobalLabels", sharedPointGlobalLabels());
-
-    return dict.writeObject
-    (
-        IOstream::ASCII,
-        IOstream::currentVersion,
-        IOstream::UNCOMPRESSED
-    );
-}
-
-
-// * * * * * * * * * * * * * * * Ostream Operators * * * * * * * * * * * * * //
-
-Foam::Ostream& Foam::operator<<(Ostream& os, const globalMeshData& p)
-{
-    os  << "nTotalPoints " << p.nTotalPoints() << token::END_STATEMENT << nl
-        << "nTotalFaces " << p.nTotalFaces() << token::END_STATEMENT << nl
-        << "nTotalCells " << p.nTotalCells() << token::END_STATEMENT << nl
-        << "nGlobalPoints " << p.nGlobalPoints() << token::END_STATEMENT << nl
-        << "sharedPointLabels " << p.sharedPointLabels()
-        << token::END_STATEMENT << nl
-        << "sharedPointAddr " << p.sharedPointAddr()
-        << token::END_STATEMENT << endl;
-
-    return os;
 }
 
 
diff --git a/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalMeshData.H b/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalMeshData.H
index a58de6a649..279b06ae2e 100644
--- a/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalMeshData.H
+++ b/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalMeshData.H
@@ -32,52 +32,56 @@ Description
     - all processor patches to have correct ordering.
     - all processorPatches to have their transforms set.
 
-    The shared point addressing is quite interesting. It gives on each processor
-    the vertices that cannot be set using a normal swap on processor patches.
-    These are the vertices that are shared between more than 2 processors.
+    The shared point and edge addressing is quite interesting.
+    It calculates addressing for points and edges on coupled patches. In
+    the 'old' way a distincation was made between points/edges that are
+    only on two processors and those that are on multiple processors. The
+    problem is that those on multiple processors do not allow any
+    transformations and require a global reduction on the master processor.
 
-    There is an issue with these shared vertices if they originate from
-    cyclics (i.e. are now separated processor patches). They will all be
-    mapped to the same global point (so even though the processor points are
-    not on the same location) since topologically they are one and the same.
+    The alternative is to have an exchange schedule (through a 'mapDistribute')
+    which sends all point/edge data (no distinction is made between
+    those on two and those on more than two coupled patches) to the local
+    'master'. This master then does any calculation and sends
+    the result back to the 'slave' points/edges. This only needs to be done
+    on points on coupled faces. Any transformation is done using a predetermined
+    set of transformations - since transformations have to be space filling
+    only a certain number of transformation is supported.
 
-    So if you ask for sharedPoints() you get only one of the coordinates of
-    the topologically shared points.
+    The exchange needs
+    - a field of data
+    - a mapDistribute which does all parallel exchange and transformations
+      This appens remote data to the end of the field.
+    - a set of indices which indicate where to get untransformed data in the
+      field
+    - a set of indices which indicate where to get transformed data in the
+      field
 
-    All the hard work of these shared points is done by the globalPoints class.
+    See also mapDistribute, globalIndexAndTransform
 
-    Shared edges: similar to shared points gives on all processors the edges
-    that are shared between more than two patches (i.e. the edges on which
-    data cannot be synchronized by a straightforward edge data swap). Note
-    that shared edges will use shared points but not all edges between shared
-    points need to be shared edges (e.g. there might be an edge connecting
-    two disconnected regions of shared points).
-
-    Currently an edge is considered shared
+    Notes:
+    - compared to 17x nTotalFaces, nTotalPoints do not compensate for
+    shared points since this would trigger full connectivity analysis
+    - most calculation is demand driven and uses parallel communication
+    so make sure to invoke on all processors at the same time.
+    - old sharedEdge calculation: currently an edge is considered shared
     if it uses two shared points and is used more than once. This is not
     correct on processor patches but it only slightly overestimates the number
     of shared edges. Doing full analysis of how many patches use the edge
     would be too complicated.
 
-    Shared edge calculation is demand driven so always make sure to have
-    your first call to one of the access functions synchronous amongst all
-    processors!
-
-
 SourceFiles
     globalMeshData.C
+    globalMeshDataTemplates.C
 
 \*---------------------------------------------------------------------------*/
 
 #ifndef globalMeshData_H
 #define globalMeshData_H
 
-#include "Switch.H"
 #include "processorTopology.H"
 #include "labelPair.H"
 #include "indirectPrimitivePatch.H"
-#include "boundBox.H"
-#include "IOobject.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -86,13 +90,11 @@ namespace Foam
 
 // Forward declaration of friend functions and operators
 
-class globalMeshData;
-Ostream& operator<<(Ostream&, const globalMeshData&);
-class globalIndex;
 class polyMesh;
 class mapDistribute;
 template<class T> class EdgeMap;
-class globalPoints;
+class globalIndex;
+class globalIndexAndTransform;
 
 /*---------------------------------------------------------------------------*\
                            Class globalMeshData Declaration
@@ -134,9 +136,6 @@ class globalMeshData
 
         // Data related to the complete mesh
 
-            //- Bounding box of complete mesh
-            boundBox bb_;
-
             //- Total number of points in the complete mesh
             label nTotalPoints_;
 
@@ -162,23 +161,70 @@ class globalMeshData
             labelList processorPatchNeighbours_;
 
 
+        // Coupled point addressing
+        // This is addressing from coupled point to coupled points/faces/cells.
+        // This is a full schedule so includes points used by only two
+        // coupled patches.
+
+            //- Patch of coupled faces. Additional patch edge to mesh edges
+            //  correspondence:
+            //      points: meshPoints(), meshPointMap()
+            //      edges : meshEdges(), meshEdgeMap()
+            mutable autoPtr<indirectPrimitivePatch> coupledPatchPtr_;
+            mutable autoPtr<labelList> coupledPatchMeshEdgesPtr_;
+            mutable autoPtr<Map<label> > coupledPatchMeshEdgeMapPtr_;
+
+            //- Global numbering for coupledPatch points
+            mutable autoPtr<globalIndex> globalPointNumberingPtr_;
+
+            //- Global numbering for transforms
+            mutable autoPtr<globalIndexAndTransform> globalTransformsPtr_;
+
+            // Coupled point to coupled points
+
+            mutable autoPtr<labelListList> globalPointSlavesPtr_;
+            mutable autoPtr<labelListList> globalPointTransformedSlavesPtr_;
+            mutable autoPtr<mapDistribute> globalPointSlavesMapPtr_;
+
+            // Coupled edge to coupled edges
+
+            mutable autoPtr<globalIndex> globalEdgeNumberingPtr_;
+            mutable autoPtr<labelListList> globalEdgeSlavesPtr_;
+            mutable autoPtr<labelListList> globalEdgeTransformedSlavesPtr_;
+            mutable autoPtr<mapDistribute> globalEdgeSlavesMapPtr_;
+
+
+            //// Coupled point to boundary faces
+            //
+            //mutable autoPtr<globalIndex> globalBoundaryFaceNumberingPtr_;
+            //mutable autoPtr<labelListList> globalPointBoundaryFacesPtr_;
+            //mutable autoPtr<mapDistribute> globalPointBoundaryFacesMapPtr_;
+            //
+            //// Coupled point to collocated boundary cells
+            //
+            //mutable autoPtr<labelList> boundaryCellsPtr_;
+            //mutable autoPtr<globalIndex> globalBoundaryCellNumberingPtr_;
+            //mutable autoPtr<labelListList> globalPointBoundaryCellsPtr_;
+            //mutable autoPtr<mapDistribute> globalPointBoundaryCellsMapPtr_;
+
+
         // Globally shared point addressing
 
             //- Total number of global points
-            label nGlobalPoints_;
+            mutable label nGlobalPoints_;
 
             //- Indices of local points that are globally shared
-            labelList sharedPointLabels_;
+            mutable autoPtr<labelList> sharedPointLabelsPtr_;
 
             //- Indices of globally shared points in the master list
             //  This list contains all the shared points in the mesh
-            labelList sharedPointAddr_;
+            mutable autoPtr<labelList> sharedPointAddrPtr_;
 
             //- Shared point global labels.
             //  Global point index for every local shared point.
             //  Only valid if constructed with this information or if
             //  pointProcAddressing read.
-            mutable labelList* sharedPointGlobalLabelsPtr_;
+            mutable autoPtr<labelList> sharedPointGlobalLabelsPtr_;
 
 
         // Globally shared edge addressing. Derived from shared points.
@@ -188,68 +234,11 @@ class globalMeshData
             mutable label nGlobalEdges_;
 
             //- Indices of local edges that are globally shared
-            mutable labelList* sharedEdgeLabelsPtr_;
+            mutable autoPtr<labelList> sharedEdgeLabelsPtr_;
 
             //- Indices of globally shared edge in the master list
             //  This list contains all the shared edges in the mesh
-            mutable labelList* sharedEdgeAddrPtr_;
-
-
-        // Coupled point addressing
-        // This is addressing from coupled point to coupled points/faces/cells.
-        // Two variants:
-        //  - collocated (so not physically separated)
-        //  - also separated
-        // This is a full schedule so includes points only used by two
-        // coupled patches.
-
-            mutable autoPtr<indirectPrimitivePatch> coupledPatchPtr_;
-
-            mutable autoPtr<labelList> coupledPatchMeshEdgesPtr_;
-
-            mutable autoPtr<Map<label> > coupledPatchMeshEdgeMapPtr_;
-
-            // Collocated
-
-                // Coupled point to collocated coupled points
-
-                mutable autoPtr<globalIndex> globalPointNumberingPtr_;
-                mutable autoPtr<labelListList> globalPointSlavesPtr_;
-                mutable autoPtr<mapDistribute> globalPointSlavesMapPtr_;
-
-                // Coupled edge to collocated coupled edges
-
-                mutable autoPtr<globalIndex> globalEdgeNumberingPtr_;
-                mutable autoPtr<labelListList> globalEdgeSlavesPtr_;
-                mutable autoPtr<mapDistribute> globalEdgeSlavesMapPtr_;
-
-                // Coupled point to collocated boundary faces
-
-                mutable autoPtr<globalIndex> globalBoundaryFaceNumberingPtr_;
-                mutable autoPtr<labelListList> globalPointBoundaryFacesPtr_;
-                mutable autoPtr<mapDistribute> globalPointBoundaryFacesMapPtr_;
-
-                // Coupled point to collocated boundary cells
-
-                mutable autoPtr<labelList> boundaryCellsPtr_;
-                mutable autoPtr<globalIndex> globalBoundaryCellNumberingPtr_;
-                mutable autoPtr<labelListList> globalPointBoundaryCellsPtr_;
-                mutable autoPtr<mapDistribute> globalPointBoundaryCellsMapPtr_;
-
-
-            // Non-collocated as well
-
-                // Coupled point to all coupled points
-
-                mutable autoPtr<globalIndex> globalPointAllNumberingPtr_;
-                mutable autoPtr<labelListList> globalPointAllSlavesPtr_;
-                mutable autoPtr<mapDistribute> globalPointAllSlavesMapPtr_;
-
-                // Coupled edge to all coupled edges (same numbering as
-                // collocated coupled edges)
-
-                mutable autoPtr<labelListList> globalEdgeAllSlavesPtr_;
-                mutable autoPtr<mapDistribute> globalEdgeAllSlavesMapPtr_;
+            mutable autoPtr<labelList> sharedEdgeAddrPtr_;
 
 
     // Private Member Functions
@@ -265,70 +254,18 @@ class globalMeshData
             label&
         );
 
+        //- Calculate shared point addressing
+        void calcSharedPoints() const;
+
         //- Calculate shared edge addressing
         void calcSharedEdges() const;
 
-        //- Count coincident faces.
-        static label countCoincidentFaces
-        (
-            const scalar tolDim,
-            const vectorField& separationDist
-        );
-
-        //- Calculate global point addressing.
-        void calcGlobalPointSlaves
-        (
-            const globalPoints&,
-            autoPtr<globalIndex>&,
-            autoPtr<labelListList>&,
-            autoPtr<mapDistribute>&
-        ) const;
-
-        //- Calculate global point addressing.
+       //- Calculate global point addressing.
         void calcGlobalPointSlaves() const;
 
-        //- Calculate global edge addressing.
-        void calcGlobalEdgeSlaves
-        (
-            const labelListList&,
-            const mapDistribute&,
-            const globalIndex&,
-            autoPtr<labelListList>&,
-            autoPtr<mapDistribute>&
-        ) const;
-
         //- Calculate global edge addressing.
         void calcGlobalEdgeSlaves() const;
 
-        //- Calculate coupled point to uncoupled boundary faces. Local only.
-        void calcPointBoundaryFaces(labelListList& pointBoundaryFaces) const;
-
-        //- Calculate global point to global boundary face addressing.
-        void calcGlobalPointBoundaryFaces() const;
-
-        //- Calculate global point to global boundary cell addressing.
-        void calcGlobalPointBoundaryCells() const;
-
-
-        // Non-collocated
-
-            //- Calculate global point addressing.
-            void calcGlobalPointAllSlaves() const;
-
-            //- Calculate global edge addressing.
-            void calcGlobalEdgeAllSlaves() const;
-
-
-        //- Synchronise pointwise data
-        template<class Type, class CombineOp>
-        void syncPointData
-        (
-            List<Type>& pointData,
-            const labelListList& slaves,
-            const mapDistribute& slavesMap,
-            const CombineOp& cop
-        ) const;
-
 
         //- Disallow default bitwise copy construct
         globalMeshData(const globalMeshData&);
@@ -345,7 +282,7 @@ public:
 
     // Static data members
 
-        //- Geomtric tolerance (fraction of bounding box)
+        //- Geomteric tolerance (fraction of bounding box)
         static const Foam::scalar matchTol_;
 
 
@@ -354,10 +291,6 @@ public:
         //- Construct from mesh, derive rest (does parallel communication!)
         globalMeshData(const polyMesh& mesh);
 
-        //- Old behaviour: read constructor given IOobject and a polyMesh
-        //  reference. Only use this for testing!
-        globalMeshData(const IOobject& io, const polyMesh& mesh);
-
 
     //- Destructor
     ~globalMeshData();
@@ -383,24 +316,21 @@ public:
                 return processorPatches_.size() > 0;
             }
 
-            const boundBox& bb() const
-            {
-                return bb_;
-            }
-
-            //- Return total number of points in decomposed mesh
+            //- Return total number of points in decomposed mesh. Not
+            //  compensated for duplicate points!
             label nTotalPoints() const
             {
                 return nTotalPoints_;
             }
 
-            //- Return total number of faces in decomposed mesh
+            //- Return total number of faces in decomposed mesh. Not
+            //  compensated for duplicate faces!
             label nTotalFaces() const
             {
                 return nTotalFaces_;
             }
 
-            //- Return total number of cells in decomposed mesh
+            //- Return total number of cells in decomposed mesh.
             label nTotalCells() const
             {
                 return nTotalCells_;
@@ -435,16 +365,10 @@ public:
         // Globally shared point addressing
 
             //- Return number of globally shared points
-            label nGlobalPoints() const
-            {
-                return nGlobalPoints_;
-            }
+            label nGlobalPoints() const;
 
             //- Return indices of local points that are globally shared
-            const labelList& sharedPointLabels() const
-            {
-                return sharedPointLabels_;
-            }
+            const labelList& sharedPointLabels() const;
 
             //- Return addressing into the complete globally shared points
             //  list
@@ -454,10 +378,7 @@ public:
             //  points. Shared point addressing gives the index in the
             //  list of all globally shared points for each of the locally
             //  shared points.
-            const labelList& sharedPointAddr() const
-            {
-                return sharedPointAddr_;
-            }
+            const labelList& sharedPointAddr() const;
 
             //- Return shared point global labels. Tries to read
             //  'pointProcAddressing' and returns list or -1 if none
@@ -512,70 +433,47 @@ public:
             //- Return map from mesh edges to coupledPatch edges
             const Map<label>& coupledPatchMeshEdgeMap() const;
 
+            //- Global transforms numbering
+            const globalIndexAndTransform& globalTransforms() const;
 
-            // Coupled point to collocated coupled points. Coupled points are
+            //- Helper: synchronise data with transforms
+            template<class Type, class CombineOp>
+            static void syncData
+            (
+                List<Type>& pointData,
+                const labelListList& slaves,
+                const labelListList& transformedSlaves,
+                const mapDistribute& slavesMap,
+                const globalIndexAndTransform&,
+                const CombineOp& cop,
+                const bool isPosition
+            );
+
+
+            // Coupled point to coupled points. Coupled points are
             // points on any coupled patch.
 
                 //- Numbering of coupled points is according to coupledPatch.
                 const globalIndex& globalPointNumbering() const;
-                //- For every coupled point the indices into the field
-                //  distributed by below map.
                 const labelListList& globalPointSlaves() const;
+                const labelListList& globalPointTransformedSlaves() const;
                 const mapDistribute& globalPointSlavesMap() const;
-                //- Helper to synchronise mesh data
+                //- Helper to synchronise mesh point data
                 template<class Type, class CombineOp>
                 void syncPointData
                 (
                     List<Type>& pointData,
-                    const CombineOp& cop
+                    const CombineOp& cop,
+                    const bool isPosition
                 ) const;
 
             // Coupled edge to coupled edges.
 
                 const globalIndex& globalEdgeNumbering() const;
                 const labelListList& globalEdgeSlaves() const;
+                const labelListList& globalEdgeTransformedSlaves() const;
                 const mapDistribute& globalEdgeSlavesMap() const;
 
-            // Coupled point to boundary faces. These are uncoupled boundary
-            // faces only but include empty patches.
-
-                //- Numbering of boundary faces is face-mesh.nInternalFaces()
-                const globalIndex& globalBoundaryFaceNumbering() const;
-                const labelListList& globalPointBoundaryFaces() const;
-                const mapDistribute& globalPointBoundaryFacesMap() const;
-
-            // Coupled point to boundary cell
-
-                //- From boundary cell to mesh cell
-                const labelList& boundaryCells() const;
-
-                //- Numbering of boundary cells is according to boundaryCells()
-                const globalIndex& globalBoundaryCellNumbering() const;
-                const labelListList& globalPointBoundaryCells() const;
-                const mapDistribute& globalPointBoundaryCellsMap() const;
-
-
-            // Collocated & non-collocated
-
-                // Coupled point to all coupled points (collocated and
-                // non-collocated).
-
-                    const globalIndex& globalPointAllNumbering()const;
-                    const labelListList& globalPointAllSlaves() const;
-                    const mapDistribute& globalPointAllSlavesMap() const;
-                    //- Helper to synchronise mesh data
-                    template<class Type, class CombineOp>
-                    void syncPointAllData
-                    (
-                        List<Type>& pointData,
-                        const CombineOp& cop
-                    ) const;
-
-                // Coupled edge to all coupled edges (same numbering as
-                // collocated)
-
-                    const labelListList& globalEdgeAllSlaves() const;
-                    const mapDistribute& globalEdgeAllSlavesMap() const;
 
             // Other
 
@@ -614,16 +512,6 @@ public:
             //  full parallel analysis to determine shared points and
             //  boundaries.
             void updateMesh();
-
-
-        // Write
-
-            bool write() const;
-
-
-    // Ostream Operator
-
-        friend Ostream& operator<<(Ostream&, const globalMeshData&);
 };
 
 
diff --git a/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalMeshDataTemplates.C b/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalMeshDataTemplates.C
index 82bbfe7694..2a853e5970 100644
--- a/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalMeshDataTemplates.C
+++ b/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalMeshDataTemplates.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -29,13 +29,73 @@ License
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+template<class Type, class CombineOp>
+void Foam::globalMeshData::syncData
+(
+    List<Type>& elems,
+    const labelListList& slaves,
+    const labelListList& transformedSlaves,
+    const mapDistribute& slavesMap,
+    const globalIndexAndTransform& transforms,
+    const CombineOp& cop,
+    const bool isPosition
+)
+{
+    // Pull slave data onto master
+    slavesMap.distribute(transforms, elems, isPosition);
+
+    // Combine master data with slave data
+    forAll(slaves, i)
+    {
+        Type& elem = elems[i];
+
+        const labelList& slavePoints = slaves[i];
+        const labelList& transformSlavePoints = transformedSlaves[i];
+
+        if (slavePoints.size()+transformSlavePoints.size() > 0)
+        {
+            // Combine master with untransformed slave data
+            forAll(slavePoints, j)
+            {
+                cop(elem, elems[slavePoints[j]]);
+            }
+
+            // Combine master with transformed slave data
+            forAll(transformSlavePoints, j)
+            {
+                cop(elem, elems[transformSlavePoints[j]]);
+            }
+
+
+            // Copy result back to slave slots
+            forAll(slavePoints, j)
+            {
+                elems[slavePoints[j]] = elem;
+            }
+            forAll(transformSlavePoints, j)
+            {
+                elems[transformSlavePoints[j]] = elem;
+            }
+        }
+    }
+
+    // Push slave-slot data back to slaves
+    slavesMap.reverseDistribute
+    (
+        transforms,
+        elems.size(),
+        elems,
+        isPosition
+    );
+}
+
+
 template<class Type, class CombineOp>
 void Foam::globalMeshData::syncPointData
 (
     List<Type>& pointData,
-    const labelListList& slaves,
-    const mapDistribute& slavesMap,
-    const CombineOp& cop
+    const CombineOp& cop,
+    const bool isPosition
 ) const
 {
     if (pointData.size() != mesh_.nPoints())
@@ -46,81 +106,26 @@ void Foam::globalMeshData::syncPointData
             << abort(FatalError);
     }
 
+    // Transfer onto coupled patch
     const indirectPrimitivePatch& cpp = coupledPatch();
-    const labelList& meshPoints = cpp.meshPoints();
+    List<Type> cppFld(UIndirectList<Type>(pointData, cpp.meshPoints()));
 
-    // Copy mesh (point)data to coupled patch (point)data
-    Field<Type> cppFld(slavesMap.constructSize());
-    forAll(meshPoints, patchPointI)
-    {
-        cppFld[patchPointI] = pointData[meshPoints[patchPointI]];
-    }
-
-    // Pull slave data onto master
-    slavesMap.distribute(cppFld);
-
-    // Combine master data with slave data
-    forAll(slaves, patchPointI)
-    {
-        const labelList& slavePoints = slaves[patchPointI];
-
-        // Combine master with slave data
-        forAll(slavePoints, i)
-        {
-            cop(cppFld[patchPointI], cppFld[slavePoints[i]]);
-        }
-        // Copy result back to slave slots
-        forAll(slavePoints, i)
-        {
-            cppFld[slavePoints[i]] = cppFld[patchPointI];
-        }
-    }
-
-    // Push master data back to slaves
-    slavesMap.reverseDistribute(meshPoints.size(), cppFld);
-
-    // Update mesh (point)data from coupled patch (point)data
-    forAll(meshPoints, patchPointI)
-    {
-        pointData[meshPoints[patchPointI]] = cppFld[patchPointI];
-    }
-}
-
-
-template<class Type, class CombineOp>
-void Foam::globalMeshData::syncPointData
-(
-    List<Type>& pointData,
-    const CombineOp& cop
-) const
-{
-    const labelListList& slaves = globalPointSlaves();
-    const mapDistribute& map = globalPointSlavesMap();
-
-    syncPointData
+    syncData
     (
-        pointData,
-        slaves,
-        map,
-        cop
+        cppFld,
+        globalPointSlaves(),
+        globalPointTransformedSlaves(),
+        globalPointSlavesMap(),
+        globalTransforms(),
+        cop,
+        isPosition
     );
-}
 
-
-template<class Type, class CombineOp>
-void Foam::globalMeshData::syncPointAllData
-(
-    List<Type>& pointData,
-    const CombineOp& cop
-) const
-{
-    syncPointData
-    (
-        pointData,
-        globalPointAllSlaves(),
-        globalPointAllSlavesMap(),
-        cop
-    );
+    // Extract back onto mesh
+    forAll(cpp.meshPoints(), i)
+    {
+        pointData[cpp.meshPoints()[i]] = cppFld[i];
+    }
 }
 
 
diff --git a/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalPoints.C b/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalPoints.C
index da811b1a1b..e481fc4c49 100644
--- a/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalPoints.C
+++ b/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalPoints.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -25,91 +25,18 @@ License
 
 #include "globalPoints.H"
 #include "processorPolyPatch.H"
-#include "processorCyclicPolyPatch.H"
 #include "cyclicPolyPatch.H"
 #include "polyMesh.H"
+#include "mapDistribute.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 defineTypeNameAndDebug(Foam::globalPoints, 0);
 
-const Foam::label Foam::globalPoints::fromCollocated = labelMax/2;
-
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-// Routines to handle global indices
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Foam::label Foam::globalPoints::toGlobal
-(
-    const label localPointI,
-    const bool isCollocated
-) const
-{
-    label globalPointI = globalIndices_.toGlobal(localPointI);
-
-    if (isCollocated)
-    {
-        return globalPointI + fromCollocated;
-    }
-    else
-    {
-        return globalPointI;
-    }
-}
-
-
-bool Foam::globalPoints::isCollocated(const label globalI) const
-{
-    return globalI >= fromCollocated;
-}
-
-
-Foam::label Foam::globalPoints::removeCollocated(const label globalI) const
-{
-    if (globalI >= fromCollocated)
-    {
-        return globalI - fromCollocated;
-    }
-    else
-    {
-        return globalI;
-    }
-}
-
-
-bool Foam::globalPoints::isLocal(const label globalI) const
-{
-    return globalIndices_.isLocal(removeCollocated(globalI));
-}
-
-
-Foam::label Foam::globalPoints::whichProcID(const label globalI) const
-{
-    return globalIndices_.whichProcID(removeCollocated(globalI));
-}
-
-
-Foam::label Foam::globalPoints::toLocal
-(
-    const label procI,
-    const label globalI
-) const
-{
-    return globalIndices_.toLocal(procI, removeCollocated(globalI));
-}
-
-
-Foam::label Foam::globalPoints::toLocal(const label globalI) const
-{
-    return toLocal(Pstream::myProcNo(), globalI);
-}
-
-
-// Collect all topological information about a point on a patch.
-
-// Total number of points on processor patches. Is upper limit for number
+// Total number of points on coupled patches. Is upper limit for number
 // of shared points
 Foam::label Foam::globalPoints::countPatchPoints
 (
@@ -121,34 +48,54 @@ Foam::label Foam::globalPoints::countPatchPoints
     forAll(patches, patchI)
     {
         const polyPatch& pp = patches[patchI];
-
-        if
-        (
-            (Pstream::parRun() && isA<processorPolyPatch>(pp))
-         || isA<cyclicPolyPatch>(pp)
-        )
+        if (pp.coupled())
         {
             nTotPoints += pp.nPoints();
         }
     }
-
     return nTotPoints;
 }
 
 
+Foam::labelPairList Foam::globalPoints::addSendTransform
+(
+    const label patchI,
+    const labelPairList& info
+) const
+{
+    labelPairList sendInfo(info.size());
+
+    forAll(info, i)
+    {
+        sendInfo[i] = globalIndexAndTransform::encode
+        (
+            globalIndexAndTransform::processor(info[i]),
+            globalIndexAndTransform::index(info[i]),
+            globalTransforms_.addToTransformIndex
+            (
+                globalIndexAndTransform::transformIndex(info[i]),
+                patchI,
+                true           // patchI is sending side
+            )
+        );
+    }
+    return sendInfo;
+}
+
+
 // Collect all topological information about a point on a patch.
 // (this information is the patch faces using the point and the relative
 // position of the point in the face)
 void Foam::globalPoints::addToSend
 (
-    const primitivePatch& pp,
+    const polyPatch& pp,
     const label patchPointI,
-    const labelList& knownInfo,
+    const labelPairList& knownInfo,
 
     DynamicList<label>& patchFaces,
     DynamicList<label>& indexInFace,
-    DynamicList<labelList>& allInfo
-)
+    DynamicList<labelPairList>& allInfo
+) const
 {
     label meshPointI = pp.meshPoints()[patchPointI];
 
@@ -164,7 +111,9 @@ void Foam::globalPoints::addToSend
 
         patchFaces.append(patchFaceI);
         indexInFace.append(findIndex(f, meshPointI));
-        allInfo.append(knownInfo);
+
+        // Add patch transformation
+        allInfo.append(addSendTransform(pp.index(), knownInfo));
     }
 }
 
@@ -173,29 +122,82 @@ void Foam::globalPoints::addToSend
 // nbrInfo is for a point a list of all the global points using it
 bool Foam::globalPoints::mergeInfo
 (
-    const labelList& nbrInfo,
-    labelList& myInfo
+    const labelPairList& nbrInfo,
+    const label localPointI,
+    labelPairList& myInfo
 )
 {
-    labelList newInfo(myInfo);
+    bool anyChanged = false;
+
+    labelPairList newInfo(myInfo);
     label newI = newInfo.size();
     newInfo.setSize(newI + nbrInfo.size());
 
     forAll(nbrInfo, i)
     {
-        label index = findIndex(myInfo, nbrInfo[i]);
+        const labelPair& info = nbrInfo[i];
+        label nbrProcI = globalIndexAndTransform::processor(info);
+        label nbrIndex = globalIndexAndTransform::index(info);
+        label nbrTransform = globalIndexAndTransform::transformIndex(info);
 
-        if (index == -1)
+        // Check if already have information about nbr point. There are two
+        // possibilities:
+        // - information found about same point but different transform.
+        //   Combine transforms
+        // - information not found.
+
+        label myIndex = -1;
+        forAll(myInfo, myI)
         {
+            if (myInfo[myI] == info)
+            {
+                // Fully identical. We already have nbrInfo.
+                myIndex = myI;
+            }
+            else if
+            (
+                globalIndexAndTransform::processor(myInfo[myI]) == nbrProcI
+             && globalIndexAndTransform::index(myInfo[myI]) == nbrIndex
+            )
+            {
+                // Only differing is the transform.
+                label myTransform = globalIndexAndTransform::transformIndex
+                (
+                    myInfo[myI]
+                );
+
+                // Combine mine and nbr transform
+                label t = globalIndexAndTransform::mergeTransformIndex
+                (
+                    nbrTransform,
+                    myTransform
+                );
+                myIndex = myI;
+
+                if (t != myTransform)
+                {
+                    // Same point but different transformation
+                    newInfo[myI] = globalIndexAndTransform::encode
+                    (
+                        nbrProcI,
+                        nbrIndex,
+                        t
+                    );
+                    anyChanged = true;
+                    break;
+                }
+            }
+        }
+
+        if (myIndex == -1)
+        {
+            // New point
             newInfo[newI++] = nbrInfo[i];
+            anyChanged = true;
         }
     }
 
     newInfo.setSize(newI);
-
-    // Did anything change?
-    bool anyChanged = (newI > myInfo.size());
-
     myInfo.transfer(newInfo);
 
     return anyChanged;
@@ -234,11 +236,10 @@ Foam::label Foam::globalPoints::localToMeshPoint
 
 // Updates database of current information on meshpoints with nbrInfo.
 // Uses mergeInfo above. Returns true if data kept for meshPointI changed.
-bool Foam::globalPoints::storeInfo
+bool Foam::globalPoints::mergeInfo
 (
-    const labelList& nbrInfo,
-    const label localPointI,
-    const bool isCollocated
+    const labelPairList& nbrInfo,
+    const label localPointI
 )
 {
     label infoChanged = false;
@@ -248,16 +249,26 @@ bool Foam::globalPoints::storeInfo
 
     if (iter != meshToProcPoint_.end())
     {
-        if (mergeInfo(nbrInfo, procPoints_[iter()]))
+        if (mergeInfo(nbrInfo, localPointI, procPoints_[iter()]))
         {
             infoChanged = true;
         }
     }
     else
     {
-        labelList knownInfo(1, toGlobal(localPointI, isCollocated));
+        // Construct local index for point
+        labelPairList knownInfo
+        (
+            1,
+            globalIndexAndTransform::encode
+            (
+                Pstream::myProcNo(),
+                localPointI,
+                globalTransforms_.nullTransformIndex()
+            )
+        );
 
-        if (mergeInfo(nbrInfo, knownInfo))
+        if (mergeInfo(nbrInfo, localPointI, knownInfo))
         {
             // Update addressing from into procPoints
             meshToProcPoint_.insert(localPointI, procPoints_.size());
@@ -271,42 +282,85 @@ bool Foam::globalPoints::storeInfo
 }
 
 
+// Updates database of current information on meshpoints with nbrInfo.
+// Uses mergeInfo above. Returns true if data kept for meshPointI changed.
+bool Foam::globalPoints::storeInitialInfo
+(
+    const labelPairList& nbrInfo,
+    const label localPointI
+)
+{
+    label infoChanged = false;
+
+    // Get the index into the procPoints list.
+    Map<label>::iterator iter = meshToProcPoint_.find(localPointI);
+
+    if (iter != meshToProcPoint_.end())
+    {
+        if (mergeInfo(nbrInfo, localPointI, procPoints_[iter()]))
+        {
+            infoChanged = true;
+        }
+    }
+    else
+    {
+        // Update addressing into procPoints
+        meshToProcPoint_.insert(localPointI, procPoints_.size());
+        // Insert into list of equivalences.
+        procPoints_.append(nbrInfo);
+
+        infoChanged = true;
+    }
+    return infoChanged;
+}
+
+
+Foam::FixedList<Foam::label, 3> Foam::globalPoints::transformBits
+(
+    const label transformIndex
+) const
+{
+    label t = transformIndex;
+
+    // Decode permutation as 3 integers
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // Note: FixedList for speed reasons.
+    FixedList<label, 3> permutation;
+    permutation[0] = (t%3)-1;
+    t /= 3;
+    permutation[1] = (t%3)-1;
+    t /= 3;
+    permutation[2] = (t%3)-1;
+
+    return permutation;
+}
+
+
 void Foam::globalPoints::printProcPoints
 (
     const labelList& patchToMeshPoint,
-    const labelList& pointInfo,
-    Ostream& os
+    const labelPairList& pointInfo
 ) const
 {
     forAll(pointInfo, i)
     {
-        label globalI = pointInfo[i];
+        label procI = globalIndexAndTransform::processor(pointInfo[i]);
+        label index = globalIndexAndTransform::index(pointInfo[i]);
+        label trafoI = globalIndexAndTransform::transformIndex(pointInfo[i]);
 
-        label procI = whichProcID(globalI);
-        os  << "    connected to proc " << procI;
+        Pout<< "proc:" << procI;
+        Pout<< " localpoint:";
+        Pout<< index;
+        Pout<< " through transform:"
+            << trafoI << " bits:" << transformBits(trafoI);
 
-        if (isCollocated(globalI))
+        if (procI == Pstream::myProcNo())
         {
-            os  << " collocated localpoint:";
-        }
-        else
-        {
-            os  << " separated localpoint:";
+            label meshPointI = localToMeshPoint(patchToMeshPoint, index);
+            Pout<< " at:" <<  mesh_.points()[meshPointI];
         }
 
-        os  << toLocal(procI, globalI);
-
-        if (isLocal(globalI))
-        {
-            label meshPointI = localToMeshPoint
-            (
-                patchToMeshPoint,
-                toLocal(globalI)
-            );
-            os  << " at:" <<  mesh_.points()[meshPointI];
-        }
-
-        os  << endl;
+        Pout<< endl;
     }
 }
 
@@ -325,16 +379,8 @@ void Foam::globalPoints::initOwnPoints
     {
         const polyPatch& pp = patches[patchI];
 
-        if
-        (
-            (Pstream::parRun() && isA<processorPolyPatch>(pp))
-         || isA<cyclicPolyPatch>(pp)
-        )
+        if (pp.coupled())
         {
-            // Assume all processor points are collocated and all
-            // processorCyclic and cyclic are separated.
-            bool isCollocatedPoint = isType<processorPolyPatch>(pp);
-
             const labelList& meshPoints = pp.meshPoints();
 
             if (allPoints)
@@ -348,19 +394,23 @@ void Foam::globalPoints::initOwnPoints
                         meshToPatchPoint,
                         meshPointI
                     );
-                    labelList knownInfo
+
+                    labelPairList knownInfo
                     (
                         1,
-                        toGlobal(localPointI, isCollocatedPoint)
+                        globalIndexAndTransform::encode
+                        (
+                            Pstream::myProcNo(),
+                            localPointI,
+                            globalTransforms_.nullTransformIndex()
+                        )
                     );
 
-                    // Update addressing from point to index in procPoints
-                    meshToProcPoint_.insert(localPointI, procPoints_.size());
-                    // Insert into list of equivalences.
-                    procPoints_.append(knownInfo);
-
                     // Update changedpoints info.
-                    changedPoints.insert(localPointI);
+                    if (storeInitialInfo(knownInfo, localPointI))
+                    {
+                        changedPoints.insert(localPointI);
+                    }
                 }
             }
             else
@@ -377,19 +427,21 @@ void Foam::globalPoints::initOwnPoints
                         meshPointI
                     );
 
-                    labelList knownInfo
+                    labelPairList knownInfo
                     (
                         1,
-                        toGlobal(localPointI, isCollocatedPoint)
+                        globalIndexAndTransform::encode
+                        (
+                            Pstream::myProcNo(),
+                            localPointI,
+                            globalTransforms_.nullTransformIndex()
+                        )
                     );
 
-                    // Update addressing from point to index in procPoints
-                    meshToProcPoint_.insert(localPointI, procPoints_.size());
-                    // Insert into list of equivalences.
-                    procPoints_.append(knownInfo);
-
-                    // Update changedpoints info.
-                    changedPoints.insert(localPointI);
+                    if (storeInitialInfo(knownInfo, localPointI))
+                    {
+                        changedPoints.insert(localPointI);
+                    }
                 }
             }
         }
@@ -407,23 +459,21 @@ void Foam::globalPoints::sendPatchPoints
 ) const
 {
     const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+    const labelPairList& patchInfo = globalTransforms_.patchTransformSign();
 
     forAll(patches, patchI)
     {
         const polyPatch& pp = patches[patchI];
 
+        // mergeSeparated=true : send from all processor patches
+        //               =false: send from ones without transform
+
         if
         (
-            Pstream::parRun()
-         && (
-                isType<processorPolyPatch>(pp)
-             || (mergeSeparated && isA<processorCyclicPolyPatch>(pp))
-            )
+            (Pstream::parRun() && isA<processorPolyPatch>(pp))
+         && (mergeSeparated || patchInfo[patchI].first() == -1)
         )
         {
-            // processor cyclics are considered separated, pure processor
-            // always collocated.
-
             const processorPolyPatch& procPatch =
                 refCast<const processorPolyPatch>(pp);
 
@@ -433,7 +483,7 @@ void Foam::globalPoints::sendPatchPoints
             // index in patch face
             DynamicList<label> indexInFace(pp.nPoints());
             // all information I currently hold about this patchPoint
-            DynamicList<labelList> allInfo(pp.nPoints());
+            DynamicList<labelPairList> allInfo(pp.nPoints());
 
 
             // Now collect information on all points mentioned in
@@ -455,10 +505,10 @@ void Foam::globalPoints::sendPatchPoints
                 {
                     label index = meshToProcPoint_[localPointI];
 
-                    const labelList& knownInfo = procPoints_[index];
+                    const labelPairList& knownInfo = procPoints_[index];
 
                     // Add my information about localPointI to the
-                    // send buffers
+                    // send buffers. Encode the transformation
                     addToSend
                     (
                         pp,
@@ -496,11 +546,13 @@ void Foam::globalPoints::receivePatchPoints
 (
     const bool mergeSeparated,
     const Map<label>& meshToPatchPoint,
+    const labelList& patchToMeshPoint,
     PstreamBuffers& pBufs,
     labelHashSet& changedPoints
 )
 {
     const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+    const labelPairList& patchInfo = globalTransforms_.patchTransformSign();
 
     // Reset changed points
     changedPoints.clear();
@@ -511,22 +563,16 @@ void Foam::globalPoints::receivePatchPoints
 
         if
         (
-            Pstream::parRun()
-         && (
-                isType<processorPolyPatch>(pp)
-             || (mergeSeparated && isA<processorCyclicPolyPatch>(pp))
-            )
+            (Pstream::parRun() && isA<processorPolyPatch>(pp))
+         && (mergeSeparated || patchInfo[patchI].first() == -1)
         )
         {
             const processorPolyPatch& procPatch =
                 refCast<const processorPolyPatch>(pp);
 
-            // Processor patch is always collocated, processorCyclic is not.
-            bool isCollocatedPoint = isType<processorPolyPatch>(pp);
-
             labelList patchFaces;
             labelList indexInFace;
-            List<labelList> nbrInfo;
+            List<labelPairList> nbrInfo;
 
             {
                 UIPstream fromNeighbour(procPatch.neighbProcNo(), pBufs);
@@ -556,13 +602,20 @@ void Foam::globalPoints::receivePatchPoints
                     meshPointI
                 );
 
-                if (storeInfo(nbrInfo[i], localPointI, isCollocatedPoint))
+                if (mergeInfo(nbrInfo[i], localPointI))
                 {
                     changedPoints.insert(localPointI);
                 }
             }
         }
-        else if (mergeSeparated && isA<cyclicPolyPatch>(pp))
+        else if
+        (
+            (
+                isA<cyclicPolyPatch>(pp)
+             && refCast<const cyclicPolyPatch>(pp).owner()
+            )
+         && (mergeSeparated || patchInfo[patchI].first() == -1)
+        )
         {
             // Handle cyclics: send lower half to upper half and vice versa.
             // Or since they both are in memory just do it point by point.
@@ -570,6 +623,8 @@ void Foam::globalPoints::receivePatchPoints
             const cyclicPolyPatch& cycPatch =
                 refCast<const cyclicPolyPatch>(pp);
 
+            //Pout<< "Patch:" << patchI << " name:" << pp.name() << endl;
+
             const labelList& meshPoints = pp.meshPoints();
             const labelList coupledMeshPoints(reverseMeshPoints(cycPatch));
 
@@ -578,6 +633,11 @@ void Foam::globalPoints::receivePatchPoints
                 label meshPointA = meshPoints[i];
                 label meshPointB = coupledMeshPoints[i];
 
+                //Pout<< "Connection between point " << meshPointA
+                //    << " at " << mesh_.points()[meshPointA]
+                //    << " and " << meshPointB
+                //    << " at " << mesh_.points()[meshPointB] << endl;
+
                 label localA = meshToLocalPoint
                 (
                     meshToPatchPoint,
@@ -594,24 +654,58 @@ void Foam::globalPoints::receivePatchPoints
                 Map<label>::iterator procPointA =
                     meshToProcPoint_.find(localA);
 
+                labelPairList infoA;
                 if (procPointA != meshToProcPoint_.end())
                 {
-                    // Store A info onto pointB
-                    if (storeInfo(procPoints_[procPointA()], localB, false))
-                    {
-                        changedPoints.insert(localB);
-                    }
+                    infoA = addSendTransform
+                    (
+                        cycPatch.index(),
+                        procPoints_[procPointA()]
+                    );
                 }
 
                 // Same for info on pointB
                 Map<label>::iterator procPointB =
                     meshToProcPoint_.find(localB);
 
+                labelPairList infoB;
                 if (procPointB != meshToProcPoint_.end())
                 {
-                    // Store B info onto pointA
-                    if (storeInfo(procPoints_[procPointB()], localA, false))
+                    infoB = addSendTransform
+                    (
+                        cycPatch.neighbPatchID(),
+                        procPoints_[procPointB()]
+                    );
+                }
+
+
+                if (infoA.size())
+                {
+                    if (mergeInfo(infoA, localB))
                     {
+                        //Pout<< "  Combined info at point "
+                        //    << mesh_.points()[meshPointB]
+                        //    << " now " << endl;
+                        //printProcPoints
+                        //(
+                        //    patchToMeshPoint,
+                        //    procPoints_[meshToProcPoint_[localB]]
+                        //);
+                        changedPoints.insert(localB);
+                    }
+                }
+                if (infoB.size())
+                {
+                    if (mergeInfo(infoB, localA))
+                    {
+                        //Pout<< "  Combined info at point "
+                        //    << mesh_.points()[meshPointA]
+                        //    << " now " << endl;
+                        //printProcPoints
+                        //(
+                        //    patchToMeshPoint,
+                        //    procPoints_[meshToProcPoint_[localA]]
+                        //);
                         changedPoints.insert(localA);
                     }
                 }
@@ -630,17 +724,16 @@ void Foam::globalPoints::remove
 )
 {
     // Save old ones.
-    Map<label> oldMeshToProcPoint(meshToProcPoint_);
-    meshToProcPoint_.clear();
-
-    List<labelList> oldProcPoints;
-    oldProcPoints.transfer(procPoints_);
+    Map<label> oldMeshToProcPoint(meshToProcPoint_.xfer());
+    meshToProcPoint_.resize(oldMeshToProcPoint.size());
+    DynamicList<labelPairList> oldProcPoints(procPoints_.xfer());
+    procPoints_.setCapacity(oldProcPoints.size());
 
     // Go through all equivalences
     forAllConstIter(Map<label>, oldMeshToProcPoint, iter)
     {
         label localPointI = iter.key();
-        const labelList& pointInfo = oldProcPoints[iter()];
+        const labelPairList& pointInfo = oldProcPoints[iter()];
 
         if (pointInfo.size() == 2)
         {
@@ -649,32 +742,40 @@ void Foam::globalPoints::remove
             // is in it. This would be an ordinary connection and can be
             // handled by normal face-face connectivity.
 
-            const label a = pointInfo[0];
-            const label b = pointInfo[1];
+            label proc0 = globalIndexAndTransform::processor(pointInfo[0]);
+            label proc1 = globalIndexAndTransform::processor(pointInfo[1]);
 
             if
             (
                 (
-                    isLocal(a)
-                 && directNeighbours.found(toLocal(a))
+                    proc0 == Pstream::myProcNo()
+                 && directNeighbours.found
+                    (
+                        globalIndexAndTransform::index(pointInfo[0])
+                    )
                 )
              || (
-                    isLocal(b)
-                 && directNeighbours.found(toLocal(b))
+                    proc1 == Pstream::myProcNo()
+                 && directNeighbours.found
+                    (
+                        globalIndexAndTransform::index(pointInfo[1])
+                    )
                 )
             )
             {
                 // Normal faceNeighbours
-                if (isLocal(a))
+                if (proc0 == Pstream::myProcNo())
                 {
                     //Pout<< "Removing direct neighbour:"
-                    //    << mesh_.points()[a[1]]
+                    //    << mesh_.points()
+                    //       [globalIndexAndTransform::index(pointInfo[0])]
                     //    << endl;
                 }
-                else if (isLocal(b))
+                else if (proc1 == Pstream::myProcNo())
                 {
                     //Pout<< "Removing direct neighbour:"
-                    //    << mesh_.points()[b[1]]
+                    //    << mesh_.points()
+                    //       [globalIndexAndTransform::index(pointInfo[1])]
                     //    << endl;
                 }
             }
@@ -703,8 +804,12 @@ void Foam::globalPoints::remove
             // So this meshPoint will have info of size one only.
             if
             (
-                !isLocal(pointInfo[0])
-             || !directNeighbours.found(toLocal(pointInfo[0]))
+                globalIndexAndTransform::processor(pointInfo[0])
+             != Pstream::myProcNo()
+             || !directNeighbours.found
+                (
+                    globalIndexAndTransform::index(pointInfo[0])
+                )
             )
             {
                 meshToProcPoint_.insert(localPointI, procPoints_.size());
@@ -719,439 +824,7 @@ void Foam::globalPoints::remove
     }
 
     procPoints_.shrink();
-}
-
-
-// Compact indices
-void Foam::globalPoints::compact(const labelList& patchToMeshPoint)
-{
-    labelList oldToNew(procPoints_.size(), -1);
-    labelList newToOld(meshToProcPoint_.size());
-
-    label newIndex = 0;
-    forAllConstIter(Map<label>, meshToProcPoint_, iter)
-    {
-        label oldIndex = iter();
-
-        if (oldToNew[oldIndex] == -1)
-        {
-            // Check if one of the procPoints already is merged.
-            const labelList& pointInfo = procPoints_[oldIndex];
-
-            if (pointInfo.size() >= 2)
-            {
-                // Merge out single entries
-
-                label minIndex = labelMax;
-
-                forAll(pointInfo, i)
-                {
-                    if (isLocal(pointInfo[i]))
-                    {
-                        label localI = toLocal(pointInfo[i]);
-
-                        // Is localPoint itself already merged?
-                        label index = meshToProcPoint_[localI];
-
-                        //Pout<< "        found point:" << localI
-                        //    << " with current index " << index << endl;
-
-                        if (oldToNew[index] != -1)
-                        {
-                            minIndex = min(minIndex, oldToNew[index]);
-                        }
-                    }
-                }
-
-                if (minIndex < labelMax && minIndex != oldIndex)
-                {
-                    // Make my index point to minIndex
-                    oldToNew[oldIndex] = minIndex;
-                }
-                else
-                {
-                    // Nothing compacted yet. Allocate new index.
-                    oldToNew[oldIndex] = newIndex;
-                    newToOld[newIndex] = oldIndex;
-                    newIndex++;
-                }
-            }
-            else
-            {
-                //Pout<< "Removed singlepoint pointI:" << iter.key()
-                //    << " currentindex:" << iter()
-                //    << endl;
-            }
-        }
-    }
-
-    // Redo indices
-    Map<label> oldMeshToProcPoint(meshToProcPoint_.xfer());
-    forAllConstIter(Map<label>, oldMeshToProcPoint, iter)
-    {
-        label newIndex = oldToNew[iter()];
-        if (newIndex != -1)
-        {
-            meshToProcPoint_.insert(iter.key(), newIndex);
-        }
-    }
-
-    List<labelList> oldProcPoints;
-    oldProcPoints.transfer(procPoints_);
-
-    newToOld.setSize(newIndex);
-
-    procPoints_.setSize(newIndex);
-
-    forAll(procPoints_, i)
-    {
-        // Transfer
-        procPoints_[i].transfer(oldProcPoints[newToOld[i]]);
-    }
-}
-
-
-// Get (indices of) points for which I am master (= lowest numbered point on
-// lowest numbered processor).
-// (equivalence lists should be complete by now)
-Foam::labelList Foam::globalPoints::getMasterPoints
-(
-    const labelList& patchToMeshPoint
-) const
-{
-    //labelList masterPoints(nPatchPoints_);
-    //label nMaster = 0;
-
-    labelHashSet masterPointSet(nPatchPoints_);
-
-
-    // Go through all equivalences and determine points where I am master.
-    forAllConstIter(Map<label>, meshToProcPoint_, iter)
-    {
-        label localPointI = iter.key();
-        const labelList& pointInfo = procPoints_[iter()];
-
-        if (pointInfo.size() < 2)
-        {
-            // Points should have an equivalence list >= 2 since otherwise
-            // they would be direct neighbours and have been removed in the
-            // call to 'remove'.
-            label meshPointI = localToMeshPoint(patchToMeshPoint, localPointI);
-
-            FatalErrorIn("globalPoints::getMasterPoints(..)")
-                << '[' << Pstream::myProcNo() << ']'
-                << " MeshPoint:" << meshPointI
-                << " coord:" << mesh_.points()[meshPointI]
-                << " has no corresponding point on a neighbouring processor"
-                << abort(FatalError);
-        }
-        else
-        {
-            // Check if lowest numbered processor and point is
-            // on this processor. Since already sorted is first element.
-
-            if
-            (
-                isLocal(pointInfo[0])
-             && toLocal(pointInfo[0]) == localPointI
-            )
-            {
-                // I am lowest numbered processor and point. Add to my list.
-                //masterPoints[nMaster++] = localPointI;
-                masterPointSet.insert(localPointI);
-            }
-        }
-    }
-
-    return masterPointSet.toc();
-}
-
-
-// Send subset of lists.
-// Note: might not be used if separated
-void Foam::globalPoints::sendSharedPoints
-(
-    const bool mergeSeparated,
-    PstreamBuffers& pBufs,
-    const DynamicList<label>& changedIndices
-) const
-{
-    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
-
-    forAll(patches, patchI)
-    {
-        const polyPatch& pp = patches[patchI];
-
-        if
-        (
-            Pstream::parRun()
-         && (
-                isType<processorPolyPatch>(pp)
-             || (mergeSeparated && isA<processorCyclicPolyPatch>(pp))
-            )
-        )
-        {
-            const processorPolyPatch& procPatch =
-                refCast<const processorPolyPatch>(pp);
-
-            UOPstream toNeighbour(procPatch.neighbProcNo(), pBufs);
-
-            if (debug)
-            {
-                Pout<< "Sending to " << procPatch.neighbProcNo()
-                    << "  changed sharedPoints info:"
-                    << changedIndices.size() << endl;
-            }
-
-            // Send over changed elements
-            toNeighbour
-                << UIndirectList<label>(sharedPointAddr_, changedIndices)()
-                << UIndirectList<label>(sharedPointLabels_, changedIndices)();
-        }
-    }
-}
-
-
-// Check if any connected local points already have a sharedPoint. This handles
-// locally connected points.
-void Foam::globalPoints::extendSharedPoints
-(
-    const Map<label>& meshToShared,
-    DynamicList<label>& changedIndices
-)
-{
-    forAllConstIter(Map<label>, meshToProcPoint_, iter)
-    {
-        label localI = iter.key();
-        label sharedI = meshToShared[localI];
-
-        if (sharedPointLabels_[sharedI] == -1)
-        {
-            // No sharedpoint yet for me. Check if any of my connected
-            // points have.
-
-            const labelList& pointInfo = procPoints_[iter()];
-            forAll(pointInfo, i)
-            {
-                if (isLocal(pointInfo[i]))
-                {
-                    label nbrLocalI = toLocal(pointInfo[i]);
-                    label nbrSharedI = meshToShared[nbrLocalI];
-
-                    if (sharedPointAddr_[nbrSharedI] != -1)
-                    {
-                        // I do have a sharedpoint for nbrSharedI. Reuse it.
-                        sharedPointLabels_[sharedI] = localI;
-                        sharedPointAddr_[sharedI] =
-                            sharedPointAddr_[nbrSharedI];
-                        changedIndices.append(sharedI);
-                        break;
-                    }
-                }
-            }
-        }
-    }
-}
-
-
-// Receive shared point indices for all my shared points. Note that since
-// there are only a few here we can build a reverse map using the point label
-// instead of doing all this relative point indexing (patch face + index in
-// face) as in send/receivePatchPoints
-void Foam::globalPoints::receiveSharedPoints
-(
-    const bool mergeSeparated,
-    const Map<label>& meshToPatchPoint,
-    const Map<label>& meshToShared,
-    PstreamBuffers& pBufs,
-    DynamicList<label>& changedIndices
-)
-{
-    changedIndices.clear();
-
-    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
-
-    // Receive and set shared points
-    forAll(patches, patchI)
-    {
-        const polyPatch& pp = patches[patchI];
-
-        if
-        (
-            Pstream::parRun()
-         && (
-                isType<processorPolyPatch>(pp)
-             || (mergeSeparated && isA<processorCyclicPolyPatch>(pp))
-            )
-        )
-        {
-            const processorPolyPatch& procPatch =
-                refCast<const processorPolyPatch>(pp);
-
-            // Map from neighbouring mesh or patch point to sharedPoint)
-            Map<label> nbrSharedPoints(sharedPointAddr_.size());
-
-            {
-                // Receive points on neighbour and sharedPoints and build
-                // map from it. Note that we could have built the map on the
-                // neighbour and sent it over.
-                labelList nbrSharedPointAddr;
-                labelList nbrSharedPointLabels;
-
-                {
-                    UIPstream fromNeighbour(procPatch.neighbProcNo(), pBufs);
-                    fromNeighbour >> nbrSharedPointAddr >> nbrSharedPointLabels;
-                }
-
-                // Insert into to map
-                forAll(nbrSharedPointLabels, i)
-                {
-                    nbrSharedPoints.insert
-                    (
-                        nbrSharedPointLabels[i], // mesh/patchpoint on neighbour
-                        nbrSharedPointAddr[i]    // sharedPoint label
-                    );
-                }
-            }
-
-
-            // Merge into whatever information I hold.
-            forAllConstIter(Map<label>, meshToProcPoint_, iter)
-            {
-                label localPointI = iter.key();
-                label sharedI = meshToShared[localPointI];
-
-                if (sharedPointAddr_[sharedI] == -1)
-                {
-                    // No shared point known yet for this point.
-                    // See if was received from neighbour.
-                    const labelList& knownInfo = procPoints_[iter()];
-
-                    // Check through the whole equivalence list for any
-                    // point from the neighbour.
-                    forAll(knownInfo, j)
-                    {
-                        const label info = knownInfo[j];
-                        label procI = whichProcID(info);
-                        label pointI = toLocal(procI, info);
-
-                        if
-                        (
-                            procI == procPatch.neighbProcNo()
-                         && nbrSharedPoints.found(pointI)
-                        )
-                        {
-                            // So this knownInfo contains the neighbour point
-                            label sharedPointI = nbrSharedPoints[pointI];
-
-                            sharedPointAddr_[sharedI] = sharedPointI;
-                            sharedPointLabels_[sharedI] = localPointI;
-                            changedIndices.append(sharedI);
-
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-        else if (mergeSeparated && isA<cyclicPolyPatch>(pp))
-        {
-            const cyclicPolyPatch& cycPatch =
-                refCast<const cyclicPolyPatch>(pp);
-
-            // Build map from mesh or patch point to sharedPoint.
-            Map<label> localToSharedPoint(sharedPointAddr_.size());
-            forAll(sharedPointLabels_, i)
-            {
-                if (sharedPointLabels_[i] != -1)
-                {
-                    localToSharedPoint.insert
-                    (
-                        sharedPointLabels_[i],
-                        sharedPointAddr_[i]
-                    );
-                }
-            }
-
-            // Sync all info.
-
-            const labelList& meshPoints = cycPatch.meshPoints();
-            const labelList coupledMeshPoints(reverseMeshPoints(cycPatch));
-
-            forAll(meshPoints, i)
-            {
-                label meshPointA = meshPoints[i];
-                label meshPointB = coupledMeshPoints[i];
-
-                label localA = meshToLocalPoint
-                (
-                    meshToPatchPoint,
-                    meshPointA
-                );
-                label localB = meshToLocalPoint
-                (
-                    meshToPatchPoint,
-                    meshPointB
-                );
-
-                // Do we already have shared point for pointA?
-                Map<label>::iterator fndA = localToSharedPoint.find(localA);
-                Map<label>::iterator fndB = localToSharedPoint.find(localB);
-
-                if (fndA != localToSharedPoint.end())
-                {
-                    if (fndB != localToSharedPoint.end())
-                    {
-                        if (fndA() != fndB())
-                        {
-                            FatalErrorIn
-                            (
-                                "globalPoints::receiveSharedPoints(..)"
-                            )   << "On patch " << pp.name()
-                                << " connected points " << meshPointA
-                                << ' ' << mesh_.points()[meshPointA]
-                                << " and " << meshPointB
-                                << ' ' << mesh_.points()[meshPointB]
-                                << " are mapped to different shared"
-                                << " points: "
-                                << fndA() << " and " << fndB()
-                                << abort(FatalError);
-                        }
-                    }
-                    else
-                    {
-                        // No shared point yet for B.
-                        label sharedPointI = fndA();
-
-                        // Store shared point for pointB
-                        label sharedI = meshToShared[localB];
-
-                        sharedPointAddr_[sharedI] = sharedPointI;
-                        sharedPointLabels_[sharedI] = localB;
-                        changedIndices.append(sharedI);
-                    }
-                }
-                else
-                {
-                    // No shared point yet for A.
-                    if (fndB != localToSharedPoint.end())
-                    {
-                        label sharedPointI = fndB();
-
-                        // Store shared point for pointA
-                        label sharedI = meshToShared[localA];
-
-                        sharedPointAddr_[sharedI] = sharedPointI;
-                        sharedPointLabels_[sharedI] = localA;
-                        changedIndices.append(sharedI);
-                    }
-                }
-            }
-        }
-    }
-
-    // Extend shared points from local connections.
-    extendSharedPoints(meshToShared, changedIndices);
+    meshToProcPoint_.resize(2*procPoints_.size());
 }
 
 
@@ -1177,6 +850,49 @@ Foam::labelList Foam::globalPoints::reverseMeshPoints
 }
 
 
+bool Foam::globalPoints::globalIndexAndTransformLessThan::operator()
+(
+    const labelPair& a,
+    const labelPair& b
+)
+{
+    label procA = globalIndexAndTransform::processor(a);
+    label procB = globalIndexAndTransform::processor(b);
+
+    if (procA < procB)
+    {
+        return true;
+    }
+    else if (procA > procB)
+    {
+        return false;
+    }
+    else
+    {
+        // Equal proc.
+        label indexA = globalIndexAndTransform::index(a);
+        label indexB = globalIndexAndTransform::index(b);
+
+        if (indexA < indexB)
+        {
+            return true;
+        }
+        else if (indexA > indexB)
+        {
+            return false;
+        }
+        else
+        {
+            // Equal index
+            label transformA = globalIndexAndTransform::transformIndex(a);
+            label transformB = globalIndexAndTransform::transformIndex(b);
+
+            return transformA < transformB;
+        }
+    }
+}
+
+
 void Foam::globalPoints::calculateSharedPoints
 (
     const Map<label>& meshToPatchPoint, // from mesh point to local numbering
@@ -1192,17 +908,8 @@ void Foam::globalPoints::calculateSharedPoints
             << endl;
     }
 
-    if (globalIndices_.size() >= fromCollocated)
-    {
-        FatalErrorIn("globalPoints::calculateSharedPoints(..)")
-            << "Integer overflow. Total number of points "
-            << globalIndices_.size()
-            << " is too large to be represented." << exit(FatalError);
-    }
 
-
-
-    labelHashSet changedPoints(nPatchPoints_);
+    labelHashSet changedPoints(2*nPatchPoints_);
 
     // Initialize procPoints with my patch points. Keep track of points
     // inserted (in changedPoints)
@@ -1243,12 +950,12 @@ void Foam::globalPoints::calculateSharedPoints
         (
             mergeSeparated,
             meshToPatchPoint,
+            patchToMeshPoint,
             pBufs,
             changedPoints
         );
     }
 
-
     // Save neighbours reachable through face-face communication.
     Map<label> neighbourList;
     if (!keepAllPoints)
@@ -1281,6 +988,7 @@ void Foam::globalPoints::calculateSharedPoints
         (
             mergeSeparated,
             meshToPatchPoint,
+            patchToMeshPoint,
             pBufs,
             changedPoints
         );
@@ -1291,184 +999,118 @@ void Foam::globalPoints::calculateSharedPoints
     } while (changed);
 
 
+    //Pout<< "**ALL** connected points:" << endl;
+    //forAllConstIter(Map<label>, meshToProcPoint_, iter)
+    //{
+    //    label localI = iter.key();
+    //    const labelPairList& pointInfo = procPoints_[iter()];
+    //    Pout<< "pointI:" << localI << " index:" << iter()
+    //        << " coord:"
+    //        << mesh_.points()[localToMeshPoint(patchToMeshPoint, localI)]
+    //        << endl;
+    //    printProcPoints(patchToMeshPoint, pointInfo);
+    //    Pout<< endl;
+    //}
+    //
+
     // Remove direct neighbours from point equivalences.
     if (!keepAllPoints)
     {
-        //Pout<< "**Removing direct neighbours:" << endl;
-        //forAllConstIter(Map<label>, neighbourList, iter)
-        //{
-        //    label localI = iter.key();
-        //    Pout<< "pointI:" << localI << " index:" << iter()
-        //        << " coord:"
-        //        << mesh_.points()[localToMeshPoint(patchToMeshPoint, localI)]
-        //        << endl;
-        //}
         remove(patchToMeshPoint, neighbourList);
     }
 
 
-    // Compact out unused elements
-    compact(patchToMeshPoint);
-
-
-
-    procPoints_.shrink();
-
-    // Sort procPoints in incremental order. This will make the master the
-    // first element.
+    // Sort procPoints in incremental order. This will make
+    // the master the first element on all processors.
+    // Note: why not sort in decreasing order? Give more work to higher
+    //       processors.
     forAllConstIter(Map<label>, meshToProcPoint_, iter)
     {
-        sort(procPoints_[iter()]);
+        labelPairList& pointInfo = procPoints_[iter()];
+        sort(pointInfo, globalIndexAndTransformLessThan());
     }
-    // We can now remove the collocated bit
-    forAll(procPoints_, index)
-    {
-        labelList& pointInfo = procPoints_[index];
-
-        forAll(pointInfo, i)
-        {
-            pointInfo[i] = removeCollocated(pointInfo[i]);
-        }
-    }
-
-
-//Pout<< "Now connected points:" << endl;
-//forAllConstIter(Map<label>, meshToProcPoint_, iter)
-//{
-//    label localI = iter.key();
-//    const labelList& pointInfo = procPoints_[iter()];
-//
-//    Pout<< "pointI:" << localI << " index:" << iter()
-//        << " coord:"
-//        << mesh_.points()[localToMeshPoint(patchToMeshPoint, localI)]
-//        << endl;
-//
-//    printProcPoints(patchToMeshPoint, pointInfo, Pout);
-//}
 
 
     // We now have - in procPoints_ - a list of points which are shared between
-    // multiple processors. These are the ones for which are sharedPoint
-    // needs to be determined. This is done by having the lowest numbered
-    // processor in the equivalence list 'ask' for a sharedPoint number
-    // and then distribute it across processor patches to the non-master
-    // processors. Note: below piece of coding is not very efficient. Uses
-    // a Map where possibly it shouldn't
+    // multiple processors. Filter into non-transformed and transformed
+    // connections.
 
-    // Initialize sharedPoint addressing. Is for every entry in procPoints_
-    // the sharedPoint.
-    sharedPointAddr_.setSize(meshToProcPoint_.size());
-    sharedPointAddr_ = -1;
-    sharedPointLabels_.setSize(meshToProcPoint_.size());
-    sharedPointLabels_ = -1;
-
-    // Get point labels of points for which I am master (lowest
-    // numbered proc)
-    labelList masterPoints(getMasterPoints(patchToMeshPoint));
-
-
-    // Get global numbering for master points
-    globalIndex globalMasterPoints(masterPoints.size());
-    nGlobalPoints_ = globalMasterPoints.size();
-
-    // Number meshToProcPoint
-    label sharedI = 0;
-    Map<label> meshToShared(meshToProcPoint_.size());
+    pointPoints_.setSize(globalIndices_.localSize());
+    List<labelPairList> transformedPoints(globalIndices_.localSize());
     forAllConstIter(Map<label>, meshToProcPoint_, iter)
     {
-        meshToShared.insert(iter.key(), sharedI++);
-    }
+        const labelPairList& pointInfo = procPoints_[iter()];
 
-    // Assign the entries for the masters
-    forAll(masterPoints, i)
-    {
-        label localPointI = masterPoints[i];
-        label sharedI = meshToShared[localPointI];
-
-        sharedPointLabels_[sharedI] = localPointI;
-        sharedPointAddr_[sharedI] = globalMasterPoints.toGlobal(i);
-    }
-
-
-    // Now we have a sharedPointLabel for some of the entries in procPoints.
-    // Send this information to neighbours. Receive their information.
-    // Loop until nothing changes.
-
-    // Initial subset to send is points for which I have sharedPoints
-    DynamicList<label> changedIndices(sharedPointAddr_.size());
-    forAll(sharedPointAddr_, i)
-    {
-        if (sharedPointAddr_[i] != -1)
+        if (pointInfo.size() >= 2)
         {
-            changedIndices.append(i);
-        }
-    }
+            // Since sorted master point is the first element
+            const labelPair& masterInfo = pointInfo[0];
 
-    // Assign local slaves from local master
-    extendSharedPoints(meshToShared, changedIndices);
-
-
-    changed = false;
-
-    do
-    {
-        if (debug)
-        {
-            Pout<< "Determined " << changedIndices.size() << " shared points."
-                << " Exchanging them" << endl;
-        }
-        PstreamBuffers pBufs
-        (
+            if
             (
-                Pstream::defaultCommsType == Pstream::scheduled
-              ? Pstream::nonBlocking
-              : Pstream::defaultCommsType
+                (
+                    globalIndexAndTransform::processor(masterInfo)
+                 == Pstream::myProcNo()
+                )
+             && (globalIndexAndTransform::index(masterInfo) == iter.key())
             )
-        );
+            {
+                labelList& pPoints = pointPoints_[iter.key()];
+                pPoints.setSize(pointInfo.size()-1);
 
-        sendSharedPoints(mergeSeparated, pBufs, changedIndices);
-        pBufs.finishedSends();
-        receiveSharedPoints
-        (
-            mergeSeparated,
-            meshToPatchPoint,
-            meshToShared,
-            pBufs,
-            changedIndices
-        );
+                labelPairList& trafoPPoints = transformedPoints[iter.key()];
+                trafoPPoints.setSize(pointInfo.size()-1);
 
-        changed = changedIndices.size() > 0;
-        reduce(changed, orOp<bool>());
+                label nonTransformI = 0;
+                label transformI = 0;
 
-    } while (changed);
+                for (label i = 1; i < pointInfo.size(); i++)
+                {
+                    labelPair info = pointInfo[i];
+                    label procI = globalIndexAndTransform::processor(info);
+                    label index = globalIndexAndTransform::index(info);
+                    label transform = globalIndexAndTransform::transformIndex
+                    (
+                        info
+                    );
 
+                    if (transform == globalTransforms_.nullTransformIndex())
+                    {
+                        pPoints[nonTransformI++] = globalIndices_.toGlobal
+                        (
+                            procI,
+                            index
+                        );
+                    }
+                    else
+                    {
+                        trafoPPoints[transformI++] = info;
+                    }
+                }
 
-//    forAll(sharedPointLabels_, sharedI)
-//    {
-//        label localI = sharedPointLabels_[sharedI];
-//
-//        Pout<< "point:" << localI
-//            << " coord:"
-//            << mesh_.points()[localToMeshPoint(patchToMeshPoint, localI)]
-//            << " ON TO GLOBAL:" << sharedPointAddr_[sharedI]
-//            << endl;
-//    }
-
-
-    forAll(sharedPointLabels_, i)
-    {
-        if (sharedPointLabels_[i] == -1)
-        {
-            FatalErrorIn("globalPoints::calculateSharedPoints(..)")
-                << "Problem: shared point on processor " << Pstream::myProcNo()
-                << " not set at index " << sharedPointLabels_[i] << endl
-                << "This might mean the individual processor domains are not"
-                << " connected and the overall domain consists of multiple"
-                << " regions. You can check this with checkMesh"
-                << abort(FatalError);
+                pPoints.setSize(nonTransformI);
+                trafoPPoints.setSize(transformI);
+            }
         }
     }
 
+
+    List<Map<label> > compactMap;
+    map_.reset
+    (
+        new mapDistribute
+        (
+            globalIndices_,
+            pointPoints_,
+
+            globalTransforms_,
+            transformedPoints,
+            transformedPointPoints_,
+
+            compactMap
+        )
+    );
+
     if (debug)
     {
         Pout<< "globalPoints::calculateSharedPoints(..) : "
@@ -1489,12 +1131,10 @@ Foam::globalPoints::globalPoints
 :
     mesh_(mesh),
     globalIndices_(mesh_.nPoints()),
+    globalTransforms_(mesh),
     nPatchPoints_(countPatchPoints(mesh.boundaryMesh())),
     procPoints_(nPatchPoints_),
-    meshToProcPoint_(nPatchPoints_),
-    sharedPointAddr_(0),
-    sharedPointLabels_(0),
-    nGlobalPoints_(0)
+    meshToProcPoint_(nPatchPoints_)
 {
     // Empty patch maps to signal storing mesh point labels
     Map<label> meshToPatchPoint(0);
@@ -1521,12 +1161,10 @@ Foam::globalPoints::globalPoints
 :
     mesh_(mesh),
     globalIndices_(coupledPatch.nPoints()),
+    globalTransforms_(mesh),
     nPatchPoints_(coupledPatch.nPoints()),
     procPoints_(nPatchPoints_),
-    meshToProcPoint_(nPatchPoints_),
-    sharedPointAddr_(0),
-    sharedPointLabels_(0),
-    nGlobalPoints_(0)
+    meshToProcPoint_(nPatchPoints_)
 {
     calculateSharedPoints
     (
diff --git a/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalPoints.H b/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalPoints.H
index 9161e67f15..ec550e87ce 100644
--- a/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalPoints.H
+++ b/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalPoints.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -39,17 +39,15 @@ Description
       - f[0] ordering on patch faces to be ok.
 
     Works by constructing equivalence lists for all the points on processor
-    patches. These list are in globalIndex numbering (so consecutively numbered
-    per processor)
+    patches. These list are in globalIndexAndTransform numbering
     E.g.
     @verbatim
           ((7 93)(4 731)(3 114))
     @endverbatim
 
     means point 93 on proc7 is connected to point 731 on proc4 and 114 on proc3.
-    It then gets the lowest numbered processor (the 'master') to request a
-    sharedPoint label from processor0 and it redistributes this label back to
-    the other processors in the equivalence list.
+    It then assigns the lowest numbered processor to be the local 'master' and
+    constructs a mapDistribute to send all data to this master.
 
     Algorithm:
         - get meshPoints of all my points on processor patches and initialize
@@ -64,24 +62,9 @@ Description
      endloop until nothing changes
 
     At this point one will have complete point-point connectivity for all
-    points on processor patches. Now
-
-        - (optional)remove point equivalences of size 2. These are
-          just normal points shared between two neighbouring procPatches.
-        - collect on each processor points for which it is the master
-        - request number of sharedPointLabels from the Pstream::master.
-
-    This information gets redistributed to all processors in a similar way
-    as that in which the equivalence lists were collected:
-
-        - initialize the indices of shared points I am the master for
-     loop
-        - send my known sharedPoints + meshPoints to all neighbours
-        - receive from all neighbour. Find which meshPoint on my processor
-          the sharedpoint is connected to
-        - mark indices for which information has changed
-     endloop until nothing changes.
-
+    points on processor patches. Now (optionally) remove point
+    equivalences of size 2. These are just normal points shared
+    between two neighbouring procPatches.
 
     Note: the data held is either mesh point labels (construct from mesh only)
     or patch point labels (construct from mesh and patch).
@@ -95,12 +78,9 @@ SourceFiles
 #define globalPoints_H
 
 #include "DynamicList.H"
-#include "Map.H"
-#include "primitivePatch.H"
-#include "edgeList.H"
-#include "globalIndex.H"
 #include "indirectPrimitivePatch.H"
-#include "PackedBoolList.H"
+#include "globalIndex.H"
+#include "globalIndexAndTransform.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -112,7 +92,7 @@ class polyMesh;
 class polyBoundaryMesh;
 class cyclicPolyPatch;
 class polyPatch;
-class coupledPolyPatch;
+class mapDistribute;
 
 /*---------------------------------------------------------------------------*\
                            Class globalPoints Declaration
@@ -120,91 +100,85 @@ class coupledPolyPatch;
 
 class globalPoints
 {
-    // Static data members
-
-        //- Offset to add to points (in globalIndices) originating from
-        //  collocated coupled points.
-        static const label fromCollocated;
-
-
     // Private data
 
         //- Mesh reference
         const polyMesh& mesh_;
 
-        //- Global numbering of points
+        //- Global numbering of untransformed points
         globalIndex globalIndices_;
 
+        //- Global numbering of transformed points
+        const globalIndexAndTransform globalTransforms_;
+
         //- Sum of points on processor patches (unfiltered, point on 2 patches
         //  counts as 2)
         const label nPatchPoints_;
 
         //- All points on boundaries and their corresponding connected points
         //  on other processors.
-        DynamicList<labelList> procPoints_;
+        DynamicList<labelPairList> procPoints_;
 
         //- Map from mesh (or patch) point to index in procPoints
         Map<label> meshToProcPoint_;
 
-        //- Shared points used by this processor (= global point number)
-        labelList sharedPointAddr_;
 
-        //- My mesh(or patch) points corresponding to the shared points
-        labelList sharedPointLabels_;
+        // Calculated mapDistribute addressing
+
+            //- Non-transformed connected points per point (in mapDistribute
+            //  indices)
+            labelListList pointPoints_;
+
+            //- Transformed points per point (in mapDistribute indices)
+            labelListList transformedPointPoints_;
+
+            //- Corresponding map
+            autoPtr<mapDistribute> map_;
 
-        //- Total number of shared points.
-        label nGlobalPoints_;
 
 
     // Private Member Functions
 
-        // Wrappers around global point numbering to add collocated bit
-
-            //- Convert into globalIndices and add collocated bit
-            label toGlobal(const label, const bool isCollocated) const;
-
-            //- Is collocated bit set
-            bool isCollocated(const label globalI) const;
-
-            //- Remove collocated bit
-            label removeCollocated(const label globalI) const;
-
-            //- (remove collocated bit and) check if originates from local proc
-            bool isLocal(const label globalI) const;
-
-            //- (remove collocated bit and) get originating processor
-            label whichProcID(const label globalI) const;
-
-            //- (remove collocated bit and) convert to local number on processor
-            label toLocal(const label procI, const label globalI) const;
-
-            //- (remove collocated bit and) convert to local number on
-            //  Pstream::myProcNo
-            label toLocal(const label globalI) const;
-
-
+        //- Helper function to sort according minimum proc, minimum index,
+        //  minimum transform
+        class globalIndexAndTransformLessThan
+        {
+            public:
+            bool operator()
+            (
+                const labelPair& a,
+                const labelPair& b
+            );
+        };
 
         //- Count all points on processorPatches. Is all points for which
         //  information is collected.
         static label countPatchPoints(const polyBoundaryMesh&);
 
+        labelPairList addSendTransform
+        (
+            const label patchI,
+            const labelPairList& info
+        ) const;
+
         //- Add information about patchPointI in relative indices to send
         //  buffers (patchFaces, indexInFace etc.)
-        static void addToSend
+        void addToSend
         (
-            const primitivePatch&,
+            const polyPatch&,
             const label patchPointI,
-            const labelList&,
+            const labelPairList&,
             DynamicList<label>& patchFaces,
             DynamicList<label>& indexInFace,
-            DynamicList<labelList>& allInfo
-        );
+            DynamicList<labelPairList>& allInfo
+        ) const;
 
         //- Merge info from neighbour into my data
         static bool mergeInfo
         (
-            const labelList& nbrInfo,
-            labelList& myInfo
+            const labelPairList& nbrInfo,
+            const label localPointI,
+            labelPairList& myInfo
         );
 
         //- From mesh point to 'local point'. Is the mesh point itself
@@ -223,18 +197,26 @@ class globalPoints
         );
 
         //- Store (and merge) info for meshPointI
-        bool storeInfo
+        bool storeInitialInfo
         (
-            const labelList& nbrInfo,
-            const label localPointI,
-            const bool isCollocated
+            const labelPairList& nbrInfo,
+            const label localPointI
         );
 
+        //- Store (and merge) info for meshPointI
+        bool mergeInfo
+        (
+            const labelPairList& nbrInfo,
+            const label localPointI
+        );
+
+        //- Get the signs for the individual transforms
+        FixedList<label, 3> transformBits(const label transformIndex) const;
+
         void printProcPoints
         (
             const labelList& patchToMeshPoint,
-            const labelList& pointInfo,
-            Ostream& os
+            const labelPairList& pointInfo
         ) const;
 
         //- Initialize procPoints_ to my patch points. allPoints = true:
@@ -260,6 +242,7 @@ class globalPoints
         (
             const bool mergeSeparated,
             const Map<label>&,
+            const labelList&,
             PstreamBuffers&,
             labelHashSet&
         );
@@ -268,34 +251,6 @@ class globalPoints
         //  Used to remove normal face-face connected points.
         void remove(const labelList& patchToMeshPoint, const Map<label>&);
 
-        //- Compact out unused elements of procPoints.
-        void compact(const labelList& patchToMeshPoint);
-
-        //- Get indices of point for which I am master (lowest numbered proc)
-        labelList getMasterPoints(const labelList& patchToMeshPoint) const;
-
-
-        //- Send subset of shared points to neighbours
-        void sendSharedPoints
-        (
-            const bool mergeSeparated,
-            PstreamBuffers&,
-            const DynamicList<label>&
-        ) const;
-
-        //- Take over any local shared points
-        void extendSharedPoints(const Map<label>&, DynamicList<label>&);
-
-        //- Receive shared points and update subset.
-        void receiveSharedPoints
-        (
-            const bool mergeSeparated,
-            const Map<label>& meshToPatchPoint,
-            const Map<label>& meshToShared,
-            PstreamBuffers&,
-            DynamicList<label>&
-        );
-
         //- Return mesh points of other side in same order as my meshPoints.
         static labelList reverseMeshPoints(const cyclicPolyPatch&);
 
@@ -325,7 +280,7 @@ public:
 
         //- Construct from mesh.
         //  keepAllPoints = false : filter out points that are on two
-        //  neighbouring coupled patches (so can be swapped)
+        //  neighbouring coupled patches only (so can be swapped)
         //  mergeSeparated:
         //      true  : merge coupled points across separated patches.
         //      false : do not merge across coupled separated patches.
@@ -338,8 +293,7 @@ public:
 
         //- Construct from mesh and patch of coupled faces. Difference with
         //  construct from mesh only is that this stores the meshToProcPoint,
-        //  procPoints and sharedPointLabels as patch local point labels
-        //  instead of mesh point labels.
+        //  procPoints as patch local point labels instead of mesh point labels.
         globalPoints
         (
             const polyMesh& mesh,
@@ -353,43 +307,68 @@ public:
 
         // Access
 
+            //- Global numbering of untransformed (mesh or patch) points
+            const globalIndex& globalIndices() const
+            {
+                return globalIndices_;
+            }
+
+            //- Global numbering of transformed (mesh or patch) points
+            const globalIndexAndTransform& globalTransforms() const
+            {
+                return globalTransforms_;
+            }
+
+            //- Non-transformed connected points per point (in mapDistribute
+            //  indices)
+            const labelListList& pointPoints() const
+            {
+                return pointPoints_;
+            }
+
+            //- Non-transformed connected points per point (in mapDistribute
+            //  indices)
+            labelListList& pointPoints()
+            {
+                return pointPoints_;
+            }
+
+            //- Transformed points per point (in mapDistribute indices)
+            const labelListList& transformedPointPoints() const
+            {
+                return transformedPointPoints_;
+            }
+
+            //- Transformed points per point (in mapDistribute indices)
+            labelListList& transformedPointPoints()
+            {
+                return transformedPointPoints_;
+            }
+
+            //- Corresponding map
+            const mapDistribute& map() const
+            {
+                return map_();
+            }
+
+            //- Corresponding map
+            mapDistribute& map()
+            {
+                return map_();
+            }
+
             //- From (mesh or patch) point to index in procPoints
             const Map<label>& meshToProcPoint() const
             {
                 return meshToProcPoint_;
             }
 
-            //- procPoints is per point the connected points (in global
-            //  point numbers)
-            const DynamicList<labelList>& procPoints() const
+            //- procPoints is per point the connected points (in
+            //  globalTransformAndIndex point numbers)
+            const DynamicList<labelPairList>& procPoints() const
             {
                 return procPoints_;
             }
-
-            //- Global numbering of (mesh or patch) points
-            const globalIndex& globalIndices() const
-            {
-                return globalIndices_;
-            }
-
-            //- shared points used by this processor (= global point number)
-            const labelList& sharedPointAddr() const
-            {
-                return sharedPointAddr_;
-            }
-
-            //- my (mesh or patch)points corresponding to the shared points
-            const labelList& sharedPointLabels() const
-            {
-                return sharedPointLabels_;
-            }
-
-            //- total number of shared points
-            label nGlobalPoints() const
-            {
-                return nGlobalPoints_;
-            }
-
 };
 
 
diff --git a/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapDistribute/mapDistribute.C b/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapDistribute/mapDistribute.C
index 1ffc3e4f73..54d8690dee 100644
--- a/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapDistribute/mapDistribute.C
+++ b/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapDistribute/mapDistribute.C
@@ -28,6 +28,7 @@ License
 #include "HashSet.H"
 #include "globalIndex.H"
 #include "globalIndexAndTransform.H"
+#include "transformField.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -199,35 +200,66 @@ void Foam::mapDistribute::checkReceivedSize
 }
 
 
-void Foam::mapDistribute::printLayout
-(
-    const label localSize,
-    List<Map<label> >& compactMap,
-    Ostream& os
-) const
+void Foam::mapDistribute::printLayout(Ostream& os) const
 {
+    // Determine offsets of remote data.
+    labelList minIndex(Pstream::nProcs(), labelMax);
+    labelList maxIndex(Pstream::nProcs(), labelMin);
+    forAll(constructMap_, procI)
+    {
+        const labelList& construct = constructMap_[procI];
+        minIndex[procI] = min(minIndex[procI], min(construct));
+        maxIndex[procI] = max(maxIndex[procI], max(construct));
+    }
+
+    label localSize;
+    if (maxIndex[Pstream::myProcNo()] == labelMin)
+    {
+        localSize = 0;
+    }
+    else
+    {
+        localSize = maxIndex[Pstream::myProcNo()]+1;
+    }
+
     os  << "Layout:" << endl
         << "local (processor " << Pstream::myProcNo() << "):" << endl
         << "    start : 0" << endl
         << "    size  : " << localSize << endl;
 
     label offset = localSize;
-    forAll(compactMap, procI)
+    forAll(minIndex, procI)
     {
         if (procI != Pstream::myProcNo())
         {
-            os  << "processor " << procI << ':' << endl
-                << "    start : " << offset << endl
-                << "    size  : " << compactMap[procI].size() << endl;
+            if (constructMap_[procI].size() > 0)
+            {
+                if (minIndex[procI] != offset)
+                {
+                    FatalErrorIn("mapDistribute::printLayout(..)")
+                        << "offset:" << offset
+                        << " procI:" << procI
+                        << " minIndex:" << minIndex[procI]
+                        << abort(FatalError);
+                }
 
-            offset += compactMap[procI].size();
+                label size = maxIndex[procI]-minIndex[procI]+1;
+                os  << "processor " << procI << ':' << endl
+                    << "    start : " << offset << endl
+                    << "    size  : " << size << endl;
+
+                offset += size;
+            }
         }
     }
     forAll(transformElements_, trafoI)
     {
-        os  << "transform " << trafoI << ':' << endl
-            << "    start : " << transformStart_[trafoI] << endl
-            << "    size  : " << transformElements_[trafoI].size() << endl;
+        if (transformElements_[trafoI].size() > 0)
+        {
+            os  << "transform " << trafoI << ':' << endl
+                << "    start : " << transformStart_[trafoI] << endl
+                << "    size  : " << transformElements_[trafoI].size() << endl;
+        }
     }
 }
 
@@ -502,8 +534,111 @@ void Foam::mapDistribute::exchangeAddressing
 }
 
 
+template<>
+void Foam::mapDistribute::applyTransforms
+(
+    const globalIndexAndTransform& globalTransforms,
+    List<point>& field,
+    const bool isPosition
+) const
+{
+    const List<vectorTensorTransform>& totalTransform =
+        globalTransforms.transformPermutations();
+
+    forAll(totalTransform, trafoI)
+    {
+        const vectorTensorTransform& vt = totalTransform[trafoI];
+        const labelList& elems = transformElements_[trafoI];
+        label n = transformStart_[trafoI];
+
+        // Could be optimised to avoid memory allocations
+
+        if (isPosition)
+        {
+            Field<point> transformFld
+            (
+                vt.transformPosition(Field<point>(field, elems))
+            );
+            forAll(transformFld, i)
+            {
+                //cop(field[n++], transformFld[i]);
+                field[n++] = transformFld[i];
+            }
+        }
+        else
+        {
+            Field<point> transformFld
+            (
+                transform(vt.R(), Field<point>(field, elems))
+            );
+
+            forAll(transformFld, i)
+            {
+                //cop(field[n++], transformFld[i]);
+                field[n++] = transformFld[i];
+            }
+        }
+    }
+}
+
+
+template<>
+void Foam::mapDistribute::applyInverseTransforms
+(
+    const globalIndexAndTransform& globalTransforms,
+    List<point>& field,
+    const bool isPosition
+) const
+{
+    const List<vectorTensorTransform>& totalTransform =
+        globalTransforms.transformPermutations();
+
+    forAll(totalTransform, trafoI)
+    {
+        const vectorTensorTransform& vt = totalTransform[trafoI];
+        const labelList& elems = transformElements_[trafoI];
+        label n = transformStart_[trafoI];
+
+        // Could be optimised to avoid memory allocations
+
+        if (isPosition)
+        {
+            Field<point> transformFld
+            (
+                vt.invTransformPosition
+                (
+                    SubField<point>(field, elems.size(), n)
+                )
+            );
+            forAll(transformFld, i)
+            {
+                field[elems[i]] = transformFld[i];
+            }
+        }
+        else
+        {
+            Field<point> transformFld(SubField<point>(field, elems.size(), n));
+            transform(transformFld, vt.R().T(), transformFld);
+
+            forAll(transformFld, i)
+            {
+                field[elems[i]] = transformFld[i];
+            }
+        }
+    }
+}
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
+//- Construct null
+Foam::mapDistribute::mapDistribute()
+:
+    constructSize_(0),
+    schedulePtr_()
+{}
+
+
 //- Construct from components
 Foam::mapDistribute::mapDistribute
 (
@@ -663,7 +798,7 @@ Foam::mapDistribute::mapDistribute
 
     if (debug)
     {
-        printLayout(globalNumbering.localSize(), compactMap, Pout);
+        printLayout(Pout);
     }
 }
 
@@ -719,7 +854,7 @@ Foam::mapDistribute::mapDistribute
 
     if (debug)
     {
-        printLayout(globalNumbering.localSize(), compactMap, Pout);
+        printLayout(Pout);
     }
 }
 
@@ -821,10 +956,9 @@ Foam::mapDistribute::mapDistribute
         n++;
     }
 
-
     if (debug)
     {
-        printLayout(globalNumbering.localSize(), compactMap, Pout);
+        printLayout(Pout);
     }
 }
 
@@ -939,10 +1073,9 @@ Foam::mapDistribute::mapDistribute
         }
     }
 
-
     if (debug)
     {
-        printLayout(globalNumbering.localSize(), compactMap, Pout);
+        printLayout(Pout);
     }
 }
 
@@ -958,8 +1091,36 @@ Foam::mapDistribute::mapDistribute(const mapDistribute& map)
 {}
 
 
+Foam::mapDistribute::mapDistribute(const Xfer<mapDistribute>& map)
+:
+    constructSize_(map().constructSize_),
+    subMap_(map().subMap_.xfer()),
+    constructMap_(map().constructMap_.xfer()),
+    transformElements_(map().transformElements_.xfer()),
+    transformStart_(map().transformStart_.xfer()),
+    schedulePtr_()
+{}
+
+
 // * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
 
+void Foam::mapDistribute::transfer(mapDistribute& rhs)
+{
+    constructSize_ = rhs.constructSize_;
+    subMap_.transfer(rhs.subMap_);
+    constructMap_.transfer(rhs.constructMap_);
+    transformElements_.transfer(rhs.transformElements_);
+    transformStart_.transfer(rhs.transformStart_);
+    schedulePtr_.clear();
+}
+
+
+Foam::Xfer<Foam::mapDistribute> Foam::mapDistribute::xfer()
+{
+    return xferMove(*this);
+}
+
+
 Foam::label Foam::mapDistribute::renumber
 (
     const globalIndex& globalNumbering,
diff --git a/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapDistribute/mapDistribute.H b/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapDistribute/mapDistribute.H
index 40bdef795f..6e1a26468c 100644
--- a/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapDistribute/mapDistribute.H
+++ b/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapDistribute/mapDistribute.H
@@ -35,19 +35,88 @@ Note:
     Schedule is a list of processor pairs (one send, one receive. One of
     them will be myself) which forms a scheduled (i.e. non-buffered) exchange.
     See distribute on how to use it.
-    Note2: number of items send on one processor have to equal the number
+    Note2: number of items sent on one processor have to equal the number
     of items received on the other processor.
 
-    Constructors using compact numbering: all my own elements first
-    (whether used or not) followed by used-only remote elements.
+    To aid constructing these maps there are the constructors from global
+    numbering, either with or without transforms.
+
+    - without transforms:
+    Constructors using compact numbering: layout is
+    - all my own elements first (whether used or not)
+    - followed by used-only remote elements sorted by remote processor.
     So e.g 4 procs and on proc 1 the compact
     table will first have all globalIndex.localSize() elements from proc1
     followed by used-only elements of proc0, proc2, proc3.
     The constructed mapDistribute sends the local elements from and
     receives the remote elements into their compact position.
     compactMap[procI] is the position of elements from procI in the compact
-    map. compactMap[myProcNo()] is empty since trivial addressing. The indices
-    into compactMap[procI] are local, not global, indices.
+    map. compactMap[myProcNo()] is empty since trivial addressing.
+
+    It rewrites the input global indices into indices into the constructed
+    data.
+
+
+    - with transforms:
+    This requires the precalculated set of possible transforms
+    (globalIndexAndTransform). These are given as permutations (+, -, or none)
+    of up to 3 independent transforms.
+    The layout of the data is
+    - all my own elements first (whether used or not)
+    - followed by used-only remote elements sorted by remote processor.
+    - followed by - for each transformation index - the set of local or
+    remote elements with that transformation.
+    The inputs for the constructor are
+    - the set of untransformed local or remote indices in globalIndex
+    numbering. These get rewritten to be indices into the layout of the data.
+    - the set of transformed local or remote indices in globalIndexAndTransform
+    encoding. These are labelPairs.
+
+    Any distribute with transforms is now done as:
+    1. exchange data with other processors and receive these into the
+    slots for that processor
+    2. for all transformations transform a subset of the data according
+    to transformElements_[transformI] and store this starting from
+    transformStart_[transformI]
+
+    In the same way a reverse distribute will
+    1. apply the inverse transform to the data starting at
+    transformStart_[transformI] and copy the result back into the
+    transformElements_[transformI]. These might be local or remote slots.
+    2. the data in the remote slots will now be sent back to the correct
+    location in the originating processor.
+
+    E.g. a map to handle
+    - mesh points on a mesh with
+    - 1 cyclic so 3 permutations (+,-,none) will have layout
+    - on e.g. processor 1 out of 2:
+
+        +------+ <- transformStart[2]
+        |      |
+        |      | <- transform2 applied to data in local or remote slots
+        |      |
+        +------+ <- transformStart[1]
+        |      |
+        |      | <- transform1 applied to data in local or remote slots
+        |      |
+        +------+ <- transformStart[1]
+        |      |
+        |      | <- transform0 applied to data in local or remote slots
+        |      |
+        +------+ <- transformStart[0]
+        |      |
+        |      | <- data from proc2
+        |      |
+        +------+
+        |      |
+        |      | <- data from proc0
+        |      |
+        +------+ <- mesh.nPoints()
+        |      |
+        |      |
+        |      |
+        +------+ 0
+
 
 SourceFiles
     mapDistribute.C
@@ -63,6 +132,7 @@ SourceFiles
 #include "Pstream.H"
 #include "boolList.H"
 #include "Map.H"
+#include "point.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -114,13 +184,6 @@ class mapDistribute
             const label receivedSize
         );
 
-        void printLayout
-        (
-            const label localSize,
-            List<Map<label> >& compactMap,
-            Ostream& os
-        ) const;
-
         void calcCompactAddressing
         (
             const globalIndex& globalNumbering,
@@ -152,23 +215,28 @@ class mapDistribute
 
         //- Helper function: copy transformElements without transformation
         template<class T>
-        void copyElements(List<T>& field) const;
+        void applyDummyTransforms(List<T>& field) const;
 
-        template<class T, class CombineOp>
+        template<class T>   //, class CombineOp>
         void applyTransforms
         (
             const globalIndexAndTransform& globalTransforms,
             List<T>& field,
-            const bool isPosition,
-            const CombineOp& cop
+            const bool isPosition
+            //const CombineOp& cop
         ) const;
-        template<class T, class CombineOp>
+
+        //- Helper function: copy transformElements without transformation
+        template<class T>
+        void applyDummyInverseTransforms(List<T>& field) const;
+
+        template<class T>   //, class CombineOp>
         void applyInverseTransforms
         (
             const globalIndexAndTransform& globalTransforms,
             List<T>& field,
-            const bool isPosition,
-            const CombineOp& cop
+            const bool isPosition
+            //const CombineOp& cop
         ) const;
 
 
@@ -180,6 +248,9 @@ public:
 
     // Constructors
 
+        //- Construct null
+        mapDistribute();
+
         //- Construct from components
         mapDistribute
         (
@@ -217,8 +288,20 @@ public:
             List<Map<label> >& compactMap
         );
 
-        //- Construct from list of (possibly) remote elements in globalIndex
-        //  numbering (or -1). Determines compact numbering (see above) and
+        //- Special variant that works with the info sorted into bins
+        //  according to local indices. E.g. think cellCells where
+        //  cellCells[localCellI] is a list of global cells
+        mapDistribute
+        (
+            const globalIndex&,
+            labelListList& cellCells,
+            List<Map<label> >& compactMap
+        );
+
+        //- Construct from list of (possibly remote) untransformed elements
+        //  in globalIndex numbering (or -1) and (possibly remote)
+        //  transformded elements in globalIndexAndTransform numbering.
+        //  Determines compact numbering (see above) and
         //  distribute map to get data into this ordering and renumbers the
         //  elements to be in compact numbering.
         mapDistribute
@@ -231,27 +314,20 @@ public:
             List<Map<label> >& compactMap
         );
 
-        //- Special variant that works with the info sorted into bins
-        //  according to local indices. E.g. think cellCells where
-        //  cellCells[localCellI] is a list of global cells
+        //- As above but with ListLists.
         mapDistribute
         (
             const globalIndex&,
             labelListList& cellCells,
-            List<Map<label> >& compactMap
-        );
-
-        //- As above but with transformed elements as well
-        mapDistribute
-        (
-            const globalIndex&,
-            labelListList& cellCells,
-            const globalIndexAndTransform& ,
+            const globalIndexAndTransform&,
             const List<labelPairList>& transformedElements,
             labelListList& transformedIndices,
             List<Map<label> >& compactMap
         );
 
+        //- Construct by transferring parameter content
+        mapDistribute(const Xfer<mapDistribute>&);
+
         //- Construct copy
         mapDistribute(const mapDistribute&);
 
@@ -296,6 +372,19 @@ public:
                 return constructMap_;
             }
 
+            //- For every globalIndexAndTransform::transformPermutations
+            //  gives the elements that need to be transformed
+            const labelListList& transformElements() const
+            {
+                return transformElements_;
+            }
+
+            //- Destination in constructMap for transformed elements
+            const labelList& transformStart() const
+            {
+                return transformStart_;
+            }
+
             //- Calculate a schedule. See above.
             static List<labelPair> schedule
             (
@@ -309,6 +398,12 @@ public:
 
         // Other
 
+            //- Transfer the contents of the argument and annul the argument.
+            void transfer(mapDistribute&);
+
+            //- Transfer contents to the Xfer container
+            Xfer<mapDistribute> xfer();
+
             //- Helper for construct from globalIndex. Renumbers element
             //  (in globalIndex numbering) into compact indices.
             static label renumber
@@ -354,7 +449,8 @@ public:
 
             //- Distribute data using default commsType.
             template<class T>
-            void distribute(List<T>& fld) const;
+            void distribute(List<T>& fld, const bool dummyTransform = true)
+            const;
 
             //- Same but with transforms
             template<class T>
@@ -367,7 +463,12 @@ public:
 
             //- Reverse distribute data using default commsType.
             template<class T>
-            void reverseDistribute(const label constructSize, List<T>&) const;
+            void reverseDistribute
+            (
+                const label constructSize,
+                List<T>&,
+                const bool dummyTransform = true
+            ) const;
 
             //- Same but with transforms
             template<class T>
@@ -387,7 +488,8 @@ public:
             (
                 const label constructSize,
                 const T& nullValue,
-                List<T>& fld
+                List<T>& fld,
+                const bool dummyTransform = true
             ) const;
 
             //- Same but with transforms
@@ -408,6 +510,9 @@ public:
             template<class T>
             void receive(PstreamBuffers&, List<T>&) const;
 
+            //- Debug: print layout
+            void printLayout(Ostream& os) const;
+
             //- Correct for topo change.
             void updateMesh(const mapPolyMesh&)
             {
@@ -423,6 +528,24 @@ public:
 
 };
 
+//- Specialisation for transforms that can apply positional transform
+template<>
+void mapDistribute::applyTransforms
+(
+    const globalIndexAndTransform& globalTransforms,
+    List<point>& field,
+    const bool isPosition
+    //const CombineOp& cop
+) const;
+
+template<>   //, class CombineOp>
+void mapDistribute::applyInverseTransforms
+(
+    const globalIndexAndTransform& globalTransforms,
+    List<point>& field,
+    const bool isPosition
+    //const CombineOp& cop
+) const;
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
diff --git a/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapDistribute/mapDistributeTemplates.C b/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapDistribute/mapDistributeTemplates.C
index 28d49738b7..68e6cb7acb 100644
--- a/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapDistribute/mapDistributeTemplates.C
+++ b/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapDistribute/mapDistributeTemplates.C
@@ -27,6 +27,7 @@ License
 #include "PstreamBuffers.H"
 #include "PstreamCombineReduceOps.H"
 #include "globalIndexAndTransform.H"
+#include "transformField.H"
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
@@ -777,7 +778,7 @@ void Foam::mapDistribute::receive(PstreamBuffers& pBufs, List<T>& field) const
 
 // In case of no transform: copy elements
 template<class T>
-void Foam::mapDistribute::copyElements(List<T>& field) const
+void Foam::mapDistribute::applyDummyTransforms(List<T>& field) const
 {
     forAll(transformElements_, trafoI)
     {
@@ -793,58 +794,48 @@ void Foam::mapDistribute::copyElements(List<T>& field) const
 }
 
 
-// Calculate transformed elements.
-template<class T, class CombineOp>
-void Foam::mapDistribute::applyTransforms
-(
-    const globalIndexAndTransform& globalTransforms,
-    List<T>& field,
-    const bool isPosition,
-    const CombineOp& cop
-) const
+// In case of no transform: copy elements
+template<class T>
+void Foam::mapDistribute::applyDummyInverseTransforms(List<T>& field) const
 {
-    const List<vectorTensorTransform>& totalTransform =
-        globalTransforms.transformPermutations();
-
-    forAll(totalTransform, trafoI)
+    forAll(transformElements_, trafoI)
     {
-        const vectorTensorTransform& vt = totalTransform[trafoI];
         const labelList& elems = transformElements_[trafoI];
         label n = transformStart_[trafoI];
 
-        // Could be optimised to avoid memory allocations
-
-        if (isPosition)
+        forAll(elems, i)
         {
-            Field<T> transformFld(vt.transformPosition(Field<T>(field, elems)));
-            forAll(transformFld, i)
-            {
-                cop(field[n++], transformFld[i]);
-            }
-        }
-        else
-        {
-            Field<T> transformFld(transform(vt.R(), Field<T>(field, elems)));
-
-            forAll(transformFld, i)
-            {
-                cop(field[n++], transformFld[i]);
-            }
+            field[elems[i]] = field[n++];
         }
     }
 }
 
 
 // Calculate transformed elements.
-template<class T, class CombineOp>
-void Foam::mapDistribute::applyInverseTransforms
+template<class T>   //, class CombineOp>
+void Foam::mapDistribute::applyTransforms
 (
     const globalIndexAndTransform& globalTransforms,
     List<T>& field,
-    const bool isPosition,
-    const CombineOp& cop
+    const bool isPosition
+    //const CombineOp& cop
 ) const
 {
+    if (isPosition)
+    {
+        FatalErrorIn
+        (
+            "mapDistribute::applyTransforms\n"
+            "(\n"
+            "    const globalIndexAndTransform&,\n"
+            "    List<T>&,\n"
+            "    const bool\n"
+            ") const\n"
+        )   << "It does not make sense to apply position transformation"
+            << " for anything else than pointFields."
+            << abort(FatalError);
+    }
+
     const List<vectorTensorTransform>& totalTransform =
         globalTransforms.transformPermutations();
 
@@ -855,36 +846,59 @@ void Foam::mapDistribute::applyInverseTransforms
         label n = transformStart_[trafoI];
 
         // Could be optimised to avoid memory allocations
+        Field<T> transformFld(transform(vt.R(), Field<T>(field, elems)));
 
-        if (isPosition)
+        forAll(transformFld, i)
         {
-            Field<T> transformFld
-            (
-                vt.invTransformPosition
-                (
-                    SubField<T>(field, n, elems.size())
-                )
-            );
-            forAll(transformFld, i)
-            {
-                cop(field[elems[i]], transformFld[i]);
-            }
+            //cop(field[n++], transformFld[i]);
+            field[n++] = transformFld[i];
         }
-        else
-        {
-            Field<T> transformFld
-            (
-                transform
-                (
-                    vt.R().T(),
-                    SubField<T>(field, n, elems)
-                )
-            );
+    }
+}
 
-            forAll(transformFld, i)
-            {
-                cop(field[elems[i]], transformFld[i]);
-            }
+
+// Calculate transformed elements.
+template<class T>   //, class CombineOp>
+void Foam::mapDistribute::applyInverseTransforms
+(
+    const globalIndexAndTransform& globalTransforms,
+    List<T>& field,
+    const bool isPosition
+    //const CombineOp& cop
+) const
+{
+    if (isPosition)
+    {
+        FatalErrorIn
+        (
+            "mapDistribute::applyInverseTransforms\n"
+            "(\n"
+            "    const globalIndexAndTransform&,\n"
+            "    List<T>&,\n"
+            "    const bool\n"
+            ") const\n"
+        )   << "It does not make sense to apply position transformation"
+            << " for anything else than pointFields."
+            << abort(FatalError);
+    }
+
+    const List<vectorTensorTransform>& totalTransform =
+        globalTransforms.transformPermutations();
+
+    forAll(totalTransform, trafoI)
+    {
+        const vectorTensorTransform& vt = totalTransform[trafoI];
+        const labelList& elems = transformElements_[trafoI];
+        label n = transformStart_[trafoI];
+
+        // Could be optimised to avoid memory allocations
+        Field<T> transformFld(SubField<T>(field, elems.size(), n));
+        transform(transformFld, vt.R().T(), transformFld);
+
+        forAll(transformFld, i)
+        {
+            //cop(field[elems[i]], transformFld[i]);
+            field[elems[i]] = transformFld[i];
         }
     }
 }
@@ -892,7 +906,11 @@ void Foam::mapDistribute::applyInverseTransforms
 
 //- Distribute data using default commsType.
 template<class T>
-void Foam::mapDistribute::distribute(List<T>& fld) const
+void Foam::mapDistribute::distribute
+(
+    List<T>& fld,
+    const bool dummyTransform
+) const
 {
     if (Pstream::defaultCommsType == Pstream::nonBlocking)
     {
@@ -930,6 +948,12 @@ void Foam::mapDistribute::distribute(List<T>& fld) const
             fld
         );
     }
+
+    //- Fill in transformed slots with copies
+    if (dummyTransform)
+    {
+        applyDummyTransforms(fld);
+    }
 }
 
 
@@ -938,9 +962,17 @@ template<class T>
 void Foam::mapDistribute::reverseDistribute
 (
     const label constructSize,
-    List<T>& fld
+    List<T>& fld,
+    const bool dummyTransform
 ) const
 {
+    fld.setSize(constructSize);
+
+    if (dummyTransform)
+    {
+        applyDummyInverseTransforms(fld);
+    }
+
     if (Pstream::defaultCommsType == Pstream::nonBlocking)
     {
         distribute
@@ -988,9 +1020,17 @@ void Foam::mapDistribute::reverseDistribute
 (
     const label constructSize,
     const T& nullValue,
-    List<T>& fld
+    List<T>& fld,
+    const bool dummyTransform
 ) const
 {
+    fld.setSize(constructSize);
+
+    if (dummyTransform)
+    {
+        applyDummyInverseTransforms(fld);
+    }
+
     if (Pstream::defaultCommsType == Pstream::nonBlocking)
     {
         distribute
@@ -1045,8 +1085,10 @@ void Foam::mapDistribute::distribute
     const bool isPosition
 ) const
 {
-    distribute(fld);
-    applyTransforms(git, fld, isPosition, eqOp<T>());
+    // Distribute. Leave out dummy transforms since we're doing them ourselves
+    distribute(fld, false);
+    // Do transforms
+    applyTransforms(git, fld, isPosition);   //, eqOp<T>());
 }
 
 
@@ -1059,13 +1101,13 @@ void Foam::mapDistribute::reverseDistribute
     const bool isPosition
 ) const
 {
-    fld.setSize(constructSize);
+    // Fill slots with reverse-transformed data. Note that it also copies
+    // back into the non-remote part of fld even though these values are not
+    // used.
+    applyInverseTransforms(git, fld, isPosition);   //, eqOp<T>());
 
-    // Fill slots with reverse-transformed data
-    applyInverseTransforms(git, fld, isPosition, eqOp<T>());
-
-    // And send back
-    reverseDistribute(constructSize, fld);
+    // And send back (the remote slots). Disable dummy transformations.
+    reverseDistribute(constructSize, fld, false);
 }
 
 
@@ -1079,13 +1121,13 @@ void Foam::mapDistribute::reverseDistribute
     const bool isPosition
 ) const
 {
-    fld = List<T>(constructSize, nullValue);
+    // Fill slots with reverse-transformed data Note that it also copies
+    // back into the non-remote part of fld even though these values are not
+    // used.
+    applyInverseTransforms(git, fld, isPosition);   //, eqOp<T>());
 
-    // Fill slots with reverse-transformed data
-    applyInverseTransforms(git, fld, isPosition, eqOp<T>());
-
-    // And send back
-    reverseDistribute(constructSize, fld);
+    // And send back (the remote slots) Disable dummy transformations.
+    reverseDistribute(constructSize, nullValue, fld, false);
 }
 
 
diff --git a/src/OpenFOAM/meshes/polyMesh/syncTools/syncTools.C b/src/OpenFOAM/meshes/polyMesh/syncTools/syncTools.C
index 94f9d6bbf8..51b6ee7a64 100644
--- a/src/OpenFOAM/meshes/polyMesh/syncTools/syncTools.C
+++ b/src/OpenFOAM/meshes/polyMesh/syncTools/syncTools.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -24,7 +24,6 @@ License
 \*----------------------------------------------------------------------------*/
 
 #include "syncTools.H"
-#include "polyMesh.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -99,24 +98,6 @@ void Foam::syncTools::transform::operator()
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-// Does anyone have couples? Since meshes might have 0 cells and 0 proc
-// boundaries need to reduce this info.
-bool Foam::syncTools::hasCouples(const polyBoundaryMesh& patches)
-{
-    bool hasAnyCouples = false;
-
-    forAll(patches, patchI)
-    {
-        if (patches[patchI].coupled())
-        {
-            hasAnyCouples = true;
-            break;
-        }
-    }
-    return returnReduce(hasAnyCouples, orOp<bool>());
-}
-
-
 // Determines for every point whether it is coupled and if so sets only one.
 Foam::PackedBoolList Foam::syncTools::getMasterPoints(const polyMesh& mesh)
 {
@@ -125,12 +106,21 @@ Foam::PackedBoolList Foam::syncTools::getMasterPoints(const polyMesh& mesh)
 
     const globalMeshData& globalData = mesh.globalData();
     const labelList& meshPoints = globalData.coupledPatch().meshPoints();
-    const labelListList& pointSlaves = globalData.globalPointAllSlaves();
+    const labelListList& slaves = globalData.globalPointSlaves();
+    const labelListList& transformedSlaves =
+            globalData.globalPointTransformedSlaves();
 
     forAll(meshPoints, coupledPointI)
     {
         label meshPointI = meshPoints[coupledPointI];
-        if (pointSlaves[coupledPointI].size() > 0)
+        if
+        (
+            (
+                slaves[coupledPointI].size()
+              + transformedSlaves[coupledPointI].size()
+            )
+          > 0
+        )
         {
             isMasterPoint[meshPointI] = true;
         }
@@ -161,12 +151,21 @@ Foam::PackedBoolList Foam::syncTools::getMasterEdges(const polyMesh& mesh)
 
     const globalMeshData& globalData = mesh.globalData();
     const labelList& meshEdges = globalData.coupledPatchMeshEdges();
-    const labelListList& edgeSlaves = globalData.globalEdgeAllSlaves();
+    const labelListList& slaves = globalData.globalEdgeSlaves();
+    const labelListList& transformedSlaves =
+        globalData.globalEdgeTransformedSlaves();
 
     forAll(meshEdges, coupledEdgeI)
     {
         label meshEdgeI = meshEdges[coupledEdgeI];
-        if (edgeSlaves[coupledEdgeI].size() > 0)
+        if
+        (
+            (
+                slaves[coupledEdgeI].size()
+              + transformedSlaves[coupledEdgeI].size()
+            )
+          > 0
+        )
         {
             isMasterEdge[meshEdgeI] = true;
         }
diff --git a/src/OpenFOAM/meshes/polyMesh/syncTools/syncTools.H b/src/OpenFOAM/meshes/polyMesh/syncTools/syncTools.H
index f27ba02a47..f1572bd4ac 100644
--- a/src/OpenFOAM/meshes/polyMesh/syncTools/syncTools.H
+++ b/src/OpenFOAM/meshes/polyMesh/syncTools/syncTools.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -33,12 +33,6 @@ Description
     - null value which gets overridden by any valid value.
     - transform function
 
-    note:Can apply coordinate rotation/separation on cyclics but only for faces
-    or if there is a single rotation/separation tensor.
-    note:syncPointList or syncEdgeList will visit shared points/edges
-    multiple times (once through patch exchange, once through shared
-    points reduce). Should be replaced by pointMesh functionality.
-
 SourceFiles
     syncTools.C
     syncToolsTemplates.C
@@ -48,9 +42,7 @@ SourceFiles
 #ifndef syncTools_H
 #define syncTools_H
 
-#include "UList.H"
 #include "Pstream.H"
-#include "Map.H"
 #include "EdgeMap.H"
 #include "PackedBoolList.H"
 #include "polyMesh.H"
@@ -72,9 +64,6 @@ class syncTools
 {
     // Private Member Functions
 
-        //- Check whether uses couples.
-        static bool hasCouples(const polyBoundaryMesh&);
-
         //- Combine value with existing value in map.
         template <class T, class CombineOp>
         static void combine
@@ -174,41 +163,41 @@ public:
                 const CombineOp& cop,
                 const TransformOp& top
             );
-
-            //- Synchronize values on all mesh points.
-            template <class T, class CombineOp, class TransformOp>
-            static void syncPointList
-            (
-                const polyMesh&,
-                UList<T>&,
-                const CombineOp& cop,
-                const T& nullValue,
-                const TransformOp& top
-            );
-
-            //- Synchronize values on selected mesh points.
-            template <class T, class CombineOp, class TransformOp>
-            static void syncPointList
-            (
-                const polyMesh&,
-                const labelList& meshPoints,
-                UList<T>&,
-                const CombineOp& cop,
-                const T& nullValue,
-                const TransformOp& top
-            );
-
-            //- Synchronize values on all mesh edges.
-            template <class T, class CombineOp, class TransformOp>
-            static void syncEdgeList
-            (
-                const polyMesh&,
-                UList<T>&,
-                const CombineOp& cop,
-                const T& nullValue,
-                const TransformOp& top
-            );
-
+//
+//            //- Synchronize values on all mesh points.
+//            template <class T, class CombineOp, class TransformOp>
+//            static void syncPointList
+//            (
+//                const polyMesh&,
+//                UList<T>&,
+//                const CombineOp& cop,
+//                const T& nullValue,
+//                const TransformOp& top
+//            );
+//
+//            //- Synchronize values on selected mesh points.
+//            template <class T, class CombineOp, class TransformOp>
+//            static void syncPointList
+//            (
+//                const polyMesh&,
+//                const labelList& meshPoints,
+//                UList<T>&,
+//                const CombineOp& cop,
+//                const T& nullValue,
+//                const TransformOp& top
+//            );
+//
+//            //- Synchronize values on all mesh edges.
+//            template <class T, class CombineOp, class TransformOp>
+//            static void syncEdgeList
+//            (
+//                const polyMesh&,
+//                UList<T>&,
+//                const CombineOp& cop,
+//                const T& nullValue,
+//                const TransformOp& top
+//            );
+//
             //- Synchronize values on boundary faces only.
             template <class T, class CombineOp, class TransformOp>
             static void syncBoundaryFaceList
@@ -227,26 +216,20 @@ public:
             static void syncPointList
             (
                 const polyMesh& mesh,
-                UList<T>& l,
+                List<T>& l,
                 const CombineOp& cop,
                 const T& nullValue
-            )
-            {
-                syncPointList(mesh, l, cop, nullValue, transform());
-            }
+            );
 
             //- Synchronize locations on all mesh points.
             template <class CombineOp>
             static void syncPointPositions
             (
                 const polyMesh& mesh,
-                UList<point>& l,
+                List<point>& l,
                 const CombineOp& cop,
                 const point& nullValue
-            )
-            {
-                syncPointList(mesh, l, cop, nullValue, transformPosition());
-            }
+            );
 
             //- Synchronize values on selected mesh points.
             template <class T, class CombineOp>
@@ -257,18 +240,7 @@ public:
                 UList<T>& l,
                 const CombineOp& cop,
                 const T& nullValue
-            )
-            {
-                syncPointList
-                (
-                    mesh,
-                    meshPoints,
-                    l,
-                    cop,
-                    nullValue,
-                    transform()
-                );
-            }
+            );
 
             //- Synchronize locations on selected mesh points.
             template <class CombineOp>
@@ -279,18 +251,7 @@ public:
                 UList<point>& l,
                 const CombineOp& cop,
                 const point& nullValue
-            )
-            {
-                syncPointList
-                (
-                    mesh,
-                    meshPoints,
-                    l,
-                    cop,
-                    nullValue,
-                    transformPosition()
-                );
-            }
+            );
 
 
         // Synchronise edge-wise data
@@ -303,10 +264,7 @@ public:
                 UList<T>& l,
                 const CombineOp& cop,
                 const T& nullValue
-            )
-            {
-                syncEdgeList(mesh, l, cop, nullValue, transform());
-            }
+            );
 
             //- Synchronize values on all mesh edges.
             template <class CombineOp>
@@ -316,10 +274,7 @@ public:
                 UList<point>& l,
                 const CombineOp& cop,
                 const point& nullValue
-            )
-            {
-                syncEdgeList(mesh, l, cop, nullValue, transformPosition());
-            }
+            );
 
 
         // Synchronise face-wise data
diff --git a/src/OpenFOAM/meshes/polyMesh/syncTools/syncToolsTemplates.C b/src/OpenFOAM/meshes/polyMesh/syncTools/syncToolsTemplates.C
index c941005f52..dc93a7dfeb 100644
--- a/src/OpenFOAM/meshes/polyMesh/syncTools/syncToolsTemplates.C
+++ b/src/OpenFOAM/meshes/polyMesh/syncTools/syncToolsTemplates.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -32,8 +32,6 @@ License
 #include "transform.H"
 #include "transformList.H"
 
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
 // Combine val with existing value at index
@@ -93,11 +91,6 @@ void Foam::syncTools::syncPointMap
 {
     const polyBoundaryMesh& patches = mesh.boundaryMesh();
 
-    if (!hasCouples(patches))
-    {
-        return;
-    }
-
     if (Pstream::parRun())
     {
         PstreamBuffers pBufs(Pstream::nonBlocking);
@@ -398,11 +391,6 @@ void Foam::syncTools::syncEdgeMap
 {
     const polyBoundaryMesh& patches = mesh.boundaryMesh();
 
-    if (!hasCouples(patches))
-    {
-        return;
-    }
-
 
     // Do synchronisation without constructing globalEdge addressing
     // (since this constructs mesh edge addressing)
@@ -767,14 +755,232 @@ void Foam::syncTools::syncEdgeMap
 }
 
 
-template <class T, class CombineOp, class TransformOp>
+//template <class T, class CombineOp, class TransformOp>
+//void Foam::syncTools::syncPointList
+//(
+//    const polyMesh& mesh,
+//    UList<T>& pointValues,
+//    const CombineOp& cop,
+//    const T& nullValue,
+//    const TransformOp& top
+//)
+//{
+//    if (pointValues.size() != mesh.nPoints())
+//    {
+//        FatalErrorIn
+//        (
+//            "syncTools<class T, class CombineOp>::syncPointList"
+//            "(const polyMesh&, UList<T>&, const CombineOp&, const T&"
+//            ", const bool)"
+//        )   << "Number of values " << pointValues.size()
+//            << " is not equal to the number of points in the mesh "
+//            << mesh.nPoints() << abort(FatalError);
+//    }
+//
+//    const polyBoundaryMesh& patches = mesh.boundaryMesh();
+//
+//
+//    if (Pstream::parRun())
+//    {
+//        PstreamBuffers pBufs(Pstream::nonBlocking);
+//
+//        // Send
+//
+//        forAll(patches, patchI)
+//        {
+//            if
+//            (
+//                isA<processorPolyPatch>(patches[patchI])
+//             && patches[patchI].nPoints() > 0
+//            )
+//            {
+//                const processorPolyPatch& procPatch =
+//                    refCast<const processorPolyPatch>(patches[patchI]);
+//
+//                // Get data per patchPoint in neighbouring point numbers.
+//                Field<T> patchInfo(procPatch.nPoints());
+//
+//                const labelList& meshPts = procPatch.meshPoints();
+//                const labelList& nbrPts = procPatch.neighbPoints();
+//
+//                forAll(nbrPts, pointI)
+//                {
+//                    label nbrPointI = nbrPts[pointI];
+//                    patchInfo[nbrPointI] = pointValues[meshPts[pointI]];
+//                }
+//
+//                UOPstream toNbr(procPatch.neighbProcNo(), pBufs);
+//                toNbr << patchInfo;
+//            }
+//        }
+//
+//        pBufs.finishedSends();
+//
+//        // Receive and combine.
+//
+//        forAll(patches, patchI)
+//        {
+//            if
+//            (
+//                isA<processorPolyPatch>(patches[patchI])
+//             && patches[patchI].nPoints() > 0
+//            )
+//            {
+//                const processorPolyPatch& procPatch =
+//                    refCast<const processorPolyPatch>(patches[patchI]);
+//
+//                Field<T> nbrPatchInfo(procPatch.nPoints());
+//                {
+//                    UIPstream fromNbr(procPatch.neighbProcNo(), pBufs);
+//                    fromNbr >> nbrPatchInfo;
+//                }
+//
+//                // Transform to this side
+//                top(procPatch, nbrPatchInfo);
+//
+//                const labelList& meshPts = procPatch.meshPoints();
+//
+//                forAll(meshPts, pointI)
+//                {
+//                    label meshPointI = meshPts[pointI];
+//                    cop(pointValues[meshPointI], nbrPatchInfo[pointI]);
+//                }
+//            }
+//        }
+//    }
+//
+//    // Do the cyclics.
+//    forAll(patches, patchI)
+//    {
+//        if (isA<cyclicPolyPatch>(patches[patchI]))
+//        {
+//            const cyclicPolyPatch& cycPatch =
+//                refCast<const cyclicPolyPatch>(patches[patchI]);
+//
+//            if (cycPatch.owner())
+//            {
+//                // Owner does all.
+//
+//                const edgeList& coupledPoints = cycPatch.coupledPoints();
+//                const labelList& meshPts = cycPatch.meshPoints();
+//                const cyclicPolyPatch& nbrPatch = cycPatch.neighbPatch();
+//                const labelList& nbrMeshPoints = nbrPatch.meshPoints();
+//
+//                Field<T> half0Values(coupledPoints.size());
+//                Field<T> half1Values(coupledPoints.size());
+//
+//                forAll(coupledPoints, i)
+//                {
+//                    const edge& e = coupledPoints[i];
+//                    half0Values[i] = pointValues[meshPts[e[0]]];
+//                    half1Values[i] = pointValues[nbrMeshPoints[e[1]]];
+//                }
+//
+//                //SubField<T> slice0(half0Values, half0Values.size());
+//                //SubField<T> slice1(half1Values, half1Values.size());
+//                //top(cycPatch, reinterpret_cast<Field<T>&>(slice1));
+//                //top(nbrPatch, reinterpret_cast<Field<T>&>(slice0));
+//
+//                top(cycPatch, half1Values);
+//                top(nbrPatch, half0Values);
+//
+//                forAll(coupledPoints, i)
+//                {
+//                    const edge& e = coupledPoints[i];
+//                    cop(pointValues[meshPts[e[0]]], half1Values[i]);
+//                    cop(pointValues[nbrMeshPoints[e[1]]], half0Values[i]);
+//                }
+//            }
+//        }
+//    }
+//
+//    // Synchronize multiple shared points.
+//    const globalMeshData& pd = mesh.globalData();
+//
+//    if (pd.nGlobalPoints() > 0)
+//    {
+//        // Values on shared points.
+//        Field<T> sharedPts(pd.nGlobalPoints(), nullValue);
+//
+//        forAll(pd.sharedPointLabels(), i)
+//        {
+//            label meshPointI = pd.sharedPointLabels()[i];
+//            // Fill my entries in the shared points
+//            sharedPts[pd.sharedPointAddr()[i]] = pointValues[meshPointI];
+//        }
+//
+//        // Combine on master.
+//        Pstream::listCombineGather(sharedPts, cop);
+//        Pstream::listCombineScatter(sharedPts);
+//
+//        // Now we will all have the same information. Merge it back with
+//        // my local information.
+//        forAll(pd.sharedPointLabels(), i)
+//        {
+//            label meshPointI = pd.sharedPointLabels()[i];
+//            pointValues[meshPointI] = sharedPts[pd.sharedPointAddr()[i]];
+//        }
+//    }
+//}
+
+
+//template <class T, class CombineOp, class TransformOp>
+//void Foam::syncTools::syncPointList
+//(
+//    const polyMesh& mesh,
+//    const labelList& meshPoints,
+//    UList<T>& pointValues,
+//    const CombineOp& cop,
+//    const T& nullValue,
+//    const TransformOp& top
+//)
+//{
+//    if (pointValues.size() != meshPoints.size())
+//    {
+//        FatalErrorIn
+//        (
+//            "syncTools<class T, class CombineOp>::syncPointList"
+//            "(const polyMesh&, const labelList&, UList<T>&, const CombineOp&"
+//            ", const T&, const bool)"
+//        )   << "Number of values " << pointValues.size()
+//            << " is not equal to the number of points "
+//            << meshPoints.size() << abort(FatalError);
+//    }
+//
+//    if (!hasCouples(mesh.boundaryMesh()))
+//    {
+//        return;
+//    }
+//
+//    Field<T> meshValues(mesh.nPoints(), nullValue);
+//
+//    forAll(meshPoints, i)
+//    {
+//        meshValues[meshPoints[i]] = pointValues[i];
+//    }
+//
+//    syncTools::syncPointList
+//    (
+//        mesh,
+//        meshValues,
+//        cop,            // combine op
+//        nullValue,      // null value
+//        top             // position or field
+//    );
+//
+//    forAll(meshPoints, i)
+//    {
+//        pointValues[i] = meshValues[meshPoints[i]];
+//    }
+//}
+
+template <class T, class CombineOp>
 void Foam::syncTools::syncPointList
 (
     const polyMesh& mesh,
-    UList<T>& pointValues,
+    List<T>& pointValues,
     const CombineOp& cop,
-    const T& nullValue,
-    const TransformOp& top
+    const T& nullValue
 )
 {
     if (pointValues.size() != mesh.nPoints())
@@ -782,173 +988,48 @@ void Foam::syncTools::syncPointList
         FatalErrorIn
         (
             "syncTools<class T, class CombineOp>::syncPointList"
-            "(const polyMesh&, UList<T>&, const CombineOp&, const T&"
-            ", const bool)"
+            "(const polyMesh&, UList<T>&, const CombineOp&, const T&)"
         )   << "Number of values " << pointValues.size()
             << " is not equal to the number of points in the mesh "
             << mesh.nPoints() << abort(FatalError);
     }
 
-    const polyBoundaryMesh& patches = mesh.boundaryMesh();
-
-    if (!hasCouples(patches))
-    {
-        return;
-    }
-
-    if (Pstream::parRun())
-    {
-        PstreamBuffers pBufs(Pstream::nonBlocking);
-
-        // Send
-
-        forAll(patches, patchI)
-        {
-            if
-            (
-                isA<processorPolyPatch>(patches[patchI])
-             && patches[patchI].nPoints() > 0
-            )
-            {
-                const processorPolyPatch& procPatch =
-                    refCast<const processorPolyPatch>(patches[patchI]);
-
-                // Get data per patchPoint in neighbouring point numbers.
-                Field<T> patchInfo(procPatch.nPoints());
-
-                const labelList& meshPts = procPatch.meshPoints();
-                const labelList& nbrPts = procPatch.neighbPoints();
-
-                forAll(nbrPts, pointI)
-                {
-                    label nbrPointI = nbrPts[pointI];
-                    patchInfo[nbrPointI] = pointValues[meshPts[pointI]];
-                }
-
-                UOPstream toNbr(procPatch.neighbProcNo(), pBufs);
-                toNbr << patchInfo;
-            }
-        }
-
-        pBufs.finishedSends();
-
-        // Receive and combine.
-
-        forAll(patches, patchI)
-        {
-            if
-            (
-                isA<processorPolyPatch>(patches[patchI])
-             && patches[patchI].nPoints() > 0
-            )
-            {
-                const processorPolyPatch& procPatch =
-                    refCast<const processorPolyPatch>(patches[patchI]);
-
-                Field<T> nbrPatchInfo(procPatch.nPoints());
-                {
-                    UIPstream fromNbr(procPatch.neighbProcNo(), pBufs);
-                    fromNbr >> nbrPatchInfo;
-                }
-
-                // Transform to this side
-                top(procPatch, nbrPatchInfo);
-
-                const labelList& meshPts = procPatch.meshPoints();
-
-                forAll(meshPts, pointI)
-                {
-                    label meshPointI = meshPts[pointI];
-                    cop(pointValues[meshPointI], nbrPatchInfo[pointI]);
-                }
-            }
-        }
-    }
-
-    // Do the cyclics.
-    forAll(patches, patchI)
-    {
-        if (isA<cyclicPolyPatch>(patches[patchI]))
-        {
-            const cyclicPolyPatch& cycPatch =
-                refCast<const cyclicPolyPatch>(patches[patchI]);
-
-            if (cycPatch.owner())
-            {
-                // Owner does all.
-
-                const edgeList& coupledPoints = cycPatch.coupledPoints();
-                const labelList& meshPts = cycPatch.meshPoints();
-                const cyclicPolyPatch& nbrPatch = cycPatch.neighbPatch();
-                const labelList& nbrMeshPoints = nbrPatch.meshPoints();
-
-                Field<T> half0Values(coupledPoints.size());
-                Field<T> half1Values(coupledPoints.size());
-
-                forAll(coupledPoints, i)
-                {
-                    const edge& e = coupledPoints[i];
-                    half0Values[i] = pointValues[meshPts[e[0]]];
-                    half1Values[i] = pointValues[nbrMeshPoints[e[1]]];
-                }
-
-                //SubField<T> slice0(half0Values, half0Values.size());
-                //SubField<T> slice1(half1Values, half1Values.size());
-                //top(cycPatch, reinterpret_cast<Field<T>&>(slice1));
-                //top(nbrPatch, reinterpret_cast<Field<T>&>(slice0));
-
-                top(cycPatch, half1Values);
-                top(nbrPatch, half0Values);
-
-                forAll(coupledPoints, i)
-                {
-                    const edge& e = coupledPoints[i];
-                    cop(pointValues[meshPts[e[0]]], half1Values[i]);
-                    cop(pointValues[nbrMeshPoints[e[1]]], half0Values[i]);
-                }
-            }
-        }
-    }
-
-    // Synchronize multiple shared points.
-    const globalMeshData& pd = mesh.globalData();
-
-    if (pd.nGlobalPoints() > 0)
-    {
-        // Values on shared points.
-        Field<T> sharedPts(pd.nGlobalPoints(), nullValue);
-
-        forAll(pd.sharedPointLabels(), i)
-        {
-            label meshPointI = pd.sharedPointLabels()[i];
-            // Fill my entries in the shared points
-            sharedPts[pd.sharedPointAddr()[i]] = pointValues[meshPointI];
-        }
-
-        // Combine on master.
-        Pstream::listCombineGather(sharedPts, cop);
-        Pstream::listCombineScatter(sharedPts);
-
-        // Now we will all have the same information. Merge it back with
-        // my local information.
-        forAll(pd.sharedPointLabels(), i)
-        {
-            label meshPointI = pd.sharedPointLabels()[i];
-            pointValues[meshPointI] = sharedPts[pd.sharedPointAddr()[i]];
-        }
-    }
+    mesh.globalData().syncPointData(pointValues, cop, false);
 }
 
 
-template <class T, class CombineOp, class TransformOp>
+template <class CombineOp>
+void Foam::syncTools::syncPointPositions
+(
+    const polyMesh& mesh,
+    List<point>& pointValues,
+    const CombineOp& cop,
+    const point& nullValue
+)
+{
+    if (pointValues.size() != mesh.nPoints())
+    {
+        FatalErrorIn
+        (
+            "syncTools<class CombineOp>::syncPointPositions"
+            "(const polyMesh&, List<point>&, const CombineOp&, const point&)"
+        )   << "Number of values " << pointValues.size()
+            << " is not equal to the number of points in the mesh "
+            << mesh.nPoints() << abort(FatalError);
+    }
+
+    mesh.globalData().syncPointData(pointValues, cop, true);
+}
+
+
+template <class T, class CombineOp>
 void Foam::syncTools::syncPointList
 (
     const polyMesh& mesh,
     const labelList& meshPoints,
     UList<T>& pointValues,
     const CombineOp& cop,
-    const T& nullValue,
-    const TransformOp& top
+    const T& nullValue
 )
 {
     if (pointValues.size() != meshPoints.size())
@@ -956,49 +1037,116 @@ void Foam::syncTools::syncPointList
         FatalErrorIn
         (
             "syncTools<class T, class CombineOp>::syncPointList"
-            "(const polyMesh&, const labelList&, UList<T>&, const CombineOp&"
-            ", const T&, const bool)"
+            "(const polyMesh&, UList<T>&, const CombineOp&, const T&)"
         )   << "Number of values " << pointValues.size()
-            << " is not equal to the number of points "
+            << " is not equal to the number of meshPoints "
             << meshPoints.size() << abort(FatalError);
     }
+    const globalMeshData& gd = mesh.globalData();
+    const indirectPrimitivePatch& cpp = gd.coupledPatch();
+    const Map<label>& mpm = cpp.meshPointMap();
 
-    if (!hasCouples(mesh.boundaryMesh()))
-    {
-        return;
-    }
-
-    Field<T> meshValues(mesh.nPoints(), nullValue);
+    List<T> cppFld(cpp.nPoints(), nullValue);
 
     forAll(meshPoints, i)
     {
-        meshValues[meshPoints[i]] = pointValues[i];
+        label pointI = meshPoints[i];
+        Map<label>::const_iterator iter = mpm.find(pointI);
+        if (iter != mpm.end())
+        {
+            cppFld[iter()] = pointValues[i];
+        }
     }
 
-    syncTools::syncPointList
+    globalMeshData::syncData
     (
-        mesh,
-        meshValues,
-        cop,            // combine op
-        nullValue,      // null value
-        top             // position or field
+        cppFld,
+        gd.globalPointSlaves(),
+        gd.globalPointTransformedSlaves(),
+        gd.globalPointSlavesMap(),
+        gd.globalTransforms(),
+        cop,
+        false       //position?
     );
 
     forAll(meshPoints, i)
     {
-        pointValues[i] = meshValues[meshPoints[i]];
+        label pointI = meshPoints[i];
+        Map<label>::const_iterator iter = mpm.find(pointI);
+        if (iter != mpm.end())
+        {
+            pointValues[i] = cppFld[iter()];
+        }
     }
 }
 
 
-template <class T, class CombineOp, class TransformOp>
+template <class CombineOp>
+void Foam::syncTools::syncPointPositions
+(
+    const polyMesh& mesh,
+    const labelList& meshPoints,
+    UList<point>& pointValues,
+    const CombineOp& cop,
+    const point& nullValue
+)
+{
+    if (pointValues.size() != meshPoints.size())
+    {
+        FatalErrorIn
+        (
+            "syncTools<class CombineOp>::syncPointList"
+            "(const polyMesh&, UList<point>&, const CombineOp&, const point&)"
+        )   << "Number of values " << pointValues.size()
+            << " is not equal to the number of meshPoints "
+            << meshPoints.size() << abort(FatalError);
+    }
+    const globalMeshData& gd = mesh.globalData();
+    const indirectPrimitivePatch& cpp = gd.coupledPatch();
+    const Map<label>& mpm = cpp.meshPointMap();
+
+    List<point> cppFld(cpp.nPoints(), nullValue);
+
+    forAll(meshPoints, i)
+    {
+        label pointI = meshPoints[i];
+        Map<label>::const_iterator iter = mpm.find(pointI);
+        if (iter != mpm.end())
+        {
+            cppFld[iter()] = pointValues[i];
+        }
+    }
+
+    globalMeshData::syncData
+    (
+        cppFld,
+        gd.globalPointSlaves(),
+        gd.globalPointTransformedSlaves(),
+        gd.globalPointSlavesMap(),
+        gd.globalTransforms(),
+        cop,
+        true    //position?
+    );
+
+    forAll(meshPoints, i)
+    {
+        label pointI = meshPoints[i];
+        Map<label>::const_iterator iter = mpm.find(pointI);
+        if (iter != mpm.end())
+        {
+            pointValues[i] = cppFld[iter()];
+        }
+    }
+}
+
+
+template <class T, class CombineOp>
 void Foam::syncTools::syncEdgeList
 (
     const polyMesh& mesh,
     UList<T>& edgeValues,
     const CombineOp& cop,
-    const T& nullValue,
-    const TransformOp& top
+    const T& nullValue
 )
 {
     if (edgeValues.size() != mesh.nEdges())
@@ -1006,168 +1154,78 @@ void Foam::syncTools::syncEdgeList
         FatalErrorIn
         (
             "syncTools<class T, class CombineOp>::syncEdgeList"
-            "(const polyMesh&, UList<T>&, const CombineOp&, const T&"
-            ", const bool)"
+            "(const polyMesh&, UList<T>&, const CombineOp&, const T&)"
         )   << "Number of values " << edgeValues.size()
             << " is not equal to the number of edges in the mesh "
             << mesh.nEdges() << abort(FatalError);
     }
 
-    const polyBoundaryMesh& patches = mesh.boundaryMesh();
+    const globalMeshData& gd = mesh.globalData();
+    const labelList& meshEdges = gd.coupledPatchMeshEdges();
+    const globalIndexAndTransform& git = gd.globalTransforms();
+    const mapDistribute& edgeMap = gd.globalEdgeSlavesMap();
 
-    if (!hasCouples(patches))
+    List<T> cppFld(UIndirectList<T>(edgeValues, meshEdges));
+
+    globalMeshData::syncData
+    (
+        cppFld,
+        gd.globalEdgeSlaves(),
+        gd.globalEdgeTransformedSlaves(),
+        edgeMap,
+        git,
+        cop,
+        false       //position?
+    );
+
+    // Extract back onto mesh
+    forAll(meshEdges, i)
     {
-        return;
+        edgeValues[meshEdges[i]] = cppFld[i];
+    }
+}
+
+
+template <class CombineOp>
+void Foam::syncTools::syncEdgePositions
+(
+    const polyMesh& mesh,
+    UList<point>& edgeValues,
+    const CombineOp& cop,
+    const point& nullValue
+)
+{
+    if (edgeValues.size() != mesh.nEdges())
+    {
+        FatalErrorIn
+        (
+            "syncTools<class CombineOp>::syncEdgePositions"
+            "(const polyMesh&, UList<point>&, const CombineOp&, const point&)"
+        )   << "Number of values " << edgeValues.size()
+            << " is not equal to the number of edges in the mesh "
+            << mesh.nEdges() << abort(FatalError);
     }
 
-    if (Pstream::parRun())
+    const globalMeshData& gd = mesh.globalData();
+    const labelList& meshEdges = gd.coupledPatchMeshEdges();
+
+    List<point> cppFld(UIndirectList<point>(edgeValues, meshEdges));
+
+    globalMeshData::syncData
+    (
+        cppFld,
+        gd.globalEdgeSlaves(),
+        gd.globalEdgeTransformedSlaves(),
+        gd.globalEdgeSlavesMap(),
+        gd.globalTransforms(),
+        cop,
+        true        //position?
+    );
+
+    // Extract back onto mesh
+    forAll(meshEdges, i)
     {
-        PstreamBuffers pBufs(Pstream::nonBlocking);
-
-        // Send
-
-        forAll(patches, patchI)
-        {
-            if
-            (
-                isA<processorPolyPatch>(patches[patchI])
-             && patches[patchI].nEdges() > 0
-            )
-            {
-                const processorPolyPatch& procPatch =
-                    refCast<const processorPolyPatch>(patches[patchI]);
-
-                const labelList& meshEdges = procPatch.meshEdges();
-                const labelList& neighbEdges = procPatch.neighbEdges();
-
-                // Get region per patch edge in neighbouring edge numbers.
-                Field<T> patchInfo(procPatch.nEdges(), nullValue);
-
-                forAll(neighbEdges, edgeI)
-                {
-                    label nbrEdgeI = neighbEdges[edgeI];
-
-                    patchInfo[nbrEdgeI] = edgeValues[meshEdges[edgeI]];
-                }
-
-                UOPstream toNbr(procPatch.neighbProcNo(), pBufs);
-                toNbr << patchInfo;
-           }
-        }
-
-        pBufs.finishedSends();
-
-        // Receive and combine.
-
-        forAll(patches, patchI)
-        {
-            if
-            (
-                isA<processorPolyPatch>(patches[patchI])
-             && patches[patchI].nEdges() > 0
-            )
-            {
-                const processorPolyPatch& procPatch =
-                    refCast<const processorPolyPatch>(patches[patchI]);
-
-                const labelList& meshEdges = procPatch.meshEdges();
-
-                // Receive from neighbour. Is per patch edge the region of the
-                // neighbouring patch edge.
-                Field<T> nbrPatchInfo(procPatch.nEdges());
-
-                {
-                    UIPstream fromNeighb(procPatch.neighbProcNo(), pBufs);
-                    fromNeighb >> nbrPatchInfo;
-                }
-
-                // Transform to this side
-                top(procPatch, nbrPatchInfo);
-
-                forAll(meshEdges, edgeI)
-                {
-                    label meshEdgeI = meshEdges[edgeI];
-                    cop(edgeValues[meshEdgeI], nbrPatchInfo[edgeI]);
-                }
-            }
-        }
-    }
-
-    // Do the cyclics.
-    forAll(patches, patchI)
-    {
-        if (isA<cyclicPolyPatch>(patches[patchI]))
-        {
-            const cyclicPolyPatch& cycPatch =
-                refCast<const cyclicPolyPatch>(patches[patchI]);
-
-            if (cycPatch.owner())
-            {
-                // Owner does all.
-                const edgeList& coupledEdges = cycPatch.coupledEdges();
-                const labelList& meshEdges = cycPatch.meshEdges();
-                const cyclicPolyPatch& nbrPatch = cycPatch.neighbPatch();
-                const labelList& nbrMeshEdges = nbrPatch.meshEdges();
-
-                Field<T> half0Values(coupledEdges.size());
-                Field<T> half1Values(coupledEdges.size());
-
-                forAll(coupledEdges, i)
-                {
-                    const edge& e = coupledEdges[i];
-                    half0Values[i] = edgeValues[meshEdges[e[0]]];
-                    half1Values[i] = edgeValues[nbrMeshEdges[e[1]]];
-                }
-
-                //SubField<T> slice0(half0Values, half0Values.size());
-                //SubField<T> slice1(half1Values, half1Values.size());
-                //top(cycPatch, reinterpret_cast<Field<T>&>(slice1));
-                //top(nbrPatch, reinterpret_cast<Field<T>&>(slice0));
-
-                top(cycPatch, half1Values);
-                top(nbrPatch, half0Values);
-
-                forAll(coupledEdges, i)
-                {
-                    const edge& e = coupledEdges[i];
-                    cop(edgeValues[meshEdges[e[0]]], half1Values[i]);
-                    cop(edgeValues[nbrMeshEdges[e[1]]], half0Values[i]);
-                }
-            }
-        }
-    }
-
-    //- Note: hasTransformation is only used for warning messages so
-    //  reduction not strictly nessecary.
-    //reduce(hasTransformation, orOp<bool>());
-
-    // Do the multiple shared edges
-    const globalMeshData& pd = mesh.globalData();
-
-    if (pd.nGlobalEdges() > 0)
-    {
-        // Values on shared edges.
-        Field<T> sharedPts(pd.nGlobalEdges(), nullValue);
-
-        forAll(pd.sharedEdgeLabels(), i)
-        {
-            label meshEdgeI = pd.sharedEdgeLabels()[i];
-
-            // Fill my entries in the shared edges
-            sharedPts[pd.sharedEdgeAddr()[i]] = edgeValues[meshEdgeI];
-        }
-
-        // Combine on master.
-        Pstream::listCombineGather(sharedPts, cop);
-        Pstream::listCombineScatter(sharedPts);
-
-        // Now we will all have the same information. Merge it back with
-        // my local information.
-        forAll(pd.sharedEdgeLabels(), i)
-        {
-            label meshEdgeI = pd.sharedEdgeLabels()[i];
-            edgeValues[meshEdgeI] = sharedPts[pd.sharedEdgeAddr()[i]];
-        }
+        edgeValues[meshEdges[i]] = cppFld[i];
     }
 }
 
@@ -1197,12 +1255,6 @@ void Foam::syncTools::syncBoundaryFaceList
 
     const polyBoundaryMesh& patches = mesh.boundaryMesh();
 
-    if (!hasCouples(patches))
-    {
-        return;
-    }
-
-
     if (Pstream::parRun())
     {
         PstreamBuffers pBufs(Pstream::nonBlocking);
@@ -1223,13 +1275,7 @@ void Foam::syncTools::syncBoundaryFaceList
                 label patchStart = procPatch.start()-mesh.nInternalFaces();
 
                 UOPstream toNbr(procPatch.neighbProcNo(), pBufs);
-                toNbr <<
-                    SubField<T>
-                    (
-                        faceValues,
-                        procPatch.size(),
-                        patchStart
-                    );
+                toNbr << SubField<T>(faceValues, procPatch.size(), patchStart);
             }
         }
 
@@ -1331,11 +1377,6 @@ void Foam::syncTools::syncFaceList
 
     const polyBoundaryMesh& patches = mesh.boundaryMesh();
 
-    if (!hasCouples(patches))
-    {
-        return;
-    }
-
     if (Pstream::parRun())
     {
         PstreamBuffers pBufs(Pstream::nonBlocking);
@@ -1466,11 +1507,6 @@ void Foam::syncTools::syncPointList
 
     const polyBoundaryMesh& patches = mesh.boundaryMesh();
 
-    if (!hasCouples(patches))
-    {
-        return;
-    }
-
     if (Pstream::parRun())
     {
         PstreamBuffers pBufs(Pstream::nonBlocking);
@@ -1630,11 +1666,6 @@ void Foam::syncTools::syncEdgeList
 
     const polyBoundaryMesh& patches = mesh.boundaryMesh();
 
-    if (!hasCouples(patches))
-    {
-        return;
-    }
-
     if (Pstream::parRun())
     {
         PstreamBuffers pBufs(Pstream::nonBlocking);
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/addPatchCellLayer.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/addPatchCellLayer.C
index 09afd9cde3..0a906aa7bc 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/addPatchCellLayer.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/addPatchCellLayer.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -104,8 +104,7 @@ Foam::labelListList Foam::addPatchCellLayer::calcGlobalEdgeFaces
         mesh,
         globalEdgeFaces,
         uniqueEqOp(),
-        labelList(),            // null value
-        Foam::dummyTransform()  // dummy transform
+        labelList()     // null value
     );
 
     // Extract pp part
diff --git a/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolate.C b/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolate.C
index 68992b0cef..d2841c9c54 100644
--- a/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolate.C
+++ b/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolate.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -39,6 +39,104 @@ namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+template<class Type, class CombineOp>
+void volPointInterpolation::syncUntransformedData
+(
+    List<Type>& pointData,
+    const CombineOp& cop
+) const
+{
+    // Transfer onto coupled patch
+    const globalMeshData& gmd = mesh().globalData();
+    const indirectPrimitivePatch& cpp = gmd.coupledPatch();
+    const labelList& meshPoints = cpp.meshPoints();
+
+    const mapDistribute& slavesMap = gmd.globalPointSlavesMap();
+    const labelListList& slaves = gmd.globalPointSlaves();
+
+    List<Type> elems(slavesMap.constructSize());
+    forAll(meshPoints, i)
+    {
+        elems[i] = pointData[meshPoints[i]];
+    }
+
+    // Pull slave data onto master. No need to update transformed slots.
+    slavesMap.distribute(elems, false);
+
+    // Combine master data with slave data
+    forAll(slaves, i)
+    {
+        Type& elem = elems[i];
+
+        const labelList& slavePoints = slaves[i];
+
+        // Combine master with untransformed slave data
+        forAll(slavePoints, j)
+        {
+            cop(elem, elems[slavePoints[j]]);
+        }
+
+        // Copy result back to slave slots
+        forAll(slavePoints, j)
+        {
+            elems[slavePoints[j]] = elem;
+        }
+    }
+
+    // Push slave-slot data back to slaves
+    slavesMap.reverseDistribute(elems.size(), elems, false);
+
+    // Extract back onto mesh
+    forAll(meshPoints, i)
+    {
+        pointData[meshPoints[i]] = elems[i];
+    }
+}
+
+
+template<class Type>
+void volPointInterpolation::pushUntransformedData
+(
+    List<Type>& pointData
+) const
+{
+    // Transfer onto coupled patch
+    const globalMeshData& gmd = mesh().globalData();
+    const indirectPrimitivePatch& cpp = gmd.coupledPatch();
+    const labelList& meshPoints = cpp.meshPoints();
+
+    const mapDistribute& slavesMap = gmd.globalPointSlavesMap();
+    const labelListList& slaves = gmd.globalPointSlaves();
+
+    List<Type> elems(slavesMap.constructSize());
+    forAll(meshPoints, i)
+    {
+        elems[i] = pointData[meshPoints[i]];
+    }
+
+    // Combine master data with slave data
+    forAll(slaves, i)
+    {
+        const labelList& slavePoints = slaves[i];
+
+        // Copy master data to slave slots
+        forAll(slaves, j)
+        {
+            elems[slavePoints[j]] = elems[i];
+        }
+    }
+
+    // Push slave-slot data back to slaves
+    slavesMap.reverseDistribute(elems.size(), elems, false);
+
+    // Extract back onto mesh
+    forAll(meshPoints, i)
+    {
+        pointData[meshPoints[i]] = elems[i];
+    }
+}
+
+
 template<class Type>
 void volPointInterpolation::addSeparated
 (
@@ -204,7 +302,8 @@ void volPointInterpolation::interpolateBoundaryField
     }
 
     // Sum collocated contributions
-    mesh().globalData().syncPointData(pfi, plusEqOp<Type>());
+    //mesh().globalData().syncPointData(pfi, plusEqOp<Type>());
+    syncUntransformedData(pfi, plusEqOp<Type>());
 
     // And add separated contributions
     addSeparated(pf);
@@ -213,7 +312,8 @@ void volPointInterpolation::interpolateBoundaryField
     // a coupled point to have its master on a different patch so
     // to make sure just push master data to slaves. Reuse the syncPointData
     // structure.
-    mesh().globalData().syncPointData(pfi, nopEqOp<Type>());
+    //mesh().globalData().syncPointData(pfi, nopEqOp<Type>());
+    pushUntransformedData(pfi);
 
 
 
@@ -238,7 +338,8 @@ void volPointInterpolation::interpolateBoundaryField
     pf.correctBoundaryConditions();
 
     // Sync any dangling points
-    mesh().globalData().syncPointData(pfi, nopEqOp<Type>());
+    //mesh().globalData().syncPointData(pfi, nopEqOp<Type>());
+    pushUntransformedData(pfi);
 
     // Apply multiple constraints on edge/corner points
     applyCornerConstraints(pf);
diff --git a/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolation.C b/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolation.C
index 38dbab7944..72e6c5c19d 100644
--- a/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolation.C
+++ b/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolation.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -101,10 +101,11 @@ void volPointInterpolation::calcBoundaryAddressing()
     // no face of a certain patch still can have boundary points marked.
     if (debug)
     {
-
         boolList oldData(isPatchPoint_);
 
-        mesh().globalData().syncPointData(isPatchPoint_, orEqOp<bool>());
+        //mesh().globalData().syncPointData(isPatchPoint_, orEqOp<bool>());
+        syncUntransformedData(isPatchPoint_, orEqOp<bool>());
+
 
         forAll(isPatchPoint_, pointI)
         {
@@ -281,7 +282,8 @@ void volPointInterpolation::makeWeights()
 
 
     // Sum collocated contributions
-    mesh().globalData().syncPointData(sumWeights, plusEqOp<scalar>());
+    //mesh().globalData().syncPointData(sumWeights, plusEqOp<scalar>());
+    syncUntransformedData(sumWeights, plusEqOp<scalar>());
 
     // And add separated contributions
     addSeparated(sumWeights);
@@ -290,7 +292,8 @@ void volPointInterpolation::makeWeights()
     // a coupled point to have its master on a different patch so
     // to make sure just push master data to slaves. Reuse the syncPointData
     // structure.
-    mesh().globalData().syncPointData(sumWeights, nopEqOp<scalar>());
+    //mesh().globalData().syncPointData(sumWeights, nopEqOp<scalar>());
+    pushUntransformedData(sumWeights);
 
 
     // Normalise internal weights
diff --git a/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolation.H b/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolation.H
index 2c6863f63a..99ecb38641 100644
--- a/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolation.H
+++ b/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolation.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -105,6 +105,18 @@ class volPointInterpolation
         //- Make patch-patch constraints
         void makePatchPatchAddressing();
 
+        //- Helper: sync data on collocated points only
+        template<class Type, class CombineOp>
+        void syncUntransformedData
+        (
+            List<Type>& pointData,
+            const CombineOp& cop
+        ) const;
+
+        //- Helper: push master point data to collocated points
+        template<class Type>
+        void pushUntransformedData(List<Type>&) const;
+
         //- Get boundary field in same order as boundary faces. Field is
         //  zero on all coupled and empty patches
         template<class Type>