VecAmpFit: vectorized amplitude-analysis fitting library

The paper introduces VecAmpFit, a new vectorized library designed for multidimensional amplitude analyses in high-energy physics, featuring explicit gradient calculation and simultaneous multi-dataset fitting capabilities for the Belle II experiment.

The Gist

Imagine you are a detective trying to solve a massive, chaotic crime scene. The "crime" is a particle collision in a high-energy physics experiment (like at the Belle II lab). When particles smash together, they break apart into a shower of smaller particles, flying off in all directions.

Your job is to figure out exactly how they broke apart. Did they break into a specific pattern? Was there a hidden, short-lived "ghost" particle in the middle that we can't see directly?

To solve this, physicists use a method called Amplitude Analysis. It's like trying to reconstruct a shattered vase by looking at the shards and guessing the original shape, the force of the blow, and the material it was made of.

The Problem: The Math Mountain

The paper describes a new tool called VecAmpFit. To understand why it's needed, imagine the math involved in this reconstruction.

Every time a particle decays, there are millions of possible ways it could happen. To find the "true" story, physicists have to run a simulation millions of times, comparing their guesses against real data.

• The Old Way: Imagine trying to count every grain of sand on a beach, one by one, using a tiny spoon. You calculate the probability for Event #1, then Event #2, then Event #3... It takes forever. The computer gets tired, and the scientists have to wait days for results.
• The Bottleneck: The hardest part is calculating the "normalization." This is like checking if your guess covers the entire beach, not just the spot you're standing on. Doing this calculation for every single event is incredibly slow.

The Solution: The Super-Team (VecAmpFit)

VecAmpFit is a new software library designed to speed this up. The authors, Kirill Chilikin and colleagues, built it to be a "vectorized" powerhouse.

Here is the analogy:

• The Old Way (Scalar): You are a single worker carrying one brick at a time to build a wall. You place it, check the level, place the next one.
• The New Way (Vectorized): You are now a construction crew with a forklift. Instead of carrying one brick, the forklift grabs a whole pallet of 8, 16, or 32 bricks at once and places them all simultaneously.

In computer terms, VecAmpFit processes data in "vectors" (groups of numbers) rather than one number at a time. It uses the modern computer's ability to do many math operations in a single instant (called SIMD instructions).

How It Works (The Toolkit)

The paper details how this library is built:

1. The Fitter: This is the brain. It takes the data and tries to adjust the "knobs" (parameters) of the model until the simulation matches the real data perfectly.
2. The Vectorized Subroutines: These are the specialized tools. Instead of writing code to calculate the speed of one particle, the library has tools that calculate the speed of 32 particles at once.
3. Gradient Calculation: Imagine you are blindfolded on a hill, trying to find the bottom (the best solution).
   • Without gradients: You take a step, feel if it's lower, then take another step. It's slow.
   • With gradients: You have a map that tells you exactly which way is "down" and how steep the slope is. You can take giant, confident strides straight to the bottom. VecAmpFit allows users to calculate these "gradients" explicitly to speed up the search.
4. Simultaneous Fitting: Sometimes you have data from different experiments (like different energy levels). VecAmpFit can solve all these puzzles at the same time, rather than solving them one by one.

The Results: A Speed Demon

The authors tested VecAmpFit against two other popular tools:

• Laura++: A standard, reliable tool (like a very good sedan).
• TensorFlowAnalysis2: A modern, AI-based tool (like a futuristic electric car).

On a standard computer (CPU):
VecAmpFit was 4 to 5 times faster than the standard tool (Laura++) and more than 10 times faster than the AI tool (TensorFlow). It was like switching from a bicycle to a sports car. The "vectorized" approach of carrying 32 bricks at once paid off huge dividends.

On a Graphics Card (GPU):
Here, the story flips. The AI tool (TensorFlow) is built specifically for graphics cards (GPUs), which are designed for massive parallel processing. VecAmpFit is still learning how to use GPUs effectively. In this specific test, the AI tool was faster. However, the authors note that VecAmpFit's GPU support is still "experimental" and they plan to improve it.

Why Does This Matter?

In high-energy physics, time is data. The faster you can analyze the data, the more experiments you can run, and the more likely you are to discover something new—like a new type of exotic particle or a hidden law of the universe.

VecAmpFit is essentially a high-performance engine for these scientific detectives. It doesn't change the laws of physics, but it gives the scientists the speed and power to see the universe's secrets much faster than before.

In a nutshell: The authors built a super-fast calculator that processes groups of data simultaneously, allowing physicists to solve complex particle puzzles in a fraction of the time it used to take.

Technical Summary

1. Problem Statement

Amplitude analysis in high-energy physics (HEP) involves fitting complex decay models to experimental data to determine particle properties (masses, widths, quantum numbers). These analyses are computationally intensive due to:

• High Dimensionality: Multidimensional phase spaces (often 3+ dimensions) require extensive numerical integration to calculate signal density normalization.
• Complexity: The signal density involves coherent sums of complex amplitudes, requiring repeated evaluation of Breit-Wigner functions, form factors, and angular distributions.
• Optimization Needs: Standard imperative programming approaches (e.g., C++, Fortran) often fail to fully utilize modern CPU vectorization capabilities (SIMD) or efficient gradient-based minimization, leading to long fitting times.
• Existing Limitations: While declarative frameworks (e.g., TensorFlow-based) offer ease of use and automatic differentiation, they can suffer from overhead on CPUs. Conversely, existing imperative frameworks (e.g., Laura++, AmpTools) often lack explicit vectorization and require manual optimization for performance.

2. Methodology

The authors developed VecAmpFit, a hybrid imperative programming library designed to maximize performance through explicit vectorization and manual optimization.

• Architecture & Language:

  • Hybrid Approach: The core amplitude calculations are implemented in Fortran 2018 for performance, while the general fit control and data handling are managed via C++.
  • Vectorization: The library operates on fixed-length data vectors (e.g., $L=1, 2, 4, \dots, 64$). Data storage and amplitude calculations are explicitly vectorized to exploit SIMD (Single Instruction, Multiple Data) instructions (AVX).
  • Buffering: To minimize redundant calculations, the library uses "event buffers" (pre-calculated kinematic variables) and "parameter buffers" (values depending only on fit parameters). These are filled once per likelihood call.

• Fitting Formalism:

  • Unbinned Maximum Likelihood: Supports standard and extended unbinned likelihood fits.
  • Normalization: Implements three methods for calculating signal density normalization integrals:
    1. Monte Carlo (MC): Uses weighted MC events.
    2. Grid Integration: Uses user-defined grid points with Jacobian weights.
    3. Formula Integration: Symbolic integration (limited to simple cases without efficiency).
  • Gradient Calculation: Supports explicit gradient calculation. Users must manually implement the gradient of the signal density, which allows for faster convergence (fewer minimization steps) compared to numerical differentiation, though it increases implementation effort.
  • Simultaneous Fitting: Capable of fitting multiple datasets (e.g., different beam energies or decay channels) simultaneously, sharing common parameters while allowing dataset-specific variations.

• Implementation Details:

  • Code Generation: A build-time tool (vecampfit-fortran) parses Fortran code to generate C headers, interfaces, and documentation.
  • Parallelism: Supports multi-threading via OpenMP. GPU offloading via OpenACC is experimental.
  • Arbitrary Precision: Includes a custom arbitrary-precision arithmetic library for calculating mathematical constants and integration points to ensure numerical stability.

3. Key Contributions

• VecAmpFit Library: A new, open-source (Apache 2.0) library providing a high-performance framework for multidimensional amplitude analysis.
• Explicit Vectorization Strategy: Unlike declarative frameworks that rely on backend optimization, VecAmpFit forces vectorization at the data structure level (separate real/imaginary arrays for complex numbers) to achieve near-optimal CPU utilization.
• Hybrid Workflow: Demonstrates a workflow combining C++ for orchestration and Fortran for heavy numerical lifting, bridging the gap between legacy HEP code and modern performance requirements.
• Comprehensive Toolset: Includes subprograms for kinematics, special functions (Blatt-Weisskopf, Wigner d-functions), statistical tests, and Monte Carlo generation.

4. Results & Performance Evaluation

The authors benchmarked VecAmpFit against two other frameworks: Laura++ (imperative) and TensorFlowAnalysis2 (TFA2) (declarative).

• Comparison with Laura++ (Imperative):

  • Test Case: $B^+ \to K^+K^+K^-$ Dalitz analysis.
  • Result: VecAmpFit was 4 to 5 times faster than Laura++ on both test machines.
  • Factors: The speedup is attributed to vectorization and efficient memory access patterns. Link-Time Optimization (LTO) provided an additional 1.3–1.8x speedup.

• Comparison with TFA2 (Declarative):

  • Test Case: $D^0 \to K^-\pi^+\pi^0$ Dalitz analysis.
  • CPU Performance: VecAmpFit was more than an order of magnitude (10x–20x) faster than TFA2 on CPU. TFA2 suffered from overhead associated with the TensorFlow backend and JIT compilation on CPU.
  • GPU Performance: The results reversed on GPU. TFA2 was ~10 times faster than VecAmpFit. VecAmpFit's GPU offloading is currently experimental and limited by compiler issues (OpenACC vector loops) and lack of mature GPU optimization.

• Vector Length Sensitivity:

  • Performance peaks when the vector length matches the CPU's vector register size (e.g., 8 for double-precision AVX).
  • Optimal vector lengths found were 16 (single precision) and 8 (double precision) for the tested hardware.

5. Significance

• Efficiency for Large Datasets: VecAmpFit addresses the critical bottleneck of computational time in modern HEP experiments (like Belle II), enabling faster analysis of large datasets and more complex models.
• Flexibility vs. Performance: It offers a middle ground: it retains the flexibility of imperative programming (allowing custom models and explicit control) while achieving performance levels that typically require declarative frameworks or massive parallelization.
• Future Outlook: While currently superior on CPUs, the authors acknowledge the need to improve GPU support to compete with declarative frameworks in heterogeneous computing environments. The library is specifically tailored for the needs of the Belle II experiment but is applicable to any high-energy physics amplitude analysis.

In summary, VecAmpFit represents a significant step forward in optimizing amplitude analysis by prioritizing explicit vectorization and manual gradient implementation, delivering substantial speedups on CPU hardware compared to existing solutions, albeit with a higher implementation cost for the user.