<!-- source-page: 151 -->

```txt
dE12Dj = term1 * E12
dE13Dj = term1 * E13
dE23Dj = term1 * E23
term2 = - third * detuInv
d2E11DjDj = term2 * dE11Dj
d2E22DjDj = term2 * dE22Dj
d2E33DjDj = term2 * dE33Dj
d2E12DjDj = term2 * dE12Dj
d2E13DjDj = term2 * dE13Dj
d2E23DjDj = term2 * dE23Dj
*
dUdE11 = d2UdE11dE11 * E11
* + d2UdE11dE22 * E22
* + d2UdE11dE33 * E33
dUdE22 = d2UdE22dE11 * E11
* + d2UdE22dE22 * E22
* + d2UdE22dE33 * E33
dUdE33 = d2UdE33dE11 * E11
* + d2UdE33dE22 * E22
* + d2UdE33dE33 * E33
dUdE12 = two * d2UdE12dE12 * E12
dUdE13 = two * d2UdE13dE13 * E13
dUdE23 = two * d2UdE23dE23 * E23
*
U = half * ( E11*dUdE11 + E22*dUdE22 + E33*dUdE33 )
* + E12*dUdE12 + E13*dUdE13 + E23*dUdE23
*
ua(2) = U
ua(1) = ua(2)
*
du1(1) = xpow * dUdE11
du1(2) = xpow * dUdE22
du1(3) = xpow * dUdE33
du1(4) = xpow * dUdE12
du1(5) = xpow * dUdE13
du1(6) = xpow * dUdE23
du1(7) = dUdE11*dE11Dj + dUdE22*dE22Dj + dUdE33*dE33Dj
* + two * ( dUdE12*dE12Dj
* + dUdE13*dE13Dj
* + dUdE23*dE23Dj )
*
xpow2 = xpow * xpow
```

<!-- source-page: 152 -->

\*

```txt
du2 (indx(1,1)) = xpow2 * d2UdE11dE11
du2 (indx(1,2)) = xpow2 * d2UdE11dE22
du2 (indx(2,2)) = xpow2 * d2UdE22dE22
du2 (indx(1,3)) = xpow2 * d2UdE11dE33
du2 (indx(2,3)) = xpow2 * d2UdE22dE33
du2 (indx(3,3)) = xpow2 * d2UdE33dE33
du2 (indx(1,4)) = zero
du2 (indx(2,4)) = zero
du2 (indx(3,4)) = zero
du2 (indx(4,4)) = xpow2 * d2UdE12dE12
du2 (indx(1,5)) = zero
du2 (indx(2,5)) = zero
du2 (indx(3,5)) = zero
du2 (indx(4,5)) = zero
du2 (indx(5,5)) = xpow2 * d2UdE13dE13
du2 (indx(1,6)) = zero
du2 (indx(2,6)) = zero
du2 (indx(3,6)) = zero
du2 (indx(4,6)) = zero
du2 (indx(5,6)) = zero
du2 (indx(6,6)) = xpow2 * d2UdE23dE23 
```

\*

```txt
du2(indx(1,7)) = xpow * (term1 * dUdE11
* + d2UdE11dE11 * dE11Dj
* + d2UdE11dE22 * dE22Dj
* + d2UdE11dE33 * dE33Dj)
du2(indx(2,7)) = xpow * (term1 * dUdE22
* + d2UdE22dE11 * dE11Dj
* + d2UdE22dE22 * dE22Dj
* + d2UdE22dE33 * dE33Dj)
du2(indx(3,7)) = xpow * (term1 * dUdE33
* + d2UdE33dE11 * dE11Dj
* + d2UdE33dE22 * dE22Dj
* + d2UdE33dE33 * dE33Dj)
du2(indx(4,7)) = xpow * (term1 * dUdE12
* + two * d2UdE12dE12 * dE12Dj)
du2(indx(5,7)) = xpow * (term1 * dUdE13
* + two * d2UdE13dE13 * dE23Dj)
du2(indx(6,7)) = xpow * (term1 * dUdE23
* + two * d2UdE23dE23 * dE13Dj)
du2(indx(7,7)) = dUdE11*d2E11DjDj
```

<!-- source-page: 153 -->

```txt
* +dUdE22*d2E22DjDj
* +dUdE33*d2E33DjDj
* + two*( dUdE12*d2E12DjDj
* +dUdE13*d2E13DjDj
* +dUdE23*d2E23DjDj)
* + d2UdE11dE11 * dE11Dj * dE11Dj
* + d2UdE22dE22 * dE22Dj * dE22Dj
* + d2UdE33dE33 * dE33Dj * dE33Dj
* + two * ( d2UdE11dE22 * dE11Dj * dE22Dj
* +d2UdE11dE33 * dE11Dj * dE33Dj
* +d2UdE22dE33 * dE22Dj * dE33Dj )
* + four * ( d2UdE12dE12 * dE12Dj * dE12Dj
* +d2UdE13dE13 * dE13Dj * dE13Dj
* +d2UdE23dE23 * dE23Dj * dE23Dj )
*
return
end
*
* Maps index from Square to Triangular storage
* of symmetric matrix
*
integer function index( i, j )
*
include 'aba_param.inc'
* 
ii = min(i,j)
jj = max(i,j)
*
indx = ii + jj*(jj-1)/2
*
return
end 
```

<!-- source-page: 154 -->

<!-- source-page: 155 -->

# 1.1.22 UCORR: User subroutine to define cross-correlation properties for random response loading.

Product: Abaqus/Standard

# References

• “Random response analysis,” Section 6.3.11 of the Abaqus Analysis User’s Guide   
• \*CORRELATION   
• “Random response to jet noise excitation,” Section 1.4.10 of the Abaqus Benchmarks Guide

# Overview

User subroutine UCORR:

• can be used to define the coefficients for the cross-correlation matrix in a random response analysis;   
• will be called once for the combination of any two degrees of freedom with nonzero prescribed loads for each load case specified as a concentrated or distributed load or once for the combination of any two excitation directions specified as a base motion;   
• allows correlation coefficients to be defined as a function of nodal coordinates; and   
• ignores any data specified outside the user subroutine for the associated cross-correlation matrix.

# Cross-correlation for base motion excitation

The spatial correlation matrix for base motion excitation is defined by the coefficients $\Psi _ { i j } ^ { I J }$ in user subroutine UCORR, where $i , j$ are excitation directions and J corresponds to the Jth frequency function referenced under load case I.

# Cross-correlation for point loads and distributed loads

The spatial correlation matrix of the load is defined as follows. Let $F _ { ( N , i ) } ^ { I }$ be the load applied to degree of freedom i at node N in load case I, through the use of a concentrated or distributed load. Let J correspond to the Jth frequency function referenced under load case I. The spatial correlation matrix used in the random response analysis for this load case is then

$$
\Psi_ {(N, i) (M, j)} ^ {I J} = C _ {(N, i) (M, j)} ^ {I J} F _ {(N, i)} ^ {I} F _ {(M, j)} ^ {I},
$$

where $C _ { ( N , i ) ( M , j ) } ^ { I J }$ are the coefficients defined in user subroutine UCORR. Typically the load magnitude is given as 1.0; therefore, the load definition is simply selecting the nonzero terms that will appear in $\Psi _ { ( N , i ) ( M , j ) } ^ { \bar { I } , J }$ .

<!-- source-page: 156 -->

User subroutine interface   
```txt
SUBROUTINE UCORR(PSD,CORRR,CORRI,KSTEP,LCASE,JNODE1,JDOF1,1 JNODE2,JDOF2,COOR1,COOR2)
C
INCLUDE 'ABA_PARAM.INC'
C
DIMENSION COOR1(3),COOR2(3)
CHARACTER*80 PSD
user coding to define CORRR and CORRI
RETURN
END 
```

Variables to be defined   
```txt
CORRR
Real part of the cross-correlation scaling factor.
CORRI
Imaginary part of the cross-correlation scaling factor. 
```

Variables passed in for information   
```txt
PSD
User-specified name for the frequency function that references this correlation, left justified.

KSTEP
Step number.

LCASE
Load case number, I.

JNODE1
First node involved, N (not used for base motion excitation).

JDOF1
Degree of freedom i at the first node (for concentrated or distributed load excitation) or global e direction i (for base motion excitation).

JNODE2
Second node involved, M (not used for base motion excitation). 
```

<!-- source-page: 157 -->

# JDOF2

Degree of freedom $j$ at the second node (for concentrated or distributed load excitation) or global excitation direction $j$ (for base motion excitation).

# COOR1

An array containing the coordinates of the first node (not used for base motion excitation).

# COOR2

An array containing the coordinates of the second node (not used for base motion excitation).

<!-- source-page: 158 -->

<!-- source-page: 159 -->

# 1.1.23 UCREEPNETWORK: User subroutine to define time-dependent behavior (creep) for models defined within the parallel rheological framework.

# Product: Abaqus/Standard

# References

• “Parallel rheological framework,” Section 22.8.2 of the Abaqus Analysis User’s Guide   
• “Nonlinear large-strain viscoelasticity with hyperelasticity,” Section 2.2.8 of the Abaqus Verification Guide   
• \*VISCOELASTIC

# Overview

User subroutine UCREEPNETWORK:

• is intended to provide creep laws for nonlinear viscoelastic networks for models defined using the parallel rheological framework (see “Parallel rheological framework,” Section 22.8.2 of the Abaqus Analysis User’s Guide);   
• can use and update solution-dependent state variables; and   
• can be used in conjunction with user subroutine USDFLD to redefine any field variables before they are passed in.

# Model description

The user subroutine allows a creep law of the following general form to be defined:

$$
\dot {\bar {\varepsilon}} ^ {c r} = g ^ {c r} (\bar {\varepsilon} ^ {c r}, I _ {1} ^ {c r}, \bar {I} _ {1}, \bar {I} _ {2}, J, p, \tilde {q}, t, \theta , F V),
$$

where

$$
I _ {1} ^ {c r} = \mathbf {I}: \mathbf {C} ^ {c r},
$$

and

I is the identity tensor, $\mathbf{C}^{cr}$ is the right Cauchy-Green creep strain tensor, $\dot{\bar{\varepsilon}}^{cr}$ is the equivalent creep strain rate, $\bar{\varepsilon}^{cr}$ is the equivalent creep strain, $\bar{I}_1$ is the first invariant of $\bar{\mathbf{B}}$ , $\bar{I}_2$ is the second invariant of $\bar{\mathbf{B}}$ , $J$ is the determinant of the deformation gradient, $\mathbf{F}$ ,

<!-- source-page: 160 -->

p is the Kirchhoff pressure, $\tilde{q}$ is the equivalent deviatoric Kirchhoff stress, $t$ is the time, $\theta$ is the temperature, and $FV$ are field variables.

The left Cauchy-Green strain tensor, , is defined as

$$
\bar {\mathbf {B}} = \bar {\mathbf {F}} \bar {\mathbf {F}} ^ {T},
$$

where is the deformation gradient with volume change eliminated, which is computed using

$$
\bar {\mathbf {F}} = J ^ {- \frac {1}{3}} \mathbf {F}.
$$

The user subroutine must define the increment of creep equivalent strain, $\Delta \bar { \varepsilon } ^ { c r }$ , as a function of the time increment, $\Delta t ,$ and the variables used in the definition of $\boldsymbol { \cdot } \boldsymbol { g } ^ { c r }$ , as well as the derivatives of the equivalent creep strain increment with respect to those variables. If any solution-dependent state variables are included in the definition of $\boldsymbol { g } ^ { c r }$ , they must also be integrated forward in time in this user subroutine.

User subroutine interface   ```csv
subroutine ucreepnetwork (
C Must be updated
* outputData,
C Can be updated
* statev,
C Information (Read only)
* nOutput,
* nstatv,
* networkid,
* coords,
* temp,
* dtemp,
* nfield,
* predef,
* dpred,
* nprops,
* props,
* i_array,
* niarray,
* r_array,
* nrarray,
* c_array, 
```
