simcon-toolkit 0.1.0__py3-none-any.whl

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

@@ -0,0 +1,163 @@
+"""The material card: processing window, no-flow temperature, and the wide box.
+
+`ProcessTemperatures` on a `.plb` reads in **Kelvin** while the SDK's rm1 builder takes
+**Celsius**. Both live inside the same SDK, so a value read from the card and handed to
+`with_material(melt_temp=...)` is wrong by 273.15 K and still produces a valid-looking deck.
+This module is the only place the card is read, it converts once, and it exposes both units
+so nothing downstream has to know.
+
+It also builds the wide box, because the box *is* a material property here: temperature is an
+interval scale, so "±50 %" of it is not a well-defined instruction, and the card's own processing
+window is the honest wide box.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+import cadmould
+from cadmould import material as _cm_material
+
+from .units import K_to_degC, UnitError
+
+
+@dataclass(frozen=True)
+class Window:
+    """One variable's bounds, in both units, with the nominal centre."""
+
+    lo_C: float
+    rec_C: float
+    hi_C: float
+
+    @property
+    def lo_K(self) -> float:
+        return self.lo_C + 273.15
+
+    @property
+    def rec_K(self) -> float:
+        return self.rec_C + 273.15
+
+    @property
+    def hi_K(self) -> float:
+        return self.hi_C + 273.15
+
+    @property
+    def span_K(self) -> float:
+        return self.hi_C - self.lo_C
+
+    def rel_span_of_rec(self, unit: str) -> float:
+        """Half-width as a fraction of the nominal, in the given unit.
+
+        Reported in both units precisely because the answer differs — which is the whole
+        argument for not expressing a temperature box as a percentage.
+        """
+        half = 0.5 * (self.hi_C - self.lo_C)
+        if unit == "degC":
+            return half / self.rec_C
+        if unit == "K":
+            return half / self.rec_K
+        raise UnitError(f"unit must be 'degC' or 'K', got {unit!r}")
+
+
+@dataclass(frozen=True)
+class MaterialCard:
+    name: str
+    group: int
+    manufacturer: str
+    melt: Window
+    mould: Window
+    no_flow_C: float
+    source: Path
+
+    @property
+    def no_flow_K(self) -> float:
+        return self.no_flow_C + 273.15
+
+    def describe(self) -> str:
+        return (
+            f"{self.name} ({self.manufacturer})\n"
+            f"  melt  {self.melt.lo_C:6.1f} .. {self.melt.rec_C:6.1f} .. {self.melt.hi_C:6.1f} degC"
+            f"   (+/-{self.melt.rel_span_of_rec('degC') * 100:.1f}% in degC,"
+            f" +/-{self.melt.rel_span_of_rec('K') * 100:.1f}% in K)\n"
+            f"  mould {self.mould.lo_C:6.1f} .. {self.mould.rec_C:6.1f} .. {self.mould.hi_C:6.1f} degC"
+            f"   (+/-{self.mould.rel_span_of_rec('degC') * 100:.1f}% in degC,"
+            f" +/-{self.mould.rel_span_of_rec('K') * 100:.1f}% in K)\n"
+            f"  no-flow {self.no_flow_C:.1f} degC ({self.no_flow_K:.2f} K)\n"
+            f"  usable melt superheat: {self.melt.rec_C - self.no_flow_C:.1f} K above no-flow"
+        )
+
+
+def load(plb_path: str | Path, *, session_open: bool = False) -> MaterialCard:
+    """Read a `.plb` material card. Opens a licence session unless one is already held."""
+    plb_path = Path(plb_path)
+    if not plb_path.exists():
+        # A .plb is a licensed Cadmould material file, so none can ship with this template.
+        # Say what to supply and where, rather than raising a bare path nobody can act on.
+        raise FileNotFoundError(
+            f"Material card not found: {plb_path}\n"
+            "A .plb is a licensed Cadmould material file and cannot be distributed with this\n"
+            "template, so you have to supply your own. Export one from Cadmould, then either\n"
+            f"  - save it as {plb_path}, or\n"
+            "  - point `material.plb` in your config at wherever you keep it.\n"
+            "The card sets the melt and wall windows the whole campaign is designed inside,\n"
+            "so setup reads it before any stage runs; there is no way to skip it."
+        )
+
+    def _read():
+        m = _cm_material.io.PlbReader().load(str(plb_path))
+        t = m.process_temperatures
+        # The card is in Kelvin. K_to_degC range-checks the result, so a card that were
+        # actually in Celsius would fail here loudly instead of being silently accepted.
+        return MaterialCard(
+            name=str(m.name),
+            group=int(m.group),
+            manufacturer=str(m.manufacturer),
+            melt=Window(
+                K_to_degC(t.melt_min, what="melt min"),
+                K_to_degC(t.melt_rec, what="melt rec"),
+                K_to_degC(t.melt_max, what="melt max"),
+            ),
+            mould=Window(
+                K_to_degC(t.mold_min, what="wall min"),
+                K_to_degC(t.mold_rec, what="wall rec"),
+                K_to_degC(t.mold_max, what="wall max"),
+            ),
+            no_flow_C=K_to_degC(t.no_flow_temp, what="wall no-flow"),
+            source=plb_path,
+        )
+
+    if session_open:
+        return _read()
+    with cadmould.Session.user_based():
+        return _read()
+
+
+def wide_box(card: MaterialCard, *, nominal_flow_cm3_s: float, flow_rel_span: float = 0.50) -> dict:
+    """The G1 wide box: card window for temperatures, nominal ±rel_span for flow.
+
+    Temperatures get the card's full processing window rather than a percentage, because a
+    percentage of a temperature depends on whether it is written in K or °C (D3). Flow rate
+    is a ratio scale with a true zero, so ±50 % on it is unambiguous.
+    """
+    return {
+        "melt_C": (card.melt.lo_C, card.melt.hi_C),
+        "wall_C": (card.mould.lo_C, card.mould.hi_C),
+        "flow_cm3_s": (nominal_flow_cm3_s * (1.0 - flow_rel_span), nominal_flow_cm3_s * (1.0 + flow_rel_span)),
+        "basis": {
+            "melt_C": "material_card",
+            "wall_C": "material_card",
+            "flow_cm3_s": f"nominal_ratio(+/-{flow_rel_span:.0%})",
+        },
+        "centre_C": {"melt_C": card.melt.rec_C, "wall_C": card.mould.rec_C, "flow_cm3_s": nominal_flow_cm3_s},
+    }
+
+
+if __name__ == "__main__":
+    import sys
+
+    # No default path: no .plb ships, so guessing one only produces a confusing miss.
+    if len(sys.argv) < 2:
+        raise SystemExit("usage: material_card.py <path-to-your.plb>")
+    card = load(sys.argv[1])
+    print(card.describe())

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

@@ -0,0 +1,169 @@
+"""Which no-flow proxy actually discriminates? Test on box corners before re-running 1 024 runs.
+
+F15 defined a trigger: if the at-arrival no-flow margin never approaches the gate, the proxy is
+too weak and a channel-closure reading should replace it. That trigger has fired (minimum margin
+32.9 K against a 15 K gate over 250 runs). Adding a KPI means re-scoring, and raw results are
+discarded by policy, so it costs a full re-run of the sweep.
+
+So test it first, on the handful of points where the proxies must differ most: the extreme corners
+of the box. Six runs, raw results kept, all candidate readings computed side by side. Cheap, and it
+answers the question instead of assuming it.
+
+Candidate readings, all forms of "distance to the material's no-flow temperature":
+  A  core T at ARRIVAL, min over nodes          - the current KPI
+  B  core T at END OF FILL, min over nodes      - channel closure, but extremum-fragile
+  C  core T at END OF FILL, 5th percentile      - channel closure, robust
+  D  core T at END OF FILL, 1st percentile      - between B and C
+  E  fraction of filled nodes below no-flow     - a count, not a distance (scope-flagged)
+
+Run:  python main.py probe configs/simple-plate.yaml
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import h5py
+import numpy as np
+
+from . import kpis as K
+from .harness import RunSpec
+from .setup_campaign import build, resolve_config
+
+ROOT = Path(__file__).resolve().parents[1]
+
+STAGE = "G1b_proxy_probe"
+
+
+def readings(h5: Path, no_flow_K: float) -> dict:
+    with h5py.File(h5, "r") as h:
+        steps = K._steps(h)
+        _t, arr, reached, _f = K._fill_state(h)
+        core = K._core_temp_series(h, steps)
+    filled = arr >= 0
+    idx = np.where(filled)[0]
+    at_arr = core[arr[filled], idx]
+    at_arr = at_arr[np.isfinite(at_arr)]
+    end = core[-1][filled]
+    end = end[np.isfinite(end)]
+
+    worst = np.full(reached.size, np.inf)
+    for i in range(len(steps)):
+        m = (arr >= 0) & (arr <= i)
+        worst[m] = np.minimum(worst[m], core[i][m])
+    w = worst[np.isfinite(worst)]
+
+    return {
+        "reached_pct": round(100.0 * float(reached.mean()), 3),
+        "A_arrival_min_K": round(float(at_arr.min()) - no_flow_K, 2),
+        "B_end_min_K": round(float(end.min()) - no_flow_K, 2),
+        "C_end_p5_K": round(float(np.percentile(end, 5)) - no_flow_K, 2),
+        "D_end_p1_K": round(float(np.percentile(end, 1)) - no_flow_K, 2),
+        "E_frac_below_nf_pct": round(100.0 * float((end < no_flow_K).mean()), 4),
+        "F_worst_min_K": round(float(w.min()) - no_flow_K, 2),
+        "G_worst_p1_K": round(float(np.percentile(w, 1)) - no_flow_K, 2),
+    }
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description="G1b feasibility-proxy probe")
+    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:
+        box = info["box"]
+        m_lo, m_hi = box["melt_C"]
+        w_lo, w_hi = box["wall_C"]
+        q_lo, q_hi = box["flow_cm3_s"]
+        nf = info["card"].no_flow_K
+
+        # Corners chosen so the proxies must separate if they separate at all: the coldest and
+        # slowest combination is the freeze-off worst case, the hottest and fastest the best.
+        pts = [
+            ("worst  cold+cold+slow", m_lo, w_lo, q_lo),
+            ("cold melt, slow      ", m_lo, w_hi, q_lo),
+            ("cold mould, slow     ", m_hi, w_lo, q_lo),
+            ("nominal-ish          ", (m_lo + m_hi) / 2, (w_lo + w_hi) / 2, (q_lo + q_hi) / 2),
+            ("hot, fast            ", m_hi, w_hi, q_hi),
+            ("best   hot+hot+fast  ", m_hi, w_hi, q_hi * 1.0),
+        ]
+        seen, specs = set(), []
+        for label, m, w, q in pts:
+            key = (round(m, 4), round(w, 4), round(q, 4))
+            if key in seen:
+                continue
+            seen.add(key)
+            specs.append(
+                RunSpec(
+                    melt_C=float(m),
+                    wall_C=float(w),
+                    flow_cm3_s=round(float(q), 4),
+                    stage=STAGE,
+                    label=label.strip(),
+                    keep_h5=True,
+                    meta={"probe": label.strip()},
+                )
+            )
+
+        print(f"\n  {len(specs)} corner probes, raw results KEPT so all readings can be compared")
+        recs = campaign.run_batch(
+            specs,
+            stage=STAGE,
+            max_workers=3,
+            description="Proxy probe: which no-flow reading discriminates at the box corners (F15 trigger).",
+        )
+
+        rows = []
+        for r in recs:
+            if not r.ok or not r.h5_kept:
+                print(f"    {r.spec.get('label')}: no kept h5 ({r.error or 'n/a'})")
+                continue
+            d = readings(info["runs_dir"] / r.h5_kept, nf)
+            d["label"] = r.spec["label"]
+            d["melt_C"] = r.spec["melt_C"]
+            d["wall_C"] = r.spec["wall_C"]
+            d["flow_cm3_s"] = r.spec["flow_cm3_s"]
+            d["fill_time_s"] = round(info["volume_cm3"] / r.spec["flow_cm3_s"], 4)
+            rows.append(d)
+
+        keys = [
+            "A_arrival_min_K",
+            "B_end_min_K",
+            "C_end_p5_K",
+            "D_end_p1_K",
+            "F_worst_min_K",
+            "G_worst_p1_K",
+            "E_frac_below_nf_pct",
+        ]
+        print(f"\n  {'point':22s} {'t_fill':>7s} " + " ".join(f"{k.split('_')[0]:>7s}" for k in keys))
+        for d in sorted(rows, key=lambda x: x["flow_cm3_s"]):
+            print(f"  {d['label'][:22]:22s} {d['fill_time_s']:7.3f} " + " ".join(f"{d[k]:7.1f}" for k in keys))
+
+        print("\n  discrimination (max - min across probes; bigger = more useful):")
+        floor = json.loads((info["stage_dir"] / "noise_floor.json").read_text())["per_kpi"]
+        f_gate = floor["no_flow_margin_K"]["floor"]
+        for k in keys:
+            v = np.array([d[k] for d in rows], float)
+            rng = float(v.max() - v.min())
+            unit = "%" if k.startswith("E") else "K"
+            extra = "" if k.startswith("E") else f"  = {rng / f_gate:5.1f} x floor"
+            print(f"    {k:22s} {v.min():8.2f} .. {v.max():8.2f} {unit}  range {rng:7.2f}{extra}")
+
+        (info["stage_dir"] / "proxy_probe.json").write_text(
+            json.dumps({"no_flow_K": nf, "floor_no_flow_margin_K": f_gate, "probes": rows}, indent=2)
+        )
+        print(f"\n  wrote {(info['stage_dir'] / 'proxy_probe.json').relative_to(ROOT)}")
+    finally:
+        info["api"].close()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())