PaperlayerView exact revision on arXiv

Source-linked AI summary

A Higher Order Perturbative Parton Evolution Toolkit (HOPPET)

Gavin P. Salam, Juan Rojo

arXiv:0804.3755v1hep-ph

TL;DR

HOPPET addresses the need for flexible and efficient numerical DGLAP evolution directly in x-space. It combines grid-based higher-order convolutions, cached Runge-Kutta evolution, and extensible PDF interfaces; its accuracy improves substantially with finer grids, while some flavour-representation and scheme operations remain limited.

  • Problem

    Numerical DGLAP evolution must balance flexible x-space inputs against the efficiency and accuracy challenges of repeated convolutions.

  • Method

    HOPPET uses higher-order x-integrations, multiple x-space grids, precomputed information, and Runge-Kutta Q evolution, with interfaces for extending PDF operations.

  • Results

    Reducing grid spacings by a factor of 4 improves accuracy by approximately a factor of 100, and acceptable results are obtained for x < 0.9.

  • Takeaways & Limitations

    The documented package provides fast and accurate x-space evolution while supporting user-defined PDF manipulations beyond built-in DGLAP evolution.

  • Takeaways & Limitations

    Mass thresholds are not currently correctly supported in the DIS scheme, and accuracy is most difficult near x = 1 and near sign changes.

Abstract

from arXiv · show

This document describes a Fortran 95 package for carrying out DGLAP evolution and other common manipulations of parton distribution functions (PDFs). The PDFs are represented on a grid in x-space so as to avoid limitations on the functional form of input distributions. Good speed and accuracy are obtained through the representation of splitting functions in terms of their convolution with a set of piecewise polynomial basis functions, and Runge-Kutta techniques are used for the evolution in Q. Unpolarised evolution is provided to NNLO, including heavy-quark thresholds in the MSbar scheme, and longitudinally polarised evolution to NLO. The code is structured so as to provide simple access to the objects representing splitting functions and PDFs, making it possible for a user to extend the facilities already provided. A streamlined interface is also available, facilitating use of the evolution part of the code from F77 and C/C++.

Program Summary

HOPPET is a Fortran 95 package for x-space DGLAP evolution and PDF manipulation, supporting unpolarised and polarised distributions with fast, cached numerical evolution.

  • The package is distributed as a compressed tar file under the GNU Public License and requires no external files or other programs.The distributed program, including test data, is approximately 270 kB.
  • HOPPET solves DGLAP evolution for unpolarised PDFs up to NNLO and longitudinally polarised PDFs up to NLO.
  • PDFs are represented on an x-space grid, with adaptive integration reducing splitting functions to a discretised form for fast convolutions.
  • Runge-Kutta Q evolution is cached, reducing repeated evolution from new initial conditions to fast computations.
  • Relative accuracy of 10^-4 can be achieved when creating a tabulation from a new initial condition in approximately 10 ms after initialization.The stated benchmark used a 3.4 GHz Pentium IV processor.

1 Introduction

The paper presents HOPPET as a documented, extensible x-space alternative for DGLAP evolution, combining flexible PDF inputs with higher-order numerical methods and speed-oriented implementation.

  • DGLAP evolution reconstructs parton densities across Q and flavours from partial experimental information, supporting predictions for collider processes.The DGLAP equation governs the Q evolution of parton momentum densities through perturbative splitting functions.
  • Mellin methods make convolutions multiplicative and numerically efficient, but require Mellin transforms of splitting functions and initial conditions.
  • x-space methods accept inputs directly in x-space but generally require more convolution work and scale quadratically with ln 1/x_min.Their flexibility has made them widely used despite these efficiency challenges.
  • Higher-order x-space integration faces cancellation limits, whereas Mellin-space Gaussian integration can reach numerical order 2n_p − 1 with accuracy (δx)^2n_p.
  • HOPPET combines higher-order x-integrations and Q evolution with multiple x-grids, precomputation, and accessible PDF operations.Dense grids are used at large x, while coarser grids exploit PDF smoothness at smaller x.
  • The documented release builds on predecessors used in resummation, NLO calculations, and benchmark comparisons, making previously request-only functionality more accessible.

2 Perturbative evolution in QCD

HOPPET organizes perturbative PDF evolution through standard QCD equations, flavour representations, perturbative orders, and threshold matching, while exposing both general and streamlined interfaces.

  • The DGLAP splitting functions are known through NNLO for unpolarised evolution and through NLO for polarised evolution.
  • Evolution of the strong coupling and PDFs supports both fixed-flavour and variable-flavour-number schemes with heavy-quark threshold matching.PDF matching receives non-trivial contributions beginning at NNLO.
  • The human representation follows the LHAPDF flavour ordering, whereas the evln representation simplifies the splitting matrix to a 2 × 2 singlet block plus diagonal non-singlet components.
  • In the evln representation, the gluon couples only to the singlet PDF while non-singlet PDFs evolve independently.Conversion from the human representation requires the user to specify the active-flavour number n_f.
  • Unpolarised evolution is available to NNLO in the MS scheme, while DIS-scheme evolution is limited to NLO.
  • Mass thresholds are not currently supported correctly in the DIS scheme.

3 Numerical techniques

HOPPET discretises PDFs and their convolutions on an x-space grid, using interpolation and evolution operators to solve DGLAP evolution efficiently. Higher-order interpolation and special large-x strategies support accuracy and compact representations.

  • Grid representation: PDFs are represented by interpolating xq(x,t) at grid points y = ln 1/x, using n + 1 nearby points for interpolation order n.Interpolating xq rather than q is numerically advantageous because xq is generally smoother.
  • Interpolation: Piecewise interpolating polynomials are chosen for convolution integration, trading grid-point smoothness for speed and accuracy relative to splines.The interpolation functions are designed for the numerical integration required by convolutions.
  • Convolution matrices: Uniform spacing in y makes the convolution matrix translation invariant, so Pαβ depends only on α − β and can be stored compactly.This structure reduces storage from O(Nx^2)-like indexing to a representation with entries determined by index differences.
  • Large-x treatment: The two large-x interpolation choices use either only points with x ≤ 1 or artificial zero-valued points beyond x = 1.The first stores O(Nx n) distinct entries near the boundary; the second stores O(Nx) entries with Pα−β = 0 for α < β.
  • Q evolution: The grid-represented DGLAP equations can be solved with higher-order iterative Runge-Kutta methods, while translation invariance allows evolution of a single matrix column.The resulting Mαβ(t) is called the evolution operator.

4 Single-flavour grids and convolutions

HOPPET provides Fortran 95 grid, PDF, and convolution objects with routines for allocation, interpolation, convolution, evolution setup, and user-defined splitting functions. Its grid design concentrates points where large-x accuracy is most difficult, while its array-based interfaces retain some usability constraints.

  • Grid definitions: The central PDF-evolution object is a derived-type grid storing information about the y = ln 1/x grid.The package is written in Fortran 95 and exposes both direct modules and the broader hoppet interface.
  • Grid definitions: Multiple sub-grids can combine coarser small-x coverage with finer large-x coverage to improve convolution precision without excessive point density.A locked combined grid propagates information from finer grids to coarser ones and imposes compatible spacing requirements.
  • Single-flavour grid quantities: Grid quantities such as xg(x) are allocated as arrays, initialised from functions, and evaluated at arbitrary y or x through routines and overloaded operators.EvalGridQuant requires the grid argument because the array itself stores no grid information.
  • Scope and constraints: Large-x evolution requires denser grid coverage because the logarithmic derivative of typical PDFs diverges there, while the array representation requires the grid to be supplied separately.The latter is identified as a drawback of using Fortran 95.
  • Single-flavour grid quantities: Arithmetic placement matters for efficiency: multiplying a grid array before evaluation processes the full array, whereas multiplying the evaluated value processes only one result.The direct EvalGridQuant form is identified as the most efficient of the illustrated options.
  • Convolution objects: Convolution operators use derived types that are allocated and initialised from user-supplied splitting functions returning xPgg(x) and related components.The example constructs a grid_conv object for the gg leading-order splitting function and handles delta-function components explicitly.

5 Multi-flavour grids and convolutions

HOPPET represents multi-flavour PDFs as grid arrays and manages human and evolution flavour representations to support efficient DGLAP convolutions.

  • PDF representation: Full-flavour PDFs are represented as arrays with an extra flavour dimension, using two-dimensional arrays for single PDFs and three-dimensional arrays for PDF collections.Allocation routines can create these arrays automatically.
  • PDF representation: The grid occupies the first array dimension, while flavour indices span -6:7 because the upper slot stores representation information.The representation label is stored in PDF(:,7).
  • Flavour representations: HOPPET uses the human representation for user-facing PDFs and the evln representation internally, where the splitting matrix has only the indices 0, 1 block non-diagonal.The evln representation depends on nf, unlike the human representation.
  • Flavour representations: Users can convert PDFs between human and evln representations with CopyHumanPdfToEvln and CopyEvlnPdfToHuman, specifying the active-flavour count for evln.GetPdfRep checks the representation, while automatic conversions occur around convolutions.
  • Convolution performance: Representation changes cost O(Nx), whereas convolutions cost O(N^2x), but repeated convolutions at low Nx can make manual conversion advantageous.Keeping a PDF in evln form across multiple convolutions avoids repeated conversion overhead.

6 DGLAP evolution

HOPPET evolves multi-flavour PDFs by combining running-coupling information, splitting matrices, threshold matching, and Runge-Kutta integration in a scale variable related to ln ln Q.

  • Running coupling: A running-coupling object stores coupling parameters, quark pole masses, matching-scale choices, and optional fixed-flavour settings.Defaults include Q = 91.2, αs = 0.118, and muMatch_mQuark = 1.0.
  • Running coupling: The running coupling is solved numerically for 1/αs with an nloop β-function and appropriate mass thresholds.For typical αs(MZ), the coupling is reliably determined over 0.5 GeV < Q < 10^19 GeV.
  • Evolution procedure: PDF evolution is split into uniform steps in a variable u related to ln ln Q, with each step solved using a Runge-Kutta approximation.The default step size is du = 0.1.
  • Evolution procedure: The finite-step evolution error scales as (du)^4, and the default du = 0.1 typically gives errors below 10^-3.This estimate is tied to the detailed benchmarks referenced by the paper.
  • Threshold matching: Variable-flavour evolution implements NNLO mass-threshold matching, whose upward and downward operations differ only at order αs^4, beyond currently known accuracies.The mismatch arises because the convolution uses different PDF flavour counts in the two directions.
  • Threshold matching: An evln_operator chains fixed-flavour evolution operators with threshold matrices so complete evolutions can cross flavour thresholds.This addresses the fixed-nf validity of individual derived splitting matrices.

7 Tabulated PDFs

HOPPET tabulates PDFs across Q so users can query evolved distributions at arbitrary x and Q, while reusing precomputed evolution for repeated initial conditions.

  • PDF tables: A pdf_table stores the tabulated PDF values, Q points, active-flavour information, and coupling values across the chosen Q range.The tabulation’s third dimension spans the Q values.
  • PDF tables: Tables are allocated over Qmin to Qmax with configurable dlnlnQ spacing, interpolation order, and below-range freezing or zeroing.The default dlnlnQ is 0.07 and the default interpolation order is 3.
  • Threshold handling: Threshold information must be added to a table to avoid interpolation across discontinuities at NNLO.The coupling’s threshold data is transferred with AddNfInfoToPdfTable.
  • Table construction: A table can be filled from an LHAPDF-style routine or by evolving an initial PDF across all tabulated Q values.EvolvePdfTable uses the same evolution arguments as EvolvePDF.
  • Repeated evolution: Precomputed evolution operators can accelerate repeated table evolution with different initial PDFs, but changing evolution parameters requires rebuilding the table.The operators cover successive Q intervals in the table.
  • Table access: Users can evaluate all flavour components at specified y,Q or x,Q values through EvalPdfTable_yQ and EvalPdfTable_xQ.The table can also expose internal arrays for systematic convolutions.

8 Streamlined interface

The streamlined interface exposes HOPPET’s core PDF evolution through a single-grid, non-object-oriented API for F77 and C/C++, including fixed- or variable-flavour schemes and cached evolution.

  • Interface design: The streamlined interface hides HOPPET’s object-oriented structure and provides access to one PDF table based on a single grid definition.The C++ interface is essentially identical, with case-sensitive names and zero-based PDF component indexing.
  • Initialization: hoppetStart initializes a compound grid, Q tabulation range, and splitting functions through the requested loop order, while hoppetStartExtended exposes these choices.The extended routine controls y and Q ranges, spacings, numerical order, and evolution type.
  • Evolution setup: Users choose fixed-flavour or variable-flavour evolution with hoppetSetFFN or hoppetSetVFN, the latter taking heavy-quark pole masses.The default setup uses variable-flavour evolution.
  • Evolution setup: hoppetEvolve accepts the coupling, perturbative order, scale ratio, initial-condition routine, and starting PDF scale, with LHAsub returning momentum densities.LHAsub is called only at Q = Q0pdf.
  • Cached evolution: Cached evolution is intended for many PDF sets with identical evolution properties and runs 3–4 times faster after preparation.Preparation takes 2–10 times longer than a normal evolution, depending on perturbative order.
  • Cached evolution: Cached results may differ slightly from normal evolution because some information is lost during caching, so users should check whether the differences matter.This is an author-stated practical caveat of the cached mode.

9 Benchmarks

The benchmarks assess hoppet’s correctness, accuracy, and speed against finely resolved reference evolutions, showing that grid choices and cached tabulations control the accuracy–runtime trade-off. Multiple x-space subgrids improve the difficult large-x region, while sign-changing flavour channels require exclusion from global relative-accuracy estimates.

  • Benchmark setup: hoppet’s correctness was benchmarked against the Mellin-space evolution code QCD-Pegasus using finely spaced grids to keep numerical errors below approximately 10^-7.The benchmark program is provided with the package for comparison and debugging of independent implementations.
  • Benchmark setup: For most physical applications, relative accuracy of 10^-3 to 10^-4 is generally adequate, making speed especially important in PDF fitting.Other uncertainties, including Monte Carlo integration and experimental errors, are rarely comparably small.
  • Accuracy assessment: The accuracy tests compare coarse-grid tabulations with a fine-grid reference over 5000 points in the x,Q plane using the same initial conditions and evolution parameters.The tested evolution uses NNLO variable-flavour-number evolution with heavy-quark thresholds and the stated reference grid parameters.
  • Accuracy assessment: Reducing grid spacings by a factor of 4 improves accuracy by approximately a factor of 100, while accuracy is poorest near x = 1 because PDFs vanish rapidly there.Multiple nested x-grids nevertheless provide acceptable results for x < 0.9, a range identified as phenomenologically relevant.
  • Accuracy assessment: Sign-changing channels are excluded near their zeros because relative accuracy diverges there, including charm near x ≃ 7 × 10^-3 and anti-up at large x.The exact excluded region is somewhat arbitrary, but the authors regard the chosen region as reasonable for the reported estimates.
  • Timing: For timing, dy = 0.2 and dlnlnQ = 0.05 yield approximately 10^-4 accuracy, while cached PDF evaluation reaches 10^-4 in about 10^-2 s and 10^-6 in about 10^-1 s.Evaluating PDFs from a completed tabulation is typically about 4–5 times faster than creating the tabulation.

10 Conclusions

hoppet provides fast, accurate x-space evolution with an interface for manipulating PDFs beyond DGLAP evolution. Its documented scope also identifies several important physics extensions for future work.

  • hoppet combines high accuracy and speed in x-space evolution with an interface for manipulating PDFs beyond built-in DGLAP evolution.
  • Future releases could add DIS coefficient functions, full DIS factorisation-scheme support, and time-like evolution for fragmentation-function fits.
  • No general public code was identified for matching resummed calculations with fixed NLO or NNLO splitting functions.
  • A more general heavy-quark mass treatment remains an extension motivated by heavy-flavour structure-function data and sizable effects on LHC predictions.
  • QCD+electroweak evolution is another demanding extension because it requires electroweak flavour couplings, CKM mixing, and polarisation.
  • hoppet’s separation of numerical and flavour aspects, together with verified unpolarised and polarised evolution, provides a starting point for such developments.

A.1 General interface

The examples demonstrate both the general and streamlined interfaces for constructing, evolving, tabulating, and evaluating PDFs. They include NNLO benchmark output and equivalent access from F95, F77, and C/C++.

  • General interface: The general-interface example initializes a grid, splitting-function holder, running coupling, PDF, and PDF table before evolving and evaluating PDFs.
  • General interface: The grid uses four nested subgrids with progressively finer spacing toward larger x.
  • General interface: At Q = 100 GeV, the example evaluates flavour combinations and the gluon at x values from 1.0E-05 to 9.0E-01.
  • General interface: The output corresponds to variable-flavour-number evolution with µF = µR and parametrised NNLO splitting functions and mass-threshold terms.
  • Streamlined interface: The streamlined example produces exactly the same output while exposing simplified evolution and evaluation calls.

A.3 Accessing tables

The package supports shared access to user-defined PDF tables and their associated evolution objects from external procedures. Examples show pre-evolution, evolution, and evaluation through a common module.

  • A common external module can hold the PDF table, splitting-function holder, running coupling, and optionally the grid.
  • External procedures use the shared objects to pre-evolve or evolve a table and evaluate PDFs at specified x and Q values.
  • The reference guide summarizes the streamlined and general interfaces and their principal modules and methods.

C Initialisation of grid quantities

The initialization facilities support compound grids, multiple PDF input conventions, and normal or cached evolution. They expose both subroutine-based and direct grid-quantity construction.

  • Grid and evolution initialization: Compound grids use spacing dy at small x, with nested subgrids available for initialization.
  • Grid and evolution initialization: The streamlined setup can define a Q range from 1 GeV to 28 TeV and configure fixed- or variable-flavour evolution.
  • Grid and evolution initialization: PDF evolution specifies the coupling scale, evolution loop count, and the relation of renormalization to factorization scales.
  • Grid and evolution initialization: Cached evolution uses an LHAPDF-like initial-condition routine called only at Q0pdf.
  • PDF initialization and access: On return, the PDF routine provides all flavours multiplied by x at the requested x and Q values.
  • PDF initialization and access: Grid quantities can be initialized from a subroutine or directly from xValues or yValues, while multi-flavour PDFs can use an LHAPDF-compatible routine.
  • PDF initialization and access: Direct initialization avoids writing a separate subroutine but requires additional allocation and deallocation.
  • Memory management: The general interface requires explicit memory allocation for grid quantities and PDF sets, whereas other initialized types allocate automatically and can be freed with Delete(...).

D NNLO splitting functions

HOPPET supports exact and parametrised NNLO splitting functions, balancing fidelity against the time required to construct the splitting matrices. Users can select among several NNLO variants before matrix initialisation.

  • Exact NNLO splitting functions: Exact NNLO splitting functions use multi-page harmonic-polylogarithm expressions supplied as Fortran code and evaluated with the included hplog package.The expressions have harmonic-polylogarithm weight up to 4.
  • Parametrised NNLO splitting functions: The default parametrised NNLO splitting functions are accurate to within 0.1%, with an evolution impact typically of about 10−5 relatively.Their smaller practical impact reflects suppression by two powers of αs.
  • Computational trade-offs: Exact NNLO splitting matrices for the full range of nf take of the order of minutes to construct.The documentation notes that the package cannot currently store splitting matrices in a file.
  • Selecting NNLO variants: Users select exact or parametrised NNLO splitting functions through dglap_Set_nnlo_splitting before initialising the splitting matrices.The available variants include exact, parametrised, and three fits based on reduced moment information.
  • Selecting NNLO variants: The reduced-moment parametrisations are mainly of historical interest because full NNLO results are now available.These fits were previously an important step toward full NNLO results.
Loading 0804.3755v1…