⚛️ high-energy experiments

GPU-accelerated spectrum reweighting for new-physics searches in solar neutrino--electron scattering

This paper presents a GPU-accelerated spectrum-reweighting framework that significantly accelerates likelihood evaluations for new-physics searches in solar neutrino--electron scattering by applying bin-to-bin weights to precomputed recoil spectra, thereby eliminating the need for costly detector Monte Carlo regeneration at each parameter point and enabling interactive parameter scans on a single workstation.

Original authors: Guangbao Sun, Xuefeng Ding, Liang Sun, Xiang Zhou

Published 2026-07-02

📖 4 min read🧠 Deep dive

CC BY 4.0

Original authors: Guangbao Sun, Xuefeng Ding, Liang Sun, Xiang Zhou

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a detective trying to solve a mystery: Is there new, hidden physics hiding inside the way solar neutrinos bounce off electrons?

To find the answer, scientists need to compare what they expect to see (based on our current understanding of the universe, called the Standard Model) with what they actually see in their detectors. The problem is that the "new physics" they are looking for (like strange new forces or a magnetic moment for the neutrino) changes the shape of the data in very subtle ways.

The Old Problem: The "Re-baking" Bottleneck

In the past, to test a new theory, scientists had to do something incredibly slow and expensive: re-bake the cake.

They would run massive computer simulations (called Monte Carlo) to model how a detector works. This is like baking a cake from scratch, measuring every crumb.
If they wanted to test a slightly different theory (changing one number in the recipe), they couldn't just tweak the existing cake. They had to start over, bake a whole new cake from scratch, and measure it again.
Since there are millions of possible theories to test, this meant baking millions of cakes. It took so long that scientists could barely scan a few options before their computers gave up.

The New Solution: The "Magic Filter"

The authors of this paper, Guangbao Sun and his team, built a GPU-accelerated spectrum reweighting framework. Think of this as a magic filter or a digital overlay.

Instead of baking a new cake every time, they bake one perfect "Standard Model" cake (a baseline simulation) and keep it safe.

The Filter: When they want to test a new theory, they don't bake a new cake. Instead, they take the original cake and run it through a special filter.
The Reweighting: This filter applies a "weight" to different parts of the cake. If the new theory says "there should be more crumbs here," the filter adds weight to that section. If it says "fewer crumbs there," it removes weight.
The Result: In seconds, they get a "new" cake that looks exactly like what the new theory would have produced, without ever having to re-bake the whole thing.

The Supercharger: Using GPUs

To make this filter work even faster, they used GPUs (Graphics Processing Units).

The CPU (The Chef): A standard computer processor is like a master chef who can do one complex task perfectly but slowly.
The GPU (The Army of Sous-Chefs): A GPU is like a kitchen with thousands of tiny sous-chefs working in perfect unison.

The authors wrote their code so that instead of one chef checking the whole cake, thousands of sous-chefs check tiny slices of the cake simultaneously. This allows them to apply the "magic filter" to the entire dataset in a fraction of a second.

The Results: Speed and Accuracy

The paper reports some impressive numbers:

Speed: On a standard, powerful computer chip (CPU), checking one theory took about 52 seconds (if you used all 64 cores). On a consumer-grade graphics card (like an RTX 3080 Ti), it took only 87 milliseconds. On a super-fast datacenter card (A30X), it took just 52 milliseconds.
The Real Win: The biggest speedup didn't actually come from the graphics card itself. It came from stopping the "re-baking." By avoiding the need to regenerate the massive detector simulation for every single test, they sped up the process by thousands of times compared to the old method. The GPU just made the "filtering" part even faster on top of that.
Accuracy: They tested their method against a known mathematical truth (an "analytic reference"). The difference between their "filtered" cake and the "real" cake was so tiny (less than 0.000001%) that it was effectively perfect.

The Bottom Line

This paper presents a tool that lets physicists interactively search for new physics. Instead of waiting days or weeks to run a scan, a scientist can now sit at their desk, tweak a parameter, and see the results instantly.

It's like going from waiting for a mail-order catalog to arrive every time you want to see a new outfit, to having a virtual mirror where you can instantly try on thousands of different looks. This allows them to explore the universe of possibilities much more thoroughly and quickly than ever before.

Technical Summary: GPU-Accelerated Spectrum Reweighting for Solar Neutrino–Electron Scattering

Problem Statement
Precision measurements of solar neutrino–electron elastic scattering serve as sensitive probes for Beyond-the-Standard-Model (BSM) physics, including Non-Standard Interactions (NSIs) and anomalous neutrino magnetic moments. These new physics effects modify the differential cross section, altering both the event rate and the spectral shape of the recoil electrons. In conventional likelihood analyses, testing a new physics hypothesis requires propagating a modified recoil spectrum through a detector-response model derived from full Monte Carlo (MC) simulations (e.g., Geant4). This process is computationally prohibitive when performed for every point in a multi-dimensional parameter space, as regenerating detector-level MC samples for each parameter variation dominates the cost of fits, scans, and Markov-chain Monte Carlo studies.

Methodology
The authors propose a GPU-accelerated spectrum-reweighting framework that decouples the physics parameter variation from the detector simulation. The core methodology relies on the following steps:

Factorization Assumption: The framework assumes that the detector response for a recoil electron of a given kinetic energy $T$ is independent of the underlying interaction (Standard Model, NSI, or magnetic moment). Consequently, a single baseline MC sample generated under the Standard Model (SM) hypothesis suffices to define the mapping between true recoil energy and reconstructed observables (e.g., photoelectrons).
Bin-to-Bin Reweighting: Instead of regenerating MC samples, the method applies multiplicative weights to the recoil-energy spectrum bins. For a set of new physics parameters $\varepsilon$ , the predicted recoil spectrum is calculated as $f_T(T; \varepsilon) = r(T; \varepsilon) \cdot \hat{f}^{SM}_T(T)$ , where $r(T; \varepsilon)$ is the reweighting function derived from the modified differential cross sections.
Fixed Response Propagation: The reweighted spectrum is propagated through a precomputed, two-dimensional detector response matrix $R_{ij}$ (mapping true recoil bin $i$ to reconstructed observable bin $j$ ). This matrix, derived from Geant4, includes effects such as scintillation quenching, energy resolution, and reconstruction efficiency.
GPU Implementation: The calculation is implemented using NVIDIA's Thrust template library, utilizing parallel primitives (transform, reduce, transform-reduce). The code is written in a single source that compiles for both CUDA (GPU) and OpenMP (CPU) backends. The pipeline involves:
- Physics Update: Computing oscillation probabilities and differential cross sections on a discretized kinematic grid.
- MC Reweighting: Applying the reweighting function to the recoil spectrum and convolving it with the fixed response matrix.
- Likelihood Evaluation: Accumulating the predicted spectrum and evaluating the Poisson log-likelihood.

Key Contributions

Algorithmic Efficiency: The primary acceleration is achieved by avoiding the regeneration of detector-level MC samples for every parameter point. This reduces the computational cost of a parameter update from hours (full simulation) to milliseconds (reweighting).
Hardware Agnosticism: The framework is designed to run on both commodity consumer GPUs (e.g., NVIDIA RTX 3080 Ti) and datacenter accelerators (e.g., NVIDIA A30X), as well as multi-core CPUs, using a unified codebase.
Validation: The method is validated against an analytic reference where the exact solution is known. The reweighting prediction reproduces the analytic truth with an integral deviation below $10^{-6}$ for a 2000-bin recoil grid, confirming that the bin-level approximation introduces negligible error compared to the discretization scale.

Results

Performance Benchmarks:
- On a datacenter NVIDIA A30X GPU, a single likelihood evaluation takes approximately 52 ms. This represents a 58× speedup over a single CPU thread and a 2.5× speedup over a fully loaded 64-thread CPU.
- On a consumer NVIDIA RTX 3080 Ti, the evaluation takes approximately 87 ms, enabling interactive parameter scans on a single workstation.
Accuracy: The framework successfully recovers injected parameters in end-to-end "injection-recovery" tests for both flavor-diagonal NSIs and neutrino magnetic moments. The steep $1/T$ dependence of the magnetic moment cross section, which poses a stringent test for binning accuracy, is handled with high precision.
Scalability: The GPU implementation scales efficiently, with the computational bottleneck being the repeated application of the response kernel, which is naturally parallelized across reconstructed-energy bins.

Significance and Claims
The paper claims that this framework enables interactive parameter scans for solar neutrino–electron scattering analyses on hardware accessible to individual researchers. The authors emphasize that the principal acceleration stems from the algorithmic strategy of avoiding MC regeneration rather than solely from GPU hardware acceleration. While the GPU provides a further factor of speedup over multi-core CPUs, the method's value lies in making high-fidelity detector modeling feasible within iterative fitting loops that were previously computationally intractable.

The scope is explicitly limited to scenarios where new physics can be represented as a reweighting of an existing recoil spectrum (e.g., flavor-diagonal NSIs and magnetic moments) while the detector response remains fixed. The authors note that scenarios involving qualitatively different final-state particles or flavor-changing structures would require additional formalism. The work serves as a methods study, validated on synthetic analytic responses and Geant4-derived matrices, without utilizing specific experimental data sets.