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

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:

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:

  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:
  3. Then input the relevant momenta, ids and helicities to calculate all spinor products necessary for the matrix element using: 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:
  5. Finally calculate the desired MHV matrix element using: 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.
  6. 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::setColorDepth(int colorDepthIn)  
    Has three options: colorDepthIn = 0 is LC, colorDepthIn = 1 is VC, colorDepthIn = 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 setColorDepth 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 getColorDepth()  
    returns the color 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];.