Initial commit

.gitattributes

@@ -58,3 +58,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+*.tif filter=lfs diff=lfs merge=lfs -text
+*.emd filter=lfs diff=lfs merge=lfs -text

CITATION.cff

@@ -0,0 +1,38 @@
+cff-version: 1.2.0
+message: "Please cite this dataset and the associated publication."
+title: "PFNC GST HAADF-STEM/EDS Tomography — Lamella b2_d3"
+type: dataset
+authors:
+  - family-names: "Picone"
+    given-names: "Daniele"
+    email: "daniele.picone@cea.fr"
+  - family-names: "Del Pozo Bueno"
+    given-names: "Daniel"
+    email: "daniel.delpozobueno@cea.fr"
+  - family-names: "Truong"
+    given-names: "Minh Thang"
+  - family-names: "Saghi"
+    given-names: "Zineb"
+    email: "zineb.saghi@cea.fr"
+version: "1.0.0"
+date-released: "TO FILL"
+repository-code: "TO FILL"
+license: "CC-BY-NC-ND-4.0"
+references:
+  - type: article
+    title: "Unsupervised Deep Learning for Limited-Angle STEM-EDX Tomography -- Application to 3D Chemical Analysis of Phase-Change Memory Devices"
+    authors:
+      - family-names: "del Pozo Bueno"
+        given-names: "Daniel"
+      - family-names: "Brosset"
+        given-names: "Serge"
+      - family-names: "Monniez"
+        given-names: "Theo"
+      - family-names: "Navarro"
+        given-names: "Gabriele"
+      - family-names: "Ciuciu"
+        given-names: "Philippe"
+      - family-names: "Saghi"
+        given-names: "Zineb"
+    year: 2026
+    doi: "10.48550/arXiv.2606.10547"

README.md

@@ -1,3 +1,364 @@
 ---
+pretty_name: "PFNC GST HAADF-STEM/EDS Tomography — b2_d3"
 license: cc-by-nc-nd-4.0
+tags:
+- electron-microscopy
+- electron-tomography
+- stem
+- haadf
+- eds
+- edx
+- spectrum-imaging
+- materials-science
+- semiconductor
+- phase-change-memory
+- gst
+- limited-angle-tomography
+size_categories:
+- n<1K
 ---
+
+# PFNC GST HAADF-STEM/EDS Tomography — Lamella `b2_d3`
+
+## Dataset summary
+
+This dataset contains a limited-angle, multi-frame HAADF-STEM and EDS electron-tomography acquisition of a cross-sectional Ge-Sb-Te phase-change-memory lamella.
+
+The data were acquired on a **Thermo Fisher Scientific Titan Themis** at the **Platform for Nanocharacterisation (PFNC), CEA Grenoble**, operated at **200 kV** and equipped with a four-detector **Super-X EDS** system.
+
+The original lamella identifier is:
+
+```text
+b2_d3
+```
+
+The mapping of this lamella to the virgin or SET device described in the associated publication remains to be confirmed.
+
+The dataset preserves:
+
+- 16 original Velox EMD acquisition containers;
+- 50 HAADF frames at each retained tilt;
+- a 50-frame EDS spectrum stream at each retained tilt;
+- integrated spectra and embedded elemental net-intensity maps;
+- extracted HAADF and elemental tilt-series stacks;
+- an aligned HAADF tilt series;
+- per-projection pixel shifts referenced to the 0° acquisition;
+- an explicit tilt-angle list.
+
+## Dataset name
+
+Recommended public title:
+
+```text
+PFNC GST HAADF-STEM/EDS Tomography — Lamella b2_d3
+```
+
+Recommended Hugging Face repository slug:
+
+```text
+pfnc-gst-haadf-stem-eds-tomography-b2-d3
+```
+
+This name identifies the facility context, material system, acquisition modalities, tomography task, and original lamella identifier without making an unverified claim about the device state.
+
+## Provenance and credits
+
+| Role | Person |
+|---|---|
+| Original acquisition operator | Le-Duc Minh Tran — `le-ducminh.tran@cea.fr` |
+| Dataset curator | Daniele Picone — `daniele.picone@cea.fr` |
+| Scientific contact | Daniel Del Pozo Bueno — `daniel.delpozobueno@cea.fr` |
+| PFNC contact | Zineb Saghi — `zineb.saghi@cea.fr` |
+| Dataset organization | CEA-Leti, Grenoble |
+| Acquisition facility | PFNC, CEA Grenoble |
+
+## Instrument and acquisition
+
+| Field | Value |
+|---|---|
+| Facility | Platform for Nanocharacterisation (PFNC), CEA Grenoble |
+| Microscope | Thermo Fisher Scientific Titan Themis |
+| Exact commercial generation/submodel | Not documented |
+| Operating voltage | 200 kV |
+| Corrector | Probe corrector |
+| EDS system | Super-X, four silicon-drift detectors |
+| Embedded detector identifier | `SuperXG1` |
+| Acquisition software | Velox |
+| Embedded Velox version | `3.17.0.967-b5399cab` |
+| EMD format | Velox EMD version 11 |
+| Acquisition date | 2025-07-07 |
+| Beam current | 115 pA |
+| Camera length | 110 mm |
+| Pixel size | 10.67 Å/pixel |
+| Frame size | 400 × 300 pixels |
+| Dwell time | 40 µs |
+| Frames per retained tilt | 50 |
+| Time per frame | 5.57 s |
+| Cumulative acquisition time per tilt | 278.5 s |
+| Fluence per frame | 2.52 × 10² e⁻ Å⁻² |
+| Fluence per tilt | 1.26 × 10⁴ e⁻ Å⁻² |
+| Approximate total fluence | 2.0 × 10⁵ e⁻ Å⁻² |
+
+## Sample
+
+| Field | Value |
+|---|---|
+| Lamella identifier | `b2_d3` |
+| Filename identifier | `D3` |
+| Material system | Ge-Sb-Te phase-change-memory device |
+| Specimen form | Cross-sectional FIB lamella |
+| Operational state | Unknown: virgin or SET |
+| Approximate GST-region thickness | 50 nm, as reported for the associated study |
+| Holder | Fischione single-axis tomography holder |
+| Tilt-axis relation | Parallel to the GST layer |
+| Wafer, die, and device lineage | Not available |
+
+## Tilt series
+
+The intended acquisition contained 17 views from −40° to +40° at nominal 5° increments. One corrupted acquisition was discarded.
+
+The 16 retained angles are:
+
+```text
+-40, -35, -30, -25, -20, -15, -10, -5,
+  0, +10, +15, +20, +25, +30, +35, +40 degrees
+```
+
+The discarded acquisition is number `0010`, corresponding to nominal `+5°`.
+
+Do not synthesize, duplicate, or interpolate the missing `+5°` projection in the archived data.
+
+Public tilt-series arrays use:
+
+```text
+(A, V, U) = (16, 400, 300)
+```
+
+where `A` is tilt index, `V` is image row, and `U` is image column. `metadata/angles_deg.txt` is the authoritative angle coordinate.
+
+## Raw EMD acquisitions
+
+The current raw filenames use the normalized convention:
+
+```text
+D3_EDS-HAADF_0001_-40.emd
+...
+D3_EDS-HAADF_0017_+40.emd
+```
+
+The filename-to-angle mapping is recorded in `metadata/acquisition_manifest.csv`.
+
+Each retained EMD contains:
+
+### HAADF-STEM frame series
+
+```text
+shape: (400, 300, 50)
+dtype: uint16
+frames: 50
+```
+
+### EDS spectrum stream
+
+```text
+spectral bins: 4096
+frames: 50
+stream dtype: uint16
+detector identifier: SuperXG1
+```
+
+An integrated spectrum of shape `(4096, 1)` and dtype `uint32` is also present.
+
+### Embedded elemental maps
+
+Velox-rendered float32 net-intensity maps are present for:
+
+```text
+N, O, Si, Ti, Ge, Sb, Te
+```
+
+The embedded map-processing settings include a 3 × 3 mean filter. These maps are processed analytical products, not raw event data or calibrated concentrations.
+
+## Derived files
+
+| File | Shape | Dtype | Interpretation |
+|---|---:|---|---|
+| `HAADF_stack.tif` | `(16, 400, 300)` | `uint16` | One extracted HAADF projection per retained tilt |
+| `HAADF_aligned.tiff` | `(16, 400, 300)` | `float32` | HAADF tilt series aligned to the 0° acquisition |
+| `Ge_stack.tif` | `(16, 400, 300)` | `float32` | Ge net-intensity tilt series |
+| `Sb_stack.tif` | `(16, 400, 300)` | `float32` | Sb net-intensity tilt series |
+| `Te_stack.tif` | `(16, 400, 300)` | `float32` | Te net-intensity tilt series |
+| `Ti_stack.tif` | `(16, 400, 300)` | `float32` | Ti net-intensity tilt series |
+| `Si_stack.tif` | `(16, 400, 300)` | `float32` | Si net-intensity tilt series |
+| `ali_haadf.json` | 16 integer pairs | — | Pixel translations used to align each HAADF projection to the 0° acquisition |
+
+The element-specific TIFF values are net intensities, not atomic concentrations.
+
+## HAADF alignment file
+
+`ali_haadf.json` contains one pair of integer pixel shifts for each projection, in stack order. Each pair specifies the translation used to align that acquisition to the 0° HAADF projection.
+
+Conceptually:
+
+```json
+[
+  [9, 2],
+  ...
+  [0, 0],
+  ...
+]
+```
+
+The `[0, 0]` entry corresponds to the 0° reference projection.
+
+The following low-level convention remains undocumented:
+
+- whether each pair is ordered as `[x, y]`, `[column, row]`, or `[row, column]`;
+- whether values encode the applied shift or the measured displacement;
+- interpolation and boundary handling used to produce `HAADF_aligned.tiff`.
+
+The shift units are pixels.
+
+## Elemental lines and later preprocessing
+
+The associated publication reports net-count extraction using:
+
+| Element | Emission line |
+|---|---|
+| Ge | Kα |
+| Te | Lα |
+| Sb | Lα |
+| Ti | Kα |
+
+The publication workflow reports:
+
+1. translation-only alignment with Fiji MultiStackReg;
+2. transform estimation from Ge maps;
+3. application of the same transformations to Te, Sb, and Ti;
+4. later crop/resampling to `176 × 112`;
+5. binning factor 2;
+6. independent maximum normalization per element before reconstruction.
+
+The distributed `(16, 400, 300)` TIFF stacks correspond to an earlier stage than the final reconstruction inputs.
+
+`ali_haadf.json` describes HAADF-to-0° alignment and should not automatically be equated with the separate Ge-derived elemental-map transformations.
+
+## Repository organization
+
+```text
+.
+├── README.md
+├── LICENSE
+├── CITATION.cff
+│
+├── metadata/
+│   ├── dataset.yaml
+│   ├── acquisition_manifest.csv
+│   ├── angles_deg.txt
+│   ├── processing.yaml
+│   ├── checksums.sha256
+│   └── audit/
+│
+├── raw/
+│   └── emd/
+│       ├── D3_EDS-HAADF_0001_-40.emd
+│       ├── ...
+│       └── D3_EDS-HAADF_0017_+40.emd
+│
+├── derived/
+│   ├── haadf/
+│   │   ├── HAADF_stack.tif
+│   │   ├── HAADF_aligned.tiff
+│   │   └── alignment/
+│   │       └── ali_haadf.json
+│   └── eds/
+│       └── elemental_tilt_series/
+│           ├── Ge_stack.tif
+│           ├── Sb_stack.tif
+│           ├── Te_stack.tif
+│           ├── Ti_stack.tif
+│           └── Si_stack.tif
+│
+├── previews/
+└── scripts/
+    └── audit_themis_dataset.py
+```
+
+## Loading the derived data
+
+```python
+from pathlib import Path
+
+import json
+import numpy as np
+import tifffile
+
+root = Path(".")
+
+haadf = tifffile.imread(root / "derived/haadf/HAADF_aligned.tiff")
+angles = np.loadtxt(root / "metadata/angles_deg.txt", dtype=np.float64)
+
+with (root / "derived/haadf/alignment/ali_haadf.json").open() as handle:
+    haadf_pixel_shifts = np.asarray(json.load(handle), dtype=np.int64)
+
+assert haadf.shape == (16, 400, 300)
+assert angles.shape == (16,)
+assert haadf_pixel_shifts.shape == (16, 2)
+```
+
+## Intended uses
+
+Potential uses include:
+
+- limited-angle HAADF-STEM tomography;
+- STEM-EDS chemical tomography;
+- multichannel reconstruction;
+- raw spectrum-stream reprocessing;
+- frame-aware denoising and registration;
+- irregular-angle reconstruction;
+- joint HAADF/EDS methods;
+- semiconductor-device characterization.
+
+The dataset does not contain an independently validated ground-truth reconstruction.
+
+## Known limitations
+
+- The meaning of the internal lamella code `b2_d3` is undocumented.
+- It remains unknown whether `b2_d3` is the virgin or SET device.
+- The exact Titan Themis generation/submodel is undocumented.
+- Wafer, die, and device lineage are unavailable.
+- The exact 50-frame HAADF combination method is undocumented.
+- The component order and sign convention in `ali_haadf.json` remain undocumented.
+- N and O maps are retained inside the EMD files but not exported as public TIFF stacks.
+- Net-intensity maps are not quantitative concentration maps.
+- No independently validated 3D ground truth is included.
+
+## Associated publication
+
+This dataset is the experimental dataset associated with:
+
+> Daniel del Pozo Bueno, Serge Brosset, Theo Monniez, Gabriele Navarro, Philippe Ciuciu, and Zineb Saghi.  
+> **Unsupervised Deep Learning for Limited-Angle STEM-EDX Tomography — Application to 3D Chemical Analysis of Phase-Change Memory Devices.**  
+> arXiv:2606.10547, 2026. DOI: `10.48550/arXiv.2606.10547`.
+
+## License
+
+This dataset is released under the **Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International** license:
+
+```text
+CC BY-NC-ND 4.0
+```
+
+You may share the unmodified dataset with attribution for non-commercial purposes. Distribution of adapted or modified versions is not permitted under this license. Consult the license text for the authoritative legal terms.
+
+## Citation
+
+Use the dataset citation in `CITATION.cff` and cite the associated publication when using these data in scientific work.
+
+## Contacts
+
+- **Dataset curator:** Daniele Picone — `daniele.picone@cea.fr`
+- **Scientific contact:** Daniel Del Pozo Bueno — `daniel.delpozobueno@cea.fr`
+- **PFNC contact:** Zineb Saghi — `zineb.saghi@cea.fr`
+- **Original acquisition:** Le-Duc Minh Tran - `le-ducminh.tran@cea.fr`
+- **Organization:** CEA-Leti, Grenoble

derived/haadf/alignment/ali_haadf.json

@@ -0,0 +1,66 @@
+[
+    [
+        9,
+        2
+    ],
+    [
+        -7,
+        5
+    ],
+    [
+        -2,
+        -1
+    ],
+    [
+        2,
+        7
+    ],
+    [
+        -14,
+        4
+    ],
+    [
+        -6,
+        -7
+    ],
+    [
+        -1,
+        -14
+    ],
+    [
+        3,
+        -1
+    ],
+    [
+        0,
+        0
+    ],
+    [
+        -20,
+        -3
+    ],
+    [
+        -16,
+        6
+    ],
+    [
+        -23,
+        9
+    ],
+    [
+        8,
+        -15
+    ],
+    [
+        -4,
+        -11
+    ],
+    [
+        1,
+        6
+    ],
+    [
+        0,
+        13
+    ]
+]

metadata/acquisition_manifest.csv

@@ -0,0 +1,17 @@
+stack_index,acquisition_number,nominal_tilt_deg,emd_file,haadf_present,eds_present,included_in_derived_stacks,status,notes
+0,1,-40,raw/emd/D3_EDS-HAADF_0001_-40.emd,yes,yes,yes,retained,Retained projection. EMD contains 50 HAADF frames and a 50-frame EDS spectrum stream. Filename normalized to remove spaces.
+1,2,-35,raw/emd/D3_EDS-HAADF_0002_-35.emd,yes,yes,yes,retained,Retained projection. EMD contains 50 HAADF frames and a 50-frame EDS spectrum stream. Filename normalized to remove spaces.
+2,3,-30,raw/emd/D3_EDS-HAADF_0003_-30.emd,yes,yes,yes,retained,Retained projection. EMD contains 50 HAADF frames and a 50-frame EDS spectrum stream. Filename normalized to remove spaces.
+3,4,-25,raw/emd/D3_EDS-HAADF_0004_-25.emd,yes,yes,yes,retained,Retained projection. EMD contains 50 HAADF frames and a 50-frame EDS spectrum stream. Filename normalized to remove spaces.
+4,5,-20,raw/emd/D3_EDS-HAADF_0005_-20.emd,yes,yes,yes,retained,Retained projection. EMD contains 50 HAADF frames and a 50-frame EDS spectrum stream. Filename normalized to remove spaces.
+5,6,-15,raw/emd/D3_EDS-HAADF_0006_-15.emd,yes,yes,yes,retained,Retained projection. EMD contains 50 HAADF frames and a 50-frame EDS spectrum stream. Filename normalized to remove spaces.
+6,7,-10,raw/emd/D3_EDS-HAADF_0007_-10.emd,yes,yes,yes,retained,Retained projection. EMD contains 50 HAADF frames and a 50-frame EDS spectrum stream. Filename normalized to remove spaces.
+7,8,-5,raw/emd/D3_EDS-HAADF_0008_-5.emd,yes,yes,yes,retained,Retained projection. EMD contains 50 HAADF frames and a 50-frame EDS spectrum stream. Filename normalized to remove spaces.
+8,9,0,raw/emd/D3_EDS-HAADF_0009_00.emd,yes,yes,yes,retained,Retained projection. EMD contains 50 HAADF frames and a 50-frame EDS spectrum stream. Filename normalized to remove spaces.
+9,11,10,raw/emd/D3_EDS-HAADF_0011_+10.emd,yes,yes,yes,retained,Retained projection. EMD contains 50 HAADF frames and a 50-frame EDS spectrum stream. Filename normalized to remove spaces.
+10,12,15,raw/emd/D3_EDS-HAADF_0012_+15.emd,yes,yes,yes,retained,Retained projection. EMD contains 50 HAADF frames and a 50-frame EDS spectrum stream. Filename normalized to remove spaces.
+11,13,20,raw/emd/D3_EDS-HAADF_0013_+20.emd,yes,yes,yes,retained,Retained projection. EMD contains 50 HAADF frames and a 50-frame EDS spectrum stream. Filename normalized to remove spaces.
+12,14,25,raw/emd/D3_EDS-HAADF_0014_+25.emd,yes,yes,yes,retained,Retained projection. EMD contains 50 HAADF frames and a 50-frame EDS spectrum stream. Filename normalized to remove spaces.
+13,15,30,raw/emd/D3_EDS-HAADF_0015_+30.emd,yes,yes,yes,retained,Retained projection. EMD contains 50 HAADF frames and a 50-frame EDS spectrum stream. Filename normalized to remove spaces.
+14,16,35,raw/emd/D3_EDS-HAADF_0016_+35.emd,yes,yes,yes,retained,Retained projection. EMD contains 50 HAADF frames and a 50-frame EDS spectrum stream. Filename normalized to remove spaces.
+15,17,40,raw/emd/D3_EDS-HAADF_0017_+40.emd,yes,yes,yes,retained,Retained projection. EMD contains 50 HAADF frames and a 50-frame EDS spectrum stream. Filename normalized to remove spaces.

metadata/angles_deg.txt

@@ -0,0 +1,16 @@
+-40
+-35
+-30
+-25
+-20
+-15
+-10
+-5
+0
+10
+15
+20
+25
+30
+35
+40

metadata/audit/audit_summary.md

@@ -0,0 +1,28 @@
+# Dataset audit summary
+
+- Dataset root: `/home/deck/Documents/code/scitomo/data/raw/D3_Tomography`
+- Total files: 9259
+- EMD files: 16
+- TIFF files: 7
+- JSON files: 19
+- Angle files: 1
+- Parsed filename angles: [-40.0, -35.0, -30.0, -25.0, -20.0, -15.0, -10.0, -5.0, 0.0, 10.0, 15.0, 20.0, 25.0, 30.0, 35.0, 40.0]
+- Inferred common angular step: 5.0
+- Missing angles within filename range: [5.0]
+- Missing acquisition numbers: [10]
+- Parsed angles file values: [-40.0, -35.0, -30.0, -25.0, -20.0, -15.0, -10.0, -5.0, 0.0, 10.0, 15.0, 20.0, 25.0, 30.0, 35.0, 40.0]
+- Angle-file parse error: none
+
+## TIFF series shapes
+
+```json
+{}
+```
+
+## Required manual checks
+
+- Confirm that the manifest order equals the plane order in every TIFF stack.
+- Resolve every mismatch between filename angles and `angles.txt`.
+- Inspect `hyperspy_summary.json` to identify HAADF and EDS signals.
+- Review exported metadata for confidential identifiers before publication.
+- Document alignment and elemental-map extraction.

metadata/audit/emd_hdf5_summary.json

@@ -0,0 +1,3 @@
+{
+  "error": "Install h5py to inspect EMD/HDF5 files."
+}

metadata/audit/hyperspy_summary.json

@@ -0,0 +1,3 @@
+{
+  "error": "Install hyperspy, rosettasciio, and sparse."
+}

metadata/audit/tiff_summary.json

@@ -0,0 +1,3 @@
+{
+  "error": "Install tifffile to inspect TIFF files."
+}

metadata/audit/tilt_manifest.csv

@@ -0,0 +1,17 @@
+stack_index_candidate,acquisition_number,filename_angle_deg,angles_file_value_deg,angle_match,emd_file,status,notes
+0,1,-40.0,-40.0,True,raw/emd/D3_EDS-HAADF_0001_-40.emd,unknown,
+1,2,-35.0,-35.0,True,raw/emd/D3_EDS-HAADF_0002_-35.emd,unknown,
+2,3,-30.0,-30.0,True,raw/emd/D3_EDS-HAADF_0003_-30.emd,unknown,
+3,4,-25.0,-25.0,True,raw/emd/D3_EDS-HAADF_0004_-25.emd,unknown,
+4,5,-20.0,-20.0,True,raw/emd/D3_EDS-HAADF_0005_-20.emd,unknown,
+5,6,-15.0,-15.0,True,raw/emd/D3_EDS-HAADF_0006_-15.emd,unknown,
+6,7,-10.0,-10.0,True,raw/emd/D3_EDS-HAADF_0007_-10.emd,unknown,
+7,8,-5.0,-5.0,True,raw/emd/D3_EDS-HAADF_0008_-5.emd,unknown,
+8,9,0.0,0.0,True,raw/emd/D3_EDS-HAADF_0009_00.emd,unknown,
+9,11,10.0,10.0,True,raw/emd/D3_EDS-HAADF_0011_+10.emd,unknown,
+10,12,15.0,15.0,True,raw/emd/D3_EDS-HAADF_0012_+15.emd,unknown,
+11,13,20.0,20.0,True,raw/emd/D3_EDS-HAADF_0013_+20.emd,unknown,
+12,14,25.0,25.0,True,raw/emd/D3_EDS-HAADF_0014_+25.emd,unknown,
+13,15,30.0,30.0,True,raw/emd/D3_EDS-HAADF_0015_+30.emd,unknown,
+14,16,35.0,35.0,True,raw/emd/D3_EDS-HAADF_0016_+35.emd,unknown,
+15,17,40.0,40.0,True,raw/emd/D3_EDS-HAADF_0017_+40.emd,unknown,

metadata/dataset.yaml

@@ -0,0 +1,101 @@
+dataset:
+  title: "PFNC GST HAADF-STEM/EDS Tomography — Lamella b2_d3"
+  repository_slug_recommended: "pfnc-gst-haadf-stem-eds-tomography-b2-d3"
+  version: "1.0.0-release-candidate"
+  license: "cc-by-nc-nd-4.0"
+  release_authorization:
+    cea: true
+    sample_owner: true
+
+provenance:
+  lamella_identifier: "b2_d3"
+  filename_identifier: "D3"
+  dataset_provider: "Daniel Del Pozo Bueno"
+  original_acquisition_operator:
+    name: "Le-Duc Minh Tran"
+    email: "le-ducminh.tran@cea.fr"
+  curator:
+    name: "Daniele Picone"
+    email: "daniele.picone@cea.fr"
+  scientific_contact:
+    name: "Daniel Del Pozo Bueno"
+    email: "daniel.delpozobueno@cea.fr"
+  pfnc_contact:
+    name: "Zineb Saghi"
+    email: "zineb.saghi@cea.fr"
+  dataset_organization: "CEA-Leti, Grenoble"
+  acquisition_facility: "PFNC, CEA Grenoble"
+  acquisition_institute_context: "CEA-Liten"
+
+instrument:
+  manufacturer: "Thermo Fisher Scientific"
+  model_family: "Titan Themis"
+  exact_generation_or_submodel: "UNKNOWN"
+  operating_voltage_kv: 200
+  probe_corrected: true
+  eds_system:
+    name: "Super-X"
+    detector_type: "silicon drift detector"
+    detector_count: 4
+    embedded_identifier: "SuperXG1"
+  software:
+    name: "Velox"
+    version: "3.17.0.967-b5399cab"
+  emd:
+    format: "Velox EMD"
+    format_version: 11
+
+sample:
+  identifier: "b2_d3"
+  filename_identifier: "D3"
+  system: "Ge-Sb-Te phase-change-memory device"
+  specimen: "cross-sectional FIB lamella"
+  operational_state: "UNKNOWN: virgin or SET"
+  approximate_gst_region_thickness_nm: 50
+  holder: "Fischione single-axis tomography holder"
+  tilt_axis_relation: "parallel to GST layer"
+
+acquisition:
+  date: "2025-07-07"
+  accelerating_voltage_kv: 200
+  beam_current_pa: 115
+  camera_length_mm: 110
+  pixel_size_angstrom: 10.67
+  frame_shape_vu: [400, 300]
+  dwell_time_us: 40
+  frames_per_tilt: 50
+  time_per_frame_s: 5.57
+  cumulative_time_per_tilt_s: 278.5
+  intended_angles_deg: [-40, -35, -30, -25, -20, -15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35, 40]
+  retained_angles_deg: [-40, -35, -30, -25, -20, -15, -10, -5, 0, 10, 15, 20, 25, 30, 35, 40]
+  discarded_angle_deg: 5
+  discarded_acquisition_number: 10
+  discarded_reason: "acquisition corruption"
+
+raw_data:
+  filename_pattern: "D3_EDS-HAADF_<acquisition>_<signed-angle>.emd"
+  haadf:
+    shape_per_tilt: [400, 300, 50]
+    dtype: uint16
+  eds:
+    spectral_bins: 4096
+    frames_per_tilt: 50
+    stream_dtype: uint16
+    integrated_spectrum_dtype: uint32
+    rendered_map_mode: NetIntensity
+    embedded_elements: [N, O, Si, Ti, Ge, Sb, Te]
+
+derived_data:
+  haadf_alignment:
+    reference_angle_deg: 0
+    shift_units: pixels
+    parameter_shape: [16, 2]
+    component_order: UNKNOWN
+    sign_convention: UNKNOWN
+  elemental_stacks: [Ge, Sb, Te, Ti, Si]
+
+associated_study:
+  title: "Unsupervised Deep Learning for Limited-Angle STEM-EDX Tomography -- Application to 3D Chemical Analysis of Phase-Change Memory Devices"
+  arxiv: "2606.10547"
+  doi: "10.48550/arXiv.2606.10547"
+  association_status: "confirmed by dataset provider"

metadata/processing.yaml

@@ -0,0 +1,58 @@
+haadf_projection_export:
+  source: "50-frame HAADF series in each Velox EMD"
+  source_shape_per_tilt: [400, 300, 50]
+  source_dtype: uint16
+  output: derived/haadf/HAADF_stack.tif
+  frame_selection: UNKNOWN
+  rejected_frames: UNKNOWN
+  combination: UNKNOWN
+  drift_correction: UNKNOWN
+  normalization: UNKNOWN
+  crop: UNKNOWN
+  binning: UNKNOWN
+
+haadf_alignment:
+  input: derived/haadf/HAADF_stack.tif
+  output: derived/haadf/HAADF_aligned.tiff
+  parameters: derived/haadf/alignment/ali_haadf.json
+  reference_angle_deg: 0
+  parameter_count: 16
+  parameter_shape: [16, 2]
+  parameter_units: pixels
+  parameter_meaning: "translation used to align each HAADF projection to the 0-degree acquisition"
+  zero_degree_entry: [0, 0]
+  component_order: UNKNOWN
+  sign_convention: UNKNOWN
+  interpolation: UNKNOWN
+  boundary_handling: UNKNOWN
+
+eds_map_extraction:
+  source: "50-frame EDS spectrum stream in each Velox EMD"
+  detector: "Super-X, four SDDs"
+  map_mode: NetIntensity
+  lines:
+    Ge: "Kα"
+    Te: "Lα"
+    Sb: "Lα"
+    Ti: "Kα"
+  embedded_additional_elements: [N, O, Si]
+  rendered_map_filter:
+    enabled: true
+    type: Mean
+    kernel_size: 3
+  spectral_filter:
+    enabled: false
+    type: Gaussian
+  absorption_correction:
+    enabled: false
+
+publication_elemental_alignment:
+  software: Fiji
+  plugin: MultiStackReg
+  transform: translation-only
+  reference_channel_for_transform_estimation: Ge
+  applied_to_channels: [Ge, Te, Sb, Ti]
+  later_output_shape: [176, 112]
+  binning_factor: 2
+  normalization: "independent maximum normalization per channel"
+  note: "The distributed 400x300 TIFFs precede this later reconstruction preprocessing."

raw/emd/D3_EDS-HAADF_0001_-40.emd

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

raw/emd/D3_EDS-HAADF_0002_-35.emd

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

raw/emd/D3_EDS-HAADF_0003_-30.emd

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

raw/emd/D3_EDS-HAADF_0004_-25.emd

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

raw/emd/D3_EDS-HAADF_0005_-20.emd

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

raw/emd/D3_EDS-HAADF_0006_-15.emd

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

raw/emd/D3_EDS-HAADF_0007_-10.emd

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

raw/emd/D3_EDS-HAADF_0008_-5.emd

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

raw/emd/D3_EDS-HAADF_0009_00.emd

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

raw/emd/D3_EDS-HAADF_0011_+10.emd

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

raw/emd/D3_EDS-HAADF_0012_+15.emd

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

raw/emd/D3_EDS-HAADF_0013_+20.emd

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

raw/emd/D3_EDS-HAADF_0014_+25.emd

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

raw/emd/D3_EDS-HAADF_0015_+30.emd

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

raw/emd/D3_EDS-HAADF_0016_+35.emd

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

raw/emd/D3_EDS-HAADF_0017_+40.emd

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

scripts/audit_themis_dataset.py

@@ -0,0 +1,568 @@
+#!/usr/bin/env python3
+"""Audit a NEOARM/EMD tomography directory without modifying source files.
+
+Outputs:
+  _audit/file_inventory.csv
+  _audit/checksums.sha256
+  _audit/tilt_manifest.csv
+  _audit/tiff_summary.json
+  _audit/json_summary.json
+  _audit/emd_hdf5_summary.json
+  _audit/hyperspy_summary.json  (only with --hyperspy-files)
+  _audit/audit_summary.md
+
+The script reads HDF5/EMD structure and TIFF metadata but does not load full
+numeric arrays unless optional HyperSpy inspection is requested.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import hashlib
+import json
+import math
+import re
+import statistics
+import sys
+from collections import Counter
+from pathlib import Path
+from typing import Any, Iterable
+
+ANGLE_RE = re.compile(r"(?P<angle>[+-]?\d+(?:\.\d+)?)\.emd$", re.IGNORECASE)
+ACQ_RE = re.compile(r"(?P<number>\d{4})(?=_[+-]?\d+(?:\.\d+)?\.emd$)", re.IGNORECASE)
+FLOAT_RE = re.compile(r"[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?")
+
+
+def sha256_file(path: Path, chunk_size: int = 8 * 1024 * 1024) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        while chunk := handle.read(chunk_size):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def safe_value(value: Any, max_chars: int = 2000) -> Any:
+    """Convert metadata values to bounded JSON-safe representations."""
+    if value is None or isinstance(value, (bool, int, float, str)):
+        text = value
+    elif isinstance(value, bytes):
+        text = value.decode("utf-8", errors="replace")
+    elif hasattr(value, "tolist"):
+        try:
+            converted = value.tolist()
+            if isinstance(converted, list) and len(converted) > 100:
+                return {
+                    "type": type(value).__name__,
+                    "length": len(converted),
+                    "preview": converted[:10],
+                }
+            return safe_value(converted, max_chars=max_chars)
+        except Exception:
+            text = repr(value)
+    elif isinstance(value, dict):
+        return {
+            str(k): safe_value(v, max_chars=max_chars)
+            for k, v in list(value.items())[:200]
+        }
+    elif isinstance(value, (list, tuple)):
+        if len(value) > 100:
+            return {
+                "length": len(value),
+                "preview": [safe_value(v, max_chars=max_chars) for v in value[:10]],
+            }
+        return [safe_value(v, max_chars=max_chars) for v in value]
+    else:
+        text = repr(value)
+
+    if isinstance(text, str) and len(text) > max_chars:
+        return text[:max_chars] + "...<truncated>"
+    return text
+
+
+def parse_angles_file(path: Path) -> list[float]:
+    text = path.read_text(encoding="utf-8", errors="replace")
+    return [float(token) for token in FLOAT_RE.findall(text)]
+
+
+def emd_records(files: Iterable[Path], root: Path) -> list[dict[str, Any]]:
+    records = []
+    for path in files:
+        angle_match = ANGLE_RE.search(path.name)
+        number_match = ACQ_RE.search(path.name)
+        records.append(
+            {
+                "path": path,
+                "relative_path": path.relative_to(root).as_posix(),
+                "filename": path.name,
+                "acquisition_number": (
+                    int(number_match.group("number")) if number_match else None
+                ),
+                "filename_angle_deg": (
+                    float(angle_match.group("angle")) if angle_match else None
+                ),
+            }
+        )
+    return sorted(
+        records,
+        key=lambda row: (
+            row["acquisition_number"] is None,
+            row["acquisition_number"] or math.inf,
+            row["filename"],
+        ),
+    )
+
+
+def infer_missing(values: list[float]) -> tuple[float | None, list[float]]:
+    unique = sorted(set(values))
+    if len(unique) < 3:
+        return None, []
+
+    positive_diffs = [
+        round(b - a, 12) for a, b in zip(unique, unique[1:]) if b > a
+    ]
+    if not positive_diffs:
+        return None, []
+
+    counts = Counter(positive_diffs)
+    step = counts.most_common(1)[0][0]
+    if step <= 0:
+        return None, []
+
+    missing: list[float] = []
+    value = unique[0]
+    while value <= unique[-1] + step / 2:
+        if not any(abs(value - observed) < 1e-8 for observed in unique):
+            missing.append(round(value, 10))
+        value += step
+    return step, missing
+
+
+def inspect_tiffs(paths: list[Path], root: Path) -> dict[str, Any]:
+    try:
+        import tifffile
+    except ImportError:
+        return {"error": "Install tifffile to inspect TIFF files."}
+
+    output: dict[str, Any] = {}
+    for path in paths:
+        key = path.relative_to(root).as_posix()
+        try:
+            with tifffile.TiffFile(path) as tif:
+                series = []
+                for item in tif.series:
+                    series.append(
+                        {
+                            "shape": list(item.shape),
+                            "dtype": str(item.dtype),
+                            "axes": getattr(item, "axes", None),
+                            "page_count": len(item.pages),
+                        }
+                    )
+                first_page = tif.pages[0] if tif.pages else None
+                tags = {}
+                if first_page is not None:
+                    for tag_name in (
+                        "ImageWidth",
+                        "ImageLength",
+                        "BitsPerSample",
+                        "SampleFormat",
+                        "XResolution",
+                        "YResolution",
+                        "ResolutionUnit",
+                        "ImageDescription",
+                        "Software",
+                        "DateTime",
+                    ):
+                        tag = first_page.tags.get(tag_name)
+                        if tag is not None:
+                            tags[tag_name] = safe_value(tag.value)
+                output[key] = {
+                    "series": series,
+                    "page_count": len(tif.pages),
+                    "is_imagej": bool(tif.is_imagej),
+                    "is_ome": bool(tif.is_ome),
+                    "imagej_metadata": safe_value(tif.imagej_metadata),
+                    "first_page_tags": tags,
+                }
+        except Exception as exc:
+            output[key] = {"error": f"{type(exc).__name__}: {exc}"}
+    return output
+
+
+def inspect_json_files(paths: list[Path], root: Path) -> dict[str, Any]:
+    output: dict[str, Any] = {}
+    for path in paths:
+        key = path.relative_to(root).as_posix()
+        try:
+            data = json.loads(path.read_text(encoding="utf-8", errors="strict"))
+            summary: dict[str, Any] = {"root_type": type(data).__name__}
+            if isinstance(data, dict):
+                summary["keys"] = list(data.keys())[:200]
+                summary["content_preview"] = safe_value(data)
+            elif isinstance(data, list):
+                summary["length"] = len(data)
+                summary["content_preview"] = safe_value(data[:10])
+            else:
+                summary["content_preview"] = safe_value(data)
+            output[key] = summary
+        except Exception as exc:
+            output[key] = {"error": f"{type(exc).__name__}: {exc}"}
+    return output
+
+
+def inspect_hdf5_emd(
+    paths: list[Path],
+    root: Path,
+    max_objects_per_file: int = 5000,
+) -> dict[str, Any]:
+    try:
+        import h5py
+    except ImportError:
+        return {"error": "Install h5py to inspect EMD/HDF5 files."}
+
+    output: dict[str, Any] = {}
+    for path in paths:
+        key = path.relative_to(root).as_posix()
+        objects: list[dict[str, Any]] = []
+        truncated = False
+        try:
+            with h5py.File(path, "r") as handle:
+                root_attrs = {
+                    str(k): safe_value(v) for k, v in handle.attrs.items()
+                }
+
+                def visitor(name: str, obj: Any) -> None:
+                    nonlocal truncated
+                    if len(objects) >= max_objects_per_file:
+                        truncated = True
+                        return
+
+                    record: dict[str, Any] = {
+                        "path": name,
+                        "kind": type(obj).__name__,
+                    }
+                    if hasattr(obj, "shape"):
+                        record["shape"] = list(obj.shape)
+                    if hasattr(obj, "dtype"):
+                        record["dtype"] = str(obj.dtype)
+                    attrs = {
+                        str(k): safe_value(v)
+                        for k, v in list(obj.attrs.items())[:50]
+                    }
+                    if attrs:
+                        record["attributes"] = attrs
+
+                    # Read only small scalar/string datasets, never large arrays.
+                    if (
+                        hasattr(obj, "shape")
+                        and hasattr(obj, "dtype")
+                        and (
+                            obj.shape == ()
+                            or (
+                                getattr(obj.dtype, "kind", "") in {"S", "U", "O"}
+                                and getattr(obj, "size", 0) <= 64
+                            )
+                        )
+                    ):
+                        try:
+                            record["value"] = safe_value(obj[()])
+                        except Exception:
+                            pass
+                    objects.append(record)
+
+                handle.visititems(visitor)
+                output[key] = {
+                    "root_attributes": root_attrs,
+                    "objects": objects,
+                    "truncated": truncated,
+                }
+        except Exception as exc:
+            output[key] = {"error": f"{type(exc).__name__}: {exc}"}
+    return output
+
+
+def metadata_to_dict(node: Any) -> Any:
+    if node is None:
+        return None
+    if hasattr(node, "as_dictionary"):
+        try:
+            return safe_value(node.as_dictionary())
+        except Exception:
+            pass
+    return safe_value(node)
+
+
+def inspect_with_hyperspy(
+    paths: list[Path],
+    root: Path,
+    count: int,
+) -> dict[str, Any]:
+    if count <= 0:
+        return {}
+    try:
+        import hyperspy.api as hs
+    except ImportError:
+        return {"error": "Install hyperspy, rosettasciio, and sparse."}
+
+    output: dict[str, Any] = {}
+    for path in paths[:count]:
+        key = path.relative_to(root).as_posix()
+        try:
+            loaded = hs.load(path, lazy=True)
+            signals = loaded if isinstance(loaded, list) else [loaded]
+            summaries = []
+            for signal in signals:
+                axes = []
+                raw_axes = list(getattr(signal.axes_manager, "_axes", []))
+                if not raw_axes:
+                    raw_axes = list(signal.axes_manager.navigation_axes) + list(
+                        signal.axes_manager.signal_axes
+                    )
+                for axis in raw_axes:
+                    # Some HyperSpy versions expose grouped axes as tuples.
+                    grouped_axes = axis if isinstance(axis, (tuple, list)) else (axis,)
+                    for item in grouped_axes:
+                        axes.append(
+                            {
+                                "name": getattr(item, "name", None),
+                                "size": int(getattr(item, "size", 0)),
+                                "scale": safe_value(getattr(item, "scale", None)),
+                                "offset": safe_value(getattr(item, "offset", None)),
+                                "units": getattr(item, "units", None),
+                                "navigate": bool(getattr(item, "navigate", False)),
+                            }
+                        )
+                summaries.append(
+                    {
+                        "class": type(signal).__name__,
+                        "title": signal.metadata.get_item(
+                            "General.title", default=None
+                        ),
+                        "data_shape": list(signal.data.shape),
+                        "data_dtype": str(signal.data.dtype),
+                        "axes": axes,
+                        "metadata": metadata_to_dict(signal.metadata),
+                        "original_metadata": metadata_to_dict(
+                            signal.original_metadata
+                        ),
+                    }
+                )
+            output[key] = summaries
+        except Exception as exc:
+            output[key] = {"error": f"{type(exc).__name__}: {exc}"}
+    return output
+
+
+def write_json(path: Path, value: Any) -> None:
+    path.write_text(
+        json.dumps(value, indent=2, ensure_ascii=False),
+        encoding="utf-8",
+    )
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("dataset_root", type=Path)
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=None,
+        help="Default: DATASET_ROOT/_audit",
+    )
+    parser.add_argument(
+        "--hyperspy-files",
+        type=int,
+        default=0,
+        help="Inspect this many EMD files with HyperSpy. Start with 1.",
+    )
+    args = parser.parse_args()
+
+    root = args.dataset_root.expanduser().resolve()
+    if not root.is_dir():
+        print(f"Not a directory: {root}", file=sys.stderr)
+        return 2
+
+    output = (
+        args.output.expanduser().resolve()
+        if args.output is not None
+        else root / "_audit"
+    )
+    output.mkdir(parents=True, exist_ok=True)
+
+    files = sorted(
+        path for path in root.rglob("*")
+        if path.is_file() and output not in path.parents
+    )
+    emd_files = [p for p in files if p.suffix.lower() == ".emd"]
+    tiff_files = [
+        p for p in files if p.suffix.lower() in {".tif", ".tiff"}
+    ]
+    json_files = [p for p in files if p.suffix.lower() == ".json"]
+    angle_files = [
+        p for p in files if p.name.lower() in {"angles.txt", "angles_deg.txt"}
+    ]
+
+    inventory_path = output / "file_inventory.csv"
+    checksum_path = output / "checksums.sha256"
+    with inventory_path.open("w", newline="", encoding="utf-8") as csv_handle, \
+            checksum_path.open("w", encoding="utf-8") as checksum_handle:
+        writer = csv.DictWriter(
+            csv_handle,
+            fieldnames=["relative_path", "size_bytes", "suffix", "sha256"],
+        )
+        writer.writeheader()
+        for path in files:
+            digest = sha256_file(path)
+            relative = path.relative_to(root).as_posix()
+            writer.writerow(
+                {
+                    "relative_path": relative,
+                    "size_bytes": path.stat().st_size,
+                    "suffix": path.suffix.lower(),
+                    "sha256": digest,
+                }
+            )
+            checksum_handle.write(f"{digest}  {relative}\n")
+
+    records = emd_records(emd_files, root)
+    angle_values: list[float] = []
+    angle_parse_error: str | None = None
+    if angle_files:
+        try:
+            angle_values = parse_angles_file(angle_files[0])
+        except Exception as exc:
+            angle_parse_error = f"{type(exc).__name__}: {exc}"
+
+    manifest_path = output / "tilt_manifest.csv"
+    with manifest_path.open("w", newline="", encoding="utf-8") as handle:
+        fieldnames = [
+            "stack_index_candidate",
+            "acquisition_number",
+            "filename_angle_deg",
+            "angles_file_value_deg",
+            "angle_match",
+            "emd_file",
+            "status",
+            "notes",
+        ]
+        writer = csv.DictWriter(handle, fieldnames=fieldnames)
+        writer.writeheader()
+        max_count = max(len(records), len(angle_values))
+        for index in range(max_count):
+            record = records[index] if index < len(records) else None
+            text_angle = angle_values[index] if index < len(angle_values) else None
+            filename_angle = (
+                record["filename_angle_deg"] if record is not None else None
+            )
+            match = (
+                filename_angle is not None
+                and text_angle is not None
+                and abs(filename_angle - text_angle) < 1e-8
+            )
+            writer.writerow(
+                {
+                    "stack_index_candidate": index,
+                    "acquisition_number": (
+                        record["acquisition_number"] if record else ""
+                    ),
+                    "filename_angle_deg": (
+                        filename_angle if filename_angle is not None else ""
+                    ),
+                    "angles_file_value_deg": (
+                        text_angle if text_angle is not None else ""
+                    ),
+                    "angle_match": match if (
+                        filename_angle is not None and text_angle is not None
+                    ) else "",
+                    "emd_file": record["relative_path"] if record else "",
+                    "status": "unknown",
+                    "notes": "",
+                }
+            )
+
+    filename_angles = [
+        row["filename_angle_deg"]
+        for row in records
+        if row["filename_angle_deg"] is not None
+    ]
+    step, missing_angles = infer_missing(filename_angles)
+    acquisition_numbers = [
+        row["acquisition_number"]
+        for row in records
+        if row["acquisition_number"] is not None
+    ]
+    missing_numbers: list[int] = []
+    if acquisition_numbers:
+        missing_numbers = sorted(
+            set(range(min(acquisition_numbers), max(acquisition_numbers) + 1))
+            - set(acquisition_numbers)
+        )
+
+    tiff_summary = inspect_tiffs(tiff_files, root)
+    json_summary = inspect_json_files(json_files, root)
+    emd_summary = inspect_hdf5_emd(emd_files, root)
+    hyperspy_summary = inspect_with_hyperspy(
+        emd_files, root, args.hyperspy_files
+    )
+
+    write_json(output / "tiff_summary.json", tiff_summary)
+    write_json(output / "json_summary.json", json_summary)
+    write_json(output / "emd_hdf5_summary.json", emd_summary)
+    if args.hyperspy_files > 0:
+        write_json(output / "hyperspy_summary.json", hyperspy_summary)
+
+    tiff_shapes = {}
+    for key, value in tiff_summary.items():
+        if isinstance(value, dict) and "series" in value:
+            tiff_shapes[key] = [
+                item.get("shape") for item in value.get("series", [])
+            ]
+
+    summary_lines = [
+        "# Dataset audit summary",
+        "",
+        f"- Dataset root: `{root}`",
+        f"- Total files: {len(files)}",
+        f"- EMD files: {len(emd_files)}",
+        f"- TIFF files: {len(tiff_files)}",
+        f"- JSON files: {len(json_files)}",
+        f"- Angle files: {len(angle_files)}",
+        f"- Parsed filename angles: {filename_angles}",
+        f"- Inferred common angular step: {step}",
+        f"- Missing angles within filename range: {missing_angles}",
+        f"- Missing acquisition numbers: {missing_numbers}",
+        f"- Parsed angles file values: {angle_values}",
+        f"- Angle-file parse error: {angle_parse_error or 'none'}",
+        "",
+        "## TIFF series shapes",
+        "",
+        "```json",
+        json.dumps(tiff_shapes, indent=2),
+        "```",
+        "",
+        "## Required manual checks",
+        "",
+        "- Confirm that the manifest order equals the plane order in every TIFF stack.",
+        "- Resolve every mismatch between filename angles and `angles.txt`.",
+        "- Inspect `hyperspy_summary.json` to identify HAADF and EDS signals.",
+        "- Review exported metadata for confidential identifiers before publication.",
+        "- Document alignment and elemental-map extraction.",
+    ]
+    (output / "audit_summary.md").write_text(
+        "\n".join(summary_lines) + "\n",
+        encoding="utf-8",
+    )
+
+    print(f"Audit complete: {output}")
+    print(f"EMD files: {len(emd_files)}")
+    print(f"TIFF files: {len(tiff_files)}")
+    print(f"Missing filename-derived angles: {missing_angles}")
+    print(f"Missing acquisition numbers: {missing_numbers}")
+    if args.hyperspy_files == 0:
+        print("HyperSpy inspection skipped. Use --hyperspy-files 1 to inspect one EMD.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/generate_haadf_preview.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+"""Generate a display PNG from the HAADF projection closest to 0 degrees.
+
+This creates a visualization only. It does not modify the TIFF source data.
+
+Dependencies:
+    python -m pip install numpy tifffile pillow
+
+Example:
+    python scripts/generate_haadf_preview.py .
+"""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+import numpy as np
+import tifffile
+from PIL import Image, PngImagePlugin
+
+
+def find_tilt_axis(shape: tuple[int, ...], n_angles: int) -> int:
+    matches = [axis for axis, size in enumerate(shape) if size == n_angles]
+    if not matches:
+        raise ValueError(
+            f"No TIFF axis has length {n_angles}; TIFF shape is {shape}."
+        )
+    if len(matches) > 1:
+        raise ValueError(
+            f"More than one TIFF axis has length {n_angles}: {matches}. "
+            "Specify a stack with an unambiguous tilt axis."
+        )
+    return matches[0]
+
+
+def normalize_to_uint8(
+    image: np.ndarray,
+    lower_percentile: float,
+    upper_percentile: float,
+    invert: bool,
+) -> np.ndarray:
+    image = np.asarray(image, dtype=np.float32)
+    finite = np.isfinite(image)
+
+    if not finite.any():
+        raise ValueError("The selected projection contains no finite values.")
+
+    values = image[finite]
+    low = float(np.percentile(values, lower_percentile))
+    high = float(np.percentile(values, upper_percentile))
+
+    if not high > low:
+        low = float(values.min())
+        high = float(values.max())
+
+    if not high > low:
+        return np.zeros(image.shape, dtype=np.uint8)
+
+    normalized = np.clip((image - low) / (high - low), 0.0, 1.0)
+    normalized[~finite] = 0.0
+
+    if invert:
+        normalized = 1.0 - normalized
+
+    return np.rint(normalized * 255.0).astype(np.uint8)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Create a PNG preview from the HAADF projection nearest 0°."
+    )
+    parser.add_argument(
+        "dataset_root",
+        type=Path,
+        nargs="?",
+        default=Path("."),
+        help="Dataset root directory. Default: current directory.",
+    )
+    parser.add_argument(
+        "--stack",
+        type=Path,
+        default=Path("derived/haadf/HAADF_aligned.tiff"),
+        help="HAADF TIFF path relative to the dataset root.",
+    )
+    parser.add_argument(
+        "--angles",
+        type=Path,
+        default=Path("metadata/angles_deg.txt"),
+        help="Angle-list path relative to the dataset root.",
+    )
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=Path("previews/haadf_zero_tilt.png"),
+        help="Output PNG path relative to the dataset root.",
+    )
+    parser.add_argument(
+        "--lower-percentile",
+        type=float,
+        default=1.0,
+        help="Lower display percentile. Default: 1.0.",
+    )
+    parser.add_argument(
+        "--upper-percentile",
+        type=float,
+        default=99.8,
+        help="Upper display percentile. Default: 99.8.",
+    )
+    parser.add_argument(
+        "--invert",
+        action="store_true",
+        help="Invert grayscale in the PNG preview.",
+    )
+    parser.add_argument(
+        "--upscale",
+        type=int,
+        default=2,
+        help="Integer nearest-neighbor upscale factor. Default: 2.",
+    )
+    args = parser.parse_args()
+
+    root = args.dataset_root.expanduser().resolve()
+    stack_path = root / args.stack
+    angles_path = root / args.angles
+    output_path = root / args.output
+
+    if not stack_path.is_file():
+        raise FileNotFoundError(f"HAADF stack not found: {stack_path}")
+    if not angles_path.is_file():
+        raise FileNotFoundError(f"Angle list not found: {angles_path}")
+    if not 0.0 <= args.lower_percentile < args.upper_percentile <= 100.0:
+        raise ValueError("Percentiles must satisfy 0 <= lower < upper <= 100.")
+    if args.upscale < 1:
+        raise ValueError("--upscale must be at least 1.")
+
+    angles = np.atleast_1d(np.loadtxt(angles_path, dtype=np.float64))
+    stack = tifffile.imread(stack_path)
+
+    if stack.ndim != 3:
+        raise ValueError(f"Expected a 3D tilt stack, got shape {stack.shape}.")
+
+    tilt_axis = find_tilt_axis(stack.shape, len(angles))
+    stack = np.moveaxis(stack, tilt_axis, 0)
+
+    index = int(np.argmin(np.abs(angles)))
+    angle = float(angles[index])
+    projection = stack[index]
+
+    preview = normalize_to_uint8(
+        projection,
+        lower_percentile=args.lower_percentile,
+        upper_percentile=args.upper_percentile,
+        invert=args.invert,
+    )
+
+    image = Image.fromarray(preview, mode="L")
+    if args.upscale > 1:
+        image = image.resize(
+            (image.width * args.upscale, image.height * args.upscale),
+            resample=Image.Resampling.NEAREST,
+        )
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    metadata = PngImagePlugin.PngInfo()
+    metadata.add_text("Source", args.stack.as_posix())
+    metadata.add_text("Tilt angle (degrees)", f"{angle:g}")
+    metadata.add_text("Stack index", str(index))
+    metadata.add_text(
+        "Display normalization",
+        f"{args.lower_percentile:g}–{args.upper_percentile:g} percentiles",
+    )
+
+    image.save(output_path, pnginfo=metadata)
+
+    print(f"Saved: {output_path}")
+    print(f"Selected stack index: {index}")
+    print(f"Selected angle: {angle:g} degrees")
+    print(f"Original projection shape: {projection.shape}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())