<!-- source-page: 401 -->

Note that you can use the MPI communication between parallel Abaqus processes to gather and scatter the data.

C Start of the analysis if (lOp .eq. j\_int\_StartAnalysis) then

User coding to set up the environment, open files, launch/connect to the external programs, etc.

C continuation from a previous analysis (restart) if (kStep .ne. 0) then end if

C Start of the step else if (lOp .eq. j\_int\_StartStep) then

Set up or exchange (import and export) initial values with external programs.

C The initial values may need to match those at the point of restart. if ( kInc .ne. 0) then end if

C Setup the increment else if (lOp .eq. j\_int\_SetupIncrement) then Change i\_Array(i\_int\_lWriteRestart) and i\_Array(i\_int\_iStatus) if desired. Change r\_Array(i\_flt\_dTime) if desired.

C Start of the increment else if (lOp .eq. j\_int\_StartIncrement) then

The time increment is finalized. Use r\_Array(i\_flt\_dTime) if desired. If needed, gather and export data from the configuration at the end of the previous increment to external programs. Import and scatter data from external program to influence the current Abaqus increment.

C End of the increment else if (lOp .eq. j\_int\_EndIncrement) then

Change i\_Array(i\_int\_iStatus) if desired. Gather and export data from the configuration at the end of the current increment

<!-- source-page: 402 -->

to external programs.

C End of the step else if (lOp .eq. j\_int\_EndStep) then

In the case of multiple steps, prepare the transition to the next step. For example, these data can serve as initial values for the next step.

C End of the analysis else if (lOp .eq. j\_int\_EndAnalysis) then

User coding to close files and disconnect any external programs, etc.

```lua
end if
return
end 
```

# Variables to be defined

None.

# Variables that can be updated

i\_Array(i\_int\_lWriteRestart)

i\_Array(i\_int\_lWriteRestart) indicates whether restart data are currently scheduled to be written. When lOp=j\_int\_SetupIncrement, you can optionally modify it either to write restart data or to skip it. A value of 1 would capture the data for a possible future restart of the analysis from the current time point; whereas 0 would forego such restart from the current time point.

i\_Array(i\_int\_iStatus)

i\_Array(i\_int\_iStatus) indicates the status of the analysis and has a default value of j\_int\_Continue. When lOp=j\_int\_SetupIncrement or j\_int\_EndIncrement, you can optionally modify it either to a value of j\_int\_TerminateStep to skip the remainder of the current step or to a value of j\_int\_TerminateAnalysis to terminate the analysis. If you request to terminate the analysis, the analysis will go through one additional increment with a zero time increment size to generate the field output that reflects the state at termination, as described in “Abaqus/Explicit output as a result of analysis termination” in “Output to the output database,” Section 4.1.3 of the Abaqus Analysis User’s Guide. When the passed in value is not equal to j\_int\_Continue, you can coordinate the necessary events with any external program.

r\_Array(i\_flt\_dTime)

Time increment. When lOp=j\_int\_SetupIncrement, it is the time increment proposed for the current increment and it can be modified to control the incrementation. When

<!-- source-page: 403 -->

lOp=j\_int\_StartIncrement, it is the finalized time increment for the increment to be taken; whereas when lOp=j\_int\_EndIncrement, it is the time increment just taken.

Variables passed in for information   
i_Array(i_int_nTotalNodes)
    Total number of nodes in the model.

i_Array(i_int_nTotalElements)
    Total number of elements in the model.

i_Array(i_int_kStep)
    Current step number. When lOp=j_int_StartAnalysis, i_Array(i_int_kStep) gives the restart step number.

i_Array(i_int_kInc)
    Current increment number. When lOp=j_int_StartStep, i_Array(i_int_kInc) gives the restart increment number.

lOp
    lOp=j_int_StartAnalysis indicates that the user subroutine is being called at the start of the analysis. A nonzero i_Array(i_int_kStep) indicates that the analysis is starting from a prior analysis (restart).
    lOp=j_int_StartStep indicates that the user subroutine is being called at the start of a step. A nonzero i_Array(i_int_kInc) indicates a continuation of the step from a prior analysis (restart).
    lOp=j_int_SetupIncrement indicates that the user subroutine is being called to set up an increment and r_Array(i_flt_dTime) can be modified. In addition, i_Array(i_int_lWriteRestart) can be modified to control output of restart data at the end of the current increment. You can also control the continuation of the analysis via i_Array(i_int_iStatus).
    lOp=j_int_StartIncrement indicates that the user subroutine is being called at the start of the agreed increment. You need to import or compute the data necessary for starting the increment.
    lOp=j_int_EndIncrement indicates that the user subroutine is being called at the end of the increment. If you have results to export, this is a good time to do so. You can also control the continuation of the analysis via i_Array(i_int_iStatus).
    lOp=j_int_EndStep indicates that the user subroutine is being called at the end of the step.
    lOp=j_int_EndAnalysis indicates that the user subroutine is being called at the end of the analysis.

r_Array(i_flt_StepTime)
    Value of current step time. When lOp=j_int_SetupIncrement or j_int_StartIncrement, the step time is at the start of the increment. When lOp=j_int_EndIncrement, the step time is at the end of the increment.

<!-- source-page: 404 -->

r\_Array(i\_flt\_TotalTime)   
```txt
Value of current total time. When lOp =j_int_SetupIncrement or j_int_StartIncrement, the total time is at the start of the increment. When lOp =j_int_EndIncrement, the total time is at the end of the increment. 
```

<!-- source-page: 405 -->

# 1.2.5 VFABRIC: User subroutine to define fabric material behavior.

# Product: Abaqus/Explicit

WARNING: The use of this user subroutine generally requires considerable expertise. You are cautioned that the implementation of any realistic constitutive model requires extensive development and testing. Initial testing on a single-element model with prescribed traction loading is strongly recommended.

# References

• “Fabric material behavior,” Section 23.4.1 of the Abaqus Analysis User’s Guide   
• \*FABRIC

# Overview

User subroutine VFABRIC:

• is used to define the mechanical constitutive behavior of a fabric material in the plane of the fabric;   
• is valid for materials that exhibit two “structural” directions that may not be orthogonal to each other with deformation;   
• is used to update the nominal fabric stresses for a given nominal fabric strain where the direct strains are defined as the nominal strain measured along the two yarn directions of the fabric and the engineering shear strain is defined as the drop in the angle between the two yarn directions going from the reference configuration to the current configuration;   
• can be used with elements under plane stress conditions;   
• will be called for blocks of material calculation points for which the material is defined in a user subroutine (“Material data definition,” Section 21.1.2 of the Abaqus Analysis User’s Guide);   
• can use and update solution-dependent state variables;   
• can use any field variables that are passed in; and   
• cannot be used in an adiabatic analysis.

# Component ordering in tensors

The component ordering depends upon whether the tensor is a “strain” variable or a “stress” variable.

# Symmetric tensors

Tensors such as the strain and strain increment have four components, and tensors such as stress have three components, with the difference between the two sets of variables arising from the assumed plane stress condition. The component order with the arrays for these variables is listed in the table below:

<!-- source-page: 406 -->

<table><tr><td>Component</td><td>Strain</td><td>Stress</td></tr><tr><td>1</td><td> $\varepsilon_{11}$ </td><td> $\sigma_{11}$ </td></tr><tr><td>2</td><td> $\varepsilon_{22}$ </td><td> $\sigma_{22}$ </td></tr><tr><td>3</td><td> $\varepsilon_{33}$ </td><td> $\sigma_{12}$ </td></tr><tr><td>4</td><td> $\varepsilon_{12}$ </td><td></td></tr></table>

The shear strain components in user subroutine VFABRIC are stored as tensor components and not as engineering components.

# Initial calculations and checks

In the datacheck phase of the analysis Abaqus/Explicit calls user subroutine VFABRIC with a set of fictitious strains and a totalTime and stepTime that are both equal to 0.0. This step serves as a check on your constitutive relation and calculates the equivalent initial material properties, upon which the initial elastic wave speeds are computed.

# Orientation of the fabric yarn

In general, the yarn directions may not be orthogonal to each other in the reference configuration. You can specify these local directions with respect to the in-plane axes of an orthogonal orientation system at a material point. Both the local directions and the orthogonal system are defined together as a single orientation definition. If the local directions are not specified, these directions are assumed to match the in-plane axes of the orthogonal system. The local direction may not remain orthogonal with deformation. Abaqus updates the local directions with deformation and computes the nominal strains along these directions and the drop in angle between them (the fabric engineering shear strain). The constitutive behavior for the fabric defines the fabric nominal stresses as a function of the fabric strains. Abaqus converts these fabric stresses into the Cauchy stress and the resulting internal forces.

# Material point deletion

Material points that satisfy a user-defined failure criterion can be deleted from the model (see “Userdefined mechanical material behavior,” Section 26.7.1 of the Abaqus Analysis User’s Guide). You must specify the state variable number controlling the element deletion flag when you allocate space for the solution-dependent state variables, as explained in “Fabric material behavior,” Section 23.4.1 of the Abaqus Analysis User’s Guide. The deletion state variable should be set to a value of one or zero in user subroutine VFABRIC. A value of one indicates that the material point is active, while a value of zero indicates that Abaqus/Explicit should delete the material point from the model by setting the stresses to zero. The structure of the block of material points passed to user subroutine VFABRIC remains unchanged during the analysis; deleted material points are not removed from the block. Abaqus/Explicit will pass zero stresses and strain increments for all deleted material points. Once a material point has been flagged as deleted, it cannot be reactivated.

<!-- source-page: 407 -->

```fortran
subroutine vfabric(
C Read only (unmodifiable)variables -
    1    nblock, ndim, npt, layer, kspt, kstep, kinc,
    2    nstatev, nfieldv, nprops,
    3    lOp, jElem, stepTime, totalTime, dt, cmname, coordMp,
    4    charLength, props, density, braidAngle, fabricStrain,
    5    fabricStrainInc,
    6    tempOld, fieldOld, fabricStressOld, stateOld,
    7    tempNew, fieldNew, enerIntern,
C Write only (modifiable)variables -
    8    fabricStressNew, stateNew, enerInelas )
C
C NOTE: In addition to the above "Write only" variables,
C the thickness direction component of fabricStrainInc
C i.e, fabricStrainInc(*,ndirStrain) may also be set by
C the user for changing thickness as a function
C of material in-plane state.
C
    include 'vaba_param.inc'
C
    parameter (ndirStrain = 3, nshr = 1, ndirStress = 2)
C
C NOTE: The constants defined above are used for array
C dimensions below.
C
    dimension
    *    jElem(nblock),
    *    coordMp(nblock,ndim),
    *    charLength(nblock),
    *    props(nprops),
    *    density(nblock),
    *    braidAngle(nblock),
    *    fabricStrain(nblock,ndirStrain+nshr),
    *    strainFabricInc(nblock,ndirStrain+nshr),
    *    tempOld(nblock),
    *    fieldOld(nblock,nfieldv),
    *    fabricStressOld(nblock,ndirStress+nshr),
    *    stateOld(nblock,nstatev),
    *    tempNew(nblock), 
```

<!-- source-page: 408 -->

```txt
* fieldNew(nblock, nfieldv),
* fabricStressNew(nblock, ndirStress+nshr),
* stateNew(nblock, nstatev),
* enerIntern(nblock),
* enerInelas(nblock)
*
character*80 cmname
C
do 100 km = 1, nblock
user coding
100 continue
return
end 
```

# Variables to be defined

fabricStressNew(nblock,ndirStress+nshr)

Nominal fabric stress at each material point at the end of the increment. This nominal fabric stress can be requested as output variable SFABRIC.

stateNew(nblock,nstatev)

State variables at each material point at the end of the increment. You define the size of this array by allocating space for it (see “User subroutines: overview,” Section 18.1.1 of the Abaqus Analysis User’s Guide, for more information). This variable can be requested as output variable SDV.

enerInelas(nblock)

Total inelastic energy density at material points at the end of the increment. This variable can be requested as output variable ENER.

# Variable that can be updated

fabricStrainInc(\*,ndirStrain)

Thickness direction strain increment. The thickness can be requested as output variable STH.

# Variables passed in for information

nblock

Number of material points to be processed in this call to VFABRIC.

ndim

Two for a two-dimensional model and three for a three-dimensional model.

Current integration point number.

<!-- source-page: 409 -->

# layer

Current layer number in the case of a composite section.

# kspt

Current material point number within the section.

# kStep

Current Abaqus step number.

# kInc

Increment number of the current Abaqus step.

# nstatev

Number of user-defined state variables that are associated with this material type (you define this as described in “Allocating space” in “User subroutines: overview,” Section 18.1.1 of the Abaqus Analysis User’s Guide).

# nfieldv

Number of user-defined external field variables.

# nprops

User-specified number of user-defined material properties.

# lOp

Integer flag indicating the computation that is expected. lOp = −2 indicates that the routine is being called to initialize the stresses corresponding to the initial strains, which can be large. lOp = −1 indicates that the routine is being called to update the stresses based on the instantaneous elastic response for a small “artificial” strain increment given. lOp = 0 indicates that this is an annealing process and you should reinitialize the internal state variables, stateNew, if necessary. The stresses will be set to zero by Abaqus. lOp = 1 indicates that the routine is being called to update the stresses and the state for a given strain increment.

# jElem(nblock)

Array of element numbers.

# stepTime

Value of time since the step began.

# totalTime

Value of total time. The time at the beginning of the step is given by totalTime - stepTime.

# dt

Time increment size.

<!-- source-page: 410 -->

# cmname

User-specified material name, left justified. It is passed in as an uppercase character string. Some internal material models are given names starting with the character string “ABQ\_”. To avoid conflict, you should not use “ABQ\_” as the leading string for cmname.

# coordMp(nblock,\*)

Material point coordinates. It is the midplane material point for shell elements and the centroid for beam elements.

# charLength(nblock)

Characteristic element length, which is either the default value based on the geometric mean or the user-defined characteristic element length defined in user subroutine VUCHARLENGTH. The default value is a typical length of a line across an element for a first-order element; it is half of the same typical length for a second-order element. For membranes and shells the default value is a characteristic length in the reference surface.

# props(nprops)

User-supplied material properties.

# density(nblock)

Current density at the material points in the midstep configuration. This value may be inaccurate in problems where the volumetric strain increment is very small. If an accurate value of the density is required in such cases, the analysis should be run in double precision. This value of the density is not affected by mass scaling.

# braidAngle(nblock)

Angle in radians between the two yarn directions at the end of the increment.

# fabricStrain(nblock,ndirStrain+nshr)

Total nominal strain in the fabric at the end of increment. This variable can be requested as output variable EFABRIC.

# fabricStrainInc(nblock,ndirStrain+nshr)

Incremental nominal strain in the fabric.

# tempOld(nblock)

Temperatures at each material point at the beginning of the increment.

# fieldOld(nblock,nfieldv)

Values of the user-defined field variables at each material point at the beginning of the increment.

# fabricStressOld(nblock,ndirStress+nshr)

Nominal fabric stress at each material point at the beginning of the increment.
