"""Generate the 1,000-trajectory DENIM capability extension v4. The extension targets four gaps left by the frozen 2,660-trajectory release: long-cycle state drift, full six-component loading, finite-element-derived local paths, and paired time-discretization/observation robustness. Existing data and splits are never overwritten. One sample remains one complete history. The structure-derived cohort is deliberately explicit about its fidelity: an AgentFEM linear-elastic solve supplies three local unit-load strain bases for four perforated/notched plates. Time-dependent load coefficients are then superposed and replayed through the same nonlinear hidden reference material used by the DENIM closure study. This produces genuine FE-derived local path shapes without claiming fully coupled elastoplastic redistribution. """ from __future__ import annotations import argparse import csv import hashlib import json import math import os import subprocess import time from collections import Counter from pathlib import Path from typing import Iterable import h5py import numpy as np from src.generate_t2_denim_boundary_v1 import quality as boundary_quality from src.generate_t2_graybox_closure import MATERIAL, material from src.t2_multiaxial_ood_v2 import PATH_FAMILIES, strain_history, tensor_to_voigt ROOT = Path(__file__).resolve().parents[1] CONFIG_PATH = ROOT / "configs" / "t2_denim_capability_v4.json" DATA_DIR = ROOT / "data" / "t2_denim_capability_v4" DATA_PATH = DATA_DIR / "cohort.h5" INDEX_PATH = DATA_DIR / "index.jsonl" INDEX_CSV_PATH = DATA_DIR / "index.csv" MANIFEST_PATH = DATA_DIR / "manifest.json" STRUCTURE_BASIS_PATH = DATA_DIR / "structure_bases.npz" ARTIFACT_DIR = ROOT / "artifacts" / "t2_denim_capability_v4" AGENTFEM_ROOT = Path("/Users/luo/Desktop/开发环境/fenicsx-code/agentfem") FULL_3D_FAMILIES = ( "triaxial_phase_lissajous", "principal_axis_rotation_3d", "three_shear_rotation", "hydro_deviatoric_sequence", "six_component_random_blocks", "biaxial_torsion_reversal", ) RESOLUTIONS = (61, 121, 241, 481) STRUCTURE_SPECS = ( ("central_hole_r018", "central_hole", 0.18), ("central_hole_r026", "central_hole", 0.26), ("double_notch_r016", "double_edge_notch", 0.16), ("double_notch_r024", "double_edge_notch", 0.24), ) def load_config() -> dict[str, object]: return json.loads(CONFIG_PATH.read_text(encoding="utf-8")) def _sha256(path: Path) -> str: digest = hashlib.sha256() with path.open("rb") as handle: for block in iter(lambda: handle.read(1024 * 1024), b""): digest.update(block) return digest.hexdigest() def _write_json(path: Path, value: object) -> None: path.parent.mkdir(parents=True, exist_ok=True) 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 _polyline(anchors: np.ndarray, count: int) -> np.ndarray: anchors = np.asarray(anchors, dtype=float) distances = np.linalg.norm(np.diff(anchors, axis=0), axis=1) cumulative = np.concatenate(([0.0], np.cumsum(distances))) if cumulative[-1] <= 0.0: return np.repeat(anchors[:1], count, axis=0) target = np.linspace(0.0, cumulative[-1], count) return np.column_stack( [np.interp(target, cumulative, anchors[:, column]) for column in range(anchors.shape[1])] ) def _symmetric_from_voigt(values: np.ndarray) -> np.ndarray: selected = np.asarray(values, dtype=float) tensor = np.zeros((*selected.shape[:-1], 3, 3), dtype=float) tensor[..., 0, 0] = selected[..., 0] tensor[..., 1, 1] = selected[..., 1] tensor[..., 2, 2] = selected[..., 2] tensor[..., 0, 1] = tensor[..., 1, 0] = selected[..., 3] tensor[..., 1, 2] = tensor[..., 2, 1] = selected[..., 4] tensor[..., 0, 2] = tensor[..., 2, 0] = selected[..., 5] return tensor def _equivalent_strain(strains: np.ndarray) -> np.ndarray: selected = np.asarray(strains, dtype=float) trace = np.trace(selected, axis1=-2, axis2=-1)[..., None, None] dev = selected - trace / 3.0 * np.eye(3) return np.sqrt(np.maximum(2.0 / 3.0 * np.sum(dev * dev, axis=(-2, -1)), 0.0)) def _scale_history(strains: np.ndarray, amplitude: float) -> np.ndarray: selected = np.asarray(strains, dtype=float) selected = 0.5 * (selected + np.swapaxes(selected, -1, -2)) scale = float(np.max(_equivalent_strain(selected))) if scale <= np.finfo(float).eps: raise ValueError("History has zero equivalent-strain amplitude.") return selected * (float(amplitude) / scale) def _base_parameters( *, index: int, family: str, amplitude: float, seed: int, points: int ) -> dict[str, object]: rng = np.random.default_rng(seed) return { **MATERIAL, "case_id": f"denim-capability-v4-{index:05d}", "material_model": "hidden_three_memory_tabulated_hardening", "path_family": family, "path_seed": int(seed), "path_shape_a": float(rng.random()), "path_shape_b": float(rng.random()), "path_shape_c": float(rng.random()), "yield_design_coordinate": float(rng.random()), "maximum_equivalent_strain": float(amplitude), "points": int(points), } def design(seed: int = 20260925) -> list[dict[str, object]]: """Create exactly 1,000 deterministic records with frozen cohort roles.""" rng = np.random.default_rng(seed) rows: list[dict[str, object]] = [] # 300 long-cycle histories. Training sees 10/25 cycles, validation 50, # and the frozen test remains a true 100-cycle horizon extrapolation. long_roles = ( (180, "train_long_cycle", (10, 25)), (40, "validation_long_cycle", (50,)), (80, "test_long_cycle_ood", (100,)), ) for count, split, cycle_options in long_roles: for local in range(count): cycles = int(cycle_options[local % len(cycle_options)]) points = cycles * 20 + 1 family = PATH_FAMILIES[(len(rows) + local) % len(PATH_FAMILIES)] row = _base_parameters( index=len(rows), family=family, amplitude=float(rng.uniform(0.003, 0.010)), seed=int(seed + len(rows) * 104729), points=points, ) row.update( cohort="long_cycle", split=split, group_id=row["case_id"], cycle_count=cycles, increments_per_cycle=20, observation_protocol="clean", ) rows.append(row) # 300 full six-component histories. Four families are available to train, # principal-axis rotation validates, and random six-component blocks are # held out as a shape-OOD family. for family in FULL_3D_FAMILIES: for local in range(50): if family in FULL_3D_FAMILIES[:4]: split = "train_full_3d" if local < 36 else "validation_full_3d" elif family == "principal_axis_rotation_3d": split = "validation_full_3d" else: split = "test_full_3d_ood" row = _base_parameters( index=len(rows), family=family, amplitude=float(rng.uniform(0.003, 0.014)), seed=int(seed + len(rows) * 130363), points=241, ) row.update( cohort="full_3d_nonproportional", split=split, group_id=row["case_id"], cycle_count=1, observation_protocol="clean", ) rows.append(row) # 200 structure-derived probe histories, 50 from each FE source group. for structure_name, structure_kind, radius in STRUCTURE_SPECS: for probe_index in range(50): family = ( "fe_tension_shear_lissajous", "fe_tension_bending_sequence", "fe_reversed_mixed_cycle", "fe_random_load_blocks", "fe_rotating_load_vector", )[probe_index % 5] row = _base_parameters( index=len(rows), family=family, amplitude=float(rng.uniform(0.003, 0.012)), seed=int(seed + len(rows) * 15485863), points=241, ) row.update( cohort="structure_derived", split="test_structure_derived", group_id=structure_name, structure_name=structure_name, structure_kind=structure_kind, structure_radius=float(radius), probe_index=int(probe_index), cycle_count=1, observation_protocol="clean", ) rows.append(row) # 50 unique continuous paths at four matched resolutions = 200 records. # Noise and sparse observation masks are fields, not extra fake samples. for matched_index in range(50): family = PATH_FAMILIES[matched_index % len(PATH_FAMILIES)] shared_seed = int(seed + 900_000 + matched_index * 32452843) shared_rng = np.random.default_rng(shared_seed) amplitude = float(shared_rng.uniform(0.003, 0.012)) shared_shapes = shared_rng.random(3) for points in RESOLUTIONS: row = _base_parameters( index=len(rows), family=family, amplitude=amplitude, seed=shared_seed, points=points, ) row["path_shape_a"], row["path_shape_b"], row["path_shape_c"] = ( float(value) for value in shared_shapes ) row.update( cohort="discretization_and_observation", split="test_discretization_observation", group_id=f"matched-resolution-{matched_index:03d}", matched_path_id=f"matched-resolution-{matched_index:03d}", cycle_count=1, observation_protocol="noisy_sparse_paired", strain_noise_fraction=float(shared_rng.uniform(0.0005, 0.0030)), stress_noise_fraction=float(shared_rng.uniform(0.0005, 0.0050)), observation_keep_fraction=float(shared_rng.uniform(0.20, 0.65)), ) rows.append(row) if len(rows) != 1000: raise RuntimeError(f"Capability extension must contain 1,000 rows, got {len(rows)}.") if len({str(row["case_id"]) for row in rows}) != len(rows): raise RuntimeError("Case IDs are not unique.") return rows def _long_cycle_history(row: dict[str, object]) -> np.ndarray: cycles = int(row["cycle_count"]) per_cycle = int(row["increments_per_cycle"]) + 1 _, one_cycle = strain_history(row, points=per_cycle) pieces = [one_cycle] pieces.extend(one_cycle[1:] for _ in range(cycles - 1)) history = np.concatenate(pieces, axis=0) if len(history) != int(row["points"]): raise RuntimeError("Long-cycle path length does not match the design.") return history def _rotation(axis: np.ndarray, angle: np.ndarray) -> np.ndarray: axis = np.asarray(axis, dtype=float) axis /= np.linalg.norm(axis) cross = np.asarray( ((0.0, -axis[2], axis[1]), (axis[2], 0.0, -axis[0]), (-axis[1], axis[0], 0.0)) ) outer = np.outer(axis, axis) rotations = [] for value in np.asarray(angle, dtype=float): rotations.append( np.cos(value) * np.eye(3) + (1.0 - np.cos(value)) * outer + np.sin(value) * cross ) return np.asarray(rotations) def _full_3d_history(row: dict[str, object]) -> np.ndarray: count = int(row["points"]) time_coordinate = np.linspace(0.0, 1.0, count) phase = 2.0 * np.pi * time_coordinate family = str(row["path_family"]) a = float(row["path_shape_a"]) b = float(row["path_shape_b"]) c = float(row["path_shape_c"]) rng = np.random.default_rng(int(row["path_seed"])) if family == "triaxial_phase_lissajous": values = np.column_stack( ( np.sin(phase), 0.75 * np.sin(2.0 * phase + 0.3 + a), 0.55 * np.sin(3.0 * phase + 0.7 + b), 0.45 * np.sin(phase + np.pi / 3.0), 0.35 * np.sin(2.0 * phase + np.pi / 5.0), 0.30 * np.sin(3.0 * phase + np.pi / 7.0), ) ) return _scale_history(_symmetric_from_voigt(values), float(row["maximum_equivalent_strain"])) if family == "principal_axis_rotation_3d": principal = np.column_stack( ( np.sin(phase), -0.55 * np.sin(phase), -0.45 * np.sin(phase), ) ) rotations = _rotation(np.asarray((1.0, 1.0 + a, 0.5 + b)), 2.0 * phase) diagonal = np.asarray([np.diag(value) for value in principal]) tensors = np.einsum("nij,njk,nlk->nil", rotations, diagonal, rotations) return _scale_history(tensors, float(row["maximum_equivalent_strain"])) if family == "three_shear_rotation": values = np.column_stack( ( np.zeros(count), np.zeros(count), np.zeros(count), np.sin(phase), np.sin(phase + 2.0 * np.pi / 3.0), np.sin(phase + 4.0 * np.pi / 3.0), ) ) return _scale_history(_symmetric_from_voigt(values), float(row["maximum_equivalent_strain"])) if family == "hydro_deviatoric_sequence": amplitude = 0.6 + 0.4 * a anchors = np.asarray( ( (0, 0, 0, 0, 0, 0), (1, 1, 1, 0, 0, 0), (1 + amplitude, 1 - amplitude, 1, 0, 0, 0), (-0.7, -0.7, -0.7, 0.6, 0, 0), (0.8, -0.4, -0.4, 0, 0.55, 0.35), (0, 0, 0, 0, 0, 0), ), dtype=float, ) return _scale_history(_symmetric_from_voigt(_polyline(anchors, count)), float(row["maximum_equivalent_strain"])) if family == "six_component_random_blocks": directions = rng.normal(size=(9, 6)) directions /= np.linalg.norm(directions, axis=1, keepdims=True) directions[1::2] *= -1.0 directions[:, :3] += 0.15 * rng.normal(size=(9, 1)) anchors = np.vstack((np.zeros(6), directions, np.zeros(6))) return _scale_history(_symmetric_from_voigt(_polyline(anchors, count)), float(row["maximum_equivalent_strain"])) if family == "biaxial_torsion_reversal": ratio = 0.4 + 0.4 * c anchors = np.asarray( ( (0, 0, 0, 0, 0, 0), (1, -0.4, 0, ratio, 0, 0), (-0.8, 0.5, 0, ratio, 0.5, 0), (0.6, 0.2, -0.5, -ratio, 0, 0.45), (-0.5, -0.3, 0.4, 0, -0.55, -0.25), (0, 0, 0, 0, 0, 0), ), dtype=float, ) return _scale_history(_symmetric_from_voigt(_polyline(anchors, count)), float(row["maximum_equivalent_strain"])) raise ValueError(f"Unknown full-3D family: {family}") def _load_coefficients(row: dict[str, object]) -> np.ndarray: count = int(row["points"]) t = np.linspace(0.0, 1.0, count) phase = 2.0 * np.pi * t family = str(row["path_family"]) rng = np.random.default_rng(int(row["path_seed"])) if family == "fe_tension_shear_lissajous": return np.column_stack((np.sin(phase), 0.75 * np.sin(2.0 * phase + 0.4), 0.35 * np.sin(phase + 1.1))) if family == "fe_tension_bending_sequence": return _polyline(np.asarray(((0, 0, 0), (1, 0, 0), (0.6, 0, 0.8), (-0.5, 0.7, 0.6), (0, 0, 0))), count) if family == "fe_reversed_mixed_cycle": return _polyline(np.asarray(((0, 0, 0), (1, 0.4, 0), (-0.8, 0.4, 0.5), (0.7, -0.6, -0.4), (-0.4, 0.3, 0.7), (0, 0, 0))), count) if family == "fe_random_load_blocks": anchors = rng.normal(size=(8, 3)) anchors /= np.maximum(np.linalg.norm(anchors, axis=1, keepdims=True), 1.0e-15) anchors[1::2] *= -1.0 return _polyline(np.vstack((np.zeros(3), anchors, np.zeros(3))), count) if family == "fe_rotating_load_vector": return np.column_stack((np.sin(phase), np.cos(phase) - 1.0, 0.6 * np.sin(2.0 * phase))) raise ValueError(f"Unknown FE load-coefficient family: {family}") def _make_gmsh_domain(kind: str, radius: float): import gmsh from agentfem import mesh if not gmsh.isInitialized(): gmsh.initialize() gmsh.clear() gmsh.option.setNumber("General.Terminal", 0) gmsh.model.add(f"denim_v4_{kind}_{radius:.3f}") length, height = 2.0, 1.0 plate = gmsh.model.occ.addRectangle(0.0, 0.0, 0.0, length, height) if kind == "central_hole": tool = gmsh.model.occ.addDisk(1.0, 0.5, 0.0, radius, radius) surfaces, _ = gmsh.model.occ.cut([(2, plate)], [(2, tool)]) elif kind == "double_edge_notch": lower = gmsh.model.occ.addDisk(1.0, 0.0, 0.0, radius, radius) upper = gmsh.model.occ.addDisk(1.0, 1.0, 0.0, radius, radius) surfaces, _ = gmsh.model.occ.cut([(2, plate)], [(2, lower), (2, upper)]) else: raise ValueError(f"Unknown structure kind: {kind}") gmsh.model.occ.synchronize() gmsh.model.addPhysicalGroup(2, [tag for _, tag in surfaces], 1) gmsh.option.setNumber("Mesh.MeshSizeMin", 0.045) gmsh.option.setNumber("Mesh.MeshSizeMax", 0.10) gmsh.model.mesh.generate(2) return mesh.import_gmsh_model(gmsh.model, gdim=2).domain def _solve_unit_strain(domain, *, traction: tuple[float, float], side: str) -> tuple[np.ndarray, np.ndarray]: from agentfem import constitutive, fields, mesh, models, studies from agentfem.solvers import LinearSolverOptions model = models.create( study=studies.static_solid(dimension=2, assumption="plane_stress"), mesh=domain, ) displacement = model.field(fields.displacement(domain, degree=1)) model.material(constitutive.isotropic_elastic(young=190.0e9, poisson=0.30, density=7800.0)) left = mesh.boundary(domain, lambda x: np.isclose(x[0], 0.0), tag=101) model.fix(displacement, on=left, value=0.0) if side == "right": boundary = mesh.boundary(domain, lambda x: np.isclose(x[0], 2.0), tag=102) elif side == "top": boundary = mesh.boundary(domain, lambda x: np.isclose(x[1], 1.0), tag=103) else: raise ValueError(f"Unknown loaded side: {side}") model.traction(traction, on=boundary) result = model.step( target=displacement, solver_options=LinearSolverOptions(ksp_type="preonly", pc_type="lu"), ).solve_result(field_variables=("E",)) result.verify("engineering").require() field = result.fields["E"].field coordinates = field.function_space.tabulate_dof_coordinates() raw = np.asarray(field.x.array, dtype=float).reshape((-1, 4)) tensor = np.zeros((len(raw), 3, 3), dtype=float) tensor[:, 0, 0] = raw[:, 0] tensor[:, 0, 1] = tensor[:, 1, 0] = 0.5 * (raw[:, 1] + raw[:, 2]) tensor[:, 1, 1] = raw[:, 3] return np.asarray(coordinates, dtype=float), tensor def build_structure_bases(*, force: bool = False) -> dict[str, dict[str, np.ndarray]]: """Solve 12 AgentFEM unit-load cases and retain 50 probe bases per structure.""" if STRUCTURE_BASIS_PATH.exists() and not force: loaded = np.load(STRUCTURE_BASIS_PATH, allow_pickle=False) result: dict[str, dict[str, np.ndarray]] = {} for name, _, _ in STRUCTURE_SPECS: result[name] = { "coordinates": loaded[f"{name}__coordinates"], "basis": loaded[f"{name}__basis"], "cell_indices": loaded[f"{name}__cell_indices"], } return result collected: dict[str, np.ndarray] = {} result = {} for name, kind, radius in STRUCTURE_SPECS: domain = _make_gmsh_domain(kind, radius) mode_outputs = ( _solve_unit_strain(domain, traction=(1.0e6, 0.0), side="right"), _solve_unit_strain(domain, traction=(0.0, 1.0e6), side="right"), _solve_unit_strain(domain, traction=(0.0, 1.0e6), side="top"), ) coordinates = mode_outputs[0][0] if any(not np.allclose(coordinates, item[0]) for item in mode_outputs[1:]): raise RuntimeError("DG0 strain-field coordinates changed between unit-load modes.") bases = np.stack([item[1] for item in mode_outputs], axis=1) score = np.linalg.norm(bases.reshape((len(bases), -1)), axis=1) valid = np.flatnonzero(score > np.quantile(score, 0.20)) order = valid[np.argsort(score[valid])] positions = np.linspace(0, len(order) - 1, 50).round().astype(int) selected = order[positions] selected_coordinates = coordinates[selected] selected_bases = bases[selected] result[name] = { "coordinates": selected_coordinates, "basis": selected_bases, "cell_indices": selected.astype(np.int64), } collected[f"{name}__coordinates"] = selected_coordinates collected[f"{name}__basis"] = selected_bases collected[f"{name}__cell_indices"] = selected.astype(np.int64) DATA_DIR.mkdir(parents=True, exist_ok=True) np.savez_compressed(STRUCTURE_BASIS_PATH, **collected) return result def _structure_history(row: dict[str, object], bases: dict[str, dict[str, np.ndarray]]) -> tuple[np.ndarray, dict[str, np.ndarray]]: source = bases[str(row["structure_name"])] probe = int(row["probe_index"]) basis = source["basis"][probe] coefficients = _load_coefficients(row) strains = np.einsum("nm,mij->nij", coefficients, basis) strains = _scale_history(strains, float(row["maximum_equivalent_strain"])) metadata = { "source_strain_basis": tensor_to_voigt(basis), "load_mode_coefficients": coefficients, "source_coordinate": source["coordinates"][probe], "source_cell_index": np.asarray([source["cell_indices"][probe]], dtype=np.int64), } return strains, metadata def _standard_history(row: dict[str, object]) -> np.ndarray: _, strains = strain_history(row, points=int(row["points"])) return strains def _integrate_reference(strains: np.ndarray) -> dict[str, np.ndarray]: law = material() count = len(strains) stress = np.empty_like(strains) plastic = np.empty_like(strains) peeq = np.empty(count) increment = np.empty(count) truth_memories = np.empty((count, 3, 3, 3)) latent_memories = np.empty((count, 2, 3, 3)) radius = np.empty(count) state = None for point, strain in enumerate(strains): update = law.update(strain, state, linearization="none") state = update.state stress[point] = update.stress plastic[point] = state.plastic_strain peeq[point] = state.equivalent_plastic_strain increment[point] = update.plastic_multiplier_increment truth_memories[point] = state.backstresses latent_memories[point, 0] = state.backstresses[0] latent_memories[point, 1] = state.backstresses[1] + state.backstresses[2] radius[point] = law.current_yield_stress(peeq[point]) - law.yield_stress return { "strain": tensor_to_voigt(strains), "stress_pa": tensor_to_voigt(stress), "plastic_strain": tensor_to_voigt(plastic), "peeq": peeq, "plastic_increment": increment, "memories_pa": tensor_to_voigt(latent_memories), "truth_memories_pa": tensor_to_voigt(truth_memories), "isotropic_radius_pa": radius, "time_coordinate": np.linspace(0.0, 1.0, count), } def _add_observations(row: dict[str, object], arrays: dict[str, np.ndarray]) -> None: if row["cohort"] != "discretization_and_observation": return rng = np.random.default_rng(int(row["path_seed"]) + int(row["points"]) * 1009) strain = arrays["strain"] stress = arrays["stress_pa"] strain_scale = max(float(np.max(np.abs(strain))), 1.0e-12) stress_scale = max(float(np.max(np.abs(stress))), 1.0) observed_strain = strain + rng.normal( scale=float(row["strain_noise_fraction"]) * strain_scale, size=strain.shape, ) observed_stress = stress + rng.normal( scale=float(row["stress_noise_fraction"]) * stress_scale, size=stress.shape, ) keep = float(row["observation_keep_fraction"]) mask = rng.random(len(strain)) < keep mask[0] = True mask[-1] = True arrays["observed_strain"] = observed_strain arrays["observed_stress_pa"] = observed_stress arrays["observation_mask"] = mask.astype(np.uint8) def solve_row(row: dict[str, object], bases: dict[str, dict[str, np.ndarray]]) -> tuple[dict[str, np.ndarray], dict[str, float | bool]]: cohort = str(row["cohort"]) extras: dict[str, np.ndarray] = {} if cohort == "long_cycle": strains = _long_cycle_history(row) elif cohort == "full_3d_nonproportional": strains = _full_3d_history(row) elif cohort == "structure_derived": strains, extras = _structure_history(row, bases) elif cohort == "discretization_and_observation": strains = _standard_history(row) else: raise ValueError(f"Unknown cohort: {cohort}") arrays = _integrate_reference(strains) arrays.update(extras) _add_observations(row, arrays) metrics = boundary_quality(arrays) metrics["maximum_equivalent_total_strain"] = float(np.max(_equivalent_strain(strains))) metrics["trajectory_point_count"] = int(len(strains)) metrics["plastic_step_count"] = int(np.count_nonzero(arrays["plastic_increment"] > 1.0e-12)) return arrays, metrics def _agentfem_commit() -> str: return subprocess.run( ("git", "rev-parse", "HEAD"), cwd=AGENTFEM_ROOT, check=True, capture_output=True, text=True, ).stdout.strip() def _record(row: dict[str, object], metrics: dict[str, float | bool]) -> dict[str, object]: return { "sample_id": str(row["case_id"]), "cohort": str(row["cohort"]), "split": str(row["split"]), "group_id": str(row["group_id"]), "path_family": str(row["path_family"]), "points": int(row["points"]), "cycle_count": int(row["cycle_count"]), "maximum_equivalent_strain": float(row["maximum_equivalent_strain"]), "all_finite": bool(metrics["all_finite"]), "plastic_step_count": int(metrics["plastic_step_count"]), "maximum_absolute_stress_pa": float(metrics["maximum_absolute_stress_pa"]), "maximum_peeq": float(metrics["maximum_peeq"]), "maximum_yield_surface_relative_residual": float(metrics["maximum_yield_surface_relative_residual"]), "minimum_peeq_increment": float(metrics["minimum_peeq_increment"]), "maximum_plastic_strain_trace": float(metrics["maximum_plastic_strain_trace"]), "observation_protocol": str(row["observation_protocol"]), } def generate(*, force: bool = False, limit: int | None = None) -> dict[str, object]: rows = design() if limit is not None: rows = rows[: int(limit)] DATA_DIR.mkdir(parents=True, exist_ok=True) ARTIFACT_DIR.mkdir(parents=True, exist_ok=True) if DATA_PATH.exists() and not force: raise FileExistsError(f"{DATA_PATH} exists; pass --force to replace it.") need_structures = any(row["cohort"] == "structure_derived" for row in rows) bases = build_structure_bases(force=force) if need_structures else {} temporary = DATA_PATH.with_suffix(".h5.tmp") records: list[dict[str, object]] = [] started = time.perf_counter() with h5py.File(temporary, "w") as h5: h5.attrs["schema"] = "agentfem.physics-data.denim-capability-extension" h5.attrs["schema_version"] = "4.0.0" h5.attrs["material_json"] = json.dumps(MATERIAL, sort_keys=True) h5.attrs["scope"] = str(load_config()["scope"]) for index, row in enumerate(rows): arrays, metrics = solve_row(row, bases) if not bool(metrics["all_finite"]): raise RuntimeError(f"Non-finite trajectory at index {index}.") if float(metrics["minimum_peeq_increment"]) < -1.0e-12: raise RuntimeError(f"PEEQ decreased at index {index}.") if float(metrics["maximum_yield_surface_relative_residual"]) > 1.0e-8: raise RuntimeError(f"Yield residual failed at index {index}.") group = h5.create_group(f"{index:05d}") for key in ( "case_id", "cohort", "split", "group_id", "path_family", "observation_protocol", ): group.attrs[key] = str(row[key]) group.attrs["points"] = int(row["points"]) group.attrs["cycle_count"] = int(row["cycle_count"]) group.attrs["parameters_json"] = json.dumps(row, sort_keys=True) group.attrs["quality_json"] = json.dumps(metrics, sort_keys=True) for name, value in arrays.items(): group.create_dataset(name, data=value, compression="gzip", shuffle=True) records.append(_record(row, metrics)) if (index + 1) % 50 == 0 or index + 1 == len(rows): print(f"generated {index + 1}/{len(rows)}", flush=True) os.replace(temporary, DATA_PATH) INDEX_PATH.write_text( "".join(json.dumps(record, sort_keys=True) + "\n" for record in records), encoding="utf-8", ) with INDEX_CSV_PATH.open("w", newline="", encoding="utf-8") as handle: writer = csv.DictWriter(handle, fieldnames=list(records[0])) writer.writeheader() writer.writerows(records) manifest: dict[str, object] = { "schema": "agentfem.physics-data.denim-capability-extension", "schema_version": "4.0.0", "sample_count": len(records), "complete_release": len(records) == 1000, "cohort_counts": dict(sorted(Counter(record["cohort"] for record in records).items())), "split_counts": dict(sorted(Counter(record["split"] for record in records).items())), "path_family_counts": dict(sorted(Counter(record["path_family"] for record in records).items())), "point_count_distribution": dict(sorted(Counter(str(record["points"]) for record in records).items())), "group_count": len({record["group_id"] for record in records}), "data_sha256": _sha256(DATA_PATH), "index_jsonl_sha256": _sha256(INDEX_PATH), "index_csv_sha256": _sha256(INDEX_CSV_PATH), "structure_bases_sha256": _sha256(STRUCTURE_BASIS_PATH) if STRUCTURE_BASIS_PATH.exists() else None, "data_bytes": DATA_PATH.stat().st_size, "generation_seconds": time.perf_counter() - started, "agentfem_commit": _agentfem_commit(), "reference_material": "hidden three-memory Chaboche with tabulated isotropic hardening", "quality": { "all_finite_failures": sum(not bool(record["all_finite"]) for record in records), "maximum_yield_surface_relative_residual": max(float(record["maximum_yield_surface_relative_residual"]) for record in records), "minimum_peeq_increment": min(float(record["minimum_peeq_increment"]) for record in records), "maximum_plastic_strain_trace": max(float(record["maximum_plastic_strain_trace"]) for record in records), "minimum_plastic_step_count": min(int(record["plastic_step_count"]) for record in records), }, "structure_fidelity": "AgentFEM linear-elastic unit-load strain bases with one-way nonlinear material replay; no coupled elastoplastic redistribution claim", "counting_rule": "One sample is one complete trajectory. Observation noise/masks are fields, not extra samples. Matched resolutions are explicitly grouped.", } _write_json(MANIFEST_PATH, manifest) _write_json(ARTIFACT_DIR / "quality.json", manifest) return manifest def audit() -> dict[str, object]: manifest = json.loads(MANIFEST_PATH.read_text(encoding="utf-8")) rows = [json.loads(line) for line in INDEX_PATH.read_text(encoding="utf-8").splitlines() if line] with h5py.File(DATA_PATH, "r") as h5: groups = list(h5.keys()) finite_failures = 0 missing = [] for group_name in groups: group = h5[group_name] required = ( "strain", "stress_pa", "plastic_strain", "peeq", "plastic_increment", "memories_pa", "truth_memories_pa", "isotropic_radius_pa", "time_coordinate", ) for name in required: if name not in group: missing.append(f"{group_name}:{name}") elif not np.isfinite(group[name][...]).all(): finite_failures += 1 if group.attrs["cohort"] == "discretization_and_observation": for name in ("observed_strain", "observed_stress_pa", "observation_mask"): if name not in group: missing.append(f"{group_name}:{name}") if group.attrs["cohort"] == "structure_derived": for name in ("source_strain_basis", "load_mode_coefficients", "source_coordinate"): if name not in group: missing.append(f"{group_name}:{name}") audit_result = { "sample_count": len(rows), "hdf5_group_count": len(groups), "case_id_unique": len({row["sample_id"] for row in rows}) == len(rows), "missing_required_fields": missing, "nonfinite_required_field_count": finite_failures, "data_sha256_matches_manifest": _sha256(DATA_PATH) == manifest["data_sha256"], "grouped_resolution_protocol": all( len([row for row in rows if row["group_id"] == group_id]) == 4 for group_id in {row["group_id"] for row in rows if row["cohort"] == "discretization_and_observation"} ), "structure_group_count": len({row["group_id"] for row in rows if row["cohort"] == "structure_derived"}), } audit_result["passed"] = bool( audit_result["sample_count"] == 1000 and audit_result["hdf5_group_count"] == 1000 and audit_result["case_id_unique"] and not audit_result["missing_required_fields"] and audit_result["nonfinite_required_field_count"] == 0 and audit_result["data_sha256_matches_manifest"] and audit_result["grouped_resolution_protocol"] and audit_result["structure_group_count"] == 4 ) _write_json(ARTIFACT_DIR / "audit.json", audit_result) return audit_result def main() -> None: parser = argparse.ArgumentParser() parser.add_argument("--force", action="store_true") parser.add_argument("--limit", type=int) parser.add_argument("--audit-only", action="store_true") args = parser.parse_args() if args.audit_only: report = audit() else: report = generate(force=args.force, limit=args.limit) if args.limit is None: report = {"generation": report, "audit": audit()} print(json.dumps(report, indent=2, sort_keys=True)) if __name__ == "__main__": main()