OpenFOAM-dev / data /applications /utilities /preProcessing /snappyHexMeshConfig /snappyHexMeshConfig.C
| /*---------------------------------------------------------------------------*\ | |
| ========= | | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | |
| \\ / O peration | Website: https://openfoam.org | |
| \\ / A nd | Copyright (C) 2023-2025 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/>. | |
| Application | |
| snappyHexMeshConfig | |
| Description | |
| Preconfigures blockMeshDict, surfaceFeaturesDict and snappyHexMeshDict | |
| files based on the case surface geometry files. | |
| Starting from a standard OpenFOAM case, this utility locates surface | |
| geometry files, e.g. OBJ, STL format, in the constant/geometry directory. | |
| It writes out the configuration files for mesh generation with | |
| snappyHexMesh based on assumptions which can be overridden by options on | |
| the command line. | |
| The utility processes the surface geometry files, attempting to anticipate | |
| their intended purpose, trying in particular to recognise whether the | |
| domain represents an external or internal flow. If there is a surface | |
| which is closed, and is either single or surrounds all other surfaces, | |
| then it is assumed that it forms the external boundary of an internal | |
| flow. This assumption is overridden if the bounds of the background mesh | |
| are specified using the '-bounds' option and they are more than 50% larger | |
| than the surface bounds. | |
| Surfaces which form boundaries of the domain may contain named regions | |
| that are intended to become patches in the final mesh. Any surface region | |
| whose name begins with 'inlet' or 'outlet' will become a patch of the same | |
| name in the final mesh. On an external surface (for an internal flow), | |
| regions can be identified as inlets and outlets using the '-inletRegions' | |
| and '-outletRegions' options, respectively. When either option specifies a | |
| single region, the resulting patch name will be specifically 'inlet' or | |
| 'outlet', respectively. Surfaces which are contained within the domain, | |
| which do not surround or intersect other surfaces, are assumed by default | |
| to be wall patches. Any closed surface which surrounds another (but not an | |
| external surface) is used to form a cellZone within the mesh. Any surface | |
| can be specifically identified as a cellZone with the '-cellZones' option, | |
| with the additional '-baffles' and '-rotatingZones' options available to | |
| assign a surface to a more specific use. | |
| The background mesh for snappyHexMesh is a single block generated by | |
| blockMesh, configured using a blockMeshDict file. The block bounds are | |
| automatically calculated, but can be overridden by the '-bounds' | |
| option. The number of cells is calculated to produce a fairly small | |
| prototype mesh. The cell density can be overridden by the '-nCells' option | |
| or can be scaled up by an integer factor using the '-refineBackground' | |
| option. When the background mesh is required to form patches in the final | |
| mesh, e.g. for an external flow, the user can specify the names and types | |
| of the patches corresponding to the six block faces using options such as | |
| '-xMinPatch', '-xMaxPatch', etc. The name and type of the default patch, | |
| formed from block faces which are not configured, can also be specified | |
| with the '-defaultPatch' option. The utility provides placeholder entries | |
| for all block faces unless the '-clearBoundary' option is used. A special | |
| '-cylindricalBackground' option generates a cylindrical background mesh, | |
| oriented along the z-axis along x = y = 0. | |
| The snappyHexMesh configuration is generated automatically, applying a set | |
| of defaults to the main configuration parameters. By default, implicit | |
| feature capturing is configured. Explicit feature capturing can | |
| alternatively be selected with the '-explicitFeatures' option, when an | |
| additional surfaceFeaturesDict file is written for the user to generate the | |
| features files with the surfaceFeatures utility. Refinement levels can be | |
| controlled with a range of options including: '-refinementLevel' for the | |
| baseline refinement level; '-refinementSurfaces' for levels on specific | |
| surfaces; '-refinementRegions' for levels inside specific surfaces; | |
| '-refinementBoxes' for quick, box-shaped refinement regions specified by min | |
| and max bounds; '-refinementDists' for distance-based refinement; and | |
| '-nCellsBetweenLevels' to control the transition between refinement | |
| levels. A '-layers' option controls additional layers of cells at specified | |
| surfaces. The insidePoint parameter is set to '(0 0 0)' by default but can | |
| be overridden using the '-insidePoint' option. There is an alternative | |
| '-insidePoints' option to specify multiple insidePoints to mesh multiple | |
| disconnected mesh regions. | |
| Usage | |
| \b snappyHexMeshConfig [OPTIONS] | |
| Options: | |
| - \par -baffles \<list\> | |
| Surfaces that form baffles, e.g. 'helical' | |
| - \par -bounds \<box\> | |
| Bounding box of the mesh, e.g. '(-10 -5 0) (10 5 10)' | |
| - \par -cellZones \<list\> | |
| Surfaces that form cellZones, e.g. 'porousZone heatSource' | |
| - \par -clearBoundary, | |
| Do not set default patch entries, i.e. xMin, xMax, yMin, etc... | |
| - \par -closedDomain | |
| Domain does not contain inlets or outlets | |
| - \par -cylindricalBackground | |
| Generate a cylindrical background mesh aligned with the z-axis | |
| - \par -defaultPatch \<entry\> | |
| Name and type of default patch, '(\<name\> \<type\>)' | |
| - \par -explicitFeatures, | |
| Use explicit feature capturing, default is implicit | |
| - \par -firstLayerThickness \<value\> | |
| Specify the thickness of the near wall cells for layer addition | |
| - \par -inletRegions \<list\> | |
| Inlet regions on an external surface, e.g. 'inletA inletB' | |
| - \par -insidePoint \<point\> | |
| Point location inside the region of geometry to be meshed | |
| - \par -insidePoints \<list\> | |
| Point locations inside geometry to be meshed, e.g. '(0 0 0) (0 1 0)' | |
| - \par -layerExpansionRatio \<value\> | |
| Specify the expansion ratio between layers, default 1.2 | |
| - \par -layers \<entry\> | |
| Number of layers on specified surfaces, e.g. '(car 3) (ground 4)' | |
| - \par -minDimCells \<cells\> | |
| Number of cells in the shortest direction, e.g. 10 | |
| - \par -nCells \<cells\> | |
| Number of cells in each direction, e.g. '(10 20 30)' | |
| - \par -nCellsBetweenLevels \<int\> | |
| Number of cells at successive refinement levels, default 3 | |
| - \par -noBackground | |
| Do not write a blockMeshDict file | |
| - \par -outletRegions \<list\> | |
| Outlet regions on an external surface, e.g. 'outletA outletB' | |
| - \par -refineBackground \<int\> | |
| Integer multiplier for the number of cells (>= 1) | |
| - \par -refinementBoxes \<entry\> | |
| Refinement boxes specified by '(\<min\> \<max\> \<level\>) (...) ' | |
| - \par -refinementDists \<entry\> | |
| Refinement distance specified by | |
| '( (\<surface\> \<dist\> \<level\>) (...) )' | |
| - \par -refinementLevel \<int\> | |
| Refinement level used by snappyHexMesh, default 2 | |
| - \par -refinementRegions \<entry\> | |
| Refinement regions specified by '(\<surface\> \<level\>) (...)' | |
| - \par -region \<name\> | |
| Specify alternative mesh region | |
| - \par -rotatingZones \<list\> | |
| Surfaces that form rotatingZones, e.g. 'rotatingZone' | |
| - \par -surface \<file\> | |
| Single surface geometry file for meshing | |
| - \par -surfaceLevels \<entry\> | |
| Refinement level at specified surfaces, e.g. '(pipe 2) (baffles 1)' | |
| - \par -xMinPatch (-xMaxPatch, -yMinPatch, etc...) \<entry\> | |
| Name and type of the xMin (xMax, yMin, etc...) patch, | |
| '(\<name\> \<type\>)' | |
| \*---------------------------------------------------------------------------*/ | |
| using namespace Foam; | |
| // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // | |
| void readPatchOption | |
| ( | |
| const argList& args, | |
| HashTable<Pair<word>>& opts, | |
| const word& name | |
| ) | |
| { | |
| if (args.optionFound(name)) | |
| { | |
| List<word> patchOption(args.optionReadList<word>(name)); | |
| if (patchOption.size() == 2) | |
| { | |
| opts.insert(name, Pair<word>(patchOption[0], patchOption[1])); | |
| } | |
| else | |
| { | |
| FatalErrorInFunction | |
| << "Argument to option '-" << name | |
| << "' is " << args.option(name) << nl | |
| << "It should be of the form \"<name> <type>\"" | |
| << exit(FatalError); | |
| } | |
| } | |
| } | |
| // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // | |
| int main(int argc, char *argv[]) | |
| { | |
| argList::usageMin = 32; | |
| argList::usageMax = 105; | |
| argList::addNote | |
| ( | |
| "Writes blockMeshDict, snappyHexMeshDict, surfaceFeaturesDict " | |
| "and meshQualityDict files.\n" | |
| "Requires surface geometry files as inputs.\n" | |
| "For more information, see 'Description' in snappyHexMeshConfig.C " | |
| "or run\n\n foamInfo snappyHexMeshConfig" | |
| ); | |
| argList::addBoolOption | |
| ( | |
| "rm", | |
| "delete mesh configuration files" | |
| ); | |
| argList::addOption | |
| ( | |
| "surface", | |
| "file", | |
| "single surface geometry file for meshing" | |
| ); | |
| argList::addOption | |
| ( | |
| "nCells", | |
| "cells", | |
| "number of cells in each direction, e.g. '(10 20 30)'" | |
| ); | |
| argList::addOption | |
| ( | |
| "minDimCells", | |
| "int", | |
| "number of cells in the shortest direction, e.g. 10" | |
| ); | |
| argList::addOption | |
| ( | |
| "bounds", | |
| "box", | |
| "bounding box of the mesh, e.g. '(-10 -5 0) (10 5 10)'" | |
| ); | |
| argList::addBoolOption | |
| ( | |
| "cylindricalBackground", | |
| "generate a cylindrical background mesh aligned with the z-axis" | |
| ); | |
| argList::addBoolOption | |
| ( | |
| "noBackground", | |
| "do not write a blockMeshDict file" | |
| ); | |
| argList::addOption | |
| ( | |
| "refineBackground", | |
| "int", | |
| "integer multiplier for the number of cells (>= 1)" | |
| ); | |
| argList::addOption | |
| ( | |
| "refinementLevel", | |
| "int", | |
| "refinement level used by snappyHexMesh, default 2" | |
| ); | |
| argList::addOption | |
| ( | |
| "surfaceLevels", | |
| "entry", | |
| "refinement level at specified surfaces, e.g. '(pipe 2) (baffles 1)'" | |
| ); | |
| argList::addOption | |
| ( | |
| "refinementRegions", | |
| "entry", | |
| "refinement regions specified by '(<surface> <level>) (...)'" | |
| ); | |
| argList::addOption | |
| ( | |
| "refinementBoxes", | |
| "entry", | |
| "refinement boxes specified by '(<min> <max> <level>) (...)'" | |
| ); | |
| argList::addOption | |
| ( | |
| "refinementDists", | |
| "entry", | |
| "refinement distance specified by " | |
| "'(<surface> <dist> <level>) (...)'" | |
| ); | |
| argList::addOption | |
| ( | |
| "defaultPatch", | |
| "entry", | |
| "name and type of default patch, '<name> <type>'" | |
| ); | |
| List<word> patches(blockMeshCartesianConfiguration::patches); | |
| forAll(patches, i) | |
| { | |
| argList::addOption | |
| ( | |
| patches[i] + "Patch", | |
| "entry", | |
| "patch in the " | |
| + patches[i] | |
| + " direction, format '<name> <type>'" | |
| ); | |
| } | |
| argList::addBoolOption | |
| ( | |
| "clearBoundary", | |
| "do not set default patch entries, i.e. xMin, xMax, etc" | |
| ); | |
| argList::addBoolOption | |
| ( | |
| "explicitFeatures", | |
| "use explicit feature capturing" | |
| ); | |
| argList::addOption | |
| ( | |
| "layers", | |
| "entry", | |
| "number of layers on specified surfaces, e.g. '(car 3) (ground 4)'" | |
| ); | |
| argList::addOption | |
| ( | |
| "firstLayerThickness", | |
| "value", | |
| "specify the thickness of the near wall cells for layer addition" | |
| ); | |
| argList::addOption | |
| ( | |
| "layerExpansionRatio", | |
| "value", | |
| "specify the expansion ratio between layers, default 1.2" | |
| ); | |
| argList::addOption | |
| ( | |
| "cellZones", | |
| "list", | |
| "surfaces that form cellZones, e.g. 'porousZone heatSource'" | |
| ); | |
| argList::addOption | |
| ( | |
| "rotatingZones", | |
| "list", | |
| "surfaces that form rotatingZones, e.g. 'rotatingZone'" | |
| ); | |
| argList::addOption | |
| ( | |
| "baffles", | |
| "list", | |
| "surfaces that form baffles, e.g. 'helical'" | |
| ); | |
| argList::addOption | |
| ( | |
| "insidePoint", | |
| "point", | |
| "point location inside the region of geometry to be meshed" | |
| ); | |
| argList::addOption | |
| ( | |
| "insidePoints", | |
| "list", | |
| "point locations inside the geometry, e.g. '(0 1 0) (1 1 1)'" | |
| ); | |
| argList::addOption | |
| ( | |
| "nCellsBetweenLevels", | |
| "int", | |
| "number of cells at successive refinement levels, default 3" | |
| ); | |
| argList::addOption | |
| ( | |
| "inletRegions", | |
| "list", | |
| "inlet regions on an external surface, e.g. 'inletA inletB'" | |
| ); | |
| argList::addOption | |
| ( | |
| "outletRegions", | |
| "list", | |
| "outlet regions on an external surface, e.g. 'outletA outletB'" | |
| ); | |
| argList::addBoolOption | |
| ( | |
| "closedDomain", | |
| "domain does not contain inlets or outlets" | |
| ); | |
| word regionName; | |
| word dir(runTime.system()); | |
| if (args.optionReadIfPresent("region", regionName)) | |
| { | |
| dir = runTime.system()/regionName; | |
| if (!isDir(dir)) | |
| { | |
| mkDir(dir); | |
| } | |
| } | |
| if (args.optionFound("rm")) | |
| { | |
| wordList dicts | |
| { | |
| "snappyHexMeshDict", | |
| "blockMeshDict", | |
| "meshQualityDict", | |
| "surfaceFeaturesDict" | |
| }; | |
| Info<< "Deleting mesh configuration files in '" | |
| << dir << "'" << endl; | |
| label count = 0; | |
| forAll(dicts, i) | |
| { | |
| if (rm(dir/dicts[i])) | |
| { | |
| Info<< "+ " << dicts[i] << endl; | |
| ++count; | |
| } | |
| } | |
| if (count == 0) | |
| { | |
| Info<< "+ No files to delete" << endl; | |
| } | |
| Info<< "\nEnd\n" << endl; | |
| return 0; | |
| } | |
| Info<< "Writing mesh configuration files to '" | |
| << dir << "'" << nl << endl; | |
| fileNameList surfaceNames; | |
| if (args.optionFound("surface")) | |
| { | |
| surfaceNames.append(args.optionRead<fileName>("surface")); | |
| } | |
| else | |
| { | |
| const fileName surfDir | |
| ( | |
| runTime.constant()/searchableSurface::geometryDir(runTime) | |
| ); | |
| // Reads files, removing "gz" extensions | |
| fileNameList files(readDir(surfDir)); | |
| // Check valid extensions and add the path to the names | |
| forAll(files, i) | |
| { | |
| if (!meshingSurface::isSurfaceExt(files[i])) | |
| { | |
| continue; | |
| } | |
| surfaceNames.append(surfDir/files[i]); | |
| } | |
| // Need to exit if no surface geometry files found | |
| if (surfaceNames.empty()) | |
| { | |
| FatalErrorInFunction | |
| << "No surface geometry files found in " | |
| << surfDir << nl | |
| << "or provided using the '-surface' option" | |
| << exit(FatalError); | |
| } | |
| } | |
| wordList cellZoneNames; | |
| if (args.optionFound("cellZones")) | |
| { | |
| cellZoneNames.append(args.optionReadList<word>("cellZones")); | |
| } | |
| wordList rotatingZoneNames; | |
| if (args.optionFound("rotatingZones")) | |
| { | |
| rotatingZoneNames.append(args.optionReadList<word>("rotatingZones")); | |
| } | |
| wordList baffleNames; | |
| if (args.optionFound("baffles")) | |
| { | |
| baffleNames.append(args.optionReadList<word>("baffles")); | |
| } | |
| boundBox bb; | |
| if (args.optionFound("bounds")) | |
| { | |
| List<vector> bounds(args.optionReadList<vector>("bounds")); | |
| if (bounds.size() != 2) | |
| { | |
| FatalErrorInFunction | |
| << "Argument to '-bounds'" | |
| << " should be of the form '(<min> <max>)'" << nl | |
| << "with the <min> and <max> bounds of a bounding box" | |
| << "\n\nFound instead the argument: " | |
| << bounds | |
| << exit(FatalError); | |
| } | |
| bb = boundBox(bounds[0], bounds[1]); | |
| Info<< "Bounding box specified by '-bounds' option: " | |
| << bb << endl; | |
| } | |
| wordList inletRegions; | |
| if (args.optionFound("inletRegions")) | |
| { | |
| inletRegions.append(args.optionReadList<word>("inletRegions")); | |
| } | |
| wordList outletRegions; | |
| if (args.optionFound("outletRegions")) | |
| { | |
| outletRegions.append(args.optionReadList<word>("outletRegions")); | |
| } | |
| const bool closedDomain(args.optionFound("closedDomain")); | |
| meshingSurfaceList surfaces | |
| ( | |
| runTime, | |
| surfaceNames, | |
| cellZoneNames, | |
| rotatingZoneNames, | |
| baffleNames, | |
| bb, | |
| inletRegions, | |
| outletRegions, | |
| closedDomain | |
| ); | |
| const Vector<label> nCells | |
| ( | |
| args.optionLookupOrDefault("nCells", Vector<label>::zero) | |
| ); | |
| const label minDimCells | |
| ( | |
| args.optionLookupOrDefault("minDimCells", 0) | |
| ); | |
| const label refineFactor | |
| ( | |
| args.optionLookupOrDefault("refineBackground", 1) | |
| ); | |
| HashTable<Pair<word>> patchOpts(7); | |
| patches.append("default"); | |
| forAll(patches, i) | |
| { | |
| readPatchOption(args, patchOpts, patches[i] + "Patch"); | |
| } | |
| const bool clearBoundary(args.optionFound("clearBoundary")); | |
| if (!args.optionFound("noBackground")) | |
| { | |
| if (args.optionFound("cylindricalBackground")) | |
| { | |
| blockMeshCylindricalConfiguration blockMeshConfig | |
| ( | |
| "blockMeshDict", | |
| dir, | |
| runTime, | |
| surfaces, | |
| args.optionFound("bounds"), | |
| nCells, | |
| refineFactor, | |
| patchOpts, | |
| clearBoundary | |
| ); | |
| blockMeshConfig.write(); | |
| } | |
| else | |
| { | |
| blockMeshCartesianConfiguration blockMeshConfig | |
| ( | |
| "blockMeshDict", | |
| dir, | |
| runTime, | |
| surfaces, | |
| args.optionFound("bounds"), | |
| nCells, | |
| minDimCells, | |
| refineFactor, | |
| patchOpts, | |
| clearBoundary | |
| ); | |
| blockMeshConfig.write(); | |
| } | |
| } | |
| // snappyHexMeshDict options | |
| const label refinementLevel | |
| ( | |
| args.optionLookupOrDefault<label>("refinementLevel", 2) | |
| ); | |
| List<Tuple2<word, label>> surfaceLevels; | |
| if (args.optionFound("surfaceLevels")) | |
| { | |
| surfaceLevels.append | |
| ( | |
| args.optionReadList<Tuple2<word, label>>("surfaceLevels") | |
| ); | |
| } | |
| List<Tuple2<word, label>> refinementRegions; | |
| if (args.optionFound("refinementRegions")) | |
| { | |
| refinementRegions.append | |
| ( | |
| args.optionReadList<Tuple2<word, label>>("refinementRegions") | |
| ); | |
| } | |
| List<Tuple3<vector, vector, label>> refinementBoxes; | |
| if (args.optionFound("refinementBoxes")) | |
| { | |
| refinementBoxes.append | |
| ( | |
| args.optionReadList<Tuple3<vector, vector, label>> | |
| ( | |
| "refinementBoxes" | |
| ) | |
| ); | |
| } | |
| List<Tuple3<word, scalar, label>> refinementDists; | |
| if (args.optionFound("refinementDists")) | |
| { | |
| refinementDists.append | |
| ( | |
| args.optionReadList<Tuple3<word, scalar, label>>("refinementDists") | |
| ); | |
| } | |
| const bool explicitFeatures(args.optionFound("explicitFeatures")); | |
| List<Tuple2<word, label>> layers; | |
| if (args.optionFound("layers")) | |
| { | |
| layers.append | |
| ( | |
| args.optionReadList<Tuple2<word, label>>("layers") | |
| ); | |
| } | |
| const scalar firstLayerThickness | |
| ( | |
| args.optionLookupOrDefault<scalar>("firstLayerThickness", 0) | |
| ); | |
| const scalar layerExpansionRatio | |
| ( | |
| args.optionLookupOrDefault<scalar>("layerExpansionRatio", 1.2) | |
| ); | |
| if (args.optionFound("insidePoint") && args.optionFound("insidePoints")) | |
| { | |
| FatalErrorInFunction | |
| << "Options '-insidePoint' and '-insidePoints' " | |
| << "cannot both be selected" | |
| << exit(FatalError); | |
| } | |
| List<point> insidePoints; | |
| bool insidePointsOpt(false); | |
| if (args.optionFound("insidePoints")) | |
| { | |
| insidePoints.append | |
| ( | |
| args.optionReadList<point>("insidePoints") | |
| ); | |
| insidePointsOpt = true; | |
| } | |
| else | |
| { | |
| insidePoints.append | |
| ( | |
| args.optionLookupOrDefault<point>("insidePoint", point::zero) | |
| ); | |
| } | |
| const label nCellsBetweenLevels | |
| ( | |
| args.optionLookupOrDefault<label>("nCellsBetweenLevels", 3) | |
| ); | |
| if (explicitFeatures) | |
| { | |
| surfaceFeaturesConfiguration surfaceFeaturesConfig | |
| ( | |
| "surfaceFeaturesDict", | |
| dir, | |
| runTime, | |
| surfaces | |
| ); | |
| surfaceFeaturesConfig.write(); | |
| } | |
| snappyHexMeshConfiguration snappyConfig | |
| ( | |
| "snappyHexMeshDict", | |
| dir, | |
| runTime, | |
| surfaces, | |
| refinementLevel, | |
| surfaceLevels, | |
| refinementRegions, | |
| refinementBoxes, | |
| refinementDists, | |
| explicitFeatures, | |
| layers, | |
| firstLayerThickness, | |
| layerExpansionRatio, | |
| insidePointsOpt, | |
| insidePoints, | |
| nCellsBetweenLevels | |
| ); | |
| snappyConfig.write(); | |
| meshQualityConfiguration meshQualityConfig | |
| ( | |
| "meshQualityDict", | |
| dir, | |
| runTime | |
| ); | |
| meshQualityConfig.write(); | |
| Info<< "\nEnd\n" << endl; | |
| return 0; | |
| } | |
| // ************************************************************************* // | |