OpenFOAM-dev / data /src /polyTopoChange /meshCut /meshModifiers /multiDirRefinement /multiDirRefinement.C
| /*---------------------------------------------------------------------------*\ | |
| ========= | | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | |
| \\ / O peration | Website: https://openfoam.org | |
| \\ / A nd | Copyright (C) 2011-2026 OpenFOAM Foundation | |
| \\/ M anipulation | | |
| ------------------------------------------------------------------------------- | |
| License | |
| This file is part of OpenFOAM. | |
| OpenFOAM is free software: you can redistribute it and/or modify it | |
| under the terms of the GNU General Public License as published by | |
| the Free Software Foundation, either version 3 of the License, or | |
| (at your option) any later version. | |
| OpenFOAM is distributed in the hope that it will be useful, but WITHOUT | |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| for more details. | |
| You should have received a copy of the GNU General Public License | |
| along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. | |
| \*---------------------------------------------------------------------------*/ | |
| // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * // | |
| namespace Foam | |
| { | |
| defineTypeNameAndDebug(multiDirRefinement, 0); | |
| } | |
| // * * * * * * * * * * * * * Private Statc Functions * * * * * * * * * * * * // | |
| void Foam::multiDirRefinement::addCells | |
| ( | |
| const Map<label>& splitMap, | |
| List<refineCell>& refCells | |
| ) | |
| { | |
| label newRefI = refCells.size(); | |
| label oldSize = refCells.size(); | |
| refCells.setSize(newRefI + splitMap.size()); | |
| for (label refI = 0; refI < oldSize; refI++) | |
| { | |
| const refineCell& refCell = refCells[refI]; | |
| Map<label>::const_iterator iter = splitMap.find(refCell.cellNo()); | |
| if (iter == splitMap.end()) | |
| { | |
| FatalErrorInFunction | |
| << "Problem : cannot find added cell for cell " | |
| << refCell.cellNo() << abort(FatalError); | |
| } | |
| refCells[newRefI++] = refineCell(iter(), refCell.direction()); | |
| } | |
| } | |
| void Foam::multiDirRefinement::update | |
| ( | |
| const Map<label>& splitMap, | |
| vectorField& field | |
| ) | |
| { | |
| field.setSize(field.size() + splitMap.size()); | |
| forAllConstIter(Map<label>, splitMap, iter) | |
| { | |
| field[iter()] = field[iter.key()]; | |
| } | |
| } | |
| void Foam::multiDirRefinement::addCells | |
| ( | |
| const Map<label>& splitMap, | |
| labelList& labels | |
| ) | |
| { | |
| label newCelli = labels.size(); | |
| labels.setSize(labels.size() + splitMap.size()); | |
| forAllConstIter(Map<label>, splitMap, iter) | |
| { | |
| labels[newCelli++] = iter(); | |
| } | |
| } | |
| // * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * // | |
| void Foam::multiDirRefinement::addCells | |
| ( | |
| const primitiveMesh& mesh, | |
| const Map<label>& splitMap | |
| ) | |
| { | |
| // Construct inverse addressing: from new to original cell. | |
| labelList origCell(mesh.nCells(), -1); | |
| forAll(addedCells_, celli) | |
| { | |
| const labelList& added = addedCells_[celli]; | |
| forAll(added, i) | |
| { | |
| label slave = added[i]; | |
| if (origCell[slave] == -1) | |
| { | |
| origCell[slave] = celli; | |
| } | |
| else if (origCell[slave] != celli) | |
| { | |
| FatalErrorInFunction | |
| << "Added cell " << slave << " has two different masters:" | |
| << origCell[slave] << " , " << celli | |
| << abort(FatalError); | |
| } | |
| } | |
| } | |
| forAllConstIter(Map<label>, splitMap, iter) | |
| { | |
| label masterI = iter.key(); | |
| label newCelli = iter(); | |
| while (origCell[masterI] != -1 && origCell[masterI] != masterI) | |
| { | |
| masterI = origCell[masterI]; | |
| } | |
| if (masterI >= addedCells_.size()) | |
| { | |
| FatalErrorInFunction | |
| << "Map of added cells contains master cell " << masterI | |
| << " which is not a valid cell number" << endl | |
| << "This means that the mesh is not consistent with the" | |
| << " done refinement" << endl | |
| << "newCell:" << newCelli << abort(FatalError); | |
| } | |
| labelList& added = addedCells_[masterI]; | |
| if (added.empty()) | |
| { | |
| added.setSize(2); | |
| added[0] = masterI; | |
| added[1] = newCelli; | |
| } | |
| else if (findIndex(added, newCelli) == -1) | |
| { | |
| label sz = added.size(); | |
| added.setSize(sz + 1); | |
| added[sz] = newCelli; | |
| } | |
| } | |
| } | |
| Foam::labelList Foam::multiDirRefinement::splitOffHex(const primitiveMesh& mesh) | |
| { | |
| const cellModel& hex = *(cellModeller::lookup("hex")); | |
| const cellShapeList& cellShapes = mesh.cellShapes(); | |
| // Split cellLabels_ into two lists. | |
| labelList nonHexLabels(cellLabels_.size()); | |
| label nonHexI = 0; | |
| labelList hexLabels(cellLabels_.size()); | |
| label hexI = 0; | |
| forAll(cellLabels_, i) | |
| { | |
| label celli = cellLabels_[i]; | |
| if (cellShapes[celli].model() == hex) | |
| { | |
| hexLabels[hexI++] = celli; | |
| } | |
| else | |
| { | |
| nonHexLabels[nonHexI++] = celli; | |
| } | |
| } | |
| nonHexLabels.setSize(nonHexI); | |
| cellLabels_.transfer(nonHexLabels); | |
| hexLabels.setSize(hexI); | |
| return hexLabels; | |
| } | |
| void Foam::multiDirRefinement::refineHex8 | |
| ( | |
| polyMesh& mesh, | |
| const labelList& hexCells, | |
| const bool writeMesh | |
| ) | |
| { | |
| if (debug) | |
| { | |
| Pout<< "multiDirRefinement : Refining hexes " << hexCells.size() | |
| << endl; | |
| } | |
| hexRef8 hexRefiner | |
| ( | |
| mesh, | |
| labelList(mesh.nCells(), 0), // cellLevel | |
| labelList(mesh.nPoints(), 0), // pointLevel | |
| refinementHistory | |
| ( | |
| IOobject | |
| ( | |
| "refinementHistory", | |
| mesh.facesInstance(), | |
| polyMesh::meshSubDir, | |
| mesh, | |
| IOobject::NO_READ, | |
| IOobject::NO_WRITE, | |
| false | |
| ), | |
| List<refinementHistory::splitCell8>(0), | |
| labelList(0), | |
| false | |
| ) // refinement history | |
| ); | |
| polyTopoChange meshMod(mesh); | |
| labelList consistentCells | |
| ( | |
| hexRefiner.consistentRefinement | |
| ( | |
| hexCells, | |
| true // buffer layer | |
| ) | |
| ); | |
| // Check that consistentRefinement hasn't added cells | |
| { | |
| // Create count 1 for original cells | |
| Map<label> hexCellSet(2*hexCells.size()); | |
| forAll(hexCells, i) | |
| { | |
| hexCellSet.insert(hexCells[i], 1); | |
| } | |
| // Increment count | |
| forAll(consistentCells, i) | |
| { | |
| const label celli = consistentCells[i]; | |
| Map<label>::iterator iter = hexCellSet.find(celli); | |
| if (iter == hexCellSet.end()) | |
| { | |
| FatalErrorInFunction | |
| << "Resulting mesh would not satisfy 2:1 ratio" | |
| << " when refining cell " << celli << abort(FatalError); | |
| } | |
| else | |
| { | |
| iter() = 2; | |
| } | |
| } | |
| // Check if all been visited (should always be since | |
| // consistentRefinement set up to extend set. | |
| forAllConstIter(Map<label>, hexCellSet, iter) | |
| { | |
| if (iter() != 2) | |
| { | |
| FatalErrorInFunction | |
| << "Resulting mesh would not satisfy 2:1 ratio" | |
| << " when refining cell " << iter.key() | |
| << abort(FatalError); | |
| } | |
| } | |
| } | |
| hexRefiner.setRefinement(consistentCells, meshMod); | |
| // Change mesh | |
| autoPtr<polyTopoChangeMap> mapPtr = meshMod.changeMesh(mesh, true); | |
| const polyTopoChangeMap& map = mapPtr(); | |
| if (writeMesh) | |
| { | |
| mesh.write(); | |
| } | |
| if (debug) | |
| { | |
| Pout<< "multiDirRefinement : updated mesh at time " | |
| << mesh.time().name() << endl; | |
| } | |
| hexRefiner.topoChange(map); | |
| // Collect all cells originating from same old cell (original + 7 extra) | |
| forAll(consistentCells, i) | |
| { | |
| addedCells_[consistentCells[i]].setSize(8); | |
| } | |
| labelList nAddedCells(addedCells_.size(), 0); | |
| const labelList& cellMap = map.cellMap(); | |
| forAll(cellMap, celli) | |
| { | |
| const label oldCelli = cellMap[celli]; | |
| if (addedCells_[oldCelli].size()) | |
| { | |
| addedCells_[oldCelli][nAddedCells[oldCelli]++] = celli; | |
| } | |
| } | |
| } | |
| void Foam::multiDirRefinement::refineAllDirs | |
| ( | |
| polyMesh& mesh, | |
| List<vectorField>& cellDirections, | |
| const cellLooper& cellWalker, | |
| undoableMeshCutter& cutter, | |
| const bool writeMesh | |
| ) | |
| { | |
| // Iterator | |
| refinementIterator refiner(mesh, cutter, cellWalker, writeMesh); | |
| forAll(cellDirections, dirI) | |
| { | |
| if (debug) | |
| { | |
| Pout<< "multiDirRefinement : Refining " << cellLabels_.size() | |
| << " cells in direction " << dirI << endl | |
| << endl; | |
| } | |
| const vectorField& dirField = cellDirections[dirI]; | |
| // Combine cell to be cut with direction to cut in. | |
| // If dirField is only one element use this for all cells. | |
| List<refineCell> refCells(cellLabels_.size()); | |
| if (dirField.size() == 1) | |
| { | |
| // Uniform directions. | |
| if (debug) | |
| { | |
| Pout<< "multiDirRefinement : Uniform refinement:" | |
| << dirField[0] << endl; | |
| } | |
| forAll(refCells, refI) | |
| { | |
| label celli = cellLabels_[refI]; | |
| refCells[refI] = refineCell(celli, dirField[0]); | |
| } | |
| } | |
| else | |
| { | |
| // Non uniform directions. | |
| forAll(refCells, refI) | |
| { | |
| const label celli = cellLabels_[refI]; | |
| refCells[refI] = refineCell(celli, dirField[celli]); | |
| } | |
| } | |
| // Do refine mesh (multiple iterations). Remember added cells. | |
| Map<label> splitMap = refiner.setRefinement(refCells); | |
| // Update overall map of added cells | |
| addCells(mesh, splitMap); | |
| // Add added cells to list of cells to refine in next iteration | |
| addCells(splitMap, cellLabels_); | |
| // Update refinement direction for added cells. | |
| if (dirField.size() != 1) | |
| { | |
| forAll(cellDirections, i) | |
| { | |
| update(splitMap, cellDirections[i]); | |
| } | |
| } | |
| if (debug) | |
| { | |
| Pout<< "multiDirRefinement : Done refining direction " << dirI | |
| << " resulting in " << cellLabels_.size() << " cells" << nl | |
| << endl; | |
| } | |
| } | |
| } | |
| void Foam::multiDirRefinement::refineFromDict | |
| ( | |
| polyMesh& mesh, | |
| List<vectorField>& cellDirections, | |
| const dictionary& dict, | |
| const bool writeMesh | |
| ) | |
| { | |
| // How to walk cell circumference. | |
| Switch pureGeomCut(dict.lookupOrDefault("geometricCut", false)); | |
| autoPtr<cellLooper> cellWalker(nullptr); | |
| if (pureGeomCut) | |
| { | |
| cellWalker.reset(new geomCellLooper(mesh)); | |
| } | |
| else | |
| { | |
| cellWalker.reset(new hexCellLooper(mesh)); | |
| } | |
| // Construct undoable refinement topology modifier. | |
| // Note: undoability switched off. | |
| // Might want to reconsider if needs to be possible. But then can always | |
| // use other constructor. | |
| undoableMeshCutter cutter(mesh, false); | |
| refineAllDirs(mesh, cellDirections, cellWalker(), cutter, writeMesh); | |
| } | |
| // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // | |
| Foam::multiDirRefinement::multiDirRefinement | |
| ( | |
| polyMesh& mesh, | |
| const labelList& cellLabels, // list of cells to refine | |
| const dictionary& dict, | |
| const dictionary& coordinatesDict | |
| ) | |
| : | |
| cellLabels_(cellLabels), | |
| addedCells_(mesh.nCells()) | |
| { | |
| Switch useHex(dict.lookupOrDefault("useHexTopology", false)); | |
| Switch writeMesh(dict.lookupOrDefault("writeMesh", false)); | |
| wordList dirNames(coordinatesDict.lookup("directions")); | |
| if (useHex && dirNames.size() == 3) | |
| { | |
| // Filter out hexes from cellLabels_ | |
| labelList hexCells(splitOffHex(mesh)); | |
| refineHex8(mesh, hexCells, writeMesh); | |
| } | |
| label nRemainingCells = cellLabels_.size(); | |
| reduce(nRemainingCells, sumOp()); | |
| if (nRemainingCells > 0) | |
| { | |
| // Any cells to refine using meshCutter | |
| // Determine directions for every cell. Can either be uniform | |
| // (size = 1) or non-uniform (one vector per cell) | |
| directions cellDirections(mesh, coordinatesDict); | |
| refineFromDict(mesh, cellDirections, dict, writeMesh); | |
| } | |
| } | |
| Foam::multiDirRefinement::multiDirRefinement | |
| ( | |
| polyMesh& mesh, | |
| const labelList& cellLabels, // list of cells to refine | |
| const List<vectorField>& cellDirs, // Explicitly provided directions | |
| const dictionary& dict, | |
| const dictionary& coordinatesDict | |
| ) | |
| : | |
| cellLabels_(cellLabels), | |
| addedCells_(mesh.nCells()) | |
| { | |
| Switch useHex(dict.lookupOrDefault("useHexTopology", false)); | |
| Switch writeMesh(dict.lookupOrDefault("writeMesh", false)); | |
| wordList dirNames(coordinatesDict.lookup("directions")); | |
| if (useHex && dirNames.size() == 3) | |
| { | |
| // Filter out hexes from cellLabels_ | |
| labelList hexCells(splitOffHex(mesh)); | |
| refineHex8(mesh, hexCells, writeMesh); | |
| } | |
| label nRemainingCells = cellLabels_.size(); | |
| reduce(nRemainingCells, sumOp()); | |
| if (nRemainingCells > 0) | |
| { | |
| // Any cells to refine using meshCutter | |
| // Working copy of cells to refine | |
| List<vectorField> cellDirections(cellDirs); | |
| refineFromDict(mesh, cellDirections, dict, writeMesh); | |
| } | |
| } | |
| Foam::multiDirRefinement::multiDirRefinement | |
| ( | |
| polyMesh& mesh, | |
| undoableMeshCutter& cutter, // actual mesh modifier | |
| const cellLooper& cellWalker, // how to cut a single cell with | |
| // a plane | |
| const labelList& cellLabels, // list of cells to refine | |
| const List<vectorField>& cellDirs, | |
| const bool writeMesh // write intermediate meshes | |
| ) | |
| : | |
| cellLabels_(cellLabels), | |
| addedCells_(mesh.nCells()) | |
| { | |
| // Working copy of cells to refine | |
| List<vectorField> cellDirections(cellDirs); | |
| refineAllDirs(mesh, cellDirections, cellWalker, cutter, writeMesh); | |
| } | |
| // ************************************************************************* // | |