Constraint Enforcement and Overlapping Constraints

Constraint Enforcement

Abaqus enforces constraints on incremental motion at every increment during the solution procedure. A variety of constraint enforcement methods are used by Abaqus. To successfully run simulations, you do not need to be aware of which constraint methods are used and how they work. However, a basic understanding of the constraint methods used might offer you some context for the diagnostic information that Abaqus provides.

Abaqus typically uses a penalty method to enforce contact constraints, although Lagrange multiplier and augmented Lagrange constraint methods are also available to enforce contact constraints in Abaqus/Standard (see Contact Constraint Enforcement Methods in Abaqus/Standard and Contact Constraint Enforcement Methods in Abaqus/Explicit). Contact penalty stiffness is treated by the central-difference time integration in Abaqus/Explicit without triggering implicit corrections (see Central-Difference Time Integration with Implicit Corrections).

Abaqus typically uses the elimination method to strictly enforce noncontact constraints. The elimination method eliminates degrees of freedom of secondary nodes in favor of degrees of freedom of main nodes. The elimination method in Abaqus/Explicit involves the implicit correction phase of central-difference time integration. Exceptions for which noncontact constraints use other constraint methods include the following:

Distributed coupling constraints in Abaqus/Standard use a Lagrange multiplier constraint method to strictly enforce that a reference node moves according to the weighted average motion of cloud nodes. Boundary conditions or other constraints also typically involve the reference node, so using an elimination method to enforce distributed couplings is undesirable.
Distributed coupling constraints in Abaqus/Explicit use a specialized form of implicit correction equations because distributed coupling constraints often participate in other boundary conditions, constraints, or connector elements.
Conflicting constraint requirements cause Abaqus/Explicit to introduce stiff penalty springs. These springs are treated during the implicit correction phase of central-difference time integration, such that the stiff springs do not influence the size of the stable time increment. Large constraint systems involving conflicting constraints can degrade Abaqus/Explicit performance. For further discussion related to overlapping constraints, see Multiple Constraints in Abaqus/Standard, Multiple Constraints in Abaqus/Explicit, and Computational Cost for Constraint Solution in Abaqus/Explicit.

Multiple Kinematic Constraints at a Node

Overconstraint Checks describes the overconstraint checks and the automatic resolution of some overconstraints performed in Abaqus/Standard.

It is possible to use a single node in several multi-point constraints, kinematic coupling constraints, tie constraints, and constraint equations. However, the constraint dependencies are handled differently in Abaqus/Standard and Abaqus/Explicit.

Multiple Constraints in Abaqus/Standard

In Abaqus/Standard kinematic constraints are usually imposed by eliminating degrees of freedom at the dependent (secondary) nodes. Once a variable has been eliminated, it cannot be referenced in any boundary condition or in any subsequent multi-point constraint, kinematic coupling constraint, tie constraint, or constraint equation. Abaqus/Standard automatically sorts MPC types BEAM, CYCLSYM, LINK, PIN, REVOLUTE, TIE, and UNIVERSAL to obtain a proper elimination order. For other constraint types, you must order constraint definitions such that constraints for which a variable (nodal degree of freedom) act as a main variable precede a constraint definition involving that variable acting as a secondary variable. Automated or manual sorting cannot overcome circular dependences or overconstraints associated with a variable acting as a secondary variable in multiple constraints.

Excessive chaining of multi-point constraints, kinematic coupling constraints, and constraint equations is not recommended and might result in a degradation in performance during analysis preprocessing. Whenever possible, it is best to relate the behavior of several nodes (grouped into a node set) to a single node by using one multi-point constraint, kinematic coupling constraint, or constraint equation.

Multiple Constraints in Abaqus/Explicit

Kinematic constraints in Abaqus/Explicit can be defined in any order without regard to constraint dependencies. Less stringent requirements pertaining to constraint ordering and overconstraints in Abaqus/Explicit compared to Abaqus/Standard are due to two factors: a more extensive automated constraint reordering algorithm for Abaqus/Explicit, and automatically switching to a penalty enforcement method to avoid overconstraints.

With the exception of constraints arising from kinematic contact pairs, Abaqus/Explicit solves for all kinematic constraints simultaneously. Thus, nodes involved in a combination of multi-point constraints, constraint equations, connector element kinematic constraints, rigid body constraints, and constraints due to boundary conditions will simultaneously satisfy these constraints as long as they are not conflicting. Redundant and closed loop constraints are acceptable but might lead to a system of constraint equations being solved each increment. This process to solve systems of equations can degrade computational performance if many nodes are involved in the overlapping system of constraints, as discussed in Constraint Enforcement and Overlapping Constraints.

Because the above constraints are enforced independent of contact constraints, you should use the penalty contact algorithm for nodes involved in both kinematic constraints and contact pair definitions. The penalty contact algorithm introduces numerical softening through the use of penalty springs and does not interfere with kinematic constraints. If a node that participates in a kinematic constraint is used in a kinematic contact pair, the contact constraint overrides the kinematic constraint in most situations. Except for rigid bodies, Abaqus/Explicit does not prevent you from defining these conditions; however, the results cannot be guaranteed. If a kinematic constraint is defined for a node on a rigid body, the penalty contact algorithm is required for all contact pairs involving the rigid body.

To obtain accurate reaction force and moment output from Abaqus/Explicit at nodes that are constrained by boundary conditions in addition to one or more of the kinematic constraints described above, it might be necessary to run the analysis in double precision. In such a situation, a double precision run also yields a better estimate of the work done by the reaction forces and moments, thereby providing a more accurate value of the energy due to the external work reported by Abaqus/Explicit.

Abaqus/Explicit uses a penalty method to solve for constraints in situations involving overconstraints. The penalties are weighted based on the masses of nodes participating in the constraint and the stable time increment. The penalty formulation attempts to satisfy the constraint approximately (that is, a very small lack of compliance exists after imposition of the constraint). One situation in which the penalty approach is used to solve the constraint is when secondary nodes of a tie constraint participate in other constraints such as multi-point constraints, kinematic coupling constraints, constraint equations, connector elements, rigid body constraints, or constraints due to boundary conditions. In this case, the lack of compliance in the tie constraint is not carried across step boundaries; thus, noisy accelerations and energy imbalance might be observed at step boundaries for certain problems. An alternative modeling approach (such as reversing the main and secondary surfaces in the tie constraint) might switch to a different solution approach and resolve the inaccuracies.

In Abaqus/Explicit, when there are two or more overlapping distributed coupling constraints or overlapping distributed coupling and tie constraints and the elements underlying the participating surfaces have very low densities, the lack of compliance might result in an inaccurate solution. Specifying reasonable density values for underlying elements might reduce the lack of compliance and improve solution accuracy.

Abaqus/Explicit always uses a geometrically nonlinear formulation for the enforcement of kinematic constraints. This is the case even when you have designated a particular analysis step as being geometrically linear. Thus, results in these geometrically linear analyses could be hard to interpret, particularly when the deformations are large and a geometrically nonlinear formulation should have been used for the step.

Computational Cost for Constraint Solution in Abaqus/Explicit

In Abaqus/Explicit some constraints and actions might be enforced through implicit solution by forming an operator matrix. Several of the constraints and actions that require such an approach include:

Connector elements, except those that have no behavior defined.
Constraints where secondary nodes have conflicting constraints; for example, a secondary node of a tie constraint that is also a secondary node in another constraint.
A secondary node of a constraint that has boundary conditions applied.
Releasing some degrees of freedoms in surface-based constraints.

Each of these constraints or actions might involve only a few nodes and small operator sizes. However, a chain of such constraints or actions can include many nodes requiring large operators.

Abaqus/Explicit examines all such systems and categorizes them according to the number of operations required for the solution. For moderate-sized systems that do not cause any appreciable performance degradation, an informational message is output to the status file. Nodes that participate in such systems are output using a node set InfoNsetSystNodesN, where N is the ordinal position of the system in a list of moderately sized operators. Nodes that most probably caused the implicit solution to be invoked are output using the node set InfoNsetSystNodesN_Trigger. The node sets are output to the output database, and a list of node set names is tabulated in the status file. The table also contains an estimate of the number of operations required for solution and the number of variables involved in the operator.

For systems of intermediate sizes, a warning message is printed to the status file. Node sets WarnNsetSystNodesN and WarnNsetSystNodesN_Trigger are tabulated to the status file along with an estimate of the number of operations and the number of variables. The node sets are also output to the output database.

For large systems that cause severe performance degradation, ErrNsetSystNodesN and ErrNsetSystNodesN_Trigger are output along with an error message in similar fashion. You can change the error message to a warning message.

Figure 1 shows an example of a model with an implicit system of constraint equations associated with the highlighted nodes. This region has redundant surface-based tie specifications with opposite main and secondary surface roles.

After running this job, the status file shows the following output:

-----------------------------------------------------------------------
CONSTRAINT SYSTEM DIAGNOSTIC OUTPUT
-----------------------------------------------------------------------

***WARNING: Abaqus/Explicit has formed at least one moderately-sized implicit
            system of equations associated with enforcing constraints. Solving
            this system of equations would  moderately degrade performance.
            Please refer to Abaqus/Explicit constraints documentation about
            implicit systems of equations for suggestions on how to reduce the
            size of, or avoid, these systems of equations.  Additional details
            on individual systems of equations follows:

System               Solve           Number of       Node set             TriggerNodeSet
 Rank              Operations        Variables
--------------------------------------------------------------------------------------------------
    1              140499               201          InfoNsetSystNodes1   InfoNsetSystNodes1_Trigger

This output informs you about a moderately sized implicit system that has 201 degrees of freedom and would require 140,499 operations to solve during each iteration of the solution. The diagnostic message for this implicit system of equations is informational (rather than a warning or error message) because the number of computational operations to solve the system of equations is moderate. The nodes highlighted in Figure 1 are associated with an automatically generated node set referred to by the diagnostic message. The TriggerNodeSet is a set of nodes that most likely have constraints that require implicit solution. In general, studying constraints and connections associated with such node sets might help you understand the source of overlap associated with the implicit system of equations. Avoiding redundant tie specifications enable this simulation to run about 30% faster. Larger speedups can occur for larger implicit systems of constraint equations.

Input File Usage

Use the following option to change the error message to a warning message:

DIAGNOSTICS, LARGE IMPLICIT SYSTEM=WARNING