StRoot  1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
DireSplittingsEW.h
1 // DireSplittingsEW.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 the Dire electroweak splitings.
7 
8 #ifndef Pythia8_DireSplittingsEW_H
9 #define Pythia8_DireSplittingsEW_H
10 
11 #define DIRE_SPLITTINGSEW_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 
19 #include "Pythia8/DireSplittingsQCD.h"
20 
21 namespace Pythia8 {
22 
23 //==========================================================================
24 
25 class DireSplittingEW : public DireSplittingQCD {
26 
27 public:
28 
29  // Constructor and destructor.
30  DireSplittingEW(string idIn, int softRS, Settings* settings,
31  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
32  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
33  DireSplittingQCD(idIn,
34  softRS,settings,particleData,rndm,beamA,beamB,coupSM,info, direInfo)
35  { init(); }
36  virtual ~DireSplittingEW() {}
37 
38  void init();
39 
40  // Z0 and W+- properties needed for gamma/Z0 mixing and weak showers.
41  double mZ, gammaZ, thetaW, mW, gammaW, aem0, enhance;
42  bool doQEDshowerByQ, doQEDshowerByL;
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);
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 (aem0 / (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 class Dire_fsr_ew_Q2QZ : public DireSplittingEW {
74 
75 public:
76 
77  Dire_fsr_ew_Q2QZ(string idIn, int softRS, Settings* settings,
78  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
79  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
80  DireSplittingEW(idIn, softRS, settings, particleData, rndm, beamA, beamB,
81  coupSM, info, direInfo){}
82 
83  bool canRadiate ( const Event&, pair<int,int>,
84  unordered_map<string,bool> = unordered_map<string,bool>(),
85  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
86  bool canRadiate ( const Event&, int, int,
87  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL)
88  {return false;}
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  // Pick z for new splitting.
109  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
110 
111  // New overestimates, z-integrated versions.
112  double overestimateInt(double zMinAbs,double zMaxAbs,
113  double pT2Old, double m2dip, int order = -1);
114 
115  // Return kernel for new splitting.
116  double overestimateDiff(double z, double m2dip, int order = -1);
117 
118  // Functions to calculate the kernel from SplitInfo information.
119  bool calc(const Event& state = Event(), int order = -1);
120 
121 };
122 
123 class Dire_fsr_ew_Q2ZQ : public DireSplittingEW {
124 
125 public:
126 
127  Dire_fsr_ew_Q2ZQ(string idIn, int softRS, Settings* settings,
128  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
129  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
130  DireSplittingEW(idIn, softRS, settings, particleData, rndm, beamA, beamB,
131  coupSM, info, direInfo){}
132 
133  bool canRadiate ( const Event&, pair<int,int>,
134  unordered_map<string,bool> = unordered_map<string,bool>(),
135  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
136  bool canRadiate ( const Event&, int, int,
137  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL)
138  {return false;}
139 
140  int kinMap ();
141 
142  // Return id of mother after splitting.
143  int motherID(int idDaughter);
144 
145  // Return id of emission.
146  int sisterID(int idDaughter);
147 
148  // Return id of recombined radiator (before splitting!)
149  int radBefID(int idRadAfter, int idEmtAfter);
150 
151  // Return colours of recombined radiator (before splitting!)
152  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
153  int colEmtAfter, int acolEmtAfter);
154 
155  double gaugeFactor ( int=0, int=0);
156  double symmetryFactor ( int=0, int=0);
157 
158  // Pick z for new splitting.
159  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
160 
161  // New overestimates, z-integrated versions.
162  double overestimateInt(double zMinAbs,double zMaxAbs,
163  double pT2Old, double m2dip, int order = -1);
164 
165  // Return kernel for new splitting.
166  double overestimateDiff(double z, double m2dip, int order = -1);
167 
168  // Functions to calculate the kernel from SplitInfo information.
169  bool calc(const Event& state = Event(), int order = -1);
170 
171 };
172 
173 class Dire_fsr_ew_Z2QQ1 : public DireSplittingEW {
174 
175 public:
176 
177  Dire_fsr_ew_Z2QQ1(string idIn, int softRS, Settings* settings,
178  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
179  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
180  DireSplittingEW(idIn, softRS, settings, particleData, rndm, beamA, beamB,
181  coupSM, info, direInfo){}
182 
183  bool canRadiate ( const Event&, pair<int,int>,
184  unordered_map<string,bool> = unordered_map<string,bool>(),
185  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
186  bool canRadiate ( const Event&, int, int,
187  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL)
188  {return false;}
189 
190  int kinMap ();
191 
192  // Return id of mother after splitting.
193  int motherID(int idDaughter);
194 
195  // Return id of emission.
196  int sisterID(int idDaughter);
197 
198  // Return id of recombined radiator (before splitting!)
199  int radBefID(int idRadAfter, int idEmtAfter);
200 
201  // Return colours of recombined radiator (before splitting!)
202  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
203  int colEmtAfter, int acolEmtAfter);
204 
205  double gaugeFactor ( int=0, int=0);
206  double symmetryFactor ( int=0, int=0);
207 
208  // Pick z for new splitting.
209  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
210 
211  // New overestimates, z-integrated versions.
212  double overestimateInt(double zMinAbs,double zMaxAbs,
213  double pT2Old, double m2dip, int order = -1);
214 
215  // Return kernel for new splitting.
216  double overestimateDiff(double z, double m2dip, int order = -1);
217 
218  // Functions to calculate the kernel from SplitInfo information.
219  bool calc(const Event& state = Event(), int order = -1);
220 
221 };
222 
223 class Dire_fsr_ew_Z2QQ2 : public DireSplittingEW {
224 
225 public:
226 
227  Dire_fsr_ew_Z2QQ2(string idIn, int softRS, Settings* settings,
228  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
229  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
230  DireSplittingEW(idIn, softRS, settings, particleData, rndm, beamA, beamB,
231  coupSM, info, direInfo){}
232 
233  bool canRadiate ( const Event&, pair<int,int>,
234  unordered_map<string,bool> = unordered_map<string,bool>(),
235  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
236  bool canRadiate ( const Event&, int, int,
237  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL)
238  {return false;}
239 
240  int kinMap ();
241 
242  // Return id of mother after splitting.
243  int motherID(int idDaughter);
244 
245  // Return id of emission.
246  int sisterID(int idDaughter);
247 
248  // Return id of recombined radiator (before splitting!)
249  int radBefID(int idRadAfter, int idEmtAfter);
250 
251  // Return colours of recombined radiator (before splitting!)
252  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
253  int colEmtAfter, int acolEmtAfter);
254 
255  double gaugeFactor ( int=0, int=0);
256  double symmetryFactor ( int=0, int=0);
257 
258  // Pick z for new splitting.
259  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
260 
261  // New overestimates, z-integrated versions.
262  double overestimateInt(double zMinAbs,double zMaxAbs,
263  double pT2Old, double m2dip, int order = -1);
264 
265  // Return kernel for new splitting.
266  double overestimateDiff(double z, double m2dip, int order = -1);
267 
268  // Functions to calculate the kernel from SplitInfo information.
269  bool calc(const Event& state = Event(), int order = -1);
270 
271 };
272 
273 class Dire_fsr_ew_W2QQ1 : public DireSplittingEW {
274 
275 public:
276 
277  Dire_fsr_ew_W2QQ1(string idIn, int softRS, Settings* settings,
278  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
279  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
280  DireSplittingEW(idIn, softRS, settings, particleData, rndm, beamA, beamB,
281  coupSM, info, direInfo){}
282 
283  bool canRadiate ( const Event&, pair<int,int>,
284  unordered_map<string,bool> = unordered_map<string,bool>(),
285  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
286  bool canRadiate ( const Event&, int, int,
287  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL)
288  {return false;}
289 
290  int kinMap ();
291 
292  // Return id of mother after splitting.
293  int motherID(int idDaughter);
294 
295  // Return id of emission.
296  int sisterID(int idDaughter);
297 
298  // Return id of recombined radiator (before splitting!)
299  int radBefID(int idRadAfter, int idEmtAfter);
300 
301  // Return colours of recombined radiator (before splitting!)
302  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
303  int colEmtAfter, int acolEmtAfter);
304 
305  double gaugeFactor ( int=0, int=0);
306  double symmetryFactor ( int=0, int=0);
307 
308  // Pick z for new splitting.
309  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
310 
311  // New overestimates, z-integrated versions.
312  double overestimateInt(double zMinAbs,double zMaxAbs,
313  double pT2Old, double m2dip, int order = -1);
314 
315  // Return kernel for new splitting.
316  double overestimateDiff(double z, double m2dip, int order = -1);
317 
318  // Functions to calculate the kernel from SplitInfo information.
319  bool calc(const Event& state = Event(), int order = -1);
320 
321 };
322 
323 class Dire_fsr_ew_W2QQ2 : public DireSplittingEW {
324 
325 public:
326 
327  Dire_fsr_ew_W2QQ2(string idIn, int softRS, Settings* settings,
328  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
329  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
330  DireSplittingEW(idIn, softRS, settings, particleData, rndm, beamA, beamB,
331  coupSM, info, direInfo){}
332 
333  bool canRadiate ( const Event&, pair<int,int>,
334  unordered_map<string,bool> = unordered_map<string,bool>(),
335  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
336  bool canRadiate ( const Event&, int, int,
337  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL)
338  {return false;}
339 
340  int kinMap ();
341 
342  // Return id of mother after splitting.
343  int motherID(int idDaughter);
344 
345  // Return id of emission.
346  int sisterID(int idDaughter);
347 
348  // Return id of recombined radiator (before splitting!)
349  int radBefID(int idRadAfter, int idEmtAfter);
350 
351  // Return colours of recombined radiator (before splitting!)
352  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
353  int colEmtAfter, int acolEmtAfter);
354 
355  double gaugeFactor ( int=0, int=0);
356  double symmetryFactor ( int=0, int=0);
357 
358  // Pick z for new splitting.
359  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
360 
361  // New overestimates, z-integrated versions.
362  double overestimateInt(double zMinAbs,double zMaxAbs,
363  double pT2Old, double m2dip, int order = -1);
364 
365  // Return kernel for new splitting.
366  double overestimateDiff(double z, double m2dip, int order = -1);
367 
368  // Functions to calculate the kernel from SplitInfo information.
369  bool calc(const Event& state = Event(), int order = -1);
370 
371 };
372 
373 //==========================================================================
374 
375 class Dire_fsr_ew_H2WW : public DireSplittingEW {
376 
377 public:
378 
379  Dire_fsr_ew_H2WW(string idIn, int softRS, Settings* settings,
380  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
381  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
382  DireSplittingEW(idIn, softRS, settings, particleData, rndm, beamA, beamB,
383  coupSM, info, direInfo){}
384 
385  bool canRadiate ( const Event&, pair<int,int>,
386  unordered_map<string,bool> = unordered_map<string,bool>(),
387  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
388  bool canRadiate ( const Event&, int, int,
389  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL)
390  {return false;}
391 
392  int kinMap ();
393 
394  // Return id of mother after splitting.
395  int motherID(int idDaughter);
396 
397  // Return id of emission.
398  int sisterID(int idDaughter);
399 
400  // Return id of recombined radiator (before splitting!)
401  int radBefID(int idRadAfter, int idEmtAfter);
402 
403  // Return colours of recombined radiator (before splitting!)
404  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
405  int colEmtAfter, int acolEmtAfter);
406 
407  double gaugeFactor ( int=0, int=0);
408  double symmetryFactor ( int=0, int=0);
409 
410  // Pick z for new splitting.
411  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
412 
413  // New overestimates, z-integrated versions.
414  double overestimateInt(double zMinAbs,double zMaxAbs,
415  double pT2Old, double m2dip, int order = -1);
416 
417  // Return kernel for new splitting.
418  double overestimateDiff(double z, double m2dip, int order = -1);
419 
420  // Functions to calculate the kernel from SplitInfo information.
421  bool calc(const Event& state = Event(), int order = -1);
422 
423 };
424 
425 //==========================================================================
426 
427 class Dire_fsr_ew_H2AA : public DireSplittingEW {
428 
429 public:
430 
431  Dire_fsr_ew_H2AA(string idIn, int softRS, Settings* settings,
432  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
433  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
434  DireSplittingEW(idIn, softRS, settings, particleData, rndm, beamA, beamB,
435  coupSM, info, direInfo) {
436  widthToAA = particleDataPtr->particleDataEntryPtr(25)->resWidthChan(
437  particleDataPtr->m0(25), 22, 22);
438  widthTot = settings->parm("MEM:WidthH");
439  }
440 
441  bool canRadiate ( const Event&, pair<int,int>,
442  unordered_map<string,bool> = unordered_map<string,bool>(),
443  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
444  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
445  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
446  bool isPartial() { return false; }
447 
448  bool isSymmetric( const Particle* rad, const Particle* emt) {
449  if (rad->id() == 22 && emt->id() == 22) return true;
450  return false;
451  }
452 
453  int couplingType (int, int);
454  double coupling (double = 0., double = 0., double = 0., double = -1.,
455  pair<int,bool> = pair<int,bool>(), pair<int,bool> = pair<int,bool>());
456 
457  int kinMap ();
458 
459  // Return id of mother after splitting.
460  int motherID(int idDaughter);
461 
462  // Return id of emission.
463  int sisterID(int idDaughter);
464 
465  // Return id of recombined radiator (before splitting!)
466  int radBefID(int idRadAfter, int idEmtAfter);
467 
468  vector <int> recPositions( const Event& state, int iRad, int iEmt);
469 
470  // Return colours of recombined radiator (before splitting!)
471  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
472  int colEmtAfter, int acolEmtAfter);
473 
474  double gaugeFactor ( int=0, int=0);
475  double symmetryFactor ( int=0, int=0);
476 
477  // Pick z for new splitting.
478  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
479 
480  // New overestimates, z-integrated versions.
481  double overestimateInt(double zMinAbs,double zMaxAbs,
482  double pT2Old, double m2dip, int order = -1);
483 
484  // Return kernel for new splitting.
485  double overestimateDiff(double z, double m2dip, int order = -1);
486 
487  // Functions to calculate the kernel from SplitInfo information.
488  bool calc(const Event& state = Event(), int order = -1);
489 
490  double widthToAA, widthTot;
491 
492 };
493 
494 //==========================================================================
495 
496 class Dire_fsr_ew_H2GG : public DireSplittingEW {
497 
498 public:
499 
500  Dire_fsr_ew_H2GG(string idIn, int softRS, Settings* settings,
501  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
502  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
503  DireSplittingEW(idIn, softRS, settings, particleData, rndm, beamA, beamB,
504  coupSM, info, direInfo) {
505  widthToGG = particleDataPtr->particleDataEntryPtr(25)->resWidthChan(
506  particleDataPtr->m0(25), 21, 21);
507  widthTot = settings->parm("MEM:WidthH");
508  }
509 
510  bool canRadiate ( const Event&, pair<int,int>,
511  unordered_map<string,bool> = unordered_map<string,bool>(),
512  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
513  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
514  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
515  bool isPartial() { return false; }
516 
517  bool isSymmetric( const Particle* rad, const Particle* emt) {
518  if (rad->id() == 21 && emt->id() == 21) return true;
519  return false;
520  }
521 
522  int couplingType (int, int);
523  double coupling (double = 0., double = 0., double = 0., double = -1.,
524  pair<int,bool> = pair<int,bool>(), pair<int,bool> = pair<int,bool>());
525 
526  int kinMap ();
527 
528  // Return id of mother after splitting.
529  int motherID(int idDaughter);
530 
531  // Return id of emission.
532  int sisterID(int idDaughter);
533 
534  // Return id of recombined radiator (before splitting!)
535  int radBefID(int idRadAfter, int idEmtAfter);
536 
537  vector <int> recPositions( const Event& state, int iRad, int iEmt);
538 
539  // Return colours of recombined radiator (before splitting!)
540  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
541  int colEmtAfter, int acolEmtAfter);
542 
543  double gaugeFactor ( int=0, int=0);
544  double symmetryFactor ( int=0, int=0);
545 
546  // Pick z for new splitting.
547  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
548 
549  // New overestimates, z-integrated versions.
550  double overestimateInt(double zMinAbs,double zMaxAbs,
551  double pT2Old, double m2dip, int order = -1);
552 
553  // Return kernel for new splitting.
554  double overestimateDiff(double z, double m2dip, int order = -1);
555 
556  // Functions to calculate the kernel from SplitInfo information.
557  bool calc(const Event& state = Event(), int order = -1);
558 
559  double widthToGG, widthTot;
560 
561 };
562 
563 //==========================================================================
564 
565 class Dire_fsr_ew_W2WA : public DireSplittingEW {
566 
567 public:
568 
569  Dire_fsr_ew_W2WA(string idIn, int softRS, Settings* settings,
570  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
571  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
572  DireSplittingEW(idIn, softRS, settings, particleData, rndm, beamA, beamB,
573  coupSM, info, direInfo){}
574 
575  bool canRadiate ( const Event&, pair<int,int>,
576  unordered_map<string,bool> = unordered_map<string,bool>(),
577  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
578  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
579  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
580 
581  int kinMap ();
582 
583  // Return id of mother after splitting.
584  int motherID(int idDaughter);
585 
586  // Return id of emission.
587  int sisterID(int idDaughter);
588 
589  // Return id of recombined radiator (before splitting!)
590  int radBefID(int idRadAfter, int idEmtAfter);
591 
592  vector <int> recPositions( const Event& state, int iRad, int iEmt);
593 
594  // Return colours of recombined radiator (before splitting!)
595  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
596  int colEmtAfter, int acolEmtAfter);
597 
598  vector<pair<int,int> > radAndEmtCols(int iRad, int, Event state) {
599  vector< pair<int,int> > ret;
600  if (state[iRad].idAbs() != 24) return ret;
601  ret = createvector<pair<int,int> >(make_pair(0, 0))(make_pair(0, 0));
602  return ret;
603  }
604 
605  double gaugeFactor ( int=0, int=0);
606  double symmetryFactor ( int=0, int=0);
607 
608  // Pick z for new splitting.
609  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
610 
611  // New overestimates, z-integrated versions.
612  double overestimateInt(double zMinAbs,double zMaxAbs,
613  double pT2Old, double m2dip, int order = -1);
614 
615  // Return kernel for new splitting.
616  double overestimateDiff(double z, double m2dip, int order = -1);
617 
618  // Functions to calculate the kernel from SplitInfo information.
619  bool calc(const Event& state = Event(), int order = -1);
620 
621 };
622 
623 //==========================================================================
624 
625 class Dire_isr_ew_Q2QZ : public DireSplittingEW {
626 
627 public:
628 
629  Dire_isr_ew_Q2QZ(string idIn, int softRS, Settings* settings,
630  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
631  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
632  DireSplittingEW(idIn, softRS, settings, particleData, rndm, beamA, beamB,
633  coupSM, info, direInfo){}
634 
635  bool canRadiate ( const Event&, pair<int,int>,
636  unordered_map<string,bool> = unordered_map<string,bool>(),
637  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
638  bool canRadiate ( const Event&, int, int,
639  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL)
640  {return false;}
641 
642  int kinMap ();
643 
644  // Return id of mother after splitting.
645  int motherID(int idDaughter);
646 
647  // Return id of emission.
648  int sisterID(int idDaughter);
649 
650  // Return id of recombined radiator (before splitting!)
651  int radBefID(int idRadAfter, int idEmtAfter);
652 
653  // Return colours of recombined radiator (before splitting!)
654  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
655  int colEmtAfter, int acolEmtAfter);
656 
657  double gaugeFactor ( int=0, int=0);
658  double symmetryFactor ( int=0, int=0);
659 
660  // Pick z for new splitting.
661  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
662 
663  // New overestimates, z-integrated versions.
664  double overestimateInt(double zMinAbs,double zMaxAbs,
665  double pT2Old, double m2dip, int order = -1);
666 
667  // Return kernel for new splitting.
668  double overestimateDiff(double z, double m2dip, int order = -1);
669 
670  // Functions to calculate the kernel from SplitInfo information.
671  bool calc(const Event& state = Event(), int order = -1);
672 
673 };
674 
675 } // end namespace Pythia8
676 
677 #endif // end Pythia8_DireSplittingLibrary_H
Pythia8::Dire_fsr_ew_Q2QZ
Definition: DireSplittingsEW.h:73
Pythia8::Dire_fsr_ew_W2WA
Definition: DireSplittingsEW.h:565
Pythia8::Dire_fsr_ew_Z2QQ1
Definition: DireSplittingsEW.h:173
Pythia8::Dire_fsr_ew_W2QQ1
Definition: DireSplittingsEW.h:273
Pythia8::Dire_isr_ew_Q2QZ
Definition: DireSplittingsEW.h:625
Pythia8::Dire_fsr_ew_Z2QQ2
Definition: DireSplittingsEW.h:223
Pythia8::Dire_fsr_ew_W2QQ2
Definition: DireSplittingsEW.h:323
Pythia8::Dire_fsr_ew_H2WW
Definition: DireSplittingsEW.h:375
Pythia8::Dire_fsr_ew_Q2ZQ
Definition: DireSplittingsEW.h:123
Pythia8::Dire_fsr_ew_H2GG
Definition: DireSplittingsEW.h:496
Pythia8::Dire_fsr_ew_H2AA
Definition: DireSplittingsEW.h:427
Generated by   doxygen 1.8.5