MHV Amplitudes

1. Parameters
2. List of MHV processes in library
3. 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

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:

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 g_s^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

• using namespace Vincia;

You can calculate an MHV amplitude by using the following steps:

1. 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.
2. 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
3. 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.
4. Next choose you're level of colour summing, with details of options provided below:
   • vincia.mhvAmplitudes.setColourDepth(colourDepthIn) // sets level of colour summing
5. 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];.