PYTHIA8/pythia8170/phpdoc/ProgramFlow.php

   1 <html>
   2 <head>
   3 <title>Program Flow</title>
   4 <link rel="stylesheet" type="text/css" href="pythia.css"/>
   5 <link rel="shortcut icon" href="pythia32.gif"/>
   6 </head>
   7 <body>
   8
   9 <script language=javascript type=text/javascript>
  10 function stopRKey(evt) {
  11 var evt = (evt) ? evt : ((event) ? event : null);
  12 var node = (evt.target) ? evt.target :((evt.srcElement) ? evt.srcElement : null);
  13 if ((evt.keyCode == 13) && (node.type=="text"))
  14 {return false;}
  15 }
  16
  17 document.onkeypress = stopRKey;
  18 </script>
  19 <?php
  20 if($_POST['saved'] == 1) {
  21 if($_POST['filepath'] != "files/") {
  22 echo "<font color='red'>SETTINGS SAVED TO FILE</font><br/><br/>"; }
  23 else {
  24 echo "<font color='red'>NO FILE SELECTED YET.. PLEASE DO SO </font><a href='SaveSettings.php'>HERE</a><br/><br/>"; }
  25 }
  26 ?>
  27
  28 <form method='post' action='ProgramFlow.php'>
  29
  30 <h2>Program Flow</h2>
  31
  32 Recall that, to first order, the event generation process can be
  33 subdivided into three stages:
  34 <ol>
  35 <li>Initializaion.</li>
  36 <li>The event loop.</li>
  37 <li>Finishing.</li>
  38 </ol>
  39 This is reflected in how the top-level <code>Pythia</code> class should
  40 be used in the user-supplied main program, further outlined in the
  41 following. Since the nature of the run is defined at the initialization
  42 stage, this is where most of the PYTHIA user code has to be written.
  43 So as not to confuse the reader unduly, the description of initialization
  44 options has been subdivided into what would normally be used and what is
  45 intended for more special applications.
  46
  47 <p/>
  48 At the bottom of this webpge is a complete survey of all public
  49 <code>Pythia</code> methods and data members, in a more formal style
  50 than the task-oriented descriptions found in the preceding sections.
  51 This offers complementary information.
  52
  53 <h3>Initialization - normal usage</h3>
  54
  55 <ol>
  56
  57 <li>
  58 Already at the top of the main program file, you need to include the proper
  59 header file
  60 <pre>
  61     #include "Pythia.h"
  62 </pre>
  63 To simplify typing, it also makes sense to declare
  64 <pre>
  65     using namespace Pythia8;
  66 </pre>
  67 </li>
  68
  69 <p/>
  70 <li>
  71 The first step is to create a generator object,
  72 e.g. with
  73 <pre>
  74      Pythia pythia;
  75 </pre>
  76 It is this object that we will use from now on. Normally a run
  77 will only contain one <code>Pythia</code> object. (But you can
  78 use several <code>Pythia</code> objects, which then will be
  79 independent of each other.)<br/>
  80 By default all output from <code>Pythia</code> will be on the
  81 <code>cout</code> stream, but the <code>list</code> methods below do
  82 allow output to alternative streams or files.
  83 </li>
  84
  85 <p/>
  86 <li>
  87 You next want to set up the character of the run.
  88 The pages under the "Setup Run Tasks" heading in the index
  89 describe all the options available (with some very few exceptions,
  90 found on the other pages).
  91 The default values and your modifications are stored in two databases,
  92 one for <?php $filepath = $_GET["filepath"];
  93 echo "<a href='SettingsScheme.php?filepath=".$filepath."' target='page'>";?>generic settings</a>
  94 and one for <?php $filepath = $_GET["filepath"];
  95 echo "<a href='ParticleDataScheme.php?filepath=".$filepath."' target='page'>";?>particle data</a>.
  96 Both of these are initialized with their default values by the
  97 <code>Pythia</code> constructor. The default values can then be
  98 changed, primarily by one of the two ways below, or by a combination
  99 of them.
 100
 101 <p/>
 102 a) You can use the
 103 <pre>
 104     pythia.readString(string);
 105 </pre>
 106 method repeatedly to do a change of a property at a time.
 107 The information in the string is case-insensitive, but upper- and
 108 lowercase can be combined for clarity. The rules are that<br/>
 109 (i) if the first nonblank character of the string is a letter
 110 it is assumed to contain a setting, and is sent on to
 111 <code>pythia.settings.readString(string)</code>;<br/>
 112 (ii) if instead the string begins with a digit it is assumed to
 113 contain particle data updates, and so sent on to
 114 <code>pythia.particleData.readString(string)</code>;<br/>
 115 (iii) if none of the above, the string is assumed to be a comment,
 116 i.e. nothing will be done.<br/>
 117 In the former two cases, a warning is issued whenever a string
 118 cannot be recognized (maybe because of a spelling mistake).<br/>
 119 Some examples would be
 120 <pre>
 121     pythia.readString("TimeShower:pTmin = 1.0");
 122     pythia.readString("111:mayDecay = false");
 123 </pre>
 124 The <code>readString(string)</code> method is intended primarily for
 125 a few changes. It can also be useful if you want to construct a
 126 parser for input files that contain commands both to PYTHIA and to
 127 other libraries.<br/>
 128
 129 <p/>
 130 b) You can read in a file containing a list of those variables
 131 you want to see changed, with a
 132 <pre>
 133     pythia.readFile(fileName);
 134 </pre>
 135 Each line in this file with be processes by the
 136 <code>readString(string)</code> method introduced above. You can thus
 137 freely mix comment lines and lines handed on to <code>Settings</code>
 138 or to <code>ParticleData</code>.<br/>
 139 This approach is better suited for more extensive changes than a direct
 140 usage of <code>readString(string)</code>, and can also avoid having to
 141 recompile and relink your main program between runs.<br/>
 142 It is also possible to read input from an <code>istream</code>, by
 143 default <code>cin</code>, rather than from a file. This may be convenient
 144 if information is generated on-the-fly, within the same run.
 145
 146 <p/>
 147 Changes are made sequentially in the order the commands are encountered
 148 during execution, meaning that if a parameter is changed several times
 149 it is the last one that counts. The two special
 150 <code><?php $filepath = $_GET["filepath"];
 151 echo "<a href='Tunes.php?filepath=".$filepath."' target='page'>";?>Tune:ee</a></code> and
 152 <code><?php $filepath = $_GET["filepath"];
 153 echo "<a href='Tunes.php?filepath=".$filepath."' target='page'>";?>Tune:pp</a></code>
 154 modes are expanded to change several settings in one go, but these obey
 155 the same ordering rules.
 156 <br/>
 157 </li>
 158
 159 <p/>
 160 <li>
 161 Next comes the initialization stage, where all
 162 remaining details of the generation are to be specified.
 163 There is one standard method to use for this
 164
 165 <p/>
 166 <code>pythia.init();</code><br/>
 167 with no arguments will read all relevant information from the
 168 <code><?php $filepath = $_GET["filepath"];
 169 echo "<a href='SettingsScheme.php?filepath=".$filepath."' target='page'>";?>Settings</a></code>
 170 and <code><?php $filepath = $_GET["filepath"];
 171 echo "<a href='ParticleDataScheme.php?filepath=".$filepath."' target='page'>";?>ParticleData</a></code>
 172 databases. Specifically the setup of incoming beams and energies
 173 is governed by the the beam parameters from the
 174 <code><?php $filepath = $_GET["filepath"];
 175 echo "<a href='BeamParameters.php?filepath=".$filepath."' target='page'>";?>Beams</a></code>
 176 group of variables. If you don't change any of those you will
 177 default to proton-proton collisions at 14 TeV, i.e. the nominal LHC
 178 values.
 179
 180 <p/>
 181 A few alternative forms are available, where the arguments of the
 182 <code>init(...)</code> call can be used to set the beam parameters.
 183 These alternatives are now deprecated, and will bew removed for
 184 PYTHIA 8.2.
 185
 186 <p/>
 187 a) <code>pythia.init( idA, idB, eCM);</code><br/>
 188 lets you specify the identities and the CM energy of the two incoming
 189 beam particles, with A (B) assumed moving in the <i>+z (-z)</i>
 190 direction.
 191
 192 <p/>
 193 b) <code>pythia.init( idA, idB, eA, eB);</code><br/>
 194 is similar, but the two beam energies can be different, so the
 195 collisions do not occur in the CM frame. If one of the beam energies
 196 is below the particle mass you obtain a fixed-target topology.
 197
 198 <p/>
 199 c) <code>pythia.init( idA, idB, pxA, pyA, pzA, pxB, pyB, pzB);</code><br/>
 200 is similar, but here you provide the three-momenta
 201 <i>(p_x, p_y, p_z)</i> of the two incoming particles,
 202 to allow for arbitrary beam directions.
 203
 204 <p/>
 205 d) <code>pythia.init(fileName);</code> <br/>
 206 assumes a file in the <?php $filepath = $_GET["filepath"];
 207 echo "<a href='LesHouchesAccord.php?filepath=".$filepath."' target='page'>";?>Les Houches
 208 Event File</a> format is provided.
 209
 210 <p/>
 211 e) <code>pythia.init( LHAup*);</code> <br/>
 212 assumes <?php $filepath = $_GET["filepath"];
 213 echo "<a href='LesHouchesAccord.php?filepath=".$filepath."' target='page'>";?>Les Houches Accord</a>
 214 initialization and event information is available in an <code>LHAup</code>
 215 class object, and that a pointer to this object is handed in.
 216
 217 <p/>
 218 <li>
 219 If you want to have a list of the generator and particle data used,
 220 either only what has been changed or everything, you can use
 221 <pre>
 222     pythia.settings.listChanged();
 223     pythia.settings.listAll();
 224     pythia.particleData.listChanged();
 225     pythia.particleData.listAll();
 226 </pre>
 227 </li>
 228
 229 </ol>
 230
 231 <h3>The event loop</h3>
 232
 233 <ol>
 234
 235 <li>
 236 Inside the event generation loop you generate the
 237 next event using the <code>next()</code> method,
 238 <pre>
 239     pythia.next();
 240 </pre>
 241 This method takes no arguments; everything has already been specified.
 242 It does return a bool value, however, <code>false</code> when the
 243 generation failed. This can be a "programmed death" when the
 244 supply of input parton-level configurations on file is exhausted.
 245 It can alternatively signal a failure of <code>Pythia</code> to
 246 generate an event, or unphysical features in the event record at the
 247 end of the generation step. It makes sense to allow a few <code>false</code>
 248 values before a run is aborted, so long as the related faulty
 249 events are skipped.
 250 </li>
 251
 252 <p/>
 253 <li>
 254 The generated event is now stored in the <code>event</code>
 255 object, of type <code><?php $filepath = $_GET["filepath"];
 256 echo "<a href='EventRecord.php?filepath=".$filepath."' target='page'>";?>Event</a></code>,
 257 which is a public member of <code>pythia</code>. You therefore have
 258 access to all the tools described on the pages under the "Study Output"
 259 header in the index. For instance, an event can be listed with
 260 <code>pythia.event.list()</code>, the identity of the <i>i</i>'th
 261 <?php $filepath = $_GET["filepath"];
 262 echo "<a href='ParticleProperties.php?filepath=".$filepath."' target='page'>";?>particle</a> is given by
 263 <code>pythia.event[i].id()</code>, and so on.<br/>
 264 The hard process - roughly the information normally stored in the
 265 Les Houches Accord event record - is available as a second object,
 266 <code>process</code>, also of type <code>Event</code>.<br/>
 267 A third useful public object is
 268 <code><?php $filepath = $_GET["filepath"];
 269 echo "<a href='EventInformation.php?filepath=".$filepath."' target='page'>";?>info</a></code>, which offers
 270 a set of one-of-a kind pieces of information about the most recent
 271 event.
 272 </li>
 273
 274 </ol>
 275
 276 <h3>Finishing</h3>
 277
 278 <ol>
 279
 280 <li>At the end of the generation process, you can call
 281 <pre>
 282     pythia.stat();
 283 </pre>
 284 to get some run statistics, on cross sections and the number of errors
 285 and warnings encountered. The alternative
 286 <code>pythia.statistics(...);</code> is equivalent but deprecated.
 287 </li>
 288
 289 </ol>
 290
 291 <h3>Advanced usage, mainly for initialization</h3>
 292
 293 A) Necessary data are automatically loaded when you use the
 294 default PYTHIA installation directory structure and run the main
 295 programs in the <code>examples</code> subdirectory. However, in the
 296 general case, you must provide the path of the <code>xmldoc</code>
 297 directory, where default settings and particle data are found.
 298 This can be done in two ways.
 299
 300 <ol>
 301
 302 <li>
 303 You can set the environment variable <code>PYTHIA8DATA</code> to
 304 contain the location of the <code>xmldoc</code> directory. In the
 305 <code>csh</code> and <code>tcsh</code> shells this could e.g. be
 306 <pre>
 307      setenv PYTHIA8DATA /home/myname/pythia81xx/xmldoc
 308 </pre>
 309 while in other shells it could be
 310 <pre>
 311      export PYTHIA8DATA=/home/myname/pythia81xx/xmldoc
 312 </pre>
 313 where xx is the subversion number.<br/>
 314 Recall that environment variables set locally are only defined in the
 315 current instance of the shell. The above lines should go into your
 316 <code>.cshrc</code> and <code>.bashrc</code> files, respectively,
 317 if you want a more permanant assignment.
 318 </li>
 319
 320 <p/>
 321 <li>
 322 You can provide the path as argument to the <code>Pythia</code>
 323 constructor, e.g.
 324 <pre>
 325      Pythia pythia("/home/myname/pythia81xx/xmldoc");
 326 </pre>
 327 </li>
 328 </ol>
 329 where again xx is the subversion number.<br/>
 330 When <code>PYTHIA8DATA</code> is set it takes precedence, else
 331 the path in the constructor is used, else one defaults to the
 332 <code>../xmldoc</code> directory.
 333
 334 <p/>
 335 B) You can override the default behaviour of PYTHIA not only by the
 336 settings and particle data, but also by replacing some of the
 337 PYTHIA standard routines by ones of your own. Of course, this is only
 338 possible if your routines fit into the general PYTHIA framework.
 339 Therefore they must be coded according to the the rules relevant
 340 in each case, as a derived class of a PYTHIA base class, and a pointer
 341 to such an object must be handed in by one of the methods below.
 342 These calls must be made before the <code>pythia.init(...)</code> call.
 343
 344 <ol>
 345
 346 <li>
 347 If you are not satisfied with the list of parton density functions that
 348 are implemented internally or available via the LHAPDF interface
 349 (see the <?php $filepath = $_GET["filepath"];
 350 echo "<a href='PDFSelection.php?filepath=".$filepath."' target='page'>";?>PDF Selection</a> page), you
 351 can suppy your own by a call to the <code>setPDFPtr(...)</code> method
 352 <pre>
 353       pythia.setPDFptr( pdfAPtr, pdfBPtr);
 354 </pre>
 355 where <code>pdfAPtr</code> and <code>pdfBPtr</code> are pointers to
 356 two <code>Pythia</code> <?php $filepath = $_GET["filepath"];
 357 echo "<a href='PartonDistributions.php?filepath=".$filepath."' target='page'>";?>PDF
 358 objects</a>. Note that <code>pdfAPtr</code> and <code>pdfBPtr</code>
 359 cannot point to the same object; even if the PDF set is the same,
 360 two copies are needed to keep track of two separate sets of <i>x</i>
 361 and density values.<br/>
 362 If you further wish to use separate PDF's for the hard process of an
 363 event than the ones being used for everything else, the extended form
 364 <pre>
 365       pythia.setPDFptr( pdfAPtr, pdfBPtr, pdfHardAPtr, pdfHardBPtr);
 366 </pre>
 367 allows you to specify those separately, and then the first two sets
 368 would only be used for the showers and for multiparton interactions.
 369 </li>
 370
 371 <p/>
 372 <li>
 373 If you want to link to an external generator that feeds in events
 374 in the LHA format, you can call the <code>setLHAupPtr(...)</code>
 375 method
 376 <pre>
 377       pythia.setLHAupPtr( lhaUpPtr);
 378 </pre>
 379 where the  <code>lhaUpPtr</code> derives from the
 380 <?php $filepath = $_GET["filepath"];
 381 echo "<a href='LesHouchesAccord.php?filepath=".$filepath."' target='page'>";?>LHAup</a> base class.
 382 </li>
 383
 384 <p/>
 385 <li>
 386 If you want to perform some particle decays with an
 387 external generator, you can call the <code>setDecayPtr(...)</code>
 388 method
 389 <pre>
 390       pythia.setDecayPtr( decayHandlePtr, particles);
 391 </pre>
 392 where the <code>decayHandlePtr</code> derives from the
 393 <code><?php $filepath = $_GET["filepath"];
 394 echo "<a href='ExternalDecays.php?filepath=".$filepath."' target='page'>";?>DecayHandler</a></code> base
 395 class and <code>particles</code> is a vector of particle codes to be
 396 handled.
 397 </li>
 398
 399 <p/>
 400 <li>
 401 If you want to use an external random number generator,
 402 you can call the <code>setRndmEnginePtr(...)</code> method
 403 <pre>
 404       pythia.setRndmEnginePtr( rndmEnginePtr);
 405 </pre>
 406 where <code>rndmEnginePtr</code> derives from the
 407 <code><?php $filepath = $_GET["filepath"];
 408 echo "<a href='RandomNumbers.php?filepath=".$filepath."' target='page'>";?>RndmEngine</a></code> base class.
 409 The <code>Pythia</code> default random number generator is perfectly
 410 good, so this is only intended for consistency in bigger frameworks.
 411 </li>
 412
 413 <p/>
 414 <li>
 415 If you want to interrupt the evolution at various stages,
 416 to interrogate the event and possibly veto it, or you want to
 417 reweight the cross section, you can use
 418 <pre>
 419       pythia.setUserHooksPtr( userHooksPtr);
 420 </pre>
 421 where <code>userHooksPtr</code> derives from the
 422 <code><?php $filepath = $_GET["filepath"];
 423 echo "<a href='UserHooks.php?filepath=".$filepath."' target='page'>";?>UserHooks</a></code> base class.
 424 </li>
 425
 426 <p/>
 427 <li>
 428 If you want to use your own merging scale definition for
 429 matrix element + parton shower merging, you can call
 430 <pre>
 431       pythia.setMergingHooksPtr( mergingHooksPtr);
 432 </pre>
 433 where <code>mergingHooksPtr</code> derives from the
 434 <code><?php $filepath = $_GET["filepath"];
 435 echo "<a href='MatrixElementMerging.php?filepath=".$filepath."' target='page'>";?>MergingHooks</a></code> base class.
 436 </li>
 437
 438 <p/>
 439 <li>
 440 If you want to use your own parametrization of beam momentum spread and
 441 interaction vertex, rather than the provided simple Gaussian
 442 parametrization (off by default), you can call
 443 <pre>
 444       pythia.setBeamShapePtr( beamShapePtr);
 445 </pre>
 446 where <code>beamShapePtr</code> derives from the
 447 <code><?php $filepath = $_GET["filepath"];
 448 echo "<a href='BeamShape.php?filepath=".$filepath."' target='page'>";?>BeamShape</a></code> base class.
 449 </li>
 450
 451 <p/>
 452 <li>
 453 If you want to implement a cross section of your own, but still make use
 454 of the built-in phase space selection machinery, you can use
 455 <pre>
 456       pythia.setSigmaPtr( sigmaPtr);
 457 </pre>
 458 where <code>sigmaPtr</code> of type <code>SigmaProcess*</code> is an
 459 instance of a class derived from one of the <code>Sigma1Process</code>,
 460 <code>Sigma2Process</code> and  <code>Sigma3Process</code> base classes
 461 in their turn derived from
 462 <code><?php $filepath = $_GET["filepath"];
 463 echo "<a href='SemiInternalProcesses.php?filepath=".$filepath."' target='page'>";?>SigmaProcess</a></code>.
 464 This call can be used repeatedly to hand in several different processes.
 465 </li>
 466
 467 <p/>
 468 <li>
 469 If your cross section contains the production of a new resonance
 470 with known analytical expression for all the relevant partial widths,
 471 you can make this resonance available to the program with
 472 <pre>
 473       pythia.setResonancePtr( resonancePtr);
 474 </pre>
 475 where <code>resonancePtr</code> of type <code>ResonanceWidths*</code>
 476 is an instance of a class derived from the
 477 <code><?php $filepath = $_GET["filepath"];
 478 echo "<a href='SemiInternalResonances.php?filepath=".$filepath."' target='page'>";?>ResonanceWidths</a></code>
 479 base class. In addition you need to add the particle to the normal
 480 <?php $filepath = $_GET["filepath"];
 481 echo "<a href='ParticleDataScheme.php?filepath=".$filepath."' target='page'>";?>particle and decay database</a>.
 482 This procedure can be used repeatedly to hand in several different
 483 resonances.
 484 </li>
 485
 486 <p/>
 487 <li>
 488 If you are a real expert and want to <?php $filepath = $_GET["filepath"];
 489 echo "<a href='ImplementNewShowers.php?filepath=".$filepath."' target='page'>";?>replace
 490 the PYTHIA initial- and final-state showers</a>, you can use
 491 <pre>
 492       pythia.setShowerPtr( timesDecPtr, timesPtr, spacePtr);
 493 </pre>
 494 where <code>timesDecPtr</code> and <code>timesPtr</code>
 495 derive from the <code>TimeShower</code> base class, and
 496 <code>spacePtr</code> from <code>SpaceShower</code>.
 497 </li>
 498
 499 </ol>
 500
 501 <p/>
 502 C) Some comments on collecting several tasks in the same run.
 503 <ol>
 504
 505 <li>
 506 PYTHIA has not been written for threadsafe execution on multicore
 507 processors. If you want to use all cores,
 508 the most efficient way presumably is to start correspondingly many jobs,
 509 with different random number seeds, and add the statistics at the end.
 510 However, note that several instances  can be set up in the same main
 511 program, since instances are completely independent of each other,
 512 so each instance could be run inside a separate thread.
 513 </li>
 514
 515 <p/>
 516 <li>
 517 In some cases it is convenient to use more than one <code>Pythia</code>
 518 object. The key example would be the simultaneous generation of signal
 519 and pileup events, see <code>main19.cc</code>. The two objects are then
 520 set up and initialized separately, and generate events completely
 521 independently of each other. It is only afterwards that the event records
 522 are combined into one single super-event per beam crossing.
 523 </li>
 524
 525 <p/>
 526 <li>
 527 When time is not an issue, it may be that you want to perform several
 528 separate subruns sequentially inside a run, e.g. to combine results for
 529 several kinematical regions or to compare results for some different
 530 tunes of the underlying event. One way to go is to create (and destroy)
 531 one <code>pythia</code> object for each subrun, in which case they are
 532 completely separate. You can also use the same <code>pythia</code> object,
 533 only doing a new <code>init(...)</code> call for each subrun. In that
 534 case, the settings and particle databases remain as they were in the
 535 previous subrun, only affected by the specific changes you introduced in
 536 the meantime. You can put those changes in the main program, with
 537 <code>pythia.readString(string)</code>, using your own logic to decide
 538 which ones to execute in which subrun. A corresponding possibility
 539 exists with <code>pythia.readFile(fileName, subrun)</code> (or an
 540 <code>istream</code> instead of a <code>fileName</code>), which as second
 541 argument can take a non-negative subrun number. Then only those
 542 sections of the file before any <code>Main:subrun = ...</code> line
 543 or with matching <code>subrun</code> number will be read. That is, the
 544 file could have a structure like
 545 <pre>
 546     ( lines always read, i.e. "default values" always (re)set )
 547     Main:subrun = 1
 548     ( lines only read with readFile(fileName, 1) )
 549     Main:subrun = 2
 550     ( lines only read with readFile(fileName, 2) )
 551 </pre>
 552 Both of these possibilities are illustrated in <code>main08.cc</code>.
 553 </li>
 554
 555 <p/>
 556 <li>
 557 When working with Les Houches Event Files, it may well be that your
 558 intended input event sample is spread over several files, that you all
 559 want to turn into complete events in one and the same run. There is no
 560 problem with looping over several subruns, where each new subrun
 561 is initialized with a new file, with name set in <code>Beams:LHEF</code>.
 562 However, in that case you will do a complete re-initialization each time
 563 around. If you want to avoid this, note that the flag
 564 <code>Beams:newLHEFsameInit = true</code> can be set for the second and
 565 subsequent subruns. Then the new file will be simulated with the same
 566 initialization data as already set in a previous
 567 <code>pythia.init()</code> call. The burden rests on you to ensure
 568 that this is indeed correct, e.g. that the two event samples have not
 569 been generated for different beam energies. Also note that cross
 570 sections for processes will be based on the information in the
 571 first-read file, when the full initialization is performed.
 572 </li>
 573
 574 </ol>
 575
 576 <h2>The Pythia Class</h2>
 577
 578 Here follows the complete survey of all public <code>Pythia</code>
 579 methods and data members.
 580
 581 <h3>Constructor and destructor</h3>
 582
 583 <a name="method1"></a>
 584 <p/><strong>Pythia::Pythia(string xmlDir = &quot;../xmldoc&quot;) &nbsp;</strong> <br/>
 585 creates an instance of the <code>Pythia</code> event generators,
 586 and sets initial default values, notably for all settings and
 587 particle data. You may use several <code>Pythia</code> instances
 588 in the same run; only when you want to access external static
 589 libraries could this cause problems. (This includes in particular
 590 Fortran libraries such as <?php $filepath = $_GET["filepath"];
 591 echo "<a href='PDFSelection.php?filepath=".$filepath."' target='page'>";?>LHAPDF</a>.)
 592 <br/><code>argument</code><strong> xmlDir </strong> (<code>default = <strong>../xmldoc</strong></code>) : allows you to choose
 593 from which directory the default settings and particle data values
 594 are read in. If the <code>PYTHIA8DATA</code> environment variable
 595 has been set it takes precedence. Else this optional argument allows
 596 you to choose another directory location than the default one. Note
 597 that it is only the directory location you can change, its contents
 598 must be the ones of the <code>xmldoc</code> directory in the
 599 standard distribution.
 600
 601
 602
 603 <a name="method2"></a>
 604 <p/><strong>Pythia::~Pythia &nbsp;</strong> <br/>
 605 the destructor deletes the objects created by the constructor.
 606
 607 <h3>Set up run</h3>
 608
 609 <a name="method3"></a>
 610 <p/><strong>bool Pythia::readString(string line, bool warn = true) &nbsp;</strong> <br/>
 611 reads in a single string, that is interpreted as an instruction to
 612 modify the value of a <?php $filepath = $_GET["filepath"];
 613 echo "<a href='SettingsScheme.php?filepath=".$filepath."' target='page'>";?>setting</a> or
 614 <?php $filepath = $_GET["filepath"];
 615 echo "<a href='ParticleDataScheme.php?filepath=".$filepath."' target='page'>";?>particle data</a>, as already described
 616 above.
 617 <br/><code>argument</code><strong> line </strong>  :
 618 the string to be interpreted as an instruction.
 619
 620 <br/><code>argument</code><strong> warn </strong> (<code>default = <strong>true</strong></code>) :
 621 write a warning message or not whenever the instruction does not make
 622 sense, e.g. if the variable does not exist in the databases.
 623
 624 <br/><b>Note:</b> the method returns false if it fails to
 625 make sense out of the string.
 626
 627
 628 <a name="method4"></a>
 629 <p/><strong>bool Pythia::readFile(string fileName, bool warn = true, int subrun = SUBRUNDEFAULT) &nbsp;</strong> <br/>
 630
 631 <strong>bool Pythia::readFile(string fileName, int subrun = SUBRUNDEFAULT) &nbsp;</strong> <br/>
 632
 633 <strong>bool Pythia::readFile(istream& inStream = cin,  bool warn = true, int subrun = SUBRUNDEFAULT) &nbsp;</strong> <br/>
 634
 635 <strong>bool Pythia::readFile(istream& inStream = cin, int subrun = SUBRUNDEFAULT) &nbsp;</strong> <br/>
 636 reads in a whole file, where each line is interpreted as an instruction
 637 to modify the value of a <?php $filepath = $_GET["filepath"];
 638 echo "<a href='SettingsScheme.php?filepath=".$filepath."' target='page'>";?>setting</a> or
 639 <?php $filepath = $_GET["filepath"];
 640 echo "<a href='ParticleDataScheme.php?filepath=".$filepath."' target='page'>";?>particle data</a>, cf. the above
 641 <code>readString</code> method. All four forms of the
 642 <code>readFile</code> command share code for actually reading a file.
 643 <br/><code>argument</code><strong> fileName </strong>  :
 644 the file from which instructions are read.
 645
 646 <br/><code>argument</code><strong> inStream </strong>  :
 647 an istream from which instructions are read.
 648
 649 <br/><code>argument</code><strong> warn </strong> (<code>default = <strong>true</strong></code>) :
 650 write a warning message or not whenever the instruction does not make
 651 sense, e.g. if the variable does not exist in the databases. In the
 652 command forms where <code>warn</code> is omitted it is true.
 653
 654 <br/><code>argument</code><strong> subrun </strong>  :
 655 allows you have several optional sets of commands within the same file.
 656 Only those sections of the file before any <code>Main:subrun = ...</code>
 657 line or following such a line with matching subrun number will be read.
 658 The subrun number should not be negative; negative codes like
 659 <code>SUBRUNDEFAULT</code> corresponds to no specific subrun.
 660
 661 <br/><b>Note:</b> the method returns false if it fails to
 662 make sense out of any one line.
 663
 664
 665 <a name="method5"></a>
 666 <p/><strong>bool Pythia::setPDFPtr( PDF* pdfAPtr, PDF* pdfBPtr, PDF* pdfHardAPtr = 0, PDF* pdfHardBPtr = 0) &nbsp;</strong> <br/>
 667 offers the possibility to link in external PDF sets for usage inside
 668 the program. The rules for constructing your own class from
 669 the <code>PDF</code> base class are described
 670 <?php $filepath = $_GET["filepath"];
 671 echo "<a href='PartonDistributions.php?filepath=".$filepath."' target='page'>";?>here</a>.
 672 <br/><code>argument</code><strong> pdfAPtr, pdfBPtr </strong>  :
 673 pointers to two <code>PDF</code>-derived objects, one for each of
 674 the incoming beams. The two objects have to be instantiated by you
 675 in your program. Even if the two beam particles are the same
 676 (protons, say) two separate instances are required, since current
 677 information is cached in the objects. If both arguments are zero
 678 then any previous linkage to external PDF's is disconnected,
 679 see further Note 2 below.
 680
 681 <br/><code>argument</code><strong> pdfHardAPtr, pdfHardBPtr </strong> (<code>default = <strong>0</strong></code>) :
 682 pointers to two further <code>PDF</code>-derived objects, one for each
 683 of the incoming beams. Normally only the first two arguments above would
 684 be used, and then the same PDF sets would be invoked everywhere. If you
 685 provide these two further pointers then two different sets of PDF's are
 686 used. This second set is then exclusively for the generation of the hard
 687 process from the process matrix elements library. The first set above
 688 is for everything else, notably parton showers and multiparton interactions.
 689
 690 <br/><b>Note 1:</b> The method returns false if the input is obviously
 691 incorrect, e.g. if two (nonzero) pointers agree.
 692 <br/><b>Note 2:</b> If you want to combine several subruns you can
 693 call <code>setPDFPtr</code> with new arguments before each
 694 <code>Pythia::init(...)</code> call. To revert from external PDF's
 695 to the normal internal PDF selection you must call
 696 <code>setPDFPtr(0, 0)</code> before <code>Pythia::init(...)</code>.
 697
 698
 699 <a name="method6"></a>
 700 <p/><strong>bool Pythia::setLHAupPtr( LHAup* lhaUpPtrIn) &nbsp;</strong> <br/>
 701 offers linkage to an external generator that feeds in events
 702 in the LHA format, see
 703 <?php $filepath = $_GET["filepath"];
 704 echo "<a href='LesHouchesAccord.php?filepath=".$filepath."' target='page'>";?>Les Houches Accord</a>,
 705 assuming that
 706 <code><?php $filepath = $_GET["filepath"];
 707 echo "<a href='BeamParameters.php?filepath=".$filepath."' target='page'>";?>Beams:frameType = 5</a></code>
 708 has been set.
 709 <br/><code>argument</code><strong> lhaUpPtrIn </strong>  :
 710 pointer to a <code>LHAup</code>-derived object.
 711
 712 <br/><b>Note:</b> The method currently always returns true.
 713
 714
 715 <a name="method7"></a>
 716 <p/><strong>bool Pythia::setDecayPtr( DecayHandler* decayHandlePtr, vector&lt;int&gt; handledParticles) &nbsp;</strong> <br/>
 717 offers the possibility to link to an external program that can do some
 718 of the particle decays, instad of using the internal decay machinery.
 719 With particles we here mean the normal hadrons and leptons, not
 720 top quarks, electroweak bosons or new particles in BSM scenarios.
 721 The rules for constructing your own class from the
 722 <code>DecayHandler</code> base class are described
 723 <?php $filepath = $_GET["filepath"];
 724 echo "<a href='ExternalDecays.php?filepath=".$filepath."' target='page'>";?>here</a>. Note that you can only
 725 provide one external object, but this object in its turn could
 726 very well hand on different particles to separate decay libraries.
 727 <br/><code>argument</code><strong> decayHandlePtr </strong>  :
 728 pointer to a <code>DecayHandler</code>-derived object. This object
 729 must be instantiated by you in your program.
 730
 731 <br/><code>argument</code><strong> handledParticles </strong>  :  vector with the PDG identity codes
 732 of the particles that should be handled by the external decay package.
 733 You should only give the particle (positive) codes; the respective
 734 antiparticle is always included as well.
 735
 736 <br/><b>Note:</b> The method currently always returns true.
 737
 738
 739 <a name="method8"></a>
 740 <p/><strong>bool Pythia::setRndmEnginePtr( RndmEngine* rndmEnginePtr) &nbsp;</strong> <br/>
 741 offers the possibility to link to an external random number generator.
 742 The rules for constructing your own class from the
 743 <code>RndmEngine</code> base class are described
 744 <?php $filepath = $_GET["filepath"];
 745 echo "<a href='RandomNumbers.php?filepath=".$filepath."' target='page'>";?>here</a>.
 746 <br/><code>argument</code><strong> rndmEnginePtr </strong>  :
 747 pointer to a <code>RndmEngine</code>-derived object. This object
 748 must be instantiated by you in your program.
 749
 750 <br/><b>Note:</b> The method returns true if the pointer is different
 751 from 0.
 752
 753
 754 <a name="method9"></a>
 755 <p/><strong>bool Pythia::setUserHooksPtr( UserHooks* userHooksPtr) &nbsp;</strong> <br/>
 756 offers the possibility to interact with the generation process at
 757 a few different specified points, e.g. to reject undesirable events
 758 at an early stage to save computer time. The rules for constructing
 759 your own class from the <code>UserHooks</code> base class are described
 760 <?php $filepath = $_GET["filepath"];
 761 echo "<a href='UserHooks.php?filepath=".$filepath."' target='page'>";?>here</a>. You can only hand in one such
 762 pointer, but this may be to a class that implements several of the
 763 different allowed possibilities.
 764 <br/><code>argument</code><strong> userHooksPtr </strong>  :
 765 pointer to a <code>userHooks</code>-derived object. This object
 766 must be instantiated by you in your program.
 767
 768 <br/><b>Note:</b> The method currently always returns true.
 769
 770
 771 <a name="method10"></a>
 772 <p/><strong>bool Pythia::setBeamShapePtr( BeamShape* beamShapePtr) &nbsp;</strong> <br/>
 773 offers the possibility to provide your own shape of the momentum and
 774 space-time spread of the incoming beams. The rules for constructing
 775 your own class from the <code>BeamShape</code> base class are described
 776 <?php $filepath = $_GET["filepath"];
 777 echo "<a href='BeamShape.php?filepath=".$filepath."' target='page'>";?>here</a>.
 778 <br/><code>argument</code><strong> BeamShapePtr </strong>  :
 779 pointer to a <code>BeamShape</code>-derived object. This object
 780 must be instantiated by you in your program.
 781
 782 <br/><b>Note:</b> The method currently always returns true.
 783
 784
 785 <a name="method11"></a>
 786 <p/><strong>bool Pythia::setSigmaPtr( SigmaProcess* sigmaPtr) &nbsp;</strong> <br/>
 787 offers the possibility to link your own implementation of a process
 788 and its cross section, to make it a part of the normal process
 789 generation machinery, without having to recompile the
 790 <code>Pythia</code> library itself.  The rules for constructing your
 791 own class from the <code>SigmaProcess</code> base class are described
 792 <?php $filepath = $_GET["filepath"];
 793 echo "<a href='SemiInternalProcesses.php?filepath=".$filepath."' target='page'>";?>here</a>. You may call this
 794 routine repeatedly, to add as many new processes as you wish.
 795 <br/><code>argument</code><strong> sigmaPtr </strong>  :
 796 pointer to a <code>SigmaProcess</code>-derived object. This object
 797 must be instantiated by you in your program.
 798
 799 <br/><b>Note:</b> The method currently always returns true.
 800
 801
 802 <a name="method12"></a>
 803 <p/><strong>bool Pythia::setResonancePtr( ResonanceWidths* resonancePtr) &nbsp;</strong> <br/>
 804 offers the possibility to link your own implementation of the
 805 calculation of partial resonance widths, to make it a part of the
 806 normal process generation machinery, without having to recompile the
 807 <code>Pythia</code> library itself.  This allows the decay of new
 808 resonances to be handled internally, when combined with new particle
 809 data. Note that the decay of normal hadrons cannot be modelled here;
 810 this is for New Physics resonances. The rules for constructing your
 811 own class from the <code>ResonanceWidths</code> base class are described
 812 <?php $filepath = $_GET["filepath"];
 813 echo "<a href='SemiInternalResonances.php?filepath=".$filepath."' target='page'>";?>here</a>. You may call this
 814 routine repeatedly, to add as many new resonances as you wish.
 815 <br/><code>argument</code><strong> resonancePtr </strong>  :
 816 pointer to a <code>ResonanceWidths</code>-derived object. This object
 817 must be instantiated by you in your program.
 818
 819 <br/><b>Note:</b> The method currently always returns true.
 820
 821
 822 <a name="method13"></a>
 823 <p/><strong>bool Pythia::setShowerPtr( TimeShower* timesDecPtr, TimeShower* timesPtr = 0, SpaceShower* spacePtr = 0) &nbsp;</strong> <br/>
 824 offers the possibility to link your own parton shower routines as
 825 replacements for the default ones. This is much more complicated
 826 since the showers are so central and are so interlinked with other
 827 parts of the program. Therefore it is also possible to do the
 828 replacement in stages, from the more independent to the more
 829 intertwined. The rules for constructing your own classes from the
 830 <code>TimeShower</code> and <code>SpaceShower</code>base classes
 831 are described <?php $filepath = $_GET["filepath"];
 832 echo "<a href='ImplementNewShowers.php?filepath=".$filepath."' target='page'>";?>here</a>. These
 833 objects must be instantiated by you in your program.
 834 <br/><code>argument</code><strong> timesDecPtr </strong>  :
 835 pointer to a <code>TimeShower</code>-derived object for doing
 836 timelike shower evolution in resonance decays, e.g. of a
 837 <i>Z^0</i>. This is decoupled from beam remnants and parton
 838 distributions, and is therefore the simplest kind of shower
 839 to write. If you provide a value 0 then the internal shower
 840 routine will be used.
 841
 842 <br/><code>argument</code><strong> timesPtr </strong> (<code>default = <strong>0</strong></code>) :
 843 pointer to a <code>TimeShower</code>-derived object for doing
 844 all other timelike shower evolution, which is normally interleaved
 845 with multiparton interactions and spacelike showers, introducing
 846 both further physics and further technical issues. If you retain
 847 the default value 0 then the internal shower routine will be used.
 848 You are allowed to use the same pointer as above for the
 849 <code>timesDecPtr</code> if the same shower can fulfill both tasks.
 850
 851 <br/><code>argument</code><strong> spacePtr </strong> (<code>default = <strong>0</strong></code>) :
 852 pointer to a <code>SpaceShower</code>-derived object for doing
 853 all spacelike shower evolution, which is normally interleaved
 854 with multiparton interactions and timelike showers. If you retain
 855 the default value 0 then the internal shower routine will be used.
 856
 857 <br/><b>Note:</b> The method currently always returns true.
 858
 859
 860 <h3>Initialize</h3>
 861
 862 At the initialization stage all the information provided above is
 863 processed, and the stage is set up for the subsequent generation
 864 of events. Currently several alterative forms of the <code>init</code>
 865 method are available for this stage, but only the first one is
 866 recommended.
 867
 868 <a name="method14"></a>
 869 <p/><strong>bool Pythia::init() &nbsp;</strong> <br/>
 870 initialize for collisions, in any of the five separate possibilities
 871 below. In this option the beams are not specified by input arguments,
 872 but instead by the settings in the
 873 <?php $filepath = $_GET["filepath"];
 874 echo "<a href='BeamParameters.php?filepath=".$filepath."' target='page'>";?>Beam Parameters</a> section.
 875 This allows the beams to be specified in the same file as other
 876 run instructions. The default settings give pp collisions at 14 TeV.
 877 <br/><b>Note:</b> The method returns false if the
 878 initialization fails. It is then not possible to generate any
 879 events.
 880
 881
 882 <a name="method15"></a>
 883 <p/><strong>bool Pythia::init( int idA, int idB, double eCM) &nbsp;</strong> <br/>
 884 initialize for collisions in the center-of-mass frame, with the
 885 beams moving in the <i>+-z</i> directions.
 886 <br/><code>argument</code><strong> idA, idB </strong>  :
 887 particle identity code for the two incoming beams.
 888
 889 <br/><code>argument</code><strong> eCM </strong>  :
 890 the CM energy of the collisions.
 891
 892 <br/><b>Notes:</b> Deprecated. The method returns false if the
 893 initialization fails. It is then not possible to generate any
 894 events.
 895
 896
 897 <a name="method16"></a>
 898 <p/><strong>bool Pythia::init( int idA, int idB, double eA, double eB) &nbsp;</strong> <br/>
 899 initialize for collisions with back-to-back beams,
 900 moving in the <i>+-z</i> directions, but with different energies.
 901 <br/><code>argument</code><strong> idA, idB </strong>  :
 902 particle identity code for the two incoming beams.
 903
 904 <br/><code>argument</code><strong> eA, eB </strong>  :
 905 the energies of the two beams. If an energy is set to be below
 906 the mass of the respective beam particle that particle is taken to
 907 be at rest. This offers a simple possibility to simulate
 908 fixed-target collisions.
 909
 910 <br/><b>Notes:</b> Deprecated. The method returns false if the
 911 initialization fails. It is then not possible to generate any
 912 events.
 913
 914
 915 <a name="method17"></a>
 916 <p/><strong>bool Pythia::init( int idA, int idB, double pxA, double pyA, double pzA, double pxB, double pyB, double pzB) &nbsp;</strong> <br/>
 917 initialize for collisions with arbitrary beam directions.
 918 <br/><code>argument</code><strong> idA, idB </strong>  :
 919 particle identity code for the two incoming beams.
 920
 921 <br/><code>argument</code><strong> pxA, pyA, pzA </strong>  :
 922 the three-momntum vector <i>(p_x, p_y, p_z)</i> of the first
 923 incoming beam.
 924
 925 <br/><code>argument</code><strong> pxB, pyB, pzB </strong>  :
 926 the three-momntum vector <i>(p_x, p_y, p_z)</i> of the second
 927 incoming beam.
 928
 929 <br/><b>Notes:</b> Deprecated. The method returns false if the
 930 initialization fails. It is then not possible to generate any
 931 events.
 932
 933
 934 <a name="method18"></a>
 935 <p/><strong>bool Pythia::init( string LesHouchesEventFile, bool skipInit = false) &nbsp;</strong> <br/>
 936 initialize for hard-process collisions fed in from an external file
 937 with events, written according to the
 938 <?php $filepath = $_GET["filepath"];
 939 echo "<a href='LesHouchesAccord.php?filepath=".$filepath."' target='page'>";?>Les Houches Event File</a>
 940 standard.
 941 <br/><code>argument</code><strong> LesHouchesEventFile </strong>  :
 942 the file name (including path, where required) where the
 943 events are stored, including relevant information on beam
 944 identities and energies.
 945
 946 <br/><code>argument</code><strong> skipInit </strong> (<code>default = <strong>false</strong></code>) :
 947 By default this method does a complete reinitialization of the
 948 generation process. If you set this argument to true then
 949 no reinitialization will occur, only the pointer to the event
 950 file is updated. This may come in handy if the full event sample
 951 is split across several files generated under the same conditions
 952 (except random numbers, of course). You then do the first
 953 initialization with the default, and all subsequent ones with
 954 true. Note that things may go wrong if the files are not created
 955 under the same conditions.
 956
 957 <br/><b>Notes:</b> Deprecated. The method returns false if the
 958 initialization fails. It is then not possible to generate any
 959 events.
 960
 961
 962 <a name="method19"></a>
 963 <p/><strong>bool Pythia::init( LHAup* lhaUpPtr) &nbsp;</strong> <br/>
 964 initialize for hard-process collisions fed in from an external
 965 source of events, consistent with the Les Houches Accord standard.
 966 The rules for constructing your own class from the <code>LHAup</code>
 967 base class are described <?php $filepath = $_GET["filepath"];
 968 echo "<a href='LesHouchesAccord.php?filepath=".$filepath."' target='page'>";?>here</a>.
 969 This class is also required to provide the beam parameters.
 970 <br/><code>argument</code><strong> lhaUpPtr </strong>  :
 971 pointer to a <code>LHAup</code>-derived object. This object
 972 must be instantiated by you in your program.
 973
 974 <br/><b>Notes:</b> Deprecated. The method returns false if the
 975 initialization fails. It is then not possible to generate any
 976 events.
 977
 978
 979 <h3>Generate events</h3>
 980
 981 The <code>next()</code> method is the main one to generate events.
 982 In this section we also put a few other specialized methods that
 983 may be useful in some circumstances.
 984
 985 <a name="method20"></a>
 986 <p/><strong>bool Pythia::next() &nbsp;</strong> <br/>
 987 generate the next event. No input parameters are required; all
 988 instructions have already been set up in the initialization stage.
 989 <br/><b>Note:</b> The method returns false if the event generation
 990 fails. The event record is then not consistent and should not be
 991 studied. When reading in hard collisions from a Les Houches Event File
 992 the problem may be that the end of the file has been reached. This
 993 can be checked with the
 994 <code><?php $filepath = $_GET["filepath"];
 995 echo "<a href='EventInformation.php?filepath=".$filepath."' target='page'>";?>Info::atEndOfFile()</a></code>
 996 method.
 997
 998
 999 <a name="method21"></a>
1000 <p/><strong>int Pythia::forceTimeShower( int iBeg, int iEnd, double pTmax, int nBranchMax = 0) &nbsp;</strong> <br/>
1001 perform a final-state shower evolution on partons in the
1002 <code>event</code> event record. This could be used for externally
1003 provided simple events, or even parts of events, for which
1004 a complete generation is not foreseen. Since the mother source of
1005 the parton system is not known, one cannot expect as good accuracy
1006 as in a normal generation. When two different timelike shower
1007 instances are set up, it is the one used for showering in resonance
1008 decays that is used here. The <code>forceTimeShower</code> method
1009 can be used in conjunction with the <code>forceHadronLevel</code>
1010 one below. Further comments are found
1011 <?php $filepath = $_GET["filepath"];
1012 echo "<a href='HadronLevelStandalone.php?filepath=".$filepath."' target='page'>";?>here</a>.
1013 <br/><code>argument</code><strong> iBeg, iEnd </strong>  :  the first and last entry of the event
1014 record to be affected by the call.
1015
1016 <br/><code>argument</code><strong> pTmax </strong>  :  the maximum <i>pT</i> scale of emissions.
1017 Additionally, as always, the <code>scale</code> variable of each parton
1018 sets the maximum <i>pT</i> scale of branchings of this parton.
1019 Recall that this scale defaults to 0 if not set, so that no radiation
1020 can occur.
1021
1022 <br/><code>argument</code><strong> nBranchMax </strong> (<code>default = <strong>0</strong></code>) :  when positive, it sets the
1023 maximum number of branchings that are allowed to occur in the shower,
1024 i.e. the shower may stop evolving before reaching the lower cutoff.
1025 The argument has no effect when zero or negative, i.e. then the shower
1026 will continue to the lower cutoff.
1027
1028 <br/><b>Note:</b> The method returns the number of branchings that
1029 has been generated.
1030
1031
1032 <a name="method22"></a>
1033 <p/><strong>bool Pythia::forceHadronLevel(bool findJunctions = true) &nbsp;</strong> <br/>
1034 hadronize the existing event record, i.e. perform string fragmentation
1035 and particle decays. There are two main applications. Firstly,
1036 you can use the same parton-level content as a basis for repeated
1037 hadronization attempts, in schemes intended to save computer time.
1038 Secondly, you may have an external program that can simulate the full
1039 partonic level of the event - hard process, parton showers, multiparton
1040 interactions, beam remnants, colour flow, and so on - but not
1041 hadronization. Further details are found
1042 <?php $filepath = $_GET["filepath"];
1043 echo "<a href='HadronLevelStandalone.php?filepath=".$filepath."' target='page'>";?>here</a>.
1044 <br/><code>argument</code><strong> findJunctions </strong> (<code>default = <strong>true</strong></code>) :
1045 normally this routine will search through the event record and try to
1046 figure out if any colour junctions are present. If so, the colour
1047 topology of such junctions must be sorted out. In tricky cases this
1048 might fail, and then hadronization will not work. A user who is
1049 aware of this and knows the intended colour flow can set up the
1050 junction information in the event record, and then call
1051 <code>forceHadronLevel(false)</code> so as not to have this information
1052 overwritten.
1053 <br/><b>Note:</b> The method returns false if the hadronization
1054 fails. The event record is then not consistent and should not be
1055 studied.
1056
1057
1058 <a name="method23"></a>
1059 <p/><strong>bool Pythia::moreDecays() &nbsp;</strong> <br/>
1060 perform decays of all particles in the event record that have not been
1061 decayed but should have been done so. This can be used e.g. for
1062 repeated decay attempts, in schemes intended to save computer time.
1063 Further details are found <?php $filepath = $_GET["filepath"];
1064 echo "<a href='HadronLevelStandalone.php?filepath=".$filepath."' target='page'>";?>here</a>.
1065 <br/><b>Note:</b> The method returns false if the decays fail. The
1066 event record is then not consistent and should not be studied.
1067
1068
1069 <a name="method24"></a>
1070 <p/><strong>bool Pythia::forceRHadronDecays() &nbsp;</strong> <br/>
1071 perform decays of R-hadrons that were previously considered stable.
1072 This could be if an R-hadron is sufficiently long-lived that
1073 it may interact in the detector between production and decay, so that
1074 its four-momentum is changed. Further details are found
1075 <?php $filepath = $_GET["filepath"];
1076 echo "<a href='RHadrons.php?filepath=".$filepath."' target='page'>";?>here</a>.
1077 <br/><b>Note:</b> The method returns false if the decays fail. The
1078 event record is then not consistent and should not be studied.
1079
1080
1081 <a name="method25"></a>
1082 <p/><strong>void Pythia::LHAeventList(ostream& os = cout) &nbsp;</strong> <br/>
1083 list the Les Houches Accord information on the current event, see
1084 <code><?php $filepath = $_GET["filepath"];
1085 echo "<a href='LesHouchesAccord.php?filepath=".$filepath."' target='page'>";?>LHAup::listEvent(...)</a></code>.
1086 (Other listings are available via the class members below, so this
1087 listing is a special case that would not fit elsewhere.)
1088 <br/><code>argument</code><strong> os </strong> (<code>default = <strong>cout</strong></code>) :
1089 output stream where the listing occurs.
1090
1091
1092
1093 <a name="method26"></a>
1094 <p/><strong>bool Pythia::LHAeventSkip(int nSkip) &nbsp;</strong> <br/>
1095 skip ahead a number of events in the Les Houches generation
1096 sequence, without doing anything further with them, see
1097 <code><?php $filepath = $_GET["filepath"];
1098 echo "<a href='LesHouchesAccord.php?filepath=".$filepath."' target='page'>";?>LHAup::skipEvent(nSkip)</a></code>.
1099 Mainly intended for debug purposes, e.g. when an event at a known
1100 location in a Les Houches Event File is causing problems.
1101 <br/><code>argument</code><strong> nSkip </strong>  :
1102 number of events to skip.
1103
1104 <br/><b>Note:</b> The method returns false if the operation fails,
1105 specifically if the end of a LHEF has been reached, cf.
1106 <code>next()</code> above.
1107
1108
1109 <h3>Finalize</h3>
1110
1111 There is no required finalization step; you can stop generating events
1112 when and how you want. It is still recommended that you make it a
1113 routine to call the following method at the end. A second method provides
1114 a deprecated alternative.
1115
1116 <a name="method27"></a>
1117 <p/><strong>void Pythia::stat() &nbsp;</strong> <br/>
1118 list statistics on the event generation, specifically total and partial
1119 cross sections and the number of different errors. For more details see
1120 <?php $filepath = $_GET["filepath"];
1121 echo "<a href='EventStatistics.php?filepath=".$filepath."' target='page'>";?>here</a> and for available options
1122 <?php $filepath = $_GET["filepath"];
1123 echo "<a href='MainProgramSettings.php?filepath=".$filepath."' target='page'>";?>here</a>.
1124
1125
1126 <a name="method28"></a>
1127 <p/><strong>void Pythia::statistics(bool all = false, bool reset = false) &nbsp;</strong> <br/>
1128 list statistics on the event generation, specifically total and partial
1129 cross sections and the number of different errors. For more details see
1130 <?php $filepath = $_GET["filepath"];
1131 echo "<a href='EventStatistics.php?filepath=".$filepath."' target='page'>";?>here</a>.
1132 <br/><code>argument</code><strong> all </strong> (<code>default = <strong>false</strong></code>) :
1133 if true also statistics on multiparton interactions is shown, by default not.
1134
1135 <br/><code>argument</code><strong> reset </strong> (<code>default = <strong>false</strong></code>) :  if true then all counters,
1136 e.g on events generated and errors experienced, are reset to zero
1137  whenever the routine is called. The default instead is that
1138 all stored statistics information is unaffected by the call. Counters
1139 are automatically reset in each new <code>Pythia::init(...)</code>
1140 call, however, so the only time the <code>reset</code> option makes a
1141 difference is if <code>statistics(...)</code> is called several times
1142 in a (sub)run.
1143
1144 <br/><b>Note:</b> Deprecated.
1145
1146
1147 <h3>Interrogate settings</h3>
1148
1149 Normally settings are used in the setup and initialization stages
1150 to determine the character of a run, e.g. read from a file with the
1151 above-described <code>Pythia::readFile(...)</code> method.
1152 There is no strict need for a user to interact with the
1153 <code>Settings</code> database in any other way. However, as an option,
1154 some settings variables have been left free for the user to set in
1155 such a file, and then use in the main program to directly affect the
1156 performance of that program, see
1157 <?php $filepath = $_GET["filepath"];
1158 echo "<a href='MainProgramSettings.php?filepath=".$filepath."' target='page'>";?>here</a>. A typical example would
1159 be the number of events to generate. For such applications the
1160 following shortcuts to some <code>Settings</code> methods may be
1161 convenient.
1162
1163 <a name="method29"></a>
1164 <p/><strong>bool Pythia::flag(string key) &nbsp;</strong> <br/>
1165 read in a boolean variable from the <code>Settings</code> database.
1166 <br/><code>argument</code><strong> key </strong>  :
1167 the name of the variable to be read.
1168
1169
1170
1171 <a name="method30"></a>
1172 <p/><strong>int Pythia::mode(string key) &nbsp;</strong> <br/>
1173 read in an integer variable from the <code>Settings</code> database.
1174 <br/><code>argument</code><strong> key </strong>  :
1175 the name of the variable to be read.
1176
1177
1178
1179 <a name="method31"></a>
1180 <p/><strong>double Pythia::parm(string key) &nbsp;</strong> <br/>
1181 read in a double-precision variable from the <code>Settings</code>
1182 database.
1183 <br/><code>argument</code><strong> key </strong>  :
1184 the name of the variable to be read.
1185
1186
1187
1188 <a name="method32"></a>
1189 <p/><strong>string Pythia::word(string key) &nbsp;</strong> <br/>
1190 read in a string variable from the <code>Settings</code> database.
1191 <br/><code>argument</code><strong> key </strong>  :
1192 the name of the variable to be read.
1193
1194
1195
1196 <h3>Data members</h3>
1197
1198 The <code>Pythia</code> class contains a few public data members,
1199 several of which play a central role. We list them here, with
1200 links to the places where they are further described.
1201
1202 <a name="method33"></a>
1203 <p/><strong>Event Pythia::process &nbsp;</strong> <br/>
1204 the hard-process event record, see <?php $filepath = $_GET["filepath"];
1205 echo "<a href='EventRecord.php?filepath=".$filepath."' target='page'>";?>here</a>
1206 for further details.
1207
1208
1209 <a name="method34"></a>
1210 <p/><strong>Event Pythia::event &nbsp;</strong> <br/>
1211 the complete event record, see <?php $filepath = $_GET["filepath"];
1212 echo "<a href='EventRecord.php?filepath=".$filepath."' target='page'>";?>here</a>
1213 for further details.
1214
1215
1216 <a name="method35"></a>
1217 <p/><strong>Info Pythia::info &nbsp;</strong> <br/>
1218 further information on the event-generation process, see
1219 <?php $filepath = $_GET["filepath"];
1220 echo "<a href='EventInformation.php?filepath=".$filepath."' target='page'>";?>here</a> for further details.
1221
1222
1223 <a name="method36"></a>
1224 <p/><strong>Settings Pythia::settings &nbsp;</strong> <br/>
1225 the settings database, see <?php $filepath = $_GET["filepath"];
1226 echo "<a href='SettingsScheme.php?filepath=".$filepath."' target='page'>";?>here</a>
1227 for further details.
1228
1229
1230 <a name="method37"></a>
1231 <p/><strong>ParticleData Pythia::particleData &nbsp;</strong> <br/>
1232 the particle properties and decay tables database, see
1233 <?php $filepath = $_GET["filepath"];
1234 echo "<a href='ParticleDataScheme.php?filepath=".$filepath."' target='page'>";?>here</a> for further details.
1235
1236
1237 <a name="method38"></a>
1238 <p/><strong>Rndm Pythia::rndm &nbsp;</strong> <br/>
1239 the random number generator, see <?php $filepath = $_GET["filepath"];
1240 echo "<a href='RandomNumberSeed.php?filepath=".$filepath."' target='page'>";?>here</a>
1241 and <?php $filepath = $_GET["filepath"];
1242 echo "<a href='RandomNumbers.php?filepath=".$filepath."' target='page'>";?>here</a> for further details.
1243
1244
1245 <a name="method39"></a>
1246 <p/><strong>CoupSM Pythia::coupSM &nbsp;</strong> <br/>
1247 Standard Model couplings and mixing matrices, see
1248 <?php $filepath = $_GET["filepath"];
1249 echo "<a href='StandardModelParameters.php?filepath=".$filepath."' target='page'>";?>here</a> for further details.
1250
1251
1252 <a name="method40"></a>
1253 <p/><strong>SusyLesHouches Pythia::slha &nbsp;</strong> <br/>
1254 parameters and particle data in the context of supersymmetric models,
1255 see <?php $filepath = $_GET["filepath"];
1256 echo "<a href='SUSYLesHouchesAccord.php?filepath=".$filepath."' target='page'>";?>here</a> for further details.
1257
1258
1259 <a name="method41"></a>
1260 <p/><strong>PartonSystems Pythia::partonSystems &nbsp;</strong> <br/>
1261 a grouping of the partons in the event record by subsystem,
1262 see <?php $filepath = $_GET["filepath"];
1263 echo "<a href='AdvancedUsage.php?filepath=".$filepath."' target='page'>";?>here</a> for further details.
1264
1265
1266 </body>
1267 </html>
1268
1269 <!-- Copyright (C) 2012 Torbjorn Sjostrand -->