63 void Foam::globalMeshData::initProcAddr()
66 processorPatchIndices_ = -1;
69 processorPatchNeighbours_ = -1;
75 label nNeighbours = 0;
79 if (isA<processorPolyPatch>(mesh_.
boundaryMesh()[patchi]))
81 processorPatches_[nNeighbours] = patchi;
82 processorPatchIndices_[patchi] = nNeighbours++;
85 processorPatches_.
setSize(nNeighbours);
93 for (
const label patchi : processorPatches_)
97 refCast<const processorPolyPatch>
104 toNeighbour << processorPatchIndices_[patchi];
107 pBufs.finishedSends();
109 for (
const label patchi : processorPatches_)
111 UIPstream fromNeighbour
113 refCast<const processorPolyPatch>
120 fromNeighbour >> processorPatchNeighbours_[patchi];
126 void Foam::globalMeshData::calcSharedPoints()
const
131 || sharedPointLabelsPtr_
132 || sharedPointAddrPtr_
141 globalPoints parallelPoints(mesh_,
false,
true);
145 forAll(parallelPoints.pointPoints(), i)
147 const labelList& pPoints = parallelPoints.pointPoints()[i];
149 parallelPoints.transformedPointPoints()[i];
151 if (pPoints.size()+transPPoints.size() > 0)
158 globalIndex masterNumbering(nMaster);
160 nGlobalPoints_ = masterNumbering.size();
167 labelList master(parallelPoints.map().constructSize(), -1);
168 forAll(parallelPoints.pointPoints(), i)
170 const labelList& pPoints = parallelPoints.pointPoints()[i];
172 parallelPoints.transformedPointPoints()[i];
174 if (pPoints.size()+transPPoints.size() > 0)
176 master[i] = masterNumbering.toGlobal(nMaster);
179 master[pPoints[j]] = master[i];
183 master[transPPoints[j]] = master[i];
201 parallelPoints.map().reverseDistribute
203 parallelPoints.map().constructSize(),
210 forAll(parallelPoints.pointPoints(), i)
218 sharedPointLabelsPtr_.reset(
new labelList(nMaster));
219 labelList& sharedPointLabels = sharedPointLabelsPtr_();
220 sharedPointAddrPtr_.reset(
new labelList(nMaster));
221 labelList& sharedPointAddr = sharedPointAddrPtr_();
224 forAll(parallelPoints.pointPoints(), i)
229 sharedPointLabels[nMaster] = i;
230 sharedPointAddr[nMaster] = master[i];
237 Pout<<
"globalMeshData : nGlobalPoints_:" << nGlobalPoints_ <<
nl
238 <<
"globalMeshData : sharedPointLabels_:"
239 << sharedPointLabelsPtr_().size() <<
nl
240 <<
"globalMeshData : sharedPointAddr_:"
241 << sharedPointAddrPtr_().size() <<
endl;
246 void Foam::globalMeshData::countSharedEdges
248 const EdgeMap<labelList>& procSharedEdges,
249 EdgeMap<label>& globalShared,
256 const edge&
e = iter.key();
258 auto globalFnd = globalShared.find(
e);
260 if (globalFnd.found())
262 if (globalFnd() == -1)
266 globalFnd() = sharedEdgeI++;
272 if (iter().size() == 1)
275 globalShared.insert(
e, -1);
281 globalShared.insert(
e, sharedEdgeI++);
288 void Foam::globalMeshData::calcSharedEdges()
const
298 || sharedEdgeLabelsPtr_
299 || sharedEdgeAddrPtr_
307 const labelList& sharedPtAddr = sharedPointAddr();
308 const labelList& sharedPtLabels = sharedPointLabels();
312 Map<label> meshToShared(2*sharedPtLabels.size());
315 meshToShared.insert(sharedPtLabels[i], i);
321 EdgeMap<labelList> localShared(2*sharedPtAddr.size());
323 const edgeList& edges = mesh_.edges();
327 const edge&
e = edges[edgeI];
329 const auto e0Fnd = meshToShared.cfind(
e[0]);
333 const auto e1Fnd = meshToShared.cfind(
e[1]);
343 sharedPtAddr[e0Fnd()],
344 sharedPtAddr[e1Fnd()]
347 auto iter = localShared.find(sharedEdge);
352 localShared.insert(sharedEdge,
labelList(1, edgeI));
359 const label sz = edgeLabels.size();
360 edgeLabels.setSize(sz+1);
361 edgeLabels[sz] = edgeI;
377 EdgeMap<label> globalShared(nGlobalPoints());
381 label sharedEdgeI = 0;
386 Pout<<
"globalMeshData::calcSharedEdges : Merging in from proc0 : "
387 << localShared.size() <<
endl;
389 countSharedEdges(localShared, globalShared, sharedEdgeI);
398 EdgeMap<labelList> procSharedEdges(fromSlave);
402 Pout<<
"globalMeshData::calcSharedEdges : "
403 <<
"Merging in from proc"
404 <<
Foam::name(slave) <<
" : " << procSharedEdges.size()
407 countSharedEdges(procSharedEdges, globalShared, sharedEdgeI);
415 EdgeMap<label> oldSharedEdges(globalShared);
417 globalShared.clear();
423 globalShared.insert(iter.key(), iter());
428 Pout<<
"globalMeshData::calcSharedEdges : Filtered "
429 << oldSharedEdges.size()
430 <<
" down to " << globalShared.size() <<
endl;
442 toSlave << globalShared;
455 toMaster << localShared;
464 fromMaster >> globalShared;
471 nGlobalEdges_ = globalShared.size();
473 DynamicList<label> dynSharedEdgeLabels(globalShared.size());
474 DynamicList<label> dynSharedEdgeAddr(globalShared.size());
478 const edge&
e = iter.key();
480 const auto edgeFnd = globalShared.cfind(
e);
488 for (
const label edgei : edgeLabels)
491 dynSharedEdgeLabels.append(edgei);
494 dynSharedEdgeAddr.append(edgeFnd());
500 sharedEdgeLabelsPtr_.reset(
new labelList());
501 labelList& sharedEdgeLabels = sharedEdgeLabelsPtr_();
502 sharedEdgeLabels.transfer(dynSharedEdgeLabels);
504 sharedEdgeAddrPtr_.reset(
new labelList());
505 labelList& sharedEdgeAddr = sharedEdgeAddrPtr_();
506 sharedEdgeAddr.transfer(dynSharedEdgeAddr);
510 Pout<<
"globalMeshData : nGlobalEdges_:" << nGlobalEdges_ <<
nl
511 <<
"globalMeshData : sharedEdgeLabels:" << sharedEdgeLabels.size()
513 <<
"globalMeshData : sharedEdgeAddr:" << sharedEdgeAddr.size()
519 void Foam::globalMeshData::calcGlobalPointSlaves()
const
523 Pout<<
"globalMeshData::calcGlobalPointSlaves() :"
524 <<
" calculating coupled master to slave point addressing."
529 globalPoints globalData(mesh_, coupledPatch(),
true,
true);
531 globalPointSlavesPtr_.reset
535 std::move(globalData.pointPoints())
538 globalPointTransformedSlavesPtr_.reset
542 std::move(globalData.transformedPointPoints())
546 globalPointSlavesMapPtr_.reset
550 std::move(globalData.map())
556 void Foam::globalMeshData::calcPointConnectivity
558 List<labelPairList>& allPointConnectivity
561 const globalIndexAndTransform& transforms = globalTransforms();
563 const labelListList& transformedSlaves = globalPointTransformedSlaves();
567 labelPairList myData(globalPointSlavesMap().constructSize());
570 myData[pointi] = transforms.encode
574 transforms.nullTransformIndex()
578 globalPointSlavesMap().distribute(myData);
582 allPointConnectivity.setSize(globalPointSlavesMap().constructSize());
590 const labelList& pSlaves = slaves[pointi];
591 const labelList& pTransformSlaves = transformedSlaves[pointi];
593 if (pSlaves.size()+pTransformSlaves.size())
597 pConnectivity.setSize(1+pSlaves.size()+pTransformSlaves.size());
601 pConnectivity[connI++] = myData[pointi];
605 pConnectivity[connI++] = myData[pSlaves[i]];
608 forAll(pTransformSlaves, i)
611 label transformI = globalPointSlavesMap().whichTransform
616 const labelPair&
n = myData[pTransformSlaves[i]];
617 label proci = transforms.processor(
n);
618 label index = transforms.index(
n);
619 pConnectivity[connI++] = transforms.encode
630 allPointConnectivity[pSlaves[i]] = pConnectivity;
632 forAll(pTransformSlaves, i)
634 allPointConnectivity[pTransformSlaves[i]] = pConnectivity;
645 if (pConnectivity.size() == 0)
647 pConnectivity.setSize(1, myData[pointi]);
652 globalPointSlavesMap().reverseDistribute
660 void Foam::globalMeshData::calcGlobalPointEdges
663 List<labelPairList>& globalPointPoints
666 const edgeList& edges = coupledPatch().edges();
667 const labelListList& pointEdges = coupledPatch().pointEdges();
668 const globalIndex& globalEdgeNumbers = globalEdgeNumbering();
670 const labelListList& transformedSlaves = globalPointTransformedSlaves();
671 const globalIndexAndTransform& transforms = globalTransforms();
675 globalPointEdges.setSize(globalPointSlavesMap().constructSize());
676 globalPointPoints.setSize(globalPointSlavesMap().constructSize());
677 forAll(pointEdges, pointi)
679 const labelList& pEdges = pointEdges[pointi];
680 globalPointEdges[pointi] = globalEdgeNumbers.toGlobal(pEdges);
683 globalPPoints.setSize(pEdges.size());
686 label otherPointi = edges[pEdges[i]].otherVertex(pointi);
687 globalPPoints[i] = transforms.encode
691 transforms.nullTransformIndex()
697 globalPointSlavesMap().distribute(globalPointEdges);
698 globalPointSlavesMap().distribute(globalPointPoints);
702 const labelList& pSlaves = slaves[pointi];
703 const labelList& pTransformSlaves = transformedSlaves[pointi];
708 n += globalPointEdges[pSlaves[i]].size();
710 forAll(pTransformSlaves, i)
712 n += globalPointEdges[pTransformSlaves[i]].size();
717 labelList& globalPEdges = globalPointEdges[pointi];
718 label sz = globalPEdges.size();
722 const labelList& otherData = globalPointEdges[pSlaves[i]];
725 globalPEdges[sz++] = otherData[j];
728 forAll(pTransformSlaves, i)
731 globalPointEdges[pTransformSlaves[i]];
734 globalPEdges[sz++] = otherData[j];
741 globalPointEdges[pSlaves[i]] = globalPEdges;
743 forAll(pTransformSlaves, i)
745 globalPointEdges[pTransformSlaves[i]] = globalPEdges;
753 label sz = globalPPoints.size();
754 globalPPoints.setSize(sz +
n);
759 const labelPairList& otherData = globalPointPoints[pSlaves[i]];
762 globalPPoints[sz++] = otherData[j];
766 forAll(pTransformSlaves, i)
769 label transformI = globalPointSlavesMap().whichTransform
775 globalPointPoints[pTransformSlaves[i]];
780 label proci = transforms.processor(
n);
781 label index = transforms.index(
n);
782 globalPPoints[sz++] = transforms.encode
794 globalPointPoints[pSlaves[i]] = globalPPoints;
796 forAll(pTransformSlaves, i)
798 globalPointPoints[pTransformSlaves[i]] = globalPPoints;
803 globalPointSlavesMap().reverseDistribute
809 globalPointSlavesMap().reverseDistribute
817 Foam::label Foam::globalMeshData::findTransform
821 const label localPoint
824 const globalIndexAndTransform& transforms = globalTransforms();
826 const label remoteProci = transforms.processor(remotePoint);
827 const label remoteIndex = transforms.index(remotePoint);
829 label remoteTransformI = -1;
830 label localTransformI = -1;
833 label proci = transforms.processor(info[i]);
834 label pointi = transforms.index(info[i]);
835 label transformI = transforms.transformIndex(info[i]);
839 localTransformI = transformI;
844 if (proci == remoteProci && pointi == remoteIndex)
846 remoteTransformI = transformI;
854 if (remoteTransformI == -1 || localTransformI == -1)
857 <<
"Problem. Cannot find " << remotePoint
858 <<
" or " << localPoint <<
" "
859 << coupledPatch().localPoints()[localPoint]
862 <<
"remoteTransformI:" << remoteTransformI <<
endl
863 <<
"localTransformI:" << localTransformI
867 return transforms.subtractTransformIndex
875 void Foam::globalMeshData::calcGlobalEdgeSlaves()
const
879 Pout<<
"globalMeshData::calcGlobalEdgeSlaves() :"
880 <<
" calculating coupled master to slave edge addressing." <<
endl;
883 const edgeList& edges = coupledPatch().edges();
884 const globalIndex& globalEdgeNumbers = globalEdgeNumbering();
885 const globalIndexAndTransform& transforms = globalTransforms();
898 List<labelPairList> allPointConnectivity;
899 calcPointConnectivity(allPointConnectivity);
905 List<labelPairList> globalPointPoints;
906 calcGlobalPointEdges(globalPointEdges, globalPointPoints);
919 List<labelPairList> allEdgeConnectivity(edges.size());
923 const edge&
e = edges[edgeI];
924 const labelList& pEdges0 = globalPointEdges[
e[0]];
926 const labelList& pEdges1 = globalPointEdges[
e[1]];
930 DynamicList<labelPair> eEdges(2);
938 transforms.nullTransformIndex()
948 pEdges0[i] == pEdges1[j]
949 && pEdges0[i] != globalEdgeNumbers.toGlobal(edgeI)
961 label transform0 = findTransform
963 allPointConnectivity[
e[0]],
967 label transform1 = findTransform
969 allPointConnectivity[
e[1]],
974 if (transform0 == transform1)
976 label proci = globalEdgeNumbers.whichProcID(pEdges0[i]);
982 globalEdgeNumbers.toLocal(proci, pEdges0[i]),
991 allEdgeConnectivity[edgeI].transfer(eEdges);
994 allEdgeConnectivity[edgeI],
1003 globalEdgeSlavesPtr_.reset(
new labelListList(edges.size()));
1005 List<labelPairList> transformedEdges(edges.size());
1006 forAll(allEdgeConnectivity, edgeI)
1009 if (edgeInfo.size() >= 2)
1011 const labelPair& masterInfo = edgeInfo[0];
1017 transforms.processor(masterInfo)
1020 && (transforms.index(masterInfo) == edgeI)
1024 labelList& eEdges = globalEdgeSlaves[edgeI];
1025 eEdges.
setSize(edgeInfo.size()-1);
1028 trafoEEdges.setSize(edgeInfo.size()-1);
1030 label nonTransformI = 0;
1031 label transformI = 0;
1033 for (label i = 1; i < edgeInfo.size(); i++)
1036 label proci = transforms.processor(info);
1037 label index = transforms.index(info);
1038 label
transform = transforms.transformIndex
1043 if (
transform == transforms.nullTransformIndex())
1045 eEdges[nonTransformI++] = globalEdgeNumbers.toGlobal
1053 trafoEEdges[transformI++] = info;
1057 eEdges.setSize(nonTransformI);
1058 trafoEEdges.setSize(transformI);
1068 globalEdgeSlavesMapPtr_.reset
1077 globalEdgeTransformedSlavesPtr_(),
1086 Pout<<
"globalMeshData::calcGlobalEdgeSlaves() :"
1087 <<
" coupled edges:" << edges.size()
1088 <<
" additional coupled edges:"
1089 << globalEdgeSlavesMapPtr_().constructSize() - edges.size()
1095 void Foam::globalMeshData::calcGlobalEdgeOrientation()
const
1099 Pout<<
"globalMeshData::calcGlobalEdgeOrientation() :"
1100 <<
" calculating edge orientation w.r.t. master edge." <<
endl;
1103 const globalIndex& globalPoints = globalPointNumbering();
1108 const mapDistribute& map = globalPointSlavesMap();
1110 masterPoint.setSize(map.constructSize());
1113 for (label pointi = 0; pointi < coupledPatch().nPoints(); pointi++)
1115 masterPoint[pointi] = globalPoints.toGlobal(pointi);
1120 globalPointSlaves(),
1121 globalPointTransformedSlaves(),
1132 const mapDistribute& map = globalEdgeSlavesMap();
1134 const labelListList& transformedSlaves = globalEdgeTransformedSlaves();
1140 for (label edgeI = 0; edgeI < coupledPatch().nEdges(); edgeI++)
1145 slaves[edgeI].size()
1146 + transformedSlaves[edgeI].size()
1153 const edge&
e = coupledPatch().edges()[edgeI];
1167 minEqOp<labelPair>()
1171 globalEdgeOrientationPtr_.reset
1173 new bitSet(coupledPatch().nEdges())
1175 bitSet& globalEdgeOrientation = globalEdgeOrientationPtr_();
1177 forAll(coupledPatch().edges(), edgeI)
1182 const edge&
e = coupledPatch().edges()[edgeI];
1192 masterEdgeVerts[edgeI]
1197 <<
"problem : my edge:" <<
e
1198 <<
" in master points:" << masterE
1199 <<
" v.s. masterEdgeVerts:" << masterEdgeVerts[edgeI]
1204 globalEdgeOrientation.set(edgeI, (stat == 1));
1209 globalEdgeOrientation.set(edgeI,
true);
1216 Pout<<
"globalMeshData::calcGlobalEdgeOrientation() :"
1217 <<
" finished calculating edge orientation."
1223 void Foam::globalMeshData::calcPointBoundaryFaces
1228 const polyBoundaryMesh&
bMesh = mesh_.boundaryMesh();
1229 const Map<label>& meshPointMap = coupledPatch().meshPointMap();
1235 for (
const polyPatch& pp :
bMesh)
1239 for (
const face&
f : pp)
1243 const auto iter = meshPointMap.cfind(
f[fp]);
1246 nPointFaces[iter.val()]++;
1256 pointBoundaryFaces.setSize(coupledPatch().
nPoints());
1257 forAll(nPointFaces, pointi)
1259 pointBoundaryFaces[pointi].setSize(nPointFaces[pointi]);
1268 const polyPatch& pp =
bMesh[patchi];
1274 const face&
f = pp[i];
1277 const auto iter = meshPointMap.cfind(
f[fp]);
1282 pp.start() + i - mesh_.nInternalFaces();
1283 pointBoundaryFaces[iter()][nPointFaces[iter()]++] =
1293 void Foam::globalMeshData::calcGlobalPointBoundaryFaces()
const
1297 Pout<<
"globalMeshData::calcGlobalPointBoundaryFaces() :"
1298 <<
" calculating coupled point to boundary face addressing."
1304 calcPointBoundaryFaces(pointBoundaryFaces);
1308 globalBoundaryFaceNumberingPtr_.reset
1310 new globalIndex(mesh_.nBoundaryFaces())
1312 globalIndex& globalIndices = globalBoundaryFaceNumberingPtr_();
1316 globalPointBoundaryFacesPtr_.reset
1320 labelListList& globalPointBoundaryFaces = globalPointBoundaryFacesPtr_();
1322 forAll(pointBoundaryFaces, pointi)
1324 const labelList& bFaces = pointBoundaryFaces[pointi];
1325 labelList& globalFaces = globalPointBoundaryFaces[pointi];
1326 globalFaces.
setSize(bFaces.size());
1329 globalFaces[i] = globalIndices.toGlobal(bFaces[i]);
1335 globalPointSlavesMap().distribute
1337 globalPointBoundaryFaces,
1346 globalPointTransformedSlaves();
1347 const globalIndexAndTransform& transforms = globalTransforms();
1351 List<labelPairList> transformedFaces(pointSlaves.size());
1354 forAll(pointSlaves, pointi)
1356 const labelList& slaves = pointSlaves[pointi];
1357 const labelList& transformedSlaves = pointTransformSlaves[pointi];
1359 if (slaves.size() > 0)
1361 labelList& myBFaces = globalPointBoundaryFaces[pointi];
1362 label sz = myBFaces.size();
1368 n += globalPointBoundaryFaces[slaves[i]].size();
1371 myBFaces.setSize(sz+
n);
1376 globalPointBoundaryFaces[slaves[i]];
1381 for (
const label slave : slaveBFaces)
1383 if (!SubList<label>(myBFaces, sz).
found(slave))
1385 myBFaces[
n++] = slave;
1393 if (transformedSlaves.size() > 0)
1395 const labelList& untrafoFaces = globalPointBoundaryFaces[pointi];
1398 label sz = myBFaces.size();
1402 forAll(transformedSlaves, i)
1404 n += globalPointBoundaryFaces[transformedSlaves[i]].size();
1407 myBFaces.setSize(sz+
n);
1409 forAll(transformedSlaves, i)
1411 label transformI = globalPointSlavesMap().whichTransform
1413 transformedSlaves[i]
1417 globalPointBoundaryFaces[transformedSlaves[i]];
1419 for (
const label slave : slaveBFaces)
1422 if (!untrafoFaces.found(slave))
1424 label proci = globalIndices.whichProcID(slave);
1425 label facei = globalIndices.toLocal(proci, slave);
1427 myBFaces[
n++] = transforms.encode
1440 if (slaves.size() + transformedSlaves.size() == 0)
1442 globalPointBoundaryFaces[pointi].clear();
1449 globalPointTransformedBoundaryFacesPtr_.reset
1454 globalPointBoundaryFacesMapPtr_.reset
1459 globalPointBoundaryFaces,
1463 globalPointTransformedBoundaryFacesPtr_(),
1468 globalPointBoundaryFaces.setSize(coupledPatch().
nPoints());
1469 globalPointTransformedBoundaryFacesPtr_().setSize(coupledPatch().
nPoints());
1473 Pout<<
"globalMeshData::calcGlobalPointBoundaryFaces() :"
1474 <<
" coupled points:" << coupledPatch().nPoints()
1475 <<
" local boundary faces:" << globalIndices.localSize()
1476 <<
" additional coupled faces:"
1477 << globalPointBoundaryFacesMapPtr_().constructSize()
1478 - globalIndices.localSize()
1484 void Foam::globalMeshData::calcGlobalPointBoundaryCells()
const
1488 Pout<<
"globalMeshData::calcGlobalPointBoundaryCells() :"
1489 <<
" calculating coupled point to boundary cell addressing."
1497 Map<label> meshCellMap(4*coupledPatch().
nPoints());
1498 DynamicList<label> cellMap(meshCellMap.size());
1503 forAll(coupledPatch().meshPoints(), pointi)
1505 label meshPointi = coupledPatch().meshPoints()[pointi];
1506 const labelList& pCells = mesh_.pointCells(meshPointi);
1508 labelList& bCells = pointBoundaryCells[pointi];
1509 bCells.
setSize(pCells.size());
1513 const label celli = pCells[i];
1514 const auto fnd = meshCellMap.cfind(celli);
1522 meshCellMap.insert(celli, bCelli);
1523 cellMap.append(celli);
1531 boundaryCellsPtr_.reset(
new labelList(std::move(cellMap)));
1532 labelList& boundaryCells = boundaryCellsPtr_();
1538 globalBoundaryCellNumberingPtr_.reset
1540 new globalIndex(boundaryCells.size())
1542 globalIndex& globalIndices = globalBoundaryCellNumberingPtr_();
1545 globalPointBoundaryCellsPtr_.reset
1549 labelListList& globalPointBoundaryCells = globalPointBoundaryCellsPtr_();
1551 forAll(pointBoundaryCells, pointi)
1553 const labelList& pCells = pointBoundaryCells[pointi];
1554 labelList& globalCells = globalPointBoundaryCells[pointi];
1555 globalCells.
setSize(pCells.size());
1558 globalCells[i] = globalIndices.toGlobal(pCells[i]);
1564 globalPointSlavesMap().distribute
1566 globalPointBoundaryCells,
1574 globalPointTransformedSlaves();
1575 const globalIndexAndTransform& transforms = globalTransforms();
1577 List<labelPairList> transformedCells(pointSlaves.size());
1580 forAll(pointSlaves, pointi)
1582 const labelList& slaves = pointSlaves[pointi];
1583 const labelList& transformedSlaves = pointTransformSlaves[pointi];
1585 if (slaves.size() > 0)
1587 labelList& myBCells = globalPointBoundaryCells[pointi];
1588 label sz = myBCells.size();
1594 n += globalPointBoundaryCells[slaves[i]].size();
1597 myBCells.setSize(sz+
n);
1602 globalPointBoundaryCells[slaves[i]];
1607 for (
const label slave : slaveBCells)
1609 if (!SubList<label>(myBCells, sz).
found(slave))
1611 myBCells[
n++] = slave;
1619 if (transformedSlaves.size() > 0)
1621 const labelList& untrafoCells = globalPointBoundaryCells[pointi];
1624 label sz = myBCells.size();
1628 forAll(transformedSlaves, i)
1630 n += globalPointBoundaryCells[transformedSlaves[i]].size();
1633 myBCells.setSize(sz+
n);
1635 forAll(transformedSlaves, i)
1637 label transformI = globalPointSlavesMap().whichTransform
1639 transformedSlaves[i]
1643 globalPointBoundaryCells[transformedSlaves[i]];
1645 for (
const label slave : slaveBCells)
1648 if (!untrafoCells.found(slave))
1650 label proci = globalIndices.whichProcID(slave);
1651 label celli = globalIndices.toLocal(proci, slave);
1652 myBCells[
n++] = transforms.encode
1664 if (slaves.size() + transformedSlaves.size() == 0)
1666 globalPointBoundaryCells[pointi].clear();
1673 globalPointTransformedBoundaryCellsPtr_.reset
1678 globalPointBoundaryCellsMapPtr_.reset
1683 globalPointBoundaryCells,
1687 globalPointTransformedBoundaryCellsPtr_(),
1692 globalPointBoundaryCells.setSize(coupledPatch().
nPoints());
1693 globalPointTransformedBoundaryCellsPtr_().setSize(coupledPatch().
nPoints());
1697 Pout<<
"globalMeshData::calcGlobalPointBoundaryCells() :"
1698 <<
" coupled points:" << coupledPatch().nPoints()
1699 <<
" local boundary cells:" << globalIndices.localSize()
1700 <<
" additional coupled cells:"
1701 << globalPointBoundaryCellsMapPtr_().constructSize()
1702 - globalIndices.localSize()
1708 void Foam::globalMeshData::calcGlobalCoPointSlaves()
const
1712 Pout<<
"globalMeshData::calcGlobalCoPointSlaves() :"
1713 <<
" calculating coupled master to collocated"
1714 <<
" slave point addressing." <<
endl;
1718 globalPoints globalData(mesh_, coupledPatch(),
true,
false);
1720 globalCoPointSlavesPtr_.reset
1724 std::move(globalData.pointPoints())
1727 globalCoPointSlavesMapPtr_.reset
1731 std::move(globalData.map())
1737 Pout<<
"globalMeshData::calcGlobalCoPointSlaves() :"
1738 <<
" finished calculating coupled master to collocated"
1739 <<
" slave point addressing." <<
endl;
1753 processorPatches_(0),
1754 processorPatchIndices_(0),
1755 processorPatchNeighbours_(0),
1757 sharedPointLabelsPtr_(nullptr),
1758 sharedPointAddrPtr_(nullptr),
1759 sharedPointGlobalLabelsPtr_(nullptr),
1761 sharedEdgeLabelsPtr_(nullptr),
1762 sharedEdgeAddrPtr_(nullptr)
1779 nGlobalPoints_ = -1;
1780 sharedPointLabelsPtr_.clear();
1781 sharedPointAddrPtr_.clear();
1782 sharedPointGlobalLabelsPtr_.clear();
1786 sharedEdgeLabelsPtr_.clear();
1787 sharedEdgeAddrPtr_.clear();
1790 coupledPatchPtr_.clear();
1791 coupledPatchMeshEdgesPtr_.clear();
1792 coupledPatchMeshEdgeMapPtr_.clear();
1793 globalTransformsPtr_.clear();
1796 globalPointNumberingPtr_.clear();
1797 globalPointSlavesPtr_.clear();
1798 globalPointTransformedSlavesPtr_.clear();
1799 globalPointSlavesMapPtr_.clear();
1801 globalEdgeNumberingPtr_.clear();
1802 globalEdgeSlavesPtr_.clear();
1803 globalEdgeTransformedSlavesPtr_.clear();
1804 globalEdgeOrientationPtr_.clear();
1805 globalEdgeSlavesMapPtr_.clear();
1808 globalBoundaryFaceNumberingPtr_.clear();
1809 globalPointBoundaryFacesPtr_.clear();
1810 globalPointTransformedBoundaryFacesPtr_.clear();
1811 globalPointBoundaryFacesMapPtr_.clear();
1814 boundaryCellsPtr_.clear();
1815 globalBoundaryCellNumberingPtr_.clear();
1816 globalPointBoundaryCellsPtr_.clear();
1817 globalPointTransformedBoundaryCellsPtr_.clear();
1818 globalPointBoundaryCellsMapPtr_.clear();
1821 globalCoPointSlavesPtr_.clear();
1822 globalCoPointSlavesMapPtr_.clear();
1830 if (!sharedPointGlobalLabelsPtr_)
1832 sharedPointGlobalLabelsPtr_.reset
1834 new labelList(sharedPointLabels().size())
1836 labelList& sharedPointGlobalLabels = sharedPointGlobalLabelsPtr_();
1840 "pointProcAddressing",
1841 mesh_.facesInstance()/mesh_.meshSubDir,
1850 Pout<<
"globalMeshData::sharedPointGlobalLabels : "
1851 <<
"Reading pointProcAddressing" <<
endl;
1863 sharedPointGlobalLabels[i] = pointProcAddressing[pointi];
1868 Pout<<
"globalMeshData::sharedPointGlobalLabels :"
1869 <<
" Setting pointProcAddressing to -1" <<
endl;
1871 sharedPointGlobalLabels = -1;
1875 return *sharedPointGlobalLabelsPtr_;
1885 const labelList& pointAddr = sharedPointAddr();
1894 label sharedPointi = pointAddr[i];
1896 sharedPoints[sharedPointi] = mesh_.points()[
pointLabels[i]];
1906 fromSlave >> nbrSharedPointAddr >> nbrSharedPoints;
1908 forAll(nbrSharedPointAddr, i)
1910 label sharedPointi = nbrSharedPointAddr[i];
1912 sharedPoints[sharedPointi] = nbrSharedPoints[i];
1923 sharedPoints.size_bytes()
1925 toSlave << sharedPoints;
1950 fromMaster >> sharedPoints;
1954 return sharedPoints;
1961 pointField sharedPoints(mesh_.points(), sharedPointLabels());
1967 scalar tolDim = matchTol_ * mesh_.bounds().mag();
1982 return mergedPoints;
1988 if (nGlobalPoints_ == -1)
1992 return nGlobalPoints_;
1998 if (!sharedPointLabelsPtr_)
2002 return *sharedPointLabelsPtr_;
2008 if (!sharedPointAddrPtr_)
2012 return *sharedPointAddrPtr_;
2018 if (nGlobalEdges_ == -1)
2022 return nGlobalEdges_;
2028 if (!sharedEdgeLabelsPtr_)
2032 return *sharedEdgeLabelsPtr_;
2038 if (!sharedEdgeAddrPtr_)
2042 return *sharedEdgeAddrPtr_;
2048 if (!coupledPatchPtr_)
2060 nCoupled += pp.size();
2072 label facei = pp.
start();
2076 coupledFaces[nCoupled++] = facei++;
2081 coupledPatchPtr_.reset
2096 Pout<<
"globalMeshData::coupledPatch() :"
2097 <<
" constructed coupled faces patch:"
2098 <<
" faces:" << coupledPatchPtr_().size()
2099 <<
" points:" << coupledPatchPtr_().nPoints()
2103 return *coupledPatchPtr_;
2109 if (!coupledPatchMeshEdgesPtr_)
2111 coupledPatchMeshEdgesPtr_.reset
2115 coupledPatch().meshEdges
2123 return *coupledPatchMeshEdgesPtr_;
2130 if (!coupledPatchMeshEdgeMapPtr_)
2134 coupledPatchMeshEdgeMapPtr_.reset(
new Map<label>(2*
me.size()));
2135 Map<label>& em = coupledPatchMeshEdgeMapPtr_();
2139 em.insert(
me[i], i);
2142 return *coupledPatchMeshEdgeMapPtr_;
2148 if (!globalPointNumberingPtr_)
2150 globalPointNumberingPtr_.
reset
2155 return *globalPointNumberingPtr_;
2162 if (!globalTransformsPtr_)
2166 return *globalTransformsPtr_;
2172 if (!globalPointSlavesPtr_)
2174 calcGlobalPointSlaves();
2176 return *globalPointSlavesPtr_;
2183 if (!globalPointTransformedSlavesPtr_)
2185 calcGlobalPointSlaves();
2187 return *globalPointTransformedSlavesPtr_;
2193 if (!globalPointSlavesMapPtr_)
2195 calcGlobalPointSlaves();
2197 return *globalPointSlavesMapPtr_;
2203 if (!globalEdgeNumberingPtr_)
2205 globalEdgeNumberingPtr_.
reset
2210 return *globalEdgeNumberingPtr_;
2216 if (!globalEdgeSlavesPtr_)
2218 calcGlobalEdgeSlaves();
2220 return *globalEdgeSlavesPtr_;
2227 if (!globalEdgeTransformedSlavesPtr_)
2229 calcGlobalEdgeSlaves();
2231 return *globalEdgeTransformedSlavesPtr_;
2237 if (!globalEdgeOrientationPtr_)
2239 calcGlobalEdgeOrientation();
2241 return *globalEdgeOrientationPtr_;
2247 if (!globalEdgeSlavesMapPtr_)
2249 calcGlobalEdgeSlaves();
2251 return *globalEdgeSlavesMapPtr_;
2258 if (!globalBoundaryFaceNumberingPtr_)
2260 calcGlobalPointBoundaryFaces();
2262 return *globalBoundaryFaceNumberingPtr_;
2269 if (!globalPointBoundaryFacesPtr_)
2271 calcGlobalPointBoundaryFaces();
2273 return *globalPointBoundaryFacesPtr_;
2280 if (!globalPointTransformedBoundaryFacesPtr_)
2282 calcGlobalPointBoundaryFaces();
2284 return *globalPointTransformedBoundaryFacesPtr_;
2291 if (!globalPointBoundaryFacesMapPtr_)
2293 calcGlobalPointBoundaryFaces();
2295 return *globalPointBoundaryFacesMapPtr_;
2301 if (!boundaryCellsPtr_)
2303 calcGlobalPointBoundaryCells();
2305 return *boundaryCellsPtr_;
2312 if (!globalBoundaryCellNumberingPtr_)
2314 calcGlobalPointBoundaryCells();
2316 return *globalBoundaryCellNumberingPtr_;
2323 if (!globalPointBoundaryCellsPtr_)
2325 calcGlobalPointBoundaryCells();
2327 return *globalPointBoundaryCellsPtr_;
2334 if (!globalPointTransformedBoundaryCellsPtr_)
2336 calcGlobalPointBoundaryCells();
2338 return *globalPointTransformedBoundaryCellsPtr_;
2345 if (!globalPointBoundaryCellsMapPtr_)
2347 calcGlobalPointBoundaryCells();
2349 return *globalPointBoundaryCellsMapPtr_;
2355 if (!globalCoPointSlavesPtr_)
2357 calcGlobalCoPointSlaves();
2359 return *globalCoPointSlavesPtr_;
2365 if (!globalCoPointSlavesMapPtr_)
2367 calcGlobalCoPointSlaves();
2369 return *globalCoPointSlavesMapPtr_;
2380 const globalIndex& globalCoupledPoints = globalPointNumbering();
2383 const mapDistribute& pointSlavesMap = globalCoPointSlavesMap();
2392 forAll(masterGlobalPoint, pointi)
2394 const labelList& slavePoints = pointSlaves[pointi];
2395 if (slavePoints.size() > 0)
2397 masterGlobalPoint[pointi] = globalCoupledPoints.
toGlobal(pointi);
2414 bitSet isMaster(mesh_.nPoints(),
true);
2415 forAll(pointSlaves, pointi)
2417 if (masterGlobalPoint[pointi] == -1)
2424 masterGlobalPoint[pointi]
2425 == globalCoupledPoints.
toGlobal(pointi)
2438 label myUniquePoints = mesh_.nPoints() - cpp.
nPoints() + nMaster;
2452 pointToGlobal.
setSize(mesh_.nPoints());
2454 uniquePoints.
setSize(myUniquePoints);
2457 forAll(isMaster, meshPointi)
2459 if (isMaster[meshPointi])
2461 pointToGlobal[meshPointi] = globalPointsPtr().toGlobal(nMaster);
2462 uniquePoints[nMaster] = meshPointi;
2472 forAll(pointSlaves, pointi)
2474 const labelList& slaves = pointSlaves[pointi];
2476 if (slaves.size() > 0)
2480 masterToGlobal[pointi] = pointToGlobal[meshPointi];
2483 masterToGlobal[slaves[i]] = masterToGlobal[pointi];
2492 forAll(pointSlaves, pointi)
2496 if (!isMaster[meshPointi])
2498 pointToGlobal[meshPointi] = masterToGlobal[pointi];
2503 return globalPointsPtr;
2517 const mapDistribute& pointSlavesMap = globalCoPointSlavesMap();
2537 labelList patchToCoupled(meshPoints.size(), -1);
2542 forAll(meshPoints, patchPointi)
2544 label meshPointi = meshPoints[patchPointi];
2546 const auto iter = cpp.
meshPointMap().cfind(meshPointi);
2550 patchToCoupled[patchPointi] = iter();
2551 coupledToGlobalPatch[iter()] = globalPPoints.toGlobal(patchPointi);
2569 pointSlavesMap.
distribute(coupledToGlobalPatch);
2570 forAll(pointSlaves, coupledPointi)
2572 const labelList& slaves = pointSlaves[coupledPointi];
2574 if (slaves.size() > 0)
2578 if (coupledToGlobalPatch[coupledPointi] != -1)
2581 masterI = coupledToGlobalPatch[coupledPointi];
2588 label slavePp = coupledToGlobalPatch[slaves[i]];
2589 if (slavePp != -1 && slavePp < masterI)
2599 coupledToGlobalPatch[coupledPointi] = masterI;
2602 coupledToGlobalPatch[slaves[i]] = masterI;
2617 forAll(meshPoints, patchPointi)
2619 if (patchToCoupled[patchPointi] == -1)
2625 label coupledPointi = patchToCoupled[patchPointi];
2628 globalPPoints.toGlobal(patchPointi)
2629 == coupledToGlobalPatch[coupledPointi]
2650 pointToGlobal.
setSize(meshPoints.size());
2652 uniqueMeshPoints.
setSize(nMasters);
2659 forAll(meshPoints, patchPointi)
2661 if (patchToCoupled[patchPointi] == -1)
2663 uniqueMeshPoints[nMasters++] = meshPoints[patchPointi];
2667 label coupledPointi = patchToCoupled[patchPointi];
2670 globalPPoints.toGlobal(patchPointi)
2671 == coupledToGlobalPatch[coupledPointi]
2674 globalMaster[coupledPointi] =
2675 globalPointsPtr().toGlobal(nMasters);
2676 uniqueMeshPoints[nMasters++] = meshPoints[patchPointi];
2696 forAll(meshPoints, patchPointi)
2698 if (patchToCoupled[patchPointi] == -1)
2700 pointToGlobal[patchPointi] = globalPointsPtr().toGlobal(nMasters++);
2704 label coupledPointi = patchToCoupled[patchPointi];
2705 pointToGlobal[patchPointi] = globalMaster[coupledPointi];
2709 globalPPoints.toGlobal(patchPointi)
2710 == coupledToGlobalPatch[coupledPointi]
2718 return globalPointsPtr;
2739 scalar tolDim = matchTol_ * mesh_.bounds().mag();
2743 Pout<<
"globalMeshData : merge dist:" << tolDim <<
endl;
2770 Pout<<
"globalMeshData : nTotalFaces_:" << nTotalFaces_ <<
endl;
2783 Pout<<
"globalMeshData : nTotalCells_:" << nTotalCells_ <<
endl;
2799 Pout<<
"globalMeshData : nTotalPoints_:" << nTotalPoints_ <<
endl;