Bug fix: parallel cell-to-point interpolation and evaluation of conditions on coupled boundaries

src/OpenFOAM/fields/PointPatchFields/basic/coupled/CoupledPointPatchField.H

@@ -153,12 +153,6 @@ public:
             //- Add field to internal field
             virtual void addField(Field<Type>&) const = 0;
 
-            //- Initialise swap of patch point values
-            virtual void initSwapAdd(Field<Type>&) const
-            {}
-
-            //- Complete swap of patch point values and add to local values
-            virtual void swapAdd(Field<Type>&) const = 0;
 
         // Matrix construction (completion) functionality
 

src/OpenFOAM/fields/PointPatchFields/constraint/cyclic/CyclicPointPatchField.C

@@ -230,47 +230,6 @@ CyclicPointPatchField
 {}
 
 
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-template
-<
-    template<class> class PatchField,
-    class Mesh,
-    class PointPatch,
-    class CyclicPointPatch,
-    template<class> class MatrixType,
-    class Type
->
-void
-CyclicPointPatchField
-<PatchField, Mesh, PointPatch, CyclicPointPatch, MatrixType, Type>::
-swapAdd(Field<Type>& pField) const
-{
-    Field<Type> pf(this->patchInternalField(pField));
-
-    const edgeList& pairs = cyclicPatch_.transformPairs();
-
-    if (doTransform())
-    {
-        forAll(pairs, pairi)
-        {
-            Type tmp = pf[pairs[pairi][0]];
-            pf[pairs[pairi][0]] = transform(forwardT()[0], pf[pairs[pairi][1]]);
-            pf[pairs[pairi][1]] = transform(reverseT()[0], tmp);
-        }
-    }
-    else
-    {
-        forAll(pairs, pairi)
-        {
-            Swap(pf[pairs[pairi][0]], pf[pairs[pairi][1]]);
-        }
-    }
-
-    addToInternalField(pField, pf);
-}
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam

src/OpenFOAM/fields/PointPatchFields/constraint/cyclic/CyclicPointPatchField.H

@@ -194,8 +194,6 @@ public:
             virtual void addField(Field<Type>&) const
             {}
 
-            //- Complete swap of patch point values and add to local values
-            virtual void swapAdd(Field<Type>&) const;
 
         // Matrix construction (completion) functionality.  Currently faked
         // HJ, 31/May/2007

src/OpenFOAM/fields/PointPatchFields/constraint/processor/ProcessorPointPatchField.C

@@ -601,86 +601,6 @@ setBoundaryCondition
 }
 
 
-template
-<
-    template<class> class PatchField,
-    class Mesh,
-    class PointPatch,
-    class ProcessorPointPatch,
-    template<class> class MatrixType,
-    class Type
->
-void
-ProcessorPointPatchField
-<PatchField, Mesh, PointPatch, ProcessorPointPatch,  MatrixType, Type>::
-initSwapAdd(Field<Type>& pField) const
-{
-    Field<Type> pf(this->patchInternalField(pField));
-
-    OPstream::write
-    (
-        Pstream::blocking,
-        procPatch_.neighbProcNo(),
-        reinterpret_cast<const char*>(pf.begin()),
-        pf.byteSize()
-    );
-}
-
-
-template
-<
-    template<class> class PatchField,
-    class Mesh,
-    class PointPatch,
-    class ProcessorPointPatch,
-    template<class> class MatrixType,
-    class Type
->
-void
-ProcessorPointPatchField
-<PatchField, Mesh, PointPatch, ProcessorPointPatch, MatrixType, Type>::
-swapAdd(Field<Type>& pField) const
-{
-    Field<Type> pnf(this->size());
-
-    IPstream::read
-    (
-        Pstream::blocking,
-        procPatch_.neighbProcNo(),
-        reinterpret_cast<char*>(pnf.begin()),
-        pnf.byteSize()
-    );
-
-    if (doTransform())
-    {
-        const labelList& nonGlobalPatchPoints =
-            procPatch_.nonGlobalPatchPoints();
-
-        const processorPolyPatch& ppp = procPatch_.procPolyPatch();
-        const labelListList& pointFaces = ppp.pointFaces();
-        const tensorField& forwardT = ppp.forwardT();
-
-        if (forwardT.size() == 1)
-        {
-            transform(pnf, forwardT[0], pnf);
-        }
-        else
-        {
-            forAll(nonGlobalPatchPoints, pfi)
-            {
-                pnf[pfi] = transform
-                (
-                    forwardT[pointFaces[nonGlobalPatchPoints[pfi]][0]],
-                    pnf[pfi]
-                );
-            }
-        }
-    }
-
-    addToInternalField(pField, pnf);
-}
-
-
 // Initialise transfer of diagonal coefficients
 template
 <

src/OpenFOAM/fields/PointPatchFields/constraint/processor/ProcessorPointPatchField.H

@@ -291,12 +291,6 @@ public:
                 Map<typename MatrixType<Type>::ConstraintType> &
             ) const;
 
-            //- Initialise swap of patch point values
-            virtual void initSwapAdd(Field<Type>&) const;
-
-            //- Complete swap of patch point values and add to local values
-            virtual void swapAdd(Field<Type>&) const;
-
 
         // Matrix construction (completion) functionality
 

src/OpenFOAM/fields/PointPatchFields/derived/global/GlobalPointPatchField.C

@@ -629,55 +629,6 @@ void GlobalPointPatchField
 }
 
 
-template
-<
-    template<class> class PatchField,
-    class Mesh,
-    class PointPatch,
-    class GlobalPointPatch,
-    template<class> class MatrixType,
-    class Type
->
-void GlobalPointPatchField
-<
-    PatchField,
-    Mesh,
-    PointPatch,
-    GlobalPointPatch,
-    MatrixType,
-    Type
->::swapAdd(Field<Type>& pField) const
-{
-    // Create the global list and insert local values
-    if (globalPointPatch_.globalPointSize() > 0)
-    {
-        Field<Type> lpf = patchInternalField(pField);
-        const labelList& addr = globalPointPatch_.sharedPointAddr();
-
-        Field<Type> gpf
-        (
-            globalPointPatch_.globalPointSize(),
-            pTraits<Type>::zero
-        );
-
-        forAll(addr, i)
-        {
-            gpf[addr[i]] += lpf[i];
-        }
-
-        combineReduce(gpf, plusEqOp<Field<Type> >());
-
-        // Extract local data
-        forAll (addr, i)
-        {
-            lpf[i] = gpf[addr[i]];
-        }
-
-        setInInternalField(pField, lpf);
-    }
-}
-
-
 // Add diagonal coefficients
 template
 <

src/OpenFOAM/fields/PointPatchFields/derived/global/GlobalPointPatchField.H

@@ -198,9 +198,6 @@ public:
                 Map<typename MatrixType<Type>::ConstraintType> &
             ) const;
 
-            //- Complete swap of patch point values and add to local values
-            virtual void swapAdd(Field<Type>&) const;
-
 
         // Matrix construction (completion) functionality
 

src/OpenFOAM/meshes/pointMesh/pointBoundaryMesh/pointBoundaryMesh.H

@@ -64,7 +64,8 @@ class pointBoundaryMesh
 
     // Private Member Functions
 
-        //- Calculate the geometry for the patches (transformation tensors etc.)
+        //- Calculate the geometry for the patches
+        //  (transformation tensors etc.)
         void calcGeometry();
 
         //- Disallow default bitwise copy construct

src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/cyclic/cyclicPointPatch.C

@@ -48,118 +48,15 @@ addToRunTimeSelectionTable
 );
 
 
-// * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
-
-void Foam::cyclicPointPatch::initGeometry()
-{
-    transformPairs_.setSize(0);
-}
-
-
-void Foam::cyclicPointPatch::calcGeometry()
-{
-    const edgeList& cp = cyclicPolyPatch_.coupledPoints();
-    const labelList& mp = cyclicPolyPatch_.meshPoints();
-
-    // If there are no global points create a 1->1 map
-    if (!boundaryMesh().mesh().globalData().nGlobalPoints())
-    {
-        nonGlobalPatchPoints_.setSize(mp.size());
-        forAll(nonGlobalPatchPoints_, i)
-        {
-            nonGlobalPatchPoints_[i] = i;
-        }
-
-        meshPoints_ = cyclicPolyPatch_.meshPoints();
-        transformPairs_ = cp;
-    }
-    else
-    {
-        // Get reference to shared points
-        const labelList& sharedPoints = 
-            boundaryMesh().globalPatch().meshPoints();
-
-        nonGlobalPatchPoints_.setSize(mp.size());
-        meshPoints_.setSize(mp.size());
-
-        labelList pointMap(mp.size(), -1);
-
-        label noFiltPoints = 0;
-
-        forAll (mp, pointI)
-        {
-            label curP = mp[pointI];
-
-            bool found = false;
-
-            forAll (sharedPoints, sharedI)
-            {
-                if (sharedPoints[sharedI] == curP)
-                {
-                    found = true;
-                    break;
-                }
-            }
-
-            if (!found)
-            {
-                pointMap[pointI] = noFiltPoints;
-                nonGlobalPatchPoints_[noFiltPoints] = pointI;
-                meshPoints_[noFiltPoints] = curP;
-                noFiltPoints++;
-            }
-        }
-
-        nonGlobalPatchPoints_.setSize(noFiltPoints);
-        meshPoints_.setSize(noFiltPoints);
-
-
-        transformPairs_.setSize(cp.size());
-
-        label noFiltPointPairs = 0;
-
-        forAll(cp, i)
-        {
-            if (pointMap[cp[i][0]] != -1 && pointMap[cp[i][1]] != -1)
-            {
-                transformPairs_[noFiltPointPairs][0] = pointMap[cp[i][0]];
-                transformPairs_[noFiltPointPairs][1] = pointMap[cp[i][1]];
-                noFiltPointPairs++;
-            }
-            else if (pointMap[cp[i][0]] == -1 && pointMap[cp[i][1]] != -1)
-            {
-                FatalErrorIn("cyclicPointPatch::calcGeometry() const")
-                    << "Point " << cp[i][0] << "of point-pair " << i
-                    << " is a global point but the other point "
-                    << cp[i][1] << " is not"
-                    << exit(FatalError);
-            }
-            else if (pointMap[cp[i][0]] != -1 && pointMap[cp[i][1]] == -1)
-            {
-                FatalErrorIn("cyclicPointPatch::calcGeometry() const")
-                    << "Point " << cp[i][1] << "of point-pair " << i
-                    << " is a global point but the other point "
-                    << cp[i][0] << " is not"
-                    << exit(FatalError);
-            }
-        }
-
-        transformPairs_.setSize(noFiltPointPairs);
-    }
-}
-
-
 void cyclicPointPatch::initUpdateMesh()
 {
     facePointPatch::initUpdateMesh();
-    cyclicPointPatch::initGeometry();
 }
 
 
 void cyclicPointPatch::updateMesh()
 {
     facePointPatch::updateMesh();
-    cyclicPointPatch::calcGeometry();
 }
 
 
@@ -184,10 +81,6 @@ cyclicPointPatch::~cyclicPointPatch()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-const edgeList& cyclicPointPatch::transformPairs() const
-{
-    return transformPairs_;
-}
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/cyclic/cyclicPointPatch.H

@@ -79,10 +79,12 @@ protected:
     // Protected Member Functions
 
         //- Initialise the calculation of the patch geometry
-        virtual void initGeometry();
+        virtual void initGeometry()
+        {}
 
         //- Calculate the patch geometry
-        virtual void calcGeometry();
+        virtual void calcGeometry()
+        {}
 
         //- Correct patches after moving points
         virtual void movePoints()
@@ -147,13 +149,6 @@ public:
             {
                 return cyclicPolyPatch_.reverseT();
             }
-
-
-        // Access functions for demand driven data
-
-            //- Return the set of pairs of points that require transformation
-            //  and/or mapping
-            virtual const edgeList& transformPairs() const;
 };
 
 

src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/cyclicGgi/cyclicGgiPointPatch.C

@@ -49,33 +49,15 @@ namespace Foam
 
 // * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
 
-void Foam::cyclicGgiPointPatch::initGeometry()
-{}
-
-
-void Foam::cyclicGgiPointPatch::calcGeometry()
-{
-    meshPoints_ = cyclicGgiPolyPatch_.meshPoints();
-
-    nonGlobalPatchPoints_.setSize(meshPoints_.size());
-    forAll(nonGlobalPatchPoints_, i)
-    {
-        nonGlobalPatchPoints_[i] = i;
-    }
-}
-
-
 void Foam::cyclicGgiPointPatch::initUpdateMesh()
 {
     facePointPatch::initUpdateMesh();
-    cyclicGgiPointPatch::initGeometry();
 }
 
 
 void Foam::cyclicGgiPointPatch::updateMesh()
 {
     facePointPatch::updateMesh();
-    cyclicGgiPointPatch::calcGeometry();
 }
 
 

src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/cyclicGgi/cyclicGgiPointPatch.H

@@ -78,10 +78,12 @@ protected:
     // Protected Member Functions
 
         //- Initialise the calculation of the patch geometry
-        virtual void initGeometry();
+        virtual void initGeometry()
+        {}
 
         //- Calculate mesh points
-        virtual void calcGeometry();
+        virtual void calcGeometry()
+        {}
 
         //- Correct patches after moving points
         virtual void movePoints()

src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/ggi/ggiPointPatch.C

@@ -49,33 +49,15 @@ namespace Foam
 
 // * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
 
-void Foam::ggiPointPatch::initGeometry()
-{}
-
-
-void Foam::ggiPointPatch::calcGeometry()
-{
-    meshPoints_ = ggiPolyPatch_.meshPoints();
-
-    nonGlobalPatchPoints_.setSize(meshPoints_.size());
-    forAll(nonGlobalPatchPoints_, i)
-    {
-        nonGlobalPatchPoints_[i] = i;
-    }
-}
-
-
 void Foam::ggiPointPatch::initUpdateMesh()
 {
     facePointPatch::initUpdateMesh();
-    ggiPointPatch::initGeometry();
 }
 
 
 void Foam::ggiPointPatch::updateMesh()
 {
     facePointPatch::updateMesh();
-    ggiPointPatch::calcGeometry();
 }
 
 

src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/ggi/ggiPointPatch.H

@@ -75,10 +75,12 @@ protected:
     // Protected Member Functions
 
         //- Initialise the calculation of the patch geometry
-        virtual void initGeometry();
+        virtual void initGeometry()
+        {}
 
         //- Calculate mesh points
-        virtual void calcGeometry();
+        virtual void calcGeometry()
+        {}
 
         //- Correct patches after moving points
         virtual void movePoints()

src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/overlapGgi/overlapGgiPointPatch.C

@@ -49,33 +49,15 @@ namespace Foam
 
 // * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
 
-void Foam::overlapGgiPointPatch::initGeometry()
-{}
-
-
-void Foam::overlapGgiPointPatch::calcGeometry()
-{
-    meshPoints_ = overlapGgiPolyPatch_.meshPoints();
-
-    nonGlobalPatchPoints_.setSize(meshPoints_.size());
-    forAll(nonGlobalPatchPoints_, i)
-    {
-        nonGlobalPatchPoints_[i] = i;
-    }
-}
-
-
 void Foam::overlapGgiPointPatch::initUpdateMesh()
 {
     facePointPatch::initUpdateMesh();
-    overlapGgiPointPatch::initGeometry();
 }
 
 
 void Foam::overlapGgiPointPatch::updateMesh()
 {
     facePointPatch::updateMesh();
-    overlapGgiPointPatch::calcGeometry();
 }
 
 

src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/overlapGgi/overlapGgiPointPatch.H

@@ -75,10 +75,12 @@ protected:
     // Protected Member Functions
 
         //- Initialise the calculation of the patch geometry
-        virtual void initGeometry();
+        virtual void initGeometry()
+        {}
 
         //- Calculate mesh points
-        virtual void calcGeometry();
+        virtual void calcGeometry()
+        {}
 
         //- Initialise the patches for moving points
         virtual void initMovePoints(const pointField&)

src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/processor/processorPointPatch.C

@@ -81,284 +81,11 @@ void Foam::processorPointPatch::initGeometry()
             pp.points()
         ).meshPoints();
     }
-
-    if (Pstream::parRun())
-    {
-        initPatchPatchPoints();
-    }
 }
 
 
 void Foam::processorPointPatch::calcGeometry()
-{
+{}
-    if (Pstream::parRun())
-    {
-        calcPatchPatchPoints();
-    }
-
-    // If it is not runing parallel or there are no global points
-    // create a 1->1 map
-    if
-    (
-        !Pstream::parRun()
-     || !boundaryMesh().mesh().globalData().nGlobalPoints()
-    )
-    {
-        nonGlobalPatchPoints_.setSize(meshPoints_.size());
-        forAll(nonGlobalPatchPoints_, i)
-        {
-            nonGlobalPatchPoints_[i] = i;
-        }
-    }
-    else
-    {
-        // Get reference to shared points
-        const labelList& sharedPoints =
-            boundaryMesh().globalPatch().meshPoints();
-
-        nonGlobalPatchPoints_.setSize(meshPoints_.size());
-
-        label noFiltPoints = 0;
-
-        forAll (meshPoints_, pointI)
-        {
-            label curP = meshPoints_[pointI];
-
-            bool found = false;
-
-            forAll (sharedPoints, sharedI)
-            {
-                if (sharedPoints[sharedI] == curP)
-                {
-                    found = true;
-                    break;
-                }
-            }
-
-            if (!found)
-            {
-                nonGlobalPatchPoints_[noFiltPoints] = pointI;
-                meshPoints_[noFiltPoints] = curP;
-                noFiltPoints++;
-            }
-        }
-
-        nonGlobalPatchPoints_.setSize(noFiltPoints);
-        meshPoints_.setSize(noFiltPoints);
-    }
-}
-
-
-void processorPointPatch::initPatchPatchPoints()
-{
-    if (debug)
-    {
-        Info<< "processorPointPatch::calcPatchPatchPoints() : "
-            << "constructing patch-patch points"
-            << endl;
-    }
-
-    const polyBoundaryMesh& bm = boundaryMesh().mesh()().boundaryMesh();
-
-    // Get the mesh points for this patch corresponding to the faces
-    const labelList& ppmp = meshPoints();
-
-    // Create a HashSet of the point labels for this patch
-    Map<label> patchPointSet(2*ppmp.size());
-
-    forAll (ppmp, ppi)
-    {
-        patchPointSet.insert(ppmp[ppi], ppi);
-    }
-
-
-    // Create the lists of patch-patch points
-    labelListList patchPatchPoints(bm.size());
-
-    // Create the lists of patch-patch point normals
-    List<List<vector> > patchPatchPointNormals(bm.size());
-
-    // Loop over all patches looking for other patches that share points
-    forAll(bm, patchi)
-    {
-        if
-        (
-            patchi != index()                 // Ignore self-self
-         && !isA<emptyPolyPatch>(bm[patchi])  // Ignore empty
-         && !bm[patchi].coupled()             // Ignore other couples
-        )
-        {
-            // Get the meshPoints for the other patch
-            const labelList& meshPoints = bm[patchi].meshPoints();
-
-            // Get the normals for the other patch
-            const vectorField& normals = bm[patchi].pointNormals();
-
-            label pppi = 0;
-            forAll(meshPoints, pointi)
-            {
-                label ppp = meshPoints[pointi];
-
-                // Check to see if the point of the other patch is shared with
-                // this patch
-                Map<label>::iterator iter = patchPointSet.find(ppp);
-
-                if (iter != patchPointSet.end())
-                {
-                    // If it is shared initialise the patchPatchPoints for this
-                    // patch
-                    if (!patchPatchPoints[patchi].size())
-                    {
-                        patchPatchPoints[patchi].setSize(ppmp.size());
-                        patchPatchPointNormals[patchi].setSize(ppmp.size());
-                    }
-
-                    // and add the entry
-                    patchPatchPoints[patchi][pppi] = iter();
-                    patchPatchPointNormals[patchi][pppi] = normals[pointi];
-                    pppi++;
-                }
-            }
-
-            // Resise the list of shared points and normals for the patch
-            // being considerd
-            patchPatchPoints[patchi].setSize(pppi);
-            patchPatchPointNormals[patchi].setSize(pppi);
-        }
-    }
-
-    // Send the patchPatchPoints to the neighbouring processor
-
-    OPstream toNeighbProc
-    (
-        Pstream::blocking,
-        neighbProcNo()
-    );
-
-    toNeighbProc
-        << ppmp.size()              // number of points for checking
-        << patchPatchPoints
-        << patchPatchPointNormals;
-
-    if (debug)
-    {
-        Info<< "processorPointPatch::calcPatchPatchPoints() : "
-            << "constructed patch-patch points"
-            << endl;
-    }
-}
-
-
-void Foam::processorPointPatch::calcPatchPatchPoints()
-{
-    // Get the patchPatchPoints from the neighbouring processor
-    IPstream fromNeighbProc
-    (
-        Pstream::blocking,
-        neighbProcNo()
-    );
-
-    label nbrNPoints(readLabel(fromNeighbProc));
-    labelListList patchPatchPoints(fromNeighbProc);
-    List<List<vector> > patchPatchPointNormals(fromNeighbProc);
-
-    pointBoundaryMesh& pbm = const_cast<pointBoundaryMesh&>(boundaryMesh());
-    const labelList& ppmp = meshPoints();
-
-    // Simple check for the very rare situation when not the same number
-    // of points on both sides. This can happen with decomposed cyclics.
-    // If on one side the cyclic shares a point with proc faces coming from
-    // internal faces it will have a different number of points from
-    // the situation where the cyclic and the 'normal' proc faces are fully
-    // separate.
-    if (nbrNPoints != ppmp.size())
-    {
-        WarningIn("processorPointPatch::calcPatchPatchPoints()")
-            << "Processor patch " << name()
-            << " has " << ppmp.size() << " points; coupled patch has "
-            << nbrNPoints << " points." << endl
-            << "   (usually due to decomposed cyclics)."
-            << " This might give problems" << endl
-            << "    when using point fields (interpolation, mesh motion)."
-            << endl;
-    }
-
-
-
-    // Loop over the patches looking for other patches that share points
-    forAll(patchPatchPoints, patchi)
-    {
-        const labelList& patchPoints = patchPatchPoints[patchi];
-        const List<vector>& patchPointNormals = patchPatchPointNormals[patchi];
-
-        // If there are potentially shared points for the patch
-        // being considered
-        if (patchPoints.size())
-        {
-            // Get the current meshPoints list for the patch
-            facePointPatch& fpp = refCast<facePointPatch>(pbm[patchi]);
-            const labelList& fmp = fpp.meshPoints();
-            labelList& mp = fpp.meshPoints_;
-
-            const vectorField& fnormals = fpp.pointNormals();
-            vectorField& normals = fpp.pointNormals_;
-
-            // Create a HashSet of the point labels for the patch
-            Map<label> patchPointSet(2*fmp.size());
-
-            forAll (fmp, ppi)
-            {
-                patchPointSet.insert(fmp[ppi], ppi);
-            }
-
-            label nPoints = mp.size();
-            label lpi = 0;
-            bool resized = false;
-
-            // For each potentially shared point...
-            forAll(patchPoints, ppi)
-            {
-                // Check if it is not already in the patch,
-                // i.e. not part of a face of the patch
-                if (!patchPointSet.found(ppmp[patchPoints[ppi]]))
-                {
-                    // If it isn't already in the patch check if the local
-                    // meshPoints is already set and if not initialise the
-                    // meshPoints_ and pointNormals_
-                    if (!resized)
-                    {
-                        if (!mp.size() && fmp.size())
-                        {
-                            mp = fmp;
-                            normals = fnormals;
-
-                            nPoints = mp.size();
-                        }
-
-                        mp.setSize(nPoints + patchPoints.size());
-                        loneMeshPoints_.setSize(patchPoints.size());
-                        normals.setSize(nPoints + patchPoints.size());
-                        resized = true;
-                    }
-
-                    // Add the new point to the patch
-                    mp[nPoints] = ppmp[patchPoints[ppi]];
-                    loneMeshPoints_[lpi++] = ppmp[patchPoints[ppi]];
-                    normals[nPoints++] = patchPointNormals[ppi];
-                }
-            }
-
-            // If the lists have been resized points have been added.
-            // Shrink the lists to the current size.
-            if (resized)
-            {
-                mp.setSize(nPoints);
-                loneMeshPoints_.setSize(lpi);
-                normals.setSize(nPoints);
-            }
-        }
-    }
-}
 
 
 void processorPointPatch::initUpdateMesh()
@@ -384,7 +111,8 @@ processorPointPatch::processorPointPatch
 )
 :
     coupledFacePointPatch(patch, bm),
-    procPolyPatch_(refCast<const processorPolyPatch>(patch))
+    procPolyPatch_(refCast<const processorPolyPatch>(patch)),
+    meshPoints_()
 {}
 
 
@@ -396,6 +124,12 @@ processorPointPatch::~processorPointPatch()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+const labelList& processorPointPatch::meshPoints() const
+{
+    return meshPoints_;
+}
+
+
 const pointField& processorPointPatch::localPoints() const
 {
     notImplemented("processorPointPatch::localPoints() const");

src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/processor/processorPointPatch.H

@@ -62,8 +62,12 @@ class processorPointPatch
 {
     // Private data
 
+        //- Reference to processor patch
         const processorPolyPatch& procPolyPatch_;
 
+        //- Mesh points.  On slave they will be reversed
+        mutable labelList meshPoints_;
+
 
     // Private Member Functions
 
@@ -174,10 +178,13 @@ public:
 
         // Access functions for demand driven data
 
-            //- Return pointField of points in patch.  Not implemented.
+            //- Return mesh points
+            virtual const labelList& meshPoints() const;
+
+            //- Return pointField of points in patch.  Not implemented
             virtual const pointField& localPoints() const;
 
-            //- Return point unit normals.  Not impelemented.
+            //- Return point unit normals.  Not implemented
             virtual const vectorField& pointNormals() const;
 
             //- Return list of edge indices for edges local to the patch

src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/regionCouple/regionCouplePointPatch.C

@@ -51,34 +51,15 @@ addToRunTimeSelectionTable
 
 // * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
 
-void Foam::regionCouplePointPatch::initGeometry()
-{}
-
-
-void Foam::regionCouplePointPatch::calcGeometry()
-{
-    meshPoints_ = regionCouplePolyPatch_.meshPoints();
-
-    nonGlobalPatchPoints_.setSize(meshPoints_.size());
-
-    forAll(nonGlobalPatchPoints_, i)
-    {
-        nonGlobalPatchPoints_[i] = i;
-    }
-}
-
-
 void Foam::regionCouplePointPatch::initUpdateMesh()
 {
     facePointPatch::initUpdateMesh();
-    regionCouplePointPatch::initGeometry();
 }
 
 
 void Foam::regionCouplePointPatch::updateMesh()
 {
     facePointPatch::updateMesh();
-    regionCouplePointPatch::calcGeometry();
 }
 
 

src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/regionCouple/regionCouplePointPatch.H

@@ -75,10 +75,12 @@ protected:
     // Protected Member Functions
 
         //- Initialise the calculation of the patch geometry
-        virtual void initGeometry();
+        virtual void initGeometry()
+        {}
 
         //- Calculate mesh points
-        virtual void calcGeometry();
+        virtual void calcGeometry()
+        {}
 
         //- Correct patches after moving points
         virtual void movePoints()

src/OpenFOAM/meshes/pointMesh/pointPatches/derived/coupled/coupledFacePointPatch.C

@@ -57,25 +57,6 @@ coupledFacePointPatch::~coupledFacePointPatch()
 {}
 
 
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-const labelList& coupledFacePointPatch::nonGlobalPatchPoints() const
-{
-    return nonGlobalPatchPoints_;
-}
-
-const labelList& coupledFacePointPatch::loneMeshPoints() const
-{
-    return loneMeshPoints_;
-}
-
-const vectorField& coupledFacePointPatch::pointNormals() const
-{
-    notImplemented("coupledFacePointPatch::pointNormals() const");
-    return Field<vector>::null();
-}
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam

src/OpenFOAM/meshes/pointMesh/pointPatches/derived/coupled/coupledFacePointPatch.H

@@ -71,24 +71,6 @@ class coupledFacePointPatch
         void operator=(const coupledFacePointPatch&);
 
 
-protected:
-
-    // Demand driven private data
-
-        //- The set of labels of the pointPatch points which are
-        //  non-global, i.e. present only in this coupledPointPatch.
-        //  MUST be initialised by calcGeometry()!
-        labelList nonGlobalPatchPoints_;
-
-        labelList loneMeshPoints_;
-
-
-        // Construction of demand-driven data
-
-            //- Calculate mesh points
-            virtual void calcGeometry() = 0;
-
-
 public:
 
     //- Runtime type information
@@ -119,21 +101,6 @@ public:
             {
                 return true;
             }
-
-
-        // Access functions for demand driven data
-
-            //- Return the set of labels of the pointPatch points which are
-            //  non-global, i.e. present in this coupledFacePointPatch
-            virtual const labelList& nonGlobalPatchPoints() const;
-
-            //- Return the set of labels of the pointPatch points which are
-            //  lone, i.e. present in this coupledFacePointPatch but not
-            //  associated with any faces
-            virtual const labelList& loneMeshPoints() const;
-
-            //- Return point unit normals.  Not impelemented.
-            virtual const vectorField& pointNormals() const;
 };
 
 

src/OpenFOAM/meshes/pointMesh/pointPatches/facePointPatch/facePointPatch.C

@@ -52,11 +52,7 @@ addToRunTimeSelectionTable
 // * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
 
 void facePointPatch::initGeometry()
-{
+{}
-    meshPoints_.setSize(0);
-    localPoints_.setSize(0);
-    pointNormals_.setSize(0);
-}
 
 
 void facePointPatch::calcGeometry()
@@ -94,60 +90,6 @@ facePointPatch::facePointPatch
 {}
 
 
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-const labelList& facePointPatch::meshPoints() const
-{
-    if (meshPoints_.size())
-    {
-        return meshPoints_;
-    }
-    else
-    {
-        return polyPatch_.meshPoints();
-    }
-}
-
-
-const pointField& facePointPatch::localPoints() const
-{
-    if (meshPoints_.size())
-    {
-        if (localPoints_.size() != meshPoints_.size())
-        {
-            const labelList& meshPts = meshPoints();
-
-            localPoints_.setSize(meshPts.size());
-            const pointField& points = polyPatch_.points();
-
-            forAll (meshPts, pointi)
-            {
-                localPoints_[pointi] = points[meshPts[pointi]];
-            }
-        }
-
-        return localPoints_;
-    }
-    else
-    {
-        return polyPatch_.localPoints();
-    }
-}
-
-
-const vectorField& facePointPatch::pointNormals() const
-{
-    if (pointNormals_.size())
-    {
-        return pointNormals_;
-    }
-    else
-    {
-        return polyPatch_.pointNormals();
-    }
-}
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam

src/OpenFOAM/meshes/pointMesh/pointPatches/facePointPatch/facePointPatch.H

@@ -47,9 +47,6 @@ SourceFiles
 namespace Foam
 {
 
-class processorPointPatch;
-class cyclicPointPatch;
-
 /*---------------------------------------------------------------------------*\
                   Class facePointPatch Declaration
 \*---------------------------------------------------------------------------*/
@@ -58,20 +55,13 @@ class facePointPatch
 :
     public pointPatch
 {
-protected:
+    // Private data
-
-    // Protected data
 
         //- Reference to the underlying polyPatch
         const polyPatch& polyPatch_;
 
-        // Optional data used if the pointPatch has points not associated
-        // with faces, i.e. not accessible via polyPatch
-
-            mutable labelList meshPoints_;
-            mutable pointField localPoints_;
-            mutable vectorField pointNormals_;
 
+protected:
 
     // Protected Member Functions
 
@@ -94,8 +84,6 @@ protected:
         virtual void updateMesh();
 
 
-private:
-
     // Private Member Functions
 
         //- Disallow default bitwise copy construct
@@ -107,10 +95,6 @@ private:
 
 public:
 
-    // Declare friendship with the coupledPointPatches to allow them to extend
-    // the set of points with those not associated with faces
-    friend class processorPointPatch;
-    friend class cyclicPointPatch;
 
 
     //- Runtime type information
@@ -172,7 +156,13 @@ public:
         //- Return size
         virtual label size() const
         {
-            return meshPoints().size();
+            return polyPatch_.nPoints();
+        }
+
+        //- Return number of faces
+        virtual label nFaces() const
+        {
+            return polyPatch_.size();
         }
 
         //- Return the index of this patch in the pointBoundaryMesh
@@ -181,14 +171,27 @@ public:
             return polyPatch_.index();
         }
 
-        //- Return mesh points
-        virtual const labelList& meshPoints() const;
 
-        //- Return pointField of points in patch
+        // Access functions for demand driven data
-        virtual const pointField& localPoints() const;
+
+            //- Return mesh points
+            virtual const labelList& meshPoints() const
+            {
+                return polyPatch_.meshPoints();
+            }
+
+            //- Return pointField of points in patch
+            virtual const pointField& localPoints() const
+            {
+                return polyPatch_.localPoints();
+            }
+
+            //- Return point unit normals
+            virtual const vectorField& pointNormals() const
+            {
+                return polyPatch_.pointNormals();
+            }
 
-        //- Return point unit normals
-        virtual const vectorField& pointNormals() const;
 };