From 6c577922c5453d4223796dbd8bbe9004c0d99c24 Mon Sep 17 00:00:00 2001
From: Hrvoje Jasak <h.jasak@wikki.co.uk>
Date: Fri, 27 May 2011 18:17:39 +0100
Subject: [PATCH] Development branch merge

---
 .../processor/ProcessorPointPatchField.C      |   46 +-
 src/OpenFOAM/graph/curve/curve.H              |    1 +
 src/OpenFOAM/memory/autoPtr/autoPtr.H         |    3 +-
 .../constraint/processor/processorPolyPatch.C |   71 +-
 .../autoHexMeshDriver/autoLayerDriver.C       |    3 +-
 .../meshRefinement/meshRefinement.C           |    2 +-
 .../fvMeshDistribute/CompactListList_dev.C    |  257 --
 .../fvMeshDistribute/CompactListList_dev.H    |  270 --
 .../fvMeshDistribute/CompactListList_devI.H   |  276 --
 .../fvMeshDistribute/CompactListList_devIO.C  |   66 -
 .../fvMeshDistribute/fvMeshDistribute.C       | 2346 -----------------
 .../fvMeshDistribute/fvMeshDistribute.H       |  368 ---
 .../fvMeshDistributeTemplates.C               |  499 ----
 .../edgeInterpolationScheme.C                 |    6 +-
 .../flowRateInletVelocityFvPatchVectorField.C |    6 +-
 .../CoEulerDdtScheme/CoEulerDdtScheme.C       |    4 +-
 .../fvMesh/fvPatches/fvPatch/fvPatch.H        |    5 +-
 ...ProcessorTetPolyPatchCellDecompPointAddr.C |   11 +-
 18 files changed, 90 insertions(+), 4150 deletions(-)
 delete mode 100644 src/dynamicMesh/dynamicMesh/directTopoChange/fvMeshDistribute/CompactListList_dev.C
 delete mode 100644 src/dynamicMesh/dynamicMesh/directTopoChange/fvMeshDistribute/CompactListList_dev.H
 delete mode 100644 src/dynamicMesh/dynamicMesh/directTopoChange/fvMeshDistribute/CompactListList_devI.H
 delete mode 100644 src/dynamicMesh/dynamicMesh/directTopoChange/fvMeshDistribute/CompactListList_devIO.C
 delete mode 100644 src/dynamicMesh/dynamicMesh/directTopoChange/fvMeshDistribute/fvMeshDistribute.C
 delete mode 100644 src/dynamicMesh/dynamicMesh/directTopoChange/fvMeshDistribute/fvMeshDistribute.H
 delete mode 100644 src/dynamicMesh/dynamicMesh/directTopoChange/fvMeshDistribute/fvMeshDistributeTemplates.C

diff --git a/src/OpenFOAM/fields/PointPatchFields/constraint/processor/ProcessorPointPatchField.C b/src/OpenFOAM/fields/PointPatchFields/constraint/processor/ProcessorPointPatchField.C
index 677473247..b7835747d 100644
--- a/src/OpenFOAM/fields/PointPatchFields/constraint/processor/ProcessorPointPatchField.C
+++ b/src/OpenFOAM/fields/PointPatchFields/constraint/processor/ProcessorPointPatchField.C
@@ -466,9 +466,12 @@ initEvaluate
     const Pstream::commsTypes commsType
 )
 {
-    if (this->isPointField())
+    if (Pstream::parRun())
     {
-        initAddFieldTempl(Pstream::blocking, this->internalField());
+        if (this->isPointField())
+        {
+            initAddFieldTempl(Pstream::blocking, this->internalField());
+        }
     }
 }
 
@@ -491,27 +494,30 @@ evaluate
     const Pstream::commsTypes commsType
 )
 {
-    if (this->isPointField())
+    if (Pstream::parRun())
     {
-        // Get the neighbour side values
-        tmp<Field<Type> > tpNeighbour = receivePointField<Type>(commsType);
-        Field<Type>& tpn = tpNeighbour();
-
-        if (doTransform())
+        if (this->isPointField())
         {
-            const processorPolyPatch& ppp = procPatch_.procPolyPatch();
-            const tensorField& forwardT = ppp.forwardT();
+            // Get the neighbour side values
+            tmp<Field<Type> > tpNeighbour = receivePointField<Type>(commsType);
+            Field<Type>& tpn = tpNeighbour();
 
-            transform(tpn, forwardT[0], tpn);
+            if (doTransform())
+            {
+                const processorPolyPatch& ppp = procPatch_.procPolyPatch();
+                const tensorField& forwardT = ppp.forwardT();
+
+                transform(tpn, forwardT[0], tpn);
+            }
+
+            // Average over two sides
+            tpn = 0.5*(patchInternalField(this->internalField()) + tpn);
+
+            // Get internal field to insert values into
+            Field<Type>& iF = const_cast<Field<Type>&>(this->internalField());
+
+            this->setInInternalField(iF, tpn);
         }
-
-        // Average over two sides
-        tpn = 0.5*(patchInternalField(this->internalField()) + tpn);
-
-        // Get internal field to insert values into
-        Field<Type>& iF = const_cast<Field<Type>&>(this->internalField());
-
-        this->setInInternalField(iF, tpn);
     }
 }
 
@@ -697,7 +703,7 @@ initAddUpperLower
 {
     // Gather the data from the given field and send it. Note that the
     // size of the field is equal to the number of edges on the field
-    // and NOT the number of points.  
+    // and NOT the number of points.  HJ, 14/Nov/2001
 
     // Get the addressing
     const labelList& me = procPatch_.localEdgeIndices();
diff --git a/src/OpenFOAM/graph/curve/curve.H b/src/OpenFOAM/graph/curve/curve.H
index 31d81d3dc..3008f60c3 100644
--- a/src/OpenFOAM/graph/curve/curve.H
+++ b/src/OpenFOAM/graph/curve/curve.H
@@ -144,6 +144,7 @@ public:
             const scalarField& y
         );
 
+        //- Create and return a clone
         autoPtr<curve> clone() const
         {
             return autoPtr<curve>(new curve(*this));
diff --git a/src/OpenFOAM/memory/autoPtr/autoPtr.H b/src/OpenFOAM/memory/autoPtr/autoPtr.H
index fd5e6643c..a4dee6035 100644
--- a/src/OpenFOAM/memory/autoPtr/autoPtr.H
+++ b/src/OpenFOAM/memory/autoPtr/autoPtr.H
@@ -95,7 +95,8 @@ public:
             //  If object pointer already set issue a FatalError.
             inline void set(T*);
 
-            //- If object pointer already set, delete object and set to given pointer
+            //- If object pointer already set, delete object and set to
+            //  given pointer
             inline void reset(T* = 0);
 
             //- If object pointer points to valid object:
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.C b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.C
index 1d365aa09..a8e6fff36 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.C
@@ -182,7 +182,7 @@ void Foam::processorPolyPatch::calcGeometry()
         // Cache face areas
         const vectorField::subField localFaceAreas = faceAreas();
 
-        forAll(faceNormals, facei)
+        forAll (faceNormals, facei)
         {
             scalar magSf = mag(localFaceAreas[facei]);
             scalar nbrMagSf = mag(neighbFaceAreas_[facei]);
@@ -320,6 +320,10 @@ void Foam::processorPolyPatch::updateMesh()
         {
             // Note cannot predict exact size since opposite nPoints might
             // be different from one over here.
+
+            // Disagree: This needs to be sorted out, so that processor patches
+            // are simply internal faces and treat cyclics separately
+            // HJ, 10/Mar/2011
             IPstream fromNeighbProc(Pstream::blocking, neighbProcNo());
 
             fromNeighbProc
@@ -338,7 +342,7 @@ void Foam::processorPolyPatch::updateMesh()
         neighbPointsPtr_ = new labelList(nPoints(), -1);
         labelList& neighbPoints = *neighbPointsPtr_;
 
-        forAll(nbrPointFace, nbrPointI)
+        forAll (nbrPointFace, nbrPointI)
         {
             // Find face and index in face on this side.
             const face& f = localFaces()[nbrPointFace[nbrPointI]];
@@ -358,7 +362,7 @@ void Foam::processorPolyPatch::updateMesh()
         }
 
         // Reset all duplicate entries to -1.
-        forAll(neighbPoints, patchPointI)
+        forAll (neighbPoints, patchPointI)
         {
             if (neighbPoints[patchPointI] == -2)
             {
@@ -372,7 +376,7 @@ void Foam::processorPolyPatch::updateMesh()
         neighbEdgesPtr_ = new labelList(nEdges(), -1);
         labelList& neighbEdges = *neighbEdgesPtr_;
 
-        forAll(nbrEdgeFace, nbrEdgeI)
+        forAll (nbrEdgeFace, nbrEdgeI)
         {
             // Find face and index in face on this side.
             const labelList& f = faceEdges()[nbrEdgeFace[nbrEdgeI]];
@@ -392,7 +396,7 @@ void Foam::processorPolyPatch::updateMesh()
         }
 
         // Reset all duplicate entries to -1.
-        forAll(neighbEdges, patchEdgeI)
+        forAll (neighbEdges, patchEdgeI)
         {
             if (neighbEdges[patchEdgeI] == -2)
             {
@@ -414,6 +418,7 @@ const Foam::labelList& Foam::processorPolyPatch::neighbPoints() const
             << "No extended addressing calculated for patch " << name()
             << abort(FatalError);
     }
+
     return *neighbPointsPtr_;
 }
 
@@ -426,6 +431,7 @@ const Foam::labelList& Foam::processorPolyPatch::neighbEdges() const
             << "No extended addressing calculated for patch " << name()
             << abort(FatalError);
     }
+
     return *neighbEdgesPtr_;
 }
 
@@ -437,12 +443,13 @@ void Foam::processorPolyPatch::initOrder(const primitivePatch& pp) const
         return;
     }
 
-    const bool isMaster = Pstream::myProcNo() < neighbProcNo();
-
-    if (isMaster)
+    // Master side sends the data and slave side rotates the faces
+    // HJ, 10/Mar/2011
+    if (owner())
     {
         pointField ctrs(calcFaceCentres(pp, pp.points()));
 
+        // Anchor point is the start point of all faces.  HJ, 10/Mar/2011
         pointField anchors(getAnchorPoints(pp, pp.points()));
 
         // Now send all info over to the neighbour
@@ -475,7 +482,7 @@ bool Foam::processorPolyPatch::order
         fileName nm
         (
             boundaryMesh().mesh().time().path()
-           /name()+"_faces.obj"
+           /name() + "_faces.obj"
         );
         Pout<< "processorPolyPatch::order : Writing my " << pp.size()
             << " faces to OBJ file " << nm << endl;
@@ -493,7 +500,7 @@ bool Foam::processorPolyPatch::order
             << "Dumping " << ctrs.size()
             << " local faceCentres to " << localStr.name() << endl;
 
-        forAll(ctrs, faceI)
+        forAll (ctrs, faceI)
         {
             writeOBJ(localStr, ctrs[faceI]);
         }
@@ -505,13 +512,11 @@ bool Foam::processorPolyPatch::order
     rotation.setSize(pp.size());
     rotation = 0;
 
-    const bool isMaster = Pstream::myProcNo() < neighbProcNo();
-
-    if (isMaster)
+    if (owner())
     {
         // Do nothing (i.e. identical mapping, zero rotation).
         // See comment at top.
-        forAll(faceMap, patchFaceI)
+        forAll (faceMap, patchFaceI)
         {
             faceMap[patchFaceI] = patchFaceI;
         }
@@ -520,6 +525,7 @@ bool Foam::processorPolyPatch::order
     }
     else
     {
+        // Slave side: receive points
         vectorField masterCtrs;
         vectorField masterAnchors;
 
@@ -543,10 +549,12 @@ bool Foam::processorPolyPatch::order
                     boundaryMesh().mesh().time().path()
                    /name() + "_nbrFaceCentres.obj"
                 );
+
                 Pout<< "processorPolyPatch::order : "
                     << "Dumping neighbour faceCentres to " << nbrStr.name()
                     << endl;
-                forAll(masterCtrs, faceI)
+
+                forAll (masterCtrs, faceI)
                 {
                     writeOBJ(nbrStr, masterCtrs[faceI]);
                 }
@@ -585,12 +593,13 @@ bool Foam::processorPolyPatch::order
 
             if (v.size() == 1)
             {
-                transformedCtrs = masterCtrs-v[0];
+                transformedCtrs = masterCtrs - v[0];
             }
             else
             {
-                transformedCtrs = masterCtrs-v;
+                transformedCtrs = masterCtrs - v;
             }
+
             matchedAll = matchPoints
             (
                 ctrs,
@@ -624,6 +633,7 @@ bool Foam::processorPolyPatch::order
         {
             vectorField transformedCtrs = masterCtrs;
             transformList(forwardT(), transformedCtrs);
+
             matchedAll = matchPoints
             (
                 ctrs,
@@ -656,7 +666,7 @@ bool Foam::processorPolyPatch::order
             fileName str
             (
                 boundaryMesh().mesh().time().path()
-               /name()/name()+"_faces.obj"
+               /name()/name() + "_faces.obj"
             );
             Pout<< "processorPolyPatch::order :"
                 << " Writing faces to OBJ file " << str.name() << endl;
@@ -675,7 +685,7 @@ bool Foam::processorPolyPatch::order
 
             label vertI = 0;
 
-            forAll(ctrs, faceI)
+            forAll (ctrs, faceI)
             {
                 label masterFaceI = faceMap[faceI];
 
@@ -690,7 +700,8 @@ bool Foam::processorPolyPatch::order
 
         if (!matchedAll)
         {
-            SeriousErrorIn
+            FatalErrorIn
+//             SeriousErrorIn
             (
                 "processorPolyPatch::order(const primitivePatch&"
                 ", labelList&, labelList&) const"
@@ -703,13 +714,13 @@ bool Foam::processorPolyPatch::order
                 << " multiple separated (from cyclics) processor patches"
                 << endl
                 << "    Continuing with incorrect face ordering from now on!"
-                << endl;
+                << abort(FatalError);
 
             return false;
         }
 
-        // Set rotation.
-        forAll(faceMap, oldFaceI)
+        // Set rotation
+        forAll (faceMap, oldFaceI)
         {
             // The face f will be at newFaceI (after morphing) and we want its
             // anchorPoint (= f[0]) to align with the anchorpoint for the
@@ -729,7 +740,8 @@ bool Foam::processorPolyPatch::order
 
             if (rotation[newFaceI] == -1)
             {
-                SeriousErrorIn
+                FatalErrorIn
+//                 SeriousErrorIn
                 (
                     "processorPolyPatch::order(const primitivePatch&"
                     ", labelList&, labelList&) const"
@@ -742,13 +754,13 @@ bool Foam::processorPolyPatch::order
                     << " when matching the halves of processor patch "
                     << name()
                     << "Continuing with incorrect face ordering from now on!"
-                    << endl;
+                    << abort(FatalError);
 
                 return false;
             }
         }
 
-        forAll(faceMap, faceI)
+        forAll (faceMap, faceI)
         {
             if (faceMap[faceI] != faceI || rotation[faceI] != 0)
             {
@@ -768,10 +780,8 @@ void Foam::processorPolyPatch::syncOrder() const
         return;
     }
 
-    // Read and discard info from master side
-    const bool isMaster = Pstream::myProcNo() < neighbProcNo();
-
-    if (!isMaster)
+    // Read and discard info from owner side from the neighbour
+    if (neighbour())
     {
         vectorField masterCtrs;
         vectorField masterAnchors;
@@ -784,6 +794,7 @@ void Foam::processorPolyPatch::syncOrder() const
     }
 }
 
+
 void Foam::processorPolyPatch::write(Ostream& os) const
 {
     polyPatch::write(os);
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.C b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.C
index 172205b05..f8fc6551d 100644
--- a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.C
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.C
@@ -2975,7 +2975,8 @@ void Foam::autoLayerDriver::addLayers
             );
 
             const_cast<Time&>(mesh.time())++;
-            Info<< "Writing shrunk mesh to " << meshRefiner_.timeName() << endl;
+            Info<< "Writing shrunk mesh to " << meshRefiner_.timeName()
+                << endl;
 
             // See comment in autoSnapDriver why we should not remove meshPhi
             // using mesh.clearPout().
diff --git a/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.C b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.C
index 1b2fd2043..3b661f455 100644
--- a/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.C
+++ b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.C
@@ -1613,7 +1613,7 @@ Foam::label Foam::meshRefinement::addPatch
     fvBoundaryMesh& fvPatches = const_cast<fvBoundaryMesh&>(mesh.boundary());
 
     // Add polyPatch at the end
-    polyPatches.setSize(sz+1);
+    polyPatches.setSize(sz + 1);
     polyPatches.set
     (
         sz,
diff --git a/src/dynamicMesh/dynamicMesh/directTopoChange/fvMeshDistribute/CompactListList_dev.C b/src/dynamicMesh/dynamicMesh/directTopoChange/fvMeshDistribute/CompactListList_dev.C
deleted file mode 100644
index 81e2d907b..000000000
--- a/src/dynamicMesh/dynamicMesh/directTopoChange/fvMeshDistribute/CompactListList_dev.C
+++ /dev/null
@@ -1,257 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright held by original author
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-\*---------------------------------------------------------------------------*/
-
-#include "CompactListList_dev.H"
-
-// * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * //
-
-template<class T, class Container>
-Foam::CompactListList_dev<T, Container>::CompactListList_dev(const List<Container>& ll)
-:
-    size_(ll.size()),
-    offsets_(ll.size()+1)
-{
-    label sumSize = 0;
-    offsets_[0] = 0;
-    forAll(ll, i)
-    {
-        sumSize += ll[i].size();
-        offsets_[i+1] = sumSize;
-    }
-
-    m_.setSize(sumSize);
-
-    label k = 0;
-    forAll(ll, i)
-    {
-        const Container& lli = ll[i];
-
-        forAll(lli, j)
-        {
-            m_[k++] = lli[j];
-        }
-    }
-}
-
-
-template<class T, class Container>
-Foam::CompactListList_dev<T, Container>::CompactListList_dev
-(
-    const UList<label>& rowSizes
-)
-:
-    size_(rowSizes.size()),
-    offsets_(rowSizes.size()+1)
-{
-    label sumSize = 0;
-    offsets_[0] = 0;
-    forAll(rowSizes, i)
-    {
-        sumSize += rowSizes[i];
-        offsets_[i+1] = sumSize;
-    }
-
-    m_.setSize(sumSize);
-}
-
-
-template<class T, class Container>
-Foam::CompactListList_dev<T, Container>::CompactListList_dev
-(
-    const UList<label>& rowSizes,
-    const T& t
-)
-:
-    size_(rowSizes.size()),
-    offsets_(rowSizes.size()+1)
-{
-    label sumSize = 0;
-    offsets_[0] = 0;
-    forAll(rowSizes, i)
-    {
-        sumSize += rowSizes[i];
-        offsets_[i+1] = sumSize;
-    }
-
-    m_.setSize(sumSize, t);
-}
-
-
-template<class T, class Container>
-Foam::CompactListList_dev<T, Container>::CompactListList_dev
-(
-    const Xfer<CompactListList_dev<T, Container> >& lst
-)
-{
-    transfer(lst());
-}
-
-
-template<class T, class Container>
-Foam::CompactListList_dev<T, Container>::CompactListList_dev
-(
-    CompactListList_dev<T, Container>& lst,
-    bool reUse
-)
-:
-    size_(lst.size()),
-    offsets_(lst.offsets_, reUse),
-    m_(lst.m_, reUse)
-{}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-template<class T, class Container>
-void Foam::CompactListList_dev<T, Container>::setSize(const label nRows)
-{
-    if (nRows == 0)
-    {
-        clear();
-    }
-    if (nRows < size())
-    {
-        size_ = nRows;
-        offsets_.setSize(nRows+1);
-        m_.setSize(offsets_[nRows]);
-    }
-    else if (nRows > size())
-    {
-        FatalErrorIn
-        (
-            "CompactListList_dev<T, Container>::setSize(const label nRows)"
-        )   << "Cannot be used to extend the list from " << offsets_.size()
-            << " to " << nRows << nl
-            << "    Please use one of the other setSize member functions"
-            << abort(FatalError);
-    }
-}
-
-
-template<class T, class Container>
-void Foam::CompactListList_dev<T, Container>::setSize
-(
-    const label nRows,
-    const label nData
-)
-{
-    size_ = nRows;
-    offsets_.setSize(nRows+1);
-    m_.setSize(nData);
-}
-
-
-template<class T, class Container>
-void Foam::CompactListList_dev<T, Container>::setSize
-(
-    const label nRows,
-    const label nData,
-    const T& t
-)
-{
-    size_ = nRows;
-    offsets_.setSize(nRows+1);
-    m_.setSize(nData, t);
-}
-
-
-template<class T, class Container>
-void Foam::CompactListList_dev<T, Container>::setSize(const UList<label>& rowSizes)
-{
-    size_ = rowSizes.size();
-    offsets_.setSize(rowSizes.size()+1);
-
-    label sumSize = 0;
-    offsets_[0] = 0;
-    forAll(rowSizes, i)
-    {
-        sumSize += rowSizes[i];
-        offsets_[i+1] = sumSize;
-    }
-
-    m_.setSize(sumSize);
-}
-
-
-template<class T, class Container>
-Foam::labelList Foam::CompactListList_dev<T, Container>::sizes() const
-{
-    labelList rowSizes(size());
-
-    if (rowSizes.size() > 0)
-    {
-        forAll(rowSizes, i)
-        {
-            rowSizes[i] = offsets_[i+1] - offsets_[i];
-        }
-    }
-    return rowSizes;
-}
-
-
-template<class T, class Container>
-void Foam::CompactListList_dev<T, Container>::clear()
-{
-    size_ = 0;
-    offsets_.clear();
-    m_.clear();
-}
-
-
-template<class T, class Container>
-void Foam::CompactListList_dev<T, Container>::transfer
-(
-    CompactListList_dev<T, Container>& a
-)
-{
-    size_ = a.size_;
-    offsets_.transfer(a.offsets_);
-    m_.transfer(a.m_);
-}
-
-
-// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
-
-template<class T, class Container>
-Foam::List<Container> Foam::CompactListList_dev<T, Container>::operator()()
-const
-{
-    List<Container> ll(size());
-
-    forAll(ll, i)
-    {
-        ll[i] = Container(operator[](i));
-    }
-
-    return ll;
-}
-
-
-// * * * * * * * * * * * * * * * *  IOStream operators * * * * * * * * * * * //
-
-#include "CompactListList_devIO.C"
-
-// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicMesh/directTopoChange/fvMeshDistribute/CompactListList_dev.H b/src/dynamicMesh/dynamicMesh/directTopoChange/fvMeshDistribute/CompactListList_dev.H
deleted file mode 100644
index 03efbf853..000000000
--- a/src/dynamicMesh/dynamicMesh/directTopoChange/fvMeshDistribute/CompactListList_dev.H
+++ /dev/null
@@ -1,270 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright held by original author
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-Class
-    Foam::CompactListList_dev
-
-Description
-    A packed storage unstructured matrix of objects of type \<T\>
-    using an offset table for access.
-
-    The offset table is the size of the number of rows+1
-    whose elements are the
-    accumulated sizes of the rows, i.e.
-      - offset[i] gives the index of first element of row i
-      - offset[i+1] - offset[i] is the number of elements in row i
-
-    Storage is allocated on free-store during construction.
-
-    As a special case a null-contructed CompactListList_dev has an empty
-    offsets_ (instead of size 1).
-
-SourceFiles
-    CompactListList_dev.C
-    CompactListList_devI.H
-    CompactListList_devIO.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef CompactListListDev_H
-#define CompactListListDev_H
-
-#include "labelList.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// Forward declaration of friend functions and operators
-
-template<class T, class Container> class CompactListList_dev;
-
-template<class T, class Container> Istream& operator>>
-(
-    Istream&,
-    CompactListList_dev<T, Container>&
-);
-template<class T, class Container> Ostream& operator<<
-(
-    Ostream&,
-    const CompactListList_dev<T, Container>&
-);
-
-
-/*---------------------------------------------------------------------------*\
-                       Class CompactListList_dev Declaration
-\*---------------------------------------------------------------------------*/
-
-template<class T, class Container = List<T> >
-class CompactListList_dev
-{
-    // Private data
-
-        label size_;
-
-        //- Offset table
-        List<label> offsets_;
-
-        //- Packed matrix of data
-        List<T> m_;
-
-
-public:
-
-    // Static Member Functions
-
-        //- Return a null CompactListList_dev
-        inline static const CompactListList_dev<T, Container>& null();
-
-    // Constructors
-
-        //- Null constructor.
-        inline CompactListList_dev();
-
-        //- Construct by converting given List<List<T> >
-        explicit CompactListList_dev(const List<Container>&);
-
-        //- Construct given size of offset table (number of rows)
-        //  and number of data.
-        inline CompactListList_dev(const label nRows, const label nData);
-
-        //- Construct given size of offset table (number of rows),
-        //  the number of data and a value for all elements.
-        inline CompactListList_dev(const label nRows, const label nData, const T&);
-
-        //- Construct given list of row-sizes.
-        explicit CompactListList_dev(const UList<label>& rowSizes);
-
-        //- Construct given list of row-sizes
-        CompactListList_dev(const UList<label>& rowSizes, const T&);
-
-        //- Construct by transferring the parameter contents
-        explicit CompactListList_dev(const Xfer<CompactListList_dev<T, Container> >&);
-
-        //- Construct as copy or re-use as specified.
-        CompactListList_dev(CompactListList_dev<T, Container>&, bool reUse);
-
-        //- Construct from Istream.
-        CompactListList_dev(Istream&);
-
-        //- Clone
-        inline autoPtr<CompactListList_dev<T, Container> > clone() const;
-
-
-    // Member Functions
-
-        // Access
-
-            //- Return the primary size, i.e. the number of rows
-            inline label size() const;
-
-            //- Return true if the number of rows is zero
-            inline bool empty() const;
-
-            //- Return the offset table (= size()+1)
-            inline const List<label>& offsets() const;
-
-            //- Return non-const access to the offset table
-            inline List<label>& offsets();
-
-            //- Return the packed matrix of data
-            inline const List<T>& m() const;
-
-            //- Return non-const access to the packed matrix of data
-            inline List<T>& m();
-
-
-        // Edit
-
-            //- Reset size of CompactListList_dev.
-            //  This form only allows contraction of the CompactListList_dev.
-            void setSize(const label nRows);
-
-            //- Reset size of CompactListList_dev.
-            void setSize(const label nRows, const label nData);
-
-            //- Reset sizes of CompactListList_dev and value for new elements.
-            void setSize(const label nRows, const label nData, const T&);
-
-            //- Reset size of CompactListList_dev.
-            void setSize(const UList<label>& rowSizes);
-
-            //- Reset size of CompactListList_dev.
-            //  This form only allows contraction of the CompactListList_dev.
-            inline void resize(const label nRows);
-
-            //- Reset size of CompactListList_dev.
-            inline void resize(const label nRows, const label nData);
-
-            //- Reset sizes of CompactListList_dev and value for new elements.
-            inline void resize(const label nRows, const label nData, const T&);
-
-            //- Reset size of CompactListList_dev.
-            inline void resize(const UList<label>& rowSizes);
-
-            //- Clear the CompactListList_dev, i.e. set sizes to zero.
-            void clear();
-
-            //- Return sizes (to be used e.g. for construction)
-            labelList sizes() const;
-
-            //- Transfer the contents of the argument CompactListList_dev
-            //  into this CompactListList_dev and annul the argument list.
-            void transfer(CompactListList_dev<T, Container>&);
-
-            //- Transfer the contents to the Xfer container
-            inline Xfer<CompactListList_dev<T, Container> > xfer();
-
-        // Other
-
-            //- Return index into m
-            inline label index(const label row, const label col) const;
-
-            //- Get row for index into m.
-            inline label whichRow(const label index) const;
-
-            //- Get column index (j) given above row
-            inline label whichColumn(const label row, const label index) const;
-
-
-    // Member operators
-
-        //- Return subscript-checked row as UList.
-        inline UList<T> operator[](const label i);
-
-        //- Return const subscript-checked row as UList.
-        inline const UList<T> operator[](const label i) const;
-
-        //- Return subscript-checked element.
-        inline T& operator()(const label i, const label j);
-
-        //- Return const subscript-checked element.
-        inline const T& operator()(const label i, const label j) const;
-
-        //- Return as List<Container>
-        List<Container> operator()() const;
-
-        //- Assignment of all entries to the given value
-        inline void operator=(const T&);
-
-
-    // Istream operator
-
-        //- Read CompactListList_dev from Istream, discarding contents
-        //  of existing CompactListList_dev.
-        friend Istream& operator>> <T, Container>
-        (
-            Istream&,
-            CompactListList_dev<T, Container>&
-        );
-
-        // Write CompactListList_dev to Ostream.
-        friend Ostream& operator<< <T, Container>
-        (
-            Ostream&,
-            const CompactListList_dev<T, Container>&
-        );
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#   include "CompactListList_devI.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#ifdef NoRepository
-#   include "CompactListList_dev.C"
-#endif
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicMesh/directTopoChange/fvMeshDistribute/CompactListList_devI.H b/src/dynamicMesh/dynamicMesh/directTopoChange/fvMeshDistribute/CompactListList_devI.H
deleted file mode 100644
index ab6cf1daf..000000000
--- a/src/dynamicMesh/dynamicMesh/directTopoChange/fvMeshDistribute/CompactListList_devI.H
+++ /dev/null
@@ -1,276 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright held by original author
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-\*---------------------------------------------------------------------------*/
-
-#include "ListOps.H"
-#include "SubList.H"
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-template<class T, class Container>
-inline Foam::CompactListList_dev<T, Container>::CompactListList_dev()
-:
-    size_(0)
-{}
-
-
-template<class T, class Container>
-inline Foam::CompactListList_dev<T, Container>::CompactListList_dev
-(
-    const label nRows,
-    const label nData
-)
-:
-    size_(nRows),
-    offsets_(nRows+1, 0),
-    m_(nData)
-{}
-
-
-template<class T, class Container>
-inline Foam::CompactListList_dev<T, Container>::CompactListList_dev
-(
-    const label nRows,
-    const label nData,
-    const T& t
-)
-:
-    size_(nRows),
-    offsets_(nRows+1, 0),
-    m_(nData, t)
-{}
-
-
-template<class T, class Container>
-inline Foam::autoPtr<Foam::CompactListList_dev<T, Container> >
-Foam::CompactListList_dev<T, Container>::clone() const
-{
-    return autoPtr<CompactListList_dev<T, Container> >
-    (
-        new CompactListList_dev<T, Container>(*this)
-    );
-}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-template<class T, class Container>
-inline const Foam::CompactListList_dev<T, Container>&
-Foam::CompactListList_dev<T, Container>::null()
-{
-    return *reinterpret_cast< CompactListList_dev<T, Container>* >(0);
-}
-
-
-template<class T, class Container>
-inline Foam::label Foam::CompactListList_dev<T, Container>::size() const
-{
-    return size_;
-}
-
-
-template<class T, class Container>
-inline bool Foam::CompactListList_dev<T, Container>::empty() const
-{
-    return !size_;
-}
-
-
-template<class T, class Container>
-inline const Foam::List<Foam::label>&
-Foam::CompactListList_dev<T, Container>::offsets() const
-{
-    return offsets_;
-}
-
-
-template<class T, class Container>
-inline Foam::List<Foam::label>& Foam::CompactListList_dev<T, Container>::offsets()
-{
-    return offsets_;
-}
-
-
-template<class T, class Container>
-inline const Foam::List<T>& Foam::CompactListList_dev<T, Container>::m()
-const
-{
-    return m_;
-}
-
-
-template<class T, class Container>
-inline Foam::List<T>& Foam::CompactListList_dev<T, Container>::m()
-{
-    return m_;
-}
-
-
-template<class T, class Container>
-inline Foam::label Foam::CompactListList_dev<T, Container>::index
-(
-    const label i,
-    const label j
-) const
-{
-    return offsets_[i] + j;
-}
-
-
-template<class T, class Container>
-inline Foam::label Foam::CompactListList_dev<T, Container>::whichRow(const label i)
-const
-{
-    if (i < 0 || i >= m_.size())
-    {
-        FatalErrorIn
-        (
-            "CompactListList_dev<T, Container>::whichRow(const label) const"
-        )   << "Index " << i << " outside 0.." << m_.size()
-            << abort(FatalError);
-    }
-
-    return findLower(offsets_, i+1);
-}
-
-
-template<class T, class Container>
-inline Foam::label Foam::CompactListList_dev<T, Container>::whichColumn
-(
-    const label row,
-    const label i
-) const
-{
-    return i - index(row, 0);
-}
-
-
-template<class T, class Container>
-inline Foam::Xfer<Foam::CompactListList_dev<T, Container> >
-Foam::CompactListList_dev<T, Container>::xfer()
-{
-    return xferMove(*this);
-}
-
-
-template<class T, class Container>
-inline void Foam::CompactListList_dev<T, Container>::resize(const label nRows)
-{
-    this->setSize(nRows);
-}
-
-
-template<class T, class Container>
-inline void Foam::CompactListList_dev<T, Container>::resize
-(
-    const label nRows,
-    const label nData
-)
-{
-    this->setSize(nRows, nData);
-}
-
-
-template<class T, class Container>
-inline void Foam::CompactListList_dev<T, Container>::resize
-(
-    const label nRows,
-    const label nData,
-    const T& t
-)
-{
-    this->setSize(nRows, nData, t);
-}
-
-
-template<class T, class Container>
-inline void Foam::CompactListList_dev<T, Container>::resize
-(
-    const UList<label>& rowSizes
-)
-{
-    this->setSize(rowSizes);
-}
-
-
-// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
-
-template<class T, class Container>
-inline Foam::UList<T> Foam::CompactListList_dev<T, Container>::operator[]
-(
-    const label i
-)
-{
-    label start = offsets_[i];
-    return UList<T>((m_.size() ? &m_[start] : NULL), offsets_[i+1] - start);
-}
-
-
-template<class T, class Container>
-inline const Foam::UList<T>
-Foam::CompactListList_dev<T, Container>::operator[]
-(
-    const label i
-) const
-{
-    label start = offsets_[i];
-    return UList<T>
-    (
-        (m_.size() ? const_cast<T*>(&m_[start]) : NULL),
-        offsets_[i+1] - start
-    );
-}
-
-
-template<class T, class Container>
-inline T& Foam::CompactListList_dev<T, Container>::operator()
-(
-    const label i,
-    const label j
-)
-{
-    return m_[index(i, j)];
-}
-
-
-template<class T, class Container>
-inline const T& Foam::CompactListList_dev<T, Container>::operator()
-(
-    const label i,
-    const label j
-) const
-{
-    return m_[index(i, j)];
-}
-
-
-template<class T, class Container>
-inline void Foam::CompactListList_dev<T, Container>::operator=(const T& t)
-{
-    m_ = t;
-}
-
-
-// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicMesh/directTopoChange/fvMeshDistribute/CompactListList_devIO.C b/src/dynamicMesh/dynamicMesh/directTopoChange/fvMeshDistribute/CompactListList_devIO.C
deleted file mode 100644
index 370893368..000000000
--- a/src/dynamicMesh/dynamicMesh/directTopoChange/fvMeshDistribute/CompactListList_devIO.C
+++ /dev/null
@@ -1,66 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright held by original author
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-\*---------------------------------------------------------------------------*/
-
-#include "CompactListList_dev.H"
-#include "Istream.H"
-
-// * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * //
-
-template<class T, class Container>
-Foam::CompactListList_dev<T, Container>::CompactListList_dev(Istream& is)
-{
-    operator>>(is, *this);
-}
-
-
-// * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
-
-template<class T, class Container>
-Foam::Istream& Foam::operator>>(Istream& is, CompactListList_dev<T, Container>& lst)
-{
-    is  >> lst.offsets_ >> lst.m_;
-    // Note: empty list gets output as two empty lists
-    if (lst.offsets_.size() == 0)
-    {
-        lst.size_ = 0;
-    }
-    else
-    {
-        lst.size_ = lst.offsets_.size()-1;
-    }
-    return is;
-}
-
-
-template<class T, class Container>
-Foam::Ostream& Foam::operator<<(Ostream& os, const CompactListList_dev<T, Container>& lst)
-{
-    os  << lst.offsets_ << lst.m_;
-    return os;
-}
-
-
-// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicMesh/directTopoChange/fvMeshDistribute/fvMeshDistribute.C b/src/dynamicMesh/dynamicMesh/directTopoChange/fvMeshDistribute/fvMeshDistribute.C
deleted file mode 100644
index 3af48b008..000000000
--- a/src/dynamicMesh/dynamicMesh/directTopoChange/fvMeshDistribute/fvMeshDistribute.C
+++ /dev/null
@@ -1,2346 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright held by original author
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-\*---------------------------------------------------------------------------*/
-
-#include "CompactListList_dev.H"
-#include "fvMeshDistribute.H"
-#include "PstreamCombineReduceOps.H"
-#include "fvMeshAdder.H"
-#include "faceCoupleInfo.H"
-#include "processorFvPatchField.H"
-#include "processorFvsPatchField.H"
-#include "directTopoChange.H"
-#include "removeCells.H"
-#include "polyModifyFace.H"
-#include "polyRemovePoint.H"
-#include "mergePoints.H"
-#include "mapDistributePolyMesh.H"
-#include "surfaceFields.H"
-#include "syncTools.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-defineTypeNameAndDebug(Foam::fvMeshDistribute, 0);
-
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-Foam::labelList Foam::fvMeshDistribute::select
-(
-    const bool selectEqual,
-    const labelList& values,
-    const label value
-)
-{
-    label n = 0;
-
-    forAll(values, i)
-    {
-        if (selectEqual == (values[i] == value))
-        {
-            n++;
-        }
-    }
-
-    labelList indices(n);
-    n = 0;
-
-    forAll(values, i)
-    {
-        if (selectEqual == (values[i] == value))
-        {
-            indices[n++] = i;
-        }
-    }
-    return indices;
-}
-
-
-// Check all procs have same names and in exactly same order.
-void Foam::fvMeshDistribute::checkEqualWordList
-(
-    const string& msg,
-    const wordList& lst
-)
-{
-    List<wordList> allNames(Pstream::nProcs());
-    allNames[Pstream::myProcNo()] = lst;
-    Pstream::gatherList(allNames);
-    Pstream::scatterList(allNames);
-
-    for (label procI = 1; procI < Pstream::nProcs(); procI++)
-    {
-        if (allNames[procI] != allNames[0])
-        {
-            FatalErrorIn("fvMeshDistribute::checkEqualWordList(..)")
-                << "When checking for equal " << msg.c_str() << " :" << endl
-                << "processor0 has:" << allNames[0] << endl
-                << "processor" << procI << " has:" << allNames[procI] << endl
-                << msg.c_str() << " need to be synchronised on all processors."
-                << exit(FatalError);
-        }
-    }
-}
-
-
-Foam::wordList Foam::fvMeshDistribute::mergeWordList(const wordList& procNames)
-{
-    List<wordList> allNames(Pstream::nProcs());
-    allNames[Pstream::myProcNo()] = procNames;
-    Pstream::gatherList(allNames);
-    Pstream::scatterList(allNames);
-
-    HashSet<word> mergedNames;
-    forAll(allNames, procI)
-    {
-        forAll(allNames[procI], i)
-        {
-            mergedNames.insert(allNames[procI][i]);
-        }
-    }
-    return mergedNames.toc();
-}
-
-
-// Print some info on mesh.
-void Foam::fvMeshDistribute::printMeshInfo(const fvMesh& mesh)
-{
-    Pout<< "Primitives:" << nl
-        << "    points       :" << mesh.nPoints() << nl
-        << "    internalFaces:" << mesh.nInternalFaces() << nl
-        << "    faces        :" << mesh.nFaces() << nl
-        << "    cells        :" << mesh.nCells() << nl;
-
-    const fvBoundaryMesh& patches = mesh.boundary();
-
-    Pout<< "Patches:" << endl;
-    forAll(patches, patchI)
-    {
-        const polyPatch& pp = patches[patchI].patch();
-
-        Pout<< "    " << patchI << " name:" << pp.name()
-            << " size:" << pp.size()
-            << " start:" << pp.start()
-            << " type:" << pp.type()
-            << endl;
-    }
-
-    if (mesh.pointZones().size())
-    {
-        Pout<< "PointZones:" << endl;
-        forAll(mesh.pointZones(), zoneI)
-        {
-            const pointZone& pz = mesh.pointZones()[zoneI];
-            Pout<< "    " << zoneI << " name:" << pz.name()
-                << " size:" << pz.size()
-                << endl;
-        }
-    }
-    if (mesh.faceZones().size())
-    {
-        Pout<< "FaceZones:" << endl;
-        forAll(mesh.faceZones(), zoneI)
-        {
-            const faceZone& fz = mesh.faceZones()[zoneI];
-            Pout<< "    " << zoneI << " name:" << fz.name()
-                << " size:" << fz.size()
-                << endl;
-        }
-    }
-    if (mesh.cellZones().size())
-    {
-        Pout<< "CellZones:" << endl;
-        forAll(mesh.cellZones(), zoneI)
-        {
-            const cellZone& cz = mesh.cellZones()[zoneI];
-            Pout<< "    " << zoneI << " name:" << cz.name()
-                << " size:" << cz.size()
-                << endl;
-        }
-    }
-}
-
-
-void Foam::fvMeshDistribute::printCoupleInfo
-(
-    const primitiveMesh& mesh,
-    const labelList& sourceFace,
-    const labelList& sourceProc,
-    const labelList& sourceNewProc
-)
-{
-    Pout<< nl
-        << "Current coupling info:"
-        << endl;
-
-    forAll(sourceFace, bFaceI)
-    {
-        label meshFaceI = mesh.nInternalFaces() + bFaceI;
-
-        Pout<< "    meshFace:" << meshFaceI
-            << " fc:" << mesh.faceCentres()[meshFaceI]
-            << " connects to proc:" << sourceProc[bFaceI]
-            << "/face:" << sourceFace[bFaceI]
-            << " which will move to proc:" << sourceNewProc[bFaceI]
-            << endl;
-    }
-}
-
-
-// Finds (non-empty) patch that exposed internal and proc faces can be put into.
-Foam::label Foam::fvMeshDistribute::findNonEmptyPatch() const
-{
-    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
-
-    label nonEmptyPatchI = -1;
-
-    forAllReverse(patches, patchI)
-    {
-        const polyPatch& pp = patches[patchI];
-
-        if (!isA<emptyPolyPatch>(pp) && !pp.coupled())
-        {
-            nonEmptyPatchI = patchI;
-            break;
-        }
-    }
-
-    if (nonEmptyPatchI == -1)
-    {
-        FatalErrorIn("fvMeshDistribute::findNonEmptyPatch() const")
-            << "Cannot find a patch which is neither of type empty nor"
-            << " coupled in patches " << patches.names() << endl
-            << "There has to be at least one such patch for"
-            << " distribution to work" << abort(FatalError);
-    }
-
-    if (debug)
-    {
-        Pout<< "findNonEmptyPatch : using patch " << nonEmptyPatchI
-            << " name:" << patches[nonEmptyPatchI].name()
-            << " type:" << patches[nonEmptyPatchI].type()
-            << " to put exposed faces into." << endl;
-    }
-
-
-    // Do additional test for processor patches intermingled with non-proc
-    // patches.
-    label procPatchI = -1;
-
-    forAll(patches, patchI)
-    {
-        if (isA<processorPolyPatch>(patches[patchI]))
-        {
-            procPatchI = patchI;
-        }
-        else if (procPatchI != -1)
-        {
-            FatalErrorIn("fvMeshDistribute::findNonEmptyPatch() const")
-                << "Processor patches should be at end of patch list."
-                << endl
-                << "Have processor patch " << procPatchI
-                << " followed by non-processor patch " << patchI
-                << " in patches " << patches.names()
-                << abort(FatalError);
-        }
-    }
-
-    return nonEmptyPatchI;
-}
-
-
-// Appends processorPolyPatch. Returns patchID.
-Foam::label Foam::fvMeshDistribute::addProcPatch
-(
-    const word& patchName,
-    const label nbrProc
-)
-{
-    // Clear local fields and e.g. polyMesh globalMeshData.
-    mesh_.clearOut();
-
-
-    polyBoundaryMesh& polyPatches =
-        const_cast<polyBoundaryMesh&>(mesh_.boundaryMesh());
-    fvBoundaryMesh& fvPatches = const_cast<fvBoundaryMesh&>(mesh_.boundary());
-
-    if (polyPatches.findPatchID(patchName) != -1)
-    {
-        FatalErrorIn("fvMeshDistribute::addProcPatch(const word&, const label)")
-            << "Cannot create patch " << patchName << " since already exists."
-            << nl
-            << "Current patch names:" << polyPatches.names()
-            << exit(FatalError);
-    }
-
-
-
-    // Add the patch
-    // ~~~~~~~~~~~~~
-
-    label sz = polyPatches.size();
-
-    // Add polyPatch
-    polyPatches.setSize(sz+1);
-    polyPatches.set
-    (
-        sz,
-        new processorPolyPatch
-        (
-            patchName,
-            0,              // size
-            mesh_.nFaces(),
-            sz,
-            mesh_.boundaryMesh(),
-            Pstream::myProcNo(),
-            nbrProc
-        )
-    );
-    fvPatches.setSize(sz+1);
-    fvPatches.set
-    (
-        sz,
-        fvPatch::New
-        (
-            polyPatches[sz],  // point to newly added polyPatch
-            mesh_.boundary()
-        )
-    );
-
-    return sz;
-}
-
-
-// Deletes last patch
-void Foam::fvMeshDistribute::deleteTrailingPatch()
-{
-    // Clear local fields and e.g. polyMesh globalMeshData.
-    mesh_.clearOut();
-
-    polyBoundaryMesh& polyPatches =
-        const_cast<polyBoundaryMesh&>(mesh_.boundaryMesh());
-    fvBoundaryMesh& fvPatches = const_cast<fvBoundaryMesh&>(mesh_.boundary());
-
-    if (polyPatches.empty())
-    {
-        FatalErrorIn("fvMeshDistribute::deleteTrailingPatch(fvMesh&)")
-            << "No patches in mesh"
-            << abort(FatalError);
-    }
-
-    label sz = polyPatches.size();
-
-    label nFaces = polyPatches[sz-1].size();
-
-    // Remove last polyPatch
-    if (debug)
-    {
-        Pout<< "deleteTrailingPatch : Removing patch " << sz-1
-            << " : " << polyPatches[sz-1].name() << " size:" << nFaces << endl;
-    }
-
-    if (nFaces)
-    {
-        FatalErrorIn("fvMeshDistribute::deleteTrailingPatch()")
-            << "There are still " << nFaces << " faces in patch to be deleted "
-            << sz-1 << ' ' << polyPatches[sz-1].name()
-            << abort(FatalError);
-    }
-
-    // Remove actual patch
-    polyPatches.setSize(sz-1);
-    fvPatches.setSize(sz-1);
-}
-
-
-// Delete all processor patches. Move any processor faces into the last
-// non-processor patch.
-Foam::autoPtr<Foam::mapPolyMesh> Foam::fvMeshDistribute::deleteProcPatches
-(
-    const label destinationPatch
-)
-{
-    // New patchID per boundary faces to be repatched. Is -1 (no change)
-    // or new patchID
-    labelList newPatchID(mesh_.nFaces() - mesh_.nInternalFaces(), -1);
-
-    label nProcPatches = 0;
-
-    forAll(mesh_.boundaryMesh(), patchI)
-    {
-        const polyPatch& pp = mesh_.boundaryMesh()[patchI];
-
-        if (isA<processorPolyPatch>(pp))
-        {
-            if (debug)
-            {
-                Pout<< "Moving all faces of patch " << pp.name()
-                    << " into patch " << destinationPatch
-                    << endl;
-            }
-
-            label offset = pp.start() - mesh_.nInternalFaces();
-
-            forAll(pp, i)
-            {
-                newPatchID[offset+i] = destinationPatch;
-            }
-
-            nProcPatches++;
-        }
-    }
-
-    // Note: order of boundary faces been kept the same since the
-    // destinationPatch is at the end and we have visited the patches in
-    // incremental order.
-    labelListList dummyFaceMaps;
-    autoPtr<mapPolyMesh> map = repatch(newPatchID, dummyFaceMaps);
-
-
-    // Delete (now empty) processor patches.
-    forAllReverse(mesh_.boundaryMesh(), patchI)
-    {
-        const polyPatch& pp = mesh_.boundaryMesh()[patchI];
-
-        if (isA<processorPolyPatch>(pp))
-        {
-            deleteTrailingPatch();
-            deleteTrailingPatchFields<volScalarField>();
-            deleteTrailingPatchFields<volVectorField>();
-            deleteTrailingPatchFields<volSphericalTensorField>();
-            deleteTrailingPatchFields<volSymmTensorField>();
-            deleteTrailingPatchFields<volTensorField>();
-
-            deleteTrailingPatchFields<surfaceScalarField>();
-            deleteTrailingPatchFields<surfaceVectorField>();
-            deleteTrailingPatchFields<surfaceSphericalTensorField>();
-            deleteTrailingPatchFields<surfaceSymmTensorField>();
-            deleteTrailingPatchFields<surfaceTensorField>();
-        }
-    }
-
-    return map;
-}
-
-
-// Repatch the mesh.
-Foam::autoPtr<Foam::mapPolyMesh> Foam::fvMeshDistribute::repatch
-(
-    const labelList& newPatchID,         // per boundary face -1 or new patchID
-    labelListList& constructFaceMap
-)
-{
-    directTopoChange meshMod(mesh_);
-
-    forAll(newPatchID, bFaceI)
-    {
-        if (newPatchID[bFaceI] != -1)
-        {
-            label faceI = mesh_.nInternalFaces() + bFaceI;
-
-            label zoneID = mesh_.faceZones().whichZone(faceI);
-            bool zoneFlip = false;
-
-            if (zoneID >= 0)
-            {
-                const faceZone& fZone = mesh_.faceZones()[zoneID];
-                zoneFlip = fZone.flipMap()[fZone.whichFace(faceI)];
-            }
-
-            meshMod.setAction
-            (
-                polyModifyFace
-                (
-                    mesh_.faces()[faceI],       // modified face
-                    faceI,                      // label of face
-                    mesh_.faceOwner()[faceI],   // owner
-                    -1,                         // neighbour
-                    false,                      // face flip
-                    newPatchID[bFaceI],         // patch for face
-                    false,                      // remove from zone
-                    zoneID,                     // zone for face
-                    zoneFlip                    // face flip in zone
-                )
-            );
-        }
-    }
-
-
-    // Do mapping of fields from one patchField to the other ourselves since
-    // is currently not supported by updateMesh.
-
-    // Store boundary fields (we only do this for surfaceFields)
-    PtrList<FieldField<fvsPatchField, scalar> > sFlds;
-    saveBoundaryFields<scalar, surfaceMesh>(sFlds);
-    PtrList<FieldField<fvsPatchField, vector> > vFlds;
-    saveBoundaryFields<vector, surfaceMesh>(vFlds);
-    PtrList<FieldField<fvsPatchField, sphericalTensor> > sptFlds;
-    saveBoundaryFields<sphericalTensor, surfaceMesh>(sptFlds);
-    PtrList<FieldField<fvsPatchField, symmTensor> > sytFlds;
-    saveBoundaryFields<symmTensor, surfaceMesh>(sytFlds);
-    PtrList<FieldField<fvsPatchField, tensor> > tFlds;
-    saveBoundaryFields<tensor, surfaceMesh>(tFlds);
-
-    // Change the mesh (no inflation). Note: parallel comms allowed.
-    autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh_, false, true);
-
-    // Update fields. No inflation, parallel sync.
-    mesh_.updateMesh(map);
-
-    // Map patch fields using stored boundary fields. Note: assumes order
-    // of fields has not changed in object registry!
-    mapBoundaryFields<scalar, surfaceMesh>(map, sFlds);
-    mapBoundaryFields<vector, surfaceMesh>(map, vFlds);
-    mapBoundaryFields<sphericalTensor, surfaceMesh>(map, sptFlds);
-    mapBoundaryFields<symmTensor, surfaceMesh>(map, sytFlds);
-    mapBoundaryFields<tensor, surfaceMesh>(map, tFlds);
-
-
-    // Move mesh (since morphing does not do this)
-    if (map().hasMotionPoints())
-    {
-        mesh_.movePoints(map().preMotionPoints());
-    }
-
-    // Adapt constructMaps.
-
-    if (debug)
-    {
-        label index = findIndex(map().reverseFaceMap(), -1);
-
-        if (index != -1)
-        {
-            FatalErrorIn
-            (
-                "fvMeshDistribute::repatch(const labelList&, labelListList&)"
-            )   << "reverseFaceMap contains -1 at index:"
-                << index << endl
-                << "This means that the repatch operation was not just"
-                << " a shuffle?" << abort(FatalError);
-        }
-    }
-
-    forAll(constructFaceMap, procI)
-    {
-        inplaceRenumber(map().reverseFaceMap(), constructFaceMap[procI]);
-    }
-
-
-    return map;
-}
-
-
-// Detect shared points. Need processor patches to be present.
-// Background: when adding bits of mesh one can get points which
-// share the same position but are only detectable to be topologically
-// the same point when doing parallel analysis. This routine will
-// merge those points.
-Foam::autoPtr<Foam::mapPolyMesh> Foam::fvMeshDistribute::mergeSharedPoints
-(
-    labelListList& constructPointMap
-)
-{
-    // Find out which sets of points get merged and create a map from
-    // mesh point to unique point.
-    Map<label> pointToMaster
-    (
-        fvMeshAdder::findSharedPoints
-        (
-            mesh_,
-            mergeTol_
-        )
-    );
-
-    if (returnReduce(pointToMaster.size(), sumOp<label>()) == 0)
-    {
-        return autoPtr<mapPolyMesh>(NULL);
-    }
-
-    directTopoChange meshMod(mesh_);
-
-    fvMeshAdder::mergePoints(mesh_, pointToMaster, meshMod);
-
-    // Change the mesh (no inflation). Note: parallel comms allowed.
-    autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh_, false, true);
-
-    // Update fields. No inflation, parallel sync.
-    mesh_.updateMesh(map);
-
-    // Adapt constructMaps for merged points.
-    forAll(constructPointMap, procI)
-    {
-        labelList& constructMap = constructPointMap[procI];
-
-        forAll(constructMap, i)
-        {
-            label oldPointI = constructMap[i];
-
-            label newPointI = map().reversePointMap()[oldPointI];
-
-            if (newPointI < -1)
-            {
-                constructMap[i] = -newPointI-2;
-            }
-            else if (newPointI >= 0)
-            {
-                constructMap[i] = newPointI;
-            }
-            else
-            {
-                FatalErrorIn("fvMeshDistribute::mergeSharedPoints()")
-                    << "Problem. oldPointI:" << oldPointI
-                    << " newPointI:" << newPointI << abort(FatalError);
-            }
-        }
-    }
-    return map;
-}
-
-
-// Construct the local environment of all boundary faces.
-void Foam::fvMeshDistribute::getNeighbourData
-(
-    const labelList& distribution,
-    labelList& sourceFace,
-    labelList& sourceProc,
-    labelList& sourceNewProc
-) const
-{
-    label nBnd = mesh_.nFaces() - mesh_.nInternalFaces();
-    sourceFace.setSize(nBnd);
-    sourceProc.setSize(nBnd);
-    sourceNewProc.setSize(nBnd);
-
-    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
-
-    // Get neighbouring meshFace labels and new processor of coupled boundaries.
-    labelList nbrFaces(nBnd, -1);
-    labelList nbrNewProc(nBnd, -1);
-
-    forAll(patches, patchI)
-    {
-        const polyPatch& pp = patches[patchI];
-
-        if (isA<processorPolyPatch>(pp))
-        {
-            label offset = pp.start() - mesh_.nInternalFaces();
-
-            // Mesh labels of faces on this side
-            forAll(pp, i)
-            {
-                label bndI = offset + i;
-                nbrFaces[bndI] = pp.start()+i;
-            }
-
-            // Which processor they will end up on
-            SubList<label>(nbrNewProc, pp.size(), offset).assign
-            (
-                UIndirectList<label>(distribution, pp.faceCells())()
-            );
-        }
-    }
-
-
-    // Exchange the boundary data
-    syncTools::swapBoundaryFaceList(mesh_, nbrFaces, false);
-    syncTools::swapBoundaryFaceList(mesh_, nbrNewProc, false);
-
-
-    forAll(patches, patchI)
-    {
-        const polyPatch& pp = patches[patchI];
-        label offset = pp.start() - mesh_.nInternalFaces();
-
-        if (isA<processorPolyPatch>(pp))
-        {
-            const processorPolyPatch& procPatch =
-                refCast<const processorPolyPatch>(pp);
-
-            // Check which of the two faces we store.
-
-            if (Pstream::myProcNo() < procPatch.neighbProcNo())
-            {
-                // Use my local face labels
-                forAll(pp, i)
-                {
-                    label bndI = offset + i;
-                    sourceFace[bndI] = pp.start()+i;
-                    sourceProc[bndI] = Pstream::myProcNo();
-                    sourceNewProc[bndI] = nbrNewProc[bndI];
-                }
-            }
-            else
-            {
-                // Use my neighbours face labels
-                forAll(pp, i)
-                {
-                    label bndI = offset + i;
-                    sourceFace[bndI] = nbrFaces[bndI];
-                    sourceProc[bndI] = procPatch.neighbProcNo();
-                    sourceNewProc[bndI] = nbrNewProc[bndI];
-                }
-            }
-        }
-        else
-        {
-            // Normal (physical) boundary
-            forAll(pp, i)
-            {
-                label bndI = offset + i;
-                sourceFace[bndI] = patchI;
-                sourceProc[bndI] = -1;
-                sourceNewProc[bndI] = -1;
-            }
-        }
-    }
-}
-
-
-// Subset the neighbourCell/neighbourProc fields
-void Foam::fvMeshDistribute::subsetBoundaryData
-(
-    const fvMesh& mesh,
-    const labelList& faceMap,
-    const labelList& cellMap,
-
-    const labelList& oldDistribution,
-    const labelList& oldFaceOwner,
-    const labelList& oldFaceNeighbour,
-    const label oldInternalFaces,
-
-    const labelList& sourceFace,
-    const labelList& sourceProc,
-    const labelList& sourceNewProc,
-
-    labelList& subFace,
-    labelList& subProc,
-    labelList& subNewProc
-)
-{
-    subFace.setSize(mesh.nFaces() - mesh.nInternalFaces());
-    subProc.setSize(mesh.nFaces() - mesh.nInternalFaces());
-    subNewProc.setSize(mesh.nFaces() - mesh.nInternalFaces());
-
-    forAll(subFace, newBFaceI)
-    {
-        label newFaceI = newBFaceI + mesh.nInternalFaces();
-
-        label oldFaceI = faceMap[newFaceI];
-
-        // Was oldFaceI internal face? If so which side did we get.
-        if (oldFaceI < oldInternalFaces)
-        {
-            subFace[newBFaceI] = oldFaceI;
-            subProc[newBFaceI] = Pstream::myProcNo();
-
-            label oldOwn = oldFaceOwner[oldFaceI];
-            label oldNei = oldFaceNeighbour[oldFaceI];
-
-            if (oldOwn == cellMap[mesh.faceOwner()[newFaceI]])
-            {
-                // We kept the owner side. Where does the neighbour move to?
-                subNewProc[newBFaceI] = oldDistribution[oldNei];
-            }
-            else
-            {
-                // We kept the neighbour side.
-                subNewProc[newBFaceI] = oldDistribution[oldOwn];
-            }
-        }
-        else
-        {
-            // Was boundary face. Take over boundary information
-            label oldBFaceI = oldFaceI - oldInternalFaces;
-
-            subFace[newBFaceI] = sourceFace[oldBFaceI];
-            subProc[newBFaceI] = sourceProc[oldBFaceI];
-            subNewProc[newBFaceI] = sourceNewProc[oldBFaceI];
-        }
-    }
-}
-
-
-// Find cells on mesh whose faceID/procID match the neighbour cell/proc of
-// domainMesh. Store the matching face.
-void Foam::fvMeshDistribute::findCouples
-(
-    const primitiveMesh& mesh,
-    const labelList& sourceFace,
-    const labelList& sourceProc,
-
-    const label domain,
-    const primitiveMesh& domainMesh,
-    const labelList& domainFace,
-    const labelList& domainProc,
-
-    labelList& masterCoupledFaces,
-    labelList& slaveCoupledFaces
-)
-{
-    // Store domain neighbour as map so we can easily look for pair
-    // with same face+proc.
-    HashTable<label, labelPair, labelPair::Hash<> > map(domainFace.size());
-
-    forAll(domainFace, bFaceI)
-    {
-        map.insert(labelPair(domainFace[bFaceI], domainProc[bFaceI]), bFaceI);
-    }
-
-
-    // Try to match mesh data.
-
-    masterCoupledFaces.setSize(domainFace.size());
-    slaveCoupledFaces.setSize(domainFace.size());
-    label coupledI = 0;
-
-    forAll(sourceFace, bFaceI)
-    {
-        if (sourceProc[bFaceI] != -1)
-        {
-            labelPair myData(sourceFace[bFaceI], sourceProc[bFaceI]);
-
-            HashTable<label, labelPair, labelPair::Hash<> >::const_iterator
-                iter = map.find(myData);
-
-            if (iter != map.end())
-            {
-                label nbrBFaceI = iter();
-
-                masterCoupledFaces[coupledI] = mesh.nInternalFaces() + bFaceI;
-                slaveCoupledFaces[coupledI] =
-                    domainMesh.nInternalFaces()
-                  + nbrBFaceI;
-
-                coupledI++;
-            }
-        }
-    }
-
-    masterCoupledFaces.setSize(coupledI);
-    slaveCoupledFaces.setSize(coupledI);
-
-    if (debug)
-    {
-        Pout<< "findCouples : found " << coupledI
-            << " faces that will be stitched" << nl << endl;
-    }
-}
-
-
-// Map data on boundary faces to new mesh (resulting from adding two meshes)
-Foam::labelList Foam::fvMeshDistribute::mapBoundaryData
-(
-    const primitiveMesh& mesh,      // mesh after adding
-    const mapAddedPolyMesh& map,
-    const labelList& boundaryData0, // mesh before adding
-    const label nInternalFaces1,
-    const labelList& boundaryData1  // added mesh
-)
-{
-    labelList newBoundaryData(mesh.nFaces() - mesh.nInternalFaces());
-
-    forAll(boundaryData0, oldBFaceI)
-    {
-        label newFaceI = map.oldFaceMap()[oldBFaceI + map.nOldInternalFaces()];
-
-        // Face still exists (is necessary?) and still boundary face
-        if (newFaceI >= 0 && newFaceI >= mesh.nInternalFaces())
-        {
-            newBoundaryData[newFaceI - mesh.nInternalFaces()] =
-                boundaryData0[oldBFaceI];
-        }
-    }
-
-    forAll(boundaryData1, addedBFaceI)
-    {
-        label newFaceI = map.addedFaceMap()[addedBFaceI + nInternalFaces1];
-
-        if (newFaceI >= 0 && newFaceI >= mesh.nInternalFaces())
-        {
-            newBoundaryData[newFaceI - mesh.nInternalFaces()] =
-                boundaryData1[addedBFaceI];
-        }
-    }
-
-    return newBoundaryData;
-}
-
-
-// Remove cells. Add all exposed faces to patch oldInternalPatchI
-Foam::autoPtr<Foam::mapPolyMesh> Foam::fvMeshDistribute::doRemoveCells
-(
-    const labelList& cellsToRemove,
-    const label oldInternalPatchI
-)
-{
-    // Mesh change engine
-    directTopoChange meshMod(mesh_);
-
-    // Cell removal topo engine. Do NOT synchronize parallel since
-    // we are doing a local cell removal.
-    removeCells cellRemover(mesh_, false);
-
-    // Get all exposed faces
-    labelList exposedFaces(cellRemover.getExposedFaces(cellsToRemove));
-
-    // Insert the topo changes
-    cellRemover.setRefinement
-    (
-        cellsToRemove,
-        exposedFaces,
-        labelList(exposedFaces.size(), oldInternalPatchI),  // patch for exposed
-                                                            // faces.
-        meshMod
-    );
-
-    // Change the mesh. No inflation. Note: no parallel comms allowed.
-    autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh_, false, false);
-
-    // Update fields
-    mesh_.updateMesh(map);
-
-    // Move mesh (since morphing does not do this)
-    if (map().hasMotionPoints())
-    {
-        mesh_.movePoints(map().preMotionPoints());
-    }
-
-    return map;
-}
-
-
-// Delete and add processor patches. Changes mesh and returns per neighbour proc
-// the processor patchID.
-void Foam::fvMeshDistribute::addProcPatches
-(
-    const labelList& neighbourNewProc,   // processor that neighbour is on
-    labelList& procPatchID
-)
-{
-    // Now use the neighbourFace/Proc to repatch the mesh. These two lists
-    // contain for all current boundary faces the global patchID (for non-proc
-    // patch) or the processor.
-
-    labelList procPatchSizes(Pstream::nProcs(), 0);
-
-    forAll(neighbourNewProc, bFaceI)
-    {
-        if (neighbourNewProc[bFaceI] != -1)
-        {
-            procPatchSizes[neighbourNewProc[bFaceI]]++;
-        }
-    }
-
-    // Per neighbour processor the label of the processor patch
-    procPatchID.setSize(Pstream::nProcs());
-
-    forAll(procPatchSizes, procI)
-    {
-        if (procPatchSizes[procI] > 0)
-        {
-            const word patchName =
-                "procBoundary"
-              + name(Pstream::myProcNo())
-              + "to"
-              + name(procI);
-
-
-            procPatchID[procI] = addProcPatch(patchName, procI);
-            addPatchFields<volScalarField>
-            (
-                processorFvPatchField<scalar>::typeName
-            );
-            addPatchFields<volVectorField>
-            (
-                processorFvPatchField<vector>::typeName
-            );
-            addPatchFields<volSphericalTensorField>
-            (
-                processorFvPatchField<sphericalTensor>::typeName
-            );
-            addPatchFields<volSymmTensorField>
-            (
-                processorFvPatchField<symmTensor>::typeName
-            );
-            addPatchFields<volTensorField>
-            (
-                processorFvPatchField<tensor>::typeName
-            );
-
-            addPatchFields<surfaceScalarField>
-            (
-                processorFvPatchField<scalar>::typeName
-            );
-            addPatchFields<surfaceVectorField>
-            (
-                processorFvPatchField<vector>::typeName
-            );
-            addPatchFields<surfaceSphericalTensorField>
-            (
-                processorFvPatchField<sphericalTensor>::typeName
-            );
-            addPatchFields<surfaceSymmTensorField>
-            (
-                processorFvPatchField<symmTensor>::typeName
-            );
-            addPatchFields<surfaceTensorField>
-            (
-                processorFvPatchField<tensor>::typeName
-            );
-        }
-        else
-        {
-            procPatchID[procI] = -1;
-        }
-    }
-}
-
-
-// Get boundary faces to be repatched. Is -1 or new patchID
-Foam::labelList Foam::fvMeshDistribute::getProcBoundaryPatch
-(
-    const labelList& neighbourNewProc,  // new processor per boundary face
-    const labelList& procPatchID        // patchID
-)
-{
-    labelList patchIDs(neighbourNewProc);
-
-    forAll(neighbourNewProc, bFaceI)
-    {
-        if (neighbourNewProc[bFaceI] != -1)
-        {
-            label nbrProc = neighbourNewProc[bFaceI];
-
-            patchIDs[bFaceI] = procPatchID[nbrProc];
-        }
-        else
-        {
-            patchIDs[bFaceI] = -1;
-        }
-    }
-    return patchIDs;
-}
-
-
-// Send mesh and coupling data.
-void Foam::fvMeshDistribute::sendMesh
-(
-    const label domain,
-    const fvMesh& mesh,
-
-    const wordList& pointZoneNames,
-    const wordList& faceZoneNames,
-    const wordList& cellZoneNames,
-
-    const labelList& sourceFace,
-    const labelList& sourceProc,
-    const labelList& sourceNewProc,
-    OSstream& toDomain
-)
-{
-    if (debug)
-    {
-        Pout<< "Sending to domain " << domain << nl
-            << "    nPoints:" << mesh.nPoints() << nl
-            << "    nFaces:" << mesh.nFaces() << nl
-            << "    nCells:" << mesh.nCells() << nl
-            << "    nPatches:" << mesh.boundaryMesh().size() << nl
-            << endl;
-    }
-
-    // Assume sparse, possibly overlapping point zones. Get contents
-    // in merged-zone indices.
-    CompactListList_dev<label> zonePoints;
-    {
-        const pointZoneMesh& pointZones = mesh.pointZones();
-
-        labelList rowSizes(pointZoneNames.size(), 0);
-
-        forAll(pointZoneNames, nameI)
-        {
-            label myZoneID = pointZones.findZoneID(pointZoneNames[nameI]);
-
-            if (myZoneID != -1)
-            {
-                rowSizes[nameI] = pointZones[myZoneID].size();
-            }
-        }
-        zonePoints.setSize(rowSizes);
-
-        forAll(pointZoneNames, nameI)
-        {
-            label myZoneID = pointZones.findZoneID(pointZoneNames[nameI]);
-
-            if (myZoneID != -1)
-            {
-                zonePoints[nameI].assign(pointZones[myZoneID]);
-            }
-        }
-    }
-
-    // Assume sparse, possibly overlapping face zones
-    CompactListList_dev<label> zoneFaces;
-    CompactListList_dev<bool> zoneFaceFlip;
-    {
-        const faceZoneMesh& faceZones = mesh.faceZones();
-
-        labelList rowSizes(faceZoneNames.size(), 0);
-
-        forAll(faceZoneNames, nameI)
-        {
-            label myZoneID = faceZones.findZoneID(faceZoneNames[nameI]);
-
-            if (myZoneID != -1)
-            {
-                rowSizes[nameI] = faceZones[myZoneID].size();
-            }
-        }
-
-        zoneFaces.setSize(rowSizes);
-        zoneFaceFlip.setSize(rowSizes);
-
-        forAll(faceZoneNames, nameI)
-        {
-            label myZoneID = faceZones.findZoneID(faceZoneNames[nameI]);
-
-            if (myZoneID != -1)
-            {
-                zoneFaces[nameI].assign(faceZones[myZoneID]);
-                zoneFaceFlip[nameI].assign(faceZones[myZoneID].flipMap());
-            }
-        }
-    }
-
-    // Assume sparse, possibly overlapping cell zones
-    CompactListList_dev<label> zoneCells;
-    {
-        const cellZoneMesh& cellZones = mesh.cellZones();
-
-        labelList rowSizes(cellZoneNames.size(), 0);
-
-        forAll(cellZoneNames, nameI)
-        {
-            label myZoneID = cellZones.findZoneID(cellZoneNames[nameI]);
-
-            if (myZoneID != -1)
-            {
-                rowSizes[nameI] = cellZones[myZoneID].size();
-            }
-        }
-
-        zoneCells.setSize(rowSizes);
-
-        forAll(cellZoneNames, nameI)
-        {
-            label myZoneID = cellZones.findZoneID(cellZoneNames[nameI]);
-
-            if (myZoneID != -1)
-            {
-                zoneCells[nameI].assign(cellZones[myZoneID]);
-            }
-        }
-    }
-    ////- Assume full cell zones
-    //labelList cellZoneID;
-    //if (hasCellZones)
-    //{
-    //    cellZoneID.setSize(mesh.nCells());
-    //    cellZoneID = -1;
-    //
-    //    const cellZoneMesh& cellZones = mesh.cellZones();
-    //
-    //    forAll(cellZones, zoneI)
-    //    {
-    //        UIndirectList<label>(cellZoneID, cellZones[zoneI]) = zoneI;
-    //    }
-    //}
-
-    // Send
-    toDomain
-        << mesh.points()
-        << CompactListList_dev<label, face>(mesh.faces())
-        << mesh.faceOwner()
-        << mesh.faceNeighbour()
-        << mesh.boundaryMesh()
-
-        << zonePoints
-        << zoneFaces
-        << zoneFaceFlip
-        << zoneCells
-
-        << sourceFace
-        << sourceProc
-        << sourceNewProc;
-
-
-    if (debug)
-    {
-        Pout<< "Started sending mesh to domain " << domain
-            << endl;
-    }
-}
-
-
-// Receive mesh. Opposite of sendMesh
-Foam::autoPtr<Foam::fvMesh> Foam::fvMeshDistribute::receiveMesh
-(
-    const label domain,
-    const wordList& pointZoneNames,
-    const wordList& faceZoneNames,
-    const wordList& cellZoneNames,
-    const Time& runTime,
-    labelList& domainSourceFace,
-    labelList& domainSourceProc,
-    labelList& domainSourceNewProc,
-    ISstream& fromNbr
-)
-{
-    pointField domainPoints(fromNbr);
-    faceList domainFaces = CompactListList_dev<label, face>(fromNbr)();
-    labelList domainAllOwner(fromNbr);
-    labelList domainAllNeighbour(fromNbr);
-    PtrList<entry> patchEntries(fromNbr);
-
-    CompactListList_dev<label> zonePoints(fromNbr);
-    CompactListList_dev<label> zoneFaces(fromNbr);
-    CompactListList_dev<bool> zoneFaceFlip(fromNbr);
-    CompactListList_dev<label> zoneCells(fromNbr);
-
-    fromNbr
-        >> domainSourceFace
-        >> domainSourceProc
-        >> domainSourceNewProc;
-
-    // Construct fvMesh
-    autoPtr<fvMesh> domainMeshPtr
-    (
-        new fvMesh
-        (
-            IOobject
-            (
-                fvMesh::defaultRegion,
-                runTime.timeName(),
-                runTime,
-                IOobject::NO_READ
-            ),
-            xferMove(domainPoints),
-            xferMove(domainFaces),
-            xferMove(domainAllOwner),
-            xferMove(domainAllNeighbour),
-            false                   // no parallel comms
-        )
-    );
-    fvMesh& domainMesh = domainMeshPtr();
-
-    List<polyPatch*> patches(patchEntries.size());
-
-    forAll(patchEntries, patchI)
-    {
-        patches[patchI] = polyPatch::New
-        (
-            patchEntries[patchI].keyword(),
-            patchEntries[patchI].dict(),
-            patchI,
-            domainMesh.boundaryMesh()
-        ).ptr();
-    }
-    // Add patches; no parallel comms
-    domainMesh.addFvPatches(patches, false);
-
-    // Construct zones
-    List<pointZone*> pZonePtrs(pointZoneNames.size());
-    forAll(pZonePtrs, i)
-    {
-        pZonePtrs[i] = new pointZone
-        (
-            pointZoneNames[i],
-            zonePoints[i],
-            i,
-            domainMesh.pointZones()
-        );
-    }
-
-    List<faceZone*> fZonePtrs(faceZoneNames.size());
-    forAll(fZonePtrs, i)
-    {
-        fZonePtrs[i] = new faceZone
-        (
-            faceZoneNames[i],
-            zoneFaces[i],
-            zoneFaceFlip[i],
-            i,
-            domainMesh.faceZones()
-        );
-    }
-
-    List<cellZone*> cZonePtrs(cellZoneNames.size());
-    forAll(cZonePtrs, i)
-    {
-        cZonePtrs[i] = new cellZone
-        (
-            cellZoneNames[i],
-            zoneCells[i],
-            i,
-            domainMesh.cellZones()
-        );
-    }
-    domainMesh.addZones(pZonePtrs, fZonePtrs, cZonePtrs);
-
-    return domainMeshPtr;
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-// Construct from components
-Foam::fvMeshDistribute::fvMeshDistribute(fvMesh& mesh, const scalar mergeTol)
-:
-    mesh_(mesh),
-    mergeTol_(mergeTol)
-{}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-Foam::labelList Foam::fvMeshDistribute::countCells
-(
-    const labelList& distribution
-)
-{
-    labelList nCells(Pstream::nProcs(), 0);
-    forAll(distribution, cellI)
-    {
-        label newProc = distribution[cellI];
-
-        if (newProc < 0 || newProc >= Pstream::nProcs())
-        {
-            FatalErrorIn("fvMeshDistribute::distribute(const labelList&)")
-                << "Distribution should be in range 0.." << Pstream::nProcs()-1
-                << endl
-                << "At index " << cellI << " distribution:" << newProc
-                << abort(FatalError);
-        }
-        nCells[newProc]++;
-    }
-    return nCells;
-}
-
-
-Foam::autoPtr<Foam::mapDistributePolyMesh> Foam::fvMeshDistribute::distribute
-(
-    const labelList& distribution
-)
-{
-    // Some checks on distribution
-    if (distribution.size() != mesh_.nCells())
-    {
-        FatalErrorIn("fvMeshDistribute::distribute(const labelList&)")
-            << "Size of distribution:"
-            << distribution.size() << " mesh nCells:" << mesh_.nCells()
-            << abort(FatalError);
-    }
-
-
-    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
-
-    // Check all processors have same non-proc patches in same order.
-    if (patches.checkParallelSync(true))
-    {
-        FatalErrorIn("fvMeshDistribute::distribute(const labelList&)")
-            << "This application requires all non-processor patches"
-            << " to be present in the same order on all patches" << nl
-            << "followed by the processor patches (which of course are unique)."
-            << nl
-            << "Local patches:" << mesh_.boundaryMesh().names()
-            << abort(FatalError);
-    }
-
-    // Save some data for mapping later on
-    const label nOldPoints(mesh_.nPoints());
-    const label nOldFaces(mesh_.nFaces());
-    const label nOldCells(mesh_.nCells());
-    labelList oldPatchStarts(patches.size());
-    labelList oldPatchNMeshPoints(patches.size());
-    forAll(patches, patchI)
-    {
-        oldPatchStarts[patchI] = patches[patchI].start();
-        oldPatchNMeshPoints[patchI] = patches[patchI].nPoints();
-    }
-
-
-
-    // Short circuit trivial case.
-    if (!Pstream::parRun())
-    {
-        // Collect all maps and return
-        return autoPtr<mapDistributePolyMesh>
-        (
-            new mapDistributePolyMesh
-            (
-                mesh_,
-
-                nOldPoints,
-                nOldFaces,
-                nOldCells,
-                oldPatchStarts.xfer(),
-                oldPatchNMeshPoints.xfer(),
-
-                labelListList(1, identity(mesh_.nPoints())).xfer(),//subPointMap
-                labelListList(1, identity(mesh_.nFaces())).xfer(), //subFaceMap
-                labelListList(1, identity(mesh_.nCells())).xfer(), //subCellMap
-                labelListList(1, identity(patches.size())).xfer(), //subPatchMap
-
-                labelListList(1, identity(mesh_.nPoints())).xfer(),//pointMap
-                labelListList(1, identity(mesh_.nFaces())).xfer(), //faceMap
-                labelListList(1, identity(mesh_.nCells())).xfer(), //cellMap
-                labelListList(1, identity(patches.size())).xfer()  //patchMap
-            )
-        );
-    }
-
-
-    // Collect any zone names
-    const wordList pointZoneNames(mergeWordList(mesh_.pointZones().names()));
-    const wordList faceZoneNames(mergeWordList(mesh_.faceZones().names()));
-    const wordList cellZoneNames(mergeWordList(mesh_.cellZones().names()));
-
-
-
-    // Local environment of all boundary faces
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    // A face is uniquely defined by
-    //  - proc
-    //  - local face no
-    //
-    // To glue the parts of meshes which can get sent from anywhere we
-    // need to know on boundary faces what the above tuple on both sides is.
-    // So we need to maintain:
-    //  - original face
-    //  - original processor id (= trivial)
-    // For coupled boundaries (where the faces are 'duplicate') we take the
-    // lowest numbered processor as the data to store.
-    //
-    // Additionally to create the procboundaries we need to know where the owner
-    // cell on the other side now is: newNeighbourProc.
-    //
-
-    // physical boundary:
-    //     sourceProc = -1
-    //     sourceNewProc = -1
-    //     sourceFace = patchID
-    // coupled boundary:
-    //     sourceProc = proc
-    //     sourceNewProc = distribution[cell on proc]
-    //     sourceFace = face
-    labelList sourceFace;
-    labelList sourceProc;
-    labelList sourceNewProc;
-    getNeighbourData(distribution, sourceFace, sourceProc, sourceNewProc);
-
-
-    // Remove meshPhi. Since this would otherwise dissappear anyway
-    // during topo changes and we have to guarantee that all the fields
-    // can be sent.
-    mesh_.clearOut();
-    mesh_.resetMotion();
-
-    // Get data to send. Make sure is synchronised
-    const wordList volScalars(mesh_.names(volScalarField::typeName));
-    checkEqualWordList("volScalarFields", volScalars);
-    const wordList volVectors(mesh_.names(volVectorField::typeName));
-    checkEqualWordList("volVectorFields", volVectors);
-    const wordList volSphereTensors
-    (
-        mesh_.names(volSphericalTensorField::typeName)
-    );
-    checkEqualWordList("volSphericalTensorFields", volSphereTensors);
-    const wordList volSymmTensors(mesh_.names(volSymmTensorField::typeName));
-    checkEqualWordList("volSymmTensorFields", volSymmTensors);
-    const wordList volTensors(mesh_.names(volTensorField::typeName));
-    checkEqualWordList("volTensorField", volTensors);
-
-    const wordList surfScalars(mesh_.names(surfaceScalarField::typeName));
-    checkEqualWordList("surfaceScalarFields", surfScalars);
-    const wordList surfVectors(mesh_.names(surfaceVectorField::typeName));
-    checkEqualWordList("surfaceVectorFields", surfVectors);
-    const wordList surfSphereTensors
-    (
-        mesh_.names(surfaceSphericalTensorField::typeName)
-    );
-    checkEqualWordList("surfaceSphericalTensorFields", surfSphereTensors);
-    const wordList surfSymmTensors
-    (
-        mesh_.names(surfaceSymmTensorField::typeName)
-    );
-    checkEqualWordList("surfaceSymmTensorFields", surfSymmTensors);
-    const wordList surfTensors(mesh_.names(surfaceTensorField::typeName));
-    checkEqualWordList("surfaceTensorFields", surfTensors);
-
-
-
-
-    // Find patch to temporarily put exposed and processor faces into.
-    label oldInternalPatchI = findNonEmptyPatch();
-
-
-
-    // Delete processor patches, starting from the back. Move all faces into
-    // oldInternalPatchI.
-    labelList repatchFaceMap;
-    {
-        autoPtr<mapPolyMesh> repatchMap = deleteProcPatches(oldInternalPatchI);
-
-        // Store face map (only face ordering that changed)
-        repatchFaceMap = repatchMap().faceMap();
-
-        // Reorder all boundary face data (sourceProc, sourceFace etc.)
-        labelList bFaceMap
-        (
-            SubList<label>
-            (
-                repatchMap().reverseFaceMap(),
-                mesh_.nFaces() - mesh_.nInternalFaces(),
-                mesh_.nInternalFaces()
-            )
-          - mesh_.nInternalFaces()
-        );
-
-        inplaceReorder(bFaceMap, sourceFace);
-        inplaceReorder(bFaceMap, sourceProc);
-        inplaceReorder(bFaceMap, sourceNewProc);
-    }
-
-
-
-    // Print a bit.
-    if (debug)
-    {
-        Pout<< nl << "MESH WITH PROC PATCHES DELETED:" << endl;
-        printMeshInfo(mesh_);
-        printFieldInfo<volScalarField>(mesh_);
-        printFieldInfo<volVectorField>(mesh_);
-        printFieldInfo<volSphericalTensorField>(mesh_);
-        printFieldInfo<volSymmTensorField>(mesh_);
-        printFieldInfo<volTensorField>(mesh_);
-        printFieldInfo<surfaceScalarField>(mesh_);
-        printFieldInfo<surfaceVectorField>(mesh_);
-        printFieldInfo<surfaceSphericalTensorField>(mesh_);
-        printFieldInfo<surfaceSymmTensorField>(mesh_);
-        printFieldInfo<surfaceTensorField>(mesh_);
-        Pout<< nl << endl;
-    }
-
-
-
-    // Maps from subsetted mesh (that is sent) back to original maps
-    labelListList subCellMap(Pstream::nProcs());
-    labelListList subFaceMap(Pstream::nProcs());
-    labelListList subPointMap(Pstream::nProcs());
-    labelListList subPatchMap(Pstream::nProcs());
-    // Maps from subsetted mesh to reconstructed mesh
-    labelListList constructCellMap(Pstream::nProcs());
-    labelListList constructFaceMap(Pstream::nProcs());
-    labelListList constructPointMap(Pstream::nProcs());
-    labelListList constructPatchMap(Pstream::nProcs());
-
-
-
-
-    // Find out schedule
-    // ~~~~~~~~~~~~~~~~~
-
-    labelListList nSendCells(Pstream::nProcs());
-    nSendCells[Pstream::myProcNo()] = countCells(distribution);
-    Pstream::gatherList(nSendCells);
-    Pstream::scatterList(nSendCells);
-
-
-    // Allocate buffers
-    PtrList<OStringStream> sendStr(Pstream::nProcs());
-    forAll(sendStr, i)
-    {
-        sendStr.set(i, new OStringStream(IOstream::BINARY));
-    }
-    //PstreamBuffers pBufs(Pstream::nonBlocking);
-
-
-    // What to send to neighbouring domains
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    forAll(nSendCells[Pstream::myProcNo()], recvProc)
-    {
-        if
-        (
-            recvProc != Pstream::myProcNo()
-         && nSendCells[Pstream::myProcNo()][recvProc] > 0
-        )
-        {
-            // Send to recvProc
-
-            if (debug)
-            {
-                Pout<< nl
-                    << "SUBSETTING FOR DOMAIN " << recvProc
-                    << " cells to send:"
-                    << nSendCells[Pstream::myProcNo()][recvProc]
-                    << nl << endl;
-            }
-
-            // Pstream for sending mesh and fields
-            //OPstream str(Pstream::blocking, recvProc);
-            //UOPstream str(recvProc, pBufs);
-
-            // Mesh subsetting engine
-            fvMeshSubset subsetter
-            (
-                IOobject
-                (
-                    "set",
-                    mesh_.time().timeName(),
-                    mesh_,
-                    IOobject::NO_READ,
-                    IOobject::NO_WRITE
-                ),
-                mesh_
-            );
-
-            // Subset the cells of the current domain.
-            subsetter.setLargeCellSubset
-            (
-                distribution,
-                recvProc,
-                oldInternalPatchI,  // oldInternalFaces patch
-                false               // no parallel sync
-            );
-
-            subCellMap[recvProc] = subsetter.cellMap();
-            subFaceMap[recvProc] = renumber
-            (
-                repatchFaceMap,
-                subsetter.faceMap()
-            );
-            subPointMap[recvProc] = subsetter.pointMap();
-            subPatchMap[recvProc] = subsetter.patchMap();
-
-
-            // Subset the boundary fields (owner/neighbour/processor)
-            labelList procSourceFace;
-            labelList procSourceProc;
-            labelList procSourceNewProc;
-
-            subsetBoundaryData
-            (
-                subsetter.subMesh(),
-                subsetter.faceMap(),        // from subMesh to mesh
-                subsetter.cellMap(),        //      ,,      ,,
-
-                distribution,               // old mesh distribution
-                mesh_.faceOwner(),          // old owner
-                mesh_.faceNeighbour(),
-                mesh_.nInternalFaces(),
-
-                sourceFace,
-                sourceProc,
-                sourceNewProc,
-
-                procSourceFace,
-                procSourceProc,
-                procSourceNewProc
-            );
-
-
-
-            // Send to neighbour
-            sendMesh
-            (
-                recvProc,
-                subsetter.subMesh(),
-
-                pointZoneNames,
-                faceZoneNames,
-                cellZoneNames,
-
-                procSourceFace,
-                procSourceProc,
-                procSourceNewProc,
-                sendStr[recvProc]
-            );
-            sendFields<volScalarField>
-            (
-                recvProc,
-                volScalars,
-                subsetter,
-                sendStr[recvProc]
-            );
-            sendFields<volVectorField>
-            (
-                recvProc,
-                volVectors,
-                subsetter,
-                sendStr[recvProc]
-            );
-            sendFields<volSphericalTensorField>
-            (
-                recvProc,
-                volSphereTensors,
-                subsetter,
-                sendStr[recvProc]
-            );
-            sendFields<volSymmTensorField>
-            (
-                recvProc,
-                volSymmTensors,
-                subsetter,
-                sendStr[recvProc]
-            );
-            sendFields<volTensorField>
-            (
-                recvProc,
-                volTensors,
-                subsetter,
-                sendStr[recvProc]
-            );
-
-            sendFields<surfaceScalarField>
-            (
-                recvProc,
-                surfScalars,
-                subsetter,
-                sendStr[recvProc]
-            );
-            sendFields<surfaceVectorField>
-            (
-                recvProc,
-                surfVectors,
-                subsetter,
-                sendStr[recvProc]
-            );
-            sendFields<surfaceSphericalTensorField>
-            (
-                recvProc,
-                surfSphereTensors,
-                subsetter,
-                sendStr[recvProc]
-            );
-            sendFields<surfaceSymmTensorField>
-            (
-                recvProc,
-                surfSymmTensors,
-                subsetter,
-                sendStr[recvProc]
-            );
-            sendFields<surfaceTensorField>
-            (
-                recvProc,
-                surfTensors,
-                subsetter,
-                sendStr[recvProc]
-            );
-        }
-    }
-
-
-    // Start sending&receiving from buffers
-    //pBufs.finishedSends();
-
-    // get the data.
-    PtrList<IStringStream> recvStr(Pstream::nProcs());
-    {
-        List<List<char> > sendBufs(sendStr.size());
-        forAll(sendStr, procI)
-        {
-            string contents = sendStr[procI].str();
-            const char* ptr = contents.data();
-
-            sendBufs[procI].setSize(contents.size());
-            forAll(sendBufs[procI], i)
-            {
-                sendBufs[procI][i] = *ptr++;
-            }
-            // Clear OStringStream
-            sendStr.set(procI, NULL);
-        }
-
-        // Transfer sendBufs into recvBufs
-        List<List<char> > recvBufs(Pstream::nProcs());
-        labelListList sizes(Pstream::nProcs());
-        exchange<List<char>, char>(sendBufs, recvBufs, sizes);
-
-        forAll(recvStr, procI)
-        {
-            string contents(recvBufs[procI].begin(), recvBufs[procI].size());
-            recvStr.set
-            (
-                procI,
-                new IStringStream(contents, IOstream::BINARY)
-            );
-        }
-    }
-
-
-    // Subset the part that stays
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    {
-        // Save old mesh maps before changing mesh
-        const labelList oldFaceOwner(mesh_.faceOwner());
-        const labelList oldFaceNeighbour(mesh_.faceNeighbour());
-        const label oldInternalFaces = mesh_.nInternalFaces();
-
-        // Remove cells.
-        autoPtr<mapPolyMesh> subMap
-        (
-            doRemoveCells
-            (
-                select(false, distribution, Pstream::myProcNo()),
-                oldInternalPatchI
-            )
-        );
-
-        // Addressing from subsetted mesh
-        subCellMap[Pstream::myProcNo()] = subMap().cellMap();
-        subFaceMap[Pstream::myProcNo()] = renumber
-        (
-            repatchFaceMap,
-            subMap().faceMap()
-        );
-        subPointMap[Pstream::myProcNo()] = subMap().pointMap();
-        subPatchMap[Pstream::myProcNo()] = identity(patches.size());
-
-        // Initialize all addressing into current mesh
-        constructCellMap[Pstream::myProcNo()] = identity(mesh_.nCells());
-        constructFaceMap[Pstream::myProcNo()] = identity(mesh_.nFaces());
-        constructPointMap[Pstream::myProcNo()] = identity(mesh_.nPoints());
-        constructPatchMap[Pstream::myProcNo()] = identity(patches.size());
-
-        // Subset the mesh data: neighbourCell/neighbourProc
-        // fields
-        labelList domainSourceFace;
-        labelList domainSourceProc;
-        labelList domainSourceNewProc;
-
-        subsetBoundaryData
-        (
-            mesh_,                          // new mesh
-            subMap().faceMap(),             // from new to original mesh
-            subMap().cellMap(),
-
-            distribution,                   // distribution before subsetting
-            oldFaceOwner,                   // owner before subsetting
-            oldFaceNeighbour,               // neighbour        ,,
-            oldInternalFaces,               // nInternalFaces   ,,
-
-            sourceFace,
-            sourceProc,
-            sourceNewProc,
-
-            domainSourceFace,
-            domainSourceProc,
-            domainSourceNewProc
-        );
-
-        sourceFace.transfer(domainSourceFace);
-        sourceProc.transfer(domainSourceProc);
-        sourceNewProc.transfer(domainSourceNewProc);
-    }
-
-
-    // Print a bit.
-    if (debug)
-    {
-        Pout<< nl << "STARTING MESH:" << endl;
-        printMeshInfo(mesh_);
-        printFieldInfo<volScalarField>(mesh_);
-        printFieldInfo<volVectorField>(mesh_);
-        printFieldInfo<volSphericalTensorField>(mesh_);
-        printFieldInfo<volSymmTensorField>(mesh_);
-        printFieldInfo<volTensorField>(mesh_);
-        printFieldInfo<surfaceScalarField>(mesh_);
-        printFieldInfo<surfaceVectorField>(mesh_);
-        printFieldInfo<surfaceSphericalTensorField>(mesh_);
-        printFieldInfo<surfaceSymmTensorField>(mesh_);
-        printFieldInfo<surfaceTensorField>(mesh_);
-        Pout<< nl << endl;
-    }
-
-
-
-    // Receive and add what was sent
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    forAll(nSendCells, sendProc)
-    {
-        // Did processor sendProc send anything to me?
-        if
-        (
-            sendProc != Pstream::myProcNo()
-         && nSendCells[sendProc][Pstream::myProcNo()] > 0
-        )
-        {
-            if (debug)
-            {
-                Pout<< nl
-                    << "RECEIVING FROM DOMAIN " << sendProc
-                    << " cells to receive:"
-                    << nSendCells[sendProc][Pstream::myProcNo()]
-                    << nl << endl;
-            }
-
-
-            // Pstream for receiving mesh and fields
-            //UIPstream str(sendProc, pBufs);
-
-
-            // Receive from sendProc
-            labelList domainSourceFace;
-            labelList domainSourceProc;
-            labelList domainSourceNewProc;
-
-            autoPtr<fvMesh> domainMeshPtr;
-            PtrList<volScalarField> vsf;
-            PtrList<volVectorField> vvf;
-            PtrList<volSphericalTensorField> vsptf;
-            PtrList<volSymmTensorField> vsytf;
-            PtrList<volTensorField> vtf;
-            PtrList<surfaceScalarField> ssf;
-            PtrList<surfaceVectorField> svf;
-            PtrList<surfaceSphericalTensorField> ssptf;
-            PtrList<surfaceSymmTensorField> ssytf;
-            PtrList<surfaceTensorField> stf;
-
-            // Opposite of sendMesh
-            {
-                domainMeshPtr = receiveMesh
-                (
-                    sendProc,
-                    pointZoneNames,
-                    faceZoneNames,
-                    cellZoneNames,
-
-                    const_cast<Time&>(mesh_.time()),
-                    domainSourceFace,
-                    domainSourceProc,
-                    domainSourceNewProc,
-                    recvStr[sendProc]
-                );
-                fvMesh& domainMesh = domainMeshPtr();
-
-                // Receive fields. Read as single dictionary because
-                // of problems reading consecutive fields from single stream.
-                dictionary fieldDicts(recvStr[sendProc]);
-
-                receiveFields<volScalarField>
-                (
-                    sendProc,
-                    volScalars,
-                    domainMesh,
-                    vsf,
-                    fieldDicts.subDict(volScalarField::typeName)
-                );
-                receiveFields<volVectorField>
-                (
-                    sendProc,
-                    volVectors,
-                    domainMesh,
-                    vvf,
-                    fieldDicts.subDict(volVectorField::typeName)
-                );
-                receiveFields<volSphericalTensorField>
-                (
-                    sendProc,
-                    volSphereTensors,
-                    domainMesh,
-                    vsptf,
-                    fieldDicts.subDict(volSphericalTensorField::typeName)
-                );
-                receiveFields<volSymmTensorField>
-                (
-                    sendProc,
-                    volSymmTensors,
-                    domainMesh,
-                    vsytf,
-                    fieldDicts.subDict(volSymmTensorField::typeName)
-                );
-                receiveFields<volTensorField>
-                (
-                    sendProc,
-                    volTensors,
-                    domainMesh,
-                    vtf,
-                    fieldDicts.subDict(volTensorField::typeName)
-                );
-
-                receiveFields<surfaceScalarField>
-                (
-                    sendProc,
-                    surfScalars,
-                    domainMesh,
-                    ssf,
-                    fieldDicts.subDict(surfaceScalarField::typeName)
-                );
-                receiveFields<surfaceVectorField>
-                (
-                    sendProc,
-                    surfVectors,
-                    domainMesh,
-                    svf,
-                    fieldDicts.subDict(surfaceVectorField::typeName)
-                );
-                receiveFields<surfaceSphericalTensorField>
-                (
-                    sendProc,
-                    surfSphereTensors,
-                    domainMesh,
-                    ssptf,
-                    fieldDicts.subDict(surfaceSphericalTensorField::typeName)
-                );
-                receiveFields<surfaceSymmTensorField>
-                (
-                    sendProc,
-                    surfSymmTensors,
-                    domainMesh,
-                    ssytf,
-                    fieldDicts.subDict(surfaceSymmTensorField::typeName)
-                );
-                receiveFields<surfaceTensorField>
-                (
-                    sendProc,
-                    surfTensors,
-                    domainMesh,
-                    stf,
-                    fieldDicts.subDict(surfaceTensorField::typeName)
-                );
-            }
-            const fvMesh& domainMesh = domainMeshPtr();
-
-
-            constructCellMap[sendProc] = identity(domainMesh.nCells());
-            constructFaceMap[sendProc] = identity(domainMesh.nFaces());
-            constructPointMap[sendProc] = identity(domainMesh.nPoints());
-            constructPatchMap[sendProc] =
-                identity(domainMesh.boundaryMesh().size());
-
-
-            // Print a bit.
-            if (debug)
-            {
-                Pout<< nl << "RECEIVED MESH FROM:" << sendProc << endl;
-                printMeshInfo(domainMesh);
-                printFieldInfo<volScalarField>(domainMesh);
-                printFieldInfo<volVectorField>(domainMesh);
-                printFieldInfo<volSphericalTensorField>(domainMesh);
-                printFieldInfo<volSymmTensorField>(domainMesh);
-                printFieldInfo<volTensorField>(domainMesh);
-                printFieldInfo<surfaceScalarField>(domainMesh);
-                printFieldInfo<surfaceVectorField>(domainMesh);
-                printFieldInfo<surfaceSphericalTensorField>(domainMesh);
-                printFieldInfo<surfaceSymmTensorField>(domainMesh);
-                printFieldInfo<surfaceTensorField>(domainMesh);
-            }
-
-
-            // Now this mesh we received (from sendProc) needs to be merged
-            // with the current mesh. On the current mesh we have for all
-            // boundaryfaces the original face and processor. See if we can
-            // match these up to the received domainSourceFace and
-            // domainSourceProc.
-            labelList masterCoupledFaces;
-            labelList slaveCoupledFaces;
-            findCouples
-            (
-                mesh_,
-
-                sourceFace,
-                sourceProc,
-
-                sendProc,
-                domainMesh,
-                domainSourceFace,
-                domainSourceProc,
-
-                masterCoupledFaces,
-                slaveCoupledFaces
-            );
-
-            // Generate additional coupling info (points, edges) from
-            // faces-that-match
-            faceCoupleInfo couples
-            (
-                mesh_,
-                masterCoupledFaces,
-                domainMesh,
-                slaveCoupledFaces,
-                mergeTol_,              // merge tolerance
-                true,                   // faces align
-                true,                   // couples are ordered already
-                false
-            );
-
-
-            // Add domainMesh to mesh
-            // ~~~~~~~~~~~~~~~~~~~~~~
-
-            autoPtr<mapAddedPolyMesh> map = fvMeshAdder::add
-            (
-                mesh_,
-                domainMesh,
-                couples,
-                false           // no parallel comms
-            );
-
-            // Update mesh data: sourceFace,sourceProc for added
-            // mesh.
-
-            sourceFace =
-                mapBoundaryData
-                (
-                    mesh_,
-                    map(),
-                    sourceFace,
-                    domainMesh.nInternalFaces(),
-                    domainSourceFace
-                );
-            sourceProc =
-                mapBoundaryData
-                (
-                    mesh_,
-                    map(),
-                    sourceProc,
-                    domainMesh.nInternalFaces(),
-                    domainSourceProc
-                );
-            sourceNewProc =
-                mapBoundaryData
-                (
-                    mesh_,
-                    map(),
-                    sourceNewProc,
-                    domainMesh.nInternalFaces(),
-                    domainSourceNewProc
-                );
-
-            // Update all addressing so xxProcAddressing points to correct item
-            // in masterMesh.
-            const labelList& oldCellMap = map().oldCellMap();
-            const labelList& oldFaceMap = map().oldFaceMap();
-            const labelList& oldPointMap = map().oldPointMap();
-            const labelList& oldPatchMap = map().oldPatchMap();
-
-            forAll(constructPatchMap, procI)
-            {
-                if (procI != sendProc && constructPatchMap[procI].size())
-                {
-                    // Processor already in mesh (either myProcNo or received)
-                    inplaceRenumber(oldCellMap, constructCellMap[procI]);
-                    inplaceRenumber(oldFaceMap, constructFaceMap[procI]);
-                    inplaceRenumber(oldPointMap, constructPointMap[procI]);
-                    inplaceRenumber(oldPatchMap, constructPatchMap[procI]);
-                }
-            }
-
-            // Added processor
-            inplaceRenumber(map().addedCellMap(), constructCellMap[sendProc]);
-            inplaceRenumber(map().addedFaceMap(), constructFaceMap[sendProc]);
-            inplaceRenumber(map().addedPointMap(), constructPointMap[sendProc]);
-            inplaceRenumber(map().addedPatchMap(), constructPatchMap[sendProc]);
-
-            if (debug)
-            {
-                Pout<< nl << "MERGED MESH FROM:" << sendProc << endl;
-                printMeshInfo(mesh_);
-                printFieldInfo<volScalarField>(mesh_);
-                printFieldInfo<volVectorField>(mesh_);
-                printFieldInfo<volSphericalTensorField>(mesh_);
-                printFieldInfo<volSymmTensorField>(mesh_);
-                printFieldInfo<volTensorField>(mesh_);
-                printFieldInfo<surfaceScalarField>(mesh_);
-                printFieldInfo<surfaceVectorField>(mesh_);
-                printFieldInfo<surfaceSphericalTensorField>(mesh_);
-                printFieldInfo<surfaceSymmTensorField>(mesh_);
-                printFieldInfo<surfaceTensorField>(mesh_);
-                Pout<< nl << endl;
-            }
-        }
-    }
-
-
-    // Print a bit.
-    if (debug)
-    {
-        Pout<< nl << "REDISTRIBUTED MESH:" << endl;
-        printMeshInfo(mesh_);
-        printFieldInfo<volScalarField>(mesh_);
-        printFieldInfo<volVectorField>(mesh_);
-        printFieldInfo<volSphericalTensorField>(mesh_);
-        printFieldInfo<volSymmTensorField>(mesh_);
-        printFieldInfo<volTensorField>(mesh_);
-        printFieldInfo<surfaceScalarField>(mesh_);
-        printFieldInfo<surfaceVectorField>(mesh_);
-        printFieldInfo<surfaceSphericalTensorField>(mesh_);
-        printFieldInfo<surfaceSymmTensorField>(mesh_);
-        printFieldInfo<surfaceTensorField>(mesh_);
-        Pout<< nl << endl;
-    }
-
-
-
-    // Add processorPatches
-    // ~~~~~~~~~~~~~~~~~~~~
-
-    // Per neighbour processor the patchID to it (or -1).
-    labelList procPatchID;
-
-    // Add processor patches.
-    addProcPatches(sourceNewProc, procPatchID);
-
-    // Put faces into correct patch. Note that we now have proper
-    // processorPolyPatches again so repatching will take care of coupled face
-    // ordering.
-
-    // Get boundary faces to be repatched. Is -1 or new patchID
-    labelList newPatchID
-    (
-        getProcBoundaryPatch
-        (
-            sourceNewProc,
-            procPatchID
-        )
-    );
-
-    // Change patches. Since this might change ordering of coupled faces
-    // we also need to adapt our constructMaps.
-    repatch(newPatchID, constructFaceMap);
-
-    // See if any geometrically shared points need to be merged. Note: does
-    // parallel comms.
-    mergeSharedPoints(constructPointMap);
-
-    // Bit of hack: processorFvPatchField does not get reset since created
-    // from nothing so explicitly reset.
-    initPatchFields<volScalarField, processorFvPatchField<scalar> >
-    (
-        pTraits<scalar>::zero
-    );
-    initPatchFields<volVectorField, processorFvPatchField<vector> >
-    (
-        pTraits<vector>::zero
-    );
-    initPatchFields
-    <
-        volSphericalTensorField,
-        processorFvPatchField<sphericalTensor>
-    >
-    (
-        pTraits<sphericalTensor>::zero
-    );
-    initPatchFields<volSymmTensorField, processorFvPatchField<symmTensor> >
-    (
-        pTraits<symmTensor>::zero
-    );
-    initPatchFields<volTensorField, processorFvPatchField<tensor> >
-    (
-        pTraits<tensor>::zero
-    );
-    initPatchFields<surfaceScalarField, processorFvsPatchField<scalar> >
-    (
-        pTraits<scalar>::zero
-    );
-    initPatchFields<surfaceVectorField, processorFvsPatchField<vector> >
-    (
-        pTraits<vector>::zero
-    );
-    initPatchFields
-    <
-        surfaceSphericalTensorField,
-        processorFvsPatchField<sphericalTensor>
-    >
-    (
-        pTraits<sphericalTensor>::zero
-    );
-    initPatchFields
-    <
-        surfaceSymmTensorField,
-        processorFvsPatchField<symmTensor>
-    >
-    (
-        pTraits<symmTensor>::zero
-    );
-    initPatchFields<surfaceTensorField, processorFvsPatchField<tensor> >
-    (
-        pTraits<tensor>::zero
-    );
-
-
-    mesh_.setInstance(mesh_.time().timeName());
-
-
-    // Print a bit
-    if (debug)
-    {
-        Pout<< nl << "FINAL MESH:" << endl;
-        printMeshInfo(mesh_);
-        printFieldInfo<volScalarField>(mesh_);
-        printFieldInfo<volVectorField>(mesh_);
-        printFieldInfo<volSphericalTensorField>(mesh_);
-        printFieldInfo<volSymmTensorField>(mesh_);
-        printFieldInfo<volTensorField>(mesh_);
-        printFieldInfo<surfaceScalarField>(mesh_);
-        printFieldInfo<surfaceVectorField>(mesh_);
-        printFieldInfo<surfaceSphericalTensorField>(mesh_);
-        printFieldInfo<surfaceSymmTensorField>(mesh_);
-        printFieldInfo<surfaceTensorField>(mesh_);
-        Pout<< nl << endl;
-    }
-
-    // Collect all maps and return
-    return autoPtr<mapDistributePolyMesh>
-    (
-        new mapDistributePolyMesh
-        (
-            mesh_,
-
-            nOldPoints,
-            nOldFaces,
-            nOldCells,
-            oldPatchStarts,
-            oldPatchNMeshPoints,
-
-            subPointMap,
-            subFaceMap,
-            subCellMap,
-            subPatchMap,
-
-            constructPointMap,
-            constructFaceMap,
-            constructCellMap,
-            constructPatchMap,
-            true                // reuse storage
-        )
-    );
-}
-
-
-// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicMesh/directTopoChange/fvMeshDistribute/fvMeshDistribute.H b/src/dynamicMesh/dynamicMesh/directTopoChange/fvMeshDistribute/fvMeshDistribute.H
deleted file mode 100644
index 646a6196a..000000000
--- a/src/dynamicMesh/dynamicMesh/directTopoChange/fvMeshDistribute/fvMeshDistribute.H
+++ /dev/null
@@ -1,368 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright held by original author
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-Class
-    Foam::fvMeshDistribute
-
-Description
-    Sends/receives parts of mesh+fvfields to neighbouring processors.
-    Used in load balancing.
-
-    Input is per local cell the processor it should move to. Moves meshes
-    and volFields/surfaceFields and returns map which can be used to
-    distribute other.
-
-    Notes:
-    - does not handle cyclics. Will probably handle separated proc patches.
-    - if all cells move off processor also all its processor patches will
-      get deleted so comms might be screwed up (since e.g. globalMeshData
-      expects procPatches on all)
-    - initial mesh has to have procPatches last and all normal patches common
-      to all processors and in the same order. This is checked.
-    - faces are matched topologically but points on the faces are not. So
-      expect problems -on separated patches (cyclics?) -on zero sized processor
-      edges.
-
-SourceFiles
-    fvMeshDistribute.C
-    fvMeshDistributeTemplates.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef fvMeshDistribute_H
-#define fvMeshDistribute_H
-
-#include "Field.H"
-//#include "uLabel.H"
-#include "fvMeshSubset.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// Forward declaration of classes
-class mapAddedPolyMesh;
-class mapDistributePolyMesh;
-
-/*---------------------------------------------------------------------------*\
-                           Class fvMeshDistribute Declaration
-\*---------------------------------------------------------------------------*/
-
-class fvMeshDistribute
-{
-    // Private data
-
-        //- Underlying fvMesh
-        fvMesh& mesh_;
-
-        //- Absolute merging tolerance (constructing meshes gets done using
-        //  geometric matching)
-        const scalar mergeTol_;
-
-
-    // Private Member Functions
-
-        //- Find indices with value
-        static labelList select
-        (
-            const bool selectEqual,
-            const labelList& values,
-            const label value
-        );
-
-        //- Check all procs have same names and in exactly same order.
-        static void checkEqualWordList(const string&, const wordList&);
-
-        //- Merge wordlists over all processors
-        static wordList mergeWordList(const wordList&);
-
-
-        // Patch handling
-
-            //- Find patch to put exposed faces into.
-            label findNonEmptyPatch() const;
-
-            //- Appends processorPolyPatch. Returns patchID.
-            label addProcPatch(const word& patchName, const label nbrProc);
-
-            //- Add patch field
-            template<class GeoField>
-            void addPatchFields(const word& patchFieldType);
-
-            //- Deletes last patch.
-            void deleteTrailingPatch();
-
-            // Delete trailing patch fields
-            template<class GeoField>
-            void deleteTrailingPatchFields();
-
-            //- Save boundary fields
-            template <class T, class Mesh>
-            void saveBoundaryFields
-            (
-                PtrList<FieldField<fvsPatchField, T> >& bflds
-            ) const;
-
-            //- Map boundary fields
-            template <class T, class Mesh>
-            void mapBoundaryFields
-            (
-                const mapPolyMesh& map,
-                const PtrList<FieldField<fvsPatchField, T> >& oldBflds
-            );
-
-            //- Init patch fields of certain type
-            template<class GeoField, class PatchFieldType>
-            void initPatchFields
-            (
-                const typename GeoField::value_type& initVal
-            );
-
-            //- Delete all processor patches. Move any processor faces into
-            //  patchI.
-            autoPtr<mapPolyMesh> deleteProcPatches(const label patchI);
-
-            //- Repatch the mesh. This is only nessecary for the proc
-            //  boundary faces. newPatchID is over all boundary faces: -1 or
-            //  new patchID. constructFaceMap is being adapted for the
-            //  possible new face position (since proc faces get automatically
-            //  matched)
-            autoPtr<mapPolyMesh> repatch
-            (
-                const labelList& newPatchID,
-                labelListList& constructFaceMap
-            );
-
-            //- Merge any shared points that are geometrically shared. Needs
-            //  parallel valid mesh - uses globalMeshData.
-            //  constructPointMap is adapted for the new point labels.
-            autoPtr<mapPolyMesh> mergeSharedPoints
-            (
-                labelListList& constructPointMap
-            );
-
-        // Coupling information
-
-            //- Construct the local environment of all boundary faces.
-            void getNeighbourData
-            (
-                const labelList& distribution,
-                labelList& sourceFace,
-                labelList& sourceProc,
-                labelList& sourceNewProc
-            ) const;
-
-            // Subset the neighbourCell/neighbourProc fields
-            static void subsetBoundaryData
-            (
-                const fvMesh& mesh,
-                const labelList& faceMap,
-                const labelList& cellMap,
-
-                const labelList& oldDistribution,
-                const labelList& oldFaceOwner,
-                const labelList& oldFaceNeighbour,
-                const label oldInternalFaces,
-
-                const labelList& sourceFace,
-                const labelList& sourceProc,
-                const labelList& sourceNewProc,
-
-                labelList& subFace,
-                labelList& subProc,
-                labelList& subNewProc
-            );
-
-            //- Find cells on mesh whose faceID/procID match the neighbour
-            //  cell/proc of domainMesh. Store the matching face.
-            static void findCouples
-            (
-                const primitiveMesh&,
-                const labelList& sourceFace,
-                const labelList& sourceProc,
-
-                const label domain,
-                const primitiveMesh& domainMesh,
-                const labelList& domainFace,
-                const labelList& domainProc,
-
-                labelList& masterCoupledFaces,
-                labelList& slaveCoupledFaces
-            );
-
-            //- Map data on boundary faces to new mesh (resulting from adding
-            //  two meshes)
-            static labelList mapBoundaryData
-            (
-                const primitiveMesh& mesh,      // mesh after adding
-                const mapAddedPolyMesh& map,
-                const labelList& boundaryData0, // mesh before adding
-                const label nInternalFaces1,
-                const labelList& boundaryData1  // added mesh
-            );
-
-
-        // Other
-
-            //- Remove cells. Add all exposed faces to patch oldInternalPatchI
-            autoPtr<mapPolyMesh> doRemoveCells
-            (
-                const labelList& cellsToRemove,
-                const label oldInternalPatchI
-            );
-
-            //- Add processor patches. Changes mesh and returns per neighbour
-            //  proc the processor patchID.
-            void addProcPatches
-            (
-                const labelList&, // processor that neighbour is on
-                labelList& procPatchID
-            );
-
-            //- Get boundary faces to be repatched. Is -1 or new patchID
-            static labelList getProcBoundaryPatch
-            (
-                const labelList& neighbourNewProc,// new processor per b. face
-                const labelList& procPatchID      // patchID
-            );
-
-            //- Send mesh and coupling data.
-            static void sendMesh
-            (
-                const label domain,
-                const fvMesh& mesh,
-                const wordList& pointZoneNames,
-                const wordList& facesZoneNames,
-                const wordList& cellZoneNames,
-                const labelList& sourceFace,
-                const labelList& sourceProc,
-                const labelList& sourceNewProc,
-                OSstream& toDomain
-            );
-            //- Send subset of fields
-            template<class GeoField>
-            static void sendFields
-            (
-                const label domain,
-                const wordList& fieldNames,
-                const fvMeshSubset&,
-                OSstream& toNbr
-            );
-
-            //- Receive mesh. Opposite of sendMesh
-            static autoPtr<fvMesh> receiveMesh
-            (
-                const label domain,
-                const wordList& pointZoneNames,
-                const wordList& facesZoneNames,
-                const wordList& cellZoneNames,
-                const Time& runTime,
-                labelList& domainSourceFace,
-                labelList& domainSourceProc,
-                labelList& domainSourceNewProc,
-                ISstream& fromNbr
-            );
-
-            //- Receive fields. Opposite of sendFields
-            template<class GeoField>
-            static void receiveFields
-            (
-                const label domain,
-                const wordList& fieldNames,
-                fvMesh&,
-                PtrList<GeoField>&,
-                const dictionary& fieldDicts
-            );
-
-            //- Do parallel exchange
-            template <class Container, class T>
-            static void exchange
-            (
-                const List<Container >& sendBufs,
-                List<Container >& recvBufs,
-                labelListList& sizes
-            );
-
-            //- Disallow default bitwise copy construct
-            fvMeshDistribute(const fvMeshDistribute&);
-
-            //- Disallow default bitwise assignment
-            void operator=(const fvMeshDistribute&);
-
-public:
-
-    ClassName("fvMeshDistribute");
-
-
-    // Constructors
-
-        //- Construct from mesh and absolute merge tolerance
-        fvMeshDistribute(fvMesh& mesh, const scalar mergeTol);
-
-
-    // Member Functions
-
-        //- Helper function: count cells per processor in wanted distribution
-        static labelList countCells(const labelList&);
-
-        //- Send cells to neighbours according to distribution
-        //  (for every cell the new proc)
-        autoPtr<mapDistributePolyMesh> distribute(const labelList& dist);
-
-        // Debugging
-
-            //- Print some info on coupling data
-            static void printCoupleInfo
-            (
-                const primitiveMesh&,
-                const labelList&,
-                const labelList&,
-                const labelList&
-            );
-
-            //- Print some field info
-            template<class GeoField>
-            static void printFieldInfo(const fvMesh&);
-
-            //- Print some info on mesh.
-            static void printMeshInfo(const fvMesh&);
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#ifdef NoRepository
-#   include "fvMeshDistributeTemplates.C"
-#endif
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicMesh/directTopoChange/fvMeshDistribute/fvMeshDistributeTemplates.C b/src/dynamicMesh/dynamicMesh/directTopoChange/fvMeshDistribute/fvMeshDistributeTemplates.C
deleted file mode 100644
index 41e005c24..000000000
--- a/src/dynamicMesh/dynamicMesh/directTopoChange/fvMeshDistribute/fvMeshDistributeTemplates.C
+++ /dev/null
@@ -1,499 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright held by original author
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-\*---------------------------------------------------------------------------*/
-
-#include "mapPolyMesh.H"
-#include "PstreamCombineReduceOps.H"
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-//- combineReduce operator for lists. Used for counting.
-class listEq
-{
-
-public:
-
-    template<class T>
-    void operator()(T& x, const T& y) const
-    {
-        forAll(y, i)
-        {
-            if (y[i].size())
-            {
-                x[i] = y[i];
-            }
-        }
-    }
-};
-
-
-template <class Container, class T>
-void Foam::fvMeshDistribute::exchange
-(
-    const List<Container >& sendBufs,
-    List<Container >& recvBufs,
-    labelListList& sizes
-)
-{
-    if (Pstream::parRun())
-    {
-        if (!contiguous<T>())
-        {
-            FatalErrorIn
-            (
-                "Pstream::exchange(..)"
-            )   << "Continuous data only." << Foam::abort(FatalError);
-        }
-
-        if (sendBufs.size() != Pstream::nProcs())
-        {
-            FatalErrorIn
-            (
-                "Pstream::exchange(..)"
-            )   << "Size of list:" << sendBufs.size()
-                << " does not equal the number of processors:"
-                << Pstream::nProcs()
-                << Foam::abort(FatalError);
-        }
-
-        sizes.setSize(Pstream::nProcs());
-        labelList& nsTransPs = sizes[Pstream::myProcNo()];
-        nsTransPs.setSize(Pstream::nProcs());
-
-        forAll(sendBufs, procI)
-        {
-            nsTransPs[procI] = sendBufs[procI].size();
-        }
-
-        Foam::combineReduce(sizes, listEq());
-
-
-        // Set up receives
-        // ~~~~~~~~~~~~~~~
-
-        recvBufs.setSize(sendBufs.size());
-        forAll(sizes, procI)
-        {
-            label nRecv = sizes[procI][Pstream::myProcNo()];
-
-            if (procI != Pstream::myProcNo() && nRecv > 0)
-            {
-                recvBufs[procI].setSize(nRecv);
-                IPstream::read
-                (
-                    Pstream::nonBlocking,
-                    procI,
-                    reinterpret_cast<char*>(recvBufs[procI].begin()),
-                    nRecv*sizeof(T)
-                );
-            }
-        }
-
-
-        // Set up sends
-        // ~~~~~~~~~~~~
-
-        forAll(sendBufs, procI)
-        {
-            if (procI != Pstream::myProcNo() && sendBufs[procI].size() > 0)
-            {
-                if
-                (
-                   !OPstream::write
-                    (
-                        Pstream::nonBlocking,
-                        procI,
-                        reinterpret_cast<const char*>(sendBufs[procI].begin()),
-                        sendBufs[procI].size()*sizeof(T)
-                    )
-                )
-                {
-                    FatalErrorIn("Pstream::exchange(..)")
-                        << "Cannot send outgoing message. "
-                        << "to:" << procI << " nBytes:"
-                        << label(sendBufs[procI].size()*sizeof(T))
-                        << Foam::abort(FatalError);
-                }
-            }
-        }
-
-
-        // Wait for all to finish
-        // ~~~~~~~~~~~~~~~~~~~~~~
-
-        IPstream::waitRequests();
-        OPstream::waitRequests();
-    }
-
-    // Do myself
-    recvBufs[Pstream::myProcNo()] = sendBufs[Pstream::myProcNo()];
-}
-
-
-template<class GeoField>
-void Foam::fvMeshDistribute::printFieldInfo(const fvMesh& mesh)
-{
-    HashTable<const GeoField*> flds
-    (
-        mesh.objectRegistry::lookupClass<GeoField>()
-    );
-
-    for
-    (
-        typename HashTable<const GeoField*>::const_iterator iter = flds.begin();
-        iter != flds.end();
-        ++iter
-    )
-    {
-        const GeoField& fld = *iter();
-
-        Pout<< "Field:" << iter.key() << " internalsize:" << fld.size()
-            //<< " value:" << fld
-            << endl;
-
-        forAll(fld.boundaryField(), patchI)
-        {
-            Pout<< "    " << patchI
-                << ' ' << fld.boundaryField()[patchI].patch().name()
-                << ' ' << fld.boundaryField()[patchI].type()
-                << ' ' << fld.boundaryField()[patchI].size()
-                << endl;
-        }
-    }
-}
-
-
-template<class GeoField>
-void Foam::fvMeshDistribute::addPatchFields(const word& patchFieldType)
-{
-    HashTable<const GeoField*> flds
-    (
-        mesh_.objectRegistry::lookupClass<GeoField>()
-    );
-
-    for
-    (
-        typename HashTable<const GeoField*>::const_iterator iter = flds.begin();
-        iter != flds.end();
-        ++iter
-    )
-    {
-        const GeoField& fld = *iter();
-
-        typename GeoField::GeometricBoundaryField& bfld =
-            const_cast<typename GeoField::GeometricBoundaryField&>
-            (
-                fld.boundaryField()
-            );
-
-        label sz = bfld.size();
-        bfld.setSize(sz + 1);
-        bfld.set
-        (
-            sz,
-            GeoField::PatchFieldType::New
-            (
-                patchFieldType,
-                mesh_.boundary()[sz],
-                fld.dimensionedInternalField()
-            )
-        );
-    }
-}
-
-
-// Delete trailing patch fields
-template<class GeoField>
-void Foam::fvMeshDistribute::deleteTrailingPatchFields()
-{
-    HashTable<const GeoField*> flds
-    (
-        mesh_.objectRegistry::lookupClass<GeoField>()
-    );
-
-    for
-    (
-        typename HashTable<const GeoField*>::const_iterator iter = flds.begin();
-        iter != flds.end();
-        ++iter
-    )
-    {
-        const GeoField& fld = *iter();
-
-        typename GeoField::GeometricBoundaryField& bfld =
-            const_cast<typename GeoField::GeometricBoundaryField&>
-            (
-                fld.boundaryField()
-            );
-
-        // Shrink patchFields
-        bfld.setSize(bfld.size() - 1);
-    }
-}
-
-
-// Save whole boundary field
-template <class T, class Mesh>
-void Foam::fvMeshDistribute::saveBoundaryFields
-(
-    PtrList<FieldField<fvsPatchField, T> >& bflds
-) const
-{
-    typedef GeometricField<T, fvsPatchField, Mesh> fldType;
-
-    HashTable<const fldType*> flds
-    (
-        mesh_.objectRegistry::lookupClass<fldType>()
-    );
-
-    bflds.setSize(flds.size());
-
-    label i = 0;
-
-    for
-    (
-        typename HashTable<const fldType*>::const_iterator iter = flds.begin();
-        iter != flds.end();
-        ++iter
-    )
-    {
-        const fldType& fld = *iter();
-
-        bflds.set(i, fld.boundaryField().clone().ptr());
-
-        i++;
-    }
-}
-
-
-// Map boundary field
-template <class T, class Mesh>
-void Foam::fvMeshDistribute::mapBoundaryFields
-(
-    const mapPolyMesh& map,
-    const PtrList<FieldField<fvsPatchField, T> >& oldBflds
-)
-{
-    const labelList& oldPatchStarts = map.oldPatchStarts();
-    const labelList& faceMap = map.faceMap();
-
-    typedef GeometricField<T, fvsPatchField, Mesh> fldType;
-
-    HashTable<const fldType*> flds
-    (
-        mesh_.objectRegistry::lookupClass<fldType>()
-    );
-
-    if (flds.size() != oldBflds.size())
-    {
-        FatalErrorIn("fvMeshDistribute::mapBoundaryFields(..)") << "problem"
-            << abort(FatalError);
-    }
-
-    label fieldI = 0;
-
-    for
-    (
-        typename HashTable<const fldType*>::const_iterator iter = flds.begin();
-        iter != flds.end();
-        ++iter
-    )
-    {
-        const fldType& fld = *iter();
-        typename fldType::GeometricBoundaryField& bfld =
-            const_cast<typename fldType::GeometricBoundaryField&>
-            (
-                fld.boundaryField()
-            );
-
-
-        const FieldField<fvsPatchField, T>& oldBfld = oldBflds[fieldI++];
-
-        // Pull from old boundary field into bfld.
-
-        forAll(bfld, patchI)
-        {
-            fvsPatchField<T>& patchFld = bfld[patchI];
-            label faceI = patchFld.patch().patch().start();
-
-            forAll(patchFld, i)
-            {
-                label oldFaceI = faceMap[faceI++];
-
-                // Find patch and local patch face oldFaceI was in.
-                forAll(oldPatchStarts, oldPatchI)
-                {
-                    label oldLocalI = oldFaceI - oldPatchStarts[oldPatchI];
-
-                    if (oldLocalI >= 0 && oldLocalI < oldBfld[oldPatchI].size())
-                    {
-                        patchFld[i] = oldBfld[oldPatchI][oldLocalI];
-                    }
-                }
-            }
-        }
-    }
-}
-
-
-// Init patch fields of certain type
-template<class GeoField, class PatchFieldType>
-void Foam::fvMeshDistribute::initPatchFields
-(
-    const typename GeoField::value_type& initVal
-)
-{
-    HashTable<const GeoField*> flds
-    (
-        mesh_.objectRegistry::lookupClass<GeoField>()
-    );
-
-    for
-    (
-        typename HashTable<const GeoField*>::const_iterator iter = flds.begin();
-        iter != flds.end();
-        ++iter
-    )
-    {
-        const GeoField& fld = *iter();
-
-        typename GeoField::GeometricBoundaryField& bfld =
-            const_cast<typename GeoField::GeometricBoundaryField&>
-            (
-                fld.boundaryField()
-            );
-
-        forAll(bfld, patchI)
-        {
-            if (isA<PatchFieldType>(bfld[patchI]))
-            {
-                bfld[patchI] == initVal;
-            }
-        }
-    }
-}
-
-
-// Send fields. Note order supplied so we can receive in exactly the same order.
-// Note that field gets written as entry in dictionary so we
-// can construct from subdictionary.
-// (since otherwise the reading as-a-dictionary mixes up entries from
-// consecutive fields)
-// The dictionary constructed is:
-//  volScalarField
-//  {
-//      p {internalField ..; boundaryField ..;}
-//      k {internalField ..; boundaryField ..;}
-//  }
-//  volVectorField
-//  {
-//      U {internalField ...  }
-//  }
-
-// volVectorField {U {internalField ..; boundaryField ..;}}
-// 
-template<class GeoField>
-void Foam::fvMeshDistribute::sendFields
-(
-    const label domain,
-    const wordList& fieldNames,
-    const fvMeshSubset& subsetter,
-    OSstream& toNbr
-)
-{
-    toNbr << GeoField::typeName << token::NL << token::BEGIN_BLOCK << token::NL;
-    forAll(fieldNames, i)
-    {
-        if (debug)
-        {
-            Pout<< "Subsetting field " << fieldNames[i]
-                << " for domain:" << domain << endl;
-        }
-
-        // Send all fieldNames. This has to be exactly the same set as is
-        // being received!
-        const GeoField& fld =
-            subsetter.baseMesh().lookupObject<GeoField>(fieldNames[i]);
-
-        tmp<GeoField> tsubfld = subsetter.interpolate(fld);
-
-        toNbr
-            << fieldNames[i] << token::NL << token::BEGIN_BLOCK
-            << tsubfld
-            << token::NL << token::END_BLOCK << token::NL;
-    }
-    toNbr << token::END_BLOCK << token::NL;
-}
-
-
-// Opposite of sendFields
-template<class GeoField>
-void Foam::fvMeshDistribute::receiveFields
-(
-    const label domain,
-    const wordList& fieldNames,
-    fvMesh& mesh,
-    PtrList<GeoField>& fields,
-    const dictionary& fieldDicts
-)
-{
-    if (debug)
-    {
-        Pout<< "Receiving fields " << fieldNames
-            << " from domain:" << domain << endl;
-    }
-
-    fields.setSize(fieldNames.size());
-
-    forAll(fieldNames, i)
-    {
-        if (debug)
-        {
-            Pout<< "Constructing field " << fieldNames[i]
-                << " from domain:" << domain << endl;
-        }
-
-        fields.set
-        (
-            i,
-            new GeoField
-            (
-                IOobject
-                (
-                    fieldNames[i],
-                    mesh.time().timeName(),
-                    mesh,
-                    IOobject::NO_READ,
-                    IOobject::AUTO_WRITE
-                ),
-                mesh,
-                fieldDicts.subDict(fieldNames[i])
-            )
-        );
-    }
-}
-
-
-// ************************************************************************* //
diff --git a/src/finiteArea/interpolation/edgeInterpolation/edgeInterpolationScheme/edgeInterpolationScheme.C b/src/finiteArea/interpolation/edgeInterpolation/edgeInterpolationScheme/edgeInterpolationScheme.C
index 2548bb8f1..50308b692 100644
--- a/src/finiteArea/interpolation/edgeInterpolation/edgeInterpolationScheme/edgeInterpolationScheme.C
+++ b/src/finiteArea/interpolation/edgeInterpolation/edgeInterpolationScheme/edgeInterpolationScheme.C
@@ -360,7 +360,7 @@ edgeInterpolationScheme<Type>::interpolate
 
             for (label i=0; i<size; i++)
             {
-                const tensorField& curT = 
+                const tensorField& curT =
                     mesh.edgeTransformTensors()[start + i];
 
                 const tensor& Te = curT[0];
@@ -372,13 +372,13 @@ edgeInterpolationScheme<Type>::interpolate
                     (
                         Te.T(),
                         pLambda[i]*transform(TP, pOwnVf[i])
-                      + (1.0 - pLambda[i])*transform(TN, pNgbVf[i])
+                      + (1 - pLambda[i])*transform(TN, pNgbVf[i])
                     );
             }
 
 //             tsf().boundaryField()[pi] =
 //                 pLambda*vf.boundaryField()[pi].patchInternalField()
-//              + (1.0 - pLambda)*vf.boundaryField()[pi].patchNeighbourField();
+//              + (1 - pLambda)*vf.boundaryField()[pi].patchNeighbourField();
         }
         else
         {
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/flowRateInletVelocity/flowRateInletVelocityFvPatchVectorField.C b/src/finiteVolume/fields/fvPatchFields/derived/flowRateInletVelocity/flowRateInletVelocityFvPatchVectorField.C
index ddfccba4c..5da7a3573 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/flowRateInletVelocity/flowRateInletVelocityFvPatchVectorField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/flowRateInletVelocity/flowRateInletVelocityFvPatchVectorField.C
@@ -118,7 +118,7 @@ void Foam::flowRateInletVelocityFvPatchVectorField::updateCoeffs()
         return;
     }
 
-    // a simpler way of doing this would be nice
+    // A simpler way of doing this would be nice
     scalar avgU = -flowRate_/gSum(patch().magSf());
 
     vectorField n = patch().nf();
@@ -128,7 +128,7 @@ void Foam::flowRateInletVelocityFvPatchVectorField::updateCoeffs()
 
     if (phi.dimensions() == dimVelocity*dimArea)
     {
-        // volumetric flow-rate
+        // Volumetric flow-rate
         operator==(n*avgU);
     }
     else if (phi.dimensions() == dimDensity*dimVelocity*dimArea)
@@ -136,7 +136,7 @@ void Foam::flowRateInletVelocityFvPatchVectorField::updateCoeffs()
         const fvPatchField<scalar>& rhop =
             patch().lookupPatchField<volScalarField, scalar>(rhoName_);
 
-        // mass flow-rate
+        // Mass flow-rate
         operator==(n*avgU/rhop);
     }
     else
diff --git a/src/finiteVolume/finiteVolume/ddtSchemes/CoEulerDdtScheme/CoEulerDdtScheme.C b/src/finiteVolume/finiteVolume/ddtSchemes/CoEulerDdtScheme/CoEulerDdtScheme.C
index df5b9bf80..90e30fbb4 100644
--- a/src/finiteVolume/finiteVolume/ddtSchemes/CoEulerDdtScheme/CoEulerDdtScheme.C
+++ b/src/finiteVolume/finiteVolume/ddtSchemes/CoEulerDdtScheme/CoEulerDdtScheme.C
@@ -69,10 +69,10 @@ tmp<volScalarField> CoEulerDdtScheme<Type>::CorDeltaT() const
 
     forAll(owner, faceI)
     {
-        corDeltaT[owner[faceI]] = 
+        corDeltaT[owner[faceI]] =
             max(corDeltaT[owner[faceI]], cofrDeltaT[faceI]);
 
-        corDeltaT[neighbour[faceI]] = 
+        corDeltaT[neighbour[faceI]] =
             max(corDeltaT[neighbour[faceI]], cofrDeltaT[faceI]);
     }
 
diff --git a/src/finiteVolume/fvMesh/fvPatches/fvPatch/fvPatch.H b/src/finiteVolume/fvMesh/fvPatches/fvPatch/fvPatch.H
index 72dcfcc4d..e7df4e76b 100644
--- a/src/finiteVolume/fvMesh/fvPatches/fvPatch/fvPatch.H
+++ b/src/finiteVolume/fvMesh/fvPatches/fvPatch/fvPatch.H
@@ -206,7 +206,10 @@ public:
             }
 
             template<class T>
-            const typename Field<T>::subField patchSlice(const Field<T>& l) const
+            const typename Field<T>::subField patchSlice
+            (
+                const Field<T>& l
+            ) const
             {
                 return typename Field<T>::subField
                 (
diff --git a/src/tetDecompositionFiniteElement/tetPolyMeshCellDecomp/tetPolyPatches/constraint/processor/calcProcessorTetPolyPatchCellDecompPointAddr.C b/src/tetDecompositionFiniteElement/tetPolyMeshCellDecomp/tetPolyPatches/constraint/processor/calcProcessorTetPolyPatchCellDecompPointAddr.C
index 3dabd89cd..d63133239 100644
--- a/src/tetDecompositionFiniteElement/tetPolyMeshCellDecomp/tetPolyPatches/constraint/processor/calcProcessorTetPolyPatchCellDecompPointAddr.C
+++ b/src/tetDecompositionFiniteElement/tetPolyMeshCellDecomp/tetPolyPatches/constraint/processor/calcProcessorTetPolyPatchCellDecompPointAddr.C
@@ -59,12 +59,11 @@ void Foam::processorTetPolyPatchCellDecomp::calcMeshPoints() const
             masterFaces[faceI] = pp[faceI].reverseFace();
         }
 
-        mp =
-            primitiveFacePatch
-            (
-                masterFaces,
-                pp.points()
-            ).meshPoints();
+        mp = primitiveFacePatch
+        (
+            masterFaces,
+            pp.points()
+        ).meshPoints();
     }
 
     // Get reference to shared points