<!-- source-page: 391 -->

rotaryI(3, 3, nblock)

Nodal point rotary inertia.

# Example: Imposition of acceleration on a rigid body with nonzero initial velocity

In this example a sinusoidal acceleration is imposed on the reference node of a rigid body. Nonzero initial velocity is also specified for the rigid body. User subroutine VDISP given below illustrates how the return value array is to be computed for different phases of the solution. The analysis results show that both the initial velocity and acceleration are correctly specified.

Input file   
```csv
*HEADING
Test VDISP with S4R element
*NODE, NSET=NALL
1,
2, 2., 0.
3, 0., 2.
4, 2., 2.
9, 1., 1., 0.
*ELEMENT, TYPE=S4R, ELSET=SHELL
10, 1,2,4,3
*SHELL SECTION, ELSET=SHELL, MATERIAL=ELSHELL
2.0000000e-02, 3
*MATERIAL, NAME=ELSHELL
*DENSITY
7850.0,
*ELASTIC
2.5000000e+11, 3.0000000e-01
*RIGID BODY, REF NODE=9, ELSET=SHELL
*INITIAL CONDITIONS, Type=VELOCITY
9, 1, 0.4
*STEP
*DYNAMIC, EXPLICIT, DIRECT USER CONTROL
0.01, 0.8
*BOUNDARY, USER, TYPE=ACCELERATION
9, 1
*OUTPUT, HISTORY, TIME INTERVAL=0.01, OP=NEW
*NODE OUTPUT, NSET=NALL
U, V, A
*END STEP 
```

<!-- source-page: 392 -->

User subroutine   
```fortran
subroutine vdisp(
c Read only variables -
    * nblock, nDof, nCoord, kstep, kinc,
    * steppTime, totalTime, dtNext, dt,
    * cbname, jBCType, jDof, jNodeUid, amp,
    * coordNp, u, v, a, rf, rmass, rotaryI,
c Write only variable -
    * rval )
c
    include 'vaba_param.inc'
    parameter( zero = 0.d0, half = 0.5d0, one = 1.d0 )
c
    character*80 cbname
    dimension jDof(nDof), jNodeUid(nblock),
    * amp(nblock), coordNp(nCoord,nblock),
    * u(nDof,nblock), v(nDof,nblock), a(nDof,nblock),
    * rf(nDof,nblock), rmass(nblock),
    * rotaryI(3,3,nblock), rval(nDof,nblock)
c
c    Impose acceleration
c
    if( jBCType .eq. 2 ) then
c
    if( steppTime .lt. zero ) then
c
c    Initialization 1
c
    do 310 k=1, nblock
    do 310 j=1, nDof
    if ( jDof(j) .gt. 0 ) then
    v0 = v(j,k)
    rval(j,k) = v0/dt
    end if
310    continue
c
    else
c
c    Time incrementation
c
    amplitude = 2.0 
```

<!-- source-page: 393 -->

```fortran
period = 0.8
twopi = 6.2831853d0
c
do 350 k=1, nblock
do 350 j=1, nDof
    if (jDof(j).gt.0) then
    rval(j,k) = amplitude*
*    sin(twopi*stepTime / period)
    end if
350 continue
    end if
    end if
c
    return
    end 
```

<!-- source-page: 394 -->

<!-- source-page: 395 -->

# 1.2.3 VDLOAD: User subroutine to specify nonuniform distributed loads.

# Product: Abaqus/Explicit

# References

• “Applying loads: overview,” Section 34.4.1 of the Abaqus Analysis User’s Guide   
• “Distributed loads,” Section 34.4.3 of the Abaqus Analysis User’s Guide   
• \*DLOAD   
• \*DSLOAD   
• “Deformation of a sandwich plate under CONWEP blast loading,” Section 9.1.9 of the Abaqus Example Problems Guide

# Overview

User subroutine VDLOAD:

• can be used to define the variation of the distributed load magnitude as a function of position, time, velocity, etc. for a group of points, each of which appears in an element-based or surface-based nonuniform load definition;   
• will be called for load integration points associated with each nonuniform load definition including PENU and PINU loads applicable for pipe elements;   
• does not make available the current value of the nonuniform distributed loads for file output purposes; and   
• recognizes an amplitude reference (“Amplitude curves,” Section 34.1.2 of the Abaqus Analysis User’s Guide) if it appears with the associated nonuniform load definition.

# User subroutine interface

```python
subroutine vdload (
C Read only (unmodifiable)variables -
    1 nBlock, ndim, stepTime, totalTime,
    2 amplitude, curCoords, velocity, dirCos, jltyp, sname,
C Write only (modifiable) variable -
    1 value )
C
    include 'vaba_param.inc'
C
    dimension curCoords(nBlock,ndim), velocity(nBlock,ndim),
    1 dirCos(nBlock,ndim,ndim), value(nBlock)
    character*80 sname
C 
```

<!-- source-page: 396 -->

do 100 km = 1, nBlock

user coding to define value

100 continue

return

end

# Variable to be defined

value (nBlock)

Magnitude of the distributed load. Units are FL−2 for surface loads, FL−3 for body forces.

# Variables passed in for information

nBlock

Number of points to be processed in this call to VDLOAD.

ndim

Number of coordinate directions: 2 for two-dimensional models, 3 for three-dimensional models. The model will be considered three-dimensional if any three-dimensional elements are defined (including SPRINGA elements).

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.

amplitude

Current value of the amplitude referenced for this load (set to unity if no amplitude is referenced). You must multiply the load by the current amplitude value within the user subroutine if the amplitude is required.

curCoords (nBlock, ndim)

Current coordinates of each point for which the load is to be calculated.

velocity (nBlock, ndim)

Current velocity of each point for which the load is to be calculated.

dirCos (nBlock, ndim, ndim)

Current orientation of the face, edge, pipe, or beam for pressure type loads (not applicable for body force type loads). The second dimension indicates the vector, and the third dimension indicates the components of that vector. For faces (pressures on three-dimensional continuum, shell, and membrane elements), the first and second vectors are the local directions in the plane of the surface and the third

<!-- source-page: 397 -->

vector is the normal to the face, as defined in “Conventions,” Section 1.2.2 of the Abaqus Analysis User’s Guide. For solid elements the normal points inward, which is the opposite of what is defined in the conventions; for shell elements the normal definition is consistent with the defined conventions. For edges (pressures on two-dimensional continuum elements and two-dimensional beams and pipes), the first vector is the normal to the edge, the second vector is the tangent to the edge, and, if ndim=3, the third vector will be a unit normal in the out-of-plane direction. For three-dimensional beam and pipe elements, the first and second vectors are the local axes ( , ) and the third vector is the tangent vector ( ), as defined in “Beam element cross-section orientation,” Section 29.3.4 of the Abaqus Analysis User’s Guide.

For a discrete element analysis using PD3D elements, the first column of the array is the radius of the element.

# jltyp

Key that identifies the distributed load type. The load type may be a body force, a surface-based load, or an element-based surface load. For element-based surface loads, this variable identifies the element face for which this call to VDLOAD is being made. See Part VI, “Elements,” of the Abaqus Analysis User’s Guide for element load type identification. This information is useful when several different nonuniform distributed loads are being imposed on an element at the same time. The key is as follows:

<table><tr><td>Jltype</td><td>Load type</td></tr><tr><td>0</td><td>Surface-based load</td></tr><tr><td>1</td><td>BXNU</td></tr><tr><td>2</td><td>BYNU</td></tr><tr><td>3</td><td>BZNU</td></tr><tr><td>20</td><td>PNU</td></tr><tr><td>21</td><td>P1NU</td></tr><tr><td>22</td><td>P2NU</td></tr><tr><td>23</td><td>P3NU</td></tr><tr><td>24</td><td>P4NU</td></tr><tr><td>25</td><td>P5NU</td></tr><tr><td>26</td><td>P6NU</td></tr><tr><td>27</td><td>PINU</td></tr><tr><td>28</td><td>PENU</td></tr><tr><td>41</td><td>PXNU</td></tr></table>

<!-- source-page: 398 -->

<table><tr><td>Jltype</td><td>Load type</td></tr><tr><td>42</td><td>PYNU</td></tr><tr><td>43</td><td>PZNU</td></tr></table>

# sname

Surface name for a surface-based load definition (JLTYP=0). For a body force or an element-based load the surface name is passed in as a blank.

<!-- source-page: 399 -->

# 1.2.4 VEXTERNALDB: User subroutine that gives control to the user at key moments of the analysis so that data can be exchanged dynamically among Abaqus user subroutines and with external programs or files.

Product: Abaqus/Explicit

# Reference

• “User subroutines: overview,” Section 18.1.1 of the Abaqus Analysis User’s Guide

# Overview

User subroutine VEXTERNALDB:

• is called once at the beginning of the analysis, at the beginning of each step, before each increment, at the start of each increment, at the end of each increment, at the end of each step, and finally at the end of the analysis;   
• can be used to communicate data between external programs and user subroutines within Abaqus/Explicit;   
• can be used to control the time incrementation of the Abaqus/Explicit analysis;   
• can be used to control the output of the restart data for the analysis;   
• can be used either to skip the remainder of an Abaqus step or to terminate the analysis;   
• can be used to open and close external files as needed for exchange of data with the Abaqus analysis;   
• can be used to exchange data with other user subroutines via user-allocated global and thread-local arrays (see “Allocatable arrays,” Section 2.1.23) and;   
• can be used to exchange data with other Abaqus processes via an MPI mechanism (see “Obtaining parallel processes information,” Section 2.1.4) in domain-parallel analyses.

# Dynamic exchange of data with other Abaqus user subroutines and external programs

Typically, Abaqus user subroutines are called with the context data limited to a specific material point, a specific element, etc. Rarely, you need to know some nonlocal information such as the state of the neighboring material points or elements. In other situations you want to specify the behavior in the user subroutines to depend dynamically on the external programs. Both these complex scenarios can be addressed using user subroutine VEXTERNALDB.

VEXTERNALDB is called once at the beginning of the analysis, at the beginning of each step, before each increment, at the start of each increment, at the end of each increment, at the end of each step, and finally at the end of the analysis. Other Abaqus subroutines are called after the call to user subroutine VEXTERNALDB at the start of the increment but before the next call at the end of that increment.

<!-- source-page: 400 -->

User subroutine interface   
```fortran
subroutine vexternaldb(lOp, i_Array, niArray, r_Array, nrArray)
C
    include 'vaba_param.inc'
C
C Contents of i_Array
    parameter( i_int_nTotalNodes    = 1,
    *    i_int_nTotalElements    = 2,
    *    i_int_kStep    = 3,
    *    i_int_kInc    = 4,
    *    i_int_iStatus    = 5,
    *    i_int_lWriteRestart    = 6 )
C Possible values for the lOp argument
    parameter( j_int_StartAnalysis    = 0,
    *    j_int_StartStep    = 1,
    *    j_int_SetupIncrement    = 2,
    *    j_int_StartIncrement    = 3,
    *    j_int_EndIncrement    = 4,
    *    j_int_EndStep    = 5,
    *    j_int_EndAnalysis    = 6 )
C Possible values for i_Array(i_int_iStatus)
    parameter( j_int_Continue    = 0,
    *    j_int_TerminateStep    = 1,
    *    j_int_TerminateAnalysis    = 2 )
C Contents of r_Array
    parameter( i_flt_TotalTime    = 1,
    *    i_flt_StepTime    = 2,
    *    i_flt_dTime    = 3 )
C dimension i_Array(niArray),
    *    r_Array(nrArray)
    kStep = i_Array(i_int_kStep)
    kInc = i_Array(i_int_kInc) 
```
