Cubit
15.8 *User
Documentation*

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.

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.

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

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_export -AE Export exodus mesh of refined grid --adapt_non_manifold -ANM Refine at non-manifold conditions Sculpt Command Summary

Command: adapt_type Adaptive meshing type Input file command: adapt_type <arg> Command line options: -A <arg> Argument Type: integer (0, 1, 2, 3, 4, 5) 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)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:

**off (0):**Cartesian grid is defined only by**nelx**,**nely**, and**nelz**or**cell_size**which is used as the basis for the sculpt mesh. No refinement will be performed.**facet_to_surface (1):**This option will evaluate every location where an edge in the Cartesian grid intersects a triangle of the STL model and measures the closest distance to the approximated geometry. The cells adjacent to intersecting edges where the measured distance is greater than the**adapt_threshold**will be identified for uniform refinement. This is done for each refinement level where a new approximated geometry is then computed based upon the finer resolution grid. The refinement will continue until all measured distances are less than the adapt_threshold, or the maximum number of levels (**adapt_levels**) is reached. This option can only be used if input comes from an STL file. Microstructures and diatoms are currently not supported.

Distance from STL Facet to Approximated Geometry. The distance d is measured between the facets (green) where they cross the edges of the grid, to the closest point on the interpolated geometry. If d > adapt_threshold then the cell is split.

**surface_to_facet (2):** This criteria is similar to **facet_to_surface** (1) except
that the locations selected for sampling are chosen from the vertices
representing the approximated surfaces. The closest distance measured
to any of the facets in the STL model is used as the criteria for
refinement. Those cells at vertices where the distance measured exceeds
the **adapt_threshold** are identified for refinement. This option is
generally faster than 1, but may miss features if the initial resolution
of the grid is too coarse. This option can also only be used if input
geometry comes from an STL file. Microstructures and diatoms are
currently not supported.

Distance from Approximated Geometry to STL Facet. The distance d is measured between points on the interpolated geometry corresponding to a projected point on the grid, to its closest point on one of the STL facets. If d > adapt_threshold then the cell is split.

**surface_to_surface (3):** This criteria will test each cell to compute
the local interpolated surface for the cell and compare with the surface
interpolated for its eight subdivided child cells. If the distance
between these two approximated surfaces is greater the the user defined
**adapt_threshold**, then the cell will be uniformly refined. This
option can be used with STL and diatom input geometry, but not with
Microstructures.

Distance Between Child and Parent Approximated Geometry. After computing the interpolated geometry for level n and level n+1, d is the distance between the two geometry representations. Cells where d > adapt_threshold are split.

**vfrac_average (4):** Each cell of the Cartesian grid is tested
to determine if it should be subdivided into eight cells. The volume
fraction of the parent cell is compared with the average volume fraction
of its eight child cells. If the absolute difference between the average
child volume fraction and its parent volume fraction is greater than the
user defined **adapt_threshold** then the cell is uniformly refined.
The **adapt_threshold** for this case should be a number between 0 and 1.
A smaller number will be more sensitive to changes in geometry, usually
resulting in more refinement at interfaces.

Difference of Cell Volume Fraction. Volume fractions are evaluated for the 8 child cells of a cell at level n. This example shows where one or more of the volume fractions at level n+1 of the lower left cells does not differ by more than a threshold d, so it remains unsplit.

**coarsen (5):** Given a dense set of data on a Cartesian Grid, Sculpt
will begin at a coarse resolution and refine to capture changes in the
data. It uses the adapt_levels option to determine the coarseness of
the initial grid. For example, a dense grid of LxMxN cells will begin
with an initial resolution of L/2^a x M/2^a x N/2^a, where a is the user
defined adapt_levels value. Cells will be identified for refinement if
the volume fraction of any material in a cell is greater than the user
defined **adapt_threshold** and less than 1.0-adapt_threshold. This
option is available only for **input_spn** and **input_micro** formats.
It is most useful for cases where very dense data is initially provided
which would be too fine to serve as an FEA mesh. This method will
effectively coarsen the mesh on the interior and exterior of solids,
but maintain a fine resolution at geometry boundaries.

Refine to Dense Data (Coarsening). Initial grid at resolution N X M is coarsened to N0 X M0 based on the adapt_levels value. Coarse cells are then split similar to criteria in adapt_type = 4.

**vfrac_difference (6):** Each cell of the Cartesian grid is tested
to determine if it should be subdivided into eight cells. The volume
fraction of the parent cell is compared with each of the volume fractions
of its eight child cells. If the absolute difference between any of the
child volume fractions and its parent volume fraction is greater than the
user defined **adapt_threshold** then the cell is uniformly refined.
The **adapt_threshold** for this case should be a number between 0 and 1.
A smaller number will be more sensitive to changes in geometry, usually
resulting in more refinement at interfaces.

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.

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

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

**facet_to_surface (1)****surface_to_facet (2)****surface_to_surface (3)**

For these options, the **adapt_type** selected represents an absolute
distance between surfaces or facets. Where the distance exceeds
**adapt_threshold** the nearby cell or cells will be identified for
refinement. The smaller this number the more sensitive will be the
adaptation and greater the resulting number of elements. If not specified,
the **adapt_threshold** will be determined as follows:

adapt_threshold = 0.25 * cell_size / adapt_levels^2

The **adapt_threshold** value in this case represents the maximum
difference in volume fraction between a parent cell and the average of
its eight child cells. This value should be between 0.0 and 1.0. The
smaller the number, the more sensitive will be the adaptation and the
greater the number of resulting elements. A default **adapt_threshold**
of 0.01 is used if not specified.

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

Command: adapt_levels Number of levels of adaptive refinement Input file command: adapt_levels <arg> Command line options: -AL <arg> Argument Type: integer >= 0Command 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.

Command: adapt_export Export exodus mesh of refined grid Input file command: adapt_export Command line options: -AECommand 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.

Command: adapt_non_manifold Refine at non-manifold conditions Input file command: adapt_non_manifold Command line options: -ANMCommand 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