Bühlmann-Splinter Decompression Algorithm

The Bühlmann decompression algorithm is a widely used model in scuba diving to calculate safe ascent profiles, based on inert gas (mainly nitrogen or helium) uptake and elimination in human tissues.

The algorithm was developed by Dr. Albert A. Bühlmann, a Swiss physician and researcher at the University of Zürich. His work led to a series of decompression models, culminating in the ZHL-16 model, which uses 16 parallel tissue compartments with different half-times. These models form the basis of many modern dive computers and decompression tables used by recreational and technical divers.

The foundational research is described on:

Bühlmann, A. A. (1983). Decompression–Decompression Sickness. Springer-Verlag, ISBN: 978-3540127576
"Dekompression – Dekompressionskrankheit"

Contents

• Installation — what to install, and what you get
• Quick look — the smallest thing that does something
• Methodology — the model, its equations, its sea level reference, and a worked dive
• Using the Model Directly — the library's public surface
• Module A — Dive Profile Analyser — run a planned dive against the model
• Module B — Altitude Analyser — flying or driving to altitude afterwards
• Project layout — how the four layers sit
• Regenerating the Report Graphs — reproducing everything in reports/

Installation

Python 3.11 or newer, and no runtime dependencies — the library imports nothing outside the standard library.

pip install master-splinter

That gives you the model and nothing else: no commands, no file formats of its own, and no opinion about where your data lives. A front end supplies those, and Using the Model Directly is the whole surface it drives.

To work on the project, from a checkout:

pip install -e '.[dev,test]'

The dev extra adds matplotlib, which nothing in the library needs — only tools/methodology_figures.py and the two commands in cli/ draw anything.

Quick look

Plan a dive, execute it against the model, and see what it costs you:

from master_splinter.model.dive_state import DiveState
from master_splinter.processors.dive_analysis import analyse_profile
from master_splinter.processors.dive_simulation import generate_dive_profile

profile = generate_dive_profile([
    (30, 2, (0, 0), "descend"),    # 30 m over 2 min
    (30, 25, (0, 0), "constant"),  # 25 min on the bottom
    (0, 3, (0, 0), "ascend"),      # up in 3 min
])
report = analyse_profile(profile, DiveState.at_surface())

for stop in report.stops:
    print(f"{stop.depth:.0f} m for {stop.duration:.1f} min")
print(f"{report.total_deco_time:.1f} min of decompression")

6 m for 3.2 min
3 m for 6.5 min
9.7 min of decompression

That three-minute ascent was never going to happen: analyse_profile clamps to the decompression ceiling and reports the stops the clamping forced. The rest of that surface is in Using the Model Directly; why those are the stops is Methodology.

Methodology

Why the numbers above are the numbers they are. The four sections below are the tissue table, the equations that drive it, the sea level reference they are all measured against, and a worked example small enough to follow by hand.

ZHL-16 Tissue Compartment Table with Tissue Types

The ZHL-16 tissue table lists 16 mathematical compartments that represent different types of body tissues — each with its own half-time, and parameters A and B that determine its decompression limits.

Variant: this implementation uses the ZHL-16C coefficients, the set most dive computers ship.

Bühlmann published three. ZHL-16A is the original theoretical set, in which both coefficients fall straight out of the half-time — a = 2 / ∛T and b = 1.005 − 1/√T. It proved too permissive against real data, so he revised the mid and slow A values by hand, giving ZHL-16B for printed tables and ZHL-16C for dive computers. The B values were never revised and are identical in all three sets, which is the quickest way to spot a corrupted table.

Both sets live in src/master_splinter/configs/zhl16.py, so changing variant really is the single edit that file claims. 16A is materially more permissive — on a 30 m / 60 min dive it asks for about a fifth less decompression.

These compartments are not actual organs, but conceptual models that simulate how inert gases (e.g. nitrogen or helium) are absorbed and released in different parts of the body at different rates.

• Half-Time: Time (in minutes) it takes the tissue to absorb or release 50% of the inert gas difference
• A-Value: Intercept in the M-value equation — tolerance for supersaturation at surface pressure
• B-Value: Reciprocal of the slope in the M-value equation — P_ambient is divided by it, so a lower B means tolerance rises faster with depth
• Tissue Type: Conceptual mapping to a body tissue (e.g. blood, muscle, fat, bone)
• Notes: Fast/slow behavior in decompression

A and B Values

They are used to calculate the M-value, the maximum safe inert gas pressure in a tissue:

• A (intercept): A constant that sets the baseline supersaturation limit for a tissue compartment at surface pressure
• B (reciprocal slope): P_ambient is divided by B, so a lower B makes the M-value climb more steeply with depth

Together, they define the ceiling for each tissue — i.e., how shallow the diver can go before needing a decompression stop.

Mathematical Foundations

This section summarizes the core equations behind the Bühlmann ZHL-16 decompression model, which simulates how inert gases (e.g., nitrogen or helium) are absorbed and eliminated from body tissues during a dive.

1. Tissue Gas Uptake and Elimination

Each tissue compartment follows a first‑order exponential model for gas loading and off‑gassing:

$$ \Large P_{\text{tissue}}(t) = P_{\text{tissue}}(0) + \left( P_{\text{inspired}} - P_{\text{tissue}}(0) \right) \left( 1 - e^{-kt} \right) $$

2. Inspired Inert Gas Pressure

The inspired inert gas pressure is calculated from ambient pressure and gas fraction:

$$ \Large P_{\text{inspired}} = f_{\text{gas}} \cdot \left( P_{\text{ambient}} - P_{H_2O} \right) $$

3. M‑Value (Maximum Safe Tissue Pressure)

Bühlmann defined a maximum allowable inert gas pressure (M‑value) for each tissue compartment:

$$ \Large M = \frac{P_{\text{ambient}}}{B} + A $$

4. Ascent Ceiling (Minimum Ambient Pressure)

To calculate the shallowest depth a diver can safely ascend to, the M‑value equation is rearranged:

$$ \Large P_{\text{ambient}}^{\min} = \left( P_{\text{tissue}} - A \right) \cdot B $$

5. Gradient Factors

Gradient Factors add conservatism by scaling down the M‑value:

$$ \Large P_{\text{allowed}} = P_{\text{ambient}} + GF \cdot \left( M - P_{\text{ambient}} \right) $$

Since GF lies between 0 and 1, the allowed pressure always falls between ambient pressure and the raw M-value — a gradient factor can only ever scale the allowance down. Its value is interpolated across the ascent, from GF_low at the first stop to GF_high at the surface:

$$ \Large GF = GF_{\text{high}} - \left( GF_{\text{high}} - GF_{\text{low}} \right) \cdot \frac{P_{\text{ambient}} - P_{\text{surface}}}{P_{\text{first stop}} - P_{\text{surface}}} $$

The Sea Level Reference

Every pressure above is absolute, in bar, and every one of them is measured against a sea level of 1.01325 bar — the published International Standard Atmosphere P0 (101325 Pa), set once as SURFACE_PRESSURE in src/master_splinter/configs/environment.py.

That is worth stating because most diving literature rounds it to 1 bar, and this project deliberately does not. The reason is the elevation conversion:

$$ \Large P(h) = P_0 \cdot \left( 1 - 2.25577 \times 10^{-5} \cdot h \right)^{5.25588} $$

Those two constants are calibrated as a set with P0 = 101325 Pa. Keeping them while rounding P0 to 1.0 gives a curve of the right shape through the wrong point — self-consistent, and wrong by about 110 m at every elevation:

The middle column is a pressure that belongs to neither convention: it is 2,400 m on the diving scale and 2,505 m on the standard atmosphere. Since altitude analysis compares tissue pressures directly against these figures, the project uses the ISA value throughout so that a stated elevation means what it says.

The visible consequences are small and all of a piece — a sea level dive reports 1.0132 bar rather than 1.0000 bar, surface equilibrium is 0.7509 bar rather than the 0.7405 bar of the tables, and compartment 1's surfacing M-value is 2.99 bar rather than the tabulated 2.96 bar. Each is the same equation evaluated at a real sea level instead of a rounded one.

The published ZHL-16C A and B coefficients are unaffected. They are properties of the algorithm, not of the atmosphere, and are used exactly as Bühlmann printed them.

Simulating a Simple Dive

Here's how these formulas come together in a practical example of a typical dive simulation:

Dive Profile

• Descend to 15 meters (ambient pressure ≈ 2.513 bar)
• Stay at 15 meters depth for 30 minutes
• Ascend to 5 meters and stay for 3 minutes
• Surface (ambient pressure ≈ 1.013 bar)

Step-by-Step Application

1. Calculate inspired nitrogen pressure at 15 meters:

   • P_ambient = 1.01325 + (15 / 10) = 2.513 bar
   • P_inspired = 0.79 × (2.513 − 0.0627) ≈ 1.936 bar

2. Update each tissue using the gas loading formula for 30 minutes at 15m:

   • For each of the 16 compartments:
     • Apply: P_tissue(t) = P_tissue(0) + (P_inspired − P_tissue(0)) × (1 − e^(−k × t))

3. Ascend to 5 meters, recalculate P_inspired, and update tissue pressures again for 3 minutes.

4. Check each compartment before surfacing:

   • Compute its M-value: M = P_ambient / B + A
   • Compare to the current P_tissue
   • If P_tissue > M, decompression stop is required

5. (Optional) Apply Gradient Factors:

   • Calculate a GF-adjusted limit: P_allowed = P_ambient + GF × (M − P_ambient)
   • This helps determine whether it's safe to surface under conservative settings like GF 30/85

Result

The dive simulation models a straightforward profile: a descent to 15 meters for 30 minutes, followed by a direct ascent to 5 meters with a 3-minute safety stop, and then surfacing. The fast compartment is the one that visibly does the work — it loads to 1.92 bar over the bottom phase and is already off-gassing by the safety stop, ending at 1.53 bar. The medium and slow compartments are still filling when the diver surfaces; on a dive this short they barely turn over at all, peaking at 1.04 and 0.79 bar respectively.

Using Bühlmann’s ZHL-16 algorithm, the tissue pressure remains safely below the calculated M-value limit. Two sets of gradient factors (GF 30/85 and GF 50/95) were applied to assess additional safety margins. The tissue pressure did not exceed either of these GF-adjusted ceilings at any point, indicating the diver stayed within conservative ascent limits.

Each compartment is paired with its own GF 30/85 ceiling, in the same colour. Drawing one compartment's ceiling across all three would compare a pressure against a limit that was never its own.

The absence of any threshold crossings suggests that no decompression stop was required, and the 3-minute hold at 5 meters was sufficient to manage supersaturation before surfacing. Overall, this profile represents a clean, no-decompression dive that adheres well to both standard and conservative ascent protocols.

Using the Model Directly

DiveState carries the tissue loading and the gradient factor anchor, and is the object every entry point below drives.

Analysing a dive

The Quick look above, with what it left out. A profile is a list of (depth, duration, elapsed) tuples: generate_dive_profile builds one from phase boundaries, load_profile reads one from a dive computer log.

from master_splinter.model.dive_state import DiveState
from master_splinter.processors.dive_analysis import analyse_profile
from master_splinter.processors.dive_simulation import generate_dive_profile

profile = generate_dive_profile([
    (30, 2, (0, 0), "descend"),
    (30, 25, (0, 0), "constant"),
    (0, 3, (0, 0), "ascend"),
])

report = analyse_profile(profile, DiveState.at_surface(gas_fraction=0.79))
print(report.stops, report.total_deco_time, report.findings)

analyse_profile does not merely judge the plan — it executes it, clamping every ascent to the decompression ceiling. So report.samples is the dive that could actually be performed, not the one requested, and report.stops is what clamping forced. report.findings lists where the plan itself was unsafe, each tagged with a Violation:

from master_splinter.processors.dive_analysis import Violation

for finding in report.findings_of(Violation.ASCENT_RATE):
    print(finding)

The knobs are keyword-only: ascent_rate, deco_step, and ppo2_limit (bar, default 1.4, and never above PPO2_CONTINGENCY_LIMIT — see ppo2_limit below).

Going up afterwards

analyse_altitude_change answers the flying-after-diving question against the tissue state a dive ended on. The gain is measured relative to the dive site, which is why surface_pressure is a parameter rather than an assumption:

from master_splinter.processors.altitude_analysis import analyse_altitude_change

verdict = analyse_altitude_change(
    report.final_state.tissues,
    elevation_gain=2400,        # a pressurised cabin
    surface_interval=18 * 60,   # minutes since surfacing
    gf_high=0.85,
)
print(verdict.safe, verdict.gradient.wait_minutes, verdict.gradient.max_gain)

It reports two Verdicts side by side — raw for unmodified Bühlmann and gradient for the GF-limited answer — and report.safe is true only when both permit the change. When a verdict is unsafe, wait_minutes is the extra surface time needed, or None when no surface interval is ever enough.

This models tissue nitrogen only. It is not a substitute for published flying-after-diving guidance, which allows 12 h after a single no-stop dive and 18 h after decompression dives.

Carrying state between dives

What carries over is the tissue pressures, not the M-values. Every entry point takes an explicit path — the library has no default state location, because where your state lives is your decision:

from master_splinter.utils.state_store import read_state, save_tissues

save_tissues(report.final_state, "dive.json")

saved = read_state("dive.json")          # exactly as written, not aged
if saved is not None:
    tissues = saved.tissues
    interval = saved.minutes_since()     # wall-clock minutes at the surface

Reading and ageing are deliberately separate: load_state does both at once, read_state gives you the file as saved so you can age it against an interval you supply. An unusable file reads as None rather than raising, so a corrupt state degrades to "start fresh" — call state_problem(path) to find out whether that happened and say so.

Validating user input

The bounds a front end needs are in one place, so two front ends cannot disagree about them. Each takes the text a user typed and raises ValueError with a message fit to show that user:

import argparse
from master_splinter import validation

def gradient_factors(text):
    try:
        return validation.gradient_factors(text)
    except ValueError as error:
        raise argparse.ArgumentTypeError(str(error)) from error

gradient_factors parses LOW/HIGH into a pair of fractions, ppo2_limit caps at the contingency limit, and elevation accepts a signed change bounded by where the troposphere formula stops being physics.

The two commands below live in cli/. They are not installed by pip install master-splinter and ship in no release artifact — they are kept in the repository as its reference consumer: the proof the library works end to end, and the only place the whole pipeline is exercised in one go. Run them from a checkout.

Module A — Dive Profile Analyser

Takes a planned dive — synthetic or a real dive computer log — and executes it against the model, clamping to the decompression ceiling so what comes out is a dive someone could actually perform. It reports the stops that clamping forced, every point where the plan was unsafe, and the tissue state to carry into the next dive.

Quick start

The analyser runs a planned dive profile against the model, reports the stops it actually requires, flags where the plan was unsafe, and writes a graph:

python -m cli.profile_analyser

Dive site: 0 m (1.0132 bar)
Gas: air (0.79 N2)
Gradient factors: 30/85

Decompression stops performed:
    6.0 m for   1.3 min
    3.0 m for   3.2 min
  total   4.5 min

Findings:
  [CEILING] t=27.5 min: plan calls for 5.0 m but the ceiling is 6.0 m (1.0 m above it)
  [CEILING] t=33.0 min: plan calls for 0.0 m but the ceiling is 3.0 m (3.0 m above it)
  [SURFACED OWING] t=33.0 min: plan surfaces owing 2.5 min, first stop at 3.0 m
  [ASCENT RATE] t=19.5 min: ascending at 10.7 m/min, above the 10.0 m/min limit

Max depth: 42.0 m
Deepest stop required (GF anchor): 18.0 m
Planned runtime: 33.0 min
Actual runtime: 36.0 min
Safe to surface (no GF): True
Safe to surface (with GF): True

Graph written to dive_simulation.png

The default profile is deliberately imperfect — it ascends through its own ceiling and surfaces owing two and a half minutes at 3 m. The Findings block is the analyser telling you so; the executed dive shown on the graph is the corrected one.

The 6.0 m and 3.0 m stops above are dwell time only. walk_ceiling_to_surface loads gas at each ceiling depth for the step interval, but the move from one stop to the next shallower one is not itself timed — the ascent between 6 m and 3 m costs nothing here, where a real ascent at MAX_ASCENT_RATE would spend a few seconds on it. That is a few tens of seconds folded away per stop, always in the optimistic direction, and it is not currently called out anywhere else in this document.

Dive options

Argument reference

Time, depth ,temperature
0,0,21
2,30,17
20,30,16
24,5,19
28,5,19
30,0,21

[
  {"time": 0,  "depth": 0},
  {"time": 2,  "depth": 30},
  {"time": 20, "depth": 30},
  {"time": 24, "depth": 5},
  {"time": 28, "depth": 5},
  {"time": 30, "depth": 0}
]

{
  "samples": [
    {"time": 0,  "depth": 0},
    {"time": 2,  "depth": 30},
    {"time": 20, "depth": 30},
    {"time": 24, "depth": 5},
    {"time": 28, "depth": 5},
    {"time": 30, "depth": 0}
  ]
}

error: cannot read dive.csv: CSV needs 'time' and 'depth' columns, missing ['depth']; found ['time', 'metres']
error: cannot read dive.csv: depth 200.0 m at sample 1 (t=5.0) is outside 0..120 m; check the units

error: cannot analyse dive.csv: Ascent did not clear within 720 minutes; tissue pressures are likely invalid.

python -m cli.profile_analyser --fresh --ppo2-limit 1.0

Working ppO2 limit: 1.00 bar
...
  [OXYGEN (MOD)] t=15.7 min: ppO2 1.09 bar at 42.0 m exceeds the 1.0 bar limit; MOD for this mix is 37.5 m

profile_analyser.py: error: argument --ppo2-limit: need 0 < limit <= 1.6, got 2.0
profile_analyser.py: error: argument --ppo2-limit: expected a ppO2 in bar such as 1.4, got 'abc'

profile_analyser.py: error: argument --gf: need 0 < low <= high <= 100, got 85/30
profile_analyser.py: error: argument --gf: expected LOW/HIGH such as 30/85, got 'abc'

WARNING: state file /home/you/.local/state/master-splinter/state.json has schema version 1, expected 2.
         Starting from surface equilibrium - residual loading from a previous
         dive is NOT accounted for, so the decompression below may be understated.
         Re-run that dive, or pass --fresh to start clean deliberately.

error: cannot write /tmp/absent/graph.png: [Errno 2] No such file or directory: '/tmp/absent/graph.png'

Dive scenarios

Worked examples, each self-contained. Expand the one you need.

python -m cli.profile_analyser --gas air   --fresh
python -m cli.profile_analyser --gas ean40 --fresh

[OXYGEN (MOD)] t=15.7 min: ppO2 2.08 bar at 42.0 m exceeds the 1.6 bar limit; MOD for this mix is 29.9 m

python -m cli.profile_analyser --fresh              # 4.5 min of deco
python -m cli.profile_analyser --surface-interval 45  # 21.3 min
python -m cli.profile_analyser --surface-interval 720 # back to 4.5 min

python -m cli.profile_analyser --fresh                  # 4.5 min of deco
python -m cli.profile_analyser --fresh --altitude 1800  # 10.8 min

Dive site: 1,800 m (0.8149 bar)
Gas: air (0.79 N2)
Gradient factors: 30/85

cat > dive.csv <<'CSV'
time,depth
0,0
1,20
2,30
20,30
22,15
25,5
28,5
30,0
CSV

python -m cli.profile_analyser --profile dive.csv --fresh

Module B — Altitude Analyser

Ascending to altitude lowers ambient pressure, which is arithmetically the same thing as surfacing further: nitrogen that was tolerable at the dive site can be supersaturated in a mountain pass or an aircraft cabin. The altitude analyser reads the same state file and answers whether a given elevation change is safe yet.

Quick start for altitude

python -m cli.altitude_analyser --elevation-gain 2400

Dive site: 0 m (1.0132 bar)
Elevation gain: +2,400 m -> 2,400 m (0.7563 bar)
Surface interval: 0 min so far

  raw Bühlmann   UNSAFE
    tolerates down to 0.8972 bar (compartment 5, 27 min half-time)
    margin -0.1410 bar
    safe in 12 min (12 min total surface interval)
    largest gain permitted now +1,014 m

  GF 85          UNSAFE
    tolerates down to 1.0009 bar (compartment 5, 27 min half-time)
    margin -0.2447 bar
    safe in 24 min (24 min total surface interval)
    largest gain permitted now +103 m

This models tissue nitrogen only. It is not a substitute for published
flying-after-diving guidance, which allows 12 h after a single no-stop dive
and 18 h after decompression dives.

Altitude options

Altitude argument reference

altitude_analyser.py: error: argument --elevation-gain: expected a signed elevation in meters, got 'abc'
altitude_analyser.py: error: argument --elevation-gain: need |elevation| <= 11000 m, got 12000.0
altitude_analyser.py: error: argument --elevation-gain: expected a finite elevation in meters, got 'nan'

    safe in 7 h 23 min (8 h 08 min total surface interval)

error: no usable tissue state in /tmp/absent.json; run the profile analyser first

Altitude scenarios

Worked examples, each self-contained. Expand the one you need.

python -m cli.altitude_analyser --elevation-gain 1000 --surface-interval 0

Elevation gain: +1,000 m -> 1,000 m (0.8987 bar)

  raw Bühlmann   SAFE
    margin +0.0015 bar
    room for a further +1,014 m

  GF 85          UNSAFE
    margin -0.1022 bar
    safe in 7 min (7 min total surface interval)

python -m cli.altitude_analyser --elevation-gain -1800 --surface-interval 0

Dive site: 1,800 m (0.8149 bar)
Elevation gain: -1,800 m -> 0 m (1.0132 bar)

  raw Bühlmann   SAFE
    margin +0.2894 bar
    room for a further +948 m

  GF 85          UNSAFE
    tolerates down to 1.0009 bar (compartment 5, 27 min half-time)
    margin -0.2447 bar
    safe in 24 min (24 min total surface interval)

python -m cli.altitude_analyser --elevation-gain 2400 --surface-interval 240

  GF 85          SAFE
    tolerates down to 0.5906 bar (compartment 16, 635 min half-time)
    margin +0.1657 bar
    room for a further +4,327 m

Reading the result

Which compartment holds you changes with time. Straight after surfacing it is a fast one — compartment 5 at a 27 minute half-time above — because the fast tissues are still near the ceiling they were held at during the ascent. Four hours later the same dive is limited by compartment 16 at 635 minutes, and the tolerable gain has grown from +1,014 m to +4,813 m. That crossover is why altitude guidance is written in hours: the slow tissues are what remain.

Read the caveat. For the default dive the model clears cabin altitude in under half an hour, while DAN asks for 12 hours. They are answering different questions — this computes when tissue nitrogen falls inside the ZHL-16C limit, whereas published guidance builds in a margin for bubble formation, individual variation and the consequences of being wrong at 10,000 feet with no chamber. Follow the published guidance. Descending is the one case with no argument: it raises ambient pressure and is always permitted.

Project layout

Four layers, each depending only on the ones above it. The model knows nothing about files or command lines, which is what lets the same equations serve a dive profile and an altitude question.

src/master_splinter/
  validation.py             bounds checking shared by every front end
  configs/     zhl16.py       the algorithm variant — half-times, A and B
               limits.py      conservatism — ascent rate, ppO2, gas mixes
               environment.py water and atmosphere — pressure conversions
  model/       splinter_decompression.py   pure ZHL-16C, no I/O
               atmosphere.py               elevation <-> pressure
               dive_state.py               tissue loading over time
  processors/  dive_analysis.py       execute a profile, judge it
               altitude_analysis.py   elevation change after a dive
               dive_simulation.py     synthetic profile generator
  utils/       profile_loader.py  read CSV/JSON dive logs
               state_store.py     tissue state between dives
  theme/       __init__.py        colour roles, and style_path()
               splinter.mplstyle  the dark theme, shipped as package data
cli/           profile_analyser.py    Module A
               altitude_analyser.py   Module B
               plotting.py            renders a dive report
               validators.py          argparse over validation.py
               paths.py               where this front end keeps things
reports/       methodology figures — see Regenerating the report graphs
tools/         methodology_figures.py  redraws the figures above

src/master_splinter/ is the whole distributable: pip install master-splinter puts exactly one name on your path. Everything outside it — cli/, reports/, tools/, tests/ — is repository furniture and ships in no release artifact.

theme/ is the exception that proves the layering: it holds no model code, but cli/ and tools/ both draw and both need the same colours, so it ships once rather than being vendored into each. Reach it with master_splinter.theme.style_path().

Pressure is the model's currency, not depth. load_gas_at_pressure and DiveState.step_at_pressure are the primitives; step(depth, …) and pressure_at_elevation are two ways of naming a pressure. A diver ascending and a diver boarding an aircraft are doing the same thing to their tissues, so both go through one code path — which is also what a future live-dive handler will drive.

Regenerating the Report Graphs

Everything under reports/ is generated, from tools/methodology_figures.py, and it is deterministic — the same model, the same style sheet, byte-identical output unless the model itself changed.

The dive report figures that used to sit alongside these were drawn by the renderer that left with the CLI, so they are gone: the package no longer draws anything. Whichever front end inherits the commands owns those figures, and needs matplotlib to redraw them.

Methodology Figures

The five figures embedded in Methodology are explanatory rather than analytical — they illustrate the equations themselves, not one dive's report — so they live in reports/methodology/ and regenerate together:

python tools/methodology_figures.py

They share one dark theme with everything else this project draws.

Every value in them is computed by master_splinter/model/splinter_decompression.py and master_splinter/configs/zhl16.py at render time — nothing is transcribed. That is deliberate. The images these replaced had drifted: they showed a 4 minute compartment 1 from ZHL-16A, an M-value of A + B · P_ambient, and gradient factor lines above the M-value rather than below it. A figure that recomputes cannot drift.

The Look

One dark theme for everything, in master_splinter.theme. The style sheet dresses the canvas — surface, grid, ink, the fallback cycler — and the module names the colours that carry meaning, so a compartment is the same blue in a dive report as in a teaching figure. It replaced bbg.mplstyle, which styled only the reports.

It ships with the package so cli/, tools/ and any consumer read one copy:

import matplotlib.pyplot as plt
from master_splinter import theme

with plt.style.context(theme.style_path()):
    ...

style.context rather than style.use is worth the habit — use mutates global rcParams, which matters to anything rendering more than one figure at a time. The style sheet is also emphatically dark and fixes its own figure size; a consumer embedding charts in a light page wants the colour roles and its own canvas.