PYTHIA  8.314
DireSplittingsU1new.h
1 // DireSplittingsU1new.h is a part of the PYTHIA event generator.
2 // Copyright (C) 2025 Stefan Prestel, 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 // Header file for parton showers with a new U(1) force, e.g. dark photons.
7 
8 #ifndef Pythia8_DireSplittingsU1new_H
9 #define Pythia8_DireSplittingsU1new_H
10 
11 #define DIRE_SPLITTINGSU1NEW_VERSION "2.002"
12 
13 #include "Pythia8/Basics.h"
14 #include "Pythia8/BeamParticle.h"
15 #include "Pythia8/ParticleData.h"
16 #include "Pythia8/PythiaStdlib.h"
17 #include "Pythia8/Settings.h"
18 #include "Pythia8/StandardModel.h"
19 
20 #include "Pythia8/DireSplittingsQCD.h"
21 
22 namespace Pythia8 {
23 
24 //==========================================================================
25 
27 
28 public:
29 
30  // Constructor and destructor.
31  DireSplittingU1new(string idIn, int softRS, Settings* settings,
32  ParticleData* particleData, Rndm* rndm, BeamParticlePtr beamA,
33  BeamParticlePtr beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo)
34  : DireSplittingQCD(idIn, softRS, settings, particleData, rndm, beamA,
35  beamB, coupSM, info, direInfo) { init(); }
36  virtual ~DireSplittingU1new() {}
37 
38  void init();
39 
40  // VARIABLES
41  double sumCharge2Tot, sumCharge2L, sumCharge2Q, ax0, enhance;
42  bool doU1NEWshowerByQ, doU1NEWshowerByL;
43 
44  AlphaEM alphaEM;
45 
46  // Function to calculate the correct running coupling/2*Pi value, including
47  // renormalisation scale variations + threshold matching.
48  double aem2Pi ( double pT2, int = 0);
49 
50  bool useFastFunctions() { return true; }
51 
52  virtual vector <int> radAndEmt(int idDaughter, int)
53  { return createvector<int>(motherID(idDaughter))(sisterID(idDaughter)); }
54  virtual int nEmissions() { return 1; }
55  virtual bool isPartial() { return true; }
56 
57  virtual bool canUseForBranching() { return true; }
58 
59  virtual int couplingType (int, int) { return 2; }
60  virtual double coupling (double = 0., double = 0., double = 0., double = -1.,
61  pair<int,bool> = pair<int,bool>(), pair<int,bool> = pair<int,bool>()) {
62  return (ax0 / (2.*M_PI));
63  }
64  virtual double couplingScale2 (double = 0., double = 0., double = 0.,
65  pair<int,bool> = pair<int,bool>(), pair<int,bool> = pair<int,bool>()) {
66  return -1.;
67  }
68 
69 
70 };
71 
72 //==========================================================================
73 
75 
76 public:
77 
78  Dire_fsr_u1new_Q2QA(string idIn, int softRS, Settings* settings,
79  ParticleData* particleData, Rndm* rndm, BeamParticlePtr beamA,
80  BeamParticlePtr beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
81  DireSplittingU1new(idIn, softRS, settings, particleData, rndm, beamA,
82  beamB, coupSM, info, direInfo){}
83 
84  bool canRadiate ( const Event&, pair<int,int>,
85  unordered_map<string,bool> = unordered_map<string,bool>(),
86  Settings* = nullptr, PartonSystems* = nullptr, BeamParticlePtr = nullptr);
87  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
88  Settings* = nullptr, PartonSystems* = nullptr, BeamParticlePtr = nullptr);
89 
90  int kinMap ();
91 
92  // Return id of mother after splitting.
93  int motherID(int idDaughter);
94 
95  // Return id of emission.
96  int sisterID(int idDaughter);
97 
98  // Return id of recombined radiator (before splitting!)
99  int radBefID(int idRadAfter, int idEmtAfter);
100 
101  // Return colours of recombined radiator (before splitting!)
102  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
103  int colEmtAfter, int acolEmtAfter);
104 
105  double gaugeFactor ( int=0, int=0 );
106  double symmetryFactor ( int=0, int=0 );
107 
108  vector <int> recPositions( const Event& state, int iRad, int iEmt);
109 
110  // Pick z for new splitting.
111  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
112 
113  // New overestimates, z-integrated versions.
114  double overestimateInt(double zMinAbs,double zMaxAbs,
115  double pT2Old, double m2dip, int order = -1);
116 
117  // Return kernel for new splitting.
118  double overestimateDiff(double z, double m2dip, int order = -1);
119 
120  // Functions to calculate the kernel from SplitInfo information.
121  bool calc(const Event& state = Event(), int order = -1);
122 
123 };
124 
125 //==========================================================================
126 
128 
129 public:
130 
131  Dire_fsr_u1new_Q2AQ(string idIn, int softRS, Settings* settings,
132  ParticleData* particleData, Rndm* rndm, BeamParticlePtr beamA,
133  BeamParticlePtr beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
134  DireSplittingU1new(idIn, softRS, settings, particleData, rndm, beamA,
135  beamB, coupSM, info, direInfo){}
136 
137  bool canRadiate ( const Event&, pair<int,int>,
138  unordered_map<string,bool> = unordered_map<string,bool>(),
139  Settings* = nullptr, PartonSystems* = nullptr, BeamParticlePtr = nullptr);
140  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
141  Settings* = nullptr, PartonSystems* = nullptr, BeamParticlePtr = nullptr);
142 
143  int kinMap ();
144 
145  // Return id of mother after splitting.
146  int motherID(int idDaughter);
147 
148  // Return id of emission.
149  int sisterID(int idDaughter);
150 
151  // Return id of recombined radiator (before splitting!)
152  int radBefID(int idRadAfter, int idEmtAfter);
153 
154  // Return colours of recombined radiator (before splitting!)
155  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
156  int colEmtAfter, int acolEmtAfter);
157 
158  double gaugeFactor ( int=0, int=0 );
159  double symmetryFactor ( int=0, int=0 );
160 
161  vector <int> recPositions( const Event& state, int iRad, int iEmt);
162 
163  // Pick z for new splitting.
164  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
165 
166  // New overestimates, z-integrated versions.
167  double overestimateInt(double zMinAbs,double zMaxAbs,
168  double pT2Old, double m2dip, int order = -1);
169 
170  // Return kernel for new splitting.
171  double overestimateDiff(double z, double m2dip, int order = -1);
172 
173  // Functions to calculate the kernel from SplitInfo information.
174  bool calc(const Event& state = Event(), int order = -1);
175 
176 };
177 
178 //==========================================================================
179 
181 
182 public:
183 
184  Dire_fsr_u1new_L2LA(string idIn, int softRS, Settings* settings,
185  ParticleData* particleData, Rndm* rndm, BeamParticlePtr beamA,
186  BeamParticlePtr beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
187  DireSplittingU1new(idIn, softRS, settings, particleData, rndm, beamA,
188  beamB, coupSM, info, direInfo){}
189 
190  bool canRadiate ( const Event&, pair<int,int>,
191  unordered_map<string,bool> = unordered_map<string,bool>(),
192  Settings* = nullptr, PartonSystems* = nullptr, BeamParticlePtr = nullptr);
193  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
194  Settings* = nullptr, PartonSystems* = nullptr, BeamParticlePtr = nullptr);
195 
196  int kinMap ();
197 
198  vector<pair<int,int> > radAndEmtCols(int iRad, int, Event state) {
199  vector< pair<int,int> > ret
200  = createvector<pair<int,int> >(make_pair(0, 0))(make_pair(0, 0));
201  if (particleDataPtr->colType(state[iRad].id()) != 0) {
202  ret[0].first = state[iRad].col();
203  ret[0].second = state[iRad].acol();
204  ret[1].first = 0;
205  ret[1].second = 0;
206  }
207  return ret;
208  }
209 
210  // Return id of mother after splitting.
211  int motherID(int idDaughter);
212 
213  // Return id of emission.
214  int sisterID(int idDaughter);
215 
216  // Return id of recombined radiator (before splitting!)
217  int radBefID(int idRadAfter, int idEmtAfter);
218 
219  // Return colours of recombined radiator (before splitting!)
220  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
221  int colEmtAfter, int acolEmtAfter);
222 
223  double gaugeFactor ( int=0, int=0 );
224  double symmetryFactor ( int=0, int=0 );
225 
226  vector <int> recPositions( const Event& state, int iRad, int iEmt);
227 
228  // Pick z for new splitting.
229  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
230 
231  // New overestimates, z-integrated versions.
232  double overestimateInt(double zMinAbs,double zMaxAbs,
233  double pT2Old, double m2dip, int order = -1);
234 
235  // Return kernel for new splitting.
236  double overestimateDiff(double z, double m2dip, int order = -1);
237 
238  // Functions to calculate the kernel from SplitInfo information.
239  bool calc(const Event& state = Event(), int order = -1);
240 
241 };
242 
243 //==========================================================================
244 
246 
247 public:
248 
249  Dire_fsr_u1new_L2AL(string idIn, int softRS, Settings* settings,
250  ParticleData* particleData, Rndm* rndm, BeamParticlePtr beamA,
251  BeamParticlePtr beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
252  DireSplittingU1new(idIn, softRS, settings, particleData, rndm, beamA,
253  beamB, coupSM, info, direInfo){}
254 
255  bool canRadiate ( const Event&, pair<int,int>,
256  unordered_map<string,bool> = unordered_map<string,bool>(),
257  Settings* = nullptr, PartonSystems* = nullptr, BeamParticlePtr = nullptr);
258  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
259  Settings* = nullptr, PartonSystems* = nullptr, BeamParticlePtr = nullptr);
260 
261  int kinMap ();
262 
263  vector<pair<int,int> > radAndEmtCols(int iRad, int, Event state) {
264  vector< pair<int,int> > ret
265  = createvector<pair<int,int> >(make_pair(0, 0))(make_pair(0, 0));
266  if (particleDataPtr->colType(state[iRad].id()) != 0) {
267  ret[0].first = state[iRad].col();
268  ret[0].second = state[iRad].acol();
269  ret[1].first = 0;
270  ret[1].second = 0;
271  }
272  return ret;
273  }
274 
275  // Return id of mother after splitting.
276  int motherID(int idDaughter);
277 
278  // Return id of emission.
279  int sisterID(int idDaughter);
280 
281  // Return id of recombined radiator (before splitting!)
282  int radBefID(int idRadAfter, int idEmtAfter);
283 
284  // Return colours of recombined radiator (before splitting!)
285  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
286  int colEmtAfter, int acolEmtAfter);
287 
288  double gaugeFactor ( int=0, int=0 );
289  double symmetryFactor ( int=0, int=0 );
290 
291  vector <int> recPositions( const Event& state, int iRad, int iEmt);
292 
293  // Pick z for new splitting.
294  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
295 
296  // New overestimates, z-integrated versions.
297  double overestimateInt(double zMinAbs,double zMaxAbs,
298  double pT2Old, double m2dip, int order = -1);
299 
300  // Return kernel for new splitting.
301  double overestimateDiff(double z, double m2dip, int order = -1);
302 
303  // Functions to calculate the kernel from SplitInfo information.
304  bool calc(const Event& state = Event(), int order = -1);
305 
306 };
307 
308 //==========================================================================
309 
311 
312 public:
313 
314  int idRadAfterSave;
315  double nchSaved;
316 
317  Dire_fsr_u1new_A2FF(int idRadAfterIn, string idIn, int softRS,
318  Settings* settings,
319  ParticleData* particleData, Rndm* rndm, BeamParticlePtr beamA,
320  BeamParticlePtr beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
321  DireSplittingU1new(idIn,
322  softRS, settings, particleData, rndm, beamA, beamB, coupSM, info,
323  direInfo),
324  idRadAfterSave(idRadAfterIn), nchSaved(1) {}
325  bool canRadiate ( const Event& state, pair<int,int> ints,
326  unordered_map<string,bool> = unordered_map<string,bool>(),
327  Settings* = nullptr, PartonSystems* = nullptr, BeamParticlePtr = nullptr) {
328  return ( state[ints.first].isFinal()
329  && state[ints.first].id() == 900032
330  && (state[ints.second].isLepton()
331  || state[ints.second].idAbs() == 900012));
332  }
333  bool canRadiate ( const Event& state, int iRadBef, int iRecBef,
334  Settings* = nullptr, PartonSystems* = nullptr, BeamParticlePtr = nullptr) {
335  return ( state[iRadBef].isFinal()
336  && state[iRadBef].id() == 900032
337  && (state[iRecBef].isLepton()
338  || state[iRecBef].idAbs() == 900012));
339  }
340 
341  int kinMap () { return 1;};
342  bool isPartial() { return false; }
343 
344  vector<pair<int,int> > radAndEmtCols(int iRad, int, Event state) {
345  vector< pair<int,int> > ret;
346  if (state[iRad].id() != 900032) return ret;
347  ret = createvector<pair<int,int> >(make_pair(0, 0))(make_pair(0, 0));
348  if (particleDataPtr->colType(idRadAfterSave) != 0) {
349  int sign = (idRadAfterSave > 0) ? 1 : -1;
350  int newCol = state.nextColTag();
351  if (sign> 0) {
352  ret[0].first = newCol;
353  ret[0].second = 0;
354  ret[1].first = 0;
355  ret[1].second = newCol;
356  } else {
357  ret[0].first = 0;
358  ret[0].second = newCol;
359  ret[1].first = newCol;
360  ret[1].second = 0;
361  }
362 
363  }
364  return ret;
365  }
366 
367  // Return id of mother after splitting.
368  int motherID(int)
369  { return idRadAfterSave; }
370  int sisterID(int)
371  { return -idRadAfterSave; }
372  vector <int> radAndEmt(int, int)
373  { return createvector<int>(idRadAfterSave)(-idRadAfterSave); }
374  //{ return createvector<int>(1)(-1); }
375  double gaugeFactor ( int=0, int=0 )
376  { return 1.; }
377  double symmetryFactor ( int=0, int=0 )
378  { return 1./double(nchSaved); }
379  // Return id of recombined radiator (before splitting!)
380  int radBefID(int idRadAfter, int idEmtAfter) {
381  if ( idRadAfter == idRadAfterSave
382  && particleDataPtr->isQuark(idRadAfter)
383  && particleDataPtr->isQuark(idEmtAfter)) return 900032;
384  return 0;
385  }
386  // Return colours of recombined radiator (before splitting!)
387  pair<int,int> radBefCols(int, int, int, int) { return make_pair(0,0); }
388 
389  // All charged particles are potential recoilers.
390  vector <int> recPositions( const Event& state, int iRad, int iEmt) {
391  if ( state[iRad].isFinal() || state[iRad].id() != idRadAfterSave
392  || state[iEmt].id() != -idRadAfterSave) return vector<int>();
393  // Particles to exclude as recoilers.
394  vector<int> iExc(createvector<int>(iRad)(iEmt));
395  // Find charged particles.
396  vector<int> recs;
397  for (int i=0; i < state.size(); ++i) {
398  if ( find(iExc.begin(), iExc.end(), i) != iExc.end() ) continue;
399  if ( state[i].isLepton() || state[i].idAbs() == 900012) {
400  if (state[i].isFinal())
401  recs.push_back(i);
402  if (state[i].mother1() == 1 && state[i].mother2() == 0)
403  recs.push_back(i);
404  if (state[i].mother1() == 2 && state[i].mother2() == 0)
405  recs.push_back(i);
406  }
407  }
408  // Done.
409  return recs;
410  }
411 
412  // All charged particles are potential recoilers.
413  int set_nCharged( const Event& state) {
414  // Find charged particles.
415  int nch=0;
416  for (int i=0; i < state.size(); ++i) {
417  if ( state[i].isLepton() || state[i].idAbs() == 900012 ) {
418  if (state[i].isFinal()) nch++;
419  if (state[i].mother1() == 1 && state[i].mother2() == 0) nch++;
420  if (state[i].mother1() == 2 && state[i].mother2() == 0) nch++;
421  }
422  }
423  // Done.
424  nchSaved = nch;
425  return nch;
426  }
427 
428  // Pick z for new splitting.
429  double zSplit(double zMinAbs, double zMaxAbs, double /*m2dip*/) {
430  return (zMinAbs + rndmPtr->flat() * (zMaxAbs - zMinAbs));
431  }
432 
433  // New overestimates, z-integrated versions.
434  double overestimateInt(double zMinAbs,double zMaxAbs,
435  double /*pT2Old*/, double /*m2dip*/, int /*order*/ = -1) {
436  double preFac = symmetryFactor() * gaugeFactor();
437  double wt = 2. *enhance * preFac * 0.5 * ( zMaxAbs - zMinAbs);
438  return wt;
439  }
440 
441  // Return kernel for new splitting.
442  double overestimateDiff(double /*z*/, double /*m2dip*/, int /*order*/ = -1) {
443  double preFac = symmetryFactor() * gaugeFactor();
444  double wt = 2. *enhance * preFac * 0.5;
445  return wt;
446  }
447 
448  // Functions to calculate the kernel from SplitInfo information.
449  bool calc(const Event& state, int orderNow) {
450 
451  // Dummy statement to avoid compiler warnings.
452  if (false) cout << state[0].e() << orderNow << endl;
453 
454  // Read all splitting variables.
455  double z(splitInfo.kinematics()->z), pT2(splitInfo.kinematics()->pT2),
456  m2dip(splitInfo.kinematics()->m2Dip),
457  m2Rad(splitInfo.kinematics()->m2RadAft),
458  m2Rec(splitInfo.kinematics()->m2Rec),
459  m2Emt(splitInfo.kinematics()->m2EmtAft);
460  int splitType(splitInfo.type);
461 
462  // Set number of recoilers.
463  set_nCharged(state);
464 
465  double wt = 0.;
466  double preFac = symmetryFactor() * gaugeFactor();
467  double kappa2 = pT2/m2dip;
468  wt = preFac
469  * (pow(1.-z,2.) + pow(z,2.));
470 
471  // Correction for massive splittings.
472  bool doMassive = (abs(splitType) == 2);
473 
474  if (doMassive) {
475 
476  double vijk = 1., pipj = 0.;
477 
478  // splitType == 2 -> Massive FF
479  if (splitType == 2) {
480  // Calculate CS variables.
481  double yCS = kappa2 / (1.-z);
482  double nu2Rad = m2Rad/m2dip;
483  double nu2Emt = m2Emt/m2dip;
484  double nu2Rec = m2Rec/m2dip;
485  vijk = pow2(1.-yCS) - 4.*(yCS+nu2Rad+nu2Emt)*nu2Rec;
486  vijk = sqrt(vijk) / (1-yCS);
487  pipj = m2dip * yCS /2.;
488 
489  // splitType ==-2 -> Massive FI
490  } else if (splitType ==-2) {
491  // Calculate CS variables.
492  double xCS = 1 - kappa2/(1.-z);
493  vijk = 1.;
494  pipj = m2dip/2. * (1-xCS)/xCS;
495  }
496 
497  // Reset kernel for massive splittings.
498  wt = preFac * 1. / vijk * ( pow2(1.-z) + pow2(z)
499  + m2Emt / ( pipj + m2Emt) );
500  }
501 
502  // Multiply with z factor
503  if (idRadAfterSave > 0) wt *= z;
504  else wt *= 1.-z;
505 
506  // Trivial map of values, since kernel does not depend on coupling.
507  unordered_map<string,double> wts;
508  wts.insert( make_pair("base", wt ));
509  if (doVariations) {
510  // Create muR-variations.
511  if (settingsPtr->parm("Variations:muRfsrDown") != 1.)
512  wts.insert( make_pair("Variations:muRfsrDown", wt ));
513  if (settingsPtr->parm("Variations:muRfsrUp") != 1.)
514  wts.insert( make_pair("Variations:muRfsrUp", wt ));
515  }
516 
517  // Store kernel values.
518  clearKernels();
519  for ( unordered_map<string,double>::iterator it = wts.begin();
520  it != wts.end(); ++it )
521  kernelVals.insert(make_pair( it->first, it->second ));
522 
523  return true;
524  }
525 
526 };
527 
528 //==========================================================================
529 
531 
532 public:
533 
534  Dire_fsr_u1new_A2SS(int idRadAfterIn, string idIn, int softRS,
535  Settings* settings,
536  ParticleData* particleData, Rndm* rndm, BeamParticlePtr beamA,
537  BeamParticlePtr beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo)
538  : Dire_fsr_u1new_A2FF(idRadAfterIn, idIn, softRS, settings, particleData,
539  rndm, beamA, beamB, coupSM, info, direInfo) {}
540 
541 };
542 
543 //==========================================================================
544 
546 
547 public:
548 
549  Dire_isr_u1new_Q2QA(string idIn, int softRS, Settings* settings,
550  ParticleData* particleData, Rndm* rndm, BeamParticlePtr beamA,
551  BeamParticlePtr beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
552  DireSplittingU1new(idIn, softRS, settings, particleData, rndm, beamA,
553  beamB, coupSM, info, direInfo){}
554 
555  bool canRadiate ( const Event&, pair<int,int>,
556  unordered_map<string,bool> = unordered_map<string,bool>(),
557  Settings* = nullptr, PartonSystems* = nullptr, BeamParticlePtr = nullptr);
558  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
559  Settings* = nullptr, PartonSystems* = nullptr, BeamParticlePtr = nullptr);
560 
561  int kinMap ();
562 
563  // Return id of mother after splitting.
564  int motherID(int idDaughter);
565 
566  // Return id of emission.
567  int sisterID(int idDaughter);
568 
569  // Return id of recombined radiator (before splitting!)
570  int radBefID(int idRadAfter, int idEmtAfter);
571 
572  // Return colours of recombined radiator (before splitting!)
573  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
574  int colEmtAfter, int acolEmtAfter);
575 
576  double gaugeFactor ( int=0, int=0 );
577  double symmetryFactor ( int=0, int=0 );
578 
579  vector <int> recPositions( const Event& state, int iRad, int iEmt);
580 
581  // Pick z for new splitting.
582  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
583 
584  // New overestimates, z-integrated versions.
585  double overestimateInt(double zMinAbs,double zMaxAbs,
586  double pT2Old, double m2dip, int order = -1);
587 
588  // Return kernel for new splitting.
589  double overestimateDiff(double z, double m2dip, int order = -1);
590 
591  // Functions to calculate the kernel from SplitInfo information.
592  bool calc(const Event& state = Event(), int order = -1);
593 
594 };
595 
597 
598 public:
599 
600  Dire_isr_u1new_A2QQ(string idIn, int softRS, Settings* settings,
601  ParticleData* particleData, Rndm* rndm, BeamParticlePtr beamA,
602  BeamParticlePtr beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
603  DireSplittingU1new(idIn, softRS, settings, particleData, rndm, beamA,
604  beamB, coupSM, info, direInfo){}
605 
606  bool canRadiate ( const Event&, pair<int,int>,
607  unordered_map<string,bool> = unordered_map<string,bool>(),
608  Settings* = nullptr, PartonSystems* = nullptr, BeamParticlePtr = nullptr);
609  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
610  Settings* = nullptr, PartonSystems* = nullptr, BeamParticlePtr = nullptr);
611 
612  int kinMap ();
613 
614  // Return id of mother after splitting.
615  int motherID(int idDaughter);
616 
617  // Return id of emission.
618  int sisterID(int idDaughter);
619 
620  // Return id of recombined radiator (before splitting!)
621  int radBefID(int idRadAfter, int idEmtAfter);
622 
623  // Return colours of recombined radiator (before splitting!)
624  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
625  int colEmtAfter, int acolEmtAfter);
626 
627  double gaugeFactor ( int=0, int=0 );
628  double symmetryFactor ( int=0, int=0 );
629 
630  // Pick z for new splitting.
631  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
632 
633  // New overestimates, z-integrated versions.
634  double overestimateInt(double zMinAbs,double zMaxAbs,
635  double pT2Old, double m2dip, int order = -1);
636 
637  // Return kernel for new splitting.
638  double overestimateDiff(double z, double m2dip, int order = -1);
639 
640  // Functions to calculate the kernel from SplitInfo information.
641  bool calc(const Event& state = Event(), int order = -1);
642 
643 };
644 
646 
647 public:
648 
649  Dire_isr_u1new_Q2AQ(string idIn, int softRS, Settings* settings,
650  ParticleData* particleData, Rndm* rndm, BeamParticlePtr beamA,
651  BeamParticlePtr beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
652  DireSplittingU1new(idIn, softRS, settings, particleData, rndm, beamA,
653  beamB, coupSM, info, direInfo){}
654 
655  bool canRadiate ( const Event&, pair<int,int>,
656  unordered_map<string,bool> = unordered_map<string,bool>(),
657  Settings* = nullptr, PartonSystems* = nullptr, BeamParticlePtr = nullptr);
658  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
659  Settings* = nullptr, PartonSystems* = nullptr, BeamParticlePtr = nullptr);
660 
661  int kinMap ();
662 
663  // Return id of mother after splitting.
664  int motherID(int idDaughter);
665 
666  // Return id of emission.
667  int sisterID(int idDaughter);
668 
669  // Return id of recombined radiator (before splitting!)
670  int radBefID(int idRadAfter, int idEmtAfter);
671 
672  // Return colours of recombined radiator (before splitting!)
673  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
674  int colEmtAfter, int acolEmtAfter);
675 
676  double gaugeFactor ( int=0, int=0 );
677  double symmetryFactor ( int=0, int=0 );
678 
679  // Pick z for new splitting.
680  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
681 
682  // New overestimates, z-integrated versions.
683  double overestimateInt(double zMinAbs,double zMaxAbs,
684  double pT2Old, double m2dip, int order = -1);
685 
686  // Return kernel for new splitting.
687  double overestimateDiff(double z, double m2dip, int order = -1);
688 
689  // Functions to calculate the kernel from SplitInfo information.
690  bool calc(const Event& state = Event(), int order = -1);
691 
692 };
693 
695 
696 public:
697 
698  Dire_isr_u1new_L2LA(string idIn, int softRS, Settings* settings,
699  ParticleData* particleData, Rndm* rndm, BeamParticlePtr beamA,
700  BeamParticlePtr beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
701  DireSplittingU1new(idIn, softRS, settings, particleData, rndm, beamA,
702  beamB, coupSM, info, direInfo){}
703 
704  bool canRadiate ( const Event&, pair<int,int>,
705  unordered_map<string,bool> = unordered_map<string,bool>(),
706  Settings* = nullptr, PartonSystems* = nullptr, BeamParticlePtr = nullptr);
707  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
708  Settings* = nullptr, PartonSystems* = nullptr, BeamParticlePtr = nullptr);
709 
710  int kinMap ();
711 
712  // Return id of mother after splitting.
713  int motherID(int idDaughter);
714 
715  // Return id of emission.
716  int sisterID(int idDaughter);
717 
718  // Return id of recombined radiator (before splitting!)
719  int radBefID(int idRadAfter, int idEmtAfter);
720 
721  // Return colours of recombined radiator (before splitting!)
722  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
723  int colEmtAfter, int acolEmtAfter);
724 
725  double gaugeFactor ( int=0, int=0 );
726  double symmetryFactor ( int=0, int=0 );
727 
728  vector <int> recPositions( const Event& state, int iRad, int iEmt);
729 
730  // Pick z for new splitting.
731  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
732 
733  // New overestimates, z-integrated versions.
734  double overestimateInt(double zMinAbs,double zMaxAbs,
735  double pT2Old, double m2dip, int order = -1);
736 
737  // Return kernel for new splitting.
738  double overestimateDiff(double z, double m2dip, int order = -1);
739 
740  // Functions to calculate the kernel from SplitInfo information.
741  bool calc(const Event& state = Event(), int order = -1);
742 
743 };
744 
746 
747 public:
748 
749  Dire_isr_u1new_A2LL(string idIn, int softRS, Settings* settings,
750  ParticleData* particleData, Rndm* rndm, BeamParticlePtr beamA,
751  BeamParticlePtr beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
752  DireSplittingU1new(idIn, softRS, settings, particleData, rndm, beamA,
753  beamB, coupSM, info, direInfo){}
754 
755  bool canRadiate ( const Event&, pair<int,int>,
756  unordered_map<string,bool> = unordered_map<string,bool>(),
757  Settings* = nullptr, PartonSystems* = nullptr, BeamParticlePtr = nullptr);
758  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
759  Settings* = nullptr, PartonSystems* = nullptr, BeamParticlePtr = nullptr);
760 
761  int kinMap ();
762 
763  // Return id of mother after splitting.
764  int motherID(int idDaughter);
765 
766  // Return id of emission.
767  int sisterID(int idDaughter);
768 
769  // Return id of recombined radiator (before splitting!)
770  int radBefID(int idRadAfter, int idEmtAfter);
771 
772  // Return colours of recombined radiator (before splitting!)
773  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
774  int colEmtAfter, int acolEmtAfter);
775 
776  double gaugeFactor ( int=0, int=0 );
777  double symmetryFactor ( int=0, int=0 );
778 
779  // Pick z for new splitting.
780  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
781 
782  // New overestimates, z-integrated versions.
783  double overestimateInt(double zMinAbs,double zMaxAbs,
784  double pT2Old, double m2dip, int order = -1);
785 
786  // Return kernel for new splitting.
787  double overestimateDiff(double z, double m2dip, int order = -1);
788 
789  // Functions to calculate the kernel from SplitInfo information.
790  bool calc(const Event& state = Event(), int order = -1);
791 
792 };
793 
795 
796 public:
797 
798  Dire_isr_u1new_L2AL(string idIn, int softRS, Settings* settings,
799  ParticleData* particleData, Rndm* rndm, BeamParticlePtr beamA,
800  BeamParticlePtr beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
801  DireSplittingU1new(idIn, softRS, settings, particleData, rndm, beamA,
802  beamB, coupSM, info, direInfo){}
803 
804  bool canRadiate ( const Event&, pair<int,int>,
805  unordered_map<string,bool> = unordered_map<string,bool>(),
806  Settings* = nullptr, PartonSystems* = nullptr, BeamParticlePtr = nullptr);
807  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
808  Settings* = nullptr, PartonSystems* = nullptr, BeamParticlePtr = nullptr);
809 
810  int kinMap ();
811 
812  // Return id of mother after splitting.
813  int motherID(int idDaughter);
814 
815  // Return id of emission.
816  int sisterID(int idDaughter);
817 
818  // Return id of recombined radiator (before splitting!)
819  int radBefID(int idRadAfter, int idEmtAfter);
820 
821  // Return colours of recombined radiator (before splitting!)
822  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
823  int colEmtAfter, int acolEmtAfter);
824 
825  double gaugeFactor ( int=0, int=0 );
826  double symmetryFactor ( int=0, int=0 );
827 
828  // Pick z for new splitting.
829  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
830 
831  // New overestimates, z-integrated versions.
832  double overestimateInt(double zMinAbs,double zMaxAbs,
833  double pT2Old, double m2dip, int order = -1);
834 
835  // Return kernel for new splitting.
836  double overestimateDiff(double z, double m2dip, int order = -1);
837 
838  // Functions to calculate the kernel from SplitInfo information.
839  bool calc(const Event& state = Event(), int order = -1);
840 
841 };
842 
843 //==========================================================================
844 
845 } // end namespace Pythia8
846 
847 #endif // end Pythia8_DireSplittingsU1new_H
constexpr double pow2(const double &x)
Powers of small integers - for balance speed/code clarity.
Definition: PythiaStdlib.h:173
Definition: DireSplittingsU1new.h:745
virtual vector< int > recPositions(const Event &, int, int)
Definition: DireSplittings.h:146
virtual double symmetryFactor(int, int)
Return symmetry factor for splitting.
Definition: DireSplittings.h:160
Definition: DireSplittingsU1new.h:794
Definition: DireSplittingsU1new.h:545
double zSplit(double zMinAbs, double zMaxAbs, double)
Pick z for new splitting.
Definition: DireSplittingsU1new.h:429
Definition: Info.h:45
The Event class holds all info on the generated event.
Definition: Event.h:408
virtual double coupling(double=0., double=0., double=0., double=-1., pair< int, bool >=pair< int, bool >(), pair< int, bool >=pair< int, bool >())
Definition: DireSplittingsU1new.h:60
Definition: DireSplittingsU1new.h:694
Definition: DireSplittingsQCD.h:27
int set_nCharged(const Event &state)
All charged particles are potential recoilers.
Definition: DireSplittingsU1new.h:413
virtual double gaugeFactor(int, int)
Return color factor for splitting.
Definition: DireSplittings.h:157
double symmetryFactor(int=0, int=0)
Return symmetry factor for splitting.
Definition: DireSplittingsU1new.h:377
virtual double overestimateInt(double, double, double, double, int=-1)
New overestimates, z-integrated versions.
Definition: DireSplittings.h:189
double aem2Pi(double pT2, int=0)
Definition: DireSplittingsU1new.cc:58
Definition: DireSplittingsU1new.h:245
Definition: DireBasics.h:374
Definition: DireSplittingsU1new.h:596
Definition: StandardModel.h:106
int motherID(int)
Return id of mother after splitting.
Definition: DireSplittingsU1new.h:368
double sumCharge2Tot
VARIABLES.
Definition: DireSplittingsU1new.h:41
Definition: DireSplittingsU1new.h:180
Definition: DireSplittingsU1new.h:26
vector< int > recPositions(const Event &state, int iRad, int iEmt)
All charged particles are potential recoilers.
Definition: DireSplittingsU1new.h:390
Definition: Basics.h:388
virtual bool calc(const Event &=Event(), int=-1)
Functions to calculate the kernel from SplitInfo information.
Definition: DireSplittings.h:203
Definition: DireSplittingsU1new.h:127
Definition: DireSplittingsU1new.h:530
double gaugeFactor(int=0, int=0)
{ return createvector<int>(1)(-1); }
Definition: DireSplittingsU1new.h:375
virtual int kinMap()
Definition: DireSplittings.h:123
vector< int > radAndEmt(int, int)
Definition: DireSplittingsU1new.h:372
void init()
The SplittingU1new class.
Definition: DireSplittingsU1new.cc:21
double overestimateInt(double zMinAbs, double zMaxAbs, double, double, int=-1)
New overestimates, z-integrated versions.
Definition: DireSplittingsU1new.h:434
Definition: StandardModel.h:135
int size() const
Event record size.
Definition: Event.h:459
virtual int couplingType(int, int)
Definition: DireSplittingsU1new.h:59
virtual double overestimateDiff(double, double, int=-1)
Return kernel for new splitting.
Definition: DireSplittings.h:193
DireSplittingU1new(string idIn, int softRS, Settings *settings, ParticleData *particleData, Rndm *rndm, BeamParticlePtr beamA, BeamParticlePtr beamB, CoupSM *coupSM, Info *info, DireInfo *direInfo)
Constructor and destructor.
Definition: DireSplittingsU1new.h:31
int radBefID(int idRadAfter, int idEmtAfter)
Return id of recombined radiator (before splitting!)
Definition: DireSplittingsU1new.h:380
virtual vector< int > radAndEmt(int idDaughter, int)
Definition: DireSplittingsU1new.h:52
Definition: DireSplittingsU1new.h:645
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
Definition: DireSplittingsU1new.h:74
bool calc(const Event &state, int orderNow)
Functions to calculate the kernel from SplitInfo information.
Definition: DireSplittingsU1new.h:449
double overestimateDiff(double, double, int=-1)
Return kernel for new splitting.
Definition: DireSplittingsU1new.h:442
virtual int radBefID(int, int)
Return id of recombined radiator (before splitting!)
Definition: DireSplittings.h:150
This class holds a map of all ParticleDataEntries.
Definition: ParticleData.h:422
virtual pair< int, int > radBefCols(int, int, int, int)
Return colours of recombined radiator (before splitting!)
Definition: DireSplittings.h:153
int kinMap()
Definition: DireSplittingsU1new.h:341
Definition: DireBasics.h:82
virtual int sisterID(int)
Return id of emission.
Definition: DireSplittings.h:129
Definition: DireSplittingsU1new.h:310
Definition: Settings.h:196
virtual double zSplit(double, double, double)
Pick z for new splitting.
Definition: DireSplittings.h:186
pair< int, int > radBefCols(int, int, int, int)
Return colours of recombined radiator (before splitting!)
Definition: DireSplittingsU1new.h:387
int sisterID(int)
Return id of emission.
Definition: DireSplittingsU1new.h:370
virtual int motherID(int)
Return id of mother after splitting.
Definition: DireSplittings.h:126