worlds/board-package/microstructure.py

"""C6 microstructure layer: declared link and measurement functions (pure numpy; no randomness except through the
generators callers pass). Shared by the physics tool C6 (ndfeb_physics_tool.py), the owner calibration
(fit/c6_calibrate.py) and the campaign twin. Nothing here changes a C5 quantity: every function reads C5 latents (the
model grain of a stage, the continuity index W, the body's relative density) and the C6 per-draw parameters c6_*.

Units: um, relative density (fraction of 7.62 g/cm3), fractions in [0, 1], seconds and deg C for the SPS trace.

A1  grain and feature size (per stage: as sintered, after 900 C/2 h, after 900 C/2 h + 520 C/2 h; the C5 grain law gives
    the 520 C step no growth, so the model grain after 900 equals the grain after 900 + 520)
    grain_sem_dist   log-normal grain distribution an SEM grain-size protocol would report: mean D_stage x c_m6 (D_stage
                     the C5 model grain, c_m6 the method factor), sigma_ln = c6_sig; median = mean x exp(-sigma^2 / 2);
                     d90 = median x exp(1.2816 sigma); coarse number fraction above a threshold t:
                     Phi((ln median - ln t) / sigma); a measured median carries field sampling (log-sd c6_sfield)
    fracture_intercept_um  mean linear intercept on a fracture SE image: D_stage x (2/3) x phi(rho) x c_m6 x exp(e),
                     2/3 the sphere stereology (the metrology's own d3 ~ 1.5 x intercept), phi(rho) the feature factor
                     (c6_phip below ~95 %TD, where fracture SE shows particles and ligaments, 1 for dense bodies; smooth
                     in rho over a 0.005 width), e field sampling ~ N(0, c6_sfield^2), independent per stage
    relief           lightly polished porous surfaces (relief class): D_stage x (2/3) x c6_phir x exp(e), log-sd 0.10;
                     relief-class observations only (they constrain c6_phir and nothing else)
A2  porosity_area_fraction_sem   BSE dark area fraction of a planar section: (1 - rho) x exp(c6_pbias + e),
                     e ~ N(0, 0.5^2) per reading; sections below RHO_PLANAR are not planar (no value)
A3  Nd-rich phase on a planar polished BSE section, latent per draw and stage (dW = W - 0.5, W the C5 continuity
    index as sintered; lam = 0 as sintered, c6_lam900 after 900, 1 after 900 + 520):
      nd_rich_area_fraction  exp(ln c6_vnd + ln(oxide factor) + c6_bf dW + lam c6_dfnd)  (Otsu basis, 26.98 nm/px)
      pocket_ecd_um          exp(ln c6_ecd0 + c6_becd dW + lam c6_decd)        (area-weighted ECD, +27.5 offset basis)
      pocket_share           sigmoid(c6_ps0 + c6_bps dW + lam c6_dps)           (thickness split, t = 0.20 um)
      elongated_share        sigmoid(c6_el0 + c6_bel dW + lam c6_del)           (aspect ratio >= 3)
      faint_line_coverage    sigmoid(c6_fl0 + c6_bfl dW + lam c6_dfl)           (T10 lines, 2.5 um intercept basis)
    the oxide factor is the C5 oxide term exp(-c5_kox x the C4 oxidation penalty), applied only for a declared
    feedstock (1 at 4 um, as in C5). Readings carry declared body-and-field scatter (A3_SCATTER; extra for a lossy
    20 kV JPEG). The anneal transition is paired: the same draw's as-sintered latent, shifted.
A4  sps_trace: descriptive SPS display trace (temperature, ram displacement, derived relative density) whose end state is
    the draw's C5 final density (README: "descriptive; densification kinetics not identified").
"""
from __future__ import annotations

import math

import numpy as np

C6_STAGES = ("as_sintered", "after_900", "after_900_520")
STAGE_ALIASES6 = {"900": "after_900", "900+520": "after_900_520"}
C6_PARAMS = ("c6_sig", "c6_cm6", "c6_phip", "c6_sfield", "c6_phir", "c6_pbias", "c6_vnd", "c6_bf", "c6_dfnd",
             "c6_ecd0", "c6_becd", "c6_decd", "c6_ps0", "c6_bps", "c6_dps", "c6_el0", "c6_bel", "c6_del", "c6_fl0",
             "c6_bfl", "c6_dfl", "c6_lam900")
A3_KEYS = ("nd_rich_area_fraction", "pocket_ecd_um", "pocket_share", "elongated_share", "faint_line_coverage")
A3_PARAMS = {"nd_rich_area_fraction": ("c6_vnd", "c6_bf", "c6_dfnd"), "pocket_ecd_um": ("c6_ecd0", "c6_becd", "c6_decd"),
             "pocket_share": ("c6_ps0", "c6_bps", "c6_dps"), "elongated_share": ("c6_el0", "c6_bel", "c6_del"),
             "faint_line_coverage": ("c6_fl0", "c6_bfl", "c6_dfl")}
KAPPA_ST = 2.0 / 3.0            # mean linear intercept / mean 3D size (spheres); the metrology's d3 ~ 1.5 x intercept
RHO_DENSE_FRACTURE = 0.95       # below ~95 %TD a fracture SE image shows particles and ligaments, not grains (C6_SPEC A1)
FRACTURE_TRANSITION_WIDTH = 0.005
RHO_PLANAR = 0.80               # declared: below 80 %TD a polished section is not planar (no BSE area fraction)
RHO_PLANAR_OBSERVED = 0.92      # the least dense planar section on record is at 92 %TD and the densest non-planar one at
                                # 76 %TD: sections between 0.80 and 0.92 are planar by declaration (no record)
Z90 = 1.2815515655446004
RELIEF_LOG_SD = 0.10            # declared: scatter of one relief-class reading (log-sd)
POROSITY_LOG_SD = 0.5           # C6_SPEC A2: the BSE dark fraction brackets rho-porosity only within a factor of 3-4
POROSITY_FLOOR = 0.002          # 1 - rho is floored here (C5 relative density can reach 1.02)
FL_FLOOR = 0.003                # detection floor of the faint-line coverage (false-positive level at T10)
ND_RICH_MAX = 0.5
# declared body-and-field scatter of one planar-section reading (one body, one field set): (scale, sd). Basis: the
# body-to-body contrasts of the historical and campaign images at near-identical routes, which W alone does not explain
A3_SCATTER = {"nd_rich_area_fraction": ("log", 0.25), "pocket_ecd_um": ("log", 0.40), "pocket_share": ("logit", 0.5),
              "elongated_share": ("logit", 0.4), "faint_line_coverage": ("logfloor", 1.0)}
# extra scatter of a lossy 20 kV JPEG (D's only image: larger interaction volume, upsampled frame), added in quadrature
IMAGE_EXTRA = {"native": {"log": 0.0, "logit": 0.0, "logfloor": 0.0},
               "jpeg_20kV": {"log": 0.35, "logit": 0.5, "logfloor": 0.5}}


def stage6(s):
    s = STAGE_ALIASES6.get(s, s)
    if s not in C6_STAGES:
        raise ValueError(f"stage must be one of {C6_STAGES} ('900' and '900+520' are accepted)")
    return s


def sigmoid(x):
    return 1.0 / (1.0 + np.exp(-np.asarray(x, float)))


def logit(p):
    p = np.clip(np.asarray(p, float), 1e-6, 1.0 - 1e-6)
    return np.log(p / (1.0 - p))


def std_normal_cdf(z):
    z = np.asarray(z, float)
    return 0.5 * np.frompyfunc(math.erfc, 1, 1)(-z / math.sqrt(2.0)).astype(float)


def stage_lambda(p, stage):
    """Share of the 900 + 520 C visible transition present at `stage` (0 as sintered, c6_lam900 after 900, 1 after
    900 + 520), per draw."""
    stage = stage6(stage)
    lam = np.asarray(p["c6_lam900"], float)
    if stage == "as_sintered":
        return np.zeros_like(lam)
    if stage == "after_900":
        return lam
    return np.ones_like(lam)


# ------------------------------------------------------------------------------------------------------------- A1
def feature_factor(p, rho):
    """phi(rho): c6_phip on porous bodies (fracture SE shows particles and ligaments), 1 on dense ones, smooth in ln."""
    s = sigmoid((np.asarray(rho, float) - RHO_DENSE_FRACTURE) / FRACTURE_TRANSITION_WIDTH)
    return np.exp(np.log(np.asarray(p["c6_phip"], float)) * (1.0 - s))


def fracture_latent(p, D, rho):
    """Mean fracture-SE intercept (um) before field sampling: D x 2/3 x phi(rho) x c_m6."""
    return np.asarray(D, float) * KAPPA_ST * feature_factor(p, rho) * np.asarray(p["c6_cm6"], float)


def relief_latent(p, D):
    return np.asarray(D, float) * KAPPA_ST * np.asarray(p["c6_phir"], float)


def grain_median(p, D):
    """Median of the SEM-protocol grain distribution: mean D x c_m6, median = mean x exp(-sigma^2 / 2)."""
    s = np.asarray(p["c6_sig"], float)
    return np.asarray(D, float) * np.asarray(p["c6_cm6"], float) * np.exp(-0.5 * s * s)


def d90(median, sigma):
    return np.asarray(median, float) * np.exp(Z90 * np.asarray(sigma, float))


def coarse_fraction(median, sigma, threshold_um):
    """Number fraction of grains above threshold_um under the log-normal (median, sigma)."""
    t = float(threshold_um)
    return std_normal_cdf((np.log(np.asarray(median, float)) - math.log(t)) / np.asarray(sigma, float))


# ------------------------------------------------------------------------------------------------------------- A2
def planar(rho):
    return np.asarray(rho, float) >= RHO_PLANAR


def porosity_latent(rho):
    return np.clip(1.0 - np.asarray(rho, float), POROSITY_FLOOR, 1.0)


# ------------------------------------------------------------------------------------------------------------- A3
def a3_latent_one(p, W, lam, key, oxide_factor=None):
    """Latent A3 quantity `key` for draws with continuity W and stage share lam (0 as sintered, 1 after 900 + 520);
    p needs only that key's three parameters (A3_PARAMS[key]). Arrays broadcast."""
    a, b, d = (np.asarray(p[k], float) for k in A3_PARAMS[key])
    dW = np.asarray(W, float) - 0.5
    lam = np.asarray(lam, float)
    if key == "nd_rich_area_fraction":
        lnf = np.log(a) + b * dW + lam * d
        if oxide_factor is not None:
            lnf = lnf + np.log(np.maximum(np.asarray(oxide_factor, float), 1e-12))
        return np.minimum(np.exp(lnf), ND_RICH_MAX)
    if key == "pocket_ecd_um":
        return np.exp(np.log(a) + b * dW + lam * d)
    return sigmoid(a + b * dW + lam * d)


def a3_latent(p, W, stage, oxide_factor=None):
    """Latent A3 quantities per draw at `stage` (dict of arrays aligned with W)."""
    lam = stage_lambda(p, stage)
    return {k: a3_latent_one(p, W, lam, k, oxide_factor) for k in A3_KEYS}


def _scale(key, image="native"):
    kind, s = A3_SCATTER[key]
    extra = IMAGE_EXTRA[image][kind]
    return kind, math.hypot(s, extra)


def a3_measure(key, x, z, image="native"):
    """One simulated reading of A3 quantity `key` from latent x and standard normals z (same shape)."""
    kind, s = _scale(key, image)
    x = np.asarray(x, float)
    if kind == "log":
        y = x * np.exp(s * z)
        return np.minimum(y, 1.0) if key == "nd_rich_area_fraction" else y
    if kind == "logit":
        return sigmoid(logit(x) + s * z)
    return np.clip((x + FL_FLOOR) * np.exp(s * z) - FL_FLOOR, 0.0, 1.0)


def a3_loglik(key, y, x, image="native"):
    """Log-likelihood of an observed reading y (scalar) under latents x (array)."""
    kind, s = _scale(key, image)
    x = np.asarray(x, float)
    if kind == "log":
        r = (math.log(y) - np.log(x)) / s
    elif kind == "logit":
        r = (float(logit(y)) - logit(x)) / s
    else:
        r = (math.log(max(y, 0.0) + FL_FLOOR) - np.log(x + FL_FLOOR)) / s
    return -0.5 * r * r - math.log(s) - 0.5 * math.log(2 * math.pi)


def normal_loglik(y_log, mu_log, s):
    s = np.asarray(s, float)
    r = (y_log - np.asarray(mu_log, float)) / s
    return -0.5 * r * r - np.log(s) - 0.5 * math.log(2 * math.pi)


# ------------------------------------------------------------------------------------------------------------- A4
# Declared descriptive priors of the SPS display trace (owner fits of RPI's raw logs #1, #2, #4, #5; #3's temperature
# column duplicates #2's and is excluded; microstructure/sintering/PER_BODY_TABLE.csv and data/RECONSTRUCTION.json).
SPS_PRIORS = {
    "rho_450": ("uniform", 0.37, 0.43, "relative density at 450 C under the pre-load (logs: 37.4-42.7 %TD)"),
    "T_onset_C": ("uniform", 505.0, 540.0, "shrinkage onset under the pre-load (logs: 505-540 C; #1 575 C)"),
    "step_share": ("uniform", 0.56, 0.68, "share of the densification from 450 C to the end carried by the load step "
                   "(logs #1, #2, #4, #5: 0.56-0.68)"),
    "heat_share": ("uniform", 0.60, 0.81, "share of the pre-load densification made during heating rather than the "
                   "dwell (logs #1, #2, #4, #5: 0.60-0.81)"),
    "heat_shape": ("uniform", 1.5, 3.0, "exponent of the heating densification in (T - onset) / (T_peak - onset) "
                   "(the ramp rate accelerates again at 760-780 C)"),
    "dwell_tau_min": ("uniform", 1.0, 5.0, "time constant of the dwell densification under the pre-load (min)"),
    "step_duration_s": ("uniform", 18.0, 35.0, "duration of the load step at load_ramp_min 0.3 (logs: 18-35 s); "
                        "scaled by load_ramp_min / 0.3 for other ramps (declared)"),
    "step_lead_s": ("uniform", 3.0, 10.0, "the load step starts this long before the logged temperature falls "
                    "(logs: 3-10 s)"),
    "compliance_mm": ("uniform", 0.0, 0.30, "elastic tooling compliance taken up with the load (bracketed 0-0.3 mm)"),
    "alpha_heat_mm_per_C": ("uniform", 0.00049, 0.00071, "tooling expansion during heating (logs: 0.49-0.71 um/C)"),
    "alpha_cool_mm_per_C": ("uniform", 0.00087, 0.00143, "tooling contraction after power-off (logs: 0.87-1.43 um/C)"),
}
SPS_DIE_DIAMETER_MM = 10.0
SPS_CHARGE_MASS_G = 0.85        # declared nominal charge (RPI's #1-#5: 0.77-0.92 g)
SPS_RHO_TD = 7.62
SPS_T_START_C = 25.0
SPS_T_LOG_END_C = 300.0         # the display trace stops at 300 C or 20 min after power-off
SPS_COOL_MAX_S = 1200.0
SPS_QUANTIZATION = {"t_s": 1.0, "T_C": 0.1, "displacement_mm": 0.01}
SPS_STATUS = "descriptive (from RPI's raw logs #1, #2, #4, #5); final density from C5; densification kinetics not identified"
SPS_STATUS_DECLARED_TIMING = ("declared: load timing other than at power-off; the load step is placed at the requested "
                              "time (no log records it); final density from C5")


def sps_draw(n, rng):
    """n draws of the declared trace parameters (dict of (n,) arrays)."""
    out = {}
    for k, spec in SPS_PRIORS.items():
        out[k] = rng.uniform(spec[1], spec[2], n)
    return out


def _height_mm(rho, mass_g):
    area_cm2 = math.pi * (SPS_DIE_DIAMETER_MM / 20.0) ** 2
    return 10.0 * mass_g / (np.maximum(rho, 1e-3) * SPS_RHO_TD * area_cm2)


def sps_trace(route, rho_end, prm, dt_s=1.0, mass_g=SPS_CHARGE_MASS_G, quantize=True):
    """Descriptive SPS display trace for draws with final relative density rho_end ((n,) array) and trace parameters
    prm (dict of (n,) arrays from sps_draw). route: a resolved tool route (T_peak_C, heating_rate_C_per_min, dwell_min,
    cooling_rate_C_per_min, pressure_mode, load_ramp_min). Returns t_s (T,), T_C (T,), displacement_mm (n, T),
    rel_density (n, T) and per-draw events (evaluated at their exact times, not on the grid). The relative density
    ends exactly at rho_end."""
    rho_end = np.atleast_1d(np.asarray(rho_end, float))
    n = len(rho_end)
    Tp = float(route["T_peak_C"])
    rate = float(route["heating_rate_C_per_min"])
    dwell_s = max(float(route["dwell_min"]) * 60.0, 0.0)
    cool = float(route["cooling_rate_C_per_min"])
    mode = route["pressure_mode"]
    t_heat = max((Tp - SPS_T_START_C) / rate * 60.0, 0.0)
    t_off = t_heat + dwell_s
    k = cool / max(Tp - SPS_T_START_C, 1e-9) / 60.0  # Newtonian cooling, initial slope = the route's cooling rate
    if Tp > SPS_T_LOG_END_C:
        t_cool = min(math.log((Tp - SPS_T_START_C) / (SPS_T_LOG_END_C - SPS_T_START_C)) / k, SPS_COOL_MAX_S)
    else:
        t_cool = 60.0
    c = lambda key: np.asarray(prm[key], float)[:, None]
    r450 = np.minimum(c("rho_450"), rho_end[:, None])
    total = rho_end[:, None] - r450
    ton = c("T_onset_C")
    share = np.where(Tp > ton, c("step_share"), 1.0)  # pre-load densification needs the onset to be reached
    d_step = share * total
    d_pre = total - d_step
    d_heat = c("heat_share") * d_pre
    d_dwell = d_pre - d_heat
    tau = c("dwell_tau_min") * 60.0
    dur = c("step_duration_s") * (float(route.get("load_ramp_min", 0.3)) / 0.3)
    if mode == "cooling":
        t0 = t_off - c("step_lead_s")
    else:  # declared: load in heating reaches its plateau at T_peak (end of the ramp); load from the dwell start
        t0 = np.full((n, 1), t_heat)
    done = np.maximum(t0 + dur, t_off)
    # the display runs to 300 C (or 20 min after power-off), and at least until every draw's load step has finished
    t = np.arange(0.0, max(t_off + t_cool, float(done.max()) + 10.0) + 0.5 * dt_s, dt_s)
    h0 = _height_mm(r450, mass_g)

    def temp(tt):
        T = np.where(tt <= t_heat, SPS_T_START_C + rate * tt / 60.0, Tp)
        T = np.where(tt > t_off, SPS_T_START_C + (Tp - SPS_T_START_C) * np.exp(-k * (tt - t_off)), T)
        return np.minimum(T, Tp)

    def state(tt):  # tt: (n, K) or (1, K) times; returns T, rel, disp of shape (n, K)
        T = temp(tt)
        x_h = np.clip((T - ton) / np.maximum(Tp - ton, 1e-9), 0.0, 1.0)
        x_h = np.where(tt <= t_heat, x_h, 1.0)
        heat = d_heat * x_h ** c("heat_shape")
        if dwell_s > 0:
            dw = d_dwell * (-np.expm1(-np.clip(tt - t_heat, 0.0, dwell_s) / tau)) / (-np.expm1(-dwell_s / tau))
        else:
            dw = np.where(tt >= t_heat, d_dwell, 0.0)
        gs = 1.0 - (1.0 - np.clip((tt - t0) / dur, 0.0, 1.0)) ** 2  # ~75 % within half the step (logs: 75-80 %)
        rel = np.where(tt >= done, rho_end[:, None], r450 + heat + dw + d_step * gs)
        th = np.where(tt <= t_off, -c("alpha_heat_mm_per_C") * (T - SPS_T_START_C),
                      -c("alpha_heat_mm_per_C") * (Tp - SPS_T_START_C) + c("alpha_cool_mm_per_C") * (Tp - T))
        disp = (h0 - _height_mm(rel, mass_g)) + c("compliance_mm") * gs + th
        return np.broadcast_to(T, rel.shape), rel, disp

    T, rel, disp = state(np.broadcast_to(t[None, :], (n, len(t))))
    rel = np.array(rel)
    rel[:, -1] = rho_end
    _, _, d0 = state(t0)
    _, _, d1 = state(t0 + dur)
    events = {"t_power_off_s": float(t_off), "t_heating_end_s": float(t_heat),
              "step_start_s": t0[:, 0], "step_duration_s": dur[:, 0], "step_dD_mm": (d1 - d0)[:, 0],
              "step_share": share[:, 0], "pre_load_points_TD": 100.0 * d_pre[:, 0],
              "rho_450": r450[:, 0], "onset_C": ton[:, 0]}
    T = temp(t)
    if quantize:
        T = np.round(T / SPS_QUANTIZATION["T_C"]) * SPS_QUANTIZATION["T_C"]
        disp = np.round(disp / SPS_QUANTIZATION["displacement_mm"]) * SPS_QUANTIZATION["displacement_mm"]
    return {"t_s": t, "T_C": T, "displacement_mm": np.asarray(disp), "rel_density": rel, "events": events}