zhyang-dev/OpenFOAM-12
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

processorPolyPatch, processorCyclicPolyPatch: Rationalized the construction of the patch name

Browse Source 
This change ensures that these patches are named consistently so that
they can be looked-up as required in e.g. patchMeanVelocityForce
This commit is contained in:
Henry Weller
2016-02-02 20:07:16 +00:00
parent fd6aed1b6c
commit 644d51b466
13 changed files with 139 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
applications/utilities/mesh/generation/extrude/extrudeMesh/extrudeMesh.C
View File

@ -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

12
applications/utilities/mesh/generation/extrude/extrudeToRegionMesh/extrudeToRegionMesh.C
View File

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

5
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshCalcDualMesh.C
View File

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

1
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshIO.C
View File

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

49
applications/utilities/parallelProcessing/decomposePar/domainDecomposition.C
View File

@ -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()
+ nInterProcPatches, //curProcessorPatchSizes.size(),
curPatchSizes.size() + nInterProcPatches,
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);

7
applications/utilities/parallelProcessing/reconstructParMesh/reconstructParMesh.C
View File

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

46
src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.C
View File

@ -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())

30
src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.H
View File

@ -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
{

32
src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.C
View File

@ -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)

21
src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.H
View File

@ -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
{

24
src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C
View File

@ -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()
);

8
src/fvOptions/sources/derived/meanVelocityForce/patchMeanVelocityForce/patchMeanVelocityForce.C
View File

@ -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)

14
src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.C
View File

@ -1018,11 +1018,10 @@ void Foam::autoLayerDriver::determineSidePatches
for (label patchI = nOldPatches; patchI < nPatches; patchI++)
{
label nbrProcI = patchToNbrProc[patchI];
word name =
"procBoundary"
+ Foam::name(Pstream::myProcNo())
+ "to"
+ Foam::name(nbrProcI);
word name
(
processorPolyPatch::newName(Pstream::myProcNo(), 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,