PYTHIA  8.313
Pythia.h
1 // Pythia.h is a part of the PYTHIA event generator.
2 // Copyright (C) 2025 Torbjorn Sjostrand.
3 // PYTHIA is licenced under the GNU GPL v2 or later, see COPYING for details.
4 // Please respect the MCnet Guidelines, see GUIDELINES for details.
5 
6 // This file contains the main class for event generation.
7 // Pythia: provide the main user interface to everything else.
8 
9 #ifndef Pythia8_Pythia_H
10 #define Pythia8_Pythia_H
11 
12 // Version number defined for use in macros and for consistency checks.
13 #define PYTHIA_VERSION 8.313
14 #define PYTHIA_VERSION_INTEGER 8313
15 
16 // Header files for the Pythia class and for what else the user may need.
17 #include "Pythia8/Analysis.h"
18 #include "Pythia8/Basics.h"
19 #include "Pythia8/BeamParticle.h"
20 #include "Pythia8/BeamSetup.h"
21 #include "Pythia8/Event.h"
22 #include "Pythia8/FragmentationFlavZpT.h"
23 #include "Pythia8/HadronLevel.h"
24 #include "Pythia8/HadronWidths.h"
25 #include "Pythia8/Info.h"
26 #include "Pythia8/JunctionSplitting.h"
27 #include "Pythia8/LesHouches.h"
28 #include "Pythia8/Logger.h"
29 #include "Pythia8/SigmaLowEnergy.h"
30 #include "Pythia8/Merging.h"
31 #include "Pythia8/MergingHooks.h"
32 #include "Pythia8/PartonLevel.h"
33 #include "Pythia8/ParticleData.h"
34 #include "Pythia8/PartonDistributions.h"
35 #include "Pythia8/PartonSystems.h"
36 #include "Pythia8/PartonVertex.h"
37 #include "Pythia8/PhysicsBase.h"
38 #include "Pythia8/ProcessLevel.h"
39 #include "Pythia8/PythiaStdlib.h"
40 #include "Pythia8/ResonanceWidths.h"
41 #include "Pythia8/RHadrons.h"
42 #include "Pythia8/Ropewalk.h"
43 #include "Pythia8/Settings.h"
44 #include "Pythia8/ShowerModel.h"
45 #include "Pythia8/SigmaTotal.h"
46 #include "Pythia8/SimpleSpaceShower.h"
47 #include "Pythia8/SimpleTimeShower.h"
48 #include "Pythia8/SpaceShower.h"
49 #include "Pythia8/StandardModel.h"
50 #include "Pythia8/StringInteractions.h"
51 #include "Pythia8/SusyCouplings.h"
52 #include "Pythia8/SLHAinterface.h"
53 #include "Pythia8/TimeShower.h"
54 #include "Pythia8/UserHooks.h"
55 #include "Pythia8/VinciaCommon.h"
56 #include "Pythia8/Weights.h"
57 
58 namespace Pythia8 {
59 
60 //==========================================================================
61 
62 // Forward declaration of the HeavyIons and HIUserHooks classes.
63 class HeavyIons;
64 class HIUserHooks;
65 
66 // Forward declaration of PythiaParallel class, to be friended.
67 class PythiaParallel;
68 
69 // The Pythia class contains the top-level routines to generate an event.
70 
71 class Pythia {
72 
73 public:
74 
75  // Constructor. (See Pythia.cc file.)
76  Pythia(string xmlDir = "../share/Pythia8/xmldoc", bool printBanner = true);
77 
78  // Constructor to copy settings and particle database from another Pythia
79  // object instead of XML files (to speed up multiple initialisations).
80  Pythia(Settings& settingsIn, ParticleData& particleDataIn,
81  bool printBanner = true);
82 
83  // Constructor taking input from streams instead of files.
84  Pythia( istream& settingsStrings, istream& particleDataStrings,
85  bool printBanner = true);
86 
87  // Destructor.
88  ~Pythia() {}
89 
90  // Copy and = constructors cannot be used.
91  Pythia(const Pythia&) = delete;
92  Pythia& operator=(const Pythia&) = delete;
93 
94  // Check consistency of version numbers (called by constructors).
95  bool checkVersion();
96 
97  // Read in one update for a setting or particle data from a single line.
98  bool readString(string line, bool warn = true, int subrun = SUBRUNDEFAULT) {
99  return isConstructed ? settings.readString(line, warn, subrun) : false;}
100 
101  // Read in updates for settings or particle data from user-defined file.
102  bool readFile(string fileName, bool warn = true,
103  int subrun = SUBRUNDEFAULT) {
104  return isConstructed ? settings.readFile(fileName, warn, subrun) : false;}
105  bool readFile(string fileName, int subrun) {
106  return readFile(fileName, true, subrun);}
107  bool readFile(istream& is = cin, bool warn = true,
108  int subrun = SUBRUNDEFAULT) {
109  return isConstructed ? settings.readFile(is, warn, subrun) : false;}
110  bool readFile(istream& is, int subrun) {
111  return readFile(is, true, subrun);}
112 
113  // Possibility to pass in pointers to PDF's.
114  bool setPDFPtr( PDFPtr pdfAPtrIn, PDFPtr pdfBPtrIn,
115  PDFPtr pdfHardAPtrIn = nullptr, PDFPtr pdfHardBPtrIn = nullptr,
116  PDFPtr pdfPomAPtrIn = nullptr, PDFPtr pdfPomBPtrIn = nullptr,
117  PDFPtr pdfGamAPtrIn = nullptr, PDFPtr pdfGamBPtrIn = nullptr,
118  PDFPtr pdfHardGamAPtrIn = nullptr, PDFPtr pdfHardGamBPtrIn = nullptr,
119  PDFPtr pdfUnresAPtrIn = nullptr, PDFPtr pdfUnresBPtrIn = nullptr,
120  PDFPtr pdfUnresGamAPtrIn = nullptr, PDFPtr pdfUnresGamBPtrIn = nullptr,
121  PDFPtr pdfVMDAPtrIn = nullptr, PDFPtr pdfVMDBPtrIn = nullptr) {
122  return beamSetup.setPDFPtr( pdfAPtrIn, pdfBPtrIn, pdfHardAPtrIn,
123  pdfHardBPtrIn, pdfPomAPtrIn, pdfPomBPtrIn, pdfGamAPtrIn, pdfGamBPtrIn,
124  pdfHardGamAPtrIn, pdfHardGamBPtrIn, pdfUnresAPtrIn, pdfUnresBPtrIn,
125  pdfUnresGamAPtrIn, pdfUnresGamBPtrIn, pdfVMDAPtrIn, pdfVMDBPtrIn); }
126  bool setPDFAPtr( PDFPtr pdfAPtrIn ) {
127  return beamSetup.setPDFAPtr( pdfAPtrIn); }
128  bool setPDFBPtr( PDFPtr pdfBPtrIn ) {
129  return beamSetup.setPDFBPtr( pdfBPtrIn); }
130 
131  // Set photon fluxes externally. Used with option "PDF:lepton2gammaSet = 2".
132  bool setPhotonFluxPtr( PDFPtr photonFluxAIn, PDFPtr photonFluxBIn) {
133  return beamSetup.setPhotonFluxPtr( photonFluxAIn, photonFluxBIn); }
134 
135  // Possibility to pass in pointer to external LHA-interfaced generator.
136  bool setLHAupPtr( LHAupPtr lhaUpPtrIn) {lhaUpPtr = lhaUpPtrIn;
137  useNewLHA = false; return beamSetup.setLHAupPtr( lhaUpPtrIn);}
138 
139  // Possibility to pass in pointer for external handling of some decays.
140  bool setDecayPtr( DecayHandlerPtr decayHandlePtrIn,
141  vector<int> handledParticlesIn = {}) {decayHandlePtr = decayHandlePtrIn;
142  handledParticles = handledParticlesIn.size() == 0 ?
143  decayHandlePtrIn->handledParticles() : handledParticlesIn; return true;}
144 
145  // Possibility to pass in pointer for external random number generation.
146  bool setRndmEnginePtr( RndmEnginePtr rndmEnginePtrIn)
147  { return rndm.rndmEnginePtr( rndmEnginePtrIn);}
148 
149  // Possibility to pass in pointer for user hooks.
150  bool setUserHooksPtr(UserHooksPtr userHooksPtrIn) {
151  userHooksPtr = userHooksPtrIn; return true;}
152 
153  // Possibility to add further pointers to allow multiple user hooks.
154  bool addUserHooksPtr( UserHooksPtr userHooksPtrIn) {
155  if ( !userHooksPtrIn ) return false;
156  if ( !userHooksPtr ) return setUserHooksPtr(userHooksPtrIn);
157  shared_ptr<UserHooksVector> uhv =
158  dynamic_pointer_cast<UserHooksVector>(userHooksPtr);
159  if ( !uhv ) { uhv = make_shared<UserHooksVector>();
160  uhv->hooks.push_back(userHooksPtr); userHooksPtr = uhv; }
161  uhv->hooks.push_back(userHooksPtrIn); return true;}
162 
163  // Possibility to insert a user hook.
164  bool insertUserHooksPtr( int idx, UserHooksPtr userHooksPtrIn) {
165  if ( !userHooksPtrIn || !userHooksPtr ) return false;
166  shared_ptr<UserHooksVector> uhv =
167  dynamic_pointer_cast<UserHooksVector>(userHooksPtr);
168  if ( !uhv || idx < 0 || idx > (int)uhv->hooks.size() ) return false;
169  uhv->hooks.insert(uhv->hooks.begin() + idx, userHooksPtrIn); return true;}
170 
171  // Possibility to pass in pointer for full merging class.
172  bool setMergingPtr( MergingPtr mergingPtrIn)
173  { mergingPtr = mergingPtrIn; return true;}
174 
175  // Possibility to pass in pointer for merging hooks.
176  bool setMergingHooksPtr( MergingHooksPtr mergingHooksPtrIn)
177  { mergingHooksPtr = mergingHooksPtrIn; return true;}
178 
179  // Possibility to pass in pointer for beam shape.
180  bool setBeamShapePtr( BeamShapePtr beamShapePtrIn)
181  { return beamSetup.setBeamShapePtr(beamShapePtrIn);}
182 
183  // Possibility to pass in pointer for external cross section,
184  // with option to include external phase-space generator.
185  bool setSigmaPtr( SigmaProcessPtr sigmaPtrIn,
186  PhaseSpacePtr phaseSpacePtrIn = nullptr)
187  { sigmaPtrs.resize(0), phaseSpacePtrs.resize(0);
188  sigmaPtrs.push_back(sigmaPtrIn);
189  phaseSpacePtrs.push_back(phaseSpacePtrIn); return true;}
190 
191  // Possibility to add further pointers to allow for multiple cross sections.
192  bool addSigmaPtr( SigmaProcessPtr sigmaPtrIn,
193  PhaseSpacePtr phaseSpacePtrIn = nullptr)
194  { sigmaPtrs.push_back(sigmaPtrIn);
195  phaseSpacePtrs.push_back(phaseSpacePtrIn); return true;}
196 
197  // Possibility to insert further pointers to allow for multiple
198  // cross sections.
199  bool insertSigmaPtr( int idx, SigmaProcessPtr sigmaPtrIn,
200  PhaseSpacePtr phaseSpacePtrIn = nullptr)
201  { if (idx < 0 || idx > (int)sigmaPtrs.size()) return false;
202  sigmaPtrs.insert(sigmaPtrs.begin() + idx, sigmaPtrIn);
203  phaseSpacePtrs.insert(phaseSpacePtrs.begin() + idx, phaseSpacePtrIn);
204  return true;}
205 
206  // Possibility to pass in pointer for external resonance.
207  bool setResonancePtr( ResonanceWidthsPtr resonancePtrIn)
208  { resonancePtrs.resize(0);
209  resonancePtrs.push_back( resonancePtrIn); return true;}
210 
211  // Possibility to add further pointers to allow for multiple resonances.
212  bool addResonancePtr( ResonanceWidthsPtr resonancePtrIn)
213  { resonancePtrs.push_back( resonancePtrIn); return true;}
214 
215  // Possibility to insert further pointers to allow for multiple resonances.
216  bool insertResonancePtr( int idx, ResonanceWidthsPtr resonancePtrIn)
217  { if (idx < 0 || idx > (int)resonancePtrs.size()) return false;
218  resonancePtrs.insert( resonancePtrs.begin() + idx, resonancePtrIn);
219  return true;}
220 
221  // Possibility to pass in pointer for external showers.
222  bool setShowerModelPtr( ShowerModelPtr showerModelPtrIn)
223  { showerModelPtr = showerModelPtrIn; return true;}
224 
225  // Possibility to pass in pointer for external fragmentation model.
226  bool setFragmentationPtr( FragmentationModelPtr fragmentationPtrIn)
227  { fragPtrs.resize(0);
228  fragPtrs.push_back( fragmentationPtrIn); return true;}
229 
230  // Possibility to allow for multiple external fragmentation models.
231  bool addFragmentationPtr( FragmentationModelPtr fragmentationPtrIn)
232  { fragPtrs.push_back( fragmentationPtrIn); return true;}
233 
234  // Possibility to insert external fragmentation model, in specific position.
235  bool insertFragmentationPtr( int idx,
236  FragmentationModelPtr fragmentationPtrIn)
237  { if (idx < 0 || idx > (int)fragPtrs.size()) return false;
238  fragPtrs.insert( fragPtrs.begin() + idx, fragmentationPtrIn);
239  return true;}
240 
241  // Possibility to pass in pointer for modelling of heavy ion collisions.
242  bool setHeavyIonsPtr( HeavyIonsPtr heavyIonsPtrIn)
243  { heavyIonsPtr = heavyIonsPtrIn; return true;}
244 
245  // Possibility to pass a HIUserHooks pointer for modifying the
246  // behavior of the heavy ion modelling.
247  bool setHIHooks(HIUserHooksPtr hiHooksPtrIn)
248  { hiHooksPtr = hiHooksPtrIn; return true; }
249 
250  // Possibility to get the pointer to a object modelling heavy ion
251  // collisions.
252  HeavyIonsPtr getHeavyIonsPtr() { return heavyIonsPtr;}
253 
254  // Possibility to access the pointer to the BeamShape object.
255  BeamShapePtr getBeamShapePtr() { return beamSetup.getBeamShapePtr(); }
256 
257  // Possibility to get the pointer to the parton-shower model.
258  ShowerModelPtr getShowerModelPtr() { return showerModelPtr; }
259 
260  // Possibility to get the pointer to the LHA accessor.
261  LHAupPtr getLHAupPtr() { return lhaUpPtr; }
262 
263  // Possibility to pass in pointer for setting of parton space-time vertices.
264  bool setPartonVertexPtr( PartonVertexPtr partonVertexPtrIn)
265  { partonVertexPtr = partonVertexPtrIn; return true;}
266 
267  // Initialize.
268  bool init();
269 
270  // Generate the next event.
271  bool next() { return next(0); }
272  bool next(int procTypeIn);
273 
274  // Switch to new beam particle identities; for similar hadrons only.
275  bool setBeamIDs( int idAin, int idBin = 0);
276 
277  // Switch beam kinematics.
278  bool setKinematics(double eCMIn);
279  bool setKinematics(double eAIn, double eBIn);
280  bool setKinematics(double pxAIn, double pyAIn, double pzAIn,
281  double pxBIn, double pyBIn, double pzBIn);
282  bool setKinematics(Vec4 pAIn, Vec4 pBIn);
283 
284  // Generate only a single timelike shower as in a decay.
285  int forceTimeShower( int iBeg, int iEnd, double pTmax, int nBranchMax = 0)
286  { if (!isInit) {
287  logger.ERROR_MSG("Pythia is not properly initialized"); return 0; }
288  partonSystems.clear(); infoPrivate.setScalup( 0, pTmax);
289  return timesDecPtr->shower( iBeg, iEnd, event, pTmax, nBranchMax); }
290 
291  // Generate only the hadronization/decay stage.
292  bool forceHadronLevel( bool findJunctions = true);
293 
294  // Special routine to allow more decays if on/off switches changed.
295  bool moreDecays() {return hadronLevel.moreDecays(event);}
296  bool moreDecays(int index) {return hadronLevel.decay(index, event);}
297 
298  // Special routine to force R-hadron decay when not done before.
299  bool forceRHadronDecays() {return doRHadronDecays();}
300 
301  // Do a low-energy collision between two hadrons in the event record.
302  bool doLowEnergyProcess(int i1, int i2, int procTypeIn) {
303  if (!isInit) {
304  logger.ERROR_MSG("Pythia is not properly initialized"); return false; }
305  return hadronLevel.doLowEnergyProcess( i1, i2, procTypeIn, event); }
306 
307  // Get total cross section for two hadrons in the event record or standalone.
308  double getSigmaTotal() { return getSigmaTotal(beamSetup.idA, beamSetup.idB,
309  beamSetup.eCM, 0); }
310  double getSigmaTotal(double eCM12, int mixLoHi = 0) {
311  return getSigmaTotal(beamSetup.idA, beamSetup.idB, eCM12, mixLoHi); }
312  double getSigmaTotal(int id1, int id2, double eCM12, int mixLoHi = 0) {
313  return getSigmaTotal(id1, id2, eCM12, particleData.m0(id1),
314  particleData.m0(id2), mixLoHi); }
315  double getSigmaTotal(int id1, int id2, double eCM12, double m1, double m2,
316  int mixLoHi = 0) {
317  if (!isInit) {
318  logger.ERROR_MSG("Pythia is not properly initialized"); return 0.; }
319  return sigmaCmb.sigmaTotal(id1, id2, eCM12, m1, m2, mixLoHi); }
320 
321  // Get partial (elastic, diffractive, nondiffractive, ...) cross sections
322  // for two hadrons in the event record or standalone.
323  double getSigmaPartial(int procTypeIn) {
324  return getSigmaPartial(beamSetup.idA, beamSetup.idB, beamSetup.eCM,
325  procTypeIn, 0); }
326  double getSigmaPartial(double eCM12, int procTypeIn, int mixLoHi = 0) {
327  return getSigmaPartial(beamSetup.idA, beamSetup.idB, eCM12, procTypeIn,
328  mixLoHi); }
329  double getSigmaPartial(int id1, int id2, double eCM12, int procTypeIn,
330  int mixLoHi = 0) { return getSigmaPartial(id1, id2, eCM12,
331  particleData.m0(id1), particleData.m0(id2), procTypeIn, mixLoHi); }
332  double getSigmaPartial(int id1, int id2, double eCM12, double m1,
333  double m2, int procTypeIn, int mixLoHi = 0) {
334  if (!isInit) {
335  logger.ERROR_MSG("Pythia is not properly initialized"); return 0.; }
336  return sigmaCmb.sigmaPartial(id1, id2, eCM12, m1, m2, procTypeIn, mixLoHi);
337  }
338 
339  // Return a parton density set among list of possibilities.
340  PDFPtr getPDFPtr(int idIn, int sequence = 1, string beam = "A",
341  bool resolved = true) {
342  return beamSetup.getPDFPtr( idIn, sequence, beam, resolved); }
343 
344  // List the current Les Houches event.
345  void LHAeventList() { if (lhaUpPtr != 0) lhaUpPtr->listEvent();}
346 
347  // Skip a number of Les Houches events at input.
348  bool LHAeventSkip(int nSkip) {
349  if (lhaUpPtr != 0) return lhaUpPtr->skipEvent(nSkip);
350  return false;}
351 
352  // Main routine to provide final statistics on generation.
353  void stat();
354 
355  // Read in settings values: shorthand, not new functionality.
356  bool flag(string key) {return settings.flag(key);}
357  int mode(string key) {return settings.mode(key);}
358  double parm(string key) {return settings.parm(key);}
359  string word(string key) {return settings.word(key);}
360 
361  // The event record for the parton-level central process.
363 
364  // The event record for the complete event history.
365  Event event = {};
366 
367  // Public information and statistic on the generation.
368  const Info& info = infoPrivate;
369 
370  // Logger: for diagnostic messages, errors, statistics, etc.
372 
373  // Settings: databases of flags/modes/parms/words to control run.
375 
376  // ParticleData: the particle data table/database.
378 
379  // Random number generator.
380  Rndm rndm = {};
381 
382  // Standard Model couplings, including alphaS and alphaEM.
384 
385  // SUSY couplings.
387 
388  // SLHA Interface
390 
391  // The partonic content of each subcollision system (auxiliary to event).
393 
394  // Merging object as wrapper for matrix element merging routines.
395  MergingPtr mergingPtr = {};
396 
397  // Pointer to MergingHooks object for user interaction with the merging.
398  // MergingHooks also more generally steers the matrix element merging.
399  MergingHooksPtr mergingHooksPtr;
400 
401  // Pointer to a HeavyIons object for generating heavy ion collisions
402  HeavyIonsPtr heavyIonsPtr = {};
403 
404  // Pointer to a HIUserHooks object to modify heavy ion modelling.
405  HIUserHooksPtr hiHooksPtr = {};
406 
407  // HadronWidths: the hadron widths data table/database.
409 
410  // The two incoming beams.
411  const BeamParticle& beamA = beamSetup.beamA;
412  const BeamParticle& beamB = beamSetup.beamB;
413 
414 private:
415 
416  // Friend PythiaParallel to give full access to underlying info.
417  friend class PythiaParallel;
418 
419  // The collector of all event generation weights that should eventually
420  // be transferred to the final output.
421  WeightContainer weightContainer = {};
422 
423  // The main keeper/collector of information, accessible from all
424  // PhysicsBase objects. The information is available from the
425  // outside through the public info object.
426  Info infoPrivate = {};
427 
428  // Initialise new Pythia object (called by constructors).
429  void initPtrs();
430 
431  // Initialise user provided plugins.
432  void initPlugins();
433 
434  // Functions to be called at the beginning and end of a next() call.
435  void beginEvent();
436  void endEvent(PhysicsBase::Status status);
437 
438  // Register a PhysicsBase object and give it a pointer to the info object.
439  void registerPhysicsBase(PhysicsBase &pb) {
440  if (find(physicsPtrs.begin(), physicsPtrs.end(), &pb) != physicsPtrs.end())
441  return;
442  pb.initInfoPtr(infoPrivate);
443  physicsPtrs.push_back(&pb);
444  }
445 
446  // If new pointers are set in Info propagate this to all
447  // PhysicsBase objects.
448  void pushInfo();
449 
450  // Constants: could only be changed in the code itself.
451  static const double VERSIONNUMBERHEAD, VERSIONNUMBERCODE;
452  // Maximum number of tries to produce parton level from given input.
453  // Negative integer to denote that no subrun has been set.
454  static const int NTRY = 10;
455 
456  // Initialization data, extracted from database.
457  string xmlPath = {};
458  bool doProcessLevel = {}, doPartonLevel = {}, doHadronLevel = {},
459  doLowEnergy = {}, doSoftQCDall = {}, doSoftQCDinel = {},
460  doCentralDiff = {}, doDiffraction = {}, doSoftQCD = {},
461  doHardDiff = {}, doResDec = {}, doFSRinRes = {}, decayRHadrons = {},
462  doPartonVertex = {}, abortIfVeto = {}, checkEvent = {},
463  checkHistory = {}, doNonPert = {};
464  int nErrList = {};
465  double epTolErr = {}, epTolWarn = {}, mTolErr = {}, mTolWarn = {};
466 
467  // Initialization data, from init(...) call, plus some event-specific.
468  bool isConstructed = {}, isInit = {}, showSaV = {}, showMaD = {},
469  doReconnect = {}, forceHadronLevelCR = {};
470  int nCount = {}, nShowLHA = {}, nShowInfo = {}, nShowProc = {},
471  nShowEvt = {}, reconnectMode = {};
472 
473  // information for error checkout.
474  int nErrEvent = {};
475  vector<int> iErrId = {}, iErrCol = {}, iErrEpm = {}, iErrNan = {},
476  iErrNanVtx = {};
477 
478  // Setup of beams: flavours, kinematics and PDFs.
479  BeamSetup beamSetup = {};
480 
481  // LHAup object for generating external events.
482  bool doLHA = false;
483  bool useNewLHA = false;
484  LHAupPtr lhaUpPtr = {};
485 
486  // Pointer to external decay handler and list of particles it handles.
487  DecayHandlerPtr decayHandlePtr = {};
488  vector<int> handledParticles = {};
489 
490  // Pointer to UserHooks object for user interaction with program.
491  UserHooksPtr userHooksPtr = {};
492  bool doVetoProcess = {}, doVetoPartons = {},
493  retryPartonLevel = {}, canVetoHadronization = {};
494 
495  // Pointer to BeamShape object for beam momentum and interaction vertex.
496  BeamShapePtr beamShapePtr = {};
497  bool doVertexSpread = {};
498  double eMinPert = {}, eWidthPert = {};
499 
500  // Pointers to external processes derived from the Pythia base classes.
501  vector<SigmaProcessPtr> sigmaPtrs = {};
502 
503  // Pointers to external phase-space generators derived from Pythia
504  // base classes.
505  vector<PhaseSpacePtr> phaseSpacePtrs = {};
506 
507  // Pointers to external calculation of resonance widths.
508  vector<ResonanceWidthsPtr> resonancePtrs = {};
509 
510  // Pointers to timelike and spacelike showers, including Vincia and
511  // Dire. Note, the showerModelPtr must be declared before the
512  // individual shower pointers, partonLevel, and hadronLevel. This
513  // ensures shared pointers that belong to showerModelPtr are
514  // unloaded correctly.
515  ShowerModelPtr showerModelPtr = {};
516  TimeShowerPtr timesDecPtr = {};
517  TimeShowerPtr timesPtr = {};
518  SpaceShowerPtr spacePtr = {};
519 
520  // Pointers to fragmentation models.
521  vector<FragmentationModelPtr> fragPtrs = {};
522 
523  // Pointer to assign space-time vertices during parton evolution.
524  PartonVertexPtr partonVertexPtr;
525 
526  // The main generator class to define the core process of the event.
527  ProcessLevel processLevel = {};
528 
529  // The main generator class to produce the parton level of the event.
530  PartonLevel partonLevel = {};
531 
532  // The main generator class to perform trial showers of the event.
533  PartonLevel trialPartonLevel = {};
534 
535  // Flags for defining the merging scheme.
536  bool doMerging = {};
537 
538  // The StringInteractions class.
539  StringIntPtr stringInteractionsPtr;
540 
541  // The Colour reconnection class.
542  ColRecPtr colourReconnectionPtr = {};
543 
544  // The junction splitting class.
545  JunctionSplitting junctionSplitting = {};
546 
547  // The main generator class to produce the hadron level of the event.
548  HadronLevel hadronLevel = {};
549 
550  // The total cross section classes are used both on process and parton level.
551  SigmaTotal sigmaTot = {};
552  SigmaLowEnergy sigmaLowEnergy;
553  NucleonExcitations nucleonExcitations = {};
554  SigmaCombined sigmaCmb = {};
555 
556  // The fragmentation pointer is used in low energy processes and HadronLevel.
557  LundFragmentationPtr fragPtr{};
558 
559  // The RHadrons class is used both at PartonLevel and HadronLevel.
560  RHadronsPtr rHadronsPtr{};
561 
562  // Flags for handling generation of heavy ion collisons.
563  bool hasHeavyIons = {}, doHeavyIons = {};
564 
565  // Write the Pythia banner, with symbol and version information.
566  void banner();
567 
568  // Check that combinations of settings are allowed; change if not.
569  void checkSettings();
570 
571  // Simplified treatment for low-energy nonperturbative collisions.
572  bool nextNonPert(int procTypeIn = 0);
573 
574  // Perform R-hadron decays.
575  bool doRHadronDecays();
576 
577  // Check that the final event makes sense.
578  bool check();
579 
580  // Initialization of SLHA data.
581  bool initSLHA();
582  stringstream particleDataBuffer;
583 
584  // Keep track of and initialize all pointers to PhysicsBase-derived objects.
585  vector<PhysicsBase*> physicsPtrs = {};
586 
587 };
588 
589 //==========================================================================
590 
591 } // end namespace Pythia8
592 
593 #endif // Pythia8_Pythia_H
Event process
The event record for the parton-level central process.
Definition: Pythia.h:362
HeavyIonsPtr getHeavyIonsPtr()
Definition: Pythia.h:252
bool doLowEnergyProcess(int i1, int i2, int procTypeIn)
Do a low-energy collision between two hadrons in the event record.
Definition: Pythia.h:302
bool setRndmEnginePtr(RndmEnginePtr rndmEnginePtrIn)
Possibility to pass in pointer for external random number generation.
Definition: Pythia.h:146
double sigmaPartial(int id1, int id2, double eCM12, double m1, double m2, int type, int mixLoHi=0)
Get partial cross sections.
Definition: SigmaLowEnergy.cc:1563
bool moreDecays(Event &event)
Special routine to allow more decays if on/off switches changed.
Definition: HadronLevel.cc:339
bool setPDFAPtr(PDFPtr pdfAPtrIn)
Routine to pass in pointers to PDF&#39;s. Usage optional.
Definition: BeamSetup.cc:105
LHAupPtr getLHAupPtr()
Possibility to get the pointer to the LHA accessor.
Definition: Pythia.h:261
bool flag(string keyIn)
Give back current value, with check that key exists.
Definition: Settings.cc:1599
Definition: NucleonExcitations.h:23
PDFPtr getPDFPtr(int idIn, int sequence=1, string beam="A", bool resolved=true)
Return a parton density set among list of possibilities.
Definition: Pythia.h:340
Definition: PhysicsBase.h:27
Definition: Info.h:45
bool rndmEnginePtr(RndmEnginePtr rndmEngPtrIn)
Possibility to pass in pointer for external random number generation.
Definition: Basics.cc:27
Definition: BeamSetup.h:33
Rndm rndm
Random number generator.
Definition: Pythia.h:380
bool LHAeventSkip(int nSkip)
Skip a number of Les Houches events at input.
Definition: Pythia.h:348
bool readString(string line, bool warn=true, int subrun=SUBRUNDEFAULT)
Read in one update for a setting or particle data from a single line.
Definition: Pythia.h:98
ParticleData particleData
ParticleData: the particle data table/database.
Definition: Pythia.h:377
The Event class holds all info on the generated event.
Definition: Event.h:408
Definition: BeamParticle.h:133
bool addResonancePtr(ResonanceWidthsPtr resonancePtrIn)
Possibility to add further pointers to allow for multiple resonances.
Definition: Pythia.h:212
Definition: Weights.h:433
Definition: SigmaLowEnergy.h:135
PDFPtr getPDFPtr(int idIn, int sequence=1, string beam="A", bool resolved=true)
Return a parton density set among list of possibilities.
Definition: BeamSetup.cc:1146
bool setResonancePtr(ResonanceWidthsPtr resonancePtrIn)
Possibility to pass in pointer for external resonance.
Definition: Pythia.h:207
Definition: SLHAinterface.h:27
vector< shared_ptr< UserHooks > > hooks
The vector of user hooks.
Definition: UserHooks.h:738
Definition: SigmaTotal.h:141
bool setDecayPtr(DecayHandlerPtr decayHandlePtrIn, vector< int > handledParticlesIn={})
Possibility to pass in pointer for external handling of some decays.
Definition: Pythia.h:140
bool setPhotonFluxPtr(PDFPtr photonFluxAIn, PDFPtr photonFluxBIn)
Set photon fluxes externally. Used with option "PDF:lepton2gammaSet = 2".
Definition: BeamSetup.h:53
Definition: JunctionSplitting.h:30
bool setFragmentationPtr(FragmentationModelPtr fragmentationPtrIn)
Possibility to pass in pointer for external fragmentation model.
Definition: Pythia.h:226
Class for doing Pythia runs in parallel.
Definition: PythiaParallel.h:18
bool checkVersion()
Check consistency of version numbers (called by constructors).
Definition: Pythia.cc:370
Settings settings
Settings: databases of flags/modes/parms/words to control run.
Definition: Pythia.h:374
bool forceRHadronDecays()
Special routine to force R-hadron decay when not done before.
Definition: Pythia.h:299
void initInfoPtr(Info &infoPtrIn)
This function is called from above for physics objects used in a run.
Definition: PhysicsBase.cc:21
Definition: ProcessLevel.h:36
Gets cross sections for hadron-hadron collisions at low energies.
Definition: SigmaLowEnergy.h:22
bool setLHAupPtr(LHAupPtr lhaUpPtrIn)
Possibility to pass in pointer to external LHA-interfaced generator.
Definition: Pythia.h:136
HIUserHooksPtr hiHooksPtr
Pointer to a HIUserHooks object to modify heavy ion modelling.
Definition: Pythia.h:405
bool setKinematics(double eCMIn)
Switch beam kinematics.
Definition: Pythia.cc:1335
Event event
The event record for the complete event history.
Definition: Pythia.h:365
bool init()
Initialize.
Definition: Pythia.cc:402
bool setPDFPtr(PDFPtr pdfAPtrIn, PDFPtr pdfBPtrIn, PDFPtr pdfHardAPtrIn=nullptr, PDFPtr pdfHardBPtrIn=nullptr, PDFPtr pdfPomAPtrIn=nullptr, PDFPtr pdfPomBPtrIn=nullptr, PDFPtr pdfGamAPtrIn=nullptr, PDFPtr pdfGamBPtrIn=nullptr, PDFPtr pdfHardGamAPtrIn=nullptr, PDFPtr pdfHardGamBPtrIn=nullptr, PDFPtr pdfUnresAPtrIn=nullptr, PDFPtr pdfUnresBPtrIn=nullptr, PDFPtr pdfUnresGamAPtrIn=nullptr, PDFPtr pdfUnresGamBPtrIn=nullptr, PDFPtr pdfVMDAPtrIn=nullptr, PDFPtr pdfVMDBPtrIn=nullptr)
Possibility to pass in pointers to PDF&#39;s.
Definition: Pythia.h:114
bool setMergingPtr(MergingPtr mergingPtrIn)
Possibility to pass in pointer for full merging class.
Definition: Pythia.h:172
bool setPDFPtr(PDFPtr pdfAPtrIn, PDFPtr pdfBPtrIn, PDFPtr pdfHardAPtrIn=nullptr, PDFPtr pdfHardBPtrIn=nullptr, PDFPtr pdfPomAPtrIn=nullptr, PDFPtr pdfPomBPtrIn=nullptr, PDFPtr pdfGamAPtrIn=nullptr, PDFPtr pdfGamBPtrIn=nullptr, PDFPtr pdfHardGamAPtrIn=nullptr, PDFPtr pdfHardGamBPtrIn=nullptr, PDFPtr pdfUnresAPtrIn=nullptr, PDFPtr pdfUnresBPtrIn=nullptr, PDFPtr pdfUnresGamAPtrIn=nullptr, PDFPtr pdfUnresGamBPtrIn=nullptr, PDFPtr pdfVMDAPtrIn=nullptr, PDFPtr pdfVMDBPtrIn=nullptr)
Possibility to pass in pointers to PDF&#39;s.
Definition: BeamSetup.cc:21
const BeamParticle & beamA
The two incoming beams.
Definition: Pythia.h:411
~Pythia()
Destructor.
Definition: Pythia.h:88
Definition: Logger.h:23
SLHAinterface slhaInterface
SLHA Interface.
Definition: Pythia.h:389
bool insertResonancePtr(int idx, ResonanceWidthsPtr resonancePtrIn)
Possibility to insert further pointers to allow for multiple resonances.
Definition: Pythia.h:216
bool insertUserHooksPtr(int idx, UserHooksPtr userHooksPtrIn)
Possibility to insert a user hook.
Definition: Pythia.h:164
HeavyIonsPtr heavyIonsPtr
Pointer to a HeavyIons object for generating heavy ion collisions.
Definition: Pythia.h:402
bool readString(string line, bool warn=true, int subrun=SUBRUNDEFAULT)
Read in one update from a single line.
Definition: Settings.cc:384
bool setPartonVertexPtr(PartonVertexPtr partonVertexPtrIn)
Possibility to pass in pointer for setting of parton space-time vertices.
Definition: Pythia.h:264
BeamShapePtr getBeamShapePtr()
Possibility to access the pointer to the BeamShape object.
Definition: Pythia.h:255
CoupSUSY coupSUSY
SUSY couplings.
Definition: Pythia.h:386
bool readFile(string fileName, bool warn=true, int subrun=SUBRUNDEFAULT)
Read in updates from a user-defined file.
Definition: Settings.cc:696
bool addFragmentationPtr(FragmentationModelPtr fragmentationPtrIn)
Possibility to allow for multiple external fragmentation models.
Definition: Pythia.h:231
bool setBeamIDs(int idAin, int idBin=0)
Switch to new beam particle identities; for similar hadrons only.
Definition: Pythia.cc:1313
CoupSM coupSM
Standard Model couplings, including alphaS and alphaEM.
Definition: Pythia.h:383
BeamParticle beamA
The two incoming beams.
Definition: BeamSetup.h:131
Definition: HadronLevel.h:44
Definition: Basics.h:388
PartonSystems partonSystems
The partonic content of each subcollision system (auxiliary to event).
Definition: Pythia.h:392
bool moreDecays()
Special routine to allow more decays if on/off switches changed.
Definition: Pythia.h:295
ShowerModelPtr getShowerModelPtr()
Possibility to get the pointer to the parton-shower model.
Definition: Pythia.h:258
bool insertFragmentationPtr(int idx, FragmentationModelPtr fragmentationPtrIn)
Possibility to insert external fragmentation model, in specific position.
Definition: Pythia.h:235
bool setBeamShapePtr(BeamShapePtr beamShapePtrIn)
Possibility to pass in pointer for beam shape.
Definition: Pythia.h:180
Definition: PartonLevel.h:45
Status
Enumerate the different status codes the event generation can have.
Definition: PhysicsBase.h:32
Definition: HadronWidths.h:22
bool setMergingHooksPtr(MergingHooksPtr mergingHooksPtrIn)
Possibility to pass in pointer for merging hooks.
Definition: Pythia.h:176
MergingHooksPtr mergingHooksPtr
Definition: Pythia.h:399
void stat()
Main routine to provide final statistics on generation.
Definition: Pythia.cc:1663
bool doLowEnergyProcess(int i1, int i2, int procTypeIn, Event &event)
Special routine to do a low-energy hadron-hadron scattering.
Definition: HadronLevel.h:81
bool addSigmaPtr(SigmaProcessPtr sigmaPtrIn, PhaseSpacePtr phaseSpacePtrIn=nullptr)
Possibility to add further pointers to allow for multiple cross sections.
Definition: Pythia.h:192
bool setHeavyIonsPtr(HeavyIonsPtr heavyIonsPtrIn)
Possibility to pass in pointer for modelling of heavy ion collisions.
Definition: Pythia.h:242
bool setLHAupPtr(LHAupPtr lhaUpPtrIn)
Possibility to pass in pointer to external LHA-interfaced generator.
Definition: BeamSetup.h:59
Definition: StandardModel.h:135
bool forceHadronLevel(bool findJunctions=true)
Generate only the hadronization/decay stage.
Definition: Pythia.cc:1452
bool readFile(string fileName, bool warn=true, int subrun=SUBRUNDEFAULT)
Read in updates for settings or particle data from user-defined file.
Definition: Pythia.h:102
HadronWidths hadronWidths
HadronWidths: the hadron widths data table/database.
Definition: Pythia.h:408
double getSigmaTotal()
Get total cross section for two hadrons in the event record or standalone.
Definition: Pythia.h:308
double m2(const Vec4 &v1)
The squared invariant mass of one or more four-vectors.
Definition: Basics.cc:598
bool setUserHooksPtr(UserHooksPtr userHooksPtrIn)
Possibility to pass in pointer for user hooks.
Definition: Pythia.h:150
bool setPDFBPtr(PDFPtr pdfBPtrIn)
Routine to pass in pointers to PDF&#39;s. Usage optional.
Definition: BeamSetup.cc:129
bool addUserHooksPtr(UserHooksPtr userHooksPtrIn)
Possibility to add further pointers to allow multiple user hooks.
Definition: Pythia.h:154
bool setShowerModelPtr(ShowerModelPtr showerModelPtrIn)
Possibility to pass in pointer for external showers.
Definition: Pythia.h:222
The PartonSystems class describes the whole set of subcollisions.
Definition: PartonSystems.h:42
Header for classes to set beam momentum and interaction vertex spread.
Definition: Analysis.h:20
The Pythia class contains the top-level routines to generate an event.
Definition: Pythia.h:71
double getSigmaPartial(int procTypeIn)
Definition: Pythia.h:323
UserHooksVector implements a vector of UserHooks and is itself a UserHooks.
Definition: UserHooks.h:313
const Info & info
Public information and statistic on the generation.
Definition: Pythia.h:368
Pythia(string xmlDir="../share/Pythia8/xmldoc", bool printBanner=true)
Constructor. (See Pythia.cc file.)
Definition: Pythia.cc:33
bool next()
Generate the next event.
Definition: Pythia.h:271
BeamShapePtr getBeamShapePtr()
Possibility to access the pointer to the BeamShape object.
Definition: BeamSetup.h:81
double sigmaTotal(int id1, int id2, double eCM12, double m1, double m2, int mixLoHi=0)
Get total cross section.
Definition: SigmaLowEnergy.cc:1526
bool setPhotonFluxPtr(PDFPtr photonFluxAIn, PDFPtr photonFluxBIn)
Set photon fluxes externally. Used with option "PDF:lepton2gammaSet = 2".
Definition: Pythia.h:132
int forceTimeShower(int iBeg, int iEnd, double pTmax, int nBranchMax=0)
Generate only a single timelike shower as in a decay.
Definition: Pythia.h:285
bool insertSigmaPtr(int idx, SigmaProcessPtr sigmaPtrIn, PhaseSpacePtr phaseSpacePtrIn=nullptr)
Definition: Pythia.h:199
void LHAeventList()
List the current Les Houches event.
Definition: Pythia.h:345
MergingPtr mergingPtr
Merging object as wrapper for matrix element merging routines.
Definition: Pythia.h:395
This class holds a map of all ParticleDataEntries.
Definition: ParticleData.h:422
bool setSigmaPtr(SigmaProcessPtr sigmaPtrIn, PhaseSpacePtr phaseSpacePtrIn=nullptr)
Definition: Pythia.h:185
bool decay(int iDec, Event &event)
Try to decay the specified particle. Returns false if decay failed.
Definition: HadronLevel.h:66
Logger logger
Logger: for diagnostic messages, errors, statistics, etc.
Definition: Pythia.h:371
bool flag(string key)
Read in settings values: shorthand, not new functionality.
Definition: Pythia.h:356
bool setBeamShapePtr(BeamShapePtr beamShapePtrIn)
Possibility to pass in pointer for beam shape.
Definition: BeamSetup.h:77
Definition: Basics.h:32
bool setHIHooks(HIUserHooksPtr hiHooksPtrIn)
Definition: Pythia.h:247
Definition: SusyCouplings.h:27
Definition: Settings.h:196
void clear()
Reset system list to empty.
Definition: PartonSystems.h:50