zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-11-28 03:28:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

updated sample dictionary

Browse Source
This commit is contained in:
mattijs
2008-07-08 12:07:54 +01:00
parent ab17085c1a
commit 72fb77ccce
1 changed files with 187 additions and 151 deletions
Download Patch File Download Diff File Expand all files Collapse all files

338
applications/utilities/mesh/generation/snappyHexMesh/snappyHexMeshDict
View File

@ -22,161 +22,171 @@ FoamFile
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Which phases to run.
doRefine true;
doSnap true;
doLayers true; // includes autoMergeFaces
// Which of the steps to run
castellatedMesh true;
snap true;
addLayers false;
// Whether to dump intermediate meshes and print lots
// 1 : write mesh
// 2 : write volScalarField with cellLevel for postprocessing
// 4 : write current intersections as .obj files
debug 0;
refineDict
// Geometry. Definition of all surfaces. 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
{
// Which part to keep.
// NOTE: This point should never be on a face, always inside a cell, even
// after refinement.
keepPoints ((3 0.28 0.43));
// box1x1x1
// {
// type searchableBox;
// min (1.5 1 -0.5);
// max (3.5 2 0.5);
// }
//
// sphere.stl
// {
// type triSurfaceMesh;
//
// // Per region the patchname. If not provided will be <name>_<region>.
// regions
// {
// secondSolid
// {
// name mySecondPatch;
// }
// }
// }
// Whether to remove/split cells likely to give problems when snapping
handleSnapProblems on;
sphere2
{
type searchableSphere;
centre (1.5 1.5 1.5);
radius 1.03;
}
};
// Merge tolerance. Is fraction of overall bounding box of initial mesh
mergeTolerance 1E-6;
// Settings for the castellatedMesh generation.
castellatedMeshControls
{
// Refinement parameters
// ~~~~~~~~~~~~~~~~~~~~~
// While refining maximum number of cells per processor. This is basically
// the number of cells that fit on a processor. If you choose this too small
// it will do just more refinement iterations to obtain a similar mesh.
procCellLimit 1000000;
maxLocalCells 1000000;
// 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.
cellLimit 2000000;
// 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 <= minimumRefine
// are selected for refinement. Note: it will at least do one iteration
// (unless the number of cells to refine is 0)
minimumRefine 0;
minRefinementCells 0;
// Number of buffer layers between different levels.
// 1 means normal 2:1 refinement restriction, larger means slower
// refinement.
nBufferLayers 1;
nCellsBetweenLevels 1;
// Feature Edge Refinement
// ~~~~~~~~~~~~~~~~~~~~~~~
// External feature file. Read from constant/triSurface for now.
// Limitations:
// - either start or edge of any feature line has to be inside domain
// and be visible from keepPoint on starting mesh.
// - refining cells containing features is separate phase before refining
// based on surface.
// - no load balancing, no check for cellLimit is done while doing this.
// Explicit feature edge refinement
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Specifies a level for any cell intersected by its edges.
// This is a featureEdgeMesh, read from constant/triSurface for now.
features
(
// {
// file "someLine.eMesh";
// level 2;
// }
//{
// file "someLine.eMesh";
// level 2;
//}
);
// Internal Mesh Refinement
// ~~~~~~~~~~~~~~~~~~~~~~~~
// Specifies the areas where the refinement has to be a certain level.
// These surfaces have to be closed. Refinement is either inside
// (refineInside = true) or outside. (note:insideness or outsideness
// is with respect to far away)
// Note:that even using these the transition can never be faster than
// nBufferLayers!
// Note:the refinement level can never be higher than any of the surfaces
// they overlap with. See below for the surface refinement level specification.
refinementShells
(
{
//type triSurfaceMesh;
//name cube1x1x1.stl;
type searchableBox;
name box1x1x1;
min (2.5 -0.5 -0.5);
max (3.5 0.5 0.5);
level 4;
refineInside true;
}
);
// Surface based refinement
// ~~~~~~~~~~~~~~~~~~~~~~~~
// Curvature. Cosine of angle between two neighbouring surface intersections.
// Only used if cell level > minLevel and < maxLevel.
curvature 0.5;
// 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.
// Overall the refinement is according to the following rules:
// - if the cell-cell vector intersects a surface any cell that
// is less refined than the minRefinementLevel of the surface gets refined.
// - else if the refinement level of the cell is between the
// minRefinementLevel and maxRefinementLevel the cell gets refined if
// - the normal of neighbouring surface intersections differ by more
// than above curvature
// - or if neighbouring surface intersections are on different surfaces or
// different surface regions.
// surfaces
surfaces
(
refinementSurfaces
{
sphere.stl
{
name sphere;
file "sphere.stl";
// Surface wide refinement level
minRefinementLevel 1;
maxRefinementLevel 1;
// Layers
surfaceLayers 1;
// Region specific refinement level
// Surface-wise min and max refinement level
level (2 2);
// Optional region-wise level specification
regions
(
{
secondSolid
{
name firstSolid;
minRefinementLevel 3;
maxRefinementLevel 3;
surfaceLayers 2;
level (3 3);
}
{
name secondSolid;
minRefinementLevel 1;
maxRefinementLevel 1;
surfaceLayers 1;
}
);
}
}
);
}
resolveFeatureAngle 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
// descending 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 distance;
// levels ((1.0 5) (2.0 3));
//}
}
// 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 locationInMesh is kept.
// NOTE: This point should never be on a face, always inside a cell, even
// after refinement.
locationInMesh (5 0.28 0.43);
}
// For snapping
snapDict
// Settings for the snapping.
snapControls
{
//- Number of patch smoothing iterations before finding correspondence
// to surface
@ -185,47 +195,64 @@ snapDict
//- Relative distance for points to be attracted by surface feature point
// or edge. True distance is this factor times local
// maximum edge length.
snapTol 4.0;
tolerance 4.0;
//- Whether to move internal mesh as well as boundary
smoothMesh true;
//- Number of mesh displacement smoothing iterations.
nSmoothDispl 30;
//- Number of mesh displacement relaxation iterations.
nSolveIter 30;
//- Maximum number of snapping relaxation iterations. Should stop
// before upon reaching a correct mesh.
nSnap 5;
nRelaxIter 5;
}
// For cell layers
layerDict
// Settings for the layer addition.
addLayersControls
{
// Per final patch (so not geometry!) the layer information
layers
{
sphere.stl_firstSolid
{
nSurfaceLayers 1;
}
maxY
{
nSurfaceLayers 1;
}
}
// Expansion factor for layer mesh
expansionRatio 1.0;
//- Wanted thickness of final added cell layer. If multiple layers
// is the
// thickness of the layer furthest away from the wall.
// Relative to undistorted size of cell outside layer.
finalLayerRatio 0.3;
//- Minimum thickness of cell layer. If for any reason layer
// cannot be above minThickness do not add layer.
// Relative to undistorted size of cell outside layer.
minThickness 0.25;
//- 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.
nGrow 1;
// Advanced settings
//- When not to extrude surface. 0 is flat surface, 90 is when two faces
// make straight angle.
featureAngle 60;
//- Maximum number of snapping relaxation iterations. Should stop
// before upon reaching a correct mesh.
nSnap 5;
//- Minimum thickness of cell layer. If for any reason layer cannot be
// above minThickness do not add layer if thickness below minThickNess.
// Relative to undistorted cell size
minThickness 0.25;
//- If points get not extruded do nGrow layers of connected faces that are
// not grown. Is used to not do layers at all close to features.
nGrow 1;
// Expansion factor for layer mesh
expansionRatio 1.3;
// Ratio of cell size in final added cell layer to cell size
// outside layer
finalLayerRatio 0.3;
nRelaxIter 5;
// Number of smoothing iterations of surface normals
nSmoothSurfaceNormals 1;
@ -248,20 +275,14 @@ layerDict
// Create buffer region for new layer terminations
nBufferCellsNoExtrude 0;
thickness 0.5;
nSmoothDispl 4;
}
// For mesh motion
motionDict
{
//
// Mesh Quality Parameters. Decide when mesh is good enough to stop
// smoothing.
//
// Generic mesh quality settings. At any undoable phase these determine
// where to undo.
meshQualityControls
{
//- Maximum non-orthogonality allowed. Set to 180 to disable.
maxNonOrtho 65;
@ -298,10 +319,10 @@ motionDict
//- minVolRatio (0 -> 1)
minVolRatio 0.01;
//must be >0 for Fluent compatibility
minTriangleTwist -1;
// Advanced
//- Number of error distribution iterations
@ -311,4 +332,19 @@ motionDict
}
// Advanced
// Flags for optional output
// 0 : only write final meshes
// 1 : write intermediate meshes
// 2 : write volScalarField with cellLevel for postprocessing
// 4 : write current intersections as .obj files
debug 0;
// Merge tolerance. Is fraction of overall bounding box of initial mesh.
// Note: the write tolerance needs to be higher than this.
mergeTolerance 1E-6;
// ************************************************************************* //