What is code verification?

Confirming that an analysis program solves the intended equations to the intended accuracy. Separate from whether the model matches reality (validation) or the error of an individual calculation (solution verification), it first shows the program itself is free of mistakes — chiefly by comparing with exact or manufactured solutions and checking error falls at the theoretical order.

What is a patch test?

A finite element test checking whether a simple solution the elements should represent exactly (a linear field for linear elements) is reproduced even on a patch of distorted elements. In the example, 1 + 2x + 3y was reproduced on distorted elements with error 1.8×10⁻¹⁵ — round-off level. Elements that fail may not approach the correct solution even under refinement.

What errors does code verification catch?

Swapped coefficients, mistakes confined to some elements, faulty boundary-condition implementation and more. In the example, planting an error that halves the area of elements in one region made the patch-test error jump to 0.23 and the convergence order fall from 2 to 0. Errors hard to spot in results become obvious in numbers.

Code Verification

Category: V&V – ASME Standards | Revised 2026-10-01

Code Verification

Theory: showing correctness in numbers

Overview

🙋

I've been asked to demonstrate the quality of an in-house analysis program. Isn't it enough that examples give plausible results?

🎓

It isn't. Small errors shift results only slightly, so they're almost never visible. Code verification checks, on problems with known answers, that error shrinks to round-off level or falls at the theoretical order under refinement. For finite elements, the basic check is the patch test: can the elements reproduce a solution they should represent, even when distorted? The key is that pass/fail comes out clearly in numbers.

Test problems

$$ \nabla^2 u = 0,\qquad u_{patch} = 1 + 2x + 3y,\qquad u_{order} = e^{x}\sin y $$

Both are exact solutions of Laplace's equation. The linear field is represented exactly by linear triangles, suiting the patch test; the exponential–sine product serves the order test.

Element stiffness and error measures

$$ K^e = \frac{1}{4A^e}\,B^{T}B,\qquad \|e\|_\infty = \max_i |u_i - u(\mathbf x_i)|,\qquad p = \frac{\ln(e_{2h}/e_h)}{\ln 2} $$

$A^e$ is triangle area and $B$ the shape-function gradient matrix. Look at maximum nodal error and the order $p$ when spacing is halved.

Coffee Break Trivia

The birth of the patch test

The patch test was devised in the mid-1960s by Irons and colleagues while developing plate-bending elements. Some elements ran fine yet didn't approach the correct answer under refinement. Irons proposed applying a simple state the elements should represent (such as uniform strain) to a small 'patch' of elements and judging correctness by whether it was reproduced exactly. Strang and others later clarified its mathematical meaning, and it remains the first test for new elements and in-house programs.

Worked example: a small finite element program

Example 1: patch test

A unit square meshed 6×6 with linear triangles had interior nodes shifted by up to 30% of spacing. Imposing 1 + 2x + 3y on the boundary and solving gave a maximum nodal error of 1.8×10⁻¹⁵ — round-off level — evidence of correct implementation.

Example 2: order test and catching a bug

With the exponential–sine solution under refinement, the correct implementation was compared with one planted with an error halving the area of elements in x > 0.5:

Divisions	Correct error	Order	Faulty error	Order
4	5.8×10⁻⁴	—	8.8×10⁻²	—
8	1.6×10⁻⁴	1.86	1.0×10⁻¹	−0.21
16	4.1×10⁻⁵	1.98	1.0×10⁻¹	0.01
32	1.0×10⁻⁵	2.00	9.9×10⁻²	0.02

🙋

The faulty implementation's error doesn't shrink at all with refinement.

🎓

Right. Halving the area doubles stiffness in those elements — a shift in the equations themselves that refinement can't cure, hence order 0. The same error also sent patch-test error up to 0.23. Conversely, passing the patch and order tests lets you say in numbers that at least this kind of error is absent. The key is automating these tests and running them on every change — passing once doesn't prevent later edits from breaking things.