<!-- source-page: 61 -->

# Total (integrated) strain

The default “integrated” strain measure, E, output by Abaqus/Standard to the data (.dat) and results (.fil) files for all elements that can handle finite strain is obtained by integrating the strain rate numerically in a material frame of reference:

$$
\boldsymbol {\varepsilon} ^ {n + 1} = \Delta \mathbf {R} \cdot \boldsymbol {\varepsilon} ^ {n} \cdot \Delta \mathbf {R} ^ {T} + \Delta \boldsymbol {\varepsilon},
$$

where $\varepsilon ^ { n + 1 }$ and $\varepsilon ^ { n }$ are the total strains at increments $n + 1$ and n, respectively; is the incremental rotation tensor; and $\Delta \varepsilon$ is the total strain increment from increment n to $n + 1$ . For elements that use a corotational coordinate system (finite-strain shells, membranes, and solid elements with user-defined orientations), the above equation simplifies to

$$
\varepsilon^ {n + 1} = \varepsilon^ {n} + \Delta \varepsilon .
$$

The strain increment is obtained by integration of the rate of deformation over the time increment:

$$
\Delta \varepsilon = \int_ {t ^ {n}} ^ {t ^ {n + 1}} \mathbf {D} d t.
$$

This strain measure is appropriate for elastic-(visco)plastic or elastic-creeping materials, because the plastic strains and creep strains are obtained by the same integration procedure. In such materials the elastic strains are small (because the yield stress is small compared to the elastic modulus), and the total strains can be compared directly with the plastic strains and creep strains.

If the principal directions of straining rotate with respect to the material axes, the resulting strain measure cannot be related to the total deformation, regardless whether a spatial or corotational coordinate system is used. If the principal directions remain fixed in the material axes, the strain is the integration of the rate of deformation,

$$
\varepsilon^ {n + 1} = \int_ {0} ^ {t ^ {n + 1}} \mathbf {D} d t,
$$

which is equivalent to the logarithmic strain discussed later.

# Green’s strain

For small-strain shells and beams in Abaqus/Standard, the default strain measure, E, is Green’s strain:

$$
\boldsymbol {\varepsilon} ^ {G} = \frac {1}{2} (\mathbf {F} ^ {T} \cdot \mathbf {F} - \mathbf {I}),
$$

where is the deformation gradient and is the identity tensor. This strain measure is appropriate for the small-strain, large-rotation approximation used in these elements. The components of $\varepsilon ^ { G }$ represent strain along directions in the original configuration. The small-strain shells and beams should not be

<!-- source-page: 62 -->

used in finite-strain analysis with either elastic-plastic or hyperelastic material behavior, since incorrect analysis results may be obtained or program failure may occur.

# Nominal strain

The nominal strain, NE, is

$$
\pmb {\varepsilon} ^ {N} = \mathbf {V} - \mathbf {I} = \sum_ {i = 1} ^ {3} \left(\lambda_ {i} - 1\right) \mathbf {n} _ {i} \mathbf {n} _ {i} ^ {T},
$$

where $\mathbf { V } = { \sqrt { \mathbf { F } \cdot \mathbf { F } ^ { T } } }$ is the left stretch tensor, $\lambda _ { i }$ are the principal stretches, and $\mathbf { n } _ { i }$ are the principal stretch directions in the current configuration. The principal values of nominal strain are, therefore, the ratios of change in length to length in the reference configuration in the principal directions, thus giving a direct measure of deformation.

# Logarithmic strain

The logarithmic strain, LE, is

$$
\pmb {\varepsilon} ^ {L} = \ln \mathbf {V} = \sum_ {i = 1} ^ {3} \ln \lambda_ {i} \mathbf {n} _ {i} \mathbf {n} _ {i} ^ {T},
$$

where the variables are as defined earlier for nominal strain. This is also the strain output for hyperelastic materials. For a hyper-viscoleastic material, the logarithmic elastic strain EE is computed from the current (relaxed) stress state, and the viscoelastic strain CE is computed as LE − EE.

# Stress invariants

Many of the constitutive models in Abaqus are formulated in terms of stress invariants. These invariants are defined as the equivalent pressure stress,

$$
p = - \frac {1}{3} \mathrm{trace} (\pmb {\sigma});
$$

the Mises equivalent stress,

$$
q = \sqrt {\frac {3}{2} (\mathbf {S} : \mathbf {S})};
$$

and the third invariant of deviatoric stress,

$$
r = (\frac {9}{2} \mathbf {S} \cdot \mathbf {S}: \mathbf {S}) ^ {\frac {1}{3}};
$$

where is the deviatoric stress, defined as

$$
\mathbf {S} = \boldsymbol {\sigma} + p \mathbf {I}.
$$

<!-- source-page: 63 -->

The following convention is used for finite rotations in space: Define $\phi _ { x } , \phi _ { y } , \phi _ { z }$ as “rotations” about the global X, Y, and Z-axes (that is, degrees of freedom 4, 5, and 6 at a node). Then define

$$
p _ {x} = \phi_ {x} / \phi , \quad p _ {y} = \phi_ {y} / \phi , \quad p _ {z} = \phi_ {z} / \phi ,
$$

where

$$
\phi = \sqrt {\phi_ {x} ^ {2} + \phi_ {y} ^ {2} + \phi_ {z} ^ {2}}.
$$

The direction is then the axis of rotation, and $\phi$ is the angular rotation (in radians) about the axis according to the right-hand rule (see Figure 1.2.2–2).

![](images/page-063_b69eadf841e4da82beedebc209a99d5bf3190edefbaf0950960ffcbabbc1c774.jpg)

<details>
<summary>text_image</summary>

z
p
Same vector rotated
by (φₓ, φᵧ, φ_z)
φ
y
Initial vector
x
</details>

Figure 1.2.2–2 Definition of finite rotation.

<!-- source-page: 64 -->

The value of $\phi$ is not uniquely determined. In large-rotation problems where the overall rotation exceeds $2 \pi$ , any multiple of can be added or subtracted, which may lead to discontinuous output values for the rotation components. If rotations larger than $2 \pi$ about one axis occur in the positive (negative) direction in Abaqus/Standard, the rotation output varies discontinuously between $\boldsymbol { \theta }$ and ( ). In Abaqus/Explicit the rotation output varies in all cases between $- 2 \pi$ and .

This convention provides straightforward input of kinematic boundary conditions and moments in most cases and simple interpretation of the output. The rotations output by Abaqus represent a single rotation from the reference configuration to the current configuration about a fixed axis. The output does not follow the history of rotation at a node. In addition, this convention reduces to the usual convention for small rotations, even in the case of small rotations superposed on an initial finite rotation (such as might be considered in the study of small vibrations about a predeformed state).

# Compound rotations

Because finite rotations are not additive, the way they must be specified is a bit different from the way other boundary conditions are specified: the increment in rotation specified over a step must be the rotation needed to rotate the node from the configuration at the beginning of the step to that desired at the end of the step. It is not enough to rotate the node over this step to a total rotation vector that would have taken the node into its final configuration if applied on the node in some other initial reference configuration. If an increment of rotation $( \Delta \phi _ { x } , \Delta \phi _ { y } , \Delta \phi _ { z } )$ is needed to rotate from the rotation boundary condition $( \phi _ { x } , \phi _ { y } , \phi _ { z } ) ^ { t }$ at the beginning of the step (and at the end of the previous step) to its final position at the end of the step, the boundary condition must be specified such that the rotation vector is $( \phi _ { x } ^ { t } + \Delta \phi _ { x } , \phi _ { y } ^ { t } + \Delta \phi _ { y } , \phi _ { z } ^ { t } + \Delta \phi _ { z } )$ at the end of the step. If the direction of the rotation vector is constant, this method of specifying rotation boundary conditions and the total rotation vector will be the same.

# Example

As an example of how to specify compound finite rotations and to interpret finite rotation output, consider the following example of the rotation of a beam.

The beam initially lies along the x-axis. We want to perform the compound rotation, where (Step 1) the beam is rotated by $6 0 ^ { \circ }$ about the z-axis, followed by (Step 2) a $9 0 ^ { \circ }$ spin of the beam about itself, followed by $( { \mathrm { S t e p } } 3 ) { \mathrm { a } } 9 0 ^ { \circ }$ rotation of the beam about an axis perpendicular to the beam in the x–y plane, such that the beam finishes on the z-axis.

This compound rotation is achieved in three steps with applied rotation vectors $\phi _ { 1 } , \phi _ { 2 }$ , and $\phi _ { 3 }$ , where

$$
\begin{array}{l} \phi_ {1} = \phi_ {1} \mathbf {e} _ {z} = \left\{ \begin{array}{c c c} 0 & 0 & 1. 0 4 7 1 9 8 \end{array} \right\} ^ {T}, \\ \phi_ {2} = \phi_ {2} (\cos \phi_ {1} \mathbf {e} _ {x} + \sin \phi_ {1} \mathbf {e} _ {y}) = \left\{ \begin{array}{l l} 0. 7 8 5 3 9 8 & 1. 3 6 0 3 5 0 \quad 0 \end{array} \right\} ^ {T}, \quad \text { and } \\ \phi_ {3} = \phi_ {3} (\sin \phi_ {1} \mathbf {e} _ {x} - \cos \phi_ {1} \mathbf {e} _ {y}) = \left\{ \begin{array}{l l l} 1. 3 6 0 3 5 0 & - 0. 7 8 5 3 9 8 & 0 \end{array} \right\} ^ {T}. \\ \end{array}
$$

For this example $\phi _ { 1 } = \pi / 3 , \phi _ { 2 } = \pi / 2$ , and $\phi _ { 3 } ~ = ~ \pi / 2$ . Here $\phi _ { i }$ represents the magnitude of each finite rotation about the (unit length) rotation axis. The rotation vectors above are applied in each of the

<!-- source-page: 65 -->

three steps on the configuration at the beginning of that step. It is most straightforward to prescribe these rotations with velocity-type boundary conditions. For convenience, the default amplitude reference in Abaqus for a velocity-type boundary condition is a constant value of one.

A typical Abaqus step definition for this example, where node 1 is pinned at the origin and the rotation is applied to node 2, is as follows:

```csv
*STEP, NLGEOM
Step 1: Rotate 60 degrees about the z-axis
*STATIC
*BOUNDARY, TYPE=VELOCITY
2, 4, 5
2, 6, 6, 1.047198
*END STEP
**
*STEP, NLGEOM
Step 2: Rotate 90 degrees about the beam axis
*STATIC
*BOUNDARY, TYPE=VELOCITY
2, 4, 4, 0.785398
2, 5, 5, 1.36035
2, 6, 6
*END STEP
**
*STEP, NLGEOM
Step 3: Rotate beam onto z-axis
*STATIC
*BOUNDARY, TYPE=VELOCITY
2, 4, 4, 1.36035
2, 5, 5, -0.785398
2, 6, 6
*END STEP 
```

The above method for applying finite-rotation boundary conditions (using a velocity-type boundary condition with the default constant amplitude definition) is strongly recommended. However, if the rotation boundary conditions are applied as displacement-type boundary conditions, the input syntax would change.

The Abaqus/Standard convention for boundary condition specification within a step is to specify the total or final boundary state. In such a case the specified boundary conditions from all of the previous steps must be added to the incremental rotation vector components. The Abaqus/Standard step definitions from above would change to:

```txt
*STEP, NLGEOM
Step 1: Rotate 60 degrees about the z-axis
*STATIC 
```

<!-- source-page: 66 -->

```csv
*BOUNDARY
2, 4, 5
2, 6, 6, 1.047198
*END STEP
**
*STEP, NLGEOM
Step 2: Rotate 90 degrees about the beam axis
*STATIC
*BOUNDARY
2, 4, 4, 0.785398
2, 5, 5, 1.36035
2, 6, 6, 1.047198
*END STEP
**
*STEP, NLGEOM
Step 3: Rotate beam onto z-axis
*STATIC
*BOUNDARY
2, 4, 4, 2.145748
2, 5, 5, 0.574952
2, 6, 6, 1.047198
*END STEP 
```

The boundary conditions in Steps 2 and 3 are the sum of the incremental rotation components plus the rotation boundary conditions specified in the previous steps.

In Abaqus/Explicit references to amplitude definitions should be used such that there are no jumps in displacement across the steps. It is often convenient to use amplitude definitions given in terms of total time for this purpose. The displacement boundary conditions will be applied incrementally based on the increment in the value of amplitude curve over the time increment. Therefore, any sudden jumps in displacement at the beginning of a step introduced either without the amplitude curves or with two amplitude curves will be ignored (see “Boundary conditions in Abaqus/Standard and Abaqus/Explicit,” Section 34.3.1). The Abaqus/Explicit step definitions for the above example would change to:

```csv
*AMPLITUDE, TIME=TOTAL TIME, NAME=RAMPUR1
0., 0., 0.001, 0., 0.002, 0.785398, 0.003, 2.145748
*AMPLITUDE, TIME=TOTAL TIME, NAME=RAMPUR2
0., 0., 0.001, 0., 0.002, 1.36035, 0.003, 0.574952
*AMPLITUDE, TIME=TOTAL TIME, NAME=RAMPUR3
0., 0., 0.001, 1.047198, 0.002, 1.047198, 0.003, 1.047198
*STEP
Step 1: Rotate 60 degrees about the z-axis
*DYNAMIC, EXPLICIT
, 0.001 
```

<!-- source-page: 67 -->

```c
*BOUNDARY, AMP=RAMPUR1
2, 4, 4, 1.0
*BOUNDARY, AMP=RAMPUR2
2, 5, 5, 1.0
*BOUNDARY, AMP=RAMPUR3
2, 6, 6, 1.0
*END STEP
**
*STEP
Step 2: Rotate 90 degrees about the beam axis
*DYNAMIC, EXPLICIT
, 0.001
*END STEP
**
*STEP
Step 3: Rotate beam onto z-axis
*DYNAMIC, EXPLICIT
, 0.001
*END STEP 
```

The boundary conditions in Steps 2 and 3 are the sum of the incremental rotation components plus the rotation boundary conditions specified in the previous steps.

The Abaqus output of the rotation field at the end of Step 3 is

$$
\mathrm{UR} 1 = 1. 9 2 7, \mathrm{UR} 2 = - 0. 5 1 6 3, \mathrm{UR} 3 = 1. 9 2 7.
$$

We see that none of the individual components of the specified boundary conditions appears in the final rotation output. The final rotation output represents the rotation vector required to obtain the final orientation in a single step.

Suppose that in Step 3 of the previous example we want to apply the rotation vector at node 1 instead of at node 2. If the rotation is applied incrementally, the Abaqus/Standard step definition is as follows:
```csv
*STEP, NLGEOM
Step 3: Rotate beam onto z-axis
*STATIC
*BOUNDARY, TYPE=VELOCITY, OP=NEW
1, 1, 3
1, 4, 4, 1.36035
1, 5, 5, -0.785398
1, 6, 6
*END STEP 
```

<!-- source-page: 68 -->

and the Abaqus/Explicit step definition is similar. It is necessary to remove the rotation boundary conditions that are in effect at node 2.

As mentioned previously, using velocity-type boundary conditions is the preferred method for applying finite-rotation boundary conditions. If the rotation boundary condition is to be applied as a displacement-type boundary condition, we must first retrieve the rotation field at node 1 at the end of Step 2. The Abaqus output of this rotation field is

$$
\mathrm{UR} 1 = 1. 4 1 2, \mathrm{UR} 2 = 0. 8 1 5 5, \mathrm{UR} 3 = 0. 8 1 5 5.
$$

These rotation vector components must then be added to the incremental rotation vector components we wish to prescribe in Step 3. The Abaqus/Standard step definition would change to
```txt
*STEP
Step 3: Rotate beam onto z-axis
*STATIC
*BOUNDARY, OP=NEW
1, 1, 3
1, 4, 4, 2.772
1, 5, 5, 0.0301
1, 6, 6, 0.8155
*END STEP 
```

and the Abaqus/Explicit step definition would change to:

```csv
*STEP
Step 3: Rotate beam onto z-axis
*DYNAMIC, EXPLICIT
, 0.001
*AMPLITUDE, TIME=STEP TIME, NAME=NODE1UR1
0., 1.412, 0.001, 2.772
*AMPLITUDE, TIME=STEP TIME, NAME=NODE1UR2
0., 0.8155, 0.001, 0.0301
*AMPLITUDE, TIME=STEP TIME, NAME=NODE1UR3
0., 0.8155, 0.001, 0.8155
*BOUNDARY, OP=NEW
1, 1, 3
*BOUNDARY, OP=NEW, AMP=NODE1UR1
1, 4, 4, 1.
*BOUNDARY, OP=NEW, AMP=NODE1UR2
1, 5, 5, 1.
*BOUNDARY, OP=NEW, AMP=NODE1UR3
1, 6, 6, 1.
*END STEP 
```

<!-- source-page: 69 -->

The boundary conditions are again specified in the Abaqus/Explicit input using amplitude curves to avoid any sudden jump in their values at the beginning of the step. As stated above and in “Boundary conditions in Abaqus/Standard and Abaqus/Explicit,” Section 34.3.1, any jumps in the displacement values will be ignored and the boundary will be maintained at the previous values.

As this last procedure clearly demonstrates, it is simpler to apply finite-rotation boundary conditions as velocity-type boundary conditions rather than as displacement-type boundary conditions. The recommended method of specifying finite-rotation boundary conditions is also described in “Boundary conditions in Abaqus/Standard and Abaqus/Explicit,” Section 34.3.1. For further discussion of how finite rotations are accumulated, see “Rotation variables,” Section 1.3.1 of the Abaqus Theory Guide.

<!-- source-page: 70 -->
