This deposit supports an article published in Nature Communications:

Ball, J.A.D., Collins, D.M., Tang, Y.T. et al. Revealing 3D strain and carbide architectures in additively manufactured Ni superalloys. Nat Commun (2026). https://doi.org/10.1038/s41467-026-77198-5

This deposit contains the following:

• Code (Jupyter notebooks) required to merge individual Scanning 3D X-Ray Diffraction (S3DXRD) layers into a complete volume
• The final merged S3DXRD data volume
• Code (Jupyter notebooks and MATLAB [MTEX]) required to perform complete-volume analysis of S3DXRD data
• Associated orientation analysis data generated by the above
• Code (Jupyter notebooks) required to generate the figures for the article.

This deposit does not contain (due to file size limits on Zenodo):

• Raw S3DXRD data
• Processed S3DXRD data, individual layers

Those data can be found in the associated DOIs. The raw experimental data have "is supplement to" relations, and the processed S3DXRD individual layer data have the "continues" relation.

The contents of README.md, available in the root of the extracted .tar.gz file, are provided below:

Post-Processing Code: Revealing 3D Strain and Carbide Architectures in Additively Manufactured Ni Superalloys

This post-processing code supports the above-titled manuscript submitted to *Nature Communications*.

Note

This code is not intended to be immediately deployed as a tool to analyse other datasets.  
This code is a modification of a standard Scanning 3DXRD data analysis pipeline available in ImageD11 - the modifications employed are specific to the way these data were acquired and may not be generally transferable.

This repository serves as a transparent record of the end-to-end data reduction steps employed to perform the analysis used in the manuscript.  
It is hoped that aspects of this code will prove useful to others working with Scanning 3DXRD datasets.

Contents

In this repository you can find:

• environment.yml - Conda environment used to run the code
  Jupyter Notebooks and MATLAB scripts required to perform the multi-layer data reduction:

• 1. 01_merge_Ni_layers.ipynb
  2. 02_mean_Ni_orientations.m
  3. 03_carbide_misorientation.ipynb
  4. 04_carbide_misorientation.m

• The output of that data reduction:
• .h5/.xdmf files containing the full reduced volume
  .csv files containing the orientation data
  figures/ - Jupyter Notebooks required to generate the figures in the main manuscript, and the figures themselves
  figures/supplementary - Jupyter Notebooks required to generate the figures in the Supplementary Content, and the figures themselves
  pars_S3DXRD - calibrated detector geometry for the experiment

Prerequisites

Raw Data

You can find the corresponding raw data deposited under the listed DOIs:
https://doi.org/10.15151/ESRF-ES-409840930  
https://doi.org/10.15151/ESRF-ES-447646593  
https://doi.org/10.15151/ESRF-ES-473825696

Per-layer reduced data and code

You can find the per-layer reduced data and associated Jupyter notebooks to perform the reduction itself here:
https://doi.esrf.fr/10.15151/ESRF-DC-2345154341

System requirements

Software dependencies and operating systems

All Python-based data processing, mostly via Jupyter Notebooks, use the ESRF standard Conda environment. You can find an `environment.yml` file that describes the full list of packages and associated version numbers. This software has only been tested on those versions.
MATLAB-based data processing took place on MATLAB R2024b Update 6 (24.2.0.2923080) with MTEX 6.1.0

All data analysis was performed on either:

• The ESRF computing cluster (for segmentation of raw detector frames). This is a mixed Intel/AMD cluster, all x86_64. Segmentation can be run locally on one machine, but will take significantly longer. No GPU required.
• A standalone ESRF machine:
  • OS: Ubuntu 24.04.3 LTS
  • Kernel: 6.8.0-87-generic
  • CPU: AMD Epyc 9454 48-core
  • RAM: 768 GB
  • GPU: NVIDIA L40S 45 GB VRAM

Any required non-standard hardware

A GPU is used to accelerate the tomographic reconstructions using the `Nabu` package. This is not essential.

Installation guide

Instructions

To perform a complete end-to-end data reduction for reproducibility purposes, I recommend you follow the below procedure:

1. Download the raw data (12+ TB total)
   Download the per-layer reduced data and code (PROCESSED_DATA) (100+ GB total)
   Make the following folder structure:

RAW_DATA/
    MA4752_S4_2_XRD/
        MA4752_S4_2_XRD_DTL1z_5/
        MA4752_S4_2_XRD_DTL1z10/
        ...
        MA4752_S4_2_XRD_DTL1z90/
PROCESSED_DATA/
    MA4752_S4_2_XRD/
        MA4752_S4_2_XRD_DTL1z_5/
            0_segment_and_label.ipynb
            1_phase_identification.ipynb
            ...
        MA4752_S4_2_XRD_DTL1z10/
        ...
        MA4752_S4_2_XRD_DTL1z90/
    pars_S3DXRD/
        detector_files/
            ...
        geometry.par
SCRIPTS/
    paper/
        <these files>

You may need to update some absolute file paths in the notebooks to your filesystem, but most paths should be relative and therefore portable.

Typical install time on a "normal" desktop computer

I expect an automated Conda installation to take less than 30 minutes on a "normal" desktop computer, but beware - the data volumes here are large (700+ GB per layer), and a typical desktop machine may not be able to manipulate them adequately.

Demo

Instructions to run on data

As mentioned above, the total size of the raw data is around 12 TB. The processed data are over 100 GB in total.
Nevertheless, a demo can be performed by independently downloading and running the per-layer data+notebooks for a single layer, starting at 2_index_Ni_simple.ipynb.  
These can be found after downloading the "Per-layer reduced data and code" linked above, then in `PROCESSED_DATA/MA4752_S4_2_XRD/MA4752_S4_2_XRD_DTL1z10/`, using layer z10 for example.  
Each layer is around 5 GB in size.  
By skipping the segmentation step, which by default uses the ESRF cluster, a significant section of computation is avoided which dramatically increases portability, and the **raw data need not be downloaded**.

Expected output

As these repositories serve as a reproduction record, the output files of each data reduction step are included. The expected output should match those files.

Expected run time for demo on a "normal" desktop computer

For a single layer, notebook execution time took ~40 minutes on the PC hardware described above, excluding the segmentation step (~5 minutes on the ESRF SLURM cluster).

Instructions for use

Instructions to run on data

A more detailed description of the code's functionality can be found in the Supplementary Content.  
Begin with the per-layer notebooks in PROCESSED_DATA/MA4752_S4_2_XRD/MA4752_S4_2_XRD_DTL1z_5, run them through in order.  
This will use the papermill Python package to automate analysis through all acquired layers.  
The segmentation stages as-written are hard-coded for the ESRF SLURM cluster and will require modification for external systems.  
As all output files are included, the segmentation step can optionally be skipped as the ..._sparse.h5 files can be used instead.  
Once all layers have been fully analysed, you can move on to the whole-sample notebooks in SCRIPTS/paper/, again in order.  
Finally, the notebooks in figures/ can be used to generate the figures for the paper.

Expected output

Final outputs of the merging notebooks in this repository should be the .h5, .xdmf, .csv files mentioned above and included here.