simcon-toolkit 0.1.0__py3-none-any.whl

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

@@ -0,0 +1,367 @@
+"""Which point is cheapest to produce at? Cycle time against robustness.
+
+**Read this before quoting any number out of it.** Cost per part for a 32-cavity medical tool is
+dominated by cycle time and by scrap. The fill-phase sweep answers neither directly:
+
+  * **Cycle time is dominated by COOLING, which the AI solver does not model at all.** Cooling time
+    is computed here analytically, from the material card's own thermal data, using the *same*
+    slab-conduction form that was cross-checked against the campaign to 8.3 % (F17/F20). That is
+    the only reason it is defensible to put a cycle time on the page — and it is still an estimate,
+    not a simulation.
+  * **Scrap is not modelled either.** Rather than invent a scrap-rate curve, robustness is
+    expressed as the freeze-off margin that survives realistic machine drift, and the economic
+    answer is stated as "cheapest point that keeps that margin", with the drift assumptions
+    exposed as inputs.
+
+The interesting result is structural: the dominant cycle-time lever is **mould temperature**, which
+the fill-phase screening ranked last of the three variables. A fill-phase DOE alone cannot find the
+economic optimum, and saying so is more useful than pretending otherwise.
+
+Run:  python main.py economics 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 . import surrogate as S
+from .run_screening import (
+    GATE_KPI,
+    NO_FLOW_END_MIN_K,
+    VARS,
+    load_records,
+)
+from .setup_campaign import (
+    load_config,
+    resolve_config,
+    runs_dir_for,
+    stage_dir_for,
+)
+
+ROOT = Path(__file__).resolve().parents[1]
+
+# ---------------------------------------------------------------------------
+# Assumptions, all stated so they can be argued with.
+# ---------------------------------------------------------------------------
+N_CAVITIES = 32  # the real tool; we simulated 1 (F21)
+HANDLING_S = 2.0  # mould open + eject + close. Not modelled anywhere; a constant, so it
+# shifts every cycle time equally and cannot change the optimum.
+# Realistic machine drift, the basis of the robustness test. A production machine holds melt to
+# roughly +/-2 K and mould water to about +/-1 K; screw metering repeats to well under a percent.
+DRIFT = {"melt_C": 2.0, "wall_C": 1.0, "flow_rel": 0.01}
+
+# The recommendation this script argues for. Stated as a constant so the report, the page and the
+# candidate table cannot drift apart from each other.
+RECOMMENDED = {"melt_C": 236.0, "wall_C": 20.0, "flow_cm3_s": 2.40}
+
+
+def cooling_time_s(
+    melt_C: float, wall_C: float, *, wall_mm: float, eject_K: float, lam: float, rho: float, cp: float
+) -> float:
+    """Time for the thickest section's core to fall from melt to ejection temperature.
+
+    One-term slab solution, the same form validated against the campaign's freeze-off boundary:
+        theta = (T_eject - T_wall) / (T_melt - T_wall)
+        theta = (4/pi) * exp(-(pi/2)^2 * Fo)   ->   Fo = -ln(theta*pi/4) / (pi/2)^2
+        t     = Fo * h^2 / alpha
+    The THICKEST section governs ejection, not the mean — a part is ejected when its slowest
+    region is rigid enough. Using the mean wall would under-state cooling roughly sixfold here.
+    """
+    alpha = lam / (rho * cp)
+    h = (wall_mm / 1000.0) / 2.0
+    theta = (eject_K - (wall_C + 273.15)) / ((melt_C + 273.15) - (wall_C + 273.15))
+    if not (0 < theta < 4 / np.pi):
+        return float("nan")
+    Fo = -np.log(theta * np.pi / 4) / (np.pi / 2) ** 2
+    return float(Fo * h * h / alpha)
+
+
+def cycle_time_s(melt_C, wall_C, flow, *, volume_cm3, pack_s, **cool_kw) -> float:
+    """fill + max(pack, cooling) + handling.
+
+    Packing runs *inside* the cooling phase — the part is cooling while it is being held — so the
+    two do not add. Whichever is longer sets the in-mould time.
+    """
+    fill = volume_cm3 / flow
+    cool = cooling_time_s(melt_C, wall_C, **cool_kw)
+    return fill + max(pack_s, cool) + HANDLING_S
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description="Cycle time vs robustness")
+    ap.add_argument(
+        "config",
+        nargs="?",
+        help="campaign config; defaults to configs/simple-plate.yaml while that is unambiguous",
+    )
+    ap.add_argument("--grid", type=int, default=33)
+    args = ap.parse_args()
+
+    cfg = load_config(resolve_config(args.config))
+    runs_dir, stage_dir = runs_dir_for(cfg), stage_dir_for(cfg)
+    g3 = json.loads((stage_dir / "g3_refinement.json").read_text())
+    floors = json.loads((stage_dir / "noise_floor.json").read_text())["per_kpi"]
+    con = json.loads((stage_dir / "g4_confirmation.json").read_text())
+    state = json.loads((runs_dir / "campaign_state.json").read_text())
+
+    # Material thermal data — from the catalogue, the same numbers used in F17/F20.
+    MAT = {"lam": 0.19, "rho": 750.0, "cp": 2500.0, "eject_K": 368.15}
+    WALL_MAX_MM = 1.788  # thickest measured section; the mesher reports it
+    volume_cm3 = state["volume_cm3"]
+    pack_s = con["pack_nominal"]["total_s"]
+
+    recs = load_records(runs_dir, "G1_wide_sweep") + load_records(runs_dir, "G3_refinement")
+    X = np.array([[r["spec"][v] for v in VARS] for r in recs], float)
+    y = np.array([r["kpis"][GATE_KPI] for r in recs], float)
+    yp = np.array([r["kpis"]["p80_bar"] for r in recs], float)
+    box = np.array([[X[:, i].min(), X[:, i].max()] for i in range(3)])
+    surr = S.fit(X, y, box, noise_floor=floors[GATE_KPI]["floor"])
+    surr_p = S.fit(X, yp, box, noise_floor=floors["p80_bar"]["floor"])
+    floor = floors[GATE_KPI]["floor"]
+    print(
+        f"  surrogate on {len(recs)} runs, LOO {100 * surr.loo_error()['nrmse_range']:.2f} %, "
+        f"gate {NO_FLOW_END_MIN_K} K, floor {floor:.3g} K"
+    )
+
+    rbox = {v: g3["recommended_box"][v] for v in VARS}
+    print("  searching the recommended box: " + ", ".join(f"{v} {rbox[v][0]:.3g}..{rbox[v][1]:.3g}" for v in VARS))
+
+    # ---- grid over the recommended box ---------------------------------
+    n = args.grid
+    axes = [np.linspace(rbox[v][0], rbox[v][1], n) for v in VARS]
+    M, W, Q = np.meshgrid(*axes, indexing="ij")
+    pts = np.stack([M.ravel(), W.ravel(), Q.ravel()], 1)
+
+    def predict(P):
+        u = (P - box[:, 0]) / (box[:, 1] - box[:, 0])
+        return surr.predict_unit(u)
+
+    nominal = predict(pts)
+
+    # ---- robustness: the margin that survives drift --------------------
+    # Worst corner of the drift box around each point. 8 corners in 3 variables; the margin is
+    # monotone enough in each variable that the worst case is a corner, and checking all 8 costs
+    # nothing.
+    worst = np.full(len(pts), np.inf)
+    for dm in (-DRIFT["melt_C"], DRIFT["melt_C"]):
+        for dw in (-DRIFT["wall_C"], DRIFT["wall_C"]):
+            for dq in (-DRIFT["flow_rel"], DRIFT["flow_rel"]):
+                P = pts.copy()
+                P[:, 0] += dm
+                P[:, 1] += dw
+                P[:, 2] *= 1 + dq
+                P = np.clip(P, box[:, 0], box[:, 1])
+                worst = np.minimum(worst, predict(P))
+
+    cyc = np.array(
+        [cycle_time_s(m, w, q, volume_cm3=volume_cm3, pack_s=pack_s, wall_mm=WALL_MAX_MM, **MAT) for m, w, q in pts]
+    )
+    p80 = surr_p.predict_unit((pts - box[:, 0]) / (box[:, 1] - box[:, 0]))
+
+    ok = worst >= NO_FLOW_END_MIN_K
+    print(
+        f"\n  {ok.sum()} of {len(pts)} grid points keep the gate under drift "
+        f"(melt +/-{DRIFT['melt_C']} K, wall +/-{DRIFT['wall_C']} K, "
+        f"flow +/-{DRIFT['flow_rel']:.0%})"
+    )
+
+    # ---- where does cycle time actually come from? ---------------------
+    print("\n  cycle-time sensitivity, one variable at a time from the box centre:")
+    mid = [(rbox[v][0] + rbox[v][1]) / 2 for v in VARS]
+    base = cycle_time_s(*mid, volume_cm3=volume_cm3, pack_s=pack_s, wall_mm=WALL_MAX_MM, **MAT)
+    sens = {}
+    for i, v in enumerate(VARS):
+        lo, hi = list(mid), list(mid)
+        lo[i], hi[i] = rbox[v][0], rbox[v][1]
+        a = cycle_time_s(*lo, volume_cm3=volume_cm3, pack_s=pack_s, wall_mm=WALL_MAX_MM, **MAT)
+        b = cycle_time_s(*hi, volume_cm3=volume_cm3, pack_s=pack_s, wall_mm=WALL_MAX_MM, **MAT)
+        sens[v] = abs(b - a)
+        print(
+            f"    {v:12s} {rbox[v][0]:7.3g} -> {rbox[v][1]:7.3g} : "
+            f"cycle {a:6.3f} -> {b:6.3f} s   swing {abs(b - a):5.3f} s"
+        )
+    print(
+        f"    baseline at box centre: {base:.3f} s (fill {volume_cm3 / mid[2]:.3f} + cool/pack + handling {HANDLING_S})"
+    )
+
+    # ---- the Pareto front ---------------------------------------------
+    print("\n  Pareto front — cheapest cycle at each robustness level:")
+    rows = []
+    for req in [NO_FLOW_END_MIN_K, 15, 20, 25, 30, 35, 40, 50]:
+        m = worst >= req
+        if not m.any():
+            continue
+        j = int(np.argmin(np.where(m, cyc, np.inf)))
+        rows.append(
+            {
+                "required_worst_margin_K": float(req),
+                "melt_C": round(float(pts[j, 0]), 2),
+                "wall_C": round(float(pts[j, 1]), 2),
+                "flow_cm3_s": round(float(pts[j, 2]), 4),
+                "cycle_s": round(float(cyc[j]), 3),
+                "fill_s": round(volume_cm3 / float(pts[j, 2]), 4),
+                "cool_s": round(cooling_time_s(float(pts[j, 0]), float(pts[j, 1]), wall_mm=WALL_MAX_MM, **MAT), 3),
+                "nominal_margin_K": round(float(nominal[j]), 2),
+                "worst_margin_K": round(float(worst[j]), 2),
+                "margin_in_floors": round(float(worst[j] - NO_FLOW_END_MIN_K) / floor, 2),
+                "p80_bar": round(float(p80[j]), 1),
+            }
+        )
+        r = rows[-1]
+        print(
+            f"    >= {req:4.0f} K : melt {r['melt_C']:6.1f} wall {r['wall_C']:5.1f} "
+            f"Q {r['flow_cm3_s']:6.3f} | cycle {r['cycle_s']:6.3f} s "
+            f"(cool {r['cool_s']:.2f}) | worst margin {r['worst_margin_K']:5.1f} K "
+            f"= {r['margin_in_floors']:5.2f} floors over the gate | p80 {r['p80_bar']:.0f} bar"
+        )
+
+    # ---- what actually opposes a cold, fast process? -------------------
+    # The freeze-off gate turns out NOT to oppose it: the cycle-optimal corner is also far from
+    # that boundary. So the trade-off, if there is one, must live in the quality KPIs. Fit them and
+    # compare candidate operating points on every KPI at once.
+    extra = {}
+    for kpi in ("weld_front_temp_K", "hotspot", "p80_bar"):
+        yy = np.array([r["kpis"].get(kpi) for r in recs], float)
+        m = np.isfinite(yy)
+        extra[kpi] = S.fit(X[m], yy[m], box, noise_floor=floors[kpi]["floor"])
+
+    def ev(sur, P):
+        return float(sur.predict_unit((np.array([P]) - box[:, 0]) / (box[:, 1] - box[:, 0]))[0])
+
+    cheapest = pts[int(np.argmin(np.where(ok, cyc, np.inf)))]
+    centre = np.array([float(g3["centre"][v]) for v in VARS])
+    # The recommendation. Mould at its minimum (the largest cycle lever, and near-inert for every
+    # fill KPI), flow near the top (buys robustness and a little cycle), melt high enough to recover
+    # most of the weld-front temperature the cold/fast corner gives away — see the front below.
+    cands = {
+        "RECOMMENDED": np.array([RECOMMENDED["melt_C"], RECOMMENDED["wall_C"], RECOMMENDED["flow_cm3_s"]]),
+        "cycle-optimal corner": cheapest,
+        "G3 robustness centre": centre,
+        "card nominal": np.array([240.0, 40.0, 1.6009]),
+        "slowest / hottest": np.array([rbox["melt_C"][1], rbox["wall_C"][1], rbox["flow_cm3_s"][0]]),
+    }
+    print("\n  candidate operating points on EVERY KPI (not just the gate):")
+    print(f"    {'point':22s} {'cycle':>7s} {'gate':>7s} {'weldT':>8s} {'hotspot':>8s} {'p80':>7s}")
+
+    def drifted(P):
+        w = np.inf
+        for dm in (-DRIFT["melt_C"], DRIFT["melt_C"]):
+            for dw in (-DRIFT["wall_C"], DRIFT["wall_C"]):
+                for dq in (-DRIFT["flow_rel"], DRIFT["flow_rel"]):
+                    Qp = np.clip([P[0] + dm, P[1] + dw, P[2] * (1 + dq)], box[:, 0], box[:, 1])
+                    w = min(w, ev(surr, Qp))
+        return w
+
+    cand_rows = []
+    for name, P in cands.items():
+        cyc_i = cycle_time_s(*P, volume_cm3=volume_cm3, pack_s=pack_s, wall_mm=WALL_MAX_MM, **MAT)
+        row = {
+            "point": name,
+            "melt_C": round(float(P[0]), 2),
+            "wall_C": round(float(P[1]), 2),
+            "flow_cm3_s": round(float(P[2]), 4),
+            "cycle_s": round(cyc_i, 3),
+            "gate_margin_K": round(ev(surr, P), 1),
+            "weld_front_temp_K": round(ev(extra["weld_front_temp_K"], P), 1),
+            "hotspot": round(ev(extra["hotspot"], P), 4),
+            "p80_bar": round(ev(extra["p80_bar"], P), 1),
+            "parts_per_hour": round(3600.0 / cyc_i * N_CAVITIES),
+            "gate_margin_drifted_K": round(drifted(P), 1),
+        }
+        cand_rows.append(row)
+        print(
+            f"    {name:22s} {row['cycle_s']:7.3f} {row['gate_margin_K']:7.1f} "
+            f"{row['weld_front_temp_K']:8.1f} {row['hotspot']:8.4f} {row['p80_bar']:7.1f}"
+        )
+    print("    (weldT higher = better bonding; hotspot lower = less differential shrinkage; p80 ordering only)")
+
+    # ---- the REAL trade-off: cycle time vs weld-front temperature ------
+    # Freeze-off does not oppose a cold, fast process, and neither does hotspot — a fast fill has
+    # less time to build thermal gradients, so it scores BETTER there. Weld-front temperature is the
+    # only KPI that genuinely opposes, because melt drives it almost 1:1. So that is the front worth
+    # drawing, and it is the trade the process engineer is actually making.
+    wt = extra["weld_front_temp_K"].predict_unit((pts - box[:, 0]) / (box[:, 1] - box[:, 0]))
+    hs = extra["hotspot"].predict_unit((pts - box[:, 0]) / (box[:, 1] - box[:, 0]))
+    print("\n  the real trade-off — cheapest cycle at each weld-front temperature:")
+    print(
+        f"    {'weldT >=':>10s} {'melt':>6s} {'wall':>5s} {'Q':>6s} {'cycle':>7s} "
+        f"{'gate':>6s} {'hotspot':>8s} {'p80':>6s}"
+    )
+    front = []
+    for req in [494, 498, 500, 502, 504, 506, 508, 509]:
+        m = ok & (wt >= req)
+        if not m.any():
+            continue
+        j = int(np.argmin(np.where(m, cyc, np.inf)))
+        r = {
+            "weld_req_K": req,
+            "melt_C": round(float(pts[j, 0]), 1),
+            "wall_C": round(float(pts[j, 1]), 1),
+            "flow_cm3_s": round(float(pts[j, 2]), 4),
+            "cycle_s": round(float(cyc[j]), 3),
+            "gate_margin_K": round(float(worst[j]), 1),
+            "hotspot": round(float(hs[j]), 4),
+            "p80_bar": round(float(p80[j]), 1),
+            "weld_front_temp_K": round(float(wt[j]), 1),
+        }
+        front.append(r)
+        print(
+            f"    {req:10.0f} {r['melt_C']:6.1f} {r['wall_C']:5.1f} {r['flow_cm3_s']:6.3f} "
+            f"{r['cycle_s']:7.3f} {r['gate_margin_K']:6.1f} {r['hotspot']:8.4f} "
+            f"{r['p80_bar']:6.1f}"
+        )
+
+    # ---- compare with the robustness centre ---------------------------
+    c = [float(g3["centre"][v]) for v in VARS]
+    c_cyc = cycle_time_s(*c, volume_cm3=volume_cm3, pack_s=pack_s, wall_mm=WALL_MAX_MM, **MAT)
+    c_worst = np.inf
+    for dm in (-DRIFT["melt_C"], DRIFT["melt_C"]):
+        for dw in (-DRIFT["wall_C"], DRIFT["wall_C"]):
+            for dq in (-DRIFT["flow_rel"], DRIFT["flow_rel"]):
+                P = np.array([[c[0] + dm, c[1] + dw, c[2] * (1 + dq)]])
+                P = np.clip(P, box[:, 0], box[:, 1])
+                c_worst = min(c_worst, float(predict(P)[0]))
+    print("\n  the G3 robustness centre, for comparison:")
+    print(f"    melt {c[0]:.1f} wall {c[1]:.1f} Q {c[2]:.3f} | cycle {c_cyc:.3f} s | worst margin {c_worst:.1f} K")
+
+    out = {
+        "generated_at": datetime.now(UTC).isoformat(),
+        "scope_warning": (
+            "Cycle time is NOT from the AI solver -- it does not model cooling. "
+            "Cooling is an analytic slab estimate from the material card, using the "
+            "same form cross-checked to 8.3 % against the campaign. Scrap is not "
+            "modelled at all; robustness stands in for it."
+        ),
+        "assumptions": {
+            "n_cavities_real_tool": N_CAVITIES,
+            "handling_s": HANDLING_S,
+            "pack_s": pack_s,
+            "wall_max_mm": WALL_MAX_MM,
+            "eject_temperature_K": MAT["eject_K"],
+            "drift": DRIFT,
+            "material_thermal": {k: MAT[k] for k in ("lam", "rho", "cp")},
+        },
+        "cycle_time_sensitivity_s": {k: round(v, 4) for k, v in sens.items()},
+        "pareto": rows,
+        "candidates": cand_rows,
+        "cycle_vs_weld_front": front,
+        "g3_robustness_centre": {
+            "melt_C": c[0],
+            "wall_C": c[1],
+            "flow_cm3_s": c[2],
+            "cycle_s": round(c_cyc, 3),
+            "worst_margin_K": round(c_worst, 2),
+        },
+    }
+    (stage_dir / "economics.json").write_text(json.dumps(out, indent=2))
+    print(f"\n  wrote {(stage_dir / 'economics.json').relative_to(ROOT)}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())