The consistent tangent: 7 iterations against 887

A nonlinear finite element analysis solves, at every load increment,

by Newton iteration, and Newton’s celebrated quadratic convergence depends on one condition that is easy to violate without noticing: the matrix used must be the exact derivative of the residual actually being evaluated.

In elastoplasticity that derivative is not the continuum tangent modulus from the constitutive theory. It is the derivative of the discrete stress-update algorithm — the return mapping — with respect to the strain increment, which is a different matrix. It has a name, the consistent or algorithmic tangent, and the difference it makes is not marginal.

Every number in this article is recomputed from its inputs by a script that runs on each build of this site, including the residual sequences, which are re-run rather than quoted.

One barPermalink to “One bar”#

Take a bar of unit area and unit length, elastic modulus 200000, yield stress 250, and power-law hardening beyond yield:

with $K = 800$, $n = 0.5$ and $\varepsilon_y = \sigma_y/E = 0.001250$. Apply a force of 320, whose exact solution is $\varepsilon = 0.008906$.

At that strain the tangent stiffness is

against an elastic modulus of 200000 — a ratio of 44. The material has softened by a factor of 44 relative to its elastic response, which is entirely normal for a plastic state and is exactly the situation the elastic tangent misrepresents.

Two Newton schemesPermalink to “Two Newton schemes”#

Starting from just past yield, iterate to a relative residual below $10^{-10}$.

With the consistent tangent, the residual sequence is

Read the last four rows: $4 \times 10^{-2}$, $4 \times 10^{-3}$, $4 \times 10^{-5}$, $3 \times 10^{-9}$. Each residual is roughly the square of the one before, which is what quadratic convergence looks like — the number of correct digits doubles per iteration, and the last three iterations do almost all of the work.

With the elastic tangent — modified Newton, in which the stiffness is formed once and reused — the same problem takes 887 iterations. The sequence decays geometrically: 2.1787e-1, 1.7207e-1, 1.5630e-1, and it is still at 1.0022e-1 after ten iterations and 8.1710e-3 after a hundred.

The two answers agree. One takes 127 times as many iterations to get there.

Why the elastic tangent is so slow herePermalink to “Why the elastic tangent is so slow here”#

Newton with an approximate Jacobian is a fixed-point iteration whose convergence rate is governed by how far the approximation is from the truth. Using $E$ where the true slope is $E_t$ means each step corrects only a fraction $E_t/E$ of the error — here $1/44$ — so the residual falls by roughly $1 - E_t/E$ per iteration, which is 0.977 here. Reducing a residual by nine orders of magnitude at 2.3% per iteration takes hundreds of steps, and the arithmetic predicts the observed count.

That also explains when modified Newton is a good idea and when it is not. Early in a load history, where most of the structure is elastic and $E_t/E$ is near 1, it converges quickly and saves a factorisation per iteration, which is genuinely the dominant cost. Near a limit load, where the tangent stiffness approaches zero, the ratio approaches zero with it and the scheme stops converging altogether. The load steps that are cheapest to solve are the ones where it helps.

Why the consistent tangent is not the continuum tangentPermalink to “Why the consistent tangent is not the continuum tangent”#

The subtle version of this mistake is to use the correct continuum elastoplastic modulus and still fail to get quadratic convergence.

The residual is assembled from stresses, and those stresses came out of a return-mapping algorithm that took a finite strain increment, made an elastic prediction, and projected it back onto the yield surface. The Jacobian of that procedure is not the tangent of the underlying continuous theory: it carries terms from the projection, and it depends on the size of the step. The two agree only in the limit of infinitesimal increments, which is the limit in which nobody actually runs.

Using the continuum tangent gives convergence that is fast but not quadratic, and — the characteristic symptom — degrades as increments are made larger. If a nonlinear solver’s iteration count rises sharply when the load step is doubled, that is the signature, and it is distinguishable from the many other reasons a nonlinear analysis converges slowly.

What it costs to do properlyPermalink to “What it costs to do properly”#

The consistent tangent has to be derived for each constitutive model and each return-mapping scheme, by differentiating the algorithm rather than the theory. For Mohr-Coulomb that means a separate derivation for the face, edge and apex returns, because they are three different algorithms.

It is real work, and it is worth it for a reason beyond speed. An iteration count that behaves as theory predicts is a test: if a model converges quadratically, its tangent is almost certainly the exact derivative of its stress update, which is a strong statement about the correctness of both. A model that converges in five to eight iterations at every increment, and keeps doing so as the increment size changes, is telling you something a residual check alone cannot — which makes convergence behaviour a verification signal rather than a performance statistic, and one worth recording alongside the benchmark values themselves.