[1] | 1 | <chapter name="Particle Properties"> |
---|
| 2 | |
---|
| 3 | <h2>Particle Properties</h2> |
---|
| 4 | |
---|
| 5 | A <code>Particle</code> corresponds to one entry/slot in the |
---|
| 6 | event record. Its properties therefore is a mix of ones belonging |
---|
| 7 | to a particle-as-such, like its identity code or four-momentum, |
---|
| 8 | and ones related to the event-as-a-whole, like which mother it has. |
---|
| 9 | |
---|
| 10 | <p/> |
---|
| 11 | What is stored for each particle is |
---|
| 12 | <ul> |
---|
| 13 | <li>the identity code,</li> |
---|
| 14 | <li>the status code,</li> |
---|
| 15 | <li>two mother indices,</li> |
---|
| 16 | <li>two daughter indices,</li> |
---|
| 17 | <li>a colour and an anticolour index,</li> |
---|
| 18 | <li>the four-momentum and mass,</li> |
---|
| 19 | <li>the scale at which the particle was produced (optional),</li> |
---|
| 20 | <li>the polarization/spin/helicity of the particle (optional),</li> |
---|
| 21 | <li>the production vertex and proper lifetime (optional),</li> |
---|
| 22 | <li>a pointer to the particle kind in the particle data table, and</li> |
---|
| 23 | <li>a pointer to the whole particle data table.</li> |
---|
| 24 | </ul> |
---|
| 25 | From these, a number of further quantities may be derived. |
---|
| 26 | |
---|
| 27 | <h3>Basic output methods</h3> |
---|
| 28 | |
---|
| 29 | The following member functions can be used to extract the most important |
---|
| 30 | information: |
---|
| 31 | |
---|
| 32 | <method name="int Particle::id()"> |
---|
| 33 | the identity of a particle, according to the PDG particle codes |
---|
| 34 | <ref>Yao06</ref>. |
---|
| 35 | </method> |
---|
| 36 | |
---|
| 37 | <method name="int Particle::status()"> |
---|
| 38 | status code. The status code includes information on how a particle was |
---|
| 39 | produced, i.e. where in the program execution it was inserted into the |
---|
| 40 | event record, and why. It also tells whether the particle is still present |
---|
| 41 | or not. It does not tell how a particle disappeared, whether by a decay, |
---|
| 42 | a shower branching, a hadronization process, or whatever, but this is |
---|
| 43 | implicit in the status code of its daughter(s). The basic scheme is: |
---|
| 44 | <ul> |
---|
| 45 | <li>status = +- (10 * i + j)</li> |
---|
| 46 | <li> + : still remaining particles</li> |
---|
| 47 | <li> - : decayed/branched/fragmented/... and not remaining</li> |
---|
| 48 | <li> i = 1 - 9 : stage of event generation inside PYTHIA</li> |
---|
| 49 | <li> i = 10 -19 : reserved for future expansion</li> |
---|
| 50 | <li> i >= 20 : free for add-on programs</li> |
---|
| 51 | <li> j = 1 - 9 : further specification</li> |
---|
| 52 | </ul> |
---|
| 53 | In detail, the list of used or foreseen status codes is: |
---|
| 54 | <ul> |
---|
| 55 | <li>11 - 19 : beam particles</li> |
---|
| 56 | <ul> |
---|
| 57 | <li>11 : the event as a whole</li> |
---|
| 58 | <li>12 : incoming beam</li> |
---|
| 59 | <li>13 : incoming beam-inside-beam (e.g. <ei>gamma</ei> |
---|
| 60 | inside <ei>e</ei>)</li> |
---|
| 61 | <li>14 : outgoing elastically scattered</li> |
---|
| 62 | <li>15 : outgoing diffractively scattered</li> |
---|
| 63 | </ul> |
---|
| 64 | <li>21 - 29 : particles of the hardest subprocess</li> |
---|
| 65 | <ul> |
---|
| 66 | <li>21 : incoming</li> |
---|
| 67 | <li>22 : intermediate (intended to have preserved mass)</li> |
---|
| 68 | <li>23 : outgoing</li> |
---|
| 69 | </ul> |
---|
| 70 | <li>31 - 39 : particles of subsequent subprocesses</li> |
---|
| 71 | <ul> |
---|
| 72 | <li>31 : incoming</li> |
---|
| 73 | <li>32 : intermediate (intended to have preserved mass)</li> |
---|
| 74 | <li>33 : outgoing</li> |
---|
| 75 | <li>34 : incoming that has already scattered</li> |
---|
| 76 | </ul> |
---|
| 77 | <li>41 - 49 : particles produced by initial-state-showers</li> |
---|
| 78 | <ul> |
---|
| 79 | <li>41 : incoming on spacelike main branch</li> |
---|
| 80 | <li>42 : incoming copy of recoiler</li> |
---|
| 81 | <li>43 : outgoing produced by a branching</li> |
---|
| 82 | <li>44 : outgoing shifted by a branching</li> |
---|
| 83 | <li>45 : incoming rescattered parton, with changed kinematics |
---|
| 84 | owing to ISR in the mother system (cf. status 34)</li> |
---|
| 85 | <li>46 : incoming copy of recoiler when this is a rescattered |
---|
| 86 | parton (cf. status 42)</li> |
---|
| 87 | </ul> |
---|
| 88 | <li>51 - 59 : particles produced by final-state-showers</li> |
---|
| 89 | <ul> |
---|
| 90 | <li>51 : outgoing produced by parton branching</li> |
---|
| 91 | <li>52 : outgoing copy of recoiler, with changed momentum</li> |
---|
| 92 | <li>53 : copy of recoiler when this is incoming parton, |
---|
| 93 | with changed momentum</li> |
---|
| 94 | <li>54 : copy of a recoiler, when in the initial state of a |
---|
| 95 | different system from the radiator</li> |
---|
| 96 | <li>55 : copy of a recoiler, when in the final state of a |
---|
| 97 | different system from the radiator</li> |
---|
| 98 | </ul> |
---|
| 99 | <li>61 - 69 : particles produced by beam-remnant treatment</li> |
---|
| 100 | <ul> |
---|
| 101 | <li>61 : incoming subprocess particle with primordial <ei>kT</ei> |
---|
| 102 | included</li> |
---|
| 103 | <li>62 : outgoing subprocess particle with primordial <ei>kT</ei> |
---|
| 104 | included</li> |
---|
| 105 | <li>63 : outgoing beam remnant</li> |
---|
| 106 | </ul> |
---|
| 107 | <li>71 - 79 : partons in preparation of hadronization process</li> |
---|
| 108 | <ul> |
---|
| 109 | <li>71 : copied partons to collect into contiguous colour singlet</li> |
---|
| 110 | <li>72 : copied recoiling singlet when ministring collapses to |
---|
| 111 | one hadron and momentum has to be reshuffled</li> |
---|
| 112 | <li>73 : combination of very nearby partons into one</li> |
---|
| 113 | <li>74 : combination of two junction quarks (+ nearby gluons) |
---|
| 114 | to a diquark</li> |
---|
| 115 | <li>75 : gluons split to decouple a junction-antijunction pair</li> |
---|
| 116 | <li>76 : partons with momentum shuffled to decouple a |
---|
| 117 | junction-antijunction pair </li> |
---|
| 118 | <li>77 : temporary opposing parton when fragmenting first two |
---|
| 119 | strings in to junction (should disappear again)</li> |
---|
| 120 | <li>78 : temporary combined diquark end when fragmenting last |
---|
| 121 | string in to junction (should disappear again)</li> |
---|
| 122 | </ul> |
---|
| 123 | <li>81 - 89 : primary hadrons produced by hadronization process</li> |
---|
| 124 | <ul> |
---|
| 125 | <li>81 : from ministring into one hadron</li> |
---|
| 126 | <li>82 : from ministring into two hadrons</li> |
---|
| 127 | <li>83, 84 : from normal string (the difference between the two |
---|
| 128 | is technical, whether fragmented off from the top of the |
---|
| 129 | string system or from the bottom, useful for debug only)</li> |
---|
| 130 | <li>85, 86 : primary produced hadrons in junction frogmentation of |
---|
| 131 | the first two string legs in to the junction, |
---|
| 132 | in order of treatment</li> |
---|
| 133 | </ul> |
---|
| 134 | <li>91 - 99 : particles produced in decay process, or by Bose-Einstein |
---|
| 135 | effects</li> |
---|
| 136 | <ul> |
---|
| 137 | <li>91 : normal decay products</li> |
---|
| 138 | <li>92 : decay products after oscillation <ei>B0 <-> B0bar</ei> or |
---|
| 139 | <ei>B_s0 <-> B_s0bar</ei></li> |
---|
| 140 | <li>93, 94 : decay handled by external program, normally |
---|
| 141 | or with oscillation</li> |
---|
| 142 | <li>99 : particles with momenta shifted by Bose-Einstein effects |
---|
| 143 | (not a proper decay, but bookkept as an <ei>1 -> 1</ei> such, |
---|
| 144 | happening after decays of short-lived resonances but before |
---|
| 145 | decays of longer-lived particles)</li> |
---|
| 146 | </ul> |
---|
| 147 | <li>101 - 109 : particles in the handling of R-hadron production and |
---|
| 148 | decay, i.e. long-lived (or stable) particles containing a very heavy |
---|
| 149 | flavour</li> |
---|
| 150 | <ul> |
---|
| 151 | <li>101 : when a string system contains two such long-lived particles, |
---|
| 152 | the system is split up by the production of a new q-qbar |
---|
| 153 | pair (bookkept as decay chains that seemingly need not conserve |
---|
| 154 | flavour etc., but do when considered together)</li> |
---|
| 155 | <li>102 : partons rearranged from the long-lived particle end to prepare |
---|
| 156 | for fragmentation from this end</li> |
---|
| 157 | <li>103 : intermediate "half-R-hadron" formed when a colour octet particle |
---|
| 158 | (like the gluino) has been fragmented on one side, but not yet on |
---|
| 159 | the other</li> |
---|
| 160 | <li>104 : an R-hadron</li> |
---|
| 161 | <li>105 : partons or particles formed together with the R-hadron during |
---|
| 162 | the fragmentation treatment</li> |
---|
| 163 | <li>106 : subdivision of an R-hadron into its flavour content, with |
---|
| 164 | momentum split accordingly, in preparation of the decay of |
---|
| 165 | the heavy new particle, if it is unstable</li> |
---|
| 166 | <li>107 : two temporary leftover gluons joined into one in the formation |
---|
| 167 | of a gluino-gluon R-hadron.</li> |
---|
| 168 | </ul> |
---|
| 169 | <li>111 - 199 : reserved for future expansion</li> |
---|
| 170 | <li>201 - : free to be used by anybody</li> |
---|
| 171 | </ul> |
---|
| 172 | </method> |
---|
| 173 | |
---|
| 174 | <method name="int Particle::mother1()"> |
---|
| 175 | </method> |
---|
| 176 | <methodmore name="int Particle::mother2()"> |
---|
| 177 | the indices in the event record where the first and last mothers are |
---|
| 178 | stored, if any. There are five allowed combinations of <code>mother1</code> |
---|
| 179 | and <code>mother2</code>: |
---|
| 180 | <ol> |
---|
| 181 | <li><code>mother1 = mother2 = 0</code>: for lines 0 - 2, where line 0 |
---|
| 182 | represents the event as a whole, and 1 and 2 the two incoming |
---|
| 183 | beam particles; </li> |
---|
| 184 | <li><code>mother1 = mother2 > 0</code>: the particle is a "carbon copy" |
---|
| 185 | of its mother, but with changed momentum as a "recoil" effect, |
---|
| 186 | e.g. in a shower;</li> |
---|
| 187 | <li><code>mother1 > 0, mother2 = 0</code>: the "normal" mother case, where |
---|
| 188 | it is meaningful to speak of one single mother to several products, |
---|
| 189 | in a shower or decay;</li> |
---|
| 190 | <li><code>mother1 < mother2</code>, both > 0, for |
---|
| 191 | <code>abs(status) = 81 - 86</code>: primary hadrons produced from the |
---|
| 192 | fragmentation of a string spanning the range from <code>mother1</code> |
---|
| 193 | to <code>mother2</code>, so that all partons in this range should be |
---|
| 194 | considered mothers; and analogously for |
---|
| 195 | <code>abs(status) = 101 - 106</code>, the formation of R-hadrons;</li> |
---|
| 196 | <li><code>mother1 < mother2</code>, both > 0, except case 4: particles |
---|
| 197 | with two truly different mothers, in particular the particles emerging |
---|
| 198 | from a hard <ei>2 -> n</ei> interaction.</li> |
---|
| 199 | </ol> |
---|
| 200 | <note>Note 1:</note> in backwards evolution of initial-state showers, |
---|
| 201 | the mother may well appear below the daughter in the event record. |
---|
| 202 | <note>Note 2:</note> the <code>motherList(i)</code> method of the |
---|
| 203 | <code>Event</code> class returns a vector of all the mothers, |
---|
| 204 | providing a uniform representation for all five cases. |
---|
| 205 | </methodmore> |
---|
| 206 | |
---|
| 207 | <method name="int Particle::daughter1()"> |
---|
| 208 | </method> |
---|
| 209 | <methodmore name="int Particle::daughter2()"> |
---|
| 210 | the indices in the event record where the first and last daughters |
---|
| 211 | are stored, if any. There are five allowed combinations of |
---|
| 212 | <code>daughter1</code> and <code>daughter2</code>: |
---|
| 213 | <ol> |
---|
| 214 | <li><code>daughter1 = daughter2 = 0</code>: there are no daughters |
---|
| 215 | (so far);</li> |
---|
| 216 | <li><code>daughter1 = daughter2 > 0</code>: the particle has a |
---|
| 217 | "carbon copy" as its sole daughter, but with changed momentum |
---|
| 218 | as a "recoil" effect, e.g. in a shower;</li> |
---|
| 219 | <li><code>daughter1 > 0, daughter2 = 0</code>: each of the incoming beams |
---|
| 220 | has only (at most) one daughter, namely the initiator parton of the |
---|
| 221 | hardest interaction; further, in a <ei>2 -> 1</ei> hard interaction, |
---|
| 222 | like <ei>q qbar -> Z^0</ei>, or in a clustering of two nearby partons, |
---|
| 223 | the initial partons only have this one daughter;</li> |
---|
| 224 | <li><code>daughter1 < daughter2</code>, both > 0: the particle has |
---|
| 225 | a range of decay products from <code>daughter1</code> to |
---|
| 226 | <code>daughter2</code>;</li> <li><code>daughter2 < daughter1</code>, |
---|
| 227 | both > 0: the particle has two separately stored decay products (e.g. |
---|
| 228 | in backwards evolution of initial-state showers).</li> |
---|
| 229 | </ol> |
---|
| 230 | <note>Note 1:</note> in backwards evolution of initial-state showers, the |
---|
| 231 | daughters may well appear below the mother in the event record. |
---|
| 232 | <note>Note 2:</note> the mother-daughter relation normally is reciprocal, |
---|
| 233 | but not always. An example is hadron beams (indices 1 and 2), where each |
---|
| 234 | beam remnant and the initiator of each multiparton interaction has the |
---|
| 235 | respective beam as mother, but the beam itself only has the initiator |
---|
| 236 | of the hardest interaction as daughter. |
---|
| 237 | <note>Note 3:</note> the <code>daughterList(i)</code> method of the |
---|
| 238 | <code>Event</code> class returns a vector of all the daughters, |
---|
| 239 | providing a uniform representation for all five cases. With this method, |
---|
| 240 | also all the daughters of the beams are caught, with the initiators of |
---|
| 241 | the basic process given first, while the rest are in no guaranteed order |
---|
| 242 | (since they are found by a scanning of the event record for particles |
---|
| 243 | with the beam as mother, with no further information). |
---|
| 244 | </methodmore> |
---|
| 245 | |
---|
| 246 | <method name="int Particle::col()"> |
---|
| 247 | </method> |
---|
| 248 | <methodmore name="int Particle::acol()"> |
---|
| 249 | the colour and anticolour tags, Les Houches Accord <ref>Boo01</ref> |
---|
| 250 | style (starting from tag 101 by default, see below). |
---|
| 251 | <note>Note:</note> in the preliminary implementation of colour sextets |
---|
| 252 | (exotic BSM particles) that exists since PYTHIA 8.150, a negative |
---|
| 253 | anticolour tag is interpreted as an additional positive colour tag, |
---|
| 254 | and vice versa. |
---|
| 255 | </methodmore> |
---|
| 256 | |
---|
| 257 | <method name="double Particle::px()"> |
---|
| 258 | </method> |
---|
| 259 | <methodmore name="double Particle::py()"> |
---|
| 260 | </methodmore> |
---|
| 261 | <methodmore name="double Particle::pz()"> |
---|
| 262 | </methodmore> |
---|
| 263 | <methodmore name="double Particle::e()"> |
---|
| 264 | the particle four-momentum components. |
---|
| 265 | </methodmore> |
---|
| 266 | |
---|
| 267 | <method name="Vec4 Particle::p()"> |
---|
| 268 | the particle four-momentum vector, with components as above. |
---|
| 269 | </method> |
---|
| 270 | |
---|
| 271 | <method name="double Particle::m()"> |
---|
| 272 | the particle mass, stored with a minus sign (times the absolute value) |
---|
| 273 | for spacelike virtual particles. |
---|
| 274 | </method> |
---|
| 275 | |
---|
| 276 | <method name="double Particle::scale()"> |
---|
| 277 | the scale at which a parton was produced, which can be used to restrict |
---|
| 278 | its radiation to lower scales in subsequent steps of the shower evolution. |
---|
| 279 | Note that scale is linear in momenta, not quadratic (i.e. <ei>Q</ei>, |
---|
| 280 | not <ei>Q^2</ei>). |
---|
| 281 | </method> |
---|
| 282 | |
---|
| 283 | <method name="double Particle::pol()"> |
---|
| 284 | the polarization/spin/helicity of a particle. Currently Pythia does not |
---|
| 285 | use this variable for any internal operations, so its meaning is not |
---|
| 286 | uniquely defined. The LHA standard sets <code>SPINUP</code> to be the |
---|
| 287 | cosine of the angle between the spin vector and the 3-momentum of the |
---|
| 288 | decaying particle in the lab frame, i.e. restricted to be between +1 |
---|
| 289 | and -1. A more convenient choice could be the same quantity in the rest |
---|
| 290 | frame of the particle production, either the hard subprocess or the |
---|
| 291 | mother particle of a decay. Unknown or unpolarized particles should |
---|
| 292 | be assigned the value 9. |
---|
| 293 | </method> |
---|
| 294 | |
---|
| 295 | <method name="double Particle::xProd()"> |
---|
| 296 | </method> |
---|
| 297 | <methodmore name="double Particle::yProd()"> |
---|
| 298 | </methodmore> |
---|
| 299 | <methodmore name="double Particle::zProd()"> |
---|
| 300 | </methodmore> |
---|
| 301 | <methodmore name="double Particle::tProd()"> |
---|
| 302 | the production vertex coordinates, in mm or mm/c. |
---|
| 303 | </methodmore> |
---|
| 304 | |
---|
| 305 | <method name="Vec4 Particle::vProd()"> |
---|
| 306 | The production vertex four-vector. Note that the components of a |
---|
| 307 | <code>Vec4</code> are named <code>px(), py(), pz() and e()</code> |
---|
| 308 | which of course then should be reinterpreted as above. |
---|
| 309 | </method> |
---|
| 310 | |
---|
| 311 | <method name="double Particle::tau()"> |
---|
| 312 | the proper lifetime, in mm/c. It is assigned for all hadrons with |
---|
| 313 | positive nominal <ei>tau</ei>, <ei>tau_0 > 0</ei>, because it can be used |
---|
| 314 | by PYTHIA to decide whether a particle should or should not be allowed |
---|
| 315 | to decay, e.g. based on the decay vertex distance to the primary interaction |
---|
| 316 | vertex. |
---|
| 317 | </method> |
---|
| 318 | |
---|
| 319 | <h3>Input methods</h3> |
---|
| 320 | |
---|
| 321 | The same method names as above are also overloaded in versions that |
---|
| 322 | set values. These have an input argument of the same type as the |
---|
| 323 | respective output above, and are of type <code>void</code>. |
---|
| 324 | |
---|
| 325 | <p/> |
---|
| 326 | There are also a few alternative methods for input: |
---|
| 327 | |
---|
| 328 | <method name="void Particle::statusPos()"> |
---|
| 329 | </method> |
---|
| 330 | <methodmore name="void Particle::statusNeg()"> |
---|
| 331 | sets the status sign positive or negative, without changing the absolute value. |
---|
| 332 | </methodmore> |
---|
| 333 | |
---|
| 334 | <method name="void Particle::statusCode(int code)"> |
---|
| 335 | changes the absolute value but retains the original sign. |
---|
| 336 | </method> |
---|
| 337 | |
---|
| 338 | <method name="void Particle::mothers(int mother1, int mother2)"> |
---|
| 339 | sets both mothers in one go. |
---|
| 340 | </method> |
---|
| 341 | |
---|
| 342 | <method name="void Particle::daughters(int daughter1, int daughter2)"> |
---|
| 343 | sets both daughters in one go. |
---|
| 344 | </method> |
---|
| 345 | |
---|
| 346 | <method name="void Particle::cols(int col, int acol)"> |
---|
| 347 | sets both colour and anticolour in one go. |
---|
| 348 | </method> |
---|
| 349 | |
---|
| 350 | <method name="void Particle::p(double px, double py, double pz, double e)"> |
---|
| 351 | sets the four-momentum components in one go. |
---|
| 352 | </method> |
---|
| 353 | |
---|
| 354 | <method name="void Particle::vProd(double xProd, double yProd, |
---|
| 355 | double zProd, double tProd)"> |
---|
| 356 | sets the production vertex components in one go. |
---|
| 357 | </method> |
---|
| 358 | |
---|
| 359 | <h3>Further output methods</h3> |
---|
| 360 | |
---|
| 361 | <p/> |
---|
| 362 | In addition, a number of derived quantities can easily be obtained, |
---|
| 363 | but cannot be set, such as: |
---|
| 364 | |
---|
| 365 | <method name="int Particle::idAbs()"> |
---|
| 366 | the absolute value of the particle identity code. |
---|
| 367 | </method> |
---|
| 368 | |
---|
| 369 | <method name="int Particle::statusAbs()"> |
---|
| 370 | the absolute value of the status code. |
---|
| 371 | </method> |
---|
| 372 | |
---|
| 373 | <method name="bool Particle::isFinal()"> |
---|
| 374 | true for a remaining particle, i.e. one with positive status code, |
---|
| 375 | else false. Thus, after an event has been fully generated, it |
---|
| 376 | separates the final-state particles from intermediate-stage ones. |
---|
| 377 | (If used earlier in the generation process, a particle then |
---|
| 378 | considered final may well decay later.) |
---|
| 379 | </method> |
---|
| 380 | |
---|
| 381 | <method name="bool Particle::isRescatteredIncoming()"> |
---|
| 382 | true for particles with a status code -34, -45, -46 or -54, else false. |
---|
| 383 | This singles out partons that have been created in a previous |
---|
| 384 | scattering but here are bookkept as belonging to the incoming state |
---|
| 385 | of another scattering. |
---|
| 386 | </method> |
---|
| 387 | |
---|
| 388 | <method name="bool Particle::hasVertex()"> |
---|
| 389 | production vertex has been set; if false then production at the origin |
---|
| 390 | is assumed. |
---|
| 391 | </method> |
---|
| 392 | |
---|
| 393 | <method name="double Particle::m2()"> |
---|
| 394 | squared mass, which can be negative for spacelike partons. |
---|
| 395 | </method> |
---|
| 396 | |
---|
| 397 | <method name="double Particle::mCalc()"> |
---|
| 398 | </method> |
---|
| 399 | <methodmore name="double Particle::m2Calc()"> |
---|
| 400 | (squared) mass calculated from the four-momentum; should agree |
---|
| 401 | with <code>m(), m2()</code> up to roundoff. Negative for spacelike |
---|
| 402 | virtualities. |
---|
| 403 | </methodmore> |
---|
| 404 | |
---|
| 405 | <method name="double Particle::eCalc()"> |
---|
| 406 | energy calculated from the mass and three-momentum; should agree |
---|
| 407 | with <code>e()</code> up to roundoff. For spacelike partons a |
---|
| 408 | positive-energy solution is picked. This need not be the correct |
---|
| 409 | one, so it is recommended not to use the method in such cases. |
---|
| 410 | </method> |
---|
| 411 | |
---|
| 412 | <method name="double Particle::pT()"> |
---|
| 413 | </method> |
---|
| 414 | <methodmore name="double Particle::pT2()"> |
---|
| 415 | (squared) transverse momentum. |
---|
| 416 | </methodmore> |
---|
| 417 | |
---|
| 418 | <method name="double Particle::mT()"> |
---|
| 419 | </method> |
---|
| 420 | <methodmore name="double Particle::mT2()"> |
---|
| 421 | (squared) transverse mass. If <ei>m_T^2</ei> is negative, which can happen |
---|
| 422 | for a spacelike parton, then <code>mT()</code> returns |
---|
| 423 | <ei>-sqrt(-m_T^2)</ei>, by analogy with the negative sign used to store |
---|
| 424 | spacelike masses. |
---|
| 425 | </methodmore> |
---|
| 426 | |
---|
| 427 | <method name="double Particle::pAbs()"> |
---|
| 428 | </method> |
---|
| 429 | <methodmore name="double Particle::pAbs2()"> |
---|
| 430 | (squared) three-momentum size. |
---|
| 431 | </methodmore> |
---|
| 432 | |
---|
| 433 | <method name="double Particle::eT()"> |
---|
| 434 | </method> |
---|
| 435 | <methodmore name="double Particle::eT2()"> |
---|
| 436 | (squared) transverse energy, |
---|
| 437 | <ei>eT = e * sin(theta) = e * pT / pAbs</ei>. |
---|
| 438 | </methodmore> |
---|
| 439 | |
---|
| 440 | <method name="double Particle::theta()"> |
---|
| 441 | </method> |
---|
| 442 | <methodmore name="double Particle::phi()"> |
---|
| 443 | polar and azimuthal angle. |
---|
| 444 | </methodmore> |
---|
| 445 | |
---|
| 446 | <method name="double Particle::thetaXZ()"> |
---|
| 447 | angle in the <ei>(p_x, p_z)</ei> plane, between <ei>-pi</ei> and |
---|
| 448 | <ei>+pi</ei>, with 0 along the <ei>+z</ei> axis |
---|
| 449 | </method> |
---|
| 450 | |
---|
| 451 | <method name="double Particle::pPos()"> |
---|
| 452 | </method> |
---|
| 453 | <methodmore name="double Particle::pNeg()"> |
---|
| 454 | <ei>E +- p_z</ei>. |
---|
| 455 | </methodmore> |
---|
| 456 | |
---|
| 457 | <method name="double Particle::y()"> |
---|
| 458 | </method> |
---|
| 459 | <methodmore name="double Particle::eta()"> |
---|
| 460 | rapidity and pseudorapidity. |
---|
| 461 | </methodmore> |
---|
| 462 | |
---|
| 463 | <method name="double Particle::xDec()"> |
---|
| 464 | </method> |
---|
| 465 | <methodmore name="double Particle::yDec()"> |
---|
| 466 | </methodmore> |
---|
| 467 | <methodmore name="double Particle::zDec()"> |
---|
| 468 | </methodmore> |
---|
| 469 | <methodmore name="double Particle::tDec()"> |
---|
| 470 | </methodmore> |
---|
| 471 | <methodmore name="Vec4 Particle::vDec()"> |
---|
| 472 | the decay vertex coordinates, in mm or mm/c. This decay vertex is |
---|
| 473 | calculated from the production vertex, the proper lifetime and the |
---|
| 474 | four-momentum assuming no magnetic field or other detector interference. |
---|
| 475 | It can be used to decide whether a decay should be performed or not, |
---|
| 476 | and thus is defined also for particles which PYTHIA did not let decay. |
---|
| 477 | </methodmore> |
---|
| 478 | |
---|
| 479 | <p/> |
---|
| 480 | Each Particle contains a pointer to the respective |
---|
| 481 | <code>ParticleDataEntry</code> object in the |
---|
| 482 | <aloc href="ParticleDataScheme">particle data tables</aloc>. |
---|
| 483 | This gives access to properties of the particle species as such. It is |
---|
| 484 | there mainly for convenience, and should be thrown if an event is |
---|
| 485 | written to disk, to avoid any problems of object persistency. Should |
---|
| 486 | an event later be read back in, the pointer will be recreated from the |
---|
| 487 | <code>id</code> code if the normal input methods are used. (Use the |
---|
| 488 | <code><aloc href="EventRecord">Event::restorePtrs()</aloc></code> method |
---|
| 489 | if your persistency scheme bypasses the normal methods.) This pointer is |
---|
| 490 | used by the following member functions: |
---|
| 491 | |
---|
| 492 | <method name="string Particle::name()"> |
---|
| 493 | the name of the particle. |
---|
| 494 | </method> |
---|
| 495 | |
---|
| 496 | <method name="string Particle::nameWithStatus()"> |
---|
| 497 | as above, but for negative-status particles the name is given in |
---|
| 498 | brackets to emphasize that they are intermediaries. |
---|
| 499 | </method> |
---|
| 500 | |
---|
| 501 | <method name="int Particle::spinType()"> |
---|
| 502 | <ei>2 *spin + 1</ei> when defined, else 0. |
---|
| 503 | </method> |
---|
| 504 | |
---|
| 505 | <method name="double Particle::charge()"> |
---|
| 506 | </method> |
---|
| 507 | <methodmore name="int Particle::chargeType()"> |
---|
| 508 | charge, and three times it to make an integer. |
---|
| 509 | </methodmore> |
---|
| 510 | |
---|
| 511 | <method name="bool Particle::isCharged()"> |
---|
| 512 | </method> |
---|
| 513 | <methodmore name="bool Particle::isNeutral()"> |
---|
| 514 | charge different from or equal to 0. |
---|
| 515 | </methodmore> |
---|
| 516 | |
---|
| 517 | <method name="int Particle::colType()"> |
---|
| 518 | 0 for colour singlets, 1 for triplets, |
---|
| 519 | -1 for antitriplets and 2 for octets. (A preliminary implementation of |
---|
| 520 | colour sextets also exists, using 3 for sextets and -3 for antisextets.) |
---|
| 521 | </method> |
---|
| 522 | |
---|
| 523 | <method name="double Particle::m0()"> |
---|
| 524 | the nominal mass of the particle, according to the data tables. |
---|
| 525 | </method> |
---|
| 526 | |
---|
| 527 | <method name="double Particle::mWidth()"> |
---|
| 528 | </method> |
---|
| 529 | <methodmore name="double Particle::mMin()"> |
---|
| 530 | </methodmore> |
---|
| 531 | <methodmore name="double Particle::mMax()"> |
---|
| 532 | the width of the particle, and the minimum and maximum allowed mass value |
---|
| 533 | for particles with a width, according to the data tables. |
---|
| 534 | </methodmore> |
---|
| 535 | |
---|
| 536 | <method name="double Particle::mass()"> |
---|
| 537 | the mass of the particle, picked according to a Breit-Wigner |
---|
| 538 | distribution for particles with width. It is different each time called, |
---|
| 539 | and is therefore only used once per particle to set its mass |
---|
| 540 | <code>m()</code>. |
---|
| 541 | </method> |
---|
| 542 | |
---|
| 543 | <method name="double Particle::constituentMass()"> |
---|
| 544 | will give the constituent masses for quarks and diquarks, |
---|
| 545 | else the same masses as with <code>m0()</code>. |
---|
| 546 | </method> |
---|
| 547 | |
---|
| 548 | <method name="double Particle::tau0()"> |
---|
| 549 | the nominal lifetime <ei>tau_0 > 0</ei>, in mm/c, of the particle species. |
---|
| 550 | It is used to assign the actual lifetime <ei>tau</ei>. |
---|
| 551 | </method> |
---|
| 552 | |
---|
| 553 | <method name="bool Particle::mayDecay()"> |
---|
| 554 | flag whether particle has been declared unstable or not, offering |
---|
| 555 | the main user switch to select which particle species to decay. |
---|
| 556 | </method> |
---|
| 557 | |
---|
| 558 | <method name="bool Particle::canDecay()"> |
---|
| 559 | flag whether decay modes have been declared for a particle, |
---|
| 560 | so that it could be decayed, should that be requested. |
---|
| 561 | </method> |
---|
| 562 | |
---|
| 563 | <method name="bool Particle::doExternalDecay()"> |
---|
| 564 | particles that are decayed by an external program. |
---|
| 565 | </method> |
---|
| 566 | |
---|
| 567 | <method name="bool Particle::isResonance()"> |
---|
| 568 | particles where the decay is to be treated as part of the hard process, |
---|
| 569 | typically with nominal mass above 20 GeV (<ei>W^+-, Z^0, t, ...</ei>). |
---|
| 570 | </method> |
---|
| 571 | |
---|
| 572 | <method name="bool Particle::isVisible()"> |
---|
| 573 | particles with strong or electric charge, or composed of ones having it, |
---|
| 574 | which thereby should be considered visible in a normal detector. |
---|
| 575 | </method> |
---|
| 576 | |
---|
| 577 | <method name="bool Particle::isLepton()"> |
---|
| 578 | true for a lepton or an antilepton (including neutrinos). |
---|
| 579 | </method> |
---|
| 580 | |
---|
| 581 | <method name="bool Particle::isQuark()"> |
---|
| 582 | true for a quark or an antiquark. |
---|
| 583 | </method> |
---|
| 584 | |
---|
| 585 | <method name="bool Particle::isGluon()"> |
---|
| 586 | true for a gluon. |
---|
| 587 | </method> |
---|
| 588 | |
---|
| 589 | <method name="bool Particle::isDiquark()"> |
---|
| 590 | true for a diquark or an antidiquark. |
---|
| 591 | </method> |
---|
| 592 | |
---|
| 593 | <method name="bool Particle::isParton()"> |
---|
| 594 | true for a gluon, a quark or antiquark up to the b (but excluding top), |
---|
| 595 | and a diquark or antidiquark consisting of quarks up to the b. |
---|
| 596 | </method> |
---|
| 597 | |
---|
| 598 | <method name="bool Particle::isHadron()"> |
---|
| 599 | true for a hadron (made up out of normal quarks and gluons, |
---|
| 600 | i.e. not for R-hadrons and other exotic states). |
---|
| 601 | </method> |
---|
| 602 | |
---|
| 603 | <method name="ParticleDataEntry& particleDataEntry()"> |
---|
| 604 | a reference to the ParticleDataEntry. |
---|
| 605 | </method> |
---|
| 606 | |
---|
| 607 | <p/> |
---|
| 608 | Not part of the <code>Particle</code> class proper, but obviously tightly |
---|
| 609 | linked, are the two methods |
---|
| 610 | |
---|
| 611 | <method name="double m(const Particle& pp1, const Particle& pp2)"> |
---|
| 612 | </method> |
---|
| 613 | <methodmore name="double m2(const Particle& pp1, const Particle& pp2)"> |
---|
| 614 | the (squared) invariant mass of two particles. |
---|
| 615 | </methodmore> |
---|
| 616 | |
---|
| 617 | <h3>Methods that perform operations</h3> |
---|
| 618 | |
---|
| 619 | There are some further methods, some of them inherited from |
---|
| 620 | <code>Vec4</code>, to modify the properties of a particle. |
---|
| 621 | They are of little interest to the normal user. |
---|
| 622 | |
---|
| 623 | <method name="void Particle::rescale3(double fac)"> |
---|
| 624 | multiply the three-momentum components by <code>fac</code>. |
---|
| 625 | </method> |
---|
| 626 | |
---|
| 627 | <method name="void Particle::rescale4(double fac)"> |
---|
| 628 | multiply the four-momentum components by <code>fac</code>. |
---|
| 629 | </method> |
---|
| 630 | |
---|
| 631 | <method name="void Particle::rescale5(double fac)"> |
---|
| 632 | multiply the four-momentum components and the mass by <code>fac</code>. |
---|
| 633 | </method> |
---|
| 634 | |
---|
| 635 | <method name="void Particle::rot(double theta, double phi)"> |
---|
| 636 | rotate three-momentum and production vertex by these polar and azimuthal |
---|
| 637 | angles. |
---|
| 638 | </method> |
---|
| 639 | |
---|
| 640 | <method name="void Particle::bst(double betaX, double betaY, double betaZ)"> |
---|
| 641 | boost four-momentum and production vertex by this three-vector. |
---|
| 642 | </method> |
---|
| 643 | |
---|
| 644 | <method name="void Particle::bst(double betaX, double betaY, double betaZ, |
---|
| 645 | double gamma)"> |
---|
| 646 | as above, but also input the <ei>gamma</ei> value, to reduce roundoff errors. |
---|
| 647 | </method> |
---|
| 648 | |
---|
| 649 | <method name="void Particle::bst(const Vec4& pBst)"> |
---|
| 650 | boost four-momentum and production vertex by |
---|
| 651 | <ei>beta = (px/e, py/e, pz/e)</ei>. |
---|
| 652 | </method> |
---|
| 653 | |
---|
| 654 | <method name="void Particle::bst(const Vec4& pBst, double mBst)"> |
---|
| 655 | as above, but also use <ei>gamma> = e/m</ei> to reduce roundoff errors. |
---|
| 656 | </method> |
---|
| 657 | |
---|
| 658 | <method name="void Particle::bstback(const Vec4& pBst)"> |
---|
| 659 | </method> |
---|
| 660 | <methodmore name="void Particle::bstback(const Vec4& pBst, double mBst)"> |
---|
| 661 | as above, but with sign of boost flipped. |
---|
| 662 | </method> |
---|
| 663 | |
---|
| 664 | <method name="void Particle::rotbst(const RotBstMatrix& M)"> |
---|
| 665 | combined rotation and boost of the four-momentum and production vertex. |
---|
| 666 | </method> |
---|
| 667 | |
---|
| 668 | <method name="void Particle::offsetHistory( int minMother, int addMother, |
---|
| 669 | int minDaughter, int addDaughter))"> |
---|
| 670 | add a positive offset to the mother and daughter indices, i.e. |
---|
| 671 | if <code>mother1</code> is above <code>minMother</code> then |
---|
| 672 | <code>addMother</code> is added to it, same with <code>mother2</code>, |
---|
| 673 | if <code>daughter1</code> is above <code>minDaughter</code> then |
---|
| 674 | <code>addDaughter</code> is added to it, same with <code>daughter2</code>. |
---|
| 675 | </method> |
---|
| 676 | |
---|
| 677 | <method name="void Particle::offsetCol( int addCol)"> |
---|
| 678 | add a positive offset to colour indices, i.e. if <code>col</code> is |
---|
| 679 | positive then <code>addCol</code> is added to it, same with <code>acol</code>. |
---|
| 680 | </method> |
---|
| 681 | |
---|
| 682 | <h3>Constructors and operators</h3> |
---|
| 683 | |
---|
| 684 | Normally a user would not need to create new particles. However, if |
---|
| 685 | necessary, the following constructors and methods may be of interest. |
---|
| 686 | |
---|
| 687 | <method name="Particle::Particle()"> |
---|
| 688 | constructs an empty particle, i.e. where all properties have been set 0 |
---|
| 689 | or equivalent. |
---|
| 690 | </method> |
---|
| 691 | |
---|
| 692 | <method name="Particle::Particle(int id, int status = 0, int mother1 = 0, |
---|
| 693 | int mother2 = 0, int daughter1 = 0, int daughter2 = 0, int col = 0, |
---|
| 694 | int acol = 0, double px = 0., double py = 0., double pz = 0., double e = 0., |
---|
| 695 | double m = 0., double scale = 0., double pol = 9.)"> |
---|
| 696 | constructs a particle with the input properties provided, and non-provided |
---|
| 697 | ones set 0 (9 for <code>pol</code>). |
---|
| 698 | </method> |
---|
| 699 | |
---|
| 700 | <method name="Particle::Particle(int id, int status, int mother1, int mother2, |
---|
| 701 | int daughter1, int daughter2, int col, int acol, Vec4 p, double m = 0., |
---|
| 702 | double scale = 0., double pol = 9.)"> |
---|
| 703 | constructs a particle with the input properties provided, and non-provided |
---|
| 704 | ones set 0 (9 for <code>pol</code>). |
---|
| 705 | </method> |
---|
| 706 | |
---|
| 707 | <method name="Particle::Particle(const Particle& pt)"> |
---|
| 708 | constructs an particle that is a copy of the input one. |
---|
| 709 | </method> |
---|
| 710 | |
---|
| 711 | <method name="Particle& Particle::operator=(const Particle& pt)"> |
---|
| 712 | copies the input particle. |
---|
| 713 | </method> |
---|
| 714 | |
---|
| 715 | <method name="void Particle::setPDTPtr()"> |
---|
| 716 | sets the pointer to the <code>ParticleData</code> objects, |
---|
| 717 | i.e. to the full particle data table. Also calls <code>setPDEPtr</code> |
---|
| 718 | below. |
---|
| 719 | </method> |
---|
| 720 | |
---|
| 721 | <method name="void Particle::setPDEPtr()"> |
---|
| 722 | sets the pointer to the <code>ParticleDataEntry</code> object of the |
---|
| 723 | particle, based on its current <code>id</code> code. |
---|
| 724 | </method> |
---|
| 725 | |
---|
| 726 | <h3>Final notes</h3> |
---|
| 727 | |
---|
| 728 | The |
---|
| 729 | <code><aloc href="EventRecord">Event</aloc></code> |
---|
| 730 | class also contains a few methods defined for individual particles, |
---|
| 731 | but these may require some search in the event record and therefore |
---|
| 732 | cannot be defined as <code>Particle</code> methods. |
---|
| 733 | |
---|
| 734 | <p/> |
---|
| 735 | Currently there is no information on polarization states. |
---|
| 736 | |
---|
| 737 | </chapter> |
---|
| 738 | |
---|
| 739 | <!-- Copyright (C) 2012 Torbjorn Sjostrand --> |
---|
| 740 | |
---|