Computing an EKO

First things first, we need to import our beloved package :)

import pathlib

import eko

eko.version.__version__

'0.0.0'

At this point, we are already almost ready to run an eko calculation, but we need to tell to eko what to compute.

By design, eko follows a “no default” approach, so the user has to spell out all the relevant options in order to start a calculation, and no sensible defaults are applied by the program itself. This is done in order to reduce the amount of unexpected behavior, that can result in unpredictable and difficult to debug differences for the end user.

In order to avoid surprises, please take care to review your choices, and their meaning.

In this example, we are going to use some runcards internally used for debugging. The options in there are in no way better than any other. For the calculation you are going to run, you are expected to know which are the appropriate values. In case of doubts, read the docs, or contact the authors (e.g. through the repository issues).

from ekobox.cards import example

th_card = example.theory()
op_card = example.operator()
# here we replace the grid with a very minimal one, to speed up the example
op_card.xgrid = [1e-3, 1e-2, 1e-1, 5e-1, 1.0]

Before starting, let’s have a look to these cards.

th_card.raw

{'order': [1, 0],
 'couplings': {'alphas': 0.118,
  'alphaem': 0.007496252,
  'ref': [91.2, 5],
  'em_running': False},
 'heavy': {'masses': [[2.0, nan], [4.5, nan], [173.07, nan]],
  'masses_scheme': 'pole',
  'matching_ratios': [1.0, 1.0, 1.0]},
 'xif': 1.0,
 'n3lo_ad_variation': [0, 0, 0, 0, 0, 0, 0],
 'use_fhmruvv': True,
 'matching_order': [0, 0]}

From there we can see we are that we are doing a LO calculation ('order': [1, 0] -> \(a_s^1 a_{em}^0\)), with the strong coupling \(\alpha_s(\mu_0 = 91.2\,\text{GeV})^{(n_f^0 = 5)} = 0.118\) and \(m_c=2\,\text{GeV}\), \(m_b=4.5\,\text{GeV}\), and \(m_t=173.07\,\text{GeV}\).

op_card.raw

{'init': [1.65, 4],
 'mugrid': [[100.0, 5]],
 'xgrid': [0.001, 0.01, 0.1, 0.5, 1.0],
 'configs': {'evolution_method': 'iterate-exact',
  'ev_op_max_order': [10, 0],
  'ev_op_iterations': 10,
  'scvar_method': None,
  'inversion_method': None,
  'interpolation_polynomial_degree': 4,
  'interpolation_is_log': True,
  'polarized': False,
  'time_like': False,
  'n_integration_cores': 1},
 'debug': {'skip_singlet': False, 'skip_non_singlet': False},
 'eko_version': '0.0.0'}

From there we can see that we are evolving PDFs from \(f^{(n_f^0=4)}(Q_0 = 1.65\,\text{GeV})\) to \(f^{(n_f^1=5)}(Q_1 = 100\,\text{GeV})\) using 5 interpolation points ([0.001, 0.01, 0.1, 0.5, 1.0]).

Note that PDFs are defined both by their scale \(Q\) and the number of active flavors \(n_f\) - we refer to the tuple as Evolution Point, e.g. \(e_1 = (Q_1, n_f^1)\). This concept also applies to other perturbative QCD objects, e.g., to reference value of the strong coupling constant mentioned above.

And now, let’s run our first eko calculation:

path = pathlib.Path("./myeko.tar")
path.unlink(missing_ok=True)
eko.solve(th_card, op_card, path)

The actual result is a complicate EKO object, which we will discuss it in a separate tutorial.

You have just run your first DGLAP calculation!