src/t2_material_loading_memory.py

"""Generate the T2 material-loading-memory pilot dataset.

The sample unit is one complete material-point trajectory. Time frames are not
counted as independent samples. The pilot deliberately keeps J2 linear
isotropic hardening and Chaboche combined hardening as separate model labels.
"""

from __future__ import annotations

import argparse
import hashlib
import json
import os
import platform
import time
from pathlib import Path

import h5py
import matplotlib

matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np
from scipy.stats import qmc

import agentfem
from agentfem import campaigns, constitutive


ROOT = Path(__file__).resolve().parents[1]
CONFIG_PATH = ROOT / "configs" / "t2_material_loading_memory_pilot.json"
DATA_DIR = ROOT / "data" / "t2_material_loading_memory_pilot"
ARTIFACT_DIR = ROOT / "artifacts" / "t2_material_loading_memory_pilot"
DATA_PATH = DATA_DIR / "t2_material_loading_memory_pilot.h5"
DESIGN_PATH = DATA_DIR / "design.jsonl"
INDEX_PATH = DATA_DIR / "index.jsonl"

AGENTFEM_COMMIT = "058faecc05aeda143d014fd229401003a9258bbb"
MATERIAL_MODELS = ("j2_linear_isotropic", "chaboche_combined")
PATH_FAMILIES = (
    "monotonic_tension",
    "unload_reload",
    "tension_compression",
    "symmetric_cyclic",
    "mean_shifted_cyclic",
    "variable_amplitude",
)


def load_config() -> dict[str, object]:
    return json.loads(CONFIG_PATH.read_text(encoding="utf-8"))


def _scale(value: float, bounds: list[float]) -> float:
    return float(bounds[0] + value * (bounds[1] - bounds[0]))


def design_parameters(seed: int | None = None) -> tuple[dict[str, object], ...]:
    """Return a deterministic balanced 96-trajectory Sobol design."""

    config = load_config()
    actual_seed = int(config["seed"] if seed is None else seed)
    ranges = config["ranges"]
    unit = qmc.Sobol(12, scramble=True, seed=actual_seed).random_base2(7)
    rows: list[dict[str, object]] = []
    cursor = 0
    for material_model in MATERIAL_MODELS:
        for path_family in PATH_FAMILIES:
            for replicate in range(8):
                u = unit[cursor]
                cursor += 1
                row: dict[str, object] = {
                    "material_model": material_model,
                    "path_family": path_family,
                    "replicate": replicate,
                    "young_pa": _scale(u[0], ranges["young_pa"]),
                    "poisson": _scale(u[1], ranges["poisson"]),
                    "yield_stress_pa": _scale(u[2], ranges["yield_stress_pa"]),
                    "maximum_equivalent_strain": _scale(
                        u[3], ranges["maximum_equivalent_strain"]
                    ),
                    "path_shape_a": float(u[10]),
                    "path_shape_b": float(u[11]),
                }
                if material_model == "j2_linear_isotropic":
                    row.update(
                        {
                            "hardening_modulus_pa": _scale(
                                u[4], ranges["j2_hardening_modulus_pa"]
                            ),
                            "backstress_c1_pa": 0.0,
                            "backstress_gamma1": 0.0,
                            "backstress_c2_pa": 0.0,
                            "backstress_gamma2": 0.0,
                            "isotropic_saturation_pa": 0.0,
                            "isotropic_rate": 0.0,
                        }
                    )
                else:
                    row.update(
                        {
                            "hardening_modulus_pa": 0.0,
                            "backstress_c1_pa": _scale(
                                u[4], ranges["chaboche_c1_pa"]
                            ),
                            "backstress_gamma1": _scale(
                                u[5], ranges["chaboche_gamma1"]
                            ),
                            "backstress_c2_pa": _scale(
                                u[6], ranges["chaboche_c2_pa"]
                            ),
                            "backstress_gamma2": _scale(
                                u[7], ranges["chaboche_gamma2"]
                            ),
                            "isotropic_saturation_pa": _scale(
                                u[8], ranges["chaboche_isotropic_saturation_pa"]
                            ),
                            "isotropic_rate": _scale(
                                u[9], ranges["chaboche_isotropic_rate"]
                            ),
                        }
                    )
                rows.append(row)
    if len(rows) != int(config["sample_count"]):
        raise RuntimeError("T2 design size differs from the frozen configuration.")
    return tuple(rows)


def case_identity(parameters: dict[str, object]) -> str:
    return campaigns.case_id("t2_material_loading_memory_pilot", parameters)


def split_assignments(parameters: tuple[dict[str, object], ...]) -> dict[int, str]:
    """Create 6/1/1 train/validation/test splits within every stratum."""

    seed = int(load_config()["seed"])
    result: dict[int, str] = {}
    for model_index, material_model in enumerate(MATERIAL_MODELS):
        for path_index, path_family in enumerate(PATH_FAMILIES):
            members = np.asarray(
                [
                    index
                    for index, row in enumerate(parameters)
                    if row["material_model"] == material_model
                    and row["path_family"] == path_family
                ],
                dtype=int,
            )
            rng = np.random.default_rng(seed + 100 * model_index + path_index)
            members = rng.permutation(members)
            for index in members[:6]:
                result[int(index)] = "train"
            result[int(members[6])] = "validation"
            result[int(members[7])] = "test"
    return result


def path_anchors(parameters: dict[str, object]) -> np.ndarray:
    """Return signed equivalent-deviatoric-strain control points."""

    amplitude = float(parameters["maximum_equivalent_strain"])
    a = float(parameters["path_shape_a"])
    b = float(parameters["path_shape_b"])
    family = str(parameters["path_family"])
    if family == "monotonic_tension":
        values = (0.0, amplitude)
    elif family == "unload_reload":
        unload = amplitude * (-0.25 + 0.60 * a)
        reload = amplitude * (0.85 + 0.30 * b)
        values = (0.0, amplitude, unload, reload)
    elif family == "tension_compression":
        reverse = -amplitude * (0.70 + 0.45 * a)
        values = (0.0, amplitude, reverse)
    elif family == "symmetric_cyclic":
        values = (0.0, amplitude, -amplitude, amplitude, -amplitude, amplitude)
    elif family == "mean_shifted_cyclic":
        lower = -amplitude * (0.25 + 0.40 * a)
        upper = amplitude * (0.90 + 0.10 * b)
        values = (0.0, upper, lower, upper, lower, upper)
    elif family == "variable_amplitude":
        first_reverse = -amplitude * (0.55 + 0.30 * a)
        second_reverse = -amplitude * (0.25 + 0.35 * b)
        values = (
            0.0,
            0.45 * amplitude,
            first_reverse,
            amplitude,
            second_reverse,
            0.75 * amplitude,
            -amplitude,
            0.20 * amplitude,
        )
    else:
        raise ValueError(f"Unknown path family: {family}")
    return np.asarray(values, dtype=float)


def prescribed_history(
    parameters: dict[str, object], *, points: int | None = None
) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
    """Return a path that samples every reversal anchor exactly.

    The 241-point refinement doubles the interval count of every 121-point
    segment. Therefore every coarse state is present at ``fine[::2]`` and the
    refinement audit measures constitutive integration, not a missed path
    extremum.
    """

    base_count = int(load_config()["points_per_trajectory"])
    count = int(base_count if points is None else points)
    if count < 3 or count % 2 == 0:
        raise ValueError("points must be an odd integer of at least three.")
    anchors = path_anchors(parameters)
    segments = len(anchors) - 1

    def allocated(intervals: int) -> np.ndarray:
        if intervals < segments:
            raise ValueError("points must provide at least one interval per segment.")
        values = np.full(segments, intervals // segments, dtype=int)
        values[: intervals % segments] += 1
        return values

    base_segments = allocated(base_count - 1)
    if (count - 1) % (base_count - 1) == 0:
        segment_intervals = base_segments * ((count - 1) // (base_count - 1))
    else:
        segment_intervals = allocated(count - 1)
    pieces: list[np.ndarray] = []
    for index, intervals in enumerate(segment_intervals):
        values = np.linspace(anchors[index], anchors[index + 1], intervals + 1)
        pieces.append(values if index == 0 else values[1:])
    scalar_strain = np.concatenate(pieces)
    if len(scalar_strain) != count:
        raise RuntimeError("Piecewise path allocation produced the wrong point count.")
    time_coordinate = np.linspace(0.0, 1.0, count)
    return time_coordinate, scalar_strain, anchors


def _strain_tensor(signed_equivalent_strain: float) -> np.ndarray:
    value = float(signed_equivalent_strain)
    return np.diag((value, -0.5 * value, -0.5 * value))


def _material(parameters: dict[str, object]):
    if parameters["material_model"] == "j2_linear_isotropic":
        return constitutive.J2LinearIsotropicHardening(
            young=float(parameters["young_pa"]),
            poisson=float(parameters["poisson"]),
            yield_stress=float(parameters["yield_stress_pa"]),
            hardening_modulus=float(parameters["hardening_modulus_pa"]),
        )
    return constitutive.chaboche(
        young=float(parameters["young_pa"]),
        poisson=float(parameters["poisson"]),
        yield_stress=float(parameters["yield_stress_pa"]),
        backstresses=(
            (
                float(parameters["backstress_c1_pa"]),
                float(parameters["backstress_gamma1"]),
            ),
            (
                float(parameters["backstress_c2_pa"]),
                float(parameters["backstress_gamma2"]),
            ),
        ),
        isotropic_saturation=float(parameters["isotropic_saturation_pa"]),
        isotropic_rate=float(parameters["isotropic_rate"]),
    )


def solve_trajectory(
    parameters: dict[str, object], *, points: int | None = None
) -> tuple[dict[str, np.ndarray], dict[str, float | int | bool]]:
    """Integrate one committed material-point path through AgentFEM."""

    time_coordinate, scalar_strain, anchors = prescribed_history(
        parameters, points=points
    )
    material = _material(parameters)
    count = len(time_coordinate)
    total_strain = np.empty((count, 3, 3), dtype=float)
    stress = np.empty((count, 3, 3), dtype=float)
    plastic_strain = np.empty((count, 3, 3), dtype=float)
    peeq = np.empty(count, dtype=float)
    signed_stress = np.empty(count, dtype=float)
    mises = np.empty(count, dtype=float)
    shifted_mises = np.empty(count, dtype=float)
    yield_radius = np.empty(count, dtype=float)
    trial_yield = np.empty(count, dtype=float)
    plastic_increment = np.empty(count, dtype=float)
    elastic = np.empty(count, dtype=np.uint8)
    backstress = np.zeros((count, 3, 3), dtype=float)
    backstress_components = np.zeros((count, 2, 3, 3), dtype=float)
    state = None

    for index, value in enumerate(scalar_strain):
        strain = _strain_tensor(value)
        update = material.update(strain, state)
        state = update.state
        total_strain[index] = strain
        stress[index] = update.stress
        plastic_strain[index] = state.plastic_strain
        peeq[index] = state.equivalent_plastic_strain
        signed_stress[index] = update.stress[0, 0] - update.stress[1, 1]
        mises[index] = constitutive.von_mises(update.stress)
        trial_yield[index] = update.yield_function_trial
        plastic_increment[index] = update.plastic_multiplier_increment
        elastic[index] = np.uint8(update.elastic)
        if parameters["material_model"] == "chaboche_combined":
            backstress[index] = state.total_backstress
            backstress_components[index] = state.backstresses
        shifted_mises[index] = constitutive.von_mises(
            update.stress - backstress[index]
        )
        yield_radius[index] = material.current_yield_stress(peeq[index])

    plastic_work_increment = np.zeros(count, dtype=float)
    external_work_increment = np.zeros(count, dtype=float)
    for index in range(1, count):
        mean_stress = 0.5 * (stress[index] + stress[index - 1])
        plastic_work_increment[index] = float(
            np.tensordot(
                mean_stress,
                plastic_strain[index] - plastic_strain[index - 1],
            )
        )
        external_work_increment[index] = float(
            np.tensordot(
                mean_stress,
                total_strain[index] - total_strain[index - 1],
            )
        )
    arrays = {
        "time_coordinate": time_coordinate,
        "path_anchors": anchors,
        "signed_equivalent_strain": scalar_strain,
        "total_strain": total_strain,
        "stress_pa": stress,
        "signed_equivalent_stress_pa": signed_stress,
        "mises_stress_pa": mises,
        "plastic_strain": plastic_strain,
        "equivalent_plastic_strain": peeq,
        "plastic_multiplier_increment": plastic_increment,
        "elastic_step": elastic,
        "trial_yield_function_pa": trial_yield,
        "yield_radius_pa": yield_radius,
        "shifted_mises_stress_pa": shifted_mises,
        "backstress_pa": backstress,
        "backstress_components_pa": backstress_components,
        "plastic_work_increment_j_m3": plastic_work_increment,
        "cumulative_plastic_work_j_m3": np.cumsum(plastic_work_increment),
        "external_work_increment_j_m3": external_work_increment,
        "cumulative_external_work_j_m3": np.cumsum(external_work_increment),
    }
    plastic_mask = plastic_increment > 0.0
    zero_strain_mask = np.abs(scalar_strain) <= 1.0e-14
    residual = np.abs(shifted_mises - yield_radius) / np.maximum(
        yield_radius, 1.0
    )
    metrics: dict[str, float | int | bool] = {
        "maximum_absolute_stress_pa": float(np.max(np.abs(signed_stress))),
        "final_equivalent_plastic_strain": float(peeq[-1]),
        "maximum_equivalent_plastic_strain": float(np.max(peeq)),
        "final_cumulative_plastic_work_j_m3": float(
            np.sum(plastic_work_increment)
        ),
        "plastic_step_count": int(np.count_nonzero(plastic_mask)),
        "maximum_plastic_strain_trace": float(
            np.max(np.abs(np.trace(plastic_strain, axis1=1, axis2=2)))
        ),
        "maximum_yield_surface_relative_residual": float(
            np.max(residual[plastic_mask]) if np.any(plastic_mask) else 0.0
        ),
        "minimum_peeq_increment": float(np.min(np.diff(peeq))),
        "minimum_plastic_work_increment_j_m3": float(
            np.min(plastic_work_increment)
        ),
        "zero_strain_stress_range_pa": float(
            np.ptp(signed_stress[zero_strain_mask])
            if np.count_nonzero(zero_strain_mask) >= 2
            else 0.0
        ),
        "all_finite": bool(
            all(np.all(np.isfinite(value)) for value in arrays.values())
        ),
    }
    return arrays, metrics


def _j2_monotonic_reference(parameters: dict[str, object]) -> tuple[float, float]:
    strain = float(parameters["maximum_equivalent_strain"])
    young = float(parameters["young_pa"])
    poisson = float(parameters["poisson"])
    shear = young / (2.0 * (1.0 + poisson))
    yield_stress = float(parameters["yield_stress_pa"])
    hardening = float(parameters["hardening_modulus_pa"])
    trial = 3.0 * shear * strain
    increment = max(0.0, (trial - yield_stress) / (3.0 * shear + hardening))
    return yield_stress + hardening * increment, increment


def _sha256(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as stream:
        for block in iter(lambda: stream.read(1024 * 1024), b""):
            digest.update(block)
    return digest.hexdigest()


def _write_json_atomic(path: Path, value: object) -> None:
    temporary = path.with_suffix(path.suffix + ".tmp")
    temporary.write_text(
        json.dumps(value, indent=2, sort_keys=True) + "\n", encoding="utf-8"
    )
    os.replace(temporary, path)


def _write_jsonl_atomic(path: Path, rows: list[dict[str, object]]) -> None:
    temporary = path.with_suffix(path.suffix + ".tmp")
    with temporary.open("w", encoding="utf-8") as stream:
        for row in rows:
            stream.write(json.dumps(row, sort_keys=True) + "\n")
    os.replace(temporary, path)


def _quality_failures(
    parameters: tuple[dict[str, object], ...],
    records: list[dict[str, object]],
    refinements: list[dict[str, object]],
) -> list[dict[str, object]]:
    thresholds = load_config()["quality_thresholds"]
    failures: list[dict[str, object]] = []
    for index, (row, record) in enumerate(zip(parameters, records, strict=True)):
        metrics = record["metrics"]
        checks = {
            "all_finite": bool(metrics["all_finite"]),
            "initial_stress": abs(float(record["initial_signed_stress_pa"]))
            <= thresholds["initial_stress_pa"],
            "plastic_incompressibility": metrics["maximum_plastic_strain_trace"]
            <= thresholds["plastic_strain_trace"],
            "peeq_monotone": metrics["minimum_peeq_increment"]
            >= -thresholds["equivalent_plastic_strain_decrease"],
            "yield_surface": metrics["maximum_yield_surface_relative_residual"]
            <= thresholds["yield_surface_relative_residual"],
            "positive_total_plastic_work": metrics[
                "final_cumulative_plastic_work_j_m3"
            ]
            > thresholds["final_plastic_work_minimum_j_m3"],
            "plastic_excitation": metrics["plastic_step_count"] > 0,
        }
        if row["material_model"] == "j2_linear_isotropic":
            checks["j2_nonnegative_plastic_work_increment"] = metrics[
                "minimum_plastic_work_increment_j_m3"
            ] >= -thresholds["j2_plastic_work_negative_tolerance_j_m3"]
        if (
            row["material_model"] == "j2_linear_isotropic"
            and row["path_family"] == "monotonic_tension"
        ):
            checks["j2_analytical"] = (
                record["j2_analytical_relative_error"]
                <= thresholds["j2_monotonic_analytical_relative_error"]
            )
        if row["path_family"] == "symmetric_cyclic":
            checks["history_memory_contrast"] = metrics[
                "zero_strain_stress_range_pa"
            ] >= thresholds["zero_strain_memory_contrast_pa"]
        failed = sorted(name for name, passed in checks.items() if not passed)
        if failed:
            failures.append({"index": index, "failed_checks": failed})
    for item in refinements:
        failed = []
        if item["maximum_stress_relative_change"] > thresholds[
            "refined_stress_relative_change"
        ]:
            failed.append("refined_stress")
        if item["maximum_peeq_relative_change"] > thresholds[
            "refined_peeq_relative_change"
        ]:
            failed.append("refined_peeq")
        if failed:
            failures.append({"index": item["index"], "failed_checks": failed})
    return failures


def _plot_preview(
    parameters: tuple[dict[str, object], ...],
    stored: dict[int, dict[str, np.ndarray]],
) -> Path:
    ARTIFACT_DIR.mkdir(parents=True, exist_ok=True)
    fig, axes = plt.subplots(2, 3, figsize=(12.0, 7.2), constrained_layout=True)
    colors = {"j2_linear_isotropic": "#2563eb", "chaboche_combined": "#dc2626"}
    labels = {"j2_linear_isotropic": "J2 isotropic", "chaboche_combined": "Chaboche"}
    for axis, family in zip(axes.flat, PATH_FAMILIES, strict=True):
        for model in MATERIAL_MODELS:
            index = next(
                idx
                for idx, row in enumerate(parameters)
                if row["material_model"] == model
                and row["path_family"] == family
                and row["replicate"] == 0
            )
            arrays = stored[index]
            axis.plot(
                100.0 * arrays["signed_equivalent_strain"],
                arrays["signed_equivalent_stress_pa"] / 1.0e6,
                color=colors[model],
                lw=1.8,
                label=labels[model],
            )
        axis.axhline(0.0, color="#9ca3af", lw=0.6)
        axis.axvline(0.0, color="#9ca3af", lw=0.6)
        axis.set_title(family.replace("_", " ").title(), fontsize=10)
        axis.set_xlabel("Signed equivalent strain (%)")
        axis.set_ylabel("Signed equivalent stress (MPa)")
        axis.grid(alpha=0.22)
    axes.flat[0].legend(frameon=False, fontsize=9)
    fig.suptitle(
        "AgentFEM T2 pilot: path-dependent material memory\n"
        "Representative independent cases; J2 and Chaboche parameters are not matched.",
        fontsize=13,
    )
    output = ARTIFACT_DIR / "hysteresis_preview.png"
    fig.savefig(output, dpi=180)
    plt.close(fig)
    return output


def generate() -> dict[str, object]:
    config = load_config()
    parameters = design_parameters()
    splits = split_assignments(parameters)
    DATA_DIR.mkdir(parents=True, exist_ok=True)
    ARTIFACT_DIR.mkdir(parents=True, exist_ok=True)
    design_rows: list[dict[str, object]] = []
    records: list[dict[str, object]] = []
    stored: dict[int, dict[str, np.ndarray]] = {}
    started = time.perf_counter()
    temporary = DATA_PATH.with_suffix(".h5.tmp")
    with h5py.File(temporary, "w") as h5:
        h5.attrs["schema"] = config["schema"]
        h5.attrs["schema_version"] = config["schema_version"]
        h5.attrs["dataset_version"] = config["dataset_version"]
        h5.attrs["agentfem_version"] = agentfem.__version__
        h5.attrs["agentfem_commit"] = AGENTFEM_COMMIT
        h5.attrs["numpy_version"] = np.__version__
        h5.attrs["python_version"] = platform.python_version()
        for index, row in enumerate(parameters):
            case_id = case_identity(row)
            split = splits[index]
            arrays, metrics = solve_trajectory(row)
            reference_error = 0.0
            if (
                row["material_model"] == "j2_linear_isotropic"
                and row["path_family"] == "monotonic_tension"
            ):
                reference_stress, reference_peeq = _j2_monotonic_reference(row)
                reference_error = max(
                    abs(arrays["signed_equivalent_stress_pa"][-1] - reference_stress)
                    / max(reference_stress, 1.0),
                    abs(arrays["equivalent_plastic_strain"][-1] - reference_peeq)
                    / max(reference_peeq, 1.0e-15),
                )
            record: dict[str, object] = {
                "id": f"{index:05d}",
                "case_id": case_id,
                "split": split,
                "parameters": row,
                "metrics": metrics,
                "initial_signed_stress_pa": float(
                    arrays["signed_equivalent_stress_pa"][0]
                ),
                "j2_analytical_relative_error": float(reference_error),
            }
            group = h5.create_group(f"{index:05d}")
            group.attrs["case_id"] = case_id
            group.attrs["split"] = split
            group.attrs["material_model"] = row["material_model"]
            group.attrs["path_family"] = row["path_family"]
            group.attrs["parameters_json"] = json.dumps(row, sort_keys=True)
            group.attrs["metrics_json"] = json.dumps(metrics, sort_keys=True)
            for name, value in arrays.items():
                group.create_dataset(name, data=value, compression="gzip", shuffle=True)
            design_rows.append(
                {
                    "id": f"{index:05d}",
                    "case_id": case_id,
                    "split": split,
                    "parameters": row,
                }
            )
            records.append(record)
            if row["replicate"] == 0:
                stored[index] = arrays
    os.replace(temporary, DATA_PATH)
    _write_jsonl_atomic(DESIGN_PATH, design_rows)
    _write_jsonl_atomic(INDEX_PATH, records)

    refinements: list[dict[str, object]] = []
    for index, row in enumerate(parameters):
        if row["replicate"] != 0:
            continue
        coarse = stored[index]
        fine, _ = solve_trajectory(row, points=241)
        fine_stress = fine["signed_equivalent_stress_pa"][::2]
        fine_peeq = fine["equivalent_plastic_strain"][::2]
        stress_scale = max(float(np.max(np.abs(fine_stress))), 1.0)
        peeq_scale = max(float(np.max(fine_peeq)), 1.0e-15)
        refinements.append(
            {
                "index": index,
                "material_model": row["material_model"],
                "path_family": row["path_family"],
                "maximum_stress_relative_change": float(
                    np.max(
                        np.abs(
                            coarse["signed_equivalent_stress_pa"] - fine_stress
                        )
                    )
                    / stress_scale
                ),
                "maximum_peeq_relative_change": float(
                    np.max(
                        np.abs(coarse["equivalent_plastic_strain"] - fine_peeq)
                    )
                    / peeq_scale
                ),
            }
        )

    failures = _quality_failures(parameters, records, refinements)
    preview = _plot_preview(parameters, stored)
    summary = {
        "status": "accepted" if not failures else "rejected",
        "sample_count": len(parameters),
        "material_models": {
            model: sum(row["material_model"] == model for row in parameters)
            for model in MATERIAL_MODELS
        },
        "path_families": {
            family: sum(row["path_family"] == family for row in parameters)
            for family in PATH_FAMILIES
        },
        "splits": {
            name: sum(value == name for value in splits.values())
            for name in ("train", "validation", "test")
        },
        "all_case_ids_unique": len({case_identity(row) for row in parameters})
        == len(parameters),
        "quality_failure_count": len(failures),
        "quality_failures": failures,
        "maximum_yield_surface_relative_residual": float(
            max(
                record["metrics"]["maximum_yield_surface_relative_residual"]
                for record in records
            )
        ),
        "maximum_plastic_strain_trace": float(
            max(
                record["metrics"]["maximum_plastic_strain_trace"]
                for record in records
            )
        ),
        "maximum_j2_analytical_relative_error": float(
            max(record["j2_analytical_relative_error"] for record in records)
        ),
        "minimum_symmetric_zero_strain_memory_contrast_pa": float(
            min(
                record["metrics"]["zero_strain_stress_range_pa"]
                for record in records
                if record["parameters"]["path_family"] == "symmetric_cyclic"
            )
        ),
        "maximum_refined_stress_relative_change": float(
            max(item["maximum_stress_relative_change"] for item in refinements)
        ),
        "maximum_refined_peeq_relative_change": float(
            max(item["maximum_peeq_relative_change"] for item in refinements)
        ),
        "minimum_plastic_work_increment_j_m3": float(
            min(
                record["metrics"]["minimum_plastic_work_increment_j_m3"]
                for record in records
            )
        ),
        "wall_seconds": float(time.perf_counter() - started),
        "data_file": str(DATA_PATH.relative_to(ROOT)),
        "data_bytes": DATA_PATH.stat().st_size,
        "data_sha256": _sha256(DATA_PATH),
        "preview": str(preview.relative_to(ROOT)),
        "agentfem_version": agentfem.__version__,
        "agentfem_commit": AGENTFEM_COMMIT,
        "refinement_audits": refinements,
    }
    _write_json_atomic(ARTIFACT_DIR / "quality.json", summary)
    report = f"""# T2 material-loading-memory pilot quality report

Status: **{summary['status']}**  
Independent trajectories: {summary['sample_count']}  
Quality failures: {summary['quality_failure_count']}

## Coverage

- J2 linear isotropic hardening: {summary['material_models']['j2_linear_isotropic']}
- Chaboche combined hardening: {summary['material_models']['chaboche_combined']}
- Six loading-path families: 16 trajectories each
- Train/validation/test trajectories: 72/12/12
- Points per trajectory: {config['points_per_trajectory']}

## Verification

- Maximum yield-surface relative residual: {summary['maximum_yield_surface_relative_residual']:.3e}
- Maximum plastic-strain trace: {summary['maximum_plastic_strain_trace']:.3e}
- Maximum J2 monotonic analytical relative error: {summary['maximum_j2_analytical_relative_error']:.3e}
- Minimum repeated-zero-strain stress contrast in symmetric cycles: {summary['minimum_symmetric_zero_strain_memory_contrast_pa'] / 1.0e6:.3f} MPa
- Maximum 121-to-241-point stress change: {summary['maximum_refined_stress_relative_change']:.3%}
- Maximum 121-to-241-point PEEQ change: {summary['maximum_refined_peeq_relative_change']:.3%}
- Minimum raw `stress:plastic-strain-increment` diagnostic: {summary['minimum_plastic_work_increment_j_m3']:.3e} J/m^3
- All case IDs unique: {summary['all_case_ids_unique']}

The data are synthetic three-dimensional small-strain material-point histories under
prescribed proportional deviatoric strain. They are not structural FEM fields, an
experimental material calibration, or fatigue-life labels. Chaboche remains explicitly
labelled as an experimental AgentFEM capability. For Chaboche, raw stress work on plastic
strain is recorded but is not labelled as thermodynamic dissipation because the current
material-point contract does not expose a complete backstress storage/recovery energy split.

![Hysteresis preview](hysteresis_preview.png)
"""
    (ARTIFACT_DIR / "QUALITY_REPORT.md").write_text(report, encoding="utf-8")
    print(json.dumps(summary, indent=2, sort_keys=True))
    if failures:
        raise RuntimeError(f"T2 pilot failed {len(failures)} quality checks.")
    return summary


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument(
        "--generate", action="store_true", help="Generate and verify the full pilot."
    )
    parser.add_argument(
        "--design-only", action="store_true", help="Write only the frozen design."
    )
    args = parser.parse_args()
    parameters = design_parameters()
    splits = split_assignments(parameters)
    if args.design_only:
        DATA_DIR.mkdir(parents=True, exist_ok=True)
        _write_jsonl_atomic(
            DESIGN_PATH,
            [
                {
                    "id": f"{index:05d}",
                    "case_id": case_identity(row),
                    "split": splits[index],
                    "parameters": row,
                }
                for index, row in enumerate(parameters)
            ],
        )
        print(DESIGN_PATH)
        return
    if args.generate:
        generate()
        return
    parser.error("Choose --generate or --design-only.")


if __name__ == "__main__":
    main()