<!-- source-page: 431 -->

state(nStates,nNodState,nBlock)

This array contains the user-defined, solution-dependent state variables for all the nodes on the slave surface. The use of state variables is applicable for node-to-face and node-to-analytical rigid surface contact. See “Frictional behavior,” Section 37.1.5 of the Abaqus Analysis User’s Guide, for more information on the size of this array. This array will be passed in containing the values of these variables prior to the call to user subroutine VFRICTION.

If any of the solution-dependent state variables are being used in conjunction with the friction behavior, they must be updated in this subroutine. These state variables need to be updated with care: outside the user subroutine these state variables are single-valued per slave node, but multiple contact points may refer to the same slave node (if it contacts a master surface at more than one point). Each contact point may be passed into the user subroutine independently in a given increment, possibly on separate calls to the user subroutine; therefore, you may end up advancing the state variables for the associated node multiple times for a single increment. To keep track of whether or not a node state is advanced, you may want to use one of the state variables exclusively for this purpose. You could set that selected state variable to the current increment number and update the state only if it is not already set to the current increment number.

Variables passed in for information   
```txt
nBlock
Number of contact points to be processed in this call to VFRICCTION.

nBlockAnal
1 for analytical rigid master surface; nBlock otherwise.

nBlockEdge
nBlock for edge-type slave surface; 1 otherwise.

nNodState
1 for node-to-face contact and node-to-analytical rigid surface contact.

nNodSlv
1 for node-to-face and node-to-analytical rigid surface contact; 2 for edge-to-edge contact.

nNodMst
1 for analytical rigid master surface; 2 for edge-type master surface; 4 for facet-type master surface.

nFricDir
Number of tangent directions at the contact points (nFricDir = nDir - 1).

nDir
Number of coordinate directions at the contact points (equal to 3). 
```

<!-- source-page: 432 -->

nStates

Number of user-defined state variables.

nProps

User-specified number of property values associated with this friction model.

nTemp

1 if the temperature is defined and 0 if the temperature is not defined.

nFields

Number of predefined field variables.

jFlag(1)

Step number.

jFlag(2)

Increment number.

jFlag(3)

1 for node-to-face contact, 2 for edge-to-edge contact, and 3 for node-to-analytical rigid surface contact.

rData(1)

Value of step time.

rData(2)

Value of total time.

rData(3)

Current increment in time from to .

rData(4)

This variable contains the value of the total frictional dissipation in the entire model from the beginning of the analysis. The units are energy per unit area.

surfInt

User-specified surface interaction name, left justified.

surfSlv

Slave surface name, currently set to a blank.

surfMst

Master surface name, currently set to a blank.

jConSlvUid(nNodSlv,nBlock)

This array lists the surface node numbers of the slave surface nodes associated with each contact point.

<!-- source-page: 433 -->

# jConMstUid(nNodMst,nBlockAnal)

This array lists the surface node numbers of the master surface nodes that make up the facet, edge, or analytical rigid surface associated with each contact point.

# props(nProps)

User-specified vector of property values to define the frictional behavior between the contacting surfaces.

# dSlipFric(nDir,nBlock)

This array contains the incremental frictional slip during the current time increment for each contact point in the current local coordinate system. These incremental slips correspond to tangential motion in the time increment from $t = t _ { c u r r } - \Delta t$ to $t = t _ { c u r r }$ . This incremental slip is used to define the local coordinate system at each contact point (see Figure 1.2.8–1) so that only the first component of dSlipFric can be nonzero in the local system.

# fStickForce(nBlock)

This array contains the magnitude of frictional force required to enforce stick conditions at each contact point. This force depends on the previous frictional force, the value of the penalty stiffness, and the previous incremental slip. The penalty stiffness is assigned automatically. Occasionally, during recovery of elastic slip associated with the penalty method, the stick force will be assigned a negative value.

# fTangPrev(nDir,nBlock)

This array contains the values of the frictional force components calculated in the previous increment but provided in the current local coordinate system (zero for nodes that were not in contact).

# fNormal(nBlock)

This array contains the magnitude of the normal force for the contact points applied at the end of current time increment; i.e., at time $t = t _ { c u r r }$ .

# areaCont(nBlock)

Area associated with the contact points. The sum of the contact areas among all contact points associated with a single slave node equals the surface area associated with that slave node (equal to 1 for node-based surface nodes). Therefore, the contact area at a contact point depends on the number of contact points currently associated with the same slave node. A contact point contributes a frictional stress to the associated slave node that is equal to fTangential(1,k) divided by areaCont(k).

# dircosN(nDir,nBlock)

Direction cosines of the normals to the master surface at the contact points.

# dirCosS1(nDir,nBlock)

Direction cosines of the incremental slip at the contact points. The direction cosines are undefined (all components zero) if the incremental frictional slip is zero.

<!-- source-page: 434 -->

shapeSlv(nNodSlv,nBlockEdge)

For edge-to-edge contact this array contains the shape functions of the nodes of its slave edge, evaluated at the location of the contact point. If the contact is not edge-to-edge, this array is passed in as a dummy array.

shapeMst(nNodMst,nBlockAnal)

For node-to-face and edge-to-edge contact this array contains the shape functions of the nodes of its master surface, evaluated at the location of the contact point. If the master surface is an analytical rigid surface, this array is passed in as a dummy array.

coordSlv(nDir,nNodSlv,nBlock)

Array containing the nDir components of the current coordinates of the contact points.

coordMst(nDir,nNodMst,nBlockAnal)

Array containing the nDir components of the current coordinates of the master nodes associated with the contact points. If the master surface is an analytical rigid surface, this array is passed in as a dummy array.

velSlv(nDir,nNodSlv,nBlock)

Array containing the nDir components of the current velocity of the contact points.

velMst(nDir,nNodMst,nBlockAnal)

Array containing the nDir components of the current velocity of the master nodes associated with the contact points. If the master surface is an analytical rigid surface, this array is passed in as a dummy array.

tempSlv(nBlock)

Current temperature of the slave surface at the contact points.

tempMst(nBlockAnal)

Current temperature at the points on the master surface associated with the contact points.

fieldSlv(nFields,nBlock)

Current user-specified predefined field variables on the slave surface at the contact points (initial values at the beginning of the analysis and current values during the analysis).

fieldMst(nFields,nBlockAnal)

Current user-specified predefined field variables at the points on the master surface associated with the contact points (initial values at the beginning of the analysis and current values during the analysis).

<!-- source-page: 435 -->

# 1.2.9 VUAMP: User subroutine to specify amplitudes.

# Product: Abaqus/Explicit

# References

• “Amplitude curves,” Section 34.1.2 of the Abaqus Analysis User’s Guide   
• \*AMPLITUDE   
• \*OUTPUT

# Overview

User subroutine VUAMP:

• allows you to define the current value of an amplitude definition as a function of time;   
• can be used to model control engineering aspects of your system when sensors are used (sensor values are from the beginning of the increment);   
• can use a predefined number of state variables in its definition; and   
• can optionally compute the derivatives and integrals of the amplitude function.

# Explicit solution dependence

The solution dependence introduced in this user subroutine is explicit: all data passed in the subroutine for information or to be updated are values at the beginning of that increment.

# User subroutine interface

SUBROUTINE VUAMP(   
```javascript
* ampName, time, ampValueOld, dt, nprops, props, nSvars,
* svars, lFlagsInfo, nSensor, sensorValues, sensorNames,
* jSensorLookUpTable,
* AmpValueNew,
* lFlagsDefine,
* AmpDerivative, AmpSecDerivative, AmpIncIntegral) 
```  
INCLUDE 'VABA\_PARAM.INC'

```txt
C time indices
parameter (iStepTime = 1,
* iTotalTime = 2,
* nTime = 2) 
```  
C flags passed in for information

<!-- source-page: 436 -->

```prolog
parameter (iInitialization = 1,
* iRegularInc = 2,
* ikStep = 3,
* nFlagsInfo = 3)
C optional flags to be defined
parameter (iComputeDeriv = 1,
* iComputeSecDeriv = 2,
* iComputeInteg = 3,
* iStopAnalysis = 4,
* iConcludeStep = 5,
* nFlagsDefine = 5)
dimension time(nTime), lFlagsInfo(nFlagsInfo),
* lFlagsDefine(nFlagsDefine),
* sensorValues(nSensor),
* props(nprops),
* sVars(nSvars)

character*80 sensorNames(nSensor)
character*80 ampName
dimension jSensorLookUpTable(*)

user coding to define AmpValueNew, and
optionally lFlagsDefine, AmpDerivative, AmpSecDerivative,
AmpIncIntegral

RETURN
END 
```

# Variable to be defined

# AmpValueNew

Current value of the amplitude.

# Variables that can be updated

# lFlagsDefine

Integer flag array to determine whether the computation of additional quantities is necessary or to set step continuation requirements.

lFlagsDefine(iComputeDeriv)

If set to 1, you must provide the computation of the amplitude derivative. The default is 0, which means that Abaqus computes the derivative automatically.

<!-- source-page: 437 -->

<table><tr><td>lFlagsDefine (iComputeSecDeriv)</td><td>If set to 1, you must provide the computation of the amplitude second derivative. The default is 0, which means that Abaqus computes the second derivative automatically.</td></tr><tr><td>lFlagsDefine (iComputeInteg)</td><td>If set to 1, you must provide the computation of the amplitude incremental integral. The default is 0, which means that Abaqus computes the incremental integral automatically.</td></tr><tr><td>lFlagsDefine (iStopAnalysis)</td><td>If set to 1, the analysis will be stopped and an error message will be issued. The default is 0, which means that Abaqus will not stop the analysis.</td></tr><tr><td>lFlagsDefine (iConcludeStep)</td><td>If set to 1, Abaqus will conclude the step execution and advance to the next step (if a next step is available). The default is 0.</td></tr></table>

# svars

An array containing the values of the solution-dependent state variables associated with this amplitude definition. The number of such variables is nsvars (see above). You define the meaning of these variables.

This array is passed into VUAMP containing the values of these variables at the start of the current increment. In most cases they should be updated to be the values at the end of the increment.

# AmpDerivative

Current value of the amplitude derivative.

# AmpSecDerivative

Current value of the amplitude second derivative.

# AmpIncIntegral

Current value of the amplitude incremental integral.

# Variables passed in for information

# ampName

User-specified amplitude name, left justified.

# time(iStepTime)

Current value of step time.

<!-- source-page: 438 -->

time(iTotalTime)

Current value of total time.

ampValueOld

Old value of the amplitude from the previous increment.

dt

Current stable time increment.

nprops

User-defined number of properties associated with this amplitude definition.

props(nprops)

User-supplied amplitude properties.

nSvars

User-defined number of solution-dependent state variables associated with this amplitude definition.

lFlagsInfo

Integer flag array with information regrading the current call to VUAMP:

lFlagsInfo(iInitialization)

This flag is equal to 1 if VUAMP is called from the initialization phase of each step and is set to 0 otherwise.

lFlagsInfo(iRegularInc)

This flag is equal to 1 if VUAMP is called from a regular increment and is set to 0 otherwise.

lFlagsInfo(ikStep)

Step number.

nSensor

Total number of sensors in the model.

sensorValues

Array with sensor values at the end of the previous increment. Each sensor value corresponds to a history output variable associated with the output database request defining the sensor.

sensorNames

Array with user-defined sensor names in the entire model, left justified. Each sensor name corresponds to a sensor value provided with the output database request. All names will be converted to uppercase characters if lowercase or mixed-case characters were used in their definition.

jSensorLookUpTable

Variable that must be passed into the utility functions IVGETSENSORID and VGETSENSORVALUE.

<!-- source-page: 439 -->

Example: Amplitude definition using sensor and state variables   
```txt
c user amplitude subroutine
Subroutine VUAMP(
C    passed in for information and state variables
*    ampName, time, ampValueOld, dt, nprops, props, nSvars,
*    svars, lFlagsInfo, nSensor, sensorValues, sensorNames,
*    jSensorLookUpTable,
C    to be defined
*    ampValueNew,
*    lFlagsDefine,
*    AmpDerivative, AmpSecDerivative, AmpIncIntegral)
include 'vaba_param.inc'
C    svars - additional state variables, similar to (V)UEL
    dimension sensorValues(nSensor), props(nprops),
*    svars(nSvars)
    character*80 sensorNames(nSensor)
    character*80 ampName
C    time indices
    parameter( iStepTime    = 1,
*    iTotalTime    = 2,
*    nTime    = 2)
C    flags passed in for information
    parameter( iInitialization    = 1,
*    iRegularInc    = 2,
*    ikStep    = 3,
*    nFlagsInfo    = 3)
C    optional flags to be defined
    parameter( iComputeDeriv    = 1,
*    iComputeSecDeriv    = 2,
*    iComputeInteg    = 3,
*    iStopAnalysis    = 4,
*    iConcludeStep    = 5,
*    nFlagsDefine    = 5)
    parameter( tStep=0.18, tAccelerateMotor = .00375,
*    omegaFinal=23.26) 
```  
c Alternatively, assign the user-defined amplitude

<!-- source-page: 440 -->

```txt
c properties on the data lines rather than using a parameter
c definition above.
c tStep = props(1)
c tAccelerateMotor = props(2)
c omegaFinal = props(3)

    dimension time(nTime), lFlagsInfo(nFlagsInfo),
    *    lFlagsDefine(nFlagsDefine)
    dimension jSensorLookUpTable(*)

    lFlagsDefine(iComputeDeriv)    = 1
    lFlagsDefine(iComputeSecDeriv) = 1

c get sensor value
    vTrans_CU1    = vGetSensorValue('HORIZ_TRANSL_MOTION',
    *    jSensorLookUpTable,
    *    sensorValues)

    if (ampName(1:22) .eq. 'MOTOR_WITH_STOP_SENSOR') then
    if (lFlagsInfo(iInitialization).eq.1) then
    ampValueNew    = ampValueOld

    svars(1) = 0.0
    svars(2) = 0.0
    else
    tim = time(iStepTime)

c ramp up the angular rot velocity of the electric
c motor after which hold constant
    if (tim .le. tAccelerateMotor) then
    ampValueNew = omegaFinal*tim/tAccelerateMotor

    else
    ampValueNew = omegaFinal
    end if

c retrieve old sensor value
    vTrans_CU1_old = svars(1)

c detect a zero crossing and count the number of
c crossings
    if (vTrans_CU1_old*vTrans_CU1 .le. 0.0 .and. 
```