Matching and Merging

Starting from a Born-level leading-order (LO) process, higher orders can be included in various ways. The three basic approaches would be

A formal order-by-order perturbative calculation, in each order higher including graphs both with one particle more in the final state and with one loop more in the intermediate state. This is accurate to the order of the calculation, but gives no hint of event structures beyond that, with more particles in the final state. Today next-to-leading order (NLO) is standard, while next-to-next-to-leading order (NNLO) is coming. This approach thus is limited to few orders, and also breaks down in soft and collinear regions, which makes it unsuitable for matching to hadronization.
Real emissions to several higher orders, but neglecting the virtual/loop corrections that should go with it at any given order. Thereby it is possible to allow for topologies with a large and varying number of partons, at the prize of not being accurate to any particular order. The approach also opens up for doublecounting, and as above breaks down in soft and colliner regions.
The parton shower provides an approximation to higher orders, both real and virtual contributions for the emission of arbitrarily many particles. As such it is less accurate than either of the two above, at least for topologies of well separated partons, but it contains a physically sensible behaviour in the soft and collinear limits, and therefore matches well onto the hadronization stage.

Given the pros and cons, much of the effort in recent years has involved the development of different prescriptions to combine the methods above in various ways.

The common traits of all combination methods are that matrix elements are used to describe the production of hard and well separated particles, and parton showers for the production of soft or collinear particles. What differs between the various approaches that have been proposed are which matrix elements are being used, how doublecounting is avoided, and how the transition from the hard to the soft regime is handled. These combination methods are typically referred to as "matching" or "merging" algorithms. There is some confusion about the distinction between the two terms, and so we leave it to the inventor/implementor of a particular scheme to choose and motivate the name given to that scheme.

PYTHIA comes with methods, to be described next, that implement or support several different kind of algorithms. The field is open-ended, however: any external program can feed in Les Houches events that PYTHIA subsequently showers, adds multiparton interactions to, and hadronizes. These events afterwards can be reweighted and combined in any desired way. The maximum pT of the shower evolution is set by the Les Houches scale, on the one hand, and by the values of the SpaceShower:pTmaxMatch, TimeShower:pTmaxMatch and other parton-shower settings, on the other. Typically it is not possible to achieve perfect matching this way, given that the PYTHIA pT evolution variables are not likely to agree with the variables used for cuts in the external program. Often one can get close enough with simple means but, for an improved matching, User Hooks can be inserted to control the steps taken on the way, e.g. to veto those parton shower branchings that would doublecount emissions included in the matrix elements.

Zooming in from the "anything goes" perspective, the list of relevent approaches actively supported is as follows.

For many/most resonance decays the first branching in the shower is merged with first-order matrix elements [Ben87, Nor01]. This means that the emission rate is accurate to NLO, similarly to the POWHEG strategy (see below), but built into the timelike showers. The angular orientation of the event after the first emission is only handled by the parton shower kinematics, however. Needless to say, this formalism is precisely what is tested by Z^0 decays at LEP1, and it is known to do a pretty good job there.
Also the spacelike showers contain a correction to first-order matrix elements, but only for the one-body-final-state processes q qbar → gamma^*/Z^0/W^+-/h^0/H^0/A0/Z'0/W'+-/R0 [Miu99] and g g → h^0/H^0/A0, and only to leading order. That is, it is equivalent to the POWHEG formalism for the real emission, but the prefactor "cross section normalization" is LO rather than NLO. Therefore this framework is less relevant, and has been superseded the following ones.
The POWHEG strategy [Nas04] provides a cross section accurate to NLO. The hardest emission is constructed with unit probability, based on the ratio of the real-emission matrix element to the Born-level cross section, and with a Sudakov factor derived from this ratio, i.e. the philosophy introduced in [Ben87].
While POWHEG is a generic strategy, the POWHEG BOX [Ali10] is an explicit framework, within which several processes are available. The code required for merging the PYTHIA showers with POWHEG input can be found in include/Pythia8Plugins/PowHegHooks.h, and is further described on a separate page. A user example is found in examples/main31.
The other traditional approach for NLO calculations is the MC@NLO one [Fri02]. In it the shower emission probability, without its Sudakov factor, is subtracted from the real-emission matrix element to regularize divergences. It therefore requires a analytic knowledge of the way the shower populates phase space. The aMC@NLO package [Fre11] offers an implementation for PYTHIA 8, developed by Paolo Torrielli and Stefano Frixione. The global-recoil option of the PYTHIA final-state shower has been constructed to be used for the above-mentioned subtraction.
Multi-jet merging in the CKKW-L approach [Lon01] is directly available. Its implementation, relevant parameters and test programs are documented on a separate page.
Multi-jet matching in the MLM approach [Man02, Man07] is also available, either based on the ALPGEN or on the Madgraph variant, and with input events either from ALPGEN or from Madgraph. For details see separate page.
Unitarised matrix element + parton shower merging (UMEPS) is directly available. Its implementation, relevant parameters and test programs are documented on a separate page.
Next-to-leading order multi-jet merging (in the NL3 and UNLOPS approaches) is directly available. Its implementation, relevant parameters and test programs are documented on a separate page.
Next-to-leading order jet matching in the FxFx approach is also available. For details see separate page.

MC@NLO, jet matching, multi-jet merging and NLO merging with main89.cc

A common Pythia main program for MC@NLO NLO+PS matching, MLM jet matching, FxFx (NLO) jet matching, CKKW-L merging, UMEPS merging and UNLOPS (NLO) merging is available through main89.cc, together with the input files main89mlm.cmnd, main89fxfx.cmnd, main89ckkwl.cmnd, main89umeps.cmnd and main89unlops.cmnd. The interface to MLM jet matching relies on MadGraph, while all other options of main89.cc use aMC@NLO input. main89.cc produces HepMC events [Dob01], that can be histogrammed (e.g. using RIVET [Buc10]), or used as input for a detector simulation. If the user is not familiar with HepMC analysis tools, it is possible to instead use Pythia's histogramming routines. For this, remove the lines referring to HepMC, and histogram events as illustrated (for CKKW-L) for the histogram histPTFirstSum in main84.cc, i.e. using weight*normhepmc as weight.

All settings can be transferred to main89.cc through an input file. The input file is part of the command line input of main89.cc, i.e. you can execute main89 with the command

./main89 myInputFile.cmnd myhepmc.hepmc

to read the input myInputFile.cmnd and produce the output file myhepmc.hepmc . Since main89.cc is currently a "front-end" for different types of matching/merging, we will briefly discuss the inputs for this sample program in the following.

Inputs

In its current form, main89.cc uses LHEF input to transfer (weighted) phase space points to Pythia. It is possible to include all parton multiplicities in one LHEF sample. If e.g. UMEPS merging for W-boson + up to two additional partons is to be performed, one LHE file containing W+zero, W+one and W+two parton events is required.

All input settings are handed to main89.cc in the form of an input file. We have included the input settings files

main89mlm.cmnd, which illustrates the MLM jet matching interface,

main89ckkwl.cmnd, which illustrates the CKKW-L multi-jet merging interface,

main89umeps.cmnd, which illustrates the UMEPS multi-jet merging interface, and

main89fxfx.cmnd, which illustrates the FxFx NLO jet matching interface,

main89unlops.cmnd, which illustrates the UNLOPS multi-jet NLO merging interface.

Other settings (e.g. using main89.cc as simple LO+PS or as MC@NLO interface) are of course possible. In the following, we will briefly explain how input for the five choices above are generated and handled.

MLM jet matching with main89.cc

For MLM jet matching, main89.cc currently relies on LHEF input from MadGraph. Due to the particular unweighting strategy performed in the generation of these inputs, the sample program starts by estimating the cross section. After this estimate, MLM jet matching within the Madgraph approach is performed in a second Pythia run. Example MLM settings can be found in main89mlm.cmnd. Please consult Jet Matching for more details.

CKKW-L merging with main89.cc

For CKKW-L merging, main89.cc currently relies on LHEF inputs generated with the leading-order mode of aMC@NLO (i.e. events should be generated with ./bin/generate_events aMC@LO). No run to estimate the cross section estimate is needed. Example CKKW-L settings can be found in main89ckkwl.cmnd. Please consult CKKW-L merging for more details.

UMEPS merging with main89.cc

For UMEPS merging, main89.cc currently relies on LHEF inputs generated with the leading-order mode of aMC@NLO as well (see above). main89.cc automatically assigns if an event will be used as "standard" event or as "subtractive" contribution. Example UMEPS settings can be found in main89umeps.cmnd. Please consult UMEPS merging and CKKW-L merging for more details.

FxFx (NLO) jet matching with main89.cc

For FxFx jet matching, main89.cc relies on MC@NLO input LHE files generated with aMC@NLO. To produce FxFx outputs in aMC@NLO, the settings PYTHIA8 = parton_shower, 3 = ickkw and x = ptj are necessary in your aMC@NLO run card. Here, x is the value of the matching scale in FxFx, i.e. has be identical to JetMatching:qCutME in the Pythia inputs. Example FxFx settings for Pythia can be found in main89fxfx.cmnd. Please consult Jet Matching and aMC@NLO matching for more details.

UNLOPS (NLO) merging with main89.cc

For UNLOPS merging, main89.cc currently relies on LHEF inputs generated with the aMC@NLO. The UNLOPS interface in main89.cc requires a) leading-order inputs generated with the leading-order mode of aMC@NLO, using the UNLOPS prescription, and b) next-to-leading-order inputs generated with the NLO mode of aMC@NLO, using the UNLOPS prescription. To produce UNLOPS outputs in aMC@NLO, the settings PYTHIA8 = parton_shower, 4 = ickkw and x = ptj are necessary in your aMC@NLO run card. Here, x is the value of the merging scale in UNLOPS, i.e. has be identical to Merging:TMS in the Pythia inputs. main89.cc will then process NLO inputs and LO inputs consecutively, and will automatically assign if an event will be used as "standard" event or as "subtractive" contribution. Example UNLOPS settings can be found in main89umeps.cmnd. Please consult UMEPS merging and CKKW-L merging for more details.