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