Verification and Diagnosis of Solver Convergence

Theoretical Foundations for Talking About Convergence

The Three Meanings of "Convergence"

Residual Definitions and Convergence Norms

In nonlinear static analysis, the residual is the imbalance between external and internal forces:

$$ \mathbf{r}^{(k)} = \mathbf{F}^{ext} - \mathbf{F}^{int}(\mathbf{u}^{(k)}) $$

The solver declares equilibrium once a residual norm drops below tolerance. In practice several measures are combined:

The key rule: never declare convergence on the displacement-correction criterion alone. A stagnating iteration also shows small displacement changes, letting an "apparent convergence" pass with the force residual still high.

What Governs Convergence Speed

Newton-Raphson converges quadratically near the solution: residuals should fall like \( 10^{-2} \to 10^{-4} \to 10^{-8} \), doubling their digits each iteration. Deviations from that accelerating pattern are diagnostic clues. For iterative linear solvers (CG, GMRES), convergence rate is governed by the condition number \( \kappa(A) \). Slender elements, extreme stiffness contrasts, and thin-walled structures degrade conditioning and cause stagnation — meaning linear solver misbehavior is itself diagnostic information about mesh, materials, and constraints.

Numerical Methods That Control Convergence

Newton Family and Load Incrementation

Nonlinear problems split the load into increments and run Newton iterations per increment. Full Newton (updating the tangent every iteration) converges quadratically at higher cost per iteration; modified Newton drops to linear convergence but iterates cheaply. When convergence struggles, the practical escalation order is:

• Reduce increment size — each increment's starting guess lands inside Newton's convergence radius
• Enable line search — scales the correction to prevent overshooting into divergence
• Add stabilization (small damping/viscosity) — traverses instabilities near buckling or snap-through; always verify afterward that dissipated energy is negligible
• Switch to arc-length (Riks) methods — when the load-displacement curve folds back, load control itself fails; trace the path with an arc-length parameter

Iterative Linear Solvers and Preconditioning

At large scale, direct solvers hit memory limits and preconditioned iterative methods become standard. Preconditioning effectively lowers the condition number — ILU variants and algebraic multigrid (AMG) are the workhorses. If iterations stagnate beyond a few hundred, the right fix is a better preconditioner or better mesh quality, not a higher iteration cap. Matching solver to matrix also matters: CG for symmetric positive-definite systems, GMRES for nonsymmetric ones (fluids, some contact formulations).

Reading the Convergence History

What Makes CFD Convergence Judgments Special

In steady CFD, "residuals reached target" and "the answer is settled" diverge more than anywhere else — residuals and monitor quantities must be used together. Residuals stalling at \( 10^{-3} \) can coexist with perfectly steady lift or pressure drop (practically converged), while small residuals can coexist with slowly drifting monitors (false steady state). Judge with a three-part test: ① scaled residual decrease, ② integral quantities (forces, flow rates, mean temperatures) reaching steady values, ③ boundary balances (mass, energy) within 1% of throughput. If monitors oscillate periodically in a separated flow, a steady solution may simply not exist — the physics is telling you to go transient.

Verification Procedures in Practice

Don't Trust Default Tolerances Blindly

Solver defaults (e.g., 0.5% force residual) are compromises that suit "many problems" — not a guarantee for yours. The standard verification is a tolerance sensitivity check: tighten the criterion by one order of magnitude, re-solve, and confirm your evaluation quantities (peak stress, displacement, reactions) change by less than your accuracy requirement. Large changes mean the normal tolerance was too loose. The same test also reveals when you are wastefully over-tightening.

Treat the Convergence History as a Deliverable

The convergence history — iterations per increment, where cutbacks clustered, final residuals — is the analysis's health record. Reports that paste the peak-stress contour and discard the history cannot be audited later. Keep at least: ① whether every increment ended within tolerance (any truncated increments?), ② which load range concentrated the cutbacks (a physical event lives there), ③ the final residual level. If even one line says "maximum iterations reached, proceeding to next increment," that solution is not in equilibrium.

A Standard Procedure for Isolating Convergence Failures

Before twiddling parameters, bisect the cause:

1. Drop to linear elastic, small displacement — if that fails too, the problem is constraints, connections, or mesh quality, not nonlinearity
2. Re-enable nonlinearities one at a time — material, then geometric, then contact; identify which one breaks it
3. Cut the load to 1/10 — converges at small load ⇒ increment-control problem; fails ⇒ model-definition problem
4. Visualize the increment just before failure — local buckling, inverted elements, and contact penetration become visible

Followed in order, this locates ~90% of "it won't converge" cases within a few increments of investigation.

Convergence Controls and Diagnostics by Solver

Criteria Settings and Diagnostic Files

Reading Cutbacks (Automatic Increment Reduction)

Implicit solvers respond to convergence failure by shrinking the increment and retrying (Abaqus cutbacks, Ansys bisection). This is not failure — it is diagnosis: load levels where cutbacks cluster host physical events — buckling, contact state changes, spreading plasticity. Visualize deformation and contact status there and the model tells you what it is trying to do. Forcing looser minimum increments to "get past" cutbacks throws that information away.

Explicit Dynamics Has No "Convergence Check" — Watch Energy Instead

Explicit codes (LS-DYNA, Abaqus/Explicit) never solve a system of equations, so there is no convergence criterion at all. The health metrics are different: energy balance (internal + kinetic + dissipated − external work ≈ constant), artificial (hourglass) energy below a few percent of internal energy, and controlled mass-scaling growth. "Explicit means no convergence worries" is wrong — the quantities to audit are simply different ones.

Research Frontiers

Scale-Up and Scalable Preconditioners

For analyses with tens of millions of DOFs, the frontier is preconditioning that stays effective in parallel: algebraic multigrid achieves mesh-independent iteration counts under ideal conditions, and domain decomposition methods (FETI-DP/BDDC) are becoming the standard on massively parallel machines. The practical lesson: many "slow convergence at scale" problems improve by orders of magnitude through solver and preconditioner selection — try that before buying more hardware on default settings.

Machine-Learned Convergence Acceleration

Neural networks that learn good initial guesses or preconditioners from families of similar solves report meaningful iteration reductions — particularly in workflows that solve many related problems (shape optimization, parametric studies). Out-of-distribution inputs can backfire, so the sound usage pattern today is: let learning accelerate, but keep classical residual criteria as the judge of convergence.

Automating Nonlinear Robustness

Adaptive strategies that auto-tune incrementation, stabilization, and solver switching keep advancing: quasi-Newton (BFGS) with automatic line search, trust-region methods with global convergence guarantees, interior-point contact formulations. As automation grows, so does the verifier's duty to read the logs of what was done automatically — post-checks like dissipated-energy audits become more important, not less.

Troubleshooting

Symptom Diagnosis Table

The Last Question When Nothing Converges

Convergence checking is not "did the run finish" but "how well are equilibrium and conservation satisfied — quantitatively." Make tolerance sensitivity checks and history archiving habitual, and convergence-related quality accidents all but disappear. See also Boundary Condition Verification and Mesh Convergence Verification.