What a solver is actually doing

Turning a physical law into arithmetic repeated a very large number of times.

A solver is a program that takes the equations describing how heat spreads, how air moves, or how a loaded part deforms, and turns them into a very large number of small sums, then repeats those sums over and over until the numbers stop changing.

I spent the better part of a year running studies on shapes that never left the screen, and somewhere in the middle of that year the question that mattered stopped being what the results looked like and became what the machine had actually been doing to produce them.

Every region waits on its neighbours

The equations for fluid flow or heat conduction cannot be solved directly for a real, complicated shape. Instead the shape is broken into a large number of small regions, and in each one the solver writes down a simplified version of the physical law relating that region's value, a temperature or a pressure or a velocity, to the values in the regions next to it. The difficulty comes from every region's equation depending on its neighbours, whose equations depend on their own neighbours in turn, so the whole set has to be solved together.

The solver's job is to guess a starting set of values everywhere then update every region once from its neighbours, then do that again, thousands of times. Each pass nudges the whole field a little closer to a state where every region's value is consistent with what sits next to it, and that state, reached by repetition alone, is the answer.

Kneading a lumpy dough smooth

Kneading bread works on the same principle. A ball of dough fresh off the mixer is lumpy, and no single fold fixes that. Folding, pressing flat, turning and folding again, dozens of times, moves a little of what is concentrated in one spot into the region next to it, until the same simple local action, repeated enough, has spread consistency across the whole ball. Each solver iteration is one such fold, and just as nobody can point to the fold that finally made the dough smooth, nobody can point to the iteration that produced the correct pressure at a given point.

Watching the residual fall

The check a solver runs on itself is called the residual, a measure of how far each region's equation still is from balancing. With a rough starting guess everywhere, that imbalance begins large, and a run is commonly called converged once the residual has fallen to about a thousandth of its starting size, and often to a millionth for quantities like temperature, at which point further passes change the answer by too little to matter. A steady descent on that graph, as against a flat line or a climb, is the fastest sign that the arithmetic is behaving.

A clean residual on a wrong setup

Everything a solver produces is downstream of two decisions a person made before the first iteration: which physical law was written into each cell, and how the shape was divided up to hold those cells. The solver cannot notice that either was wrong, and it will iterate a wrong setup to convergence with its residual falling just as cleanly. What the residual certifies is that the arithmetic reached an internally consistent state, and whether that state describes anything real is a separate question.

Colourful, detailed pictures of pressure make that easy to forget, because detail reads as authority. The arithmetic can be trusted completely, and the setup that fed it cannot be trusted at all until something outside the solver has checked it.