processorPolyPatch, processorCyclicPolyPatch: Rationalized the construction of the patch name

This change ensures that these patches are named consistently so that
they can be looked-up as required in e.g. patchMeanVelocityForce

applications/utilities/mesh/generation/extrude/extrudeMesh/extrudeMesh.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -540,24 +540,15 @@ int main(int argc, char *argv[])
             {
                 label nbrProcI = patchToNbrProc[patchI];
 
-                word name =
-                        "procBoundary"
-                      + Foam::name(Pstream::myProcNo())
-                      + "to"
-                      + Foam::name(nbrProcI);
-
                 Pout<< "Adding patch " << patchI
-                    << " name:" << name
                     << " between " << Pstream::myProcNo()
                     << " and " << nbrProcI
                     << endl;
 
-
                 newPatches.append
                 (
                     new processorPolyPatch
                     (
-                        name,
                         0,                  // size
                         mesh.nFaces(),      // start
                         patchI,             // index

applications/utilities/mesh/generation/extrude/extrudeToRegionMesh/extrudeToRegionMesh.C

@@ -955,13 +955,11 @@ void addCoupledPatches
             }
             else
             {
-                // Rrocessor patch
+                // Processor patch
-
+                word name
-                word name =
+                (
-                    "procBoundary"
+                    processorPolyPatch::newName(Pstream::myProcNo(), nbrProcI)
-                  + Foam::name(Pstream::myProcNo())
+                );
-                  + "to"
-                  + Foam::name(nbrProcI);
 
                 sidePatchID[edgeI] = findPatchID(newPatches, name);
 

applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshCalcDualMesh.C

@@ -1631,10 +1631,7 @@ Foam::label Foam::conformalVoronoiMesh::createPatchInfo
             if (procUsed[pUI])
             {
                 patchNames[nNonProcPatches + procAddI] =
-                    "procBoundary"
+                    processorPolyPatch::newName(Pstream::myProcNo(), pUI);
-                   + name(Pstream::myProcNo())
-                   + "to"
-                   + name(pUI);
 
                 patchDicts[nNonProcPatches + procAddI].set
                 (

applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshIO.C

@@ -432,7 +432,6 @@ Foam::autoPtr<Foam::fvMesh> Foam::conformalVoronoiMesh::createDummyMesh
         {
             patches[patchI] = new processorPolyPatch
             (
-                patchNames[patchI],
                 0,          //patchSizes[p],
                 0,          //patchStarts[p],
                 patchI,

applications/utilities/parallelProcessing/decomposePar/domainDecomposition.C

@@ -444,29 +444,12 @@ bool Foam::domainDecomposition::writeDecomposition(const bool decomposeSets)
         label nInterProcPatches = 0;
         forAll(curSubPatchIDs, procPatchI)
         {
-            //Info<< "For processor " << procI
-            //    << " have to destination processor "
-            //    << curNeighbourProcessors[procPatchI] << endl;
-            //
-            //forAll(curSubPatchIDs[procPatchI], i)
-            //{
-            //    Info<< "    from patch:" << curSubPatchIDs[procPatchI][i]
-            //        << " starting at:" << curSubStarts[procPatchI][i]
-            //        << endl;
-            //}
-
             nInterProcPatches += curSubPatchIDs[procPatchI].size();
         }
 
-        //Info<< "For processor " << procI
-        //    << " have " << nInterProcPatches
-        //    << " patches to neighbouring processors" << endl;
-
-
         List<polyPatch*> procPatches
         (
-            curPatchSizes.size()
+            curPatchSizes.size() + nInterProcPatches,
-          + nInterProcPatches,          //curProcessorPatchSizes.size(),
             reinterpret_cast<polyPatch*>(0)
         );
 
@@ -517,22 +500,12 @@ bool Foam::domainDecomposition::writeDecomposition(const bool decomposeSets)
                   : curProcessorPatchSizes[procPatchI] - subStarts[i]
                 );
 
-//                Info<< "From processor:" << procI << endl
-//                    << "  to processor:" << curNeighbourProcessors[procPatchI]
-//                    << endl
-//                    << "    via patch:" << subPatchID[i] << endl
-//                    << "    start    :" << curStart << endl
-//                    << "    size     :" << size << endl;
-
                 if (subPatchID[i] == -1)
                 {
                     // From internal faces
                     procPatches[nPatches] =
                         new processorPolyPatch
                         (
-                            word("procBoundary") + Foam::name(procI)
-                          + "to"
-                          + Foam::name(curNeighbourProcessors[procPatchI]),
                             size,
                             curStart,
                             nPatches,
@@ -549,24 +522,16 @@ bool Foam::domainDecomposition::writeDecomposition(const bool decomposeSets)
                               boundaryMesh()[subPatchID[i]]
                           );
 
-                    // From cyclic
-                    const word& referPatch = pcPatch.name();
-
                     procPatches[nPatches] =
                         new processorCyclicPolyPatch
                         (
-                            word("procBoundary") + Foam::name(procI)
-                          + "to"
-                          + Foam::name(curNeighbourProcessors[procPatchI])
-                          + "through"
-                          + referPatch,
                             size,
                             curStart,
                             nPatches,
                             procMesh.boundaryMesh(),
                             procI,
                             curNeighbourProcessors[procPatchI],
-                            referPatch,
+                            pcPatch.name(),
                             pcPatch.transform()
                         );
                 }
@@ -577,16 +542,6 @@ bool Foam::domainDecomposition::writeDecomposition(const bool decomposeSets)
             }
         }
 
-
-        //forAll(procPatches, patchI)
-        //{
-        //    Pout<< "    " << patchI
-        //        << '\t' << "name:" << procPatches[patchI]->name()
-        //        << '\t' << "type:" << procPatches[patchI]->type()
-        //        << '\t' << "size:" << procPatches[patchI]->size()
-        //        << endl;
-        //}
-
         // Add boundary patches
         procMesh.addPatches(procPatches);
 

applications/utilities/parallelProcessing/reconstructParMesh/reconstructParMesh.C

@@ -161,12 +161,9 @@ autoPtr<faceCoupleInfo> determineCoupledFaces
 
                 for (label mergedProcI = 0; mergedProcI < procI; mergedProcI++)
                 {
-                    const string fromProcString
+                    const word fromProcString
                     (
-                        "procBoundary"
+                        processorPolyPatch::newName(procI, mergedProcI)
-                      + name(procI)
-                      + "to"
-                      + name(mergedProcI)
                     );
 
                     if (pp.name() == fromProcString)

src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -69,6 +69,36 @@ Foam::processorPolyPatch::processorPolyPatch
 {}
 
 
+Foam::processorPolyPatch::processorPolyPatch
+(
+    const label size,
+    const label start,
+    const label index,
+    const polyBoundaryMesh& bm,
+    const int myProcNo,
+    const int neighbProcNo,
+    const transformType transform,
+    const word& patchType
+)
+:
+    coupledPolyPatch
+    (
+        newName(myProcNo, neighbProcNo),
+        size,
+        start,
+        index,
+        bm,
+        patchType,
+        transform
+    ),
+    myProcNo_(myProcNo),
+    neighbProcNo_(neighbProcNo),
+    neighbFaceCentres_(),
+    neighbFaceAreas_(),
+    neighbFaceCellCentres_()
+{}
+
+
 Foam::processorPolyPatch::processorPolyPatch
 (
     const word& name,
@@ -149,6 +179,20 @@ Foam::processorPolyPatch::~processorPolyPatch()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+Foam::word Foam::processorPolyPatch::newName
+(
+    const label myProcNo,
+    const label neighbProcNo
+)
+{
+    return
+        "procBoundary"
+      + Foam::name(myProcNo)
+      + "to"
+      + Foam::name(neighbProcNo);
+}
+
+
 void Foam::processorPolyPatch::initGeometry(PstreamBuffers& pBufs)
 {
     if (Pstream::parRun())

src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -81,6 +81,23 @@ class processorPolyPatch
 
 protected:
 
+    // Protected constructors
+
+        //- Construct from components with specified name
+        processorPolyPatch
+        (
+            const word& name,
+            const label size,
+            const label start,
+            const label index,
+            const polyBoundaryMesh& bm,
+            const int myProcNo,
+            const int neighbProcNo,
+            const transformType transform = UNKNOWN,  // transformation type
+            const word& patchType = typeName
+        );
+
+
     // Protected Member functions
 
         //- Initialise the calculation of the patch geometry
@@ -126,10 +143,9 @@ public:
 
     // Constructors
 
-        //- Construct from components
+        //- Construct from components with automatically generated standard name
         processorPolyPatch
         (
-            const word& name,
             const label size,
             const label start,
             const label index,
@@ -270,6 +286,14 @@ public:
             return !owner();
         }
 
+        //- Return the name of a processorPolyPatch
+        //  constructed from the processor IDs
+        static word newName
+        (
+            const label myProcNo,
+            const label neighbProcNo
+        );
+
         //- Return processor-neighbbour patch face centres
         const vectorField& neighbFaceCentres() const
         {

src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -41,7 +41,6 @@ namespace Foam
 
 Foam::processorCyclicPolyPatch::processorCyclicPolyPatch
 (
-    const word& name,
     const label size,
     const label start,
     const label index,
@@ -55,7 +54,7 @@ Foam::processorCyclicPolyPatch::processorCyclicPolyPatch
 :
     processorPolyPatch
     (
-        name,
+        newName(referPatchName, myProcNo, neighbProcNo),
         size,
         start,
         index,
@@ -157,6 +156,33 @@ Foam::processorCyclicPolyPatch::~processorCyclicPolyPatch()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+Foam::word Foam::processorCyclicPolyPatch::newName
+(
+    const word& cyclicPolyPatchName,
+    const label myProcNo,
+    const label neighbProcNo
+)
+{
+    return
+        processorPolyPatch::newName(myProcNo, neighbProcNo)
+      + "through"
+      + cyclicPolyPatchName;
+}
+
+
+Foam::labelList Foam::processorCyclicPolyPatch::patchIDs
+(
+    const word& cyclicPolyPatchName,
+    const polyBoundaryMesh& bm
+)
+{
+    return bm.findIndices
+    (
+        string("procBoundary.*to.*through" + cyclicPolyPatchName)
+    );
+}
+
+
 int Foam::processorCyclicPolyPatch::tag() const
 {
     if (tag_ == -1)

src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -114,7 +114,6 @@ public:
         //- Construct from components
         processorCyclicPolyPatch
         (
-            const word& name,
             const label size,
             const label start,
             const label index,
@@ -261,11 +260,29 @@ public:
 
     // Member functions
 
+        //- Return name of originating cyclicPolyPatch patch
         const word& referPatchName() const
         {
             return referPatchName_;
         }
 
+        //- Return the name of a processorCyclicPolyPatch
+        //  constructed from cyclicPolyPatch name and the processor IDs
+        static word newName
+        (
+            const word& cyclicPolyPatchName,
+            const label myProcNo,
+            const label neighbProcNo
+        );
+
+        //- Return the indices of a processorCyclicPolyPatchs
+        //  constructed from the given cyclicPolyPatch
+        static labelList patchIDs
+        (
+            const word& cyclicPolyPatchName,
+            const polyBoundaryMesh& bm
+        );
+
         //- Referring patchID.
         label referPatchID() const
         {

src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C

@@ -45,7 +45,7 @@ License
 
 namespace Foam
 {
-defineTypeNameAndDebug(fvMeshDistribute, 0);
+    defineTypeNameAndDebug(fvMeshDistribute, 0);
 }
 
 
@@ -929,16 +929,8 @@ void Foam::fvMeshDistribute::addProcPatches
                 if (referPatchID[bFaceI] == -1)
                 {
                     // Ordinary processor boundary
-
-                    const word patchName =
-                        "procBoundary"
-                      + name(Pstream::myProcNo())
-                      + "to"
-                      + name(procI);
-
                     processorPolyPatch pp
                     (
-                        patchName,
                         0,              // size
                         mesh_.nFaces(),
                         mesh_.boundaryMesh().size(),
@@ -968,27 +960,15 @@ void Foam::fvMeshDistribute::addProcPatches
                               mesh_.boundaryMesh()[referPatchID[bFaceI]]
                           );
 
-                    // Processor boundary originating from cyclic
-                    const word& cycName = pcPatch.name();
-
-                    const word patchName =
-                        "procBoundary"
-                      + name(Pstream::myProcNo())
-                      + "to"
-                      + name(procI)
-                      + "through"
-                      + cycName;
-
                     processorCyclicPolyPatch pp
                     (
-                        patchName,
                         0,              // size
                         mesh_.nFaces(),
                         mesh_.boundaryMesh().size(),
                         mesh_.boundaryMesh(),
                         Pstream::myProcNo(),
                         nbrProc[bFaceI],
-                        cycName,
+                        pcPatch.name(),
                         pcPatch.transform()
                     );
 

src/fvOptions/sources/derived/meanVelocityForce/patchMeanVelocityForce/patchMeanVelocityForce.C

@@ -24,6 +24,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "patchMeanVelocityForce.H"
+#include "processorCyclicPolyPatch.H"
 #include "addToRunTimeSelectionTable.H"
 
 // * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
@@ -92,14 +93,9 @@ Foam::scalar Foam::fv::patchMeanVelocityForce::magUbarAve
 
     if (Pstream::parRun() && isA<cyclicPolyPatch>(patches[patchi_]))
     {
-        const keyType processorCyclicPatchNames
-        (
-            string("procBoundary.*to.*through" + patch_)
-        );
-
         labelList processorCyclicPatches
         (
-            patches.findIndices(processorCyclicPatchNames)
+            processorCyclicPolyPatch::patchIDs(patch_, patches)
         );
 
         forAll(processorCyclicPatches, pcpi)

src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.C

@@ -1018,11 +1018,10 @@ void Foam::autoLayerDriver::determineSidePatches
         for (label patchI = nOldPatches; patchI < nPatches; patchI++)
         {
             label nbrProcI = patchToNbrProc[patchI];
-            word name =
+            word name
-                    "procBoundary"
+            (
-                  + Foam::name(Pstream::myProcNo())
+                processorPolyPatch::newName(Pstream::myProcNo(), nbrProcI)
-                  + "to"
+            );
-                  + Foam::name(nbrProcI);
 
             dictionary patchDict;
             patchDict.add("type", processorPolyPatch::typeName);
@@ -1031,11 +1030,6 @@ void Foam::autoLayerDriver::determineSidePatches
             patchDict.add("nFaces", 0);
             patchDict.add("startFace", mesh.nFaces());
 
-            //Pout<< "Adding patch " << patchI
-            //    << " name:" << name
-            //    << " between " << Pstream::myProcNo()
-            //    << " and " << nbrProcI << endl;
-
             label procPatchI = meshRefiner_.appendPatch
             (
                 mesh,