Reference

The material Jacobian

DDSDDE is the array that decides how fast your analysis converges and, when it is wrong, whether it converges at all. It is also the part of a UMAT that nothing checks for you.

A wrong material Jacobian does not give you a wrong answer. It gives you the right answer slowly, or no answer at all — and the difference between those two outcomes and a genuine physics error is invisible from the stress alone. That is what makes it worth understanding properly.

What DDSDDE actually is

DDSDDE(I,J) is the derivative of the stress increment with respect to the strain increment, holding everything at the start of the increment fixed:

DDSDDE(I,J) = d(delta sigma_I) / d(delta eps_J)

Three things in that sentence are load-bearing and routinely missed.

It is with respect to the increment, not to the total strain. Differentiating the total stress-strain relation gives a different matrix in any model with history.
The start-of-increment state is held fixed. State variables, the previous stress, the accumulated plastic strain — all frozen. A derivative taken while letting the state move is a different quantity.
It is not the Voigt image of a single fourth-order tensor. The strain increment carries engineering shear, so the shear columns absorb a factor of two. For isotropic elasticity the shear diagonal is G, not 2G, and that one character is among the most common faults there is.

Algorithmic versus continuum: the difference that costs you

For an elastic material the tangent is just the elastic stiffness and there is nothing to discuss. For anything with a return mapping there are two candidates, and they are not the same.

Two tangents, both defensible, one of them what Abaqus wants
	Continuum tangent	Algorithmic (consistent) tangent
What it differentiates	The rate equations	The discrete return mapping you actually perform
Correct when	The increment tends to zero	At every increment size
Newton convergence	Linear	Quadratic
Typical iterations	8 to 12 an increment	3 to 4
Answer it converges to	The same	The same

The last row is why this is hard to catch. Both tangents converge to the same stress, because the fixed point of the Newton iteration is where the residual vanishes and the tangent does not appear in that condition. The tangent decides how long the trip takes, not where it ends.

For radial-return J2 plasticity the two differ by a single factor. Writing the algorithmic form as the continuum expression with the deviatoric term scaled:

The algorithmic tangent for radial-return J2, in Voigt form with engineering shear

C[i][j] = K                        for i,j both direct
        + 2G theta (delta_ij - 1/3)    for i,j both direct
        + G theta                      for i = j shear        <- G, not 2G
        - (4G/3) thetabar n_i n_j      for all i,j

theta    = 1 - 3 G dgamma / q_trial
thetabar = 3G / (3G + H) - (1 - theta)

Set dgamma = 0 and theta becomes one, and you have the continuum tangent. That is not a coincidence: the continuum form is the algorithmic form in the limit of a vanishing increment. It is also why the mistake is so convincing — it is exactly right in a limit nobody runs at.

How to check a tangent without guessing

The check is old and the value is entirely in doing it carefully. Perturb one component of the strain increment, re-run the stress update, and read off the change in stress. Do it for every component and a matrix falls out that owes nothing to your derivation.

Perturb from the same state every timeNot from wherever the last perturbation left things. The stress update mutates state variables, and running the columns in sequence differentiates along a path rather than about a point.
Use central differencesForward differences have first-order truncation error, which at a usable step size sits around 1e-8 relative — the same order as a real sign error in a small off-diagonal term. Central differences are second order and cost one extra evaluation per column.
Scale the step to the strain, not to oneA perturbation of 1e-8 is enormous next to a strain increment of 1e-9 and invisible next to one of 1e-1. Make it relative to the increment and the accumulated strain, with a floor so a zero increment is still probed.
Detect branch changes rather than averaging over themIf the plus and minus runs land on different algorithmic branches, the two-sided difference straddles a kink and the derivative genuinely does not exist there. Flag the column; do not report it as an error.
Check at more than one stateEvery wrong tangent is exactly right somewhere. An elastic-only tangent is correct before yield. A shear-block error is invisible under pure tension. A component-ordering error is invisible unless all three shear components are loaded to different levels.

What each kind of error looks like

A disagreement between the analytical and numerical tangents can usually be named rather than merely noticed, because the common mistakes have distinguishable signatures.

Named faults, and how each one gives itself away
Fault	Signature
Elastic stiffness returned after yield	The matrix is identical at a plastic state and an elastic one, while the stress update clearly changed behaviour
Continuum tangent instead of the algorithmic one	The error falls in proportion to the increment size — slope near one on a log-log plot of error against increment
Shear components in Explicit order inside a UMAT	Swapping the last two shear slots reconstructs the reference matrix
Engineering shear treated as tensor shear	Halving the shear diagonal reconstructs the reference matrix
Sign error in the plastic correction	The whole discrepancy is a single rank-one term of the form `c v⊗v`, which is the shape of the flow-direction contribution and of nothing else
Tangent formed from the updated stress rather than the trial stress	Error vanishes with the increment, like a continuum tangent, but faster than first order

The distinction between the second and the third rows is the one worth internalising. An error that shrinks with the increment is a linearisation error; an error that stays flat is a misplaced component. The remedies have nothing in common, and fitting the slope of error against increment size separates them cleanly.

What it costs the solver

Newton solves R(u) = 0 by iterating with whatever stiffness was assembled. Expanding the residual about the solution, the error obeys e_{k+1} = (I - B^-1 K) e_k + O(|e_k|^2) with B the assembled tangent and K the true one. Two things follow.

B = K exactly: the linear term vanishes and the error squares each iteration. Three or four iterations take a residual from 1 to 1e-8.
B ≠ K: the linear term survives at rate rho = spectral radius of (I - B^-1 K), and iterations grow like log(tolerance) / log(rho). At rho >= 1 there is no convergence at any increment size.

In Abaqus/Standard the defaults turn that into observable behaviour. Past four equilibrium iterations the increment stops growing. At sixteen the attempt is abandoned and the increment is cut by a quarter. A tangent error does not improve when the increment shrinks, so the cutbacks do not help. That is exactly why a job which cuts back repeatedly and never converges points at the tangent rather than at the step size.

Check *CONTROLS in your job before relying on those numbers. They are the defaults, not the law.

Symmetry, and the trap in it

Abaqus uses the symmetric solver unless the step carries UNSYMM=YES. Hand it an unsymmetric DDSDDE and it will symmetrise the matrix without telling you. The analysis then iterates on a matrix nobody wrote, converging slowly or not at all, with no message that explains why. If your tangent is genuinely unsymmetric — non-associated flow, most anisotropic damage — say so on the step.

Common questions

Can I just return the elastic stiffness and let Abaqus sort it out?

You can, and the analysis will often converge. It will take eight to twelve iterations an increment instead of three or four. The increment size will never grow past the default threshold, and jobs near a limit point will cut back and fail.

The stress is unaffected. That is what makes this such a durable habit: it works well enough to survive, and it costs you a multiple of your run time forever.

Is a numerical tangent an acceptable shipping answer?

Yes, and it is often the right first move. A finite-difference DDSDDE computed inside the subroutine is correct by construction and converges quadratically. It costs NTENS extra stress-update evaluations per integration point per iteration, which for a cheap update is nothing and for an expensive one is a great deal.

Ship it, get the physics right, then replace it with the algorithmic form and check the two against each other.

My tangent passes a finite-difference check but the job still will not converge.

Then the tangent is consistent with a stress update that is wrong, or the problem is outside the material. Both are common.

Run physics tests that do not consult DDSDDE at all. Elastic moduli off a stress-strain curve, plastic volume change, flow direction against the yield surface normal, and the same total strain applied in one increment and in sixty-four. If those pass too, look at contact, boundary conditions and the mesh.

How large may the disagreement be before it matters?

A correct analytical tangent compared against a stable central difference lands near 1e-9 relative in double precision. Anything below about 1e-6 is the numerical method talking rather than the model.

Between 1e-6 and 1e-2 is where a nearly-right tangent lives — a continuum form at a small increment, or a term that happens to be small at that state. Above 1e-2 no plausible round-off explains it.