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(),
82 ioAddr.rename(
"faceProcAddressing");
85 labelHashSet faceProcAddressingHash(2*fvFaceProcAddressing.size());
95 if (hasGlobalFaceZones_)
98 ioAddr.rename(
"owner");
101 for (
int i = 0; i < ownerSize; ++i)
103 faceProcAddressingHash.insert(fvFaceProcAddressing[i]);
108 faceProcAddressingHash.insert
110 static_cast<labelList&>(fvFaceProcAddressing)
117 const label index = (
faceLabels()[facei] + 1);
119 if (faceProcAddressingHash.found(index))
121 faceToProc_[facei] = proci;
126 Info<<
"\nFinished decomposition in " 127 << decompositionTime.elapsedCpuTime()
137 const label nProcessors,
142 nProcs_(nProcessors),
144 hasGlobalFaceZones_(false),
145 faceToProc_(nFaces()),
146 procFaceLabels_(nProcs_),
147 procMeshEdgesMap_(nProcs_),
148 procNInternalEdges_(nProcs_,
Zero),
149 procPatchEdgeLabels_(nProcs_),
150 procPatchPointAddressing_(nProcs_),
151 procPatchEdgeAddressing_(nProcs_),
152 procEdgeAddressing_(nProcs_),
153 procFaceAddressing_(nProcs_),
154 procBoundaryAddressing_(nProcs_),
155 procPatchSize_(nProcs_),
156 procPatchStartIndex_(nProcs_),
157 procNeighbourProcessors_(nProcs_),
158 procProcessorPatchSize_(nProcs_),
159 procProcessorPatchStartIndex_(nProcs_),
160 globallySharedPoints_(),
161 cyclicParallel_(false)
175 if (params.
found(
"globalFaceZones"))
177 hasGlobalFaceZones_ =
true;
187 const word& polyMeshRegionName =
mesh().
name();
189 Info<<
"\nDistributing faces to processors" <<
endl;
195 forAll(faceToProc_, facei)
197 const label proci = faceToProc_[facei];
199 if (proci < 0 || proci >= nProcs_)
202 <<
"Invalid processor label " << proci
203 <<
" for face " << facei <<
nl 208 ++nLocalFaces[proci];
213 forAll(nLocalFaces, proci)
215 procFaceAddressing_[proci].resize(nLocalFaces[proci]);
216 nLocalFaces[proci] = 0;
220 forAll(faceToProc_, facei)
222 const label proci = faceToProc_[facei];
223 const label localFacei = nLocalFaces[proci];
224 ++nLocalFaces[proci];
226 procFaceAddressing_[proci][localFacei] = facei;
232 for (label procI = 0; procI < nProcs(); procI++)
238 time().caseName()/(
"processor" +
Foam::name(procI))
246 processorDb.timeName(),
264 ioAddr.rename(
"pointProcAddressing");
267 Map<label> fvFaceProcAddressingHash;
271 ioAddr.rename(
"faceProcAddressing");
274 fvFaceProcAddressingHash.resize(2*fvFaceProcAddressing.size());
276 forAll(fvFaceProcAddressing, facei)
278 fvFaceProcAddressingHash.insert
280 fvFaceProcAddressing[facei],
286 const labelList& curProcFaceAddressing = procFaceAddressing_[procI];
288 labelList& curFaceLabels = procFaceLabels_[procI];
290 curFaceLabels =
labelList(curProcFaceAddressing.size(), -1);
292 forAll(curProcFaceAddressing, faceI)
294 curFaceLabels[faceI] =
295 fvFaceProcAddressingHash.find
297 faceLabels()[curProcFaceAddressing[faceI]] + 1
309 const Map<label>& map =
patch.meshPointMap();
311 EdgeMap<label> edgesHash;
313 const label nIntEdges =
patch.nInternalEdges();
315 for (label edgei = 0; edgei < nIntEdges; ++edgei)
317 edgesHash.insert(
patch.edges()[edgei], edgesHash.size());
323 const label size =
boundary()[patchi].labelList::size();
325 for (label edgei=0; edgei < size; ++edgei)
337 const labelList& procMeshPoints = procPatch.meshPoints();
338 const edgeList& procEdges = procPatch.edges();
340 labelList& curPatchPointAddressing = procPatchPointAddressing_[procI];
341 curPatchPointAddressing.
resize(procMeshPoints.size(), -1);
343 forAll(procMeshPoints, pointi)
345 curPatchPointAddressing[pointi] =
346 map[fvPointProcAddressing[procMeshPoints[pointi]]];
349 labelList& curPatchEdgeAddressing = procPatchEdgeAddressing_[procI];
350 curPatchEdgeAddressing.
resize(procEdges.size(), -1);
352 Map<label>& curMap = procMeshEdgesMap_[procI];
354 curMap.resize(2*procEdges.size());
358 edge curGlobalEdge(curPatchPointAddressing, procEdges[edgeI]);
359 curPatchEdgeAddressing[edgeI] = edgesHash.find(curGlobalEdge).val();
362 forAll(curPatchEdgeAddressing, edgeI)
364 curMap.insert(curPatchEdgeAddressing[edgeI], edgeI);
367 procNInternalEdges_[procI] = procPatch.nInternalEdges();
371 Info <<
"\nDistributing edges to processors" <<
endl;
378 const edgeList& edges = this->edges();
380 const labelList& neighbour = edgeNeighbour();
384 List<SLList<label>> procEdgeList(nProcs());
386 forAll(procEdgeList, procI)
388 for(label i=0; i<procNInternalEdges_[procI]; i++)
390 procEdgeList[procI].append(procPatchEdgeAddressing_[procI][i]);
398 List<SLList<label>> interProcBoundaries(nProcs());
401 List<SLList<SLList<label>>> interProcBEdges(nProcs());
403 List<SLList<label>> procPatchIndex(nProcs());
407 if (faceToProc_[owner[edgeI]] != faceToProc_[neighbour[edgeI]])
413 bool interProcBouFound =
false;
415 const label ownProc = faceToProc_[owner[edgeI]];
416 const label neiProc = faceToProc_[neighbour[edgeI]];
418 auto curInterProcBdrsOwnIter =
419 interProcBoundaries[ownProc].cbegin();
421 auto curInterProcBEdgesOwnIter =
422 interProcBEdges[ownProc].begin();
429 curInterProcBdrsOwnIter.good()
430 && curInterProcBEdgesOwnIter.good();
431 ++curInterProcBdrsOwnIter,
432 ++curInterProcBEdgesOwnIter
435 if (curInterProcBdrsOwnIter() == neiProc)
438 interProcBouFound =
true;
440 bool neighbourFound =
false;
442 curInterProcBEdgesOwnIter().append(edgeI);
444 auto curInterProcBdrsNeiIter =
445 interProcBoundaries[neiProc].cbegin();
447 auto curInterProcBEdgesNeiIter =
448 interProcBEdges[neiProc].begin();
455 curInterProcBdrsNeiIter.good()
456 && curInterProcBEdgesNeiIter.good();
457 ++curInterProcBdrsNeiIter,
458 ++curInterProcBEdgesNeiIter
461 if (curInterProcBdrsNeiIter() == ownProc)
464 neighbourFound =
true;
466 curInterProcBEdgesNeiIter().append(edgeI);
469 if (neighbourFound)
break;
472 if (interProcBouFound && !neighbourFound)
475 (
"faDomainDecomposition::decomposeMesh()")
476 <<
"Inconsistency in inter - " 477 <<
"processor boundary lists for processors " 478 << ownProc <<
" and " << neiProc
483 if (interProcBouFound)
break;
486 if (!interProcBouFound)
494 interProcBoundaries[ownProc].append(neiProc);
495 interProcBEdges[ownProc].append(SLList<label>(edgeI));
498 interProcBoundaries[neiProc].append(ownProc);
499 interProcBEdges[neiProc]
515 forAll(procPatchSize_, procI)
518 procPatchStartIndex_[procI].setSize(
patches.
size());
524 forAll(procPatchSize_, procI)
526 procPatchSize_[procI][patchI] = 0;
527 procPatchStartIndex_[procI][patchI] =
528 procEdgeList[procI].size();
541 const label size =
patches[patchI].labelList::size();
545 for(
int eI=0; eI<size; eI++)
547 patchEdgeFaces[eI] = eF[
patches[patchI][eI]][0];
550 forAll(patchEdgeFaces, edgeI)
552 const label curProc = faceToProc_[patchEdgeFaces[edgeI]];
555 procEdgeList[curProc].append(patchStart + edgeI);
558 procPatchSize_[curProc][patchI]++;
565 const faPatch& cPatch =
patches[patchI];
567 const label cycOffset = cPatch.
size()/2;
583 forAll(firstEdgeFaces, edgeI)
587 faceToProc_[firstEdgeFaces[edgeI]]
588 != faceToProc_[secondEdgeFaces[edgeI]]
597 cyclicParallel_ =
true;
599 bool interProcBouFound =
false;
601 const label ownProc =
602 faceToProc_[firstEdgeFaces[edgeI]];
603 const label neiProc =
604 faceToProc_[secondEdgeFaces[edgeI]];
606 auto curInterProcBdrsOwnIter =
607 interProcBoundaries[ownProc].cbegin();
609 auto curInterProcBEdgesOwnIter =
610 interProcBEdges[ownProc].begin();
617 curInterProcBdrsOwnIter.good()
618 && curInterProcBEdgesOwnIter.good();
619 ++curInterProcBdrsOwnIter,
620 ++curInterProcBEdgesOwnIter
623 if (curInterProcBdrsOwnIter() == neiProc)
627 interProcBouFound =
true;
629 bool neighbourFound =
false;
631 curInterProcBEdgesOwnIter()
632 .append(patchStart + edgeI);
634 auto curInterProcBdrsNeiIter
635 = interProcBoundaries[neiProc].cbegin();
637 auto curInterProcBEdgesNeiIter =
638 interProcBEdges[neiProc].begin();
645 curInterProcBdrsNeiIter.good()
646 && curInterProcBEdgesNeiIter.good();
647 ++curInterProcBdrsNeiIter,
648 ++curInterProcBEdgesNeiIter
651 if (curInterProcBdrsNeiIter() == ownProc)
654 neighbourFound =
true;
656 curInterProcBEdgesNeiIter()
665 if (neighbourFound)
break;
668 if (interProcBouFound && !neighbourFound)
672 "faDomainDecomposition::decomposeMesh()" 673 ) <<
"Inconsistency in inter-processor " 674 <<
"boundary lists for processors " 675 << ownProc <<
" and " << neiProc
676 <<
" in cyclic boundary matching" 681 if (interProcBouFound)
break;
684 if (!interProcBouFound)
692 interProcBoundaries[ownProc].append(neiProc);
693 interProcBEdges[ownProc]
694 .append(SLList<label>(patchStart + edgeI));
697 interProcBoundaries[neiProc].append(ownProc);
698 interProcBEdges[neiProc]
713 label ownProc = faceToProc_[firstEdgeFaces[edgeI]];
716 procEdgeList[ownProc].append(patchStart + edgeI);
719 procPatchSize_[ownProc][patchI]++;
730 forAll(secondEdgeFaces, edgeI)
734 faceToProc_[firstEdgeFaces[edgeI]]
735 == faceToProc_[secondEdgeFaces[edgeI]]
739 label ownProc = faceToProc_[firstEdgeFaces[edgeI]];
742 procEdgeList[ownProc].append
743 (patchStart + cycOffset + edgeI);
746 procPatchSize_[ownProc][patchI]++;
754 forAll(procEdgeList, procI)
757 SLList<label>& curProcEdges = procEdgeList[procI];
760 labelList& curProcEdgeAddressing = procEdgeAddressing_[procI];
763 procNeighbourProcessors_[procI];
766 procProcessorPatchSize_[procI];
768 labelList& curProcProcessorPatchStartIndex =
769 procProcessorPatchStartIndex_[procI];
772 label nEdgesOnProcessor = curProcEdges.
size();
774 for (
const auto& bedges : interProcBEdges[procI])
776 nEdgesOnProcessor += bedges.size();
779 curProcEdgeAddressing.setSize(nEdgesOnProcessor);
792 for (
const label procEdgei : curProcEdges)
794 curProcEdgeAddressing[nEdges] = procEdgei;
802 curProcNeighbourProcessors.setSize
804 interProcBoundaries[procI].size()
807 curProcProcessorPatchSize.setSize
809 interProcBoundaries[procI].size()
812 curProcProcessorPatchStartIndex.setSize
814 interProcBoundaries[procI].size()
819 auto curInterProcBdrsIter =
820 interProcBoundaries[procI].cbegin();
822 auto curInterProcBEdgesIter =
823 interProcBEdges[procI].cbegin();
828 curInterProcBdrsIter.good()
829 && curInterProcBEdgesIter.good();
830 ++curInterProcBdrsIter,
831 ++curInterProcBEdgesIter
835 curInterProcBdrsIter();
847 for (
const label edgei : *curInterProcBEdgesIter)
853 if (faceToProc_[owner[edgei]] == procI)
855 curProcEdgeAddressing[nEdges] = edgei;
861 curProcEdgeAddressing[nEdges] = edgei;
876 Info <<
"\nCalculating processor boundary addressing" <<
endl;
882 forAll(procPatchSize_, procI)
885 const labelList oldPatchSizes = procPatchSize_[procI];
887 const labelList oldPatchStarts = procPatchStartIndex_[procI];
889 labelList& curPatchSizes = procPatchSize_[procI];
891 labelList& curPatchStarts = procPatchStartIndex_[procI];
893 const labelList& curProcessorPatchSizes =
894 procProcessorPatchSize_[procI];
896 labelList& curBoundaryAddressing = procBoundaryAddressing_[procI];
901 + curProcessorPatchSizes.size()
906 forAll(oldPatchSizes, patchI)
912 curBoundaryAddressing[
nPatches] = patchI;
914 curPatchSizes[
nPatches] = oldPatchSizes[patchI];
916 curPatchStarts[
nPatches] = oldPatchStarts[patchI];
926 forAll(curProcessorPatchSizes, procPatchI)
928 curBoundaryAddressing[
nPatches] = -1;
933 curBoundaryAddressing.setSize(
nPatches);
956 for (label procI = 0; procI < nProcs(); procI++)
959 const labelList& curEdgeLabels = procEdgeAddressing_[procI];
962 const labelList& curProcessorPatchStarts =
963 procProcessorPatchStartIndex_[procI];
965 const labelList& curProcessorPatchSizes =
966 procProcessorPatchSize_[procI];
971 forAll(curProcessorPatchStarts, patchI)
973 const label curStart = curProcessorPatchStarts[patchI];
974 const label curEnd = curStart + curProcessorPatchSizes[patchI];
978 label edgeI = curStart;
985 const label curE = curEdgeLabels[edgeI];
987 const edge&
e = edges[curE];
991 if (pointsUsage[
e[pointI]] == 0)
994 pointsUsage[
e[pointI]] = patchI + 1;
996 else if (pointsUsage[
e[pointI]] != patchI + 1)
999 gSharedPoints.insert(
e[pointI]);
1007 globallySharedPoints_ = gSharedPoints.sortedToc();
1013 for (label procI = 0; procI < nProcs(); procI++)
1015 fileName processorCasePath
1017 time().caseName()/(
"processor" +
Foam::name(procI))
1035 processorDb.timeName(),
1048 const labelList& curEdgeAddressing = procEdgeAddressing_[procI];
1050 const labelList& curPatchStartIndex = procPatchStartIndex_[procI];
1051 const labelList& curPatchSize = procPatchSize_[procI];
1053 const labelList& curProcessorPatchStartIndex =
1054 procProcessorPatchStartIndex_[procI];
1056 const labelList& curProcessorPatchSize =
1057 procProcessorPatchSize_[procI];
1059 labelListList& curPatchEdgeLabels = procPatchEdgeLabels_[procI];
1060 curPatchEdgeLabels.
resize 1063 + curProcessorPatchSize.size()
1066 forAll(curPatchSize, patchI)
1068 labelList& curEdgeLabels = curPatchEdgeLabels[patchI];
1069 curEdgeLabels.
setSize(curPatchSize[patchI], -1);
1075 int i=curPatchStartIndex[patchI];
1076 i<(curPatchStartIndex[patchI]+curPatchSize[patchI]);
1080 curEdgeLabels[edgeI] =
1081 procMeshEdgesMap_[procI][curEdgeAddressing[i]];
1086 forAll(curProcessorPatchSize, patchI)
1089 curPatchEdgeLabels[curPatchSize.size() + patchI];
1090 curEdgeLabels.
setSize(curProcessorPatchSize[patchI], -1);
1096 int i=curProcessorPatchStartIndex[patchI];
1097 i<(curProcessorPatchStartIndex[patchI]
1098 +curProcessorPatchSize[patchI]);
1102 curEdgeLabels[edgeI] =
1103 procMeshEdgesMap_[procI][curEdgeAddressing[i]];
1113 const word& polyMeshRegionName =
mesh().
name();
1115 Info<<
"\nConstructing processor FA meshes" <<
endl;
1118 Map<label> sharedPointLookup(2*globallySharedPoints_.size());
1120 forAll(globallySharedPoints_, pointi)
1122 sharedPointLookup.insert(globallySharedPoints_[pointi], pointi);
1125 label maxProcFaces = 0;
1126 label totProcFaces = 0;
1127 label maxProcEdges = 0;
1128 label totProcEdges = 0;
1129 label maxProcPatches = 0;
1130 label totProcPatches = 0;
1133 for (label procI = 0; procI < nProcs(); procI++)
1137 fileName processorCasePath
1139 time().caseName()/(
"processor" +
Foam::name(procI))
1156 processorDb.timeName(),
1165 "boundaryProcAddressing",
1183 const labelList& curBoundaryAddressing =
1184 procBoundaryAddressing_[procI];
1186 const labelList& curPatchSizes = procPatchSize_[procI];
1188 const labelList& curNeighbourProcessors =
1189 procNeighbourProcessors_[procI];
1191 const labelList& curProcessorPatchSizes =
1192 procProcessorPatchSize_[procI];
1195 procPatchEdgeLabels_[procI];
1201 curPatchSizes.size() + curProcessorPatchSizes.size()
1206 forAll(curPatchSizes, patchi)
1210 const label neiPolyPatchId =
1211 fvBoundaryProcAddressing.
find 1213 meshPatches[curBoundaryAddressing[patchi]]
1214 .ngbPolyPatchIndex()
1220 meshPatches[curBoundaryAddressing[patchi]].clone
1222 procMesh.boundary(),
1231 forAll(curProcessorPatchSizes, procPatchI)
1238 new processorFaPatch
1242 procMesh.boundary(),
1245 curNeighbourProcessors[procPatchI]
1253 procMesh.addFaPatches(procPatches);
1261 Info<<
nl <<
"Processor " << procI;
1263 if (procMesh.nFaces())
1272 Info<<
"Number of faces = " << procMesh.nFaces() <<
nl;
1274 if (procMesh.nFaces())
1276 Info<<
" Number of points = " << procMesh.nPoints() <<
nl;
1279 totProcFaces += procMesh.nFaces();
1280 maxProcFaces =
max(maxProcFaces, procMesh.nFaces());
1282 label nBoundaryEdges = 0;
1284 label nProcEdges = 0;
1286 for (
const faPatch& fap : procMesh.boundary())
1288 const auto* ppp = isA<processorFaPatch>(fap);
1292 const auto& procPatch = *ppp;
1294 Info<<
" Number of edges shared with processor " 1295 << procPatch.neighbProcNo() <<
" = " 1296 << procPatch.size() <<
nl;
1298 nProcEdges += procPatch.size();
1303 nBoundaryEdges += fap.size();
1307 if (procMesh.nFaces() && (nBoundaryEdges || nProcEdges))
1310 <<
" Number of processor edges = " << nProcEdges <<
nl 1311 <<
" Number of boundary edges = " << nBoundaryEdges <<
nl;
1314 totProcEdges += nProcEdges;
1316 maxProcEdges =
max(maxProcEdges, nProcEdges);
1333 ioAddr.rename(
"pointProcAddressing");
1334 IOListRef<label>(ioAddr, procPatchPointAddressing_[procI]).
write();
1337 ioAddr.rename(
"edgeProcAddressing");
1338 IOListRef<label>(ioAddr, procEdgeAddressing_[procI]).
write();
1341 ioAddr.rename(
"faceProcAddressing");
1342 IOListRef<label>(ioAddr, procFaceAddressing_[procI]).
write();
1345 ioAddr.rename(
"boundaryProcAddressing");
1346 IOListRef<label>(ioAddr, procBoundaryAddressing_[procI]).
write();
1352 <<
"Number of processor edges = " << (totProcEdges/2) <<
nl 1353 <<
"Max number of faces = " << maxProcFaces;
1355 if (maxProcFaces != totProcFaces)
1357 scalar avgValue = scalar(totProcFaces)/nProcs_;
1359 Info<<
" (" << 100.0*(maxProcFaces-avgValue)/avgValue
1360 <<
"% above average " << avgValue <<
')';
1364 Info<<
"Max number of processor patches = " << maxProcPatches;
1367 scalar avgValue = scalar(totProcPatches)/nProcs_;
1369 Info<<
" (" << 100.0*(maxProcPatches-avgValue)/avgValue
1370 <<
"% above average " << avgValue <<
')';
1374 Info<<
"Max number of edges between processors = " << maxProcEdges;
1377 scalar avgValue = scalar(totProcEdges)/nProcs_;
1379 Info<<
" (" << 100.0*(maxProcEdges-avgValue)/avgValue
1380 <<
"% 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 ...
List< labelList > labelListList
A List of labelList.
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.
label find(const T &val, label pos=0) const
Find index of the first occurrence of the value.
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.
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.
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.
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 INVALID.
List< edge > edgeList
A List of edges.
bool writeDecomposition()
Write decomposition.
label size() const noexcept
The number of elements 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)
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.
const fileName & rootPath() const
Return the Time::rootPath()
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.
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.
const fileName & caseName() const
Return the Time::caseName()
#define FatalErrorIn(functionName)
Report an error message using Foam::FatalError.
IOList< label > labelIOList
Label container classes.
static constexpr const zero Zero
Global zero (0)