[1] | 1 | <chapter name="Event Information"> |
---|
| 2 | |
---|
| 3 | <h2>Event Information</h2> |
---|
| 4 | |
---|
| 5 | The <code>Info</code> class collects various one-of-a-kind information, |
---|
| 6 | some relevant for all events and others for the current event. |
---|
| 7 | An object <code>info</code> is a public member of the <code>Pythia</code> |
---|
| 8 | class, so if you e.g. have declared <code>Pythia pythia</code>, the |
---|
| 9 | <code>Info</code> methods can be accessed by |
---|
| 10 | <code>pythia.info.method()</code>. Most of this is information that |
---|
| 11 | could also be obtained e.g. from the event record, but is here more |
---|
| 12 | directly available. It is primarily intended for processes generated |
---|
| 13 | internally in PYTHIA, but many of the methods would work also for |
---|
| 14 | events fed in via the Les Houches Accord. |
---|
| 15 | |
---|
| 16 | <h3>List information</h3> |
---|
| 17 | |
---|
| 18 | <method name="void Info::list()"> |
---|
| 19 | a listing of most of the information set for the current event. |
---|
| 20 | </method> |
---|
| 21 | |
---|
| 22 | <h3>The beams</h3> |
---|
| 23 | |
---|
| 24 | <method name="int Info::idA()"> |
---|
| 25 | </method> |
---|
| 26 | <methodmore name="int Info::idB()"> |
---|
| 27 | the identities of the two beam particles. |
---|
| 28 | </methodmore> |
---|
| 29 | |
---|
| 30 | <method name="double Info::pzA()"> |
---|
| 31 | </method> |
---|
| 32 | <methodmore name="double Info::pzB()"> |
---|
| 33 | the longitudinal momenta of the two beam particles. |
---|
| 34 | </methodmore> |
---|
| 35 | |
---|
| 36 | <method name="double Info::eA()"> |
---|
| 37 | </method> |
---|
| 38 | <methodmore name="double Info::eB()"> |
---|
| 39 | the energies of the two beam particles. |
---|
| 40 | </methodmore> |
---|
| 41 | |
---|
| 42 | <method name="double Info::mA()"> |
---|
| 43 | </method> |
---|
| 44 | <methodmore name="double Info::mB()"> |
---|
| 45 | the masses of the two beam particles. |
---|
| 46 | </methodmore> |
---|
| 47 | |
---|
| 48 | <method name="double Info::eCM()"> |
---|
| 49 | </method> |
---|
| 50 | <methodmore name="double Info::s()"> |
---|
| 51 | the CM energy and its square for the two beams. |
---|
| 52 | </methodmore> |
---|
| 53 | |
---|
| 54 | <h3>Initialization</h3> |
---|
| 55 | |
---|
| 56 | <method name="bool Info::tooLowPTmin()"> |
---|
| 57 | normally false, but true if the proposed <ei>pTmin</ei> scale was too low |
---|
| 58 | in timelike or spacelike showers, or in multiparton interactions. In the |
---|
| 59 | former case the <ei>pTmin</ei> is raised to some minimal value, in the |
---|
| 60 | latter the initialization fails (it is impossible to obtain a minijet |
---|
| 61 | cross section bigger than the nondiffractive one by reducing |
---|
| 62 | <ei>pTmin</ei>). |
---|
| 63 | </method> |
---|
| 64 | |
---|
| 65 | <h3>The event type</h3> |
---|
| 66 | |
---|
| 67 | <method name="string Info::name()"> |
---|
| 68 | </method> |
---|
| 69 | <methodmore name="int Info::code()"> |
---|
| 70 | the name and code of the process that occured. |
---|
| 71 | </methodmore> |
---|
| 72 | |
---|
| 73 | <method name="int Info::nFinal()"> |
---|
| 74 | the number of final-state partons in the hard process. |
---|
| 75 | </method> |
---|
| 76 | |
---|
| 77 | <method name="bool Info::isResolved()"> |
---|
| 78 | are beam particles resolved, i.e. were PDF's used for the process? |
---|
| 79 | </method> |
---|
| 80 | |
---|
| 81 | <method name="bool Info::isDiffractiveA()"> |
---|
| 82 | </method> |
---|
| 83 | <methodmore name="bool Info::isDiffractiveB()"> |
---|
| 84 | is either beam diffractively excited? |
---|
| 85 | </methodmore> |
---|
| 86 | |
---|
| 87 | <method name="bool Info::isDiffractiveC()"> |
---|
| 88 | is there central diffraction (a.k.a. double Pomeron exchange)? |
---|
| 89 | </method> |
---|
| 90 | |
---|
| 91 | <method name="bool Info::isMinBias()"> |
---|
| 92 | is the process a minimum-bias one? |
---|
| 93 | </method> |
---|
| 94 | |
---|
| 95 | <method name="bool Info::isLHA()"> |
---|
| 96 | has the process been generated from external Les Houches Accord |
---|
| 97 | information? |
---|
| 98 | </method> |
---|
| 99 | |
---|
| 100 | <method name="bool Info::atEndOfFile()"> |
---|
| 101 | true if a linked Les Houches class refuses to return any further |
---|
| 102 | events, presumably because it has reached the end of the file from |
---|
| 103 | which events have been read in. |
---|
| 104 | </method> |
---|
| 105 | |
---|
| 106 | <method name="bool Info::hasSub()"> |
---|
| 107 | does the process have a subprocess classification? |
---|
| 108 | Currently only true for minbias and Les Houches events, where it allows |
---|
| 109 | the hardest collision to be identified. |
---|
| 110 | </method> |
---|
| 111 | |
---|
| 112 | <method name="string Info::nameSub()"> |
---|
| 113 | </method> |
---|
| 114 | <methodmore name="int Info::codeSub()"> |
---|
| 115 | </methodmore> |
---|
| 116 | <methodmore name="int Info::nFinalSub()"> |
---|
| 117 | the name, code and number of final-state partons in the subprocess |
---|
| 118 | that occured when <code>hasSub()</code> is true. For a minimum-bias event |
---|
| 119 | the <code>code</code> would always be 101, while <code>codeSub()</code> |
---|
| 120 | would vary depending on the actual hardest interaction, e.g. 111 for |
---|
| 121 | <ei>g g -> g g</ei>. For a Les Houches event the <code>code</code> would |
---|
| 122 | always be 9999, while <code>codeSub()</code> would be the external |
---|
| 123 | user-defined classification code. The methods below would also provide |
---|
| 124 | information for such particular subcollisions. |
---|
| 125 | </methodmore> |
---|
| 126 | |
---|
| 127 | <h3>Hard process initiators</h3> |
---|
| 128 | |
---|
| 129 | The methods in this sections refer to the two initial partons of the |
---|
| 130 | hard <ei>2 -> n</ei> process (diffraction excluded; see below). |
---|
| 131 | |
---|
| 132 | <method name="int Info::id1()"> |
---|
| 133 | </method> |
---|
| 134 | <methodmore name="int Info::id2()"> |
---|
| 135 | the identities of the two partons coming in to the hard process. |
---|
| 136 | </methodmore> |
---|
| 137 | |
---|
| 138 | <method name="double Info::x1()"> |
---|
| 139 | </method> |
---|
| 140 | <methodmore name="double Info::x2()"> |
---|
| 141 | <ei>x</ei> fractions of the two partons coming in to the hard process. |
---|
| 142 | </methodmore> |
---|
| 143 | |
---|
| 144 | <method name="double Info::y()"> |
---|
| 145 | </method> |
---|
| 146 | <methodmore name="double Info::tau()"> |
---|
| 147 | rapidity and scaled mass-squared of the hard-process subsystem, as |
---|
| 148 | defined by the above <ei>x</ei> values. |
---|
| 149 | </methodmore> |
---|
| 150 | |
---|
| 151 | <method name="bool Info::isValence1()"> |
---|
| 152 | </method> |
---|
| 153 | <methodmore name="bool Info::isValence2()"> |
---|
| 154 | <code>true</code> if the two hard incoming partons have been picked |
---|
| 155 | to belong to the valence piece of the parton-density distribution, |
---|
| 156 | else <code>false</code>. Should be interpreted with caution. |
---|
| 157 | Information is not set if you switch off parton-level processing. |
---|
| 158 | </methodmore> |
---|
| 159 | |
---|
| 160 | <h3>Hard process parton densities and scales</h3> |
---|
| 161 | |
---|
| 162 | The methods in this section refer to the partons for which parton |
---|
| 163 | densities have been defined, in order to calculate the cross section |
---|
| 164 | of the hard process (diffraction excluded; see below). |
---|
| 165 | |
---|
| 166 | <p/> |
---|
| 167 | These partons would normally agree with the |
---|
| 168 | ones above, the initiators of the <ei>2 -> n</ei> process, but it |
---|
| 169 | does not have to be so. Currently the one counterexample is POWHEG |
---|
| 170 | events <ref>Ali10</ref>. Here the original hard process could be |
---|
| 171 | <ei>2 -> (n-1)</ei>. The NLO machinery at times would add an |
---|
| 172 | initial-state branching to give a <ei>2 -> n</ei> process with a |
---|
| 173 | changed initial state. In that case the values in this section |
---|
| 174 | refer to the original <ei>2 -> (n-1)</ei> state and the initiator |
---|
| 175 | ones above to the complete<ei>2 -> n</ei> process. The |
---|
| 176 | <code>Info::list()</code> printout will contain a warning in such cases. |
---|
| 177 | |
---|
| 178 | <p/> |
---|
| 179 | For external events in the Les Houches format, the pdf information |
---|
| 180 | is obtained from the optional <code>#pdf</code> line. When this |
---|
| 181 | information is absent, the parton identities and <ei>x</ei> values agree |
---|
| 182 | with the initiator ones above, while the pdf values are unknown and |
---|
| 183 | therefore set to vanish. The <ei>alpha_s</ei> and <ei>alpha_em</ei> |
---|
| 184 | values are part of the compulsory information. The factorization and |
---|
| 185 | renormalization scales are both equated with the one compulsory scale |
---|
| 186 | value in the Les Houches standard, except when a <code>#pdf</code> |
---|
| 187 | line provides the factorization scale separately. If <ei>alpha_s</ei>, |
---|
| 188 | <ei>alpha_em</ei> or the compulsory scale value are negative at input |
---|
| 189 | then new values are defined as for internal processes. |
---|
| 190 | |
---|
| 191 | <method name="int Info::id1pdf()"> |
---|
| 192 | </method> |
---|
| 193 | <methodmore name="int Info::id2pdf()"> |
---|
| 194 | the identities of the two partons for which parton density values |
---|
| 195 | are defined. |
---|
| 196 | </methodmore> |
---|
| 197 | |
---|
| 198 | <method name="double Info::x1pdf()"> |
---|
| 199 | </method> |
---|
| 200 | <methodmore name="double Info::x2pdf()"> |
---|
| 201 | <ei>x</ei> fractions of the two partons for which parton density values |
---|
| 202 | are defined. |
---|
| 203 | </methodmore> |
---|
| 204 | |
---|
| 205 | <method name="double Info::pdf1()"> |
---|
| 206 | </method> |
---|
| 207 | <methodmore name="double Info::pdf2()"> |
---|
| 208 | parton densities <ei>x*f(x,Q^2)</ei> evaluated for the two incoming |
---|
| 209 | partons; could be used e.g. for reweighting purposes in conjunction |
---|
| 210 | with the <code>idpdf</code>, <code>xpdf</code> and <code>QFac</code> |
---|
| 211 | methods. Events obtained from external programs or files may not |
---|
| 212 | contain this information and, if so, 0 is returned. |
---|
| 213 | </methodmore> |
---|
| 214 | |
---|
| 215 | <method name="double Info::QFac()"> |
---|
| 216 | </method> |
---|
| 217 | <methodmore name="double Info::Q2Fac()"> |
---|
| 218 | the <ei>Q</ei> or <ei>Q^2</ei> factorization scale at which the |
---|
| 219 | densities were evaluated. |
---|
| 220 | </methodmore> |
---|
| 221 | |
---|
| 222 | <method name="double Info::alphaS()"> |
---|
| 223 | </method> |
---|
| 224 | <methodmore name="double Info::alphaEM()"> |
---|
| 225 | the <ei>alpha_strong</ei> and <ei>alpha_electromagnetic</ei> values used |
---|
| 226 | for the hard process. |
---|
| 227 | </methodmore> |
---|
| 228 | |
---|
| 229 | <method name="double Info::QRen()"> |
---|
| 230 | </method> |
---|
| 231 | <methodmore name="double Info::Q2Ren()"> |
---|
| 232 | the <ei>Q</ei> or <ei>Q^2</ei> renormalization scale at which |
---|
| 233 | <ei>alpha_strong</ei> and <ei>alpha_electromagnetic</ei> were evaluated. |
---|
| 234 | </methodmore> |
---|
| 235 | |
---|
| 236 | <h3>Hard process kinematics</h3> |
---|
| 237 | |
---|
| 238 | The methods in this section provide info on the kinematics of the hard |
---|
| 239 | processes, with special emphasis on <ei>2 -> 2</ei> (diffraction excluded; |
---|
| 240 | see below). |
---|
| 241 | |
---|
| 242 | <method name="double Info::mHat()"> |
---|
| 243 | </method> |
---|
| 244 | <methodmore name="double Info::sHat()"> |
---|
| 245 | the invariant mass and its square for the hard process. |
---|
| 246 | </methodmore> |
---|
| 247 | |
---|
| 248 | <method name="double Info::tHat()"> |
---|
| 249 | </method> |
---|
| 250 | <methodmore name="double Info::uHat()"> |
---|
| 251 | the remaining two Mandelstam variables; only defined for <ei>2 -> 2</ei> |
---|
| 252 | processes. |
---|
| 253 | </methodmore> |
---|
| 254 | |
---|
| 255 | <method name="double Info::pTHat()"> |
---|
| 256 | </method> |
---|
| 257 | <methodmore name="double Info::pT2Hat()"> |
---|
| 258 | transverse momentum and its square in the rest frame of a <ei>2 -> 2</ei> |
---|
| 259 | processes. |
---|
| 260 | </methodmore> |
---|
| 261 | |
---|
| 262 | <method name="double Info::m3Hat()"> |
---|
| 263 | </method> |
---|
| 264 | <methodmore name="double Info::m4Hat()"> |
---|
| 265 | the masses of the two outgoing particles in a <ei>2 -> 2</ei> processes. |
---|
| 266 | </methodmore> |
---|
| 267 | |
---|
| 268 | <method name="double Info::thetaHat()"> |
---|
| 269 | </method> |
---|
| 270 | <methodmore name="double Info::phiHat()"> |
---|
| 271 | the polar and azimuthal scattering angles in the rest frame of |
---|
| 272 | a <ei>2 -> 2</ei> process. |
---|
| 273 | </methodmore> |
---|
| 274 | |
---|
| 275 | <h3>Diffraction</h3> |
---|
| 276 | |
---|
| 277 | Information on the primary elastic or |
---|
| 278 | <aloc href="Diffraction">diffractive</aloc> process |
---|
| 279 | (<ei>A B -> A B, X1 B, A X2, X1 X2, A X B</ei>) can be obtained with |
---|
| 280 | the methods in the "Hard process kinematics" section above. The |
---|
| 281 | variables here obviously are <ei>s, t, u, ...</ei> rather than |
---|
| 282 | <ei>sHat, tHat, uHat, ...</ei>, but the method names remain to avoid |
---|
| 283 | unnecessary duplication. Most other methods are irrelevant for a |
---|
| 284 | primary elastic/diffractive process. |
---|
| 285 | |
---|
| 286 | <p/>Central diffraction <ei>A B -> A X B</ei> is a <ei>2 -> 3</ei> |
---|
| 287 | process, and therefore most of the <ei>2 -> 2</ei> variables are |
---|
| 288 | no longer relevant. The <code>tHat()</code> and <code>uHat()</code> |
---|
| 289 | methods instead return the two <ei>t</ei> values at the <ei>A -> A</ei> |
---|
| 290 | and <ei>B -> B</ei> vertices, and <code>pTHat()</code> the average |
---|
| 291 | transverse momentum of the three outgoing "particles", while |
---|
| 292 | <code>thetaHat()</code> and <code>phiHat()</code> are undefined. |
---|
| 293 | |
---|
| 294 | <p/> |
---|
| 295 | While the primary interaction does not contain a hard process, |
---|
| 296 | the diffractive subsystems can contain them, but need not. |
---|
| 297 | Specifically, double diffraction can contain two separate hard |
---|
| 298 | subprocesses, which breaks the methods above. Most of them have been |
---|
| 299 | expanded with an optional argument to address properties of diffractive |
---|
| 300 | subsystems. This argument can take four values: |
---|
| 301 | <ul> |
---|
| 302 | <li>0 : default argument, used for normal nondiffractive events or |
---|
| 303 | the primary elastic/diffractive process (see above); |
---|
| 304 | <li>1 : the <ei>X1</ei> system in single diffraction <ei>A B -> X1 B</ei> |
---|
| 305 | or double diffraction <ei>A B -> X1 X2</ei>; |
---|
| 306 | <li>2 : the <ei>X2</ei> system in single diffraction <ei>A B -> A X2</ei> |
---|
| 307 | or double diffraction <ei>A B -> X1 X2</ei>; |
---|
| 308 | <li>3 : the <ei>X</ei> system in central diffraction <ei>A B -> A X B</ei>. |
---|
| 309 | </ul> |
---|
| 310 | The argument is defined for all of the methods in the three sections above, |
---|
| 311 | "Hard process initiators", "Hard process parton densities and scales" and |
---|
| 312 | "Hard process kinematics", with the exception of the <code>isValence</code> |
---|
| 313 | methods. Also the four final methods of "The event type" section, the |
---|
| 314 | <code>...Sub()</code> methods, take this argument. But recall that they |
---|
| 315 | will only provide meaningful answers, firstly if there is a system of the |
---|
| 316 | requested type, and secondly if there is a hard subprocess in this system. |
---|
| 317 | A simple check for this is that <code>id1()</code> has to be nonvanishing. |
---|
| 318 | The methods below this section do not currently provide information |
---|
| 319 | specific to diffractive subsystems, e.g. the MPI information is not |
---|
| 320 | bookkept in such cases. |
---|
| 321 | |
---|
| 322 | <h3>Event weight and activity</h3> |
---|
| 323 | |
---|
| 324 | <method name="double Info::weight()"> |
---|
| 325 | weight assigned to the current event. Is normally 1 and thus |
---|
| 326 | uninteresting. However, there are several cases where one may have |
---|
| 327 | nontrivial event weights. These weights must the be used e.g. when |
---|
| 328 | filling histograms. |
---|
| 329 | <br/>(i) In the <code><aloc href="PhaseSpaceCuts"> |
---|
| 330 | PhaseSpace:increaseMaximum = off</aloc></code> default strategy, |
---|
| 331 | an event with a differential cross-section above the assumed one |
---|
| 332 | (in a given phase-space point) is assigned a weight correspondingly |
---|
| 333 | above unity. This should happen only very rarely, if at all, and so |
---|
| 334 | could normally be disregarded. |
---|
| 335 | <br/>(ii) The <aloc href="UserHooks">User Hooks</aloc> class offers |
---|
| 336 | the possibility to bias the selection of phase space points, which |
---|
| 337 | means that events come with a compensating weight, stored here. |
---|
| 338 | <br/>(iii) For Les Houches events some strategies allow negative weights, |
---|
| 339 | which then after unweighting lead to events with weight -1. There are |
---|
| 340 | also Les Houches strategies where no unweighting is done, so events |
---|
| 341 | come with a weight. Specifically, for strategies <ei>+4</ei> and |
---|
| 342 | <ei>-4</ei>, the event weight is in units of pb. (Internally in mb, |
---|
| 343 | but converted at output.) |
---|
| 344 | </method> |
---|
| 345 | |
---|
| 346 | <method name="double Info::weightSum()"> |
---|
| 347 | Sum of weights accumulated during the run. For unweighted events this |
---|
| 348 | agrees with the number of generated events. In order to obtain |
---|
| 349 | histograms normalized "per event", at the end of a run, histogram |
---|
| 350 | contents should be divided by this weight. (And additionally |
---|
| 351 | divided by the bin width.) Normalization to cross section also |
---|
| 352 | required multiplication by <code>sigmaGen()</code> below. |
---|
| 353 | </method> |
---|
| 354 | |
---|
| 355 | <method name="int Info::lhaStrategy()"> |
---|
| 356 | normally 0, but if Les Houches events are input then it gives the |
---|
| 357 | event weighting strategy, see |
---|
| 358 | <aloc href="LesHouchesAccord">Les Houches Accord</aloc>. |
---|
| 359 | </method> |
---|
| 360 | |
---|
| 361 | <method name="int Info::nISR()"> |
---|
| 362 | </method> |
---|
| 363 | <methodmore name="int Info::nFSRinProc()"> |
---|
| 364 | </methodmore> |
---|
| 365 | <methodmore name="int Info::nFSRinRes()"> |
---|
| 366 | the number of emissions in the initial-state showering, in the final-state |
---|
| 367 | showering excluding resonance decys, and in the final-state showering |
---|
| 368 | inside resonance decays, respectively. |
---|
| 369 | </methodmore> |
---|
| 370 | |
---|
| 371 | <method name="double Info::pTmaxMPI()"> |
---|
| 372 | </method> |
---|
| 373 | <methodmore name="double Info::pTmaxISR()"> |
---|
| 374 | </methodmore> |
---|
| 375 | <methodmore name="double Info::pTmaxFSR()"> |
---|
| 376 | Maximum <ei>pT</ei> scales set for MPI, ISR and FSR, given the |
---|
| 377 | process type and scale choice for the hard interactions. The actual |
---|
| 378 | evolution will run down from these scales. |
---|
| 379 | </methodmore> |
---|
| 380 | |
---|
| 381 | <method name="double Info::pTnow()"> |
---|
| 382 | The current <ei>pT</ei> scale in the combined MPI, ISR and FSR evolution. |
---|
| 383 | Useful for classification in <aloc href="UserHooks">user hooks</aloc>, |
---|
| 384 | but not once the event has been evolved. |
---|
| 385 | </method> |
---|
| 386 | |
---|
| 387 | <method name="double Info::mergingWeight()"> |
---|
| 388 | combined CKKW-L weight assigned to the current event. If CKKW-L merging is |
---|
| 389 | performed, all histograms should be filled with this weight, as discussed in |
---|
| 390 | <a href="MatrixElementMerging.html" target="page"> Matrix Element |
---|
| 391 | Merging</a>. |
---|
| 392 | </method> |
---|
| 393 | |
---|
| 394 | <h3>Multiparton interactions</h3> |
---|
| 395 | |
---|
| 396 | <method name="double Info::a0MPI()"> |
---|
| 397 | The value of a0 when an x-dependent matter profile is used, |
---|
| 398 | <code>MultipartonInteractions:bProfile = 4</code>. |
---|
| 399 | </method> |
---|
| 400 | |
---|
| 401 | <method name="double Info::bMPI()"> |
---|
| 402 | The impact parameter <ei>b</ei> assumed for the current collision when |
---|
| 403 | multiparton interactions are simulated. Is not expressed in any physical |
---|
| 404 | size (like fm), but only rescaled so that the average should be unity |
---|
| 405 | for minimum-bias events (meaning less than that for events with hard |
---|
| 406 | processes). |
---|
| 407 | </method> |
---|
| 408 | |
---|
| 409 | <method name="double Info::enhanceMPI()"> |
---|
| 410 | The choice of impact parameter implies an enhancement or depletion of |
---|
| 411 | the rate of subsequent interactions, as given by this number. Again |
---|
| 412 | the average is normalized be unity for minimum-bias events (meaning |
---|
| 413 | more than that for events with hard processes). |
---|
| 414 | </method> |
---|
| 415 | |
---|
| 416 | <method name="int Info::nMPI()"> |
---|
| 417 | The number of hard interactions in the current event. Is 0 for elastic |
---|
| 418 | and diffractive events, and else at least 1, with more possible from |
---|
| 419 | multiparton interactions. |
---|
| 420 | </method> |
---|
| 421 | |
---|
| 422 | <method name="int Info::codeMPI(int i)"> |
---|
| 423 | </method> |
---|
| 424 | <methodmore name="double Info::pTMPI(int i)"> |
---|
| 425 | the process code and transverse momentum of the <code>i</code>'th |
---|
| 426 | subprocess, with <code>i</code> in the range from 0 to |
---|
| 427 | <code>nMPI() - 1</code>. The values for subprocess 0 is redundant with |
---|
| 428 | information already provided above. |
---|
| 429 | </methodmore> |
---|
| 430 | |
---|
| 431 | <method name="int Info::iAMPI(int i)"> |
---|
| 432 | </method> |
---|
| 433 | <methodmore name="int Info::iBMPI(int i)"> |
---|
| 434 | are normally zero. However, if the <code>i</code>'th subprocess is |
---|
| 435 | a rescattering, i.e. either or both incoming partons come from the |
---|
| 436 | outgoing state of previous scatterings, they give the position in the |
---|
| 437 | event record of the outgoing-state parton that rescatters. |
---|
| 438 | <code>iAMPI</code> and <code>iBMPI</code> then denote partons coming from |
---|
| 439 | the first or second beam, respectively. |
---|
| 440 | </methodmore> |
---|
| 441 | |
---|
| 442 | <method name="double Info::eMPI(int i)"> |
---|
| 443 | The enhancement or depletion of the rate of the <code>i</code>'th |
---|
| 444 | subprocess. Is primarily of interest for the |
---|
| 445 | <code>MultipartonInteractions:bProfile = 4</code> option, where the |
---|
| 446 | size of the proton depends on the <ei>x</ei> values of the colliding |
---|
| 447 | partons. Note that <code>eMPI(0) = enhanceMPI()</code>. |
---|
| 448 | </method> |
---|
| 449 | |
---|
| 450 | <h3>Cross sections</h3> |
---|
| 451 | |
---|
| 452 | Here are the currently available methods related to the event sample |
---|
| 453 | as a whole, for the default value <code>i = 0</code>, and otherwise for |
---|
| 454 | the specific process code provided as argument. This is the number |
---|
| 455 | obtained with <code>Info::code()</code>, while the further subdivision |
---|
| 456 | given by <code>Info::codeSub()</code> is not bookkept. While continuously |
---|
| 457 | updated during the run, it is recommended only to study these properties |
---|
| 458 | at the end of the event generation, when the full statistics is available. |
---|
| 459 | The individual process results are not available if |
---|
| 460 | <aloc href="ASecondHardProcess">a second hard process</aloc> has beeen |
---|
| 461 | chosen, but can be gleaned from the <code>pythia.stat()</code> output. |
---|
| 462 | |
---|
| 463 | <method name="long Info::nTried(int i = 0)"> |
---|
| 464 | </method> |
---|
| 465 | <methodmore name="long Info::nSelected(int i = 0)"> |
---|
| 466 | </methodmore> |
---|
| 467 | <methodmore name="long Info::nAccepted(int i = 0)"> |
---|
| 468 | the total number of tried phase-space points, selected hard processes |
---|
| 469 | and finally accepted events, summed over all allowed processes |
---|
| 470 | (<code>i = 0</code>) or for the given process. |
---|
| 471 | The first number is only intended for a study of the phase-space selection |
---|
| 472 | efficiency. The last two numbers usually only disagree if the user introduces |
---|
| 473 | some veto during the event-generation process; then the former is the number |
---|
| 474 | of acceptable events found by PYTHIA and the latter the number that also |
---|
| 475 | were approved by the user. If you set <aloc href="ASecondHardProcess">a |
---|
| 476 | second hard process</aloc> there may also be a mismatch. |
---|
| 477 | </methodmore> |
---|
| 478 | |
---|
| 479 | <method name="double Info::sigmaGen(int i = 0)"> |
---|
| 480 | </method> |
---|
| 481 | <methodmore name="double Info::sigmaErr(int i = 0)"> |
---|
| 482 | the estimated cross section and its estimated error, |
---|
| 483 | summed over all allowed processes (<code>i = 0</code>) or for the given |
---|
| 484 | process, in units of mb. The numbers refer to the accepted event sample |
---|
| 485 | above, i.e. after any user veto. |
---|
| 486 | </methodmore> |
---|
| 487 | |
---|
| 488 | <h3>Loop counters</h3> |
---|
| 489 | |
---|
| 490 | Mainly for internal/debug purposes, a number of loop counters from |
---|
| 491 | various parts of the program are stored in the <code>Info</code> class, |
---|
| 492 | so that one can keep track of how the event generation is progressing. |
---|
| 493 | This may be especially useful in the context of the |
---|
| 494 | <code><aloc href="UserHooks">User Hooks</aloc></code> facility. |
---|
| 495 | |
---|
| 496 | <method name="int Info::getCounter(int i)"> |
---|
| 497 | the method that gives you access to the value of the various loop |
---|
| 498 | counters. |
---|
| 499 | <argument name="i"> the counter number you want to access: |
---|
| 500 | <argoption value="0 - 9"> counters that refer to the run as a whole, |
---|
| 501 | i.e. are set 0 at the beginning of the run and then only can increase. |
---|
| 502 | </argoption> |
---|
| 503 | <argoption value="0"> the number of successful constructor calls for the |
---|
| 504 | <code>Pythia</code> class (can only be 0 or 1). |
---|
| 505 | </argoption> |
---|
| 506 | <argoption value="1"> the number of times a <code>Pythia::init(...)</code> |
---|
| 507 | call has been begun. |
---|
| 508 | </argoption> |
---|
| 509 | <argoption value="2"> the number of times a <code>Pythia::init(...)</code> |
---|
| 510 | call has been completed successfully. |
---|
| 511 | </argoption> |
---|
| 512 | <argoption value="3"> the number of times a <code>Pythia::next()</code> |
---|
| 513 | call has been begun. |
---|
| 514 | </argoption> |
---|
| 515 | <argoption value="4"> the number of times a <code>Pythia::next()</code> |
---|
| 516 | call has been completed successfully. |
---|
| 517 | </argoption> |
---|
| 518 | <argoption value="10 - 19"> counters that refer to each individual event, |
---|
| 519 | and are reset and updated in the top-level <code>Pythia::next()</code> |
---|
| 520 | method. |
---|
| 521 | </argoption> |
---|
| 522 | <argoption value="10"> the number of times the selection of a new hard |
---|
| 523 | process has been begun. Normally this should only happen once, unless a |
---|
| 524 | user veto is set to abort the current process and try a new one. |
---|
| 525 | </argoption> |
---|
| 526 | <argoption value="11"> the number of times the selection of a new hard |
---|
| 527 | process has been completed successfully. |
---|
| 528 | </argoption> |
---|
| 529 | <argoption value="12"> as 11, but additionally the process should |
---|
| 530 | survive any user veto and go on to the parton- and hadron-level stages. |
---|
| 531 | </argoption> |
---|
| 532 | <argoption value="13"> as 11, but additionally the process should |
---|
| 533 | survive the parton- and hadron-level stage and any user cuts. |
---|
| 534 | </argoption> |
---|
| 535 | <argoption value="14"> the number of times the loop over parton- and |
---|
| 536 | hadron-level processing has begun for a hard process. Is reset each |
---|
| 537 | time counter 12 above is reached. |
---|
| 538 | </argoption> |
---|
| 539 | <argoption value="15"> the number of times the above loop has successfully |
---|
| 540 | completed the parton-level step. |
---|
| 541 | </argoption> |
---|
| 542 | <argoption value="16"> the number of times the above loop has successfully |
---|
| 543 | completed the checks and user vetoes after the parton-level step. |
---|
| 544 | </argoption> |
---|
| 545 | <argoption value="17"> the number of times the above loop has successfully |
---|
| 546 | completed the hadron-level step. |
---|
| 547 | </argoption> |
---|
| 548 | <argoption value="18"> the number of times the above loop has successfully |
---|
| 549 | completed the checks and user vetoes after the hadron-level step. |
---|
| 550 | </argoption> |
---|
| 551 | <argoption value="20 - 39"> counters that refer to a local part of the |
---|
| 552 | individual event, and are reset at the beginning of this part. |
---|
| 553 | </argoption> |
---|
| 554 | <argoption value="20"> the current system being processed in |
---|
| 555 | <code>PartonLevel::next()</code>. Is almost always 1, but for double |
---|
| 556 | diffraction the two diffractive systems are 1 and 2, respectively. |
---|
| 557 | </argoption> |
---|
| 558 | <argoption value="21"> the number of times the processing of the |
---|
| 559 | current system (see above) has begun. |
---|
| 560 | </argoption> |
---|
| 561 | <argoption value="22"> the number of times a step has begun in the |
---|
| 562 | combined MPI/ISR/FSR evolution downwards in <ei>pT</ei> |
---|
| 563 | for the current system. |
---|
| 564 | </argoption> |
---|
| 565 | <argoption value="23"> the number of times MPI has been selected for the |
---|
| 566 | downwards step above. |
---|
| 567 | </argoption> |
---|
| 568 | <argoption value="24"> the number of times ISR has been selected for the |
---|
| 569 | downwards step above. |
---|
| 570 | </argoption> |
---|
| 571 | <argoption value="25"> the number of times FSR has been selected for the |
---|
| 572 | downwards step above. |
---|
| 573 | </argoption> |
---|
| 574 | <argoption value="26"> the number of times MPI has been accepted as the |
---|
| 575 | downwards step above, after the vetoes. |
---|
| 576 | </argoption> |
---|
| 577 | <argoption value="27"> the number of times ISR has been accepted as the |
---|
| 578 | downwards step above, after the vetoes. |
---|
| 579 | </argoption> |
---|
| 580 | <argoption value="28"> the number of times FSR has been accepted as the |
---|
| 581 | downwards step above, after the vetoes. |
---|
| 582 | </argoption> |
---|
| 583 | <argoption value="29"> the number of times a step has begun in the |
---|
| 584 | separate (optional) FSR evolution downwards in <ei>pT</ei> |
---|
| 585 | for the current system. |
---|
| 586 | </argoption> |
---|
| 587 | <argoption value="30"> the number of times FSR has been selected for the |
---|
| 588 | downwards step above. |
---|
| 589 | </argoption> |
---|
| 590 | <argoption value="31"> the number of times FSR has been accepted as the |
---|
| 591 | downwards step above, after the vetoes. |
---|
| 592 | </argoption> |
---|
| 593 | <argoption value="40 - 49"> counters that are unused (currently), and |
---|
| 594 | that therefore are free to use, with the help of the two methods below. |
---|
| 595 | </argoption> |
---|
| 596 | </argument> |
---|
| 597 | </method> |
---|
| 598 | |
---|
| 599 | <method name="void Info::setCounter(int i, int value = 0)"> |
---|
| 600 | set the above counters to a given value. Only to be used by you |
---|
| 601 | for the unassigned counters 40 - 49. |
---|
| 602 | <argument name="i"> the counter number, see above. |
---|
| 603 | </argument> |
---|
| 604 | <argument name="value" default="0"> set the counter to this number; |
---|
| 605 | normally the default value is what you want. |
---|
| 606 | </argument> |
---|
| 607 | </method> |
---|
| 608 | |
---|
| 609 | <method name="void Info::addCounter(int i, int value = 0)"> |
---|
| 610 | increase the above counters by a given amount. Only to be used by you |
---|
| 611 | for the unassigned counters 40 - 49. |
---|
| 612 | <argument name="i"> the counter number, see above. |
---|
| 613 | </argument> |
---|
| 614 | <argument name="value" default="1"> increase the counter by this amount; |
---|
| 615 | normally the default value is what you want. |
---|
| 616 | </argument> |
---|
| 617 | </method> |
---|
| 618 | |
---|
| 619 | <h3>Parton shower history</h3> |
---|
| 620 | |
---|
| 621 | The following methods are mainly intended for internal use, |
---|
| 622 | e.g. for matrix-element matching. |
---|
| 623 | |
---|
| 624 | <method name="void Info::hasHistory(bool hasHistoryIn)"> |
---|
| 625 | </method> |
---|
| 626 | <methodmore name="bool Info::hasHistory()"> |
---|
| 627 | set/get knowledge whether the likely shower history of an event |
---|
| 628 | has been traced. |
---|
| 629 | </methodmore> |
---|
| 630 | |
---|
| 631 | <method name="void Info::zNowISR(bool zNowIn)"> |
---|
| 632 | </method> |
---|
| 633 | <methodmore name="double Info::zNowISR()"> |
---|
| 634 | set/get value of <ei>z</ei> in latest ISR branching. |
---|
| 635 | </methodmore> |
---|
| 636 | |
---|
| 637 | <method name="void Info::pT2NowISR(bool pT2NowIn)"> |
---|
| 638 | </method> |
---|
| 639 | <methodmore name="double Info::pT2NowISR()"> |
---|
| 640 | set/get value of <ei>pT^2</ei> in latest ISR branching. |
---|
| 641 | </methodmore> |
---|
| 642 | |
---|
| 643 | <h3>Header information</h3> |
---|
| 644 | |
---|
| 645 | A simple string key/value store, mainly intended for accessing |
---|
| 646 | information that is stored in the header block of Les Houches Event |
---|
| 647 | (LHE) files. In principle, any <code>LHAup</code> derived class can set |
---|
| 648 | this header information, which can then be read out later. Although the |
---|
| 649 | naming convention is arbitrary, in practice, it is dictated by the |
---|
| 650 | XML-like format of LHE files, see <aloc href="LesHouchesAccord"> |
---|
| 651 | Les Houches Accord</aloc> for more details. |
---|
| 652 | |
---|
| 653 | <method name="string Info::header(string key)"> |
---|
| 654 | return the header named <code>key</code> |
---|
| 655 | </method> |
---|
| 656 | |
---|
| 657 | <method name="vector <string> Info::headerKeys()"> |
---|
| 658 | return a vector of all header key names |
---|
| 659 | </method> |
---|
| 660 | |
---|
| 661 | <method name="void Info::setHeader(string key, string val)"> |
---|
| 662 | set the header named <code>key</code> with the contents of <code>val</code> |
---|
| 663 | </method> |
---|
| 664 | |
---|
| 665 | </chapter> |
---|
| 666 | |
---|
| 667 | <!-- Copyright (C) 2012 Torbjorn Sjostrand --> |
---|