eko.runner package

Manage steps to DGLAP solution, and operator creation.

class eko.runner.OperatorCard(init: Tuple[float, int], mugrid: List[Tuple[float, int]], xgrid: XGrid, configs: Configs, debug: Debug, eko_version: str = '0.15.2')

Bases: DictLike

Represents specific operator settings.

This describes the specific settings for a given set of operator, rather than the general theory settings. Important settings are e.g. the initial and final evolution points, or the solution method.

init: Tuple[float, int]

Initial evolution point.

mugrid: List[Tuple[float, int]]

Final list of evolution points.

xgrid: XGrid

Momentum fraction interpolation grid.

configs: Configs

Specific configuration to be used during the calculation of these operators.

debug: Debug

Debug configurations.

eko_version: str = '0.15.2'

Version of EKO package used for generation.

property mu20

Squared value of initial scale.

property mu2grid: ndarray[tuple[int, ...], dtype[_ScalarType_co]]

Grid of squared final scales.

property evolgrid: List[Tuple[float, int]]

Grid of squared final evolution points.

property pids

Internal flavor basis, used for computation.

class eko.runner.TheoryCard(order: Tuple[int, int], couplings: CouplingsInfo, heavy: HeavyInfo, xif: float, n3lo_ad_variation: Tuple[int, int, int, int, int, int, int], use_fhmruvv: bool | None = True, matching_order: Tuple[int, int] | None = None)

Bases: DictLike

Represents general theory settings.

This describes the general settings, which define the parameters for the general framework rather than a specific operator. Important settings are e.g. perturbative order, quark masses, or the reference value of the couplings.

order: Tuple[int, int]

Perturbative order tuple, (QCD, QED).

The entries correspond to the power of the respective couplings, e.g. (1,0) refers to \(a_s^1 a_{em}^0\), i.e. LO QCD evolution.

couplings: CouplingsInfo

Couplings configuration.

heavy: HeavyInfo

Heavy quarks related information.

xif: float

Ratio between factorization scale and process scale.

n3lo_ad_variation: Tuple[int, int, int, int, int, int, int]

(gg, gq, qg, qq, nsp, nsm, nsv).

Type:

N3LO anomalous dimension variation

use_fhmruvv: bool | None = True

If True use the FHMRUVV N3LO anomalous dimensions.

matching_order: Tuple[int, int] | None = None

Matching conditions perturbative order tuple, (QCD, QED).

Similar, to order the entries refer to the powers of the respective couplings. QED OME are currently not available. Note that for LO QCD evolution one needs (0,0) as matching_order, because the matching conditions are shifted by one order (since they are related to processes). If not provided it will use this assumption as default.

eko.runner.solve(theory: TheoryCard, operator: OperatorCard, path: Path)

Solve DGLAP equations in terms of evolution kernel operators (EKO).

Submodules

eko.runner.commons module

Runners common utilities.

eko.runner.commons.interpolator(operator: OperatorCard) → InterpolatorDispatcher

Create interpolator from runcards.

eko.runner.commons.atlas(theory: TheoryCard, operator: OperatorCard) → Atlas

Create thresholds atlas from runcards.

eko.runner.commons.couplings(theory: TheoryCard, operator: OperatorCard) → Couplings

Create couplings from runcards.

eko.runner.managed module

Fully managed runner.

This is an automated runner, mainly suggested for small EKOs computations.

The primitives used here to compute the various pieces are part of the public interface, and should be directly used to manage a more complex run for a considerably large operator.

Thus, parallelization and multi-node execution is possible using EKO primitives, but not automatically performed.

eko.runner.managed.solve(theory: TheoryCard, operator: OperatorCard, path: Path)

Solve DGLAP equations in terms of evolution kernel operators (EKO).

eko.runner.operators module

Combine parts into operators.

eko.runner.operators.retrieve(ep: Tuple[float, int], eko: EKO) → List[Operator]

Retrieve parts required for the given evolution point operator.

eko.runner.operators.join(elements: List[Operator]) → Operator

Join the elements into the final operator.

Note

Since the matrices composing the path have to be multiplied from the destination to the origin, the input order, coming from path (which is instead origin -> target), is being reversed.

Todo

consider if reversing the path…

eko.runner.parts module

Compute operator components.

Todo

This is the only part of the new runner making use of the global context through the EKO object.

After #242, the goal is to update Operator and OperatorMatrixElement to simplify the computation and passing down parameters.

eko.runner.parts.evolve(eko: EKO, recipe: Evolution) → Operator

Compute evolution in isolation.

eko.runner.parts.match(eko: EKO, recipe: Matching) → Operator

Compute matching in isolation.

Note

Compared to the old prescription, a dedicated rotation to a different intrinsic basis is not needed any longer.

All the operators are blown up to flavor basis, and they are saved and joined in that unique basis. So, the only rotation used is towards that basis, and encoded in the blowing up prescription.

eko.runner.recipes module

Recipes containing instructions for atomic computations.

eko.runner.recipes.create(eko: EKO)

Create and load all associated recipes.