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_.valid()
132 || sharedPointAddrPtr_.valid()
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_.valid()
299 || sharedEdgeAddrPtr_.valid()
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);
403 EdgeMap<labelList> procSharedEdges(fromSlave);
407 Pout<<
"globalMeshData::calcSharedEdges : "
408 <<
"Merging in from proc"
409 <<
Foam::name(slave) <<
" : " << procSharedEdges.size()
412 countSharedEdges(procSharedEdges, globalShared, sharedEdgeI);
420 EdgeMap<label> oldSharedEdges(globalShared);
422 globalShared.clear();
428 globalShared.insert(iter.key(), iter());
433 Pout<<
"globalMeshData::calcSharedEdges : Filtered "
434 << oldSharedEdges.size()
435 <<
" down to " << globalShared.size() <<
endl;
452 toSlave << globalShared;
465 toMaster << localShared;
474 fromMaster >> globalShared;
481 nGlobalEdges_ = globalShared.size();
483 DynamicList<label> dynSharedEdgeLabels(globalShared.size());
484 DynamicList<label> dynSharedEdgeAddr(globalShared.size());
488 const edge&
e = iter.key();
490 const auto edgeFnd = globalShared.cfind(
e);
498 for (
const label edgei : edgeLabels)
501 dynSharedEdgeLabels.append(edgei);
504 dynSharedEdgeAddr.append(edgeFnd());
510 sharedEdgeLabelsPtr_.reset(
new labelList());
511 labelList& sharedEdgeLabels = sharedEdgeLabelsPtr_();
512 sharedEdgeLabels.transfer(dynSharedEdgeLabels);
514 sharedEdgeAddrPtr_.reset(
new labelList());
515 labelList& sharedEdgeAddr = sharedEdgeAddrPtr_();
516 sharedEdgeAddr.transfer(dynSharedEdgeAddr);
520 Pout<<
"globalMeshData : nGlobalEdges_:" << nGlobalEdges_ <<
nl
521 <<
"globalMeshData : sharedEdgeLabels:" << sharedEdgeLabels.size()
523 <<
"globalMeshData : sharedEdgeAddr:" << sharedEdgeAddr.size()
529 void Foam::globalMeshData::calcGlobalPointSlaves()
const
533 Pout<<
"globalMeshData::calcGlobalPointSlaves() :"
534 <<
" calculating coupled master to slave point addressing."
539 globalPoints globalData(mesh_, coupledPatch(),
true,
true);
541 globalPointSlavesPtr_.reset
545 std::move(globalData.pointPoints())
548 globalPointTransformedSlavesPtr_.reset
552 std::move(globalData.transformedPointPoints())
556 globalPointSlavesMapPtr_.reset
560 std::move(globalData.map())
566 void Foam::globalMeshData::calcPointConnectivity
568 List<labelPairList>& allPointConnectivity
571 const globalIndexAndTransform& transforms = globalTransforms();
573 const labelListList& transformedSlaves = globalPointTransformedSlaves();
577 labelPairList myData(globalPointSlavesMap().constructSize());
580 myData[pointi] = transforms.encode
584 transforms.nullTransformIndex()
588 globalPointSlavesMap().distribute(myData);
592 allPointConnectivity.setSize(globalPointSlavesMap().constructSize());
600 const labelList& pSlaves = slaves[pointi];
601 const labelList& pTransformSlaves = transformedSlaves[pointi];
603 if (pSlaves.size()+pTransformSlaves.size())
607 pConnectivity.setSize(1+pSlaves.size()+pTransformSlaves.size());
611 pConnectivity[connI++] = myData[pointi];
615 pConnectivity[connI++] = myData[pSlaves[i]];
618 forAll(pTransformSlaves, i)
621 label transformI = globalPointSlavesMap().whichTransform
626 const labelPair&
n = myData[pTransformSlaves[i]];
627 label proci = transforms.processor(
n);
628 label index = transforms.index(
n);
629 pConnectivity[connI++] = transforms.encode
640 allPointConnectivity[pSlaves[i]] = pConnectivity;
642 forAll(pTransformSlaves, i)
644 allPointConnectivity[pTransformSlaves[i]] = pConnectivity;
655 if (pConnectivity.size() == 0)
657 pConnectivity.setSize(1, myData[pointi]);
662 globalPointSlavesMap().reverseDistribute
670 void Foam::globalMeshData::calcGlobalPointEdges
673 List<labelPairList>& globalPointPoints
676 const edgeList& edges = coupledPatch().edges();
677 const labelListList& pointEdges = coupledPatch().pointEdges();
678 const globalIndex& globalEdgeNumbers = globalEdgeNumbering();
680 const labelListList& transformedSlaves = globalPointTransformedSlaves();
681 const globalIndexAndTransform& transforms = globalTransforms();
685 globalPointEdges.setSize(globalPointSlavesMap().constructSize());
686 globalPointPoints.setSize(globalPointSlavesMap().constructSize());
687 forAll(pointEdges, pointi)
689 const labelList& pEdges = pointEdges[pointi];
690 globalPointEdges[pointi] = globalEdgeNumbers.toGlobal(pEdges);
693 globalPPoints.setSize(pEdges.size());
696 label otherPointi = edges[pEdges[i]].otherVertex(pointi);
697 globalPPoints[i] = transforms.encode
701 transforms.nullTransformIndex()
707 globalPointSlavesMap().distribute(globalPointEdges);
708 globalPointSlavesMap().distribute(globalPointPoints);
712 const labelList& pSlaves = slaves[pointi];
713 const labelList& pTransformSlaves = transformedSlaves[pointi];
718 n += globalPointEdges[pSlaves[i]].size();
720 forAll(pTransformSlaves, i)
722 n += globalPointEdges[pTransformSlaves[i]].size();
727 labelList& globalPEdges = globalPointEdges[pointi];
728 label sz = globalPEdges.size();
732 const labelList& otherData = globalPointEdges[pSlaves[i]];
735 globalPEdges[sz++] = otherData[j];
738 forAll(pTransformSlaves, i)
741 globalPointEdges[pTransformSlaves[i]];
744 globalPEdges[sz++] = otherData[j];
751 globalPointEdges[pSlaves[i]] = globalPEdges;
753 forAll(pTransformSlaves, i)
755 globalPointEdges[pTransformSlaves[i]] = globalPEdges;
763 label sz = globalPPoints.size();
764 globalPPoints.setSize(sz +
n);
769 const labelPairList& otherData = globalPointPoints[pSlaves[i]];
772 globalPPoints[sz++] = otherData[j];
776 forAll(pTransformSlaves, i)
779 label transformI = globalPointSlavesMap().whichTransform
785 globalPointPoints[pTransformSlaves[i]];
790 label proci = transforms.processor(
n);
791 label index = transforms.index(
n);
792 globalPPoints[sz++] = transforms.encode
804 globalPointPoints[pSlaves[i]] = globalPPoints;
806 forAll(pTransformSlaves, i)
808 globalPointPoints[pTransformSlaves[i]] = globalPPoints;
813 globalPointSlavesMap().reverseDistribute
819 globalPointSlavesMap().reverseDistribute
827 Foam::label Foam::globalMeshData::findTransform
831 const label localPoint
834 const globalIndexAndTransform& transforms = globalTransforms();
836 const label remoteProci = transforms.processor(remotePoint);
837 const label remoteIndex = transforms.index(remotePoint);
839 label remoteTransformI = -1;
840 label localTransformI = -1;
843 label proci = transforms.processor(info[i]);
844 label pointi = transforms.index(info[i]);
845 label transformI = transforms.transformIndex(info[i]);
849 localTransformI = transformI;
854 if (proci == remoteProci && pointi == remoteIndex)
856 remoteTransformI = transformI;
864 if (remoteTransformI == -1 || localTransformI == -1)
867 <<
"Problem. Cannot find " << remotePoint
868 <<
" or " << localPoint <<
" "
869 << coupledPatch().localPoints()[localPoint]
872 <<
"remoteTransformI:" << remoteTransformI <<
endl
873 <<
"localTransformI:" << localTransformI
877 return transforms.subtractTransformIndex
885 void Foam::globalMeshData::calcGlobalEdgeSlaves()
const
889 Pout<<
"globalMeshData::calcGlobalEdgeSlaves() :"
890 <<
" calculating coupled master to slave edge addressing." <<
endl;
893 const edgeList& edges = coupledPatch().edges();
894 const globalIndex& globalEdgeNumbers = globalEdgeNumbering();
895 const globalIndexAndTransform& transforms = globalTransforms();
908 List<labelPairList> allPointConnectivity;
909 calcPointConnectivity(allPointConnectivity);
915 List<labelPairList> globalPointPoints;
916 calcGlobalPointEdges(globalPointEdges, globalPointPoints);
929 List<labelPairList> allEdgeConnectivity(edges.size());
933 const edge&
e = edges[edgeI];
934 const labelList& pEdges0 = globalPointEdges[
e[0]];
936 const labelList& pEdges1 = globalPointEdges[
e[1]];
940 DynamicList<labelPair> eEdges(2);
948 transforms.nullTransformIndex()
958 pEdges0[i] == pEdges1[j]
959 && pEdges0[i] != globalEdgeNumbers.toGlobal(edgeI)
971 label transform0 = findTransform
973 allPointConnectivity[
e[0]],
977 label transform1 = findTransform
979 allPointConnectivity[
e[1]],
984 if (transform0 == transform1)
986 label proci = globalEdgeNumbers.whichProcID(pEdges0[i]);
992 globalEdgeNumbers.toLocal(proci, pEdges0[i]),
1001 allEdgeConnectivity[edgeI].transfer(eEdges);
1004 allEdgeConnectivity[edgeI],
1013 globalEdgeSlavesPtr_.reset(
new labelListList(edges.size()));
1015 List<labelPairList> transformedEdges(edges.size());
1016 forAll(allEdgeConnectivity, edgeI)
1019 if (edgeInfo.size() >= 2)
1021 const labelPair& masterInfo = edgeInfo[0];
1027 transforms.processor(masterInfo)
1030 && (transforms.index(masterInfo) == edgeI)
1034 labelList& eEdges = globalEdgeSlaves[edgeI];
1035 eEdges.
setSize(edgeInfo.size()-1);
1038 trafoEEdges.setSize(edgeInfo.size()-1);
1040 label nonTransformI = 0;
1041 label transformI = 0;
1043 for (label i = 1; i < edgeInfo.size(); i++)
1046 label proci = transforms.processor(info);
1047 label index = transforms.index(info);
1048 label
transform = transforms.transformIndex
1053 if (
transform == transforms.nullTransformIndex())
1055 eEdges[nonTransformI++] = globalEdgeNumbers.toGlobal
1063 trafoEEdges[transformI++] = info;
1067 eEdges.setSize(nonTransformI);
1068 trafoEEdges.setSize(transformI);
1078 globalEdgeSlavesMapPtr_.reset
1087 globalEdgeTransformedSlavesPtr_(),
1096 Pout<<
"globalMeshData::calcGlobalEdgeSlaves() :"
1097 <<
" coupled edges:" << edges.size()
1098 <<
" additional coupled edges:"
1099 << globalEdgeSlavesMapPtr_().constructSize() - edges.size()
1105 void Foam::globalMeshData::calcGlobalEdgeOrientation()
const
1109 Pout<<
"globalMeshData::calcGlobalEdgeOrientation() :"
1110 <<
" calculating edge orientation w.r.t. master edge." <<
endl;
1113 const globalIndex& globalPoints = globalPointNumbering();
1118 const mapDistribute& map = globalPointSlavesMap();
1120 masterPoint.setSize(map.constructSize());
1123 for (label pointi = 0; pointi < coupledPatch().nPoints(); pointi++)
1125 masterPoint[pointi] = globalPoints.toGlobal(pointi);
1130 globalPointSlaves(),
1131 globalPointTransformedSlaves(),
1142 const mapDistribute& map = globalEdgeSlavesMap();
1144 const labelListList& transformedSlaves = globalEdgeTransformedSlaves();
1150 for (label edgeI = 0; edgeI < coupledPatch().nEdges(); edgeI++)
1155 slaves[edgeI].size()
1156 + transformedSlaves[edgeI].size()
1163 const edge&
e = coupledPatch().edges()[edgeI];
1177 minEqOp<labelPair>()
1181 globalEdgeOrientationPtr_.reset
1183 new bitSet(coupledPatch().nEdges())
1185 bitSet& globalEdgeOrientation = globalEdgeOrientationPtr_();
1187 forAll(coupledPatch().edges(), edgeI)
1192 const edge&
e = coupledPatch().edges()[edgeI];
1202 masterEdgeVerts[edgeI]
1207 <<
"problem : my edge:" <<
e
1208 <<
" in master points:" << masterE
1209 <<
" v.s. masterEdgeVerts:" << masterEdgeVerts[edgeI]
1214 globalEdgeOrientation.set(edgeI, (stat == 1));
1219 globalEdgeOrientation.set(edgeI,
true);
1226 Pout<<
"globalMeshData::calcGlobalEdgeOrientation() :"
1227 <<
" finished calculating edge orientation."
1233 void Foam::globalMeshData::calcPointBoundaryFaces
1238 const polyBoundaryMesh&
bMesh = mesh_.boundaryMesh();
1239 const Map<label>& meshPointMap = coupledPatch().meshPointMap();
1245 for (
const polyPatch& pp :
bMesh)
1249 for (
const face&
f : pp)
1253 const auto iter = meshPointMap.cfind(
f[fp]);
1256 nPointFaces[iter.val()]++;
1266 pointBoundaryFaces.setSize(coupledPatch().
nPoints());
1267 forAll(nPointFaces, pointi)
1269 pointBoundaryFaces[pointi].setSize(nPointFaces[pointi]);
1278 const polyPatch& pp =
bMesh[patchi];
1284 const face&
f = pp[i];
1287 const auto iter = meshPointMap.cfind(
f[fp]);
1292 pp.start() + i - mesh_.nInternalFaces();
1293 pointBoundaryFaces[iter()][nPointFaces[iter()]++] =
1303 void Foam::globalMeshData::calcGlobalPointBoundaryFaces()
const
1307 Pout<<
"globalMeshData::calcGlobalPointBoundaryFaces() :"
1308 <<
" calculating coupled point to boundary face addressing."
1314 calcPointBoundaryFaces(pointBoundaryFaces);
1318 globalBoundaryFaceNumberingPtr_.reset
1320 new globalIndex(mesh_.nBoundaryFaces())
1322 globalIndex& globalIndices = globalBoundaryFaceNumberingPtr_();
1326 globalPointBoundaryFacesPtr_.reset
1330 labelListList& globalPointBoundaryFaces = globalPointBoundaryFacesPtr_();
1332 forAll(pointBoundaryFaces, pointi)
1334 const labelList& bFaces = pointBoundaryFaces[pointi];
1335 labelList& globalFaces = globalPointBoundaryFaces[pointi];
1336 globalFaces.
setSize(bFaces.size());
1339 globalFaces[i] = globalIndices.toGlobal(bFaces[i]);
1345 globalPointSlavesMap().distribute
1347 globalPointBoundaryFaces,
1356 globalPointTransformedSlaves();
1357 const globalIndexAndTransform& transforms = globalTransforms();
1361 List<labelPairList> transformedFaces(pointSlaves.size());
1364 forAll(pointSlaves, pointi)
1366 const labelList& slaves = pointSlaves[pointi];
1367 const labelList& transformedSlaves = pointTransformSlaves[pointi];
1369 if (slaves.size() > 0)
1371 labelList& myBFaces = globalPointBoundaryFaces[pointi];
1372 label sz = myBFaces.size();
1378 n += globalPointBoundaryFaces[slaves[i]].size();
1381 myBFaces.setSize(sz+
n);
1386 globalPointBoundaryFaces[slaves[i]];
1391 for (
const label slave : slaveBFaces)
1393 if (!SubList<label>(myBFaces, sz).
found(slave))
1395 myBFaces[
n++] = slave;
1403 if (transformedSlaves.size() > 0)
1405 const labelList& untrafoFaces = globalPointBoundaryFaces[pointi];
1408 label sz = myBFaces.size();
1412 forAll(transformedSlaves, i)
1414 n += globalPointBoundaryFaces[transformedSlaves[i]].size();
1417 myBFaces.setSize(sz+
n);
1419 forAll(transformedSlaves, i)
1421 label transformI = globalPointSlavesMap().whichTransform
1423 transformedSlaves[i]
1427 globalPointBoundaryFaces[transformedSlaves[i]];
1429 for (
const label slave : slaveBFaces)
1432 if (!untrafoFaces.found(slave))
1434 label proci = globalIndices.whichProcID(slave);
1435 label facei = globalIndices.toLocal(proci, slave);
1437 myBFaces[
n++] = transforms.encode
1450 if (slaves.size() + transformedSlaves.size() == 0)
1452 globalPointBoundaryFaces[pointi].clear();
1459 globalPointTransformedBoundaryFacesPtr_.reset
1464 globalPointBoundaryFacesMapPtr_.reset
1469 globalPointBoundaryFaces,
1473 globalPointTransformedBoundaryFacesPtr_(),
1478 globalPointBoundaryFaces.setSize(coupledPatch().
nPoints());
1479 globalPointTransformedBoundaryFacesPtr_().setSize(coupledPatch().
nPoints());
1483 Pout<<
"globalMeshData::calcGlobalPointBoundaryFaces() :"
1484 <<
" coupled points:" << coupledPatch().nPoints()
1485 <<
" local boundary faces:" << globalIndices.localSize()
1486 <<
" additional coupled faces:"
1487 << globalPointBoundaryFacesMapPtr_().constructSize()
1488 - globalIndices.localSize()
1494 void Foam::globalMeshData::calcGlobalPointBoundaryCells()
const
1498 Pout<<
"globalMeshData::calcGlobalPointBoundaryCells() :"
1499 <<
" calculating coupled point to boundary cell addressing."
1507 Map<label> meshCellMap(4*coupledPatch().
nPoints());
1508 DynamicList<label> cellMap(meshCellMap.size());
1513 forAll(coupledPatch().meshPoints(), pointi)
1515 label meshPointi = coupledPatch().meshPoints()[pointi];
1516 const labelList& pCells = mesh_.pointCells(meshPointi);
1519 bCells.setSize(pCells.size());
1523 const label celli = pCells[i];
1524 const auto fnd = meshCellMap.cfind(celli);
1532 meshCellMap.insert(celli, bCelli);
1533 cellMap.append(celli);
1541 boundaryCellsPtr_.reset(
new labelList(std::move(cellMap)));
1542 labelList& boundaryCells = boundaryCellsPtr_();
1548 globalBoundaryCellNumberingPtr_.reset
1550 new globalIndex(boundaryCells.size())
1552 globalIndex& globalIndices = globalBoundaryCellNumberingPtr_();
1555 globalPointBoundaryCellsPtr_.reset
1559 labelListList& globalPointBoundaryCells = globalPointBoundaryCellsPtr_();
1561 forAll(pointBoundaryCells, pointi)
1563 const labelList& pCells = pointBoundaryCells[pointi];
1564 labelList& globalCells = globalPointBoundaryCells[pointi];
1565 globalCells.
setSize(pCells.size());
1568 globalCells[i] = globalIndices.toGlobal(pCells[i]);
1574 globalPointSlavesMap().distribute
1576 globalPointBoundaryCells,
1584 globalPointTransformedSlaves();
1585 const globalIndexAndTransform& transforms = globalTransforms();
1587 List<labelPairList> transformedCells(pointSlaves.size());
1590 forAll(pointSlaves, pointi)
1592 const labelList& slaves = pointSlaves[pointi];
1593 const labelList& transformedSlaves = pointTransformSlaves[pointi];
1595 if (slaves.size() > 0)
1597 labelList& myBCells = globalPointBoundaryCells[pointi];
1598 label sz = myBCells.size();
1604 n += globalPointBoundaryCells[slaves[i]].size();
1607 myBCells.setSize(sz+
n);
1612 globalPointBoundaryCells[slaves[i]];
1617 for (
const label slave : slaveBCells)
1619 if (!SubList<label>(myBCells, sz).
found(slave))
1621 myBCells[
n++] = slave;
1629 if (transformedSlaves.size() > 0)
1631 const labelList& untrafoCells = globalPointBoundaryCells[pointi];
1634 label sz = myBCells.size();
1638 forAll(transformedSlaves, i)
1640 n += globalPointBoundaryCells[transformedSlaves[i]].size();
1643 myBCells.setSize(sz+
n);
1645 forAll(transformedSlaves, i)
1647 label transformI = globalPointSlavesMap().whichTransform
1649 transformedSlaves[i]
1653 globalPointBoundaryCells[transformedSlaves[i]];
1655 for (
const label slave : slaveBCells)
1658 if (!untrafoCells.found(slave))
1660 label proci = globalIndices.whichProcID(slave);
1661 label celli = globalIndices.toLocal(proci, slave);
1662 myBCells[
n++] = transforms.encode
1674 if (slaves.size() + transformedSlaves.size() == 0)
1676 globalPointBoundaryCells[pointi].clear();
1683 globalPointTransformedBoundaryCellsPtr_.reset
1688 globalPointBoundaryCellsMapPtr_.reset
1693 globalPointBoundaryCells,
1697 globalPointTransformedBoundaryCellsPtr_(),
1702 globalPointBoundaryCells.setSize(coupledPatch().
nPoints());
1703 globalPointTransformedBoundaryCellsPtr_().setSize(coupledPatch().
nPoints());
1707 Pout<<
"globalMeshData::calcGlobalPointBoundaryCells() :"
1708 <<
" coupled points:" << coupledPatch().nPoints()
1709 <<
" local boundary cells:" << globalIndices.localSize()
1710 <<
" additional coupled cells:"
1711 << globalPointBoundaryCellsMapPtr_().constructSize()
1712 - globalIndices.localSize()
1718 void Foam::globalMeshData::calcGlobalCoPointSlaves()
const
1722 Pout<<
"globalMeshData::calcGlobalCoPointSlaves() :"
1723 <<
" calculating coupled master to collocated"
1724 <<
" slave point addressing." <<
endl;
1728 globalPoints globalData(mesh_, coupledPatch(),
true,
false);
1730 globalCoPointSlavesPtr_.reset
1734 std::move(globalData.pointPoints())
1737 globalCoPointSlavesMapPtr_.reset
1741 std::move(globalData.map())
1747 Pout<<
"globalMeshData::calcGlobalCoPointSlaves() :"
1748 <<
" finished calculating coupled master to collocated"
1749 <<
" slave point addressing." <<
endl;
1763 processorPatches_(0),
1764 processorPatchIndices_(0),
1765 processorPatchNeighbours_(0),
1767 sharedPointLabelsPtr_(nullptr),
1768 sharedPointAddrPtr_(nullptr),
1769 sharedPointGlobalLabelsPtr_(nullptr),
1771 sharedEdgeLabelsPtr_(nullptr),
1772 sharedEdgeAddrPtr_(nullptr)
1789 nGlobalPoints_ = -1;
1790 sharedPointLabelsPtr_.clear();
1791 sharedPointAddrPtr_.clear();
1792 sharedPointGlobalLabelsPtr_.clear();
1796 sharedEdgeLabelsPtr_.clear();
1797 sharedEdgeAddrPtr_.clear();
1800 coupledPatchPtr_.clear();
1801 coupledPatchMeshEdgesPtr_.clear();
1802 coupledPatchMeshEdgeMapPtr_.clear();
1803 globalTransformsPtr_.clear();
1806 globalPointNumberingPtr_.clear();
1807 globalPointSlavesPtr_.clear();
1808 globalPointTransformedSlavesPtr_.clear();
1809 globalPointSlavesMapPtr_.clear();
1811 globalEdgeNumberingPtr_.clear();
1812 globalEdgeSlavesPtr_.clear();
1813 globalEdgeTransformedSlavesPtr_.clear();
1814 globalEdgeOrientationPtr_.clear();
1815 globalEdgeSlavesMapPtr_.clear();
1818 globalBoundaryFaceNumberingPtr_.clear();
1819 globalPointBoundaryFacesPtr_.clear();
1820 globalPointTransformedBoundaryFacesPtr_.clear();
1821 globalPointBoundaryFacesMapPtr_.clear();
1824 boundaryCellsPtr_.clear();
1825 globalBoundaryCellNumberingPtr_.clear();
1826 globalPointBoundaryCellsPtr_.clear();
1827 globalPointTransformedBoundaryCellsPtr_.clear();
1828 globalPointBoundaryCellsMapPtr_.clear();
1831 globalCoPointSlavesPtr_.clear();
1832 globalCoPointSlavesMapPtr_.clear();
1840 if (!sharedPointGlobalLabelsPtr_.valid())
1842 sharedPointGlobalLabelsPtr_.reset
1844 new labelList(sharedPointLabels().size())
1846 labelList& sharedPointGlobalLabels = sharedPointGlobalLabelsPtr_();
1850 "pointProcAddressing",
1851 mesh_.facesInstance()/mesh_.meshSubDir,
1860 Pout<<
"globalMeshData::sharedPointGlobalLabels : "
1861 <<
"Reading pointProcAddressing" <<
endl;
1873 sharedPointGlobalLabels[i] = pointProcAddressing[pointi];
1878 Pout<<
"globalMeshData::sharedPointGlobalLabels :"
1879 <<
" Setting pointProcAddressing to -1" <<
endl;
1881 sharedPointGlobalLabels = -1;
1885 return *sharedPointGlobalLabelsPtr_;
1895 const labelList& pointAddr = sharedPointAddr();
1904 label sharedPointi = pointAddr[i];
1906 sharedPoints[sharedPointi] = mesh_.points()[
pointLabels[i]];
1921 fromSlave >> nbrSharedPointAddr >> nbrSharedPoints;
1923 forAll(nbrSharedPointAddr, i)
1925 label sharedPointi = nbrSharedPointAddr[i];
1927 sharedPoints[sharedPointi] = nbrSharedPoints[i];
1945 toSlave << sharedPoints;
1970 fromMaster >> sharedPoints;
1974 return sharedPoints;
1981 pointField sharedPoints(mesh_.points(), sharedPointLabels());
1987 scalar tolDim = matchTol_ * mesh_.bounds().mag();
2002 return mergedPoints;
2008 if (nGlobalPoints_ == -1)
2012 return nGlobalPoints_;
2018 if (!sharedPointLabelsPtr_.valid())
2022 return *sharedPointLabelsPtr_;
2028 if (!sharedPointAddrPtr_.valid())
2032 return *sharedPointAddrPtr_;
2038 if (nGlobalEdges_ == -1)
2042 return nGlobalEdges_;
2048 if (!sharedEdgeLabelsPtr_.valid())
2052 return *sharedEdgeLabelsPtr_;
2058 if (!sharedEdgeAddrPtr_.valid())
2062 return *sharedEdgeAddrPtr_;
2068 if (!coupledPatchPtr_.valid())
2080 nCoupled += pp.size();
2092 label facei = pp.
start();
2096 coupledFaces[nCoupled++] = facei++;
2101 coupledPatchPtr_.reset
2116 Pout<<
"globalMeshData::coupledPatch() :"
2117 <<
" constructed coupled faces patch:"
2118 <<
" faces:" << coupledPatchPtr_().size()
2119 <<
" points:" << coupledPatchPtr_().nPoints()
2123 return *coupledPatchPtr_;
2129 if (!coupledPatchMeshEdgesPtr_.valid())
2131 coupledPatchMeshEdgesPtr_.reset
2135 coupledPatch().meshEdges
2143 return *coupledPatchMeshEdgesPtr_;
2150 if (!coupledPatchMeshEdgeMapPtr_.valid())
2154 coupledPatchMeshEdgeMapPtr_.reset(
new Map<label>(2*
me.size()));
2155 Map<label>& em = coupledPatchMeshEdgeMapPtr_();
2159 em.insert(
me[i], i);
2162 return *coupledPatchMeshEdgeMapPtr_;
2168 if (!globalPointNumberingPtr_.valid())
2170 globalPointNumberingPtr_.
reset
2175 return *globalPointNumberingPtr_;
2182 if (!globalTransformsPtr_.valid())
2186 return *globalTransformsPtr_;
2192 if (!globalPointSlavesPtr_.valid())
2194 calcGlobalPointSlaves();
2196 return *globalPointSlavesPtr_;
2203 if (!globalPointTransformedSlavesPtr_.valid())
2205 calcGlobalPointSlaves();
2207 return *globalPointTransformedSlavesPtr_;
2213 if (!globalPointSlavesMapPtr_.valid())
2215 calcGlobalPointSlaves();
2217 return *globalPointSlavesMapPtr_;
2223 if (!globalEdgeNumberingPtr_.valid())
2225 globalEdgeNumberingPtr_.
reset
2230 return *globalEdgeNumberingPtr_;
2236 if (!globalEdgeSlavesPtr_.valid())
2238 calcGlobalEdgeSlaves();
2240 return *globalEdgeSlavesPtr_;
2247 if (!globalEdgeTransformedSlavesPtr_.valid())
2249 calcGlobalEdgeSlaves();
2251 return *globalEdgeTransformedSlavesPtr_;
2257 if (!globalEdgeOrientationPtr_.valid())
2259 calcGlobalEdgeOrientation();
2261 return *globalEdgeOrientationPtr_;
2267 if (!globalEdgeSlavesMapPtr_.valid())
2269 calcGlobalEdgeSlaves();
2271 return *globalEdgeSlavesMapPtr_;
2278 if (!globalBoundaryFaceNumberingPtr_.valid())
2280 calcGlobalPointBoundaryFaces();
2282 return *globalBoundaryFaceNumberingPtr_;
2289 if (!globalPointBoundaryFacesPtr_.valid())
2291 calcGlobalPointBoundaryFaces();
2293 return *globalPointBoundaryFacesPtr_;
2300 if (!globalPointTransformedBoundaryFacesPtr_.valid())
2302 calcGlobalPointBoundaryFaces();
2304 return *globalPointTransformedBoundaryFacesPtr_;
2311 if (!globalPointBoundaryFacesMapPtr_.valid())
2313 calcGlobalPointBoundaryFaces();
2315 return *globalPointBoundaryFacesMapPtr_;
2321 if (!boundaryCellsPtr_.valid())
2323 calcGlobalPointBoundaryCells();
2325 return *boundaryCellsPtr_;
2332 if (!globalBoundaryCellNumberingPtr_.valid())
2334 calcGlobalPointBoundaryCells();
2336 return *globalBoundaryCellNumberingPtr_;
2343 if (!globalPointBoundaryCellsPtr_.valid())
2345 calcGlobalPointBoundaryCells();
2347 return *globalPointBoundaryCellsPtr_;
2354 if (!globalPointTransformedBoundaryCellsPtr_.valid())
2356 calcGlobalPointBoundaryCells();
2358 return *globalPointTransformedBoundaryCellsPtr_;
2365 if (!globalPointBoundaryCellsMapPtr_.valid())
2367 calcGlobalPointBoundaryCells();
2369 return *globalPointBoundaryCellsMapPtr_;
2375 if (!globalCoPointSlavesPtr_.valid())
2377 calcGlobalCoPointSlaves();
2379 return *globalCoPointSlavesPtr_;
2385 if (!globalCoPointSlavesMapPtr_.valid())
2387 calcGlobalCoPointSlaves();
2389 return *globalCoPointSlavesMapPtr_;
2400 const globalIndex& globalCoupledPoints = globalPointNumbering();
2403 const mapDistribute& pointSlavesMap = globalCoPointSlavesMap();
2412 forAll(masterGlobalPoint, pointi)
2414 const labelList& slavePoints = pointSlaves[pointi];
2415 if (slavePoints.size() > 0)
2417 masterGlobalPoint[pointi] = globalCoupledPoints.
toGlobal(pointi);
2434 bitSet isMaster(mesh_.nPoints(),
true);
2435 forAll(pointSlaves, pointi)
2437 if (masterGlobalPoint[pointi] == -1)
2444 masterGlobalPoint[pointi]
2445 == globalCoupledPoints.
toGlobal(pointi)
2458 label myUniquePoints = mesh_.nPoints() - cpp.
nPoints() + nMaster;
2472 pointToGlobal.
setSize(mesh_.nPoints());
2474 uniquePoints.
setSize(myUniquePoints);
2477 forAll(isMaster, meshPointi)
2479 if (isMaster[meshPointi])
2481 pointToGlobal[meshPointi] = globalPointsPtr().toGlobal(nMaster);
2482 uniquePoints[nMaster] = meshPointi;
2492 forAll(pointSlaves, pointi)
2494 const labelList& slaves = pointSlaves[pointi];
2496 if (slaves.size() > 0)
2500 masterToGlobal[pointi] = pointToGlobal[meshPointi];
2503 masterToGlobal[slaves[i]] = masterToGlobal[pointi];
2512 forAll(pointSlaves, pointi)
2516 if (!isMaster[meshPointi])
2518 pointToGlobal[meshPointi] = masterToGlobal[pointi];
2523 return globalPointsPtr;
2537 const mapDistribute& pointSlavesMap = globalCoPointSlavesMap();
2557 labelList patchToCoupled(meshPoints.size(), -1);
2562 forAll(meshPoints, patchPointi)
2564 label meshPointi = meshPoints[patchPointi];
2566 const auto iter = cpp.
meshPointMap().cfind(meshPointi);
2570 patchToCoupled[patchPointi] = iter();
2571 coupledToGlobalPatch[iter()] = globalPPoints.toGlobal(patchPointi);
2589 pointSlavesMap.
distribute(coupledToGlobalPatch);
2590 forAll(pointSlaves, coupledPointi)
2592 const labelList& slaves = pointSlaves[coupledPointi];
2594 if (slaves.size() > 0)
2598 if (coupledToGlobalPatch[coupledPointi] != -1)
2601 masterI = coupledToGlobalPatch[coupledPointi];
2608 label slavePp = coupledToGlobalPatch[slaves[i]];
2609 if (slavePp != -1 && slavePp < masterI)
2619 coupledToGlobalPatch[coupledPointi] = masterI;
2622 coupledToGlobalPatch[slaves[i]] = masterI;
2637 forAll(meshPoints, patchPointi)
2639 if (patchToCoupled[patchPointi] == -1)
2645 label coupledPointi = patchToCoupled[patchPointi];
2648 globalPPoints.toGlobal(patchPointi)
2649 == coupledToGlobalPatch[coupledPointi]
2670 pointToGlobal.
setSize(meshPoints.size());
2672 uniqueMeshPoints.
setSize(nMasters);
2679 forAll(meshPoints, patchPointi)
2681 if (patchToCoupled[patchPointi] == -1)
2683 uniqueMeshPoints[nMasters++] = meshPoints[patchPointi];
2687 label coupledPointi = patchToCoupled[patchPointi];
2690 globalPPoints.toGlobal(patchPointi)
2691 == coupledToGlobalPatch[coupledPointi]
2694 globalMaster[coupledPointi] =
2695 globalPointsPtr().toGlobal(nMasters);
2696 uniqueMeshPoints[nMasters++] = meshPoints[patchPointi];
2716 forAll(meshPoints, patchPointi)
2718 if (patchToCoupled[patchPointi] == -1)
2720 pointToGlobal[patchPointi] = globalPointsPtr().toGlobal(nMasters++);
2724 label coupledPointi = patchToCoupled[patchPointi];
2725 pointToGlobal[patchPointi] = globalMaster[coupledPointi];
2729 globalPPoints.toGlobal(patchPointi)
2730 == coupledToGlobalPatch[coupledPointi]
2738 return globalPointsPtr;
2759 scalar tolDim = matchTol_ * mesh_.bounds().mag();
2763 Pout<<
"globalMeshData : merge dist:" << tolDim <<
endl;
2787 Pout<<
"globalMeshData : nTotalFaces_:" << nTotalFaces_ <<
endl;
2800 Pout<<
"globalMeshData : nTotalCells_:" << nTotalCells_ <<
endl;
2815 Pout<<
"globalMeshData : nTotalPoints_:" << nTotalPoints_ <<
endl;