46 void Foam::refinementHistory::writeEntry
48 const List<splitCell8>& splitCells,
49 const splitCell8&
split
53 if (
split.addedCellsPtr_.valid())
56 <<
" subCells:" <<
split.addedCellsPtr_()
66 if (
split.parent_ >= 0)
81 const List<splitCell8>& splitCells
87 forAll(visibleCells, celli)
89 label index = visibleCells[celli];
93 Pout<<
"Cell from refinement:" << celli <<
" index:" << index
98 writeEntry(splitCells, splitCells[index]);
103 Pout<<
"Unrefined cell:" << celli <<
" index:" << index <<
endl;
115 addedCellsPtr_(nullptr)
122 addedCellsPtr_(nullptr)
137 sc.addedCellsPtr_.valid()
159 s.addedCellsPtr_.valid()
168 if (addedCellsPtr_.valid() !=
s.addedCellsPtr_.valid())
172 else if (parent_ !=
s.parent_)
176 else if (addedCellsPtr_.valid())
178 return addedCellsPtr_() ==
s.addedCellsPtr_();
197 is >> sc.
parent_ >> addedCells;
199 if (addedCells.size())
222 if (sc.addedCellsPtr_.valid())
238 void Foam::refinementHistory::checkIndices()
const
243 if (visibleCells_[i] < 0 && visibleCells_[i] >= splitCells_.size())
246 <<
"Illegal entry " << visibleCells_[i]
247 <<
" in visibleCells at location" << i <<
nl
248 <<
"It points outside the range of splitCells : 0.."
249 << splitCells_.size()-1
256 Foam::label Foam::refinementHistory::allocateSplitCell
264 if (freeSplitCells_.size())
266 index = freeSplitCells_.
remove();
268 splitCells_[index] = splitCell8(parent);
272 index = splitCells_.size();
274 splitCells_.append(splitCell8(parent));
281 splitCell8& parentSplit = splitCells_[parent];
283 if (parentSplit.addedCellsPtr_.empty())
286 parentSplit.addedCellsPtr_.reset(
new FixedList<label, 8>(-1));
291 FixedList<label, 8>& parentSplits = parentSplit.addedCellsPtr_();
293 parentSplits[i] = index;
300 void Foam::refinementHistory::freeSplitCell(
const label index)
302 splitCell8&
split = splitCells_[index];
305 if (
split.parent_ >= 0)
307 autoPtr<FixedList<label, 8>>& subCellsPtr =
308 splitCells_[
split.parent_].addedCellsPtr_;
310 if (subCellsPtr.valid())
312 FixedList<label, 8>& subCells = subCellsPtr();
314 label myPos = subCells.find(index);
319 <<
"Problem: cannot find myself in"
324 subCells[myPos] = -1;
333 freeSplitCells_.
append(index);
337 void Foam::refinementHistory::markSplit
341 DynamicList<splitCell8>& newSplitCells
344 if (oldToNew[index] == -1)
348 const splitCell8&
split = splitCells_[index];
350 oldToNew[index] = newSplitCells.size();
351 newSplitCells.append(
split);
353 if (
split.parent_ >= 0)
355 markSplit(
split.parent_, oldToNew, newSplitCells);
357 if (
split.addedCellsPtr_.valid())
359 const FixedList<label, 8>& splits =
split.addedCellsPtr_();
365 markSplit(splits[i], oldToNew, newSplitCells);
373 void Foam::refinementHistory::mark
380 splitToVal[index] =
val;
382 const splitCell8&
split = splitCells_[index];
384 if (
split.addedCellsPtr_.valid())
386 const FixedList<label, 8>& splits =
split.addedCellsPtr_();
392 mark(
val, splits[i], splitToVal);
399 Foam::label Foam::refinementHistory::markCommonCells
406 labelList splitToCluster(splitCells_.size(), -1);
409 forAll(visibleCells_, cellI)
411 label index = visibleCells_[cellI];
416 while (splitCells_[index].parent_ != -1)
418 index = splitCells_[index].parent_;
422 if (splitToCluster[index] == -1)
424 mark(clusterI, index, splitToCluster);
431 cellToCluster.setSize(visibleCells_.size(), -1);
433 forAll(visibleCells_, cellI)
435 label index = visibleCells_[cellI];
439 cellToCluster[cellI] = splitToCluster[index];
461 markCommonCells(cellToCluster);
466 label nUnblocked = 0;
470 label ownCluster = cellToCluster[
mesh.faceOwner()[faceI]];
471 label neiCluster = cellToCluster[
mesh.faceNeighbour()[faceI]];
473 if (ownCluster != -1 && ownCluster == neiCluster)
475 if (blockedFace[faceI])
477 blockedFace[faceI] =
false;
486 Info<<
type() <<
" : unblocked " << nUnblocked <<
" faces" <<
endl;
506 label nClusters = markCommonCells(cellToCluster);
520 label ownCluster = cellToCluster[own];
521 label neiCluster = cellToCluster[nei];
523 if (ownCluster != -1 && ownCluster == neiCluster)
525 if (clusterToProc[ownCluster] == -1)
527 clusterToProc[ownCluster] = decomposition[own];
530 if (decomposition[own] != clusterToProc[ownCluster])
532 decomposition[own] = clusterToProc[ownCluster];
535 if (decomposition[nei] != clusterToProc[ownCluster])
537 decomposition[nei] = clusterToProc[ownCluster];
546 Info<<
type() <<
" : changed decomposition on " << nChanged
560 warnNoRereading<refinementHistory>();
580 Pout<<
"refinementHistory::refinementHistory :"
581 <<
" constructed history from IOobject :"
582 <<
" splitCells:" << splitCells_.size()
583 <<
" visibleCells:" << visibleCells_.size()
584 <<
" active:" << active_
600 splitCells_(splitCells),
602 visibleCells_(visibleCells)
605 warnNoRereading<refinementHistory>();
614 readStream(typeName) >> *
this;
623 Pout<<
"refinementHistory::refinementHistory :"
624 <<
" constructed history from IOobject or components :"
625 <<
" splitCells:" << splitCells_.size()
626 <<
" visibleCells:" << visibleCells_.size()
627 <<
" active:" << active_
644 warnNoRereading<refinementHistory>();
653 readStream(typeName) >> *
this;
658 visibleCells_.setSize(nCells);
659 splitCells_.setCapacity(nCells);
661 for (
label cellI = 0; cellI < nCells; cellI++)
663 visibleCells_[cellI] = cellI;
676 Pout<<
"refinementHistory::refinementHistory :"
677 <<
" constructed history from IOobject or initial size :"
678 <<
" splitCells:" << splitCells_.size()
679 <<
" visibleCells:" << visibleCells_.size()
680 <<
" active:" << active_
699 warnNoRereading<refinementHistory>();
708 readStream(typeName) >> *
this;
713 visibleCells_.setSize(nCells);
714 splitCells_.setCapacity(nCells);
716 for (
label celli = 0; celli < nCells; celli++)
718 visibleCells_[celli] = celli;
728 Pout<<
"refinementHistory::refinementHistory :"
729 <<
" constructed history from IOobject or initial size :"
730 <<
" splitCells:" << splitCells_.size()
731 <<
" visibleCells:" << visibleCells_.size()
732 <<
" active:" << active_
752 Pout<<
"refinementHistory::refinementHistory : constructed initial"
753 <<
" history." <<
endl;
776 <<
"read option IOobject::MUST_READ, READ_IF_PRESENT or "
777 <<
"MUST_READ_IF_MODIFIED"
778 <<
" suggests that a read constructor would be more appropriate."
791 offsets[refI+1] = offsets[refI]+subSplits.size();
795 splitCells_.
setSize(offsets.last());
801 splitCell8& newSplit = splitCells_[offsets[refI]+i];
804 newSplit = subSplits[i];
809 newSplit.
parent_ += offsets[refI];
820 splits[i] += offsets[refI];
832 const labelList& cellMap = cellMaps[refI];
833 const labelList& subVis = refs[refI].visibleCells();
837 label& newVis = visibleCells_[cellMap[i]];
842 newVis += offsets[refI];
853 if (refs[refI].active())
865 Pout<<
"refinementHistory::refinementHistory :"
866 <<
" constructed history from multiple refinementHistories :"
867 <<
" splitCells:" << splitCells_.size()
868 <<
" visibleCells:" << visibleCells_.size()
888 Pout<<
"refinementHistory::refinementHistory :"
889 <<
" constructed history from Istream"
890 <<
" splitCells:" << splitCells_.size()
891 <<
" visibleCells:" << visibleCells_.size()
915 oldToNewSplit.
setSize(splitCells_.size());
924 forAll(splitCells_, index)
926 if (splitCellProc[index] == procI && splitCellNum[index] == 8)
929 oldToNewSplit[index] = newSplitCells.size();
930 newSplitCells.
append(splitCells_[index]);
935 forAll(visibleCells_, cellI)
937 label index = visibleCells_[cellI];
939 if (index >= 0 && decomposition[cellI] == procI)
941 label parent = splitCells_[index].parent_;
944 oldToNewSplit[index] = newSplitCells.size();
955 newSplitCells.shrink();
958 forAll(newSplitCells, index)
962 if (
split.parent_ >= 0)
966 if (
split.addedCellsPtr_.valid())
974 splits[i] = oldToNewSplit[splits[i]];
983 forAll(decomposition, cellI)
985 if (decomposition[cellI] == procI)
994 forAll(visibleCells_, cellI)
996 if (decomposition[cellI] == procI)
998 label index = visibleCells_[cellI];
1001 index = oldToNewSplit[index];
1003 newVisibleCells[nSub++] = index;
1032 decomposition[cellMap[i]] = 1;
1037 labelList splitCellProc(splitCells_.size(), -1);
1042 forAll(visibleCells_, cellI)
1044 label index = visibleCells_[cellI];
1050 splitCells_[index].parent_,
1051 decomposition[cellI],
1087 label oldSize = visibleCells_.size();
1091 Pout<<
"refinementHistory::resize from " << oldSize <<
" to " << size
1092 <<
" cells" <<
endl;
1095 visibleCells_.setSize(size);
1098 for (
label i = oldSize; i < visibleCells_.size(); i++)
1100 visibleCells_[i] = -1;
1115 forAll(visibleCells_, celli)
1117 if (visibleCells_[celli] != -1)
1119 label index = visibleCells_[celli];
1122 if (splitCells_[index].addedCellsPtr_.valid())
1128 label newCelli = reverseCellMap[celli];
1132 newVisibleCells[newCelli] = index;
1139 Pout<<
"refinementHistory::updateMesh : from "
1140 << visibleCells_.size()
1141 <<
" to " << newVisibleCells.size()
1142 <<
" cells" <<
endl;
1145 visibleCells_.transfer(newVisibleCells);
1159 labelList newVisibleCells(cellMap.size(), -1);
1161 forAll(newVisibleCells, celli)
1163 label oldCelli = cellMap[celli];
1165 label index = visibleCells_[oldCelli];
1168 if (index >= 0 && splitCells_[index].addedCellsPtr_.valid())
1174 newVisibleCells[celli] = index;
1179 Pout<<
"refinementHistory::updateMesh : from "
1180 << visibleCells_.size()
1181 <<
" to " << newVisibleCells.size()
1182 <<
" cells" <<
endl;
1185 visibleCells_.transfer(newVisibleCells);
1190 void Foam::refinementHistory::countProc
1193 const label newProcNo,
1198 if (splitCellProc[index] != newProcNo)
1202 splitCellProc[index] = newProcNo;
1203 splitCellNum[index] = 1;
1207 splitCellNum[index]++;
1210 if (splitCellNum[index] == 8)
1214 Pout<<
"Moving " << splitCellNum[index]
1215 <<
" cells originating from cell " << index
1217 <<
" to processor " << splitCellProc[index]
1221 label parent = splitCells_[index].parent_;
1225 countProc(parent, newProcNo, splitCellProc, splitCellNum);
1265 labelList destination(visibleCells_.size());
1269 forAll(subCellMap, proci)
1271 const labelList& newToOld = subCellMap[proci];
1275 label oldCelli = newToOld[i];
1277 destination[oldCelli] = proci;
1282 labelList splitCellProc(splitCells_.size(), -1);
1286 forAll(visibleCells_, celli)
1288 label index = visibleCells_[celli];
1294 splitCells_[index].parent_,
1316 labelList oldToNew(splitCells_.size(), -1);
1324 forAll(splitCells_, index)
1326 if (splitCellProc[index] == proci && splitCellNum[index] == 8)
1329 oldToNew[index] = newSplitCells.size();
1330 newSplitCells.append(splitCells_[index]);
1335 forAll(visibleCells_, celli)
1337 label index = visibleCells_[celli];
1339 if (index >= 0 && destination[celli] == proci)
1341 label parent = splitCells_[index].parent_;
1344 oldToNew[index] = newSplitCells.size();
1355 newSplitCells.shrink();
1358 forAll(newSplitCells, index)
1362 if (
split.parent_ >= 0)
1366 if (
split.addedCellsPtr_.valid())
1374 splits[i] = oldToNew[splits[i]];
1381 const labelList& subMap = subCellMap[proci];
1384 labelList newVisibleCells(subMap.size(), -1);
1388 label oldCelli = subMap[newCelli];
1390 label oldIndex = visibleCells_[oldCelli];
1394 newVisibleCells[newCelli] = oldToNew[oldIndex];
1405 toNbr << newSplitCells << newVisibleCells;
1413 splitCells_.clear();
1433 label offset = splitCells_.size();
1438 forAll(newSplitCells, index)
1442 if (
split.parent_ >= 0)
1444 split.parent_ += offset;
1446 if (
split.addedCellsPtr_.valid())
1454 splits[i] += offset;
1459 splitCells_.append(
split);
1466 forAll(newVisibleCells, i)
1468 if (newVisibleCells[i] >= 0)
1470 visibleCells_[constructMap[i]] = newVisibleCells[i] + offset;
1474 splitCells_.shrink();
1486 Pout<<
"refinementHistory::compact() Entering with:"
1487 <<
" freeSplitCells_:" << freeSplitCells_.size()
1488 <<
" splitCells_:" << splitCells_.size()
1489 <<
" visibleCells_:" << visibleCells_.size()
1493 forAll(freeSplitCells_, i)
1495 label index = freeSplitCells_[i];
1497 if (splitCells_[index].parent_ != -2)
1500 <<
"Problem index:" << index
1506 forAll(visibleCells_, celli)
1510 visibleCells_[celli] >= 0
1511 && splitCells_[visibleCells_[celli]].parent_ == -2
1515 <<
"Problem : visible cell:" << celli
1524 labelList oldToNew(splitCells_.size(), -1);
1530 forAll(visibleCells_, celli)
1532 label index = visibleCells_[celli];
1540 splitCells_[index].parent_ != -1
1541 || splitCells_[index].addedCellsPtr_.valid()
1544 markSplit(index, oldToNew, newSplitCells);
1550 forAll(splitCells_, index)
1552 if (splitCells_[index].parent_ == -2)
1558 splitCells_[index].parent_ == -1
1559 && splitCells_[index].addedCellsPtr_.empty()
1568 markSplit(index, oldToNew, newSplitCells);
1576 forAll(newSplitCells, index)
1580 if (
split.parent_ >= 0)
1584 if (
split.addedCellsPtr_.valid())
1592 splits[i] = oldToNew[splits[i]];
1601 Pout<<
"refinementHistory::compact : compacted splitCells from "
1602 << splitCells_.size() <<
" to " << newSplitCells.size() <<
endl;
1605 splitCells_.transfer(newSplitCells);
1606 freeSplitCells_.clearStorage();
1611 Pout<<
"refinementHistory::compact() NOW:"
1612 <<
" freeSplitCells_:" << freeSplitCells_.size()
1613 <<
" splitCells_:" << splitCells_.size()
1614 <<
" newSplitCells:" << newSplitCells.size()
1615 <<
" visibleCells_:" << visibleCells_.size()
1621 forAll(visibleCells_, celli)
1623 label index = visibleCells_[celli];
1628 visibleCells_[celli] = oldToNew[index];
1640 writeDebug(visibleCells_, splitCells_);
1650 label parentIndex = -1;
1652 if (visibleCells_[celli] != -1)
1657 parentIndex = visibleCells_[celli];
1661 visibleCells_[celli] = -1;
1666 parentIndex = allocateSplitCell(-1, -1);
1673 label addedCelli = addedCells[i];
1677 visibleCells_[addedCelli] = allocateSplitCell(parentIndex, i);
1684 const label masterCelli,
1689 label parentIndex = splitCells_[visibleCells_[masterCelli]].parent_;
1694 label celli = combinedCells[i];
1696 freeSplitCell(visibleCells_[celli]);
1697 visibleCells_[celli] = -1;
1700 splitCell8& parentSplit = splitCells_[parentIndex];
1702 visibleCells_[masterCelli] = parentIndex;
1708 bool ok = readData(readStream(typeName));
1745 if (
exists(setsDir/typeName))
1747 rm(setsDir/typeName);
1758 is >> rh.splitCells_ >> rh.visibleCells_;
1771 return os <<
"// splitCells" <<
nl
1772 << rh.splitCells_ <<
nl
1773 <<
"// visibleCells" <<
nl
1774 << rh.visibleCells_;