RadField3D: A Data Generator and Data Format for Deep Learning in Radiation-Protection Dosimetry for Medical Applications

This paper introduces RadField3D, an open-source Geant4-based Monte Carlo simulation tool and a compatible machine-interpretable data format with a Python API, designed to generate 3D radiation field datasets for advancing deep learning research in medical radiation-protection dosimetry.

The Gist

Imagine you are a doctor performing a delicate surgery using X-rays (Interventional Radiology). While the patient gets the treatment, the medical staff standing nearby are constantly bathed in a complex, invisible sea of radiation. Some of it comes straight from the machine (the "direct beam"), and some bounces off the patient's body like a ball hitting a wall (the "scatter").

The problem? Current safety tools are like wearing a blindfold. They assume radiation hits everyone evenly, but in reality, it's a chaotic, uneven storm. If a doctor stands in a "hot spot" for just a few seconds, they might get a dangerous dose without knowing it.

To fix this, scientists need a way to predict exactly where the radiation is, in real-time, so they can warn staff or train them in Virtual Reality (VR) without exposing them to actual danger. But the computers used to calculate this are too slow—like trying to predict the weather by simulating every single raindrop individually.

Enter "RadField3D": The Radiation Weather Forecast.

This paper introduces two new tools created by a team of researchers to solve this problem:

1. The Simulator: RadField3D (The "Digital Crystal Ball")

Think of the old way of calculating radiation as trying to count every single grain of sand on a beach by hand. It's accurate but takes forever.

The researchers built a new program called RadField3D. It's a super-smart digital simulator based on a famous physics engine (Geant4). Instead of just guessing, it shoots millions of "virtual photons" (tiny packets of light/radiation) through a 3D model of a hospital room and a patient.

• The Magic Trick: It breaks the 3D space into tiny, invisible cubes (like a 3D Minecraft grid). As the virtual photons fly through, the program counts how many hit each cube and how much energy they carry.
• The Result: It creates a detailed, 3D "heat map" of the radiation field. It knows exactly how much radiation is hitting the doctor's left hand versus their head, even if they are standing behind a lead shield.

2. The Data Format: RadFiled3D (The "Universal Translator")

Even if you have a perfect map, it's useless if you can't read it. Most radiation data is stored in messy, complicated formats that are hard for modern Artificial Intelligence (AI) to understand. It's like trying to teach a robot to drive using a map drawn in invisible ink.

The team created a new file format called RadFiled3D.

• The Analogy: Imagine taking that messy, invisible ink map and turning it into a clean, standardized digital file (like a high-quality JPEG or MP4) that any computer can read instantly.
• Why it matters: This format is designed specifically for AI. It allows researchers to feed this radiation data directly into machine learning models. This means we can eventually train an AI to predict radiation doses in a split second, making real-time safety warnings possible.

Did it Work? (The "Taste Test")

You can't just trust a computer simulation; you have to check it against reality. The researchers set up a real X-ray machine in their lab and placed a "phantom" (a fake human body made of water or a plastic torso) in the beam.

They measured the radiation with real detectors at many different angles and compared it to what their computer simulation predicted.

• The Verdict: The simulation was incredibly accurate. In most areas, the computer's guess was within 10% of the real measurement.
• The Glitch: The only time it was slightly off was at the very sharp edges of the radiation beam (like the edge of a shadow). This is because the real detector is a physical ball, while the computer uses a grid of cubes. It's like trying to measure the exact edge of a shadow with a ruler made of blocks; it's slightly fuzzy. However, for safety purposes, this small error is acceptable because the system is designed to be a "safety net" (better to overestimate the danger than underestimate it).

Why Should You Care?

This isn't just about better math; it's about saving lives and improving training.

1. Real-Time Safety: Eventually, this technology could power a system that tells a surgeon, "Step two feet to the left, the radiation is 50% lower there," instantly.
2. Better Training: VR training for doctors can become hyper-realistic. Instead of just seeing a cartoon, they can see a scientifically accurate simulation of radiation hitting their virtual body, teaching them how to protect themselves without ever getting a single X-ray dose.
3. Open Source: The best part? The team gave away the blueprints. Anyone can download the code and the data format to build better radiation safety tools.

In short: The researchers built a fast, accurate "radiation weather map" generator and a universal language to talk to AI about it. This paves the way for a future where medical staff can work with X-rays safely, knowing exactly where the invisible dangers are hiding.

Technical Summary

1. Problem Statement

Radiation protection in medical settings, particularly Interventional Radiology (IR), faces significant challenges due to non-uniform radiation fields.

• Limitations of Current Dosimetry: Standard personal dosimeters are reliable only for uniform fields. In IR, medical staff are exposed to complex, spatially varying fields caused by proximity to patients and scattered radiation, making individual dose assessment inaccurate.
• Computational Bottlenecks: While Computational Dosimetry systems (tracking staff posture and calculating spatial doses) exist, they rely on Monte-Carlo Simulations (MCS). MCS is highly accurate but computationally expensive, making it too slow for real-time dose calculations or Virtual Reality (VR) training applications.
• Data Scarcity: There is a lack of open-source, validated datasets and standardized data formats required to train Deep Learning (DL) models to accelerate radiation transport simulations. Existing formats (e.g., ROOT, MCNP text, DICOM) are either too complex, inefficient, or too specific to physical hardware to be reusable for simulations.

2. Methodology

The authors developed two primary components: a simulation engine and a data format.

A. RadField3D (Simulation Engine)

• Core Framework: Built on Geant4, a state-of-the-art toolkit for particle transport.
• Physics Configuration: Uses the QGSP_BIC_HP physics list combined with G4EmStandardPhysics Option4 to optimize for medical applications.
• Voxelization & Scoring:
  • Instead of analytical line-cube intersection tests (which are computationally heavy), the system samples points along photon trajectories (within 0.5x the minimal voxel extent) to identify intersected voxels efficiently.
  • It scores three components per voxel: Beam (direct), Patient (scatter inside), and Scatter (scatter outside).
  • Data Recorded: For each voxel, it stores the percentage of photon hits, the probability distribution of photon energies ($p(E_\gamma)$), and the dominant direction of the entrance trajectory.
• Statistical Error Control: Implements Welford's online algorithm to incrementally calculate variance without storing every step. The simulation terminates when the relative statistical error ($\epsilon_{rel}$) of 95% of voxels falls below a threshold.
• Geometry Handling: Supports loading mesh geometries (OBJ, FBX) via the assimp library, paired with JSON description files for material properties and nesting.

B. RadFiled3D (Data Format)

• Structure: A minimalist, fast binary file format designed for machine interpretability.
• Organization:
  • Header: Contains mandatory fixed metadata (following Sechopoulos et al. guidelines) and dynamic metadata.
  • Channels & Layers: Data is organized into channels (e.g., "Beam," "Scatter") containing layers. Each layer holds specific values (scalars or vectors) per voxel with associated units and statistical errors.
• Integration: Includes a Python API (via PyBind11) to allow seamless loading and processing within machine learning workflows.

C. Experimental Validation

• Setup: Two configurations were tested at Physikalisch-Technische Bundesanstalt (PTB) using an X-ray tube (H-100 quality):
  1. Configuration A: A water-filled cylinder (simulating a human head).
  2. Configuration B: A reconstructed 3D mesh of a male Alderson phantom torso (derived from CT scans).
• Measurement: Air Kerma rates ($\dot{K}_{air}$) were measured at various angles and distances using a 30 cm³ spherical ionization chamber.
• Conversion: Simulated relative energy distributions were converted to absolute Air Kerma rates by comparing the integral of the simulated curve against the measured curve to derive a conversion factor ($S_c$).

3. Key Contributions

1. RadField3D Application: An open-source Geant4-based application capable of generating spatially resolved, 3D voxelized radiation fields with specific separation of primary beam and scatter components.
2. RadFiled3D Format: A novel, standardized binary data format with a Python API, designed specifically to bridge the gap between radiation physics simulations and deep learning research.
3. Validated Dataset: The release of a comprehensive dataset (simulation + ground truth measurements) for training and validating acceleration techniques.
4. Efficient Voxelization: A sampling-based voxelization method that maintains analytical accuracy while significantly reducing computational overhead compared to traditional intersection tests.

4. Results

• Geometric Agreement: The simulation demonstrated excellent geometric agreement with measurements, correctly handling occlusion and complex geometries (like the Alderson phantom).
• Error Metrics:
  • Median Relative Error: Generally below 10% across all experiments (e.g., 4.0% for Config A.1, 6.6% for Config B.1).
  • Mean Relative Error: Higher (up to 18.5%) due to steep gradients at "hard edges" (beam boundaries and phantom edges) where the ionization chamber's physical size and voxel discretization cause discrepancies.
• Error Mitigation:
  • Excluding edge angles reduced mean errors significantly (e.g., A.2 mean error dropped from 18.5% to 11.9%).
  • Applying a linear blending of fluence and spectra based on the detector's distance from voxel centers reduced the standard deviation of errors by roughly half.
• Component Analysis: When separating the primary beam from the scatter component, relative error means improved to 1.8% – 5.5%. The simulation slightly overestimates scatter, which is acceptable for radiation protection as it provides a conservative (upper limit) dose estimate.

5. Significance

• Enabling Real-Time Dosimetry: By providing high-quality, validated datasets, this work facilitates the training of Deep Learning models to replace or accelerate slow Monte-Carlo simulations, a prerequisite for real-time VR training and dynamic dose monitoring in IR.
• Reproducibility and Interoperability: The open-source nature of both the code and the data format addresses the "black box" issue in radiation simulation, allowing researchers to compare algorithms and reproduce results easily.
• Standardization: The RadFiled3D format offers a domain-specific solution that overcomes the limitations of general-purpose formats (like ROOT) and medical imaging formats (like DICOM), fostering better collaboration between physicists and AI researchers.
• Safety: The ability to accurately model complex scatter fields helps in developing better protective strategies for medical staff, ultimately reducing occupational radiation exposure.