A High Performance Partial Wave Analysis Framework for Hadron Spectroscopy

arXiv:2608.25963 · hep-ex · Submitted 2026-08-26 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: High Energy Physics: Experiment. The day in high-energy experiment: detectors, searches and limits.

Kai: I'm Kai.

Mira: And I'm Mira, here with Lev.

Kai: We're looking at the paper: "A High Performance Partial Wave Analysis Framework for Hadron Spectroscopy".

Mira: Here's the gist of the paper. Partial wave analysis (PWA) is a key method in hadron physics for extracting the properties of hadronic resonances This framework addresses the main limitations of conventional unbinned maximum-likelihood fits, where repeated event-by-event amplitude evaluation leads to large time and memory costs, especially for samples of 105–106 events and models with many interfering amplitudes.

Kai: Framework Overview The CTPWA framework is a high performance PWA framework based on covariant tensor formalism The method exploits the factorization of the covariant tensor amplitude formalism.

Mira: The key observation underlying the method is that a substantial part of the decay amplitude is determined solely by the event kinematics and the decay topology, and is thus independent of the fit parameters.

Kai: This allows kinematic building blocks to be precomputed once and reused throughout the fit, while only resonance propagators and coupling combinations need to be updated during minimization.

Paper summary: Kai: So, to recap this paper on "A High Performance Partial Wave Analysis Framework for Hadron Spectroscopy," the central thesis is that conventional partial wave analysis methods struggle with memory usage and speed as experimental statistics increase >

Mira: They present CTPWA, which is their high performance PWA framework based on the covariant tensor formalism. They claim this method addresses those difficulties by adopting extensive precomputation and caching mechanisms >

Kai: The paper's main claim is that by exploiting the factorization of the covariant tensor amplitude formalism, a substantial part of the decay amplitude becomes independent of the fit parameters >

Mira: This means kinematic building blocks can be precomputed once and reused, leaving only resonance propagators and coupling combinations to be updated during minimization >

Lev: So they are essentially separating what’s fixed from what’s variable in the fitting process, which is a smart way to structure the problem computationally >

Kai: And they achieve this by casting the likelihood into a compact matrix form so that both its gradient and Hessian follow analytically, avoiding the overhead of graph-based automatic differentiation >

Mira: This analytical handling of derivatives is what leads to those performance gains, allowing them to run the likelihood evaluation and minimization entirely on the GPU >

Lev: That’s where I start looking at it from a hardware perspective. Running everything on the GPU means we eliminate those slow host-device transfers, which is crucial when you're dealing with large data streams >

Kai: They emphasize that this optimization allows high-statistics partial-wave analysis to become feasible at experiments like BESIII >

Mira: So, the paper is focused on showing a practical framework that makes fitting these complex systems fast enough for modern high-precision experiments in hadron physics >

Conclusion: Kai: Looking at the full title, "A High Performance Partial Wave Analysis Framework for Hadron Spectroscopy," it clearly signals that this isn't just a minor tweak to an old method >

Mira: No, it suggests they’ve built a whole new way to structure the analysis specifically to handle the computational demands of modern hadron spectroscopy data sets >

Lev: It’s about moving away from iterative calculations for every event and toward a precomputed, highly optimized structure that leverages the geometry of the kinematics >

Kai: What this means for someone listening who isn't in physics is that we can finally analyze massive datasets from these experiments in a way that actually scales computationally without immediately crashing the system >

Mira: The implication is that this framework makes high-statistics partial wave analysis practically accessible for researchers at places like BESIII or LHCb, which rely on extracting subtle resonance properties >

Lev: And the authors are essentially showing how to make complex theoretical frameworks usable in a way that respects the reality of modern computational hardware, which is what we build things for anyway >

Institute of High Energy Physics, Chinese Academy of Sciences · University of Chinese Academy of Sciences · School of Physics, Henan Normal University

hep-ex

Submitted: 2026-08-26

Updated: 2026-11-06

Journal ref: Chin. Phys. C \textbf 51, no.1,013003 (2027)

DOI: 10.1088/1674-1137/aeb254

Code: https://github.com/BHXiang/ctpwa

License: http://creativecommons.org/licenses/by/4.0/

Importance score: 87/100

The gist: Partial wave analysis (PWA) is a key method in hadron physics for extracting the properties of hadronic resonances This framework addresses the main limitations of conventional unbinned…

Key concepts

Partial Wave Analysis (PWA)
A method used in hadron physics to extract the properties of resonances by analyzing the decay of particles. It involves fitting experimental data using a model composed of various interfering amplitudes, which is then broken down into individual 'partial waves' representing different angular momentum states.
Covariant Tensor Formalism
The mathematical framework used in CTPWA that exploits the factorization of the covariant tensor amplitude formalism. This approach allows the method to separate kinematic building blocks—which depend only on event geometry—from resonance parameters, simplifying computation and allowing precomputation.
GPU Acceleration
A computational strategy where all likelihood calculations, derivatives, and minimization loops are implemented entirely on a Graphics Processing Unit (GPU). This eliminates slow host-device data transfers between the CPU and GPU, significantly speeding up the fitting process for large datasets.
Negative Log-Likelihood (NLL)
A function used to quantify how well a theoretical model describes experimental data. Minimizing this value helps determine the best set of parameters for the resonance model by finding where the model's predicted intensity matches the observed event distribution.

Terminology

Summary

Partial wave analysis (PWA) is a key method in hadron physics for extracting the properties of hadronic resonances This framework addresses the main limitations of conventional unbinned maximum-likelihood fits, where repeated event-by-event amplitude evaluation leads to large time and memory costs, especially for samples of 105–106 events and models with many interfering amplitudes. p. 6

Where the paper says it

5 Summary We have developed CTPWA, a GPU-oriented partial wave analysis framework for high-statistics hadron spectroscopy. It addresses the main limitations of conventional unbinned maximum-likelihood fits, where repeated event-by-event amplitude evaluation leads to large time and memory costs, especially for samples of 105–106 events and models with many interfering amplitudes.

Framework Overview

The CTPWA framework is a high performance PWA framework based on covariant tensor formalism The method exploits the factorization of the covariant tensor amplitude formalism. The key observation underlying the method is that a substantial part of the decay amplitude is determined solely by the event kinematics and the decay topology, and is thus independent of the fit parameters. p. 1

Where the paper says it

To address the difficulties above, the framework adopts extensive precomputation and caching mechanisms, as well as fully GPU-based likelihood computation and minimization. The key observation underlying the method is that a substantial part of the decay amplitude is determined solely by the event kinematics and the decay topology, and is thus independent of the fit parameters: these kinematic building blocks can be precomputed once and reused throughout the fit, and only the resonance propagators and the coupling combinations need to be updated during minimization.

This allows kinematic building blocks to be precomputed once and reused throughout the fit, while only resonance propagators and coupling combinations need to be updated during minimization. p. 1
Where the paper says it

To address the difficulties above, the framework adopts extensive precomputation and caching mechanisms, as well as fully GPU-based likelihood computation and minimization. The key observation underlying the method is that a substantial part of the decay amplitude is determined solely by the event kinematics and the decay topology, and is thus independent of the fit parameters: these kinematic building blocks can be precomputed once and reused throughout the fit, and only the resonance propagators and the coupling combinations need to be updated during minimization.

Computational Optimization

CTPWA implements two key strategies to overcome memory and CPU–GPU communication challenges. First, all parameter-independent kinematic quantities are precomputed and cached once, so that the device memory usage is fixed before the fit starts and no kinematic factor is ever recomputed Second, the entire likelihood, its analytic derivatives and the minimization loop are implemented entirely on the GPU. p. 2

Where the paper says it

First, all parameter-independent kinematic quantities are precomputed and cached once, so that the device memory usage is fixed before the fit starts and no kinematic factor is ever recomputed. Second, the entire likelihood, its analytic derivatives and the minimization loop are implemented entirely on the GPU, eliminating host–device transfers, kernel-launch and graph-tracing overheads, and per-iteration allocations.

This eliminates host–device transfers and kernel-launch overheads. p. 2
Where the paper says it

First, all parameter-independent kinematic quantities are precomputed and cached once, so that the device memory usage is fixed before the fit starts and no kinematic factor is ever recomputed. Second, the entire likelihood, its analytic derivatives and the minimization loop are implemented entirely on the GPU, eliminating host–device transfers, kernel-launch and graph-tracing overheads, and per-iteration allocations.

Likelihood Construction

The negative log-likelihood is minimized by evaluating the intensity at data events and normalizing the model to the phase-space integral. The event intensity is expressed as a quadratic form in the coupling parameters θc, I(x;θ)=XλθaAλ/2=θ†aBθa, B≡XλA∗λATλ, (7). p. 3

Where the paper says it

Chinese Physics C Vol. x (2026) xxx event intensity becomes a quadratic form in the coupling parameters θc, I(x;θ)=X λ θaAλ 2 =θ † aBθa, B≡ X λ A∗ λAT λ , (7) where B is an Nch×Nch Hermitian positive-semidefinite matrix per event.

The phase-space contribution to the likelihood and its derivatives costs a single O(N 2ch) operation per iteration. p. 3
Where the paper says it

(4) is obtained from the element-wise logarithms of the resulting intensities. For the phase-space normalization, the per-event matrices are pre-averaged once, B¯ = 1 Nphsp NXphsp j=1 Bj , (8) so that the phase-space contribution to the likelihood and its derivatives costs a single O(N 2 ch) operation per iteration, independent of Nphsp.

Performance Gains

The optimized formulas compute the NLL and the gradient for 106 events in about 2 ms, compared to GPU autograd and CPU autograd. The analytic Hessian is faster by about two orders of magnitude relative to GPU autograd. p. 6

Where the paper says it

For synthetic samples with 106 events, the optimized implementation evaluates the negative log-likelihood and gradient in a few milliseconds, about one order of magnitude faster than GPU autograd and more than three orders of magnitude faster than CPU autograd. The analytic Hessian is faster by about two orders of magnitude relative to GPU autograd and more than four orders of magnitude relative to CPU autograd.

This single-pass accumulation replaces the O(Nparams) backward passes required by automatic differentiation. p. 5
Where the paper says it

75 s for GPU autograd and 75 s for CPU autograd, factors of about 122 and about 1. The single-pass accumulation replaces the O(Nparams) backward passes of automatic differentiation, and this is what makes Hessian-based uncertainty estimation practical at high statistics.

The complete high-statistics amplitude fit is thus completed within minutes. p. 6
Where the paper says it

The model accurately reproduces the resonant structures across the full kinematic range, the residuals are consistent with statistical fluctuations, and the fitted parameters agree with the generated input values. A complete high-statistics amplitude fit is thus completed within minutes, a performance scale that comfortably meets the typical requirements of BESIII partial-wave analyses.

Demonstration Results

A fit with fixed resonance parameters converges within seconds A complete single fit with floating resonance parameters completes in about 102 seconds. The fitted projections reproduce the generated distributions well, and the extracted parameters are consistent with the input values. p. 7

Where the paper says it

A fit with fixed resonance parameters converges within seconds, while a fit with floating resonance parameters completes in about 102 seconds. The fitted projections reproduce the generated distributions well, and the extracted parameters are consistent with the input values.

These results show that CTPWA offers an efficient solution to the computation challenges for large-scale PWA at modern experiments such as BESIII and LHCb. p. 7
Where the paper says it

The fitted projections reproduce the generated distributions well, and the extracted parameters are consistent with the input values. These results show that CTPWA offers an efficient solution to the computation challenges for large-scale PWA at modern experiments such as BESIII and LHCb.

The framework is publicly available at https://github. p. 7
Where the paper says it

12225509, 12235017; the Strategic Priority Research Program of Chinese Academy of Sciences under Grant XDA0480600. 7 Program availability The CTPWA framework described in this paper is publicly available at https://github.

com/BHXiang/ctpwa. p. 7
Where the paper says it

7 Program availability The CTPWA framework described in this paper is publicly available at https://github. com/BHXiang/ctpwa.

Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.

Improvements for AI systems

  1. Optimized AI systems can perform high-statistics partial-wave analysis for hadron spectroscopy by utilizing CTPWA to accelerate fitting speeds by two orders of magnitude relative to autograd-based GPU PWA programs. This allows for feasible analysis at highprecision experiments like BESIII, even with large event samples reaching 105–106.

  2. The improved system can handle memory exhaustion during large sample fits by adopting the CTPWA strategy where all parameter-independent kinematic quantities are precomputed and cached once, so that the device memory usage is fixed before the fit starts. This ensures that no allocation occurs during the optimization and avoids device exhaustion encountered in conventional iterative amplitude recomputation.

  3. The AI can execute likelihood evaluation, its analytic derivatives, and minimization entirely on the GPU to eliminate overheads like host–device transfers, kernel-launch and graph-tracing overheads. This is achieved by expressing the negative log-likelihood as a batched dense linear algebra over the event dimension, mapping computations onto optimized matrix kernels.

  4. The system can achieve significantly faster gradient evaluation by avoiding the O(Nparams) backward passes required by automatic differentiation through analytic construction of derivatives, which are cross-checked against PyTorch autograd on the same likelihood, agreeing to machine precision. This allows for Hessian-based uncertainty estimation to be practical even at high statistics.

  5. The framework enables rapid convergence in complex fits; for a realistic test case like J/psi→K+K−η with one million events, the system can complete a fit in about 7 seconds with fixed resonance parameters or 102 seconds when resonance parameters float, meeting requirements for modern PWA analyses.

Abstract

Partial wave analysis (PWA) is a key method in hadron physics for extracting the properties of hadronic resonances. As experimental statistics grow, conventional implementations face severe difficulties in both memory usage and speed. We present CTPWA, a high performance PWA framework based on covariant tensor formalism. This framework adopts extensive precomputation and caching mechanisms, as well as fully GPU-based likelihood computation and minimization. With these optimization, the fitting speed is accelerated by two orders of magnitude relative to autograd-based GPU PWA programs, rendering high-statistics partial-wave analysis feasible at high-precision experiments like BESIII.

Sources

Related papers