Fast array-based particle coincidence detection in a TimePix3-based velocity map imaging instrument

This paper presents a rapid, GPU-parallelized array-based algorithm that enables real-time, high-fidelity particle coincidence detection and centroiding for TimePix3-based velocity map imaging instruments, achieving processing speeds 25 times faster than data acquisition while outperforming traditional delay line anode detectors in discriminating simultaneous hits.

The Gist

Here is an explanation of the paper, translated into everyday language with some creative analogies.

The Big Picture: Catching Ghosts in a Storm

Imagine you are trying to study a very fast, chaotic storm. In this case, the "storm" is a laser beam hitting gas molecules, causing them to explode into tiny, charged particles (electrons and ions). Scientists want to catch these particles to understand exactly how the explosion happened.

To do this, they use a special camera called a TimePix3. But here's the problem: The camera is so sensitive and the laser is so fast that it sees thousands of tiny flashes every second. If you try to look at the raw data, it's like trying to read a book where someone is throwing pages at you at 1,000 miles per hour. You can't make sense of it.

This paper is about building a super-fast "translator" that turns that chaotic storm of data into a clear, sharp picture, allowing scientists to see details they've never seen before.

---

The Problem: The "Blurry Flash"

The Old Way (The Delay Line):
Previously, scientists used a detector that worked like a telephone wire. When a particle hit the detector, it sent a signal down a wire. By timing how long the signal took to travel, the computer could guess where the hit happened.

• The Flaw: If two particles hit the wire at the same time, the signals get tangled. It's like two people shouting into the same telephone line at once; the listener can't tell who said what or where they were standing. If the hits are too close together (within 7.5 mm), the system gets confused and merges them into one blurry blob.

The New Way (The Pixel Camera):
The TimePix3 is different. Instead of a wire, it's a grid of millions of tiny sensors (pixels), like a super-high-definition digital camera.

• The Good News: It can see exactly which pixels lit up.
• The Bad News: The data comes in a weird, scattered stream. It doesn't send a "picture" (a frame); it sends a list of "events" like: "Pixel 50, 100 lit up at 12:00:01.0001 for 5 nanoseconds."
• The Challenge: Because the light from a single particle spreads out and hits several pixels at once, the computer has to figure out: "Okay, these 10 pixels all lit up together. They must be one single particle. Where is the exact center of that group?"

Doing this math for thousands of particles, thousands of times a second, used to be too slow. By the time the computer finished calculating, the laser had already fired again.

---

The Solution: The "Super-Speedy Organizer"

The authors created a new algorithm (a set of mathematical instructions) to solve this puzzle. Think of it as a super-efficient party planner for the data.

Here is how their "Party Planner" works in three steps:

1. The "Who's Sitting Together?" Game (Neighborhooding)

Imagine a crowded room where people are shouting. The computer looks at the list of who lit up and asks, "Who is sitting next to whom?"

• It uses a clever math trick (called an adjacency matrix) to instantly group pixels that are close together in space and time. It ignores the empty pixels (the dark parts of the room) because they don't matter. This is the "sparse" part of the paper—they only look at the people who are actually talking.

2. Finding the "Captain" (Local Maxima)

Once the groups are formed, the computer needs to know how many particles there are. It looks at each group and finds the brightest pixel (the one that stayed "on" the longest).

• Analogy: Imagine a group of friends huddled together. The computer finds the tallest person in the huddle. That person represents the "center" of the group. If there are two distinct huddles, it finds two captains. This tells the computer exactly how many particles hit the detector.

3. The "Center of Gravity" (Centroiding)

Now, the computer calculates the exact center of each group. It doesn't just guess the middle; it weighs every pixel based on how bright it was.

• Analogy: Imagine a seesaw. If one side has a heavy rock (a bright pixel) and the other has a pebble (a dim pixel), the balance point isn't in the middle of the seesaw; it's closer to the rock. The computer calculates this balance point for every single particle.
• The Result: Instead of a blurry blob covering 5 pixels, the computer pinpoints the particle's location to a tiny spot smaller than a single pixel. This is called sub-pixel precision.

---

Why is this a Big Deal?

1. It's Lightning Fast (The GPU Boost)

The authors realized that doing this math one by one is slow. So, they moved the calculation to a Graphics Processing Unit (GPU)—the same powerful chip found in video game consoles.

• The Analogy: Imagine you have to sort 1,000 piles of laundry.
  • Old Way: You sort one pile, then the next, then the next.
  • New Way: You hire 1,000 people (the GPU cores) and give them all the laundry at once.
• The Result: The computer processes the data 25 times faster than the laser fires. This means the system can keep up with the fastest lasers in the world in real-time.

2. It Sees What Others Can't (The Coincidence Breakthrough)

Because the new method is so precise, it can tell the difference between two particles hitting the detector very close to each other.

• The Comparison: The old "telephone wire" detectors needed particles to be 7.5 mm apart to tell them apart. The new TimePix3 method can distinguish particles that are only 1 mm apart.
• Why it matters: In chemistry, sometimes two particles are born at the exact same time and fly out together. If you can't tell them apart, you miss the most interesting part of the story. This new tool lets scientists see these "double hits" clearly.

3. Sharper Pictures

By finding the exact center of the light, the images become incredibly sharp.

• Analogy: It's like taking a blurry photo of a star and using software to sharpen it until you can see the texture of the star's surface. The paper shows that features in the data (called "Freeman resonances") that were previously hidden in the blur suddenly pop into sharp focus.

The Bottom Line

This paper describes a new "super-solver" for a very fast camera. By using smart math and powerful computer chips, the scientists turned a chaotic stream of data into a crystal-clear, high-speed movie of molecular explosions.

This allows them to study rare, complex chemical reactions that happen in a fraction of a second, opening the door to understanding how molecules behave under extreme conditions—like those found in X-ray lasers or powerful electric fields. It's a major step forward in seeing the invisible world of atoms.

Technical Summary

Here is a detailed technical summary of the paper "Fast array-based particle coincidence detection in a TimePix3-based velocity map imaging instrument."

1. Problem Statement

Velocity Map Imaging (VMI) is a critical technique for resolving the momentum and angular distributions of charged particles (ions and electrons) in photo-induced processes. To study rare events and complex multi-particle dynamics (e.g., Coulomb explosions, covariance mapping), modern experiments require:

• High Repetition Rates: Utilizing laser sources operating at kHz to MHz frequencies.
• High Count Rates: Detecting tens of particles per laser shot.
• Coincidence Capability: Distinguishing multiple simultaneous hits to reconstruct full kinematic information.

Current Limitations:

• Delay Line Anode (DLA) Detectors: While fast, they suffer from "hit ambiguity." They cannot distinguish simultaneous hits that occur within a specific spatial separation (typically ~7.5 mm for state-of-the-art hexanode detectors), leading to data loss in high-count-rate covariance regimes.
• Optical Detectors (Phosphor Screens): Offer high spatial resolution but traditionally struggle with data throughput. Conventional frame-based cameras generate massive data volumes, and existing pixelated detectors (like TimePix3) produce sparse data streams that are difficult to process in real-time.
• Processing Bottleneck: Existing methods for TimePix3 data often involve offline processing, frame reconstruction (losing sparsity benefits), or neglecting centroiding entirely, preventing real-time analysis at high repetition rates.

2. Methodology

The authors developed a fast, array-based centroiding algorithm specifically designed for the sparse data stream of the TimePix3 camera (TPX3CAM) integrated into a VMI instrument. The approach leverages the sparsity of the data (most pixels are dark) and utilizes GPU parallelization.

Key Technical Components:

• Apparatus: A voltage-switching VMI instrument using a 1 kHz Ti:sapphire laser, a Microchannel Plate (MCP) with a P47 phosphor screen, and a TPX3CAM detector. The system detects both electrons and ions simultaneously.
• Data Preprocessing:
  • ToA Unwrapping: Corrects for time-wrapping artifacts in the Time-of-Arrival (ToA) data caused by the 42-bit/44-bit integer counters wrapping around every ~27s/107s.
  • Background Elimination: Filters out "dead time" data (dark counts) by checking if the Time-of-Flight (ToF) falls within the expected 100 µs window relative to the laser trigger.
  • Timewalk Correction: Corrects the correlation between Time-over-Threshold (ToT) and ToF. Dimmer pixels (lower ToT) appear to arrive later due to signal rise-time effects. A model $\Delta ToF(ToT)$ is fitted and applied to all pixels.
• The Centroiding Algorithm (Three Steps):
  1. Neighborhooding: Identifies which pixels belong to the same particle hit. Instead of sorting, it constructs an adjacency matrix ($A_{ij}$) by computing the element-wise (Hadamard) product of distance matrices for X, Y, and ToF dimensions. Pixels within a defined spatial/temporal threshold are marked as neighbors.
  2. Local Maxima Detection: Identifies the "brightest" pixel (highest ToT) in each neighborhood to serve as the initial hit center. This determines the number of distinct hits. To handle quantization degeneracy (where two pixels have identical ToT), a tiny ascending offset is added to break ties.
  3. Centroid Calculation: Computes the center of mass for each hit using the ToT values as weights (proxy for brightness). The formula used is:
     $$X_{cent} = \frac{\sum (X_j \cdot A_{ij} \cdot ToT_j)}{\sum (A_{ij} \cdot ToT_j)}$$
     This is performed for X, Y, and ToF dimensions simultaneously.
• GPU Implementation:
  • The algorithm is implemented in PyTorch on an NVIDIA Titan RTX GPU.
  • Batching: Data from multiple laser shots are processed in parallel. Since shots have varying numbers of pixel events, the data is zero-padded to form rectangular arrays compatible with GPU tensor operations.

3. Key Contributions

• Real-Time Sparse Processing: The first demonstration of a centroiding algorithm that fully exploits the sparsity of TimePix3 data, avoiding the overhead of frame reconstruction.
• Sub-Pixel Precision: The algorithm localizes particle hits to better than a single pixel (sub-pixel resolution) by calculating the center of mass of the fluorescence spot.
• Massive Speedup: The GPU-parallelized implementation processes data ~25 times faster than the data acquisition rate (for a 1 kHz system with ~10-50 particles/shot). This enables true real-time analysis.
• Superior Coincidence Resolution: The method resolves simultaneous hits separated by as little as ~1 mm on the detector surface, significantly outperforming the ~7.5 mm limit of hexanode DLA detectors.

4. Results

• Image Sharpening: Application of the algorithm to Argon Above-Threshold Ionization (ATI) data at 400 nm showed significant sharpening of spectral features.
  • The width of peaks near 60 pixels narrowed by a factor of 2.6x.
  • Sub-structures, such as Freeman resonances and azimuthal dependencies, became clearly visible, which were previously blurred by the multi-pixel fluorescence spots.
  • Dead pixels on the detector were effectively masked out during the centroiding process.
• Multi-Hit Discrimination: Analysis of pairwise centroid distances from 500,000 laser shots confirmed the ability to distinguish simultaneous electron hits separated by >1 mm.
• Performance Metrics:
  • Throughput: Processing speed exceeds acquisition speed by a factor of 25.
  • Scalability: The algorithm scales well with repetition rates. While memory usage scales quadratically ($O(N^2)$) with the number of pixels per shot (due to the adjacency matrix), the authors note that for high-repetition/low-particles-per-shot regimes, the method is highly efficient.

5. Significance

This work bridges the gap between high-repetition-rate laser science and particle detection capabilities.

• Enabling Covariance Mapping: By solving the "hit ambiguity" problem of DLA detectors and the "throughput" problem of optical detectors, this system enables high-fidelity covariance mapping and multi-particle coincidence studies at kHz repetition rates.
• Future-Proofing: The architecture is designed to scale to higher repetition rates (MHz) as laser technology advances, provided the per-shot count rate remains manageable or batching strategies are optimized.
• Scientific Impact: The ability to resolve sub-pixel features and simultaneous hits with high fidelity allows for more precise reconstruction of molecular geometries via Coulomb explosion imaging and detailed analysis of complex ionization dynamics.

In conclusion, the authors present a robust, GPU-accelerated solution that transforms the TimePix3 camera into a high-speed, high-resolution coincidence detector, overcoming the limitations of current state-of-the-art VMI instrumentation.