Defining an Analysis

An analysis in Abaqus is defined using steps, analysis procedures, and optional history data.

There are two kinds of steps in Abaqus: general analysis steps, which can be used to analyze linear or nonlinear response, and linear perturbation steps, which can be used only to analyze linear problems. General analysis steps can be included in an Abaqus/Standard or Abaqus/Explicit analysis; linear perturbation analysis steps are available only in Abaqus/Standard. In Abaqus/Standard linear analysis is always considered to be linear perturbation analysis about the state at the time when the linear analysis procedure is introduced. This linear perturbation approach allows general application of linear analysis techniques in cases where the linear response depends on preloading or on the nonlinear response history of the model. See General and Perturbation Procedures for more details.

The analysis procedure can be changed from step to step in any meaningful way, so you have great flexibility in performing analyses. Since the state of the model (stresses, strains, temperatures, etc.) is updated throughout all general analysis steps, the effects of previous history are always included in the response in each new analysis step. Thus, for example, if natural frequency extraction is performed after a geometrically nonlinear static analysis step, the preload stiffness is included. Linear perturbation steps have no effect on subsequent general analysis steps.

The most obvious reason for using several steps in an analysis is to change analysis procedure type. However, several steps can also be used as a matter of convenience—for example, to change output requests, contact pairs in Abaqus/Explicit, boundary conditions, or loading (any information specified as history, or step-dependent, data). Sometimes an analysis may have progressed to a point where the present step definition needs to be modified. Abaqus provides for this contingency with the restart capability, where a step can be terminated prematurely and a new step can be defined for the problem continuation (see Restarting an Analysis).

Optional history data (see Abaqus Model Definition) prescribing the loading, boundary conditions, output controls, and auxiliary controls remains in effect for all subsequent general analysis steps, including those that are defined in a restart analysis, until they are modified or reset. Abaqus compares all loads and boundary conditions specified in a step with the loads and boundary conditions in effect during the previous step to ensure consistency and continuity. This comparison is expensive if the number of individually specified loads and boundary conditions is very large. Hence, the number of individually specified loads and boundary conditions should be minimized, which can usually be done by using element and node sets instead of individual elements and nodes. For linear perturbation steps only the output controls are continued from one linear perturbation step to the next if there are no intermediate general analysis steps and the output controls are not redefined (see About Output).

Within Abaqus/Standard or Abaqus/Explicit, any combination of available procedures can be used from step to step. However, Abaqus/Standard and Abaqus/Explicit procedures cannot be used in the same analysis. See About Transferring Results between Abaqus Analyses for information on importing results from one type of analysis to another.

By default, Abaqus assumes that external parameters, such as load magnitudes and boundary conditions, are constant (step function) or vary linearly (ramped) over a step, depending on the analysis procedure, as shown in Table 1. Some exceptions in Abaqus/Standard are discussed below.

No default amplitude variation is defined for a direct cyclic analysis step; for each applied load or boundary condition, the amplitude must be defined explicitly.

Each step in an Abaqus analysis is divided into multiple increments. In most cases you have two choices for controlling the solution: automatic time incrementation or user-specified fixed time incrementation. Automatic incrementation is recommended for most cases. The methods for selecting automatic or direct incrementation are discussed in the individual procedure sections.

The issues associated with time incrementation in Abaqus/Standard and Abaqus/Explicit are quite different, since time increments are generally much smaller in Abaqus/Explicit.

You can monitor the simulation state (as quantified by the values of certain output variables) as the analysis continues and take an action, such as terminating the current step or even the entire analysis, upon reaching a threshold criterion. Alternatively, you can note when the threshold is reached and let the analysis continue. In addition, you can choose to modify the time increment as the simulation state approaches this threshold value. You must identify the specific output to be monitored as a "measure" of the simulation state—for example, an electric potential or a displacement at a given node—as a sensor (see Defining Sensors). You can trigger the action when either the algebraic or the absolute value of the sensor has reached either a maximum or a minimum threshold.

If you choose to affect the time increment as the threshold is approached, you can do so either by giving a fixed time increment value or going with the automatically determined value, which is adjusted internally to meet the threshold value as closely as possible. In the former case, Abaqus/Standard uses the specified time increment value, provided that it is lower than the time increment computed by the automatic time-incrementation algorithms in Abaqus/Standard and the condition for time increment refinement is met.

STEP CONTROL, NAME=step_control_name, DT REFINEMENT=NO, ACTION=END STEP (or  END ANALYSIS )
sensor_name, operate_criteria (max, min, etc), sensor_threshold_value

STEP CONTROL, NAME=step_control_name, DT REFINEMENT=YES, ACTION=END STEP (or  END ANALYSIS )
sensor_name, operate_criteria (max, min, etc), sensor_threshold_value, dt_refined_value, sensor_value_when_dt_refinement_starts

STEP CONTROL, NAME=step_control_name, DT REFINEMENT=AUTO, ACTION=END STEP (or  END ANALYSIS )
sensor_name, operate_criteria (max, min, etc), sensor_threshold_value

STEP CONTROL, NAME=step_control_name, DT REFINEMENT=YES, ACTION=CONTINUE 
sensor_name,  , dt_refined_value, sensor_value_when_dt_refinement_starts, sensor_value_when_dt_refinement_ends

Abaqus/Standard distinguishes between regular, equilibrium iterations (in which the solution varies smoothly) and severe discontinuity iterations (SDIs) in which abrupt changes in stiffness occur. The most common of such severe discontinuities involve open-close changes in contact and stick-slip changes in friction. By default, Abaqus/Standard continues to iterate until the severe discontinuities are sufficiently small (or no severe discontinuities occur) and the equilibrium (flux) tolerances are satisfied. Alternatively, you can choose a different approach in which Abaqus/Standard continues to iterate until no severe discontinuities occur.

For contact openings with the default approach, a force discontinuity is generated when the contact force is set to zero, and this force discontinuity leads to force residuals that are checked against the time average force in the usual way, as described in Convergence Criteria for Nonlinear Problems. Similarly, in stick-to-slip transitions the frictional force is set to a lower value, which also leads to force residuals.

For contact closures a severe discontinuity is considered sufficiently small if the penetration error is smaller than the contact compatibility tolerance times the incremental displacement. The penetration error is defined as the difference between the actual penetration and the penetration following from the contact pressure and pressure-overclosure relation. In cases where the displacement increment is essentially zero, a “zero penetration” check is used, similar to the check used for zero displacement increments (see Convergence Criteria for Nonlinear Problems). The same checks are used for slip-to-stick transitions in Lagrange friction.

To make sure that sufficient accuracy is obtained for contact between hard bodies, it is also required that the estimated contact force error is smaller than the time average force times the contact force error tolerance. The estimated contact force error is obtained by multiplying the penetration by an effective stiffness. For hard contact this effective stiffness is equal to the stiffness of the underlying element, whereas for softened/penalty contact the effective stiffness is obtained by adding the compliance of the contact constraint and the underlying element.

Forcing the iteration process to continue until no severe discontinuities occur is the more traditional, conservative method. However, this method can sometimes lead to convergence problems, particularly in large problems with many contact points or situations where contact conditions are only weakly determined. In such cases excessive iteration may occur and convergence may not be obtained.

STEP, CONVERT SDI=NO

Step module: step editor: Other: Convert severe discontinuity 
iterations: Off

Abaqus/Standard generally uses Newton's method to solve nonlinear problems and the stiffness method to solve linear problems. In both cases the stiffness matrix is required. In some problems—for example, with Coulomb friction—this matrix is not symmetric. Abaqus/Standard automatically chooses whether a symmetric or unsymmetric matrix storage and solution scheme is used based on the model and step definition used. In some cases you can override this choice; the rules are explained below.

Usually it is not necessary to specify the matrix storage and solution scheme. The choice is available to improve computational efficiency in those cases where you judge that the default value is not the best choice. In certain cases where the exact tangent stiffness matrix is not symmetric, the extra iterations required by a symmetric approximation to the tangent matrix use less computer time than solving the nonsymmetric tangent matrix at each iteration. Therefore, for example, Abaqus/Standard invokes the symmetric matrix storage and solution scheme automatically in problems with Coulomb friction where every friction coefficient is less than or equal to 0.2, even though the resulting tangent matrix has some nonsymmetric terms. However, if any friction coefficient is greater than 0.2, Abaqus/Standard uses the unsymmetric matrix storage and solution scheme automatically since it may significantly improve the convergence history. This choice of the unsymmetric matrix storage and solution scheme considers changes to the friction model. Thus, if you modify the friction definition during the analysis to introduce a friction coefficient greater than 0.2, Abaqus/Standard activates the unsymmetric matrix storage and solution scheme automatically. In cases in which the unsymmetric matrix storage and solution scheme is selected automatically, you must explicitly turn it off if so desired; it is recommended to do so if friction prevents any sliding motions.

STEP, UNSYMM=YES or NO

Step module: step editor: Other: Storage: Use solver default or Unsymmetric or Symmetric

You can choose a double-precision executable (with 64-bit word lengths) for Abaqus/Explicit on machines with a default, single-precision word length of 32 bits (see Abaqus/Standard and Abaqus/Explicit Execution). Most new computers have 32-bit default word lengths even though they may have 64-bit memory addressing. The single-precision executable typically results in a CPU savings of 20% to 30% compared to the double-precision executable, and single precision provides accurate results in most cases. Exceptions in which single precision tends to be inadequate include analyses that require greater than approximately 300,000 increments, have typical nodal displacement increments less than 10⁻⁶ times the corresponding nodal coordinate values, include hyperelastic materials, or involve multiple revolutions of deformable parts; the double-precision executable is recommended in these cases (for example, see Simulation of propeller rotation).

You can also run only a part of Abaqus/Explicit using double precision, while using single precision for the rest (see Abaqus/Standard and Abaqus/Explicit Execution). These options are described below.

• If double=explicit is used or the double option is specified without a value, the Abaqus/Explicit analysis runs in double precision, while the packager runs in single precision. While this choice would satisfy higher precision needs in most analyses, the data are written to the state (.abq) file in single precision. Moreover, analysis-related computations performed in the packager are still run in single precision. Thus, new steps, restart, and import analyses begin from data that are stored/computed in single precision despite the fact that calculations during the step are performed in double precision. Thus, in general,you can expect somewhat noisy solutions at the beginning of the first step, at step transitions, on restart, and after import.

• If double=both is used, both the Abaqus/Explicit packager and analysis run in double precision. This is the most expensive option but ensures the highest overall execution precision. Analysis database floating point data are written to the state (.abq) file at the end of packager or of a given step in double precision, thus ensuring in most cases the smoothest transition at step boundaries, on restart, and after an import.

• There may be cases where the default single precision analysis is inadequate, while the double=both option is too expensive. These are typically models that have complex links of constraints (such as a complex mechanism with connector elements, complex combinations of distributed/kinematic couplings, tie constraints and multi-point constraints, or interactions of such constraints with boundary conditions). For such models it is desirable to solve only the constraints in the model in double precision while the rest of the model is solved in single precision. This combination gives the desired accuracy of the solution while increasing performance compared to a full double precision analysis.

• If double=constraint is used, the constraint packager and constraint solver are executed in double precision, while the remainder of the Abaqus/Explicit packager and analysis are executed in single precision.

• If double=off is used or the double option is omitted (default), both the Abaqus/Explicit packager and the analysis run in single precision. The double=off option is useful when you want to override the setting in the environment file.

The significance of the precision level is indicated by comparing the solutions obtained with single and double precision. If no significant difference is found between single- and double-precision solutions for a particular model, the single-precision executable can be deemed adequate.