43 void Foam::faMeshDecomposition::distributeFaces()
45 const word& polyMeshRegionName =
mesh().
name();
47 Info<<
"\nCalculating distribution of finiteArea faces" <<
endl;
51 for (label proci = 0; proci <
nProcs(); ++proci)
67 processorDb.timeName(),
85 ioAddr.rename(
"faceProcAddressing");
88 labelHashSet faceProcAddressingHash(2*fvFaceProcAddressing.size());
98 if (hasGlobalFaceZones_)
101 ioAddr.rename(
"owner");
104 for (
int i = 0; i < ownerSize; ++i)
106 faceProcAddressingHash.insert(fvFaceProcAddressing[i]);
111 faceProcAddressingHash.insert
113 static_cast<labelList&>(fvFaceProcAddressing)
120 const label index = (
faceLabels()[facei] + 1);
122 if (faceProcAddressingHash.found(index))
124 faceToProc_[facei] = proci;
129 Info<<
"\nFinished decomposition in " 130 << decompositionTime.elapsedCpuTime()
140 const label nProcessors,
145 nProcs_(nProcessors),
147 hasGlobalFaceZones_(false),
148 faceToProc_(nFaces()),
149 procFaceLabels_(nProcs_),
150 procMeshEdgesMap_(nProcs_),
151 procNInternalEdges_(nProcs_,
Zero),
152 procPatchEdgeLabels_(nProcs_),
153 procPatchPointAddressing_(nProcs_),
154 procPatchEdgeAddressing_(nProcs_),
155 procEdgeAddressing_(nProcs_),
156 procFaceAddressing_(nProcs_),
157 procBoundaryAddressing_(nProcs_),
158 procPatchSize_(nProcs_),
159 procPatchStartIndex_(nProcs_),
160 procNeighbourProcessors_(nProcs_),
161 procProcessorPatchSize_(nProcs_),
162 procProcessorPatchStartIndex_(nProcs_),
163 globallySharedPoints_(),
164 cyclicParallel_(false)
178 if (params.
found(
"globalFaceZones"))
180 hasGlobalFaceZones_ =
true;
190 const word& polyMeshRegionName =
mesh().
name();
192 Info<<
"\nDistributing faces to processors" <<
endl;
198 forAll(faceToProc_, facei)
200 const label proci = faceToProc_[facei];
202 if (proci < 0 || proci >= nProcs_)
205 <<
"Invalid processor label " << proci
206 <<
" for face " << facei <<
nl 211 ++nLocalFaces[proci];
216 forAll(nLocalFaces, proci)
218 procFaceAddressing_[proci].resize(nLocalFaces[proci]);
219 nLocalFaces[proci] = 0;
223 forAll(faceToProc_, facei)
225 const label proci = faceToProc_[facei];
226 const label localFacei = nLocalFaces[proci];
227 ++nLocalFaces[proci];
229 procFaceAddressing_[proci][localFacei] = facei;
235 for (label procI = 0; procI < nProcs(); procI++)
241 time().caseName()/(
"processor" +
Foam::name(procI)),
251 processorDb.timeName(),
269 ioAddr.rename(
"pointProcAddressing");
272 Map<label> fvFaceProcAddressingHash;
276 ioAddr.rename(
"faceProcAddressing");
279 fvFaceProcAddressingHash =
invertToMap(fvFaceProcAddressing);
283 const labelList& curProcFaceAddressing = procFaceAddressing_[procI];
285 labelList& curFaceLabels = procFaceLabels_[procI];
287 curFaceLabels =
labelList(curProcFaceAddressing.size(), -1);
289 forAll(curProcFaceAddressing, faceI)
291 curFaceLabels[faceI] =
292 fvFaceProcAddressingHash.find
294 faceLabels()[curProcFaceAddressing[faceI]] + 1
306 const Map<label>& map =
patch.meshPointMap();
308 EdgeMap<label> edgesHash;
310 const label nIntEdges =
patch.nInternalEdges();
312 for (label edgei = 0; edgei < nIntEdges; ++edgei)
314 edgesHash.insert(
patch.edges()[edgei], edgesHash.size());
320 const label size =
boundary()[patchi].labelList::size();
322 for (label edgei=0; edgei < size; ++edgei)
334 const labelList& procMeshPoints = procPatch.meshPoints();
335 const edgeList& procEdges = procPatch.edges();
337 labelList& curPatchPointAddressing = procPatchPointAddressing_[procI];
338 curPatchPointAddressing.
resize(procMeshPoints.size(), -1);
340 forAll(procMeshPoints, pointi)
342 curPatchPointAddressing[pointi] =
343 map[fvPointProcAddressing[procMeshPoints[pointi]]];
346 labelList& curPatchEdgeAddressing = procPatchEdgeAddressing_[procI];
347 curPatchEdgeAddressing.
resize(procEdges.size(), -1);
349 Map<label>& curMap = procMeshEdgesMap_[procI];
351 curMap.reserve(procEdges.size());
355 edge curGlobalEdge(curPatchPointAddressing, procEdges[edgeI]);
356 curPatchEdgeAddressing[edgeI] = edgesHash.find(curGlobalEdge).val();
359 forAll(curPatchEdgeAddressing, edgeI)
361 curMap.insert(curPatchEdgeAddressing[edgeI], edgeI);
364 procNInternalEdges_[procI] = procPatch.nInternalEdges();
368 Info <<
"\nDistributing edges to processors" <<
endl;
375 const edgeList& edges = this->edges();
377 const labelList& neighbour = edgeNeighbour();
381 List<SLList<label>> procEdgeList(nProcs());
383 forAll(procEdgeList, procI)
385 for(label i=0; i<procNInternalEdges_[procI]; i++)
387 procEdgeList[procI].append(procPatchEdgeAddressing_[procI][i]);
395 List<SLList<label>> interProcBoundaries(nProcs());
398 List<SLList<SLList<label>>> interProcBEdges(nProcs());
400 List<SLList<label>> procPatchIndex(nProcs());
404 if (faceToProc_[owner[edgeI]] != faceToProc_[neighbour[edgeI]])
410 bool interProcBouFound =
false;
412 const label ownProc = faceToProc_[owner[edgeI]];
413 const label neiProc = faceToProc_[neighbour[edgeI]];
415 auto curInterProcBdrsOwnIter =
416 interProcBoundaries[ownProc].cbegin();
418 auto curInterProcBEdgesOwnIter =
419 interProcBEdges[ownProc].begin();
426 curInterProcBdrsOwnIter.good()
427 && curInterProcBEdgesOwnIter.good();
428 ++curInterProcBdrsOwnIter,
429 ++curInterProcBEdgesOwnIter
432 if (curInterProcBdrsOwnIter() == neiProc)
435 interProcBouFound =
true;
437 bool neighbourFound =
false;
439 curInterProcBEdgesOwnIter().append(edgeI);
441 auto curInterProcBdrsNeiIter =
442 interProcBoundaries[neiProc].cbegin();
444 auto curInterProcBEdgesNeiIter =
445 interProcBEdges[neiProc].begin();
452 curInterProcBdrsNeiIter.good()
453 && curInterProcBEdgesNeiIter.good();
454 ++curInterProcBdrsNeiIter,
455 ++curInterProcBEdgesNeiIter
458 if (curInterProcBdrsNeiIter() == ownProc)
461 neighbourFound =
true;
463 curInterProcBEdgesNeiIter().append(edgeI);
466 if (neighbourFound)
break;
469 if (interProcBouFound && !neighbourFound)
472 (
"faDomainDecomposition::decomposeMesh()")
473 <<
"Inconsistency in inter - " 474 <<
"processor boundary lists for processors " 475 << ownProc <<
" and " << neiProc
480 if (interProcBouFound)
break;
483 if (!interProcBouFound)
491 interProcBoundaries[ownProc].append(neiProc);
492 interProcBEdges[ownProc].append(SLList<label>(edgeI));
495 interProcBoundaries[neiProc].append(ownProc);
496 interProcBEdges[neiProc]
512 forAll(procPatchSize_, procI)
515 procPatchStartIndex_[procI].setSize(
patches.
size());
521 forAll(procPatchSize_, procI)
523 procPatchSize_[procI][patchI] = 0;
524 procPatchStartIndex_[procI][patchI] =
525 procEdgeList[procI].size();
538 const label size =
patches[patchI].labelList::size();
542 for(
int eI=0; eI<size; eI++)
544 patchEdgeFaces[eI] = eF[
patches[patchI][eI]][0];
547 forAll(patchEdgeFaces, edgeI)
549 const label curProc = faceToProc_[patchEdgeFaces[edgeI]];
552 procEdgeList[curProc].append(patchStart + edgeI);
555 procPatchSize_[curProc][patchI]++;
562 const faPatch& cPatch =
patches[patchI];
564 const label cycOffset = cPatch.
size()/2;
580 forAll(firstEdgeFaces, edgeI)
584 faceToProc_[firstEdgeFaces[edgeI]]
585 != faceToProc_[secondEdgeFaces[edgeI]]
594 cyclicParallel_ =
true;
596 bool interProcBouFound =
false;
598 const label ownProc =
599 faceToProc_[firstEdgeFaces[edgeI]];
600 const label neiProc =
601 faceToProc_[secondEdgeFaces[edgeI]];
603 auto curInterProcBdrsOwnIter =
604 interProcBoundaries[ownProc].cbegin();
606 auto curInterProcBEdgesOwnIter =
607 interProcBEdges[ownProc].begin();
614 curInterProcBdrsOwnIter.good()
615 && curInterProcBEdgesOwnIter.good();
616 ++curInterProcBdrsOwnIter,
617 ++curInterProcBEdgesOwnIter
620 if (curInterProcBdrsOwnIter() == neiProc)
624 interProcBouFound =
true;
626 bool neighbourFound =
false;
628 curInterProcBEdgesOwnIter()
629 .append(patchStart + edgeI);
631 auto curInterProcBdrsNeiIter
632 = interProcBoundaries[neiProc].cbegin();
634 auto curInterProcBEdgesNeiIter =
635 interProcBEdges[neiProc].begin();
642 curInterProcBdrsNeiIter.good()
643 && curInterProcBEdgesNeiIter.good();
644 ++curInterProcBdrsNeiIter,
645 ++curInterProcBEdgesNeiIter
648 if (curInterProcBdrsNeiIter() == ownProc)
651 neighbourFound =
true;
653 curInterProcBEdgesNeiIter()
662 if (neighbourFound)
break;
665 if (interProcBouFound && !neighbourFound)
669 "faDomainDecomposition::decomposeMesh()" 670 ) <<
"Inconsistency in inter-processor " 671 <<
"boundary lists for processors " 672 << ownProc <<
" and " << neiProc
673 <<
" in cyclic boundary matching" 678 if (interProcBouFound)
break;
681 if (!interProcBouFound)
689 interProcBoundaries[ownProc].append(neiProc);
690 interProcBEdges[ownProc]
691 .append(SLList<label>(patchStart + edgeI));
694 interProcBoundaries[neiProc].append(ownProc);
695 interProcBEdges[neiProc]
710 label ownProc = faceToProc_[firstEdgeFaces[edgeI]];
713 procEdgeList[ownProc].append(patchStart + edgeI);
716 procPatchSize_[ownProc][patchI]++;
727 forAll(secondEdgeFaces, edgeI)
731 faceToProc_[firstEdgeFaces[edgeI]]
732 == faceToProc_[secondEdgeFaces[edgeI]]
736 label ownProc = faceToProc_[firstEdgeFaces[edgeI]];
739 procEdgeList[ownProc].append
740 (patchStart + cycOffset + edgeI);
743 procPatchSize_[ownProc][patchI]++;
751 forAll(procEdgeList, procI)
754 SLList<label>& curProcEdges = procEdgeList[procI];
757 labelList& curProcEdgeAddressing = procEdgeAddressing_[procI];
760 procNeighbourProcessors_[procI];
763 procProcessorPatchSize_[procI];
765 labelList& curProcProcessorPatchStartIndex =
766 procProcessorPatchStartIndex_[procI];
769 label nEdgesOnProcessor = curProcEdges.
size();
771 for (
const auto& bedges : interProcBEdges[procI])
773 nEdgesOnProcessor += bedges.size();
776 curProcEdgeAddressing.setSize(nEdgesOnProcessor);
789 for (
const label procEdgei : curProcEdges)
791 curProcEdgeAddressing[nEdges] = procEdgei;
799 curProcNeighbourProcessors.setSize
801 interProcBoundaries[procI].size()
804 curProcProcessorPatchSize.setSize
806 interProcBoundaries[procI].size()
809 curProcProcessorPatchStartIndex.setSize
811 interProcBoundaries[procI].size()
816 auto curInterProcBdrsIter =
817 interProcBoundaries[procI].cbegin();
819 auto curInterProcBEdgesIter =
820 interProcBEdges[procI].cbegin();
825 curInterProcBdrsIter.good()
826 && curInterProcBEdgesIter.good();
827 ++curInterProcBdrsIter,
828 ++curInterProcBEdgesIter
832 curInterProcBdrsIter();
844 for (
const label edgei : *curInterProcBEdgesIter)
850 if (faceToProc_[owner[edgei]] == procI)
852 curProcEdgeAddressing[nEdges] = edgei;
858 curProcEdgeAddressing[nEdges] = edgei;
873 Info <<
"\nCalculating processor boundary addressing" <<
endl;
879 forAll(procPatchSize_, procI)
882 const labelList oldPatchSizes = procPatchSize_[procI];
884 const labelList oldPatchStarts = procPatchStartIndex_[procI];
886 labelList& curPatchSizes = procPatchSize_[procI];
888 labelList& curPatchStarts = procPatchStartIndex_[procI];
890 const labelList& curProcessorPatchSizes =
891 procProcessorPatchSize_[procI];
893 labelList& curBoundaryAddressing = procBoundaryAddressing_[procI];
898 + curProcessorPatchSizes.size()
903 forAll(oldPatchSizes, patchI)
909 curBoundaryAddressing[
nPatches] = patchI;
911 curPatchSizes[
nPatches] = oldPatchSizes[patchI];
913 curPatchStarts[
nPatches] = oldPatchStarts[patchI];
923 forAll(curProcessorPatchSizes, procPatchI)
925 curBoundaryAddressing[
nPatches] = -1;
930 curBoundaryAddressing.setSize(
nPatches);
953 for (label procI = 0; procI < nProcs(); procI++)
956 const labelList& curEdgeLabels = procEdgeAddressing_[procI];
959 const labelList& curProcessorPatchStarts =
960 procProcessorPatchStartIndex_[procI];
962 const labelList& curProcessorPatchSizes =
963 procProcessorPatchSize_[procI];
968 forAll(curProcessorPatchStarts, patchI)
970 const label curStart = curProcessorPatchStarts[patchI];
971 const label curEnd = curStart + curProcessorPatchSizes[patchI];
975 label edgeI = curStart;
982 const label curE = curEdgeLabels[edgeI];
984 const edge&
e = edges[curE];
988 if (pointsUsage[
e[pointI]] == 0)
991 pointsUsage[
e[pointI]] = patchI + 1;
993 else if (pointsUsage[
e[pointI]] != patchI + 1)
996 gSharedPoints.insert(
e[pointI]);
1004 globallySharedPoints_ = gSharedPoints.sortedToc();
1010 for (label procI = 0; procI < nProcs(); procI++)
1017 time().caseName()/(
"processor" +
Foam::name(procI)),
1029 processorDb.timeName(),
1042 const labelList& curEdgeAddressing = procEdgeAddressing_[procI];
1044 const labelList& curPatchStartIndex = procPatchStartIndex_[procI];
1045 const labelList& curPatchSize = procPatchSize_[procI];
1047 const labelList& curProcessorPatchStartIndex =
1048 procProcessorPatchStartIndex_[procI];
1050 const labelList& curProcessorPatchSize =
1051 procProcessorPatchSize_[procI];
1053 labelListList& curPatchEdgeLabels = procPatchEdgeLabels_[procI];
1054 curPatchEdgeLabels.
resize 1057 + curProcessorPatchSize.size()
1060 forAll(curPatchSize, patchI)
1062 labelList& curEdgeLabels = curPatchEdgeLabels[patchI];
1063 curEdgeLabels.
setSize(curPatchSize[patchI], -1);
1069 int i=curPatchStartIndex[patchI];
1070 i<(curPatchStartIndex[patchI]+curPatchSize[patchI]);
1074 curEdgeLabels[edgeI] =
1075 procMeshEdgesMap_[procI][curEdgeAddressing[i]];
1080 forAll(curProcessorPatchSize, patchI)
1083 curPatchEdgeLabels[curPatchSize.size() + patchI];
1084 curEdgeLabels.
setSize(curProcessorPatchSize[patchI], -1);
1090 int i=curProcessorPatchStartIndex[patchI];
1091 i<(curProcessorPatchStartIndex[patchI]
1092 +curProcessorPatchSize[patchI]);
1096 curEdgeLabels[edgeI] =
1097 procMeshEdgesMap_[procI][curEdgeAddressing[i]];
1107 const word& polyMeshRegionName =
mesh().
name();
1109 Info<<
"\nConstructing processor FA meshes" <<
endl;
1112 Map<label> sharedPointLookup(
invertToMap(globallySharedPoints_));
1115 label maxProcFaces = 0;
1116 label totProcFaces = 0;
1117 label maxProcEdges = 0;
1118 label totProcEdges = 0;
1119 label maxProcPatches = 0;
1120 label totProcPatches = 0;
1123 for (label procI = 0; procI < nProcs(); procI++)
1132 time().caseName()/(
"processor" +
Foam::name(procI)),
1143 processorDb.timeName(),
1152 "boundaryProcAddressing",
1170 const labelList& curBoundaryAddressing =
1171 procBoundaryAddressing_[procI];
1173 const labelList& curPatchSizes = procPatchSize_[procI];
1175 const labelList& curNeighbourProcessors =
1176 procNeighbourProcessors_[procI];
1178 const labelList& curProcessorPatchSizes =
1179 procProcessorPatchSize_[procI];
1182 procPatchEdgeLabels_[procI];
1188 curPatchSizes.size() + curProcessorPatchSizes.size()
1193 forAll(curPatchSizes, patchi)
1197 const label neiPolyPatchId =
1198 fvBoundaryProcAddressing.
find 1200 meshPatches[curBoundaryAddressing[patchi]]
1201 .ngbPolyPatchIndex()
1207 meshPatches[curBoundaryAddressing[patchi]].clone
1209 procMesh.boundary(),
1218 forAll(curProcessorPatchSizes, procPatchI)
1225 new processorFaPatch
1229 procMesh.boundary(),
1232 curNeighbourProcessors[procPatchI]
1240 procMesh.addFaPatches(procPatches);
1248 Info<<
nl <<
"Processor " << procI;
1250 if (procMesh.nFaces())
1259 Info<<
"Number of faces = " << procMesh.nFaces() <<
nl;
1261 if (procMesh.nFaces())
1263 Info<<
" Number of points = " << procMesh.nPoints() <<
nl;
1266 totProcFaces += procMesh.nFaces();
1267 maxProcFaces =
max(maxProcFaces, procMesh.nFaces());
1269 label nBoundaryEdges = 0;
1271 label nProcEdges = 0;
1273 for (
const faPatch& fap : procMesh.boundary())
1275 const auto* ppp = isA<processorFaPatch>(fap);
1279 const auto& procPatch = *ppp;
1281 Info<<
" Number of edges shared with processor " 1282 << procPatch.neighbProcNo() <<
" = " 1283 << procPatch.size() <<
nl;
1285 nProcEdges += procPatch.size();
1290 nBoundaryEdges += fap.size();
1294 if (procMesh.nFaces() && (nBoundaryEdges || nProcEdges))
1297 <<
" Number of processor edges = " << nProcEdges <<
nl 1298 <<
" Number of boundary edges = " << nBoundaryEdges <<
nl;
1301 totProcEdges += nProcEdges;
1303 maxProcEdges =
max(maxProcEdges, nProcEdges);
1320 ioAddr.rename(
"pointProcAddressing");
1321 IOListRef<label>(ioAddr, procPatchPointAddressing_[procI]).
write();
1324 ioAddr.rename(
"edgeProcAddressing");
1325 IOListRef<label>(ioAddr, procEdgeAddressing_[procI]).
write();
1328 ioAddr.rename(
"faceProcAddressing");
1329 IOListRef<label>(ioAddr, procFaceAddressing_[procI]).
write();
1332 ioAddr.rename(
"boundaryProcAddressing");
1333 IOListRef<label>(ioAddr, procBoundaryAddressing_[procI]).
write();
1339 <<
"Number of processor edges = " << (totProcEdges/2) <<
nl 1340 <<
"Max number of faces = " << maxProcFaces;
1342 if (maxProcFaces != totProcFaces)
1344 scalar avgValue = scalar(totProcFaces)/nProcs_;
1346 Info<<
" (" << 100.0*(maxProcFaces-avgValue)/avgValue
1347 <<
"% above average " << avgValue <<
')';
1351 Info<<
"Max number of processor patches = " << maxProcPatches;
1354 scalar avgValue = scalar(totProcPatches)/nProcs_;
1356 Info<<
" (" << 100.0*(maxProcPatches-avgValue)/avgValue
1357 <<
"% above average " << avgValue <<
')';
1361 Info<<
"Max number of edges between processors = " << maxProcEdges;
1364 scalar avgValue = scalar(totProcEdges)/nProcs_;
1366 Info<<
" (" << 100.0*(maxProcEdges-avgValue)/avgValue
1367 <<
"% above average " << avgValue <<
')';
PtrList< faPatch > faPatchList
Store lists of faPatch as a PtrList.
Finite area mesh (used for 2-D non-Euclidian finite area method) defined using a patch of faces on a ...
void size(const label n)
Older name for setAddressableSize.
void resize(const label len)
Adjust allocated size of list.
error FatalError
Error stream (stdout output on all processes), with additional 'FOAM FATAL ERROR' header text and sta...
A list of keyword definitions, which are a keyword followed by a number of values (eg...
#define FatalErrorInFunction
Report an error message using Foam::FatalError.
List< edge > edgeList
List of edge.
const Time & time() const
Return reference to time.
const word & name() const noexcept
Return the object name.
label max(const labelHashSet &set, label maxValue=labelMin)
Find the max value in labelHashSet, optionally limited by second argument.
std::enable_if< std::is_same< bool, TypeT >::value, bool >::type set(const label i, bool val=true)
A bitSet::set() method for a list of bool.
constexpr char nl
The newline '\n' character (0x0a)
label start() const noexcept
The start label of boundary faces in the polyMesh face list.
static word meshSubDir
Return the mesh sub-directory name (usually "polyMesh")
Ostream & endl(Ostream &os)
Add newline and flush stream.
SubList< label > subList
Declare type of subList.
Ignore writing from objectRegistry::writeObject()
label nProcs() const noexcept
Number of processor in decomposition.
void updateParameters(const dictionary ¶ms)
Update flags based on the decomposition model settings.
labelList faceLabels(nFaceLabels)
List< labelList > labelListList
List of labelList.
Various functions to operate on Lists.
bool found(const word &keyword, enum keyType::option matchOpt=keyType::REGEX) const
Find an entry (const access) with the given keyword.
#define forAll(list, i)
Loop across all elements in list.
const fileName & caseName() const noexcept
Return the Time::caseName()
HashSet< label, Hash< label > > labelHashSet
A HashSet of labels, uses label hasher.
Functions used by OpenFOAM that are specific to POSIX compliant operating systems and need to be repl...
void write(vtk::formatter &fmt, const Type &val, const label n=1)
Component-wise write of a value (N times)
const dimensionedScalar e
Elementary charge.
IOList< label > labelIOList
IO for a List of label.
void setSize(const label n)
Alias for resize()
const labelList & faceLabels() const noexcept
Return the underlying polyMesh face labels.
word name(const expressions::valueTypeCode typeCode)
A word representation of a valueTypeCode. Empty for expressions::valueTypeCode::INVALID.
bool writeDecomposition()
Write decomposition.
label size() const noexcept
The number of entries in the list.
static unsigned int minPrecision(unsigned int prec) noexcept
Set the minimum default precision.
static word controlDictName
The default control dictionary name (normally "controlDict")
label min(const labelHashSet &set, label minValue=labelMax)
Find the min value in labelHashSet, optionally limited by second argument.
errorManip< error > abort(error &err)
label find(const T &val) const
Find index of the first occurrence of the value.
bool readIfPresent(const word &keyword, T &val, enum keyType::option matchOpt=keyType::REGEX) const
Find an entry if present, and assign to T val. FatalIOError if it is found and the number of tokens i...
const polyMesh & mesh() const
Return access to polyMesh.
faMeshDecomposition(const polyMesh &mesh, const label nProcessors, const dictionary ¶ms=dictionary::null)
Construct from components. Values will come from the volume decomposition.
static word meshSubDir
The mesh sub-directory name (usually "faMesh")
PrimitivePatch< UIndirectList< face >, const pointField & > uindirectPrimitivePatch
A PrimitivePatch with UIndirectList for the faces, const reference for the point field.
void decomposeMesh()
Decompose mesh.
const fileName & rootPath() const noexcept
Return the Time::rootPath()
cpuTimePosix cpuTime
Selection of preferred clock mechanism for the elapsed cpu time.
const word & name() const
Return reference to name.
IOobject(const IOobject &)=default
Copy construct.
const polyBoundaryMesh & patches
const std::string patch
OpenFOAM patch number as a std::string.
messageStream Info
Information stream (stdout output on master, null elsewhere)
Mesh consisting of general polyhedral cells.
List< label > labelList
A List of labels.
Non-intrusive singly-linked list.
Map< label > invertToMap(const labelUList &values)
Create inverse mapping, which is a lookup table into the given list.
#define FatalErrorIn(functionName)
Report an error message using Foam::FatalError.
Do not request registration (bool: false)
static constexpr const zero Zero
Global zero (0)