Sculpt Adaptive Meshing

Sculpt options for specifying adaptive meshing. Sculpt uses an initial overlay Cartesian grid that serves as the basis for the all-hex mesh. The default mesh size will roughly follow the constant size cells of the overlay grid. The adaptivity option allows the user to automatically split cells of the Cartesian grid based on geometric criteria, resulting in smaller cells in regions with finer details. The adapted grid is then used as the basis for the Sculpt procedure.

3D-multi-level-1a 3D-multi-level-2a 3D-multi-level-smoothed

Adaptive mesh begins with constant size coarse Cartesian grid. Cells are recursively split based on geometry criteria and transitions added between levels. Projections and smoothing are performed to improve element quality.

Three options are used for controlling the adaptivity in sculpt: adapt_type, adapt_levels and adapt_threshold. The adapt_type option controls the method and geometric criteria used for deciding which cells to split in the grid, while the adapt_levels option controls the the maximum number of times any one cell can be split. Depending upon the adapt_type selected, the adapt_threshold is used as the specific geometric threshold value at which the decision is made to split any given cell.

dragon-grid

Initial cut-away view of adapted grid from dragon model before performing Sculpt operations.

dragon-L4 dragon-L4-cut

The final mesh of the dragon model and cutaway view of the mesh is shown with up to 4 levels of adaptive refinement.


Adaptive Meshing             -adp     --adapt
  --adapt_type               -A    <arg> Adaptive meshing type                               
  --adapt_threshold          -AT   <arg> Threshold for adaptive meshing                      
  --adapt_levels             -AL   <arg> Number of levels of adaptive refinement             
  --adapt_material           -AM   <arg> Info for adapting material                          
  --adapt_export             -AE         Export exodus mesh of refined grid                  
  --adapt_non_manifold       -ANM        Refine at non-manifold conditions                   
  --adapt_load_balance       -ALB        Adaptive parallel load balancing                    
  --adapt_memory_stats       -AMS        Write memory usage stats for adaptivity             

Sculpt Command Summary

Adaptive Refinement Type

Command: adapt_type     Adaptive meshing type

Input file command:   adapt_type <arg>
Command line options: -A <arg>
Argument Type:        integer (0, 1, 2,...7) 
Input arguments: off (0)
                 facet_to_surface (1)
                 surface_to_facet (2)
                 surface_to_surface (3)
                 vfrac_average (4)
                 coarsen (5)
                 vfrac_diff (6)
                 vfrac_difference (6)
                 resample (7)
                 material (8)
                 region (12)
Command Description:

This option will automatically refine the mesh according to a user-defined criteria. Without this option, a constant cell size will be assumed everywhere in the model. To build the mesh, Sculpt uses an approximation to the exact geometry of the CAD model by interpolating mesh surfaces from volume fraction samples in each cell of the Cartesian grid. In general, the, higher the resolution of the Cartesian grid, the more sampling is done and the more accurate the mesh will represent the initial geometry. The adapt_type selected will control the criteria used for refining the mesh. If the criteria is not satisfied, the refinement will continue until a threshold indicated by the adapt_threshold parameter is satisfied everywhere, or the maximum number of levels (adapt_levels) is reached. The following criteria for refinement are available:

To maintain a conforming mesh, transition elements will be inserted to transition between smaller and larger element sizes. Default for the adapt_type option is off (0) (or that no adaptive refinement will take place).

In all cases the initial Cartesian grid defined by xint, yint and zint or the cell_size value will be used as the basis for refinement and will define the approximate largest element size in the mesh.


Adaptive Refinement Threshold

Command: adapt_threshold     Threshold for adaptive meshing

Input file command:   adapt_threshold <arg>
Command line options: -AT <arg>
Argument Type:        floating point value >= 0.0 
Command Description:

This value controls the sensitivity of of the adaptivity. The value used should be based upon the adapt_type:

Note that the user defined adapt_threshold may not be satisfied everywhere in the mesh if the value defined for adapt_levels is exceeded.


Number of Adaptive Levels

Command: adapt_levels     Number of levels of adaptive refinement

Input file command:   adapt_levels <arg>
Command line options: -AL <arg>
Argument Type:        integer >= 0 
Command Description:

The maximum number of levels of adaptive refinement to be performed. One level of refinement will split each Cartesian grid cell identified for uniform refinement into eight child cells. Two levels of refinement will split each cell again into eight, resulting in sixty-four child cells, three levels into 256, and so on. The maximum number of subdivision per cell is give as:

  number of cells = 8^adapt_levels

The minimum edge length for any cell will be given by:

  min cell edge length = cell_size / adapt_levels^2

The actual number of refinement levels used will be determined by whether all cells meet the adapt_threshold, or the adapt_levels value is exceeded. The default adapt_levels is 2. Note that setting the adapt_levels more than 4 or 5 can result in long compute times.


Info for Adapt Material

Command: adapt_material     Info for adapting material

Input file command:   adapt_material <arg>
Command line options: -AM <arg>
Argument Type:        5 optional values 
Command Description:

Specifies material information to be used with the adapt_type = material option. This option expects up to 5 ordered values representing the following:

  1. material id: ID of material to be refined
  2. levels: (optional) Number of levels to uniformly refine within the specified material. If not specified or levels <= 0, the global value for adapt_levels will be used.
  3. threshold: (optional) Threshold used to determine whether to uniformly refine. Refinement occurs if volume fraction of material in a cell exceeds the threshold value. If not specified or threshold <= 0, the global value for adapt_threshold will be used.
  4. expansion distance: (optional) Absolute distance beyond the specified material that will be uniformly refined. If not specified or expansion distance = 0, uniform refinement will be restricted to the material. A negative integer value for expansion distance will be interpreted as the number of layers of cells beyond the material that will be refined.
  5. region: (optional) specify a region id as defined by an adapt_region specification. Refinement will be limited to the adapt_region overlapping the specified region. If not specified or region <= 0, the full material domain will be refined.

This option may be used multiple times in the same input, once per material to be adapted.


Export Refined Cartesian Grid

Command: adapt_export     Export exodus mesh of refined grid

Input file command:   adapt_export
Command line options: -AE
Command Description:

Export an exodus mesh containing the refined Cartesian grid. Interface reconstruction, boundary layer insertion and smoothing have not yet been applied to this mesh. It is the base mesh used as input to Sculpt. One file per processor will be exported in the form "vfrac_adapt.e.x.x". The exodus mesh produced will also contain the computed volume fractions for each material present in the model represented as element variables.

This option is primarily used for debugging the refinement option. However the mesh produced with this option can be used as the base mesh when used with the input_mesh option. For example, instead of Cartesian grid options, the input mesh may be specified as input_mesh = vfrac_adapt.e.1.0. Sculpt will use the refined mesh and the volume fraction element variables to build the final mesh.


Adapt Cells at Non-manifold Nodes

Command: adapt_non_manifold     Refine at non-manifold conditions

Input file command:   adapt_non_manifold
Command line options: -ANM
Command Description:

If refinement results in a non-manifold condition at a node, the surrounding cells will be identified for refinement. In some cases, using this option will result in a closer match to geometry for thin layers or small features. Using this option will normally result in more elements at material interfaces. Note that in all cases non-manifold conditions will be resolved even without this option in a subsequent step, however without this option, the resulting solution may not match geometry as accurately.

The adapt_non_manifold option is off by default. It is currently only implemented for adapt_type that use an STL geometry definition. (adapt_type = 1,2,3)


Adaptive Parallel Load Balancing

Command: adapt_load_balance     Adaptive parallel load balancing

Input file command:   adapt_load_balance
Command line options: -ALB
Command Description:

Do adaptive load balancing during refinement. Uses Zoltan's Recursive Coordinate Bisection (RCB) algorithm to repartition parallel domains following each adaptive level.

Default (OFF), refinement, will use roughly spatially equal volume domains on each processor. This can cause significant imbalance in work between processors, sometimes causing failure, especially where adpativity is localized. When using adapt_load_balance, Sculpt will repartition the parallel domains after each adaptivity level so that each processor maintains approximetly equal numbers of elements to equalize work and memory among processors.


Write Memory Usage Stats for Adaptivity

Command: adapt_memory_stats     Write memory usage stats for adaptivity

Input file command:   adapt_memory_stats
Command line options: -AMS
Command Description:

When the adapt_type option is enabled, it allows users to monitor the memory usage and availability during the adaptivity procedures. By setting this option, both minimum and maximum memory usage for the current processor arrangement will be recorded. This information can be particularly useful when building meshes with many levels of refinement or when there are significant variations in the spatial distribution of refinement regions.