A method for luminosity determination based on real-time hit reconstruction with the LHCb silicon pixel detector

This paper presents a new real-time luminosity determination method for the upgraded LHCb experiment, implemented directly in the VELO detector's FPGA firmware using 40 MHz hit reconstruction, which achieves sub-percent statistical resolution and millisecond-level granularity during the 2024 physics run.

The Gist

Imagine the Large Hadron Collider (LHC) at CERN as the world's most powerful particle accelerator, a 27-kilometer ring where tiny packets of protons zoom around at nearly the speed of light, smashing into each other billions of times a second.

The LHCb experiment is one of the "cameras" watching these collisions. Its job is to take pictures of the debris to understand the fundamental rules of the universe. But to do this correctly, the camera needs to know exactly how bright the flash is every single time the particles collide. In physics, this "brightness" is called luminosity.

If the camera doesn't know the brightness, it can't tell if a rare, interesting event happened by chance or because the machine was running too hot or too cold.

The Problem: Counting at the Speed of Light

In the past, LHCb had to wait for a computer to process the data after a collision to count how many particles were created. But the collisions happen so fast (40 million times a second) that waiting for the computer was like trying to count raindrops by waiting for the news report the next day. You'd miss almost everything.

The Solution: A "Smart Counter" Built into the Camera

This paper describes a brilliant new method where the LHCb team built a real-time counter directly into the camera's hardware.

Think of the LHCb detector as a giant, high-tech digital camera. Inside the lens (called the VELO), there are millions of tiny pixels. When a particle hits a pixel, it leaves a "hit."

• Old Way: The camera took the picture, sent it to a computer, and the computer tried to group the pixels into "hits."
• New Way: The camera's own brain (a specialized chip called an FPGA) does the grouping instantly as the light hits the sensor. It doesn't wait. It counts the hits while the collision is happening.

The Analogy: The Rain Gauge in a Storm

Imagine you are trying to measure how hard it is raining during a massive storm.

• The Old Method: You wait for the rain to stop, then go outside and count every puddle. By then, the storm has passed, and you don't know the intensity of the peak rain.
• The New Method: You have a smart bucket that instantly counts every drop as it hits. But here's the catch: if the rain is too heavy, the drops merge into one big splash, and your bucket might count one splash as one drop, even though it was actually five drops. This is called saturation.

The LHCb team solved this by placing their "buckets" (counters) in specific zones:

1. Inner Buckets: Close to the center of the storm.
2. Outer Buckets: Further away, where the rain is lighter and drops don't merge.

By focusing on the Outer Buckets, they avoid the "merging drops" problem. They count the hits, and because they know exactly how the rain behaves, they can calculate the total storm intensity (luminosity) with incredible precision.

How They Make It Accurate

To make sure their "smart bucket" is accurate, they perform a special calibration called a Van der Meer scan.

• The Analogy: Imagine two flashlights shining on a wall. To measure how bright the overlap is, you slowly move the flashlights apart and together, measuring the light intensity at every step. This creates a perfect map of the "beam."
• Using this map, they can translate the raw number of hits into a precise measurement of luminosity.

The Results: A Super-Stable Flashlight

The paper reports that this new method is a huge success:

• Speed: It updates the luminosity measurement every 90 milliseconds (faster than a human eye blink).
• Precision: It is accurate to within 0.3%. That's like measuring the distance from New York to London and being off by less than the length of a car.
• Reliability: It works even when the "storm" gets crazy (like when colliding heavy lead ions instead of just protons).
• Stability: It stays consistent over weeks of operation, even if the "flashlights" (the particle beams) wiggle slightly.

Why This Matters

This isn't just about counting numbers. By knowing the luminosity instantly and accurately, the LHCb experiment can:

1. Level the Beam: If the machine gets too bright, the system can automatically adjust the beams to keep the "flash" steady, protecting the delicate equipment.
2. Catch Rare Events: Physicists can trust that when they see a rare particle, it's not just a glitch in the measurement.
3. Save Time: It works in real-time, meaning scientists don't have to wait days to analyze the data to know how the experiment is running.

In short, the LHCb team built a super-fast, self-calibrating counter inside their camera, allowing them to measure the intensity of the universe's most energetic collisions with the precision of a master watchmaker.

Technical Summary

1. Problem Statement

The LHCb experiment at CERN operates under a "luminosity levelling" scheme, where the instantaneous luminosity is kept constant to optimize data collection. For Run 3 (starting in 2022/2024), the experiment underwent a major upgrade to handle a fivefold increase in instantaneous luminosity ($2 \times 10^{33} \text{ cm}^{-2}\text{s}^{-1}$).

• The Challenge: Reliable real-time measurement of instantaneous luminosity with a precision of at least 5% is essential for the LHC beam steering and luminosity levelling feedback loop.
• Limitations of Previous Methods: In Run 1 and Run 2, luminosity was measured using the calorimeter (L0 trigger) or dedicated detectors like PLUME. However, the removal of the hardware L0 trigger in Run 3 and the need for faster, more robust monitoring required new approaches. Existing methods based on currents or specific sub-detectors often lack the granularity or flexibility required for the new triggerless readout architecture.
• Goal: Develop a luminosity measurement method that operates directly at the detector readout level (Firmware/FPGA), independent of the high-level software trigger, with high time granularity and robustness against saturation.

2. Methodology

The proposed method utilizes the Vertex Locator (VELO) silicon pixel detector, which is the innermost tracking detector closest to the interaction point.

A. Real-Time Hit Reconstruction

• FPGA Implementation: The upgraded LHCb readout boards (TELL40) contain Intel Arria-10 FPGAs. A custom 2D clustering algorithm is embedded directly into the firmware.
• Process: Instead of waiting for offline reconstruction, the firmware reconstructs "hits" (clusters of neighboring active pixels) at the full LHC beam-crossing rate of 40 MHz.
• Output: This generates a stream of reconstructed clusters (approx. $10^{11}$ hits/s) available in real-time for luminosity estimation.

B. Luminosity Counters

The system implements an array of 208 cluster counters within the FPGA firmware, distributed across the 26 VELO layers (4 inner and 4 outer regions per layer).

• Accumulation Regions: Counters are defined in specific radial zones (Inner $\approx$ 14 mm, Outer $\approx$ 26 mm from the beam axis) to minimize hit merging (saturation) effects.
• Collision Types: The system distinguishes between four bunch-crossing types based on the LHC filling scheme:
  • bb: Beam-beam (both bunches filled).
  • be/eb: Beam-empty (one bunch filled).
  • ee: Empty-empty (neither filled).
• Estimation Algorithms:
  1. Average Method (Primary): Counts the number of reconstructed clusters ($c$) for each collision type. The visible interaction rate $\mu_{vis}$ is calculated by subtracting background contributions:
     $$\mu_{vis} = \frac{c_{bb}}{N_{bb}} - \frac{c_{be}}{N_{be}} - \frac{c_{eb}}{N_{eb}} + \frac{c_{ee}}{N_{ee}}$$
  2. Log0 Method (Cross-check): Counts "empty events" (events with zero clusters) to derive $\mu_{vis} = -\ln(P(0))$. This is robust against saturation but sensitive to Poisson distribution assumptions.
  3. Per-BXID: Counts empty events for specific bunch-crossing identifiers (BXID) to monitor individual bunch pairs.

C. Data Processing & Calibration

• Running Mean: To manage memory and provide stable readings, a running mean is calculated in the FPGA using parameters $N$ (number of events) and $\lambda$ (weighting factor). The system updates the mean every $\sim$90 ms and is read out by the Experiment Control System (ECS) every 3 seconds.
• Global Estimator: The 208 individual counters are combined into a single global luminosity estimator using a trimmed mean (discarding the top and bottom 15% of values) to reject outliers and noisy channels.
• Calibration: The visible cross-section ($\sigma_{vis}$) is determined using van der Meer (vdM) scans, where beams are displaced transversely to measure the overlap integral.

3. Key Contributions

• First Real-Time FPGA Clustering: Successfully implemented a full 2D clustering algorithm on the VELO readout FPGAs, enabling luminosity monitoring directly at the detector level without relying on the software trigger farm.
• Background Subtraction at Readout: Developed a robust method to subtract beam-gas and beam-background contributions (using $be$, $eb$, and $ee$ counters) directly in the firmware logic.
• Trimmed-Mean Global Estimator: Introduced a statistical combination strategy that dynamically excludes outliers, significantly improving stability compared to simple arithmetic means.
• Beam-Position Correction: Demonstrated a method to correct luminosity measurements based on the real-time position of the luminous region (specifically the $z$-axis shift), reducing systematic uncertainties.

4. Results

The method was validated using data from the 2024 physics run (both proton-proton and lead-lead collisions).

• Statistical Resolution:
  • Achieves a statistical resolution better than 1% (specifically $\sim$0.27% in stable conditions, scaling to $\sim$0.01% at nominal luminosity due to high statistics).
  • The trimmed mean reduces the spread of measurements from $\sim$2.2% (all counters) to $\sim$1.0% (outer counters only).
• Linearity:
  • The method shows excellent linearity up to $\mu_{vis} \approx 7.7$ (significantly above the nominal Run 3 operating point of $\sim$5.3).
  • Nonlinearity coefficients are compatible with zero: $g_{nl} \approx (0.02 \pm 0.22)\%/\mu_{vis}$ for the average method.
  • Saturation effects are negligible in the chosen accumulation regions.
• Stability:
  • Over a two-week period in July 2024, the ratio between the VELO-hit estimator and the official PLUME luminometer was stable within 0.5%.
  • After applying beam-position corrections, the stability improved to 0.3%.
• Heavy-Ion (PbPb) Performance:
  • The method is applicable to Lead-Lead collisions, despite the much higher occupancy ($\sim$70x higher than pp).
  • While the average method is preferred for linearity, the system remains linear even in high-occupancy scenarios due to the low interaction rate of PbPb collisions ($\mu \sim 10^{-3}$).
• Availability:
  • The system has an availability of ~93% of stable beam time, with only ~2% intrinsic inefficiency due to VELO movement and self-consistency checks.

5. Significance

• Operational Reliability: This method provides a critical, independent, and fast luminosity monitor essential for the LHCb luminosity levelling feedback loop, ensuring the experiment operates at optimal efficiency.
• Independence: It offers a measurement independent of the calorimeter and the PLUME detector, allowing for cross-calibration and increased robustness against single-detector failures.
• Scalability: The firmware-based approach is highly flexible. The accumulation regions and integration parameters can be reconfigured to adapt to different running conditions or to measure other quantities (e.g., real-time beam-spot position).
• Future Impact: The successful implementation of real-time clustering on FPGAs sets a precedent for future upgrades in high-luminosity environments, demonstrating that complex reconstruction tasks can be offloaded to the detector front-end to reduce latency and bandwidth requirements.

In conclusion, the paper presents a highly effective, real-time luminosity determination method that meets the stringent precision and stability requirements of the LHCb Run 3 physics program, successfully bridging the gap between raw detector data and high-level physics monitoring.