GPU optical photon Monte Carlo for noble liquid detectors: validation against Geant4 in a large liquid argon TPC benchmark

This paper presents Simphony, a GPU-accelerated optical photon Monte Carlo tool that achieves a ~1000-fold speedup over Geant4 while maintaining subpercent accuracy in photon detection metrics, thereby enabling practical large-scale optical simulations for noble liquid detector development and machine learning applications.

The Gist

Imagine you are trying to predict how a giant, invisible cloud of light behaves inside a massive, frozen tank of liquid argon. This isn't just any light; it's billions of tiny, fast-moving "photons" (particles of light) bouncing off walls, changing colors, and getting absorbed. Scientists need to simulate this to design giant detectors that can catch neutrinos (ghostly particles from space) or study other fundamental physics.

The problem? Simulating this cloud of light on a standard computer is incredibly slow. It's like trying to count every single grain of sand on a beach by hand, one by one. If you need to run this simulation thousands of times to test different detector designs, you'd be waiting for years.

This paper introduces a new tool called Simphony that uses a powerful graphics card (GPU) to do this counting job thousands of times faster. Here is the breakdown of what they did, using simple analogies.

The Problem: The "Hand-Counting" Bottleneck

In the world of particle physics, when a particle hits liquid argon, it creates a flash of light. To understand what happened, scientists use a program called Geant4 to simulate how every single photon travels.

• The Old Way: Imagine a single, very careful librarian (the CPU) trying to track 60 million books (photons) flying through a library. The librarian has to check every book's path, color, and speed one by one. This takes a long time (hours per event).
• The Need: Scientists need to run this simulation over and over to design better detectors. Waiting hours for one result is too slow.

The Solution: The "Super-Worker" GPU

The authors built Simphony, a tool that moves this job from the single librarian to a massive team of workers (the GPU).

• The Analogy: Instead of one librarian, imagine a stadium filled with 10,000 workers. They all grab a handful of books and track them simultaneously.
• The Tech: They used a high-end graphics card (an NVIDIA RTX 4090), which is the kind of chip usually found in gaming computers, but repurposed it to handle physics simulations.

The "Magic" Ingredient: Color-Changing Walls

A major challenge in these detectors is that the light starts as a color our eyes (and sensors) can't see (ultraviolet). It needs to be converted to a visible color.

• The Analogy: Imagine the photons are trying to run through a hallway lined with special mirrors. When a photon hits a mirror, it changes color (wavelength shifting) and bounces off in a new direction.
• The Innovation: Simphony doesn't just move the photons; it also simulates this color-changing process on the GPU. They built a specific "color-changing engine" that mimics the complex rules of the real world, ensuring the simulation is accurate.

The Test: Did the Team Work as Well as the Librarian?

To prove their new team of workers was accurate, they ran a strict test:

1. The Setup: They created a simplified, giant liquid argon tank (14,700 tons of it) with two layers of color-changing walls.
2. The Race: They fed the exact same starting conditions (60 million photons) to both the old single-librarian method (Geant4) and the new GPU team (Simphony).
3. The Results:
   • Accuracy: The GPU team counted the same number of photons as the librarian, with a difference of less than 0.25%. They also matched the timing and colors perfectly.
   • Speed: The GPU team finished the job in about 3 seconds for a batch of events that took the librarian 222 hours to do.
   • The Speedup: The GPU was roughly 1,000 times faster at moving the light than the single computer thread.

Why This Matters (According to the Paper)

The paper claims this tool makes it possible to do things that were previously too slow:

• Designing Detectors: Scientists can now quickly test different shapes and materials for their detectors without waiting months for results.
• Training AI: Machine learning models need huge amounts of labeled data to learn. Simphony can generate these massive datasets of "light patterns" quickly, which helps train AI to recognize particles better.
• Calorimetry Scans: The authors demonstrated they could scan through thousands of different particle types and energies in just a few hours on a single computer, a task that would have taken weeks on a standard setup.

Important Limitations (What the Paper Doesn't Claim)

The authors are very careful to state what this tool is not yet:

• It's a Benchmark, Not a Final Product: They tested this on a simplified, idealized tank. Real detectors have messy details (dead zones, imperfect sensors, complex wiring) that weren't included in this specific test.
• It Doesn't Replace the Whole Process: The GPU is fast at moving light, but the computer still has to do the "heavy lifting" of generating the initial particle crash. Once the light simulation is done, the computer still has to write the data to the hard drive.
• No "Magic" Physics: It doesn't invent new physics; it just simulates the known rules of light much faster.

The Bottom Line

Think of Simphony as a massive speed-up for a very specific, tedious part of physics research. It takes a task that used to require a supercomputer running for days and shrinks it down to a few minutes on a single powerful graphics card, while keeping the results accurate enough to trust. This allows scientists to iterate on their designs much faster, bringing them closer to building better detectors for the future.

Technical Summary

Technical Summary: GPU Optical Photon Monte Carlo for Noble Liquid Detectors

Problem Statement
Optical photon Monte Carlo (MC) simulation is a critical yet computationally prohibitive component in the design and analysis of large noble liquid Time Projection Chambers (TPCs), such as those using liquid argon (LAr). A single GeV-scale interaction can generate $\sim 10^7$ optical photons that undergo complex propagation, including Rayleigh scattering, absorption, and multi-stage wavelength shifting (WLS), over distances of tens of meters. Traditional CPU-based Geant4 simulations struggle with the high per-event cost of tracking these photons, creating a bottleneck for detector design studies that require repeated geometry variations and for machine learning workflows that demand large, labeled optical datasets. While fast optical workflows (e.g., lookup tables, neural network surrogates) exist, they often sacrifice detailed truth information or require regeneration when detector geometries or material properties change.

Methodology
The authors present Simphony, a GPU-accelerated optical simulation tool (formerly EIC-Opticks) built on the Opticks framework, utilizing NVIDIA OptiX for ray tracing and CUDA for physics processes. The core methodology involves:

1. GPU Offloading Workflow: The system uses a "genstep" interface where a host Geant4 simulation generates compact records of optical photon production (position, time, direction, parent track ID). These records are transferred to the GPU, where the optical transport, photon generation, and hit detection occur entirely on the device.
2. Wavelength Shifting (WLS) Implementation: A central technical contribution is the GPU implementation of the Geant4 G4OpWLS model. Simphony utilizes the same material property tables (WLSCOMPONENT, WLSABSLENGTH, WLSTIMECONSTANT) as Geant4. It performs WLS absorption, re-emission, timing, direction, and polarization sampling on the GPU. The emission spectrum is pre-processed into a normalized cumulative distribution function (CDF) with inverse CDF tables to ensure efficient sampling.
3. Truth Propagation: To manage memory for events with tens of millions of photons, Simphony does not store full per-step optical histories. Instead, it assigns contiguous global photon indices to gensteps. Upon detection, the host reconstructs the source association (event, step, parent track) via a binary search on the cumulative offset array, retaining only compact process flags and hit records.
4. Benchmark Configuration: Validation was performed against Geant4 11.3.2 using a simplified 14.7 kt liquid argon TPC geometry. This benchmark features a 60 m $\times$ 13.5 m $\times$ 13 m active volume surrounded by a two-stage WLS shell (200 $\mu$m pTP and 6 mm TPB-doped acrylic) and an idealized 100% efficient photon counting boundary.

Key Results
The validation compared Simphony against Geant4 using identical initial photon distributions from electron, muon, and proton sources:

• Agreement with Geant4:
  • Integrated Hit Ratios: For three paired 2.5 GeV electron simulations (producing $\sim 61$ M photons each), the ratio of detected photons ($R_N$) agreed with Geant4 at the sub-percent level ($R_N = 1.0022 \pm 0.0002$). Similar agreement was found for 1 GeV muons ($R_N = 1.0017 \pm 0.0008$) and 400 MeV protons ($R_N = 1.0005 \pm 0.0014$).
  • Spectral Distributions: The arrival time and wavelength spectra yielded $\chi^2/\text{ndf}$ values of 0.98 and 1.08, respectively, for electron showers. Spatial hit maps on the detector face also showed statistical consistency.
• Performance:
  • Throughput: On an NVIDIA RTX 4090, a stacked launch of four 2.5 GeV electron events (transporting 243 M photons) completed in $3.03 \pm 0.06$ s, achieving a throughput of $80.2 \pm 1.6$ M photons s$^{-1}$.
  • Speedup: Relative to a single-thread Geant4 reference, the optical transport speedup was $1053 \pm 55$. The end-to-end wall time acceleration (including host simulation, setup, and I/O) was $89 \pm 5$.
  • Scaling: The GPU kernel time scales linearly with photon count, with a fixed per-launch overhead. Host-side processing (Geant4 particle simulation) remains the dominant cost in the end-to-end workflow after GPU acceleration.
• Application: The authors demonstrated the utility of this speedup by performing a high-throughput optical calorimetry scan (3,000 events across 3 particle species and 5 energies) in 3.83 hours on a single GPU. A comparable workload using single-thread Geant4 optical transport would require approximately 10 CPU thread-days.

Significance and Scope
The paper establishes that Simphony can reproduce Geant4 optical transport results with high fidelity while offering orders-of-magnitude speedups, making explicit optical photon MC practical for detector development studies and the generation of machine learning training datasets.

The authors explicitly frame the work as a controlled transport benchmark rather than a full detector performance prediction. The validation is conditional on the generated photon source (gensteps) and isolates the optical transport, WLS, and boundary handling stages. The benchmark geometry uses idealized detector boundaries (100% efficiency) and does not include realistic photon detector modules, spectral responses, or absolute scintillation yield models (e.g., NEST, Birks). Consequently, while the tool validates the physics of photon propagation and WLS, it does not claim to predict absolute detection efficiencies or calorimetric performance for specific experiments without further integration of realistic detector models and calibration data. The work serves as a foundation for future integration into production frameworks and validation against measured data.