R E C O L AREcursive Computation of One-Loop Amplitudes 1footnote 11footnote 1The program is available from http://recola.hepforge.org.

R E C O L a
REcursive Computation of One-Loop Amplitudes 111The program is available from http://recola.hepforge.org.

Stefano Actis stefano.actis@gmail.com Ansgar Denner ansgar.denner@physik.uni-wuerzburg.de Lars Hofer hofer@ecm.ub.edu Jean-Nicolas Lang jlang@physik.uni-wuerzburg.de Andreas Scharf ascharf@physik.uni-wuerzburg.de Sandro Uccirati uccirati@to.infn.it Lilienstrasse 7, 5200 Brugg AG, Switzerland Universität Würzburg, Institut für Theoretische Physik und Astrophysik,
D-97074 Würzburg, Germany
Department de Física Quàntica i Astrofísica (FQA),
Institut de Ciències del Cosmos (ICCUB), Universitat de Barcelona (UB),
Martí Franquès 1, E-08028 Barcelona, Spain
Università di Torino e INFN, 10125 Torino, Italy
Abstract

We present the Fortran95 program Recola for the perturbative computation of next-to-leading-order transition amplitudes in the Standard Model of particle physics. The code provides numerical results in the ’t Hooft–Feynman gauge. It uses the complex-mass scheme and allows for a consistent isolation of resonant contributions. Dimensional regularization is employed for ultraviolet and infrared singularities, with the alternative possibility of treating collinear and soft singularities in mass regularization. Recola supports various renormalization schemes for the electromagnetic and a dynamical -flavour scheme for the strong coupling constant. The calculation of next-to-leading-order squared amplitudes, summed over spin and colour, is supported as well as the computation of colour- and spin-correlated leading-order squared amplitudes needed in the dipole subtraction formalism.

keywords:
NLO computations; one-loop amplitudes; higher orders
journal: Computer Physics Communications

PROGRAM SUMMARY

Manuscript Title: Recola: REcursive Computation of One-Loop Amplitudes
Authors: Stefano Actis, Ansgar Denner, Lars Hofer, Jean-Nicolas Lang, Andreas Scharf, Sandro Uccirati
Program Title: Recola
Journal Reference:
Catalogue identifier:
Licensing provisions: GNU GPL version 3
Programming language: Fortran95
Computer: any with a Fortran95 compiler
Operating system: Linux, Mac OS X
RAM: Depends on the nature of the problem, typically 1GB for a process.
Number of processors used: one
Supplementary material: none
Keywords: NLO computations, radiative corrections, one-loop amplitudes; higher orders
Classification:
4.4 Feynman diagrams, 11.1 General, High Energy Physics and Computing
External routines/libraries: Collier library
Subprograms used: none
Nature of problem:
Evaluation of general tree-level and one-loop scattering amplitudes occurring in the calculation of observables in relativistic quantum field theories
Solution method:
Tree-level and one-loop amplitudes are numerically calculated using a recursive algorithm. For one-loop amplitudes numerical results for tensor integrals are needed as input. These are provided by the Collier library. In addition, contributions of counterterms and rational terms are determined via dedicated Feynman rules.
Restrictions:
The code has been used for processes with up to 7 external particles at one-loop level and up to 9 external particles at tree level. For large multiplicities available internal storage may cause limitations.
Additional comments: none
Running time: Depends on the nature of the problem, typically 100ms for a process.

1 Introduction

The experimental studies at present and future high-energy colliders are focused on the precise determination of the free parameters of the Standard Model (SM) and on the search for new physics. The interpretation of the data often relies on accurate theoretical predictions based on perturbation theory, requiring detailed calculations beyond the leading-order (LO) approximation. In the past years, many groups have concentrated their efforts on next-to-leading-order (NLO) calculations (see e.g. Refs. Campbell:2013qaa (); Andersen:2014efa (); Bern:2008ef (); Binoth:2010nha (); AlcarazMaestre:2012vp ()), and alternative strategies to the traditional Feynman-diagrammatic approach have been developed, which helped to automatize and speed up the calculation of NLO amplitudes. One class of methods makes use of generalized unitarity relations or of amplitude reduction at the integrand level in order to directly express one-loop amplitudes in terms of scalar integrals Bern:1994zx (); Bern:1994cg (); Britto:2004nc (); Ossola:2006us (); Ellis:2007br (); Giele:2008ve (); Ellis:2008ir (); vanHameren:2009dr (). Other methods instead rely on higher-rank tensor integrals, either via an improved diagrammatic approach Cascioli:2011va () or employing one-loop recursion relations vanHameren:2009vq (); Actis:2012qn (). Finally, yet another strategy consists in performing a simultaneous numerical integration over the phase space and the loop momentum of NLO amplitudes Nagy:2003qn (); Becker:2010ng (); Duplancic:2016lzh ().

The traditional as well as the new techniques for the calculation of one-loop amplitudes have been implemented in many codes such as FeynArts/ FormCalc Hahn:2000kx (); Agrawal:2012cv (); Nejad:2013ina (), CutTools Ossola:2007ax (), Blackhat Berger:2008sj (), Helac-1loop vanHameren:2009dr (), NGluon Badger:2010nx (), Samurai Mastrolia:2010nb (), Madloop Hirschi:2011pa (), GoSam Cullen:2011ac (), and OpenLoops Cascioli:2011va (). In this article we present the Fortran95 library Recola for the generation of tree-level and one-loop amplitudes in the SM. While almost all of the above-listed programs were developed with a focus on QCD corrections111FeynArts/FormCalc allows to perform calculations in more general scenarios in and beyond the SM, though with less emphasis on high multiplicities and CPU performance., Recola has been designed from the beginning with the main objective of facilitating an automated calculation of electroweak (EW) corrections. Recently, EW corrections have been included also in OpenLoops Kallweit:2014xda (); Kallweit:2015dum () and MadGraph5_aMC@NLO Frixione:2014qaa (); Frixione:2015zaa (). Recola further differs from other public codes in the implemented method as it makes consequent use of a recursive construction of one-loop off-shell currents following the technique described in Ref. Actis:2012qn (). It has successfully applied for the calculation of EW corrections to the processes Denner:2014ina () and  Biedermann:2016yvs (), and for the calculation of QCD corrections to the process  Denner:2015yca ().

For the evaluation of the one-loop integrals, a task that demands high standards with respect to numerical stability and CPU performance, amplitude generators are either equipped with own internal implementations, or they rely on external libraries like FF vanOldenborgh:1990yc (), LoopTools Hahn:1998yk (), QCDLoop Ellis:2007qk (), OneLOop vanHameren:2010cp (), Golem95C Cullen:2011kv (), PJFry Fleischer:2010sq (), Package-X Patel:2015tea (), and Collier Denner:2014gla (); Denner:2016kdg (). In the case of Recola, the public Fortran95 library Collier is used which achieves a fast and stable calculation of tensor integrals via the strategies developed in Refs. Denner:1999gp (); Denner:2005fg (); Denner:2010tr ().

The available one-loop generators do not only differ in the class of computations they can perform, but also in the level of automation and in the cost of performance (speed and memory). The latter is an essential aspect because typical Monte-Carlo simulations require a huge number of evaluations of the matrix element for each partonic process in order to obtain a sufficient statistical accuracy. To this end, in the development of Recola a big effort has been invested in the optimization of the performance in order to permit the fast “on-the-fly” generation and evaluation of NLO matrix elements. This strategy is complementary to the one used by other groups, as for example the Blackhat collaboration, who have developed a flexible storage format of pre-calculated matrix elements for partonic events in large Root -tuple files Bern:2013zja (), which are then read by the Monte Carlo generator.

This article is organized as follows: In Section 2 we describe the basic features of Recola; Section 3 gives the user the necessary information on how to download and install the Recola library. Section 4 explains the usage of Recola and gives a detailed description of its input parameters and of all subroutines that can be called by the user. Finally, in Section B we list the processes that have been checked against other programs and we conclude in Section 5.

2 Basic features of Recola

Recola is a Fortran95 code for the computation of tree-level and one-loop scattering amplitudes in the SM, based on recursion relations Actis:2012qn ().

The algorithm to compute the tree-level amplitude is inspired by the Dyson–Schwinger equations Dyson:1949ha (); Schwinger:1951ex (); Schwinger:1951hq (). The recursion relations for the one-loop amplitudes are more involved and rely on the decomposition of the one-loop amplitude in terms of tensor integrals (TIs) and tensor coefficients (TCs) :

(1)

Here, is the contribution from the counterterms. In order to regularize ultraviolet (UV) singularities the TIs are treated in dimensional regularization by introducing the variable space-time dimension together with the mass scale :

(2)

Here, is the number of propagators in the loop, the rank of and

(3)

UV singularities of the TIs manifest themselves as poles in , and they are cancelled by analogous singularities present in the counterterm amplitude , which can be built from tree-level topologies involving counterterm vertices Denner:1991kt ().

Based on an idea by van Hameren vanHameren:2009vq (), a recursive procedure to compute the TCs numerically has been developed Actis:2012qn () and implemented in Recola. In this framework the indices are taken strictly 4-dimensional (with values ), and the -dimensional part of the contraction between the TCs and TIs in is taken into account in the form of an additional rational part (of type Ossola:2008xq ()):

(4)

The hat on the indices indicates that they run over the 4 dimensions . The tensor integrals are computed in Recola by means of an interface with the Collier library Denner:2014gla (). The contribution is determined evaluating tree-level-like topologies with special Feynman rules Ossola:2008xq (); Draggiotis:2009yb (); Garzelli:2009is (); Shao:2011tg () similar to those for the counterterms.

2.1 Collinear and soft singularities

Collinear singularities originating from light fermions can be treated in Recola either in dimensional or in mass regularization. For each fermion an individual choice can be made: If a fermion is defined as massless, collinear divergences stemming from this fermion are regularized dimensionally. If on the other hand it has been assigned a (regulator) mass, its collinear singularities are regularized by the corresponding mass parameter.

Soft singularities are either regularized dimensionally or by assigning a mass regulator to photons and gluons. The second case is allowed in Recola only if collinear singularities are treated in mass regularization for all fermions.

2.2 Dimensional regularization

If dimensional regularization is used for collinear or soft singularities, poles in of infrared (IR) origin are generated in together with a dependence on the scale . In order to distinguish this and  dependence of IR origin from the one of UV origin, Recola introduces the separate parameters , and , in all TIs and counterterms, together with

(5)

Following the conventions of Collier Denner:2014gla (); Denner:2016kdg () and Ref. Denner:2010tr (), the parameters , and that contain the poles in absorb a normalization factor of the form . In terms of these parameters, the one-loop amplitude takes the general form

(6)

The term vanishes after renormalization. The a priori unphysical scale should either cancel between the TIs and the counterterms, or it should receive a physical interpretation as for example when it is identified with the renormalization scale in the scheme for the strong coupling constant . In Recola, however, the renormalization scale is kept independent from . In this way, also -renormalized amplitudes are independent of but depend on instead.

The counterterm , relating the bare and the renormalized strong coupling constants and according to is defined as

(7)

where is the number of active (light) flavours and runs over the inactive (heavy) flavours. According to eq. (7), the contribution from active flavours is renormalized within the scheme, while the one from inactive flavours is subtracted at zero momentum transfer. The classification into active and inactive flavours defines the flavour scheme. In Recola the user can choose between:

  • The variable-flavour scheme: All quark flavours lighter than are considered as active, the remaining ones are treated as inactive.

  • The -flavour scheme: The lightest quarks are considered active, the remaining ones are treated as inactive. In this case, cannot be chosen lower than the number of massless quarks.

After renormalization, the one-loop amplitude becomes

(8)

Recola performs a numerical computation of the complete amplitude , with the values for , , and supplied by the user. The contribution can be obtained by setting (default). Since the computation of involves objects depending on and at intermediate steps, numerical values for these variables must be given as well. The independence of on and can be verified numerically by varying these parameters. Recola provides default values for all the above-mentioned parameters that can be changed by the user.

2.3 The strong coupling constant

The renormalized strong coupling constant depends on the renormalization scale . It is appropriate to choose a value for of the order of the energy scale characteristic for the process in question and to take as coupling constant the corresponding value for .

Often, in the computation of physical processes the scale is defined from the momenta of the external particles and is thus assigned a different value for each phase-space point. The possibility to use such a dynamical scale is supported by Recola, and the respective values for the running can either be supplied by the user or computed by Recola. In the latter case, the value for at the scale is determined from its value at the initialization scale , by means of the following one- and two-loop formulas in the -flavour scheme Ellis:1991qj ():

1-loop running: (9)
2-loop running: (10)

Here, we have introduced

(11)
(12)

2.4 Electroweak renormalization

Due to the presence of massive and unstable gauge bosons in the EW sector of the SM, complex masses have to be introduced without spoiling gauge invariance. This is achieved in Recola by using the complex-mass scheme of Refs. Denner:1999gp (); Denner:2005fg (); Denner:2006ic (). The user can, however, also choose to proceed in the on-shell scheme, where only the real part of the self-energies is taken for the computation of the counterterms and the imaginary part of the masses is kept only in the denominator of propagators.

For the renormalization of the EW coupling constant , the user can choose between three different schemes:

  • scheme:
    In this scheme the renormalized electromagnetic coupling is derived from the Fermi constant , measured in muon decay, and the masses of the and  bosons via the tree-level relation:

    (13)
  • scheme:
    In this scheme is fixed from the value measured in Thomson scattering at .

  • scheme:
    In this scheme is renormalized at the pole, thus implicitly taking into account its running from to .

2.5 Amplitude structure

In general, the amplitude of a process depends on helicities and colours of external particles. For a process with external legs we introduce the notation

(14)

The variable () defines the helicity of the external particle and can take the values or for fermions and massless vector bosons, and the values , or for massive vector bosons (see Section 2.9 for the conventions used in Recola). For scalar particles it necessarily assumes the value . The variable () defines the colour of the external particle and can take the values for quarks and anti-quarks, and the values for gluons, while it is absent for colourless particles.

According to the decomposition , the colour-octet representation of the gluon can be related to the product of the fundamental and anti-fundamental representation of quarks and anti-quarks. The colour content of the amplitude can thus alternatively be expressed in the so-called colour-flow representation, where the colour of the gluons is represented by means of a pair of indices taking the values (see Refs. Actis:2012qn (); Kanaki:2000ms (); Maltoni:2002mq () for details). Following this approach we write the amplitude as

(15)

The colour index () is absent for colourless particles, incoming quarks and outgoing anti-quarks, while it takes the values for gluons, incoming anti-quarks and outgoing quarks. Similarly, the anti-colour index () is absent for colourless particles, incoming anti-quarks and outgoing quarks, while it takes the values for gluons, incoming quarks and outgoing anti-quarks. The unphysical colour-singlet component, implicitly contained in the decomposition of the representation of the gluons, is eliminated by requiring

(16)

if particle is a gluon. The two parametrizations (colour-octet vs. colour-flow representation of the gluon) are related through

(17)
(18)

where the sums run over the colour indices present in and , respectively. The matrices are given by

(19)

where () are the usual Gell-Mann matrices.222In our convention, the are normalized according to . Note that, while Recola exclusively works in the colour-flow formalism, we give all formulae in both representations to allow for an easy translation from one to the other.

In the colour-flow representation the colour part of the Feynman rules contains products of Kronecker s, and the colour structure of the amplitude can be obtained as a linear combination of all possible structures built from products of Kronecker s carrying the colour indices of the external particles:

(20)

Here, the sum runs over all possible permutations of the labels of external gluons, incoming quarks, and outgoing anti-quarks. The amplitudes are called structure-dressed amplitudes. For example in the process , this decomposition is given by

(21)

where denotes the colour index of the incoming quark, the one of the incoming anti-quark, and and the ones of the outgoing gluons. In order to render the notation more compact, we introduce the following -dimensional vectors:

  • with components ,

  • with components , where if is present in the colour structure (i.e. if particle is a gluon, an incoming anti-quark or an outgoing quark) and otherwise (i.e. if particle is a colourless particle, an incoming quark or an outgoing anti-quark).

We then rewrite the structure-dressed amplitudes in the compact form

(22)

Recola computes the Born contribution and the one-loop contribution to the structure-dressed amplitudes for all values the vectors and can take according to the external particles of the process.

2.6 Squared amplitudes

Recola also computes the squared amplitude, summed over helicities and colours of the outgoing particles and averaged over helicities and colours of the incoming ones (the average is indicated by a “bar”):

(23)

An order-by-order expansion of the previous formula defines the Born and one-loop contribution to the squared amplitude. Omitting for compactness the colour and helicity indices, we have

(24)

At the Born level Recola computes the squared amplitude , given by

(25)

at the one-loop level it computes the one-loop contribution to the squared amplitude. If the Born amplitude does not vanish, is calculated as

(26)

For processes with a vanishing Born amplitude (but non-vanishing ), Recola computes the first non-vanishing contribution to the squared amplitude, which in this case amounts to

(27)

2.7 Colour- and spin-correlated squared amplitudes

In order to compute the subtraction terms in the Catani–Seymour dipole formalism Catani:1996vz (); Catani:2002hc (), colour- and spin-correlated squared tree-level amplitudes are needed.

Being the amplitude of a process, one builds for every coloured particle the amplitude , where the original colour structures have been extended by an additional factor describing the emission of a gluon of colour from particle of the original process:

(28)
(29)

Here, are the structure constants333The normalization for is fixed by . of and . In the colour-flow formalism used by Recola, Eqs. (28) and (29) translate into

(30)

and

(31)

where denotes the original amplitude, the modified one, and the additional gluon has colour indices ().

Recola computes, at the Born level, the colour-correlated squared amplitude between particle and for all pairs , defined as

(32)

where the sum is over all colour and helicity indices. The global factor is given by if particle is a quark or an anti-quark and by if particle is a gluon.444The Casimir operators in the fundamental and adjoint representation are defined as and , respectively, such that and as usual. These choices are made such that is independent of the normalization chosen for .

In the case of a or a splitting, the Catani–Seymour subtraction formalism requires also spin correlations to build the subtraction terms (the non-diagonal terms of Eqs. (5.8), (5.9), (5.40), (5.41), (5.67), (5.68), (5.99), (5.100), (5.147), (5.148), (5.167), (5.168), (5.185), (5.186) of Ref. Catani:1996vz ()). These terms can essentially be obtained replacing the polarization vector of the splitting gluon by an appropriate four-vector. To this end, Recola provides, at the Born level, the spin–colour-correlated squared amplitude for pairs of external gluons and external coloured particles . It is given by the colour-correlated squared amplitude computed with the special vector (to be provided by the user) instead of the usual polarization vector for gluon .

The QCD subtraction formalism of Ref. Catani:1996vz () can be adapted for application to QED by replacing gluons with photons and colour with electric charge. Due to the Abelian nature of QED, charge correlation does not involve special amplitudes (unlike colour correlation) and can be trivially built from the squared Born amplitude. In the subtraction method for QED, spin correlation is needed in the case of a photon splitting into a fermion anti-fermion pair, which, in an analogous manner to the QCD case, can be obtained by replacing the polarization vector of the corresponding photon with an appropriate four-vector. For this purpose, Recola provides, at the Born level, the spin-correlated squared amplitude for external photons . It is given by the squared amplitude computed with a special vector (to be provided by the user) instead of the usual polarization vector for photon .

2.8 Selecting intermediate states and resonances

As a further useful feature, Recola offers the possibility to request specific intermediate states in the amplitude, i.e. to select those contributions where the final state of the process is reached via one or more definite intermediate particles. The cross-section of a process is often dominated by contributions where these intermediate states become resonant. Such contributions are related to specific combinations of production and decay subprocesses and can be additionally enhanced by the experimental cuts. A typical example is the production of fermion pairs originating from the decay of a gauge boson, e.g. in the process

(33)

with the boson decaying into the pair. Recola allows to select such specific contributions, even with multiple and nested decays, like for example

(34)

This feature can be used to extract the resonant parts of the amplitude. Moreover it can be employed to calculate matrix elements in the pole approximation. In this approximation, only the resonant parts of the amplitude are kept and the residues of the poles in the amplitude are calculated with on-shell momenta. To this end, the complex squared mass of the resonant particle is replaced by its real part everywhere in the amplitude except for the denominators of resonant propagators where the width is kept. The latter are further evaluated off shell at , while the rest of the amplitude is calculated with on-shell kinematics, i.e. . This mismatch is accounted for in Recola by the possibility of choosing a different value for in the denominator of the resonant propagator than in the rest of the amplitude. At NLO, the selection of resonant contributions to a process can be used to calculate the so-called factorizable corrections in the pole approximation555The implementation of the factorizable NLO corrections in Recola in the pole approximation has been validated for Drell–Yan processes with resonant and  boson, as well as for doubly resonant processes with intermediate and  bosons.. In addition, Recola offers the possibility to switch off corrections of self-energy type related to the resonant propagators, which cancel in the pole approximation.666While the omission of the self-energies related to the resonance improves the numerical stability in the pole approximation, these contributions have to be taken into account if the pole approximation is not used.

In order to apply the pole approximation the following steps have to be performed:

  • The potentially resonant contributions have to be selected in the process definition (see Section 4.3 for details).

  • The potentially resonant particles have to be marked as resonant (see Section 4.2.22 for details).

  • The user has to ensure that the momenta of the resonant particles are on the mass shell, i.e. .

  • The squared off-shell momenta in the denominators of the resonant propagators have to be set (see Section 4.5.1 for details).

In this way the matrix elements in the pole approximation can be obtained at LO and for the factorizable part at NLO. The non-factorizable NLO corrections are not provided by the present version of Recola.

Note that marking particles as resonant sets the widths of these particles to zero in all defined processes. In order to calculate some of the matrix elements within the pole approximation and others exactly, it is therefore necessary to reset Recola and perform the integrations of the different contributions sequentially.

2.9 Conventions

Recola uses the following symbols (of type character) for the SM particles:
Higgs boson: ’H’ Goldstone bosons: ’p0’, ’p+’, ’p-’ Vector bosons: ’g’, ’A’, ’Z’, ’W+’, ’W-’ Neutrinos: ’nu_e’, ’nu_mu’, ’nu_tau’ Anti-Neutrinos: ’nu_e~’, ’nu_mu~’, ’nu_tau~’ Charged leptons: ’e-’, ’e+’, ’mu-’, ’mu+’, ’tau-’, ’tau+’ Quarks: ’u’, ’d’, ’c’, ’s’, ’t’, ’b’ Anti-Quarks: ’u~’, ’d~’, ’c~’, ’s~’, ’t~’, ’b~’   .
The helicities of the external particles are described in Recola by a variable of type character with the values [+],[-],[0], or by an integer variable with values +1,-1,0. This value determines the spinor (polarization vector) to be attributed to the corresponding fermion (vector boson), and is fixed to zero for scalar particles:
Incoming fermion: [+] or +1 [-] or -1 Outgoing fermion: [+] or +1 [-] or -1 Incoming anti-fermion: [-] or -1 [+] or +1 Outgoing anti-fermion: [-] or -1 [+] or +1 Transverse vector boson: [+] or +1 [-] or -1 Longitudinal vector boson: [0] or 0 Scalar boson: [0] or 0   .

The explicit expressions of the spinors and polarization vectors used in Recola can be found in A.

For the normalization of the amplitudes we use the conventions of Refs. Agashe:2014kda (); Bohm:2001yx (). Accordingly, cross sections and decay widths are obtained as

(35)

with

(36)

The SM Feynman rules implemented in Recola follow the conventions of Refs. Bohm:2001yx (); Denner:1991kt ().

3 Installation

Since Recola relies on the Collier library, the installation of both packages is required to have a working amplitude generator. The following two options are available:

  • Download of the stand-alone RecolaCollier package for a combined installation of both libraries.

  • Download of the Recola package alone which then has to be linked to a local Collier installation.

Both packages are available from the web site ”http://recola.hepforge.org”.

3.1 The RecolaCollier package

The stand-alone package recola-collier_ contains the version of the Recola library together with a working copy of the Collier library. After downloading the file recola-collier_.tar.gz, extract the tarball in the current working directory with the shell command

   "tar -zxvf recola-collier_X.Y.Z.tar.gz" .

This operation creates the directory recola-collier_ containing the following files and folders:

  • CMakeLists.txt:
    CMake makefile to produce the Collier and Recola libraries;

  • build:
    build directory, where CMake puts all files necessary for the creation of the libraries;

  • COLLIER_A.B.C:
    main directory of the Collier package COLLIER_;

  • recola_X.Y.Z:
    main directory of the Recola package recola_ (see Section 3.2 for details).

The combined compilation of Collier and Recola proceeds by changing to the build directory and executing there the shell command ”cmake [options] ..” (creating Makefiles for Collier and Recola located in COLLIER_/build and recola_/build, respectively), followed by make:

   "cd recola-collier-X.Y.Z/build"
   "cmake [options] .."
   "make" .

This requires CMake to be installed on the system. If no options are specified, CMake automatically searches for installed Fortran compilers and chooses a suited one, e.g. gfortran. The user can force CMake to use a specific compiler by adding in the cmake command line the option

   "-D CMAKE_Fortran_COMPILER=<comp>" ,

where <comp> can be gfortran, ifort, pgf95, ... or the full path to a compiler.

By default, the installation sequence generates Collier and Recola as shared libraries:

  • libcollier.so is created in recola-collier_X.Y.Z/COLLIER_A.B.C and the corresponding module files are placed in the modules subdirectory within this folder.

  • librecola.so is created in recola-collier_X.Y.Z/recola_X.Y.Z and the corresponding module files are placed in the modules subdirectory within this folder.

The option

   "-D static=ON"

causes CMake to create the static libraries libcollier.a and librecola.a instead of the shared ones.

The packages Recola and Collier both contain a directory called demos, where the user can find programs that illustrate the usage of the codes. Issuing

   "make <demofile>"

in the directory recola-collier-X.Y.Z/build, with <demofile> being the name (without extension) of one of these demofiles, will compile the corresponding program. The executable <demofile> is created in the respective directory demos of Recola or Collier. More details on Recola demo programs are given in Section 3.2; for more details on the demo programs of Collier we refer to Ref. Denner:2016kdg ().

3.2 The Recola package

If the user wants to use his local installation777 Collier can be downloaded from http://collier.hepforge.org. of Collier with Recola, he can download the archive recola_X.Y.Z.tar.gz containing only the Recola package, in its version . Extract the tarball in the current working directory with the shell command

   "tar -zxvf recola_X.Y.Z.tar.gz" .

This operation creates the directory recola_X.Y.Z containing the following files and folders:

  • CMakeLists.txt:
    CMake makefile, to produce Recola library;

  • build:
    build directory, where CMake puts all necessary files for the creation of the library;

  • src:
    Recola source directory, containing

    • the source files input_rcl.f90, process_definition_rcl.f90, process_generation_rcl.f90, process_computation_rcl.f90, and reset_rcl.f90 with the global variables and public subroutines accessible to the user;

    • the directory internal with private source files which should not be modified by the user.

  • demos:
    directory with demo programs illustrating the use of Recola, including shell scripts for their compilation and execution.

The compilation of Recola proceeds by changing to the build directory and executing there the shell command "cmake [options] .." (creating a Makefile for Recola in recola_X.Y.Z/build), followed by make:

   "cd recola_X.Y.Z/build"
   "cmake [options] .."
   "make [demofile]" .

This requires CMake to be installed on the system. If no options are specified, CMake automatically searches for installed Fortran compilers and chooses a suited one. The user can force CMake to use a specific compiler by adding in the cmake command line the option

   "-D CMAKE_Fortran_COMPILER=<comp>" ,

where <comp> can be gfortran, ifort, pgf95, ... or the full path to a compiler.

By default, the installation sequence generates Recola as shared library librecola.so with the corresponding module files placed in the modules subdirectory. The option

   "-D static=ON"

causes CMake to create the static library librecola.a instead of the shared one.

The installation procedure further links Recola with the Collier library. If not specified otherwise, CMake assumes the existence of a folder named COLLIER that is located in the parent directory of recola_X.Y.Z and that contains the Collier library libcollier.so and/or libcollier.a, as well as the subdirectory modules with the module files of Collier. Note that, depending on whether Recola shall be generated as shared or as static library, the Collier library must be present in the same format.

While the location of the libcollier.so/libcollier.a and the module files within the Collier folder must be kept as described above, the overall path may deviate from the default setting. In this case, the full path to the Collier directory must be given to CMake via the option

   "-D collier_path=<path to collier>" ,

where <path to collier> can be either an absolute or a relative path.

Moreover, by adding the option

   "-D cmake_collier=ON"

to the cmake command line, the user can enforce that Collier is (re-)compiled when the installation sequence for Recola is performed888This only works if the complete Collier package with all source files is provided in the respective folder.. In this case the CMake makefile of Recola calls the CMake makefile of Collier and generates the Collier Makefile (any existing Collier Makefile is overwritten). The subsequent execution of make in recola-X.Y.Z/build then generates the Collier library and module files (placed in the respective directory) in addition to Recola library and modules.

To create executables for the demo programs of Recola in the directory demos, the command

   "make <demofile>"

should be issued in the directory recola-X.Y.Z/build, with <demofile> being either demo0_rcl, demo1_rcl, demo2_rcl or demo3_rcl. Alternatively, the user can execute (after issuing cmake) the shell scripts run with the command

   ./run <demofile>

in the demos directory. This generates and runs the respective executable <demofile>.

The demo programs demo0_rcl, demo1_rcl, demo2_rcl, demo3_rcl exemplify the usage of Recola for various purposes:

  • demo0_rcl:
    Basic usage of Recola.

  • demo1_rcl:
    Usage of Recola for more than one process simultaneously, with explicit modification of input parameters and with selection of specific helicities for the external particles and of certain powers of the strong coupling constant. In addition, files with LaTeX source code for diagrams are generated.

  • demo2_rcl:
    Usage of Recola for the selection of resonant contributions and pole approximation.

  • demo3_rcl:
    Usage of Recola for the computation of colour- and/or spin-correlation.

The demos directory also contains the shell script draw-tex which compiles all LaTeX files of the form process_*.tex present in the folder and creates the corresponding .pdf files (see Section 4.1.9 for more details). It can be run executing

   ./draw-tex

in the demos directory.

4 Usage of Recola

In order to use Recola in a Fortran program, its modules have to be loaded by including the line

  use recola

in the preamble of the respective code, and the library librecola.so or librecola.a has to be supplied to the linker. This gives access to the public functions and subroutines of the Recola library described in the following subsections. The names of all these routines end with the suffix “_rcl”. This name convention is supposed to avoid conflicts with routine names present in the master program and increases readability by allowing for an easy identification of command lines referring to the Recola library.

Typically, an application of Recola involves the following five steps:

  • Step 1: Setting input parameters (optional)

    The input needed for the computation of SM processes can be set by the user in two ways: either by editing the file input.f90, changing there the values of the corresponding variables explicitly, or by making use of subroutines provided by Recola for this purpose. While the former option requires a recompilation of the program, the latter allows for dynamical changes of the input parameters within the same run of the program. Input variables and subroutines are described in Section 4.1 and Section 4.2, respectively. Since Recola provides default values for all input parameters, this first step is optional.

  • Step 2: Defining the processes

    Before Recola can be employed to calculate matrix elements for one or more processes, each process must be declared and labelled with a unique identifier. This is done by calling the subroutine define_process_rcl for every process, as described in Section 4.3.

  • Step 3: Generating the processes

    In the next step the subroutine generate_processes_rcl is called which triggers the initialization of the complete list of processes defined in step 2. As a result, all relevant building blocks for the recursive computation of off-shell currents are generated (see Section 4.4 for details).

  • Step 4: Computing the processes

    After the arrangements made in the previous steps, Recola is ready to calculate amplitudes for any of the processes defined in step 2. The computation of the amplitude and of the squared amplitude is performed by means of the subroutine compute_process_rcl, which uses the process-dependent information on the recursive procedure derived in step 3. The subroutine compute_process_rcl is called with the momenta of the external particles provided by the user. In a Monte Carlo integration, the call of compute_process_rcl is repeated many times for different phase-space points.

    Recola further provides subroutines that allow to obtain particular contributions of the amplitude or the squared amplitude. In particular, it is possible to calculate colour- and/or spin-correlated squared amplitudes at the Born level. Making use of the subroutines set_alphas_rcl or compute_running_alphas_rcl one can also work with a running value for the strong coupling constant .

    Detailed information on the subroutines that can be employed in step 4 will be given in Section 4.5.

  • Step 5: resetting Recola

    Finally, by calling the subroutine reset_recola_rcl, the process-dependent information generated in steps 2–4 is deleted and the corresponding memory is deallocated. The input variables keep their values defined in step 1 before.

Note that these steps have to be followed in the order given above. In particular, after step 3 no new process can be defined unless Recola is reset (step 5). After step 5 the user can restart with step 1 or step 2. More information on the allowed sequence of calls can be found in the description of the routines below.

Examples of calls of Recola can be found in the directory demos.

4.1 Input variables

The physical input parameters and the flags steering the output are declared and initialized in the file input.f90. This file contains default values for these variables, which can be changed by the user.

4.1.1 Pole masses and widths of the SM particles

The SM particles can be grouped into massive unstable particles, characterized by their mass and decay width, massive stable particles, characterized by their mass, and massless ones. In Recola, the gluon, the photon and the neutrinos are treated as strictly massless (though the photon and the gluon can actually get a fictitious mass to regularize soft singularities, see Section 4.1.3). The electron as well as the up, down and strange quarks are considered in Recola as (potentially) massive stable particles, implying the possibility to assign to them a non-zero mass. All other particles are considered as (potentially) massive unstable particles, so that apart from a non-zero mass they can also be assigned a non-zero width.

The mass and width variables declared in input.f90 represent the pole mass and the pole width , defined from the complex pole of the propagator as

(37)

They are related to the on-shell quantities and measured at the LEP and Tevatron experiments for the and the boson via

(38)

The default values (in GeV) for the pole masses and widths in Recola are:

  real(dp) :: mass_z  =  91.153480619182744d0
  real(dp) :: width_z  = 2.4942663787728243d0
  real(dp) :: mass_w  =  80.357973609877547d0
  real(dp) :: width_w  = 2.0842989982782196d0
  real(dp) :: mass_h  = 125.d0,                width_h  = 0.d0
  real(dp) :: mass_el =   0.d0
  real(dp) :: mass_mu =   0.d0,                width_mu = 0.d0
  real(dp) :: mass_ta =   0.d0,                width_ta = 0.d0
  real(dp) :: mass_u  =   0.d0
  real(dp) :: mass_d  =   0.d0
  real(dp) :: mass_c  =   0.d0,                width_c  = 0.d0
  real(dp) :: mass_s  =   0.d0
  real(dp) :: mass_t  = 173.2d0,               width_t  = 0.d0
  real(dp) :: mass_b  =   0.d0,                width_b  = 0.d0 ,

where indicates a double precision variable. The default values for the and bosons have been computed from the on-shell values

4.1.2 Parameters governing the treatment of collinear singularities

The treatment of collinear singularities caused by a fermion is fixed from the value of its pole mass : for , dimensional regularization is applied with the regularization parameters given in Section 4.1.4. For , the variable light_ of type logical, which can be set individually for each fermion = el, mu, ta, u, d, c, s, t, b, controls how Recola deals with the fermion mass :

  • light_ = .true.:
    The fermion is considered as “light”, and its non-zero pole mass is kept only in mass-singular logarithms but neglected elsewhere. In this case,