/prep7

A = 46.6 ! crack length

W = 100 ! width
W1 = 125 ! total width
H = 60 ! half height
R = 12.5 ! radius of load circle
E = 27.5 ! pin height
S = 3 ! half width of notch
D1 = 80 ! depth of notch
D2 = 75 ! depth of notch
B = -12 ! thickness

k,1,A
k,2,W
k,3,W,H
k,4,,H
k,5,(W-W1),H
K,6,(W-W1),S
k,7,,S
k,8,(W-D1),S
k,9,(W-D2)
k,10,,E
k,11,,E,E
!!!!!start!!!!!

k,20,W,-H
k,21,,-H
K,22,(W-W1),-H
k,23,(W-W1),-S
k,24,,-S
k,25,(W-D1),-S
k,26,(W-D2)
k,27,,-E
k,28,,-E,E

k,40,(W-D1),H
k,41,(W-D1),-H
!!!!!end!!!!!!
circle,10,r,11,4,,8
l,1,2
l,2,3
l,3,40
l,40,4
l,4,5
l,5,6
l,6,7
l,7,8
l,8,9
l,9,1
l,4,12
l,16,7

!!!!!!!!!!
circle,27,r,28,21,,8
l,20,41
l,41,21
l,21,22
l,22,23
l,23,24
l,24,25
l,25,26
l,26,1
l,2,20
l,24,33
l,29,21
l,8,40
l,25,41

AL,9,10,11,40,17,18
Al,41,35,36,9,37,29
AL,12,19,8,7,6,5,20,16,40
AL,34,38,24,23,22,21,39,30,41
AL,38,33,32,31,39,28,27,26,25
AL,13,19,1,2,3,4,20,15,14
!!!!!!!!!!

et,1,187
type,1
mp,ex,1,200000
mp,nuxy,1,0.33

! Paris' Law Constants

C=2.29E-10
M=2

! Fatigue crack growth Law Specification

tb, cgcr, 2, , , PARIS
tbdata, 1, C, M

esize,4
vext,all,,,0,0,B
allsel,all

vmesh,all

asel,s,,,8
asel,a,,,18
asel,a,,,13
AREFINE,all,,,,1

esel,s,ename,,187
allsel,all

ASEL,s, , , 23
ASEL,a, , , 24
ASEL,a, , , 25
ASEL,a, , , 26
ASEL,a, , , 50
ASEL,a, , , 51
ASEL,a, , , 52
ASEL,a, , , 53
nsla,s,1

*GET, numnode, NODE, 0, count, , ,

f,all,fy,450/numnode
allsel,all

!lsel,s,,,88
!lsel,a,,,92
ASEL,s, , , 33
ASEL,a, , , 34
ASEL,a, , , 35
ASEL,a, , , 36
ASEL,a, , , 39
ASEL,a, , , 40
ASEL,a, , , 41
ASEL,a, , , 42
nsla,s,1
*GET, numnode, NODE, 0, count, , ,
f,all,fy,-450/numnode
allsel,all

lsel,s,,,49
nsll,s,1
D,ALL,UY,0
D,ALL,UZ,0
allsel

lsel,s,,,74
lsel,a,,,90
nsll,s,1
D,ALL,UX,0
allsel

nsel,s,loc,x,a,a
nsel,r,loc,y,0
nlist
cm,crack1,node
ALLSEL,ALL

ASEL,S, , ,12,13
NSLA,S,1
CM,CRACKT_SUR_01,NODE!upper
ALLSEL

ASEL,S, , ,18,19
NSLA,S,1
CM,CRACKT_SUR_02,NODE!lower
ALLSEL

finish

/solu
ANTYPE,STATIC
KBC,1
ANTYPE,STATIC
cint,new,1
CINT,TYPE,SIFS
CINT,TYPE,JINT
cint,ctnc,crack1
CINT,EDIR,CS,0,x
cint,norm,0,2
CINT,SURF,CRACKT_SUR_01,CRACKT_SUR_02
cint,ncon,5

CGROW, NEW, 1
CGROW, CID, 1
CGROW, METHOD, SMART,REME

CGROW, FCG, METH, LC ! life-cycle method

CGROW, FCG, DAMX, 0.5 ! maximum crack growth increment
CGROW, FCG, SRAT, 0 ! stress-ratio
CGROW, fcoption, mtab, 2

NSUBST,6
OUTRES,all,ALL

/solu
solve
finish

/POST1

*get, nstep, active, 0, set, nset

crkId = 1

maxnumNd = 0
SET,FIRST
*do,istep,1,nstep
! get number of crack tips
*get, pval, CINT,1, NNOD
*if, pval,gt,maxnumNd,then
maxnumNd = pval
*endif
SET,NEXT
*enddo

*DIM, numNd,array,nstep,1
*DIM, nodeNum,array,maxnumNd,nstep
*DIM,DN,array,2,nstep
*DIM,DA,array,2,nstep
*DIM,DK,array,2,nstep
*DIM,DR,array,2,nstep
*DIM,ND_X,array,2,nstep
*DIM,ND_Y,array,2,nstep
*DIM,ND_Z,array,2,nstep
*DIM,ND_A,array,2,nstep
! DN_R and DK_R store the reference results
*DIM,DN_R,array,2,nstep
*DIM,DK_R,array,2,nstep
! OUT0 stores the results of the first node
! OUT1 stores the results of the last node
*DIM,OUT0_DN,array,nstep,2
*DIM,OUT0_DA,array,nstep,2
*DIM,OUT0_DK,array,nstep,2
*DIM,OUT1_DN,array,nstep,2
*DIM,OUT1_DA,array,nstep,2
*DIM,OUT1_DK,array,nstep,2

SET,FIRST
! get number of crack tips
*get, pval, CINT,1, NNOD
istep = 1
numNd(istep,1) = pval
! get tip node numbers
*do, inode, 1, 2
*if,inode,eq,1,then
*get, NdNum, CINT,crkId, NODE, inode
*else
*get, NdNum, CINT,crkId, NODE, numNd(istep,1)
*endif

nodeNum(inode,istep) = NdNum

*get, pval, CINT,crkId,CTIP,NdNum,CONTOUR,1,DTYPE,dltn

DN(inode,istep) = pval
*get, pval, CINT,crkId,CTIP,NdNum,CONTOUR,1,DTYPE,dlta
DA(inode,istep) = pval
*get, pval, CINT,crkId,CTIP,NdNum,CONTOUR,1,DTYPE,dltk
DK(inode,istep) = pval
*get, pval, CINT,crkId,CTIP,NdNum,CONTOUR,1,DTYPE,R
DR(inode,istep) = pval

*get, pval, CINT,crkId,CTIP,NdNum,CONTOUR,1,DTYPE,crdx

ND_X(inode,istep) = pval
*get, pval, CINT,crkId,CTIP,NdNum,CONTOUR,1,DTYPE,crdy
ND_Y(inode,istep) = pval
*get, pval, CINT,crkId,CTIP,NdNum,CONTOUR,1,DTYPE,crdz
ND_Z(inode,istep) = pval
*get, pval, CINT,crkId,CTIP,NdNum,CONTOUR,1,DTYPE,apos
ND_A(inode,istep) = pval
C=2.29E-10
M = 2
W=100
PF=450
BB=12
PI=3.1416
a0 = 46.6
aw=a0/W
Z=16.7*aw**0.5-104.7*aw**1.5+369.9*aw**2.5
ZZ=-573.8*aw**3.5+360.5*aw**4.5
ZZZ=PF/BB*SQRT(PI/W)
DeltK= ZZZ*(ZZ+Z)

DK_R(inode,istep) = DeltK
DeltN = DA(inode,1)/(C*(DeltK**M))
DN_R(inode,istep) = DeltN
*if,inode,eq,1,then
OUT0_DN(istep,1)=DN(1,istep)
OUT0_DA(istep,1)=DA(1,istep)
OUT0_DK(istep,1)=DK(1,istep)
OUT0_DN(istep,2)=DN_R(1,istep)
OUT0_DK(istep,2)=DK_R(1,istep)
 *else
OUT1_DN(istep,1)=DN(inode,istep)
OUT1_DA(istep,1)=DA(inode,istep)
OUT1_DK(istep,1)=DK(inode,istep)
OUT1_DN(istep,2)=DN_R(inode,istep)
OUT1_DK(istep,2)=DK_R(inode,istep)
*endif
*enddo

SET,NEXT

*do,istep,2,nstep

! get number of crack tips

*get, pval, CINT,1, NNOD
numNd(istep,1) = pval
! get tip node numbers
*do, inode, 1, 2
*if,inode,eq,1,then
*get, NdNum, CINT,crkId, NODE, inode
*else
*get, NdNum, CINT,crkId, NODE, numNd(istep,1)
*endif

*get, pval, CINT,crkId,CTIP,NdNum,CONTOUR,1,DTYPE,dltn

DN(inode,istep) = DN(inode,istep-1) + pval
*get, pval, CINT,crkId,CTIP,NdNum,CONTOUR,1,DTYPE,dlta
DA(inode,istep) = DA(inode,istep-1) + pval
*get, pval, CINT,crkId,CTIP,NdNum,CONTOUR,1,DTYPE,dltk
DK(inode,istep) = pval
*get, pval, CINT,crkId,CTIP,NdNum,CONTOUR,1,DTYPE,R
DR(inode,istep) = pval

*get, pval, CINT,crkId,CTIP,NdNum,CONTOUR,1,DTYPE,crdx

ND_X(inode,istep) = pval
*get, pval, CINT,crkId,CTIP,NdNum,CONTOUR,1,DTYPE,crdy
ND_Y(inode,istep) = pval
*get, pval, CINT,crkId,CTIP,NdNum,CONTOUR,1,DTYPE,crdz
ND_Z(inode,istep) = pval
*get, pval, CINT,crkId,CTIP,NdNum,CONTOUR,1,DTYPE,apos
ND_A(inode,istep) = pval
! calculate the reference results
DA0=DA(inode,istep-1)
a0 = 46.6+DA0
aw=a0/W
Z=16.7*aw**0.5-104.7*aw**1.5+369.9*aw**2.5
ZZ=-573.8*aw**3.5+360.5*aw**4.5
ZZZ=PF/BB*SQRT(PI/W)
DeltK= ZZZ*(ZZ+Z)

DK_R(inode,istep) = DeltK
Nst = (DA(inode,istep)-DA0)/(C*(DeltK**M))
DeltN = DN_R(inode,istep-1) + Nst
DN_R(inode,istep) = DeltN
*if,inode,eq,1,then
OUT0_DN(istep,1)=DN(1,istep)
OUT0_DA(istep,1)=DA(1,istep)
OUT0_DK(istep,1)=DK(1,istep)
 OUT0_DN(istep,2)=DN_R(1,istep)
OUT0_DK(istep,2)=DK_R(1,istep)
*else
OUT1_DN(istep,1)=DN(inode,istep)
OUT1_DK(istep,1)=DK(inode,istep)
OUT1_DA(istep,1)=DA(inode,istep)
OUT1_DN(istep,2)=DN_R(inode,istep)
OUT1_DK(istep,2)=DK_R(inode,istep)
*endif
*enddo

SET,NEXT

*enddo

*DIM,LABEL,array,nstep,1
*DIM,DNTab,table,nstep,1
*DIM,DATab,table,nstep,1
*DIM,DKTab,table,nstep,1

*do,i,1,nstep
LABEL(i)=i
*VFILL,DNTab(i,1),DATA,DN(1,i)
*VFILL,DATab(i,1),DATA,DA(1,i)
*VFILL,DKTab(i,1),DATA,DK(1,i)
*enddo

!Plot results

/show,PNG
/view,1,1,1,1
/dscale,,0
/graphics,power

/AXLAB,X,Crack Extension
/AXLAB,Y,Number Of Cycles
/GCOL,1,MAPDL
/GCOL,2,TARGET
*VPLOT,DATab(1,1),DNTab(1,1),2

/AXLAB,X,Crack Extension
/AXLAB,Y, DELTA-K
/GCOL,1,MAPDL
/GCOL,2,TARGET
*VPLOT,DATab(1,1),DKTab(1,1),2

/out
/COM, ----------------------SOLVER RESULTS
COMPARISON------------------------
/COM,
/COM, DK OF THE FIRST NODE
/COM,
/COM,Step | A value | TARGET | Mechanical APDL
/COM,
/COM, --------------------
/COM,
/out
*VWRITE,LABEL(1),OUT0_DA(1,1),OUT0_DK(1,2),OUT0_DK(1,1)
(F3.0,' ',F14.8,' ',F14.5,' ',F14.5)

/out
/COM, ----------------------SOLVER RESULTS
COMPARISON------------------------
/COM,
/COM, DN OF THE FIRST NODE
/COM,
/COM,Step | A value | TARGET | Mechanical APDL
/COM,
/COM, --------------------
/COM,
/out
*VWRITE,LABEL(1),OUT0_DA(1,1),OUT0_DN(1,2),OUT0_DN(1,1)
(F3.0,' ',F14.8,' ',F14.5,' ',F14.5)
/COM,
/COM, ----------------------SOLVER RESULTS
COMPARISON------------------------
/COM,
/COM, DK OF THE LAST NODE
/COM,
/COM,Step | A value | TARGET | Mechanical APDL
/COM,
/COM, --------------------
/COM,
/out
*VWRITE,LABEL(1),OUT1_DA(1,1),OUT1_DK(1,2),OUT1_DK(1,1)
(F3.0,' ',F14.8,' ',F14.5,' ',F14.5)
/out
/COM, ----------------------SOLVER RESULTS
COMPARISON------------------------
/COM,
/COM, DN OF THE LAST NODE
/COM,
/COM,Step | A value | TARGET | Mechanical APDL
/COM,
/COM, --------------------
/COM,
/out
*VWRITE,LABEL(1),OUT1_DA(1,1),OUT1_DN(1,2),OUT1_DN(1,1)
(F3.0,' ',F14.8,' ',F14.5,' ',F14.5)
/com,
/out,scratch
da_comparison0=2.5
da_comparison1=3.0

*if,OUT0_DA(6,1),lt,da_comparison0,then
/out,
/com,===================================
/com, Comparison FAILED
/com,===================================
*elseif,OUT0_DA(6,1),gt,da_comparison1,then
/out,
/com,===================================
/com, Comparison FAILED
 /com,===================================
*else
/out,
/com,===================================
/com, Comparison SUCCESSFUL
/com,===================================
/out,scratch
*endif

finish
/out,scratch
SMART Method for Crack-Growth Simulation
Use Separating, Morphing, Adaptive and Remeshing Technology
(SMART) to simulate both static and fatigue crack growth in
engineering structures. SMART updates the mesh from crack-
geometry changes due to crack growth automatically at each
solution step. Mesh updates occur around the crack-front region
only and are integrated into the Mechanical APDL solver without
exiting and reentering the solver, resulting in a computationally
efficient solution of the crack-growth problem. Crack-growth
mechanics include various fracture criteria for static crack growth
and Paris' Law for fatigue crack growth.

Following are the primary characteristics of the SMART crack-

growth method:

 3-D Mode I crack growth only.

 Linear elastic isotropic materials only.
 Uses SOLID187 only.
 Ignores large-deflection and finite-rotation effects, crack-tip
plasticity effects, and crack-tip closure or compression effects.
 Fracture criteria for static crack growth includes critical stress-
intensity factorand J-integral.
 Fatigue crack growth is based on Paris' Law [1].

The following topics for the SMART crack-growth method are available:

 Understanding a SMART Crack-Growth Simulation

 Performing the SMART Crack-Growth Calculation
 SMART Crack-Growth Assumptions and Limitations
 Postprocessing SMART Crack-Growth Analysis Results
 Example: Fatigue Crack-Growth Analysis Using SMART
 
3.2.1. Understanding a SMART Crack-Growth Simulation

A SMART crack-growth simulation is assumed to be quasi-static. You can

use the SMART crack-growth method to perform a static or fatigue crack-
growth simulation.
Crack-growth simulation is a nonlinear structural analysis. The analysis
details presented here emphasize features specific to crack growth:

 Creating a Finite Element Model with an Initial Crack

 Defining the Fracture-Parameter Calculation Set
 Defining the Fracture Criterion
 Setting Crack-Growth Solution Controls
 Specifying the Crack-Extension Increments in a Step

For more information, see Example: Fatigue Crack-Growth Analysis

Using SMART.

 
3.2.1.1. Creating a Finite Element Model with an Initial Crack

Standard nonlinear finite element solution procedures apply for creating a

crack model with proper solution-control settings, loadings and boundary
conditions.

SMART uses higher-order tetrahedral element SOLID187, and the finite

element model must be meshed with that element.

To create a finite element model with an initial crack, you can use ANSYS
Workbench, ANSYS Mechanical, Mechanical APDL, or any third-party
meshing tools that work with Mechanical APDL.

Fracture mechanics deals with cracks (defects), and a singularity always

exists around the crack tip/front. The crack-tip/-front mesh is therefore of
utmost importance in a crack analysis, as stress-analysis and fracture-
parameters calculation accuracy depend on the crack mesh. Size and shape
differences in the elements ahead of and behind the crack tip/front affect
the accuracy of the fracture-parameters calculation, and therefore the
crack-growth simulation.

For more information, see Understanding How Fracture Mechanics

Problems Are Solved and Procedure for Calculating the Fracture
Parameters.

 
3.2.1.2. Defining the Fracture-Parameter Calculation Set
The SMART crack-growth method uses either J-integral or stress-intensity
factors (SIFS) as the fracture parameter (driving force) and the criteria for
crack-growth calculation.

For each crack, only one fracture parameter can be specified. The
parameter must be consistent with the specified crack-growth criterion
(CGROW,FCOPTION).

The CINT command initiates the fracture-parameter calculation and

specifies options for the calculation.

1. Define the crack-calculation set:

CINT,NEW,SETNUMBER

where SETNUMBER is an integer value indicating the fracture-parameter

set ID, used to identify the fracture parameter for the crack-growth
criterion.

2. Calculate the fracture parameter:

CINT,TYPE,FractureParameter

where FractureParameter is JINT (J-integral) or SIFS (stress-intensity

factors).

3. Specify crack-front node component (CTNC) or crack-extension

node component (CENC):
CINT,CTNC,Par1

where Par1 is the crack-tip node-component name,

or
CINT,CENC,Par1,Par2,Par3

where Par1 is the crack-extension node-component

name, Par2 is crack-extension direction calculation-assist node
(any node on the open side of the crack), and Par3 is crack
front’s end-node crack-extension direction-override flag.

If specifying CINT,CTNC, also define the crack-plane normal

(CINT,NORM).
 4. Specify the number of contours for fracture-parameter calculation:
CINT,NCON,NUM_CONTOURS

 
3.2.1.3. Defining the Fracture Criterion

SMART supports static and fatigue crack-growth analyses:

 Static Crack-Growth Criterion

 Fatigue Crack-Growth Criterion

For each crack, only one fracture criterion can be specified. The criterion
parameter must be consistent with the defined fracture-parameter
calculation (CINT).

When specifying J-integral as a fracture parameter, the crack is assumed to

always grow along the initial direction. It is therefore suited for Mode I
crack growth only.

 
3.2.1.3.1. Static Crack-Growth Criterion

For static crack-growth simulation, SMART supports the J-

integraland stress-intensity factors (SIFs) fracture criteria. Specify a
fracture criterion and provide the corresponding fracture-criterion value:
CGROW,FCOPTION,Par1,Par2

where Par1 is the fracture criterion (KEFF or JIC), and Par2is the critical

value of the fracture parameter.

 
3.2.1.3.2. Fatigue Crack-Growth Criterion

For fatigue crack-growth simulation, crack growth is based on Paris' Law,

where input requires a material data table defining Paris' Law and the
constants:
TB,CGCR,MAT_ID,,,Option

CGROW,FCOPTION,MATB,MAT_ID,CONTOUR
where MAT_ID is the material ID for the material data table and CONTOUR is the
fracture-parameter contour to use for fracture evaluation.

When specifying J-integral as a fracture parameter, the calculated J-

Integral is converted to a stress-intensity factor (using a plane-strain
assumption) for the Paris' law calculation.

 
3.2.1.4. Setting Crack-Growth Solution Controls

Specify crack-growth solution controls (CGROW):

To specify this Issue this CGROW command:

solution control...
Fracture criterion CGROW,FCRAT,VALUE,
ratio (fc)
where VALUE is the ratio
Initial time step when CGROW,DTIME,VALUE,
crack growth initiates
where VALUE is initial time step

To avoid over-predicting the load-carrying capacity, specify a

small initial time step.
Minimum time step for CGROW,DTMIN,VALUE,
subsequent crack
growth where VALUE is the minimum time step size
Maximum time step CGROW,DTMAX,VALUE,
for subsequent crack
growth where VALUE is the maximum time step size
Maximum crack CGROW,STOP,CEMX,VALUE,
extension allowed at
any crack-front nodes where VALUE is the maximum crack extension

Because crack-growth simulation can be time-consuming, use

this command to stop the analysis when the specified crack
extension of interest has been reached.

When a crack extends rapidly (for example, in cases of unstable crack

growth), use smaller DTMAX and DTMIN values to allow time for load
rebalancing. When a crack is not growing, the specified time-stepping
controls are ignored and the solution adheres to standard time-stepping
control.
The STOP criterion (CEMX) is based on the total accumulated maximum
crack increment   in a step:

 
3.2.1.5. Specifying the Crack-Extension Increments in a Step

Fracture mechanics deals with cracks (defects), and a singularity always

exists around the crack tip or crack front. The finite element solution will
therefore always depend on the element sizes, especially around the crack
tip. To ensure consistent results throughout the crack-growth process,
maintain a consistent crack-tip/-front element size and crack-extension
increment.

The crack-growth calculation occurs in the solution phase after stress

calculation. The fracture parameter is calculated first, followed by the
crack extension according to the crack-growth method:

 If using the fatigue-crack-growth Life-cycle (LC) method:

CGROW,FCG,METH,LC

The crack-extension increment   is calculated using the maximum

element size of the crack-front node:

where   is the size of the elements along the crack front.

If   < DAMN, the crack-extension increment is set to the

specified minimum crack-extension increment DAMN:

 = DAMN

If   > DAMX, the crack-extension increment is set to the

specified maximum crack-extension increment DAMX:

 = DAMX
 The cycle increment   is calculated using the calculated crack
extension   and the maximum stress-intensity factor   of the
crack-front node:

The crack-extension increment of the nodes   is determined by:

where   is the calculated nodal crack-extension increment,   is

the stress-intensity factor of the crack-front node, and   is the
stress ratio.

 If using the fatigue-crack-growth Cycle-by-cycle (CBC) method:

CGROW,FCG,METH,CBC

The crack-extension increment   is calculated by the cycle

increment  with the maximum stress-intensity factor   of the
crack-front node:

If   < DAMN, the crack-extension increment is set to the

specified minimum crack-extension increment DAMN, and the new
cycle increment is calculated:

If   > DAMX, the crack-extension increment is set to the

specified maximum crack-extension increment DAMX, and the new
cycle increment is calculated:
 The crack-extension increment of the remaining nodes   is
determined by:

where   is the calculated nodal crack-extension increment,   is

the stress-intensity factor of the crack-front node, and   is the
stress ratio.

 If using static crack growth:

The maximum stress-intensity factor of the crack-front node is

calculated. If it is greater than the specified criterion, the crack is set
to grow. The crack extension of each crack-front node is then
calculated based on the averaged crack-front element size:

where   is the averaged size of the elements along the crack
front,   is the stress-intensity factor along the crack front, and   
is the averaged stress-intensity factor.

To specify the maximum crack-extension increment:

CGROW,FCG,DAMX,INCREMENT

Default: INCREMENT = 1.5 x average element size along the crack front. (If a
larger INCREMENT value is specified, the program uses the default value.)

To specify the minimum crack-extension increment:

CGROW,FCG,DAMN,INCREMENT

Default: INCREMENT = 0.25 x average element size along the crack front. (If a
smaller INCREMENT value is specified, the program uses the default value.)

When the fracture criterion is reached for the specified crack-growth type,

SMART determines the crack-growth sizes (new crack faces) and
generates meshes for the new crack surfaces. Nodes inside the new crack
faces are released to form the new crack.

For fatigue crack growth, the minimum crack-extension increment,

maximum crack-extension increment, and number-of-cycles increment
may not be sufficiently satisfied during the solution phase to ensure a
robust meshing change.

 
3.2.2. Performing the SMART Crack-Growth Calculation

SMART supports static or fatigue crack-growth analyses:

 Static Crack-Growth Calculation

 Fatigue Crack-Growth Calculation

The CGROW command defines all necessary crack-growth-calculation

parameters.

 
3.2.2.1. Static Crack-Growth Calculation

1. Define a set number for this crack-growth calculation:

CGROW,NEW,SETNUMBER

2. Specify the crack-calculation ID (created when you defined the

fracture-parameter calculation set) to use as the fracture criterion:
CGROW,CID,ID

3. Set the crack-growth method to SMART:

CGROW,METHOD,SMART,REME

4. Specify the fracture criterion:

CGROW,FCOPTION,Par1,Par2 when the fracture parameter is only a

constant,

or, when fracture parameters are more than just a constant,

TB,CGCR,MAT_ID,,,Option
 CGROW,FCOPTION,MATB,MAT_ID,CONTOUR

5. Set the crack-growth time-stepping controls:

CGROW,DTMAX,MAX_TIME_STEP

CGROW,DTMIN,MIN_TIME_STEP

6. Stop the crack analysis as needed:

CGROW,STOP,CEMX,MAX_CRACK_EXT

The command stops the analysis when the crack extension for any
crack-front node reaches the maximum value specified.

Large Time Steps and Fracture Parameters A crack-growth condition

is based on whether the fracture criterion is met along the crack-front
nodes; therefore, a large time step may result in significant overprediction
of the fracture parameters (and therefore the load-carrying capacity of the
structures). A large time step can also cause overprediction in the solution
when crack growth becomes unstable. In both cases, try using a small
minimum time DTMIN.

 
3.2.2.2. Fatigue Crack-Growth Calculation

1. Define a set number for this crack-growth calculation:

CGROW,NEW,SETNUMBER

2. Specify the crack-calculation ID (created when you defined the

fracture-parameter calculation set) to use as the fracture criterion:
CGROW,CID,ID

3. Set the crack-growth method to SMART:

CGROW,METHOD,SMART,REME

4. Specify either the life-cycle (LC) or cycle-by-cycle (CBC) method

for the fatigue crack-growth calculation:

CGROW,FCG,METH,LC or CBC
 If using the CBC method, also specify the cycle
incrementto use in a calculation step:
CGROW,FCG,DELN,INCREMENT

5. Specify the fatigue crack-growth model and parameters:

TB,CGCR,MAT_ID,,,Option

CGROW,FCOPTION,MATB,MAT_ID,CONTOUR

6. Specify the stress ratio:

CGROW,FCG,SRAT,VALUE

7. Specify maximum and minimum crack increment in a step:

CGROW,DAMX,MAX_INCREMENT

CGROW,DAMN,MIN_INCREMENT

8. Stop the crack analysis as needed:

CGROW,STOP,CEMX,MAX_CRACK_EXT

The command stops the analysis when the crack extension for any
crack-front node reaches the maximum value specified.

Also see Example: Fatigue Crack-Growth Analysis Using SMART.

 
3.2.3. SMART Crack-Growth Assumptions and Limitations

 SMART supports 3-D crack growth only.

 SMART is used with SOLID187 only.
 SMART supports Mode I crack growth only.
 Only one crack can be defined.
 Material behavior is assumed to be linear elastic isotropic, with only
one material in the crack-growth domain.
 Plasticity effects, nonlinear geometry effects, load-compression
effects, and crack-tip-closure effects are not considered.
 Restarting the analysis (ANTYPE,,RESTART) is currently not
supported.
  When the crack grows to the point of breaking the structural
component apart, all solution results are set to zero and no crack-
front information is reported.
 Multiple load steps are not supported.
 MPC contact is the only supported contact option.

 
3.2.4. Postprocessing SMART Crack-Growth Analysis Results

Use the following standard POST1 (/POST1) commands for

postprocessing SMART crack-growth analysis results:

Command Purpose
ANDATA Displays animated graphics data for nonlinear problems
ANTIME Generates a sequential contour animation over a range of time
*GET Retrieves a value and stores it as a scalar parameter or part of an array
parameter
PLDISP Displays the displaced structure
PLESOL Displays the solution results as discontinuous element contours
PLNSOL Displays results as continuous contours
PLVECT Displays results as vectors
PRESOL Prints element solution results
PRNSOL Prints nodal solution results
PRVECT Prints results as vector magnitude and direction cosines
 
3.2.5. Example: Fatigue Crack-Growth Analysis Using SMART

The following figure represents the model to be used in a SMART-based

fatigue crack-growth simulation:

Figure 3.2: Standard Compact-Tension Specimen

The fatigue calculation is based on Paris' Law. The numbers of cycles are
obtained for various crack-growth increments and compared to the
reference solution.

Following are the material properties, specimen dimensions, and loading:

 Material Properties Geometry Loading
E = 2e5 Mpa, µ = 0.33 W = 100 mm P = 450 N

Paris’ Law: C = 2.29e-10, m = 2 B = 12 mm Stress ratio: R = 0

The problem is solved using the 3-D SOLID187 element. Stress-intensity

factors (SIFS) were defined for the fracture parameter, and SMART was
used for the crack-growth analysis with remeshing only
(CGROW,METHOD,SMART,REME). The life-cycle (LC) method was
used for fatigue analysis with a maximum crack-growth increment of 0.5
m. The number of cycles is obtained and compared to the theoretical
results.

A value Target Mechanical APDL Ratio

 of the First Node:

0.3945 32.534 31.188 0.959
0.7949 32.892 31.708 0.964
1.2124 33.263 32.654 0.982
1.6558 33.658 33.995 1.010
2.1061 34.086 34.628 1.016
2.5686 34.530 35.503 1.028

 of the First Node:

0.3945 1627507 1770957 1.088
0.7949 3243567 3510006 1.082
1.2124 4891584 5220097 1.067
1.6558 6600680 6895468 1.045
2.1061 8293223 8535421 1.029
2.5686 9987014 10137707 1.015
 

SEMI elliptical crack

For the Semi-Elliptical Crack object, the application defines the

internally generated crack mesh after the initial base mesh. The
base mesh generation is based on a different set of requirements
and constraints than the crack mesh. As a result, the crack mesh,
generated using the Hex dominant mesh method, may not perfectly
match the boundaries of the fracture affected zone. Because they
may not match perfectly, kinematic constraints are required to
establish a connection between base mesh and crack mesh in the
boundaries of the fracture affected zone, which is accomplished
using the multi-point constraint (MPC) contact. A contact pair is
created at the interface of the crack and base meshes, with contact
surface created at the interface on the buffer zone side of the base
mesh and target surface created at the interface on the fracture
affected zone side of the hex dominant mesh. When the solution is
performed using internally-generated crack meshes, the MPC
contact region is automatically created and sent to the solver.

Note:  When meshing a Semi-Elliptical Crack, the application does not

create a contact pair when the Mesh Method property is set
to Tetrahedrons.

Note:  Static Structural and Transient Structural analyses are