Blame for code/pimamba/build_dataset.py

"""Build the unified modelling dataset from 论文提取data_final.xlsx.

Implements the data-side requirements of `step 2.docx`:
  * yellow-highlighted rows are erroneous -> dropped (sample_id 24..60);
  * shape-aware geometry with *applicability flags* (never a fake zero);
  * per-variable observed masks (missing != 0);
  * physical unit handling (dislocation density stored in 1e19 m^-2);
  * train-split-only normalisation statistics.

Outputs (data/processed/):
  samples_meta.csv   one row per sample, static (conditioning) features, raw units
  trajectories.csv   long format, 401 strain points per sample, raw units, NaN = unobserved
  data_dictionary.json
  build_report.json
"""
from __future__ import annotations

import json
import re
from pathlib import Path

import numpy as np
import openpyxl
import pandas as pd

HERE = Path(__file__).resolve().parent
ROOT = HERE.parents[1]
RAW_XLSX = ROOT / "raw" / "论文提取data_final.xlsx"
OUT = ROOT / "data" / "processed"

ELEMENTS = ["Al", "Ti", "Zr", "Nb", "Mo", "Ta", "V", "Cr", "Mn", "Fe",
            "Co", "Ni", "Cu", "Hf", "W", "Re", "Sc", "Mg", "Si", "Sn"]

# Sheet2 block layout (18 columns per block: id + 16 data + 1 spacer)
TRAJ_COLS = ["strain", "sigma_GPa", "twin_density_nm-1",
             "xi_BCC", "xi_FCC", "xi_HCP", "xi_other",
             "rho_total", "rho_perfect", "rho_shockley", "rho_frank",
             "rho_stairrod", "rho_hirth", "rho_other_disl",
             "rho_112_111", "rho_100"]
RHO_COLS = ["rho_total", "rho_perfect", "rho_shockley", "rho_frank",
            "rho_stairrod", "rho_hirth", "rho_other_disl", "rho_112_111", "rho_100"]

# Sheet1 column indices (1-based)
COL = dict(sid=1, title=2, doi=3, alloy=4, VEC=5, delta=6, rbar=7, dHmix=8,
           dSmix=9, chi=10, Mavg=11, dmu=12, Tm=13, rhomass=14, load=15,
           direction=16, rate=17, T0=18, eta=19, ensemble=20, cryst=21,
           shape=22, LWH=23, diam=24, aspect=25,
           xi_BCC=26, xi_FCC=27, xi_HCP=28, xi_other=29, rho0=30,
           d_perfect=31, d_shockley=32, d_frank=33, d_stairrod=34,
           d_hirth=35, d_oth=36, d_112_111=37, d_100=38,
           phase=39, potential=40, twin_nuc=41, twin_type=42, twin_lambda=43)
ELEM0 = 44


def _f(v):
    """None/str -> float or NaN."""
    if v is None:
        return np.nan
    if isinstance(v, (int, float)):
        return float(v)
    s = str(v).strip().replace("−", "-").replace("–", "-")
    if s == "" or s in {"-", "NA", "N/A"}:
        return np.nan
    try:
        return float(s)
    except ValueError:
        return np.nan


def _parse_lwh(text):
    """'100 × 50 × 3.4 nm（长×高×宽）' -> (length, height, width, volume_nm3)."""
    if not text:
        return np.nan, np.nan, np.nan
    s = str(text).replace("×", "x").replace("*", "x")
    nums = re.findall(r"(\d+(?:\.\d+)?)\s*(?:x|,)\s*(\d+(?:\.\d+)?)\s*(?:x|,)\s*(\d+(?:\.\d+)?)", s)
    if nums:
        a, b, c = map(float, nums[0])
        # convention stated in the sheet: 长(length) × 高(height) × 宽(width)
        return a, b, c
    one = re.findall(r"(\d+(?:\.\d+)?)", s)
    if len(one) >= 3:
        return float(one[0]), float(one[1]), float(one[2])
    return np.nan, np.nan


def _parse_diameter(text):
    """'10（顶）– 11.3（底）' -> 10.65 ; '13' -> 13."""
    if not text:
        return np.nan
    s = str(text).replace("−", "-").replace("–", "-").replace("—", "-")
    nums = [float(x) for x in re.findall(r"(\d+(?:\.\d+)?)", s)]
    nums = [x for x in nums if 0 < x < 1e4]
    if not nums:
        return np.nan
    if len(nums) >= 2 and (("-" in s) or ("~" in s)):
        return float(np.mean([nums[0], nums[1]]))
    return float(nums[0])


def _parse_orientation(text):
    """Return (h,k,l, has_flag) from strings like '[011]（X 向拉伸）'."""
    if not text:
        return np.nan, np.nan, np.nan, 0.0
    m = re.search(r"\[\s*(-?\d)\s*(-?\d)\s*(-?\d)\s*\]", str(text))
    if m:
        return float(m.group(1)), float(m.group(2)), float(m.group(3)), 1.0
    return np.nan, np.nan, np.nan, 0.0


def _parse_eta(text):
    """'+1/3' / '−1/3' / '0' -> float."""
    if text is None:
        return np.nan
    s = str(text).strip().replace("−", "-").replace("–", "-").replace("+", "")
    if "/" in s:
        try:
            a, b = s.split("/")
            return float(a) / float(b)
        except Exception:
            return np.nan
    try:
        return float(s)
    except ValueError:
        return np.nan


def _parse_ensemble(text):
    s = str(text or "").upper()
    if "NPT" in s:
        return "NPT"
    if "NVE" in s:
        return "NVE"
    if "NVT" in s:
        return "NVT"
    return "unknown"


def _parse_potential(text):
    s = str(text or "").upper()
    if "SNAP" in s:
        return "SNAP"
    if "MEAM" in s:
        return "MEAM"
    if "EAM" in s:
        return "EAM"
    return "other"


def read_meta(ws) -> pd.DataFrame:
    rows = []
    for r in range(2, ws.max_row + 1):
        sid = ws.cell(r, 1).value
        if sid is None:
            continue
        g = lambda k: ws.cell(r, COL[k]).value
        rec = {
            "sample_id": int(sid),
            "title": g("title"),
            "doi": g("doi"),
            "alloy": str(g("alloy")).strip(),
            "load_mode": str(g("load") or "").strip(),
            "load_direction": g("direction"),
            "strain_rate": _f(g("rate")),
            "T0": _f(g("T0")),
            "eta": _parse_eta(g("eta")),
            "ensemble": _parse_ensemble(g("ensemble")),
            "crystalline": str(g("cryst") or "").strip(),
            "shape_raw": str(g("shape") or "").strip(),
            "lwh_raw": g("LWH"),
            "diameter_raw": g("diam"),
            "aspect_raw": g("aspect"),
            "rho0": _f(g("rho0")),
            "phase_raw": g("phase"),
            "potential": _parse_potential(g("potential")),
            "twin_nuc": _f(g("twin_nuc")),
            "twin_type": g("twin_type"),
            "twin_lambda": _f(g("twin_lambda")),
        }
        for k in ["VEC", "delta", "rbar", "dHmix", "dSmix", "chi", "Mavg",
                  "dmu", "Tm", "rhomass"]:
            rec[k] = _f(g(k))
        for k in ["xi_BCC", "xi_FCC", "xi_HCP", "xi_other"]:
            rec["init_" + k] = _f(g(k))
        for k in ["d_perfect", "d_shockley", "d_frank", "d_stairrod",
                  "d_hirth", "d_oth", "d_112_111", "d_100"]:
            rec["init_" + k] = _f(g(k))

        comp = np.array([_f(ws.cell(r, ELEM0 + i).value) for i in range(len(ELEMENTS))])
        comp = np.nan_to_num(comp, nan=0.0)
        tot = comp.sum()
        rec["comp_sum"] = tot
        for i, el in enumerate(ELEMENTS):
            rec["at_" + el] = comp[i] / tot if tot > 0 else np.nan

        # ---- geometry: shape-aware, with applicability flags -------------
        shape = rec["shape_raw"].lower()
        is_cyl = shape in {"c", "cylinder", "cyl"} or "cyl" in shape
        is_prism = (not is_cyl) and (shape in {"r", "rectangular prism", "prism"} or "rect" in shape)
        L = W = H = D = AR = np.nan
        if is_prism:
            L, H, W = _parse_lwh(rec["lwh_raw"])
        elif is_cyl:
            D = _parse_diameter(rec["diameter_raw"])
            AR = _f(rec["aspect_raw"])
            if not np.isfinite(AR) and np.isfinite(_f(rec["aspect_raw"])):
                AR = _f(rec["aspect_raw"])
        rec["shape_type"] = "prism" if is_prism else ("cylinder" if is_cyl else "unknown")
        rec["geom_L"] = L
        rec["geom_W"] = W
        rec["geom_H"] = H
        rec["geom_D"] = D
        rec["geom_AR"] = AR
        rec["app_L"] = float(np.isfinite(L))
        rec["app_W"] = float(np.isfinite(W))
        rec["app_H"] = float(np.isfinite(H))
        rec["app_D"] = float(np.isfinite(D))
        rec["app_AR"] = float(np.isfinite(AR))
        if is_prism and np.isfinite(L) and np.isfinite(W) and np.isfinite(H):
            rec["geom_volume_nm3"] = L * W * H
        elif is_cyl and np.isfinite(D) and np.isfinite(AR):
            rec["geom_volume_nm3"] = np.pi * (D / 2) ** 2 * (AR * D)
        else:
            rec["geom_volume_nm3"] = np.nan
        rec["app_V"] = float(np.isfinite(rec["geom_volume_nm3"]))

        h, k, l, has = _parse_orientation(rec["load_direction"])
        norm = np.sqrt(h * h + k * k + l * l) if has else np.nan
        rec.update({"orient_h": h / norm if has else np.nan,
                    "orient_k": k / norm if has else np.nan,
                    "orient_l": l / norm if has else np.nan,
                    "app_orient": has})
        rows.append(rec)
    return pd.DataFrame(rows)


def read_traj(ws2) -> pd.DataFrame:
    starts = list(range(1, ws2.max_column + 1, 18))
    frames = []
    for s in starts:
        sid = ws2.cell(2, s).value
        if sid is None:
            continue
        vals = []
        for r in range(2, ws2.max_row + 1):
            row = [ws2.cell(r, c).value for c in range(s, s + 17)]
            if row[0] is None and row[1] is None:
                continue
            vals.append([_f(v) for v in row[1:17]])
        if not vals:
            continue
        arr = np.asarray(vals, dtype=float)
        df = pd.DataFrame(arr, columns=TRAJ_COLS)
        df.insert(0, "sample_id", int(sid))
        frames.append(df)
    out = pd.concat(frames, ignore_index=True)
    # enforce physical plausibility: tiny negative round-off -> 0
    for c in ["sigma_GPa"] + RHO_COLS + ["twin_density_nm-1"]:
        out.loc[out[c] < 0, c] = np.nan if c != "sigma_GPa" else 0.0
    return out


def drop_yellow(wb, meta: pd.DataFrame):
    ws = wb["Sheet1"]
    bad_rows = []
    for r in range(2, ws.max_row + 1):
        n = sum(1 for c in ws[r] if c.fill and c.fill.fgColor
                and c.fill.fgColor.rgb == "FFFFFF00")
        if n >= 50:  # a whole highlighted record
            bad_rows.append(ws.cell(r, 1).value)
    return [int(x) for x in bad_rows if x is not None]


def main():
    OUT.mkdir(parents=True, exist_ok=True)
    wb = openpyxl.load_workbook(RAW_XLSX, data_only=True)
    meta_all = read_meta(wb["Sheet1"])
    traj_all = read_traj(wb["Sheet2"])
    bad = drop_yellow(wb, meta_all)

    meta = meta_all[~meta_all.sample_id.isin(bad)].reset_index(drop=True)
    traj = traj_all[~traj_all.sample_id.isin(bad)].reset_index(drop=True)
    traj = traj.sort_values(["sample_id", "strain"]).reset_index(drop=True)

    meta.to_csv(OUT / "samples_meta.csv", index=False, encoding="utf-8-sig")
    traj.to_csv(OUT / "trajectories.csv", index=False, encoding="utf-8-sig")

    coverage = {}
    for c in TRAJ_COLS[1:]:
        coverage[c] = {
            "n_samples_with_label": int(traj.groupby("sample_id")[c].apply(lambda s: s.notna().any()).sum()),
            "n_points": int(traj[c].notna().sum()),
            "min": float(np.nanmin(traj[c])) if traj[c].notna().any() else None,
            "max": float(np.nanmax(traj[c])) if traj[c].notna().any() else None,
        }
    report = {
        "n_samples_raw": int(len(meta_all)),
        "dropped_yellow_sample_ids": bad,
        "n_samples_used": int(len(meta)),
        "n_strain_points_per_sample": int(traj.groupby("sample_id").size().mode().iloc[0]),
        "alloys": {k: int(v) for k, v in meta.alloy.value_counts().items()},
        "coverage": coverage,
        "unit_notes": {
            "rho_*": "stored value x 1e19 = m^-2",
            "sigma_GPa": "GPa (magnitude, positive)",
            "twin_density_nm-1": "nm^-1",
            "xi_*": "volume fraction 0-1",
        },
    }
    (OUT / "build_report.json").write_text(json.dumps(report, ensure_ascii=False, indent=2))
    (OUT / "data_dictionary.json").write_text(json.dumps({
        "static_features": list(meta.columns),
        "trajectory_targets": TRAJ_COLS[1:],
        "rho_columns": RHO_COLS,
        "phase_columns": ["xi_BCC", "xi_FCC", "xi_HCP", "xi_other"],
    }, ensure_ascii=False, indent=2))

    print(json.dumps({k: v for k, v in report.items() if k != "coverage"},
                     ensure_ascii=False, indent=2))
    print("\ncoverage:")
    for k, v in coverage.items():
        print(f"  {k:22s} samples={v['n_samples_with_label']:2d} points={v['n_points']:5d} "
              f"range=[{v['min']}, {v['max']}]")


if __name__ == "__main__":
    main()