simcon-toolkit 0.1.0__py3-none-any.whl

simcon_toolkit/_kit/templates/process-window/process_window/run_confirm.py

@@ -0,0 +1,403 @@
+"""G4: build and validate the numerical confirmation set.
+
+Selects 12-16 points from the G3 result — the centre, the face points of the recommended box, and
+deliberate probes just *outside* the green edge — and writes a complete, valid Cadmould `.rm1`
+deck for each, on the **same mesh** as the AI runs so the comparison is apples to apples.
+
+This is where the packing and cooling variables enter, and where **switchover becomes a real swept
+input** rather than the read-out it was on the AI side. Switchover is encoded the way the solver
+expresses it: the fill profile runs to level φ_s and the packing profile takes over
+from there, so φ_s *is* the velocity-to-pressure handover point.
+
+Scope for this session (user directive): the decks and submit specs are the deliverable; executing
+them is not required and `.car` parsing is out of scope. "Validated" therefore means something
+real and checkable without the solver — every deck is written, **read back with `Rm1Reader`, and
+its process parameters compared field by field against what was intended**. A deck that does not
+round-trip is a failure, not a stub.
+
+Run:  python main.py confirm configs/simple-plate.yaml
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from datetime import UTC, datetime
+from pathlib import Path
+
+import numpy as np
+
+import cadmould
+from cadmould import domain, io as cio, material as cmat, mesh as cmesh, tools
+
+from .run_screening import VARS
+from .setup_campaign import build, resolve_config
+from .units import Process
+
+ROOT = Path(__file__).resolve().parents[1]
+
+STAGE = "G4_numerical_confirmation"
+N_FILL_STEPS = 12
+SWITCHOVER_VARIANTS = (0.92, 0.96, 0.99)
+
+
+def fill_profile_to(phi_s: float, rate_cm3_s: float, n: int = N_FILL_STEPS):
+    """Constant-rate fill profile running from 0 to level ``phi_s``.
+
+    Switchover is the level at which velocity control stops, so a profile that ends at phi_s and
+    hands over to the pack profile *is* the switchover setting. Constant rate matches what the AI
+    solver could see, which keeps the comparison honest: the numerical deck is not quietly given a
+    better velocity profile than the AI runs that recommended it.
+    """
+    levels = np.linspace(phi_s / n, phi_s, n)
+    steps = [domain.FillStep(float(level), float(rate_cm3_s)) for level in levels]
+    return domain.FillProfile(steps), levels
+
+
+def pack_profile(hold_bar: float, hold_s: float, n: int = 4):
+    """Flat hold then a ramp down — the conventional shape.
+
+    ``PackStep.time_s`` is a **cumulative schedule time, not a per-step duration**: the solver
+    rejects the profile with "step times must be strictly increasing" otherwise. That mirrors
+    ``FillStep.level``, which is likewise an absolute position on an increasing axis rather than an
+    increment — both profiles are schedules, not lists of durations. Learned by having it rejected.
+    """
+    hold_flat = 0.6 * hold_s  # full pressure until gate seal
+    times = [hold_flat] + list(np.linspace(hold_flat, hold_s, n)[1:])
+    press = [hold_bar] + [hold_bar * (1.0 - i / (n - 1)) for i in range(1, n - 1)] + [0.0]
+    steps = [domain.PackStep(float(p), float(t)) for p, t in zip(press, times, strict=True)]
+    # Strictly increasing times, defensively — a silently accepted bad profile is worse than a raise.
+    for a, b in zip(steps, steps[1:], strict=False):  # deliberately offset by one
+        if not float(b.time_s) > float(a.time_s):
+            raise ValueError(f"pack profile times not strictly increasing: {[float(s.time_s) for s in steps]}")
+    return domain.PackProfile(steps)
+
+
+def build_deck(
+    *,
+    out: Path,
+    parts,
+    material,
+    gate_mm,
+    melt_C: float,
+    wall_C: float,
+    rate_cm3_s: float,
+    phi_s: float,
+    hold_bar: float,
+    hold_s: float,
+    cool_s: float,
+) -> dict:
+    """Write one .rm1 and report what was requested. Falls back if packing is unlicensed."""
+    fp, levels = fill_profile_to(phi_s, rate_cm3_s)
+    gates = domain.GatePoints.at(float(gate_mm[0]), float(gate_mm[1]), float(gate_mm[2]))
+    warn = []
+
+    def _mk(with_pack: bool):
+        b = (
+            domain.SimulationConfig.Builder(parts)
+            .with_material(material, melt_temp=float(melt_C))  # degC
+            .with_injection(gates)
+            .with_wall_temperature(domain.ConstantWallTemp(temp=float(wall_C)))  # degC
+            .with_filling(fp)
+            .with_cooling(float(cool_s))
+        )
+        if with_pack:
+            b = b.with_packing(pack_profile(hold_bar, hold_s))
+        return b.build()
+
+    try:
+        cfg = _mk(True)
+        packed = True
+    except Exception as exc:
+        # with_packing requires LICENCE_PACK. Report it rather than silently shipping a
+        # fill-only deck labelled as a packing study.
+        warn.append(
+            f"packing not applied ({type(exc).__name__}: {exc}); deck is FILL-ONLY and "
+            "the holding-pressure variables are recorded in the spec but not in the rm1"
+        )
+        cfg = _mk(False)
+        packed = False
+
+    out.parent.mkdir(parents=True, exist_ok=True)
+    cio.Rm1Writer().save(cfg, str(out))
+    return {
+        "packing_in_deck": packed,
+        "warnings": warn,
+        "fill_levels": [round(float(x), 4) for x in levels],
+        "bytes": out.stat().st_size,
+    }
+
+
+def validate_deck(path: Path, intended: dict) -> dict:
+    """Read the deck back and compare its process parameters with what was intended."""
+    checks: dict = {}
+    try:
+        cfg = cio.Rm1Reader().load(str(path))
+    except Exception as exc:
+        return {"round_trip": False, "error": f"{type(exc).__name__}: {exc}"}
+    checks["round_trip"] = True
+    try:
+        pp = cfg.process_params
+        got_melt = float(pp.melt_temperature)
+        got_wall = float(pp.wall_temperature)
+        # The reader may return either unit; accept whichever matches and record which, rather
+        # than assuming — this is exactly the K/degC boundary that breaks silently.
+        for name, got, want in (("melt", got_melt, intended["melt_C"]), ("wall", got_wall, intended["wall_C"])):
+            if abs(got - want) < 0.51:
+                checks[f"{name}_ok"] = True
+                checks[f"{name}_unit_read"] = "degC"
+            elif abs(got - (want + 273.15)) < 0.51:
+                checks[f"{name}_ok"] = True
+                checks[f"{name}_unit_read"] = "K"
+            else:
+                checks[f"{name}_ok"] = False
+                checks[f"{name}_read"] = round(got, 3)
+                checks[f"{name}_wanted_degC"] = round(want, 3)
+        fp = pp.fill_profile
+        steps = list(fp.steps) if fp is not None else []
+        checks["n_fill_steps"] = len(steps)
+        if steps:
+            last = float(steps[-1].level)
+            checks["switchover_level_read"] = round(last, 4)
+            checks["switchover_ok"] = abs(last - intended["phi_s"]) < 1e-3
+            rates = {round(float(s.rate), 4) for s in steps}
+            checks["constant_rate"] = len(rates) == 1
+            checks["rate_read"] = round(float(steps[-1].rate), 4)
+            checks["rate_ok"] = abs(float(steps[-1].rate) - intended["rate_cm3_s"]) < 1e-3
+        checks["n_parts"] = len(cfg.parts) if cfg.parts is not None else 0
+        checks["has_material"] = cfg.material is not None
+    except Exception as exc:
+        checks["inspect_error"] = f"{type(exc).__name__}: {exc}"
+    checks["all_ok"] = all(v for k, v in checks.items() if k.endswith("_ok") or k == "round_trip")
+    return checks
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description="G4 numerical confirmation decks")
+    ap.add_argument(
+        "config",
+        nargs="?",
+        help="campaign config; defaults to configs/simple-plate.yaml while that is unambiguous",
+    )
+    args = ap.parse_args()
+
+    campaign, info = build(resolve_config(args.config))
+    try:
+        stage_dir, runs_dir = info["stage_dir"], info["runs_dir"]
+        g3_path = stage_dir / "g3_refinement.json"
+        if not g3_path.exists():
+            print(f"  need {g3_path.relative_to(ROOT)} first — run `python main.py refine`")
+            return 1
+        g3 = json.loads(g3_path.read_text())
+        centre = {v: float(g3["centre"][v]) for v in VARS}
+        rbox = {v: [float(x) for x in g3["recommended_box"][v]] for v in VARS}
+        wide = {v: [float(x) for x in np.array(info["box"][v], float)] for v in VARS}
+        vol = info["volume_cm3"]
+        cool_s = info["sdk_cooling_time_s"]
+
+        # Packing nominals from the SDK, not invented.
+        with cadmould.Session.user_based():
+            raw_mat = cmat.io.PlbReader().load(
+                str(
+                    Path(info["cfg"]["material"]["plb"])
+                    if Path(info["cfg"]["material"]["plb"]).is_absolute()
+                    else ROOT / info["cfg"]["material"]["plb"]
+                )
+            )
+            parts = cmesh.io.CfexReader().load(str(info["cfex"]))
+            pk = tools.suggest_pack_profile(parts[0], raw_mat)
+            pk_steps = [(float(s.pressure_bar), float(s.time_s)) for s in pk.steps]
+            hold_bar = max(p for p, _ in pk_steps)
+            hold_s = sum(t for _, t in pk_steps)
+            print(
+                f"  SDK pack suggestion: {len(pk_steps)} steps, peak {hold_bar:.0f} bar, "
+                f"total {hold_s:.2f} s; cooling {cool_s:.2f} s"
+            )
+
+            # ---- the point set -------------------------------------------
+            pts: list[dict] = []
+
+            def add(pid, role, melt, wall, flow, phi_s=0.96, hb=None, hs=None, note=""):
+                pts.append(
+                    {
+                        "id": pid,
+                        "role": role,
+                        "melt_C": round(float(melt), 3),
+                        "wall_C": round(float(wall), 3),
+                        "flow_cm3_s": round(float(flow), 4),
+                        "phi_s": float(phi_s),
+                        "hold_bar": float(hb if hb is not None else hold_bar),
+                        "hold_s": float(hs if hs is not None else hold_s),
+                        "cool_s": float(cool_s),
+                        "note": note,
+                    }
+                )
+
+            add(
+                "C0",
+                "centre",
+                centre["melt_C"],
+                centre["wall_C"],
+                centre["flow_cm3_s"],
+                note="Chebyshev centre of the green region, shrunk by the margin",
+            )
+            for v in VARS:
+                for side, i in (("lo", 0), ("hi", 1)):
+                    p = dict(centre)
+                    p[v] = rbox[v][i]
+                    add(
+                        f"F_{v}_{side}",
+                        "face",
+                        p["melt_C"],
+                        p["wall_C"],
+                        p["flow_cm3_s"],
+                        note=f"face point of the recommended box: {v} at its {side} bound",
+                    )
+            # Probes deliberately OUTSIDE the green edge, to test whether the gate is too
+            # conservative. If these fill cleanly, the bound moves outward next campaign — but
+            # per the brief, disagreement only ever steps the bounds INWARD, never outward,
+            # so a clean probe is recorded as evidence, not acted on unilaterally.
+            add(
+                "P1",
+                "probe_outside",
+                wide["melt_C"][0],
+                centre["wall_C"],
+                wide["flow_cm3_s"][0],
+                note="coldest melt + slowest flow: the freeze-off corner, outside the green edge",
+            )
+            add(
+                "P2",
+                "probe_outside",
+                wide["melt_C"][0],
+                wide["wall_C"][0],
+                wide["flow_cm3_s"][0],
+                note="coldest everything: worst case in the wide box",
+            )
+            add(
+                "P3",
+                "probe_outside",
+                centre["melt_C"],
+                centre["wall_C"],
+                wide["flow_cm3_s"][1],
+                note="fastest flow: shear/pressure edge rather than the thermal edge",
+            )
+            # Switchover is a genuinely swept variable here (D2).
+            for phi in SWITCHOVER_VARIANTS:
+                add(
+                    f"S_{int(phi * 100)}",
+                    "switchover",
+                    centre["melt_C"],
+                    centre["wall_C"],
+                    centre["flow_cm3_s"],
+                    phi_s=phi,
+                    note=f"centre with velocity-to-pressure switchover at phi={phi}",
+                )
+
+            print(
+                f"\n  {len(pts)} confirmation points "
+                f"({sum(1 for p in pts if p['role'] == 'face')} face, "
+                f"{sum(1 for p in pts if p['role'] == 'probe_outside')} outside-probes, "
+                f"{sum(1 for p in pts if p['role'] == 'switchover')} switchover)"
+            )
+
+            # ---- build + validate every deck -----------------------------
+            deck_dir = runs_dir / STAGE
+            results = []
+            for p in pts:
+                # Unit-checked: the AI side is Kelvin, the rm1 builder is Celsius.
+                proc = Process(melt_C=p["melt_C"], wall_C=p["wall_C"], flow_cm3_s=p["flow_cm3_s"], volume_cm3=vol)
+                rm1 = deck_dir / f"{p['id']}.rm1"
+                bi = build_deck(
+                    out=rm1,
+                    parts=parts,
+                    material=raw_mat,
+                    gate_mm=info["gates_mm"][0],
+                    melt_C=proc.melt_C,
+                    wall_C=proc.wall_C,
+                    rate_cm3_s=proc.flow_cm3_s,
+                    phi_s=p["phi_s"],
+                    hold_bar=p["hold_bar"],
+                    hold_s=p["hold_s"],
+                    cool_s=p["cool_s"],
+                )
+                val = validate_deck(
+                    rm1,
+                    {"melt_C": proc.melt_C, "wall_C": proc.wall_C, "phi_s": p["phi_s"], "rate_cm3_s": proc.flow_cm3_s},
+                )
+                results.append(
+                    {
+                        **p,
+                        "fill_time_s": proc.fill_time_s,
+                        "rm1": str(rm1.relative_to(runs_dir)),
+                        "build": bi,
+                        "validation": val,
+                        "submit": {
+                            "endpoint": "cadmould.cloud.simulation.create_simulation",
+                            "rest": "POST /api/v1/simulations then .../submit",
+                            "tier": 1,
+                            "poll_interval_s": 15,
+                            "timeout_s": 7200,
+                            "status": "prepared",
+                        },
+                    }
+                )
+                ok = "OK " if val.get("all_ok") else "FAIL"
+                print(
+                    f"    {ok} {p['id']:16s} melt {proc.melt_C:6.1f}C wall {proc.wall_C:5.1f}C "
+                    f"Q {proc.flow_cm3_s:6.3f} phi_s {p['phi_s']:.2f}  "
+                    f"{bi['bytes'] / 1000:6.1f} kB" + ("" if val.get("all_ok") else f"  {val}")
+                )
+
+        n_ok = sum(1 for r in results if r["validation"].get("all_ok"))
+        n_pack = sum(1 for r in results if r["build"]["packing_in_deck"])
+        print(f"\n  {n_ok}/{len(results)} decks validated by Rm1Writer -> Rm1Reader round trip")
+        print(f"  {n_pack}/{len(results)} decks carry the packing profile")
+        if n_pack == 0:
+            print(
+                "  NOTE: packing is unlicensed here (LICENCE_PACK) — decks are fill-only and the "
+                "holding-pressure/cooling variables are recorded in the specs only."
+            )
+
+        out = {
+            "stage": STAGE,
+            "generated_at": datetime.now(UTC).isoformat(),
+            "mesh": "same_as_ai_runs",
+            "cfex": str(info["cfex"].name),
+            "geometry_id_ai": info["geometry_id"],
+            "material": {
+                "plb": info["cfg"]["material"]["plb"],
+                "is_placeholder": bool(info["cfg"]["material"].get("is_placeholder")),
+            },
+            "pack_nominal": {
+                "source": "tools.suggest_pack_profile",
+                "steps_bar_s": pk_steps,
+                "peak_bar": hold_bar,
+                "total_s": hold_s,
+            },
+            "cooling_nominal_s": {"value": cool_s, "source": "tools.suggest_cooling_time"},
+            "switchover_variants": list(SWITCHOVER_VARIANTS),
+            "inward_only_rule": (
+                "Where a numerical result disagrees with the AI ordering, step the bounds INWARD, never outward."
+            ),
+            "validation_summary": {"decks": len(results), "round_trip_ok": n_ok, "with_packing": n_pack},
+            "points": results,
+        }
+        (stage_dir / "g4_confirmation.json").write_text(json.dumps(out, indent=2))
+        print(f"  wrote {(stage_dir / 'g4_confirmation.json').relative_to(ROOT)}")
+
+        campaign.note(
+            f"G4: {len(results)} numerical confirmation decks built on the SAME mesh as the AI runs "
+            f"({n_ok}/{len(results)} validated by rm1 write->read round trip). Centre + "
+            f"{sum(1 for p in pts if p['role'] == 'face')} face points + "
+            f"{sum(1 for p in pts if p['role'] == 'probe_outside')} deliberate probes outside the "
+            f"green edge + {len(SWITCHOVER_VARIANTS)} switchover settings. Packing "
+            f"{'included' if n_pack else 'NOT licensed here, recorded in specs only'}; cooling "
+            f"{cool_s:.2f} s from tools.suggest_cooling_time. Decks are prepared, not submitted."
+        )
+    finally:
+        info["api"].close()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

simcon_toolkit/_kit/templates/process-window/process_window/run_epsilon_floor.py

@@ -0,0 +1,198 @@
+"""Derive THIS part's resolution floor per KPI, empirically.
+
+Guardrail 2 forbids importing the reference campaign's ±1.2 bar / 2 bar figures — they are
+part-specific. So: perturb the inputs by amounts no machine could resolve (0.02–0.10 K on
+temperatures, 0.02–0.1 % on flow — two orders of magnitude below what a production machine
+holds) and measure how far each KPI moves. That spread is the floor below which an apparent
+effect is not an effect.
+
+What this is not. The solver is deterministic, so there is no run-to-run scatter and a zero
+perturbation would return a bit-identical result. The spread measured here is **float16 storage
+quantization of the result fields plus the model's own conditioning** — a genuine resolution
+floor, but not something more runs could average away. The dossier must say so; calling it
+"noise" invites exactly the wrong inference.
+
+Run:  python main.py epsilon-floor [configs/simple-plate.yaml]
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from datetime import UTC, datetime
+from pathlib import Path
+
+import numpy as np
+
+from .design import epsilon_design
+from .harness import RunSpec
+from .setup_campaign import build, resolve_config
+
+ROOT = Path(__file__).resolve().parents[1]
+
+STAGE = "G1a_epsilon_floor"
+
+# KPIs the floor is derived for, with the unit each is reported in. p80 is the only one in
+# physical units; the rest are dimensionless by construction (guardrail 1).
+KPI_UNITS = {
+    "p80_bar": "bar",
+    "no_flow_margin": "-",
+    "no_flow_margin_K": "K",
+    "no_flow_margin_end_K": "K",
+    "frozen_fraction_end": "-",
+    "weld_front_temp_K": "K",
+    "weld_front_temp_ratio": "-",
+    "hotspot": "-",
+    "fill_residual": "-",
+}
+
+
+def summarise(records) -> dict:
+    """Per-KPI spread across the epsilon set, plus the input span that produced it."""
+    vals: dict[str, list[float]] = {k: [] for k in KPI_UNITS}
+    for r in records:
+        if not r.ok:
+            continue
+        for k in KPI_UNITS:
+            v = r.kpis.get(k)
+            if v is not None and np.isfinite(v):
+                vals[k].append(float(v))
+
+    out: dict[str, dict] = {}
+    for k, unit in KPI_UNITS.items():
+        a = np.asarray(vals[k], dtype=float)
+        if a.size < 3:
+            out[k] = {
+                "basis": "derived",
+                "n_runs": int(a.size),
+                "floor": None,
+                "unit": unit,
+                "note": "too few successful runs",
+            }
+            continue
+        rng = float(a.max() - a.min())
+        out[k] = {
+            "basis": "derived",
+            "n_runs": int(a.size),
+            "unit": unit,
+            # The floor is the full observed range, not a standard deviation: with a
+            # deterministic solver this is a bound on how far the output can move for an input
+            # change that means nothing, and a bound is what an inert-variable test needs.
+            "floor": round(rng, 6),
+            "range": [round(float(a.min()), 6), round(float(a.max()), 6)],
+            "median": round(float(np.median(a)), 6),
+            "std": round(float(a.std(ddof=1)), 6),
+            "rel_floor_pct": (round(100.0 * rng / abs(float(np.median(a))), 4) if np.median(a) else None),
+        }
+    return out
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description="G1a resolution floor")
+    ap.add_argument(
+        "config",
+        nargs="?",
+        help="campaign config; defaults to configs/simple-plate.yaml while that is unambiguous",
+    )
+    args = ap.parse_args()
+    cfg_path = resolve_config(args.config)
+    campaign, info = build(cfg_path)
+    try:
+        centre = {
+            "melt_C": info["card"].melt.rec_C,
+            "wall_C": info["card"].mould.rec_C,
+            "flow_cm3_s": info["nominal_flow_cm3_s"],
+        }
+        print(
+            f"\n  centre: melt {centre['melt_C']:.1f} C, wall {centre['wall_C']:.1f} C, "
+            f"Q {centre['flow_cm3_s']:.2f} cm3/s"
+        )
+
+        pts = epsilon_design(centre)
+        specs = [
+            RunSpec(
+                melt_C=p["melt_C"],
+                wall_C=p["wall_C"],
+                flow_cm3_s=p["flow_cm3_s"],
+                stage=STAGE,
+                label=p["label"],
+                keep_h5=(p["kind"] == "nominal"),  # keep the nominal as an anchor
+                meta={"kind": p["kind"]},
+            )
+            for p in pts
+        ]
+        print(
+            f"  {len(specs)} epsilon points (perturbations <= 0.1 K and <= 0.1 % — "
+            "two orders of magnitude below machine control)"
+        )
+
+        records = campaign.run_batch(
+            specs,
+            stage=STAGE,
+            max_workers=int(info["cfg"]["solver"]["max_concurrency"]),
+            description="Epsilon-input micro experiment: physically meaningless input deltas, "
+            "to derive this part's per-KPI resolution floor (guardrail 2).",
+        )
+
+        floor = summarise(records)
+        print("\n  derived floor per KPI:")
+        for k, d in floor.items():
+            if d.get("floor") is None:
+                print(f"    {k:22s} n={d['n_runs']:2d}  (insufficient)")
+                continue
+            rel = f"{d['rel_floor_pct']:.3f}%" if d["rel_floor_pct"] is not None else "n/a"
+            print(
+                f"    {k:22s} floor={d['floor']:<12.6g} {d['unit']:4s} "
+                f"(median {d['median']:.4g}, rel {rel}, n={d['n_runs']})"
+            )
+
+        out = {
+            "stage": STAGE,
+            "generated_at": datetime.now(UTC).isoformat(),
+            "method": "epsilon_input_micro_experiment",
+            "mechanism": (
+                "Solver is deterministic; this is float16 storage quantization of the "
+                "result fields plus model conditioning, NOT run-to-run scatter. "
+                "Replicates carry zero information."
+            ),
+            "perturbations": {"melt_K": [0.02, 0.05, 0.10], "wall_K": [0.02, 0.05, 0.10], "flow_rel": [2e-4, 1e-3]},
+            "justification": (
+                "A production machine holds melt to ~+/-1-2 K and mould to ~+/-1 K; "
+                "these deltas are two orders of magnitude smaller, so any output "
+                "movement they cause cannot be a real process effect."
+            ),
+            "centre": centre,
+            "per_kpi": floor,
+            "runs": [
+                {
+                    "run_id": r.run_id,
+                    "label": r.spec.get("label"),
+                    "kind": (r.spec.get("meta") or {}).get("kind"),
+                    "simulation_id": r.simulation_id,
+                    "ok": r.ok,
+                    "error": r.error or None,
+                    "kpis": {k: (r.kpis or {}).get(k) for k in KPI_UNITS} if r.ok else None,
+                }
+                for r in records
+            ],
+        }
+        dest = info["stage_dir"] / "noise_floor.json"
+        dest.write_text(json.dumps(out, indent=2))
+        print(f"\n  wrote {dest.relative_to(ROOT)}")
+
+        p80 = floor.get("p80_bar", {})
+        if p80.get("floor") is not None:
+            campaign.note(
+                f"Noise floor DERIVED for this part from {p80['n_runs']} epsilon-input runs "
+                f"(perturbations <=0.1 K / <=0.1 %): p80 floor = {p80['floor']:.3g} bar "
+                f"({p80['rel_floor_pct']:.3g} % of median). Mechanism is float16 quantization + "
+                f"model conditioning, not scatter — the solver is deterministic. Reference "
+                f"campaign's +/-1.2 bar / 2 bar figures deliberately NOT imported (guardrail 2)."
+            )
+    finally:
+        info["api"].close()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())