Release AgentFEM Material Loading Memory v1

.pytest_cache/.gitignore

@@ -0,0 +1,2 @@
+# Created by pytest automatically.
+*

.pytest_cache/CACHEDIR.TAG

@@ -0,0 +1,4 @@
+Signature: 8a477f597d28d172789f06886806bc55
+# This file is a cache directory tag created by pytest.
+# For information about cache directory tags, see:
+#	https://bford.info/cachedir/spec.html

.pytest_cache/README.md

@@ -0,0 +1,8 @@
+# pytest cache directory #
+
+This directory contains data from the pytest's cache plugin,
+which provides the `--lf` and `--ff` options, as well as the `cache` fixture.
+
+**Do not** commit this to version control.
+
+See [the docs](https://docs.pytest.org/en/stable/how-to/cache.html) for more information.

.pytest_cache/v/cache/nodeids

@@ -0,0 +1,12 @@
+[
+  "tests/test_t2_material_loading_memory.py::test_t2_agentfem_material_point_smoke_paths_are_physical",
+  "tests/test_t2_material_loading_memory.py::test_t2_design_is_unique_balanced_and_split_by_trajectory",
+  "tests/test_t2_material_loading_memory.py::test_t2_j2_monotonic_path_matches_closed_form",
+  "tests/test_t2_material_loading_memory.py::test_t2_packaged_pilot_is_readable_when_present",
+  "tests/test_t2_material_loading_memory.py::test_t2_prescribed_histories_have_fixed_size_and_required_reversals",
+  "tests/test_t2_material_loading_memory.py::test_t2_refined_paths_are_nested_at_every_coarse_state",
+  "tests/test_t2_material_loading_memory_v1.py::test_v1_design_is_unique_balanced_and_stratified",
+  "tests/test_t2_material_loading_memory_v1.py::test_v1_histories_preserve_reversals_under_refinement",
+  "tests/test_t2_material_loading_memory_v1.py::test_v1_packaged_data_and_lightweight_reader_when_present",
+  "tests/test_t2_material_loading_memory_v1.py::test_v1_parameter_ranges_and_model_labels_are_explicit"
+]

CODE_LICENSE

@@ -0,0 +1,159 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, "control" means (i) the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form,
+made available under the License, as indicated by a copyright notice that is
+included in or attached to the work.
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original
+version of the Work and any modifications or additions to that Work or
+Derivative Works thereof, that is intentionally submitted to Licensor for
+inclusion in the Work by the copyright owner or by an individual or Legal Entity
+authorized to submit on behalf of the copyright owner. For the purposes of this
+definition, "submitted" means any form of electronic, verbal, or written
+communication sent to the Licensor or its representatives, including but not
+limited to communication on electronic mailing lists, source code control
+systems, and issue tracking systems that are managed by, or on behalf of, the
+Licensor for the purpose of discussing and improving the Work, but excluding
+communication that is conspicuously marked or otherwise designated in writing by
+the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this
+License, each Contributor hereby grants to You a perpetual, worldwide,
+non-exclusive, no-charge, royalty-free, irrevocable copyright license to
+reproduce, prepare Derivative Works of, publicly display, publicly perform,
+sublicense, and distribute the Work and such Derivative Works in Source or
+Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License,
+each Contributor hereby grants to You a perpetual, worldwide, non-exclusive,
+no-charge, royalty-free, irrevocable (except as stated in this section) patent
+license to make, have made, use, offer to sell, sell, import, and otherwise
+transfer the Work, where such license applies only to those patent claims
+licensable by such Contributor that are necessarily infringed by their
+Contribution(s) alone or by combination of their Contribution(s) with the Work
+to which such Contribution(s) was submitted. If You institute patent litigation
+against any entity (including a cross-claim or counterclaim in a lawsuit)
+alleging that the Work or a Contribution incorporated within the Work
+constitutes direct or contributory patent infringement, then any patent licenses
+granted to You under this License for that Work shall terminate as of the date
+such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or
+Derivative Works thereof in any medium, with or without modifications, and in
+Source or Object form, provided that You meet the following conditions:
+
+(a) You must give any other recipients of the Work or Derivative Works a copy
+of this License; and
+
+(b) You must cause any modified files to carry prominent notices stating that
+You changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works that You
+distribute, all copyright, patent, trademark, and attribution notices from the
+Source form of the Work, excluding those notices that do not pertain to any part
+of the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its distribution, then
+any Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or, within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents of
+the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works that
+You distribute, alongside or as an addendum to the NOTICE text from the Work,
+provided that such additional attribution notices cannot be construed as
+modifying the License.
+
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a
+whole, provided Your use, reproduction, and distribution of the Work otherwise
+complies with the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any
+Contribution intentionally submitted for inclusion in the Work by You to the
+Licensor shall be under the terms and conditions of this License, without any
+additional terms or conditions. Notwithstanding the above, nothing herein shall
+supersede or modify the terms of any separate license agreement you may have
+executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names,
+trademarks, service marks, or product names of the Licensor, except as required
+for reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in
+writing, Licensor provides the Work (and each Contributor provides its
+Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied, including, without limitation, any warranties or
+conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+PARTICULAR PURPOSE. You are solely responsible for determining the
+appropriateness of using or redistributing the Work and assume any risks
+associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in
+tort (including negligence), contract, or otherwise, unless required by
+applicable law (such as deliberate and grossly negligent acts) or agreed to in
+writing, shall any Contributor be liable to You for damages, including any
+direct, indirect, special, incidental, or consequential damages of any character
+arising as a result of this License or out of the use or inability to use the
+Work (including but not limited to damages for loss of goodwill, work stoppage,
+computer failure or malfunction, or any and all other commercial damages or
+losses), even if such Contributor has been advised of the possibility of such
+damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or
+Derivative Works thereof, You may choose to offer, and charge a fee for,
+acceptance of support, warranty, indemnity, or other liability obligations
+and/or rights consistent with this License. However, in accepting such
+obligations, You may act only on Your own behalf and on Your sole
+responsibility, not on behalf of any other Contributor, and only if You agree to
+indemnify, defend, and hold each Contributor harmless for any liability incurred
+by, or claims asserted against, such Contributor by reason of your accepting any
+such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS

DATA_LICENSE.md

@@ -0,0 +1,12 @@
+# Dataset license
+
+The dataset files, metadata, figures and accompanying dataset documentation in
+this repository are licensed under the Creative Commons Attribution 4.0
+International License (CC BY 4.0).
+
+License text and terms: https://creativecommons.org/licenses/by/4.0/legalcode
+
+SPDX identifier: `CC-BY-4.0`
+
+Attribution should identify the dataset as **AgentFEM Layered Thermoelastic
+Bending 2D** and link to this repository.

README.md

@@ -1,3 +1,109 @@
 ---
 license: cc-by-4.0
+task_categories:
+- time-series-forecasting
+- other
+tags:
+- constitutive-modeling
+- computational-mechanics
+- scientific-machine-learning
+- hysteresis
+- agentfem
+pretty_name: AgentFEM Material Loading Memory
+size_categories:
+- 1K<n<10K
 ---
+
+# AgentFEM Material Loading Memory v1
+
+This dataset contains 1,008 verified synthetic material-point trajectories for
+path-dependent small-strain plasticity. It is designed for sequence models,
+constitutive surrogates, loading-path generalization, material-model discovery
+and reproducible scientific-ML studies.
+
+![Loading-path and hysteresis preview](artifacts/t2_material_loading_memory_v1/hysteresis_preview.png)
+
+## Dataset summary
+
+- 504 J2 linear-isotropic-hardening trajectories.
+- 504 Chaboche combined-hardening trajectories.
+- Six balanced loading families: monotonic tension, unload/reload,
+  tension/compression, symmetric cycling, mean-shifted cycling and variable
+  amplitude.
+- 121 ordered states per trajectory; frames are not counted as independent
+  samples.
+- Trajectory-level split: 768 train, 120 validation and 120 test cases.
+- Eight HDF5 shards with 126 independent trajectories per shard.
+- SI units, deterministic Sobol parameter design and stable case IDs.
+
+Every HDF5 group stores prescribed strain, stress, plastic strain, equivalent
+plastic strain, plastic multiplier increments, elastic/plastic flags, trial and
+corrected yield information, Chaboche backstress state, raw work diagnostics,
+material parameters and split metadata.
+
+## Verification
+
+All 1,008 trajectories passed finite-value, initial-state, plastic
+incompressibility, nondecreasing-PEEQ, plastic-excitation and yield-surface
+checks. The maximum yield-surface relative residual was `2.166e-11`; the
+maximum J2 monotonic analytical relative error was `4.714e-16`. Twenty-four
+representative 121-to-241-state refinement audits produced maximum stress and
+PEEQ changes of 0.387% and 0.129%, respectively. Every HDF5 shard is recorded
+with a SHA-256 digest in `manifest.json`.
+
+The complete evidence is in
+`artifacts/t2_material_loading_memory_v1/QUALITY_REPORT.md`.
+
+## Baselines
+
+Two compact PyTorch baselines were trained using complete-trajectory splits and
+train-only normalization. A pointwise MLP sees the current prescribed strain
+and material parameters but no loading history. A GRU sees the ordered strain
+history.
+
+| Baseline | Test RMSE | Test MAE | Test R2 |
+|---|---:|---:|---:|
+| Pointwise MLP | 244.54 MPa | 198.82 MPa | 0.4316 |
+| History-aware GRU | 16.52 MPa | 12.01 MPa | 0.9974 |
+
+The comparison demonstrates that the response is not a single-valued function
+of current strain and parameters; loading history contains essential predictive
+information. These are reproducible reference baselines, not claims of an
+optimal architecture.
+
+![Baseline predictions](artifacts/t2_material_loading_memory_v1/baseline_predictions.png)
+
+## Lightweight use
+
+The reader requires only NumPy and h5py:
+
+```python
+from src.load_t2_material_loading_memory import load_trajectory
+
+sample = load_trajectory("data/t2_material_loading_memory_v1", 0)
+strain = sample["history"]["signed_equivalent_strain"]
+stress = sample["history"]["signed_equivalent_stress_pa"]
+print(sample["material_model"], sample["path_family"], strain.shape, stress.shape)
+```
+
+## Scope and limitations
+
+The data are synthetic three-dimensional small-strain material-point histories
+under prescribed proportional deviatoric strain. They are not structural
+finite-element fields, experimental material calibration or fatigue-life
+labels. Damage, temperature dependence, finite strain and non-proportional
+multiaxial loading are outside v1.
+
+Chaboche is explicitly marked as an experimental AgentFEM capability. Raw
+stress work on plastic strain is retained as a diagnostic, but it is not named
+thermodynamic dissipation because the current material-point contract does not
+expose a complete backstress storage/recovery energy split.
+
+## Reproducibility and license
+
+The dataset was generated with AgentFEM `0.3.7.dev0`, exact commit
+`058faecc05aeda143d014fd229401003a9258bbb`. The frozen configuration,
+restartable generator, lightweight reader, baseline and tests are included.
+
+Dataset contents are released under CC BY 4.0. Included source code is released
+under Apache-2.0.

SHA256SUMS

@@ -0,0 +1,28 @@
+4a8e89fe65965e0b5ab34a6a1b8faa412666e426ce92500dba6af0c8f3e0ca0b  CODE_LICENSE
+cdd59472c82b98d55f37288e0dd5994059194134fba6568029052eeff64faee4  DATA_LICENSE.md
+0a423180979b86b932b153be5cd1538fb33a288643ab4a457b716916008b7933  README.md
+b06a19ffe36df25bbeedf35ccb8df9a9afff6df28870a354bf5c0dfc245fd948  artifacts/t2_material_loading_memory_v1/QUALITY_REPORT.md
+d19cc739e61edff4182ed700e924af7b051f24d37f07fbfa6581eff5e589483a  artifacts/t2_material_loading_memory_v1/baseline_metrics.json
+0537f7cd76aae72abfa644761b8eec2f58903e66b8b2c040354f71650cfe0615  artifacts/t2_material_loading_memory_v1/baseline_models.pt
+9fc457b15d4e838a7dffd1d98d92fc002ee7d4e44f919c5ce1cf37e1bad75e8b  artifacts/t2_material_loading_memory_v1/baseline_predictions.png
+d671538e1fe482de5ee12496185a7c2f65363d1376af4174016a902b1d8cb24d  artifacts/t2_material_loading_memory_v1/hysteresis_preview.png
+4986bb10e002c1c2c1648b8ff3ee20676b2982215494e7f7eafaabdf7eeda298  artifacts/t2_material_loading_memory_v1/quality.json
+5054d2c6e6d289c928e91c67b1c2535b7fc765d00ed7e05c39ec364c35981851  configs/t2_material_loading_memory_pilot.json
+50eb2dee418aba303e20ba6c219fb7d201d0a5a2391b933da2f3651e767191f5  configs/t2_material_loading_memory_v1.json
+d2523144f022f78b71c0f5b006c03a393123dc8bcad190e23375a994a248330d  data/t2_material_loading_memory_v1/design.jsonl
+86ce6e7fa60f668736906c7158dfe0d5e3a8d40ca8a7e8d4e93df1d6a9afadfd  data/t2_material_loading_memory_v1/index.jsonl
+0c863700bb310edbe6363ad3ca143015279226b7d1af9db25599ae79f7beb297  data/t2_material_loading_memory_v1/manifest.json
+bf77420e04584151af10ea6e503fe4ab09946aa8c52d097ac8d4c902362387d3  data/t2_material_loading_memory_v1/shards/part-00000.h5
+7278e897caf225f3cb3a6e34e65881fc2c87f310f730245ab4bffb54ace475b3  data/t2_material_loading_memory_v1/shards/part-00001.h5
+952b90eed1ce3ac288487cf31180384fc12f79aa03d95e4885bfd73b85c9a46d  data/t2_material_loading_memory_v1/shards/part-00002.h5
+5de72c7a4aba0594945cb381c33696c25c58c6f72c873098852ce68e0f447094  data/t2_material_loading_memory_v1/shards/part-00003.h5
+37edc592132c17f9c0e0f186cf2f0fab60d7abf6135ed31834003ed3d6595801  data/t2_material_loading_memory_v1/shards/part-00004.h5
+7039ab13425efac4e7bbdd415d31a5276acd3617a22163ad563c6817fca7360e  data/t2_material_loading_memory_v1/shards/part-00005.h5
+67739a62d001131729ce506bb575a48555dd7dbbf393ac5a30cacf5094636854  data/t2_material_loading_memory_v1/shards/part-00006.h5
+37d8caa79a1cb672288f38e1625b4837671bfb9210416b10ce4a60ad5a912ef8  data/t2_material_loading_memory_v1/shards/part-00007.h5
+d36bef7aa852e850a524e22f4b9689325b40320ad3046004d2f31df4c7605e26  src/baseline_t2_material_loading_memory.py
+21158e37d8742b20ef5817bb314fb0dfe926f9633b82087a063447d8e863f9fe  src/load_t2_material_loading_memory.py
+79eddf3174eb343ef1e8dc4aef2df0a7be62819a03c594aaa22886fd49f57c2d  src/t2_material_loading_memory.py
+604bc6283e7a461073d03a3b69440873d46809baf9e2ca4c79dfbeaa0704a5d7  src/t2_material_loading_memory_v1.py
+05c9cc11d32f54c88d3769b394b15f14bc283dc1f10b33b187b9e59166c676d6  tests/test_t2_material_loading_memory.py
+de16ddbac7c1e9dd020d2fff57da76d56ffd4ba2ce3b1ef61b41f02295c89e5a  tests/test_t2_material_loading_memory_v1.py

artifacts/t2_material_loading_memory_v1/QUALITY_REPORT.md

@@ -0,0 +1,34 @@
+# T2 material-loading-memory v1 quality report
+
+Status: **accepted**  
+Independent trajectories: 1008  
+Quality failures: 0
+
+## Coverage
+
+- J2 linear isotropic hardening: 504
+- Chaboche combined hardening: 504
+- Six loading-path families: 168 trajectories each
+- Train/validation/test trajectories: 768/120/120
+- Points per trajectory: 121
+- Packaged HDF5 shards: 8
+
+## Verification
+
+- Maximum yield-surface relative residual: 2.166e-11
+- Maximum plastic-strain trace: 0.000e+00
+- Maximum J2 monotonic analytical relative error: 4.714e-16
+- Minimum repeated-zero-strain stress contrast in symmetric cycles: 193.713 MPa
+- Maximum 121-to-241-point stress change across 24 audits: 0.387%
+- Maximum 121-to-241-point PEEQ change across 24 audits: 0.129%
+- Minimum raw `stress:plastic-strain-increment` diagnostic: -1.428e+05 J/m^3
+- All case IDs unique: True
+
+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)

artifacts/t2_material_loading_memory_v1/baseline_metrics.json

@@ -0,0 +1,88 @@
+{
+  "history_gru": {
+    "chaboche_combined": {
+      "mae_mpa": 12.837212656481174,
+      "r2": 0.997053655627979,
+      "range_normalized_rmse": 0.011501122865380178,
+      "rmse_mpa": 17.32188453340398
+    },
+    "j2_linear_isotropic": {
+      "mae_mpa": 11.17908518287917,
+      "r2": 0.9977184826561191,
+      "range_normalized_rmse": 0.012058524381695452,
+      "rmse_mpa": 15.672277397346926
+    },
+    "overall": {
+      "mae_mpa": 12.008148919680172,
+      "r2": 0.9974064908954444,
+      "range_normalized_rmse": 0.010967163901429768,
+      "rmse_mpa": 16.517686923537017
+    }
+  },
+  "normalization": {
+    "parameter_mean": [
+      191097290059.1636,
+      0.29465488306948845,
+      314705026.3470009,
+      2082437937.673601,
+      18496297278.725273,
+      34.82776667457074,
+      4271141687.4747887,
+      5.228669154967065,
+      35494605.25018125,
+      5.595684179708769
+    ],
+    "parameter_names": [
+      "young_pa",
+      "poisson",
+      "yield_stress_pa",
+      "hardening_modulus_pa",
+      "backstress_c1_pa",
+      "backstress_gamma1",
+      "backstress_c2_pa",
+      "backstress_gamma2",
+      "isotropic_saturation_pa",
+      "isotropic_rate"
+    ],
+    "parameter_scale": [
+      22764894888.991604,
+      0.02591473412611028,
+      76635956.73250286,
+      2579853541.284986,
+      20671344586.386173,
+      40.363554335079115,
+      4997449643.931367,
+      6.547008002361187,
+      41055780.03282887,
+      6.6352674608519955
+    ],
+    "strain_scale": 0.013482345574567714,
+    "stress_scale_pa": 325595658.3862858
+  },
+  "pointwise_mlp": {
+    "chaboche_combined": {
+      "mae_mpa": 174.96636413415263,
+      "r2": 0.5650588979566006,
+      "range_normalized_rmse": 0.13973774001891945,
+      "rmse_mpa": 210.4595373772259
+    },
+    "j2_linear_isotropic": {
+      "mae_mpa": 222.68187339076022,
+      "r2": 0.3005172750573124,
+      "range_normalized_rmse": 0.2111401254033973,
+      "rmse_mpa": 274.415551214186
+    },
+    "overall": {
+      "mae_mpa": 198.8241187624564,
+      "r2": 0.43156604542855415,
+      "range_normalized_rmse": 0.1623642652154708,
+      "rmse_mpa": 244.5374323301256
+    }
+  },
+  "split_policy": "complete trajectories; normalization fitted on train only",
+  "status": "completed",
+  "task": "signed-equivalent-stress history prediction",
+  "test_trajectory_count": 120,
+  "torch_version": "2.13.0",
+  "wall_seconds": 23.655544749926776
+}

artifacts/t2_material_loading_memory_v1/baseline_models.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0537f7cd76aae72abfa644761b8eec2f58903e66b8b2c040354f71650cfe0615
+size 87167

artifacts/t2_material_loading_memory_v1/quality.json

@@ -0,0 +1,206 @@
+{
+  "agentfem_commit": "058faecc05aeda143d014fd229401003a9258bbb",
+  "agentfem_version": "0.3.7.dev0",
+  "all_case_ids_unique": true,
+  "data_bytes": 76029327,
+  "material_models": {
+    "chaboche_combined": 504,
+    "j2_linear_isotropic": 504
+  },
+  "maximum_j2_analytical_relative_error": 4.713687395585475e-16,
+  "maximum_plastic_strain_trace": 0.0,
+  "maximum_refined_peeq_relative_change": 0.0012918014334128156,
+  "maximum_refined_stress_relative_change": 0.0038699701283640207,
+  "maximum_yield_surface_relative_residual": 2.16579096075354e-11,
+  "minimum_plastic_work_increment_j_m3": -142826.47301995277,
+  "minimum_symmetric_zero_strain_memory_contrast_pa": 193713300.83466035,
+  "path_families": {
+    "mean_shifted_cyclic": 168,
+    "monotonic_tension": 168,
+    "symmetric_cyclic": 168,
+    "tension_compression": 168,
+    "unload_reload": 168,
+    "variable_amplitude": 168
+  },
+  "points_per_trajectory": 121,
+  "preview": "artifacts/t2_material_loading_memory_v1/hysteresis_preview.png",
+  "quality_failure_count": 0,
+  "quality_failures": [],
+  "refinement_audits": [
+    {
+      "index": 0,
+      "material_model": "j2_linear_isotropic",
+      "maximum_peeq_relative_change": 1.9691100487952772e-16,
+      "maximum_stress_relative_change": 4.0495326567019173e-16,
+      "path_family": "monotonic_tension"
+    },
+    {
+      "index": 83,
+      "material_model": "j2_linear_isotropic",
+      "maximum_peeq_relative_change": 2.2141051965947146e-16,
+      "maximum_stress_relative_change": 3.2491654772037307e-16,
+      "path_family": "monotonic_tension"
+    },
+    {
+      "index": 84,
+      "material_model": "j2_linear_isotropic",
+      "maximum_peeq_relative_change": 5.872047860997571e-16,
+      "maximum_stress_relative_change": 4.809200195348651e-16,
+      "path_family": "unload_reload"
+    },
+    {
+      "index": 167,
+      "material_model": "j2_linear_isotropic",
+      "maximum_peeq_relative_change": 9.455615721006915e-16,
+      "maximum_stress_relative_change": 3.5057748529466403e-16,
+      "path_family": "unload_reload"
+    },
+    {
+      "index": 168,
+      "material_model": "j2_linear_isotropic",
+      "maximum_peeq_relative_change": 7.195511936407169e-16,
+      "maximum_stress_relative_change": 4.1591366364598886e-16,
+      "path_family": "tension_compression"
+    },
+    {
+      "index": 251,
+      "material_model": "j2_linear_isotropic",
+      "maximum_peeq_relative_change": 5.03263695603114e-16,
+      "maximum_stress_relative_change": 4.134529023380189e-16,
+      "path_family": "tension_compression"
+    },
+    {
+      "index": 252,
+      "material_model": "j2_linear_isotropic",
+      "maximum_peeq_relative_change": 2.4080288084231124e-15,
+      "maximum_stress_relative_change": 1.1444269888020809e-15,
+      "path_family": "symmetric_cyclic"
+    },
+    {
+      "index": 335,
+      "material_model": "j2_linear_isotropic",
+      "maximum_peeq_relative_change": 1.0883566441967917e-15,
+      "maximum_stress_relative_change": 6.111208028918634e-16,
+      "path_family": "symmetric_cyclic"
+    },
+    {
+      "index": 336,
+      "material_model": "j2_linear_isotropic",
+      "maximum_peeq_relative_change": 3.185831716980416e-16,
+      "maximum_stress_relative_change": 3.2417814226270937e-16,
+      "path_family": "mean_shifted_cyclic"
+    },
+    {
+      "index": 419,
+      "material_model": "j2_linear_isotropic",
+      "maximum_peeq_relative_change": 2.9976886982131045e-15,
+      "maximum_stress_relative_change": 7.126659468347532e-16,
+      "path_family": "mean_shifted_cyclic"
+    },
+    {
+      "index": 420,
+      "material_model": "j2_linear_isotropic",
+      "maximum_peeq_relative_change": 1.8132803564402278e-15,
+      "maximum_stress_relative_change": 6.008433503440595e-16,
+      "path_family": "variable_amplitude"
+    },
+    {
+      "index": 503,
+      "material_model": "j2_linear_isotropic",
+      "maximum_peeq_relative_change": 4.926407148119625e-16,
+      "maximum_stress_relative_change": 5.465031339597028e-16,
+      "path_family": "variable_amplitude"
+    },
+    {
+      "index": 504,
+      "material_model": "chaboche_combined",
+      "maximum_peeq_relative_change": 4.7689064477326605e-05,
+      "maximum_stress_relative_change": 3.623405365425279e-05,
+      "path_family": "monotonic_tension"
+    },
+    {
+      "index": 587,
+      "material_model": "chaboche_combined",
+      "maximum_peeq_relative_change": 5.291163194442036e-05,
+      "maximum_stress_relative_change": 8.5340277015935e-05,
+      "path_family": "monotonic_tension"
+    },
+    {
+      "index": 588,
+      "material_model": "chaboche_combined",
+      "maximum_peeq_relative_change": 0.00022050968191946916,
+      "maximum_stress_relative_change": 0.00035889290512209027,
+      "path_family": "unload_reload"
+    },
+    {
+      "index": 671,
+      "material_model": "chaboche_combined",
+      "maximum_peeq_relative_change": 0.00019081420746639962,
+      "maximum_stress_relative_change": 0.0004410244818224862,
+      "path_family": "unload_reload"
+    },
+    {
+      "index": 672,
+      "material_model": "chaboche_combined",
+      "maximum_peeq_relative_change": 0.00022023114380788846,
+      "maximum_stress_relative_change": 0.0004410479264523355,
+      "path_family": "tension_compression"
+    },
+    {
+      "index": 755,
+      "material_model": "chaboche_combined",
+      "maximum_peeq_relative_change": 0.00020046996696709512,
+      "maximum_stress_relative_change": 0.00033472825896666594,
+      "path_family": "tension_compression"
+    },
+    {
+      "index": 756,
+      "material_model": "chaboche_combined",
+      "maximum_peeq_relative_change": 0.0008566275658290944,
+      "maximum_stress_relative_change": 0.0007693778418125614,
+      "path_family": "symmetric_cyclic"
+    },
+    {
+      "index": 839,
+      "material_model": "chaboche_combined",
+      "maximum_peeq_relative_change": 0.001033225845075327,
+      "maximum_stress_relative_change": 0.0038699701283640207,
+      "path_family": "symmetric_cyclic"
+    },
+    {
+      "index": 840,
+      "material_model": "chaboche_combined",
+      "maximum_peeq_relative_change": 0.0012918014334128156,
+      "maximum_stress_relative_change": 0.001690629833999976,
+      "path_family": "mean_shifted_cyclic"
+    },
+    {
+      "index": 923,
+      "material_model": "chaboche_combined",
+      "maximum_peeq_relative_change": 0.0003638695281148608,
+      "maximum_stress_relative_change": 0.00037712200092439026,
+      "path_family": "mean_shifted_cyclic"
+    },
+    {
+      "index": 924,
+      "material_model": "chaboche_combined",
+      "maximum_peeq_relative_change": 0.0008002457139733245,
+      "maximum_stress_relative_change": 0.001113976631730561,
+      "path_family": "variable_amplitude"
+    },
+    {
+      "index": 1007,
+      "material_model": "chaboche_combined",
+      "maximum_peeq_relative_change": 0.0007903616798123826,
+      "maximum_stress_relative_change": 0.002678974417237217,
+      "path_family": "variable_amplitude"
+    }
+  ],
+  "sample_count": 1008,
+  "splits": {
+    "test": 120,
+    "train": 768,
+    "validation": 120
+  },
+  "status": "accepted"
+}

configs/t2_material_loading_memory_pilot.json

@@ -0,0 +1,51 @@
+{
+  "schema": "agentfem.physics-data.material-loading-memory",
+  "schema_version": "0.1.0",
+  "dataset_version": "pilot-0.1",
+  "seed": 20260925,
+  "sample_count": 96,
+  "points_per_trajectory": 121,
+  "material_models": {
+    "j2_linear_isotropic": 48,
+    "chaboche_combined": 48
+  },
+  "path_families": {
+    "monotonic_tension": 16,
+    "unload_reload": 16,
+    "tension_compression": 16,
+    "symmetric_cyclic": 16,
+    "mean_shifted_cyclic": 16,
+    "variable_amplitude": 16
+  },
+  "splits": {
+    "train": 72,
+    "validation": 12,
+    "test": 12
+  },
+  "ranges": {
+    "young_pa": [150000000000.0, 230000000000.0],
+    "poisson": [0.25, 0.34],
+    "yield_stress_pa": [180000000.0, 450000000.0],
+    "maximum_equivalent_strain": [0.003, 0.012],
+    "j2_hardening_modulus_pa": [500000000.0, 8000000000.0],
+    "chaboche_c1_pa": [15000000000.0, 60000000000.0],
+    "chaboche_gamma1": [20.0, 120.0],
+    "chaboche_c2_pa": [2000000000.0, 15000000000.0],
+    "chaboche_gamma2": [1.0, 20.0],
+    "chaboche_isotropic_saturation_pa": [20000000.0, 120000000.0],
+    "chaboche_isotropic_rate": [2.0, 20.0]
+  },
+  "quality_thresholds": {
+    "initial_stress_pa": 0.001,
+    "plastic_strain_trace": 1e-10,
+    "equivalent_plastic_strain_decrease": 1e-12,
+    "yield_surface_relative_residual": 1e-8,
+    "j2_monotonic_analytical_relative_error": 1e-10,
+    "zero_strain_memory_contrast_pa": 1000000.0,
+    "refined_stress_relative_change": 0.02,
+    "refined_peeq_relative_change": 0.05,
+    "j2_plastic_work_negative_tolerance_j_m3": 0.01,
+    "final_plastic_work_minimum_j_m3": 0.0
+  },
+  "scope": "Synthetic three-dimensional small-strain material-point trajectories under prescribed proportional deviatoric strain. J2 linear isotropic hardening and experimental Chaboche combined hardening are separate labels. No experimental calibration, fatigue-life label, damage, temperature dependence, finite-strain claim or structural FEM field claim."
+}

configs/t2_material_loading_memory_v1.json

@@ -0,0 +1,53 @@
+{
+  "schema": "agentfem.physics-data.material-loading-memory",
+  "schema_version": "1.0.0",
+  "dataset_version": "1.0.0",
+  "seed": 20260925,
+  "sample_count": 1008,
+  "samples_per_stratum": 84,
+  "points_per_trajectory": 121,
+  "shard_count": 8,
+  "material_models": {
+    "j2_linear_isotropic": 504,
+    "chaboche_combined": 504
+  },
+  "path_families": {
+    "monotonic_tension": 168,
+    "unload_reload": 168,
+    "tension_compression": 168,
+    "symmetric_cyclic": 168,
+    "mean_shifted_cyclic": 168,
+    "variable_amplitude": 168
+  },
+  "splits": {
+    "train": 768,
+    "validation": 120,
+    "test": 120
+  },
+  "ranges": {
+    "young_pa": [150000000000.0, 230000000000.0],
+    "poisson": [0.25, 0.34],
+    "yield_stress_pa": [180000000.0, 450000000.0],
+    "maximum_equivalent_strain": [0.003, 0.012],
+    "j2_hardening_modulus_pa": [500000000.0, 8000000000.0],
+    "chaboche_c1_pa": [15000000000.0, 60000000000.0],
+    "chaboche_gamma1": [20.0, 120.0],
+    "chaboche_c2_pa": [2000000000.0, 15000000000.0],
+    "chaboche_gamma2": [1.0, 20.0],
+    "chaboche_isotropic_saturation_pa": [20000000.0, 120000000.0],
+    "chaboche_isotropic_rate": [2.0, 20.0]
+  },
+  "quality_thresholds": {
+    "initial_stress_pa": 0.001,
+    "plastic_strain_trace": 1e-10,
+    "equivalent_plastic_strain_decrease": 1e-12,
+    "yield_surface_relative_residual": 1e-8,
+    "j2_monotonic_analytical_relative_error": 1e-10,
+    "zero_strain_memory_contrast_pa": 1000000.0,
+    "refined_stress_relative_change": 0.02,
+    "refined_peeq_relative_change": 0.05,
+    "j2_plastic_work_negative_tolerance_j_m3": 0.01,
+    "final_plastic_work_minimum_j_m3": 0.0
+  },
+  "scope": "Synthetic three-dimensional small-strain material-point trajectories under prescribed proportional deviatoric strain. J2 linear isotropic hardening and experimental Chaboche combined hardening are separate labels. No experimental calibration, fatigue-life label, damage, temperature dependence, finite-strain claim or structural FEM field claim."
+}

data/t2_material_loading_memory_v1/manifest.json

@@ -0,0 +1,75 @@
+{
+  "agentfem_commit": "058faecc05aeda143d014fd229401003a9258bbb",
+  "agentfem_version": "0.3.7.dev0",
+  "dataset_version": "1.0.0",
+  "points_per_trajectory": 121,
+  "sample_count": 1008,
+  "schema": "agentfem.physics-data.material-loading-memory",
+  "schema_version": "1.0.0",
+  "shards": [
+    {
+      "bytes": 9088040,
+      "first_id": "00000",
+      "last_id": "00125",
+      "path": "data/t2_material_loading_memory_v1/shards/part-00000.h5",
+      "sample_count": 126,
+      "sha256": "bf77420e04584151af10ea6e503fe4ab09946aa8c52d097ac8d4c902362387d3"
+    },
+    {
+      "bytes": 9153896,
+      "first_id": "00126",
+      "last_id": "00251",
+      "path": "data/t2_material_loading_memory_v1/shards/part-00001.h5",
+      "sample_count": 126,
+      "sha256": "7278e897caf225f3cb3a6e34e65881fc2c87f310f730245ab4bffb54ace475b3"
+    },
+    {
+      "bytes": 8964284,
+      "first_id": "00252",
+      "last_id": "00377",
+      "path": "data/t2_material_loading_memory_v1/shards/part-00002.h5",
+      "sample_count": 126,
+      "sha256": "952b90eed1ce3ac288487cf31180384fc12f79aa03d95e4885bfd73b85c9a46d"
+    },
+    {
+      "bytes": 9141402,
+      "first_id": "00378",
+      "last_id": "00503",
+      "path": "data/t2_material_loading_memory_v1/shards/part-00003.h5",
+      "sample_count": 126,
+      "sha256": "5de72c7a4aba0594945cb381c33696c25c58c6f72c873098852ce68e0f447094"
+    },
+    {
+      "bytes": 9889328,
+      "first_id": "00504",
+      "last_id": "00629",
+      "path": "data/t2_material_loading_memory_v1/shards/part-00004.h5",
+      "sample_count": 126,
+      "sha256": "37edc592132c17f9c0e0f186cf2f0fab60d7abf6135ed31834003ed3d6595801"
+    },
+    {
+      "bytes": 9964093,
+      "first_id": "00630",
+      "last_id": "00755",
+      "path": "data/t2_material_loading_memory_v1/shards/part-00005.h5",
+      "sample_count": 126,
+      "sha256": "7039ab13425efac4e7bbdd415d31a5276acd3617a22163ad563c6817fca7360e"
+    },
+    {
+      "bytes": 9860839,
+      "first_id": "00756",
+      "last_id": "00881",
+      "path": "data/t2_material_loading_memory_v1/shards/part-00006.h5",
+      "sample_count": 126,
+      "sha256": "67739a62d001131729ce506bb575a48555dd7dbbf393ac5a30cacf5094636854"
+    },
+    {
+      "bytes": 9967445,
+      "first_id": "00882",
+      "last_id": "01007",
+      "path": "data/t2_material_loading_memory_v1/shards/part-00007.h5",
+      "sample_count": 126,
+      "sha256": "37d8caa79a1cb672288f38e1625b4837671bfb9210416b10ce4a60ad5a912ef8"
+    }
+  ]
+}

data/t2_material_loading_memory_v1/shards/part-00000.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bf77420e04584151af10ea6e503fe4ab09946aa8c52d097ac8d4c902362387d3
+size 9088040

data/t2_material_loading_memory_v1/shards/part-00001.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7278e897caf225f3cb3a6e34e65881fc2c87f310f730245ab4bffb54ace475b3
+size 9153896

data/t2_material_loading_memory_v1/shards/part-00002.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:952b90eed1ce3ac288487cf31180384fc12f79aa03d95e4885bfd73b85c9a46d
+size 8964284

data/t2_material_loading_memory_v1/shards/part-00003.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5de72c7a4aba0594945cb381c33696c25c58c6f72c873098852ce68e0f447094
+size 9141402

data/t2_material_loading_memory_v1/shards/part-00004.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:37edc592132c17f9c0e0f186cf2f0fab60d7abf6135ed31834003ed3d6595801
+size 9889328

data/t2_material_loading_memory_v1/shards/part-00005.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7039ab13425efac4e7bbdd415d31a5276acd3617a22163ad563c6817fca7360e
+size 9964093

data/t2_material_loading_memory_v1/shards/part-00006.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:67739a62d001131729ce506bb575a48555dd7dbbf393ac5a30cacf5094636854
+size 9860839

data/t2_material_loading_memory_v1/shards/part-00007.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:37d8caa79a1cb672288f38e1625b4837671bfb9210416b10ce4a60ad5a912ef8
+size 9967445

src/baseline_t2_material_loading_memory.py

@@ -0,0 +1,337 @@
+"""Train pointwise-MLP and history-aware GRU baselines for T2 v1."""
+
+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 torch import nn
+from torch.utils.data import DataLoader, TensorDataset
+
+try:
+    from src.load_t2_material_loading_memory import iter_trajectories
+except ModuleNotFoundError:
+    from load_t2_material_loading_memory import iter_trajectories
+
+
+ROOT = Path(__file__).resolve().parents[1]
+DATA_DIR = ROOT / "data" / "t2_material_loading_memory_v1"
+ARTIFACT_DIR = ROOT / "artifacts" / "t2_material_loading_memory_v1"
+PARAMETER_NAMES = (
+    "young_pa",
+    "poisson",
+    "yield_stress_pa",
+    "hardening_modulus_pa",
+    "backstress_c1_pa",
+    "backstress_gamma1",
+    "backstress_c2_pa",
+    "backstress_gamma2",
+    "isotropic_saturation_pa",
+    "isotropic_rate",
+)
+MODEL_NAMES = ("j2_linear_isotropic", "chaboche_combined")
+PATH_FAMILIES = (
+    "monotonic_tension",
+    "unload_reload",
+    "tension_compression",
+    "symmetric_cyclic",
+    "mean_shifted_cyclic",
+    "variable_amplitude",
+)
+
+
+class PointwiseMLP(nn.Module):
+    def __init__(self, input_size: int) -> None:
+        super().__init__()
+        self.network = nn.Sequential(
+            nn.Linear(input_size, 64),
+            nn.Tanh(),
+            nn.Linear(64, 64),
+            nn.Tanh(),
+            nn.Linear(64, 1),
+        )
+
+    def forward(self, values: torch.Tensor) -> torch.Tensor:
+        return self.network(values)
+
+
+class HistoryGRU(nn.Module):
+    def __init__(self, input_size: int) -> None:
+        super().__init__()
+        self.recurrent = nn.GRU(input_size, 64, batch_first=True)
+        self.output = nn.Linear(64, 1)
+
+    def forward(self, values: torch.Tensor) -> torch.Tensor:
+        hidden, _ = self.recurrent(values)
+        return self.output(hidden)
+
+
+def _load_arrays() -> dict[str, object]:
+    samples = list(iter_trajectories(DATA_DIR))
+    parameters = np.asarray(
+        [[float(sample["parameters"][name]) for name in PARAMETER_NAMES] for sample in samples],
+        dtype=np.float64,
+    )
+    model_one_hot = np.zeros((len(samples), len(MODEL_NAMES)), dtype=np.float64)
+    for index, sample in enumerate(samples):
+        model_one_hot[index, MODEL_NAMES.index(sample["material_model"])] = 1.0
+    strain = np.asarray(
+        [sample["history"]["signed_equivalent_strain"] for sample in samples],
+        dtype=np.float64,
+    )
+    stress = np.asarray(
+        [sample["history"]["signed_equivalent_stress_pa"] for sample in samples],
+        dtype=np.float64,
+    )
+    splits = np.asarray([sample["split"] for sample in samples])
+    train = splits == "train"
+    parameter_mean = parameters[train].mean(axis=0)
+    parameter_scale = parameters[train].std(axis=0)
+    parameter_scale[parameter_scale < 1.0e-15] = 1.0
+    normalized_parameters = (parameters - parameter_mean) / parameter_scale
+    strain_scale = float(np.max(np.abs(strain[train])))
+    normalized_strain = strain / strain_scale
+    delta = np.diff(normalized_strain, axis=1, prepend=normalized_strain[:, :1])
+    constant = np.concatenate((normalized_parameters, model_one_hot), axis=1)
+    repeated = np.repeat(constant[:, None, :], strain.shape[1], axis=1)
+    pointwise = np.concatenate((normalized_strain[:, :, None], repeated), axis=2)
+    history = np.concatenate(
+        (normalized_strain[:, :, None], delta[:, :, None], repeated), axis=2
+    )
+    stress_scale = float(np.std(stress[train]))
+    target = stress / stress_scale
+    return {
+        "samples": samples,
+        "pointwise": pointwise.astype(np.float32),
+        "history": history.astype(np.float32),
+        "target": target.astype(np.float32),
+        "stress_pa": stress,
+        "splits": splits,
+        "normalization": {
+            "parameter_names": list(PARAMETER_NAMES),
+            "parameter_mean": parameter_mean.tolist(),
+            "parameter_scale": parameter_scale.tolist(),
+            "strain_scale": strain_scale,
+            "stress_scale_pa": stress_scale,
+        },
+    }
+
+
+def _train_pointwise(
+    features: np.ndarray,
+    target: np.ndarray,
+    train: np.ndarray,
+    validation: np.ndarray,
+    *,
+    epochs: int,
+) -> PointwiseMLP:
+    model = PointwiseMLP(features.shape[-1])
+    optimizer = torch.optim.Adam(model.parameters(), lr=2.0e-3)
+    criterion = nn.MSELoss()
+    x_train = torch.from_numpy(features[train].reshape(-1, features.shape[-1]))
+    y_train = torch.from_numpy(target[train].reshape(-1, 1))
+    loader = DataLoader(TensorDataset(x_train, y_train), batch_size=4096, shuffle=True)
+    x_validation = torch.from_numpy(
+        features[validation].reshape(-1, features.shape[-1])
+    )
+    y_validation = torch.from_numpy(target[validation].reshape(-1, 1))
+    best: dict[str, torch.Tensor] | None = None
+    best_loss = float("inf")
+    remaining = 6
+    for _ in range(epochs):
+        model.train()
+        for x_batch, y_batch in loader:
+            optimizer.zero_grad()
+            loss = criterion(model(x_batch), y_batch)
+            loss.backward()
+            optimizer.step()
+        model.eval()
+        with torch.no_grad():
+            loss = float(criterion(model(x_validation), y_validation))
+        if loss < best_loss - 1.0e-6:
+            best_loss = loss
+            best = {name: value.detach().clone() for name, value in model.state_dict().items()}
+            remaining = 6
+        else:
+            remaining -= 1
+            if remaining == 0:
+                break
+    if best is not None:
+        model.load_state_dict(best)
+    return model
+
+
+def _train_gru(
+    features: np.ndarray,
+    target: np.ndarray,
+    train: np.ndarray,
+    validation: np.ndarray,
+    *,
+    epochs: int,
+) -> HistoryGRU:
+    model = HistoryGRU(features.shape[-1])
+    optimizer = torch.optim.Adam(model.parameters(), lr=2.0e-3)
+    criterion = nn.MSELoss()
+    loader = DataLoader(
+        TensorDataset(torch.from_numpy(features[train]), torch.from_numpy(target[train, :, None])),
+        batch_size=32,
+        shuffle=True,
+    )
+    x_validation = torch.from_numpy(features[validation])
+    y_validation = torch.from_numpy(target[validation, :, None])
+    best: dict[str, torch.Tensor] | None = None
+    best_loss = float("inf")
+    remaining = 8
+    for _ in range(epochs):
+        model.train()
+        for x_batch, y_batch in loader:
+            optimizer.zero_grad()
+            loss = criterion(model(x_batch), y_batch)
+            loss.backward()
+            optimizer.step()
+        model.eval()
+        with torch.no_grad():
+            loss = float(criterion(model(x_validation), y_validation))
+        if loss < best_loss - 1.0e-6:
+            best_loss = loss
+            best = {name: value.detach().clone() for name, value in model.state_dict().items()}
+            remaining = 8
+        else:
+            remaining -= 1
+            if remaining == 0:
+                break
+    if best is not None:
+        model.load_state_dict(best)
+    return model
+
+
+def _predict(model: nn.Module, features: np.ndarray, *, batch_size: int) -> np.ndarray:
+    model.eval()
+    chunks: list[np.ndarray] = []
+    with torch.no_grad():
+        for start in range(0, len(features), batch_size):
+            chunks.append(model(torch.from_numpy(features[start : start + batch_size])).numpy())
+    return np.concatenate(chunks, axis=0).squeeze(-1)
+
+
+def _metrics(reference: np.ndarray, prediction: np.ndarray) -> dict[str, float]:
+    error = prediction - reference
+    rmse = float(np.sqrt(np.mean(error**2)))
+    mae = float(np.mean(np.abs(error)))
+    centered = reference - float(np.mean(reference))
+    r2 = 1.0 - float(np.sum(error**2) / np.sum(centered**2))
+    scale = float(np.max(reference) - np.min(reference))
+    return {
+        "rmse_mpa": rmse / 1.0e6,
+        "mae_mpa": mae / 1.0e6,
+        "range_normalized_rmse": rmse / scale,
+        "r2": r2,
+    }
+
+
+def train(*, mlp_epochs: int = 40, gru_epochs: int = 60) -> dict[str, object]:
+    torch.manual_seed(20260925)
+    np.random.seed(20260925)
+    torch.set_num_threads(min(4, torch.get_num_threads()))
+    torch.use_deterministic_algorithms(True)
+    arrays = _load_arrays()
+    splits = arrays["splits"]
+    train_mask = splits == "train"
+    validation_mask = splits == "validation"
+    test_mask = splits == "test"
+    started = time.perf_counter()
+    mlp = _train_pointwise(
+        arrays["pointwise"],
+        arrays["target"],
+        train_mask,
+        validation_mask,
+        epochs=mlp_epochs,
+    )
+    gru = _train_gru(
+        arrays["history"],
+        arrays["target"],
+        train_mask,
+        validation_mask,
+        epochs=gru_epochs,
+    )
+    stress_scale = arrays["normalization"]["stress_scale_pa"]
+    mlp_prediction = _predict(mlp, arrays["pointwise"], batch_size=128) * stress_scale
+    gru_prediction = _predict(gru, arrays["history"], batch_size=64) * stress_scale
+    reference = arrays["stress_pa"]
+    metrics: dict[str, object] = {
+        "status": "completed",
+        "task": "signed-equivalent-stress history prediction",
+        "split_policy": "complete trajectories; normalization fitted on train only",
+        "test_trajectory_count": int(np.count_nonzero(test_mask)),
+        "pointwise_mlp": {"overall": _metrics(reference[test_mask], mlp_prediction[test_mask])},
+        "history_gru": {"overall": _metrics(reference[test_mask], gru_prediction[test_mask])},
+        "wall_seconds": float(time.perf_counter() - started),
+        "torch_version": torch.__version__,
+        "normalization": arrays["normalization"],
+    }
+    samples = arrays["samples"]
+    for model_name in MODEL_NAMES:
+        mask = test_mask & np.asarray(
+            [sample["material_model"] == model_name for sample in samples]
+        )
+        metrics["pointwise_mlp"][model_name] = _metrics(reference[mask], mlp_prediction[mask])
+        metrics["history_gru"][model_name] = _metrics(reference[mask], gru_prediction[mask])
+
+    ARTIFACT_DIR.mkdir(parents=True, exist_ok=True)
+    (ARTIFACT_DIR / "baseline_metrics.json").write_text(
+        json.dumps(metrics, indent=2, sort_keys=True) + "\n", encoding="utf-8"
+    )
+    torch.save(
+        {
+            "pointwise_mlp": mlp.state_dict(),
+            "history_gru": gru.state_dict(),
+            "normalization": arrays["normalization"],
+            "parameter_names": PARAMETER_NAMES,
+            "model_names": MODEL_NAMES,
+        },
+        ARTIFACT_DIR / "baseline_models.pt",
+    )
+
+    fig, axes = plt.subplots(2, 3, figsize=(12.0, 7.2), constrained_layout=True)
+    for axis, family in zip(axes.flat, PATH_FAMILIES, strict=True):
+        index = next(
+            idx
+            for idx, sample in enumerate(samples)
+            if test_mask[idx]
+            and sample["material_model"] == "chaboche_combined"
+            and sample["path_family"] == family
+        )
+        strain = 100.0 * samples[index]["history"]["signed_equivalent_strain"]
+        axis.plot(strain, reference[index] / 1.0e6, color="#111827", lw=2.0, label="AgentFEM")
+        axis.plot(strain, mlp_prediction[index] / 1.0e6, color="#f59e0b", lw=1.2, label="Pointwise MLP")
+        axis.plot(strain, gru_prediction[index] / 1.0e6, color="#2563eb", lw=1.5, label="History GRU")
+        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=8)
+    fig.suptitle("T2 v1 baseline comparison on held-out Chaboche trajectories", fontsize=13)
+    fig.savefig(ARTIFACT_DIR / "baseline_predictions.png", dpi=180)
+    plt.close(fig)
+    print(json.dumps(metrics, indent=2, sort_keys=True))
+    return metrics
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--mlp-epochs", type=int, default=40)
+    parser.add_argument("--gru-epochs", type=int, default=60)
+    args = parser.parse_args()
+    train(mlp_epochs=args.mlp_epochs, gru_epochs=args.gru_epochs)
+
+
+if __name__ == "__main__":
+    main()

src/load_t2_material_loading_memory.py

@@ -0,0 +1,79 @@
+"""Lightweight reader for T2 material-loading-memory HDF5 shards."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Iterator
+
+import h5py
+import numpy as np
+
+
+def load_manifest(dataset_root: str | Path) -> dict[str, object]:
+    root = Path(dataset_root)
+    return json.loads((root / "manifest.json").read_text(encoding="utf-8"))
+
+
+def _resolve_shard(root: Path, relative_path: str) -> Path:
+    candidate = root / "shards" / Path(relative_path).name
+    if candidate.exists():
+        return candidate
+    return root.parents[1] / relative_path
+
+
+def _group_to_sample(sample_id: str, group: h5py.Group) -> dict[str, object]:
+    return {
+        "id": sample_id,
+        "case_id": str(group.attrs["case_id"]),
+        "split": str(group.attrs["split"]),
+        "material_model": str(group.attrs["material_model"]),
+        "path_family": str(group.attrs["path_family"]),
+        "parameters": json.loads(str(group.attrs["parameters_json"])),
+        "metrics": json.loads(str(group.attrs["metrics_json"])),
+        "history": {name: np.asarray(group[name]) for name in group.keys()},
+    }
+
+
+def iter_trajectories(
+    dataset_root: str | Path,
+    *,
+    split: str | None = None,
+    material_model: str | None = None,
+    path_family: str | None = None,
+) -> Iterator[dict[str, object]]:
+    """Yield copied histories, optionally filtered by trajectory metadata."""
+
+    root = Path(dataset_root)
+    manifest = load_manifest(root)
+    for shard in manifest["shards"]:
+        with h5py.File(_resolve_shard(root, shard["path"]), "r") as h5:
+            for sample_id in sorted(h5.keys()):
+                group = h5[sample_id]
+                if split is not None and str(group.attrs["split"]) != split:
+                    continue
+                if (
+                    material_model is not None
+                    and str(group.attrs["material_model"]) != material_model
+                ):
+                    continue
+                if (
+                    path_family is not None
+                    and str(group.attrs["path_family"]) != path_family
+                ):
+                    continue
+                yield _group_to_sample(sample_id, group)
+
+
+def load_trajectory(
+    dataset_root: str | Path, sample_id: str | int
+) -> dict[str, object]:
+    target = f"{int(sample_id):05d}"
+    root = Path(dataset_root)
+    manifest = load_manifest(root)
+    for shard in manifest["shards"]:
+        if shard["first_id"] <= target <= shard["last_id"]:
+            with h5py.File(_resolve_shard(root, shard["path"]), "r") as h5:
+                if target in h5:
+                    return _group_to_sample(target, h5[target])
+    raise KeyError(f"Unknown trajectory id: {target}")

src/t2_material_loading_memory.py

@@ -0,0 +1,770 @@
+"""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()

src/t2_material_loading_memory_v1.py

@@ -0,0 +1,743 @@
+"""Build the restartable T2 material-loading-memory v1 dataset.
+
+One sample is one complete material-point trajectory. The 121 states within a
+trajectory are never counted as independent samples. J2 linear isotropic
+hardening and Chaboche combined hardening remain explicit 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
+
+try:
+    from src import t2_material_loading_memory as core
+except ModuleNotFoundError:  # Direct execution from the src directory.
+    import t2_material_loading_memory as core
+
+
+ROOT = Path(__file__).resolve().parents[1]
+CONFIG_PATH = ROOT / "configs" / "t2_material_loading_memory_v1.json"
+DATA_DIR = ROOT / "data" / "t2_material_loading_memory_v1"
+SAMPLE_DIR = DATA_DIR / "samples"
+RECORD_DIR = DATA_DIR / "records"
+SHARD_DIR = DATA_DIR / "shards"
+ARTIFACT_DIR = ROOT / "artifacts" / "t2_material_loading_memory_v1"
+DESIGN_PATH = DATA_DIR / "design.jsonl"
+INDEX_PATH = DATA_DIR / "index.jsonl"
+MANIFEST_PATH = DATA_DIR / "manifest.json"
+
+AGENTFEM_COMMIT = "058faecc05aeda143d014fd229401003a9258bbb"
+MATERIAL_MODELS = core.MATERIAL_MODELS
+PATH_FAMILIES = core.PATH_FAMILIES
+REQUIRED_ARRAYS = (
+    "time_coordinate",
+    "path_anchors",
+    "signed_equivalent_strain",
+    "total_strain",
+    "stress_pa",
+    "signed_equivalent_stress_pa",
+    "mises_stress_pa",
+    "plastic_strain",
+    "equivalent_plastic_strain",
+    "plastic_multiplier_increment",
+    "elastic_step",
+    "trial_yield_function_pa",
+    "yield_radius_pa",
+    "shifted_mises_stress_pa",
+    "backstress_pa",
+    "backstress_components_pa",
+    "plastic_work_increment_j_m3",
+    "cumulative_plastic_work_j_m3",
+    "external_work_increment_j_m3",
+    "cumulative_external_work_j_m3",
+)
+
+
+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 1,008-trajectory Sobol design."""
+
+    config = load_config()
+    actual_seed = int(config["seed"] if seed is None else seed)
+    ranges = config["ranges"]
+    per_stratum = int(config["samples_per_stratum"])
+    required = len(MATERIAL_MODELS) * len(PATH_FAMILIES) * per_stratum
+    exponent = int(np.ceil(np.log2(required)))
+    unit = qmc.Sobol(12, scramble=True, seed=actual_seed).random_base2(exponent)
+    rows: list[dict[str, object]] = []
+    cursor = 0
+    for material_model in MATERIAL_MODELS:
+        for path_family in PATH_FAMILIES:
+            for replicate in range(per_stratum):
+                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 v1 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_v1", parameters)
+
+
+def split_assignments(parameters: tuple[dict[str, object], ...]) -> dict[int, str]:
+    """Create 64/10/10 train/validation/test splits in 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[:64]:
+                result[int(index)] = "train"
+            for index in members[64:74]:
+                result[int(index)] = "validation"
+            for index in members[74:84]:
+                result[int(index)] = "test"
+    return result
+
+
+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:
+    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 _write_jsonl_atomic(path: Path, rows: list[dict[str, object]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    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 _write_npz_atomic(path: Path, arrays: dict[str, np.ndarray]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_suffix(path.suffix + ".tmp")
+    with temporary.open("wb") as stream:
+        np.savez_compressed(stream, **arrays)
+    os.replace(temporary, path)
+
+
+def sample_paths(index: int) -> tuple[Path, Path]:
+    return SAMPLE_DIR / f"{index:05d}.npz", RECORD_DIR / f"{index:05d}.json"
+
+
+def write_design() -> Path:
+    parameters = design_parameters()
+    splits = split_assignments(parameters)
+    rows = [
+        {
+            "id": f"{index:05d}",
+            "case_id": case_identity(row),
+            "split": splits[index],
+            "parameters": row,
+        }
+        for index, row in enumerate(parameters)
+    ]
+    _write_jsonl_atomic(DESIGN_PATH, rows)
+    return DESIGN_PATH
+
+
+def _sample_complete(index: int, expected_case_id: str) -> bool:
+    sample_path, record_path = sample_paths(index)
+    if not sample_path.exists() or not record_path.exists():
+        return False
+    try:
+        record = json.loads(record_path.read_text(encoding="utf-8"))
+        if record["case_id"] != expected_case_id:
+            return False
+        with np.load(sample_path) as arrays:
+            if set(REQUIRED_ARRAYS) - set(arrays.files):
+                return False
+            return all(np.isfinite(arrays[name]).all() for name in REQUIRED_ARRAYS)
+    except (OSError, ValueError, KeyError, json.JSONDecodeError):
+        return False
+
+
+def _solve_record(
+    index: int, parameters: dict[str, object], split: str
+) -> tuple[dict[str, np.ndarray], dict[str, object]]:
+    points = int(load_config()["points_per_trajectory"])
+    arrays, metrics = core.solve_trajectory(parameters, points=points)
+    reference_error = 0.0
+    if (
+        parameters["material_model"] == "j2_linear_isotropic"
+        and parameters["path_family"] == "monotonic_tension"
+    ):
+        reference_stress, reference_peeq = core._j2_monotonic_reference(parameters)
+        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_identity(parameters),
+        "split": split,
+        "parameters": parameters,
+        "metrics": metrics,
+        "initial_signed_stress_pa": float(arrays["signed_equivalent_stress_pa"][0]),
+        "j2_analytical_relative_error": float(reference_error),
+    }
+    return arrays, record
+
+
+def generate_range(start: int, stop: int, *, force: bool = False) -> dict[str, object]:
+    parameters = design_parameters()
+    splits = split_assignments(parameters)
+    if start < 0 or stop > len(parameters) or start >= stop:
+        raise ValueError(f"Invalid range [{start}, {stop}) for {len(parameters)} samples.")
+    if not DESIGN_PATH.exists():
+        write_design()
+    started = time.perf_counter()
+    generated = 0
+    reused = 0
+    failures: list[dict[str, object]] = []
+    for index in range(start, stop):
+        row = parameters[index]
+        case_id = case_identity(row)
+        if not force and _sample_complete(index, case_id):
+            reused += 1
+            continue
+        sample_path, record_path = sample_paths(index)
+        try:
+            arrays, record = _solve_record(index, row, splits[index])
+            _write_npz_atomic(sample_path, arrays)
+            _write_json_atomic(record_path, record)
+            generated += 1
+        except Exception as exc:  # Preserve failed identities instead of hiding them.
+            failures.append(
+                {
+                    "id": f"{index:05d}",
+                    "case_id": case_id,
+                    "error_type": type(exc).__name__,
+                    "error": str(exc),
+                }
+            )
+    summary = {
+        "start": start,
+        "stop": stop,
+        "generated": generated,
+        "reused": reused,
+        "failures": failures,
+        "wall_seconds": float(time.perf_counter() - started),
+    }
+    _write_json_atomic(ARTIFACT_DIR / f"range_{start:05d}_{stop:05d}.json", summary)
+    print(json.dumps(summary, indent=2, sort_keys=True))
+    if failures:
+        raise RuntimeError(f"Range [{start}, {stop}) had {len(failures)} failures.")
+    return summary
+
+
+def _load_records() -> list[dict[str, object]]:
+    count = int(load_config()["sample_count"])
+    records: list[dict[str, object]] = []
+    missing: list[int] = []
+    for index in range(count):
+        _, record_path = sample_paths(index)
+        if not record_path.exists():
+            missing.append(index)
+            continue
+        records.append(json.loads(record_path.read_text(encoding="utf-8")))
+    if missing:
+        raise RuntimeError(f"Missing {len(missing)} records; first IDs: {missing[:8]}")
+    return records
+
+
+def package_shards() -> dict[str, object]:
+    config = load_config()
+    parameters = design_parameters()
+    records = _load_records()
+    SHARD_DIR.mkdir(parents=True, exist_ok=True)
+    index_rows: list[dict[str, object]] = []
+    shard_rows: list[dict[str, object]] = []
+    for shard_index, members in enumerate(
+        np.array_split(np.arange(len(parameters), dtype=int), int(config["shard_count"]))
+    ):
+        output = SHARD_DIR / f"part-{shard_index:05d}.h5"
+        temporary = output.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 in members:
+                record = records[int(index)]
+                sample_path, _ = sample_paths(int(index))
+                if not _sample_complete(int(index), str(record["case_id"])):
+                    raise RuntimeError(f"Incomplete sample: {int(index):05d}")
+                group = h5.create_group(f"{int(index):05d}")
+                group.attrs["case_id"] = record["case_id"]
+                group.attrs["split"] = record["split"]
+                group.attrs["material_model"] = record["parameters"]["material_model"]
+                group.attrs["path_family"] = record["parameters"]["path_family"]
+                group.attrs["parameters_json"] = json.dumps(
+                    record["parameters"], sort_keys=True
+                )
+                group.attrs["metrics_json"] = json.dumps(record["metrics"], sort_keys=True)
+                with np.load(sample_path) as arrays:
+                    for name in REQUIRED_ARRAYS:
+                        group.create_dataset(
+                            name, data=arrays[name], compression="gzip", shuffle=True
+                        )
+                index_rows.append(
+                    {
+                        **record,
+                        "shard": str(output.relative_to(ROOT)),
+                    }
+                )
+        os.replace(temporary, output)
+        shard_rows.append(
+            {
+                "path": str(output.relative_to(ROOT)),
+                "first_id": f"{int(members[0]):05d}",
+                "last_id": f"{int(members[-1]):05d}",
+                "sample_count": int(len(members)),
+                "bytes": output.stat().st_size,
+                "sha256": _sha256(output),
+            }
+        )
+    index_rows.sort(key=lambda row: str(row["id"]))
+    _write_jsonl_atomic(INDEX_PATH, index_rows)
+    manifest = {
+        "schema": config["schema"],
+        "schema_version": config["schema_version"],
+        "dataset_version": config["dataset_version"],
+        "sample_count": len(parameters),
+        "points_per_trajectory": config["points_per_trajectory"],
+        "agentfem_version": agentfem.__version__,
+        "agentfem_commit": AGENTFEM_COMMIT,
+        "shards": shard_rows,
+    }
+    _write_json_atomic(MANIFEST_PATH, manifest)
+    print(json.dumps(manifest, indent=2, sort_keys=True))
+    return manifest
+
+
+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 _refinement_audits(
+    parameters: tuple[dict[str, object], ...]
+) -> list[dict[str, object]]:
+    selected = [
+        index
+        for index, row in enumerate(parameters)
+        if int(row["replicate"]) in (0, int(load_config()["samples_per_stratum"]) - 1)
+    ]
+    refinements: list[dict[str, object]] = []
+    for index in selected:
+        row = parameters[index]
+        sample_path, _ = sample_paths(index)
+        with np.load(sample_path) as coarse:
+            coarse_stress = np.asarray(coarse["signed_equivalent_stress_pa"])
+            coarse_peeq = np.asarray(coarse["equivalent_plastic_strain"])
+        fine, _ = core.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_stress - fine_stress)) / stress_scale
+                ),
+                "maximum_peeq_relative_change": float(
+                    np.max(np.abs(coarse_peeq - fine_peeq)) / peeq_scale
+                ),
+            }
+        )
+    return refinements
+
+
+def _create_preview(parameters: tuple[dict[str, object], ...]) -> 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
+            )
+            sample_path, _ = sample_paths(index)
+            with np.load(sample_path) as arrays:
+                strain = np.asarray(arrays["signed_equivalent_strain"])
+                stress = np.asarray(arrays["signed_equivalent_stress_pa"])
+            axis.plot(100.0 * strain, stress / 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 v1: 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 audit_dataset() -> dict[str, object]:
+    config = load_config()
+    parameters = design_parameters()
+    splits = split_assignments(parameters)
+    records = _load_records()
+    manifest = json.loads(MANIFEST_PATH.read_text(encoding="utf-8"))
+    integrity_failures: list[dict[str, object]] = []
+    observed_ids: list[str] = []
+    for shard in manifest["shards"]:
+        path = ROOT / shard["path"]
+        if _sha256(path) != shard["sha256"]:
+            integrity_failures.append({"shard": shard["path"], "error": "sha256"})
+            continue
+        with h5py.File(path, "r") as h5:
+            observed_ids.extend(sorted(h5.keys()))
+            for sample_id, group in h5.items():
+                missing = sorted(set(REQUIRED_ARRAYS) - set(group.keys()))
+                nonfinite = [
+                    name for name in REQUIRED_ARRAYS if name in group and not np.isfinite(group[name][:]).all()
+                ]
+                if missing or nonfinite:
+                    integrity_failures.append(
+                        {"id": sample_id, "missing": missing, "nonfinite": nonfinite}
+                    )
+    expected_ids = [f"{index:05d}" for index in range(len(parameters))]
+    if observed_ids != expected_ids:
+        integrity_failures.append({"error": "sample_id_coverage"})
+    refinements = _refinement_audits(parameters)
+    failures = _quality_failures(parameters, records, refinements)
+    failures.extend(integrity_failures)
+    preview = _create_preview(parameters)
+    summary = {
+        "status": "accepted" if not failures else "rejected",
+        "sample_count": len(parameters),
+        "points_per_trajectory": config["points_per_trajectory"],
+        "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)
+        ),
+        "data_bytes": int(sum(int(shard["bytes"]) for shard in manifest["shards"])),
+        "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 v1 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: 168 trajectories each
+- Train/validation/test trajectories: 768/120/120
+- Points per trajectory: {config['points_per_trajectory']}
+- Packaged HDF5 shards: {len(manifest['shards'])}
+
+## 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 across 24 audits: {summary['maximum_refined_stress_relative_change']:.3%}
+- Maximum 121-to-241-point PEEQ change across 24 audits: {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 v1 failed {len(failures)} quality checks.")
+    return summary
+
+
+def validate_design() -> dict[str, object]:
+    parameters = design_parameters()
+    splits = split_assignments(parameters)
+    config = load_config()
+    result = {
+        "sample_count": len(parameters),
+        "unique_case_ids": len({case_identity(row) for row in parameters}),
+        "splits": {
+            name: sum(value == name for value in splits.values())
+            for name in ("train", "validation", "test")
+        },
+        "strata": {
+            f"{model}/{family}": sum(
+                row["material_model"] == model and row["path_family"] == family
+                for row in parameters
+            )
+            for model in MATERIAL_MODELS
+            for family in PATH_FAMILIES
+        },
+        "expected": {
+            "sample_count": config["sample_count"],
+            "splits": config["splits"],
+        },
+    }
+    if result["sample_count"] != config["sample_count"]:
+        raise RuntimeError("Unexpected design size.")
+    if result["unique_case_ids"] != result["sample_count"]:
+        raise RuntimeError("Duplicate case IDs.")
+    if result["splits"] != config["splits"]:
+        raise RuntimeError("Unexpected split counts.")
+    print(json.dumps(result, indent=2, sort_keys=True))
+    return result
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--design-only", action="store_true")
+    parser.add_argument("--validate-design", action="store_true")
+    parser.add_argument("--range", nargs=2, type=int, metavar=("START", "STOP"))
+    parser.add_argument("--force", action="store_true")
+    parser.add_argument("--package", action="store_true")
+    parser.add_argument("--audit", action="store_true")
+    parser.add_argument("--all", action="store_true")
+    args = parser.parse_args()
+    if args.design_only:
+        print(write_design())
+        return
+    if args.validate_design:
+        validate_design()
+        return
+    if args.range:
+        generate_range(args.range[0], args.range[1], force=args.force)
+        return
+    if args.package:
+        package_shards()
+        return
+    if args.audit:
+        audit_dataset()
+        return
+    if args.all:
+        generate_range(0, int(load_config()["sample_count"]), force=args.force)
+        package_shards()
+        audit_dataset()
+        return
+    parser.error("Choose --design-only, --validate-design, --range, --package, --audit or --all.")
+
+
+if __name__ == "__main__":
+    main()

tests/test_t2_material_loading_memory.py

@@ -0,0 +1,112 @@
+import json
+from pathlib import Path
+
+import h5py
+import numpy as np
+
+from src.t2_material_loading_memory import (
+    DATA_PATH,
+    MATERIAL_MODELS,
+    PATH_FAMILIES,
+    _j2_monotonic_reference,
+    case_identity,
+    design_parameters,
+    prescribed_history,
+    solve_trajectory,
+    split_assignments,
+)
+
+
+def test_t2_design_is_unique_balanced_and_split_by_trajectory():
+    rows = design_parameters()
+    split = split_assignments(rows)
+    assert len(rows) == 96
+    assert len({case_identity(row) for row in rows}) == 96
+    assert sum(value == "train" for value in split.values()) == 72
+    assert sum(value == "validation" for value in split.values()) == 12
+    assert sum(value == "test" for value in split.values()) == 12
+    for model in MATERIAL_MODELS:
+        assert sum(row["material_model"] == model for row in rows) == 48
+        for family in PATH_FAMILIES:
+            indices = [
+                index
+                for index, row in enumerate(rows)
+                if row["material_model"] == model
+                and row["path_family"] == family
+            ]
+            assert len(indices) == 8
+            assert sum(split[index] == "train" for index in indices) == 6
+            assert sum(split[index] == "validation" for index in indices) == 1
+            assert sum(split[index] == "test" for index in indices) == 1
+
+
+def test_t2_prescribed_histories_have_fixed_size_and_required_reversals():
+    for row in design_parameters():
+        time, strain, anchors = prescribed_history(row)
+        assert len(time) == len(strain) == 121
+        assert np.all(np.diff(time) > 0.0)
+        assert strain[0] == 0.0
+        assert np.max(np.abs(strain)) <= 1.15 * row["maximum_equivalent_strain"]
+        for anchor in anchors:
+            assert np.any(np.isclose(strain, anchor, rtol=0.0, atol=1.0e-15))
+        if row["path_family"] not in ("monotonic_tension", "unload_reload"):
+            assert np.min(anchors) < 0.0 < np.max(anchors)
+
+
+def test_t2_refined_paths_are_nested_at_every_coarse_state():
+    for row in design_parameters():
+        _, coarse, _ = prescribed_history(row, points=121)
+        _, fine, _ = prescribed_history(row, points=241)
+        np.testing.assert_allclose(coarse, fine[::2], rtol=0.0, atol=1.0e-15)
+
+
+def test_t2_agentfem_material_point_smoke_paths_are_physical():
+    rows = design_parameters()
+    for model in MATERIAL_MODELS:
+        for family in PATH_FAMILIES:
+            row = next(
+                item
+                for item in rows
+                if item["material_model"] == model
+                and item["path_family"] == family
+            )
+            arrays, metrics = solve_trajectory(row, points=41)
+            assert metrics["all_finite"]
+            assert metrics["plastic_step_count"] > 0
+            assert metrics["maximum_plastic_strain_trace"] < 1.0e-10
+            assert metrics["minimum_peeq_increment"] >= -1.0e-12
+            assert metrics["maximum_yield_surface_relative_residual"] < 1.0e-8
+            assert arrays["signed_equivalent_stress_pa"][0] == 0.0
+            if family == "symmetric_cyclic":
+                assert metrics["zero_strain_stress_range_pa"] > 1.0e6
+
+
+def test_t2_j2_monotonic_path_matches_closed_form():
+    row = next(
+        item
+        for item in design_parameters()
+        if item["material_model"] == "j2_linear_isotropic"
+        and item["path_family"] == "monotonic_tension"
+    )
+    arrays, _ = solve_trajectory(row, points=41)
+    stress, peeq = _j2_monotonic_reference(row)
+    np.testing.assert_allclose(
+        arrays["signed_equivalent_stress_pa"][-1], stress, rtol=1.0e-11
+    )
+    np.testing.assert_allclose(
+        arrays["equivalent_plastic_strain"][-1], peeq, rtol=1.0e-11
+    )
+
+
+def test_t2_packaged_pilot_is_readable_when_present():
+    if not DATA_PATH.exists():
+        return
+    quality_path = DATA_PATH.parents[2] / "artifacts" / DATA_PATH.parent.name / "quality.json"
+    quality = json.loads(quality_path.read_text(encoding="utf-8"))
+    assert quality["status"] == "accepted"
+    with h5py.File(DATA_PATH, "r") as h5:
+        assert len(h5) == 96
+        for group in h5.values():
+            assert group["stress_pa"].shape == (121, 3, 3)
+            assert np.isfinite(group["stress_pa"][:]).all()
+            assert np.isfinite(group["equivalent_plastic_strain"][:]).all()

tests/test_t2_material_loading_memory_v1.py

@@ -0,0 +1,72 @@
+import json
+
+import numpy as np
+
+from src.load_t2_material_loading_memory import load_trajectory
+from src.t2_material_loading_memory import prescribed_history
+from src.t2_material_loading_memory_v1 import (
+    DATA_DIR,
+    MATERIAL_MODELS,
+    PATH_FAMILIES,
+    case_identity,
+    design_parameters,
+    split_assignments,
+)
+
+
+def test_v1_design_is_unique_balanced_and_stratified():
+    rows = design_parameters()
+    split = split_assignments(rows)
+    assert len(rows) == 1008
+    assert len({case_identity(row) for row in rows}) == 1008
+    assert sum(value == "train" for value in split.values()) == 768
+    assert sum(value == "validation" for value in split.values()) == 120
+    assert sum(value == "test" for value in split.values()) == 120
+    for model in MATERIAL_MODELS:
+        assert sum(row["material_model"] == model for row in rows) == 504
+        for family in PATH_FAMILIES:
+            indices = [
+                index
+                for index, row in enumerate(rows)
+                if row["material_model"] == model and row["path_family"] == family
+            ]
+            assert len(indices) == 84
+            assert sum(split[index] == "train" for index in indices) == 64
+            assert sum(split[index] == "validation" for index in indices) == 10
+            assert sum(split[index] == "test" for index in indices) == 10
+
+
+def test_v1_parameter_ranges_and_model_labels_are_explicit():
+    rows = design_parameters()
+    for row in rows:
+        assert 150.0e9 <= row["young_pa"] <= 230.0e9
+        assert 0.25 <= row["poisson"] <= 0.34
+        assert 180.0e6 <= row["yield_stress_pa"] <= 450.0e6
+        assert 0.003 <= row["maximum_equivalent_strain"] <= 0.012
+        if row["material_model"] == "j2_linear_isotropic":
+            assert row["backstress_c1_pa"] == 0.0
+            assert row["isotropic_saturation_pa"] == 0.0
+        else:
+            assert row["hardening_modulus_pa"] == 0.0
+            assert row["backstress_c1_pa"] > 0.0
+
+
+def test_v1_histories_preserve_reversals_under_refinement():
+    for row in design_parameters()[::83]:
+        _, coarse, anchors = prescribed_history(row, points=121)
+        _, fine, _ = prescribed_history(row, points=241)
+        np.testing.assert_allclose(coarse, fine[::2], rtol=0.0, atol=1.0e-15)
+        for anchor in anchors:
+            assert np.any(np.isclose(coarse, anchor, rtol=0.0, atol=1.0e-15))
+
+
+def test_v1_packaged_data_and_lightweight_reader_when_present():
+    manifest_path = DATA_DIR / "manifest.json"
+    if not manifest_path.exists():
+        return
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    assert manifest["sample_count"] == 1008
+    assert len(manifest["shards"]) == 8
+    sample = load_trajectory(DATA_DIR, 0)
+    assert sample["history"]["stress_pa"].shape == (121, 3, 3)
+    assert np.isfinite(sample["history"]["stress_pa"]).all()