WorksPhysics and Astronomy
Fourier Transforms of Color Glass Condensate Multi-Wilson-Line Correlators via Filon Quadrature
Abstract
Calculating cross sections in the Color Glass Condensate effective theory requires Fourier transforms of multi-Wilson-line correlators from transverse coordinate space to transverse momentum space. Under the common assumption of impact-parameter independence, each transform reduces to a set of Hankel transforms whose Bessel-function kernels oscillate rapidly at phenomenologically relevant momenta, making direct quadrature prohibitively expensive. We present a Filon-type quadrature, applicable to any integrand, that integrates these oscillatory factors in closed form on the stored coordinate grid, reducing each Hankel transform to a precomputed weight vector and the full nested transform chain to a sequence of matrix products. We develop and validate the method on the deep inelastic scattering dijet cross section beyond the correlation-limit approximation, where an exprel-based reformulation of the quadrupole Wilson-line correlator removes a numerical instability inherent to its standard parametrization. Porting the calculation to the Graphics Processing Unit (GPU), with custom CUDA kernels that fuse the momentum-space contraction directly into the correlator evaluation, brings the runtime for one dipole input down to about two minutes on a single NVIDIA A800, from several hours on a multi-core Central Processing Unit (CPU). We further generalize the algorithm to three sequential Hankel transforms and validate the resulting six-dimensional transform against an analytic Gaussian integrand family with closed-form results at every stage. This general, process-independent algorithm is directly applicable to next-to-leading-order proton-nucleus and electron-ion scattering cross-section calculations performed without the correlation-limit approximation. The code is publicly available at https://github.com/CCNU-CGC-py/FFT_filon.
Introduction
At high energy, the gluon density inside a hadron or nucleus grows rapidly and eventually saturates, giving rise to a new regime of strong-interaction dynamics governed by a large intrinsic momentum scale, the saturation scale . The Color Glass Condensate (CGC) effective theory provides a systematic framework for this regime: the dense small- gluon fields are treated as classical color fields radiated by fast color sources, and scattering off these fields is encoded in Wilson lines that resum multiple interactions with the target to all orders in the strong coupling. Observables such as inclusive and semi-inclusive cross sections in deep-inelastic scattering (DIS) and in proton-nucleus collisions are then expressed through correlators of these Wilson lines [1, 2, 3, 4, 5, 6, 7]. Because the underlying dynamics is formulated in transverse coordinate space, where the small- evolution equations for the correlators take their simplest form, while physical cross sections are measured differentially in transverse momentum, cross sections in momentum space are obtained by Fourier transforming these correlators from transverse coordinate space to transverse momentum space. Numerically, this places nested two-dimensional Fourier transforms of multi-point correlators at the center of CGC phenomenology [8, 9, 10, 11, 12, 13, 14].
A common and often adequate approximation is to neglect the impact-parameter dependence of the correlators, which restores rotational invariance and reduces each two-dimensional transform to a set of Bessel (Hankel) transforms of angular modes. Even so, the oscillatory nature of the Bessel functions at the large gluon momenta of phenomenological interest remains a serious numerical obstacle. For dijet correlations, going beyond the back-to-back correlation-limit approximation requires solving for the full four-point correlator and Fourier transforming it from coordinate to momentum space, which arises already at leading order and in the large- limit in DIS and in proton-nucleus collisions [10, 11, 15]. A few studies have tackled the numerical Fourier transform of the four-point Wilson-line correlator [12, 16], but only at relatively low transverse momenta, where the Bessel oscillations are still mild enough for direct quadrature; at larger the cancellations between neighboring oscillations degrade any fixed-order scheme. The complementary strategy has been the Factorized Dipole Approximation [17, 18, 19, 20], which simplifies the quadrupole into a product of dipoles and thereby bypasses the complicated Fourier transform. But this assumes that color fluctuations are independent and uncorrelated. It is valid only in the region , with the effective transverse area of the proton/nucleus, and it discards the genuinely connected multi-gluon correlations that are important for gluon saturation effects. Extending full CGC calculations to the higher- region relevant for comparison with experimental data therefore requires an efficient and accurate method for evaluating these multi-point Wilson-line correlator transforms across the full kinematic range.
This work develops a quadrature designed for exactly this problem: a Filon-type rule, applied directly on the stored coordinate grid, in which the oscillatory factors are integrated in closed form. This collapses every Hankel transform into a precomputable weight vector, so that each transform, and the full nested chain built from them, reduces to a sequence of matrix products. The method is formulated for the general case of three nested transforms and is independent of the specific form of the integrand. We develop and validate the method on one concrete observable, the deep inelastic scattering dijet cross section at full angle and at fixed photon virtuality [10, 11], for two reasons. First, it offers an easier testing ground compare to the proton-nucleus case: only two of the three coordinate integrals carry a momentum transfer, so every intermediate result can be saved and inspected for validation. Second, the dijet computation beyond the correlation limit is of direct physical interest in its own right, and the tables produced here feed a CGC event generator described in a companion paper [21]. The general three-momentum algorithm is nevertheless implemented in full and validated against an analytic integrand family with closed-form solutions.
The paper is organized as follows. § 2 sets up the dijet cross section, fixes the notation, and lays out the components of the calculation; § 3 assembles them into the CPU reference implementation; § 4 moves the expensive stage to the GPU, first keeping the inner table (§ 4.1) and then removing it altogether (§ 4.4); § 5 presents the extension of the algorithm to the general case of three sequential Hankel transforms, validated on an analytic family, with production use deferred to forthcoming proton-nucleus applications.
The deep-inelastic scattering di-parton cross section
Physical setup
We first consider inclusive di-parton (dijet) production in deep-inelastic scattering, , in the dipole picture of small- DIS. In light-cone perturbation theory the virtual photon of virtuality splits into a quark-antiquark pair carrying light-cone momentum fractions and of the photon. The pair then scatters eikonally off the strong color field of the target, picking up Wilson-line phases, before fragmenting into the final state hadrons. Because at the leading order, the splitting vertex appears once in the matrix element and once in its complex conjugate, the cross section involves the transverse dipole configuration in the matrix element and in its complex conjugate, together with an impact-parameter variable that separates the two dipoles’ centers. Eikonal scattering off the target correlates all four endpoints of these two dipoles, producing the four-Wilson-line (“quadrupole”) correlator that appears below. This process is also the standard tool for accessing the small- gluon Wigner distribution and gluon TMDs through dijet azimuthal correlations, and for constraining the dipole/quadrupole Wilson-line correlators that encode gluon saturation [11, 22, 23, 24].
Both photon transverse () and longitudinal () polarizations require the same type of integral, so let us denote the integrand as a function . In the case of DIS [11],
where
and the overall polarization prefactors and multiply the transverse and longitudinal results once at the end. The modified Bessel functions , and the scale are the familiar output of the light-cone wavefunction. The scale sets the characteristic transverse size of the fluctuation. Throughout this work, momentum variables and scales, including , , , and , are quoted in GeV, while transverse coordinate distances are quoted in . The functions and , with the angular factor for , arise from the spin structure of the longitudinally and transversely polarized photon vertices, respectively. The momentum is the transverse momentum of the tagged parton, while , which is conjugate to , is the net transverse momentum transferred to the target (the recoil of the pair as a whole). This differs from next-to-leading order forward dihadron production in collisions, where two independent final-state momenta together with a fluctuating target impact parameter generally require Fourier transforms with respect to three independent transverse momenta [25, 26]. In DIS dijet production, by contrast, the cross section depends only on the relative dipole momentum and the pair recoil . Under the assumption of impact-parameter independence, the target’s overall impact parameter integrates out trivially, leaving only two Fourier conjugate pairs.
The four-point correlator is built from the dipole correlator , taken either from the Golec-Biernat–Wüsthoff (GBW) parametrization [27] or from a tabulated solution of small- evolution in which a neural network is used to extract an unparametrized initial dipole correlator, subsequently evolved with the collinearly-improved BK equation and fit globally to small- experimental data [28, 29]. The resulting form is
where , and . Physically, is the target average of four Wilson lines sitting at the endpoints of the two dipoles and , separated by . It encodes the interference between the eikonal phase picked up in the matrix element and in its complex conjugate. Equation (3) is the Gaussian approximation and large- limit reduction of this quadrupole to products of dipole -matrices, including the elastic and inelastic terms [11, 22, 23, 24]. Only the two-point function , evolved by the BK equation, is needed as external input. The dimensionless combinations and implement this reduction exactly. Equation (3) takes the form when , or equivalently when . We avoid this form using
and as a result,
where and . For we use ; otherwise we use the direct definition.
Reduction of the integral for numerical evaluation
Here we focus on the integral involving only two Fourier transforms and exploit this structure to reduce it analytically before numerical evaluation. For the given integrand ,
with , i.e. , and define the relative angles
Here are the ordinary polar angles of , , , and , measure them relative to , which is the only vector shared by both phases below and whose overall orientation is therefore integrated out first. Writing , the integral becomes
There are only two Fourier phases. Expanding each gives
The integral enforces the following selection rule.
while the angular Fourier modes are
Using , and integrating out the radial variable ,
Here is the -th azimuthal partial wave of the original integrand after the radial integration, and should not be confused with itself. Introducing the double Bessel transform
one obtains the two-Bessel radial form
where the sum over the integer azimuthal harmonic is in principle infinite but is truncated at , once becomes negligible at the required numerical precision. In practice, is set by the smoothness of in the angles , i.e. by how quickly its angular Fourier coefficients fall off. Since , caused by the real and reflection symmetry of of , this can be written as
For the Hankel transform, we use Filon quadrature [30] that will be described next subsection. The scheduling of these contractions on Central Processing Unit (CPU) and Graphics Processing Unit (GPU), including memory management and custom CUDA kernel fusion, is described in the later sections.
Filon–Bessel quadrature with closed-form local moments
The double Bessel transform of Eq. (13) is evaluated sequentially, with the integral performed first. Its smooth factor is at . Since the $\Delta dependence plays no role in the integral, we suppress it for brevity and write . The transforms are oscillatory: at production-level momenta, reaches across the grid, so any quadrature rule that directly resolves the oscillation requires a prohibitively fine mesh. Instead, we use a Filon-type rule [30] on the stored grid. On each interval the smooth function is fit by a degree- polynomial (default ) in the local coordinate ,
with nodes in total on the grid. The fit for interval uses the five points , while the resulting polynomial is integrated only over the interval .
The oscillation is then integrated exactly against each monomial via local moments, which admit a closed analytic form. Given the interval, with and held fixed, we expand the Bessel factor as a Taylor series in about . The chain rule gives
where is the -th derivative of evaluated at . On this interval, the Bessel function is thus replaced by a polynomial in , which can be integrated against exactly. The elementary integral is
where is the width of the th interval. Applying this term-by-term gives the moments
By Stirling’s formula, , so the terms in the series grow until and decay factorially beyond it. The required truncation order therefore scales with the interval width . Since we evaluate all intervals with a single, common truncation order (to allow the local moments to be computed simultaneously through vectorization), this order must be set by the widest interval, , defined as the maximum value among . We take , with the ceiling rounds that estimate up to an integer, capped at . Because gives the slowest-converging case, this choice guarantees convergence on every interval, not just the widest one.
Filon weight vectors
The fit of § 2.3 uses five sampled values on each interval. For interval , let denote the global grid indices of these five fit points, and define the local offsets and sampled values , for . The coefficients of the degree-4 polynomial satisfy
These are five equations for the five unknown coefficients . Their coefficient matrix is a Vandermonde matrix, with
and the five grid nodes are distinct. Equation (20) therefore has a unique solution.
Rather than solving Eq. (20) separately for every set of sampled values, we construct the solution using the Lagrange cardinal polynomials
For example, the polynomial associated with the first fit point is
and by construction, . The unique interpolating polynomial is therefore
Indeed, setting in Eq. (24) kills every term except , since , leaving . Uniqueness of this interpolant then follows from Eq. (21).
To obtain the polynomial coefficients, we expand each cardinal polynomial in the monomial basis,
Inserting Eq. (25) into Eq. (24) gives . Relabeling each column by the corresponding global grid index gives the form used below,
The matrix depends only on the five node offsets, not on the sampled values, and is constructed once for each interval. In the implementation, the offsets are first divided by the width of the five-node window before solving the equivalent system, the th coefficient is then divided by the th power of that width. This rescaling keeps the system well conditioned as the grid is refined.
Combining Eq. (26) with the moments of Eq. (19), with , the contribution of one interval is
The two bracketed terms are the constant and varying parts of the Jacobian , the constant multiplies the moment at the fit power, while the varying part raises the fit power by one and yields the moment one order up. With the fit coefficients still grouped, substituting Eq. (26) into Eq. (27) and summing over intervals gives
The parenthesized quantity is precisely . Expanding the parenthesis and reordering the sums so that the samples appear first,
The second line merely regroups the first by grid node: each interval contributes five numbers, one to the weight-vector entry of each of its five fit points and since a node belongs to at most five fit sets, each entry is the sum of at most five such contributions. Explicitly,
where the outer sum runs over the (at most five) intervals whose fit set contains node . Here no further index is needed, because the fit points in are labeled by their global grid indices, so the column is defined whenever .
Every factor on the right of Eq. (29) is now accounted for: depends only on the node positions, while the moments depend on the grid, the momentum , and the order . The integrand enters the transform only through its sampled values , and only linearly. The weight vector is therefore a property of the (grid, momentum, order) triple, computed once and then reused for both polarizations and every dipole table on that grid. Stacking the rows over and over the target momenta turns each Hankel transform of the chain in § 2.2 into a single matrix product. The following sections describe how these products are scheduled on the CPU and GPU.
The CPU reference implementation
The first production implementation runs on the CPU and is deliberately plain. Exact library functions evaluate the Bessel factors , , and a cubic spline in interpolates through the dipole’s tabulated nodes. Every later implementation is checked against this reference. Its structure is shared by all implementations and follows directly from the reduction of § 2.2. The computation separates into two stages.
Stage 1 evaluates the angular modes of Eq. (11) and the integral of Eq. (12), producing the inner table on the stored grid. No momentum enters this stage.
Stage 2 applies the two Hankel transforms of Eq. (13) as Filon weight-vector contractions (§ 2.4), turning the table into the angular modes of the cross section . All momentum dependence lives here.
The inner table connects the two stages: stage 1 writes it, stage 2 reads it, and nothing else crosses the boundary. Because the table is momentum-free, the expensive stage is paid once per dipole and , while the cheap stage can be repeated on any momentum grid. Algorithm 1 gives the pseudocode, and Figure 1 shows the workflow. The two stages are detailed below.

Figure 1. Workflow of the CPU reference implementation. Light rounded boxes are compute stages. Sharp rectangles are data, the double frame marks data saved to disk, and dashed rounded frames are loop scopes. Momentum never enters stage 1, and the momentum-free inner table is the only object that passes between them.
Algorithm 1 The CPU reference implementation. Stage 1 builds the momentum-free inner table; stage 2 contracts it with Filon weight vectors; the inner table is the only object crossing the stage boundary.
Stage 1 builds the inner table without momentum.
precompute the grids, angular sample points, the interpolation, Gauss–Legendre rule
for all -chunks (one worker process per chunk) do
evaluate the -free factors ,
for do
evaluate the guarded integrands of Eqs. (2) and (5) on the block
project onto the angular modes of Eq. (11); add with weight
end for
end for
multiply the polarization prefactors onto the finished arrays
Inner table is held in memory, archived on disk.
Stage 2 performs the momentum-dependent Hankel transforms.
build the -grid weight rows for every ▷ § 2.4
for each of the momentum grid do
build the -grid weight rows
contract over and then over using Eq. (32) for all
end for
From continuous to discrete
Every integral of § 2 is replaced by a finite sum. The angles are sampled on equally spaced points, , , and likewise . The axis carries a Gauss–Legendre rule on with nodes and weights , . The values , , and , are the stored coordinate grids.
The angular Fourier transform, Eq. (11), becomes the equally spaced double sum. For a smooth -periodic integrand this sum is exact for every Fourier mode below the sampling limit, so the one requirement is . With , the two phases combine into , and for the real integrands of Eq. (2) only its cosine survives. Applying the rule to Eq. (12) then gives the discrete inner table on the stored grid points,
The two Hankel transforms of Eq. (13) are discretized by the Filon weight vectors of § 2.4, one axis at a time. The axis is transformed first, with rows built on the grid at momentum , then the axis, with rows built on the grid at momentum . Substituting the first contraction into the second,
The superscript in parentheses names the grid on which a weight row is built, and the accompanying index ( on the grid, on the grid) labels the grid node. The subscript is the Bessel order, common to both transforms by the selection rule of § 2.2. The argument is the momentum at which the row was built. Every weight depends only on its (grid, momentum, order) triple, independent of the dipole and polarization, so the same rows serve both polarizations and every dipole table. Stacking the rows over the momentum grid then turns each of the two sums in Eq. (32) into a matrix product.
The inner table
The product of stage 1 is a pair of real arrays (transverse and longitudinal) of shape , and determines and . The photon splitting wavefunction enters through and , which vary on the scale . As decreases, rises like toward the origin, and the wavefunction reaches larger before dying off, so resolving it takes many points over a wider range. The direction is untouched by because the wavefunction depends only on and , so the profile of the table is set by the quadrupole correlator. The quadrupole falls off slowly at large , as seen directly in Figure 4, so the grid is sized once for that long tail and reused unchanged for every . Here we set in every production table.
Figure 4. Inner table for a proton dipole at and GeV, modes , respectively. Each row contains the transverse (left) and longitudinal (right) polarizations. The color scale is symmetric logarithmic.
In production the range depends on . We use at , growing to at the smallest production value . The grid is uniform for ; for it uses the quadratic map , which concentrates points near . The point count follows the range as , giving at the reference range and at GeV.1 The integral widens and deepens alongside, GeV and , which raises the build cost but not the table size.
The resulting table size follows directly. With and , the pair of arrays occupies disk storage about 0.2 GB at GeV and about 0.6 GB at GeV. The table is held in system memory and archived on disk as a plain-text table, one row per entry with a small metadata file alongside. The text storage inflates the raw numbers roughly tenfold, so the largest production tables reach about 5 GB each on disk. The table is momentum-free, so angular modes of the cross section on a new momentum grid require only stage 2 to be rerun. A production set nevertheless spans many combinations at gigabytes each, and this storage burden is one of the motivations for the fused implementation of § 4.4, which produces the angular modes without ever materializing the table.
Profile
The wall time splits cleanly between the two stages. Table 1 reports the measured breakdown. All GeV share the same grid (, ) and therefore the same cost, so a single measurement suffices.
| [GeV] | stage 1 (16 cores) | stage 2 | total | ||
| 200 | 256 | 19 943 s (5.5 h) | 26 s | 5.5 h | |
| 0.1 (scaled) | 535 | 384 | 80 022 s (22 h) | 69 s | 22 h |
Table 1. Wall-time breakdown of the CPU reference implementation on 16 cores (, , , proton dipole at , measured on 16 cores of a 20-core desktop).
The GeV row is scaled from the measured per-point cost, which is constant per node and per -chunk across . Only the time that needed to start the worker processes is not scaled.
Convergence and validation
Three convergence properties are checked. First, the angular mode sum of § 2.2 must saturate. The accumulated partial sum at fixed should flatten well before . Figure 2 demonstrates this for representative momenta.
Figure 2. Convergence of the angular mode sum for the proton dipole at . The accumulated sum at GeV, GeV is normalized by its converged value with , for five momentum angles and three photon scales , quoted in GeV (transverse polarization). The horizontal axis is linear up to angular mode sum and logarithmic beyond.
Figure 2 establishes angular convergence at representative points, but the default CPU production resolution, and , does not resolve the entire small- region. At GeV, some production-grid points retain significant high-mode contributions and can even yield a negative truncated angular reconstruction. Resolving them requires increasing both the angular sampling and the retained mode count. Because the dominant stage-1 work scales as , increasing from 64 to 256 multiplies the angular work by sixteen. Applied to the multi-hour and day-scale CPU costs in Table 1, such a convergence study would require an unreasonable amount of CPU time. This computational limitation is one of the motivations for the GPU implementation.
We therefore defer the demanding small- test to § 4.3, after the GPU algorithm and its agreement with the CPU reference have been established. There we use the GPU to reach and in a practical wall time and show explicitly that the same algorithm recovers a stable, positive result once sufficient angular resolution is supplied.
Second, the Filon weight contraction must converge with the grid. At fixed momentum and mode, the transform computed on progressively finer grids (or with increasing fit degree) should settle to a stable value. Figure 3 shows the relative change as a function of grid refinement.

Figure 3. Convergence of the Filon weight contraction with -grid refinement for the proton table at and GeV. The curves show the relative deviation of from the full-grid () result, for modes and momenta GeV. The coarse grids keep every 16th to every 2nd node; the finest grids remove every 4th to every 256th node, always keeping the endpoint so the integration range is unchanged. At the deviation is identically zero by construction.
Third, the inner table and the final cross sections are inspected visually. Figure 4, and Figure 5 shows a heatmap of the inner table for a proton dipole, and Figure 6 shows slices of the resulting cross sections.
Figure 5. Inner table for a proton dipole at , GeV, and modes , respectively. Each row contains the transverse (left) and longitudinal (right) polarizations. The color scale is symmetric logarithmic.
Figure 6. Cross sections for a proton dipole at , GeV in the transverse polarization. The folded mode sum is plotted against at fixed GeV for three momentum angles on a log scale. The sharp dips are deep cancellation minima rather than zero crossings. The mode sum remains positive at every plotted point.
This reference implementation is the baseline against which all GPU implementations are checked. The following sections make the build itself fast by moving it to the GPU.
The GPU implementations
Two GPU implementations are presented below. Both leave the mathematics of the preceding sections untouched and use the same reduction, Filon weight vectors, and guarded integrand. The first (§ 4.1) keeps the two-stage structure of § 3 exactly and ports stage 1, which carries essentially all the cost, to CUDA for speed; the inner table remains a stored, reusable object. The second (§ 4.4) goes one step further and removes the stage boundary itself: the Hankel contraction is a linear sum over table entries, so it can be applied to each piece of the table as that piece is computed, and the full table never needs to exist. The three-transform case developed later requires this capability.
The CUDA table builder
The first GPU implementation is designed for speed. It computes the same inner table as § 3.2 and uses the same stage 2: that stage performs the weight contraction of Eq. (32) and runs on either processor. What changes is how stage 1 evaluates its integrand samples. Two ideas provide the speedup.
First, the special functions are tabulated before the GPU calculation. Every transcendental ingredient is precomputed on the CPU as interpolation coefficients and evaluated on the GPU by polynomial interpolation. The first table stores on a uniform grid and is exact for the GBW dipole, whose is a parabola in . The regular combinations and (finite at , where and themselves diverge) are stored in two additional tables. The tables are sized so that the lookup error is negligible compared to double precision.
Second, each factor of the integrand is computed only on the set of variables it actually depends on, instead of being recomputed at every point of the four-dimensional block. A naive kernel evaluates everything on for every ; here four custom kernels split the work as shown in Table 2.
| kernel | depends on | frequency | computes |
| wavefunction | per -chunk | , , via table lookup; | |
| per | and ; their sum and its exponential | ||
| per | |||
| final assembly | per | , , , and |
Table 2. Kernel decomposition of stage 1 on the GPU. The first three kernels evaluate factors reused in the final assembly of .
The only correlator evaluated is , whose logarithmic combinations are
The products and , together with , are evaluated on smaller domains and reused. The remaining term completes and depends on the full block at fixed , so the ratio and the guarded result are assembled only on that full block. This split avoids recomputing the reusable factors at every point. The angular projection then uses one dense matrix product per , followed by the weighted contraction.
This decomposition is specific to the DIS dijet integrand of Eq. (2); a different observable would require its own kernel split, because the factorization exploits the particular dependence of the wavefunction and correlator on the integration variables.
Memory is scheduled around a GPU memory budget: the axis is cut into chunks, and the two integrand buffers dominate, occupying about MB per row at production sizes. Each finished column of the projected table is copied to system memory when complete. The assembled table is stored in system memory and archived exactly as in § 3.2: it remains momentum-free and reusable, but is produced faster. Algorithm 2 gives the pseudocode, and Figure 7 shows the workflow; the stage separation of Figure 1 is unchanged.

Figure 7. Workflow of the CUDA table builder. Dark rounded boxes are CUDA stages; all other conventions are as in Figure 1. The two-stage structure and the inner table between the stages are unchanged from the CPU implementation; only the production of the table moves to the GPU.
Algorithm 2 The CUDA table builder. Stage 2 is unchanged from Algorithm 1; only the production of the inner table moves to the GPU.
Stage 1 builds the inner table with CUDA.
prepare the grids, angular mode matrix, and rules on the CPU; spline-coefficient tables for , , ; upload to the GPU
for all -chunks (GPU memory budget) do
wavefunction kernel on evaluates , lookups,
for each of the values do
evaluate the reusable -dependent factors of Eq. (33)
evaluate on after the remaining lookup
angular projection (dense matrix product); contraction
copy the finished column to system memory
end for
end for
Inner table resides in system memory and is archived on disk.
Stage 2 performs the Hankel transforms as in Algorithm 1 (CPU or GPU).
Kernel profiling and wall-time breakdown
The decomposition of Table 2 keeps the final assembly compute-bound rather than memory-bound; this is the only stage that touches the full four-dimensional block. Table 3 reports the hardware metrics measured by NVIDIA Nsight Compute for the five kernels at production grid sizes. The streaming multiprocessor (SM) and dynamic random-access memory (DRAM) entries are the achieved percentages of the corresponding limits [31]. An SM value between 83 and 95 percent means that the processing resources are already operating near their sustained limit, while a DRAM value between 5 and 11 percent means that global-memory bandwidth remains far from saturation. In the Roofline interpretation, the large separation between these values identifies a compute-bound regime rather than a memory-bound one [32, 33]: the available memory bandwidth is therefore sufficient, and the limiting factor is the hardware’s compute capacity.
| kernel | bottleneck | SM [%] | DRAM [%] | occupancy [%] |
| wavefunction | compute | 87 | 11 | 97 |
| compute | 83 | 8 | 93 | |
| compute | 86 | 8 | 94 | |
| final assembly | compute | 87 | 10 | 96 |
| angular projection (cuBLAS) | compute | 95 | 5 | 16 |
Table 3. Kernel profiling with NVIDIA Nsight Compute on an RTX 3090 at production grid sizes ( GeV). SM and DRAM columns report the fraction of peak sustained throughput; all five kernels are compute-bound.
Table 4 reports the end-to-end wall time for one inner-table build on two GPUs. The NVIDIA RTX 3090 has a 1/64 FP64 rate, while the NVIDIA A800 has a full FP64 rate.2 The breakdown into stage 1 and stage 2 is reported separately.
| GPU | [GeV] | stage 1 | stage 2 | total |
| RTX 3090 | 4.0 | 167 s | 20 s | 186 s |
| RTX 3090 | 0.1 | 666 s | 24 s | 691 s |
| A800 | 4.0 | 23 s | 40 s | 62 s |
| A800 | 0.1 | 74 s | 48 s | 122 s |
Table 4. Wall-time breakdown for one inner-table build on an RTX 3090 and an A800. Proton dipole at . Only the stage-1 times are stable GPU measurements; stage 2 is dominated by the CPU construction of the Filon weight rows, so it reflects the CPU rather than the GPU and varies with CPU load. In production the weight rows are built once per and reused for every dipole, so the stage-2 cost is amortized.
The percentages in Table 3 are normalized to the RTX 3090’s own peak rates and do not represent the same absolute throughput on different GPUs. Stage 1 is dominated by double-precision arithmetic and is compute-bound, so the A800 accelerates this stage by providing much more FP64 throughput, which is the resource that limits the calculation. Table 4 shows this directly: the stage-1 time decreases from 167 to 23 seconds at GeV and from 666 to 74 seconds at GeV, corresponding to speedups of about 7.3 and 9.0. Stage 2 does not follow this trend because its time is set mainly by the CPU construction of the Filon weights.
Figure 8 closes the loop on correctness: the folded cross sections produced by the GPU table path lie on top of the CPU reference across momenta and angles, including through the deep cancellation minima of the log panels. The small residual discrepancies can be partially attributed to the improved treatment of the integral in the GPU path relative to the CPU reference.
Figure 8. Cross sections from the GPU table builder (open triangles, every third momentum point) overlaid on the CPU reference implementation (lines) for the proton dipole at and GeV in the transverse polarization. The quantity is plotted against at three fixed values of for three momentum angles on a log scale.
Figure 9 quantifies the same CPU–GPU agreement at the discrete GPU marker positions. The largest relative errors occur near the deep cancellation minima, where the CPU reference in the denominator becomes small.
Figure 9. Pointwise relative error corresponding to Figure 8, defined as . Only the GPU marker positions shown in Figure 8 (every third point) are used, and the curves connect these sampled values. The three panels use the same fixed values and the colors and line styles denote the same momentum angles ; both axes are logarithmic.
High-resolution angular convergence
The comparison in Figure 8 establishes that the GPU implementation reproduces the CPU reference at the default production resolution. Its speed also makes it possible to increase the angular resolution far beyond what is practical in the CPU study. We now return to the small- limitation identified in § 3.4 and use the GPU to test whether the apparent failure is a truncation effect or a failure of the algorithm itself.
For the proton dipole at and GeV, replaying the angular scan at the default , resolution identifies an unconverged point at GeV, GeV, whose longitudinal result is most negative at . Figure 10 shows the complete slice through this value of . The GPU calculation permits us to repeat the same calculation at , and at the alias-safe resolution , . As the angular resolution and retained mode count increase, the calculation progressively approaches the converged result: the 128/64 result is already substantially improved, while the 256/127 result recovers a positive angular minimum at the selected point.
Figure 10. Angular-resolution stress test for the proton dipole at , , and . The upper row shows the longitudinal mode sum as a function of at the fixed angle , where the selected default point is negative. The lower row shows, independently at each , the smallest value over a dense 512-point scan of ; hence the minimizing angle need not be the same at different . The default , result is compared with , (left) and , (right). Red points mark unconverged data in the default calculation.
The recovery is seen more directly by following the partial mode sum at the selected point. Figure 11 retains its sign and therefore displays both the oscillatory approach and the zero crossings. The default truncation terminates on the negative branch, whereas the finer angular FFT supplies the additional modes needed to reach the stable positive result. The calculation is performed only once, through . All intermediate cutoffs shown are partial sums of this same saved set of angular modes.
Figure 11. Signed angular partial sums at the selected unconverged point , , and , for transverse (top) and longitudinal (bottom) polarization. The default , curve is compared with the refined , and , calculations. The circles on the high-resolution curve mark and .
Taking the absolute value exposes the tail over several orders of magnitude. Figure 12 shows that the oscillations damp and the result reaches a plateau. At the selected angle, the longitudinal partial sum at differs from the result by in relative terms. The GPU calculation therefore shows that the small- failure at the default resolution is purely an angular-truncation effect: the algorithm recovers the fully converged result once sufficient resolution is supplied.
Figure 12. Absolute values of the same partial sums as in Figure 11, shown on a logarithmic vertical scale. The decay of the longitudinal oscillations and the common high- plateau make the convergence of the refined angular calculation explicit.
Computing the transforms without storing the inner table
The dijet calculation can afford to store because this table has only two coordinate indices and one angular-mode index, and remains smaller than one gigabyte. The three-transform calculation discussed in § 1 would add another coordinate index and another mode index; its table would be larger by orders of magnitude, and a separate table would be required for every combination of Bjorken and . We therefore construct the transformed result without storing the inner table. The dijet calculation provides a setting in which this method can be tested before it is used for the three-transform case.
The starting point is an observation about Eq. (32): both Hankel transforms are linear sums over table entries, so nothing requires the table to be complete before the sums begin. Split the contraction into its two steps,
and evaluate the first line as the values of are constructed: a small set of values is multiplied by the weights and added to , and those values are then discarded. After all values have been included, the weights are applied to to obtain . The full inner table is never formed or saved. This changes only the order of the additions, so the two implementations agree within rounding errors (Table 6).
Table 6. Agreement between the two GPU paths at production grid sizes. Both paths compute the angular modes of the cross section for the proton dipole at on identical momentum grids with geometrically spaced , GeV. The table builder stores the full inner table and contracts it with the Filon weights afterwards. The fused path contracts on the fly with the sum folded into the build kernel. Quoted are the largest absolute and relative entry-wise differences over all angular modes and both polarizations.
| [GeV] | GPU | max abs diff | max rel diff |
| 4.0 | RTX 3090 | ||
| 0.1 | RTX 3090 | ||
| 4.0 | A800 | ||
| 0.1 | A800 |
The grids, the integration rules, the angular-mode matrix, the Bessel values, and the Filon weights are the same for every dipole at fixed , and are therefore computed once; a new dipole requires only its spline coefficients. The momenta and must be chosen when the Filon weights are computed, so changing these momenta requires repeating the calculation. This is the price of avoiding the stored table, which could otherwise be transformed again at new momenta.
Figure 13 shows the calculation. It is repeated over the grid, and the values are handled one at a time. For each , is evaluated and summed over in the same step, so the result depends only on and is projected directly onto the angular modes; multiplication by the weights then adds this contribution to . After all values have been included, the weights give . The full integrand is never stored. At any point, the calculation stores only the current intermediate values, of order 10 MB, and the final result of a few MB; only the final result is copied from the GPU. The output contains about rows instead of a table several gigabytes in size.

Figure 13. Evaluation without storing the inner table. Each contribution is summed over and transformed as it is evaluated. Only the finished result is copied from the GPU.
Fused profiling and correctness
Table 5 reports the total wall time of the fused implementation alongside the table-builder path of § 4.1 at the same and GPU. Because the fused path replays the same build kernels for the dipole correlator, any difference in total time reflects the cost of the incremental weight contraction versus the cost of writing and later reading the full table; the two are expected to be comparable.
Table 5. Wall time of the fused implementation vs the two-stage table builder on the same GPU and grid, proton dipole at . The fused time is end-to-end and includes building the Filon weight rows. It is to be compared with the sum of the two table-builder stages. As in Table 4, stage 2 and the weight-construction part of the fused path are CPU-bound.
| GPU | [GeV] | table builder | fused | |
| stage 1 | stage 2 | |||
| RTX 3090 | 4.0 | 167 s | 20 s | 149 s |
| RTX 3090 | 0.1 | 666 s | 24 s | 279 s |
| A800 | 4.0 | 23 s | 40 s | 49 s |
| A800 | 0.1 | 74 s | 48 s | 84 s |
Because the fused path folds the sum into the build kernel and processes one node at a time, the order in which the same finite sums are accumulated differs from that of the table builder. Table 6 reports the maximum absolute and relative differences between the fused and table-builder angular modes of the cross section across all modes, momenta, and both polarizations.
The six-dimensional Fourier transform
The dijet computation in the previous sections uses only two of the three sequential Hankel transforms, appropriate for the leading-order deep-inelastic-scattering process. This section presents the algorithm for the general case and validates it on an analytic family. Its production deployment is deferred to forthcoming next-to-leading-order proton–nucleus applications, where the third momentum is physical. The general problem attaches an independent momentum to each of the three working variables,
which is a genuinely six-dimensional Fourier transform, evaluated as three sequential Hankel transforms. The fused implementation of § 4.4 was designed for precisely this case: the momentum-free intermediate now carries three coordinate axes and two mode indices, far too large to store per Bjorken- and , so only the fused path is viable. The algorithm does not require a specific form of . We test it below with an integrable function whose transform is known exactly.
Angular reduction with three phases
The angular reduction proceeds as in § 2.2, but with three phases the integral over the global angle now enforces , so only two signed mode indices survive. Storing the pair for the - and -angle modes fixes the order to , and with chosen along the axis,
where , are the momentum azimuths. All three phases carry , and the powers of from the three Bessel expansions cancel identically in this combination.
Streaming the three-transform contraction
The coefficient is too large to store on the full coordinate grid. Instead, is evaluated for a subset of the grid and successive values; for each , the angular dependence is projected onto and the sum is performed immediately. The and sums are then applied in sequence,
So the full coefficient is not stored. If is too large for the full grid, the same calculation is performed for successive groups of values. For a real integrand, , so only is computed and the remaining modes are reconstructed by this symmetry. Algorithm 3 summarizes the calculation.
Algorithm 3 The fully fused three-momentum calculation.
build the three Filon weight families , , and
for all successive groups of values do
for all successive subsets of the grid do
set
for each value do
evaluate
project onto and add the -weighted result to
end for
apply the weights to to obtain
apply the weights to and add the result to
end for
end for
Angular projection at each coordinate point
At each point, is sampled on the angular grid. The coefficients are obtained by first summing over and then over , retaining only the required values of . Each coefficient is multiplied by its weight and added directly to in Eq. (37); the and weights are then applied to obtain . This is the calculation stated in Algorithm 3.
Validation against an analytic Gaussian family
We test the algorithm with the integrable function
where the constants are chosen so that the quadratic form is positive definite, and whose six-dimensional Fourier transform is known analytically. We use , , and 320 nodes on GeV for each radial coordinate. The numerical and exact results agree to better than at every point in Figure 14, verifying the angular projection, the three Hankel transforms, and the final sum over angular modes.
Figure 14. Analytical (lines) and our numerical (open triangle points) results of the Eq. (36) for the test function in Eq. (38), shown as a function of at GeV and GeV for three angle pairs.
Outlook for physical applications
We have not yet applied the three-transform algorithm to a specific physical process. The correlators and kinematic factors depend on the chosen process and determine both the coordinate grids and the GPU calculation. We leave this application in the next-leading order p-A CGC calculations and its performance study to future work.
Conclusion
We have developed a Filon-based algorithm for the nested two-dimensional Fourier transforms that arise from multi-Wilson-line correlators in Color Glass Condensate calculations, and validated it through an incremental sequence of implementations. Starting from the deep inelastic scattering dijet cross section without the correlation-limit approximation, we showed that the exprel identity of Eq. (5) removes the numerical instability of the quadrupole correlator near the codimension-one surface where the naive parametrization takes the form 0/0, and that a Filon-type quadrature converts each oscillatory Hankel transform into a precomputed weight vector, turning the full transform chain into a sequence of matrix products. Each mathematical reduction and each numerical step was validated before being carried into the next implementation. The CPU reference implementation of § 3 was checked against direct convergence tests in the angular mode number and the Filon grid, the CUDA table builder of § 4.1 was checked against the CPU reference, and the fused GPU implementation of § 4.4 was checked against the table-based path. The resulting calculation evaluates the DIS dijet cross section over the full kinematic range relevant for phenomenology within a practical runtime, reducing the computation from several hours on a multi-core CPU to on the order of one to two minutes on a single commercial GPU.
The experience gained from this staged development, encapsulated in Algorithms 1–3, allowed us to generalize the method to three sequential two-dimensional Fourier transforms. Because the corresponding momentum-free intermediate would be too large to store for a realistic range of Bjorken- and values, this general algorithm is implemented directly in the fused, streaming form of § 4.4. We validated the resulting six-dimensional transform against an analytic Gaussian integrand family with a closed-form solution at every stage of the calculation, confirming the angular projection, the three Hankel transforms, and the final reconstruction of the physical result.
The three-transform algorithm has not yet been deployed for a production CGC observable. Different processes involve different combinations of correlators and kinematic prefactors, so each physical application requires its own CUDA kernels, memory layout, and optimization, and a timing measurement obtained with the analytic test function would not be representative of a process-specific calculation. The production coordinate and momentum grids likewise depend on the observable under consideration. We therefore defer the production implementation and performance study to future work on next-to-leading-order proton-nucleus and electron-ion scattering cross sections computed without the back-to-back correlation-limit approximation. The present algorithm and its validated GPU implementation provide a direct foundation for these applications.
Published Code: The CPU, CUDA, and fused GPU implementations described in this paper, together with the scripts used to generate the validation figures, are publicly available at https://github.com/CCNU-CGC-py/FFT_filon.
Acknowledgements
We thank Xiaolong Liu for reviewing the manuscript. This work was supported in part by the Outstanding Leading Talent Team Program of Central China Normal University (XJ2026000302). This work was also supported in part by the 2025 Cross Research Project of the Fundamental Research Funds for the Central Universities of Central China Normal University, “Advanced Detection and Artificial Intelligence at the Frontiers of Physics” (No. 30101250317). C. Y is supported in part by National Natural Science Foundation of China (NSFC) under Grant No. 12547164 and the China Postdoctoral Science Foundation under Grant Number 2025M783388. H. D is partially supported by NSFC under Grant No. 12535010.
References
- [1]Y. V. Kovchegov, E. Levin, Quantum Chromodynamics at High Energy, Vol. 33, Oxford University Press, 2013. doi:10.1017/9781009291446.
- [2]L. McLerran, The color glass condensate, Nucl. Phys. A 702 (2002) 49–64. doi:10.1016/S0375-9474(02)00688-7.DOI
- [3]E. Iancu, R. Venugopalan, The Color glass condensate and high-energy scattering in QCD, 2003, pp. 249–3363. arXiv:hep-ph/0303204, doi:10.1142/9789812795533_0005.
- [4]H. Weigert, Evolution at small x(bj): The Color glass condensate, Prog. Part. Nucl. Phys. 55 (2005) 461–565. arXiv:hep-ph/0501087, doi:10.1016/j.ppnp.2005.01.029.
- [5]F. Gelis, E. Iancu, J. Jalilian-Marian, R. Venugopalan, The Color Glass Condensate, Ann. Rev. Nucl. Part. Sci. 60 (2010) 463–489. arXiv:1002.0333, doi:10.1146/annurev.nucl.010909.083629.DOI
- [6]J. L. Albacete, C. Marquet, Gluon saturation and initial conditions for relativistic heavy ion collisions, Prog. Part. Nucl. Phys. 76 (2014) 1–42. arXiv:1401.4866, doi:10.1016/j.ppnp.2014.01.004.DOI
- [7]A. Morreale, F. Salazar, Mining for Gluon Saturation at Colliders, Universe 7 (8) (2021) 312. arXiv:2108.08254, doi:10.3390/universe7080312.DOI
- [8]D. Kharzeev, E. Levin, L. McLerran, Jet azimuthal correlations and parton saturation in the color glass condensate, Nucl. Phys. A 748 (2005) 627–640. arXiv:hep-ph/0403271, doi:10.1016/j.nuclphysa.2004.10.031.DOI
- [9]C. Marquet, Forward inclusive dijet production and azimuthal correlations in p(A) collisions, Nucl. Phys. A 796 (2007) 41–60. arXiv:0708.0231, doi:10.1016/j.nuclphysa.2007.09.001.DOI
- [10]F. Dominguez, B.-W. Xiao, F. Yuan, k_t-factorization for Hard Processes in Nuclei, Phys. Rev. Lett. 106 (2011) 022301. arXiv:1009.2141, doi:10.1103/PhysRevLett.106.022301.DOI
- [11]F. Dominguez, C. Marquet, B.-W. Xiao, F. Yuan, Universality of Unintegrated Gluon Distributions at small x, Phys. Rev. D 83 (2011) 105005. arXiv:1101.0715, doi:10.1103/PhysRevD.83.105005.DOI
- [12]T. Lappi, H. Mantysaari, Forward dihadron correlations in deuteron-gold collisions with the Gaussian approximation of JIMWLK, Nucl. Phys. A 908 (2013) 51–72. arXiv:1209.2853, doi:10.1016/j.nuclphysa.2013.03.017.DOI
- [13]A. Stasto, S.-Y. Wei, B.-W. Xiao, F. Yuan, On the Dihadron Angular Correlations in Forward pA collisions, Phys. Lett. B 784 (2018) 301–306. arXiv:1805.05712, doi:10.1016/j.physletb.2018.08.011.DOI
- [14]P. Caucal, Z.-B. Kang, P. Korcyl, F. Salazar, B. Schenke, T. Stebel, R. Venugopalan, W. Zhao, Probing gluon saturation with forward dihadron correlations in proton-nucleus collisions, Phys. Lett. B 879 (2026) 140599. arXiv:2512.21466, doi:10.1016/j.physletb.2026.140599.DOI
- [15]T. Altinoluk, A. Kovner, Particle Production at High Energy and Large Transverse Momentum - ’The Hybrid Formalism’ Revisited, Phys. Rev. D 83 (2011) 105004. arXiv:1102.5327, doi:10.1103/PhysRevD.83.105004.DOI
- [16]H. Mäntysaari, N. Mueller, F. Salazar, B. Schenke, Multigluon Correlations and Evidence of Saturation from Dijet Measurements at an Electron-Ion Collider, Phys. Rev. Lett. 124 (11) (2020) 112301. arXiv:1912.05586, doi:10.1103/PhysRevLett.124.112301.DOI
- [17]A. Kovner, A. H. Rezaeian, Double parton scattering in the color glass condensate: Hanbury-Brown-Twiss correlations in double inclusive photon production, Phys. Rev. D 95 (11) (2017) 114028. arXiv:1701.00494, doi:10.1103/PhysRevD.95.114028.DOI
- [18]M. Li, V. V. Skokov, First saturation correction in high energy proton-nucleus collisions. Part III. Ensemble averaging, JHEP 01 (2022) 160. arXiv:2111.05304, doi:10.1007/JHEP01(2022)160.DOI
- [19]A. Kovner, V. V. Skokov, Bose enhancement, the Liouville effective action and the high multiplicity tail in p-A collisions, Phys. Rev. D 98 (1) (2018) 014004. arXiv:1805.09296, doi:10.1103/PhysRevD.98.014004.DOI
- [20]H. Duan, A. Kovner, V. V. Skokov, CGC for ultra-peripheral Pb+Pb collisions at the Large Hadron Collider: a more realistic calculation, JHEP 12 (2022) 077. arXiv:2208.05000, doi:10.1007/JHEP12(2022)077.DOI
- [21]H. Duan, C. Yi, S.-W. Dai, S.-Y. Wei, W. Zhao, L. Zheng, in preparation (2026). arXiv:2026.08xxx.
- [22]J. P. Blaizot, F. Gelis, R. Venugopalan, High-energy pA collisions in the color glass condensate approach. 2. Quark production, Nucl. Phys. A 743 (2004) 57–91. arXiv:hep-ph/0402257, doi:10.1016/j.nuclphysa.2004.07.006.DOI
- [23]H. Fujii, F. Gelis, R. Venugopalan, Quark pair production in high energy pA collisions: General features, Nucl. Phys. A 780 (2006) 146–174. arXiv:hep-ph/0603099, doi:10.1016/j.nuclphysa.2006.09.012.DOI
- [24]A. H. Rezaeian, CGC predictions for p+A collisions at the LHC and signature of QCD saturation, Phys. Lett. B 718 (2013) 1058–1069. arXiv:1210.2385, doi:10.1016/j.physletb.2012.11.066.DOI
- [25]G. A. Chirilli, B.-W. Xiao, F. Yuan, Inclusive Hadron Productions in pA Collisions, Phys. Rev. D 86 (2012) 054005. arXiv:1203.6139, doi: 10.1103/PhysRevD.86.054005.DOI
- [26]Y. Shi, L. Wang, S.-Y. Wei, B.-W. Xiao, Pursuing the Precision Study for Color Glass Condensate in Forward Hadron Productions, Phys. Rev. Lett. 128 (20) (2022) 202302. arXiv:2112.06975, doi: 10.1103/PhysRevLett.128.202302.DOI
- [27]K. J. Golec-Biernat, M. Wusthoff, Saturation effects in deep inelastic scattering at low Q**2 and its implications on diffraction, Phys. Rev. D 59 (1998) 014017. arXiv:hep-ph/9807513, doi:10.1103/PhysRevD.59.014017.
- [28]S.-W. Dai, F.-P. Li, L.-G. Pang, G.-Y. Qin, S.-Y. Wei, H.-Z. Zhang, W. Zhao, Physics-Informed Global Extraction of the Universal Small-x Dipole Amplitude (3 2026). arXiv:2603.08008.arxiv.org/abs/2603.08008
- [29]S.-W. Dai, H. Duan, L.-G. Pang, G.-Y. Qin, S.-Y. Wei, H.-Z. Zhang, W. Zhao, Unbiased Data-Driven Determination of the Nuclear Dipole Amplitude in the Color Glass Condensate (7 2026). arXiv:2607.27603.arxiv.org/abs/2607.27603
- [30]L. N. G. Filon, Iii.—on a quadrature formula for trigonometric integrals, Proceedings of the Royal Society of Edinburgh 49 (1930) 38–47. doi: 10.1017/S03701646000026262.
- [31]NVIDIA Corporation, NVIDIA Nsight Compute Profiling Guide, accessed 16 August 2026. URL https://docs.nvidia.com/nsight-compute/ProfilingGuide/index.html
- [32]S. Williams, A. Waterman, D. Patterson, Roofline: An insightful visual performance model for multicore architectures, Communications of the ACM 52 (4) (2009) 65–76. doi:10.1145/1498765.1498785.DOI
- [33]H. He, Making deep learning go brrr from first principles (2022). URL https://horace.io/brrr_intro.html









