# Bootstrap: the pymrm this page was checked with, and the gallery files it was
# published with. Works in a checkout, in CI and on a fresh Colab VM.
GALLERY_REF = "gallery-2026.11.10.3"  # replaced by the release tag at publication
PYMRM = ">=3.3.0,<4"  # equals meta.yaml pymrm_min_version, up to the next major
PAGE = "D1.1-froment-fixed-bed-ladder"  # equals the page directory

import os, sys, urllib.request
from pathlib import Path
_shared = next((p / "shared" for p in (Path.cwd(), *Path.cwd().parents)
                if (p / "shared" / "gallery_bootstrap.py").is_file()), None)
if _shared is None:
    _shared = (Path(os.environ.get("XDG_CACHE_HOME") or Path.home() / ".cache")
               / "pymrm-gallery" / GALLERY_REF)
    _shared.mkdir(parents=True, exist_ok=True)
    urllib.request.urlretrieve(
        "https://raw.githubusercontent.com/computational-chemical-engineering/"
        f"pymrm-gallery/{GALLERY_REF}/shared/gallery_bootstrap.py",
        _shared / "gallery_bootstrap.py")
sys.path.insert(0, str(_shared))
sys.modules.pop("gallery_bootstrap", None)
from gallery_bootstrap import setup
setup(PAGE, PYMRM, GALLERY_REF);  # the semicolon stops the cell echoing the path

import inspect
from dataclasses import replace

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import brentq
from gallery_utils import load_data, load_meta, load_claims, Claims
from model import (KCAL, Reactor, film, eta_sphere, phi_prime, Ladder, Pellet, hotspot,
                   solve_robust, T_max_safe, CTL_JUMP, CTL_STATS, NotACrossing,
                   crossing_control, p0_critical, cross_scan, ode_reference,
                   p0_critical_ode, richardson)
from model import _shift_or_none

# DETERMINISM: nothing on this page is stochastic - no sampling, no bootstrap, no
# random initial guess.  Every fixed-inlet solve starts from a guess that is a fixed
# function of the inputs, and every threshold is followed along its branch from one
# such start inside a single call, so no state crosses from one call to the next.
# Two consecutive executions give identical content and agreement.json.
# A pandas Styler's text/plain repr is a memory address and its HTML carries a
# random id, so Stylers go through to_html() with a PINNED uuid; and ipykernel
# flushes stdout on a timer, so the flush interval is disabled.
try:
    sys.stdout.flush_interval = 1e6
except Exception:
    pass
from IPython.display import HTML, display


def show(styler):
    display(HTML(styler.to_html()))


plt.rcParams.update({"figure.dpi": 110, "axes.grid": True, "grid.alpha": 0.3})
C_BLUE, C_ORANGE, C_GREEN, C_PURPLE, C_RED = ("#0072B2", "#D55E00", "#009E73",
                                              "#CC79A7", "#8B0000")
np.set_printoptions(precision=8, suppress=False)

PAGE = "D1.1-froment-fixed-bed-ladder"
D22 = "D2.2-van-welsenaere-froment-runaway"
C210 = "C2.10-o-xylene-phthalic-anhydride"
B11 = "B1.1-thiele-weisz-hicks"
A11 = "A1.1-ergun-pressure-drop"

BK = load_data("froment-2011-ch11-printed.csv", page=PAGE).set_index("key")
BKMETA = load_meta("froment-2011-ch11-printed.csv", page=PAGE)


def bk(key, field="value"):
    """A number or sentence from Chapter 11, looked up - never retyped in a cell."""
    v = BK.loc[key, field]
    return float(v) if field == "value" else str(v)


print("this page's own dataset :", BKMETA["dataset_id"], "-",
      len(BK), "rows read from Chapter 11")
print("  ", BK.kind.value_counts().to_dict())
print("borrowed, and each source page read:")
VWF_PAR = load_data("van-welsenaere-froment-1970-parameters.csv", page=D22).set_index("symbol")
VWF_EX = load_data("van-welsenaere-froment-1970-examples.csv", page=D22)
F67_PAR = load_data("froment-1967-parameters.csv", page=C210).set_index("symbol")
F67_RES = load_data("froment-1967-stated-results.csv", page=C210)
ETA_REF = load_data("isothermal-exact.csv", page=B11)
ERG_PAR = load_data("ergun-1952-parameters.csv", page=A11)
for nm, pg, df in ((load_meta("van-welsenaere-froment-1970-parameters.csv", page=D22)["dataset_id"], D22, VWF_PAR),
                   (load_meta("van-welsenaere-froment-1970-examples.csv", page=D22)["dataset_id"], D22, VWF_EX),
                   (load_meta("froment-1967-parameters.csv", page=C210)["dataset_id"], C210, F67_PAR),
                   (load_meta("froment-1967-stated-results.csv", page=C210)["dataset_id"], C210, F67_RES),
                   (load_meta("isothermal-exact.csv", page=B11)["dataset_id"], B11, ETA_REF),
                   (load_meta("ergun-1952-parameters.csv", page=A11)["dataset_id"], A11, ERG_PAR)):
    print(f"   {nm:<34s} {len(df):5d} rows   from pages/{pg}/")

# what the four source pages establish about these rows, read from their own
# committed claims rather than retyped; The data, below, says what each affects
D22_C, C210_C, B11_C, A11_C = (load_claims(pg) for pg in (D22, C210, B11, A11))
C210_U_WORST = max(abs(C210_C[k]) for k in ("u_ref_identity_rel", "u_lam075_identity_rel",
                                             "u_aw150_identity_rel"))

# ---- Van Welsenaere & Froment's printed parameters, from D2.2's CSV -----------
V = dict(zip(VWF_PAR.index, VWF_PAR.value))
P = dict(M=V["M"], p_t=V["P"], rho_b=V["rho_b"], rho_g=V["rho_g"],
         minus_dH=V["minus_dH"], cp_vol=V["c_p"], u=V["u"], U=V["U"], R=V["R"],
         p_B0=V["p_B0"], a=V["a"], b=V["b"])
# c_p is ALREADY VOLUMETRIC, kcal/(m3 degC) - that trap is D2.2's finding, and
# D2.2's own unit column is what says so.  It is not rediscovered here.
assert VWF_PAR.loc["c_p", "unit"] == "kcal/(m3 degC)", VWF_PAR.loc["c_p", "unit"]

L_BED = bk("tube_length")
D_T_PRINTED = bk("tube_id")
D_P = bk("particle_diameter")
T_R0 = bk("coolant_temperature")                   # 352 C
T_PERM = bk("temp_range_high")                     # 415 C, the printed ceiling
R_T = P["R"]                                       # 0.0125 m; justified below
EPS = bk("voidage_a") + bk("voidage_b") * (
    1.0 + (D_T_PRINTED / D_P - 2.0) ** 2 / (D_T_PRINTED / D_P) ** 2)   # (11.5.1-16)
LAM_ER, ALPHA_W = bk("lam_er"), bk("alpha_w")
PE_MR, PE_HR = bk("pe_mr"), bk("pe_hr")

# the design case of model.py: every rung, pellet and reference solve reads it
RX = Reactor(**P, length=L_BED, d_p=D_P, T_r=T_R0, T_perm=T_PERM, eps=EPS,
             lam_er=LAM_ER, alpha_w=ALPHA_W, pe_mr=PE_MR, pe_hr=PE_HR,
             re_film=bk("Re_1173"))
A_G, B_G = RX.A, RX.B                              # the groups of (11.5.2-1/2)
THETA = RX.theta                                   # kmol/(m3 atm), from (11.5.2-1)
CP_MASS = RX.cp_mass                               # kJ/(kg K)
RHO_S = RX.rho_s
A_V = 6.0 * (1.0 - EPS) / D_P
C_G, kexp = RX.C, RX.kexp


# ================= the atm -> bar audit of section 11.5.2 =====================
ATM = 1.01325
rows = []


def add(what, book_key, orig, factor, note):
    b_ = bk(book_key)
    rows.append(dict(quantity=what, VWF_1970=orig, book_11_5_2=b_,
                     ratio=b_ / orig, vs_atm_to_bar=b_ / (orig * factor) - 1.0,
                     reading=note))


add("oxygen partial pressure p_B0", "oxygen_pressure", V["p_B0"], ATM, "converted")
add("heat of reaction (-dH)", "heat_of_reaction", V["minus_dH"] * KCAL, 1.0, "kcal -> kJ")
for k, q in (("vwf_p0_lower_625", "1a p0_lower"), ("vwf_p0_upper_625", "1a p0_upper"),
             ("vwf_p0_mean_625", "1a p0_mean"), ("vwf_p0_backint_625", "1a p0_critical")):
    ex = VWF_EX[(VWF_EX.example == "1a") & (VWF_EX.quantity == q.split()[1])]
    o = float(ex.value.iloc[0])
    add(f"Table 11.5.3.A-2 {q.split()[1]}", k, o, ATM,
        "converted" if "critical" not in q else "NOT converted")
AUDIT = pd.DataFrame(rows)
show(AUDIT.style.set_uuid("d11audit").hide(axis="index").format(
    {"VWF_1970": "{:.6g}", "book_11_5_2": "{:.6g}", "ratio": "{:.6f}",
     "vs_atm_to_bar": "{:+.2e}"}))

CONV_WORST = float(np.abs(AUDIT.vs_atm_to_bar.iloc[:-1]).max())
BACKINT_RESIDUAL = float(AUDIT.vs_atm_to_bar.iloc[-1])
print(f"\nThe first five rows are Van Welsenaere & Froment's atm values multiplied by"
      f"\n1 atm / 1 bar = {ATM}, reproduced to {CONV_WORST:.1e} relative - so section 11.5.2"
      f"\nIS their parameter set converted, and the conversion is not in doubt.")
print(f"The last row is not: the back-integrated critical inlet pressure is printed as"
      f"\n'{bk('vwf_p0_backint_625','as_printed')} bar' and is Van Welsenaere & Froment's"
      f" {VWF_EX[(VWF_EX.example=='1a')&(VWF_EX.quantity=='p0_critical')].value.iloc[0]} ATM"
      f"\nleft unconverted ({BACKINT_RESIDUAL:+.2e} against the converted value).")
_mean_bar = bk("vwf_p0_mean_625")
_bi_atm = float(VWF_EX[(VWF_EX.example == "1a") & (VWF_EX.quantity == "p0_critical")].value.iloc[0])
AGREE_AS_PRINTED = _mean_bar / _bi_atm - 1.0
AGREE_CONSISTENT = _mean_bar / (_bi_atm * ATM) - 1.0
print(f"\nThe book calls the two 'in excellent agreement'. As printed they differ by"
      f" {100*AGREE_AS_PRINTED:+.2f} %;"
      f"\nconverted consistently, by {100*AGREE_CONSISTENT:+.2f} % - the claim is BETTER than"
      f" the numbers beside it.")

# =================== what the chapter's own groups require ====================
route = []
route.append(("group B of Example 11.5.3.A = 257e6",
              bk("vwf_B"), P["minus_dH"] * P["rho_b"] * P["p_B0"] / P["cp_vol"],
              "p_B0 rho_b (-dH) / (rho_g c_p)"))
route.append(("group A of Example 11.5.3.A = 6150",
              bk("vwf_A"), A_G, "M p_t p_B0 rho_b / rho_g, the formula printed above it"))
_dTad = float(VWF_EX[(VWF_EX.example == "3") & (VWF_EX.quantity == "dT_ad")].value.iloc[0])
route.append(("A implied by dT_ad = 312.6 K at p0 = 0.0075 atm",
              bk("vwf_A"), bk("vwf_B") / (_dTad / 0.0075), "B / (dT_ad / p0)"))
GRP = pd.DataFrame(route, columns=["the book prints", "printed", "recomputed", "from"])
GRP["rel. dev."] = GRP.recomputed / GRP.printed - 1.0
show(GRP.style.set_uuid("d11groups").hide(axis="index").format(
    {"printed": "{:.6g}", "recomputed": "{:.7g}", "rel. dev.": "{:+.3e}"}))
A_PRINTED_DEV = float(GRP["rel. dev."].iloc[1])
B_PRINTED_DEV = float(GRP["rel. dev."].iloc[0])
print(f"\nB is reproduced to {abs(GRP['rel. dev.'].iloc[0]):.1e}, which pins (-dH), rho_b, p_B0"
      f"\nand the volumetric c_p together. A is not: the printed 6150 is"
      f" {100*A_PRINTED_DEV:+.3f} % from"
      f"\nits own printed formula, and the example's own dT_ad = 312.6 K at 0.0075 needs"
      f" {GRP.recomputed.iloc[2]:.1f}.")

# c_p: three independent routes against the printed 0.992 kJ/(kg K)
G_FLUX = P["rho_g"] * P["u"] / 3600.0                       # kg/(m2 s)
cp_routes = pd.DataFrame([
    ("volumetric c_p of D2.2's CSV / rho_g", P["cp_vol"] * KCAL / P["rho_g"]),
    ("B = 257e6 with (-dH), rho_b, p_B0 as printed",
     P["minus_dH"] * P["rho_b"] * P["p_B0"] / bk("vwf_B") * KCAL / P["rho_g"]),
    ("Pe_hr = 5.25 with lambda_er = 0.78e-3, G, d_p",
     PE_HR * LAM_ER / (G_FLUX * D_P)),
    ("Froment (1967) p. 19, loaded from C2.10", F67_PAR.loc["c_p", "value"] * KCAL),
], columns=["route", "c_p [kJ/(kg K)]"])
cp_routes["vs printed 0.992"] = cp_routes["c_p [kJ/(kg K)]"] / bk("specific_heat") - 1.0
show(cp_routes.style.set_uuid("d11cp").hide(axis="index").format(
    {"c_p [kJ/(kg K)]": "{:.6f}", "vs printed 0.992": "{:+.4f}"}))
CP_SPREAD = float(cp_routes["c_p [kJ/(kg K)]"].max() / cp_routes["c_p [kJ/(kg K)]"].min() - 1.0)
CP_PRINTED_DEV = float(cp_routes["vs printed 0.992"].mean())
print(f"\nFour routes, three of them inside Chapter 11 and the fourth Froment's own 1967"
      f"\npaper loaded from C2.10: they span {CP_SPREAD:.2e} and sit"
      f" {100*CP_PRINTED_DEV:+.1f} % from the 0.992 kJ/(kg K)"
      f"\nsection 11.5.2 prints. The printed value is recorded as a defect and is used"
      f" nowhere.")
print(f"\nBUT THE FOUR ARE NOT FOUR INDEPENDENT DETERMINATIONS, and the spread must not be"
      f"\nread as one. Route 2 reproduces route 1 to"
      f" {abs(cp_routes['c_p [kJ/(kg K)]'].iloc[1]/cp_routes['c_p [kJ/(kg K)]'].iloc[0]-1):.1e} BY CONSTRUCTION: B is printed as"
      f"\n(-dH) rho_b p_B0 / (rho_g c_p) and route 1 is the same c_p divided by the same"
      f" rho_g.\nRoute 4 is route 1 rounded -"
      f" {P['cp_vol']*KCAL/P['rho_g']/KCAL:.4f} kcal/(kg C) printed as"
      f" {F67_PAR.loc['c_p','value']} - and C2.10's own CSV note says its"
      f"\n0.25 is pinned on that page by the printed Pe_hR = 5.25, which is route 3. So the"
      f"\nfour trace to ONE printed determination plus route 3 evaluated exactly against the"
      f"\nsame number rounded. What survives is the CONCLUSION - the printed 0.992 is"
      f"\ninconsistent with the chapter's own groups - not an agreement among four witnesses."
      f"\nThat is why cp_route_spread carries a caveat in the break table.")

# the mean-density units error, provable from the same sentence
RHO_FROM_SENTENCE = bk("mass_flux") / bk("superficial_velocity")
print(f"\nSame sentence, same defect class: 'a mean fluid density of"
      f" {bk('mean_density','as_printed')} kg/m3'"
      f"\nwith G = {bk('mass_flux','as_printed')} kg/(m2 h) and u_s ="
      f" {bk('superficial_velocity','as_printed')} m/h, whose ratio is"
      f" {RHO_FROM_SENTENCE:.4f} kg/m3.\nD2.2's CSV gives Van Welsenaere & Froment's"
      f" {P['rho_g']} kg/m3; the printed value is out by 10^3.")

# ---- eq. (11.7.4-1): rung 1's U is rung 5's pair ----------------------------
ALPHA_I = 1.0 / (1.0 / ALPHA_W + R_T / (4.0 * LAM_ER))
U_VWF_SI = P["U"] * KCAL / 3600.0
ALPHA_I_PRINTED_R = 1.0 / (1.0 / ALPHA_W + (D_T_PRINTED / 2.0) / (4.0 * LAM_ER))
print(f"\neq. (11.7.4-1) at R_t = {R_T} m, alpha_w = {ALPHA_W}, lambda_er = {LAM_ER}:"
      f"\n  alpha_i = {ALPHA_I:.6f} kJ/(m2 s K)   against the printed"
      f" {bk('overall_U','as_printed')}, equal to round-off (within"
      f" 1e-12; here {ALPHA_I/bk('overall_U')-1:+.1e})"
      f"\n  Van Welsenaere & Froment's U = {P['U']} kcal/(m2 h K) ="
      f" {U_VWF_SI:.6f} kJ/(m2 s K)  -> {U_VWF_SI/ALPHA_I-1:+.3e}"
      f"\nAt R_t = {D_T_PRINTED/2} m (the printed 2.54 cm diameter) it would be"
      f" {ALPHA_I_PRINTED_R:.6f}, i.e. {ALPHA_I_PRINTED_R/bk('overall_U')-1:+.3e}"
      f"\nfrom the printed 0.096 - and it ROUNDS TO {ALPHA_I_PRINTED_R:.3f}, not to"
      f" {bk('overall_U'):.3f}.\nC2.10 recomputes U from this pair for the 1967 case, to"
      f" {100*C210_U_WORST:.2f} % at worst (its own claims);"
      f"\nthis is that check with the BOOK's SI values, and it is what fixes R_t = 0.0125 m."
      f"\nWHAT IT IS NOT: proof that the book DERIVED 0.096 from (11.7.4-1). VWF's own"
      f"\nU = {U_VWF_SI:.5f} rounds to the same 0.096 at the two significant figures printed,"
      f"\nso the identity discriminates the RADIUS, which is what it is used for here, and"
      f"\nnot the provenance of the number.")
U_FROM_2D_DEV = float(ALPHA_I / bk("overall_U") - 1.0)
U_PRINTED_R_DEV = float(ALPHA_I_PRINTED_R / bk("overall_U") - 1.0)

# ---- the unit the model is in, and the one the section prints ----------------
Y_A0 = bk("y_A0_1173")
M_IMPLIED = bk("y_A0_mass_1173") / 1000.0 / (Y_A0 * P["rho_g"] / P["M"])
print(f"\nUNITS. This page runs on Van Welsenaere & Froment's parameter set as D2.2 carries"
      f"\nit: p_t = {P['p_t']} ATM and p_B0 = {P['p_B0']} ATM, with ln k = {P['b']} - {P['a']:.0f}/T"
      f"\nas printed for those units. Section 11.5.2 prints"
      f" '{bk('total_pressure','as_printed')} bar' and"
      f"\n'{bk('oxygen_pressure','as_printed')} bar' for the same two quantities - and the audit"
      f" above shows the second\nIS the first converted - while restating k unchanged, which is"
      f" the partial\nconversion. Its own Fig. 11.5.2-1 labels the ordinate"
      f" '{bk('fig1152_1_ordinate_unit','as_printed')}' (book page"
      f" {int(BK.loc['fig1152_1_ordinate_unit','book_page'])};\nthat unit word is the only thing"
      f" this page takes from any figure in the chapter).\nEvery pressure reported below is"
      f" therefore in ATM. What the other reading costs is\nmeasured in Validation.")
print(f"\nAnd section 11.7.3's {Y_A0} is a MOLE FRACTION, not a pressure: page 574 prints it"
      f"\n'corresponding to {bk('y_A0_mass_1173','as_printed')} g/m3', which needs a molar mass of"
      f" {M_IMPLIED:.1f} kg/kmol - an aromatic C8,\nnot the {P['M']} kg/kmol mean. At p_t ="
      f" {P['p_t']} atm its partial pressure is numerically the\nsame number, which is why it can"
      f" be used as one.")
# the same 0.00924 is Froment (1967)'s N_A0, which C2.10 has already audited
NA0_F67 = float(F67_PAR.loc["N_A0", "value"])
assert NA0_F67 == Y_A0, "11.7.3's inlet mole fraction is not C2.10's N_A0"
NA0_C210 = NA0_F67 * (1.0 + C210_C["na0_from_44gnm3_rel"])     # C2.10's 44 g/Nm3 reading
C_NORMAL = 101325.0 / (8.314462618 * 273.15) / 1000.0         # kmol/m3 at 0 C and 1 atm
M_OXYLENE = 8 * 12.011 + 10 * 1.008                           # C8H10, kg/kmol
M_NORMAL = bk("y_A0_mass_1173") / 1000.0 / (Y_A0 * C_NORMAL)
print(f"\nC2.10 HAS READ THE SAME NUMBER, as Froment (1967)'s N_A0 = {NA0_F67}, and its CSV"
      f" records\nthat the 44 is g per NORMAL m3 (the paper's Figure 11 axis is g/Nm3):"
      f" 44 g/Nm3 of o-xylene\nis N_A0 = {NA0_C210:.5f}, {100*C210_C['na0_from_44gnm3_rel']:+.2f} %"
      f" from the printed {NA0_F67} (C2.10's claim).\nThe {M_IMPLIED:.1f} kg/kmol above divides by"
      f" rho_g/M = {P['rho_g']/P['M']:.5f} kmol/m3; the molar density at\n0 C and 1 atm is"
      f" {C_NORMAL:.5f}, and with it the molar mass is {M_NORMAL:.2f} kg/kmol, against"
      f" o-xylene's\n{M_OXYLENE:.2f}. The rest of the gap is the printed 0.00924 against"
      f" {NA0_C210:.5f}:\n{M_NORMAL:.2f} x {Y_A0}/{NA0_C210:.5f} = {M_NORMAL*Y_A0/NA0_C210:.2f}."
      f" The page uses the printed mole fraction, as the chapter does.")

print(f"\nderived: eps = {EPS:.6f} from (11.5.1-16) at d_t/d_p ="
      f" {D_T_PRINTED/D_P:.4f};  rho_s = {RHO_S:.1f} kg/m3;"
      f"  a_v = {A_V:.2f} m2/m3\n         theta = {THETA:.6f} kmol/(m3 atm);"
      f"  A = {A_G:.4f};  B = {B_G:.6e};  C = {C_G():.2f} 1/h")

print("What the source pages establish about the rows used here, from their claims:")
print(f"   D2.2 : criterion-1 brackets {D22_C['bracket_width_c1_min_pct']:.0f} to"
      f" {D22_C['bracket_width_c1_max_pct']:.0f} % wide; first-order upwind leaves"
      f" {D22_C['hotspot_error_n1500_K']:.2f} K of hot-spot error at n_z = 1500")
print(f"   C2.10: runaway limits {C210_C['t0crit_1d_C']:.2f} C (1-D) and"
      f" {C210_C['t0crit_2d_C']:.2f} C (2-D); U from lambda_R and alpha_w within"
      f" {100*C210_U_WORST:.2f} %")
print(f"   B1.1 : its pymrm pellet against the exact table, worst"
      f" {B11_C['isothermal_max_rel_error_phi_le_30']:.1e} for phi <= 30 and"
      f" {B11_C['isothermal_max_rel_error_all_phi']:.1e} over all phi")
print(f"   A1.1 : refit k1 = {A11_C['k1_refit_all_points']:.1f},"
      f" k2 = {A11_C['k2_refit_all_points']:.3f}; Kozeny-Carman line"
      f" {bk('ergun_b')*A11_C['kozeny_carman_line_over_k1']:.1f}")

# The five rungs are model.py's `Ladder`; its operator assembly, printed here, is
# where the rungs differ.  The bisection, the crossing control and the
# grid-free rung-1 route are `p0_critical`, `crossing_control` and
# `ode_reference` in the same file.
print(inspect.getsource(Ladder._ops))

P0_BOOK = bk("runaway_p0_safe")   # 0.018, section 11.5.2's own design point, in atm
P0_REF = bk("y_A0_1173")          # 0.00924, section 11.7.3's own inlet mole fraction
#                                 # for the SAME reactor, hence its partial pressure
#                                 # in atm at p_t = 1 atm.
NS_RUNG1 = (150, 300, 600, 1200, 2400, 4800)     # the ONE rung-1 refinement chain
_RUNG1_CACHE = {}
# The order fit is only meaningful if the finest grid's error is far above the
# thresholds' own noise floor (claims-design section 3).  That floor is NOT the 1e-12
# bisection bracket: a threshold moves by about 1e-8 relative when only its starting
# guess changes, so 1e-8 is the floor used here.
START_FLOOR = 1e-8


def rung1_chain(R=None, ceiling=None, ns=NS_RUNG1):
    """Rung 1's threshold and hot spot on a refinement chain, its observed orders,
    the Richardson limits, and the same two numbers from the grid-free ODE route.

    THIS IS THE ONLY PLACE rung 1's reported numbers are computed.  The Validation
    cell below DISPLAYS this function's return value, `h_rung1` RETURNS its metric
    subset, and the break rows call it with a perturbed R or ceiling - so the
    displayed number and the agreement.json number are the same object, not two
    computations that happen to agree.

    Memoised on its own arguments only, which is a pure function of them, so it
    changes nothing about determinism.
    """
    R = R_T if R is None else R
    ceiling = T_PERM if ceiling is None else ceiling
    key = (R, ceiling, tuple(ns))
    if key in _RUNG1_CACHE:
        return _RUNG1_CACHE[key]
    rows = []
    for n in ns:
        lad = Ladder(RX, rung=1, n_z=n, R=R)
        Tm, zm, _edge = hotspot(lad.z_c, lad.solve(P0_BOOK)[:, 1])
        rows.append(dict(n_z=n, T_hot=Tm, z_hot=zm,
                         p0_star=p0_critical(lad, ceiling=ceiling)))
    tab = pd.DataFrame(rows)
    ordT, limT = richardson(tab.T_hot, tab.n_z)
    ordP, limP = richardson(tab.p0_star, tab.n_z)
    ordZ, limZ = richardson(tab.z_hot, tab.n_z)
    T_ode, z_ode, _ = ode_reference(RX, P0_BOOK, R=R)
    p0_ode = p0_critical_ode(RX, R=R, ceiling=ceiling)
    out = dict(table=tab, order_z=ordZ, limit_z=limZ, limit_T=limT, limit_p0=limP,
               T_ode=T_ode, z_ode=z_ode, p0_ode=p0_ode,
               metrics=dict(rung1_p0_star_extrapolated=limP, rung1_order_p0=ordP,
                            rung1_order_T=ordT,
                            ode_vs_pymrm_p0=abs(limP / p0_ode - 1.0),
                            ode_vs_pymrm_T=abs(limT / T_ode - 1.0),
                            p0_star_vs_printed_0018=p0_ode / P0_BOOK - 1.0,
                            rung1_finest_err_over_start_floor=abs(
                                float(tab.p0_star.iloc[-1]) / limP - 1.0) / START_FLOOR))
    _RUNG1_CACHE[key] = out
    return out


_CROSS_R_CACHE = {}


def shift_rung5(R, n_z=600, n_r=10):
    """rung 5 against rung 1 AT THE SAME RADIUS - both thresholds move with R_t."""
    return 100.0 * (p0_critical(Ladder(RX, rung=5, n_z=n_z, n_r=n_r, R=R), hi=0.09)
                    / p0_critical(Ladder(RX, rung=1, n_z=n_z, R=R), hi=0.09) - 1.0)


R_SWEEP = (R_T, 0.0120, 0.0115, 0.0110, 0.0105, 0.0100, 0.0098, 0.0096, 0.0094,
           0.0090, 0.0085, 2.5 * D_P)
#          ^ from the chapter's own tube outward, down to d_t/d_p = 5, which is
#            where section 11.5.1 says the Ergun constants "drastically change".
#            The sweep runs until the target is straddled by two VALIDATED points
#            and stops there - each evaluation is two threshold bisections, one of
#            them two-dimensional, so the points past the bracket are not spent.
#            What happens on narrower tubes is measured separately, below the
#            crossover table, where it is the question being asked.


def cross_R(target, n_z=600, n_r=10, iters=4):
    """The tube radius at which rung 5's shift crosses `target`, from the same
    controlled scan as every other row.  Memoised on its own arguments so that the
    display cell and the break-table helper are ONE computation: each evaluation is
    two full threshold bisections, one of them two-dimensional, so this is the most
    expensive search on the page.

    ITERS IS A BRACKET TOLERANCE AND NOT AN ACCURACY: four refinement levels of the 0.5 mm straddling pair
    is about 2e-6 m, while the GRID moves the shift by about 0.1 percentage points,
    which on the local slope of the sweep is some 3e-5 m of R_t*.  The display cell
    computes that from the page's own two grids and prints R_t* with it."""
    key = (target, n_z, n_r, iters)
    if key not in _CROSS_R_CACHE:
        _CROSS_R_CACHE[key] = cross_scan(
            lambda R: shift_rung5(R, n_z=n_z, n_r=n_r), R_SWEEP, target,
            levels=iters)
    return _CROSS_R_CACHE[key]


def unit_reading(p_B0, p_t, R=R_T, ceiling=T_PERM):
    """Rung 1's threshold and its hot spot at the printed 0.018, on a stated
    reading of section 11.5.2's pressure unit: the design case with p_B0 and p_t
    replaced.  Grid-free (Radau) throughout, so the comparison between the two
    readings carries no discretisation at all."""
    rx = replace(RX, p_B0=p_B0, p_t=p_t)
    return dict(p0_star=p0_critical_ode(rx, R=R, ceiling=ceiling),
                T_at_book_p0=ode_reference(rx, P0_BOOK, R=R)[0])


G_FLUX = RX.mass_flux
FILM = film(RX)
print("film coefficients from Wakao & Funazkri (page A3.4), at the chapter's printed Re:")
for k in ("Re", "Sc", "Pr", "Sh", "Nu"):
    print(f"   {k:>3s} = {FILM[k]:10.4f}")
print(f"   k_g = {FILM['k_g']:.6f} m/s      h_f = {FILM['h_f']:.6f} kJ/(m2 s K)"
      f"      a_v = {FILM['a_v']:.2f} m2/m3")

N_Z, N_R = 1200, 20
RUNGS = [(1, "11.5", "S2", "basic 1-D plug flow"),
         (2, "11.6", "S4", "+ axial dispersion"),
         (3, "11.8", "S7", "+ film resistance"),
         (4, "11.9", "S8", "+ intraparticle profiles"),
         (5, "11.7", "S6", "2-D radial dispersion")]
HI = {1: 0.0200, 2: 0.0200, 3: 0.0200, 4: 0.0600, 5: 0.0200}
# The profiles are compared at P0_REF rather than at 0.018 for a reason that is itself
# a result: 0.018 is above the threshold of some of the rungs (the count is COMPUTED and
# printed below, not asserted here), so their "hot spot" there is a runaway state rather
# than an operating point.  P0_REF is subcritical on all five, and the chapter prints it
# for this reactor.

SOL, LAD, ROWS = {}, {}, []
for r, sec, st, what in RUNGS:
    lad = Ladder(RX, rung=r, n_z=N_Z, n_r=N_R)
    LAD[r] = lad
    c = solve_robust(lad, P0_REF)
    SOL[r] = c
    Tm, zm, edge = hotspot(lad.z_c, lad.bulk_T(c))
    assert not edge, f"rung {r}: hot spot at a grid edge, not an interior root"
    pc = p0_critical(lad, hi=HI[r])
    ROWS.append(dict(rung=r, section=sec, structure=st, adds=what,
                     T_hot=Tm - 273.15, z_hot=zm,
                     p_exit=float(c[..., 0].mean(axis=-1)[-1] if r == 5 else c[-1, 0]),
                     p0_star=pc, newton_residual=lad.last_residual))
LADDER = pd.DataFrame(ROWS)
LADDER["vs_rung1_pct"] = 100.0 * (LADDER.p0_star / LADDER.p0_star.iloc[0] - 1.0)
# The hot spot at 0.018 atm is reported only for rungs still BELOW their threshold
# there.  Past it, the fixed-inlet solve starts cold from the rung-1 profile, which is
# then a runaway guess, and which state Newton reaches (or whether it converges) is
# decided by round-off (see the note on locating thresholds in Validation); branch
# following settles this for thresholds but not for a fixed-inlet solve above one.
LADDER["T_hot_at_0018"] = [(f"{T_max_safe(LAD[r], P0_BOOK) - 273.15:.1f}"
                            if LADDER.p0_star[i] > P0_BOOK else "past threshold")
                           for i, (r, *_) in enumerate(RUNGS)]
assert (LADDER.newton_residual < 1e-8).all(), "a ladder solve did not reach 1e-8"
show(LADDER.style.set_uuid("d11ladder").hide(axis="index").format(
    {"T_hot": "{:.2f}", "z_hot": "{:.4f}", "p_exit": "{:.3e}",
     "p0_star": "{:.7f}", "vs_rung1_pct": "{:+.2f}",
     "newton_residual": lambda v: "< 1e-8"}))

P0S = dict(zip(LADDER.rung, LADDER.p0_star))
SHIFT = dict(zip(LADDER.rung, LADDER.vs_rung1_pct))
R34_LIKE = 100.0 * (P0S[4] / P0S[3] - 1.0)      # rung 3 -> rung 4, against RUNG 3
R34_RATIO = abs(R34_LIKE) / abs(SHIFT[3])
N_SUPERCRIT = int((LADDER.p0_star < P0_BOOK).sum())
print(f"\nAll pressures are in ATM (see Parameters). T_hot and z_hot are at"
      f" p_A0 = {P0_REF} atm\n(section 11.7.3's own mole fraction for this reactor, at"
      f" p_t = {P['p_t']} atm); T_hot_at_0018 is\nat section 11.5.2's design point."
      f"\n\n'past threshold' MARKS A RUNG WHOSE OWN p0* IS BELOW 0.018 atm. Its hot spot"
      f" there is a\nrunaway state reached by a cold-started fixed-inlet solve, and which"
      f" state that\nsolve reaches is decided by round-off (see the note on locating"
      f" thresholds in Validation), so\nno temperature is printed for it. Newton residuals are all below"
      f" 1e-8 (asserted)."
      f"\n\nAT 0.018 ATM, {N_SUPERCRIT} OF THE FIVE RUNGS ARE ALREADY PAST THEIR OWN"
      f" THRESHOLD - rungs"
      f" {', '.join(str(r) for r in LADDER.rung[LADDER.p0_star < P0_BOOK])} - which is why"
      f" the\nprofile comparison is made at {P0_REF} atm and not there.")
print(f"\nEach rung, as a shift in the safe inlet partial pressure of the SAME reactor,"
      f"\nmeasured against RUNG 1:")
for r, sec, st, what in RUNGS[1:]:
    print(f"   {what:<26s} (sec. {sec}, {st})   {SHIFT[r]:+7.2f} %")
print(f"\nThe two heterogeneous rungs pull in OPPOSITE directions. Like for like - rung 4"
      f"\nagainst RUNG 3, which is the model it corrects, not against rung 1 -"
      f"\n   rung 1 -> rung 3 : {SHIFT[3]:+.2f} %   (of rung 1's threshold)"
      f"\n   rung 3 -> rung 4 : {R34_LIKE:+.2f} %   (of rung 3's threshold)"
      f"\nso the second correction is {R34_RATIO:.1f} times the size of the first. Against the"
      f" common\nrung-1 baseline the same pair reads {SHIFT[3]:+.2f} and {SHIFT[4]:+.2f} %, a"
      f" difference of {SHIFT[4]-SHIFT[3]:+.2f}\nPERCENTAGE POINTS - a different quantity, and"
      f" not a percentage of anything.\nEither way: stopping at rung 3 leaves you further from"
      f" rung 4"
      f" ({abs(P0S[4]-P0S[3]):.6f} atm)\nthan rung 1 was"
      f" ({abs(P0S[4]-P0S[1]):.6f} atm).")

fig, ax = plt.subplots(1, 2, figsize=(11.0, 4.0))
COL = {1: C_BLUE, 2: C_GREEN, 3: C_ORANGE, 4: C_PURPLE, 5: C_RED}
for r, sec, st, what in RUNGS:
    lad, c = LAD[r], SOL[r]
    ax[0].plot(lad.z_c, lad.bulk_T(c) - 273.15, color=COL[r], lw=1.6,
               label=f"{r}. {sec} {st} {what}")
    ax[1].plot(lad.z_c, (c[..., 0].mean(axis=-1) if r == 5 else c[..., 0]),
               color=COL[r], lw=1.6)
ax[0].plot(LAD[5].z_c, LAD[5].axis_T(SOL[5]) - 273.15, color=C_RED, lw=1.0, ls=":",
           label="5. axis temperature")
ax[0].axhline(T_PERM - 273.15, color="0.35", lw=1.0, ls="--")
ax[0].annotate(f"{T_PERM-273.15:.0f} $^\\circ$C, top of the printed operating range",
               (1.05, T_PERM - 273.15 + 3), fontsize=8, color="0.25")
ax[0].set_xlabel("z [m]"); ax[0].set_ylabel("temperature [$^\\circ$C]")
ax[0].set_title(f"five models, one reactor, $p_{{A0}}$ = {P0_REF} atm")
ax[0].legend(fontsize=7.2, loc="upper right")
ax[1].set_xlabel("z [m]"); ax[1].set_ylabel("$p_A$ [atm]")
ax[1].set_title("hydrocarbon partial pressure")
fig.tight_layout(); plt.show()

fig, ax = plt.subplots(figsize=(6.2, 3.6))
ax.barh([f"{r}. sec. {s} ({t})" for r, s, t, _ in RUNGS], LADDER.vs_rung1_pct,
        color=[COL[r] for r, *_ in RUNGS], height=0.55)
ax.axvline(0.0, color="0.3", lw=1.0)
ax.set_xlabel("shift in the safe inlet partial pressure $p_{A0}^*$ [%] vs rung 1"
              "\n($p_{A0}^*$ in atm; see Parameters)")
ax.set_title("what each rung buys, on the same reactor")
ax.invert_yaxis(); fig.tight_layout(); plt.show()

# ============ 1. Example 11.5.1.A, and the two equivalent diameters ==========
E = dict(L=bk("ex1151a_length"), d=bk("ex1151a_cylinder"), eps=bk("ex1151a_voidage"),
         G=bk("ex1151a_mass_flux"), mu=bk("ex1151a_viscosity"),
         rho=bk("ex1151a_density"))
E["u"] = E["G"] / E["rho"]
ERG = dict(zip(ERG_PAR.quantity, ERG_PAR.value))
print("Ergun's constants, loaded from A1.1 rather than retyped:")
for q in ERG_PAR.quantity:
    print(f"   {q:<34s} {ERG[q]}")
print(f"   and A1.1's own refit of Ergun's markers gives"
      f" k1 = {A11_C['k1_refit_all_points']:.1f}, k2 = {A11_C['k2_refit_all_points']:.3f}"
      f" (its claims),\n   which is A1.1's finding and changes nothing here: Example 11.5.1.A is"
      f"\n   arithmetic ON the printed constants.")
assert ERG["k1_viscous_constant"] == bk("ergun_b") and ERG["k2_kinetic_constant"] == bk("ergun_a"), \
    "A1.1's Ergun constants and the book's printed a, b disagree"


def f_ergun(dp, a, b):
    Re = dp * E["G"] / E["mu"]
    return Re, (1.0 - E["eps"]) / E["eps"] ** 3 * (a + b * (1.0 - E["eps"]) / Re)


def f_hicks(dp):
    Re = dp * E["G"] / E["mu"]
    return Re, (bk("hicks_coefficient") * (1.0 - E["eps"]) ** bk("hicks_exponent_eps")
                / E["eps"] ** 3 * Re ** bk("hicks_exponent_Re"))


def dP(f, dp):
    return f * E["rho"] * E["u"] ** 2 / dp * E["L"]          # eq. (11.5.1-3)


DP_AREA = np.sqrt(1.5) * E["d"]      # sphere of equal surface AREA - what is printed
DP_SV = E["d"]                       # eq. (11.5.1-9), 6 V_p/S_p, for a cylinder d = h
DP_ROUNDED = bk("ex1151a_dp")        # the printed 0.0037, used by the book downstream
tab = []
for nm, dp in (("as printed, 0.0037 m", DP_ROUNDED),
               ("sqrt(1.5) x 0.003, unrounded", DP_AREA),
               ("eq. (11.5.1-9): 6 V/S = d", DP_SV)):
    Re, fe = f_ergun(dp, bk("ergun_a"), bk("ergun_b"))
    _, fm = f_ergun(dp, bk("mcdonald_a"), bk("mcdonald_b"))
    _, fh = f_hicks(dp)
    tab.append(dict(d_p=dp, basis=nm, Re=Re, f_Ergun=fe, dP_Ergun=dP(fe, dp),
                    f_McDonald=fm, dP_McDonald=dP(fm, dp),
                    f_Hicks=fh, dP_Hicks_bar=dP(fh, dp) / 1e5))
EX1 = pd.DataFrame(tab)
EX1.loc[len(EX1)] = dict(d_p=DP_ROUNDED, basis="THE BOOK PRINTS", Re=bk("ex1151a_Re"),
                         f_Ergun=bk("ex1151a_f_ergun"), dP_Ergun=bk("ex1151a_dp_ergun"),
                         f_McDonald=bk("ex1151a_f_mcdonald"),
                         dP_McDonald=bk("ex1151a_dp_mcdonald"),
                         f_Hicks=bk("ex1151a_f_hicks"), dP_Hicks_bar=bk("ex1151a_dp_hicks"))
show(EX1.style.set_uuid("d11ex1151a").hide(axis="index").format(
    {"d_p": "{:.6f}", "Re": "{:.2f}", "f_Ergun": "{:.4f}", "dP_Ergun": "{:.0f}",
     "f_McDonald": "{:.4f}", "dP_McDonald": "{:.0f}", "f_Hicks": "{:.4f}",
     "dP_Hicks_bar": "{:.4f}"}))

EX1151A_ERGUN_DEV = abs(EX1.dP_Ergun.iloc[0] / bk("ex1151a_dp_ergun") - 1.0)
EX1151A_MCD_DEV = abs(EX1.dP_McDonald.iloc[0] / bk("ex1151a_dp_mcdonald") - 1.0)
EX1151A_HICKS_DEV = abs(EX1.dP_Hicks_bar.iloc[0] / bk("ex1151a_dp_hicks") - 1.0)
EX1151A_WORST = max(EX1151A_ERGUN_DEV, EX1151A_MCD_DEV, EX1151A_HICKS_DEV)
DP_DEFINITION_COST = EX1.dP_Ergun.iloc[2] / EX1.dP_Ergun.iloc[0] - 1.0
print(f"\nOn the printed d_p = 0.0037 m the three pressure drops come back to"
      f" {EX1151A_WORST:.1e}\nrelative, i.e. to every digit the example prints."
      f"\n\nBut the printed d_p is NOT the chapter's own definition. Eq. (11.5.1-9) reads"
      f"\nd_p = 6(1-eps)/a_v, i.e. 6 V_p/S_p, and the text calls it 'the diameter of a"
      f"\nsphere with the same surface area PER UNIT VOLUME as the actual particle'. For a"
      f"\ncylinder with d = h = 3 mm, S_p/V_p = 6/d exactly, so eq. (11.5.1-9) gives"
      f"\nd_p = {DP_SV:.4f} m. The example instead uses sqrt(1.5) x 0.003 ="
      f" {DP_AREA:.6f} m, which is the\nsphere of equal surface AREA (pi d_s^2 = 1.5 pi d^2)"
      f" - a different definition.\nOn the chapter's own definition the Ergun pressure drop"
      f" is {EX1.dP_Ergun.iloc[2]/1e5:.4f} bar against\nthe printed"
      f" {bk('ex1151a_dp_ergun')/1e5:.3f} bar: {100*DP_DEFINITION_COST:+.1f} %. Reported, not"
      f" repaired.")

# and: no single Reynolds number produces all three printed friction factors
implied = {}
implied["Ergun"] = brentq(lambda R: (1 - E["eps"]) / E["eps"] ** 3 * (
    bk("ergun_a") + bk("ergun_b") * (1 - E["eps"]) / R) - bk("ex1151a_f_ergun"), 50, 500)
implied["McDonald"] = brentq(lambda R: (1 - E["eps"]) / E["eps"] ** 3 * (
    bk("mcdonald_a") + bk("mcdonald_b") * (1 - E["eps"]) / R) - bk("ex1151a_f_mcdonald"), 50, 500)
implied["Hicks"] = brentq(lambda R: bk("hicks_coefficient") * (1 - E["eps"]) ** bk(
    "hicks_exponent_eps") / E["eps"] ** 3 * R ** bk("hicks_exponent_Re")
    - bk("ex1151a_f_hicks"), 50, 500)
RE_IMPLIED_SPREAD = max(implied.values()) - min(implied.values())
print(f"\nA third, smaller printed inconsistency in the same example. Inverting each"
      f"\nprinted friction factor for the Reynolds number it needs, at the printed"
      f" eps = 0.38:")
for k, v in implied.items():
    print(f"   f_{k:<9s} = {bk('ex1151a_f_' + k.lower()):7.2f}  requires  Re = {v:.2f}")
print(f"   the example prints  Re = {bk('ex1151a_Re'):.0f}, and d_p = 0.0037 m gives"
      f" {DP_ROUNDED*E['G']/E['mu']:.2f}."
      f"\nThe Ergun and Hicks branches were evaluated at Re ~= {implied['Ergun']:.1f} and the"
      f"\nMcDonald branch at Re ~= {implied['McDonald']:.2f}; the spread is"
      f" {RE_IMPLIED_SPREAD:.2f}.\nA1.1 carries neither the McDonald nor the"
      f" Hicks constants, so this branch of the\nexample is not covered anywhere else.")

# ===== 2. the parametric-sensitivity sentence, and every axis that carries error
print("section 11.5.2, book page 513, verbatim:")
print("   " + bk("runaway_claim", "as_printed"))
print(f"   and the operating range on page 511 is {bk('temp_range_low','as_printed')}"
      f" to {bk('temp_range_high','as_printed')} C, which is what\n   'permissible limits'"
      f" means.\n")

R1 = rung1_chain()               # THE one rung-1 computation; agreement.json reads it
CONV1 = R1["table"]
ORD_T, LIM_T = R1["metrics"]["rung1_order_T"], R1["limit_T"]
ORD_P, LIM_P = R1["metrics"]["rung1_order_p0"], R1["limit_p0"]
ORD_Z, LIM_Z = R1["order_z"], R1["limit_z"]
show(CONV1.style.set_uuid("d11conv1").hide(axis="index").format(
    {"T_hot": "{:.6f}", "z_hot": "{:.6f}", "p0_star": "{:.8f}"}))
print(f"observed orders  T_hot {ORD_T:.3f}   z_hot {ORD_Z:.3f}   p0* {ORD_P:.3f}"
      f"   (first-order upwind)\nRichardson limits  T_hot {LIM_T:.5f} K ="
      f" {LIM_T-273.15:.3f} C   z_hot {LIM_Z:.5f} m   p0* {LIM_P:.8f} atm")
R1_FINEST_OVER_FLOOR = R1["metrics"]["rung1_finest_err_over_start_floor"]
print(f"The finest grid's threshold error against that limit is"
      f" {R1_FINEST_OVER_FLOOR:.0f} times the {START_FLOOR:.0e}\nby which a threshold moves"
      f" when only its starting guess changes, so the order fit is not\nfitted to that noise.")

T_ODE, Z_ODE = R1["T_ode"], R1["z_ode"]
P0_ODE = R1["p0_ode"]
ODE_T_DEV = R1["metrics"]["ode_vs_pymrm_T"]
ODE_P_DEV = R1["metrics"]["ode_vs_pymrm_p0"]
print(f"\nSECOND, INDEPENDENT ROUTE - adaptive Radau on the two ODEs, no grid, no pymrm"
      f"\noperator, no Newton, sharing only the constants:"
      f"\n   T_hot  {T_ODE:.6f} K = {T_ODE-273.15:.4f} C   vs the extrapolated pymrm"
      f" {LIM_T-273.15:.4f} C   ->  {ODE_T_DEV:.1e}"
      f"\n   z_hot  {Z_ODE:.6f} m                     vs {LIM_Z:.6f} m"
      f"\n   p0*    {P0_ODE:.8f} atm                 vs {LIM_P:.8f} atm     ->  {ODE_P_DEV:.1e}"
      f"\nA break row perturbs an input; this catches a wrong baseline, and it is the"
      f"\nreason the reported p0* is the extrapolated one and not the 1200-cell value"
      f" ({100*(P0S[1]/LIM_P-1):+.3f} %)."
      f"\nEVERY rung-1 number in agreement.json is an entry of the dict this cell is"
      f"\ndisplaying - one computation, not two that agree.")

T_AT_BOOK_P0 = T_ODE - 273.15
_p0_plus = P0_BOOK + bk("runaway_p0_increment")
print(f"\nSo, on the book's own constants with R_t = {R_T} m, IN ATM:"
      f"\n   p_A0 = {P0_BOOK:.4f} atm          ->  hot spot {T_AT_BOOK_P0:.2f} C, "
      f"{T_PERM-273.15 - T_AT_BOOK_P0:.2f} C BELOW the printed ceiling"
      f"\n   p_A0 = {_p0_plus:.4f} atm (+{bk('runaway_p0_increment'):.4f})  ->  hot spot"
      f" {ode_reference(RX, _p0_plus)[0]-273.15:.1f} C, far above it"
      f"\n   the ceiling is crossed at p_A0 = {P0_ODE:.6f} atm,"
      f" {100*(P0_ODE/P0_BOOK-1):+.3f} % from the printed 0.018."
      f"\nThe sentence is right, to one part in"
      f" {1.0/abs(P0_ODE/P0_BOOK-1):.0f}.")

# ---- WHAT THE SENTENCE IS AN AGREEMENT *WITH*: the two unit readings, measured ----
UNIT_ATM = unit_reading(P["p_B0"], P["p_t"])
UNIT_BAR = unit_reading(bk("oxygen_pressure"), bk("total_pressure"))
P0_STAR_BAR_DEV = UNIT_BAR["p0_star"] / P0_BOOK - 1.0
T_0018_BAR_C = UNIT_BAR["T_at_book_p0"] - 273.15
UNITS = pd.DataFrame([
    dict(reading=f"VWF's set, p_B0 = {P['p_B0']} atm, p_t = {P['p_t']} atm  (THIS PAGE)",
         p0_star=UNIT_ATM["p0_star"], vs_printed_0018=UNIT_ATM["p0_star"] / P0_BOOK - 1.0,
         T_hot_at_0018_C=UNIT_ATM["T_at_book_p0"] - 273.15),
    dict(reading=f"11.5.2 as printed, p_B0 = {bk('oxygen_pressure')} bar,"
                 f" p_t = {bk('total_pressure'):.0f} bar",
         p0_star=UNIT_BAR["p0_star"], vs_printed_0018=P0_STAR_BAR_DEV,
         T_hot_at_0018_C=T_0018_BAR_C),
])
show(UNITS.style.set_uuid("d11units").hide(axis="index").format(
    {"p0_star": "{:.6f}", "vs_printed_0018": "{:+.5f}", "T_hot_at_0018_C": "{:.1f}"}))
print(f"Both rows are the same grid-free Radau solve with one constant changed, so the"
      f"\ndifference is a PARAMETER-SET difference and carries no discretisation at all."
      f"\nThe +{100*UNIT_ATM['p0_star']/P0_BOOK-100:.3f} % reproduction of section 11.5.2's"
      f" sensitivity sentence is an agreement with"
      f"\nVan Welsenaere & Froment's 0.018 ATM, obtained with THEIR atm parameter set. Read"
      f"\nin the bar that section 11.5.2 itself prints, the same sentence is out by"
      f" {100*P0_STAR_BAR_DEV:.3f} %\nand its own design point sits at"
      f" {T_0018_BAR_C:.0f} C -"
      f" {T_0018_BAR_C-(T_PERM-273.15):.0f} K ABOVE the ceiling the facing page"
      f"\nstates, which no reading of the chapter can be right about. That is why the atm"
      f"\nreading is the one used, and it is stated rather than assumed:"
      f" Fig. 11.5.2-1's own\nordinate label reads"
      f" '{bk('fig1152_1_ordinate_unit','as_printed')}'.")

print(f"\nAt R_t = {D_T_PRINTED/2} m - the radius the printed 2.54 cm diameter implies -"
      f" the same\ninlet pressure gives a hot spot of"
      f" {ode_reference(RX, P0_BOOK, R=D_T_PRINTED/2)[0]-273.15:.0f} C, outside the operating range"
      f" the same page\nstates, and p0* falls to"
      f" {p0_critical_ode(RX, R=D_T_PRINTED/2):.6f} atm. The figures of section 11.5.2\ncannot have"
      f" been computed at that radius; R_t = {R_T} m is what reproduces them, and\nit is also"
      f" what eq. (11.7.4-1) needs to return the printed U. Two independent\nconstraints, same"
      f" answer.")

# ---- IS THE THRESHOLD A CEILING CROSSING OR A NEWTON-CONVERGENCE BOUNDARY? -------
print(f"\n\nCONTROL: p0_critical bisects and treats a non-converged solve as"
      f" supercritical, so\nthe number it returns COULD be a Newton-convergence boundary"
      f" rather than a crossing\nof the {T_PERM-273.15:.0f} C ceiling. It is checked, on"
      f" EVERY call this page makes - not\nonly on these five rungs:"
      f" `p0_critical` runs `crossing_control`"
      f" itself and RAISES if it fails, so a\nthreshold that is not a ceiling crossing"
      f" cannot reach a table, a sweep or a\nbisection. What follows is that same check,"
      f" displayed for the five reported rungs.")
ctl = []
for r, sec, st, what in RUNGS:
    lad, pc = LAD[r], P0S[r]
    lo_, hi_, ok_ = crossing_control(lad, pc)
    ctl.append(dict(rung=r, p0_star=pc, T_just_below_C=lo_ - 273.15,
                    T_just_above_C=hi_ - 273.15, jump_K=hi_ - lo_, crossing=ok_))
CTL = pd.DataFrame(ctl)
show(CTL.style.set_uuid("d11ctl").hide(axis="index").format(
    {"p0_star": "{:.7f}", "T_just_below_C": "{:.2f}", "T_just_above_C": "{:.2f}",
     "jump_K": "{:.3f}"}, na_rep="Newton did not converge"))
CROSSING_OK = bool(CTL.crossing.all())
assert CROSSING_OK, "a rung's threshold is NOT a ceiling crossing"
print(f"All five cross the ceiling, and cross it CONTINUOUSLY: the widest jump between"
      f" the\ntwo solves is {CTL.jump_K.abs().max():.3f} K, against the"
      f" {CTL_JUMP:.0f} K the control allows and the hundreds of\nkelvin an ignition"
      f" discontinuity gives. So no rung's p0* is set by a convergence\nfailure. Above"
      f" the threshold the Newton may give up - the situation bisection exists to\nsurvive -"
      f" and that is NOT an absence of a steady state: the grid-free Radau route\nreturns a"
      f" bounded one at the top of the bracket,"
      f" {ode_reference(RX, HI[1])[0]-273.15:.0f} C at p_A0 = {HI[1]}."
      f"\n\nBrentq on the identical bracket, on ALL FIVE rungs at the n_z = 600 the break"
      f" rows\nuse - this is what licenses bisection, so it is measured on every rung"
      f" rather than\non the two it is cheapest to show:")
_BRENT_OK, _BRENT_FAIL = [], []
for r in (1, 2, 3, 4, 5):
    _bs = p0_critical(Ladder(RX, rung=r, n_z=600, n_r=10), hi=HI[r])   # always, first
    try:
        _rt = brentq(lambda q: T_max_safe(Ladder(RX, rung=r, n_z=600, n_r=10), q) - T_PERM,
                     0.004, HI[r], xtol=1e-12)
        assert abs(_rt / _bs - 1.0) < 1e-10, f"rung {r}: brentq and bisection disagree"
        _BRENT_OK.append(r)
    except ValueError:
        _BRENT_FAIL.append(r)
    print(f"   rung {r}: bisection {_bs:.8f}")
assert _BRENT_FAIL, "brentq survived on every rung, so the text below is not what ran"
print(f"Brentq raises on a NaN on at least one rung, and on every rung where it survives it"
      f"\nreturns the bisection root to better than 1e-10 (asserted). WHICH rungs it survives"
      f"\nis decided by round-off, not by the rung: its points above the threshold are"
      f"\ncold-started fixed-inlet solves, whose convergence is the round-off-decided"
      f" event the\nnote on locating thresholds describes (here it fails on rungs"
      f" {', '.join(map(str, _BRENT_FAIL))}). So brentq is not wrong\nwhere it survives;"
      f" it simply cannot be relied on.")
_T5_COARSE = T_max_safe(Ladder(RX, rung=5, n_z=600, n_r=10), P0_BOOK)
assert np.isfinite(_T5_COARSE) and _T5_COARSE - 273.15 > 900.0, (
    "rung 5 at 0.018 atm on (600, 10) is not the bounded runaway state the text says")
print(f"\nAnd rung 5 at p_A0 = {P0_BOOK} atm, past its own threshold: on the coarser (600, 10)"
      f"\ngrid the cold-started solve reaches a bounded runaway state above 900 C (asserted),"
      f"\nmore than 480 K past the ceiling (here {_T5_COARSE-273.15:.0f} C), so the reactor HAS"
      f" a steady\nstate there. Its exact temperature, and whether the (1200, 20) grid"
      f" converges at all,\nis decided by round-off: this is a fixed-inlet solve above a"
      f" threshold, started\ncold, which branch following does not cover.")

# ---- rung 5 carries error on TWO axes: refine both, separately ---------------
r5 = []
for n_z in (300, 600, 1200):
    for n_r in (5, 10, 20, 40):
        lad = Ladder(RX, rung=5, n_z=n_z, n_r=n_r)
        c = solve_robust(lad, P0_REF)
        Tb, zb, _ = hotspot(lad.z_c, lad.bulk_T(c))
        Ta, za, _ = hotspot(lad.z_c, lad.axis_T(c))
        i = int(np.argmax(lad.axis_T(c)))
        r5.append(dict(n_z=n_z, n_r=n_r, T_bulk=Tb, T_axis=Ta,
                       dT_radial=float(c[i, 0, 1] - c[i, -1, 1])))
R5 = pd.DataFrame(r5)
show(R5.style.set_uuid("d11conv5").hide(axis="index").format(
    {"T_bulk": "{:.4f}", "T_axis": "{:.4f}", "dT_radial": "{:.4f}"}))
_z = R5[R5.n_r == 40]
_r = R5[R5.n_z == 1200]
ORD_Z5, LIM_Z5 = richardson(_z.T_axis, _z.n_z)
ORD_R5, LIM_R5 = richardson(_r.T_axis, _r.n_r)
T_AXIS_REPORTED = float(R5[(R5.n_z == N_Z) & (R5.n_r == N_R)].T_axis.iloc[0])
ERR_RADIAL = T_AXIS_REPORTED - LIM_R5
ERR_AXIAL = float(_z.T_axis.iloc[-1]) - LIM_Z5
AXIS_MINUS_BULK = T_AXIS_REPORTED - (LADDER.loc[4, "T_hot"] + 273.15)
print(f"axial axis (n_r = 40): observed order {ORD_Z5:.3f}, limit {LIM_Z5-273.15:.4f} C"
      f"\nradial axis (n_z = 1200): observed order {ORD_R5:.3f}, limit"
      f" {LIM_R5-273.15:.4f} C"
      f"\nThe radial axis converges at second order and the axial at first, so the"
      f"\ntwo-dimensional rung's error is set by the axis the model is NOT named after."
      f"\nBOTH ARE TINY. Comparing LIKE WITH LIKE - the AXIS temperature against an AXIS"
      f"\nlimit, on the same axis that was refined:"
      f"\n   radial discretisation error at ({N_Z}, {N_R}) : {ERR_RADIAL:+.4f} K"
      f"\n   axial  discretisation error at ({N_Z}, 40) : {ERR_AXIAL:+.4f} K"
      f"\ni.e. both below 0.03 K on a {LIM_R5-273.15:.0f} C hot spot (asserted), and the"
      f" axial one is\n{abs(ERR_AXIAL/ERR_RADIAL):.0f} times the radial one.")
assert max(abs(ERR_RADIAL), abs(ERR_AXIAL)) < 0.03, "a rung-5 axis error is not below 0.03 K"
print(f"\nWHAT IS *NOT* A GRID ERROR:"
      f"\nthe axis-minus-bulk difference at the reported grid,"
      f" {AXIS_MINUS_BULK:+.3f} K"
      f"\n({T_AXIS_REPORTED-273.15:.2f} C on the axis against"
      f" {LADDER.loc[4,'T_hot']:.2f} C for the radial mean). That is the radial"
      f"\ntemperature difference the two-dimensional model exists to resolve - the physics,"
      f"\nnot the discretisation - and it is {abs(AXIS_MINUS_BULK/ERR_RADIAL):.0f} times the"
      f" radial grid error beside it. The\nsame quantity measured wall-to-axis is the"
      f" dT_radial column above,"
      f" {float(R5[(R5.n_z==N_Z)&(R5.n_r==N_R)].dT_radial.iloc[0]):.2f} K.")
print(f"\nNOT REFINED ANYWHERE, and said so: rung 5's THRESHOLD, which is the quantity the"
      f"\nladder table reports. Its (600, 10) and ({N_Z}, {N_R}) values differ by about a"
      f"\ntenth of a percentage point - printed in the break-table cell below - and no"
      f"\nobserved order or Richardson limit is offered for it. The two refinements above"
      f"\nare of the hot spot at a fixed inlet, not of the threshold.")

# ---- rung 2: the difference it makes against the numerical diffusion of upwind
DISP_LEN = D_P / 1.5
print(f"\nRUNG 2 NEEDS THIS SAID OUT LOUD. First-order upwind adds a numerical"
      f"\ndiffusivity u dz/2, i.e. a dispersion LENGTH dz/2 - A2.1's finding, applied"
      f"\nhere. The physical dispersion length of (11.6-1) divided by u_s is"
      f"\nd_p/Pe_ma = {DISP_LEN*1e3:.3f} mm. At n_z = {N_Z} the numerical one is"
      f" {0.5*L_BED/N_Z*1e3:.3f} mm, i.e."
      f" {100*0.5*L_BED/N_Z/DISP_LEN:.0f} %\nof it, so a rung-1-versus-rung-2 comparison on a"
      f" single grid is mostly scheme.")
d2 = []
for n in (300, 600, 1200, 2400, 4800):
    l1, l2 = Ladder(RX, rung=1, n_z=n), Ladder(RX, rung=2, n_z=n)
    p1, p2 = p0_critical(l1), p0_critical(l2)
    d2.append(dict(n_z=n, numerical_mm=0.5 * L_BED / n * 1e3, p0_rung1=p1,
                   p0_rung2=p2, shift_pct=100.0 * (p2 / p1 - 1.0)))
D2 = pd.DataFrame(d2)
show(D2.style.set_uuid("d11r2conv").hide(axis="index").format(
    {"numerical_mm": "{:.4f}", "p0_rung1": "{:.8f}", "p0_rung2": "{:.8f}",
     "shift_pct": "{:+.4f}"}))
ORD_S2, LIM_S2 = richardson(D2.shift_pct, D2.n_z)
print(f"The shift itself converges (observed order {ORD_S2:.2f}) to {LIM_S2:+.4f} % as"
      f" h -> 0.\nIt is smaller than the {100*abs(P0S[1]/LIM_P-1):.3f} % discretisation"
      f" error of the rung-1 baseline at\nn_z = {N_Z}, so this rung is only resolvable if both"
      f" models are extrapolated -\nwhich is exactly why the ladder table above reports"
      f" root-found thresholds and\nthis cell reports their limit.")

# ===== 3. Example 11.5.3.A against Van Welsenaere & Froment's own numbers =====
# D2.2 owns the criteria; this checks the BOOK'S TRANSCRIPTION of their example.
tr = []
for bkey, ex_q in (("vwf_TM_625", "T_cr"), ("vwf_dT_625", "dT_eff"), ("vwf_Q_625", "Q"),
                   ("vwf_p0_lower_625", "p0_lower"), ("vwf_p0_upper_625", "p0_upper"),
                   ("vwf_p0_mean_625", "p0_mean"), ("vwf_p0_backint_625", "p0_critical")):
    src = VWF_EX[(VWF_EX.example.isin(["1a", "4"])) & (VWF_EX.quantity == ex_q)]
    o = float(src.value.iloc[0])
    # WHICH of Van Welsenaere & Froment's examples the row was found in, and at what
    # radius, is printed - because a row-by-row ratio of 1.000000 says nothing about
    # whether the two rows belong to the SAME case, and here two of them do not.
    tr.append(dict(quantity=ex_q, VWF_example=str(src.example.iloc[0]),
                   VWF_conditions=str(src.conditions.iloc[0])[:34],
                   VWF_1970=o, unit=str(src.unit.iloc[0]),
                   book=bk(bkey), ratio=bk(bkey) / o))
TRANS = pd.DataFrame(tr)
show(TRANS.style.set_uuid("d11trans").hide(axis="index").format(
    {"VWF_1970": "{:.6g}", "book": "{:.6g}", "ratio": "{:.6f}"}))
N_EXAMPLES = TRANS.VWF_example.nunique()
print(f"Every dimensionless and kelvin row transcribes unchanged and every ATM row is"
      f"\nmultiplied by {ATM} - except the last, which is not: the atm/bar audit again,"
      f"\nfrom the other side."
      f"\n\nBUT LOOK AT THE `VWF_example` COLUMN. These seven rows are looked up in"
      f" whichever of the\n1970 paper's worked examples happens to carry each quantity, and"
      f" they come from\n{N_EXAMPLES} of them, at two different tube radii. A ratio of"
      f" 1.000000 says the number was\ncopied correctly; it says nothing about whether the"
      f" rows belong to the SAME case.\nQ is the one where they do not, and the next block is"
      f" what this check misses.")

# Table 11.5.3.A-2's own arithmetic, on its own printed Q and dT
Q, DT = bk("vwf_Q_625"), bk("vwf_dT_625")
t2 = pd.DataFrame([
    ("Lower limit", "dT (1 + Q^2)", DT * (1 + Q ** 2), bk("vwf_dTad_lower_625")),
    ("Upper limit", "dT (1 + Q)^2", DT * (1 + Q) ** 2, bk("vwf_dTad_upper_625")),
    ("Mean", "dT (1 + Q + Q^2)", DT * (1 + Q + Q ** 2), bk("vwf_dTad_mean_625")),
], columns=["row", "formula printed on that row", "the formula gives", "the table prints"])
t2["ratio"] = t2["the table prints"] / t2["the formula gives"]
show(t2.style.set_uuid("d11t2").hide(axis="index").format(
    {"the formula gives": "{:.2f}", "the table prints": "{:.2f}", "ratio": "{:.4f}"}))
T2_UPPER_RATIO = float(t2.ratio.iloc[1])
_mean_of_printed = 0.5 * (bk("vwf_dTad_lower_625") + bk("vwf_dTad_upper_625"))
print(f"Row 1 checks. Row 2 does not: dT(1+Q)^2 = {DT*(1+Q)**2:.1f} C, and the"
      f" {bk('vwf_dTad_upper_625')} C\nprinted beside it is what row 3's formula gives"
      f" ({DT*(1+Q+Q**2):.1f} C). Row 3 then prints\n"
      f"{bk('vwf_dTad_mean_625')} C, which is the arithmetic mean of the two printed"
      f" numbers ({_mean_of_printed:.1f} C) and\nwhich no formula in the table produces."
      f" One slip, propagating once.\nNote that dT(1+Q+Q^2) IS identically the mean of"
      f" dT(1+Q^2) and dT(1+Q)^2 - the\nidentity holds for every Q - so the 'Mean' row's"
      f" formula is right and only its\nnumber is wrong. Table 11.5.3.A-1, at 635 K, is"
      f" internally consistent throughout:")
Q1, DT1 = bk("vwf_Q_635"), bk("vwf_TM_635") - 635.0
t1 = pd.DataFrame([
    ("Lower limit", DT1 * (1 + Q1 ** 2), bk("vwf_dTad_lower_635")),
    ("Upper limit", DT1 * (1 + Q1) ** 2, bk("vwf_dTad_upper_635")),
    ("Mean", DT1 * (1 + Q1 + Q1 ** 2), bk("vwf_dTad_mean_635")),
], columns=["row", "the formula gives", "the table prints"])
t1["rel. dev."] = t1["the formula gives"] / t1["the table prints"] - 1.0
show(t1.style.set_uuid("d11t1").hide(axis="index").format(
    {"the formula gives": "{:.2f}", "the table prints": "{:.2f}", "rel. dev.": "{:+.4f}"}))
T1_WORST = float(np.abs(t1["rel. dev."]).max())
print(f"worst {T1_WORST:.3f} on a table whose entries are printed to 3 figures.")

# ===== the LARGER defect in the same table, which no row-by-row check can see =====
# Table 11.5.3.A-2 has TWO columns, and the example prints the constant that ties
# them together: dT_ad = (B/A) p0.  ONE DIVISION on the example's own printed A and B.
BOA = bk("vwf_B") / bk("vwf_A")                 # per ATM, the units A and B are in
xc = []
for lab, pkey, dkey, form in (
        ("Lower limit", "vwf_p0_lower_625", "vwf_dTad_lower_625", lambda q: DT * (1 + q ** 2)),
        ("Upper limit", "vwf_p0_upper_625", "vwf_dTad_upper_625", lambda q: DT * (1 + q) ** 2),
        ("Mean", "vwf_p0_mean_625", "vwf_dTad_mean_625", lambda q: DT * (1 + q + q ** 2))):
    p0_atm = bk(pkey) / ATM                      # the column is printed in bar
    needed = p0_atm * BOA
    qi = brentq(lambda q: form(q) - needed, 0.1, 20.0, xtol=1e-13)
    xc.append(dict(row=lab, p0_printed_bar=bk(pkey), dTad_needed_K=needed,
                   dTad_printed_K=bk(dkey), dev=bk(dkey) / needed - 1.0, Q_implied=qi))
XC = pd.DataFrame(xc)
show(XC.style.set_uuid("d11t2cross").hide(axis="index").format(
    {"p0_printed_bar": "{:.5f}", "dTad_needed_K": "{:.1f}", "dTad_printed_K": "{:.1f}",
     "dev": "{:+.3f}", "Q_implied": "{:.4f}"}))
T2_DTAD_WORST_DEV = float(np.abs(XC.dev).max())
T2_Q_IMPLIED = float(XC.Q_implied.iloc[0])
T1_CROSS_WORST = max(abs(bk(dk) / (bk(pk) / ATM * BOA) - 1.0) for pk, dk in
                     (("vwf_p0_lower_635", "vwf_dTad_lower_635"),
                      ("vwf_p0_upper_635", "vwf_dTad_upper_635"),
                      ("vwf_p0_mean_635", "vwf_dTad_mean_635")))
print(f"THE TWO COLUMNS OF TABLE 11.5.3.A-2 DISAGREE. dT_ad = (B/A) p0 with the example's"
      f"\nown printed A = {bk('vwf_A'):.0f} and B = {bk('vwf_B'):.3g}, i.e. B/A ="
      f" {BOA:.0f} per atm, and the printed"
      f"\ndT_ad column is {100*T2_DTAD_WORST_DEV:.0f} % low at worst. Invert each row for the Q"
      f" it needs and all\nthree agree: Q = {XC.Q_implied.min():.4f} to"
      f" {XC.Q_implied.max():.4f}, against the printed {Q}."
      f"\nTABLE 11.5.3.A-1 PASSES THE SAME TEST - worst {100*T1_CROSS_WORST:.1f} % on the same"
      f" three rows,\nagainst {100*T2_DTAD_WORST_DEV:.0f} % - which rules out a wrong B/A, a"
      f" wrong conversion and a wrong\nreading of the formulae, since every one of those"
      f" would move BOTH tables.\nIt does NOT confine the defect to A-2:"
      f" the block below inverts each table's own printed Q"
      f" for the radius it\nimplies, and both of them point at the same 0.0175 m.")

# WHERE the printed Q comes from - the example's own second half, two paragraphs on
Q_SCALED = Q * np.sqrt(bk("vwf_R_critical_625") / R_T)
C_AT = lambda R: 2.0 * P["U"] / (P["cp_vol"] * R)
Q_FROM_C = lambda R, A, TM=None: np.sqrt(
    C_AT(R) / (A * np.exp(P["b"] - P["a"] / (bk("vwf_TM_625") if TM is None else TM))))
_r4 = VWF_EX[(VWF_EX.example == "4") & (VWF_EX.quantity == "R")]
print(f"\nWHY. The same Example 11.5.3.A asks, two paragraphs later, what radius would be"
      f"\ncritical, and answers - book page"
      f" {int(BK.loc['vwf_R_critical_625','book_page'])} -"
      f" '{bk('vwf_C_formula_claim','as_printed')}'"
      f"\nD2.2's CSV of the 1970 original carries the same answer as its Example 4:"
      f" R = {float(_r4.value.iloc[0])} m,\n\"{str(_r4.conditions.iloc[0])}\"."
      f" So Q = {Q} IS a printed value of this example - it is the Q of the"
      f"\nCRITICAL radius {bk('vwf_R_critical_625')} m, transplanted onto the"
      f" {R_T} m case that Table 11.5.3.A-2\ntabulates."
      f"\nThat printed C formula is itself the proof, because C = 2U/(c_p R_t) - with the"
      f"\nVOLUMETRIC c_p, D2.2's finding - is"
      f"\ninversely proportional to R_t at a fixed T_M, so Q scales as R_t^(-1/2):"
      f"\n   Q at R_t = {R_T} m, from Q({bk('vwf_R_critical_625')}) x sqrt(R_crit/R_t)   :"
      f" {Q_SCALED:.4f}"
      f"\n   Q at R_t = {R_T} m, from C = Q^2 A exp(b - E/RT_M) directly : "
      f"{Q_FROM_C(R_T, A_G):.4f}   (A = {A_G:.0f})"
      f"\n   Q at R_t = {bk('vwf_R_critical_625')} m by the same formula, against the printed"
      f" {Q}: {Q_FROM_C(bk('vwf_R_critical_625'), A_G):.4f}"
      f"\n   Q the p0 column of Table 11.5.3.A-2 needs                 : {T2_Q_IMPLIED:.4f}"
      f"\nFour routes, one answer: the case tabulated needs Q ~ {T2_Q_IMPLIED:.2f} and the"
      f" table was computed\nwith {Q}. The p0 column is Van Welsenaere & Froment's own,"
      f" converted;"
      f"\nthe dT_ad column beside it was recomputed with a Q from a different radius."
      f"\nThis is LARGER than the Upper/Mean slip above, and it is invisible to the"
      f"\ntranscription table: every one of those rows transcribes at ratio 1.000000,"
      f"\nbecause the number was copied correctly - from the wrong case. Reported, not"
      f"\nrepaired: nothing on this page uses Q.")

# ---- AND THE SAME TEST ON TABLE A-1, WHICH THE CROSS-COLUMN CHECK CANNOT SEE ----
# The C route is validated on Van Welsenaere & Froment's own printed numbers first:
# their Q at the critical radius, and their printed C, which pins R by itself.
_C4 = float(VWF_EX[(VWF_EX.example == "4") & (VWF_EX.quantity == "C")].value.iloc[0])
R_FROM_C_PRINTED = 2.0 * P["U"] / (P["cp_vol"] * _C4)
R_IMPLIED = lambda Qp, TM: R_T * (Q_FROM_C(R_T, A_G, TM) / Qp) ** 2
QINV = pd.DataFrame([
    dict(table="11.5.3.A-2", T_M_K=bk("vwf_TM_625"), Q_printed=Q,
         Q_at_0_0125=Q_FROM_C(R_T, A_G, bk("vwf_TM_625")),
         R_t_implied=R_IMPLIED(Q, bk("vwf_TM_625"))),
    dict(table="11.5.3.A-1", T_M_K=bk("vwf_TM_635"), Q_printed=Q1,
         Q_at_0_0125=Q_FROM_C(R_T, A_G, bk("vwf_TM_635")),
         R_t_implied=R_IMPLIED(Q1, bk("vwf_TM_635"))),
])
show(QINV.style.set_uuid("d11qinv").hide(axis="index").format(
    {"T_M_K": "{:.2f}", "Q_printed": "{:.4f}", "Q_at_0_0125": "{:.4f}",
     "R_t_implied": "{:.6f}"}))
R_A1_IMPLIED = float(QINV.R_t_implied.iloc[1])
print(f"The route is Van Welsenaere & Froment's own, and it is checked against their own"
      f"\nprinted numbers before it is inverted: their C = {_C4:.1f} 1/h with"
      f" C = 2U/(c_p R_t) alone\ngives R ="
      f" {R_FROM_C_PRINTED:.6f} m against the {bk('vwf_R_critical_625')} m the book prints"
      f" beside it, and\nQ({bk('vwf_R_critical_625')}) = {Q_FROM_C(bk('vwf_R_critical_625'), A_G):.4f}"
      f" against their printed {Q}."
      f"\n\nBOTH TABLES' Q BELONG TO R_t = {bk('vwf_R_critical_625')} m."
      f" Table A-1's printed Q = {Q1} implies\nR_t ="
      f" {R_A1_IMPLIED:.6f} m, the same radius as A-2's {Q}, and A-1 states the same"
      f" {R_T} m\nas A-2 does. So the transplant is in BOTH tables, and the reason only"
      f" A-2's columns\ndisagree is that A-1's two columns are not independent of each"
      f" other: they agree to\n{100*T1_CROSS_WORST:.1f} %, which is what a column"
      f" back-calculated from the other looks like, while\nA-2's p0 column is Van"
      f" Welsenaere & Froment's own - the transcription table above\nshows those three"
      f" entries at ratio {ATM} exactly - and its dT_ad column is not."
      f"\nA CROSS-COLUMN TEST CAN ONLY SEE A TRANSPLANT THAT MOVED ONE COLUMN. That is a"
      f"\nlimit of the test: A-1's pass does not confine the defect to A-2.")

# ======== 4. eq. (11.9.1-11) against a pellet grid solve and B1.1's table =====
# the pellet is model.py's `Pellet`: a spherical grid (`nu = 2`), surface values
# imposed, eta from the surface-flux row of the gradient operator.

# (a) the pellet grid solve against eq. (11.9.1-11), refined
# the pellet is examined at the rung-1 hot spot of section 11.5.2's OWN design point,
# which is the hottest state any rung reaches while still having a solution
_c1hs = Ladder(RX, rung=1, n_z=N_Z).solve(P0_BOOK)
_ihs = int(np.argmax(_c1hs[:, 1]))
T_HS = float(_c1hs[_ihs, 1])
P_HS = float(_c1hs[_ihs, 0])
PHI_HS = phi_prime(RX, T_HS, 1.0e-6)
pv = []
for n in (16, 32, 64, 128, 256):
    e = Pellet(RX, n_r=n).solve(THETA * P_HS, T_HS)["eta"]
    pv.append(dict(n_r=n, eta_numeric=e, eta_11_9_1_11=eta_sphere(PHI_HS),
                   rel_dev=e / eta_sphere(PHI_HS) - 1.0))
PV = pd.DataFrame(pv)
show(PV.style.set_uuid("d11pellet").hide(axis="index").format(
    {"eta_numeric": "{:.9f}", "eta_11_9_1_11": "{:.9f}", "rel_dev": "{:+.2e}"}))
ORD_ETA, LIM_ETA = richardson(PV.eta_numeric, PV.n_r)
ETA_DEV = float(abs(PV.rel_dev.iloc[-1]))
print(f"phi'' = {PHI_HS:.6f} at the rung-1 hot spot ({T_HS-273.15:.2f} C,"
      f" p_A = {P_HS:.6f} atm)."
      f"\nobserved order {ORD_ETA:.3f}, limit {LIM_ETA:.9f}, against eq. (11.9.1-11)'s"
      f" {eta_sphere(PHI_HS):.9f}\n  -> {abs(LIM_ETA/eta_sphere(PHI_HS)-1):.1e}. The analytical"
      f" solution and the grid solve agree.")

# (b) the same closed form against B1.1's exact table, which is an INDEPENDENT
#     transcription of it from Thiele (1939) rather than from Froment eq. (11.9.1-11)
SPH = ETA_REF[ETA_REF.geometry == "sphere"]
B11_DEV = float(np.abs(eta_sphere(SPH.phi.values) / SPH.eta.values - 1.0).max())
print(f"\nEq. (11.9.1-11) against B1.1's {len(SPH)} exact sphere rows, phi ="
      f" {SPH.phi.min():.2f} to {SPH.phi.max():.0f}:"
      f"\n   worst relative deviation {B11_DEV:.2e}. Same closed form, two independent"
      f"\n   transcriptions from two documents. B1.1's own pymrm pellet matches its table"
      f"\n   to {B11_C['isothermal_max_rel_error_phi_le_30']:.1e} for phi <= 30 and"
      f" {B11_C['isothermal_max_rel_error_all_phi']:.1e} over all phi - B1.1's claims, and"
      f"\n   this page's {ETA_DEV:.1e} at phi = {PHI_HS:.2f} is consistent with it.")

# (c) the book's claim that the particle is practically isothermal
print(f"\nsection 11.9.1, book page 598, verbatim:\n   "
      + bk("isothermal_pellet_claim", "as_printed"))
niso = Pellet(RX, n_r=128, isothermal=False).solve(THETA * P_HS, T_HS)
PELLET_DT = niso["T_centre"] - T_HS
BETA_PRATER = (P["minus_dH"] * KCAL) * 1.0e-6 * (THETA * P_HS) / (1.0e-3 * T_HS)
GAMMA_ARRH = P["a"] / T_HS
_c3hs = solve_robust(Ladder(RX, rung=3, n_z=N_Z), P0S[3])
FILM_DT_HS = float(np.max(_c3hs[:, 3] - _c3hs[:, 1]))
print(f"   intraparticle rise, centre minus surface : {PELLET_DT:+.4f} K"
      f"\n   interfacial rise across the film, at rung 3's own threshold: {FILM_DT_HS:+.4f} K"
      f"\n   ratio                                    : {FILM_DT_HS/PELLET_DT:.2f}"
      f"\n   Prater number beta = {BETA_PRATER:.3e}, Arrhenius gamma = {GAMMA_ARRH:.2f},"
      f" gamma*beta = {GAMMA_ARRH*BETA_PRATER:.4f}"
      f"\n   eta with the pellet energy balance on: {niso['eta']:.8f}, against"
      f" {eta_sphere(PHI_HS):.8f} isothermal"
      f"\nBoth halves of the claim hold on this reactor, and the second half is the"
      f"\nstronger: the film carries {FILM_DT_HS/PELLET_DT:.0f}x the temperature difference the"
      f" particle does. This\nsits far below B1.1's fold (beta = 0.6, gamma = 20), so none of"
      f" its multiplicity\nis in play here and none of it is borrowed.")

# ===== 5. the chapter's own criteria for deciding whether to climb a rung =====
print("Section 11.6 offers three yardsticks for whether rung 2 is needed. Two of them"
      "\ncannot be evaluated on the reactor section 11.5.2 designs.\n")
print("(i) the rule of thumb, book page 560:\n   " + bk("axial_50dp_claim", "as_printed"))
L_OVER_DP = L_BED / D_P
PE_L = L_OVER_DP * bk("pe_axial_low"), L_OVER_DP * bk("pe_axial_high")
print(f"   L/d_p = {L_OVER_DP:.0f}, which is {L_OVER_DP/bk('axial_50dp_claim'):.0f}x the"
      f" rule's 50, and the length Peclet number\n   Pe_a' = Pe_a L/d_p ="
      f" {PE_L[0]:.0f} to {PE_L[1]:.0f}. Page 563 says axial mixing would matter in"
      f"\n   methanol synthesis below Pe_a' = {bk('pe_ma_methanol'):.0f} and in ethylene"
      f" oxidation below {bk('pe_ma_ethylene'):.0f}."
      f"\n   MEASURED SHIFT, extrapolated: {LIM_S2:+.4f} % in p0*. The rule of thumb is"
      f" right.\n")

print("(ii) criterion (11.6-3), for a rate that decreases monotonically:")
r_A0 = kexp(T_R0) * P["p_B0"] * P0_BOOK                      # kmol/(kg cat h)
C0 = THETA * P0_BOOK
CRIT_MASS = r_A0 * P["rho_b"] * D_P / (P["u"] * C0)
print(f"      r_A0 rho_B d_p / (u_s C_0)  =  {CRIT_MASS:.3e}   <<  Pe_ma ="
      f" {bk('pe_axial_low'):.0f} to {bk('pe_axial_high'):.0f}   satisfied by"
      f" {bk('pe_axial_low')/CRIT_MASS:.1e}")
print(f"      (-dH) r_A0 rho_B d_p / [(T_0 - T_w) u_s rho_g c_p]  <<  Pe_ha")
print(f"      T_0 - T_w = {T_R0 - T_R0:.1f} K on this reactor, BY CONSTRUCTION: section"
      f" 11.5.2 sets\n      T = T_0 = T_r at z = 0, and section 11.5.3 builds its whole"
      f" runaway diagram\n      for 'the common situation where T_r = T_0'. The heat"
      f" criterion divides by\n      zero and cannot be evaluated for the chapter's own"
      f" design case.\n")

print("(iii) criterion (11.6-4), for a rate with an interior maximum, book page 561:")
lad1 = Ladder(RX, rung=1, n_z=4800)
c1 = lad1.solve(P0_BOOK)
dx_dzdp = float(np.max(np.abs(np.gradient(1.0 - c1[:, 0] / P0_BOOK, lad1.z_c))) * D_P)
dT_dzdp = float(np.max(np.abs(np.gradient(c1[:, 1], lad1.z_c))) * D_P)
print(f"      max |dx / d(z/d_p)|  =  {dx_dzdp:.4e}   <<  Pe_ma   satisfied by"
      f" {bk('pe_axial_low')/dx_dzdp:.0f}x")
print(f"      max |dT / d(z/d_p)|  =  {dT_dzdp:.4f} K   <<  Pe_ha")
print(f"      AS PRINTED THIS IS DIMENSIONALLY INHOMOGENEOUS: the left side is a"
      f" temperature\n      per particle diameter and the right side is a dimensionless"
      f" group. Its own\n      companion in (11.6-3) is normalised by (T_0 - T_w) and is"
      f" dimensionless;\n      (11.6-4)'s mass criterion is dimensionless too, because x"
      f" is. The heat one\n      is missing a temperature scale, and there is no candidate"
      f" in the chapter:\n      (T_0 - T_w) is zero here.")
print(f"\n      the book asserts, on the same page:\n      \"" +
      bk("axial_steep_claim", "as_printed") + "\"")
print(f"      Taking the natural repair - dividing by the adiabatic temperature rise,"
      f"\n      LABELLED AS AN INFERENCE and not as the book's - gives"
      f" {dT_dzdp/(B_G/A_G*P0_BOOK):.3e}, satisfied\n      by"
      f" {bk('pe_axial_low')/(dT_dzdp/(B_G/A_G*P0_BOOK)):.0f}x. So the assertion is"
      f" correct on any reading; it is the criterion,\n      not the conclusion, that cannot"
      f" be used.")
print(f"\n(iv) THE CHAPTER IS NOT THE ONLY PLACE THE BOOK DISCUSSES THESE. Section 12.7.2,"
      f"\n     book page {int(BK.loc['ch12_yf_claim','book_page'])},"
      f" {int(BK.loc['ch12_yf_claim','book_page']) - 561} pages later, says of the very same"
      f" criteria:\n     \"" + bk("ch12_yf_claim", "as_printed") + "\"")
print("     Read that carefully, because the page's gloss on it is an INFERENCE and is"
      "\n     labelled as one. What 12.7.2 STATES is that Mears found the criteria not"
      "\n     general and supplied alternates for equal feed and wall temperatures. That"
      "\n     those alternates exist BECAUSE of the two problems found above - a division"
      "\n     by (T_0 - T_w) that is zero when the feed and wall temperatures are equal,"
      "\n     and a dimensionally inhomogeneous heat criterion - is this page's reading of"
      "\n     the sentence, not something the sentence says. The one thing that is not an"
      "\n     inference is that the situation it singles out, equal feed and wall"
      "\n     temperatures, is exactly the situation section 11.5.2 builds. Section 11.6"
      "\n     carries no cross-reference to 12.7.2 and 12.7.2 none to 11.6; the nearest"
      "\n     thing is 12.7.2's own next paragraph, 'the latter has been thoroughly covered"
      "\n     in Chapter 11', which is about RADIAL dispersion, not about the criteria."
      "\n     (Searched: all 13 occurrences of 'Peclet number' in the 902-page text layer,"
      "\n     both 'Finlayson' hits in Ch. 11 and both in Ch. 12, and the notation list"
      "\n     entries between Pr and PN, which define only Pe_a = u_i d_p / D_ea and"
      "\n     Pe_a' = u_i L / D_ea - never Pe_ha or Pe_ma.)")

CRIT_HEAT_DENOM = T_R0 - T_R0

# ======== 6. rung 3's interfacial difference against the book's own claim =====
print("section 11.8.2, book page 590, on this same reactor and kinetic scheme:\n   \""
      + bk("film_dT_claim", "as_printed") + "\"")
lad3 = Ladder(RX, rung=3, n_z=N_Z, T_r=bk("startup_T0_1182"))
c3 = solve_robust(lad3, bk("y_A0_1173"))
DT_FILM_1182 = float(np.max(c3[:, 3] - c3[:, 1]))
DP_FILM_1182 = float(np.max(c3[:, 0] - c3[:, 2]))
print(f"\nAt the book's own startup conditions - T_0 = T_r ="
      f" {bk('startup_T0_1182','as_printed')} C, and the 11.7.3\ninlet mole fraction"
      f" y_A0 = {bk('y_A0_1173')} for the same reactor:"
      f"\n   max gas-to-solid temperature difference : {DT_FILM_1182:.4f} K   against the"
      f" printed 'of the order of 1 C'"
      f"\n   max partial-pressure drop across the film: {DP_FILM_1182:.3e} atm,"
      f" {100*DP_FILM_1182/bk('y_A0_1173'):.3f} % of the inlet"
      f"\nThe temperature claim holds; the chapter's other statement that 'the most likely"
      f"\ninterfacial gradient to occur is the temperature gradient' (page 585) is"
      f" confirmed\nby the same pair of numbers."
      f"\n\nTWO OF THE THREE INPUTS ARE NOT SECTION 11.8.2'S. It prints"
      f" T_0 = T_r = {bk('startup_T0_1182','as_printed')} C and\nnothing else quantitative for"
      f" this case: the inlet composition is borrowed from\nsection 11.7.3 and k_g, h_f come"
      f" from A3.4's correlation, which the chapter does not\nprint either. So this"
      f" reproduces 'of the order of 1 C' at the book's own startup\nTEMPERATURE with two"
      f" imported inputs, and it is worth exactly what an order-of-\nmagnitude claim with two"
      f" free inputs is worth. The crossover row below is what\nbounds the film's importance"
      f" without them.")

# Mears' criterion for the onset of interphase temperature gradients, page 588.
# The criterion family belongs to published B1.7; this is it evaluated here.
i_hs = int(np.argmax(c3[:, 1]))
r_obs = kexp(c3[i_hs, 3]) * P["p_B0"] * c3[i_hs, 2] / 3600.0          # kmol/(kg s)
CHI = ((P["minus_dH"] * KCAL) * r_obs * P["rho_b"] * D_P
       / (2.0 * FILM["h_f"] * c3[i_hs, 1]))
MEARS_RHS = bk("mears_constant") / (P["a"] / c3[i_hs, 1])
print(f"\nMears' interphase criterion, book page 588 (the criterion family is B1.7's;"
      f"\nthis is B1.7's eq. 14 evaluated on this reactor):"
      f"\n   |chi| = (-dH) r_A rho_B d_p / (2 h_f T) = {CHI:.5f}"
      f"\n   0.15 R T / E                            = {MEARS_RHS:.5f}"
      f"\n   -> {'SATISFIED' if CHI < MEARS_RHS else 'VIOLATED'}, by a factor"
      f" {MEARS_RHS/CHI:.2f}")
print(f"\nAND YET. At section 11.5.2's own design point the same {FILM_DT_HS:.2f} K film"
      f" difference moves\nthe safe inlet partial pressure by {SHIFT[3]:+.2f} %"
      f" - {abs(SHIFT[3])/(100*bk('runaway_p0_increment')/bk('runaway_p0_safe')):.1f} times"
      f" the {100*bk('runaway_p0_increment')/bk('runaway_p0_safe'):.2f} % margin\nthat section"
      f" 11.5.2's own sensitivity sentence hangs on. Mears' criterion asks whether\nthe"
      f" OBSERVED RATE deviates by 5 % from the intrinsic one, and it correctly says no."
      f"\nIt is not a statement about the runaway boundary, and near a runaway boundary a"
      f"\nrate that is right to 5 % is not enough. That is the ladder's lesson in one"
      f" line:\nthe criteria in the chapter test the RATE, and what a designer of this"
      f" reactor\nneeds tested is the THRESHOLD.")

print(f"\nAND THE CHAPTER SAYS SO ITSELF, in the sentence immediately after the one this"
      f"\npage uses as its anchor. Book page"
      f" {int(BK.loc['heat_mass_transfer_claim','book_page'])}, verbatim:\n   \""
      + bk("heat_mass_transfer_claim", "as_printed") + "\"")
print(f"That is section 11.5.2 stating, at exactly the operating points this page works"
      f"\nat - {P0_BOOK}, and the curves just above it - that the pseudohomogeneous model is"
      f"\nno longer adequate there and that interfacial transport has to be added. Which is"
      f"\nrung 3, qualitatively, PRINTED IN THE CHAPTER. So the contribution here is not"
      f"\nthe observation; it is the size and the sign - {SHIFT[3]:+.2f} % in the threshold,"
      f" against a\nMears criterion that passes by a factor {MEARS_RHS/CHI:.2f} - and the"
      f" point that the chapter's own\nyardsticks are rate criteria while its own warning is"
      f" about the threshold. The\nchapter noticed; it did not quantify, and it did not"
      f" reconcile the warning with\nthe criteria it prints three pages later.")

# ======== 7. the crossovers, root-found rather than sampled ==================
print("Where does each rung stop mattering? Every row of the table below is a CONTROLLED"
      "\nSCAN: a sweep outward from the chapter's own value in which each threshold must"
      "\npass the crossing control before its shift is used for anything, run until two"
      "\nVALIDATED points straddle the target, then refined between them with every"
      "\niterate controlled too. All four rows are ROOTS.\n"
      "\nThe thresholds follow the start-up branch (see the note on locating thresholds"
      "\nat the top of Validation), and the scan meets no rejected point at all.\n")
BASE600 = p0_critical(Ladder(RX, rung=1, n_z=600))
# ONE definition of "shift" in this table, and it is the same-grid one: rung 1 at the
# SAME n_z as the rung being moved.  Mixing two - some rows against the
# Richardson-extrapolated rung-1 threshold and others against a same-grid one -
# costs a large fraction of the target, because rung 1's own
# 600-cell discretisation error is a fifth of it.  Both readings of the film row are
# measured and printed at the end of this cell.  Same-grid is the right one: it is
# what cancels the discretisation between the two models being compared.


def shift_pct(lad, base=None):
    return 100.0 * (p0_critical(lad, hi=0.09) / (BASE600 if base is None else base)
                    - 1.0)


TARGET = 1.0                      # per cent shift in p0*, the crossover definition
cross, SCANS = [], {}


def _row(key, lbl, quantity, chapter, factor, res):
    """factor = how many times the chapter's own value the located one is."""
    SCANS[key] = res
    cross.append((lbl, quantity, res["kind"], res["value"], chapter, factor,
                  res["shift_pct"]))


_MARGIN_BEFORE_SCANS = CTL_STATS["margin_K"]     # the four scans' own margin, below
CTL_STATS["margin_K"] = np.inf
# (a) rung 2: how small must Pe_ma = Pe_ha be before axial dispersion moves p0* 1 %?
PE_SWEEP = (2.0, 1.5, 1.0, 0.6, 0.4, 0.32, 0.30, 0.25, 0.24, 0.23, 0.22, 0.21,
            0.20, 0.15, 0.10)
S2 = cross_scan(lambda pe: shift_pct(Ladder(RX, rung=2, n_z=600, pe_ma=pe, pe_ha=pe)),
                PE_SWEEP, TARGET)
_row("pe", "rung 2, sec. 11.6", "axial Peclet number Pe_a",
     f"{bk('pe_axial_low'):.0f} to {bk('pe_axial_high'):.0f} (page 560)",
     bk("pe_axial_low") / S2["value"], S2)

# (b) rung 3: how large must the film coefficients be before the film moves p0* 1 %?
FILM_SWEEP = (1.0, 2.0, 3.0, 4.0, 6.0, 10.0, 30.0, 100.0)
S3 = cross_scan(lambda fs: shift_pct(Ladder(RX, rung=3, n_z=600, film_scale=fs)),
                FILM_SWEEP, TARGET)
_row("film", "rung 3, sec. 11.8", "Wakao-Funazkri k_g and h_f, x",
     "1.0 (as correlated)", S3["value"] / 1.0, S3)

# (c) rung 4: how large must D_e be before intraparticle diffusion moves p0* 1 %?
#     measured against RUNG 3, not rung 1: as D_e -> infinity rung 4 collapses onto
#     rung 3 (eta -> 1), not onto rung 1, so rung 1 is the wrong baseline for THIS
#     rung's own contribution.  The other three rows each sit one rung above their
#     own baseline already.
BASE3 = p0_critical(Ladder(RX, rung=3, n_z=600))
DE_SWEEP = (1.0e-6, 3.0e-6, 1.0e-5, 3.0e-5, 1.0e-4, 1.0e-3, 1.0e-2)
S4 = cross_scan(lambda de: shift_pct(Ladder(RX, rung=4, n_z=600, D_e=de), base=BASE3),
                DE_SWEEP, TARGET)
_row("De", "rung 4, sec. 11.9", "effective diffusivity D_e [m2/s], vs rung 3",
     "NOT PRINTED for this catalyst", S4["value"] / 1.0e-6, S4)

# (d) rung 5: how small must the tube radius be before 2-D moves p0* 1 %?
S5 = cross_R(TARGET)
SCAN_MARGIN_K = CTL_STATS["margin_K"]
CTL_STATS["margin_K"] = min(_MARGIN_BEFORE_SCANS, SCAN_MARGIN_K)
_row("R", "rung 5, sec. 11.7", "tube radius R_t [m]", f"{R_T} (this reactor)",
     R_T / S5["value"], S5)

SWEEP_LABEL = {"pe": "Pe_ma = Pe_ha", "film": "film coefficients, x",
               "De": "D_e [m2/s]", "R": "R_t [m]"}
for _k, _res in SCANS.items():
    _t = _res["sweep"].rename(columns={"x": SWEEP_LABEL[_k]})
    print(f"\nthe {SWEEP_LABEL[_k]} sweep: {_res['n_evaluated']} points evaluated,"
          f" {_res['n_controlled']} validated, the search uses only those,\nand the sweep"
          f" stops once two VALIDATED points straddle the target. Refinement:"
          f"\n{_res['levels']} levels took the {_res['bracket0']:.4g}-wide straddling pair"
          f" to {_res['bracket']:.3g}.")
    show(_t.style.set_uuid("d11sweep" + _k).hide(axis="index").format(
        {SWEEP_LABEL[_k]: "{:.6g}", "shift_pct": "{:+.4f}"},
        na_rep="the control REJECTS this point"))
PE_STAR, FILM_STAR, DE_STAR, R_STAR = (S2["value"], S3["value"], S4["value"],
                                       S5["value"])
CROSS = pd.DataFrame(cross, columns=["rung", "quantity", "kind", "crossover",
                                     "the chapter's value", "factor away",
                                     "shift there, %"])
# NOT asserted that list(CROSS.kind) == ["root"] * 4: cross_scan has a single
# `return`, always kind="root", so that assert could never fail - a toothless
# check on the one page that audits toothless checks.  The "kind" column stays,
# printed rather than guarded.
show(CROSS.style.set_uuid("d11cross").hide(axis="index").format(
    {"crossover": "{:.4g}", "factor away": "{:.3g}", "shift there, %": "{:+.4f}"}))

# the certificate the located rung-2 crossover itself carries, printed rather than
# asserted - it is the whole of the case that this row is a root and not an artefact
_L2S = Ladder(RX, rung=2, n_z=600, pe_ma=PE_STAR, pe_ha=PE_STAR)
_P2S = p0_critical(_L2S, hi=0.09)
_LO2, _HI2, _OK2 = crossing_control(_L2S, _P2S)
assert _OK2, "the located rung-2 crossover does not pass the crossing control"
SCAN_PROBED = sum(_r["probed"] for _r in SCANS.values())
SCAN_REFUSED = (sum(_r["refused"] for _r in SCANS.values())
                + sum(_r["n_evaluated"] - _r["n_controlled"] for _r in SCANS.values()))
print(f"\nALL FOUR ROWS ARE ROOTS. At Pe_a = {PE_STAR:.4f} the rung-2 shift is"
      f" {S2['shift_pct']:+.5f} %, and that\nthreshold carries the same certificate as the"
      f" five rungs of the ladder table -\np0* = {_P2S:.8f} atm with {_LO2-273.15:.2f} C just"
      f" below it and {_HI2-273.15:.2f} C just above, a\n{_HI2-_LO2:.3f} K jump against the"
      f" {CTL_JUMP:.0f} K the control allows. So axial dispersion has to be"
      f"\n{bk('pe_axial_low')/PE_STAR:.2f} times stronger than the chapter's own lower limit"
      f" before it moves the\nthreshold {TARGET:.0f} %. The four refinements probed"
      f" {SCAN_PROBED} interior points between them and,\nwith the sweep points, the control"
      f" rejected {SCAN_REFUSED} of all the thresholds the four scans used.")

RANK = CROSS.sort_values("factor away")
print(f"\nRead the 'factor away' column as a RANKING: it is how far each coefficient would"
      f"\nhave to move from the chapter's own value before its rung shifted the threshold"
      f"\n{TARGET:.0f} %, so SMALL means the rung is close to not mattering.")
for _, _row_ in RANK.iterrows():
    print(f"   {_row_['rung']:<20s} factor {_row_['factor away']:7.2f}"
          f"   {_row_['quantity']}")
print(f"\nThe ordering is DECIDABLE, all four of it: rung 5 is closest to irrelevance by a"
      f"\nwide margin, then rung 2 at {bk('pe_axial_low')/PE_STAR:.2f}, then rung 3 at"
      f" {FILM_STAR:.2f}, and rung 4 is furthest at\n{DE_STAR/1.0e-6:.2f}. Rungs 2 and 3 are"
      f" only {100*abs(FILM_STAR/(bk('pe_axial_low')/PE_STAR)-1):.0f} % apart, which is the"
      f" honest caveat on THAT pair.")

# THE CONTROL'S VERDICT ALONG Pe_a, on a regular 0.001 grid from 0.316 to 0.308.
_UNIFORM = []
for _p in np.round(np.arange(0.316, 0.3075, -0.001), 4):
    _UNIFORM.append((float(_p), *_shift_or_none(
        lambda p: shift_pct(Ladder(RX, rung=2, n_z=600, pe_ma=p, pe_ha=p)), float(_p))))
UNIFORM_OK = sum(1 for _, _, o in _UNIFORM if o)
assert UNIFORM_OK == len(_UNIFORM), "the control rejects a point of the fine Pe_a grid"
assert np.all(np.diff([v for _, v, _ in _UNIFORM]) > 0), (
    "the rung-2 shift is not monotone on the fine Pe_a grid")
print(f"\nTHE CONTROL'S VERDICT ALONG Pe_a, on a regular 0.001 grid:\n   "
      + "  ".join(f"{p:.3f} {v:+.4f} %" for p, v, _ in _UNIFORM)
      + f"\n{UNIFORM_OK} of {len(_UNIFORM)} validate, and the shift rises monotonically as"
      f" Pe_a falls.")

# THE REST OF THE Pe_a SWEEP, evaluated although the crossover did not need it. The
# scan above stops as soon as the target is bracketed, so "the largest shift the sweep
# shows" would otherwise be an artefact of where it stopped.  The tail is measured.
PE_TAIL = [(float(_p), *_shift_or_none(
    lambda x: shift_pct(Ladder(RX, rung=2, n_z=600, pe_ma=x, pe_ha=x)), float(_p)))
    for _p in PE_SWEEP[S2["n_evaluated"]:]]
_ALL2 = ([(float(r.x), float(r.shift_pct)) for r in S2["sweep"].itertuples() if r.controlled]
         + [(p, v) for p, v, ok in PE_TAIL if ok])
_MAX2 = max(_ALL2, key=lambda t: abs(t[1]))
PE_TAIL_OK = sum(1 for _, _, ok in PE_TAIL if ok)
print(f"\nWHAT THE WHOLE SWEEP REACHES, tail included:\n   "
      + "  ".join(f"{p:.2f} " + (f"{v:+.4f} %" if ok else "REFUSED") for p, v, ok in PE_TAIL)
      + f"\nAcross all {len(PE_SWEEP)} swept points the control validates {len(_ALL2)}, and the"
      f" largest |shift| any\nof them carries is {abs(_MAX2[1]):.4f} % at"
      f" Pe_a = {_MAX2[0]:.2f}. So a {2*TARGET:.0f} % crossover for rung 2 is bracketable on"
      f"\nthis sweep, and the break row that moves the crossover target moves it to"
      f" {2*TARGET:.0f} %.\nWhat lies below Pe_a = {min(p for p, _ in _ALL2):.2f} is not"
      f" reported here.")

# THE ACCURACY OF THE RUNG-2 ROOT, the same way rung 5's is done below: the same-grid
# shift at a validated sweep point on three grids, divided by the local slope.
PE_ANCHOR = S2["pair"][1]
PE_GRID = {}
for _n in (600, 900, N_Z):
    _b1 = BASE600 if _n == 600 else p0_critical(Ladder(RX, rung=1, n_z=_n))
    PE_GRID[_n] = 100.0 * (p0_critical(Ladder(RX, rung=2, n_z=_n, pe_ma=PE_ANCHOR,
                                              pe_ha=PE_ANCHOR), hi=0.09) / _b1 - 1.0)
PE_GAP = max(PE_GRID.values()) - min(PE_GRID.values())
PE_SLOPE = abs(S2["pair_shift"][1] - S2["pair_shift"][0]) / abs(S2["pair"][1]
                                                                - S2["pair"][0])
PE_STAR_UNC = PE_GAP / PE_SLOPE
print(f"\nAND THE DIGITS OF Pe_a* THAT MEAN ANYTHING. The refinement resolves the"
      f" straddling\npair to {S2['bracket']:.1e}, but that is a TOLERANCE. The accuracy is"
      f" set by the grid, and it is\nmeasured under the SAME-GRID definition this table uses"
      f" - which is the point, because\nagainst a fixed extrapolated baseline the same"
      f" comparison would carry rung 1's own\n600-to-{N_Z} movement instead of cancelling it."
      f" At Pe_a = {PE_ANCHOR:.4f}, a validated sweep point:"
      + "".join(f"\n   n_z = {n:5d}   shift = {v:+.5f} %" for n, v in PE_GRID.items())
      + f"\na spread of {PE_GAP:.4f} pp across a doubling of the grid. On the local slope of"
      f" the\nsweep, {PE_SLOPE*1e-3:.4f} pp per 0.001 in Pe_a, that is"
      f" Pe_a* = {PE_STAR:.4f} +/- {PE_STAR_UNC:.4f},\nfactor"
      f" {bk('pe_axial_low')/PE_STAR:.3f} +/-"
      f" {bk('pe_axial_low')*PE_STAR_UNC/PE_STAR**2:.3f}. Three figures on Pe_a*, not the"
      f" six its refinement\ntolerance would suggest - the same reading the tube radius gets"
      f" below.")
_sw5 = S5["sweep"]
_brk5 = abs(S5["pair"][1] - S5["pair"][0])     # the straddling pair the root sits in
_slope5 = abs(abs(S5["pair_shift"][1]) - abs(S5["pair_shift"][0])) / _brk5
_gap5 = abs(_sw5.shift_pct[0] - SHIFT[5])     # (600, 10) against (1200, 20), R_t as built
R_STAR_UNC = _gap5 / _slope5
assert np.all(np.diff(_sw5.shift_pct[_sw5.controlled].values) > 0), (
    "the rung-5 shift is not monotone over the validated sweep")
print(f"\nRUNG 5, THE ONE ROW WHOSE CROSSOVER IS INSIDE THIS REACTOR'S OWN RANGE."
      f" R_t* = {R_STAR:.6f} m,\nd_t/d_p = {2*R_STAR/D_P:.3f}, where |shift| ="
      f" {abs(S5['shift_pct']):.4f} %: a tube only {R_T/R_STAR:.2f}x narrower than this"
      f"\none - {R_STAR*1e3:.2f} mm rather than {R_T*1e3:.1f} mm - already brings the"
      f" two-dimensional rung\ninside {TARGET:.0f} %. THE DIGITS THAT MEAN ANYTHING:"
      f" the refinement resolves the bracket to\n{S5['bracket']*1e6:.1f}"
      f" micrometres, but that is a TOLERANCE and not an accuracy. The accuracy is set"
      f"\nby the grid: this page's own (600, 10) and ({N_Z}, {N_R}) values of the rung-5"
      f" shift differ by\n{_gap5:.3f} pp, and the local slope of the sweep is"
      f" {_slope5*1e-3:.1f} pp/mm, so R_t* = {R_STAR*1e3:.3f} +/- {R_STAR_UNC*1e3:.3f} mm,"
      f"\nd_t/d_p = {2*R_STAR/D_P:.2f} +/- {2*R_STAR_UNC/D_P:.2f}, factor"
      f" {R_T/R_STAR:.3f} +/- {R_T*R_STAR_UNC/R_STAR**2:.3f}. Three figures on R_t*, not six.")

# NARROWER TUBES THAN THE CROSSOVER, measured HERE and not inside the crossover scan:
# the scan stops as soon as the target is bracketed, and this is a different question.
R_NARROW = (0.0098, 0.00975, 0.0097, 0.0096, 0.0094, 0.0090)
_NARROW = [(R, *_shift_or_none(shift_rung5, R)) for R in R_NARROW]
assert all(ok for _, _, ok in _NARROW), "the control rejects a radius below the crossover"
_N_OK5 = [(R, v) for R, v, ok in _NARROW]
assert np.all(np.diff([v for _, v in _N_OK5]) > 0), (
    "the rung-5 shift is not monotone over the radii below the crossover")
_SIGN5 = [(R, v) for R, v in _N_OK5 if v > 0.0][0]
_NEG5 = [(R, v) for R, v in _N_OK5 if v < 0.0][-1]
assert _SIGN5[0] < _NEG5[0], "the rung-5 sign change is not where this text says"
_UNDER5 = [(R, v) for R, v in _N_OK5 if abs(v) < TARGET]
_OVER5 = [(R, v) for R, v in _N_OK5 if v > TARGET]
assert _OVER5 and min(R for R, _ in _UNDER5) > max(R for R, _ in _OVER5), (
    "the second 1 % crossing on narrow tubes is not where this text says")
print(f"\nAND ON TUBES NARROWER THAN THE CROSSOVER. On {len(R_NARROW)} radii below it the"
      f" control validates\nevery threshold:\n   "
      + "  ".join(f"{R*1e3:.2f} mm {v:+.4f} %" for R, v in _N_OK5)
      + f"\nThe signed shift rises monotonically as the tube narrows (checked, not assumed)"
      f" and\nCHANGES SIGN between {_NEG5[0]*1e3:.2f} mm ({_NEG5[1]:+.4f} %) and"
      f" {_SIGN5[0]*1e3:.2f} mm ({_SIGN5[1]:+.4f} %): the\ntwo-dimensional correction is"
      f" NEGATIVE on this tube and POSITIVE on a narrower one.\n|shift| stays under"
      f" {TARGET:.0f} % from R_t* = {R_STAR*1e3:.2f} mm down to"
      f" {min(R for R, _ in _UNDER5)*1e3:.2f} mm, and is past {TARGET:.0f} % again,"
      f"\non the positive side, by {max(R for R, _ in _OVER5)*1e3:.2f} mm"
      f" ({[v for R, v in _OVER5][0]:+.4f} %).")
print(f"\nNone of that contradicts section 11.7.3's own sentence, which reads, verbatim:"
      f"\n   \"" + bk("radial_gradient_claim", "as_printed") + "\"" + f"\nThat sentence is"
      f" about the radial temperature GRADIENT and this measure is about the"
      f"\nrunaway THRESHOLD: the gradient here is"
      f" {float(R5[(R5.n_z==N_Z)&(R5.n_r==N_R)].dT_radial.iloc[0]):.1f} K wall-to-axis while"
      f" the threshold moves {abs(SHIFT[5]):.1f} %. Severe\ngradients and a modest threshold"
      f" shift are the same reactor."
      f"\nThe film sits a factor {FILM_STAR:.1f} away, which is why that rung's size depends"
      f"\non which correlation you pick. The intraparticle rung is the one that is not"
      f"\ndecidable from the chapter at all: the crossover D_e is {DE_STAR:.2e} m2/s,"
      f"\nand the chapter prints no D_e for this catalyst - it sends the reader to two"
      f"\ndocuments ({bk('De_source_claim','as_printed')[:52]}...).")

# THE CONTROL ON A COARSE GRID: rung 4's anchor at n_z = 300, the grid of the
# coarse-grid break row.
_L300 = Ladder(RX, rung=4, n_z=300)
_P300 = p0_critical(_L300, hi=0.09)
_LO3, _HI3, _OK3 = crossing_control(_L300, _P300)
print(f"\nAND ON A COARSE GRID. At n_z = 300, rung 4's own anchor point - its default"
      f"\nD_e = {1.0e-6:.0e} m2/s, the first point of that sweep - returns p0* = {_P300:.10f}"
      f" with\n{_LO3-273.15:.3f} C just below it and {_HI3-273.15:.3f} C just above: a clean"
      f" crossing ({_OK3}), so the\ncoarse-grid break row runs at 300 cells.")

# WHAT THE OTHER SHIFT DEFINITION WOULD COST, measured on the row where it is largest
S3_EXTRAP = cross_scan(lambda fs: shift_pct(Ladder(RX, rung=3, n_z=600, film_scale=fs),
                                            base=LIM_P), FILM_SWEEP, TARGET)
print(f"\nTHE COST OF THE SHIFT DEFINITION, on the row where it is largest. Rung 1's"
      f" 600-cell\nthreshold is {BASE600:.8f} atm and its Richardson limit is {LIM_P:.8f},"
      f" a gap of\n{100*(BASE600/LIM_P-1):+.3f} percentage points - a fifth of the"
      f" {TARGET:.0f} % target. The film row against the"
      f"\nsame-grid baseline used above: {S3['value']:.4f}. Against the extrapolated"
      f" baseline: {S3_EXTRAP['value']:.4f}.\nOne definition, said once, in every row: the"
      f" same-grid one, because it is what\ncancels the discretisation between the two models"
      f" being compared.")

# what the printed a_1 group of page 574 would cost, given the chapter's own
# insensitivity claim for Pe_mr
print(f"\nAnd the printed a_1 = (D_er)_s/(u_i d_p) inconsistency of page 574, measured."
      f"\nThe chapter says: \"{bk('pe_mr_insensitive_claim','as_printed')}\"")
S_PEMR_AS_IS = shift_pct(Ladder(RX, rung=5, n_z=600, n_r=10))
S_PEMR_LITERAL = shift_pct(Ladder(RX, rung=5, n_z=600, n_r=10, pe_mr=PE_MR / EPS))
S_LAMER_5PCT = shift_pct(Ladder(RX, rung=5, n_z=600, n_r=10, lam_er=LAM_ER * 1.05,
                                pe_hr=PE_HR / 1.05))
print(f"   Pe_mr = {PE_MR:.0f} as this page reads the group : p0* shift"
      f" {S_PEMR_AS_IS:+.3f} %"
      f"\n   Pe_mr = {PE_MR/EPS:.1f}, the printed group read literally: p0* shift"
      f" {S_PEMR_LITERAL:+.3f} %  (delta"
      f" {S_PEMR_LITERAL-S_PEMR_AS_IS:+.3f} %)"
      f"\n   lambda_er raised 5 %                          : p0* shift"
      f" {S_LAMER_5PCT:+.3f} %  (delta {S_LAMER_5PCT-S_PEMR_AS_IS:+.3f} %)"
      f"\nThe chapter's sensitivity claim is confirmed on the threshold as well as on the"
      f"\nprofiles, and it is WHY the epsilon in a_1 is invisible: a factor 1/eps ="
      f" {1/EPS:.2f} in\nradial mass dispersion costs"
      f" {abs(S_PEMR_LITERAL-S_PEMR_AS_IS):.3f} % where 5 % on lambda_er costs"
      f" {abs(S_LAMER_5PCT-S_PEMR_AS_IS):.3f} %.\nA printed group can be wrong by a void"
      f" fraction and never be found, if the quantity\nit multiplies is the one the model is"
      f" insensitive to.")