Machine Learning-Based Cluster Classification to Suppress Background in a Prototype RPC Detector

This paper demonstrates that machine learning classifiers, particularly XGBoost, effectively suppress background hits in low-resistive Resistive Plate Chamber (RPC) prototypes by utilizing fifteen cluster-level descriptors to distinguish genuine signals from secondary hits, thereby improving track reconstruction efficiency in self-triggering environments.

The Gist

Imagine you are trying to listen to a single friend's voice at a very loud, crowded party. Your friend is the signal (the real data you want), but the room is filled with chatter, clinking glasses, and people shouting from other tables. These are the background noises (fake signals).

In the world of high-energy physics, scientists use special detectors called RPCs (Resistive Plate Chambers) to "listen" to particles zipping through space. However, these detectors have a glitch: sometimes, when a real particle hits, the detector gets confused and creates "ghost echoes" a few nanoseconds later. These ghosts look just like real hits, making it hard to know what's real and what's fake.

Traditionally, scientists tried to fix this by turning up the "volume" (raising the threshold) to ignore quiet noises. But the problem is, sometimes the real voice is quiet too, so you end up missing your friend along with the noise.

This paper presents a smarter solution: Machine Learning as a "Smart Bouncer."

The Problem: The "Ghost" Hits

The researchers noticed that their detectors were producing these "ghost hits" (secondary signals) that looked suspiciously like real ones. In a normal lab, they could use a separate "trigger" (like a security guard with a walkie-talkie) to say, "Okay, that noise at 5:00 PM was real because the guard saw it." But in the real world (or in self-triggering detectors), there is no security guard. The detector has to decide for itself, "Is this a real particle or just a glitch?"

The Solution: Looking at the "Shape" of the Noise

Instead of just listening to how loud a hit is, the scientists decided to look at the shape of the noise. They realized that a real particle and a ghost echo leave different "fingerprints."

They grouped the hits together into clusters (like grouping all the chatter from one table). Then, they measured 15 different things about these clusters, such as:

• How many people are at the table? (Cluster size)
• How spread out is the conversation? (Time difference between hits)
• How consistent is the volume? (ADC/Charge distribution)

The Analogy:
Imagine a real hit is a group of friends singing a song together. They start at the same time, they are all loud, and they stay in sync.
A fake hit (background) is like someone shouting randomly, followed by a few confused echoes. They start at different times, they are quieter, and they are out of sync.

The "Smart Bouncers" (The AI Models)

The team trained three different types of Artificial Intelligence "bouncers" to look at these 15 fingerprints and decide: "Real Party" (Signal) or "Fake Noise" (Background).

1. DNN (Deep Neural Network): Think of this as a super-intelligent detective who has read every book on party dynamics. It looks at all the clues at once.
2. 1D-CNN (Convolutional Neural Network): This is like a pattern-spotter. It looks for specific shapes in the data, similar to how you might recognize a face by looking at the eyes and mouth in a specific order.
3. XGBoost (The Winner): This is like a panel of 200 experienced bouncers. Each one looks at a small part of the data and makes a quick decision. They vote, and the majority wins.

The Results: Who Won?

All three bouncers were excellent, but XGBoost (the panel of 200) was the best at the job.

• The Secret Weapon: The AI discovered that the size of the group (how many pads fired) and the timing spread (how scattered the hits were) were the biggest giveaways. Real hits tend to be bigger groups that happen all at once. Fake hits are smaller and scattered.
• Performance: The AI could separate the real hits from the fake ones with over 94% accuracy. This is much better than the old method of just turning up the volume.

Why Does This Matter?

• Speed: The AI is incredibly fast. It can process a million hits in just a few seconds. It's light enough to be used in real-time, meaning the detector can clean up its own data while the experiment is running.
• Efficiency: By using this "Smart Bouncer," scientists can keep the detector sensitive (hearing the quiet voices) without getting overwhelmed by the noise.

In a Nutshell

The scientists took a messy, noisy detector problem and solved it by teaching a computer to recognize the "personality" of the noise. Instead of just shouting "QUIET!" (raising the threshold), they taught the detector to say, "That noise sounds like a glitch; ignore it. That one sounds like a real particle; keep it."

This allows future physics experiments to see the universe more clearly, even in the noisiest environments.

Technical Summary

1. Problem Statement

Context: Resistive Plate Chambers (RPCs) are critical timing and triggering detectors in high-energy physics. However, low-resistive bakelite RPCs operated with self-trigger electronics (specifically using XYTER chips) frequently suffer from a specific artifact: secondary (fake) hits.
The Issue:

• These secondary hits appear a few nanoseconds after the primary signal, manifesting as a "long tail" or a secondary peak in time-correlation spectra.
• They degrade both time resolution and spatial resolution.
• In self-trigger mode (where no external reference trigger exists), distinguishing these fake hits from genuine signals is extremely difficult.
• Traditional mitigation, such as increasing the ADC threshold, suppresses fake hits but simultaneously reduces the overall detection efficiency.

2. Methodology

The authors propose a machine learning (ML) strategy to classify hit clusters as either "signal" (genuine) or "background" (secondary/crosstalk) based solely on internal detector observables, without relying on external triggers.

A. Experimental Setup & Data Acquisition

• Detector: A single-gap low-resistive bakelite RPC.
• Trigger: A master trigger generated by three scintillators (two large, one narrow finger) arranged vertically with the RPC. This setup was used for offline labeling to generate ground truth data.
• Readout: Signals processed via NIM electronics and Front-End Boards (FEBs) with FPGA-based processing.
• Conditions: Operated at 10.0 kV, 22°C, and 40% humidity.

B. Feature Construction (The Core Innovation)

Instead of analyzing individual hits, the approach uses spatial and temporal agglomerative clustering. Since a single particle typically fires multiple adjacent pads, the properties of the resulting cluster are used as the input features.

• Labeling: Hits in the main time peak were labeled "Signal"; hits in the secondary peak were labeled "Background."
• Input Features: A total of 15 cluster-level descriptors were engineered to capture statistical and fit-based properties of the time and charge (ADC) distributions within a cluster. These include:
  • Statistical: Cluster size, mean, and standard deviation (sigma) of time and ADC differences.
  • Fit-based: Mean, sigma, and amplitude derived from Gaussian fits to time/ADC distributions.
  • Quality Metrics: Chi-square ($\chi^2$) and Number of Degrees of Freedom (NDF) from the Gaussian fits.

C. Machine Learning Models

Three distinct classifiers were trained on balanced datasets (equal signal/background):

1. Deep Neural Network (DNN): A feed-forward network with dense layers (64 $\to$ 32 $\to$ 1 neurons) using ReLU and Sigmoid activations.
2. 1D Convolutional Neural Network (1D-CNN): Designed to capture local patterns in sequential data using convolutional filters (128 and 32 filters) followed by global max-pooling.
3. XGBoost (Boosted Decision Tree): An ensemble of 200 decision trees (max depth 5, learning rate 0.05) using row subsampling to prevent overfitting.

3. Key Results

A. Classification Performance

All three models demonstrated strong discrimination capabilities on an independent test dataset.

• AUC (Area Under Curve):
  • XGBoost: 0.941 (Highest)
  • DNN: 0.937
  • CNN: 0.933
• F1 Score: XGBoost achieved the highest (0.880), followed by DNN (0.873) and CNN (0.870).
• Precision/Recall: All models maintained high precision (>94%) while achieving reasonable recall (~81%), crucial for background-dominated environments.

B. Feature Importance Analysis

Using the XGBoost model, the authors identified the most critical discriminants:

1. Cluster Size: The single most important feature, contributing ~41.8% of the total gain. Background clusters are significantly smaller than signal clusters.
2. Temporal Shape: The standard deviation of the time distribution and the amplitude from the Gaussian time fit contributed significantly (~22.9% and ~9.4%, respectively).
3. Charge Distribution: ADC-related variables (sigma, $\chi^2$) provided additional sensitivity.

C. Computational Performance

A benchmark test was conducted on an AMD EPYC 7713 processor (single-threaded) processing 100,000 events (~1.5 million hits).

• Total Processing Time: 4.46 seconds.
• Latency:
  • 44.6 $\mu$s per event.
  • 2.98 $\mu$s per hit.
• Breakdown: Clustering (19.4 $\mu$s), Feature Extraction (2.4 $\mu$s), and XGBoost Inference (14.6 $\mu$s).
• Conclusion: The ML inference adds only a modest computational overhead, making the method suitable for real-time applications.

4. Significance and Contributions

• Self-Trigger Compatibility: The method successfully separates signal from background using only internal cluster properties, making it viable for RPCs operating without external triggers.
• Superiority over Traditional Cuts: The ML approach outperforms simple ADC threshold cuts, which typically sacrifice detection efficiency to remove noise.
• Interpretability: The feature importance analysis provides physical insight, confirming that genuine signals form larger, tighter temporal clusters compared to the scattered, smaller background hits.
• Real-Time Viability: The low latency (44 $\mu$s/event) and low memory footprint (330 MB) demonstrate that this approach can be integrated into online reconstruction pipelines and fast data-processing systems for high-rate experiments.
• Model Selection: While XGBoost showed the best generalization, the DNN offered comparable accuracy with fast inference, suggesting flexibility in deployment depending on hardware constraints.

Summary

This paper presents a robust, data-driven solution to a persistent problem in RPC detector physics. By shifting the analysis from individual hits to cluster-level descriptors and applying machine learning classifiers, the authors achieved high-efficiency background suppression without external triggers. The XGBoost model, driven primarily by cluster size and temporal shape, offers a practical, low-latency solution for improving track reconstruction in high-rate environments.