"""Embed learned constitutive histories in a displacement-controlled bar FE test. This is a controlled one-dimensional structural deployment gate. The global finite-element equilibrium is solved independently for a smooth notched bar, while each element obtains its path-dependent generalized stress either from the native AgentFEM Chaboche update or from a trained neural constitutive model. It is not presented as a general three-dimensional learned-material provider for AgentFEM. """ from __future__ import annotations import argparse import json import time from pathlib import Path import matplotlib matplotlib.use("Agg") import matplotlib.pyplot as plt import numpy as np import torch from scipy.optimize import least_squares from agentfem import constitutive try: from src import train_t2_multiaxial_models as learning from src import train_t2_physics_integrator as physics_integrator except ModuleNotFoundError: import train_t2_multiaxial_models as learning import train_t2_physics_integrator as physics_integrator ROOT = Path(__file__).resolve().parents[1] MODEL_ROOT = ROOT / "models" / "t2_multiaxial_ood_v2" ARTIFACT_ROOT = ROOT / "artifacts" / "t2_multiaxial_ood_v2" / "structural_validation" BASIS = np.diag((1.0, -0.5, -0.5)) BASIS_VOIGT = np.asarray((1.0, -0.5, -0.5, 0.0, 0.0, 0.0)) MATERIAL_PARAMETERS = np.asarray( ( 190.0e9, 0.30, 280.0e6, 0.0, 35.0e9, 60.0, 8.0e9, 8.0, 70.0e6, 8.0, ), dtype=float, ) def load_history(points: int = 81, *, scale: float = 1.0) -> np.ndarray: anchors = np.asarray((0.0, 0.0035, -0.0025, 0.0055, -0.0035, 0.0065, 0.0)) positions = np.linspace(0.0, len(anchors) - 1, points) lower = np.minimum(np.floor(positions).astype(int), len(anchors) - 2) fraction = positions - lower return scale * ((1.0 - fraction) * anchors[lower] + fraction * anchors[lower + 1]) def material() -> constitutive.ChabocheCombinedHardening: p = MATERIAL_PARAMETERS return constitutive.chaboche( young=float(p[0]), poisson=float(p[1]), yield_stress=float(p[2]), backstresses=((float(p[4]), float(p[5])), (float(p[6]), float(p[7]))), isotropic_saturation=float(p[8]), isotropic_rate=float(p[9]), ) def _normalization(values: dict[str, object]) -> learning.Normalization: def tensor(name: str, shape: tuple[int, ...]) -> torch.Tensor: return torch.tensor(values[name], dtype=torch.float32).reshape(shape) return learning.Normalization( strain_mean=tensor("strain_mean", (1, 1, 6)), strain_std=tensor("strain_std", (1, 1, 6)), parameter_mean=tensor("parameter_mean", (1, 10)), parameter_std=tensor("parameter_std", (1, 10)), stress_mean=tensor("stress_mean", (1, 1, 6)), stress_std=tensor("stress_std", (1, 1, 6)), plastic_scale=tensor("plastic_scale", (1, 1, 6)), backstress_scale=tensor("backstress_scale", (1, 1, 6)), peeq_scale=tensor("peeq_scale", (1, 1)), ) def load_checkpoint(name: str): if name == physics_integrator.MODEL_NAME: return physics_integrator.load_checkpoint("id") path = MODEL_ROOT / f"id_{name}.pt" checkpoint = torch.load(path, map_location="cpu", weights_only=False) model = learning.build_model(str(checkpoint["model_name"]), int(checkpoint["input_size"])) model.load_state_dict(checkpoint["state_dict"]) model.eval() return model, _normalization(checkpoint["normalization"]) def neural_response( model: torch.nn.Module, model_name: str, norm, history: list[float], ) -> tuple[float, float]: previous = torch.tensor(history[:-1], dtype=torch.float32) current = torch.tensor(float(history[-1]), dtype=torch.float32, requires_grad=True) scalar = torch.cat((previous, current.reshape(1))) strain = scalar[:, None] * torch.tensor(BASIS_VOIGT, dtype=torch.float32)[None, :] parameters = torch.tensor(MATERIAL_PARAMETERS, dtype=torch.float32).reshape(1, 10) if model_name == physics_integrator.MODEL_NAME: parameter_mean, parameter_std, correction_steps = norm output = physics_integrator.rollout( strain[None, ...], parameters, model, parameter_mean, parameter_std, correction_steps=correction_steps, )["stress"] generalized = output[0, -1, 0] - 0.5 * output[0, -1, 1] - 0.5 * output[0, -1, 2] tangent = torch.autograd.grad(generalized, current, create_graph=False)[0] return float(generalized.detach()), float(tangent.detach()) normalized_strain = (strain[None, ...] - norm.strain_mean) / norm.strain_std normalized_parameters = (parameters - norm.parameter_mean) / norm.parameter_std repeated = normalized_parameters[:, None, :].expand(1, len(scalar), -1) indicator = torch.tensor((0.0, 1.0), dtype=torch.float32).reshape(1, 1, 2).expand(1, len(scalar), -1) x = torch.cat((normalized_strain, repeated, indicator), dim=-1) if model_name == "physics_state_gru": output = model(x, strain[None, ...], parameters, norm)["stress"] else: output = model(x) * norm.stress_std + norm.stress_mean generalized = ( output[0, -1, 0] - 0.5 * output[0, -1, 1] - 0.5 * output[0, -1, 2] ) tangent = torch.autograd.grad(generalized, current, create_graph=False)[0] return float(generalized.detach()), float(tangent.detach()) def native_response( law: constitutive.ChabocheCombinedHardening, old_state, strain: float, ): update = law.update(float(strain) * BASIS, old_state) generalized = float(np.tensordot(update.stress, BASIS)) tangent = float(np.einsum("ij,ijkl,kl", BASIS, update.algorithmic_tangent, BASIS)) return generalized, tangent, update.state def geometry(elements: int, notch_depth: float = 0.42) -> tuple[np.ndarray, np.ndarray]: nodes = np.linspace(0.0, 1.0, elements + 1) centers = 0.5 * (nodes[:-1] + nodes[1:]) area = 1.0 - float(notch_depth) * np.exp(-((centers - 0.5) / 0.13) ** 2) return nodes, area def solve_native(elements: int, displacement: np.ndarray, *, notch_depth: float = 0.42) -> dict[str, np.ndarray | float | int]: nodes, area = geometry(elements, notch_depth) lengths = np.diff(nodes) law = material() states = [None] * elements strain_histories = [[] for _ in range(elements)] u = np.zeros(elements + 1) reactions = [] strains = [] stresses = [] iterations = [] started = time.perf_counter() for step, end_value in enumerate(displacement): if step > 0: u += np.linspace(0.0, end_value - u[-1], elements + 1) u[0] = 0.0 u[-1] = end_value converged_states = None for iteration in range(30): internal = np.zeros(elements + 1) stiffness = np.zeros((elements + 1, elements + 1)) trial_states = [] current_strain = np.diff(u) / lengths current_stress = np.empty(elements) for element in range(elements): stress, tangent, state = native_response(law, states[element], current_strain[element]) current_stress[element] = stress trial_states.append(state) b = np.asarray((-1.0 / lengths[element], 1.0 / lengths[element])) dofs = (element, element + 1) internal[list(dofs)] += area[element] * stress * b * lengths[element] stiffness[np.ix_(dofs, dofs)] += area[element] * tangent * np.outer(b, b) * lengths[element] residual = internal[1:-1] scale = max(float(np.linalg.norm(internal)), 1.0) if np.linalg.norm(residual) <= 1.0e-8 * scale + 1.0e-3: converged_states = trial_states break u[1:-1] -= np.linalg.solve(stiffness[1:-1, 1:-1], residual) if converged_states is None: raise RuntimeError(f"Native structural solve failed at step {step}.") states = converged_states current_strain = np.diff(u) / lengths for element, value in enumerate(current_strain): strain_histories[element].append(float(value)) reactions.append(float(internal[-1])) strains.append(current_strain.copy()) stresses.append(current_stress.copy()) iterations.append(iteration + 1) return { "displacement": displacement, "reaction": np.asarray(reactions), "strain": np.asarray(strains), "stress": np.asarray(stresses), "nodes": nodes, "area": area, "iterations": np.asarray(iterations), "elapsed_seconds": time.perf_counter() - started, } def solve_neural( elements: int, displacement: np.ndarray, model_name: str, *, notch_depth: float = 0.42, ) -> dict[str, np.ndarray | float | int]: if model_name == physics_integrator.MODEL_NAME: return solve_physics_integrator( elements, displacement, notch_depth=notch_depth ) nodes, area = geometry(elements, notch_depth) lengths = np.diff(nodes) loaded = load_checkpoint(model_name) if model_name == physics_integrator.MODEL_NAME: model, parameter_mean, parameter_std, correction_steps = loaded norm = (parameter_mean, parameter_std, correction_steps) else: model, norm = loaded histories = [[] for _ in range(elements)] u = np.zeros(elements + 1) reactions = [] strains = [] stresses = [] iterations = [] started = time.perf_counter() for step, end_value in enumerate(displacement): if step > 0: u += np.linspace(0.0, end_value - u[-1], elements + 1) u[0] = 0.0 u[-1] = end_value converged = False for iteration in range(40): internal = np.zeros(elements + 1) stiffness = np.zeros((elements + 1, elements + 1)) current_strain = np.diff(u) / lengths current_stress = np.empty(elements) for element in range(elements): history = histories[element] + [float(current_strain[element])] stress, tangent = neural_response(model, model_name, norm, history) current_stress[element] = stress # Prevent a local noisy or nearly singular learned derivative from # destroying the global linear solve; the event is counted below. if not np.isfinite(tangent) or tangent <= 0.0: raise RuntimeError( f"{physics_integrator.MODEL_NAME} produced an invalid tangent " f"({tangent}) at step {step}." ) b = np.asarray((-1.0 / lengths[element], 1.0 / lengths[element])) dofs = (element, element + 1) internal[list(dofs)] += area[element] * stress * b * lengths[element] stiffness[np.ix_(dofs, dofs)] += area[element] * tangent * np.outer(b, b) * lengths[element] residual = internal[1:-1] scale = max(float(np.linalg.norm(internal)), 1.0) if np.linalg.norm(residual) <= 2.0e-6 * scale + 1.0e2: converged = True break increment = np.linalg.solve(stiffness[1:-1, 1:-1], residual) maximum = 0.20 * max(abs(end_value), 1.0e-5) norm_increment = np.max(np.abs(increment)) if norm_increment > maximum: increment *= maximum / norm_increment u[1:-1] -= increment if not converged: raise RuntimeError(f"{model_name} structural solve failed at step {step}.") current_strain = np.diff(u) / lengths for element, value in enumerate(current_strain): histories[element].append(float(value)) reactions.append(float(internal[-1])) strains.append(current_strain.copy()) stresses.append(current_stress.copy()) iterations.append(iteration + 1) return { "displacement": displacement, "reaction": np.asarray(reactions), "strain": np.asarray(strains), "stress": np.asarray(stresses), "nodes": nodes, "area": area, "iterations": np.asarray(iterations), "elapsed_seconds": time.perf_counter() - started, } def _detach_state(state: physics_integrator.State) -> physics_integrator.State: return physics_integrator.State( state.plastic.detach(), state.peeq.detach(), state.alpha1.detach(), state.alpha2.detach(), ) def physics_increment_response( model: torch.nn.Module, parameter_mean: torch.Tensor, parameter_std: torch.Tensor, correction_steps: int, committed: physics_integrator.State, previous_strain: float, current_strain: float, ) -> tuple[float, float, physics_integrator.State]: dtype = next(model.parameters()).dtype basis = torch.tensor(BASIS_VOIGT, dtype=dtype).reshape(1, 6) current = torch.tensor(float(current_strain), dtype=dtype) strain = current.reshape(1, 1) * basis previous = torch.tensor(float(previous_strain), dtype=dtype).reshape(1, 1) * torch.tensor( BASIS_VOIGT, dtype=dtype ).reshape(1, 6) parameters = torch.tensor(MATERIAL_PARAMETERS, dtype=dtype).reshape(1, 10) stress, updated, _ = physics_integrator.advance( strain, previous, committed, parameters, model, parameter_mean, parameter_std, correction_steps=correction_steps, ) generalized = stress[0, 0] - 0.5 * stress[0, 1] - 0.5 * stress[0, 2] # The learned seed and active-set switch make a raw autograd tangent noisy # near first yield. Differentiate the fully discrete update numerically, # matching the robust tangent strategy used by AgentFEM's native Chaboche # implementation. step = max(2.0e-8, 2.0e-5 * max(abs(float(current_strain)), 1.0e-3)) neighboring = [] with torch.no_grad(): for value in (float(current_strain) - step, float(current_strain) + step): neighbor_stress, _, _ = physics_integrator.advance( torch.tensor(value, dtype=dtype).reshape(1, 1) * basis, previous, committed, parameters, model, parameter_mean, parameter_std, correction_steps=correction_steps, ) neighboring.append( neighbor_stress[0, 0] - 0.5 * neighbor_stress[0, 1] - 0.5 * neighbor_stress[0, 2] ) tangent = (neighboring[1] - neighboring[0]) / (2.0 * step) return float(generalized.detach()), float(tangent.detach()), _detach_state(updated) def solve_physics_integrator( elements: int, displacement: np.ndarray, *, notch_depth: float, ) -> dict[str, np.ndarray | float | int]: nodes, area = geometry(elements, notch_depth) lengths = np.diff(nodes) model, parameter_mean, parameter_std, correction_steps = physics_integrator.load_checkpoint("id") model = model.double() parameter_mean = parameter_mean.double() parameter_std = parameter_std.double() correction_steps = max(correction_steps, 8) states = [physics_integrator.initial_state(1, dtype=torch.float64) for _ in range(elements)] previous_strains = np.zeros(elements) u = np.zeros(elements + 1) reactions, strains, stresses, iterations = [], [], [], [] trust_region_fallback_steps: list[int] = [] started = time.perf_counter() for step, end_value in enumerate(displacement): if step > 0: u += np.linspace(0.0, end_value - u[-1], elements + 1) u[0] = 0.0 u[-1] = end_value converged = False converged_states = None for iteration in range(40): internal = np.zeros(elements + 1) stiffness = np.zeros((elements + 1, elements + 1)) current_strain = np.diff(u) / lengths current_stress = np.empty(elements) trial_states = [] for element in range(elements): stress, tangent, trial_state = physics_increment_response( model, parameter_mean, parameter_std, correction_steps, states[element], previous_strains[element], current_strain[element], ) current_stress[element] = stress trial_states.append(trial_state) tangent = float(np.clip(tangent, 1.0e7, 4.0e11)) b = np.asarray((-1.0 / lengths[element], 1.0 / lengths[element])) dofs = (element, element + 1) internal[list(dofs)] += area[element] * stress * b * lengths[element] stiffness[np.ix_(dofs, dofs)] += area[element] * tangent * np.outer(b, b) * lengths[element] residual = internal[1:-1] scale = max(float(np.linalg.norm(internal)), 1.0) if np.linalg.norm(residual) <= 2.0e-6 * scale + 1.0e2: converged = True converged_states = trial_states break increment = np.linalg.solve(stiffness[1:-1, 1:-1], residual) maximum = 0.20 * max(abs(end_value), 1.0e-5) norm_increment = np.max(np.abs(increment)) if norm_increment > maximum: increment *= maximum / norm_increment u[1:-1] -= increment if not converged: # At complete displacement reversals the residual-stress state can # make a plain Newton step leave the local basin. Use a bounded # trust-region least-squares fallback on the same FE equilibrium; # this changes only the global nonlinear strategy, not the learned # constitutive response. end_fixed = float(end_value) def equilibrium(interior: np.ndarray) -> np.ndarray: candidate = np.concatenate(([0.0], interior, [end_fixed])) candidate_strain = np.diff(candidate) / lengths candidate_internal = np.zeros(elements + 1) for local_element in range(elements): local_stress, _, _ = physics_increment_response( model, parameter_mean, parameter_std, correction_steps, states[local_element], previous_strains[local_element], candidate_strain[local_element], ) local_b = np.asarray( (-1.0 / lengths[local_element], 1.0 / lengths[local_element]) ) local_dofs = (local_element, local_element + 1) candidate_internal[list(local_dofs)] += ( area[local_element] * local_stress * local_b * lengths[local_element] ) return candidate_internal[1:-1] / 1.0e8 recovered = least_squares( equilibrium, u[1:-1], method="trf", jac="3-point", max_nfev=250, xtol=1.0e-12, ftol=1.0e-12, gtol=1.0e-12, ) if recovered.success: u[1:-1] = recovered.x current_strain = np.diff(u) / lengths internal = np.zeros(elements + 1) current_stress = np.empty(elements) trial_states = [] for element in range(elements): stress, _, trial_state = physics_increment_response( model, parameter_mean, parameter_std, correction_steps, states[element], previous_strains[element], current_strain[element], ) current_stress[element] = stress trial_states.append(trial_state) b = np.asarray((-1.0 / lengths[element], 1.0 / lengths[element])) dofs = (element, element + 1) internal[list(dofs)] += area[element] * stress * b * lengths[element] residual = internal[1:-1] scale = max(float(np.linalg.norm(internal)), 1.0) if np.linalg.norm(residual) <= 2.0e-6 * scale + 1.0e2: converged = True converged_states = trial_states iteration = 40 + int(recovered.nfev) trust_region_fallback_steps.append(step) if not converged or converged_states is None: raise RuntimeError( f"{physics_integrator.MODEL_NAME} structural solve failed at step {step}; " f"max_abs_element_strain={float(np.max(np.abs(current_strain))):.6g}." ) states = converged_states previous_strains = np.diff(u) / lengths reactions.append(float(internal[-1])) strains.append(previous_strains.copy()) stresses.append(current_stress.copy()) iterations.append(iteration + 1) return { "displacement": displacement, "reaction": np.asarray(reactions), "strain": np.asarray(strains), "stress": np.asarray(stresses), "nodes": nodes, "area": area, "iterations": np.asarray(iterations), "trust_region_fallback_steps": trust_region_fallback_steps, "elapsed_seconds": time.perf_counter() - started, } def compare(reference: dict[str, object], predicted: dict[str, object]) -> dict[str, float | int]: reaction_reference = np.asarray(reference["reaction"]) reaction_predicted = np.asarray(predicted["reaction"]) strain_reference = np.asarray(reference["strain"]) strain_predicted = np.asarray(predicted["strain"]) stress_reference = np.asarray(reference["stress"]) stress_predicted = np.asarray(predicted["stress"]) reaction_scale = max(float(np.max(np.abs(reaction_reference))), 1.0) stress_scale = max(float(np.max(np.abs(stress_reference))), 1.0) result = { "reaction_relative_l2": float(np.linalg.norm(reaction_predicted - reaction_reference) / max(np.linalg.norm(reaction_reference), 1.0)), "reaction_max_relative_error": float(np.max(np.abs(reaction_predicted - reaction_reference)) / reaction_scale), "strain_relative_l2": float(np.linalg.norm(strain_predicted - strain_reference) / max(np.linalg.norm(strain_reference), 1.0e-15)), "stress_relative_l2": float(np.linalg.norm(stress_predicted - stress_reference) / max(np.linalg.norm(stress_reference), 1.0)), "stress_max_relative_error": float(np.max(np.abs(stress_predicted - stress_reference)) / stress_scale), "maximum_newton_iterations": int(np.max(predicted["iterations"])), "mean_newton_iterations": float(np.mean(predicted["iterations"])), "elapsed_seconds": float(predicted["elapsed_seconds"]), } if "trust_region_fallback_steps" in predicted: result["trust_region_fallback_count"] = len(predicted["trust_region_fallback_steps"]) result["trust_region_fallback_steps"] = list(predicted["trust_region_fallback_steps"]) return result def run( elements: int = 12, points: int = 81, model_names: tuple[str, ...] = ("gru", "physics_state_gru", "physics_integrator_nn"), case_name: str = "severe_ood", ) -> dict[str, object]: if case_name == "mild_id": notch_depth = 0.12 load_scale = 0.65 elif case_name == "moderate_ood": notch_depth = 0.30 load_scale = 0.85 elif case_name == "severe_ood": notch_depth = 0.42 load_scale = 1.0 else: raise ValueError(f"Unknown structural case: {case_name}") displacement = load_history(points, scale=load_scale) print("solving native AgentFEM Chaboche reference", flush=True) reference = solve_native(elements, displacement, notch_depth=notch_depth) learned = {} metrics = {} failures = {} for model_name in model_names: print(f"solving learned structural model: {model_name}", flush=True) try: result = solve_neural( elements, displacement, model_name, notch_depth=notch_depth, ) except RuntimeError as error: failures[model_name] = str(error) print(f"recorded structural failure: {error}", flush=True) else: learned[model_name] = result metrics[model_name] = compare(reference, result) output_directory = ARTIFACT_ROOT / case_name output_directory.mkdir(parents=True, exist_ok=True) figure, axes = plt.subplots(1, 3, figsize=(14.0, 4.2), constrained_layout=True) axes[0].plot(displacement, np.asarray(reference["reaction"]) / 1.0e6, color="#111827", lw=2.2, label="AgentFEM Chaboche") colors = {"gru": "#2563eb", "physics_state_gru": "#dc2626", "physics_integrator_nn": "#059669"} labels = {"gru": "GRU", "physics_state_gru": "Physics-state GRU", "physics_integrator_nn": "Physics-integrator NN"} for name, result in learned.items(): axes[0].plot(displacement, np.asarray(result["reaction"]) / 1.0e6, color=colors[name], lw=1.5, label=labels[name]) axes[0].set_xlabel("End displacement / length") axes[0].set_ylabel("Reaction (MN for unit area)") axes[0].set_title("Structural force-displacement") centers = 0.5 * (np.asarray(reference["nodes"])[:-1] + np.asarray(reference["nodes"])[1:]) axes[1].plot(centers, np.asarray(reference["strain"])[-2], color="#111827", lw=2.2) axes[2].plot(centers, np.asarray(reference["stress"])[-2] / 1.0e6, color="#111827", lw=2.2) for name, result in learned.items(): axes[1].plot(centers, np.asarray(result["strain"])[-2], color=colors[name], lw=1.4) axes[2].plot(centers, np.asarray(result["stress"])[-2] / 1.0e6, color=colors[name], lw=1.4) axes[1].set_title("Near-final element strain") axes[1].set_xlabel("Bar coordinate") axes[1].set_ylabel("Generalized strain") axes[2].set_title("Near-final generalized stress") axes[2].set_xlabel("Bar coordinate") axes[2].set_ylabel("Stress (MPa)") for axis in axes: axis.grid(alpha=0.2) axes[0].legend(frameon=False, fontsize=8) figure.savefig(output_directory / "notched_bar_comparison.png", dpi=190) plt.close(figure) archive = { "displacement": displacement, "nodes": reference["nodes"], "area": reference["area"], "reference_reaction": reference["reaction"], "reference_strain": reference["strain"], "reference_stress": reference["stress"], } for name, result in learned.items(): archive[f"{name}_reaction"] = result["reaction"] archive[f"{name}_strain"] = result["strain"] archive[f"{name}_stress"] = result["stress"] np.savez_compressed(output_directory / "notched_bar_results.npz", **archive) summary = { "status": "completed" if not failures else "completed_with_model_failures", "scope": "controlled one-dimensional notched-bar finite-element deployment", "case_name": case_name, "notch_depth_fraction": notch_depth, "load_scale": load_scale, "elements": elements, "load_points": points, "material_model": "chaboche_combined", "native_elapsed_seconds": float(reference["elapsed_seconds"]), "models": metrics, "model_failures": failures, "limitations": [ "This is a reduced one-dimensional structural gate, not a general 3D learned AgentFEM material provider.", "The physics-integrator uses a numerical tangent of its fully discrete update and records any trust-region fallback used when plain global Newton leaves its local basin.", "The loading is proportional at each material point even though the training dataset is multiaxial.", ], } (output_directory / "structural_validation.json").write_text(json.dumps(summary, indent=2, sort_keys=True) + "\n", encoding="utf-8") print(json.dumps(summary, indent=2), flush=True) return summary def main() -> None: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--elements", type=int, default=12) parser.add_argument("--points", type=int, default=81) parser.add_argument( "--models", nargs="+", choices=("gru", "physics_state_gru", "physics_integrator_nn"), default=("gru", "physics_state_gru", "physics_integrator_nn"), ) parser.add_argument("--case", choices=("mild_id", "moderate_ood", "severe_ood"), default="severe_ood") args = parser.parse_args() run( elements=args.elements, points=args.points, model_names=tuple(args.models), case_name=args.case, ) if __name__ == "__main__": main()