<!-- source-page: 91 -->

be considered as a vector function $f ,$ and the first set of degrees of freedom $\mathbf { \delta } _ { u } \mathbf { 1 }$ in the vector function $f$ will be eliminated to impose the constraint. The sets $u ^ { 2 } , u ^ { 3 }$ , etc. are the independent degrees of freedom at nodes 2, 3, etc. involved in the constraint. The set $u ^ { 1 }$ must be composed of NDEP degrees of freedom at the first node of the MPC definition. For example, if the dependent degrees of freedom are the x-displacement, the z-displacement, and the y-rotation at the first node, $\pmb { u } ^ { 1 } = \big ( \bar { u } _ { x } ^ { 1 } , u _ { z } ^ { 1 } , \phi _ { u } ^ { 1 } \big ) . \ \pmb { u } ^ { 2 } , \ \pmb { u } ^ { 3 }$ etc. can be composed of any number of degrees of freedom, depending on which ones play a role in the constraint, and need not be of the same size; for example, $u ^ { 2 } \overset { \cdot } { = } ( u _ { y } ^ { 2 } )$ and ${ \pmb u } ^ { 3 } = ( u _ { x } ^ { 3 } , u _ { y } ^ { 3 } , \bar { u _ { z } ^ { 3 } } )$ .

The dependent node can also reappear as an independent node in the MPC. However, since the dependent degrees of freedom of this node will be eliminated, they cannot be used as independent degrees of freedom in this MPC. For example, if the rotations at node a are constrained by the MPC, the displacements of node a can still be used as independent degrees of freedom in the MPC, but the rotations themselves cannot. Similarly, the degrees of freedom that will be eliminated to impose the constraint cannot be used in subsequent kinematic constraints (multi-point constraints, linear equation constraints, or boundary conditions). The MPCs are imposed in the order given in the input for this purpose.

The nodal version of user subroutine MPC was designed with the application of nonlinear constraints involving large three-dimensional rotations in mind. Due to the incremental nature of the solution procedure in Abaqus/Standard, a linearized set of constraints

$$
\delta f _ {i} = \boldsymbol {A} _ {i} ^ {1} \cdot \delta \boldsymbol {u} ^ {1} + \boldsymbol {A} _ {i} ^ {2} \cdot \delta \boldsymbol {u} ^ {2} + \boldsymbol {A} _ {i} ^ {3} \cdot \delta \boldsymbol {u} ^ {3} + \dots = 0 \quad i = 1, 2, \dots , \text {NDEP},
$$

where $A _ { i } ^ { 1 } \ = \ A _ { i } ^ { 1 } ( u ^ { 1 } , u ^ { 2 } , . . . ) , A _ { i } ^ { 2 } \ = \ A _ { i } ^ { 2 } ( u ^ { 1 } , u ^ { 2 } , . . . )$ , etc. is applied during each iteration. This linearized set of constraints is used for the calculation of equilibrium. For finite rotations the linearized equation is given in terms of the linearized rotations $\delta \pmb { \theta } ^ { 1 } , \delta \pmb { \theta } ^ { 2 } , \delta \pmb { \theta } ^ { 3 } , . . .$ , yielding

$$
\delta f _ {i} = \boldsymbol {A} _ {i} ^ {1} \cdot \delta \boldsymbol {\theta} ^ {1} + \boldsymbol {A} _ {i} ^ {2} \cdot \delta \boldsymbol {\theta} ^ {2} + \boldsymbol {A} _ {i} ^ {3} \cdot \delta \boldsymbol {\theta} ^ {3} + \dots = 0 \quad i = 1, 2, \dots , \mathrm{NDEP}.
$$

Since the linearized rotation field, , is not the variation of the total rotation vector, $\phi$ (see “Rotation variables,” Section 1.3.1 of the Abaqus Theory Guide), you cannot obtain the linearized constraint equation by simply taking derivatives of the vector function, $f ,$ with respect to the rotational degrees of freedom involved. The formulation of the linearized constraint in $\delta \pmb { \theta }$ is equivalent to the formulation of a geometrically linear constraint in the deformed configuration and is generally easier to formulate than the constraint in terms of $\delta \phi$ . For an exact formulation of the constraint, the dependent components of the total rotation vector $\phi ^ { 1 }$ must be defined exactly (see “Rotation variables,” Section 1.3.1 of the Abaqus Theory Guide).

You must provide, at all times, two items of information in subroutine MPC:

1. A matrix of degree of freedom identifiers at the nodes that are listed in the corresponding multipoint constraint definition. The columns of this matrix correspond to $\boldsymbol { u } ^ { 1 } , \boldsymbol { u } ^ { 2 } , \boldsymbol { u } ^ { 3 }$ , etc. in the set of constraints as given above, where unused entries are padded with zeros. The number of nonzero entries in $u ^ { 1 }$ will implicitly determine the number of dependent degrees of freedom, NDEP.   
2. The matrices representing the linearized constraint function with respect to the degrees of freedom involved. These matrices are needed for the redistribution of loads from degrees of freedom $u ^ { 1 }$ to

<!-- source-page: 92 -->

the other degrees of freedom and for the elimination of $u ^ { 1 }$ from the system matrices. For constraints that do not involve three-dimensional rotations and constraints with planar rotations, these matrices can be readily obtained from the derivatives of the total constraint function with respect to the degrees of freedom involved:

$$
A _ {i j} ^ {1} = \frac {\partial f _ {i}}{\partial u _ {j} ^ {1}}, \quad A _ {i j} ^ {2} = \frac {\partial f _ {i}}{\partial u _ {j} ^ {2}}, \quad A _ {i j} ^ {3} = \frac {\partial f _ {i}}{\partial u _ {j} ^ {3}}, \quad \dots
$$

For constraints that involve finite rotations, the matrices follow from the linearized form:

$$
A _ {i j} ^ {1} \delta \theta_ {j} ^ {1} + A _ {i j} ^ {2} \delta \theta_ {j} ^ {2} + A _ {i j} ^ {3} \delta \theta_ {j} ^ {3} + \ldots = 0.
$$

In addition, you can provide the values of the dependent degrees of freedom $u ^ { 1 }$ , as a function of the independent degrees of freedom $u ^ { 2 } , u ^ { 3 }$ etc. For finite rotations, $\phi ^ { 1 }$ must be specified as a function of $\phi ^ { 2 } , \phi ^ { 2 }$ , etc. If these values are not provided, Abaqus/Standard will update $\boldsymbol { u } ^ { 1 }$ based on the linearized form of the constraint equations. Subroutine MPC should be coded and checked with care: if the matrices of derivatives $A _ { i j } ^ { 1 }$ , etc. do not correspond to the definition of $u ^ { 1 }$ in terms of $u ^ { 2 } , u ^ { 3 }$ etc., forces will be transmitted improperly by the MPC and violations of equilibrium may occur. In addition, convergence of the solution may be adversely affected.

User subroutine interface   ```txt
SUBROUTINE MPC(UE,A,JDOF,MDOF,N,JTYPE,X,U,UINIT,MAXDOF, * LMPC,KSTEP,KINC,TIME,NT,NF,TEMP,FIELD,LTRAN,TRAN)
C
INCLUDE 'ABA_PARAM.INC'
C
DIMENSION UE(MDOF),A(MDOF,MDOF,N),JDOF(MDOF,N),X(6,N), * U(MAXDOF,N),UINIT(MAXDOF,N),TIME(2),TEMP(NT,N), * FIELD(NF,NT,N),LTRAN(N),TRAN(3,3,N)
user coding to define JDOF, UE, A and, optionally, LMPC
RETURN
END 
```

<!-- source-page: 93 -->

# JDOF(MDOF,N)

Matrix of degrees of freedom identifiers at the nodes involved in the constraint. Before each call to MPC, Abaqus/Standard will initialize all of the entries of JDOF to zero. All active degrees of freedom for a given column (first index ranging from 1 to MDOF) must be defined starting at the top of the column with no zeros in between. A zero will mark the end of the list for that column. The number of nonzero entries in the first column will implicitly determine the number of dependent degrees of freedom (NDEP). For example, if the dependent degrees of freedom are the z-displacement, the xrotation, and the z-rotation at the first node, NDEP and

$$
\mathrm{JDOF} (1, 1) = 3, \quad \mathrm{JDOF} (2, 1) = 4, \quad \mathrm{JDOF} (3, 1) = 6.
$$

If the degrees of freedom at the third node involved in the MPC are the x-displacement and the yrotation, define

$$
\mathrm{JDOF} (1, 3) = 1, \quad \mathrm{JDOF} (2, 3) = 5.
$$

# A(MDOF,MDOF,N)

Submatrices of coefficients of the linearized constraint function,

$$
\mathsf {A} (\mathsf {I}, \mathsf {J}, 1) = A _ {i j} ^ {1}, \quad \mathsf {A} (\mathsf {I}, \mathsf {J}, 2) = A _ {i j} ^ {2}, \quad \dots
$$

Before each call to user subroutine MPC, Abaqus/Standard will initialize all of the entries of A to zero; therefore, only nonzero entries need to be defined. If the coding in the subroutine defines NDEP nonzero entries in the column JDOF(J,1), it should define NDEP × NDEP entries in the submatrix A(I,J,1). Since this submatrix will be inverted to impose the MPC, it must be nonsingular. A maximum of NDEP × MDOF entries can be defined for the remaining submatrices A(I,J,K), K = 2, , N. The number of columns in each submatrix A(I,J,K) must correspond to the number of nonzero entries in the corresponding column of the matrix JDOF(J,K).

# Variables that can be updated

# UE(NDEP)

This array is passed in as the total value of the eliminated degrees of freedom, $u ^ { 1 }$ . This array will either be zero or contain the current values of $u ^ { 1 }$ based on the linearized constraint equations, depending at which stage of the iteration the user subroutine is called. For small-displacement analysis or perturbation analysis this array need not be defined: Abaqus/Standard will compute $u ^ { 1 }$ as

$$
u _ {i} ^ {1} = - \sum_ {r = 1} ^ {\mathrm{NDEP}} A _ {i r} ^ {1} {} ^ {- 1} \sum_ {s = 2} ^ {\mathrm{N}} \sum_ {t = 1} ^ {\mathrm{MDOF}} A _ {r t} ^ {s} u _ {\mathrm{JDOF} (t, s)} ^ {s} \qquad i = 1, \dots , \mathrm{NDEP}.
$$

<!-- source-page: 94 -->

For large-displacement analysis this array can be updated to the value of $\boldsymbol { u } ^ { 1 }$ at the end of the increment to satisfy the constraint exactly. If the return values are the same as the incoming values, Abaqus/Standard will update the eliminated degrees of freedom based on the linearized form of the constraint equations. In this case the constraint is not likely to be satisfied exactly.

# LMPC

Set this variable to zero to avoid the application of the multi-point constraint. If the variable is not changed, the MPC will be applied. This variable must be set to zero every time the subroutine is called if the user MPC is to remain deactivated. This MPC variable is useful for switching the MPC on and off during an analysis. This option should be used with care: switching off an MPC may cause a sudden disturbance in equilibrium, which can lead to convergence problems.

# Variables passed in for information

# MDOF

Number of active degrees of freedom per node in the analysis. For example, for a coupled temperaturedisplacement analysis with two-dimensional continuum elements, the active degrees of freedom are 1, 2, and 11 and, hence, MDOF will be equal to 3.

# N

Number of nodes involved in the constraint. The value of N is defined as the number of nodes given in the corresponding multi-point constraint definition.

# JTYPE

Constraint identifier given for the corresponding multi-point constraint definition.

# X(6,N)

An array containing the original coordinates of the nodes involved in the constraint.

# U(MAXDOF,N)

An array containing the values of the degrees of freedom at the nodes involved in the constraint. These values will either be the values at the end of the previous iteration or the current values based on the linearized constraint equation, depending at which stage of the iteration the user subroutine is called.

# UINIT(MAXDOF,N)

An array containing the values at the beginning of the current iteration of the degrees of freedom at the nodes involved in the constraint. This information is useful for decision-making purposes when you do not want the outcome of a decision to change during the course of an iteration. For example, there are constraints in which the degrees of freedom to be eliminated change during the course of the analysis, but it is necessary to prevent the choice of the dependent degrees of freedom from changing during the course of an iteration.

<!-- source-page: 95 -->

# MAXDOF

Maximum degree of freedom number at any node in the analysis. For example, for a coupled temperature-displacement analysis with continuum elements, MAXDOF is equal to 11.

# KSTEP

Step number.

# KINC

Increment number within the step.

# TIME(1)

Current value of step time.

# TIME(2)

Current value of total time.

# NT

Number of positions through a section where temperature or field variable values are stored at a node. In a mesh containing only continuum elements, NT=1. For a mesh containing shell or beam elements, NT is the largest of the values specified for the number of temperature points in the shell or beam section definition (or 2 for temperatures specified together with gradients for shells or two-dimensional beams, 3 for temperatures specified together with gradients for three-dimensional beams).

# NF

Number of different predefined field variables requested for any node (including field variables defined as initial conditions).

# TEMP(NT,N)

An array containing the temperatures at the nodes involved in the constraint. This array is not used for a heat transfer, coupled temperature-displacement, coupled thermal-electrical, or coupled thermalelectrical-structural analysis since the temperatures are degrees of freedom of the problem.

# FIELD(NF,NT,N)

An array containing all field variables at the nodes involved in the constraint.

# LTRAN(N)

An integer array indicating whether the nodes in the MPC are transformed. If LTRAN(I)=1, a transformation is applied to node I; if LTRAN(I)=0, no transformation is applied.

# TRAN(3,3,N)

An array containing the local-to-global transformation matrices for the nodes used in the MPC. If no transformation is present at node I, TRAN(\*,\*,I) is the identity matrix.

<!-- source-page: 96 -->

As an example of a nonlinear MPC, consider the insertion of a rigid beam in a large-displacement, planar (two-dimensional) problem. This MPC is the two-dimensional version of library BEAM-type MPC. It can be implemented as a set of three different single degree of freedom MPCs or as a single nodal MPC. Here, the second method will be worked out because it is simpler and requires less data input.

Let a and b (see Figure 1.1.14–2) be the ends of the beam, with a the dependent end.

![](images/page-096_655003410d54524a381141dc8fedadb1043f04dd566e308a804672d81f22bf25.jpg)

<details>
<summary>text_image</summary>

y
x
L
a
b
φ_b^b + φ_0
</details>

Figure 1.1.14–2 Nonlinear MPC example: rigid beam.

The rigid beam will then define both components of displacement and the rotation at a in terms of the displacements and rotation at end b according to the set of equations:

$$
f _ {1} (\boldsymbol {u} ^ {a}, \boldsymbol {u} ^ {b}) = x ^ {a} - x ^ {b} - L \cos (\phi_ {z} ^ {b} + \phi_ {0}) = 0,
$$

$$
f _ {2} (\pmb {u} ^ {a}, \pmb {u} ^ {b}) = y ^ {a} - y ^ {b} - L \sin (\phi_ {z} ^ {b} + \phi_ {0}) = 0,
$$

$$
f _ {3} (\pmb {u} ^ {a}, \pmb {u} ^ {b}) = \phi_ {z} ^ {a} - \phi_ {z} ^ {b} = 0,
$$

where $\pmb { u } ^ { a } = ( u _ { x } ^ { a } , u _ { y } ^ { a } , \phi _ { z } ^ { a } )$ and $\boldsymbol { u } ^ { b } = ( u _ { x } ^ { b } , u _ { y } ^ { b } , \phi _ { z } ^ { b } ) , ( x ^ { a } , y ^ { a } )$ and $( x ^ { b } , y ^ { b } )$ are the current locations of a and $b , \phi _ { z } ^ { a }$ and $\phi _ { z } ^ { b }$ are the rotations at a and b about the z-axis, L is the length of the link, and $\phi _ { 0 }$ is the original orientation of the link.

In terms of the original positions $( X ^ { a } , Y ^ { a } )$ and $( X ^ { b } , Y ^ { b } )$ of a and $\begin{array} { r } { \pmb { b } , } \end{array}$

$$
L = \sqrt {L _ {X} ^ {2} + L _ {Y} ^ {2}}
$$

and

$$
\cos \phi_ {0} = L _ {X} / L,
$$

$$
\sin \phi_ {0} = L _ {Y} / L,
$$

where $L _ { X } = X ^ { a } - X ^ { b }$ and $L _ { Y } = Y ^ { a } - Y ^ { b }$ . Thus, the constraint equations can be expressed as

<!-- source-page: 97 -->

$$
f _ {1} (\boldsymbol {u} ^ {a}, \boldsymbol {u} ^ {b}) = u _ {x} ^ {a} - u _ {x} ^ {b} + L _ {X} - L _ {X} \cos \phi_ {z} ^ {b} + L _ {Y} \sin \phi_ {z} ^ {b} = 0,
$$

$$
f _ {2} (\boldsymbol {u} ^ {a}, \boldsymbol {u} ^ {b}) = u _ {y} ^ {a} - u _ {y} ^ {b} + L _ {Y} - L _ {X} \sin \phi_ {z} ^ {b} - L _ {Y} \cos \phi_ {z} ^ {b} = 0,
$$

$$
f _ {3} (\pmb {u} ^ {a}, \pmb {u} ^ {b}) = \phi_ {z} ^ {a} - \phi_ {z} ^ {b} = 0.
$$

In light of the above formulation, the nontrivial portions of the matrices A and JDOF are

$$
\mathsf {A} (1: 3, 1: 3, 1) = \left( \begin{array}{c c c} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{array} \right), \quad \mathsf {A} (1: 3, 1: 3, 2) = \left( \begin{array}{c c c} - 1 & 0 & L _ {X} \sin \phi_ {z} ^ {b} + L _ {Y} \cos \phi_ {z} ^ {b} \\ 0 & - 1 & - L _ {X} \cos \phi_ {z} ^ {b} + L _ {Y} \sin \phi_ {z} ^ {b} \\ 0 & 0 & - 1 \end{array} \right)
$$

and

$$
\mathrm{JDOF} (1: 3, 1) = \mathrm{JDOF} (1: 3, 2) = \left( \begin{array}{c} 1 \\ 2 \\ 6 \end{array} \right).
$$

Since degree of freedom 6 ( ) appears in this constraint, there must be an element in the mesh that uses that degree of freedom—a B21 beam element, for example.

If the above multi-point constraint is defined as type 1 with nodes a and b, the user subroutine MPC could be coded as follows:
```txt
SUBROUTINE MPC(UE,A,JDOF,MDOF,N,JTYPE,X,U,UINIT,MAXDOF,LMPC,
* KSTEP,KINC,TIME,NT,NF,TEMP,FIELD,LTRAN,TRAN)
C
INCLUDE 'ABA_PARAM.INC'
C
DIMENSION UE(MDOF),A(MDOF,MDOF,N),JDOF(MDOF,N),X(6,N),
* U(MAXDOF,N),UINIT(MAXDOF,N),TIME(2),TEMP(NT,N),
* FIELD(NF,NT,N),LTRAN(N),TRAN(3,3,N)
C
IF (JTYPE .EQ. 1) THEN
COSFIB = COS(U(6,2))
SINFIB = SIN(U(6,2))
ALX = X(1,1) - X(1,2)
ALY = X(2,1) - X(2,2)
C
UE(1) = U(1,2) + ALX*(COSFIB-1.) - ALY*SINFIB
UE(2) = U(2,2) + ALY*(COSFIB-1.) + ALX*SINFIB
UE(3) = U(6,2)
C
A(1,1,1) = 1.
A(2,2,1) = 1.
A(3,3,1) = 1. 
```

<!-- source-page: 98 -->

```prolog
A(1,1,2) = -1.
A(1,3,2) = ALX*SINFIB + ALY*COSFIB
A(2,2,2) = -1.
A(2,3,2) = -ALX*COSFIB + ALY*SINFIB
A(3,3,2) = -1.
C
JDOF(1,1) = 1
JDOF(2,1) = 2
JDOF(3,1) = 6
JDOF(1,2) = 1
JDOF(2,2) = 2
JDOF(3,2) = 6
END IF
C
RETURN
END 
```

# Example: Nonlinear MPC involving finite rotations

As an example of a nonlinear MPC involving finite rotations, consider a two-dimensional constant velocity joint that might be part of a robotics application. Let a, b, c (see Figure 1.1.14–3) be the nodes making up the joint, with a the dependent node.

![](images/page-098_512737e1c62e4f7251984bccbaea6a0be28c00c8003060f74b1a2d139e1a281a.jpg)

<details>
<summary>text_image</summary>

y
x
φ^c
c
b
a
φ^b
</details>

Figure 1.1.14–3 Nonlinear MPC example: constant velocity joint.

The joint is operated by prescribing an axial rotation $\phi ^ { \mathrm { c } } = \phi ^ { \mathrm { c } } \mathbf { e } _ { x }$ at c and an out-of-plane rotation $\phi ^ { b } = $ $\phi ^ { b } \mathbf { e } _ { z }$ at b. The compounding of these two prescribed rotation fields will determine the total rotation at a. We can formally write this constraint as follows:

<!-- source-page: 99 -->

$$
\boldsymbol {f} (\phi^ {a}, \phi^ {b}, \phi^ {c}) = \phi^ {a} - \phi^ {b} \circ \phi^ {c} = 0,
$$

where denotes the rotation product. The formulation of the linearized constraint can be readily achieved from geometrically linear considerations in the deformed state.

In geometrically linear problems compound rotations are obtained simply as the linear superposition of individual rotation vectors. Consider the geometry depicted in Figure 1.1.14–3 and assume that the infinitesimal rotations $\delta \pmb { \theta } ^ { \mathrm { c } } = \delta \theta ^ { \mathrm { c } } \mathbf { e } _ { x }$ and $\delta \pmb { \theta } ^ { b } = \delta \theta ^ { b } \mathbf { e }$ are applied at c and b, respectively. The rotation $\delta \pmb { \theta } ^ { a }$ at a will simply be the sum of the vector $\delta \pmb { \theta } ^ { b }$ to the vector $\delta \pmb { \theta } ^ { c }$ rotated by an angle $\phi ^ { b }$ about the z-axis. Thus, the linearized constraint can be written directly as

$$
\delta f _ {1} \left(\phi^ {a}, \phi^ {b}, \phi^ {c}\right) = \delta \theta_ {x} ^ {a} - \cos \left(\phi^ {b}\right) \delta \theta^ {c} = 0,
$$

$$
\delta f _ {2} (\phi^ {a}, \phi^ {b}, \phi^ {c}) = \delta \theta_ {y} ^ {a} - \sin (\phi^ {b}) \delta \theta^ {c} = 0,
$$

$$
\delta f _ {3} (\phi^ {a}, \phi^ {b}, \phi^ {c}) = \delta \theta_ {z} ^ {a} - \delta \theta^ {b} = 0.
$$

In light of this formulation, the nontrivial portions of the matrices JDOF and A are

$$
\mathrm{JDOF} (1: 3, 1) = \left( \begin{array}{c} 4 \\ 5 \\ 6 \end{array} \right), \quad \mathrm{JDOF} (1, 2) = 6, \quad \mathrm{JDOF} (1, 3) = 4,
$$

and

$$
\mathsf {A} (1: 3, 1: 3, 1) = \left( \begin{array}{c c c} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{array} \right), \quad \mathsf {A} (1: 3, 1, 2) = \left( \begin{array}{c} 0 \\ 0 \\ - 1 \end{array} \right), \quad \mathsf {A} (1: 3, 1, 3) = \left( \begin{array}{c} - \cos (\phi^ {b}) \\ - \sin (\phi^ {b}) \\ 0 \end{array} \right).
$$

Since degrees of freedom 4 $( \phi _ { x } ) , 5 ( \phi _ { y } )$ , and $6 ( \phi _ { z } )$ appear in this constraint, there must be an element in the mesh that uses these degrees of freedom—a B31 beam element, for example. The MPC subroutine has been coded with just this information. In this case Abaqus/Standard updates the dependent rotation field, $\phi ^ { a }$ , based on the linearized constraint equations. Although the constraint is not satisfied exactly, good results are obtained as long as the rotation increments are kept small enough. A more rigorous derivation of the linearized constraint and the exact nonlinear recovery of the dependent degrees of freedom is presented in “Rotation variables,” Section 1.3.1 of the Abaqus Theory Guide.

If the above multi-point constraint is defined as type 1 with nodes $a , b ,$ and $c ,$ user subroutine MPC could be coded as follows:

SUBROUTINE MPC(UE,A,JDOF,MDOF,N,JTYPE,X,U,UINIT,MAXDOF,LMPC,
* KSTEP,KINC,TIME,NT,NF,TEMP,FIELD,LTRAN,TRAN)
C
INCLUDE 'ABA_PARAM.INC'
C
DIMENSION UE(MDOF),A(MDOF,MDOF,N),JDOF(MDOF,N),X(6,N),
* U(MAXDOF,N),UINIT(MAXDOF,N),TIME(2),TEMP(NT,N),

<!-- source-page: 100 -->

\* FIELD(NF,NT,N),LTRAN(N),TRAN(3,3,N)

```txt
IF (JTYPE .EQ. 1) THEN
A(1,1,1) = 1.
A(2,2,1) = 1.
A(3,3,1) = 1.
A(3,1,2) = -1.
A(1,1,3) = -COS(U(6,2))
A(2,1,3) = -SIN(U(6,2)) 
```

C

```txt
JDOF(1,1) = 4
JDOF(2,1) = 5
JDOF(3,1) = 6
JDOF(1,2) = 6
JDOF(1,3) = 4
END IF 
```

```txt
RETURN
END 
```
