Adds samples.

CLAUDE.md

@@ -0,0 +1,132 @@
+# CLAUDE.md
+
+Context for continuing work on this dataset. Captures the design decisions and conventions worked out so far.
+
+## What this dataset is
+
+`Inova-Mk1-ASTM` is the **ML-facing mechanical-test dataset**: one row per ASTM specimen (D638 tensile, D790 flex), with the mechanical response (curves + scalars) and the **printer state that produced the part** embedded inline as a snapshot. Domain-aligned with `Inova-Mk1-Database`, which is the canonical *graph* of printer entities.
+
+Default to embedding snapshots over relying on cross-joins — consumers training models should be able to load this one config and have everything they need on each row.
+
+## Ecosystem
+
+- **Upstream graph dataset**: `ppak10/Inova-Mk1-Database` — canonical print jobs, sessions, profiles, objects (see its CLAUDE.md). This dataset reads `Inova-Mk1-Database/data/jobs.jsonl` and `Inova-Mk1-Database/source/PrintProfiles/*.json` directly via a sibling-folder relative path.
+- **Sibling domain datasets** (planned): `Inova-Mk1-Telemetry`.
+- **Raw mechanical-test source**: TestWorks 4.1 (MTS Insight EM Tension / 3-pt Flex) — per-session folders dropped under `source/{YYYY_MM_DD}/`. LFS-tracked.
+
+## Architectural decisions
+
+- **One row per specimen.** Granularity = a single TestRun. `specimen_id` (= `"{session_folder}/TSR{n}"`) is the path-style unique key; `sample_id` (= `"{batch_label}{seq}"`, e.g. `"C7"`) is the human-friendly handle.
+- **One HF config per ASTM standard.** Tensile (D638) and flex (D790) live in `data/D638.jsonl` and `data/D790.jsonl` and load as separate configs (`load_dataset("ppak10/Inova-Mk1-ASTM", "D790")`). The schema is identical across configs; only the `astm.standard` value and the metric coverage differ.
+- **Snapshot + reference for SLS rows.** Each SLS row carries both the FK ids (`job_id`, `print_profile_id`, `object_hash`) AND the full `print_profile_snapshot` JSON. The PrintProfile is the load-bearing feature set for ML; the job snapshot is *not* embedded (job_id is enough — consumers can join if they need the full job metadata).
+- **Batch labels are a property of the print batch, not the test session.** `batch_label` (A/B/C/D/E) identifies the print run the specimen came from, so the same batch can appear in both configs (e.g. Batch C produced both tensile and flex specimens from the same 06/02 print). `sample_id` numbering is **per-config-per-batch**, so `C1` in D638 ≠ `C1` in D790 (different physical specimens, same batch).
+- **PLA / PETG control rows live alongside SLS rows in the D638 config.** They carry the same mechanical-result fields with `material_class != "SLS"`, null Database FKs, and **null `sample_id`/`batch_label`** (they didn't come from an SLS print batch). They're benchtop comparison filament printed elsewhere and tested on the same Instron.
+- **One script per source session folder, plus a shared `_lib.py`.** Each `scripts/specimens/{NN}_*.py` declares one `SESSION` dict (session_folder, xlsx_name, astm, batch_label, test_runs) and calls `_lib.process_session(SESSION)`. Reader/joiner/builder logic lives in `_lib.py`. Auto-inference of "test the day after print" is **not** safe — 2026-06-10 mixes 3 materials in one session and Batch C flex was tested 8 days after print, so the session→print-job mapping has to be declared per script.
+- **One JSONL file per specimen.** Outputs land under `data/{standard}/{sample_id}.jsonl` (or `data/D638/{material_class}_TSR{n}.jsonl` for PLA/PETG controls without a sample_id). HF configs glob these via `path: data/D638/*.jsonl`. This keeps git diffs scoped to a single specimen when a row is regenerated and makes it easy to delete or replace individual rows.
+- **Domain dependencies, not stdlib-only.** Unlike `Inova-Mk1-Database` (stdlib only), the ETL here needs `h5py` and `openpyxl`. They're declared in `pyproject.toml`. Python 3.13.
+
+## Directory layout
+
+```
+source/
+  {YYYY_MM_DD}/                         # one folder per test date
+    [sublabel/]                         # e.g. "Tensile Testing", "Batch C 3pt test"
+      *.tsproj                          # TestWorks project pointer
+      *.xlsx                            # human-readable export, one sheet per TSR
+      TST1.Test/
+        TestRuns/TSR{n}.TestRun/
+          Data/DaqTaskActivity1.h5      # raw DAQ scans (10 Hz): ext_m, load_N, time_s
+          AnalysisRuns/ANR1.AnalysisRun/
+            persistent.h5               # analyzed scalars + StressArray/StrainArray
+          TestRun.Traits                # small XML — Name, Date, UniqueId
+          TestRun.1.Traits              # ~20k lines, mostly base64 .NET ExecutionState — SKIP
+
+scripts/specimens/
+  _lib.py                               # shared readers, Database lookup, build_row, process_session
+  01_2026_05_26.py                      # Batch A tensile
+  02_2026_06_01.py                      # Batch B tensile
+  03_2026_06_03.py                      # Batch C tensile
+  04_2026_06_10_tensile.py              # Batch D tensile + PLA/PETG controls
+  05_2026_06_10_batch_c.py              # Batch C flex
+  06_2026_06_10_batch_d.py              # Batch D flex
+  07_2026_06_10_batch_e.py              # Batch E flex (no Database FK yet)
+
+data/
+  D638/                                 # one JSONL per specimen (HF glob: data/D638/*.jsonl)
+    A1.jsonl ... D5.jsonl               # SLS specimens, named by sample_id
+    PLA_TSR6.jsonl ... PETG_TSR11.jsonl # PLA/PETG controls (no sample_id)
+  D790/
+    C1.jsonl ... E10.jsonl              # SLS specimens, named by sample_id
+```
+
+## File format notes — TestWorks 4.1 output
+
+- **`Data/DaqTaskActivity1.h5`**: HDF5 with one `Session{16-digit}` group. `Scans` is `(N, 3) float64` of `[extension_m, load_N, time_s]` per the `Signals` dataset. `Triggers` records DAQ config (sample rate is in there as e.g. `Frequency=10`).
+- **`AnalysisRuns/ANR1.AnalysisRun/persistent.h5`**: HDF5 with a single dataset `Values` of shape `(1,)` containing a giant compound record. All scalar metrics (Modulus, PeakStress, StressAtBreak, Yield, Slope, etc.) are `<f8` fields; **stress-strain curves are `object`-dtype fields** (`StressArray`, `StrainArray`, `_TimeArray`, etc.) that decode to variable-length numpy arrays.
+- **xlsx export**: cols A-B = curve, row 1 = TestRun name, row 2 = units, cols D-I = `(DisplayName, Value, Unit, Reset Value, Original Value, Description)` per scalar metric. **Specimen `Width` and `Thickness` only live here** — not in any tidy field in the h5 files (the h5 only has the derived `Area` and `AdjGage`).
+- **`TestRun.1.Traits`** and `Test.1.Traits` etc. are mostly opaque .NET binary serialization (base64-encoded inside an `<ExecutionState>` element). Don't try to parse — re-derive from the h5 / xlsx instead.
+
+## Row shape
+
+See `README.md` for the full schema. Key envelope fields:
+- `sample_id` = `"{batch_label}{seq}"` (e.g. `"A1"`, `"C7"`, `"E10"`); null for non-SLS controls.
+- `batch_label` ∈ `{"A","B","C","D","E"}`; null for non-SLS controls.
+- `specimen_id` = `"{session_folder}/TSR{n}"` — fully qualified unique key (use this if you need to disambiguate across configs).
+- `material_class` ∈ `{"SLS", "PLA", "PETG", …}` — only `"SLS"` rows have populated Database FKs and `print_profile_snapshot`.
+- `astm` = `{standard, type, year}` object — structured (not a flat string) so ISO equivalents can be added later without breaking schema.
+- `curves` carries **both** analyzed (`stress_pa`, `strain`) and raw DAQ (`time_s`, `extension_m`, `load_n`) — lossless.
+
+### IMPORTANT — TestWorks analysis often fails to detect peak/break for tensile
+
+Many D638 TSRs have `Peak = LongMax (9223372036854775807)` in persistent.h5, which leaves `PeakLoad`, `PeakStress`, `StressAtBreak`, `EnergyToBreak`, `StrnAtBreak` etc. all `NaN` despite a real break occurring. Our extract surfaces these as `null`. **The full stress-strain curve is still saved**, so consumers can re-derive peak/break with their own criteria. D790 flex rows have these populated more consistently. Don't filter rows based on null metrics; they may still be perfectly valid trials.
+
+### IMPORTANT — field-name divergence between tensile and flex persistent.h5
+
+Same TestWorks framework, different schema. Notable renames you have to handle:
+- `StrnAtPeak` (tensile) ↔ `StrainAtPeak` (flex)
+- `StrnAtBreak` (tensile) ↔ `BreakStrain` (flex)
+- `StrnAtYield` (tensile) ↔ `StrainAtYield` (flex)
+- `Slope` (tensile, single) ↔ `Slope1`/`Slope2` (flex)
+- `AdjGage` (tensile only — flex has no analogous field, gauge_length_mm is always null for D790)
+
+`get_either(d, "tensile_name", "flex_name")` in `01_extract.py` handles this. If you add new scalars, check both files and use `get_either` rather than picking one name.
+
+## Current state
+
+- `D638` config — 28 rows (22 SLS + 3 PLA + 3 PETG).
+- `D790` config — 27 rows (17 SLS with full FKs + 10 Batch E SLS rows with null FKs pending Database backfill).
+- Total: 55 specimens across 7 TestWorks sessions.
+
+## Running the extract
+
+Each per-session script is independently runnable; output is per-specimen JSONL.
+
+```bash
+# All sessions:
+for f in scripts/specimens/0*.py; do uv run "$f"; done
+
+# Just one session (e.g. when re-extracting after a fix):
+uv run scripts/specimens/01_2026_05_26.py
+```
+
+## Adding a new session — recipe
+
+1. Drop the TestWorks session folder under `source/{YYYY_MM_DD}/` (or `source/{YYYY_MM_DD}/{label}/` for multiple sessions per day, as 2026_06_10 already does).
+2. `git lfs add` the `.h5`, `.Traits`, `.xlsx` files via the repo's `.gitattributes` (already configured).
+3. Add a new `scripts/specimens/{NN}_{slug}.py` (number it after the existing scripts). Use any of the existing scripts as a template — they're ~15 lines each. Declare:
+   - `session_folder`, `test_folder` (almost always `"TST1.Test"`), `xlsx_name`
+   - `astm` block (`standard` routes the output to `data/D638/` vs `data/D790/`)
+   - `batch_label` (single letter)
+   - `test_runs`: list of `(tsr_index, material_class, db_print_date | None)`. For SLS rows pick the source print job from `Inova-Mk1-Database/data/jobs.jsonl` by `print_date`. For non-SLS and SLS-without-Database-job, pass `None`.
+4. Run that one script → new files land in `data/{standard}/`.
+5. Update the README's "Test sessions covered" table.
+
+## Backfilling Batch E
+
+When the print job behind Batch E lands in `Inova-Mk1-Database/data/jobs.jsonl`:
+1. In `scripts/specimens/07_2026_06_10_batch_e.py`, change `(i, "SLS", None)` to `(i, "SLS", "<print_date>")`.
+2. Re-run that one script. The 10 Batch E JSONLs in `data/D790/E*.jsonl` get FKs and `print_profile_snapshot` filled in. No schema change needed.
+
+## Scope note
+
+Mirrors the `Inova-Mk1-Database` scope: ASTM-subset only. If the parent Database is later broadened to cover all SLS prints, the `MANIFEST` here doesn't need to change — only the specimens whose source print job is now in Database will get FKs filled in.

README.md

@@ -1,3 +1,149 @@
 ---
 license: mit
+tags:
+- astm
+- mechanical-testing
+- tensile
+- flex
+- sls
+- 3d-printing
+- additive-manufacturing
+- inova-mk1
+configs:
+- config_name: D638
+  data_files:
+  - split: train
+    path: data/D638/*.jsonl
+  default: true
+- config_name: D790
+  data_files:
+  - split: train
+    path: data/D790/*.jsonl
 ---
+
+# Inova-Mk1-ASTM
+
+ASTM mechanical-test specimens (D638 tensile, D790 flex) printed on the Inova Mk1 SLS printer and pulled on an MTS / TestWorks Instron. Each row is a single specimen with full geometry, scalar results, stress–strain + raw DAQ curves, and — for SLS rows — FK references and an embedded snapshot of the upstream print profile from [`ppak10/Inova-Mk1-Database`](https://huggingface.co/datasets/ppak10/Inova-Mk1-Database).
+
+Rows are self-contained for ML use: the full `PrintProfile` JSON is inlined, so features (material/energy profile) and target (mechanical response) live on the same row.
+
+```python
+from datasets import load_dataset
+tensile = load_dataset("ppak10/Inova-Mk1-ASTM", "D638", split="train")
+flex    = load_dataset("ppak10/Inova-Mk1-ASTM", "D790", split="train")
+```
+
+## Composite stress–strain
+
+Every specimen overlaid on one plot per standard. Colors are batch labels (A/B/C/D/E); dashed and dotted gray lines in D638 are PLA/PETG filament controls — they print at much higher stress and strain than the SLS PA12 specimens, which is why the SLS curves cluster near the origin.
+
+| D638 (tensile) | D790 (three-point flex) |
+|---|---|
+| ![D638 composite](assets/D638_composite.png) | ![D790 composite](assets/D790_composite.png) |
+
+Regenerate with `uv run scripts/plots/01_composite.py`.
+
+---
+
+## Configs
+
+| Config | Description | Files |
+|---|---|---|
+| `D638` (default) | Tensile specimens (ASTM D638 Type I). 22 SLS + 3 PLA + 3 PETG = 28 rows. | `data/D638/*.jsonl` (one row per file) |
+| `D790` | Three-point flex specimens (ASTM D790 Procedure A). 27 SLS rows (10 of them — Batch E — from a print job not yet in Database, so they carry null FKs). | `data/D790/*.jsonl` (one row per file) |
+
+One JSONL file per specimen — SLS rows are named after their `sample_id` (e.g. `data/D638/A1.jsonl`, `data/D790/E10.jsonl`); PLA/PETG controls use `{material}_TSR{n}.jsonl` (e.g. `data/D638/PLA_TSR6.jsonl`). Both configs share the same row schema and are produced by the per-session scripts under `scripts/specimens/`.
+
+Specimens are labeled with a `sample_id` of the form `{batch_letter}{seq}` (e.g. `A1`, `C7`), where the batch letter identifies the print batch they came from. The same `sample_id` may appear in both configs — `C1` in `D638` and `C1` in `D790` are **different physical specimens** that came from the same Batch C print.
+
+## Source Layout
+
+```
+source/
+  2026_05_26/          # one folder per test session
+    *.tsproj           # TestWorks project pointer
+    *.xlsx             # TestWorks Excel export, one sheet per specimen
+    TST1.Test/
+      TestRuns/
+        TSR{n}.TestRun/
+          Data/DaqTaskActivity1.h5            # raw DAQ scans (10 Hz)
+          AnalysisRuns/ANR1.AnalysisRun/
+            persistent.h5                     # analyzed scalars + curves
+```
+
+Test sessions covered:
+
+| Session folder | Specimens | Standard | Batch | Source print job (Database) |
+|---|---:|---|---|---|
+| `2026_05_26/` | 5 | D638 | A | 2026-05-25 (d638_type1) |
+| `2026_06_01/` | 5 | D638 | B | 2026-05-30 (d638_type1_engraved) |
+| `2026_06_03/` | 7 | D638 | C | 2026-06-02 (d638_type1_engraved) |
+| `2026_06_10/Tensile Testing/` | 5 SLS + 3 PLA + 3 PETG | D638 | D (SLS only) | SLS: 2026-06-07 (d638_type1_engraved) |
+| `2026_06_10/Batch C 3pt test/` | 9 | D790 | C | 2026-06-02 (d790_flex_specimen) |
+| `2026_06_10/Batch D 3pt test/` | 8 | D790 | D | 2026-06-07 (d790_flex_specimen) |
+| `2026_06_10/Batch E 3pt test/` | 10 | D790 | E | print job **not yet in Database** — FKs null until backfilled |
+
+TSR11 in `Batch E 3pt test/` exists on disk but has empty `Data/` (aborted run, no DAQ scans) and no corresponding xlsx sheet — it is excluded from the JSONL.
+
+## Row shape
+
+```json
+{
+  "sample_id": "A1",
+  "batch_label": "A",
+  "specimen_id": "2026_05_26/TSR1",
+  "test_date": "2026-05-26",
+  "session_folder": "2026_05_26",
+  "test_run_name": "TSR1",
+  "specimen_index": 1,
+
+  "material_class": "SLS",
+  "astm": { "standard": "D638", "type": "Type I", "year": "2022" },
+  "test_end_reason": "Break Detected",
+
+  "geometry": {
+    "width_mm": 12.9, "thickness_mm": 3.2,
+    "area_mm2": 41.28, "gauge_length_mm": 103.0
+  },
+
+  "job_id":           "ba17a5ba-a5f6-4d60-8832-b6c13a2dfa67",
+  "print_date":       "2026-05-25",
+  "print_profile_id": "52715389-d580-4be9-9194-ed300bdf911b",
+  "object_hash":      "E4251951376A82B4303394F832996A2E9883EAB0",
+  "session_id":       null,
+
+  "print_profile_snapshot": { "...full PrintProfile JSON..." },
+
+  "metrics": {
+    "modulus_pa": 341090566.27,
+    "peak_load_n": null, "peak_stress_pa": null,
+    "strain_at_break": null, "stress_at_break_pa": null,
+    "energy_to_break_j": null, "yield_stress_pa": null,
+    "slope_n_per_m": 136701.15
+  },
+
+  "curves": {
+    "time_s":      [/* N */],
+    "extension_m": [/* N */],
+    "load_n":      [/* N */],
+    "strain":      [/* N */],
+    "stress_pa":   [/* N */]
+  },
+
+  "source_paths": {
+    "persistent_h5": "source/2026_05_26/TST1.Test/TestRuns/TSR1.TestRun/AnalysisRuns/ANR1.AnalysisRun/persistent.h5",
+    "daq_h5":        "source/2026_05_26/TST1.Test/TestRuns/TSR1.TestRun/Data/DaqTaskActivity1.h5",
+    "xlsx":          "source/2026_05_26/tensile_testing_5.26.xlsx",
+    "xlsx_sheet":    "Sheet1"
+  }
+}
+```
+
+## Notes on results
+
+- `sample_id` is null for PLA/PETG control rows (they didn't come from an SLS print batch). Filter on `material_class == "SLS"` to get the rows that link back to Database.
+- `batch_label == "E"` rows currently have `job_id`, `print_profile_id`, `object_hash`, and `print_profile_snapshot` all null — the source print job for Batch E is not yet in Database. The mechanical results are still valid.
+- `metrics.peak_*` and `metrics.*_at_break` are often `null` in the D638 tensile rows because TestWorks did not detect a peak/break point on those runs. D790 flex rows have these fields more consistently populated. The `curves.stress_pa` / `curves.strain` arrays are populated regardless, so consumers can re-derive peak/break with their own criteria.
+- `metrics.modulus_pa` matches the kN/mm² value in the TestWorks xlsx after unit conversion (e.g. tensile 0.341 kN/mm² → 3.41 × 10⁸ Pa). For D790, TestWorks computes the flexural modulus via the 3-point-bend formula directly; values may look unintuitive compared to the tensile modulus.
+- DAQ scans are in SI units (m, N, s); stress is Pa and strain is dimensionless.
+- For D790, `geometry.gauge_length_mm` is always null (gauge length is a tensile concept; flex uses support span which is not surfaced).