Skip to content

Dimensional Chain Diagram

A modelling tool — instantiates Tolerance Stack Management

Draws the closed loop of dimensions and interfaces whose deviations combine, anchoring each link to a common reference so the contributors to a fit can be seen and counted before they are computed.

Before anyone can add up variation, they have to know which dimensions add up — and in a real assembly that is rarely obvious. Dimensional Chain Diagram lays out the path of dimensions and interfaces that connect one functional feature to another as an explicit closed loop, drawn from a common reference datum, so that the exact set of contributors to a given fit becomes visible and countable. Its defining contribution is identification, not calculation: it establishes the loop — every link in it, every link that only looks relevant but isn't, and what each link is measured from — so that the arithmetic siblings have a correct set of terms to combine. A stack computed over the wrong chain is precisely wrong; this tool is what makes the chain right.

Example

A laptop lid must close so its top edge sits flush with the base — a target gap of about 0.3 mm with roughly ±0.2 mm of allowable play. The gap is not controlled by any one part; it is the closure of a loop: base casting datum → hinge mounting boss → hinge pin → lid bracket → lid edge, and back to the base reference. The Dimensional Chain Diagram draws that loop as a directed path, marks each link as adding to or subtracting from the gap, and pins every dimension to the base datum rather than chaining part-to-part. Drawing it does two things immediately: it reveals that a screw-hole clearance everyone had been fretting about is not in the loop (it floats), and that a hinge-boss location dimension nobody flagged is — and it exposes that two links had been dimensioned from each other rather than from the datum, a chained reference that was silently doubling their contribution. Only after the loop is correct does the team hand it to a stack calculation.

How it works

The tool builds a closed dimensional loop: it must start and end at the same reference so that the contributions sum to a defined gap. Each link is signed (does growing it open or close the fit?) and anchored to a shared datum instead of daisy-chained to its neighbour, which is what stops a single feature's error from propagating down the chain. The diagram then carries, on each link, that contributor's nominal and tolerance — an inventory attached to the map rather than kept in a separate list. What it deliberately does not do is combine them; it hands a verified loop and its per-link tolerances to whichever accumulation method the stakes call for.

Tuning parameters

  • Loop closure point — which feature-to-feature gap the chain is drawn to control. Choose the wrong closure and you analyse a fit that doesn't matter.
  • Datum strategy — baseline dimensioning (all links from one reference) versus chained dimensioning (part-to-part). Baseline prevents error propagation but demands a well-chosen datum; chaining is easy to draw and quietly stacks.
  • Granularity — how finely the path is decomposed. Finer links expose hidden contributors but bloat the loop and invite false confidence that everything's captured.
  • 1-D versus multi-axis — whether the diagram tracks a single direction or the interacting geometry of a real 3-D fit; more axes catch angular and parallel-path effects but complicate the loop.
  • Inclusion rule — how aggressively floating, non-contributing features are pruned; over-pruning drops a real contributor, under-pruning pads the stack.

When it helps, and when it misleads

Its strength is that it makes the structure of a stack legible before any number is chosen, catching the two errors that silently corrupt every downstream calculation: a missing contributor and a mis-referenced datum. Anchoring to a shared datum reference — the discipline formalized in geometric dimensioning and tolerancing — is what keeps one feature's deviation from cascading through the whole chain.[1]

It misleads when the drawn loop is mistaken for the real assembly: a diagram that omits a thermal-expansion link, an assembly-sequence effect, or a second load path will hand a clean, wrong term-set to the math, and the resulting stack will be confidently incorrect. It is also easy to draw a tidy 1-D chain for a fit that is genuinely three-dimensional. The discipline is to validate the loop against the physical build — walk the actual parts and confirm every contributor is drawn and every drawn link is real — before trusting anything computed on top of it.

How it implements the components

  • stack_path_map — it is the map: the explicit chain/loop of contributors whose deviations combine to produce the fit.
  • interface_reference_datum — it anchors each link to a common datum, defining what every contributor is measured from and stopping error propagation across interfaces.
  • local_tolerance_inventory — it carries each link's nominal and tolerance band on the diagram itself, recording the per-contributor allowances in place.

It does not compute how those tolerances combine, nor check the total against a requirement — the accumulation is done by Worst-Case Stack Calculation, Root-Sum-Square Calculation, and their siblings, and the fit check by Tolerance Stack Analysis.

Notes

The diagram is an input artifact: getting the loop and the datums right is upstream of every number, which is why an error here is the most expensive kind — it doesn't make a calculation noisy, it makes it answer the wrong question. Keep it as a living drawing that is re-walked when the design or the assembly sequence changes.

References

[1] In geometric dimensioning and tolerancing (e.g. ASME Y14.5), features are located from a defined datum reference frame rather than from each other; baseline-from-datum dimensioning is the standard way to prevent a single deviation from accumulating down a chain of part-to-part references. ↩