Suppression of $^{14}\mathrm{C}$ photon hits in large liquid scintillator detectors via spatiotemporal deep learning

This paper proposes three deep learning models—a gated spatiotemporal graph neural network and two Transformer-based architectures—that effectively tag and suppress $^{14}$C photon hits in liquid scintillator detectors, significantly improving energy resolution for overlapping $e^+$ and $^{14}$C events while maintaining a low misidentification rate.

The Gist

Imagine you are trying to listen to a beautiful, clear violin solo (the positron signal) in a concert hall. This solo is crucial because it tells scientists about the secrets of the universe (neutrinos).

However, there's a problem. The concert hall is filled with tiny, invisible crickets (Carbon-14 atoms) that are constantly chirping. Usually, these crickets are so quiet and rare that you don't notice them. But in this massive, super-sensitive concert hall (the JUNO detector), there are so many crickets that they chirp at the exact same time as the violin.

The result? The violin sound gets muddy. The crickets' chirps mix with the music, making it hard to tell exactly how loud the violin was playing. In physics terms, this "muddy sound" ruins the energy resolution, meaning scientists can't measure the energy of the particles precisely.

This paper is about teaching a computer to act like a super-smart audio engineer who can instantly separate the violin from the crickets, even when they are chirping right on top of each other.

The Problem: The "Crickets" in the Room

The detector is a giant tank of liquid that glows when particles hit it.

• The Good Signal: A positron (from a neutrino interaction) hits the liquid and creates a bright, clear flash of light.
• The Bad Noise: Carbon-14, a natural isotope in the liquid, decays and creates a tiny, faint flash of light.
• The Pile-up: Sometimes, a Carbon-14 decay happens at the exact same millisecond as the positron. The detector sees one big, messy blob of light instead of two distinct events.

Because the Carbon-14 flashes are so weak and happen so often in a giant detector, they drown out the precision needed for the experiment.

The Solution: Three "Smart Filters"

The researchers built three different types of Artificial Intelligence (AI) models to look at the data and say, "This flash of light is the violin (positron), and that tiny flicker is a cricket (Carbon-14)."

Think of the data as a 3D map of millions of tiny light sensors (PMTs) recording when and how bright a flash was.

1. The Neighborhood Watcher (Gated-STGNN):

   • How it works: Imagine a security guard walking through the crowd. This model looks at a specific flash of light and asks, "Who are my neighbors? Did they flash at the same time? Are they close by?" It builds a map of connections between the flashes.
   • Analogy: It's like a detective looking at a group of people and figuring out who belongs to the same party based on who is standing next to whom and talking at the same time.

2. The Global Listener (STT-Scalar):

   • How it works: This model uses a "Transformer" (the same tech behind tools like ChatGPT). Instead of just looking at neighbors, it listens to the entire concert hall at once. It pays attention to the whole pattern of light flashes simultaneously.
   • Analogy: Imagine a conductor who can hear every single instrument in the orchestra at once and instantly knows which note is out of place, even if it's buried in the noise.

3. The Detective with a Magnifying Glass (STT-Vector):

   • How it works: This is the "champion" model. It does everything the Global Listener does, but it also looks at the density of the light. It calculates how much "charge" (brightness) is coming from a specific spot and its immediate surroundings, creating a detailed 3D profile of the light.
   • Analogy: This is like the Global Listener, but they also have a special pair of glasses that shows them the "texture" of the sound. They can tell the difference between a violin and a cricket not just by the note, but by the feeling of the sound wave.

The Results: Cleaning Up the Music

The researchers tested these models on simulated data where a positron and a Carbon-14 decay happened almost simultaneously.

• The Challenge: When the two events happen very close together in time (within a few nanoseconds), it's incredibly hard to tell them apart. It's like trying to hear a whisper while someone is shouting right next to you.
• The Success:
  • The models managed to identify and remove about 25% to 48% of the "cricket" flashes (Carbon-14).
  • Crucially, they did this without accidentally deleting the "violin" flashes (the positron). They kept the "false alarm" rate (mistaking a violin for a cricket) below 1%.
  • The Payoff: By removing the muddy background noise, the clarity of the music improved. The energy resolution (how precisely they can measure the energy) got significantly better—by up to 20% in the hardest cases.

Why This Matters

In the world of neutrino physics, precision is everything. If you can't measure the energy of a particle perfectly, you can't solve the biggest mysteries of the universe, like why the universe is made of matter instead of antimatter.

This paper shows that by using advanced AI to "clean up" the raw data at the very smallest level (the individual flashes of light), we can make giant detectors like JUNO much more powerful. It's like taking a blurry, noisy photo and using AI to sharpen it, revealing details that were previously hidden.

In short: The scientists taught computers to be better at ignoring the background noise of the universe, allowing them to hear the faint, beautiful signals of neutrinos much more clearly.

Technical Summary

1. Problem Statement

Large liquid scintillator (LS) detectors, such as the Jiangmen Underground Neutrino Observatory (JUNO), are critical for high-precision neutrino physics (e.g., determining neutrino mass ordering). However, they face a significant challenge known as $^{14}$C pile-up.

• The Issue: The $^{14}$C isotope naturally present in the scintillator undergoes $\beta$-decay, producing low-energy photons. When these decays occur within the same data acquisition window (1000 ns) as a signal event (e.g., an inverse beta decay positron, $e^+$), they contaminate the signal.
• The Challenge: Unlike high-energy physics pile-up where signals are distinct, $^{14}$C decays (endpoint ~0.16 MeV) produce far fewer photons than MeV-scale positrons. When the time difference ($\Delta t$) between the $e^+$ and $^{14}$C is small (specifically $\Delta t \in [-100, 300]$ ns), the $^{14}$C hits are buried within the dominant $e^+$ signal.
• Consequence: This contamination degrades the energy resolution, which is critical for JUNO's goal of achieving 3% resolution at 1 MeV. Traditional timing cuts fail in this overlapping regime, necessitating a hit-level discrimination method that utilizes both spatial and temporal correlations.

2. Methodology

The authors propose a deep learning framework to perform semantic segmentation on sparse point clouds of photon hits. The dataset consists of simulated events containing one $e^+$, one $^{14}$C decay, and dark noise (DN). The input for each hit includes spatial coordinates $(x,y,z)$, arrival time $t$, and charge $q$.

Three distinct architectures were developed and compared:

A. Gated Spatiotemporal Graph Neural Network (Gated-STGNN)

• Concept: Models the event as a graph where nodes are hits and edges represent local spatiotemporal proximity.
• Mechanism:
  • Uses Gated Recurrent Units (GRUs) for message passing to propagate contextual information across the graph.
  • Incorporates window-level context (aggregate statistics like hit count and charge mean per time bin) to capture global temporal evolution.
  • Employs a sparse neighborhood aggregation strategy (fixed $K$ neighbors) to handle the sparsity of the data efficiently.
• Complexity: Linear scaling with the number of hits ($O(N)$), making it computationally efficient for large multiplicities.

B. Spatiotemporal Transformer with Scalar Charge Encoding (STT-Scalar)

• Concept: Treats hits as tokens in a sequence, utilizing global self-attention mechanisms.
• Mechanism:
  • Uses periodic positional encodings for spatial and temporal coordinates.
  • Encodes charge as a scalar value embedded via an MLP.
  • Relies on self-attention to capture global dependencies between all hits in the event.
• Complexity: Quadratic scaling ($O(N^2)$) due to the attention matrix, limiting batch sizes and increasing memory footprint.

C. Spatiotemporal Transformer with Vector Charge Encoding (STT-Vector)

• Concept: An enhancement of STT-Scalar that explicitly encodes local and global charge density correlations.
• Mechanism:
  • Constructs an 18-dimensional vector feature for each hit. This vector aggregates charge sums within specific spatiotemporal windows (current, next, and previous time frames) at multiple spatial scales (radii ranging from 3m to 23m).
  • This vector is embedded and concatenated with spatiotemporal features before being processed by the Transformer backbone.
• Complexity: Similar to STT-Scalar ($O(N^2)$) but incurs an additional $O(N^2)$ preprocessing cost for feature construction (which is precomputed in this study).

3. Key Contributions

1. Novel Application: First application of advanced spatiotemporal deep learning (Graph NNs and Transformers) specifically for $^{14}$C pile-up suppression in liquid scintillator detectors at the hit level.
2. Architecture Comparison: A systematic comparison between graph-based (local correlation focused) and Transformer-based (global correlation focused) approaches for sparse, discontinuous photon data.
3. Feature Engineering: The introduction of Vector Charge Encoding in STT-Vector, which aggregates multi-scale charge density information, significantly improving the model's ability to distinguish low-energy $^{14}$C hits from the dense $e^+$ background.
4. Performance Metric: Demonstration that hit-level classification directly translates to improved energy resolution, quantified via the total charge ($Q_{sum}$) distribution.

4. Results

The models were evaluated on a simulation dataset with positron kinetic energies ($E_k$) ranging from 0 to 5 MeV.

• Classification Performance:

  • Recall ($^{14}$C Identification): The STT-Vector model achieved the highest recall, ranging from 25% to 48% depending on the energy regime. STT-Scalar followed closely, while Gated-STGNN performed slightly lower.
  • Misidentification Rates: Crucially, all models maintained extremely low false-positive rates:
    • $e^+$ misidentified as $^{14}$C: < 1% (preserving signal yield).
    • Dark Noise misidentified as $^{14}$C: < 2% (preserving noise baseline).
  • Energy Dependence: Performance was best at low $E_k$ (0 MeV) where $^{14}$C is more distinct relative to the $e^+$ background. At 5 MeV, the dense $e^+$ hits made $^{14}$C identification harder (recall dropped to ~25%), but the models remained robust.

• Energy Resolution Improvement:

  • Removing predicted $^{14}$C hits significantly improved the resolution of the total charge ($Q_{sum}$).
  • For $E_k = 0$ MeV, the resolution improved by ~18%.
  • For $E_k = 5$ MeV, the improvement was ~3% (as the intrinsic $e^+$ statistics dominate at high energy).
  • The STT-Vector model consistently provided the best resolution recovery across all tested positions (center to boundary) and energies.

• Computational Efficiency:

  • Gated-STGNN was approximately 10x faster per epoch than the Transformer models due to its linear complexity vs. the quadratic complexity of Transformers.
  • However, the STT-Vector's superior accuracy justified the higher computational cost for offline analysis.

5. Significance

• Physics Impact: This work demonstrates a viable path to mitigating the $^{14}$C pile-up background, a major systematic limitation for next-generation neutrino experiments like JUNO. By improving energy resolution, it directly enhances the sensitivity to neutrino mass ordering and other precision measurements.
• Methodological Advance: It validates that deep learning architectures designed for complex point cloud data (Transformers and Graph NNs) can effectively handle the unique sparsity and spatiotemporal discontinuity of detector hit data.
• Scalability: The study provides a blueprint for handling pile-up in large-scale detectors where traditional cut-based methods are insufficient, paving the way for more complex background rejection strategies in future experiments.

Conclusion: The proposed STT-Vector model offers the best trade-off between identification accuracy and energy resolution recovery, successfully tagging up to 48% of $^{14}$C hits while preserving the integrity of the primary signal, thereby offering a powerful tool for high-precision neutrino physics.