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)
66 processorDb.timeName(),
84 ioAddr.rename(
"faceProcAddressing");
87 labelHashSet faceProcAddressingHash(2*fvFaceProcAddressing.size());
97 if (hasGlobalFaceZones_)
100 ioAddr.rename(
"owner");
103 for (
int i = 0; i < ownerSize; ++i)
105 faceProcAddressingHash.insert(fvFaceProcAddressing[i]);
110 faceProcAddressingHash.insert
112 static_cast<labelList&>(fvFaceProcAddressing)
119 const label index = (
faceLabels()[facei] + 1);
121 if (faceProcAddressingHash.found(index))
123 faceToProc_[facei] = proci;
128 Info<<
"\nFinished decomposition in " 129 << decompositionTime.elapsedCpuTime()
139 const label nProcessors,
144 nProcs_(nProcessors),
146 hasGlobalFaceZones_(false),
147 faceToProc_(nFaces()),
148 procFaceLabels_(nProcs_),
149 procMeshEdgesMap_(nProcs_),
150 procNInternalEdges_(nProcs_,
Zero),
151 procPatchEdgeLabels_(nProcs_),
152 procPatchPointAddressing_(nProcs_),
153 procPatchEdgeAddressing_(nProcs_),
154 procEdgeAddressing_(nProcs_),
155 procFaceAddressing_(nProcs_),
156 procBoundaryAddressing_(nProcs_),
157 procPatchSize_(nProcs_),
158 procPatchStartIndex_(nProcs_),
159 procNeighbourProcessors_(nProcs_),
160 procProcessorPatchSize_(nProcs_),
161 procProcessorPatchStartIndex_(nProcs_),
162 globallySharedPoints_(),
163 cyclicParallel_(false)
177 if (params.
found(
"globalFaceZones"))
179 hasGlobalFaceZones_ =
true;
189 const word& polyMeshRegionName =
mesh().
name();
191 Info<<
"\nDistributing faces to processors" <<
endl;
197 forAll(faceToProc_, facei)
199 const label proci = faceToProc_[facei];
201 if (proci < 0 || proci >= nProcs_)
204 <<
"Invalid processor label " << proci
205 <<
" for face " << facei <<
nl 210 ++nLocalFaces[proci];
215 forAll(nLocalFaces, proci)
217 procFaceAddressing_[proci].resize(nLocalFaces[proci]);
218 nLocalFaces[proci] = 0;
222 forAll(faceToProc_, facei)
224 const label proci = faceToProc_[facei];
225 const label localFacei = nLocalFaces[proci];
226 ++nLocalFaces[proci];
228 procFaceAddressing_[proci][localFacei] = facei;
234 for (label procI = 0; procI < nProcs(); procI++)
240 time().caseName()/(
"processor" +
Foam::name(procI)),
250 processorDb.timeName(),
268 ioAddr.rename(
"pointProcAddressing");
271 Map<label> fvFaceProcAddressingHash;
275 ioAddr.rename(
"faceProcAddressing");
278 fvFaceProcAddressingHash.reserve(fvFaceProcAddressing.size());
280 forAll(fvFaceProcAddressing, facei)
282 fvFaceProcAddressingHash.insert
284 fvFaceProcAddressing[facei],
290 const labelList& curProcFaceAddressing = procFaceAddressing_[procI];
292 labelList& curFaceLabels = procFaceLabels_[procI];
294 curFaceLabels =
labelList(curProcFaceAddressing.size(), -1);
296 forAll(curProcFaceAddressing, faceI)
298 curFaceLabels[faceI] =
299 fvFaceProcAddressingHash.find
301 faceLabels()[curProcFaceAddressing[faceI]] + 1
313 const Map<label>& map =
patch.meshPointMap();
315 EdgeMap<label> edgesHash;
317 const label nIntEdges =
patch.nInternalEdges();
319 for (label edgei = 0; edgei < nIntEdges; ++edgei)
321 edgesHash.insert(
patch.edges()[edgei], edgesHash.size());
327 const label size =
boundary()[patchi].labelList::size();
329 for (label edgei=0; edgei < size; ++edgei)
341 const labelList& procMeshPoints = procPatch.meshPoints();
342 const edgeList& procEdges = procPatch.edges();
344 labelList& curPatchPointAddressing = procPatchPointAddressing_[procI];
345 curPatchPointAddressing.
resize(procMeshPoints.size(), -1);
347 forAll(procMeshPoints, pointi)
349 curPatchPointAddressing[pointi] =
350 map[fvPointProcAddressing[procMeshPoints[pointi]]];
353 labelList& curPatchEdgeAddressing = procPatchEdgeAddressing_[procI];
354 curPatchEdgeAddressing.
resize(procEdges.size(), -1);
356 Map<label>& curMap = procMeshEdgesMap_[procI];
358 curMap.reserve(procEdges.size());
362 edge curGlobalEdge(curPatchPointAddressing, procEdges[edgeI]);
363 curPatchEdgeAddressing[edgeI] = edgesHash.find(curGlobalEdge).val();
366 forAll(curPatchEdgeAddressing, edgeI)
368 curMap.insert(curPatchEdgeAddressing[edgeI], edgeI);
371 procNInternalEdges_[procI] = procPatch.nInternalEdges();
375 Info <<
"\nDistributing edges to processors" <<
endl;
382 const edgeList& edges = this->edges();
384 const labelList& neighbour = edgeNeighbour();
388 List<SLList<label>> procEdgeList(nProcs());
390 forAll(procEdgeList, procI)
392 for(label i=0; i<procNInternalEdges_[procI]; i++)
394 procEdgeList[procI].append(procPatchEdgeAddressing_[procI][i]);
402 List<SLList<label>> interProcBoundaries(nProcs());
405 List<SLList<SLList<label>>> interProcBEdges(nProcs());
407 List<SLList<label>> procPatchIndex(nProcs());
411 if (faceToProc_[owner[edgeI]] != faceToProc_[neighbour[edgeI]])
417 bool interProcBouFound =
false;
419 const label ownProc = faceToProc_[owner[edgeI]];
420 const label neiProc = faceToProc_[neighbour[edgeI]];
422 auto curInterProcBdrsOwnIter =
423 interProcBoundaries[ownProc].cbegin();
425 auto curInterProcBEdgesOwnIter =
426 interProcBEdges[ownProc].begin();
433 curInterProcBdrsOwnIter.good()
434 && curInterProcBEdgesOwnIter.good();
435 ++curInterProcBdrsOwnIter,
436 ++curInterProcBEdgesOwnIter
439 if (curInterProcBdrsOwnIter() == neiProc)
442 interProcBouFound =
true;
444 bool neighbourFound =
false;
446 curInterProcBEdgesOwnIter().append(edgeI);
448 auto curInterProcBdrsNeiIter =
449 interProcBoundaries[neiProc].cbegin();
451 auto curInterProcBEdgesNeiIter =
452 interProcBEdges[neiProc].begin();
459 curInterProcBdrsNeiIter.good()
460 && curInterProcBEdgesNeiIter.good();
461 ++curInterProcBdrsNeiIter,
462 ++curInterProcBEdgesNeiIter
465 if (curInterProcBdrsNeiIter() == ownProc)
468 neighbourFound =
true;
470 curInterProcBEdgesNeiIter().append(edgeI);
473 if (neighbourFound)
break;
476 if (interProcBouFound && !neighbourFound)
479 (
"faDomainDecomposition::decomposeMesh()")
480 <<
"Inconsistency in inter - " 481 <<
"processor boundary lists for processors " 482 << ownProc <<
" and " << neiProc
487 if (interProcBouFound)
break;
490 if (!interProcBouFound)
498 interProcBoundaries[ownProc].append(neiProc);
499 interProcBEdges[ownProc].append(SLList<label>(edgeI));
502 interProcBoundaries[neiProc].append(ownProc);
503 interProcBEdges[neiProc]
519 forAll(procPatchSize_, procI)
522 procPatchStartIndex_[procI].setSize(
patches.
size());
528 forAll(procPatchSize_, procI)
530 procPatchSize_[procI][patchI] = 0;
531 procPatchStartIndex_[procI][patchI] =
532 procEdgeList[procI].size();
545 const label size =
patches[patchI].labelList::size();
549 for(
int eI=0; eI<size; eI++)
551 patchEdgeFaces[eI] = eF[
patches[patchI][eI]][0];
554 forAll(patchEdgeFaces, edgeI)
556 const label curProc = faceToProc_[patchEdgeFaces[edgeI]];
559 procEdgeList[curProc].append(patchStart + edgeI);
562 procPatchSize_[curProc][patchI]++;
569 const faPatch& cPatch =
patches[patchI];
571 const label cycOffset = cPatch.
size()/2;
587 forAll(firstEdgeFaces, edgeI)
591 faceToProc_[firstEdgeFaces[edgeI]]
592 != faceToProc_[secondEdgeFaces[edgeI]]
601 cyclicParallel_ =
true;
603 bool interProcBouFound =
false;
605 const label ownProc =
606 faceToProc_[firstEdgeFaces[edgeI]];
607 const label neiProc =
608 faceToProc_[secondEdgeFaces[edgeI]];
610 auto curInterProcBdrsOwnIter =
611 interProcBoundaries[ownProc].cbegin();
613 auto curInterProcBEdgesOwnIter =
614 interProcBEdges[ownProc].begin();
621 curInterProcBdrsOwnIter.good()
622 && curInterProcBEdgesOwnIter.good();
623 ++curInterProcBdrsOwnIter,
624 ++curInterProcBEdgesOwnIter
627 if (curInterProcBdrsOwnIter() == neiProc)
631 interProcBouFound =
true;
633 bool neighbourFound =
false;
635 curInterProcBEdgesOwnIter()
636 .append(patchStart + edgeI);
638 auto curInterProcBdrsNeiIter
639 = interProcBoundaries[neiProc].cbegin();
641 auto curInterProcBEdgesNeiIter =
642 interProcBEdges[neiProc].begin();
649 curInterProcBdrsNeiIter.good()
650 && curInterProcBEdgesNeiIter.good();
651 ++curInterProcBdrsNeiIter,
652 ++curInterProcBEdgesNeiIter
655 if (curInterProcBdrsNeiIter() == ownProc)
658 neighbourFound =
true;
660 curInterProcBEdgesNeiIter()
669 if (neighbourFound)
break;
672 if (interProcBouFound && !neighbourFound)
676 "faDomainDecomposition::decomposeMesh()" 677 ) <<
"Inconsistency in inter-processor " 678 <<
"boundary lists for processors " 679 << ownProc <<
" and " << neiProc
680 <<
" in cyclic boundary matching" 685 if (interProcBouFound)
break;
688 if (!interProcBouFound)
696 interProcBoundaries[ownProc].append(neiProc);
697 interProcBEdges[ownProc]
698 .append(SLList<label>(patchStart + edgeI));
701 interProcBoundaries[neiProc].append(ownProc);
702 interProcBEdges[neiProc]
717 label ownProc = faceToProc_[firstEdgeFaces[edgeI]];
720 procEdgeList[ownProc].append(patchStart + edgeI);
723 procPatchSize_[ownProc][patchI]++;
734 forAll(secondEdgeFaces, edgeI)
738 faceToProc_[firstEdgeFaces[edgeI]]
739 == faceToProc_[secondEdgeFaces[edgeI]]
743 label ownProc = faceToProc_[firstEdgeFaces[edgeI]];
746 procEdgeList[ownProc].append
747 (patchStart + cycOffset + edgeI);
750 procPatchSize_[ownProc][patchI]++;
758 forAll(procEdgeList, procI)
761 SLList<label>& curProcEdges = procEdgeList[procI];
764 labelList& curProcEdgeAddressing = procEdgeAddressing_[procI];
767 procNeighbourProcessors_[procI];
770 procProcessorPatchSize_[procI];
772 labelList& curProcProcessorPatchStartIndex =
773 procProcessorPatchStartIndex_[procI];
776 label nEdgesOnProcessor = curProcEdges.
size();
778 for (
const auto& bedges : interProcBEdges[procI])
780 nEdgesOnProcessor += bedges.size();
783 curProcEdgeAddressing.setSize(nEdgesOnProcessor);
796 for (
const label procEdgei : curProcEdges)
798 curProcEdgeAddressing[nEdges] = procEdgei;
806 curProcNeighbourProcessors.setSize
808 interProcBoundaries[procI].size()
811 curProcProcessorPatchSize.setSize
813 interProcBoundaries[procI].size()
816 curProcProcessorPatchStartIndex.setSize
818 interProcBoundaries[procI].size()
823 auto curInterProcBdrsIter =
824 interProcBoundaries[procI].cbegin();
826 auto curInterProcBEdgesIter =
827 interProcBEdges[procI].cbegin();
832 curInterProcBdrsIter.good()
833 && curInterProcBEdgesIter.good();
834 ++curInterProcBdrsIter,
835 ++curInterProcBEdgesIter
839 curInterProcBdrsIter();
851 for (
const label edgei : *curInterProcBEdgesIter)
857 if (faceToProc_[owner[edgei]] == procI)
859 curProcEdgeAddressing[nEdges] = edgei;
865 curProcEdgeAddressing[nEdges] = edgei;
880 Info <<
"\nCalculating processor boundary addressing" <<
endl;
886 forAll(procPatchSize_, procI)
889 const labelList oldPatchSizes = procPatchSize_[procI];
891 const labelList oldPatchStarts = procPatchStartIndex_[procI];
893 labelList& curPatchSizes = procPatchSize_[procI];
895 labelList& curPatchStarts = procPatchStartIndex_[procI];
897 const labelList& curProcessorPatchSizes =
898 procProcessorPatchSize_[procI];
900 labelList& curBoundaryAddressing = procBoundaryAddressing_[procI];
905 + curProcessorPatchSizes.size()
910 forAll(oldPatchSizes, patchI)
916 curBoundaryAddressing[
nPatches] = patchI;
918 curPatchSizes[
nPatches] = oldPatchSizes[patchI];
920 curPatchStarts[
nPatches] = oldPatchStarts[patchI];
930 forAll(curProcessorPatchSizes, procPatchI)
932 curBoundaryAddressing[
nPatches] = -1;
937 curBoundaryAddressing.setSize(
nPatches);
960 for (label procI = 0; procI < nProcs(); procI++)
963 const labelList& curEdgeLabels = procEdgeAddressing_[procI];
966 const labelList& curProcessorPatchStarts =
967 procProcessorPatchStartIndex_[procI];
969 const labelList& curProcessorPatchSizes =
970 procProcessorPatchSize_[procI];
975 forAll(curProcessorPatchStarts, patchI)
977 const label curStart = curProcessorPatchStarts[patchI];
978 const label curEnd = curStart + curProcessorPatchSizes[patchI];
982 label edgeI = curStart;
989 const label curE = curEdgeLabels[edgeI];
991 const edge&
e = edges[curE];
995 if (pointsUsage[
e[pointI]] == 0)
998 pointsUsage[
e[pointI]] = patchI + 1;
1000 else if (pointsUsage[
e[pointI]] != patchI + 1)
1003 gSharedPoints.insert(
e[pointI]);
1011 globallySharedPoints_ = gSharedPoints.sortedToc();
1017 for (label procI = 0; procI < nProcs(); procI++)
1024 time().caseName()/(
"processor" +
Foam::name(procI)),
1036 processorDb.timeName(),
1049 const labelList& curEdgeAddressing = procEdgeAddressing_[procI];
1051 const labelList& curPatchStartIndex = procPatchStartIndex_[procI];
1052 const labelList& curPatchSize = procPatchSize_[procI];
1054 const labelList& curProcessorPatchStartIndex =
1055 procProcessorPatchStartIndex_[procI];
1057 const labelList& curProcessorPatchSize =
1058 procProcessorPatchSize_[procI];
1060 labelListList& curPatchEdgeLabels = procPatchEdgeLabels_[procI];
1061 curPatchEdgeLabels.
resize 1064 + curProcessorPatchSize.size()
1067 forAll(curPatchSize, patchI)
1069 labelList& curEdgeLabels = curPatchEdgeLabels[patchI];
1070 curEdgeLabels.
setSize(curPatchSize[patchI], -1);
1076 int i=curPatchStartIndex[patchI];
1077 i<(curPatchStartIndex[patchI]+curPatchSize[patchI]);
1081 curEdgeLabels[edgeI] =
1082 procMeshEdgesMap_[procI][curEdgeAddressing[i]];
1087 forAll(curProcessorPatchSize, patchI)
1090 curPatchEdgeLabels[curPatchSize.size() + patchI];
1091 curEdgeLabels.
setSize(curProcessorPatchSize[patchI], -1);
1097 int i=curProcessorPatchStartIndex[patchI];
1098 i<(curProcessorPatchStartIndex[patchI]
1099 +curProcessorPatchSize[patchI]);
1103 curEdgeLabels[edgeI] =
1104 procMeshEdgesMap_[procI][curEdgeAddressing[i]];
1114 const word& polyMeshRegionName =
mesh().
name();
1116 Info<<
"\nConstructing processor FA meshes" <<
endl;
1119 Map<label> sharedPointLookup(2*globallySharedPoints_.size());
1121 forAll(globallySharedPoints_, pointi)
1123 sharedPointLookup.insert(globallySharedPoints_[pointi], pointi);
1126 label maxProcFaces = 0;
1127 label totProcFaces = 0;
1128 label maxProcEdges = 0;
1129 label totProcEdges = 0;
1130 label maxProcPatches = 0;
1131 label totProcPatches = 0;
1134 for (label procI = 0; procI < nProcs(); procI++)
1143 time().caseName()/(
"processor" +
Foam::name(procI)),
1154 processorDb.timeName(),
1163 "boundaryProcAddressing",
1181 const labelList& curBoundaryAddressing =
1182 procBoundaryAddressing_[procI];
1184 const labelList& curPatchSizes = procPatchSize_[procI];
1186 const labelList& curNeighbourProcessors =
1187 procNeighbourProcessors_[procI];
1189 const labelList& curProcessorPatchSizes =
1190 procProcessorPatchSize_[procI];
1193 procPatchEdgeLabels_[procI];
1199 curPatchSizes.size() + curProcessorPatchSizes.size()
1204 forAll(curPatchSizes, patchi)
1208 const label neiPolyPatchId =
1209 fvBoundaryProcAddressing.
find 1211 meshPatches[curBoundaryAddressing[patchi]]
1212 .ngbPolyPatchIndex()
1218 meshPatches[curBoundaryAddressing[patchi]].clone
1220 procMesh.boundary(),
1229 forAll(curProcessorPatchSizes, procPatchI)
1236 new processorFaPatch
1240 procMesh.boundary(),
1243 curNeighbourProcessors[procPatchI]
1251 procMesh.addFaPatches(procPatches);
1259 Info<<
nl <<
"Processor " << procI;
1261 if (procMesh.nFaces())
1270 Info<<
"Number of faces = " << procMesh.nFaces() <<
nl;
1272 if (procMesh.nFaces())
1274 Info<<
" Number of points = " << procMesh.nPoints() <<
nl;
1277 totProcFaces += procMesh.nFaces();
1278 maxProcFaces =
max(maxProcFaces, procMesh.nFaces());
1280 label nBoundaryEdges = 0;
1282 label nProcEdges = 0;
1284 for (
const faPatch& fap : procMesh.boundary())
1286 const auto* ppp = isA<processorFaPatch>(fap);
1290 const auto& procPatch = *ppp;
1292 Info<<
" Number of edges shared with processor " 1293 << procPatch.neighbProcNo() <<
" = " 1294 << procPatch.size() <<
nl;
1296 nProcEdges += procPatch.size();
1301 nBoundaryEdges += fap.size();
1305 if (procMesh.nFaces() && (nBoundaryEdges || nProcEdges))
1308 <<
" Number of processor edges = " << nProcEdges <<
nl 1309 <<
" Number of boundary edges = " << nBoundaryEdges <<
nl;
1312 totProcEdges += nProcEdges;
1314 maxProcEdges =
max(maxProcEdges, nProcEdges);
1331 ioAddr.rename(
"pointProcAddressing");
1332 IOListRef<label>(ioAddr, procPatchPointAddressing_[procI]).
write();
1335 ioAddr.rename(
"edgeProcAddressing");
1336 IOListRef<label>(ioAddr, procEdgeAddressing_[procI]).
write();
1339 ioAddr.rename(
"faceProcAddressing");
1340 IOListRef<label>(ioAddr, procFaceAddressing_[procI]).
write();
1343 ioAddr.rename(
"boundaryProcAddressing");
1344 IOListRef<label>(ioAddr, procBoundaryAddressing_[procI]).
write();
1350 <<
"Number of processor edges = " << (totProcEdges/2) <<
nl 1351 <<
"Max number of faces = " << maxProcFaces;
1353 if (maxProcFaces != totProcFaces)
1355 scalar avgValue = scalar(totProcFaces)/nProcs_;
1357 Info<<
" (" << 100.0*(maxProcFaces-avgValue)/avgValue
1358 <<
"% above average " << avgValue <<
')';
1362 Info<<
"Max number of processor patches = " << maxProcPatches;
1365 scalar avgValue = scalar(totProcPatches)/nProcs_;
1367 Info<<
" (" << 100.0*(maxProcPatches-avgValue)/avgValue
1368 <<
"% above average " << avgValue <<
')';
1372 Info<<
"Max number of edges between processors = " << maxProcEdges;
1375 scalar avgValue = scalar(totProcEdges)/nProcs_;
1377 Info<<
" (" << 100.0*(maxProcEdges-avgValue)/avgValue
1378 <<
"% 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.
static unsigned int defaultPrecision() noexcept
Return the default precision.
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.
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 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.
#define FatalErrorIn(functionName)
Report an error message using Foam::FatalError.
Do not request registration (bool: false)
static constexpr const zero Zero
Global zero (0)