diff --git a/constant/extendedFeatureEdgeMesh/pipe02.extendedFeatureEdgeMesh.gz b/constant/extendedFeatureEdgeMesh/pipe02.extendedFeatureEdgeMesh.gz new file mode 100644 index 0000000..6dd11fe Binary files /dev/null and b/constant/extendedFeatureEdgeMesh/pipe02.extendedFeatureEdgeMesh.gz differ diff --git a/constant/polyMesh/boundary b/constant/polyMesh/boundary new file mode 100644 index 0000000..f158922 --- /dev/null +++ b/constant/polyMesh/boundary @@ -0,0 +1,30 @@ +/*--------------------------------*- C++ -*----------------------------------*\ +| ========= | | +| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | +| \\ / O peration | Version: 2206 | +| \\ / A nd | Website: www.openfoam.com | +| \\/ M anipulation | | +\*---------------------------------------------------------------------------*/ +FoamFile +{ + version 2.0; + format ascii; + arch "LSB;label=32;scalar=64"; + class polyBoundaryMesh; + location "constant/polyMesh"; + object boundary; +} +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +1 +( + defaultFaces + { + type empty; + inGroups 1(empty); + nFaces 50400; + startFace 1150800; + } +) + +// ************************************************************************* // diff --git a/constant/polyMesh/faces.gz b/constant/polyMesh/faces.gz new file mode 100644 index 0000000..17fa69e Binary files /dev/null and b/constant/polyMesh/faces.gz differ diff --git a/constant/polyMesh/neighbour.gz b/constant/polyMesh/neighbour.gz new file mode 100644 index 0000000..b178c2a Binary files /dev/null and b/constant/polyMesh/neighbour.gz differ diff --git a/constant/polyMesh/owner.gz b/constant/polyMesh/owner.gz new file mode 100644 index 0000000..c2de285 Binary files /dev/null and b/constant/polyMesh/owner.gz differ diff --git a/constant/polyMesh/points.gz b/constant/polyMesh/points.gz new file mode 100644 index 0000000..421bff4 Binary files /dev/null and b/constant/polyMesh/points.gz differ diff --git a/constant/triSurface/pipe02.curvature.gz b/constant/triSurface/pipe02.curvature.gz new file mode 100644 index 0000000..1270f87 Binary files /dev/null and b/constant/triSurface/pipe02.curvature.gz differ diff --git a/constant/triSurface/pipe02.eMesh.gz b/constant/triSurface/pipe02.eMesh.gz new file mode 100644 index 0000000..4ac94b8 Binary files /dev/null and b/constant/triSurface/pipe02.eMesh.gz differ diff --git a/system/blockMeshDict b/system/blockMeshDict index 1c00538..2dc7f78 100644 --- a/system/blockMeshDict +++ b/system/blockMeshDict @@ -18,19 +18,19 @@ scale 1; vertices ( - (-0.33 -0.33 -0.044) - ( 0.11 -0.33 -0.044) - ( 0.11 0.11 -0.044) - (-0.33 0.11 -0.044) - (-0.33 -0.33 0.044) - ( 0.11 -0.33 0.044) - ( 0.11 0.11 0.044) - (-0.33 0.11 0.044) + (-0.5 -0.5 -0.05) + ( 0.2 -0.5 -0.05) + ( 0.2 0.2 -0.05) + (-0.5 0.2 -0.05) + (-0.5 -0.5 0.05) + ( 0.2 -0.5 0.05) + ( 0.2 0.2 0.05) + (-0.5 0.2 0.05) ); blocks ( - hex (0 1 2 3 4 5 6 7) (100 100 20) simpleGrading (1 1 1) + hex (0 1 2 3 4 5 6 7) (140 140 20) simpleGrading (1 1 1) ); edges diff --git a/system/controlDict b/system/controlDict index 4da1b95..1f1f41a 100644 --- a/system/controlDict +++ b/system/controlDict @@ -34,7 +34,7 @@ purgeWrite 0; writeFormat ascii; -writePrecision 16; +writePrecision 8; writeCompression true; diff --git a/system/decomposeParDict b/system/decomposeParDict index 22e4362..170e797 100644 --- a/system/decomposeParDict +++ b/system/decomposeParDict @@ -16,7 +16,7 @@ FoamFile numberOfSubdomains 4; -method hierarchical; +method scotch; coeffs { diff --git a/system/snappyHexMeshDict b/system/snappyHexMeshDict index 7be1a23..7021df0 100644 --- a/system/snappyHexMeshDict +++ b/system/snappyHexMeshDict @@ -115,6 +115,22 @@ snapControls nRelaxIter 5; nFeatureSnapIter 3; strictRegionSnap true; + + // Feature snapping - copied from template dict generated by foamGetDict snappyHexMeshDict + // Number of feature edge snapping iterations. + // Leave out altogether to disable. + nFeatureSnapIter 10; + + // Detect (geometric only) features by sampling the surface + // (default=false). + implicitFeatureSnap false; + + // Use castellatedMeshControls::features (default = true) + explicitFeatureSnap true; + + // Detect features between multiple surfaces + // (only for explicitFeatureSnap, default = false) + multiRegionFeatureSnap false; } addLayersControls diff --git a/system/snappyHexMeshDictTEMPLATE b/system/snappyHexMeshDictTEMPLATE new file mode 100644 index 0000000..e4d319f --- /dev/null +++ b/system/snappyHexMeshDictTEMPLATE @@ -0,0 +1,837 @@ +/*--------------------------------*- C++ -*----------------------------------*\ +| ========= | | +| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | +| \\ / O peration | Version: v2206 | +| \\ / A nd | Website: www.openfoam.com | +| \\/ M anipulation | | +\*---------------------------------------------------------------------------*/ +FoamFile +{ + version 2.0; + format ascii; + class dictionary; + object snappyHexMeshDict; +} +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +// Which of the steps to run +castellatedMesh true; +snap true; +addLayers false; + + +// Optional: single region surfaces get patch names according to +// surface only. Multi-region surfaces get patch name +// surface "_ "region. Default is true +// singleRegionName false; + +// Optional: avoid patch-face merging. Allows mesh to be used for +// refinement/unrefinement +// mergePatchFaces false; // default true + +// Optional: allow patch-face merging even if differing patches. This avoids +// splitting boundary faces and might benefit layer coverage. +// (Note: only applicable if mergePatchFaces true) +// mergeAcrossPatches true; // default false + +// Optional: preserve all generated patches. Default is to remove +// zero-sized patches. +// keepPatches true; + + +// Geometry. All surfaces are of class searchableSurface. +// Surfaces are used +// - to specify refinement for any mesh cell intersecting it +// - to specify refinement for any mesh cell inside/outside/near +// - to 'snap' the mesh boundary to the surface +geometry +{ + box1x1x1 + { + type box; + min (1.5 1 -0.5); + max (3.5 2 0.5); + } + + // Shell for directional refinement + wakeBox + { + type box; + min (1.5 1 -0.5); + max (3.5 2 0.5); + } + + sphere.stl + { + type triSurfaceMesh; + + //tolerance 1E-5; // optional:non-default tolerance on intersections + //maxTreeDepth 10; // optional:depth of octree. Decrease only in case + // of memory limitations. + + // Per region the patchname. If not provided will be _. + // Note: this name cannot be used to identity this region in any + // other part of this dictionary; it is only a name + // for the combination of surface+region (which is only used + // when creating patches) + regions + { + secondSolid + { + name mySecondPatch; + } + } + } + + sphere2 + { + type sphere; + centre (1.5 1.5 1.5); + radius 1.03; + } +}; + + +// Settings for the castellatedMesh generation. +castellatedMeshControls +{ + + // Refinement parameters + // ~~~~~~~~~~~~~~~~~~~~~ + + // If local number of cells is >= maxLocalCells on any processor + // switches from from refinement followed by balancing + // (current method) to (weighted) balancing before refinement. + maxLocalCells 100000; + + // Overall cell limit (approximately). Refinement will stop immediately + // upon reaching this number so a refinement level might not complete. + // Note that this is the number of cells before removing the part which + // is not 'visible' from the keepPoint. The final number of cells might + // actually be a lot less. + maxGlobalCells 2000000; + + // The surface refinement loop might spend lots of iterations refining just + // a few cells. This setting will cause refinement to stop if + // <= minRefinementCells cells are selected for refinement. Note: it will + // at least do one iteration unless + // a: the number of cells to refine is 0 + // b: minRefinementCells = -1. This is a special value indicating + // no refinement. + minRefinementCells 0; + + // Allow a certain level of imbalance during refining + // (since balancing is quite expensive) + // Expressed as fraction of perfect balance (= overall number of cells / + // nProcs). 0=balance always. + maxLoadUnbalance 0.10; + + // Number of buffer layers between different levels. + // 1 means normal 2:1 refinement restriction, larger means slower + // refinement. + nCellsBetweenLevels 1; + + + // Explicit feature edge refinement + // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + // Specifies a level for any cell intersected by explicitly provided + // edges. + // This is a featureEdgeMesh, read from constant/triSurface for now. + // Specify 'levels' in the same way as the 'distance' mode in the + // refinementRegions (see below). The old specification + // level 2; + // is equivalent to + // levels ((0 2)); + + features + ( + //{ + // file "someLine.eMesh"; + // //level 2; // Have level 2 for all cells intersected + // // by feature. + // levels ((0.1 2)); // Have level 2 for all cells within + // // 0.1 of feature. + //} + ); + + + // Surface based refinement + // ~~~~~~~~~~~~~~~~~~~~~~~~ + + // Specifies two levels for every surface. The first is the minimum level, + // every cell intersecting a surface gets refined up to the minimum level. + // The second level is the maximum level. Cells that 'see' multiple + // intersections where the intersections make an + // angle > resolveFeatureAngle get refined up to the maximum level. + + refinementSurfaces + { + sphere.stl + { + // Surface-wise min and max refinement level + level (2 2); + + // Optional region-wise level specification + regions + { + secondSolid + { + level (3 3); + } + } + + // Optional specification of patch type (default is wall). No + // constraint types (cyclic, symmetry) etc. are allowed. + patchInfo + { + type patch; + inGroups (meshedPatches); + } + + + //- Optional increment (on top of max level) in small gaps + //gapLevelIncrement 2; + + //- Optional angle to detect small-large cell situation + // perpendicular to the surface. Is the angle of face w.r.t. + // the local surface normal. Use on flat(ish) surfaces only. + // Otherwise leave out or set to negative number. + //perpendicularAngle 10; + + //- Optional faceZone and (for closed surface) cellZone with + // how to select the cells that are in the cellZone + // (inside / outside / specified insidePoint) + // The orientation of the faceZone is + // - if on cellZone(s) : point out of (minimum) cellZone + // - if freestanding : oriented according to surface + + //faceZone sphere; + //cellZone sphere; + //cellZoneInside inside; // outside/insidePoint + //insidePoint (1 1 1); // if (cellZoneInside == insidePoint) + + //- Optional specification of what to do with faceZone faces: + // internal : keep them as internal faces (default) + // baffle : create baffles from them. This gives more + // freedom in mesh motion + // boundary : create free-standing boundary faces (baffles + // but without the shared points) + //faceType baffle; + + //- Optional automatic gap refinement. See section in + // refinementRegions ('gapLevel', 'gapMode') + + //- Optional removal of cells in thin gaps. Start removing cells + // if at refinement level 10 we're detecting thin gaps. + //blockLevel 10; + + //- Optional early detection of connections between inside and + // outside locations. Default is only after all refinement has + // been done. + //leakLevel 10; + } + } + + // Feature angle: + // - used if min and max refinement level of a surface differ + // - used if feature snapping (see snapControls below) is used + resolveFeatureAngle 30; + + //- Optional increment (on top of max level) in small gaps + //gapLevelIncrement 2; + + + // Planar angle: + // - used to determine if surface normals + // are roughly the same or opposite. Used + // - in proximity refinement + // - to decide when to merge free-standing baffles + // (if e.g. running in surfaceSimplify mode set this to 180 to + // merge all baffles) + // - in snapping to avoid snapping to nearest on 'wrong' side + // of thin gap + // + // If not specified same as resolveFeatureAngle + planarAngle 30; + + + // Region-wise refinement + // ~~~~~~~~~~~~~~~~~~~~~~ + + // Specifies refinement level for cells in relation to a surface. One of + // three modes + // - distance. 'levels' specifies per distance to the surface the + // wanted refinement level. The distances need to be specified in + // increasing order. + // - inside. 'levels' is only one entry and only the level is used. All + // cells inside the surface get refined up to the level. The surface + // needs to be closed for this to be possible. + // - outside. Same but cells outside. + + refinementRegions + { + box1x1x1 + { + mode inside; + levels ((1.0 4)); + } + //sphere.stl + //{ + // mode inside; + // levels ((1.0 4)); + // // Optional override of uniform refinement level such + // // that in small gaps we're getting more cells. + // // The specification is + // // - numGapCells : minimum number of cells in the gap + // // (usually >3; lower than this might not + // // resolve correctly) + // // - minLevel : min refinement level at which to kick in + // // - maxLevel : upper refinement level (to avoid refinement + // // continuing on a single extraneous feature) + // // All three settings can be overridden on a surface by + // // surface basis in the refinementSurfaces section. + // gapLevel ( ); + // // Optional: when doing the gapLevel refinement directly remove + // // based on orientation w.r.t. gap. This limits the + // // amount of cells before doing the 'locationInMesh' + // // cell selection. Default is 'mixed' i.e. keep cells + // // whilst doing the gap-level refinement. + // //gapMode inside; // inside/outside/mixed + // //gapSelf false; // ignore gaps in same surface + //} + + //wakeBox + //{ + // mode inside; + // // Dummy base level + // levels ((10000 0)); + // + // // Optional directional refinement (after all other refinement) + // // Directional refinement + // // for all cells according to 'mode' ('inside' or 'outside'; + // // 'distance' not supported) and within certain range. E.g. + // // - for all cells with level 2-5 + // // - do one split in x direction + // levelIncrement (2 5 (1 0 0)); + // + // // Note + // // - ignores 'levels' and gap* settings. + // // - the cellLevel/pointLevels files are no longer consistent + // // with the mesh, the resulting mesh is no longer compatible + // // with e.g. dynamic refinement/unrefinement. + // // - cellLevel will include any directional refinement + // // (i.e. it will be the maximum of all three directions) + //} + + //wakeBox + //{ + // mode inside; + // // Dummy base level + // levels ((10000 0)); + // + // // Optional directional refinement (after all other refinement) + // // Directional refinement + // // for all cells according to 'mode' ('inside' or 'outside'; + // // 'distance' not supported) and within certain range. E.g. + // // - for all cells with level 2-5 + // // - do one split in x direction + // levelIncrement (2 5 (1 0 0)); + // + // // Note + // // - ignores 'levels' and gap* settings. + // // - the cellLevel/pointLevels files are no longer consistent + // // with the mesh, the resulting mesh is no longer compatible + // // with e.g. dynamic refinement/unrefinement. + // // - cellLevel will include any directional refinement + // // (i.e. it will be the maximum of all three directions) + // + // // Optional directional expansion-ratio smoothing (after all + // // refinement). This will try to smooth out edge/cell size jumps + // // Specify smoothing direction and number of iterations + // smoothDirection (1 0 0); + // // Smoothing of expansion ratio + // nSmoothExpansion 100; + // // Smoothing of positions + // nSmoothPosition 100; + //} + } + + + + // Optionally limit refinement in geometric region. This limits all + // refinement (from features, refinementSurfaces, refinementRegions) + // in a given geometric region. The syntax is exactly the same as for the + // refinementRegions; the cell level now specifies the upper limit + // for any cell. (a special setting is cell level -1 which will remove + // any cells inside the region). Note that it does not override the + // refinement constraints given by the nCellsBetweenLevels setting. + limitRegions + { + } + + + // Mesh selection + // ~~~~~~~~~~~~~~ + + // After refinement patches get added for all refinementSurfaces and + // all cells intersecting the surfaces get put into these patches. The + // section reachable from the location(s)InMesh is kept. + // NOTE: This point should never be on a face, always inside a cell, even + // after refinement. + // + // There are two different ways of specifying the regions to keep: + // 1. a single locationInMesh. This is the unzoned part of the mesh. + // All the 'zoned' surfaces are marked as such + // in the refinementSurfaces with the faceZone and cellZone keywords. + // It is illegal to have the locationInMesh inside a surface for which + // a cellZone is specified. + // + // or + // + // 2. multiple locationsInMesh, with per location the name of the cellZone. + // This uses walking to determine zones and automatically creates + // faceZones on the outside of cellZones. The special name 'none' is + // used to indicate the unzoned/background part of the mesh. + + + // Ad 1. Specify a single location and how to treat faces inbetween + // cellZones + locationInMesh (5 0.28 0.43); + + // Whether any faceZones (as specified in the refinementSurfaces) + // are only on the boundary of corresponding cellZones. + // Not used if there are no faceZones. The behaviour has changed + // with respect to previous versions: + // true : all intersections with surface are put in faceZone + // (same behaviour as before) + // false : depending on the type of surface intersected: + // - if intersecting surface has faceZone only (so no cellZone) + // leave in faceZone (so behave as if set to true) (= changed + // behaviour) + // - if intersecting surface has faceZone and cellZone + // remove if inbetween same cellZone or if on boundary + // (same behaviour as before) + allowFreeStandingZoneFaces true; + + + + // 2. Specify multiple locations with optional cellZones for the + // regions (use cellZone "none" to specify the unzoned cells) + // FaceZones are automatically constructed from the + // names of the cellZones: _to_ + // where the cellZoneA is the lowest numbered cellZone (non-cellZone + // cells are in a special region called "none" which is always + // last). + + locationsInMesh + ( + ((-0.09 -0.039 -0.049) bottomAir) // cellZone 0 + ((-0.09 0.009 -0.049) topAir) // cellZone 1 + ((-0.09 0.001 -0.049) leftSolid) // cellZone 2 + ((0.02 0.001 -0.049) rightSolid) // cellZone 3 + ((-0.001 -0.039 0.0015) heater) // cellZone 4 + ); + + // Per synthesised faceZone name the faceType and type of baffles to + // create + faceZoneControls + { + bottomAir_to_heater + { + // Optional specification of patch type (default is wall). No + // constraint types (cyclic, symmetry) etc. are allowed. + patchInfo + { + type patch; + inGroups (patchPatches); + } + faceType baffle; + } + } + + + + // Optional locations that should not be reachable from + // location(s)InMesh + locationsOutsideMesh ((100 100 100)); + + // Optional: do not remove cells likely to give snapping problems + // handleSnapProblems false; + + // Optional: switch off topological test for cells to-be-squashed + // and use geometric test instead + //useTopologicalSnapDetection false; + + // Optional: do not refine surface cells with opposite faces of + // differing refinement levels + //interfaceRefine false; + + // Optional: use an erosion instead of region assignment to allocate + // left-over cells to the background region (i.e. make cellZones + // consistent with the intersections of the surface). + // Erosion is specified as a number of erosion iterations. + // Erosion has less chance of bleeding and changing the zone + // for a complete region. + // A negative value implements 'growing' the cellZones which + // might help with small non-physical gaps inbetween cellZones. + // (currently only a single layer growth i.e. -1 is supported) + // Default value is 0. + //nCellZoneErodeIter 2; + + // Optional: delete any region smaller than below fraction of the overall + // size (on a per-zone basis). This is occasionally useful + // when generating meshes with faceZones as baffles or boundary + // faces. + //minCellFraction 0.001; + // Optional: same but in absolute number of cells. Default is 0. + //nMinCells 100; + + // Optional: enable automatic leak closure (default is exit immediately) + //useLeakClosure true; +} + +// Settings for the snapping. +snapControls +{ + // Number of patch smoothing iterations before finding correspondence + // to surface + nSmoothPatch 3; + + // Optional: number of smoothing iterations for internal points on + // refinement interfaces. This will reduce non-orthogonality on + // refinement interfaces. + //nSmoothInternal $nSmoothPatch; + + // Maximum relative distance for points to be attracted by surface. + // True distance is this factor times local maximum edge length. + tolerance 2.0; + + // Number of mesh displacement relaxation iterations. + nSolveIter 30; + + // Maximum number of snapping relaxation iterations. Should stop + // before upon reaching a correct mesh. + nRelaxIter 5; + + // (wip) disable snapping to opposite near surfaces (revert to 22x + // behaviour) + // detectNearSurfacesSnap false; + + + // Feature snapping + + // Number of feature edge snapping iterations. + // Leave out altogether to disable. + nFeatureSnapIter 10; + + // Detect (geometric only) features by sampling the surface + // (default=false). + implicitFeatureSnap false; + + // Use castellatedMeshControls::features (default = true) + explicitFeatureSnap true; + + // Detect features between multiple surfaces + // (only for explicitFeatureSnap, default = false) + multiRegionFeatureSnap false; + + + //- When to run face splitting (never at first iteration, always + // at last iteration). Is interval. Default -1 (disabled) + //nFaceSplitInterval 5; + + + // (wip) Optional for explicit feature snapping: + //- Detect baffle edges. Default is true. + //detectBaffles false; + //- On any faces where points are on multiple regions (see + // multiRegionFeatureSnap) have the other points follow these points + // instead of having their own independent movement, i.e. have snapping + // to multi-region edges/points take priority. This might aid snapping + // to sharp edges that are also region edges. The default is false. + //releasePoints true; + //- Walk along feature edges, adding missing ones. Default is true. + //stringFeatures false; + //- If diagonal attraction also attract other face points. Default is + // false + //avoidDiagonal true; + //- When splitting what concave faces to leave intact. Default is 45 + // degrees. + //concaveAngle 30; + //- When splitting the minimum area ratio of faces. If face split + // causes ratio of area less than this do not split. Default is 0.3 + //minAreaRatio 0.3; + //- Attract points only to the surface they originate from. Default + // false. This can improve snapping of intersecting surfaces. + // strictRegionSnap true; +} + +// Settings for the layer addition. +addLayersControls +{ + // Are the thickness parameters below relative to the undistorted + // size of the refined cell outside layer (true) or absolute sizes (false). + relativeSizes true; + + // Layer thickness specification. This can be specified either through the + // 'thicknessModel' parameter (new) or by specifying the individual + // settings. The parameters are the cell height of the cells next to the + // wall ('firstLayerThickness'), the cell height of the cells next to the + // bulk ('finalLayerThickness'), the expansionRatio ('expansionRatio') and + // the overall thickness of all layers ('thickness'). + + //- specification of firstLayerThickness and overallThicknes, calculates + // needed expansionRatio. + // thicknessModel firstAndOverall; + + //- specification of firstLayerThickness and expansionRatio. + // thicknessModel firstAndExpansion; + + //- specification of finalLayerThickness and expansionRatio. + // thicknessModel finalAndExpansion; + + //- specification of thickness and expansionRatio. + // thicknessModel overallAndExpansion; + + //- specification of firstLayerThickness and finalLayerThickness. The + // firstLayerThickness is always absolute, the finalLayerThickness is + // always relative, independent of the relativeSizes setting + // thicknessModel firstAndRelativeFinal; + + + // Expansion factor for layer mesh + expansionRatio 1.0; + + // Wanted thickness of the layer furthest away from the wall. + // If relativeSizes this is relative to undistorted size of cell + // outside layer. + finalLayerThickness 0.3; + + + // Minimum overall thickness of total layers. If for any reason layer + // cannot be above minThickness do not add layer. + // If relativeSizes this is relative to undistorted size of cell + // outside layer.. + minThickness 0.1; + + + // Per final patch or faceZone (so not geometry!) the layer information: + // - whether to use relative or absolute sizes + // - thicknessModel (or individual settings) + // - minimum thickness + // + // Note: mesh shrinking behaviour changed after 21x. Any non-mentioned + // patches now slide unless: + // - nSurfaceLayers is explicitly mentioned to be 0. + // - angle to nearest surface < slipFeatureAngle (see below) + layers + { + sphere.stl_firstSolid + { + nSurfaceLayers 1; + + } + maxY + { + nSurfaceLayers 1; + // Per patch layer data + expansionRatio 1.3; + finalLayerThickness 0.3; + minThickness 0.1; + } + + // Disable any mesh shrinking and layer addition on any point of + // a patch by setting nSurfaceLayers to 0 + frozenPatches + { + nSurfaceLayers 0; + } + } + + // If points get not extruded do nGrow layers of connected faces that are + // also not grown. This helps convergence of the layer addition process + // close to features. + // Note: changed(corrected) w.r.t 1.7.x! (didn't do anything in 1.7.x) + nGrow 0; + + // Advanced settings + + + // Static analysis of starting mesh + + // When not to extrude surface. 0 is flat surface, 90 is when two faces + // are perpendicular. Note: was not working correctly < 1806 + featureAngle 120; + + // When to merge patch faces. Default is featureAngle. Useful when + // featureAngle is large. + //mergePatchFacesAngle 45; + + // Stop layer growth on highly warped cells + maxFaceThicknessRatio 0.5; + + + // Patch displacement + + // Number of smoothing iterations of surface normals + nSmoothSurfaceNormals 1; + + // Smooth layer thickness over surface patches + nSmoothThickness 10; + + + + // Choice of mesh shrinking algorithm + + // Optional mesh shrinking algorithm (default is displacementMedialAxis) + // The displacementMotionSolver is a wrapper around the displacement + // motion solvers. It needs specification of the solver to use and + // its control dictionary. + //meshShrinker displacementMotionSolver; + //solver displacementLaplacian; + //displacementLaplacianCoeffs + //{ + // diffusivity quadratic inverseDistance + // ( + // sphere.stl_firstSolid + // maxY + // ); + //} + // Note that e.g. displacementLaplacian needs entries in + // fvSchemes, fvSolution. Also specify a minIter > 1 when solving + // cellDisplacement since otherwise solution might not be sufficiently + // accurate on points. + + + // Medial axis analysis (for use with default displacementMedialAxis) + + // Angle used to pick up medial axis points + // Note: changed(corrected) w.r.t 1.7.x! 90 degrees corresponds to 130 + // in 1.7.x. + minMedialAxisAngle 90; + + // Reduce layer growth where ratio thickness to medial + // distance is large + maxThicknessToMedialRatio 0.3; + + // Number of smoothing iterations of interior mesh movement direction + nSmoothNormals 3; + + // Optional: limit the number of steps walking away from the surface. + // Default is unlimited. + //nMedialAxisIter 10; + + // Optional: smooth displacement after medial axis determination. + // default is 0. + //nSmoothDisplacement 90; + + // (wip)Optional: do not extrude any point where + // (false) : all surrounding faces are not fully extruded + // (true) : all surrounding points are not extruded + // Default is false. + //detectExtrusionIsland true; + + // Optional: do not extrude around sharp edges if both faces are not + // fully extruded i.e. if one of the faces on either side would + // become a wedge. + // Default is 0.5*featureAngle. Set to -180 always attempt extrusion + //layerTerminationAngle 25; + + // Optional: disable shrinking of edges that have one (or two) points + // on an extruded patch. + // Default is false to enable single/two cell thick channels to still + // have layers. In <=1806 this was true by default. On larger gaps it + // should have no effect. + //disableWallEdges true; + + // Optional: at non-patched sides allow mesh to slip if extrusion + // direction makes angle larger than slipFeatureAngle. Default is + // 0.5*featureAngle. + slipFeatureAngle 30; + + // Maximum number of snapping relaxation iterations. Should stop + // before upon reaching a correct mesh. + nRelaxIter 5; + + + // Mesh shrinking + + // Create buffer region for new layer terminations, i.e. gradually + // step down number of layers. Set to <0 to terminate layer in one go. + nBufferCellsNoExtrude 0; + + // Overall max number of layer addition iterations. The mesher will + // exit if it reaches this number of iterations; possibly with an + // illegal mesh. + nLayerIter 50; + + // Max number of iterations after which relaxed meshQuality controls + // get used. Up to nRelaxedIter it uses the settings in + // meshQualityControls, + // after nRelaxedIter it uses the values in + // meshQualityControls::relaxed. + nRelaxedIter 20; + + // Additional reporting: if there are just a few faces where there + // are mesh errors (after adding the layers) print their face centres. + // This helps in tracking down problematic mesh areas. + //additionalReporting true; +} + +// Generic mesh quality settings. At any undoable phase these determine +// where to undo. +meshQualityControls +{ + // Specify mesh quality constraints in separate dictionary so can + // be reused (e.g. checkMesh -meshQuality) + #include "meshQualityDict" + + + // Optional : some meshing phases allow usage of relaxed rules. + // See e.g. addLayersControls::nRelaxedIter. + relaxed + { + // Maximum non-orthogonality allowed. Set to 180 to disable. + maxNonOrtho 75; + } + + + // Advanced + + // Number of error distribution iterations + nSmoothScale 4; + // amount to scale back displacement at error points + errorReduction 0.75; +} + +// Advanced + +//// Debug flags +//debugFlags +//( +// mesh // write intermediate meshes +// intersections // write current mesh intersections as .obj files +// featureSeeds // write information about explicit feature edge +// // refinement +// attraction // write attraction as .obj files +// layerInfo // write information about layers +//); +// +//// Write flags +//writeFlags +//( +// scalarLevels // write volScalarField with cellLevel for postprocessing +// layerSets // write cellSets, faceSets of faces in layer +// layerFields // write volScalarField for layer coverage +//); + + +//// Format for writing lines. E.g. leak path. Default is vtk format. +//setFormat ensight; + +// Merge tolerance. Is fraction of overall bounding box of initial mesh. +// Note: the write tolerance needs to be higher than this. +mergeTolerance 1e-6; + +// ************************************************************************* //