! This file is for the user to set the different parameters of MadLoop.
! The name of the variable to define must start with the '#' sign and then
! the value should be put immediately on the next line.

!     
#MLReductionLib
!6|7|1
! Default :: 6|7|1
!     The tensor integral reduction library.The current choices are:
!     1 | CutTools
!     2 | PJFry++
!     3 | IREGI
!     4 | Golem95
!     5 | Samurai
!     6 | Ninja
!     7 | COLLIER
!     One can use the combinations to reduce integral,e.g.
!     1|2|3 means first use CutTools, if it is not stable, use PJFry++, 
!     if it is still unstable, use IREGI. If it failed, use QP of CutTools.
!     Notice that any reduction tool not avaialble on the system will be automatically
!     skipped. 

!     When using quadruple precision with Ninja or CutTools, the reduction will 
!     always be done in quadruple precision, but the parameters below allow you to
!     chose if you want to also recompute the *integrand* in quadruple precision.
!     Doing so is slow but might improve the accuracy in some situation.
#UseQPIntegrandForCutTools
!.TRUE.
! Default :: .TRUE.
#UseQPIntegrandForNinja
!.TRUE.
! Default :: .TRUE.
!

!     =================================================================================
!     The parameters below set the parameters for IREGI
!     =================================================================================

#IREGIMODE
!2
! Default :: 2
!     IREGIMODE=0, IBP reduction
!     IREGIMODE=1, PaVe reduction
!     IREGIMODE=2, PaVe reduction with stablility improved by IBP reduction

#IREGIRECY
!.TRUE.
! Default :: .TRUE.
!     Use RECYCLING OR NOT IN IREGI
!

!     =================================================================================
!     The parameters below set the stability checks of MadLoop at run time
!     =================================================================================

!     Decide in which mode to run MadLoop
!
!     imode:|  description                                     
!       1   |  Double precision, loops reduced with propagator in original order                               
!       2   |  Double precision, loops reduced with propagator with reversed order                               
!       4   |  Quadruple precision, loops reduced with propagator in original order                               
!       5   |  Quadruple precision, loops reduced with propagator with reversed order                          
!      -1   | Exhaustive automated numerical stability checks. See below for details.
!     
!     Due to the architecture of the program, you are better off
!     rerunning the full PS point in quadruple precision than just a single loop 
!     because the two things would almost take the same time. So '-1' is always
!     very recommended.
#CTModeRun
!-1
! Default :: -1
!     In the negative mode -1, MadLoop first evaluates each PS points in modes 1 and 2,
!     yielding results Res1 and Res2, and then check if:
!                    (Res1-Res2)/(2*(Res1+Res2)< MLStabThres
!     If it is not the case, MadLoop evaluates again the PS point in modes 4 and 5,
!     yielding results Res4 and Res5, and then check if:
!                    (Res4-Res5)/(2*(Res4+Res5)< MLStabThres
!     If it is the case then the unstable phase-space point could be cured. If it is
!     not the case, MadLoop outputs a warning. 
!     Notice that MLStabThres is used only when CTModeRun is negative.
#MLStabThres
!1.0d-3
! Default :: 1.0d-3
!     You can add other evaluation method to check for the stability in DP and QP.
!     Below you can chose if you want to use zero, one or two rotations of the PS point 
!     in QP.
#NRotations_DP
!0
! Default :: 0
#NRotations_QP
!0
! Default :: 0

!     By default, MadLoop is allowed to slightly deform the Phase-Space point in input
!     so to insure perfect onshellness of the external particles and perfect energy-momentum
!     conservation. The deformation is minimal and such that it leaves the input PS point 
!     unchanged if it already satisfies the physical condiditions mentioned above.
!     This integer values select what is the method to be employed preferably to restore this
!     precision. It can take the following values:
!
!     -1 :: No method is used for double precision computations, and method 2 will be used
!           preferentially when quadruple precision (for which this precision improvement
!           is mandatory, otherwise quadruple precision is pointless)
!      1 :: This methods imitates what is done in PSMC, namely 
!           a) Set the space-like momentum of the last external particle to be the
!              opposite of the sum of the others (with a minus sign for the initial states).
!           b) Rescale all final state space-like momenta by a fixed value x computed such
!              that energy is conserved when particles are put exactly onshell. This value 
!              is determined numericaly via Ralph-Newton's method.
!           c) Set all energies to have particles exactly onshell.           
!      2  :: This method applies a shift to the energy and the x and y components of the first 
!            initial state momentum in order to restore exact energy momentum conservation after
!            particles have been put exactly onshell via a shift of the z component of their 
!            momenta.
#ImprovePSPoint
!2
! Default :: 2

!     =================================================================================
!     The parameters below set two CutTools internal parameters accessible to the user. 
!     =================================================================================

!     Choose here what library to chose for CutTools/TIR to compute the scalar loops of the
!     master integral basis. The choices are as follows:
!     (Does not apply for Golem95, where OneLOop is always used)
!     2 | OneLOop
!     3 | QCDLoop
#CTLoopLibrary
!2
! Default :: 2

!     Choose here the stability threshold used within CutTools to decide when to go to
!     higher precision.
#CTStabThres
!1.0d-2
! Default :: 1.0d-2

!     =================================================================================
!     The parameters below set the general behavior of MadLoop for the initialization
!     =================================================================================

!     Decide in which mode to run when performing MadLoop's initialization of
!     the helicity (and possibly loop) filter. The possible modes are:
!
!     Decide in which mode to run MadLoop
!
!     imode:|  description                                     
!       1   |  Double precision, loops reduced with propagator in original order                               
!       2   |  Double precision, loops reduced with propagator with reversed order                               
!       4   |  Quadruple precision, loops reduced with propagator in original order                               
!       5   |  Quadruple precision, loops reduced with propagator with reversed order                            
!
#CTModeInit
!1
! Default :: 1

!     CheckCycle sets on how many PS points trials the initialization filters must be 
!     obtained. As long as MadLoop does not find that many consecutive PS points for 
!     which the filters are the same, it will start over but only a maximum of
!     MaxAttempts times.
#CheckCycle
!3
! Default :: 3
#MaxAttempts
!10
! Default :: 10

!     Setting the threshold for deciding wether a numerical contribution is analytically 
!     zero or not.
#ZeroThres
!1.0d-9
! Default :: 1.0d-9

!     Setting the on-shell threshold for deciding whether the invariant variables
! of external momenta are on-shell or not. It will only be used in constructing
! s-matrix in Golem95.
#OSThres
!1.0d-8
! Default :: 1.0d-8

!     The setting below is recommended to be on as it allows to systematically used the 
!     first PS point thrown at ML5 to be used for making sure that the helicity filter
!     read from HelFilter.dat is consistent as it might be no longer up to date with
!     certain changes of the paramaters by the user.
#DoubleCheckHelicityFilter
!.TRUE.
! Default :: .TRUE.

!     This decides whether to write out the helicity and loop filters to the files 
!     HelFilters.dat and LoopFilters.dat to save them for future runs. It usually
!     preferable but sometimes not desired because of the need of threadlocks in the
!     context of mpi parallelization. So it can be turned off here in such cases.
#WriteOutFilters
!.TRUE.
! Default :: .TRUE.

!     Some loop contributions may be zero for some helicities which are however
!     contributing. In order to save their computing time, you can chose here to try
!     to filter them out. The gain is typically minimal, so it is turned off by default.
#UseLoopFilter
!.FALSE.
! Default :: .FALSE.

!     The integer below set at which level the user wants to filter helicity configuration.
!     Notice that this does not entail any approximation. It only offers the possibility of
!     performing exact simplifications based on numerical checks. HelicityFilterLevel =
!     0 :  No filtering at all. Not HelFilter.dat file will be written out and *all* helicity
!          configurations will be computed.
!     1 :  Analytically zero helicity configurations will be recognized as such by numerical
!          comparisons (using the 'ZeroThres' param) and consistently skipped in further 
!          computations.
!     2 :  Filters both helicity configuration which are analytically zero *and* those 
!          consistently identical (typically because of CP symmetry).
!          (Will only effectively do it if process was generated in 'optimized_mode')
#HelicityFilterLevel
!2
! Default :: 2

!     This decides whether consecutive consistency for the loop filtering setup is also 
!     required.
#LoopInitStartOver
!.FALSE.
! Default :: .FALSE.

!     This decides wether consecutive consistency for the helicity filtering setup is also 
!     required. Better to set it to false as it can cause problems for unstable processes.
#HelInitStartOver
!.FALSE.
! Default :: .FALSE.

!     =================================================================================
!     The parameters below set the main parameters for COLLIER
!     To edit more specific technical COLLIER parameters, modify directly the content
!     of the subroutine 'INITCOLLIER' in the file 'MadLoopCommons.f'
!     =================================================================================

!     Decide if COLLIER must be computed multiple times to evaluate the UV pole residues
!     (Withing a Monte-Carlo performed in MG5aMC, this is automatically disabled internally)
#COLLIERComputeUVpoles
!.TRUE.
! Default :: .TRUE.

!     Decide if COLLIER must be computed multiple times to evaluate the IR pole residues
!     (Withing a Monte-Carlo performed in MG5aMC, this is automatically disabled internally)
#COLLIERComputeIRpoles
!.TRUE.
! Default :: .TRUE.

!     Decide if COLLIER must be computed multiple times to evaluate the IR pole residues
#COLLIERRequiredAccuracy
!1.0d-8
! Default :: 1.0d-8
!     A value of -1.0d0 means that it will be automatically set from MLStabThres.
!     The default value of 1.0d-8 corresponds to the value for which COLLIER's authors
!     have optimized the library.

!     Decide whether to use COLLIER's internal stability test or the loop-direction
!     switch test instead.
#COLLIERUseInternalStabilityTest
!.TRUE.
! Default :: .TRUE.
!     COLLIER's internal stability test is at no extra cost but not as reliable
!     as the loop-direction switch test, which however doubles the reduction time.
!     This parameter is only relevant when running MadLoop with CTModeRun=-1.
!     If you find a large number of unstable points with COLLIER for complicated
!     processes, set this parameter to .FALSE. to make sure the PS points flagged
!     as unstable with COLLIER really are so.

!     Set up to which N-loop to use the COLLIER global caching system.
#COLLIERGlobalCache
!-1
! Default :: -1
!     -1 : Enable the global cache for all loops 
!      0 : Disable the global cache alltogether
!      N : Enable the global cache but only for up to N-loops

!     Use the global cache when evaluating the poles as well (more memory consuming)
!     During a Monte-Carlo it is typically not useful anyway, because the pole  
!     computation is automatically disabled for COLLIER, irrespectively of the value
!     of the parameters COLLIERCompute<UV/IR>poles specified above.
#COLLIERUseCacheForPoles
!.FALSE.
! Default :: .FALSE.

!     Choose which branch(es) of COLLIER have to be used
#COLLIERMode
!1
! Default :: 1
!     COLLIERMode=1 : COLI branch 
!     COLLIERMode=2 : DD branch
!     COLLIERMode=3 : Both DD and COLI branch compared

!     Decide if COLLIER can output its information in a log directory.
#COLLIERCanOutput
!.FALSE.
! Default :: .FALSE.

/* End of param file */
