42 void Foam::faMeshDecomposition::distributeFaces()
44 const word& polyMeshRegionName =
mesh().
name();
46 Info<<
"\nCalculating distribution of finiteArea faces" <<
endl;
50 for (label procI = 0; procI <
nProcs(); procI++)
64 processorDb.timeName(),
77 if (hasGlobalFaceZones_)
95 const label ownerSize =
113 for (
int i = 0; i < ownerSize; ++i)
120 if (faceProcAddressingHash.found(
faceLabels()[faceI] + 1))
122 faceToProc_[faceI] = procI;
134 "faceProcAddressing",
146 if (faceProcAddressingHash.found(
faceLabels()[faceI] + 1))
148 faceToProc_[faceI] = procI;
154 Info<<
"\nFinished decomposition in "
155 << decompositionTime.elapsedCpuTime()
165 const label nProcessors,
170 nProcs_(nProcessors),
172 hasGlobalFaceZones_(
false),
173 faceToProc_(nFaces()),
174 procFaceLabels_(nProcs_),
175 procMeshEdgesMap_(nProcs_),
176 procNInternalEdges_(nProcs_,
Zero),
177 procPatchEdgeLabels_(nProcs_),
178 procPatchPointAddressing_(nProcs_),
179 procPatchEdgeAddressing_(nProcs_),
180 procEdgeAddressing_(nProcs_),
181 procFaceAddressing_(nProcs_),
182 procBoundaryAddressing_(nProcs_),
183 procPatchSize_(nProcs_),
184 procPatchStartIndex_(nProcs_),
185 procNeighbourProcessors_(nProcs_),
186 procProcessorPatchSize_(nProcs_),
187 procProcessorPatchStartIndex_(nProcs_),
188 globallySharedPoints_(),
189 cyclicParallel_(
false)
191 updateParameters(params);
203 if (params.
found(
"globalFaceZones"))
205 hasGlobalFaceZones_ =
true;
217 Info<<
"\nDistributing faces to processors" <<
endl;
223 forAll(faceToProc_, facei)
225 const label proci = faceToProc_[facei];
227 if (proci < 0 || proci >= nProcs_)
230 <<
"Invalid processor label " << proci
231 <<
" for face " << facei <<
nl
236 ++nLocalFaces[proci];
241 forAll(nLocalFaces, proci)
243 procFaceAddressing_[proci].resize(nLocalFaces[proci]);
244 nLocalFaces[proci] = 0;
248 forAll(faceToProc_, facei)
250 const label proci = faceToProc_[facei];
251 const label localFacei = nLocalFaces[proci];
252 ++nLocalFaces[proci];
254 procFaceAddressing_[proci][localFacei] = facei;
260 for (label procI = 0; procI < nProcs(); procI++)
266 time().caseName()/(
"processor" +
Foam::name(procI))
283 "pointProcAddressing",
299 "faceProcAddressing",
308 forAll(fvFaceProcAddressing, faceI)
310 fvFaceProcAddressingHash.insert
312 fvFaceProcAddressing[faceI], faceI
317 const labelList& curProcFaceAddressing = procFaceAddressing_[procI];
319 labelList& curFaceLabels = procFaceLabels_[procI];
321 curFaceLabels =
labelList(curProcFaceAddressing.size(), -1);
323 forAll(curProcFaceAddressing, faceI)
325 curFaceLabels[faceI] =
326 fvFaceProcAddressingHash.find
328 faceLabels()[curProcFaceAddressing[faceI]] + 1
336 procFaceLabels_[procI]
344 const label nIntEdges =
patch.nInternalEdges();
346 for (label edgei = 0; edgei < nIntEdges; ++edgei)
354 const label size =
boundary()[patchi].labelList::size();
356 for (label edgei=0; edgei < size; ++edgei)
372 labelList& curPatchPointAddressing = procPatchPointAddressing_[procI];
373 curPatchPointAddressing.
setSize(procPoints.size(), -1);
375 forAll(procPoints, pointI)
377 curPatchPointAddressing[pointI] =
378 map[fvPointProcAddressing[procMeshPoints[pointI]]];
381 labelList& curPatchEdgeAddressing = procPatchEdgeAddressing_[procI];
382 curPatchEdgeAddressing.
resize(procEdges.size(), -1);
384 Map<label>& curMap = procMeshEdgesMap_[procI];
386 curMap.resize(2*procEdges.size());
390 edge curGlobalEdge(curPatchPointAddressing, procEdges[edgeI]);
391 curPatchEdgeAddressing[edgeI] = edgesHash.
find(curGlobalEdge).val();
394 forAll(curPatchEdgeAddressing, edgeI)
396 curMap.insert(curPatchEdgeAddressing[edgeI], edgeI);
403 Info <<
"\nDistributing edges to processors" <<
endl;
410 const edgeList& edges = this->edges();
412 const labelList& neighbour = edgeNeighbour();
418 forAll(procEdgeList, procI)
420 for(label i=0; i<procNInternalEdges_[procI]; i++)
422 procEdgeList[procI].
append(procPatchEdgeAddressing_[procI][i]);
439 if (faceToProc_[owner[edgeI]] != faceToProc_[neighbour[edgeI]])
445 bool interProcBouFound =
false;
447 const label ownProc = faceToProc_[owner[edgeI]];
448 const label neiProc = faceToProc_[neighbour[edgeI]];
450 auto curInterProcBdrsOwnIter =
451 interProcBoundaries[ownProc].cbegin();
453 auto curInterProcBEdgesOwnIter =
454 interProcBEdges[ownProc].begin();
461 curInterProcBdrsOwnIter.good()
462 && curInterProcBEdgesOwnIter.good();
463 ++curInterProcBdrsOwnIter,
464 ++curInterProcBEdgesOwnIter
467 if (curInterProcBdrsOwnIter() == neiProc)
470 interProcBouFound =
true;
472 bool neighbourFound =
false;
474 curInterProcBEdgesOwnIter().
append(edgeI);
476 auto curInterProcBdrsNeiIter =
477 interProcBoundaries[neiProc].cbegin();
479 auto curInterProcBEdgesNeiIter =
480 interProcBEdges[neiProc].begin();
487 curInterProcBdrsNeiIter.good()
488 && curInterProcBEdgesNeiIter.good();
489 ++curInterProcBdrsNeiIter,
490 ++curInterProcBEdgesNeiIter
493 if (curInterProcBdrsNeiIter() == ownProc)
496 neighbourFound =
true;
498 curInterProcBEdgesNeiIter().
append(edgeI);
501 if (neighbourFound)
break;
504 if (interProcBouFound && !neighbourFound)
507 (
"faDomainDecomposition::decomposeMesh()")
508 <<
"Inconsistency in inter - "
509 <<
"processor boundary lists for processors "
510 << ownProc <<
" and " << neiProc
515 if (interProcBouFound)
break;
518 if (!interProcBouFound)
526 interProcBoundaries[ownProc].
append(neiProc);
530 interProcBoundaries[neiProc].
append(ownProc);
531 interProcBEdges[neiProc]
547 forAll(procPatchSize_, procI)
549 procPatchSize_[procI].setSize(
patches.size());
550 procPatchStartIndex_[procI].setSize(
patches.size());
556 forAll(procPatchSize_, procI)
558 procPatchSize_[procI][patchI] = 0;
559 procPatchStartIndex_[procI][patchI] =
560 procEdgeList[procI].size();
573 const label size =
patches[patchI].labelList::size();
577 for(
int eI=0; eI<size; eI++)
579 patchEdgeFaces[eI] = eF[
patches[patchI][eI]][0];
582 forAll(patchEdgeFaces, edgeI)
584 const label curProc = faceToProc_[patchEdgeFaces[edgeI]];
587 procEdgeList[curProc].
append(patchStart + edgeI);
590 procPatchSize_[curProc][patchI]++;
599 const label cycOffset = cPatch.
size()/2;
615 forAll(firstEdgeFaces, edgeI)
619 faceToProc_[firstEdgeFaces[edgeI]]
620 != faceToProc_[secondEdgeFaces[edgeI]]
629 cyclicParallel_ =
true;
631 bool interProcBouFound =
false;
633 const label ownProc =
634 faceToProc_[firstEdgeFaces[edgeI]];
635 const label neiProc =
636 faceToProc_[secondEdgeFaces[edgeI]];
638 auto curInterProcBdrsOwnIter =
639 interProcBoundaries[ownProc].cbegin();
641 auto curInterProcBEdgesOwnIter =
642 interProcBEdges[ownProc].begin();
649 curInterProcBdrsOwnIter.good()
650 && curInterProcBEdgesOwnIter.good();
651 ++curInterProcBdrsOwnIter,
652 ++curInterProcBEdgesOwnIter
655 if (curInterProcBdrsOwnIter() == neiProc)
659 interProcBouFound =
true;
661 bool neighbourFound =
false;
663 curInterProcBEdgesOwnIter()
664 .
append(patchStart + edgeI);
666 auto curInterProcBdrsNeiIter
667 = interProcBoundaries[neiProc].cbegin();
669 auto curInterProcBEdgesNeiIter =
670 interProcBEdges[neiProc].begin();
677 curInterProcBdrsNeiIter.good()
678 && curInterProcBEdgesNeiIter.good();
679 ++curInterProcBdrsNeiIter,
680 ++curInterProcBEdgesNeiIter
683 if (curInterProcBdrsNeiIter() == ownProc)
686 neighbourFound =
true;
688 curInterProcBEdgesNeiIter()
697 if (neighbourFound)
break;
700 if (interProcBouFound && !neighbourFound)
704 "faDomainDecomposition::decomposeMesh()"
705 ) <<
"Inconsistency in inter-processor "
706 <<
"boundary lists for processors "
707 << ownProc <<
" and " << neiProc
708 <<
" in cyclic boundary matching"
713 if (interProcBouFound)
break;
716 if (!interProcBouFound)
724 interProcBoundaries[ownProc].
append(neiProc);
725 interProcBEdges[ownProc]
729 interProcBoundaries[neiProc].
append(ownProc);
730 interProcBEdges[neiProc]
745 label ownProc = faceToProc_[firstEdgeFaces[edgeI]];
748 procEdgeList[ownProc].
append(patchStart + edgeI);
751 procPatchSize_[ownProc][patchI]++;
762 forAll(secondEdgeFaces, edgeI)
766 faceToProc_[firstEdgeFaces[edgeI]]
767 == faceToProc_[secondEdgeFaces[edgeI]]
771 label ownProc = faceToProc_[firstEdgeFaces[edgeI]];
774 procEdgeList[ownProc].
append
775 (patchStart + cycOffset + edgeI);
778 procPatchSize_[ownProc][patchI]++;
786 forAll(procEdgeList, procI)
792 labelList& curProcEdgeAddressing = procEdgeAddressing_[procI];
795 procNeighbourProcessors_[procI];
798 procProcessorPatchSize_[procI];
800 labelList& curProcProcessorPatchStartIndex =
801 procProcessorPatchStartIndex_[procI];
804 label nEdgesOnProcessor = curProcEdges.size();
806 for (
const auto& bedges : interProcBEdges[procI])
808 nEdgesOnProcessor += bedges.size();
811 curProcEdgeAddressing.
setSize(nEdgesOnProcessor);
824 for (
const label procEdgei : curProcEdges)
826 curProcEdgeAddressing[nEdges] = procEdgei;
834 curProcNeighbourProcessors.
setSize
836 interProcBoundaries[procI].size()
839 curProcProcessorPatchSize.
setSize
841 interProcBoundaries[procI].size()
844 curProcProcessorPatchStartIndex.
setSize
846 interProcBoundaries[procI].size()
851 auto curInterProcBdrsIter =
852 interProcBoundaries[procI].cbegin();
854 auto curInterProcBEdgesIter =
855 interProcBEdges[procI].cbegin();
860 curInterProcBdrsIter.good()
861 && curInterProcBEdgesIter.good();
862 ++curInterProcBdrsIter,
863 ++curInterProcBEdgesIter
867 curInterProcBdrsIter();
879 for (
const label edgei : *curInterProcBEdgesIter)
885 if (faceToProc_[owner[edgei]] == procI)
887 curProcEdgeAddressing[nEdges] = edgei;
893 curProcEdgeAddressing[nEdges] = edgei;
908 Info <<
"\nCalculating processor boundary addressing" <<
endl;
914 forAll(procPatchSize_, procI)
917 const labelList oldPatchSizes = procPatchSize_[procI];
919 const labelList oldPatchStarts = procPatchStartIndex_[procI];
921 labelList& curPatchSizes = procPatchSize_[procI];
923 labelList& curPatchStarts = procPatchStartIndex_[procI];
925 const labelList& curProcessorPatchSizes =
926 procProcessorPatchSize_[procI];
928 labelList& curBoundaryAddressing = procBoundaryAddressing_[procI];
933 + curProcessorPatchSizes.size()
938 forAll(oldPatchSizes, patchI)
944 curBoundaryAddressing[
nPatches] = patchI;
946 curPatchSizes[
nPatches] = oldPatchSizes[patchI];
948 curPatchStarts[
nPatches] = oldPatchStarts[patchI];
958 forAll(curProcessorPatchSizes, procPatchI)
960 curBoundaryAddressing[
nPatches] = -1;
988 for (label procI = 0; procI < nProcs(); procI++)
991 const labelList& curEdgeLabels = procEdgeAddressing_[procI];
994 const labelList& curProcessorPatchStarts =
995 procProcessorPatchStartIndex_[procI];
997 const labelList& curProcessorPatchSizes =
998 procProcessorPatchSize_[procI];
1003 forAll(curProcessorPatchStarts, patchI)
1005 const label curStart = curProcessorPatchStarts[patchI];
1006 const label curEnd = curStart + curProcessorPatchSizes[patchI];
1010 label edgeI = curStart;
1017 const label curE = curEdgeLabels[edgeI];
1019 const edge&
e = edges[curE];
1023 if (pointsUsage[
e[pointI]] == 0)
1026 pointsUsage[
e[pointI]] = patchI + 1;
1028 else if (pointsUsage[
e[pointI]] != patchI + 1)
1031 gSharedPoints.
insert(
e[pointI]);
1039 globallySharedPoints_ = gSharedPoints.sortedToc();
1045 for (label procI = 0; procI < nProcs(); procI++)
1049 time().caseName()/(
"processor" +
Foam::name(procI))
1076 procFaceLabels_[procI]
1080 const labelList& curEdgeAddressing = procEdgeAddressing_[procI];
1082 const labelList& curPatchStartIndex = procPatchStartIndex_[procI];
1083 const labelList& curPatchSize = procPatchSize_[procI];
1085 const labelList& curProcessorPatchStartIndex =
1086 procProcessorPatchStartIndex_[procI];
1088 const labelList& curProcessorPatchSize =
1089 procProcessorPatchSize_[procI];
1091 labelListList& curPatchEdgeLabels = procPatchEdgeLabels_[procI];
1092 curPatchEdgeLabels.
resize
1095 + curProcessorPatchSize.size()
1098 forAll(curPatchSize, patchI)
1100 labelList& curEdgeLabels = curPatchEdgeLabels[patchI];
1101 curEdgeLabels.
setSize(curPatchSize[patchI], -1);
1107 int i=curPatchStartIndex[patchI];
1108 i<(curPatchStartIndex[patchI]+curPatchSize[patchI]);
1112 curEdgeLabels[edgeI] =
1113 procMeshEdgesMap_[procI][curEdgeAddressing[i]];
1118 forAll(curProcessorPatchSize, patchI)
1121 curPatchEdgeLabels[curPatchSize.size() + patchI];
1122 curEdgeLabels.
setSize(curProcessorPatchSize[patchI], -1);
1128 int i=curProcessorPatchStartIndex[patchI];
1129 i<(curProcessorPatchStartIndex[patchI]
1130 +curProcessorPatchSize[patchI]);
1134 curEdgeLabels[edgeI] =
1135 procMeshEdgesMap_[procI][curEdgeAddressing[i]];
1147 Info<<
"\nConstructing processor FA meshes" <<
endl;
1150 Map<label> sharedPointLookup(2*globallySharedPoints_.size());
1152 forAll(globallySharedPoints_, pointi)
1154 sharedPointLookup.insert(globallySharedPoints_[pointi], pointi);
1157 label totProcEdges = 0;
1158 label maxProcPatches = 0;
1159 label maxProcEdges = 0;
1162 for (label procI = 0; procI < nProcs(); procI++)
1168 time().caseName()/(
"processor" +
Foam::name(procI))
1194 "boundaryProcAddressing",
1208 procFaceLabels_[procI]
1212 const labelList& curBoundaryAddressing =
1213 procBoundaryAddressing_[procI];
1215 const labelList& curPatchSizes = procPatchSize_[procI];
1217 const labelList& curNeighbourProcessors =
1218 procNeighbourProcessors_[procI];
1220 const labelList& curProcessorPatchSizes =
1221 procProcessorPatchSize_[procI];
1224 procPatchEdgeLabels_[procI];
1230 curPatchSizes.size() + curProcessorPatchSizes.size()
1235 forAll(curPatchSizes, patchi)
1239 const label neiPolyPatchId =
1240 fvBoundaryProcAddressing.find
1242 meshPatches[curBoundaryAddressing[patchi]]
1243 .ngbPolyPatchIndex()
1249 meshPatches[curBoundaryAddressing[patchi]].clone
1260 forAll(curProcessorPatchSizes, procPatchI)
1272 curNeighbourProcessors[procPatchI]
1279 curNeighbourProcessors[procPatchI]
1295 <<
"Processor " << procI <<
nl
1296 <<
" Number of faces = " << procMesh.
nFaces()
1299 label nBoundaryEdges = 0;
1301 label nProcEdges = 0;
1306 isA<processorFaPatch>(procMesh.
boundary()[patchi]);
1310 const auto& procPatch = *ppp;
1312 Info<<
" Number of edges shared with processor "
1313 << procPatch.neighbProcNo() <<
" = "
1314 << procPatch.size() <<
endl;
1316 nProcEdges += procPatch.size();
1321 nBoundaryEdges += procMesh.
boundary()[patchi].size();
1326 <<
" Number of processor edges = " << nProcEdges <<
nl
1327 <<
" Number of boundary edges = " << nBoundaryEdges <<
endl;
1329 totProcEdges += nProcEdges;
1331 maxProcEdges =
max(maxProcEdges, nProcEdges);
1338 "pointProcAddressing",
1345 procPatchPointAddressing_[procI]
1347 pointProcAddressing.
write();
1353 "edgeProcAddressing",
1360 procEdgeAddressing_[procI]
1362 edgeProcAddressing.
write();
1368 "faceProcAddressing",
1375 procFaceAddressing_[procI]
1383 "boundaryProcAddressing",
1390 procBoundaryAddressing_[procI]
1392 boundaryProcAddressing.
write();
1396 <<
"Number of processor edges = " << totProcEdges/2 <<
nl
1397 <<
"Max number of processor patches = " << maxProcPatches <<
nl
1398 <<
"Max number of faces between processors = " << maxProcEdges