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