61 Foam::snappyRefineDriver::snappyRefineDriver
72 meshRefiner_(meshRefiner),
73 decomposer_(decomposer),
74 distributor_(distributor),
75 globalToMasterPatch_(globalToMasterPatch),
76 globalToSlavePatch_(globalToSlavePatch),
77 setFormatter_(setFormatter),
84 Foam::label Foam::snappyRefineDriver::featureEdgeRefine
104 const fvMesh&
mesh = meshRefiner_.
mesh();
108 if (meshRefiner_.
features().size() && maxIter > 0)
110 for (; iter < maxIter; iter++)
113 <<
"Feature refinement iteration " << iter <<
nl
114 <<
"------------------------------" <<
nl
146 Info<<
"Determined cells to refine in = "
147 <<
mesh.time().cpuTimeIncrement() <<
" s" <<
endl;
151 label nCellsToRefine = cellsToRefine.size();
152 reduce(nCellsToRefine, sumOp<label>());
154 Info<<
"Selected for feature refinement : " << nCellsToRefine
155 <<
" cells (out of " <<
mesh.globalData().nTotalCells()
158 if (nCellsToRefine <= minRefine)
160 Info<<
"Stopping refining since too few cells selected."
168 const_cast<Time&
>(
mesh.time())++;
183 "feature refinement iteration " +
name(iter),
194 "feature refinement iteration " +
name(iter),
207 Foam::label Foam::snappyRefineDriver::smallFeatureRefine
209 const refinementParameters& refineParams,
218 if (refineParams.minRefineCells() == -1)
225 addProfiling(feature,
"snappyHexMesh::refine::smallFeature");
226 const fvMesh&
mesh = meshRefiner_.mesh();
231 labelList surfaceMaxLevel(meshRefiner_.surfaces().maxGapLevel());
232 labelList shellMaxLevel(meshRefiner_.shells().maxGapLevel());
234 if (
max(surfaceMaxLevel) == 0 &&
max(shellMaxLevel) == 0)
239 for (; iter < maxIter; iter++)
242 <<
"Small surface feature refinement iteration " << iter <<
nl
243 <<
"--------------------------------------------" <<
nl
252 meshRefiner_.refineCandidates
254 refineParams.locationsInMesh(),
255 refineParams.curvature(),
256 refineParams.planarAngle(),
267 refineParams.maxGlobalCells(),
268 refineParams.maxLocalCells()
274 meshRefiner_.meshCutter().consistentRefinement
280 Info<<
"Determined cells to refine in = "
284 label nCellsToRefine = cellsToRefine.size();
285 reduce(nCellsToRefine, sumOp<label>());
287 Info<<
"Selected for refinement : " << nCellsToRefine
293 if (nCellsToRefine == 0)
295 Info<<
"Stopping refining since too few cells selected."
311 (
mesh.
nCells() >= refineParams.maxLocalCells()),
316 meshRefiner_.balanceAndRefine
318 "small feature refinement iteration " +
name(iter),
322 refineParams.maxLoadUnbalance()
327 meshRefiner_.refineAndBalance
329 "small feature refinement iteration " +
name(iter),
333 refineParams.maxLoadUnbalance()
341 Foam::label Foam::snappyRefineDriver::surfaceOnlyRefine
343 const refinementParameters& refineParams,
352 if (refineParams.minRefineCells() == -1)
359 addProfiling(surface,
"snappyHexMesh::refine::surface");
360 const fvMesh&
mesh = meshRefiner_.mesh();
364 label overallMaxLevel =
max(meshRefiner_.surfaces().maxLevel());
367 for (iter = 0; iter < maxIter; iter++)
370 <<
"Surface refinement iteration " << iter <<
nl
371 <<
"------------------------------" <<
nl
382 meshRefiner_.refineCandidates
384 refineParams.locationsInMesh(),
385 refineParams.curvature(),
386 refineParams.planarAngle(),
397 refineParams.maxGlobalCells(),
398 refineParams.maxLocalCells()
403 meshRefiner_.meshCutter().consistentRefinement
409 Info<<
"Determined cells to refine in = "
413 label nCellsToRefine = cellsToRefine.size();
414 reduce(nCellsToRefine, sumOp<label>());
416 Info<<
"Selected for refinement : " << nCellsToRefine
426 iter >= overallMaxLevel
427 && nCellsToRefine <= refineParams.minRefineCells()
431 Info<<
"Stopping refining since too few cells selected."
447 (
mesh.
nCells() >= refineParams.maxLocalCells()),
452 meshRefiner_.balanceAndRefine
454 "surface refinement iteration " +
name(iter),
458 refineParams.maxLoadUnbalance()
463 meshRefiner_.refineAndBalance
465 "surface refinement iteration " +
name(iter),
469 refineParams.maxLoadUnbalance()
477 Foam::label Foam::snappyRefineDriver::gapOnlyRefine
479 const refinementParameters& refineParams,
488 if (refineParams.minRefineCells() == -1)
495 const fvMesh&
mesh = meshRefiner_.mesh();
500 label maxIncrement = 0;
501 const labelList& maxLevel = meshRefiner_.surfaces().maxLevel();
502 const labelList& gapLevel = meshRefiner_.surfaces().gapLevel();
506 maxIncrement =
max(maxIncrement, gapLevel[i]-maxLevel[i]);
511 if (maxIncrement == 0)
516 for (iter = 0; iter < maxIter; iter++)
519 <<
"Gap refinement iteration " << iter <<
nl
520 <<
"--------------------------" <<
nl
531 meshRefiner_.refineCandidates
533 refineParams.locationsInMesh(),
534 refineParams.curvature(),
535 refineParams.planarAngle(),
546 refineParams.maxGlobalCells(),
547 refineParams.maxLocalCells()
553 Pout<<
"Writing current mesh to time "
554 << meshRefiner_.timeName() <<
endl;
565 Pout<<
"Dumped mesh in = "
569 Pout<<
"Dumping " << candidateCells.size()
570 <<
" cells to cellSet candidateCellsFromGap." <<
endl;
571 cellSet
c(
mesh,
"candidateCellsFromGap", candidateCells);
572 c.instance() = meshRefiner_.timeName();
581 isCandidateCell[candidateCells[i]] =
true;
584 for (label i=0; i<1; i++)
586 boolList newIsCandidateCell(isCandidateCell);
594 if (isCandidateCell[own] != isCandidateCell[nei])
596 newIsCandidateCell[own] =
true;
597 newIsCandidateCell[nei] =
true;
621 if (isCandidateCell[own] != neiIsCandidateCell[bFacei])
623 newIsCandidateCell[own] =
true;
627 isCandidateCell.transfer(newIsCandidateCell);
631 forAll(isCandidateCell, celli)
633 if (isCandidateCell[celli])
638 candidateCells.setSize(
n);
640 forAll(isCandidateCell, celli)
642 if (isCandidateCell[celli])
644 candidateCells[
n++] = celli;
652 Pout<<
"Dumping " << candidateCells.size()
653 <<
" cells to cellSet candidateCellsFromGapPlusBuffer." <<
endl;
654 cellSet
c(
mesh,
"candidateCellsFromGapPlusBuffer", candidateCells);
655 c.instance() = meshRefiner_.timeName();
662 meshRefiner_.meshCutter().consistentRefinement
668 Info<<
"Determined cells to refine in = "
672 label nCellsToRefine = cellsToRefine.size();
673 reduce(nCellsToRefine, sumOp<label>());
675 Info<<
"Selected for refinement : " << nCellsToRefine
686 && nCellsToRefine <= refineParams.minRefineCells()
690 Info<<
"Stopping refining since too few cells selected."
706 (
mesh.
nCells() >= refineParams.maxLocalCells()),
711 meshRefiner_.balanceAndRefine
713 "gap refinement iteration " +
name(iter),
717 refineParams.maxLoadUnbalance()
722 meshRefiner_.refineAndBalance
724 "gap refinement iteration " +
name(iter),
728 refineParams.maxLoadUnbalance()
736 Foam::label Foam::snappyRefineDriver::surfaceProximityBlock
738 const refinementParameters& refineParams,
742 if (refineParams.minRefineCells() == -1)
749 fvMesh&
mesh = meshRefiner_.mesh();
751 if (
min(meshRefiner_.surfaces().blockLevel()) ==
labelMax)
758 for (iter = 0; iter < maxIter; iter++)
761 <<
"Gap blocking iteration " << iter <<
nl
762 <<
"------------------------" <<
nl
769 meshRefiner_.removeGapCells
771 refineParams.planarAngle(),
772 meshRefiner_.surfaces().blockLevel(),
773 globalToMasterPatch_,
774 refineParams.nFilterIter()
780 Pout<<
"Writing gap blocking iteration "
781 << iter <<
" mesh to time " << meshRefiner_.timeName()
799 Foam::label Foam::snappyRefineDriver::bigGapOnlyRefine
801 const refinementParameters& refineParams,
802 const bool spreadGapSize,
806 if (refineParams.minRefineCells() == -1)
818 const fvMesh&
mesh = meshRefiner_.mesh();
823 labelList surfaceMaxLevel(meshRefiner_.surfaces().maxGapLevel());
824 labelList shellMaxLevel(meshRefiner_.shells().maxGapLevel());
826 label overallMaxLevel(
max(
max(surfaceMaxLevel),
max(shellMaxLevel)));
828 if (overallMaxLevel == 0)
834 for (; iter < maxIter; iter++)
837 <<
"Big gap refinement iteration " << iter <<
nl
838 <<
"------------------------------" <<
nl
847 meshRefiner_.refineCandidates
849 refineParams.locationsInMesh(),
850 refineParams.curvature(),
851 refineParams.planarAngle(),
862 refineParams.maxGlobalCells(),
863 refineParams.maxLocalCells()
870 Pout<<
"Writing current mesh to time "
871 << meshRefiner_.timeName() <<
endl;
882 Pout<<
"Dumped mesh in = "
885 Pout<<
"Dumping " << candidateCells.size()
886 <<
" cells to cellSet candidateCellsFromBigGap." <<
endl;
887 cellSet
c(
mesh,
"candidateCellsFromBigGap", candidateCells);
888 c.instance() = meshRefiner_.timeName();
894 meshRefiner_.meshCutter().consistentRefinement
900 Info<<
"Determined cells to refine in = "
904 label nCellsToRefine = cellsToRefine.size();
905 reduce(nCellsToRefine, sumOp<label>());
907 Info<<
"Selected for refinement : " << nCellsToRefine
917 iter >= overallMaxLevel
918 && nCellsToRefine <= refineParams.minRefineCells()
922 Info<<
"Stopping refining since too few cells selected."
938 (
mesh.
nCells() >= refineParams.maxLocalCells()),
943 meshRefiner_.balanceAndRefine
945 "big gap refinement iteration " +
name(iter),
949 refineParams.maxLoadUnbalance()
954 meshRefiner_.refineAndBalance
956 "big gap refinement iteration " +
name(iter),
960 refineParams.maxLoadUnbalance()
968 Foam::label Foam::snappyRefineDriver::danglingCellRefine
970 const refinementParameters& refineParams,
975 if (refineParams.minRefineCells() == -1)
987 addProfiling(dangling,
"snappyHexMesh::refine::danglingCell");
988 const fvMesh&
mesh = meshRefiner_.mesh();
991 for (iter = 0; iter < maxIter; iter++)
994 <<
"Dangling coarse cells refinement iteration " << iter <<
nl
995 <<
"--------------------------------------------" <<
nl
1007 cellSet candidateCellSet(
mesh,
"candidateCells",
cells.size()/1000);
1011 const cell& cFaces =
cells[celli];
1013 label nIntFaces = 0;
1023 label patchi = pbm.patchID()[bFacei];
1024 if (pbm[patchi].coupled())
1031 if (nIntFaces == nFaces)
1033 candidateCellSet.insert(celli);
1039 Pout<<
"Dumping " << candidateCellSet.size()
1040 <<
" cells to cellSet candidateCellSet." <<
endl;
1041 candidateCellSet.instance() = meshRefiner_.timeName();
1042 candidateCellSet.
write();
1044 candidateCells = candidateCellSet.toc();
1051 meshRefiner_.meshCutter().consistentRefinement
1057 Info<<
"Determined cells to refine in = "
1061 label nCellsToRefine = cellsToRefine.size();
1062 reduce(nCellsToRefine, sumOp<label>());
1064 Info<<
"Selected for refinement : " << nCellsToRefine
1075 && nCellsToRefine <= refineParams.minRefineCells()
1079 Info<<
"Stopping refining since too few cells selected."
1095 (
mesh.
nCells() >= refineParams.maxLocalCells()),
1100 meshRefiner_.balanceAndRefine
1102 "coarse cell refinement iteration " +
name(iter),
1106 refineParams.maxLoadUnbalance()
1111 meshRefiner_.refineAndBalance
1113 "coarse cell refinement iteration " +
name(iter),
1117 refineParams.maxLoadUnbalance()
1127 Foam::label Foam::snappyRefineDriver::refinementInterfaceRefine
1129 const refinementParameters& refineParams,
1133 if (refineParams.minRefineCells() == -1)
1146 const fvMesh&
mesh = meshRefiner_.mesh();
1150 if (refineParams.interfaceRefine())
1152 for (;iter < maxIter; iter++)
1155 <<
"Refinement transition refinement iteration " << iter <<
nl
1156 <<
"--------------------------------------------" <<
nl
1159 const labelList& surfaceIndex = meshRefiner_.surfaceIndex();
1160 const hexRef8& cutter = meshRefiner_.meshCutter();
1174 cellSet transitionCells
1183 const cell& cFaces =
cells[celli];
1184 label cLevel = cutter.cellLevel()[celli];
1188 label facei = cFaces[cFacei];
1190 if (surfaceIndex[facei] != -1)
1192 label fLevel = cutter.faceLevel(facei);
1193 if (fLevel != cLevel)
1195 transitionCells.insert(celli);
1202 cellSet candidateCellSet
1323 for (
const label celli : transitionCells)
1325 const cell& cFaces =
cells[celli];
1326 label cLevel = cutter.cellLevel()[celli];
1329 bool foundOpposite =
false;
1333 label facei = cFaces[cFacei];
1337 surfaceIndex[facei] != -1
1338 && cutter.faceLevel(facei) > cLevel
1343 if (faceOwner[facei] != celli)
1351 label face2i = cFaces[cFaceI2];
1356 && surfaceIndex[face2i] != -1
1361 if (faceOwner[face2i] != celli)
1367 if ((
n&n2) < oppositeCos)
1369 foundOpposite =
true;
1385 candidateCellSet.insert(celli);
1391 Pout<<
"Dumping " << candidateCellSet.size()
1392 <<
" cells to cellSet candidateCellSet." <<
endl;
1393 candidateCellSet.instance() = meshRefiner_.timeName();
1394 candidateCellSet.
write();
1396 candidateCells = candidateCellSet.toc();
1403 meshRefiner_.meshCutter().consistentRefinement
1409 Info<<
"Determined cells to refine in = "
1413 label nCellsToRefine = cellsToRefine.size();
1414 reduce(nCellsToRefine, sumOp<label>());
1416 Info<<
"Selected for refinement : " << nCellsToRefine
1427 && nCellsToRefine <= refineParams.minRefineCells()
1431 Info<<
"Stopping refining since too few cells selected."
1447 (
mesh.
nCells() >= refineParams.maxLocalCells()),
1452 meshRefiner_.balanceAndRefine
1454 "interface cell refinement iteration " +
name(iter),
1458 refineParams.maxLoadUnbalance()
1463 meshRefiner_.refineAndBalance
1465 "interface cell refinement iteration " +
name(iter),
1469 refineParams.maxLoadUnbalance()
1478 void Foam::snappyRefineDriver::removeInsideCells
1480 const refinementParameters& refineParams,
1481 const label nBufferLayers
1485 if (meshRefiner_.limitShells().shells().size() == 0 && nBufferLayers == 0)
1496 <<
"Removing mesh beyond surface intersections" <<
nl
1497 <<
"------------------------------------------" <<
nl
1500 const fvMesh&
mesh = meshRefiner_.mesh();
1508 meshRefiner_.removeLimitShells
1512 globalToMasterPatch_,
1513 globalToSlavePatch_,
1514 refineParams.locationsInMesh(),
1515 refineParams.zonesInMesh()
1520 meshRefiner_.splitMesh
1523 refineParams.nErodeCellZone(),
1524 globalToMasterPatch_,
1525 globalToSlavePatch_,
1526 refineParams.locationsInMesh(),
1527 refineParams.zonesInMesh(),
1528 refineParams.locationsOutsideMesh(),
1536 Pout<<
"Writing subsetted mesh to time "
1537 << meshRefiner_.timeName() <<
endl;
1548 Pout<<
"Dumped mesh in = "
1554 Foam::label Foam::snappyRefineDriver::shellRefine
1556 const refinementParameters& refineParams,
1565 if (refineParams.minRefineCells() == -1)
1573 const fvMesh&
mesh = meshRefiner_.mesh();
1576 meshRefiner_.userFaceData().setSize(1);
1580 meshRefiner_.userFaceData()[0].second() = ListOps::createWithValue<label>
1583 meshRefiner_.intersectedFaces(),
1591 label overallMaxShellLevel = meshRefiner_.shells().maxLevel();
1594 for (iter = 0; iter < maxIter; iter++)
1597 <<
"Shell refinement iteration " << iter <<
nl
1598 <<
"----------------------------" <<
nl
1603 meshRefiner_.refineCandidates
1605 refineParams.locationsInMesh(),
1606 refineParams.curvature(),
1607 refineParams.planarAngle(),
1618 refineParams.maxGlobalCells(),
1619 refineParams.maxLocalCells()
1625 Pout<<
"Dumping " << candidateCells.size()
1626 <<
" cells to cellSet candidateCellsFromShells." <<
endl;
1628 cellSet
c(
mesh,
"candidateCellsFromShells", candidateCells);
1629 c.instance() = meshRefiner_.timeName();
1642 findIndices(meshRefiner_.userFaceData()[0].second(), 0)
1650 if (refineParams.nBufferLayers() <= 2)
1652 cellsToRefine = meshRefiner_.meshCutter().consistentSlowRefinement
1654 refineParams.nBufferLayers(),
1658 meshRefiner_.intersectedPoints()
1663 cellsToRefine = meshRefiner_.meshCutter().consistentSlowRefinement2
1665 refineParams.nBufferLayers(),
1671 Info<<
"Determined cells to refine in = "
1675 label nCellsToRefine = cellsToRefine.size();
1676 reduce(nCellsToRefine, sumOp<label>());
1678 Info<<
"Selected for internal refinement : " << nCellsToRefine
1688 iter >= overallMaxShellLevel
1689 && nCellsToRefine <= refineParams.minRefineCells()
1693 Info<<
"Stopping refining since too few cells selected."
1708 (
mesh.
nCells() >= refineParams.maxLocalCells()),
1713 meshRefiner_.balanceAndRefine
1715 "shell refinement iteration " +
name(iter),
1719 refineParams.maxLoadUnbalance()
1724 meshRefiner_.refineAndBalance
1726 "shell refinement iteration " +
name(iter),
1730 refineParams.maxLoadUnbalance()
1734 meshRefiner_.userFaceData().clear();
1740 Foam::label Foam::snappyRefineDriver::directionalShellRefine
1742 const refinementParameters& refineParams,
1751 addProfiling(shell,
"snappyHexMesh::refine::directionalShell");
1752 const fvMesh&
mesh = meshRefiner_.mesh();
1753 const shellSurfaces& shells = meshRefiner_.shells();
1756 const_cast<labelIOList&
>(meshRefiner_.meshCutter().cellLevel());
1758 const_cast<labelIOList&
>(meshRefiner_.meshCutter().pointLevel());
1763 const labelPairList dirSelect(shells.directionalSelectLevel());
1766 forAll(dirSelect, shelli)
1768 overallMinLevel =
min(dirSelect[shelli].first(), overallMinLevel);
1769 overallMaxLevel =
max(dirSelect[shelli].second(), overallMaxLevel);
1772 if (overallMinLevel > overallMaxLevel)
1778 List<labelVector> dirCellLevel(cellLevel.size());
1785 for (iter = 0; iter < maxIter; iter++)
1788 <<
"Directional shell refinement iteration " << iter <<
nl
1789 <<
"----------------------------------------" <<
nl
1792 label nAllRefine = 0;
1803 labelList currentLevel(dirCellLevel.size());
1804 forAll(dirCellLevel, celli)
1806 currentLevel[celli] = dirCellLevel[celli][dir];
1811 meshRefiner_.directionalRefineCandidates
1813 refineParams.maxGlobalCells(),
1814 refineParams.maxLocalCells(),
1823 meshRefiner_.meshCutter().consistentRefinement
1831 Info<<
"Determined cells to refine in = "
1834 label nCellsToRefine = cellsToRefine.size();
1835 reduce(nCellsToRefine, sumOp<label>());
1838 <<
" refinement : " << nCellsToRefine
1842 nAllRefine += nCellsToRefine;
1846 if (nCellsToRefine > 0)
1853 const bitSet isRefineCell(
mesh.
nCells(), cellsToRefine);
1855 autoPtr<mapPolyMesh> map
1857 meshRefiner_.directionalRefine
1859 "directional refinement iteration " +
name(iter),
1865 Info<<
"Refined mesh in = "
1886 forAll(map().cellMap(), celli)
1888 if (isRefineCell[map().cellMap()[celli]])
1890 dirCellLevel[celli][dir]++;
1896 forAll(map().pointMap(), pointi)
1898 label oldPointi = map().pointMap()[pointi];
1899 if (map().reversePointMap()[oldPointi] != pointi)
1902 pointLevel[pointi]++;
1909 if (nAllRefine == 0)
1911 Info<<
"Stopping refining since no cells selected."
1916 meshRefiner_.printMeshInfo
1919 "After directional refinement iteration " +
name(iter)
1924 Pout<<
"Writing directional refinement iteration "
1925 << iter <<
" mesh to time " << meshRefiner_.timeName() <<
endl;
1947 cellLevel[celli] =
cmptMax(dirCellLevel[celli]);
1954 void Foam::snappyRefineDriver::mergeAndSmoothRatio
1957 const label nSmoothExpansion,
1958 List<Tuple2<scalar, scalar>>& keyAndValue
1963 SortableList<scalar> unmergedDist(allSeedPointDist);
1964 DynamicList<scalar> mergedDist;
1966 scalar prevDist = GREAT;
1969 scalar curDist = unmergedDist[i];
1970 scalar difference =
mag(curDist - prevDist);
1971 if (difference > meshRefiner_.mergeDistance())
1974 mergedDist.append(curDist);
1980 SortableList<scalar> sortedDist(mergedDist);
1981 labelList indexSet = sortedDist.indices();
1984 scalarList seedPointsNewLocation = sortedDist;
1986 scalar initResidual = 0.0;
1987 scalar prevIterResidual = GREAT;
1989 for (label iter = 0; iter < nSmoothExpansion; iter++)
2003 for(label i = 2; i<mergedDist.size()-1; i++)
2005 scalar oldX00 = sortedDist[i-2];
2006 scalar oldX1 = sortedDist[i+1];
2007 scalar curX0 = seedPointsNewLocation[i-1];
2008 seedPointsNewLocation[i] = curX0 + (oldX1 - oldX00)/3;
2011 const scalarField residual(seedPointsNewLocation-sortedDist);
2013 scalar res(
sumMag(residual));
2019 res /= initResidual;
2021 if (
mag(prevIterResidual - res) < SMALL)
2025 Pout<<
"Converged with iteration " << iter
2026 <<
" initResidual: " << initResidual
2027 <<
" final residual : " << res <<
endl;
2033 prevIterResidual = res;
2038 sortedDist = seedPointsNewLocation;
2042 keyAndValue.setSize(mergedDist.size());
2046 keyAndValue[i].first() = mergedDist[i];
2047 label index = indexSet[i];
2048 keyAndValue[i].second() = seedPointsNewLocation[index];
2053 Foam::label Foam::snappyRefineDriver::directionalSmooth
2055 const refinementParameters& refineParams
2060 <<
"Directional expansion ratio smoothing" <<
nl
2061 <<
"-------------------------------------" <<
nl
2064 fvMesh& baseMesh = meshRefiner_.mesh();
2065 const searchableSurfaces& geometry = meshRefiner_.surfaces().geometry();
2066 const shellSurfaces& shells = meshRefiner_.shells();
2070 forAll(shells.nSmoothExpansion(), shellI)
2074 shells.nSmoothExpansion()[shellI] > 0
2075 || shells.nSmoothPosition()[shellI] > 0
2078 label surfi = shells.shells()[shellI];
2079 const vector& userDirection = shells.smoothDirection()[shellI];
2086 List<volumeType> volType;
2087 geometry[surfi].getVolumeType(baseMesh.points(), volType);
2119 bitSet isXEdge(baseMesh.edges().size());
2121 const edgeList& edges = baseMesh.edges();
2124 const edge&
e = edges[edgei];
2125 vector eVec(
e.vec(baseMesh.points()));
2127 if (
mag(eVec&userDirection) > 0.9)
2136 const scalar totalLength =
2137 geometry[surfi].bounds().span()
2139 const scalar startPosition =
2140 geometry[surfi].bounds().min()
2147 normalizedPosition[i] =
2149 ((baseMesh.points()[pointi]&userDirection) - startPosition)
2157 DynamicList<scalar> seedPointDist;
2160 scalar prevDist = GREAT;
2163 label pointi = order[i];
2164 scalar curDist = normalizedPosition[pointi];
2165 if (
mag(curDist - prevDist) > meshRefiner_.mergeDistance())
2167 seedPointDist.append(curDist);
2181 ListListOps::combine<scalarList>
2183 gatheredDist, accessOp<scalarList>()
2188 bitSet isFrozenPoint(baseMesh.nPoints(),
true);
2191 scalar minSeed =
min(allSeedPointDist);
2193 scalar maxSeed =
max(allSeedPointDist);
2196 forAll(normalizedPosition, posI)
2198 const scalar
pos = normalizedPosition[posI];
2201 (
mag(
pos-minSeed) < meshRefiner_.mergeDistance())
2202 || (
mag(
pos-maxSeed) < meshRefiner_.mergeDistance())
2216 Info<<
"Smoothing " << geometry[surfi].name() <<
':' <<
nl
2217 <<
" Direction : " << userDirection <<
nl
2218 <<
" Number of points : "
2220 <<
" (out of " << baseMesh.globalData().nTotalPoints()
2222 <<
" Smooth expansion iterations : "
2223 << shells.nSmoothExpansion()[shellI] <<
nl
2224 <<
" Smooth position iterations : "
2225 << shells.nSmoothPosition()[shellI] <<
nl
2226 <<
" Number of planes : "
2227 << allSeedPointDist.size()
2231 List<Tuple2<scalar, scalar>> keyAndValue(allSeedPointDist.size());
2240 shells.nSmoothExpansion()[shellI],
2250 const interpolationTable<scalar> table
2262 const point& curPoint = baseMesh.points()[pointi];
2263 scalar curDist = normalizedPosition[i];
2264 scalar newDist = table(curDist);
2265 scalar newPosition = startPosition + newDist*totalLength;
2266 baseNewPoints[pointi] +=
2267 userDirection * (newPosition - (curPoint &userDirection));
2271 vectorField disp(baseNewPoints-baseMesh.points());
2276 maxMagSqrEqOp<vector>(),
2279 baseMesh.movePoints(baseMesh.points()+disp);
2283 const_cast<Time&
>(baseMesh.time())++;
2285 Pout<<
"Writing directional expansion ratio smoothed"
2286 <<
" mesh to time " << meshRefiner_.timeName() <<
endl;
2296 baseMesh.time().path()/meshRefiner_.timeName()
2303 pointField baseMeshPoints(baseMesh.points());
2304 scalar initResidual = 0.0;
2305 scalar prevIterResidual = GREAT;
2306 for (iter = 0; iter < shells.nSmoothPosition()[shellI]; iter++)
2309 const edgeList& edges = baseMesh.edges();
2319 const edge&
e = edges[edgei];
2321 (unsmoothedPoints[
e[1]]&userDirection);
2324 (unsmoothedPoints[
e[0]]&userDirection);
2345 if (nSumXEdges[pointi] < 2)
2349 const labelList& pEdges = pointEdges[pointi];
2352 label edgei = pEdges[pE];
2355 const edge&
e = edges[edgei];
2356 label otherPt =
e.otherVertex(pointi);
2357 nSumOther[pointi]--;
2360 unsmoothedPoints[otherPt]
2387 if ((nSumOther[pointi] >= 2) && !isFrozenPoint[pointi])
2392 (unsmoothedPoints[pointi]&userDirection)
2393 +sumOther[pointi]/nSumOther[pointi]
2396 vector& v = baseNewPoints[pointi];
2397 v += (smoothPos-(v&userDirection))*userDirection;
2401 const vectorField residual(baseNewPoints - baseMeshPoints);
2403 scalar res(
gSum(
mag(residual)));
2409 res /= initResidual;
2411 if (
mag(prevIterResidual - res) < SMALL)
2413 Info<<
"Converged smoothing in iteration " << iter
2414 <<
" initResidual: " << initResidual
2415 <<
" final residual : " << res <<
endl;
2420 prevIterResidual = res;
2425 baseMeshPoints = baseNewPoints;
2430 vectorField dispSmooth(baseMeshPoints-baseMesh.points());
2435 maxMagSqrEqOp<vector>(),
2438 baseMesh.movePoints(baseMesh.points()+dispSmooth);
2442 const_cast<Time&
>(baseMesh.time())++;
2444 Pout<<
"Writing positional smoothing iteration "
2445 << iter <<
" mesh to time " << meshRefiner_.timeName()
2455 baseMesh.time().path()/meshRefiner_.timeName()
2464 void Foam::snappyRefineDriver::baffleAndSplitMesh
2466 const refinementParameters& refineParams,
2467 const snapParameters& snapParams,
2468 const bool handleSnapProblems,
2469 const dictionary& motionDict
2479 <<
"Splitting mesh at surface intersections" <<
nl
2480 <<
"---------------------------------------" <<
nl
2483 const fvMesh&
mesh = meshRefiner_.mesh();
2493 meshRefiner_.baffleAndSplitMesh
2499 refineParams.useTopologicalSnapDetection(),
2502 refineParams.nErodeCellZone(),
2506 globalToMasterPatch_,
2507 globalToSlavePatch_,
2508 refineParams.locationsInMesh(),
2509 refineParams.zonesInMesh(),
2510 refineParams.locationsOutsideMesh(),
2515 if (!handleSnapProblems)
2517 meshRefiner_.mergeFreeStandingBaffles
2520 refineParams.useTopologicalSnapDetection(),
2523 refineParams.planarAngle(),
2526 globalToMasterPatch_,
2527 globalToSlavePatch_,
2528 refineParams.locationsInMesh(),
2529 refineParams.locationsOutsideMesh(),
2536 void Foam::snappyRefineDriver::zonify
2538 const refinementParameters& refineParams,
2553 namedSurfaces.size()
2554 || refineParams.zonesInMesh().size()
2558 <<
"Introducing zones for interfaces" <<
nl
2559 <<
"--------------------------------" <<
nl
2562 const fvMesh&
mesh = meshRefiner_.mesh();
2571 refineParams.allowFreeStandingZoneFaces(),
2572 refineParams.nErodeCellZone(),
2573 refineParams.locationsInMesh(),
2574 refineParams.zonesInMesh(),
2580 Pout<<
"Writing zoned mesh to time "
2581 << meshRefiner_.timeName() <<
endl;
2600 void Foam::snappyRefineDriver::splitAndMergeBaffles
2602 const refinementParameters& refineParams,
2603 const snapParameters& snapParams,
2604 const bool handleSnapProblems,
2605 const dictionary& motionDict
2614 <<
"Handling cells with snap problems" <<
nl
2615 <<
"---------------------------------" <<
nl
2618 const fvMesh&
mesh = meshRefiner_.mesh();
2626 const scalarField& perpAngle = meshRefiner_.surfaces().perpendicularAngle();
2628 meshRefiner_.baffleAndSplitMesh
2634 refineParams.useTopologicalSnapDetection(),
2637 refineParams.nErodeCellZone(),
2641 globalToMasterPatch_,
2642 globalToSlavePatch_,
2643 refineParams.locationsInMesh(),
2644 refineParams.zonesInMesh(),
2645 refineParams.locationsOutsideMesh(),
2650 meshRefiner_.mergeFreeStandingBaffles
2653 refineParams.useTopologicalSnapDetection(),
2656 refineParams.planarAngle(),
2659 globalToMasterPatch_,
2660 globalToSlavePatch_,
2661 refineParams.locationsInMesh(),
2662 refineParams.locationsOutsideMesh(),
2673 meshRefiner_.dupNonManifoldPoints();
2679 label nCouples =
returnReduce(couples.size(), sumOp<label>());
2681 Info<<
"Detected unsplittable baffles : " << nCouples <<
endl;
2688 meshRefiner_.mergeBaffles(couples, Map<label>(0));
2693 meshRefiner_.checkData();
2697 meshRefiner_.splitMeshRegions
2699 globalToMasterPatch_,
2700 globalToSlavePatch_,
2701 refineParams.locationsInMesh(),
2702 refineParams.locationsOutsideMesh(),
2710 meshRefiner_.checkData();
2713 Info<<
"Merged free-standing baffles in = "
2719 Pout<<
"Writing handleProblemCells mesh to time "
2720 << meshRefiner_.timeName() <<
endl;
2742 if (faceZoneToPatches.size())
2745 <<
"Adding patches for face zones" <<
nl
2746 <<
"-----------------------------" <<
nl
2750 <<
setw(6) <<
"Patch"
2751 <<
setw(20) <<
"Type"
2752 <<
setw(30) <<
"Name"
2753 <<
setw(30) <<
"FaceZone"
2754 <<
setw(10) <<
"FaceType"
2756 <<
setw(6) <<
"-----"
2757 <<
setw(20) <<
"----"
2758 <<
setw(30) <<
"----"
2759 <<
setw(30) <<
"--------"
2760 <<
setw(10) <<
"--------"
2768 const word& fzName = iter.key();
2775 const word& masterName = fzName;
2785 <<
setw(30) << masterName
2786 <<
setw(30) << fzName
2796 <<
setw(30) << slaveName
2797 <<
setw(30) << fzName
2801 meshRefiner.
addFaceZone(fzName, masterName, slaveName, fzType);
2809 void Foam::snappyRefineDriver::mergePatchFaces
2823 <<
"Merge refined boundary faces" <<
nl
2824 <<
"----------------------------" <<
nl
2827 const fvMesh&
mesh = meshRefiner_.mesh();
2831 mergeType == meshRefinement::FaceMergeType::GEOMETRIC
2832 || mergeType == meshRefinement::FaceMergeType::IGNOREPATCH
2835 meshRefiner_.mergePatchFacesUndo
2839 meshRefiner_.meshedPatches(),
2848 meshRefiner_.mergePatchFaces
2853 meshRefiner_.meshedPatches(),
2854 meshRefinement::FaceMergeType::GEOMETRIC
2860 meshRefiner_.checkData();
2867 meshRefiner_.checkData();
2877 const bool prepareForSnapping,
2884 <<
"Refinement phase" <<
nl
2885 <<
"----------------" <<
nl
2906 globalToMasterPatch_,
2909 voxelDriver.
doRefine(refineParams);
2925 max(meshRefiner_.surfaces().maxGapLevel()) > 0
2926 ||
max(meshRefiner_.shells().maxGapLevel()) > 0
2964 surfaceProximityBlock
3015 refinementInterfaceRefine
3022 directionalShellRefine
3042 max(meshRefiner_.shells().nSmoothExpansion()) > 0
3043 ||
max(meshRefiner_.shells().nSmoothPosition()) > 0
3046 directionalSmooth(refineParams);
3062 zonify(refineParams, zonesToFaceZone);
3076 const word& fzName = zonesToFaceZone[czNames];
3078 const word& masterName = fzName;
3079 const word slaveName = czNames.
second() +
"_to_" + czNames.first();
3081 faceZoneToPatches.insert(fzName,
patches);
3083 addFaceZones(meshRefiner_, refineParams, faceZoneToPatches);
3087 splitAndMergeBaffles
3096 if (prepareForSnapping)
3098 mergePatchFaces(mergeType, refineParams, motionDict);
3105 <<
"Doing final balancing" <<
nl
3106 <<
"---------------------" <<
nl
3112 meshRefiner_.balance