Deep Learning-Based $^{14}$C Pile-Up Identification in the JUNO Experiment

This paper demonstrates that deep learning models, including convolutional and transformer architectures, offer a promising solution for identifying challenging $^{14}$C pile-up events in the JUNO experiment, thereby helping to preserve the high energy resolution required for determining the neutrino mass ordering.

The Gist

Imagine you are trying to listen to a very quiet, specific whisper in a massive, echoing cathedral. That whisper is a neutrino, a ghost-like particle that barely interacts with anything. The JUNO experiment is a giant, ultra-sensitive "ear" built deep underground in China, designed to catch these whispers to solve one of physics' biggest mysteries: how heavy are neutrinos, and in what order do they weigh?

To hear the whisper clearly, the scientists need to measure the energy of the "echo" (a positron) with incredible precision. But there's a problem: the cathedral isn't empty. It's filled with a constant, low-level hum of background noise.

The Problem: The "Static" in the Signal

In the JUNO detector, the liquid used to catch the neutrinos contains a tiny amount of a radioactive isotope called Carbon-14. Think of Carbon-14 as a swarm of tiny, invisible fireflies that keep blinking randomly in the dark.

When a neutrino hits the detector, it creates a bright flash (the positron). But sometimes, a Carbon-14 firefly blinks at the exact same moment and in the exact same spot as the flash. This is called a "pile-up."

It's like trying to take a photo of a firework, but a tiny bug lands on the lens at the exact same moment. The bug's shadow messes up the picture, making the firework look dimmer or brighter than it really is. If the scientists can't tell the difference between the firework and the bug, their measurement of the neutrino's weight will be wrong.

The Solution: Teaching Computers to Spot the Bugs

The challenge is that the Carbon-14 "bug" is much smaller and fainter than the neutrino "firework." It's hard for human eyes (or simple computer programs) to spot the tiny bug hiding in the giant flash.

So, the researchers in this paper decided to teach Artificial Intelligence (AI) to become a super-sleuth. They built three different types of "detective brains" using Deep Learning to look at the data and say, "Hey, this flash has a bug in it!"

Here is how their three detective methods work, using simple analogies:

1. The 2D CNN: The "Satellite Map" Detective

Imagine you have a giant map of the detector, where every light sensor is a pixel on a map.

• How it works: This AI looks at the data like a satellite image. It sees two layers of information: how bright the lights are (charge) and when they blinked (time).
• The Analogy: It's like looking at a weather map to see a storm. It tries to spot the "shape" of the bug's shadow against the firework.
• The Result: It's okay at finding the bugs, but it's a bit slow and sometimes misses the ones that are hiding very close to the firework.

2. The 1D CNN: The "Sound Wave" Detective

Instead of a map, imagine looking at a sound wave on a graph.

• How it works: This AI looks at the data as a timeline. When a firework and a bug happen together, the timeline usually shows two distinct "humps" or clusters. If they happen at the same time, the humps merge into one weird shape.
• The Analogy: It's like listening to a song. If two notes are played at the same time, the sound wave looks different than if only one note is played. This detective is really good at spotting that weird "double-note" shape.
• The Result: This detective is much faster and better at spotting the tricky bugs that hide right next to the firework.

3. The Transformer: The "Super-Reader" Detective

This is the newest, most advanced type of AI (the same kind that powers modern chatbots).

• How it works: Instead of just looking at shapes or waves, this AI reads the data like a sentence. It understands the relationship between every single piece of information in the timeline, no matter how far apart they are.
• The Analogy: If the 1D CNN is like recognizing a word by its shape, the Transformer is like understanding the meaning of the whole sentence. It knows that a tiny blip here might be connected to a big flash there, even if they seem far apart.
• The Result: It performs just as well as the "Sound Wave" detective but uses a very different, very powerful way of thinking.

The Verdict

The scientists tested these three detectives on millions of simulated events.

• The "Satellite Map" (2D CNN) was a bit too slow and missed some tricky cases.
• The "Sound Wave" (1D CNN) and the "Super-Reader" (Transformer) were the winners. They were incredibly good at spotting the Carbon-14 bugs, especially the ones that were hiding right next to the neutrino signal.

Why This Matters

By using these AI detectives, the JUNO experiment can now filter out the "noise" and get a crystal-clear picture of the neutrino signal. This is a crucial step toward finally solving the mystery of the neutrino's mass ordering.

In short: They taught computers to spot tiny, invisible bugs in a giant flash of light, ensuring the universe's secrets aren't lost in the static.

Technical Summary

1. Problem Statement

The Jiangmen Underground Neutrino Observatory (JUNO) aims to determine the Neutrino Mass Ordering (NMO) with a 3$\sigma$ confidence level within six years. A critical requirement for this goal is achieving a positron ($e^+$) energy resolution of better than 3%.

However, the liquid scintillator (LS) used in the detector contains residual Carbon-14 ($^{14}$C) isotopes. The beta decay of $^{14}$C produces signals that can overlap (pile-up) with the inverse beta decay (IBD) signals from neutrinos. This pile-up degrades the energy resolution of the positron. Preliminary estimates suggest a potential relative degradation of $\sim$2% at 1 MeV visible energy with a default $^{14}$C activity of 40,000 Bq.

The core challenge is identifying these pile-up events to either reject them or reconstruct their energy accurately. This is difficult because:

• The $^{14}$C signal is significantly smaller than the positron signal.
• $^{14}$C events often occur very close in time and vertex position to the positron events, making them hard to distinguish using traditional reconstruction methods.

2. Methodology

The study employs Deep Learning (DL) models to classify events as either "pure positron" or "positron with $^{14}$C pile-up." The approach involves three distinct model architectures, trained on a dataset generated by JUNO offline software (Geant4 simulation, electronics simulation, and event reconstruction).

Dataset:

• Composition: Pure $e^+$ events and $e^+$ events with $^{14}$C pile-up.
• Selection: Training utilized ~160,000 pure $e^+$ events and ~90,000 pile-up events where the number of PMT hits from $^{14}$C ($nHit_{14C}$) was $>50$ (events with fewer hits have negligible impact on resolution).
• Energy Range: $e^+$ kinetic energy ranges from 0 to 5 MeV.

Model Architectures:

1. Two-Dimensional Convolutional Neural Network (2DCNN):

   • Input Transformation: PMT data is projected onto a 2D image format. PMT IDs are mapped to $(x, y)$ coordinates.
   • Channels: Two channels are created:
     1. Charge (scaled by 5).
     2. First hit time (scaled by 100).
   • Preprocessing: The reconstructed position is rotated to align with the X-axis.
   • Architecture: Standard 2D convolutional layers, batch normalization, max pooling, and fully connected layers with ReLU activation.

2. One-Dimensional Convolutional Neural Network (1DCNN):

   • Input Transformation: Utilizes 1D data representing the number of PMT hits versus time.
   • Channels: Two channels are created for each event:
     1. PMT hits vs. time (-250 ns to 1250 ns).
     2. PMT hits vs. time with time-of-flight (TOF) subtracted (-500 ns to 1000 ns).
   • Rationale: Pile-up events typically show two clusters in the time domain (one for $e^+$, one for $^{14}$C), or a single merged cluster if the time difference is small.
   • Architecture: 1D convolutional layers, batch normalization, and max pooling.

3. Transformer-Based Model:

   • Input: Uses the same 1D time-series data as the 1DCNN, treated as a sequence of vectors.
   • Architecture:
     1. Convolution layer for embedding.
     2. Position encoder.
     3. Standard Transformer encoder layer.
     4. Fully connected layers for output.
   • Goal: To leverage the attention mechanism to capture long-range dependencies in the time-series data.

Training Configuration:

• Loss Function: Cross-entropy.
• Optimizer: Adam.
• Scheduler: One-cycle learning rate scheduler.
• Output: Probability of an event being a pile-up event.

3. Key Contributions

• Novel Application: First application of Transformer models and comparative analysis of 1D/2D CNNs specifically for $^{14}$C pile-up identification in the JUNO experiment.
• Data Representation: Developed specific data mapping techniques to convert PMT hit patterns into 2D images (for 2DCNN) and time-series vectors with TOF correction (for 1DCNN/Transformer).
• Performance Benchmarking: Provided a comprehensive comparison of three distinct deep learning architectures regarding accuracy, efficiency in critical time regions, and computational cost.

4. Results

The models were evaluated on test samples with $e^+$ kinetic energies from 0 to 5 MeV.

• General Performance: All three models achieved a 99% identification efficiency for pure $e^+$ events.
• Critical Region Analysis (0–300 ns):
  • The "key region" is defined as the time difference between the $^{14}$C event and the electronics readout being between 0 and 300 ns. Events in this region are hardest to distinguish but have the most significant impact on energy resolution.
  • 2DCNN: Showed suboptimal efficiency in the 0–300 ns region.
  • 1DCNN & Transformer: Demonstrated significantly enhanced efficiency in this critical region compared to the 2DCNN.
• Model Comparison:
  • The Transformer-based model yielded results similar to the 1DCNN model, confirming the feasibility of using attention mechanisms for this task.
  • Both 1D approaches outperformed the 2D approach in the most challenging temporal overlaps.
• Training Efficiency:
  • 1DCNN: ~4 minutes per epoch (fastest).
  • Transformer: ~27 minutes per epoch.
  • 2DCNN: ~60 minutes per epoch (slowest).

5. Significance

This study demonstrates that deep learning is a highly promising tool for mitigating $^{14}$C pile-up effects in the JUNO experiment.

• Energy Resolution Preservation: By accurately identifying pile-up events in the critical 0–300 ns window (where traditional methods struggle), the proposed models help preserve the required $<3\%$ energy resolution.
• Operational Feasibility: The 1DCNN model offers the best balance of high performance in critical regions and low computational cost (training time), making it a strong candidate for real-time or offline reconstruction pipelines.
• Scientific Impact: Successfully identifying and correcting for these pile-up events is a crucial step toward achieving JUNO's primary physics goal: determining the neutrino mass ordering with high confidence.