<!-- source-page: 81 -->

# TIME(1)

Step time at the end of the increment.

# TIME(2)

Total time at the end of the increment.

# DTIME

Time increment.

# PREDEF(\*)

An array containing the values of all of the user-specified field variables at this point (initial values at the beginning of the analysis and current values during the analysis).

# DPRED(\*)

Array of increments of predefined field variables.

<!-- source-page: 82 -->

<!-- source-page: 83 -->

# 1.1.14 MPC: User subroutine to define multi-point constraints.

# Product: Abaqus/Standard

# References

• “General multi-point constraints,” Section 35.2.2 of the Abaqus Analysis User’s Guide   
• \*MPC

# Overview

# User subroutine MPC:

• is called to impose a user-defined multi-point constraint and is intended for use when general constraints cannot be defined with one of the MPC types provided by Abaqus/Standard;   
• can use only degrees of freedom that also exist on an element somewhere in the same model (methods for overcoming this limitation are discussed below);   
• can generate linear as well as nonlinear constraints;   
• allows definition of constraints involving finite rotations; and   
• makes it possible to switch constraints on and off during an analysis.

# Coding methods

There are two methods for coding this routine. By default, the subroutine operates in a degree of freedom mode. In this mode each call to this subroutine allows one individual degree of freedom to be constrained. Alternatively, you can specify that the subroutine operate in a nodal mode. In this mode each call to this subroutine allows a set of constraints to be imposed all at once; that is, on multiple degrees of freedom of the dependent node. In either case, the routine will be called for each user-subroutine-defined multi-point constraint or set of constraints. See “General multi-point constraints,” Section 35.2.2 of the Abaqus Analysis User’s Guide, for details.

# Constraints that involve rotational degrees of freedom

In geometrically nonlinear analyses Abaqus/Standard compounds three-dimensional rotations based on a finite-rotation formulation and not by simple addition of the individual rotation components (see “Conventions,” Section 1.2.2 of the Abaqus Analysis User’s Guide, and “Rotation variables,” Section 1.3.1 of the Abaqus Theory Guide). An incremental rotation involving one component usually results in changes in all three total rotation components. Therefore, any general constraint that involves large three-dimensional rotations should be implemented using the nodal mode of user subroutine MPC. The single degree of freedom version of user subroutine MPC can be used for geometrically linear problems, geometrically nonlinear problems with planar rotations, and constraints that do not involve rotation components.

<!-- source-page: 84 -->

The degrees of freedom involved in user MPCs must appear on some element or Abaqus/Standard MPC type in the model: user MPCs cannot use degrees of freedom that have not been introduced somewhere on an element. For example, a mesh that uses only continuum (solid) elements cannot have user MPCs that involve rotational degrees of freedom. The simplest way to overcome this limitation is to introduce an element somewhere in the model that uses the required degrees of freedom but does not affect the solution in any other way. Alternatively, if the degrees of freedom are rotations, they can be activated by the use of a library BEAM-type MPC somewhere in the model.

# Use with nodal coordinate systems

When a local coordinate system (“Transformed coordinate systems,” Section 2.1.5 of the Abaqus Analysis User’s Guide) and a user MPC are both used at a node, the variables at the node are first transformed before the MPC is imposed. Therefore, user-supplied MPCs must be based on the transformed degrees of freedom. The local-to-global transformation matrices $\mathbf { T } ^ { I }$ for the individual nodes:

$$
\mathbf {u} _ {g l o b a l} ^ {I} = \mathbf {T} ^ {I} \cdot \mathbf {u} _ {l o c a l} ^ {I}
$$

are passed in for information.

# Degree of freedom version of user subroutine MPC

This version of user subroutine MPC allows for one individual degree of freedom to be constrained and, thus, eliminated at a time. The constraint can be quite general and nonlinear of the form:

$$
f (u ^ {1}, u ^ {2}, u ^ {3}, \dots , u ^ {N}, \text {   geometry,   temperature,   field   variables   }) = 0.
$$

The first degree of freedom in this function, $u ^ { 1 }$ , is the degree of freedom that will be eliminated to impose the constraint. $u ^ { 2 } , u ^ { 3 }$ , etc. are any other degrees of freedom that are involved in the constraint. Since $u ^ { 1 }$ will be eliminated to impose the constraint, it cannot be used in subsequent kinematic constraints (multi-point constraints, linear equation constraints, or boundary conditions). Therefore, the user MPCs are imposed in the order given in the input.

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

1. A list of degree of freedom identifiers at the nodes that are listed in the corresponding multi-point constraint definition. This list corresponds to $u ^ { 1 } , u ^ { 2 } , u ^ { 3 }$ , etc. in the constraint as given above.   
2. An array of the derivatives

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

<!-- source-page: 85 -->

of the constraint function with respect to the degrees of freedom involved. This array is needed for the redistribution of loads from degree of freedom $u ^ { 1 }$ to the other degrees of freedom and for the elimination of $u ^ { 1 }$ from the system matrices.

In addition, you can provide the value of the dependent degree of freedom $u ^ { 1 }$ as a function of the independent degrees of freedom $u ^ { 2 } , u ^ { 3 }$ etc. If this value is not provided, Abaqus/Standard will update $u ^ { 1 }$ based on the linearized form of the constraint equation as

$$
u ^ {1} = - \frac {1}{A ^ {1}} \sum_ {i = 2} ^ {N} A ^ {i} u ^ {i}.
$$

Subroutine MPC should be coded and checked with care: if the array of derivatives $\partial f / \partial \boldsymbol { u } ^ { 1 }$ , etc. does not correspond to the definition of $\cdot _ { 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   ```fortran
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 A(N),JDOF(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 UE, A, JDOF, and, optionally, LMPC
RETURN
END 
```  
Variables to be defined   
A(N)

An array containing the derivatives of the constraint function,

$$
A (1) = \frac {\partial f}{\partial u ^ {1}}, \quad A (2) = \frac {\partial f}{\partial u ^ {2}}, \quad \dots
$$

The coding in the subroutine must define N entries in A, where N is defined below.

<!-- source-page: 86 -->

# JDOF(N)

An array containing the degree of freedom identifiers at the nodes that are involved in the constraint. For example, if $u ^ { 1 }$ is the z-displacement at a node, give JDOF(1) = 3; if $u ^ { 2 }$ is the x-displacement at a node, give $\pmb { \sigma } \pmb { \mathrm { D } } \pmb { 0 } \pmb { \mathrm { F } } ( 2 ) = 1$ . The coding in the subroutine must define N entries in JDOF, where N is defined below.

# Variables that can be updated

# UE

This variable is passed in as the total value of the eliminated degree of freedom, $u ^ { 1 }$ . This variable will either be zero or have the current value of $\mathit { \Pi } _ { u } ^ { 1 }$ based on the linearized constraint equation, depending at which stage of the iteration the user subroutine is called. If the constraint is linear and is used in a smalldisplacement analysis (nonlinear geometric effects are not considered) or in a perturbation analysis, this variable need not be defined: Abaqus/Standard will compute $u ^ { 1 }$ as

$$
u ^ {1} = - \frac {1}{A ^ {1}} \sum_ {i = 2} ^ {N} A ^ {i} u ^ {i}.
$$

If the constraint is nonlinear, this variable should be updated to the value of $u ^ { 1 }$ at the end of the increment to satisfy the constraint exactly. If the return value is the same as the incoming value, Abaqus/Standard will update the eliminated degree of freedom based on the linearized form of the constraint equation. 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. The MPC will be applied if the variable is not changed. 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. However, the option should be used with care: switching off an MPC may cause a sudden disturbance in equilibrium, which can lead to convergence problems. If this variable is used to switch on an MPC during an analysis, the variable UE should be defined; otherwise, the constraint may not be satisfied properly.

# Variables passed in for information

# MDOF

Maximum number of active degrees of freedom per node involved in the MPC. For the degree of freedom mode of user subroutine MPC, MDOF= 1.

# N

Number of degrees of freedom that are involved in the constraint, defined as the number of nodes given in the corresponding multi-point constraint definition. If more than one degree of freedom at a node is

<!-- source-page: 87 -->

involved in a constraint, the node must be repeated as needed or, alternatively, the nodal mode should be used.

# 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 be either 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 degree of freedom to be eliminated changes during the course of the analysis, but it is necessary to prevent the choice of the dependent degree of freedom from changing during the course of an iteration.

# MAXDOF

Maximum degree of freedom number at any node in the analysis. For example, for a coupled temperature-displacement analysis with continuum elements, MAXDOF will be 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).

<!-- source-page: 88 -->

# 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.

# Example: Nonlinear single degree of freedom MPC

An example of a nonlinear single degree of freedom MPC is a geometrically nonlinear two-dimensional slider involving nodes a, b, and c. The constraint forces node a to be on the straight line connecting nodes b and c (see Figure 1.1.14–1).

![](images/page-088_8f657df88c4514ae7b09613833ac3a286e1de527e185fd3e16beb725bfc277be.jpg)

<details>
<summary>text_image</summary>

y
x
a
b
c
</details>

Figure 1.1.14–1 Nonlinear MPC example: two-dimensional slider.

<!-- source-page: 89 -->

The constraint equation can be written in the form

$$
f (u ^ {a}, v ^ {a}, u ^ {b}, v ^ {b}, u ^ {c}, v ^ {c}) = (x ^ {a} - x ^ {b}) (y ^ {c} - y ^ {b}) - (y ^ {a} - y ^ {b}) (x ^ {c} - x ^ {b}) = 0,
$$

where $( x ^ { a } , y ^ { a } ) , ( x ^ { b } , y ^ { b } )$ , and $( x ^ { c } , y ^ { c } )$ are the current locations of ${ \pmb a } ,$ b, and c. The derivatives are readily obtained as

$$
\begin{array}{l} \frac {\partial f}{u ^ {a}} = y ^ {c} - y ^ {b}, \frac {\partial f}{u ^ {b}} = y ^ {a} - y ^ {c}, \frac {\partial f}{u ^ {c}} = y ^ {b} - y ^ {a}, \\ \frac {\partial f}{v ^ {a}} = x ^ {b} - x ^ {c}, \frac {\partial f}{v ^ {b}} = x ^ {c} - x ^ {a}, \frac {\partial f}{v ^ {c}} = x ^ {a} - x ^ {b}. \\ \end{array}
$$

Depending on the orientation of the segment $( b , c )$ we choose either $u ^ { a }$ or $v ^ { a }$ as the degree of freedom to be eliminated. If $\left| x ^ { c } - x ^ { b } \right| \geq \left| y ^ { \bar { c } } - y ^ { b } \right|$ , we choose $v ^ { a }$ as the dependent degree of freedom. If $\left| x ^ { c } - x ^ { b } \right| < \left| y ^ { c } - y ^ { b } \right|$ , we choose $u ^ { a }$ as the dependent degree of freedom. Moreover, if points b and c are coincident, the constraint is not applied.

To prevent the choice of either $u ^ { a }$ or $v ^ { a }$ as the dependent degree of freedom from changing during the course of an iteration, the orientation of the segment $( b , c )$ is tested based on the geometry at the beginning of the iteration. The dependent degree of freedom is allowed to change from increment to increment.

Suppose the above multi-point constraint is defined as type 1, with nodes a, a, b, b, c, c. The user subroutine MPC could be coded as follows:
```fortran
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 A(N),JDOF(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)
PARAMETER( PRECIS = 1.D-15 )
C
IF (JTYPE .EQ. 1) THEN
    DYBC0 = X(2,5) + UINIT(2,5) - X(2,3) - UINIT(2,3)
    DXBC0 = X(1,3) + UINIT(1,3) - X(1,5) - UINIT(1,5)
    DYBC = X(2,5) + U(2,5) - X(2,3) - U(2,3)
    DXBC = X(1,3) + U(1,3) - X(1,5) - U(1,5)
    A(3) = X(2,1) + U(2,1) - X(2,5) - U(2,5)
    A(4) = X(1,5) + U(1,5) - X(1,1) - U(1,1)
    A(5) = X(2,3) + U(2,3) - X(2,1) - U(2,1)
    A(6) = X(1,1) + U(1,1) - X(1,3) - U(1,3)
    JDOF(3) = 1 
```

<!-- source-page: 90 -->

```prolog
JDOF(4) = 2
JDOF(5) = 1
JDOF(6) = 2
IF (ABS(DYBC0).LE.PRECIS .AND. ABS(DXBC0).LE.PRECIS) THEN
POINTS B AND C HAVE COLLAPSED. DO NOT APPLY CONSTRAINT.
LMPC = 0
ELSE IF (ABS(DXBC0).LT. ABS(DYBC0)) THEN
MAKE U_A DEPENDENT DOF.
JDOF(1) = 1
JDOF(2) = 2
A(1) = DYBC
A(2) = DXBC
UE = A(5)A(2)/A(1) + X(1,3) + U(1,3) - X(1,1)
ELSE
MAKE V_A DEPENDENT DOF.
JDOF(1) = 2
JDOF(2) = 1
A(1) = DXBC
A(2) = DYBC
UE = -A(6)A(2)/A(1) + X(2,3) + U(2,3) - X(2,1)
END IF
END IF
RETURN
END 
```

# Nodal version of user subroutine MPC

The nodal version of user subroutine MPC allows for multiple degrees of freedom of a node to be eliminated simultaneously. The set of constraints can be quite general and nonlinear, of the form

$$
f _ {i} \left(\boldsymbol {u} ^ {1}, \boldsymbol {u} ^ {2}, \boldsymbol {u} ^ {3}, \dots , \boldsymbol {u} ^ {N}, \text {geometry, temperature, field variables}\right) = 0 \quad i = 1, 2, \dots , \text {NDEP}.
$$

NDEP is the number of dependent degrees of freedom that are involved in the constraint and should have a value between 1 and MDOF, which is the number of active degrees of freedom per node in the analysis. N is the number of nodes involved in the constraint. The scalar constraint functions $f _ { i }$ can also
