View difference between Paste ID: YqQgDbn1 and f2S3FeEj

 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
 |  \\    /   O peration     | Version:  2.2.0                                 |
 |   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/
 FoamFile
 {
     version     2.0;
     format      ascii;
     class       dictionary;
     object      autoHexMeshDict;
 }
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 #include        "$FOAM_CASE/include/initialConditions"
 // Which of the steps to run
 castellatedMesh true;
 snap            true;
 addLayers       false;
 
 
 // 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
 {
     lumen.stl
     {
         type triSurfaceMesh;
         name lumen;
     }
 
 /*    AAA
     {
         type searchableBox;
         min (#calc "$xmin - 5E-3" #calc "$ymin - 5E-3" $zAAAmin);
         max (#calc "$xmax + 5E-3" #calc "$ymax + 5E-3" $zAAAmax);
     }
 */
 };
 
 
 
 
 // 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 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.
     maxGlobalCells 10000000;
 
     // 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)
     minRefinementCells 2;
 
     // Number of buffer layers between different levels.
     // 1 means normal 2:1 refinement restriction, larger means slower
     // refinement.
     nCellsBetweenLevels 2;
 
 
 
     // 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 "lumen.vtk";
             levels ((0 2)(0.002 1));
         }
     );
 
 
 
     // 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
     {
        "lumen_*"
         {
             // Surface-wise min and max refinement level
             level (1 1);
 
         }
 
 
     }
 
     resolveFeatureAngle 25;
 
 
     // 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
     {
   /*      AAA
         {
             mode inside;
             levels ((1E15 1));
         }
 */
     }
 
 
 
 
     // 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.
     // This is an outside point locationInMesh (-0.033 -0.033 0.0033);
       //locationInMesh (27 0 0) ;//( 0 -0.2 0.905); //fluid
       locationInMesh ($locx $locy $locz); //OK
       //locationInMesh ( 0.07 -0.194 0.78); //OK
     // Whether any faceZones (as specified in the refinementSurfaces)
     // are only on the boundary of corresponding cellZones or also allow
     // free-standing zone faces. Not used if there are no faceZones.
     allowFreeStandingZoneFaces true;
 }
 
 // Settings for the snapping.
 snapControls
 {
     //- Number of patch smoothing iterations before finding correspondence
     //  to surface
     nSmoothPatch 3;
 
     //- Relative distance for points to be attracted by surface feature point
     //  or edge. True distance is this factor times local
     //  maximum edge length.
     tolerance 8;
 
     //- Number of mesh displacement relaxation iterations.
     nSolveIter 30;
 
     //- Maximum number of snapping relaxation iterations. Should stop
     //  before upon reaching a correct mesh.
     nRelaxIter 5;
 
     // Feature snapping
 
         //- Number of feature edge snapping iterations.
         //  Leave out altogether to disable.
         nFeatureSnapIter 10;
 
         //- Detect (geometric) features by sampling the surface
         implicitFeatureSnap false;
 
         //- Use castellatedMeshControls::features
         explicitFeatureSnap true;
 
         //- Detect features between multiple surfaces
         //  (only for explicitFeatureSnap, default = false)
         multiRegionFeatureSnap false;
 }
 
 
 
 // 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;
 
     // Per final patch (so not geometry!) the layer information
     layers
     {
   /*      "flange_.*"
         {
             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.
     // See relativeSizes parameter.
     finalLayerThickness 0.3;
 
     // Minimum thickness of cell layer. If for any reason layer
     // cannot be above minThickness do not add layer.
     // See relativeSizes parameter.
     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 0;
 
 
     // Advanced settings
 
     // When not to extrude surface. 0 is flat surface, 90 is when two faces
     // are perpendicular
     featureAngle 30;
 
     // Maximum number of snapping relaxation iterations. Should stop
     // before upon reaching a correct mesh.
     nRelaxIter 5;
 
     // Number of smoothing iterations of surface normals
     nSmoothSurfaceNormals 1;
 
     // Number of smoothing iterations of interior mesh movement direction
     nSmoothNormals 3;
 
     // Smooth layer thickness over surface patches
     nSmoothThickness 10;
 
     // Stop layer growth on highly warped cells
     maxFaceThicknessRatio 0.5;
 
     // Reduce layer growth where ratio thickness to medial
     // distance is large
     maxThicknessToMedialRatio 0.3;
 
     // Angle used to pick up medial axis points
     minMedianAxisAngle 90;
 
     // Create buffer region for new layer terminations
     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 nRelaxIter it uses the settings in meshQualityControls,
     // after nRelaxIter it uses the values in meshQualityControls::relaxed.
     nRelaxedIter 20;
 }
 
 
 
 // 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;
 
     //- Max skewness allowed. Set to <0 to disable.
     maxBoundarySkewness 20;
     maxInternalSkewness 4;
 
     //- Max concaveness allowed. Is angle (in degrees) below which concavity
     //  is allowed. 0 is straight face, <0 would be convex face.
     //  Set to 180 to disable.
     maxConcave 80;
 
     //- Minimum pyramid volume. Is absolute volume of cell pyramid.
     //  Set to a sensible fraction of the smallest cell volume expected.
     //  Set to very negative number (e.g. -1E30) to disable.
     minVol 1e-13;
 
     //- Minimum quality of the tet formed by the face-centre
     //  and variable base point minimum decomposition triangles and
     //  the cell centre.  Set to very negative number (e.g. -1E30) to
     //  disable.
     //     <0 = inside out tet,
     //      0 = flat tet
     //      1 = regular tet
     minTetQuality 1e-30;
 
     //- Minimum face area. Set to <0 to disable.
     minArea -1;
 
     //- Minimum face twist. Set to <-1 to disable. dot product of face normal
     //- and face centre triangles normal
     minTwist 0.02;
 
     //- minimum normalised cell determinant
     //- 1 = hex, <= 0 = folded or flattened illegal cell
     minDeterminant 0.001;
 
     //- minFaceWeight (0 -> 0.5)
     minFaceWeight 0.05;
 
     //- minVolRatio (0 -> 1)
     minVolRatio 0.01;
 
     //must be >0 for Fluent compatibility
     minTriangleTwist -1;
 
     //- if >0 : preserve single cells with all points on the surface if the
     //  resulting volume after snapping (by approximation) is larger than
     //  minVolCollapseRatio times old volume (i.e. not collapsed to flat cell).
     //  If <0 : delete always.
     //minVolCollapseRatio 0.5;
 
 
     // Advanced
 
     //- Number of error distribution iterations
     nSmoothScale 4;
     //- amount to scale back displacement at error points
     errorReduction 0.75;
 
 
 
     // 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
 
 // 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;