R E C O L a
REcursive Computation of OneLoop Amplitudes
^{1}^{1}1The program is available from
http://recola.hepforge.org.
Abstract
We present the Fortran95 program Recola for the perturbative computation of nexttoleadingorder transition amplitudes in the Standard Model of particle physics. The code provides numerical results in the ’t Hooft–Feynman gauge. It uses the complexmass 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 nexttoleadingorder squared amplitudes, summed over spin and colour, is supported as well as the computation of colour and spincorrelated leadingorder squared amplitudes needed in the dipole subtraction formalism.
keywords:
NLO computations; oneloop amplitudes; higher ordersPROGRAM SUMMARY
Manuscript Title: Recola: REcursive Computation of OneLoop Amplitudes
Authors: Stefano Actis, Ansgar Denner, Lars Hofer, JeanNicolas
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, oneloop
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 treelevel and oneloop scattering amplitudes
occurring in the calculation of observables in relativistic quantum
field theories
Solution method:
Treelevel and oneloop amplitudes are numerically calculated using a
recursive algorithm. For oneloop 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 oneloop 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 highenergy 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 leadingorder (LO) approximation. In the past years, many groups have concentrated their efforts on nexttoleadingorder (NLO) calculations (see e.g. Refs. Campbell:2013qaa (); Andersen:2014efa (); Bern:2008ef (); Binoth:2010nha (); AlcarazMaestre:2012vp ()), and alternative strategies to the traditional Feynmandiagrammatic 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 oneloop 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 higherrank tensor integrals, either via an improved diagrammatic approach Cascioli:2011va () or employing oneloop 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 oneloop amplitudes have been implemented in many codes such as FeynArts/ FormCalc Hahn:2000kx (); Agrawal:2012cv (); Nejad:2013ina (), CutTools Ossola:2007ax (), Blackhat Berger:2008sj (), Helac1loop 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 treelevel and oneloop amplitudes in the SM. While almost all of the abovelisted programs were developed with a focus on QCD corrections^{1}^{1}1FeynArts/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 oneloop offshell 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 oneloop 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 (), PackageX 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 oneloop 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 MonteCarlo 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 “onthefly” 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 precalculated 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 treelevel and oneloop scattering amplitudes in the SM, based on recursion relations Actis:2012qn ().
The algorithm to compute the treelevel amplitude is inspired by the Dyson–Schwinger equations Dyson:1949ha (); Schwinger:1951ex (); Schwinger:1951hq (). The recursion relations for the oneloop amplitudes are more involved and rely on the decomposition of the oneloop 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 spacetime 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 treelevel 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 4dimensional (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 treelevellike 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 oneloop 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 variableflavour 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 oneloop 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 abovementioned 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 phasespace 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 twoloop formulas in the flavour scheme Ellis:1991qj ():
1loop running:  (9)  
2loop 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 complexmass scheme of Refs. Denner:1999gp (); Denner:2005fg (); Denner:2006ic (). The user can, however, also choose to proceed in the onshell scheme, where only the real part of the selfenergies 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 treelevel 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 antiquarks, and the values for gluons, while it is absent for colourless particles.
According to the decomposition , the colouroctet representation of the gluon can be related to the product of the fundamental and antifundamental representation of quarks and antiquarks. The colour content of the amplitude can thus alternatively be expressed in the socalled colourflow 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 antiquarks, while it takes the values for gluons, incoming antiquarks and outgoing quarks. Similarly, the anticolour index () is absent for colourless particles, incoming antiquarks and outgoing quarks, while it takes the values for gluons, incoming quarks and outgoing antiquarks. The unphysical coloursinglet 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 (colouroctet vs. colourflow 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 GellMann matrices.^{2}^{2}2In our convention, the are normalized according to . Note that, while Recola exclusively works in the colourflow formalism, we give all formulae in both representations to allow for an easy translation from one to the other.
In the colourflow 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 antiquarks. The amplitudes are called structuredressed 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 antiquark, 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 antiquark or an outgoing quark) and otherwise (i.e. if particle is a colourless particle, an incoming quark or an outgoing antiquark).
We then rewrite the structuredressed amplitudes in the compact form
(22) 
Recola computes the Born contribution and the oneloop contribution to the structuredressed 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 orderbyorder expansion of the previous formula defines the Born and oneloop 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 oneloop level it computes the oneloop contribution to the squared amplitude. If the Born amplitude does not vanish, is calculated as
(26) 
For processes with a vanishing Born amplitude (but nonvanishing ), Recola computes the first nonvanishing contribution to the squared amplitude, which in this case amounts to
(27) 
2.7 Colour and spincorrelated squared amplitudes
In order to compute the subtraction terms in the Catani–Seymour dipole formalism Catani:1996vz (); Catani:2002hc (), colour and spincorrelated squared treelevel 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 constants^{3}^{3}3The normalization for is fixed by . of and . In the colourflow 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 colourcorrelated 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 antiquark and by if particle is a gluon.^{4}^{4}4The 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 nondiagonal 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 fourvector. To this end, Recola provides, at the Born level, the spin–colourcorrelated squared amplitude for pairs of external gluons and external coloured particles . It is given by the colourcorrelated 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 antifermion 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 fourvector. For this purpose, Recola provides, at the Born level, the spincorrelated 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 crosssection 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 onshell 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 onshell 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 socalled factorizable corrections in the pole approximation^{5}^{5}5The 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 selfenergy type related to the resonant propagators, which cancel in the pole approximation.^{6}^{6}6While the omission of the selfenergies 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 offshell 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 nonfactorizable 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’
AntiNeutrinos:
’nu_e~’, ’nu_mu~’, ’nu_tau~’
Charged leptons:
’e’, ’e+’, ’mu’, ’mu+’, ’tau’, ’tau+’
Quarks:
’u’, ’d’, ’c’, ’s’, ’t’, ’b’
AntiQuarks:
’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 antifermion:
[] or 1
[+] or +1
Outgoing antifermion:
[] 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 standalone Recola–Collier 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 Recola–Collier package
The standalone package recolacollier_ contains the version of the Recola library together with a working copy of the Collier library. After downloading the file recolacollier_.tar.gz, extract the tarball in the current working directory with the shell command
"tar zxvf recolacollier_X.Y.Z.tar.gz" .
This operation creates the directory recolacollier_ 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 recolacollierX.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 recolacollier_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 recolacollier_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 recolacollierX.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 installation^{7}^{7}7 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 performed^{8}^{8}8This 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 recolaX.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 recolaX.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 spincorrelation.
The demos directory also contains the shell script drawtex 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
./drawtex
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 offshell 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 processdependent 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 phasespace 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 spincorrelated 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 processdependent 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 nonzero mass. All other particles are considered as (potentially) massive unstable particles, so that apart from a nonzero mass they can also be assigned a nonzero 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 onshell 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 onshell 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 nonzero pole mass is kept only in masssingular logarithms but neglected elsewhere. In this case,