On this page:
5.4.7 Automatic Scheme Selection
5.4.8 Conversion
5.4.8.1 HTet
5.4.8.2 QTri
5.4.8.3 THex
5.4.8.4 TQuad
5.4.9 Copying a Mesh
5.4.10 Radialmesh
5.4.11 Parallel Meshing
5.4.11.1 Sculpt
5.4.11.1.1.3 Sculpt Process Flow
5.4.11.2 Sculpt Adaptive Meshing
5.4.11.3 Sculpt Application
5.4.11.4 Sculpt Boundary Conditions
5.4.11.5 Sculpt Boundary Layers
5.4.11.6 Sculpt Command Summary
5.4.11.7 Sculpt GUI
5.4.11.8 Sculpt Mesh Improvement
5.4.11.8.1 
5.4.11.9 Sculpt Input Data Files
5.4.11.10 Sculpt Mesh Type
5.4.11.11 Sculpt Output
5.4.11.12 Sculpt Process Control
5.4.11.13 Sculpt Overlay Grid Specification
5.4.11.14 Sculpt Smoothing
5.4.11.15 Sculpt Technical Description
5.4.11.16 Sculpt Mesh Transformation
5.4.11.17 brick1.stl
5.4.11.18 brick2.stl
5.4.11.19 bricks.diatom
5.4.12 Traditional
5.4.12.1 Bias, Dualbias
5.4.12.2 Circle
5.4.12.3 Curvature
5.4.12.4 Equal
5.4.12.5 Hole
5.4.12.6 Mapping
5.4.12.7 Pave
5.4.12.8 Pentagon
5.4.12.9 Pinpoint
5.4.12.10 Polyhedron
5.4.12.11 Quad Dominant
5.4.12.12 Sphere
5.4.12.13 STransition
5.4.12.14 Stretch
5.4.12.15 Stride
5.4.12.16 Submap
5.4.12.17 Surface Vertex Types
5.4.12.18 Sweep
5.4.12.19 Tet  Mesh
5.4.12.20 Tetprimitive
5.4.12.21 Tri  Advance
5.4.12.22 Tri  Delaunay
5.4.12.23 Tri  Map
5.4.12.24 Tri  Mesh
5.4.12.25 Tri  Pave
5.4.12.26 Tri  Primitive
2022.4+26187-e1209cf7 Apr 14, 2022

5.4 Meshing Schemes

Meshing schemes in Cubit can be divided into four broad categories as detailed in the following sections.

If no scheme is selected, Cubit will attempt to assign a scheme using the automatic scheme selection methods.

5.4.1 Traditional Meshing Schemes

Traditional meshing schemes are used to apply a mesh to an existing geometry using the methods described in Meshing the Geometry (i.e. setting a scheme, applying interval sizes, and meshing). Traditional meshing schemes are available for all geometry types.

    

5.4.2 Free Meshing Schemes

Free meshing schemes will create a free-standing mesh without any prior existing geometry. The final mesh will have mesh-based geometry.

5.4.3 Conversional Meshing Schemes

Conversional meshing schemes are used to convert an existing mesh into a mesh of different element type or size. For example, the THex scheme will convert a tetrahedral mesh into a hexahedral mesh.

5.4.4 Duplication Meshing Schemes

Duplication meshing schemes are used to copy an existing mesh from one geometry onto another similar geometry.

5.4.5 Parallel Meshing Scheme

The Sculpt algorithm is an all-hex, automatic, parallel meshing scheme available in the Cubit Pro version.

5.4.6  General Meshing Information

Information on specific mesh schemes available in Cubit is given in this section. The following sections have important meshing-related information as well, and should be read before applying any of the mesh schemes described below.

In most cases, meshing a geometric entity in Cubit consists of three steps:

Mesh {geom_list}

This command will match intervals on the given entity, then mesh any unmeshed lower order entities, then mesh the given entity.

After meshing is completed, the mesh quality is automatically checked (see Mesh Quality Assessment), then the mesh is drawn in the graphics window.

The following table classifies the meshing schemes with respect to their applicable geometry.

Curves

Surfaces

Volumes

Bias/Dualbias

Circle

Copy

Copy

Copy

HTet

Curvature

Mapping

Hole

Polyhedron

Equal

Mapping

Sphere

Pinpoint

Submap

Stretch

Pave

Sweep

Pentagon

TetMesh, TetINTRIA

Polyhedron

Tetprimitive

QTri

THex

Submap

TriDelaunay

Sculpt

Triprimitive

TriMap

TriMesh

TriAdvance

TriPave

STransition

QuadDominant

5.4.7 Automatic Scheme Selection

For volume and surface geometries the user may allow Cubit to automatically select the meshing scheme. Automatic scheme selection is based on several constraints, some of which are controllable by the user. The algorithms to select meshing schemes will use topological and geometric data to select the best quad or hex meshing tool. Auto scheme selection will not select tet or tri meshing algorithms. The command to invoke automatic scheme selection is:

{geom_list} Scheme Auto

Specifically for surface meshing, interval specifications will affect the scheme designation. For this reason it is recommended that the user specify intervals before calling automatic scheme selection. If the user later chooses to change the interval assignment, it may be necessary to call scheme selection again. For example, if the user assigns a square surface to have 4 intervals along each curve, scheme selection will choose the surface mapping algorithm. However if the user designates opposite curves to have different intervals, scheme selection will choose paving, since this surface and its assigned intervals will not satisfy the mapping algorithm’s interval constraints. In cases where a general interval size for a surface or volume is specified and then changed, scheme selection will not change. For example, if the user specified an interval size of 1.0 a square 10X10 surface, scheme selection will choose mapping. If the user changes the interval size to 2.0, mapping will still be chosen as the meshing scheme from scheme selection. If a mesh density is not specified for a surface, a size based on the smallest curve on the surface will be selected automatically.

5.4.7.1  Default Scheme Selection

If the user does not set a scheme for a particular entity and chooses to mesh the entity, Cubit will automatically run the auto scheme selection algorithm and attempt to set a scheme. In cases where the auto scheme selection fails to choose a scheme, the meshing operation will fail. In this case explicit specification of the meshing scheme and/or further geometry decomposition may be necessary.

The default scheme selection in Cubit, unless otherwise set, will attempt to set a quadrilateral or hexahedral meshing scheme on the entity. If tet or tri meshing will always be the desired element shape, the following command can be used:

Set Default Element [Tet|Tri|HEX|QUAD|None]

Setting the default element to tet or tri will bypass the auto scheme selection and always use either the triadvance or tetmesh schemes if the scheme has not otherwise been set by the user. The default settings of quad or hex will use the automatic scheme selection.

Previous functionality of Cubit used a default scheme of map and interval of 1 for all surface and volume entities. For backwards compatibility and if this behavior is still desired, the none option may be used on the set default element command.

5.4.7.2 Auto Scheme Selection General Notes

In general, automatic scheme selection reduces the amount of user input. If the user knows the model consists of 2.5D meshable volumes, three commands to generate a mesh after importing or creating the model are needed.

To automatically calculate the meshing scheme

  1. On the Command Panel, click on Mesh and then Volume.

  2. Click on the Mesh action button.

  3. Enter the appropriate value for Select Volumes. This can also be done using the Pick Widget function.

  4. Select Automatically Calculate from the drop-down menu.

  5. Click Apply Scheme then click Mesh.

volume all size <value>

volume all scheme auto

mesh volume all

The model shown in the following figure was meshed using these three commands (part of the model is not shown to reveal the internal structure of the model).

Figure 227: Non-trivial model meshed using automatic scheme selection

5.4.7.3 Scheme Firmness

Meshing schemes may be selected through three different approaches. They are: default settings, automatic scheme selection, and user specification. These methods also affect the scheme firmness settings for surfaces and volumes. Scheme firmness is completely analogous to interval firmness.

Scheme firmness can be set explicitly by the user using the command

{geom_list} Scheme {Default | Soft | Hard}

Scheme firmness settings can only be applied to surfaces and volumes.

This may be useful if the user is working on several different areas in the model. Once she/he is satisfied with an area’s scheme selection and doesn’t want it to change, the firmness command can be given to hard set the schemes in that area. Or, if some surfaces were hard set by the user, and the user now wants to set them through automatic scheme selection then she/he may change the surface’s scheme firmness to soft or default.

5.4.7.4 Surface Auto Scheme Selection

Surface auto scheme selection (White, 99) will choose between Pave, Submap, Triprimitive, and Map meshing schemes, and will always result in selecting a meshing scheme due to the existence of the paving algorithm, a general surface meshing tool (assuming the surface passes the even interval constraint).

Surface auto scheme selection uses an angle metric to determine the vertex type to assign to each vertex on a surface; these vertex types are then analyzed to determine whether the surface can be mapped or submapped. Often, a surface’s meshing scheme will be selected as Pave or Triprimitive when the user would prefer the surface to be mapped or submapped. The user can overcome this by several methods. First, the user can manually set the surface scheme for the "fuzzy" surface. Second, the user can manually set the "vertex types" for the surface. Third, the user can increase the angle tolerance for determining "fuzziness." The command to change scheme selection’s angle tolerances is:

[Set] Scheme Auto Fuzzy [Tolerance] {value} (value in degrees)

The acceptable range of values is between 0 and 360 degrees. If the user enters 360 degrees as the fuzzy tolerance, no fuzzy tolerance checks will be calculated, and in general mapping and submapping will be chosen more often. If the user enters 0 degrees, only surfaces that are "blocky" will be selected to be mapped or submapped, and in general paving will be chosen more often.

5.4.7.5 Volume Auto Scheme Selection

When automatic scheme selection is called for a volume, surface scheme selection is invoked on the surfaces of the given volume. Mesh density selections should also be specified before automatic volume scheme selection is invoked due to the relationship of surface and volume scheme assignment.

Volume scheme selection chooses between Map, Submap and Sweep meshing schemes. Other schemes can be assigned manually, either before or after the automatic scheme selection.

Volume scheme selection is limited to selecting schemes for 2.5D geometries, with additional tool limitations (e.g. Sweep can currently only sweep from several sources to a single target, not multiple targets); this is due to the lack of a completely automatic 3D hexahedral meshing algorithm. If volume scheme selection is unable to select a meshing scheme, the mesh scheme will remain as the default and a warning will be reported to the user.

Volume scheme selection can fail to select a meshing scheme for several reasons. First, the volume may not be mappable and not 2.5D; in this case, further decomposition of the model may be necessary. Second, volume scheme selection may fail due to improper surface scheme selection. Volume schemes such as Map, Submap, and Sweep require certain surface meshing schemes, as mentioned previously.

5.4.8 Conversion

5.4.8.1 HTet

Applies to: Volumes

Summary: Converts an existing hex mesh into a conforming tetrahedral mesh.

Syntax:

HTet Volume <range> {UNSTRUCTURED | structured}

Discussion:

Unlike other meshing schemes in this section, The HTet command requires an existing hexahedral mesh on which to operate. Rather than setting a meshing scheme for use with the mesh command, the HTet command works after an initial hex mesh has been generated.

Two methods for decomposing a hex mesh into tetrahedra are available. Set the method to be used with the optional arguments unstructured and structured. The unstructured method is the default. Figure 228 shows the difference between the two methods:

Figure 228: Left: Unstructured method creates 6 tets per hex. Right: Structured method creates 28 tets per hex

5.4.8.1.1 Unstructured

This method creates 6 tetrahedra for every hexahedra. No new nodes will be generated. The orientation of the 6 hexahedra will be based upon the element node numbering, as a result orientations may change if node numbering changes. This method is referred to as unstructured because the number of tetrahedra adjacent each node will be relatively arbitrary in the final mesh. Tetrahedral element quality is generally sufficient for most applications, however the user may want to verify quality before performing analysis.

5.4.8.1.2 Structured

With this approach, 28 tetrahedra are generated for every hexahedra in the mesh. This method adds a node to each face of the hex and one to the interior. Although this method generates significantly more elements, the orientation and quality of the resulting tetrahedra are more consistent. Each previously existing interior node in the mesh will have the same number of adjacent tetrahedra.

5.4.8.2 QTri

Applies to : Surfaces

Summary: Meshes surfaces using a quadrilateral scheme, then converts the quadrilateral elements into triangles.

Syntax:

Surface <range> Scheme Qtri [Base Scheme quad_scheme>]

QTri {Surface <range> | Face <range> }

Set QTri Split [2|4]

Set QTri Test {Angle|Diagonal}

Discussion: QTri is used to mesh surfaces with triangular elements. The surface is, first, meshed with the quadrilateral scheme, and, then, the generated quads are split along a diagonal to produce triangles. The first command listed above sets the meshing scheme on a surface to QTri. The second form sets the scheme and generates the mesh in a single step.

In the first command, the user has the option of specifying the underlying quadrilateral meshing scheme using the base scheme <quad_scheme> option. If no base scheme is specified, Cubit will automatically select a scheme. For non-periodic surfaces, the base scheme will be set to scheme pave. For periodic surfaces, the base scheme will be set to scheme map.

Generally, the second command, Qtri Surface <range>, is used on surfaces that have already been meshed with quadrilaterals. If, however, this command is used on a surface that has not been meshed, a base scheme will automatically be selected using CUBIT’s auto-scheme capabilities. The user can over-ride this selection by specifying a quadrilateral meshing scheme prior to using the qtri command (using the Surface <range> Scheme <quad_scheme> command). QTri may also be performed on quadrilateral elements on a surface or a subset of quadrilateral elements on a surface. to split existing quadrilaterals the QTri command can be given a list of faces.

In addition to the default 2 tris per quad, the set qtri split command may alter the QTri scheme so that it will split the quad into 4 triangles per quad. Where the 4 option is used, an additional mesh node is placed at the centroid of each quad.

There are two methods that may be used to calculate the best diagonal to use for splitting the quadrilateral elements: angle or diagonal. The angle measurement uses the largest angle, while the diagonal option uses the shortest diagonal. The largest angle measurement will be more accurate but takes more time.

Also, the QTri scheme is used in the TriMesh command as a backup to the TriAdvance triangle meshing scheme.

Figure 229: Surface meshed with scheme QTri

5.4.8.3 THex

Applies to: Volumes

Summary: Converts a tetrahedral mesh into a hexahedral mesh.

Syntax:

THex Volume <range>

Discussion: The THex command splits each tetrahedral element in a volume into four hexahedral elements, as shown in Figure 230. This is done by splitting each edge and face at its midpoint, and then forming connections to the center of the tet.

When THexing merged volumes, all of the volumes must be THexed at the same time, in a single command. Otherwise, meshes on shared surfaces will be invalid. An example of the THex algorithm is shown in Figure 231.

Figure 230: Conversion of a tetrahedron to four hexahedra, as performed by the THex algorithm.

Figure 231: A cylinder before and after the THex algorithm is applied.

5.4.8.4 TQuad

Applies to: Surfaces

Summary: Converts a triangular surface mesh into a quadrilateral mesh.

Syntax:

TQuad Surface <range>

Discussion: The TQuad command splits each triangular surface element in four quadrilateral elements, as shown in Figure 232. This is done by splitting each edge at its midpoint, and then forming connections to the center of the triangle. The result is the same as using the THex algorithm, but only applies to surfaces. In general it is better to use a mapped or paved mesh to generate quadrilateral surface meshes. However, the TQuad scheme may be useful for converting facet-based triangular meshes to quadrilateral meshes when remeshing is not possible.

Figure 232: A triangle split into 3 quads using the TQuad scheme

5.4.9 Copying a Mesh

Applies to: Curves, Surfaces, Volumes

Summary: Copies the mesh from one entity to another

To copy a mesh on a curve

  1. On the Command Panel, click on Mesh and then Curve.

  2. Click on the Copy/Morph action button.

  3. Enter the values for Source Curve ID(s) and Target Curve ID(s). This can also be done using the Pick Widget function.

  4. Optionally, click on Optional Data to further specify the settings.

  5. Click on Appy Scheme and then Mesh.

The Command Panel GUI is shown below:

Figure 233:

Curve <range> Scheme Copy source Curve <range> [Source Percent [<percentage> | auto]] [Source [combine|SEPARATE]] [Target [combine|SEPARATE]] [Source Vertex <id_range>] [Target Vertex <id_range>]]

Copy Mesh Curve <curve_id> Onto Curve <curve_id_range> [Source Node <starting node id> <ending node id>] [Source Percent [<percentage>|auto]] [Source Vertex <id_range>] [Target Vertex <id_range>]

To copy a mesh on a surface

  1. On the Command Panel, click on Mesh and then Surface.

  2. Click on the Copy/Morph action button.

  3. Using the pickwidgets in the command panel select source and target data.

  4. To force copying of interior vertex loops select the "Interior Vertices" tab and enter in pairs of vertices to be matched when copying.

The Command Panel GUI is shown below:

Figure 234:

Copy Mesh Surface <surface_id> Onto Surface <surface_id> Source Curve<id> Target Curve <id> Source Vertex <id>Target Vertex <id> [Interior (pair vertex <id><id>)...] [smooth] [mirror] [preview]

Surface <id> Scheme copy source surface <id> source curve <id> target curve <id> source vertex <id> target vertex <id> [nosmoothing][mirror]

To copy a mesh on a volume

  1. On the Command Panel, click on Mesh and then Volume.

  2. Click on the Copy/Morph action button.

  3. Enter the values for Source Volume ID(s) and Target Volume ID(s). This can also be done using the Pick Widget function.

  4. Optionally, click on Optional Data to further specify the settings.

  5. Click on Appy Scheme and then Mesh.

The Command Panel GUI is shown below:

Figure 235:

Volume <range> Scheme Copy [Source Volume] <id> [[Source Surface <id> Target Surface <id>] [Source Curve <id> Target Curve <id>] [Source Vertex <id> Target Vertex <id>]][Nosmoothing]

Copy Mesh Volume <volume_id> Onto Volume <volume_id> [Source Vertex <vertex_id> Target Vertex <vertex_id>] [Source Curve <curve_id> Target Curve <curve_id>] [Nosmoothing]

Related Commands:

Set Morph Smooth {on | off}

Discussion: If the user desires to copy the mesh from a surface, volume, curve, or set of curves that has already been meshed, the copy mesh scheme can be used. Note that this scheme can be set before the source entity has been meshed; the source entity will be meshed automatically, if necessary, before the mesh is copied to the target entity. The user has the option of providing orientation data to specify how to orient the source mesh on the target entity. For example, when copying a curve mesh, the user can specify which vertex on the source (the source vertex) gets copied to which vertex on the target (the target vertex). If you need to reference mesh entities for the copy, use the copy mesh commands. If no orientation data is specified, or if the data is insufficient to completely determine the orientation on the target entity, the copy algorithm will attempt to determine the remaining orientation data automatically. If conflicting, or inappropriate, orientation data is given, the algorithm attempts to discard enough information to arrive at a proper mesh orientation.

Curve mesh copying has certain options that allow the copying of just a section of the source curves’ mesh. These options are accessed through the extra keyword options. The percent option allows the user to specify that a certain percentage of the source mesh be copied–in this context the auto keyword means that the percentage will be calculated based on the ratio of lengths of the source and target curves. The combine and separate keywords relate to how the command line options are interpreted. If the user wishes to specify a group of target curves that will each receive an identical copy of a source mesh, then the target separate option should be used (this is the default). If, however, the user wishes the source mesh to be spread out along the range of target curves, then the target combine option should be used. The source curves are treated in a similar fashion.

Surface mesh copying with multiple holes in the surface may require matching up interior pair vertices. This will be required if the algorithm cannot match them up spatially. Interior pair vertices can be specified with the option interior pair vertex ...

Volume mesh copying depends on the surface copying scheme. Because of this, the target volume must not have any of its surfaces meshed already.

An exact copy of the mesh may not always happen. Dissimilar geometry or smoothing may cause inexact copies. If the geometry is similar, the smoothing option may be turned off to get an exact copy of the mesh, by either specifying nosmoothing or by omitting smooth. If the geometry is dissimilar, the user may set the set morph smooth _on, which will activate a special smoother that will match up the meshes as closely as possible. Example: As an example, the following copy is done with the command

copy mesh surf 23 onto surf 14 source curve 1 source vertex 1 target curve 24 target vertex 20

The source and target vertices match up and are highlighted, while the source and target curves match up and are highlighted. Matching the source and target curves/vertices help define the orientation.

Figure 236:

5.4.10 Radialmesh

Creates a free cylindrical mesh with precise node locations based on input radii, angles, and offsets, then creates mesh-based geometry to fit the mesh.

Create Radialmesh \
NumZ <val> [Span <val>] \
Zblock 1 [<offset val>] \
{Interval|Bias|Fraction|First Size} <val> \
[{Interval|Bias|Fraction|Last Size} <val>] \
Zblock 2 [<offset val>] \
{Interval|Bias|Fraction|First Size} <val> \
[{Interval|Bias|Fraction|Last Size} <val>] \
... NumZ \

NumR <val> {Trisection|Initial Radius<val>} \
Rblock 1 <offset radius val> \
{Interval|Bias|Fraction|First Size} <val> \
[{Interval|Bias|Fraction|Last Size} <val>] \
Rblock 2 <offset radius val> \
{Interval|Bias|Fraction|First Size} <val> \
[{Interval|Bias|Fraction|Last Size} <val>] \
... NumR \

NumA <val> [Full360] [Span <val>] \
Ablock 1 [<offset angle val>] \
{Interval|Bias|Fraction|First Angle} <val> \
[{Interval|Bias|Fraction|Last Angle} <val>] \
Ablock 2 [<offset angle val>] \
{Interval|Bias|Fraction|First Angle} <val> \
[{Interval|Bias|Fraction|Last Angle} <val>] \
... NumA

Discussion:

The purpose of the radialmesh command is to create a cylindrical mesh with precise node locations. Unlike all other meshing commands which place nodes using smoothing algorithms to optimize element quality, node locations for the radialmesh command are calculated based on the input radii, angles, and offsets. In addition, the radialmesh command does not mesh existing geometry. Rather, it creates a mesh based on the input parameters, after which a mesh-based geometry is created to fit the free mesh.

The radialmesh command requires input for the 3 coordinate directions (Z, radial, angular). The number of blocks in each direction is specified with the numZ, numR, and numA values in the command. Each block forms a new volume in the final mesh. All bodies in the mesh are merged to form a conformal mesh between blocks.

The Radialmesh command can create meshes which span any angle greater than 0.0 up to 360 degrees. In addition, meshes can model either a tri-section (see Figure 237), or a non-trisection mesh (see Figure 238).

Figure 237: Tri-section Radialmesh

Figure 238: Non-tri-section Radialmesh

The command to generate the mesh in Figure 237 is:

create radialmesh \
numZ 1 zblock 1 1 interval 5 \
numR 3 trisection rblock 1 2 interval 5 \
rblock 2 3 interval 5 \
rblock 3 4 interval 5 \
numA 1 span 90 ablock 1 interval 10

The command to generate the mesh in Figure 238 is:

create radialmesh \
numZ 1 zblock 1 1 interval 5 \
numR 1 initial radius 3 rblock 1 4 interval 5 \
numA 1 span 90 ablock 1 interval 10

A mesh can span an entire 360 degrees by using the "full360" keyword. For example, the mesh in Figure 3 was generated with the following command:

create radialmesh numZ 1 zblock 1 1 interval 5 \
numR 3 trisection rblock 1 1 interval 5 \
rblock 2 2 interval 5 \
rblock 3 3 interval 5 \
numA 5 full360 span ablock 1 interval 5 \
ablock 2 interval 5 \
ablock 3 interval 5 \
ablock 4 interval 5

Figure 239: Radialmesh using full360 option

After the mesh is generated, the radialmesh command fits the mesh with mesh based geometry. The surfaces created to fit the mesh are given special names according to their location on the geometry. To see the names of the surfaces, issue the command label surface name after creating a radialmesh. Also, if you create a tri-section mesh, the edges on the center axis are given names. To see these names issue the command label curve name after creating a trisection Radialmesh.

The user can control the number of intervals and the spacing of these intervals using the optional parameters in each rblock, zblock and ablock. There are 11 combinations that these can be combined as listed below:

Figure 240 shows an example of a bias spaced mesh with the following command:

create radialmesh numZ 2 zblock 1 1 first size 0.2 \
zblock 2 10 first size 0.2 last size 1.0 \
numR 3 trisection rblock 1 1 interval 5 \
rblock 2 2 first size .25 \
rblock 3 5 first size .25 bias 2.0 \
numA 1 span 90 ablock 1 interval 5

Figure 240: Radialmesh created with biased spacing

5.4.11 Parallel Meshing

Cubit has been designed as a serial application, using a single CPU to generate its meshes. In some cases, where memory or time constraints are critical, parallel meshing may be necessary. Cubit currently provides a separate application designed to run in parallel either on a desktop or on massively parallel cluster machines. In these cases, Cubit can be used as a pre-processor to manipulate geometry and set up for meshing, however the actual meshing procedure is performed as a separate process or on another machine.

Sculpt is the separate process mentioned.

5.4.11.1 Sculpt

Sculpt is a separate parallel application designed to generate all-hex meshes on complex geometries with little or no user interaction. Sculpt was developed as a separate application so that it can be run independently from Cubit on high performance computing platforms. It was also designed as a separable software library so it can be easily integrated as an in-situ meshing solution within other codes. Cubit provides a front end command line and GUI for the Sculpt application. The command will build the appropriate input files based on the current geometry and can also automatically invoke Sculpt to generate the mesh and bring the mesh back to Cubit.

5.4.11.1.1 Preparing to Use Sculpt
5.4.11.1.1.1 Platforms

Sculpt is available for Windows, Mac and Linux operating systems.

5.4.11.1.1.2 Sculpt Installation

Sculpt is a stand-alone executable, separate from Cubit. In order for Cubit to start up Sculpt, it must be on your system and accessible to Cubit. The default installation of Cubit should install files in the correct locations for this to occur. Check with Cubit support if it did not come with your installation or you are not able to locate it or any of its supporting applications.

To run Sculpt from Cubit, four executable files are needed:

To view the current path to these executables that Cubit will use, issue the following command from the Cubit command window

Sculpt Parallel Path List

See the Sculpt Parallel Path Command for more info on setting and customizing these paths.

The following image illustrates the process flow when the sculpt parallel command is used in Cubit.

Figure 241:

5.4.11.1.1.3 Sculpt Process Flow

For the Sculpt meshing process, a set of files, including a facet-based stl file are written to disk. The sculpt application is then started up which in turn invokes mpiexec to start up multiple instances of psculpt in parallel. psculpt then performs the meshing and writes one exodus file per processor. These files can then be combined using epu and then imported back into Cubit for viewing.

5.4.11.1.1.4 Setting your Working Directory

When using the Sculpt Parallel command in Cubit, several temporary files will be written to the current working directory. Because of this, it is important to set your working directory before using Sculpt to a desired location where you want these files placed.

5.4.11.1.2 Sculpt Parallel Command

The command syntax for preparing a model for Sculpt is:

   Sculpt Parallel

 

[[volume <ids>] [block <ids>]]

 

[processors <value>]

[fileroot ’<root filename>’]

[exodus ’<exodus filename>’]

[{OVERWRITE|no_overwrite}]

[absolute_path]

[{EXECUTE|no_execute}]

[size <value>|autosize <value>]
 [box {align |

location <options>|expand <value>}]

[smooth <value>]

[csmooth <value>]

[num_laplace <value>]

[max_opt_iters <value>]

[opt_threshold <value>]

[curve_opt_thresh <value>]

[max_pcol_iters <value>]

[pcol_threshold <value>]

[max_deg_iters <value>]

[deg_threshold <value>]

[xintervals <value>]

[yintervals <value>]

[zintervals <value>]

[gen_sideset <value>]

[{void|NO_VOID}]

[void_block <value>]

[stair <value>]

[htet <value>]

[pillow <value>]

[adapt_type <value>]

[adapt_threshold <value>]

[adapt_levels <value>]

[scale <value>]

[xtranslate <value>]

[ytranslate <value>]

[ztranslate <value>]

[{COMBINE|no_combine}]

[{IMPORT|no_import}]

[{SHOW|no_show}]

[{capture|NO_CAPTURE}]

[{CLEAN|no_clean}]

[{gen_input_file <filename>|no_gen_input_file}]

[debug <value>]

The following table is a summary of options that can be invoked from the Cubit sculpt parallel command. It includes an abbreviated description of the option as well as the option’s default. If the option is not explicitly used in the command, the default value listed will be used. The Sculpt option is the corresponding command that can be used in a sculpt input file when sculpt is invoked directly from a terminal window. See Sculpt Application for more information.

Cubit Option

   

Description

   

Default

   

Sculpt Option

volume <ids> | block <ids>

   

List of volumes or blocks to include in the mesh.

   

Volume all

   

stl_file, diatom_file, cubit option

processors <value>

   

Number of processors to use for meshing.

   

4

   

num_procs

fileroot <root filename>

   

Root of file names for output.

   

sculpt_parallel

   

cubit option

exodus <exodus filename>

   

Output Exodus mesh file name

   

<’root filename’>

   

exodus_file

OVERWRITE | no_overwrite

   

Force overwrite of files in directory

   

overwrite

   

cubit option

absolute_path

   

Use absolute path for filenames

   

OFF (relative path)

   

cubit_option

EXECUTE | no_execute

   

Run sculpt or dump input files only

   

execute

   

cubit option

size <value> | autosize <value>

   

Set size of cells in Cartesian grid

   

autosize 10

   

cell_size, cubit option

xintervals <value> yintervals <value> zintervals <value>

   

Number of cells in each coordinate direction in the overlay Cartesian grid

   

automatically computed from size

   

nelx, nely, nelz

box align

   

Automatically align geometry to grid

   

OFF

   

align

box location <options>

   

Define bounds of the Cartesian grid

   

Enclosing bounding box with 2.5 additional cells on each side

   

xmin, ymin, zmin, xmax, ymax, zmax, cubit option

box expand <value>

   

Define Cartesian grid by expansion percentage from a tight bounding box.

   

OFF

   

bbox_expand

smooth <value>

   

Smoothing method for volumes and surfaces

   

1

   

smooth

csmooth <value>

   

Smoothing method for curves

   

5

   

csmooth

num_laplace <value>

   

Number of Laplacian smoothing iterations

   

2

   

laplacian_iters

max_opt_iters <value>

   

Maximum number of parallel Jacobi optimization iterations

   

5

   

max_opt_iters

opt_threshold <value>

   

Stopping criteria for Jacobi optimization smoothing

   

0.6

   

opt_threshold

curve_opt_thresh <value>

   

Metric at which curves are not honored

   

0.1

   

curve_opt_thresh

max_pcol_iters <value>

   

Maximum number of parallel coloring smoothing iterations

   

100

   

max_pcol_iters

pcol_threshold <value>

   

Stopping criteria for parallel color smoothing

   

0.2

   

max_pcol_iters

max_deg_iters <value>

   

Maximum number of degenerate iterations

   

0

   

max_deg_iters

deg_threshold <value>

   

Convert hexes below threshold to degenerates

   

0.2

   

deg_threshold

gen_sidesets

   

Sideset and nodeset generation method

   

0

   

gen_sidesets

void

   

Mesh void

   

OFF

   

mesh_void

void_block

   

Block ID of void mesh

   

0

   

void_mat

stair <value>

   

Generate Stair-step mesh

   

OFF

   

stair

htet <value>

   

Convert hexes below quality threshold to tets

   

-1

   

htet

pillow <value>

   

Set pillowing criteria

   

0

   

pillow

adapt_type <value>

   

Adaptive meshing type

   

0

   

adapt_type

adapt_threshold <value>

   

Threshold for adaptive meshing

   

0.25 * cell_size / adapt_levels^2

   

adapt_threshold

adapt_levels <value>

   

Number of levels of adaptive refinement

   

2

   

adapt_levels

scale <value>

   

Scale mesh by factor

   

1.0

   

scale

xtranslate <value> ytranslate <value> ztranslate <value>

   

Translate mesh in coordinate directions

   

0.0

   

xtranslate, ytranslate, ztranslate

COMBINE | no_combine

   

Combine Exodus mesh files into a single mesh for import

   

combine

   

cubit option

IMPORT | no_import

   

Import the mesh after mesh generation in Sculpt

   

import

   

cubit option

SHOW | no_show

   

Echo the ouput of Sculpt to command line window

   

show

   

cubit option

capture | NO_CAPTURE

   

Project boundary nodes to STL geometry (beta feature)

   

no_capture

   

capture

CLEAN | no_clean

   

Delete temporary files generated during Sculpt run

   

clean

   

cubit option

gen_input_file <file name> | no_gen_input_file

   

Generate a Sculpt input file with current settings

   

gen_input_file

   

cubit option

debug <value>

   

Set a debug processor for debugging

   

-1

   

cubit option

5.4.11.1.3 Controlling the Execution of Sculpt

The following command options can be used to control the execution of Sculpt from within Cubit and can be used with the sculpt parallel command. Follow the links above for others not lsted here.

volume <ids> | block <ids> List of volumes or blocks to include in the mesh. One file containing a faceted representation (STL) per volume will be generated and saved in the current working directory to be used as input to Sculpt. Each volume will be treated as a separate material within sculpt and a conforming mesh will be generated where volumes touch. If the Block command is used, one file per block will be used. Each block represents a separate material in Sculpt.

fileroot <root filename> Root of file names for output. When the sculpt parallel command is executed, Cubit will generate multiple files in the working directory used for input to the Sculpt application. The ’<root filename>’ will be used as the basis for naming these files.

OVERWRITE | no_overwrite By default, Cubit will overwrite an existing set of files with the same ’<root filename>’. To over-ride, use the no_overwrite option.

absolute_path By default, Cubit will write the relative path names of files used in the .run and .diatom files. To force absolute path names to be written, use the absolute_path option.

EXECUTE | no_execute By default, Cubit will attempt to run sculpt in parallel on the machine Cubit is currently running on. To generate just the required input to run Sculpt at a later time or on another machine, use this option. A file of the form <root filename>.run will be generated in the current working directory. (for example "model.run"). Executing the .run file from the linux command line should run sculpt in parallel. It can also be used to run sculpt on a cluster where a Cubit executable may not be available.

size <value> | autosize <value> The size option is the absolute cell size for the Cartesian grid and is the same as the cell_size option in sculpt. The autosize option is a value between 0 and 10. It represents a model independent size where 1 is the small size and 10 is large. This is the same scaling factor used in Cubit’s auto sizing but is divided by ten. A size value will be computed from the selected autosize and used as the absolute cell size for the base Cartesian grid.

box location <options> location options define the bounds of the Cartesian grid. The first Location <option> defines the minimum Cartesian coordinate of the grid and the second, the maximum. The <options> can be any valid method for defining a coordinate location in cubit. In most cases the position option can be used. The default is computed as an enclosing bounding box with 2.5 additional cells on each side.

COMBINE | no_combine If the no_combine option is used, following execution of Sculpt, the resulting exodus meshes will not be combined using the epu seacas tool. Otherwise the default will automatically combine the meshes generated by each processor into a single mesh. Note that epu should be installed on your system and the path to epu defined using the sculpt parallel path command. Epu is a code developed by Sandia National Laboratories and is part of the SEACAS tool suite. It combines multiple Exodus databases produced by a parallel application into a single Exodus database. The epu program should be included with distributions of Cubit beginning with Version 15.0.

IMPORT | no_import If the no_import option is used, following execution of Sculpt, the result will be not be imported into Cubit as a free mesh. The default IMPORT option will automatically import the mesh that was generated in Sculpt. If the no_combine option has been used, then multiple free meshes will be imported with duplicate nodes and faces at processor domain boundaries. Otherwise a single free mesh, the result of the epu code, will be imported. Note that the resulting mesh will not be associated with the original geometry, however Block (material) definitions will be maintained. In addition, a separate group will be generated for each imported mesh (One per processor). The default will automatically import the mesh following mesh generation in Sculpt.

SHOW | no_show If the no_show option is used, while the external Sculpt process is running, no ouput from the Sculpt application will be displayed to the command window. Otherwise, the default SHOW is used and output from the Sculpt application will be echoed to the Cubit command window. This option is only effective if the no_execute is not used.

CLEAN | no_clean If the clean option is used, temporary files generated during the sculpt parallel command will be deleted. This includes any exodus mesh files, .stl, .diatom, .log and .run files. The default for this option is CLEAN, therefore, use the no_clean option to keep any temporary files generated as part of the current Sculpt run.

gen_input_file <file name> | no_gen_input_file An input file with the given file name will be generated when the command is executed. This is a text file containing all sculpt options used in the command. The input file is intended to be used for batch execution of sculpt. To run sculpt from the operating system command line you would use the -i option. For example: sculpt -i myinputfile.i -j 4 where myinputfile.i is the name of the input file specified with the gen_input_file option and -j 4 is the number of processors to use.

debug <value> The debug option is used only as a developer debugging tool. It will set the debug processor and sleep upon execution to allow a debugger to be attached to the process.

5.4.11.1.4 Sculpt Parallel Path Command

The command for letting Cubit know where the Sculpt and related applications are located is:

Sculpt Parallel Path [List|Psculpt|Epu|Mpiexec]

This command defines the path to psculpt, epu and mpiexec on your system. In most cases, however, these paths should be automatically set provided Sculpt was successfully installed with your Cubit installation. The

list

option will list the current paths that Cubit will use for these tools. If an alternate path to these executables is desired, it is recommended that this command be used in the .cubit initialization file so that it wont be necessary to define these parameters every time Cubit is run.

5.4.11.1.5 Sculpt Mesh Quality Control

In most cases, the Sculpt tool can be used without adjusting default values. Depending on the characteristics of the geometry to be meshed, the default values may not yield adequate mesh quality. Upon completion, Sculpt reports to the command line, a summary of the mesh that was generated. This includes a summary of the mesh quality. Care should be taken to review this summary to ensure the minimum mesh quality is in a range suitable for analysis.

The element metric used for computing mesh quality in Sculpt is the Scaled Jacobian. This is a value between -1 and 1 that is a relative measure of the angles at the element’s nodes. A value of 1 indicates a perfect 90 degree angle between each of its edges. In most cases a value less than zero, or negtive Jacobian element, indicates an unusable mesh. Sculpt’s default settings try to achieve a minimum Scaled Jacobian of 0.2, which is normally usable in most analysis. The following discussion provides several options for adjusting the model or Sculpt parameters to help improve mesh quality.

  1. Locating poor mesh quality: When the Sculpt mesh has been imported back into CUBIT it is a good idea to display the element quality. You can do this with variations of the following commands:

    quality hex all scaled jacobian
     quality hex all draw mesh

  2. Identify regions where hexes are poor quality and zoom in to these regions.

  3. Modifying the geometry: Zooming in to poor quality elements may reveal that the mesh does not adequately represent the underlying geometry. In some cases you may find that small features, or small gaps between parts may be on the order of the size of the Sculpt cell size. If these features are not important to the analysis, you may consider using Cubit’s geometry modification tools to remove features or close small gaps.

  4. Modifying the cell size: In cases where small geometric features or gaps are important to the simulation, it may be necessary to use a smaller base cell size. Use the size or autosize input parameters or increase the numbers of intervals. Normally to adequately capture a feature you would want the cell size to be no greater than about 1/3 to 1/2 the size of the smallest feature you would want to represent in the simulation.

  5. Turning on Pillowing for multiple materials: For models that have more than one material that share an interface, unless the geometry is precisely aligned with the global axis, it is usually a good idea to turn on pillowing. Pillowing automatically inserts an additional layer of hexes at interface boundaries to improve mesh quality. Without pillowing may notice inverted or poor quality elements at curve interfaces where 2 or more materials meet.

  6. Modifying smoothing parameters: Sculpt includes a tiered approach to smoothing to improve element quality. It starts by applying smoothing to all nodes in the mesh and progressively restricts the smoothing operations to only those nodes that fall below a user-defined scaled Jacobian threshold. Default numbers of iterations and thresholds for each smoothing phase have been tuned for general use, however it may be worthwhile to adjust these parameters. The three smoothing phases include: Observing the mesh quality output to the command line following each smoothing iteration can provide some insight on the effect of modifying smoothing parameters.
    • Laplacian Smoothing: Applied to all elements. Very inexpensive fast approach to improve quality, but can result in degraded element quality if applied to excess. A fixed default of 2 iterations is applied to all hexes. Increasing the num_laplace parameter can improve some cases, especially convex shapes

    • Optimization Smoothing: Applied only to elements who’s scaled Jacobian falls below the opt_threshold parameter (default 0.6) and their surrounding elements. This approach uses a more expensive optimization technique to improve regions of elements simultaneously. The max_opt_iters parameter can control the maximum number of iterations applied (default is 5). Iterations will terminate, however, if no further improvement is detected. Because this method optimizes node locations simultaneously, neighboring nodes with competing optimum can sometimes limit mesh quality.

    • Spot Optimization: Also known as parallel coloring, is applied only to elements who’s element quality falls below the pcol_threshold parameter (default 0.2). This technique is the most expensive of the techniques, but focusses only on nodes that are immediately adjacent to poor quality hexes. Each node is smoothed independently of its neighbors, and may require a high number of iterations using the max_pcol_iters to achieve desired results. Increasing the pcol_threshold and max_pcol_iters may yield improved results.

  7. Creating degenerate hexes: Some geometries will not permit a usable mesh with a traditional all-hex mesh. Sculpt includes the option to automatically and selectively collapse element edges to improve low-quality elements. The max_deg_iters and the deg_threshold values are used to control the creation of degenerates. Degenerate elements are treated as standard hex elements, but use repeated nodes in the eight-node connectivity array.

  8. Creating hex-dominant mesh Another option for avoiding mesh quality issues is to generate a few tet elements in the mesh using the htet option. With this option you can specify a scaled Jacobian threshold value below which hexes will be converted to tet elements. The interface between hex and tet elements is managed by an automatically defined set of nodesets and sidesets that describe where multi-point constraints will be applied.

  9. Defeaturing The defeature option does an initial filter on the cells of the base grid and attempts to reassign the material ID for cells that meet certain criteria. These are cases where a small grouping of cells form a small volume, or where protrusions exist that would otherwise be difficult or impossible to mesh with good quality elements. By reassigning the cells in these locations, in many cases it will allow the mesh to be acceptable. This operation may result in small changes to the boundary or surface definitions, however usually small enough to still be a reasonable approximation.

5.4.11.1.6 Sculpt Examples

The following examples use this simple geometry. Execute these commands prior to performing the example Sculpt Parallel command line operations

sphere rad 1
 sphere rad 1
 vol 2 mov x 2
 cylinder rad 1 height 2
 vol 3 rota 90 about y
 vol 3 mov x 1
 unite vol al

Figure 242: Geometry created from the above commands and used for the following examples.

5.4.11.1.6.1 Basic Sculpt

This example illustrates use of Sculpt with all default options. So that we can view the result, we will also use the overwrite, combine and import options.

sculpt parallel
 draw block all

The result of this operation is shown in Figure 243. For this example, behind the scenes, Cubit built an input file for Sculpt, ran it on 4 processors, combined the resulting 4 meshes, and subsequently imported the resulting mesh into Cubit. Note that Volume 1 remains "unmeshed" and we have created a free mesh that is not associated with a volume. The result of any Sculpt command is always an unassociated free mesh.

Figure 243: Free mesh generated from sculpt command

5.4.11.1.6.2 Size and Bounding Box

This example illustrates the use of the size and box options

delete mesh
 sculpt parallel size 0.1 box location position -1.5 0 -1.5 location position 1 1.5 0
 draw block all

In this case we have used the size option to define the base cell size for the grid. We have also used the box option to define a bounding box in which the mesh will be generated. Any geometry falling outside of the bounding box is ignored by Sculpt. Figure 244 shows the mesh generated with this command.

Figure 244: Sculpt "box" option limits the extent of the generated mesh.

5.4.11.1.6.3 Meshing the Void

In this example we illustrate the use of the void option:

delete mesh
 sculpt parallel size 0.1 box location position -1.5 0 -1.5 location position 1 1.5 0 void
 draw block all

The result is shown in figure 4. Notice that this example is precisely the same as the last with the exception of the addition of the void option. Mesh is generated in the space surrounding the volume out to the extent of the bounding box. In this case, an additional material block is defined and automatically assigned an ID of 2. The nodes and element faces at the interface between the two blocks are shared between the two materials.

Figure 245: Sculpt "void" operation generates mesh outside the volume.

5.4.11.1.6.4 Automatic Sideset Definition

In this example we illustrate the use of the sideset option.

Generating sidesets on the free mesh with Cubit: Sideset boundary conditions can be manually created on the resulting free mesh from Sculpt using the standard sideset <sideset_id> face <id_range> syntax. The group seed command is also useful in grouping faces based on a feature angle to be used in a single sideset.

Generating sidesets in Sculpt: Sculpt also provides several options for defining sidesets as part of the Sculpt run. The following illustrates one option:

delete mesh
 sculpt parallel size 0.1 box location position -1.5 0 -1.5 location position 1 1.5 0 void sideset 2
 list sideset all
 draw sideset all

Once again we use the same syntax but add the sideset 2 option to automatically generate a series of sidesets. The list command should reveal that 10 sidesets were defined for this example with IDs 1 to 10. Figure 246 shows the result of the draw command showing all of the sidesets in different colors. Note that for the sideset 2 option, sidesets are created with the following criteria:

See the sideset option above for a description of other options for generating sidesets in Sculpt.

Figure 246: Automatic sidesets created using Sculpt

5.4.11.1.6.5 Running Sculpt Stand-Alone

This example illustrates how to set up the files necessary to run Sculpt as a stand-alone process. This can be done on the same desktop machine or moved to a larger cluster machine more suited for parallel processing.

Begin by setting your working directory to a location that is convenient for placing example files

cd "path/to/my/sculpt/examples"

Next we issue the basic sculpt parallel command to mesh the volume

delete mesh
 sculpt parallel processors 8 fileroot "bean" over no_execute

In this case, we used the no_execute option which does not invoke the Sculpt application. Instead it will write a series of files to the working directory. The fileroot option defines the base file name for the files that will be written; in this case "bean". We also use the processors option to set the number of processors to be used to 8.

To see the files that Cubit placed in the working directory, bring up a terminal window on your desktop and change directories to the current working directory (ie. cd path/to/my/sculpt/examples). A directory listing should reveal 3 files as shown in Figure 247.

Figure 247: Directory listing of files written from Cubit

The following describes the purpose of each of the resulting files:
  • bean.diatom: Diatoms is a file format used by Sandia’s CTH and Alegra analysis programs that includes a rich constructive solid geometry definition. A series of directives for constructing and orienting primitives to build a complete solid model can be used. Included in the Diatom description is an STL import option. While any standard Diatom description may be used as input to Sculpt, for Cubit’s purposes, only the STL option is used. This file contains a listing of all STL files that will be used as input to Sculpt.

  • bean.run: The .run file contains the unix command line for running sculpt. Note that the file permissions have been set to execute to allow this file to be used as a unix script. Figure 248 shows the .run file for this example. Note that the command uses mpiexec and the psculpt executables, along with their full path. These paths may need to be edited when running on a different machine. It also includes the default parameters for setting the sizes, bounding box and smoothing parameters that have been computed by Cubit.

Figure 248: Unix command line for running Sculpt generated by Cubit

To run sculpt on the same machine, from the terminal window in your current working directory you would issue the following command:

./bean.run

If Sculpt is to be run on a different machine, copy the files in the working directory to the other machine and issue the same command. Remember to change the path to the mpiexec and psculpt executables to match those on the new machine. For running on cluster machines that have scheduling of resources, check with your system administrator for how to submit a job for running.

After running Sculpt, Figure 249 shows the resulting files that would be written to the current working directory.

Figure 249: 8 Exodus files were generated and placed in working directory

Note that 8 exodus files have been generated, 1 from each processor. These files can be used by themselves or used as-is for use in a simlation, or they can be combined into a single file. The exodus files produced by Sculpt include all appropriate parallel communication information as defined by the Nemesis format. Nemesis is an extension of Sandia’s Exodus II format that also includes appropriate parallel communication information.

To combine the resulting exodus files into a single file, we can use the epu tool. Epu should be included in your Cubit distribution, but may require you to set up appropriate paths for it to be recognized. To run epu on this model, use the following command from a unix terminal window:

epu -p 8 bean.diatom_result

The result should be a single file with the name bean.diatom_result.e. The mesh in this file can then be imported into Cubit. Switch back to your Cubit application and from the command line type the following command:

import mesh "bean.diatom_result.e" no_geom

The result should be the same mesh we generated previously that is shown in Figure 243.

5.4.11.1.6.6 Meshing Multiple Materials With Sculpt

This example illustrates using Sculpt to mesh models with multiple materials. To begin with, we will modify our current model by adding some additional volumes. Use the following commands:

delete mesh
 cylinder rad 0.5 height 3
 cylinder rad 0.5 height 3
 vol 5 mov x 2

The resulting geometry should look like the image in Figure 250.

Figure 250: Geometry used to demonstrate multiple materials with Sculpt

Use this geometry to generate a mesh using Sculpt.

sculpt parallel size 0.075
 draw block all

The resulting mesh should look like the image in Figure 2420.

Figure 251: Mesh generated on multiple materials

Notice that one mesh block per volume was created. We should also note that no boolean operations were performed prior to building the mesh with Sculpt. In fact, volumes 4 and 5 were significantly overlapping volume 1. This would be an invalid condition for normal Cubit meshing operations. Figure 2421 shows a cut-away image of the mesh using the Clipping Plane tool.

Figure 252: Cut-away of mesh generated on multiple materials

We should also note that imprint/merge operations typically needed, were also not required. While it is usually best to avoid overlaps to avoid ambiguities in the topology, Sculpt is able to generate a mesh giving precedence to the most recently defined materials. Merging is performed strictly by geometric proximity. Volumes closer than about one half the user input size will normally be automatically merged.

Next, we will examine the mesh quality of the free mesh. The following command will display a graphical representation of the Scaled Jacobian metric.

quality hex all scaled jacobian draw mesh

The result is shown in Figure 2422. Note the elements (colored red) at the interface between materials are unacceptable for simulation. This is caused by the Sculpt algorithm projecting nodes to a common curve interface shared by the materials.

Figure 253: Mesh quality of multi-material mesh.

In most cases, the poor element quality at material interfaces can be improved by using the pillow option. Adding this option will direct Sculpt to add an additional layer of elements surrounding each surface. To see the result of pillowing, issue the following commands:

delete mesh
 sculpt parallel size 0.075 over combine import pillow 1
 quality hex all scaled jacobian draw mesh

Figure 254: Mesh quality of multi-material mesh using pillow option

The resulting mesh is showed in Figure 2423. Note the improved mesh quality at the shared curve interface. A closer look at the mesh, shown in Figure 2424. reveals the additional layer of hexes surrounding each surface that allows for improved mesh quality when compared with Figure 2421. When generating meshes with multiple materials that must share common interfaces, the pillow option is usually recommended.

Figure 255: Cutaway of mesh reveals the additional layer of hexes surrounding each surface when the pillow option is used.

5.4.11.2 Sculpt Adaptive Meshing