Event Information

  1. List information
  2. The beams
  3. Initialization
  4. The event type
  5. Hard process initiators
  6. Hard process parton densities and scales
  7. Hard process kinematics
  8. Soft Diffraction
  9. Hard Diffraction
  10. Photons from lepton beams
  11. Event activity
  12. Multiparton interactions
  13. Cross sections
  14. Loop counters
  15. Parton shower history
  16. Les Houches Event File information
  17. Heavy Ion Information
The Info class collects various one-of-a-kind information, some relevant for all events and others for the current event. An object info is a public member of the Pythia class, so if you e.g. have declared Pythia pythia, the Info methods can be accessed by pythia.info.method(). Most of this is information that could also be obtained e.g. from the event record, but is here more directly available. It is primarily intended for processes generated internally in PYTHIA, but many of the methods would work also for events fed in via the Les Houches Accord.

Note that further Info methods related to cross sections and event weights are collected on the Cross Sections and Weights page.

List information

void Info::list()  
a listing of most of the information set for the current event.

The beams

int Info::idA()  
int Info::idB()  
the identities of the two beam particles.

double Info::pzA()  
double Info::pzB()  
the longitudinal momenta of the two beam particles.

double Info::eA()  
double Info::eB()  
the energies of the two beam particles.

double Info::mA()  
double Info::mB()  
the masses of the two beam particles.

double Info::eCM()  
double Info::s()  
the CM energy and its square for the two beams.

Initialization

bool Info::tooLowPTmin()  
normally false, but true if the proposed pTmin scale was too low in timelike or spacelike showers, or in multiparton interactions. In the former case the pTmin is raised to some minimal value, in the latter the initialization fails (it is impossible to obtain a minijet cross section bigger than the nondiffractive one by reducing pTmin).

The event type

string Info::name()  
int Info::code()  
the name and code of the process that occurred.

int Info::nFinal()  
the number of final-state partons in the hard process.

bool Info::isResolved()  
are beam particles resolved, i.e. were PDF's used for the process?

bool Info::isDiffractiveA()  
bool Info::isDiffractiveB()  
is either beam soft diffractively excited?

bool Info::isDiffractiveC()  
is there soft central diffraction (a.k.a. double Pomeron exchange)?

bool Info::isHardDiffractiveA()  
bool Info::isHardDiffractiveB()  
is either beam hard diffractively excited?

bool Info::isNonDiffractive()  
is the process the SoftQCD:nonDiffractive one, i.e. corresponding to the full inelastic nondiffractive part of the total cross section. (Note that a hard process, say Z^0 production, normally is nondiffractive, but this is not what we aim at here, and so the method would return false, unless the Z^0 had been generated as part of the MPI machinery for the SoftQCD:nonDiffractive component.)

bool Info::isMinBias()  
the same as above, retained for backwards compatibility, but to be removed in PYTHIA 8.2.

bool Info::isLHA()  
has the process been generated from external Les Houches Accord information?

bool Info::atEndOfFile()  
true if a linked Les Houches class refuses to return any further events, presumably because it has reached the end of the file from which events have been read in.

bool Info::hasSub()  
does the process have a subprocess classification? Currently only true for nondiffractive and Les Houches events, where it allows the hardest collision to be identified.

string Info::nameSub()  
int Info::codeSub()  
int Info::nFinalSub()  
the name, code and number of final-state partons in the subprocess that occurred when hasSub() is true. For a minimum-bias event the code would always be 101, while codeSub() would vary depending on the actual hardest interaction, e.g. 111 for g g → g g. For a Les Houches event the code would always be 9999, while codeSub() would be the external user-defined classification code. The methods below would also provide information for such particular subcollisions.

Hard process initiators

The methods in this sections refer to the two initial partons of the hard 2 → n process (diffraction excluded; see below).

int Info::id1()  
int Info::id2()  
the identities of the two partons coming in to the hard process.

double Info::x1()  
double Info::x2()  
x fractions of the two partons coming in to the hard process.

double Info::y()  
double Info::tau()  
rapidity and scaled mass-squared of the hard-process subsystem, as defined by the above x values.

bool Info::isValence1()  
bool Info::isValence2()  
true if the two hard incoming partons have been picked to belong to the valence piece of the parton-density distribution, else false. Should be interpreted with caution. Information is not set if you switch off parton-level processing.

Hard process parton densities and scales

The methods in this section refer to the partons for which parton densities have been defined, in order to calculate the cross section of the hard process (diffraction excluded; see below).

These partons would normally agree with the ones above, the initiators of the 2 → n process, but it does not have to be so. Currently the one counterexample is POWHEG events [Ali10]. Here the original hard process could be 2 → (n-1). The NLO machinery at times would add an initial-state branching to give a 2 → n process with a changed initial state. In that case the values in this section refer to the original 2 → (n-1) state and the initiator ones above to the complete2 → n process. The Info::list() printout will contain a warning in such cases.

For external events in the Les Houches format, the pdf information is obtained from the optional #pdf line. When this information is absent, the parton identities and x values agree with the initiator ones above, while the pdf values are unknown and therefore set to vanish. The alpha_s and alpha_em values are part of the compulsory information. The factorization and renormalization scales are both equated with the one compulsory scale value in the Les Houches standard, except when a #pdf line provides the factorization scale separately. If alpha_s, alpha_em or the compulsory scale value are negative at input then new values are defined as for internal processes.

int Info::id1pdf()  
int Info::id2pdf()  
the identities of the two partons for which parton density values are defined.

double Info::x1pdf()  
double Info::x2pdf()  
x fractions of the two partons for which parton density values are defined.

double Info::pdf1()  
double Info::pdf2()  
parton densities x*f(x,Q^2) evaluated for the two incoming partons; could be used e.g. for reweighting purposes in conjunction with the idpdf, xpdf and QFac methods. Events obtained from external programs or files may not contain this information and, if so, 0 is returned.

double Info::QFac()  
double Info::Q2Fac()  
the Q or Q^2 factorization scale at which the densities were evaluated.

double Info::alphaS()  
double Info::alphaEM()  
the alpha_strong and alpha_electromagnetic values used for the hard process.

double Info::QRen()  
double Info::Q2Ren()  
the Q or Q^2 renormalization scale at which alpha_strong and alpha_electromagnetic were evaluated.

double Info::scalup()  
returns the stored SCALUP value for Les Houches events, and else zero. It may agree with both the QFac() and QRen() values, as explained above. However, to repeat, should the input SCALUP scale be negative, separate positive factorization and renormalization scales are calculated and set as for internally generated events. Furthermore, when PDF info is supplied for the Les Houches event, the factorization scale is set by this PDF info (scalePDF), which can disagree with SCALUP.

Hard process kinematics

The methods in this section provide info on the kinematics of the hard processes, with special emphasis on 2 → 2 (diffraction excluded; see below).

double Info::mHat()  
double Info::sHat()  
the invariant mass and its square for the hard process.

double Info::tHat()  
double Info::uHat()  
the remaining two Mandelstam variables; only defined for 2 → 2 processes.

double Info::pTHat()  
double Info::pT2Hat()  
transverse momentum and its square in the rest frame of a 2 → 2 processes.

double Info::m3Hat()  
double Info::m4Hat()  
the masses of the two outgoing particles in a 2 → 2 processes.

double Info::thetaHat()  
double Info::phiHat()  
the polar and azimuthal scattering angles in the rest frame of a 2 → 2 process.

Soft Diffraction

Information on the primary elastic or diffractive process (A B → A B, X1 B, A X2, X1 X2, A X B) can be obtained with the methods in the "Hard process kinematics" section above. The variables here obviously are s, t, u, ... rather than sHat, tHat, uHat, ..., but the method names remain to avoid unnecessary duplication. Most other methods are irrelevant for a primary elastic/diffractive process.

Central diffraction A B → A X B is a 2 → 3 process, and therefore most of the 2 → 2 variables are no longer relevant. The tHat() and uHat() methods instead return the two t values at the A → A and B → B vertices, and pTHat() the average transverse momentum of the three outgoing "particles", while thetaHat() and phiHat() are undefined.

While the primary interaction does not contain a hard process, the diffractive subsystems can contain them, but need not. Specifically, double diffraction can contain two separate hard subprocesses, which breaks the methods above. Most of them have been expanded with an optional argument to address properties of diffractive subsystems. This argument can take four values:

The argument is defined for all of the methods in the three sections above, "Hard process initiators", "Hard process parton densities and scales" and "Hard process kinematics", with the exception of the isValence methods. Also the four final methods of "The event type" section, the ...Sub() methods, take this argument. But recall that they will only provide meaningful answers, firstly if there is a system of the requested type, and secondly if there is a hard subprocess in this system. A simple check for this is that id1() has to be nonvanishing. The methods below this section do not currently provide information specific to diffractive subsystems, e.g. the MPI information is not bookkept in such cases.

Hard Diffraction

Information on the momentum fraction taken from the beam and the momentum transfer in the hard diffractive process. Note that when side A is diffractively exited, then the Pomeron has been taken from side B and vice versa.

double Info::xPomeronA()  
double Info::xPomeronB()  
x fractions of momenta carried by the Pomeron in the hard diffractive process.

double Info::tPomeronA()  
double Info::tPomeronB()  
The momentum transfer t in the hard diffractive process.

Photons from lepton beams

Information about the kinematics of photon-photon collisions from lepton beams.

double Info::eCMsub()  
Collision energy of the gamma-gamma sub-system.

double Info::xGammaA()  
double Info::xGammaB()  
x fractions of lepton momenta carried by the photons.

double Info::Q2GammaA()  
double Info::Q2GammaB()  
Virtualities of the photons emitted by the leptons.

double Info::thetaScatLepA()  
double Info::thetaScatLepB()  
Scattering angles of the leptons wrt. the beam direction.

int Info::photonMode()  
Type of photon process, see Photoproduction for details.

Event activity

int Info::nISR()  
int Info::nFSRinProc()  
int Info::nFSRinRes()  
the number of emissions in the initial-state showering, in the final-state showering excluding resonance decays, and in the final-state showering inside resonance decays, respectively.

double Info::pTmaxMPI()  
double Info::pTmaxISR()  
double Info::pTmaxFSR()  
Maximum pT scales set for MPI, ISR and FSR, given the process type and scale choice for the hard interactions. The actual evolution will run down from these scales.

double Info::pTnow()  
The current pT scale in the combined MPI, ISR and FSR evolution. Useful for classification in user hooks, but not once the event has been evolved.

Multiparton interactions

As already noted, these methods do not make sense for diffractive topologies, and should not be used there. Partly this is physics, but mainly it is for technical reasons, e.g. that double diffraction involves two separate systems that would have to be bookkept as such.

double Info::a0MPI()  
The value of a0 when an x-dependent matter profile is used, MultipartonInteractions:bProfile = 4.

double Info::bMPI()  
The impact parameter b assumed for the current collision when multiparton interactions are simulated. Is not expressed in any physical size (like fm), but only rescaled so that the average should be unity for minimum-bias events (meaning less than that for events with hard processes).

double Info::enhanceMPI()  
The choice of impact parameter implies an enhancement or depletion of the rate of subsequent interactions, as given by this number. Again the average is normalized to be unity for minimum-bias events (meaning more than that for events with hard processes).

double Info::enhanceMPIavg()  
The average enhancement factor expected for hard processes, in those cases where it can be calculated already at initialization, i.e. excluding the x-dependent b profile. The normalization is here chosen to apply to cases with two hard interactions A and B preselected in the process level, and there multiplies sigma_A * sigma_B / sigma_{nondiff} to give the joint cross section. (Additional corrections from joint PDF weights somewhat reduce the final number.) The normalization is slightly different (typically around 5%) from the average of the enhanceMPI() method above, which instead is normalized to average value unity for nondiffractive events. As used internally the two are consistent.

int Info::nMPI()  
The number of hard interactions in the current event. Is 0 for elastic and diffractive events, and else at least 1, with more possible from multiparton interactions.

int Info::codeMPI(int i)  
double Info::pTMPI(int i)  
the process code and transverse momentum of the i'th subprocess, with i in the range from 0 to nMPI() - 1. The values for subprocess 0 is redundant with information already provided above.

int Info::iAMPI(int i)  
int Info::iBMPI(int i)  
are normally zero. However, if the i'th subprocess is a rescattering, i.e. either or both incoming partons come from the outgoing state of previous scatterings, they give the position in the event record of the outgoing-state parton that rescatters. iAMPI and iBMPI then denote partons coming from the first or second beam, respectively.

double Info::eMPI(int i)  
The enhancement or depletion of the rate of the i'th subprocess. Is primarily of interest for the MultipartonInteractions:bProfile = 4 option, where the size of the proton depends on the x values of the colliding partons. Note that eMPI(0) = enhanceMPI().

double Info::bMPIold()  
double Info::enhanceMPIold()  
double Info::enhanceMPIoldavg()  
These methods are only relevant for hard diffraction with the requirement of no MPI in the hadron-hadron collision. Then an impact parameter and associated enhancement factor is picked for this collision, but afterwards overwritten when the Pomeron-hadron subcollision is considered. In such cases the old hadron-hadron values can be found here, while bMPI, enhanceMPI and enhanceMPIavg provide the new Pomeron-hadron ones.

Cross sections

Dedicated documentation describes the details of cross sections and weights.

Loop counters

Mainly for internal/debug purposes, a number of loop counters from various parts of the program are stored in the Info class, so that one can keep track of how the event generation is progressing. This may be especially useful in the context of the User Hooks facility.

int Info::getCounter(int i)  
the method that gives you access to the value of the various loop counters.
argument i : the counter number you want to access:
argumentoption 0 - 9 : counters that refer to the run as a whole, i.e. are set 0 at the beginning of the run and then only can increase.
argumentoption 0 : the number of successful constructor calls for the Pythia class (can only be 0 or 1).
argumentoption 1 : the number of times a Pythia::init() call has been begun.
argumentoption 2 : the number of times a Pythia::init() call has been completed successfully.
argumentoption 3 : the number of times a Pythia::next() call has been begun.
argumentoption 4 : the number of times a Pythia::next() call has been completed successfully.
argumentoption 10 - 19 : counters that refer to each individual event, and are reset and updated in the top-level Pythia::next() method.
argumentoption 10 : the number of times the selection of a new hard process has been begun. Normally this should only happen once, unless a user veto is set to abort the current process and try a new one.
argumentoption 11 : the number of times the selection of a new hard process has been completed successfully.
argumentoption 12 : as 11, but additionally the process should survive any user veto and go on to the parton- and hadron-level stages.
argumentoption 13 : as 11, but additionally the process should survive the parton- and hadron-level stage and any user cuts.
argumentoption 14 : the number of times the loop over parton- and hadron-level processing has begun for a hard process. Is reset each time counter 12 above is reached.
argumentoption 15 : the number of times the above loop has successfully completed the parton-level step.
argumentoption 16 : the number of times the above loop has successfully completed the checks and user vetoes after the parton-level step.
argumentoption 17 : the number of times the above loop has successfully completed the hadron-level step.
argumentoption 18 : the number of times the above loop has successfully completed the checks and user vetoes after the hadron-level step.
argumentoption 20 - 39 : counters that refer to a local part of the individual event, and are reset at the beginning of this part.
argumentoption 20 : the current system being processed in PartonLevel::next(). Is almost always 1, but for double diffraction the two diffractive systems are 1 and 2, respectively.
argumentoption 21 : the number of times the processing of the current system (see above) has begun.
argumentoption 22 : the number of times a step has begun in the combined MPI/ISR/FSR evolution downwards in pT for the current system.
argumentoption 23 : the number of times MPI has been selected for the downwards step above.
argumentoption 24 : the number of times ISR has been selected for the downwards step above.
argumentoption 25 : the number of times FSR has been selected for the downwards step above.
argumentoption 26 : the number of times MPI has been accepted as the downwards step above, after the vetoes.
argumentoption 27 : the number of times ISR has been accepted as the downwards step above, after the vetoes.
argumentoption 28 : the number of times FSR has been accepted as the downwards step above, after the vetoes.
argumentoption 29 : the number of times a step has begun in the separate (optional) FSR evolution downwards in pT for the current system.
argumentoption 30 : the number of times FSR has been selected for the downwards step above.
argumentoption 31 : the number of times FSR has been accepted as the downwards step above, after the vetoes.
argumentoption 40 : keeps track of vetoed emission for shower reweighting.
argumentoption 41 - 49 : counters that are unused (currently), and that therefore are free to use, with the help of the two methods below.

void Info::setCounter(int i, int value = 0)  
set the above counters to a given value. Only to be used by you for the unassigned counters 40 - 49.
argument i : the counter number, see above.
argument value (default = 0) : set the counter to this number; normally the default value is what you want.

void Info::addCounter(int i, int value = 0)  
increase the above counters by a given amount. Only to be used by you for the unassigned counters 40 - 49.
argument i : the counter number, see above.
argument value (default = 1) : increase the counter by this amount; normally the default value is what you want.

Parton shower history

The following methods are mainly intended for internal use, e.g. for matrix-element matching.

void Info::hasHistory(bool hasHistoryIn)  
bool Info::hasHistory()  
set/get knowledge whether the likely shower history of an event has been traced.

void Info::zNowISR(bool zNowIn)  
double Info::zNowISR()  
set/get value of z in latest ISR branching.

void Info::pT2NowISR(bool pT2NowIn)  
double Info::pT2NowISR()  
set/get value of pT^2 in latest ISR branching.

Les Houches Event File information

Since the Info class is one of the main interfaces between the PYTHIA generation and the user, it also handles the retrieval of information that is passed to PYTHIA through input Les Houches Event files. The Info class further provides the interface to the information stored after reading Les Houches Event files in the updated format [But14]. An example main program using LHEF 3.0 information is main127.cc. For the documentation of the necessary Info class retrieval functions, please consult the Les Houches Event Files section.

Heavy Ion Information

When generating collisions involving heavy ions, the Info object will contain a non-null pointer Info::hiInfo to a special HIInfo object. The information stored there is typically related to the Glauber modelling of the nucleons in a nuclei.

double HIInfo::b()  
the impact parameter in femtometers.

double HIInfo::phi()  
the impact parameter angle.

double HIInfo::sigmaTot()  
the total cross section from the Glauber calculation in millibarns.

double HIInfo::sigmaTotErr()  
the error in the total cross section.

double HIInfo::sigmaND()  
the inelastic non-diffractive cross section from the Glauber calculation in millibarns.

double HIInfo::sigmaNDErr()  
the error in the inelastic non-diffractive cross section.

long HIInfo::nAttempts()  
the number of attempted impact parameter points.

long HIInfo::nAccepted()  
the number of accepted impact parameter points (resulting in actual events).

int HIInfo::nCollTot()  
the number of separate sub-collisions in the current event.

int HIInfo::nCollND()  
the number of separate fully non-diffractive sub-collisions in the current event.

int HIInfo::nCollNDTot()  
the total number of non-diffractive NN-collisions in the current event.

int HIInfo::nCollSDP()  
the number of separate single diffractive projectile nucleon excitation sub-collisions in the current event.

int HIInfo::nCollSDT()  
the number of separate single diffractive target nucleon excitation sub-collisions in the current event.

int HIInfo::nCollDD()  
the number of separate double diffractive excitation sub-collisions in the current event.

int HIInfo::nCollCD()  
the number of separate central diffractive excitation sub-collisions in the current event.

int HIInfo::nCollEL()  
the number of separate elastic sub-collisions in the current event.

int HIInfo::nPartProj()  
number of interacting projectile nucleons in the current event.

int HIInfo::nAbsProj()  
number of absorptively wounded projectile nucleons in the current event.

int HIInfo::nDiffProj()  
number of diffrectively wounded projectile nucleons in the current event.

int HIInfo::nELProj()  
number of elastically scattered projectile nucleons in the current event.

int HIInfo::nPartTarg()  
number of interacting target nucleons in the current event.

int HIInfo::nAbsTarg()  
number of absorptively wounded target nucleons in the current event.

int HIInfo::nDiffTarg()  
number of diffrectively wounded target nucleons in the current event.

int HIInfo::nELTarg()  
number of elastically scattered target nucleons in the current event.

int HIInfo::nFail()  
number of failed nucleon excitations in the current event.

double HIInfo::weight()  
the weight of the current event.

double HIInfo::weightSum()  
the sum of weights of the events generated so far.