PYTHIA  8.312
SplittingsOnia.h
1 // SplittingsOnia.h is a part of the PYTHIA event generator.
2 // Copyright (C) 2024 Naomi Cooke, Philip Ilten, Leif Lonnblad, Steve Mrenna,
3 // Torbjorn Sjostrand.
4 // PYTHIA is licenced under the GNU GPL v2 or later, see COPYING for details.
5 // Please respect the MCnet Guidelines, see GUIDELINES for details.
6 
7 // Header file for fragmentation functions for onia showers.
8 
9 #ifndef Pythia8_SplittingsOnia_H
10 #define Pythia8_SplittingsOnia_H
11 
12 #include "Pythia8/Basics.h"
13 #include "Pythia8/PythiaStdlib.h"
14 #include "Pythia8/SigmaOnia.h"
15 #include "Pythia8/SimpleTimeShower.h"
16 
17 namespace Pythia8 {
18 
19 //==========================================================================
20 
21 // A helper class used to set up the onia splittings. This class
22 // derives from OniaSetup, where a shared implementation for similar
23 // configuration between SigmaOniaSetup and this class is
24 // implemented. This class extends the OniaSetup class for additional
25 // configuration that is not shared between SigmaOniaSetup and
26 // SplittingsOniaSetup.
27 
28 class SplitOniaSetup : public OniaSetup {
29 
30 public:
31 
32  // Constructor.
33  SplitOniaSetup(Info* infoPtrIn, AlphaStrong* alphaSPtrIn, int flavourIn);
34 
35  // Initialise the splittings.
36  void setup(vector<SplitOniaPtr> &splits, set<double> &thresholds,
37  bool oniaIn = false);
38 
39  // Flag if only octet -> X splittings enabled.
40  bool onlyOctet{false};
41 
42  private:
43 
44  // Additional stored validity and production flags
45  // not inherited from OniaSetup.
46  bool onia1S0{true}, valid1S0{true};
47 
48  // Additional stored pointers. Note, alpha_s cannot be taken from the Info
49  // CoupSM pointer since this is not the TimeShower alpha_s.
50  AlphaStrong* alphaSPtr{};
51 
52  // Stored vectors of settings.
53  vector<int> states1S0, spins1S0;
54  vector<string> meNames1S0;
55  vector< vector<double> > mes1S0;
56  vector<string> splitNames1S0, splitNames3S1, splitNames3PJ;
57  vector< vector<bool> > splits1S0, splits3S1, splits3PJ;
58 
59 };
60 
61 //===========================================================================
62 
63 // The SplitOnia encodes the generation of a particular
64 // emission of an onium state from a parton in a dipole.
65 //
66 // The basic generation in the shower assumes a function of the form
67 // dP(pT2, z) = alphaS/2pi dpT2/pT2 dz F(pT2, z)
68 // in an A -> B + C splitting, where B takes a fraction z of the
69 // momentum of A.
70 //
71 // A subclass of this base clase should encode not only the
72 // function F(pT2, z), but also an overestimate and the z-integral
73 // of this overestimate:
74 //
75 // G(pT2, z) >= F(pT2, z) and OIZ = \int_0^1 G(pT2, z) dz
76 //
77 // The ratio F/G for a generated point should then be used as a weight
78 // for the phase space point generated. The subclass should also be
79 // able to generate the z according to the overestimate and possible
80 // other internal variables that have been integrated out.
81 
82 class SplitOnia {
83 
84 public:
85 
86  // Constructor that needs to be called by the subclass.
87  SplitOnia(int idAIn, int idBIn, int idCIn, double ldmeIn, Info* infoPtrIn,
88  AlphaStrong* alphaSPtrIn) :
89  idA(idAIn), idB(idBIn), idC(idCIn),
90  mA(infoPtrIn->particleDataPtr->m0(idAIn)),
91  mB(infoPtrIn->particleDataPtr->m0(idBIn)),
92  mC(infoPtrIn->particleDataPtr->m0(idCIn)),
93  m2A(pow2(mA)), m2B(pow2(mB)), m2C(pow2(mC)), ldme(ldmeIn),
94  alphaMode(infoPtrIn->settingsPtr->mode("OniaShower:alphaScale")),
95  loggerPtr(infoPtrIn->loggerPtr), alphaSPtr(alphaSPtrIn),
96  rndmPtr(infoPtrIn->rndmPtr) {}
97 
98  // Virtual destructor.
99  virtual ~SplitOnia() = default;
100 
101  // Calculate the splitting overestimate.
102  virtual double overestimate(const TimeDipoleEnd &dip, double pT2Min,
103  bool enh);
104 
105  // Return the weight of the splitting function and Jacobian at the
106  // generated point divided by the overestimate.
107  virtual double weight(const TimeDipoleEnd &dip) const = 0;
108 
109  // Generate internal degrees of freedom (in particluar z).
110  // Default behaviour is to generate z from a flat distribution.
111  virtual double generateZ(const TimeDipoleEnd &) {
112  zGen = zMin + rndmPtr->flat()*(zMax - zMin); return zGen;}
113 
114  // Check if this emission is available for the current dipole end
115  // with the given ID of the radiator.
116  bool isActive(const TimeDipoleEnd &dip, int id, double m) {
117  if (idA == 99 && dip.oniumType == 2) {
118  idB = id; mA = mB = m; m2A = m2B = pow2(mA);}
119  return ldme > 0 && (abs(id) == idA || (idA == 99 && dip.oniumType == 2))
120  && dip.mDip > dip.mRec + mB + mC;}
121 
122  // Check if the emission is a colour octet state.
123  bool isOctet() {return idC == 0;}
124 
125  // Check if the emission is enhanced.
126  bool isEnhanced() {return enhance != 1;}
127 
128  // Set the enhancement factor.
129  void setEnhance(const unordered_map<string, double> &enhanceFSRs) {
130  enhance = 1;
131  auto enhanceFSR = enhanceFSRs.find(enhanceName());
132  if ( enhanceFSR != enhanceFSRs.end() && enhanceFSR->second > enhance )
133  enhance = enhanceFSR->second;}
134 
135  // Return the enhancement weight.
136  double enhanceWeight() {return enhance;}
137 
138  // Return the name to be used if this emission is enhanced.
139  virtual string enhanceName() const {return "";}
140 
141  // Possibility to add more than one emitted particle.
142  virtual vector<int> addEmitted(Event &, int, int, int, int,
143  vector<TimeDipoleEnd> &) {return {};}
144 
145  // Update the dipole end with the generated values.
146  virtual void updateDipole(TimeDipoleEnd &dip) {
147  dip.z = zGen; dip.flavour = idC; dip.mFlavour = mC;
148  dip.m2A = m2A; dip.m2B = m2B; dip.m2C = m2C;
149  dip.m2 = dip.m2Rad + dip.pT2 / (dip.z * (1. - dip.z));
150  }
151 
152  // Update the passed branching variables with the internal values.
153  bool updateBranchVars(const TimeDipoleEnd* dip, Event& event,
154  int &idRadIn, int &idEmtIn, int &colRadIn, int &acolRadIn, int &colEmtIn,
155  int &acolEmtIn, int &appendEmtIn, double &pTorigIn, double &pTcorrIn,
156  double &pzRadPlusEmtIn, double &pzRadIn, double &pzEmtIn,
157  double &mRadIn, double &m2RadIn, double &mEmtIn);
158 
159 protected:
160 
161  // Update the internal kinematics.
162  virtual bool kinematics(const TimeDipoleEnd* dip, Event &event);
163 
164  // Set the z limits and return the difference.
165  virtual void overestimate(const TimeDipoleEnd &, double) {}
166 
167  // Integrate the distribution used to generate z.
168  // Default behaviour is to integrate a flat distribution.
169  virtual double integrateZ() const {return zMax - zMin;}
170 
171  // Set the colour octet ID and ensure in particle database.
172  void setOctetID(int state, double mSplit, Info* infoPtr);
173 
174  // The ID and mass (squared) of the radiating particle (A), the
175  // scattered radiated particle (B, taking a fraction z of A's
176  // momentum), and the emitted particle (C).
177  int idA, idB, idC;
178  double mA, mB, mC, m2A, m2B, m2C;
179 
180  // Enhancement, max value of alpha_S, and long-distance matrix element.
181  double enhance{1}, ldme{-1};
182 
183  // The constant and variable overestimate prefactors.
184  double cFac{0}, oFac{0};
185 
186  // The z limits used in the overestimated z-integral and generated z value.
187  double zMin{0}, zMax{1}, zGen{0};
188 
189  // IDs, colors, and number of emitters to append.
190  int idRad{0}, idEmt{0}, colRad{0}, acolRad{0}, colEmt{0}, acolEmt{0},
191  appendEmt{1};
192 
193  // Transverse and longitudinal momentum, and masses.
194  double pTorig{0}, pTcorr{0}, pzRadPlusEmt{0}, pzRad{0}, pzEmt{0}, mRad{0},
195  m2Rad{0}, mEmt{0};
196 
197  // Mode to evaluate the final alpha_s scale.
198  int alphaMode{1};
199 
200  // Return alpha_s at the requested scale.
201  double alphaScale(double m2, double pT2, double s) const {
202  if (alphaMode == 0) return alphaSPtr->alphaS(m2);
203  else if (alphaMode == 2) return alphaSPtr->alphaS(s);
204  else return alphaSPtr->alphaS(pT2);
205  }
206 
207  // Logger pointer.
208  Logger* loggerPtr{};
209 
210  // The alphaS object in current use.
211  AlphaStrong* alphaSPtr{};
212 
213  // The random number generator in current use.
214  Rndm* rndmPtr{};
215 
216 };
217 
218 //==========================================================================
219 
220 // Splitting class for Q -> QQbar[1S0(1)] Q (Q = c or b).
221 // The splitting function is taken from equation 19 of Bra93a.
222 
224 
225 public:
226 
227  // Constructor.
228  Split2Q2QQbar1S01Q(int flavourIn, int stateIn, double ldmeIn,
229  Info *infoPtrIn, AlphaStrong* alphaSPtrIn) : SplitOnia(flavourIn,
230  flavourIn, stateIn, ldmeIn, infoPtrIn, alphaSPtrIn) {}
231 
232  // Return the splitting weight.
233  double weight(const TimeDipoleEnd &dip) const override;
234 
235  // Return ehancement names.
236  string enhanceName() const override {return "fsr:Q2OX";}
237 
238 private:
239 
240  // Return the splitting overestimate.
241  void overestimate(const TimeDipoleEnd &dip, double pT2Min) override;
242 
243 };
244 
245 //==========================================================================
246 
247 // Splitting class for g -> QQbar[1S0(1)] g (Q = c or b).
248 // The splitting function is taken from equation 6 of Bra93.
249 
251 
252 public:
253 
254  // Constructor.
255  Split2g2QQbar1S01g(int stateIn, double ldmeIn, Info *infoPtrIn,
256  AlphaStrong* alphaSPtrIn) : SplitOnia(21, 21, stateIn, ldmeIn, infoPtrIn,
257  alphaSPtrIn) {}
258 
259  // Return the splitting weight.
260  double weight(const TimeDipoleEnd &dip) const override;
261 
262  // Return the enhancement names.
263  string enhanceName() const override {return "fsr:G2OX";}
264 
265 private:
266 
267  // Return the splitting overestimate.
268  void overestimate(const TimeDipoleEnd &dip, double pT2Min) override;
269 
270 };
271 
272 //==========================================================================
273 
274 // Splitting class for Q -> QQbar[3S1(1)] Q (Q = c or b).
275 // The splitting function is taken from equations 14 and 15 of Bra93a.
276 
278 
279 public:
280 
281  // Constructor.
282  Split2Q2QQbar3S11Q(int flavourIn, int stateIn, double ldmeIn,
283  Info *infoPtrIn, AlphaStrong* alphaSPtrIn) : SplitOnia(flavourIn,
284  flavourIn, stateIn, ldmeIn, infoPtrIn, alphaSPtrIn) {}
285 
286  // Return the splitting weight.
287  double weight(const TimeDipoleEnd &dip) const override;
288 
289  // Return enhancement names.
290  string enhanceName() const override {return "fsr:Q2OX";}
291 
292 private:
293 
294  // Return the splitting overestimate.
295  void overestimate(const TimeDipoleEnd &dip, double pT2Min) override;
296 
297 };
298 
299 //==========================================================================
300 
301 // Splitting class for g -> QQbar[3S1(1)] g g (Q = c or b).
302 // The splitting function is taken from equations 3 and 8 of Bra95.
303 
305 
306 public:
307 
308  // Constructor.
309  Split2g2QQbar3S11gg(int stateIn, double ldmeIn, Info *infoPtrIn,
310  AlphaStrong* alphaSPtrIn) : SplitOnia(21, 21, stateIn, ldmeIn,
311  infoPtrIn, alphaSPtrIn) {}
312 
313  // Generate a 1/(z(1-z)) distribution.
314  double generateZ(const TimeDipoleEnd &) override {
315  double u(rndmPtr->flat());
316  zGen = u < 0.5 ? zMin*pow(zMax/zMin, 2*u):
317  1 - (1 - zMax)*pow((1 - zMin)/(1 - zMax), 2*u - 1);
318  ygg = pow(rndmPtr->flat(), 1.0/(1.0 - pg))*zGen;
319  return zGen;
320  }
321 
322  // Return the splitting weight.
323  double weight(const TimeDipoleEnd &dip) const override;
324 
325  // Update the dipole end with the generated values.
326  void updateDipole(TimeDipoleEnd &dip) override {
327  SplitOnia::updateDipole(dip); dip.m2gg = ygg*dip.pT2/(zGen*(1 - zGen));}
328 
329  // Update the internal kinematics.
330  bool kinematics(const TimeDipoleEnd* dip, Event &event) override;
331 
332  // Possibility to add more than one emitted particle, here an extra gluon.
333  vector<int> addEmitted(Event &, int, int, int, int,
334  vector<TimeDipoleEnd> &) override;
335 
336  // Return the enhancement names.
337  string enhanceName() const override {return "fsr:G2OX";}
338 
339 private:
340 
341  // Return the splitting overestimate.
342  void overestimate(const TimeDipoleEnd &dip, double pT2Min) override;
343 
344  // Integrate a 1/(z(1-z)) distribution.
345  double integrateZ() const override {
346  return log(zMax/zMin) + log((1 - zMin)/(1 - zMax));}
347 
348  // Additional kinematic variables.
349  double ygg{0}, pg{0.5};
350 
351 };
352 
353 //==========================================================================
354 
355 // Splitting class for Q -> QQbar[1P1(1)] Q (Q = c or b).
356 // The splitting function is taken from equations 16 - 21 of Yua94.
357 
359 
360 public:
361 
362  // Constructor.
363  Split2Q2QQbar1P11Q(int flavourIn, int stateIn, double ldmeIn,
364  Info *infoPtrIn, AlphaStrong* alphaSPtrIn) : SplitOnia(flavourIn,
365  flavourIn, stateIn, ldmeIn, infoPtrIn, alphaSPtrIn) {}
366 
367  // Return the splitting weight.
368  double weight(const TimeDipoleEnd &dip) const override;
369 
370  // Return the enhancement names.
371  string enhanceName() const override {return "fsr:Q2OX";}
372 
373 private:
374 
375  // Return the splitting overestimate.
376  void overestimate(const TimeDipoleEnd &dip, double pT2Min) override;
377 
378  // Defined as r = mQ/(mQ + mQ') and b = 1 - r, see Yua93 equation 7.
379  double r{0.5}, b{0.5};
380 
381 };
382 
383 //==========================================================================
384 
385 // Splitting class for Q -> QQbar[3PJ(1)] Q (Q = c or b).
386 // The splitting function is taken from equations 16, 23 - 27, 98,
387 // and 99 of Yua94.
388 
390 
391 public:
392 
393  // Constructor.
394  Split2Q2QQbar3PJ1Q(int flavourIn, int stateIn, double ldmeIn, int spinIn,
395  Info *infoPtrIn, AlphaStrong* alphaSPtrIn) : SplitOnia(flavourIn,
396  flavourIn, stateIn, ldmeIn, infoPtrIn, alphaSPtrIn), spin(spinIn) {}
397 
398  // Return the splitting weight.
399  double weight(const TimeDipoleEnd &dip) const override;
400 
401  // Return the enhancement names.
402  string enhanceName() const override {return "fsr:Q2OX";}
403 
404 private:
405 
406  // Return the splitting overestimate.
407  void overestimate(const TimeDipoleEnd &dip, double pT2Min) override;
408 
409  // Total angular momentum.
410  int spin;
411 
412  // Defined as r = mQ/(mQ + mQ') and b = 1 - r, see Yua93 equation 7.
413  double r{0.5}, b{0.5};
414 
415 };
416 
417 //==========================================================================
418 
419 // Splitting class for g -> QQbar[3PJ(1)] g (Q = c or b).
420 // The splitting function is taken from equations 8 - 12 of Bra94.
421 
423 
424 public:
425 
426  // Constructor.
427  Split2g2QQbar3PJ1g(int stateIn, double ldmeIn, int spinIn,
428  Info *infoPtrIn, AlphaStrong* alphaSPtrIn, set<double> &thresholds) :
429  SplitOnia(21, 21, stateIn, ldmeIn, infoPtrIn, alphaSPtrIn), spin(spinIn) {
430  thresholds.insert({0.26*m2C, 3*m2C});
431  }
432 
433  // Return the splitting weight.
434  double weight(const TimeDipoleEnd &dip) const override;
435 
436  // Return the enhancement names.
437  string enhanceName() const override {return "fsr:G2OX";}
438 
439 private:
440 
441  // Return the splitting overestimate.
442  void overestimate(const TimeDipoleEnd &dip, double pT2Min) override;
443 
444  // Total angular momentum.
445  int spin;
446 
447 };
448 
449 //==========================================================================
450 
451 // Splitting class for Q -> QQbar[3PJ(8)] Q (Q = c or b).
452 // The splitting function is taken from equations 54, 55, and 59 - 61 of
453 // Yua94.
454 
456 
457 public:
458 
459  // Constructor.
460  Split2Q2QQbar3PJ8Q(int flavourIn, int stateIn, double ldmeIn, int spinIn,
461  double mSplitIn, Info *infoPtrIn, AlphaStrong* alphaSPtrIn) : SplitOnia(
462  flavourIn, flavourIn, stateIn, ldmeIn, infoPtrIn, alphaSPtrIn),
463  spin(spinIn) {setOctetID(0, mSplitIn, infoPtrIn);}
464 
465  // Return the splitting weight.
466  double weight(const TimeDipoleEnd &dip) const override;
467 
468  // Return the enhancement names.
469  string enhanceName() const override {return "fsr:Q2OX";}
470 
471 private:
472 
473  // Return the splitting overestimate.
474  void overestimate(const TimeDipoleEnd &dip, double pT2Min) override;
475 
476  // Total angular momentum.
477  int spin;
478 
479  // Defined as r = mQ/(mQ + mQ') and b = 1 - r, see Yua93 equation 7.
480  double r{0.5}, b{0.5};
481 
482 };
483 
484 //==========================================================================
485 
486 // Splitting class for g -> QQbar[X(8)] (Q = c or b).
487 
488 class Split2g2QQbarX8: public SplitOnia {
489 
490 public:
491 
492  // Constructor.
493  Split2g2QQbarX8(int stateIn, double ldmeIn, int spinIn, double mSplitIn,
494  Info *infoPtrIn, AlphaStrong* alphaSPtrIn, set<double> &thresholds) :
495  SplitOnia(21, stateIn, 0, ldmeIn, infoPtrIn, alphaSPtrIn), spin(spinIn) {
496  setOctetID(0, mSplitIn, infoPtrIn);
497  if (ldme > 0) thresholds.insert({m2B, m2B*(1.0 + delta)});}
498 
499  // Return the splitting overestimate.
500  double overestimate(const TimeDipoleEnd &dip, double pT2Min,
501  bool enh) override;
502 
503  // Return the splitting weight.
504  double weight(const TimeDipoleEnd &dip) const override {
505  return (dip.pT2 > m2B*(1.0 + delta) || dip.pT2 < m2B) ? 0 : 1;}
506 
507  // Update the internal branching variables.
508  void updateDipole(TimeDipoleEnd &dip) override {
509  dip.z = zGen; dip.flavour = idB; dip.mFlavour = mB;}
510 
511  // Return the enhancement names.
512  string enhanceName() const override {return "fsr:G2OX";}
513 
514 private:
515 
516  // Update the internal kinematics.
517  bool kinematics(const TimeDipoleEnd* dip, Event &event) override;
518 
519  // Total angular momentum and delta function width.
520  int spin{0};
521  double delta{0.01};
522 
523 };
524 
525 //==========================================================================
526 
527 // Splitting class for QQbar[X(8)] -> QQbar[X(8)] + g (Q = c or b),
528 // treating the colour octet as a quark.
529 
531 
532 public:
533 
534  // Constructor.
535  Split2QQbarXq82QQbarX8g(double colFacIn, Info *infoPtrIn,
536  AlphaStrong* alphaSPtrIn) : SplitOnia(99, 99, 21, colFacIn, infoPtrIn,
537  alphaSPtrIn) {};
538 
539  // Generate a 1/(1 - z) distribution.
540  double generateZ(const TimeDipoleEnd &) override {
541  zGen = 1 - (1 - zMax)*pow((1 - zMin)/(1 - zMax), rndmPtr->flat());
542  return zGen;}
543 
544  // Return the splitting weight.
545  double weight(const TimeDipoleEnd &dip) const override;
546 
547  // Return the enhancement names.
548  string enhanceName() const override {return "fsr:O2OX";}
549 
550 private:
551 
552  // Return the splitting overestimate.
553  void overestimate(const TimeDipoleEnd &dip, double pT2Min) override;
554 
555  // Update the internal kinematics.
556  bool kinematics(const TimeDipoleEnd* dip, Event &event) override;
557 
558  // Integrate a 1/(1 - z) distribution.
559  double integrateZ() const override {
560  return log((1 - zMin)/(1 - zMax));}
561 
562 };
563 
564 //==========================================================================
565 
566 // Splitting class for QQbar[X(8)] -> QQbar[X(8)] + g (Q = c or b),
567 // treating the colour octet as a heavy gluon.
568 
570 
571 public:
572 
573  // Constructor.
574  Split2QQbarXg82QQbarX8g(double colFacIn, Info *infoPtrIn,
575  AlphaStrong* alphaSPtrIn) : Split2QQbarXq82QQbarX8g(colFacIn, infoPtrIn,
576  alphaSPtrIn) {};
577 
578  // Generate a 1/(z*(1 - z)) distribution.
579  double generateZ(const TimeDipoleEnd &) override {
580  double u = rndmPtr->flat();
581  zGen = u < 0.5 ? zMin*pow(zMax/zMin, 2*u) :
582  1 - (1 - zMax)*pow((1 - zMin)/(1 - zMax), 2*u - 1);
583  return zGen;}
584 
585  // Return the splitting weight.
586  double weight(const TimeDipoleEnd &dip) const override;
587 
588  // Return the enhancement names.
589  string enhanceName() const override {return "fsr:O2OX";}
590 
591 private:
592 
593  // Return the splitting overestimate.
594  void overestimate(const TimeDipoleEnd &dip, double pT2Min) override;
595 
596  // Integrate a 1/(z*(1 - z)) distribution.
597  double integrateZ() const override {
598  return log(zMax/zMin) + log((1 - zMin)/(1 - zMax));}
599 
600 };
601 
602 //==========================================================================
603 
604 } // end namespace Pythia8
605 
606 #endif // Pythia8_SplittingsOnia_H
Definition: SplittingsOnia.h:250
void setup(vector< SplitOniaPtr > &splits, set< double > &thresholds, bool oniaIn=false)
Initialise the splittings.
Definition: SplittingsOnia.cc:69
constexpr double pow2(const double &x)
Powers of small integers - for balance speed/code clarity.
Definition: PythiaStdlib.h:182
string enhanceName() const override
Return the enhancement names.
Definition: SplittingsOnia.h:263
Definition: SplittingsOnia.h:82
void setEnhance(const unordered_map< string, double > &enhanceFSRs)
Set the enhancement factor.
Definition: SplittingsOnia.h:129
string enhanceName() const override
Return the enhancement names.
Definition: SplittingsOnia.h:437
Definition: StandardModel.h:23
string enhanceName() const override
Return the enhancement names.
Definition: SplittingsOnia.h:512
Split2Q2QQbar3PJ1Q(int flavourIn, int stateIn, double ldmeIn, int spinIn, Info *infoPtrIn, AlphaStrong *alphaSPtrIn)
Constructor.
Definition: SplittingsOnia.h:394
Definition: Info.h:45
The Event class holds all info on the generated event.
Definition: Event.h:453
string enhanceName() const override
Return the enhancement names.
Definition: SplittingsOnia.h:337
Definition: SplittingsOnia.h:223
double mSplit
Stored parameters.
Definition: SigmaOnia.h:55
void updateDipole(TimeDipoleEnd &dip) override
Update the internal branching variables.
Definition: SplittingsOnia.h:508
int flavour
Properties specific to current trial emission.
Definition: SimpleTimeShower.h:68
Definition: SplittingsOnia.h:358
Definition: SplittingsOnia.h:422
virtual void overestimate(const TimeDipoleEnd &, double)
Set the z limits and return the difference.
Definition: SplittingsOnia.h:165
Split2g2QQbar3PJ1g(int stateIn, double ldmeIn, int spinIn, Info *infoPtrIn, AlphaStrong *alphaSPtrIn, set< double > &thresholds)
Constructor.
Definition: SplittingsOnia.h:427
double generateZ(const TimeDipoleEnd &) override
Generate a 1/(z(1-z)) distribution.
Definition: SplittingsOnia.h:314
virtual void updateDipole(TimeDipoleEnd &dip)
Update the dipole end with the generated values.
Definition: SplittingsOnia.h:146
Definition: SplittingsOnia.h:530
Definition: SplittingsOnia.h:277
Definition: Logger.h:23
Definition: SigmaOnia.h:21
Definition: SplittingsOnia.h:389
string enhanceName() const override
Return the enhancement names.
Definition: SplittingsOnia.h:589
string enhanceName() const override
Return the enhancement names.
Definition: SplittingsOnia.h:548
Definition: Basics.h:386
bool isActive(const TimeDipoleEnd &dip, int id, double m)
Definition: SplittingsOnia.h:116
Split2Q2QQbar3S11Q(int flavourIn, int stateIn, double ldmeIn, Info *infoPtrIn, AlphaStrong *alphaSPtrIn)
Constructor.
Definition: SplittingsOnia.h:282
Split2QQbarXg82QQbarX8g(double colFacIn, Info *infoPtrIn, AlphaStrong *alphaSPtrIn)
Constructor.
Definition: SplittingsOnia.h:574
double alphaScale(double m2, double pT2, double s) const
Return alpha_s at the requested scale.
Definition: SplittingsOnia.h:201
Info * infoPtr
Stored pointers.
Definition: SigmaOnia.h:38
int idA
Definition: SplittingsOnia.h:177
Split2Q2QQbar1S01Q(int flavourIn, int stateIn, double ldmeIn, Info *infoPtrIn, AlphaStrong *alphaSPtrIn)
Constructor.
Definition: SplittingsOnia.h:228
bool isEnhanced()
Check if the emission is enhanced.
Definition: SplittingsOnia.h:126
Split2g2QQbarX8(int stateIn, double ldmeIn, int spinIn, double mSplitIn, Info *infoPtrIn, AlphaStrong *alphaSPtrIn, set< double > &thresholds)
Constructor.
Definition: SplittingsOnia.h:493
double weight(const TimeDipoleEnd &dip) const override
Return the splitting weight.
Definition: SplittingsOnia.h:504
string enhanceName() const override
Return ehancement names.
Definition: SplittingsOnia.h:236
Definition: SplittingsOnia.h:455
Definition: SplittingsOnia.h:304
string enhanceName() const override
Return enhancement names.
Definition: SplittingsOnia.h:290
void updateDipole(TimeDipoleEnd &dip) override
Update the dipole end with the generated values.
Definition: SplittingsOnia.h:326
string enhanceName() const override
Return the enhancement names.
Definition: SplittingsOnia.h:402
Data on radiating dipole ends; only used inside SimpleTimeShower class.
Definition: SimpleTimeShower.h:25
Definition: SplittingsOnia.h:28
bool isOctet()
Check if the emission is a colour octet state.
Definition: SplittingsOnia.h:123
SplitOniaSetup(Info *infoPtrIn, AlphaStrong *alphaSPtrIn, int flavourIn)
Constructor.
Definition: SplittingsOnia.cc:23
Split2Q2QQbar1P11Q(int flavourIn, int stateIn, double ldmeIn, Info *infoPtrIn, AlphaStrong *alphaSPtrIn)
Constructor.
Definition: SplittingsOnia.h:363
virtual vector< int > addEmitted(Event &, int, int, int, int, vector< TimeDipoleEnd > &)
Possibility to add more than one emitted particle.
Definition: SplittingsOnia.h:142
double enhanceWeight()
Return the enhancement weight.
Definition: SplittingsOnia.h:136
double m2(const Vec4 &v1)
The squared invariant mass of one or more four-vectors.
Definition: Basics.cc:605
double generateZ(const TimeDipoleEnd &) override
Generate a 1/(z*(1 - z)) distribution.
Definition: SplittingsOnia.h:579
double generateZ(const TimeDipoleEnd &) override
Generate a 1/(1 - z) distribution.
Definition: SplittingsOnia.h:540
virtual double integrateZ() const
Definition: SplittingsOnia.h:169
Header for classes to set beam momentum and interaction vertex spread.
Definition: Analysis.h:20
double m(const Vec4 &v1)
Invariant mass and its square.
Definition: Basics.cc:595
string enhanceName() const override
Return the enhancement names.
Definition: SplittingsOnia.h:469
Split2Q2QQbar3PJ8Q(int flavourIn, int stateIn, double ldmeIn, int spinIn, double mSplitIn, Info *infoPtrIn, AlphaStrong *alphaSPtrIn)
Constructor.
Definition: SplittingsOnia.h:460
virtual string enhanceName() const
Return the name to be used if this emission is enhanced.
Definition: SplittingsOnia.h:139
string enhanceName() const override
Return the enhancement names.
Definition: SplittingsOnia.h:371
Splitting class for g -> QQbar[X(8)] (Q = c or b).
Definition: SplittingsOnia.h:488
bool onlyOctet
Flag if only octet -> X splittings enabled.
Definition: SplittingsOnia.h:40
Split2QQbarXq82QQbarX8g(double colFacIn, Info *infoPtrIn, AlphaStrong *alphaSPtrIn)
Constructor.
Definition: SplittingsOnia.h:535
Split2g2QQbar3S11gg(int stateIn, double ldmeIn, Info *infoPtrIn, AlphaStrong *alphaSPtrIn)
Constructor.
Definition: SplittingsOnia.h:309
Split2g2QQbar1S01g(int stateIn, double ldmeIn, Info *infoPtrIn, AlphaStrong *alphaSPtrIn)
Constructor.
Definition: SplittingsOnia.h:255
virtual double generateZ(const TimeDipoleEnd &)
Definition: SplittingsOnia.h:111
SplitOnia(int idAIn, int idBIn, int idCIn, double ldmeIn, Info *infoPtrIn, AlphaStrong *alphaSPtrIn)
Constructor that needs to be called by the subclass.
Definition: SplittingsOnia.h:87
Definition: SplittingsOnia.h:569