The workflow for fatigue crack propagation with adaptive remeshing is based on
well-established Abaqus/Standard fracture/fatigue technology in conjunction with tetrahedral element–based adaptive
remeshing technology.
The workflow assumes a preexisting seam crack in the structure. It is semi-automated and
involves automatic execution of a series of successive Abaqus/Standard analyses with progressively longer crack lengths, without requiring any direct user
intervention. Each Abaqus/Standard analysis subjects the cracked structure to a complete load cycle. The workflow makes
use of extrapolation techniques, which removes the need to model every single load
cycle.
You can use the capability only for linear elastic fatigue crack growth analysis; state
mapping between any two successive Abaqus/Standard analyses is not necessary.
You can use Abaqus/CAE to create the initial model with the preexisting crack (seam). However, you must use
an Abaqus/Standard input file to define the fatigue crack propagation with adaptive remeshing workflow.
For more information, see Creating a seam.
The general workflow for performing a fatigue crack growth analysis with adaptive
remeshing is as follows:
Prepare the model.
Create a model containing a single seam crack.
Partition the overall domain into adaptive and (optionally)
nonadaptive subdomains.
The adaptive domain must contain the seam
crack. The mesh in the adaptive remeshing is updated
automatically following each Abaqus/Standard analysis.
Mesh the adaptive subdomain with second-order tetrahedral
(C3D10) elements with
a refined, but otherwise unstructured, mesh around the crack
front.
The optional nonadaptive subdomain can include any of
the stress/displacement elements available in the Abaqus/Standard element library.
Define a surface-based tie constraint between the adaptive and the
nonadaptive subdomains.
Ensure that the model (Abaqus input file) does not contain any parts and assemblies.
If you create the model in Abaqus/CAE, write out an Abaqus/Standard input file without parts and assemblies.
Launch the fatigue crack growth with adaptive remeshing workflow.
Abaqus/Standard computes the new crack front by performing a series of fatigue
calculations that are based on the current crack front. Each set of
calculations constitutes an increment of crack growth.
For a given crack length, Abaqus/Standard computes the energy release rates or the stress intensity factors
at each node along the crack front.
Using these quantities Abaqus/Standard calculates the updated (due to crack growth) locations of the
crack front nodes and the number of load cycles required to reach
this state from the beginning of the analysis.
After each increment of crack growth, Abaqus/Standard uses the tetrahedral element–based adaptive remeshing technology
to create a new mesh that accommodates the updated crack front.
It also automatically creates a new Abaqus/Standard model with an updated (“longer”) crack.
Abaqus/Standard then uses this new model to continue the fatigue crack growth
calculations by essentially repeating Step 3 above.
This process continues until either:
the maximum number of cycles that you specified is reached,
the structural component has completely lost its load carrying
capacity, or
the crack front reaches the adaptive domain boundary (assuming both
adaptive and nonadaptive domains exist).
Figure 1
shows the initial mesh (left) of a structure with a crack, as well as a new mesh
(right) of the same structure with a longer crack. The new mesh is more refined
around the current crack front, while it is less refined in the wake of the
crack.Figure 1. Use of adaptive remeshing to generate a new mesh that conforms to the
updated crack front as the crack propagates.
Figure 2 outlines
the different phases of the workflow. Figure 2. Phases of the fatigue crack growth analysis with adaptive remeshing
workflow.
Preparing Your Model for Adaptive Remeshing
You must define the initial model using the Abaqus/Standard input file interface (see Input Syntax Rules), and the
model must not contain any parts and assemblies. You can use Abaqus/CAE to create the model and write an input file for the model.
In general, the model should consist of two subdomains:
an adaptive subdomain containing the crack, and
a nonadaptive subdomain for the rest of the model.
The initial mesh in the adaptive domain must contain a refined mesh with
several layers of second-order tetrahedral elements around the crack front. You must
ensure that the mesh along the crack front is refined sufficiently to capture the
large gradients expected in the vicinity of a sharp crack front. Abaqus/Standard uses the averaged element length along the initial crack front to define the
seeds for the local mesh refinements around the updated crack front during each
adaptive remeshing.
Activating the Adaptive Remeshing Capability and Identifying the Adaptive
Subdomain in a Model
A typical model for this workflow consists of an adaptive and (optional)
nonadaptive subdomains. To illustrate the approach for selecting the subdomains,
refer to the example below that represents a quarter model of a thermal ring
(Figure 3). This model consists of an inner hub containing a crack that grows during
the analysis and an outer rim that either does not have any crack or has a
stationary crack (that is, a crack that will not grow during the analysis). In
this example, you should define the inner hub as the adaptive subdomain, and you
should treat the outer rim as a nonadaptive subdomain.Figure 3. A model containing an adaptive subdomain and a nonadaptive
subdomain.
You must identify the adaptive subdomain in the model by associating the adaptive
remesh definition with the appropriate element set.
Input File Usage
Use the following option to identify the adaptive domain in the
model:
Retaining Mesh/Mesh Geometric Entities for Load and Boundary Condition
Considerations
During adaptive remeshing, Abaqus/Standard needs to preserve the element sets, node sets, and surfaces that are part of the
adaptive subdomain and are involved in the application of loads, boundary
conditions, constraints, nodal transformation, section definitions, etc. To enable
this, you must explicitly specify the entities (sets and surfaces) that must be
preserved or retained. Following each instance of adaptive remeshing, Abaqus/Standard updates the members of these sets and/or surfaces and recreates the relevant Abaqus/Standard options and the corresponding data in the new model. In the (optional)
nonadaptive subdomain, all options remain unchanged in the updated models following
each instance of remeshing.
Tracking the Sets and Surfaces in the Adaptive Domain
To illustrate the requirements for preserving mesh and geometric entities, such
as sets and surfaces, refer to the examples below. The first example models a
semi-elliptical crack in a rig subjected to internal pressure loading (see Figure 4). The second
example models a single-edge crack panel, which requires three separate section
definitions, as shown in Figure 5. The numeric labels superposed on the figures below
summarize the mesh/mesh geometric entities that need to be preserved.Figure 4. A semi-elliptical crack in a rig subjected to internal
pressure. Figure 5. A single edge crack panel with multiple section definitions
Updated node sets for applying (symmetry) boundary conditions
Updated node sets along the crack front for contour integral
calculations
Updated element facets for applying the internal pressure loading
Updated element facets on the crack faces for enforcing contact
constraints
Updated element set for each of the section definitions
Updated node sets with discrete nodes for applying boundary
conditions
Specifying the Retained Sets and Surfaces in the Adaptive Subdomain of the
Model
Based on the requirements outlined above, you must specify the mesh and geometry
entities in the adaptive domain that need to be preserved after each remeshing
operation. Depending on your model, you might need to preserve:
One or more node sets, each containing a group of discrete nodes; this
approach is necessary for prescribing boundary conditions, or
concentrated loads, or constraints, and/or requesting output.
For example, in Figure 5, boundary conditions are applied to the
discrete corner nodes. The geometric locations of the nodes in the node
set are preserved during remeshing, although the individual node numbers
(labels) in the updated mesh might be different after each remeshing
operation.
One or more element sets; this approach is necessary to identify the regions
(volumes) for different section definitions, as illustrated in Figure 5; to
apply volume-based loads, such as gravity; to apply node-based constraints
(multi-point constraints, displacement boundary conditions); and to request
node-based output on a cloud of nodes over a certain volume.
One or more surfaces; this approach is necessary for the application of
surface-based constraints and distributed loads, and it is necessary to
associate mesh entities (node sets) to mesh geometry entities
(edges/surfaces) in the adaptive subdomain, as illustrated in Figure 4.
You can retain multiple node sets, element sets, and surfaces in the adaptive
subdomain simultaneously.
Input File Usage
Use the following option to identify the node sets (containing a group of
discrete nodes) to be retained:
ADAPTIVE REMESH RETAIN, TYPE=POINTList of node set labels in the adaptive subdomain that need to be reconstructed after remeshing
Use the following option to identify the element sets to be
retained:
ADAPTIVE REMESH RETAIN, TYPE=VOLUMEList of element set labels in the adaptive subdomain that need to be reconstructed after remeshing
Use the following option to identify the surfaces to be retained:
ADAPTIVE REMESH RETAIN, TYPE=SURFACEList of user-defined surface labels in the adaptive subdomain that need to be reconstructed after remeshing.
Establishing a Relationship between a Mesh Entity with a Mesh Geometry Entity in the
Adaptive Subdomain
In the discussion that follows, the term mesh entity refers to a node set, while the
term mesh geometry entity refers to a surface or an edge.
While you can retain the discrete geometric points associated with a node set
directly, you should minimize the use of such an approach to provide maximum
flexibility to the remeshing algorithm.
As an extreme example, if you were to retain all the node sets (containing all nodes
in the model) directly, there would be no changes to the mesh topology during
adaptive remeshing. Therefore, you should retain node sets containing a few discrete
nodes only to apply boundary conditions, loads, constraints, and/or to request
output. If you want to apply boundary conditions or constraints to an edge or a
surface, it is recommended that you retain the edge or the surface directly, rather
than retaining the corresponding node sets. You can define a surface-based node set
to associate mesh entities (node sets) with the retained mesh geometry entities
(surfaces or edges). After remeshing, Abaqus/Standard transfers loads, constraints, boundary conditions, and other prescribed
conditions automatically from the old mesh to the new mesh using a geometry
attachment approach.
Input File Usage
Use the following option to define a surface-based node set:
You can specify the name of a previously defined surface (About Surfaces), in
which case the nodes on the surface are assigned to the specified node set. You
can use this method to define sorted node sets only.
Loads and Boundary Conditions in the Adaptive Subdomain
Within the adaptive subdomain, you cannot apply loads, constraints, nodal
transformations, boundary conditions, other prescribed conditions, or request output
using individual node or element labels directly because Abaqus/Standard modifies the node and element labels after each remeshing operation. Instead, you
must specify such attributes on mesh or geometric entities such as node sets,
element sets, and surfaces. The mesh or geometric entities must be preserved during
adaptive remeshing, although the set members are updated after each remeshing
operation.
There are no restrictions on applying loads, boundary conditions, or other prescribed
conditions in the nonadaptive subdomain.
Applying Boundary Conditions on an Edge or Surface Using the Geometry
Attachment Approach
The geometry attachment approach is typically used
to apply loads, constraints, nodal transformation, boundary conditions, and
other prescribed conditions. It is also used to request output at all the nodes
on an edge or a surface.
In this approach, the nodes on an edge or a surface are considered soft entities.
The remeshing algorithm preserves the shape of the underlying mesh geometric
entity (that is, an edge or a surface), but the mesh density is allowed to
change. An example of this involves the application of boundary constraints to
an entire surface or edge in the adaptive domain of the model, as illustrated in
Figure 6.
Figure 6. Boundary conditions applied to the bottom surface and the upper right
edge of the model. In this case, the node sets are associated with either an entire edge or
an entire surface. The edge and the surface can be defined using either a
node-based surface definition or an element-based surface definition. The two
mesh geometric entities shown in Figure 6
(the upper right edge and the bottom surface) are preserved and carried over to
the new mesh after remeshing. In this example, Abaqus/Standard updates the members of the node sets on both the edge and the surface based
on the new mesh after each remeshing operation.
With the geometry attachment approach for applying boundary conditions on an edge
or a surface, you must first identify the edge or the surface that must be
retained after remeshing (see Specifying the Retained Sets and Surfaces in the Adaptive Subdomain of the Model). Then, you must define the node sets corresponding to these geometric
entities using the surface-based node set definition method discussed earlier.
This node set contains all the nodes forming an edge already defined with the
node-based surface definition, and/or it contains all the nodes forming the
surface already defined with the element-based surface definition. You then
apply the boundary conditions to such node sets in the usual manner. When you
specify a node-based surface definition, you must use an unsorted node set. Abaqus/Standard lists the members of an unsorted node set in order from one end of the edge
to the other end of the edge.
Input File Usage
Use the following options to apply boundary conditions to the upper right
edge as illustrated in Figure 6:
NSET, NSET=top_edgeN, UNSORTEDList of nodes in order from one end of the edge to the other end of the edge SURFACE, TYPE=NODE, NAME=top_edgeStop_edgeNADAPTIVE REMESH RETAIN, TYPE=SURFACEtop_edgeSNSET, NSET=nset_top_edge, SURFACE=top_edgeSNo data lines neededBOUNDARYnset_top_edge,1,3
Use the following options to apply boundary conditions to the bottom
surface as illustrated in Figure 6:
SURFACE, TYPE=ELEMENT, NAME=bot_surfaceSList of element facets and face identifiers at the bottom surfaceADAPTIVE REMESH RETAIN, TYPE=SURFACEbot_surfaceSNSET, NSET=nset_bot_surface, SURFACE=bot_surfaceSNo data lines neededBOUNDARYnset_bot_surface,1,3
Applying Boundary Conditions on Discrete Nodes Using the Defined Set
Approach
The defined set approach is typically used to define loads, constraints, and
boundary conditions on a group of a few individual discrete nodes with fixed
geometric locations in the adaptive subdomain of the model. They are considered
as hard entities. These nodes must be retained to ensure that they are preserved
after remeshing.
An example of the application of boundary conditions at a few points in the model
is illustrated in Figure 7.
Figure 7. Boundary conditions applied to the vertices of a model. In this case, you must retain one or more node sets containing these
discrete nodes. After remeshing, Abaqus/Standard preserves the geometric location of each individual node specified in such
node sets, although the node label (number) of the individual nodes in the node
sets might change. The discrete nodes can be located at any geometric location,
not only at the corners of the adaptive subdomain.
Applying Initial Conditions to all Nodes in the Adaptive Subdomain
If your application requires you to specify initial conditions (for example, on
temperature) on all the nodes in the adaptive subdomain, you must first define a
node set containing all these nodes. Abaqus/Standard retains such a node set automatically after remeshing. After each remeshing
operation, Abaqus/Standard reconstructs the node set that contains all the nodes in the entire adaptive
subdomain and also retains the name of the node set.
Input File Usage
Use the following options to apply initial conditions on temperature on
all the nodes in the adaptive subdomain of a model (in this case, you do not
need to retain this node set explicitly; Abaqus/Standard retains it by default)
NSET, NSET=Nset_all_Adaptive_SubdomainList of nodes in the entire adaptive subdomain of the modelINITIAL CONDITIONS, TYPE=TEMPERATURENset_all_Adaptive_Subdomain, Temperature Value
Applying Distributed Loads to Element-Based Surfaces in the Adaptive
Subdomain
You cannot apply loads, constraints, and other prescribed conditions to any
element in the adaptive subdomain using the element label (number) directly.
Instead, you must use an element-based surface definition to apply distributed
loads or constraints to a group of element facets. Figure 8 shows
an example of an application where surface-based distributed loading needs to be
applied to the two shaded surfaces. Figure 8. Distributed loads applied to the top surface and inner surface of the
model. Clearly these surfaces must be retained following each adaptive remeshing
operation. First, you must specify these surfaces as retained (see Specifying the Retained Sets and Surfaces in the Adaptive Subdomain of the Model); then, you apply the distributed loads to these surfaces in the usual
manner. While Abaqus/Standard retains the specified surface, the individual element facets that make up
this surface are updated with every remeshing operation. Abaqus/Standard also retains the surface name. This algorithm is subject to the restriction
that any element facet cannot be a part of more than one retained surface
definition in the adaptive subdomain.
When you specify an element-based surface that needs to be retained, Abaqus/Standard does not retain the element sets used to define the original surface.
Instead, after remeshing, the data lines of the surface definition option are
converted into updated individual element labels and face identifiers that
replace the old set that existed prior to remeshing.
Input File Usage
Use the following options to apply distributed loads to the top and the
inner surfaces in Figure 8:
SURFACE, TYPE=ELEMENT, NAME=TopSurf_nameElement set name or element label, face identifiers SURFACE, TYPE=ELEMENT, NAME=InnerSurf_nameElement set name or element label, face identifiers ADAPTIVE REMESH RETAIN, TYPE=SURFACETopSurf_name, InnerSurf_nameDSLOADTopSurf_nameInnerSurf_name
Defining Multiple Solid Section Properties in the Adaptive Subdomain
By default, after each remeshing operation, Abaqus/Standard retains certain element sets in the adaptive subdomain. An example of an element
set that is retained by default is one that contains all the elements in the
adaptive subdomain. Such an element set is typically used to define the element
section or element-based volume loads (such as body forces) for the entire adaptive
subdomain.
If the adaptive subdomain requires more than one solid section property definition in
the model (see Figure 5), the element set corresponding to each section definition must be retained after
each operation (see Specifying the Retained Sets and Surfaces in the Adaptive Subdomain of the Model). Other situations that require retaining multiple element sets in the adaptive
subdomain include the application of different element-based body forces to
different parts of the adaptive subdomain, the application of node-based constraints
(MPCs or displacement boundary conditions), or
the need to request node-based output on a cloud of nodes over a certain material
volume.
If it is necessary to retain more than one element set, the following apply:
Abaqus/Standard preserves the volume occupied by each element set in the model after
remeshing.
You cannot specify any given element in more than one retained element
set.
Retaining multiple element sets is equivalent to partitioning the adaptive
subdomain into several parts. Ideally, you should minimize retaining element sets as
much as possible for maximum flexibility with remeshing.
Input File Usage
Use the following options to assign all the elements in the adaptive subdomain
to a single element set (in this case, you do not need to retain this element
set explicitly; Abaqus/Standard retains it by default):
ELSET, ELSET=Elset_all_Adaptive_SubdomainList of elements in the entire adaptive subdomain of the modelSOLID SECTION, ELSET=Elset_all_Adaptive_Subdomain
Use the following options to preserve multiple regions (material volumes)
corresponding to different section definitions, or to apply volume-based loads
(such as gravity) in a portion of the adaptive subdomain, as shown in Figure 5:
ELSET, ELSET=Elset_name1List of elements in part one of the adaptive subdomainELSET, ELSET=Elset_name2List of elements in part two of the adaptive subdomainELSET, ELSET=Elset_name3List of elements in part three of the adaptive subdomainADAPTIVE REMESH RETAIN, TYPE=VOLUMEElset_name1, Elset_name2, Elset_name3SOLID SECTION, ELSET=Elset_name1SOLID SECTION, ELSET=Elset_name2SOLID SECTION, ELSET=Elset_name3
Use the following options to request node-based output on a cloud of nodes
over a certain material volume in the adaptive subdomain:
ELSET, ELSET=Elset_nameList of elements in a certain material volume within the adaptive subdomainADAPTIVE REMESH RETAIN, TYPE=VOLUMEElset_nameNSET, NSET=Nset_name, ELSET=Elset_nameNo data lines neededNODE OUTPUT, NSET=Nset_name
Fatigue Crack Growth Criterion
Simulation of fatigue crack growth under subcritical cyclic loading requires the
specification of a fatigue crack growth criterion. For fatigue crack growth with
adaptive remeshing, you can use the criterion only with a general linear elastic
fatigue crack growth analysis (see Linear Elastic Fatigue Crack Growth Analysis).
You cannot use fatigue crack growth with adaptive remeshing for low-cycle fatigue
applications using the direct cyclic approach. A fatigue crack growth step can be
the only step in the analysis, or it can follow a general static step that is used
for preloading the structure prior to the fatigue analysis. You cannot use multiple
fatigue crack growth steps in a single simulation.
The onset and growth of a fatigue crack are characterized by the Paris law, which
relates the initiation as well as the rate of crack growth to the fracture energy
release rate or the stress intensity factor. Different forms of the basic Paris law
are available in Abaqus/Standard. For more information, see Linear Elastic Fatigue Crack Growth Behaviors.
Input File Usage
The option to specify a fatigue crack growth law is part of the material
definition and must appear there along with other relevant material options
(properties):
Abaqus/Standard calculates the fracture energy release rates or the stress intensity factors at
the crack-tip nodes based on the contour integral method (see Contour Integral Evaluation). Only second-order tetrahedral elements can
be used to mesh the adaptive domain.
The mesh is unstructured (as is typical for tetrahedral meshes); therefore, the mesh
around the crack front must be refined with several layers or rings of elements to
obtain accurate results from the contour integral evaluations.
If the crack front intersects the external surface of a three-dimensional solid, the
virtual crack extension direction, q, must lie in the plane of
the free surface for accurate contour integral evaluation. To achieve this if the
free surface is planar and the normal to the free surface remains unchanged during
the fatigue crack growth, you can specify the surface normals directly by using the
nodal coordinates (the fourth–sixth coordinates) at the crack-tip nodes lying on the
free surface. If the free surface is nonplanar and the normal on the free surface
intersected with the crack front is expected to change, you can request that Abaqus/Standard calculates the normal for these nodes to correct any inadequate virtual crack
extension direction. For large models, requesting that Abaqus/Standard calculate the surface normals on the free surfaces can increase the computation
time.
Input File Usage
Use both of the parameters listed below if the normals on the free
surfaces are specified by the user:
Use all three parameters listed below to specify that the normals to the
free surfaces should be calculated by Abaqus/Standard:
CONTOUR INTEGRAL, TYPE=K FACTORS, RING RADIUS, SURFACE NORMAL=FREE
Controlling the Incremental Crack Growth
Fatigue crack growth is characterized by the Paris law, which relates the crack
growth rate to the fracture energy release rate or the stress intensity factor (see
Fatigue Crack Growth Using the Paris Law):
In addition, you can utilize user subroutine UMIXMODEFATIGUE to
implement a user-defined fatigue crack growth law. The Paris regime is bounded by
the stress intensity factor fatigue threshold, , below which there is no consideration of fatigue crack initiation
or growth, and the stress intensity factor fatigue upper limit, , above which the fatigue crack grows at an accelerated rate. The
process of fatigue crack growth is based on a damage extrapolation technique, which
relies on propagating a crack tip node by at least a factor of a typical element
characteristic length ahead of the current crack front (once the onset criterion is
satisfied) with a corresponding increase in the number of cycles. Specifically, if
the criterion for the onset of the crack growth is satisfied at any crack tip at the
end of a completed cycle, , Abaqus/Standard extends the crack length , by propagating it by at least a factor of a typical element
characteristic length ahead of the current crack front. This local (at each crack
front node) increase in the crack length corresponds to an increase in the cycle
count from to , where is computed based upon the Paris Law. If , the elements ahead of the crack tips are fractured by increasing
the cycle number count, , by one only.
Two different approaches are available to control the propagation of the crack: a
cycle increment-based approach and a crack length increment-based approach.
Input File Usage
Use the following option to specify a fatigue crack growth analysis with a
cycle increment-based or a crack length increment-based approach.
FATIGUEinitial time increment, single loading cycle time, minimum time increment, maximum time increment
, , ,
When you specify a nonzero value of , Abaqus/Standard uses the crack length increment–based approach.
Cycle Increment-Based Approach
You specify the minimum and maximum number of cycles ( and ) over which the crack is extended. Abaqus/Standard then initially sets equal to to calculate the crack extension length for all the nodes along the crack front.
If none of the calculated for the nodes along the current crack front is equal to or
greater than one typical element characteristic length, Abaqus/Standard adjusts the cycle increment to ensure that the crack propagates at least one typical
element characteristic length for at least one of the nodes along the crack
front.
On the other hand, if any calculated for the nodes along the current crack front is greater than
two times the typical element characteristic length, Abaqus/Standard adjusts the cycle increment to ensure none of the nodes along the crack front propagates
more than two times the element characteristic length.
Crack Length Increment-Based Approach
To use the crack length increment-based approach, you specify a nonzero value for , the ratio of the crack extension length, to the typical element characteristic length. Abaqus/Standard extends the crack length by for all the crack-tip nodes and calculates the corresponding
cycle increment for each node i along the crack front. The overall cycle
increment for this increment of crack growth, , is then set equal to the average of . When you use the crack length increment-based approach, the
crack shape always grows in a self-similar manner although the size of the crack
can increase.
Performing Adaptive Remeshing after Each Crack Extension
At the beginning of the workflow, Abaqus/Standard automatically extracts the following data and creates two auxiliary files:
The node, element, node and element set, and surface definitions within the
adaptive subdomain
The crack front information (that is, the crack front nodes and the
direction cosines defining the crack propagation direction at each node
along the crack front) within the adaptive subdomain
Next, Abaqus/Standard modifies the original input file for the model by replacing the node, element,
set, surface, and crack front definitions in the adaptive subdomain with the
corresponding data contained in the two auxiliary files. This is accomplished by
‘including’ (Including Model or History Data from an External File) the two auxiliary files in the modified input file. As the crack grows and the
mesh updates adaptively, the contents of the two auxiliary files also update for the
next phase of crack growth.
The updated crack front location is obtained using the procedure described in the
earlier sections. Abaqus/Standard uses a tetrahedral element-based adaptive remeshing technology to morph the old
mesh to a new mesh, such that it conforms to the updated crack front. As discussed
above, Abaqus/Standard writes a new input file, along with two external include files (that are
referenced from the new input file), with the updated mesh. In the nonadaptive
subdomain, all options and their associated data lines remain unchanged in the
updated input file following each adaptive remeshing operation. To avoid the risk of
potentially conflicting element and node labels in the model after each remeshing
operation, the largest element label and the largest node label in the nonadaptive
subdomain are used as offsets when generating new node and new element labels,
respectively, in the adaptive subdomain. Care must be taken that any large offset
values will not result in a generated node or element label in the adaptive
subdomain exceeding the maximum value allowed, which is 999,999,999.
Execution and File Management
Fatigue crack growth with adaptive remeshing is based upon a series of automated
successive Abaqus/Standard fatigue analyses with progressively longer crack lengths. You must launch the
workflow execution using the following command:
You must specify the job name and the file name separately. Abaqus/Standard generates a number of files over the course of the workflow. Some of these files
contain analysis results and intermediate input files; Abaqus/Standard retains these files for use by other analysis options to maintain the flexibility
of this workflow. For example, from an intermediate point in the workflow (which
corresponds to the cracked structure after it has been subjected to many fatigue
loading cycles) you can perform:
a stand-alone analysis to evaluate the linear or nonlinear static or
eigenfrequency responses of the cracked structure;
a restart-based fatigue analysis using a different cyclic loading amplitude
compared to the one specified in the original analysis; or
additional postprocessing.
If you perform either a stand-alone analysis or a restart-based fatigue
analysis from an intermediate point in the workflow, you must augment the input
files retained by Abaqus with either additional steps or a separate restart analysis input file.
This section describes the files that are created and retained by Abaqus/Standard during this workflow.
At the end of each fatigue crack growth increment corresponding to a fatigue cycle
number, Abaqus/Standard automatically creates a new input file (.inp) and two
external (.inc) files with updated crack geometry. Abaqus/Standard names these files by appending _cyclenumber to the original
file names and uses the new files to continue the workflow. Specifically, the new
files are the input for a new Abaqus/Standard fatigue crack growth analysis to compute the next increment of crack growth based
on the updated crack geometry.
After each fatigue crack growth increment, Abaqus/Standard retains each of the following:
In addition, Abaqus/Standard retains a single file of each of the following types for the entire analysis:
printed job output file (.dat),
log file (.log),
message file (.msg),
usage file (.use), and
status file (.sta).
To do so, it progressively appends the files generated at the end of the
current fatigue crack growth cycle increment to those obtained at the end of the
previous fatigue crack growth cycle increments.
Other files exist only while Abaqus/Standard is executing; Abaqus/Standard deletes them once the workflows completes.
Visualization
A special Abaqus/Viewer plug-in is available to:
create a series of frames (.png files) to show the
deformed shapes of the structures following each increment of crack
growth;
facilitate the creation of path plots for the series of crack growth
analyses; and
create animations of crack growth in MP4 or
GIF format directly.
Predefined temperatures and field variables can be specified in a model, as described
in Predefined Fields, with some
restrictions (see Loads and Boundary Conditions in the Adaptive Subdomain).
The specified values will affect temperature- and field-variable-dependent material
properties, if any.
Material Options
The adaptive remeshing capability can be used only with the linear elastic material
model (see Elastic Behavior).
Elements
The adaptive remeshing capability can be used only with second-order tetrahedral
stress/displacement continuum elements in the adaptive subdomain.
You can only use a mesh with second-order tetrahedral elements in the adaptive
subdomain.
You cannot use fatigue crack growth with adaptive remeshing in a model defined
in terms of an assembly of part instances.
No state mapping is performed (or necessary) between Abaqus/Standard analyses to compute successive increments in crack growth.
You can include only a single crack in the adaptive subdomain of the model.
You cannot use multiple fatigue steps in a single simulation.
Mesh morphing fails (hence, the workflow terminates) when an embedded crack tip
has propagated to the free/external surface of the model.
Input File Template
The following is an example of a typical input file for modeling fatigue crack
propagation with adaptive remeshing for the model illustrated in Figure 3:
*HEADING
*NODE
*NSET, NSET=NSET_INNER
*NSET, NSET=NSET_OUTER
*ELEMENT, TYPE=C3D10
**Define the element set in the adaptive domain
*ELSET, ELSET=ELSET_INNER
**Define the element set in the nonadaptive domain
*ELSET, ELSET=ELSET_OUTER
**Specify an outer surface of the adaptive domain
*ELSET, ELSET=elset_name1
*ELSET, ELSET=elset_name2
*SURFACE, TYPE=ELEMENT, NAME=OUTER_SURFelset_name1elset_name2
**Specify an inner surface of the nonadaptive domain
*ELSET, ELSET=elset_name3
*ELSET, ELSET=elset_name4
*SURFACE, TYPE=ELEMENT, NAME=INNER_SURFelset_name3elset_name4
**Specify additional surface in the adaptive domain
**subjected to internal pressure
*ELSET, ELSET=elset_name5
*ELSET, ELSET=elset_name6
*SURAFCE, TYPE=ELEMENT, NAME=PRESSURE_SURFelset_name5elset_name6
**Identify the adaptive domain
*ADAPTIVE REMESH, ELSET=ELSET_INNER
**Identify the surfaces in the adaptive subdomain
**that need to be reconstructed after remeshing
*ADAPTIVE REMESH RETAIN, TYPE=SURFACE
OUTER_SURF, PRESSURE_SURF
**Specify node sets with a few discrete nodes in the nonadaptive domain
*NSET, NSET=nset_NodeX
*NSET, NSET=nset_NodeY
*SOLID SECTION, MATERIAL=STEEL, ELSET=ELSET_INNER
*SOLID SECTION, MATERIAL=IRON, ELSET=ELSET_OUTER
*MATERIAL, NAME=STEEL
**Specify the crack growth law
*FRACTURE CRITERION, TYPE=FATIGUE
Data lines to specify the fatigue crack propagation criterion
*MATERIAL, NAME=IRON
**Impose tie constraints between the outer surface of the adaptive domain
**and the inner surface of the nonadaptive domain
*TIE
OUTER_SURF, INNER_SURF
*STEP
**Define a fatigue crack growth step
*FATIGUE
…
*BOUNDARY
nset_nodeXnset_nodeY
**Apply pressure to an internal surface in the adaptive domain
*DSLOAD
PRESSURE_SURF, P
**Perform contour integral calculations
*CONTOUR INTEGRAL, TYPE=K FACTORS, RINGRADIUS, SURFACE NORMAL=FREE
Nodeid_1, nodeid_1, qx1, qy1, qz1
Nodeid_2, nodeid_2, qx2, qy2, qz2
Nodeid_3, nodeid_3, qx3, qy3, qz3
…………………
*OUTPUT, FIELD
*NODE OUTPUT
K, U
*END STEP