Recola2 is a Fortran95 computer program for the automated generation and numerical evaluation of amplitudes in general quantum field theories at one-loop order. It has been built on top of Recola and comes with the same features and additional ones.
Evaluation of amplitudes in general theories via model file approach.
Consistent treatment of unstable particle with the complex-mass scheme.
Consistent isolation of resonant contributions and pole approximation.
Dimensional regularization for ultraviolet and infrared singularities, with the possibility of treating collinear in mass regularization.
Switching between various renormalization schemes. Possible choices depend on model file in use.
Evaluation in different gauges as defined by the model file. Support for 't Hooft-Feynman gauge, Background-Field Method and Rxi gauge.
Dynamical Nf-flavour renormalization scheme for the strong coupling constant in theories with SM-QCD particle content.
Computation of next-to-leading-order amplitudes for all helicities and colour structures.
Computation of next-to-leading-order squared amplitudes summed/averaged over spin and colour.
Computation of colour- and/or spin-correlated leading-order squared amplitudes for dipole subtraction.
This Recola2 package is distributed as a standalone version and requires the user to resolve dependencies to Collier and the model files by hand. In the following it is assumed that the Collier library is built as shared libraries and ready to get linked to Recola2. The compilation of Recola2 consists of the following steps:
cmakemakecmakemakeObtain a model file from the website http://recola.hepforge.org/ and extract the tarball via the shell command
tar -zxvf <model>-X.Y.Z.tar.gz
where <model> can be SM, SM_BFM, HS, HS_BFM, THDM, THDM_BFM and X.Y.Z is the current Recola2 version. Then, switch to the build directory and run
cd modelfile-X.Y.Z/build
cmake [options] .. -Dcollier_path=<path_to_collier>
make [options]
where <path_to_collier> points to the directory including the compiled Collier library. It is highly advised to run the compilation of model files parallelized
make -j <THREADS>
with <THREADS> being the number of parallel compilation units.
Obtain a copy of Recola2 from http://recola.hepforge.org/ and extract it via the shell command
tar -zxvf recola2-X.Y.Z.tar.gz
where X.Y.Z is the current Recola2 version. Then, switch to the build directory and run
cd recola2-X.Y.Z/build
cmake [options] .. -Dcollier_path=<path_to_collier> -Dmodelfile_path=<path_to_modelfile>
make [options]
where <path_to_collier> and <path_to_modelfile> point to the directories containing the compiled Collier and model file library, respectively.
The Recola2 demo files are located in:
recola2-X.Y.Z/demos
The Fortran and C++ demo files can be run by invoking the run script
./run <demofile>
where can be demo{i}_rcl, cdemo{i}_rcl (i=0,..5). The python demo files can be run directly
python <demofile>
with taking the values pydemo{i}_rcl.py (i=0,..5).
| CMake option | Value | Short description |
|---|---|---|
| collier path | Path | Absolute or relative path to the Collier library. |
| modelfile path | Path | Absolute or relative path to the Recola2 model file. Only available in Recola2 CMakeLists.txt. |
| static | On/Off | Compile the library as a shared or static library. |
| with_python3 | On/Off | Choose Python 3.x over Python 2.7 to compile pyrecola. Only available in Recola2 CMakeLists.txt. |
| with_smtests | On/Off | Run tests against Pole and OpenLoops. Only available in Recola2 CMakeLists.txt. |
| CMAKE_BUILD_TYPE | Debug/Release | Set the compiler flags. By default Release flags (optimized) are used. |
| CMAKE_Fortran_COMPILER | Path/Name | Set the Fortran compiler either via executable name or the absolute path to executable. |
| CMAKE_INSTALL_PREFIX | Path | Set the installation prefix. |
| Makefile option | Value | Short description |
|---|---|---|
| -j | Integer | Number of threads for compilation. |
| VERBOSE | True/False | Enable verbose compilation. In this mode all compilation flags are visible to the user. |
The automated tests in the SM can be enabled via
cmake [options] .. -Dwith_smtests=On -Dcollier_path=<path_to_collier> -Dmodelfile_path=<path_to_modelfile>
where <path_to_modelfile> should point to a SM model file. Then, after compilation, run the tests with
make test
or
ctest
In order to use Recola2 its modules have to be loaded:
Fortran: use recola
C++: #include "recola.hpp"
Python: import pyrecola
in the preamble of the respective code, and the library librecola.so(or librecola.a, librecola.dynlib, pyrecola.so) has to be supplied to the linker. This gives access to the public functions and subroutines of the Recola2 library. The names of all these routines end with the suffix _rcl.
Typically, an application of Recola2 involves the following five steps:
Step 1: Setting input parameters (optional)
The input needed for the computation of processes can be set by calling dedicated subroutines as provided by Recola2. See Section 4.2 Input subroutines in the official manual for the full set of supported methods. Since Recola2 provides default values for all input parameters, this first step is optional.
Step 2: Process definition
The calculation of matrix elements for one or more processes requires each process to be declared and labelled with a unique identifier. This is done by calling the define_process_rcl.
Step 3: Process generation
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.
Step 4: Process computation
Recola2 is now 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 derived in step 3. The subroutine compute_process_rcl is called with the momenta of the external particles provided by the user.
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 additional processes can be defined unless Recola is reset (step 5). After step 5 the user can restart with step 1 or step 2.