6.1.5 Iterative linear equation solver

Products: ABAQUS/Standard  ABAQUS/CAE  



The iterative linear equation solver in ABAQUS/Standard:

  • is based on the domain decomposition method;

  • can be used only for linear and nonlinear static, quasi-static, and steady-state heat transfer solution procedures with a symmetric stiffness matrix and a single load case;

  • finds an approximate solution to the linear system of equations;

  • should be used only for very large, well-conditioned models (typically several million degrees of freedom)—in all other cases the direct sparse solver should be used (see Direct linear equation solver, Section 6.1.4);

  • is likely to be faster than the direct equation solver for large, well-conditioned, blocky structures;

  • requires less disk storage but more in-core memory than the direct equation solver; and

  • cannot be used with automatic stabilization.

The domain decomposition-based iterative solver

The iterative solver in ABAQUS/Standard can be used to find the solution to a linear system of equations and can be invoked in a static, quasi-static, or steady-state heat transfer analysis step. Since it is an iterative technique, a converged solution to a given system of linear equations cannot be guaranteed. In cases where the iterative solver fails to converge to a solution, the only choice may be to use the direct solver. When the iterative solver converges, the accuracy of this solution will depend on the relative tolerance that is used; the default tolerance is sufficiently accurate for most purposes. In addition, the performance of the iterative solver is highly sensitive to the geometry of the model, favoring blocky type structures (i.e., models that look more like a cube than a plate) with a high degree of mesh connectivity and a relatively low degree of sparsity. These types of models often demand the most resources for the direct sparse solver. Models with a lesser degree of connectivity (often said to have a higher degree of sparsity), such as thin, shell-like structures, are much more suited to the direct solver (see Direct linear equation solver, Section 6.1.4).

Input File Usage:           Use the following option to invoke the iterative solver:


Step module: step editor: Other: Method: Iterative

The iterative solution technique

The iterative solution technique is based on the so-called FETI method (Finite Element Tearing and Interconnecting), which uses the following general strategy:

  1. The finite element model is decomposed into disjoint domains containing non-overlapping collections of elements (each element belongs to exactly one domain).

  2. The stiffness matrix for each domain is factored independently with the direct linear equation solver and saved in memory (there is no out-of-core option with the iterative solver).

  3. A system of Lagrange multipliers that enforces domain-to-domain continuity is generated internally (the so-called interface problem) and solved using a preconditioned conjugate gradient algorithm to some desired level of accuracy (which you can set if necessary). The interface problem is formed using the factors of the domain stiffness matrices.

  4. The global displacement solution is recovered from the domain solutions and the approximate Lagrange multipliers.

The process outlined above is performed entirely internal to ABAQUS/Standard, with no user intervention required.

Convergence of the linear system of equations

To generate the solution to the system of linear algebraic equations (denoted by the matrix equation , where K is the global stiffness matrix, f is the load vector, and u is the desired displacement solution), a sequence of linear solver iterations is performed, whereby an approximate solution gets closer to the exact solution at each iteration. The error in the approximate solution is measured by the residual of the linear system, defined by , where is the norm. The term “convergence” is used to describe this process, and the approximate solution is said to be converged when the residual is below a specified relative tolerance. By default, this tolerance is 10–6. The rate at which the approximate solution converges is directly related to the conditioning of the original system of equations. A linear system that is well conditioned will converge faster than an ill-conditioned system. If the residual does not converge to zero, the iterative solver is said to have stagnated and ABAQUS/Standard will exit with an error or warning message depending on the magnitude of the final residual.

Residual checking

During the iterative solution process, an estimate of the global residual is used to check for convergence with respect to the requested tolerance. This estimate is printed to the message file after each iteration. When the iterative solver has converged, the global residual is calculated and written to the message file and can be directly compared to the estimated residual. In some extreme cases the estimate may prove to be far smaller than the true residual, which can occur with severely ill-conditioned models. If the global residual in a nonlinear analysis is more than 10 times larger than the estimated residual, ABAQUS/Standard will issue a warning message and the analysis will continue. If the global residual in a perturbation analysis is more than 10 times larger than the estimated residual, ABAQUS/Standard will also issue a warning message and continue, although the results should be interpreted with care. However, if the global residual is more than 103 times larger than the estimated residual in a perturbation analysis, ABAQUS/Standard will exit with an error message since the solution is most likely incorrect.

Setting controls for the iterative linear solver

The default controls provided in ABAQUS/Standard are usually sufficient. However, a method for overriding the default relative convergence tolerance, maximum number of solver iterations, and number of domains is provided.

Resetting the solver controls

You can specify that the solver controls be reset to their default values.

Input File Usage:           


Step module: OtherSolver ControlsEdit: Reset all parameters to their system-defined defaults

Specifying the relative convergence tolerance

For nonlinear problems the accuracy of the linear solution can impact the convergence of the Newton method. In some cases it may be necessary to decrease the iterative solver relative tolerance to achieve a sufficiently accurate solution. This can often lead to better convergence of the Newton method.

Input File Usage:           
relative tolerance for convergence


Step module: OtherSolver ControlsEdit: Specify: Relative tolerance: Specify: relative tolerance for convergence

Specifying the maximum number of solver iterations

In some cases the linear solver may require more than the default number of iterations to converge to the desired level of accuracy. In this case you can increase the maximum number of iterations allowed by the iterative solver (the default value is 300). Increasing this number will also lead to greater memory usage. The amount of memory affected by this number is roughly equal to bytes, where is the number of interface equations, printed in the data file, and M is the maximum number of allowed iterations. In most cases this is a relatively small percentage of the total solver memory, although if M is larger than a few hundred, it can become a significant amount of memory. The memory estimates printed in the data file are based on the maximum number of allowed iterations; however, memory will be allocated only for the number of iterations needed for convergence.

Input File Usage:           
 , max number of solver iterations


Step module: OtherSolver ControlsEdit: Specify: Max. number of iterations: Specify: max number of solver iterations

Specifying the number of domains

By default, the model will be decomposed into domains that have approximately 8000 degrees of freedom each; domains of this size have shown to provide good performance on a wide variety of problems. You can directly specify the number of desired domains; however, this is discouraged except in cases where it is absolutely necessary, such as for models containing fewer than 16000 degrees of freedom. However, even when you directly specify the number of domains, ABAQUS/Standard may internally adjust this number by a small amount to achieve better shaped domains. Element sets are created for each domain; each element set is named “DOMAIN” with the step number appended. A node set for all nodes on the domain interface is written to the output database after the decomposition is generated; each node set is named “DOMAIN INTERFACE” with the step number appended.

Input File Usage:           
 , , number of domains


Step module: OtherSolver ControlsEdit: Specify: Number of domains: Specify: number of domains

Deciding to use the iterative solver

Many factors must be carefully weighed before deciding to use the iterative solver in ABAQUS/Standard, such as element type, contact and constraint equations, material and geometric nonlinearities, and material properties, all of which can impact robustness and performance. In cases where the model is ill-conditioned the iterative solver may converge very slowly or fail to converge. This may occur, for example, if regions of the model have vastly different material properties or many elements have poor aspect ratios. In other cases the estimated residual could prove to be much smaller than the true residual. In general, these problems indicate that the iterative solver is not suited to the problem at hand.

In addition to the robustness issues (relating mainly to the rate of convergence or stagnation), the iterative solver is expected to outperform the direct solver only for the largest models (even when the model is well conditioned). Typically, for a well-conditioned solid model, the number of degrees of freedom in the global model must be greater than one million before the iterative solver will be comparable to the direct solver in terms of run time.

Element type and model geometry

The most basic modeling issue that will affect the performance of the iterative solver is the model geometry, which must be carefully considered when deciding if the iterative solver is suited to a particular model. In general, models that are blocky in nature (i.e., look more like a cube than a plate) and are dominated by solid elements will behave well with the iterative solver. Although structural elements such as beams and shells are supported, models dominated by structural elements will not perform optimally; the direct solver should be used instead for such models. Models with special-purpose elements such as springs and connectors should be carefully considered before choosing the iterative solver, since these elements often have stiffness properties that are vastly different than the solid elements in the model. Common modeling techniques such as coating solid elements with a thin layer of membrane elements to recover accurate stresses on the boundary or fixing rigid body motion with weak springs will not work with the iterative solver. Both of these techniques will lead to extremely slow convergence or stagnation.

Another factor that can influence the convergence of the iterative solver is the quality of the elements. Blocky models, such as an engine block, that contain many poorly shaped elements with high aspect ratios can also lead to poor iterative solver convergence. It is a good idea to look for warning messages about poorly shaped elements when evaluating the performance of the iterative solver.

Constraint equations

The iterative solver can be used for models that have a relatively small number of constraint equations (such as multi-point constraints, surface-based tie constraints, kinematic couplings, etc.). While constraint equations coupling only a few nodes, such as BEAM-type MPCs and equations, will generally not lead to convergence problems, other constraints that couple large surfaces, such as surface-based tie constraints, may lead to performance and robustness difficulties, causing the iterative solver to fail.


Since contact is a form of nonlinear analysis, special care must be taken in selecting the convergence tolerance for the iterative solver (see “Nonlinear analysis” below). Therefore, it is recommended to run the model through a static perturbation analysis before proceeding to the nonlinear problem. This will demonstrate how the iterative solver will perform for the specific model geometry without the added difficulty of nonlinear convergence.

Material properties

When deciding to use the iterative solver, the variation of material properties in the model should be considered. Models that have large discontinuities in material behavior (several orders of magnitude) will most likely converge slowly and possibly stagnate.

Nonlinear analysis

The iterative solver can be used to solve the linear system of algebraic equations that arises at each iteration of the Newton procedure. However, the convergence of the nonlinear problem will be affected by the convergence of the iterative linear solver. The actual impact depends on the particular model and type of nonlinearities present. In some cases the default iterative solver tolerance of 10–6 is sufficient to maintain the convergence of the Newton method; in other cases a smaller linear solver tolerance (for example, 10–8) must be used.

If a nonlinear analysis that uses the iterative solver fails to converge, it is often difficult to determine if this is due to the approximate linear equation solution of the iterative solver or if the Newton process itself is failing to converge. If nonlinear convergence problems occur, the direct solver can be used to eliminate the approximate linear solution as a possible source of the problem. If this is not possible, the true residual at the end of each linear solver pass should be checked to ensure that it is indeed small. If the true residual is much larger than the estimated residual, the linear solver convergence tolerance can be decreased. If the linear solver stagnates, the direct solver may be the only choice for this model, since it is likely to be too ill-conditioned for the iterative solver.