OpenFOAM-dev / data /applications /utilities /preProcessing /snappyHexMeshConfig /blockMeshCylindricalConfiguration.C
| /*---------------------------------------------------------------------------*\ | |
| ========= | | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | |
| \\ / O peration | Website: https://openfoam.org | |
| \\ / A nd | Copyright (C) 2023-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 * * * * * * * * * * * * * // | |
| const Foam::List<Foam::word> Foam::blockMeshCylindricalConfiguration::patches = | |
| {"zMin", "zMax"}; | |
| // * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * // | |
| void Foam::blockMeshCylindricalConfiguration::bbInflate | |
| ( | |
| boundBox& bb, | |
| const vector& s | |
| ) | |
| { | |
| bb.min() = cmptMultiply(s, bb.min()); | |
| bb.max() = cmptMultiply(s, bb.max()); | |
| } | |
| bool Foam::blockMeshCylindricalConfiguration::isBoundBoxOnZaxis() | |
| { | |
| const vector bbMidNorm = bb_.midpoint()/bb_.mag(); | |
| return mag(bbMidNorm.x()) < rootSmall && mag(bbMidNorm.y()) < rootSmall; | |
| } | |
| void Foam::blockMeshCylindricalConfiguration::calcBlockMeshDict | |
| ( | |
| const bool& boundsOpt, | |
| const bool& rotatingZonesOpt | |
| ) | |
| { | |
| // Set nCells as a vector: (boxCells radialCells zCells) | |
| label boxCells = nCells_.x(); | |
| label radialCells = nCells_.y(); | |
| if (nCells_ == Vector<label>::zero) | |
| { | |
| boxCells = 5; | |
| radialCells = 15; | |
| nCells_ = Vector<label> | |
| ( | |
| boxCells, | |
| radialCells, | |
| 2.0*radialCells*bb_.span().z()/bb_.span().x() | |
| ); | |
| } | |
| // Size the bounding box | |
| const scalar roundFactor = roundingScale(0.01*bb_.minDim()); | |
| // If '-bounds' is not specified, or '-rotatingZones' is specified | |
| // inflate the respective bounding box(es) in radial direction, | |
| // followed by rounding | |
| if(!boundsOpt || rotatingZonesOpt) | |
| { | |
| const scalar expansion = 1.0/(Foam::cos(degToRad(45.0/nCells_.x()))); | |
| const vector scaling(expansion, expansion, 1); | |
| if(!boundsOpt) | |
| { | |
| bbInflate(bb_, scaling); | |
| roundBoundingBox(bb_, roundFactor); | |
| } | |
| if(rotatingZonesOpt) | |
| { | |
| bbInflate(rzbb_, scaling); | |
| roundBoundingBox(rzbb_, roundFactor); | |
| } | |
| } | |
| radBox_ = ceil(0.3*rzbb_.max().x()/roundFactor)*roundFactor; | |
| nCells_ *= refineFactor_; | |
| } | |
| void Foam::blockMeshCylindricalConfiguration::writeBackgroundMesh() | |
| { | |
| const scalar radOut = bb_.max().x(); | |
| const scalar radIn = rzbb_.max().x(); | |
| const scalar boxToRadOut = radOut - radBox_; | |
| const scalar boxToRadIn = radIn - radBox_; | |
| const label inCells = ceil(boxToRadIn*nCells_.y()/boxToRadOut); | |
| const label outCells = nCells_.y() - inCells; | |
| beginDict(os_, "backgroundMesh"); | |
| os_ << indent << "radOut " << radOut << ";" << endl; | |
| os_ << indent << "radIn " << radIn << ";" << endl; | |
| os_ << indent << "radBox " << radBox_ << ";" << nl << endl; | |
| os_ << indent << "zMin " << bb_.min().z() << ";" << endl; | |
| os_ << indent << "zMax " << bb_.max().z() << ";" << nl << endl; | |
| os_ << indent << "boxCells " << nCells_.x() << ";" << endl; | |
| os_ << indent << "inCells " << inCells << ";" << endl; | |
| os_ << indent << "outCells " << outCells << ";" << endl; | |
| os_ << indent << "zCells " << nCells_.z() << ";" << nl << endl; | |
| os_ << indent << "outGrading 2.0;" << nl << endl; | |
| os_ << indent << "radOutN #neg $radOut;" << endl; | |
| os_ << indent << "radInN #neg $radIn;" << endl; | |
| os_ << indent << "radBoxN #neg $radBox;" << endl; | |
| endDict(os_); | |
| } | |
| void Foam::blockMeshCylindricalConfiguration::writeDefaultPatch() | |
| { | |
| Pair<word> defaultPatch; | |
| word opt = "defaultPatch"; | |
| if (patchOpts_.found(opt)) | |
| { | |
| defaultPatch = readPatchOption(opt); | |
| } | |
| else | |
| { | |
| defaultPatch = {"background", "internal"}; | |
| } | |
| beginDict(os_, "defaultPatch"); | |
| os_ << indent << "name " << defaultPatch.first() << ";" << nl | |
| << indent << "type " << defaultPatch.second() << ";" << endl; | |
| endDict(os_); | |
| Info<< "\nAdding defaultPatch '" << defaultPatch.first() | |
| << "' of type '" << defaultPatch.second() << "'" << endl; | |
| } | |
| void Foam::blockMeshCylindricalConfiguration::writePatch | |
| ( | |
| const word& name, | |
| const word& type, | |
| const string& face | |
| ) | |
| { | |
| os_ << indent << name | |
| << " { type " << type | |
| << "; faces ( " << face.c_str() | |
| << " ); }" << endl; | |
| Info<< "Adding patch '" << name | |
| << "' of type '" << type << "'" << endl; | |
| } | |
| void Foam::blockMeshCylindricalConfiguration::writeBoundary() | |
| { | |
| // Enable boundary section if a patch option or clearBoundary is selected | |
| bool enableBoundary = clearBoundary_; | |
| forAll(patches, i) | |
| { | |
| if (enableBoundary) | |
| { | |
| break; | |
| } | |
| enableBoundary = patchOpts_.found(patches[i] + "Patch"); | |
| } | |
| if (!enableBoundary) | |
| { | |
| os_ << "// delete \"-disabled\" to enable boundary settings" << endl; | |
| Info<< "\nNote: The boundary list in blockMeshDict is disabled" << nl | |
| << "To enable, open the file and edit line number " | |
| << os_.lineNumber() << nl << endl; | |
| } | |
| beginList | |
| ( | |
| os_, | |
| enableBoundary ? "boundary" : "boundary-disabled" | |
| ); | |
| forAll(patches, i) | |
| { | |
| const bool optFound(patchOpts_.found(patches[i] + "Patch")); | |
| // Do not write patch entry if clearBoundary option is selected | |
| // and the respective patch option is not selected | |
| if (clearBoundary_ && !optFound) | |
| { | |
| continue; | |
| } | |
| Pair<word> patch(patches[i], "patch"); | |
| if (optFound) | |
| { | |
| patch = readPatchOption(patch.first() + "Patch"); | |
| } | |
| beginDict(os_, patch.first()); | |
| os_ << indent << "type " << patch.second() << ";" << endl; | |
| beginList(os_, "faces"); | |
| switch (i) | |
| { | |
| case 0: | |
| { | |
| os_ << indent << "(0 1 2 3)" << nl | |
| << indent << "(0 4 5 1)" << nl | |
| << indent << "(1 5 6 2)" << nl | |
| << indent << "(2 6 7 3)" << nl | |
| << indent << "(3 7 4 0)" << nl | |
| << indent << "(4 8 9 5)" << nl | |
| << indent << "(5 9 10 6)" << nl | |
| << indent << "(6 10 11 7)" << nl | |
| << indent << "(7 11 8 4)" << endl; | |
| break; | |
| } | |
| case 1: | |
| { | |
| os_ << indent << "(12 13 14 15)" << nl | |
| << indent << "(12 16 17 13)" << nl | |
| << indent << "(13 17 18 14)" << nl | |
| << indent << "(14 18 19 15)" << nl | |
| << indent << "(15 19 16 12)" << nl | |
| << indent << "(16 20 21 17)" << nl | |
| << indent << "(17 21 22 18)" << nl | |
| << indent << "(18 22 23 19)" << nl | |
| << indent << "(19 23 20 16)" << endl; | |
| break; | |
| } | |
| } | |
| endList(os_, false); | |
| endDict(os_, i != 1); | |
| } | |
| endList(os_); | |
| } | |
| void Foam::blockMeshCylindricalConfiguration::writeGeometry() | |
| { | |
| beginDict(os_, "geometry"); | |
| List<word> geometries {"rotatingZone", "outer"}; | |
| List<word> dims {"radIn", "radOut"}; | |
| scalar zMin = roundDown(bb_.min().z(), 10); | |
| scalar zMax = roundUp(bb_.max().z(), 10); | |
| // Extend the bounds to avoid bad projections | |
| const scalar span = zMax - zMin; | |
| zMax += span; | |
| zMin -= span; | |
| forAll(geometries, i) | |
| { | |
| beginDict(os_, geometries[i]); | |
| os_ << indent << "type cylinder;" << nl | |
| << indent << "point1 (0 0 " << zMin << ");" << nl | |
| << indent << "point2 (0 0 " << zMax << ");" << nl | |
| << indent << "radius $!backgroundMesh/" << dims[i] << ";" << endl; | |
| endDict(os_); | |
| } | |
| endDict(os_); | |
| } | |
| void Foam::blockMeshCylindricalConfiguration::writeProjectedVertex | |
| ( | |
| const word& x, | |
| const word& y, | |
| const word& z, | |
| const word& surface | |
| ) | |
| { | |
| os_ << indent << "project" << endl; | |
| writeVertex(x, y, z); | |
| os_ << indent << "(" << surface << ")" << nl << endl; | |
| } | |
| void Foam::blockMeshCylindricalConfiguration::writeVertices() | |
| { | |
| beginList(os_, "vertices"); | |
| forAll(patches, i) | |
| { | |
| const word& dir = patches[i]; | |
| writeVertex("radBoxN", "radBoxN", dir); | |
| writeVertex("radBox", "radBoxN", dir); | |
| writeVertex("radBox", "radBox", dir); | |
| writeVertex("radBoxN", "radBox", dir); | |
| os_ << endl; | |
| writeProjectedVertex("radInN", "radInN", dir, "rotatingZone"); | |
| writeProjectedVertex("radIn", "radInN", dir, "rotatingZone"); | |
| writeProjectedVertex("radIn", "radIn", dir, "rotatingZone"); | |
| writeProjectedVertex("radInN", "radIn", dir, "rotatingZone"); | |
| writeProjectedVertex("radOutN", "radOutN", dir, "outer"); | |
| writeProjectedVertex("radOut", "radOutN", dir, "outer"); | |
| writeProjectedVertex("radOut", "radOut", dir, "outer"); | |
| writeProjectedVertex("radOutN", "radOut", dir, "outer"); | |
| } | |
| endList(os_); | |
| } | |
| void Foam::blockMeshCylindricalConfiguration::writeBlocks() | |
| { | |
| os_ << "boxMesh" << endl; | |
| writeVertex("boxCells", "boxCells", "zCells"); | |
| os_ << "simpleGrading (1 1 1);" << nl << endl; | |
| os_ << "inMesh" << endl; | |
| writeVertex("boxCells", "inCells", "zCells"); | |
| os_ << "simpleGrading (1 1 1);" << nl << endl; | |
| os_ << "outMesh" << endl; | |
| writeVertex("boxCells", "outCells", "zCells"); | |
| os_ << "simpleGrading (1 $!backgroundMesh/outGrading 1);" << nl << endl; | |
| beginList(os_, "blocks"); | |
| os_ << indent << "hex (0 1 2 3 12 13 14 15) $boxMesh" << nl << nl | |
| << indent << "hex (1 0 4 5 13 12 16 17) $inMesh" << nl | |
| << indent << "hex (0 3 7 4 12 15 19 16) $inMesh" << nl | |
| << indent << "hex (2 1 5 6 14 13 17 18) $inMesh" << nl | |
| << indent << "hex (3 2 6 7 15 14 18 19) $inMesh" << nl << nl | |
| << indent << "hex (5 4 8 9 17 16 20 21) $outMesh" << nl | |
| << indent << "hex (4 7 11 8 16 19 23 20) $outMesh" << nl | |
| << indent << "hex (6 5 9 10 18 17 21 22) $outMesh" << nl | |
| << indent << "hex (7 6 10 11 19 18 22 23) $outMesh" << endl; | |
| endList(os_); | |
| } | |
| void Foam::blockMeshCylindricalConfiguration::writeEdges() | |
| { | |
| beginList(os_, "edges"); | |
| os_ << indent << "project 4 5 (rotatingZone)" << nl | |
| << indent << "project 5 6 (rotatingZone)" << nl | |
| << indent << "project 6 7 (rotatingZone)" << nl | |
| << indent << "project 7 4 (rotatingZone)" << nl | |
| << indent << "project 16 17 (rotatingZone)" << nl | |
| << indent << "project 17 18 (rotatingZone)" << nl | |
| << indent << "project 18 19 (rotatingZone)" << nl | |
| << indent << "project 19 16 (rotatingZone)" << nl << nl | |
| << indent << "project 8 9 (outer)" << nl | |
| << indent << "project 9 10 (outer)" << nl | |
| << indent << "project 10 11 (outer)" << nl | |
| << indent << "project 11 8 (outer)" << nl | |
| << indent << "project 20 21 (outer)" << nl | |
| << indent << "project 21 22 (outer)" << nl | |
| << indent << "project 22 23 (outer)" << nl | |
| << indent << "project 23 20 (outer)" << endl; | |
| endList(os_); | |
| } | |
| void Foam::blockMeshCylindricalConfiguration::writeMergePatchPairs() | |
| { | |
| os_ << "mergePatchPairs" << nl | |
| << "(" << nl | |
| << ");" << endl; | |
| } | |
| // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // | |
| Foam::blockMeshCylindricalConfiguration::blockMeshCylindricalConfiguration | |
| ( | |
| const fileName& name, | |
| const fileName& dir, | |
| const Time& time, | |
| const meshingSurfaceList& surfaces, | |
| const bool& boundsOpt, | |
| const Vector<label>& nCells, | |
| const label refineFactor, | |
| const HashTable<Pair<word>>& patchOpts, | |
| const bool clearBoundary | |
| ) | |
| : | |
| blockMeshConfigurationBase(name, dir, time, surfaces, patchOpts), | |
| rzbb_(surfaces.rzbb()), | |
| nCells_(nCells), | |
| refineFactor_(refineFactor), | |
| clearBoundary_(clearBoundary) | |
| { | |
| if (!isBoundBoxOnZaxis()) | |
| { | |
| FatalErrorInFunction | |
| << "Attempting to create a cylindrical background mesh" | |
| << nl << "but the geometry bounds are not aligned with the z-axis." | |
| << exit(FatalError); | |
| } | |
| bool rotatingZonesOpt(true); | |
| if (rzbb_.volume() == 0) | |
| { | |
| rotatingZonesOpt = false; | |
| WarningInFunction | |
| << "Creating a cylindrical background mesh without a " | |
| << "rotatingZone specified by the '-rotatingZones' option." | |
| << nl <<endl; | |
| // Create the intermediate interface at 40% of domain size if no | |
| // rotating zone is specified | |
| scalar factor = 0.4; | |
| rzbb_.min() = factor*bb_.min(); | |
| rzbb_.max() = factor*bb_.max(); | |
| } | |
| calcBlockMeshDict(boundsOpt, rotatingZonesOpt); | |
| } | |
| // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // | |
| Foam::blockMeshCylindricalConfiguration::~blockMeshCylindricalConfiguration() | |
| {} | |
| // * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * // | |
| void Foam::blockMeshCylindricalConfiguration::write() | |
| { | |
| dict_.writeHeader(os_, word("dictionary")); | |
| writeBackgroundMesh(); | |
| writeDefaultPatch(); | |
| writeBoundary(); | |
| writeGeometry(); | |
| writeVertices(); | |
| writeBlocks(); | |
| writeEdges(); | |
| writeMergePatchPairs(); | |
| dict_.writeEndDivider(os_); | |
| } | |
| // ************************************************************************* // | |