A numerical implementation of the NLO DIS structure functions in the dipole picture

This paper presents a numerical program that calculates deep inelastic scattering structure functions at next-to-leading order accuracy within the dipole picture, utilizing a reformulated expression for massive quark impact factors to ensure stable cross-section evaluations.

The Gist

Imagine you are trying to understand how a proton (a tiny particle inside an atom) is built. You can't just look at it with a microscope; it's too small and moves too fast. Instead, scientists act like high-speed photographers, firing electrons at protons and watching how they bounce off. This is called Deep Inelastic Scattering (DIS).

Think of the proton not as a solid ball, but as a chaotic, swirling storm of even smaller particles called quarks and gluons. When you smash an electron into this storm, it's like throwing a pebble into a hurricane. The way the pebble bounces off tells you about the wind speed and density of the storm.

The Problem: The Storm is Getting Too Crowded

As we look deeper into the proton (at very high energies), we see that the number of gluons (the "glue" holding quarks together) explodes. It's like a traffic jam that keeps getting worse and worse. If this kept going forever, it would break the laws of physics (a concept called "unitarity").

Physicists believe that at some point, these gluons start merging together, like cars merging lanes to avoid a crash. This is called Gluon Saturation. It's nature's way of saying, "Okay, that's enough traffic; we need to merge."

The Challenge: Doing the Math

To prove this "traffic merge" is happening, we need to compare our theoretical math with real-world data from particle colliders (like the old HERA collider or the upcoming Electron-Ion Collider).

The problem is that the math is incredibly hard.

• Leading Order (LO): This is like calculating traffic flow assuming cars only drive straight and never change lanes. It's a rough guess.
• Next-to-Leading Order (NLO): This is the real deal. It accounts for cars changing lanes, merging, braking, and accelerating. It's much more accurate but requires solving millions of complex equations simultaneously.

Until now, doing these NLO calculations with heavy quarks (like the "charm" quark) was like trying to solve a Rubik's cube while juggling chainsaws. It was prone to errors and numerical instability.

The Solution: The New "Calculator"

This paper introduces a new computer program (a numerical code) that acts as a super-accurate calculator for these complex physics problems.

Here is how the authors describe their tool using simple analogies:

1. The "Dipole Picture" (The Lens):
   Instead of looking at the whole proton at once, the program views the interaction as a "dipole"—a pair of particles (a quark and an antiquark) created by the electron. Imagine looking at the proton storm through a specific pair of binoculars. This program calculates exactly what that pair sees when it hits the proton.

2. Stability (The Shock Absorbers):
   The biggest hurdle in these calculations is "numerical instability." Imagine trying to balance a stack of plates while the table is shaking. If you make a tiny mistake, the whole stack falls.
   The authors rewrote the mathematical formulas (the "impact factors") to act like shock absorbers. They rearranged the equations so that even when the numbers get huge or tiny, the calculation remains stable and doesn't crash. They also included the mass of heavy quarks (like the charm quark) as a "weight" that helps stabilize the stack.

3. The "Monte Carlo" Engine (The Dice Rollers):
   To solve these equations, the program uses a method called "Monte Carlo integration." Imagine trying to calculate the volume of a weirdly shaped rock. You can't use a ruler. Instead, you throw a million darts at a board with the rock's shape drawn on it. By counting how many darts hit the rock, you can estimate its volume.
   This program throws billions of "mathematical darts" to integrate the complex shapes of the proton's internal structure. The paper details how they organized these "dart throws" to make sure they don't waste time and get the most accurate result possible.

4. The "Running Coupling" (The Dimmer Switch):
   The strength of the force between particles changes depending on how close they are. The program includes a "dimmer switch" (the running coupling) that automatically adjusts the strength of the interaction based on the distance between particles, ensuring the physics remains realistic at all scales.

Why Does This Matter?

This program is a universal translator between theory and experiment.

• For Theorists: It allows them to test their ideas about "Gluon Saturation" with high precision.
• For Experimentalists: It provides a precise prediction of what the new Electron-Ion Collider (EIC) should see.

By running this code, scientists can finally say with confidence: "Yes, the gluons are merging," or "No, the traffic jam isn't forming yet." It turns a blurry, theoretical guess into a sharp, testable prediction, helping us understand the fundamental glue that holds our universe together.

In short: The authors built a robust, high-precision software engine that allows physicists to simulate the chaotic collision of particles with such accuracy that we can finally spot the subtle signs of gluons merging together inside the proton.

Technical Summary

1. Problem Statement

Deep Inelastic Scattering (DIS) is a primary tool for probing the partonic structure of hadrons. At small Bjorken-$x$ (high energy), the gluon density rises rapidly, a phenomenon described by the Color Glass Condensate (CGC) effective theory. To find conclusive evidence of gluon saturation, theoretical predictions must match the precision of experimental data (e.g., from HERA and the future Electron-Ion Collider).

While Leading Order (LO) calculations in the dipole picture are well-established, Next-to-Leading Order (NLO) calculations are required for precision. Existing NLO frameworks often rely on the massless quark limit ($m_q=0$), which simplifies calculations but fails to suppress "aligned-jet" contributions and does not accurately describe heavy quark production (charm, bottom). Furthermore, explicit numerical implementations of NLO DIS impact factors with massive quarks that ensure stable numerical evaluation were previously unavailable as a general-purpose tool.

2. Methodology

The authors present a C++ numerical program (NLODIS) that calculates DIS structure functions ($F_2, F_L, F_T$) at NLO accuracy within the dipole picture. The methodology involves:

• Theoretical Framework:

  • The total cross-section is decomposed into three components based on the partonic state interacting with the target shockwave:
    1. $\sigma^{IC}$: Lowest-order contribution (virtual photon $\to q\bar{q}$) with the dipole amplitude evaluated at the initial condition ($Y=Y_0$).
    2. $\sigma^{dip}$: Loop corrections to the $q\bar{q}$-target interaction.
    3. $\sigma^{q\bar{q}g}$: Contributions where a $q\bar{q}g$ state interacts with the target.
  • The calculation includes massive quarks ($m_q \neq 0$) in the impact factors, following results from Refs. [11–13].
  • The target is described by Wilson line correlators evolved via the Balitsky-Kovchegov (BK) equation at NLO accuracy.

• Numerical Implementation Strategy:

  • Stability: The authors rewrite the NLO impact factors to ensure numerical stability. A major challenge in NLO calculations is the cancellation of ultraviolet (UV) divergences between different terms. The code uses an exponential subtraction scheme (Ref. [18]) to handle these divergences.
  • Dimensional Reduction: To handle the complex multi-dimensional integrals, the authors group terms based on the number of required numerical integrations (2D, 3D, or 4D).
  • Handling Divergences: For terms involving generalized Bessel functions ($G^{(a;b)}$), the code analytically separates the $\lambda \to 0$ limit (which contains the divergence) from the finite remainder. This allows the Monte Carlo integrator to handle the finite parts without numerical instability.
  • Integration: Multi-dimensional integrals are performed using the Vegas algorithm from the Cuba library. The integration variables include dipole sizes, momentum fractions ($z$), and auxiliary variables introduced during the subtraction of divergences.
  • Running Coupling: The code supports different schemes for the running strong coupling $\alpha_s(r)$, including choices based on the smallest dipole size or the parent dipole, and options for infrared freezing or smoothing.

• Input/Output:

  • Input: The user must provide a dipole-target scattering amplitude (e.g., from a fit to HERA data) via a class inheriting from a virtual Dipole interface.
  • Output: The program computes the structure functions $F_2$, $F_L$, and $F_T$ for given kinematic variables ($Q^2, x_{Bj}$).

3. Key Contributions

• First General NLO Code with Massive Quarks: This is the first publicly available numerical implementation of NLO DIS structure functions that explicitly includes massive quark effects, crucial for phenomenological applications involving heavy flavors.
• Robust Numerical Formulation: The paper details a specific rewriting of the NLO cross-section terms to separate UV-divergent parts from finite parts, enabling stable Monte Carlo integration. This includes explicit formulas for the special functions ($eIV$, $G^{(a;b)}$, etc.) used in the code.
• Modular C++ Implementation: The code is designed to be flexible, accepting any dipole amplitude model (e.g., from BK fits) and allowing users to configure parameters such as quark masses, running coupling schemes, and integration accuracy.
• Nuclear Extension: While the core code assumes impact-parameter independence (suitable for protons), the authors provide a framework (Section 3.2) to calculate nuclear structure functions using the optical Glauber model approximation, allowing for EIC (Electron-Ion Collider) predictions.

4. Results and Performance

• Validation: The code was tested against known limits. It was confirmed that the program smoothly matches the zero-mass quark results when the quark mass is set to a very small value.
• Performance:
  • On a standard laptop, calculating $F_2$ at a single kinematic point takes approximately 1 minute using safe Monte Carlo settings.
  • The most computationally expensive part is the evaluation of the multi-dimensional integrals.
  • The code is highly parallelizable; since the initialization is fast and memory requirements are modest, it is suitable for global analyses requiring thousands of cross-section evaluations across different kinematic points and initial conditions.
• Example Output: The paper provides a minimal working example calculating $F_2$ at $Q^2=8.5$ GeV$^2$ and $x_{Bj}=0.001$, yielding a value of $\approx 0.876$, demonstrating the code's readiness for phenomenological use.

5. Significance

This work bridges a critical gap between high-precision theoretical QCD calculations and experimental data analysis.

• For Saturation Physics: By enabling NLO calculations with massive quarks, the code allows for more rigorous tests of the saturation scale and the CGC framework, particularly in the transition region between perturbative and non-perturbative regimes.
• For Future Colliders: The tool is specifically designed to support the upcoming Electron-Ion Collider (EIC) program. It enables precise predictions for electron-nucleus scattering, which are essential for identifying gluon saturation signatures in nuclei.
• Global Fits: The ability to run many evaluations in parallel makes this code a vital component for global fits of the dipole amplitude to experimental data, improving the extraction of parton distribution functions (PDFs) and saturation parameters.

In summary, the paper provides a robust, open-source numerical tool that elevates the precision of DIS calculations in the dipole picture, directly addressing the need for NLO accuracy with realistic quark masses in the era of high-precision nuclear physics.