MHV Amplitudes
- Parameters
- List of MHV processes in library
- How to use MHV as standalone program
MHV amplitudes are a special type of helicity amplitude which is remarkably
simple to calculate. MHV proccesses are ones in which every external particle
is massless, outgoing, and all but two external particles have the same helicity. By
default, Vincia uses MHV amplitudes to speed up its
Matrix-Element Corrections (MEC)s when using a
helicity shower.
Parameters
Use in MECs
By default, Vincia will attempt to use the MHV library to calculate its MECs.
This ensures the fastest possible corrections.
flag
Vincia:useMHVamplitudes
(default = true
)
option
off : MADGRAPH4 is used for all matrix-element corrections.
List of MHV processes in library
The MHVamplitudes class utilises the all-outgoing formalism, therefore we will
list our available processes in this formalism. Note that the input kinematics need
to be in the 2→n format. The following processes are included in the MHV libraray:
Type of process |
Number of particles |
|
All-gluon |
4 - 6 |
1 (massless) quark pair + gluons |
4 - 7 |
2 (massless) quark pairs + gluons |
4, 5 |
1 (massless) lepton pair, 1 (massless) quark pair + gluons |
4 - 9 |
|
How to use MHV as standalone program
Note: Pythia must still be compiled so that MHVamplitudes class has access to
pythia objects such as pythia::Vec4. Also, MHVamplitudes factors out the QCD coupling,
setting gs^2 = 4παs = 1
To calculate an MHV amplitude on its own, the user should create a vincia object. One should therefore include Vincia in the following way:
- #include "Vincia.h" //Include all of VINCIA
The MHVamplitudes class and functions have all been defined to live inside the Vincia
namespace, so to use them in your code they must either be prefaced by Vincia::
, or you can include the Vincia
namespace:
You can calculate an MHV amplitude by using the following steps:
- Create an instance of the
Pythia
and VinciaPlugin
objects as per Vincia's linking instructions. Make sure to include the relevant header and initialise both Pythia and Vincia as well. Only one such instance of each object should be constructed for each main program and this assumes you already included the relevant namespace above.
-
Create your process and set the initial-state partons. The process requires the particles' momenta, ids and helicities. You can either use pre-set momenta, or use Vincia's rambo generator. The initial-state momenta are set using:
- vincia.mhvAmplitudes.setIIpos(pos1In,pos2In) // Set particles pos1In and pos2In to be incoming
-
Then input the relevant momenta, ids and helicities to calculate all spinor products necessary for the matrix element using:
- vincia.mhvAmplitudes.calcSpinorProds(k, h, id, false) // calculate all necessary inner products to calculate amplitude for particles with momenta k, helicities h, ids id, and which are unordered in colour
If the last input is put as true it means that Vincia will assume the correct colour order (see below). This may be useful if you're interested in a particular colour ordering which is different to the default. If calculating a full colour-summed amplitude we recommend to keep this as false.
- Next choose you're level of colour summing, with details of options provided below:
- vincia.mhvAmplitudes.setColourDepth(colourDepthIn) // sets level of colour summing
-
Finally calculate the desired MHV matrix element using:
- vincia.mhvAmplitudes.ME2() // Calculate matrix element
It is possible to calculate multiple matrix elements with different levels of colour information for the same process. This is done by resetting the colour depth and then re-evaluating ME2()
before changing the phase-space point/process.
Note: It is also possible to use Vincia to calculate spinor products on their own. Some extra functionality is also described below.
Constructor
MHVamplitudes::MHVamplitudes()
Creates MHVamplitudes object
Member inputs
void MHVamplitudes::initPtr(pythia::Couplings* couplingsPtrIn, pythia::ParticleData* particleDataPtrIn, pythia::Settings* settingsPtrIn)
Initialise pointers to settings and Pythia objects
bool MHVamplitudes::init()
Sets couplings, masses and widths of electroweak processes.
void MHVamplitudes::setIIpos(int pos1In, int pos2In)
Tells MHVamplitudes that the input particles in positions pos1In and pos2In
are in the initial state, and need to be crossed to the final state.
bool MHVamplitudes::calcSpinorProds(pythia::Vec4 k, int h, int id, bool isOrdered = false)
Calculates every spinor product needed to calculate the squared matrix element,
and some helicity-dependent information. isOrdered is set to false by default, so that
init knows to re-order particles, and check that the process is physical. isOrdered is
set to true within Vincia when calculating MECs. We recommend keeping isOrdered as false,
however if the user wants to speed up the process it is possible to set it as true as
long as the following orders are used (note that all particles below are considered
outgoing):
Type of process |
Order of particles |
|
All-gluon |
g1,
, gn |
1 (massless) quark pair + gluons |
q, g1,
, gn, q̅ |
2 (massless) quark pairs + gluons |
q, q̅, q', g, q̅' |
1 (massless) lepton pair, 1 (massless) quark pair + gluons |
q, g1,
, gn, q̅, e+, e- |
|
Note: All fermion pairs (e.g. q' q̅' in the 2 quark-pair + gluon amplitude) must
have opposite helicities. Further note that the LC amplitude will be calculated with partons
in the same order as the table above.
void MHVamplitudes::setColourDepth(int colourDepthIn)
Has three options: colourDepthIn = 0 is LC, colourDepthIn = 1 is VC, colourDepthIn
= 2 is FC. This can be set dynamically so the user can quickly calculate e.g. LC and
FC squared marix elements for the same phase space point.
void MHVamplitudes::setVerbose(int verboseIn)
For debugging, use verboseIn
to 4 or higher.
void MHVamplitudes::resetBags()
Resets all spinor products and all amplitudes to 0 in their arrays
Member Outputs
double MHVamplitudes::ME2()
Calculates the squared matrix element at the colour-accuracy specified by the
function setColourDepth above.
void MHVamplitudes::printSPbag()
Prints every spinor product in the process. Entry i,j corresponds to <i j> for
mostly-plus MHV amplitudes, and to [i j] for mostly-minus MHV amplitudes.
int getColourDepth()
returns the colour depth, as defined above.
complex<double> spinorProdPos(pythia::Vec4 k_i, pythia::Vec4 k_j)
Calculates the spinor product <i j>.
complex<double> spinorProdNeg(pythia::Vec4 k_i, pythia::Vec4 k_j)
Calculates the spinor product [i j];.