StRoot  1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
DireSplittingsQCD.h
1 // DireSplittingsQCD.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 of QCD splittings for the Dire parton shower.
7 
8 #ifndef Pythia8_DireSplittingsQCD_H
9 #define Pythia8_DireSplittingsQCD_H
10 
11 #define ZETA3 1.202056903159594
12 #define DIRE_SPLITTINGSQCD_VERSION "2.002"
13 
14 #include "Pythia8/Basics.h"
15 #include "Pythia8/BeamParticle.h"
16 #include "Pythia8/ParticleData.h"
17 #include "Pythia8/PythiaStdlib.h"
18 #include "Pythia8/Settings.h"
19 #include "Pythia8/StandardModel.h"
20 
21 #include "Pythia8/DireSplittings.h"
22 
23 namespace Pythia8 {
24 
25 //==========================================================================
26 
27 class DireSplittingQCD : public DireSplitting {
28 
29 public:
30 
31  // Constructor and destructor.
32  DireSplittingQCD(string idIn, int softRS, Settings* settings,
33  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
34  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
35  DireSplitting(idIn,
36  softRS, settings, particleData, rndm, beamA, beamB, coupSM, info,
37  direInfo)
38  { init();
39  asSchemeISR=settingsPtr->mode("DireSpace:alphasScheme");
40  asSchemeFSR=settingsPtr->mode("DireTimes:alphasScheme"); }
41  virtual ~DireSplittingQCD() {}
42 
43  void init();
44 
45  // VARIABLES
46  double CA, TR, CF, pTmin, pT2minVariations;
47  int NF_qcd_fsr, orderSave;
48  bool usePDFalphas, doVariations, doCorrelations, doMECs;
49  double alphaSorder, alphaS2pi;
50 
51  AlphaStrong alphaS;
52 
53  static const double SMALL_TEVOL;
54 
55  // AUXILIARY FUNCTIONS
56  double getNF(double pT2);
57  double GammaQCD2(double NF=5.);
58  double GammaQCD3(double NF=5.);
59  double betaQCD0(double NF=5.);
60  double betaQCD1(double NF=5.);
61  double betaQCD2(double NF=5.);
62 
63  // Function to calculate the correct running coupling/2*Pi value, including
64  // renormalisation scale variations + threshold matching.
65  double as2Pi(double pT2, int orderNow = -1, double renormMultFacNow = -1.);
66 
67  double softRescaleInt(int order);
68  double softRescaleDiff(int order, double pT2, double renormMultFacNow = -1.);
69  double beta0Endpoint(int order, double m2dip, double pT2, double z,
70  double renormMultFacNow = -1.);
71 
72  double polevl(double x,double* coef,int N );
73  double DiLog(double x);
74 
75  vector<int> sharedColor(const Event& event, int iRad, int iRec);
76  bool hasSharedColor(const Event& event, int iRad, int iRec);
77 
78  int findCol(int col, vector<int> iExc, const Event&, int type);
79 
80  bool useFastFunctions() { return true; }
81 
82  virtual vector <int> radAndEmt(int idDaughter, int)
83  { return createvector<int>(motherID(idDaughter))(sisterID(idDaughter)); }
84  virtual bool isPartial() { return true; }
85 
86  virtual int couplingType (int, int) { return 1; }
87  virtual double coupling (double z, double pT2, double m2dip,
88  double renormMultFacNow = -1.,
89  pair<int,bool> radBef = pair<int,bool>(),
90  pair<int,bool> recBef = pair<int,bool>()) {
91  if (!usePDFalphas && alphaSorder == 0) return alphaS2pi;
92  double scale2 = couplingScale2 ( z, pT2, m2dip, radBef, recBef);
93  if (scale2 < 0.) scale2 = pT2;
94  if (z < 0.) scale2 = pT2;
95  // Return coupling. Set up such the argument is NOT RESCALED in as2Pi
96  // function - rather guarantee that INPUT pT2/scale has desired value.
97  double fac = (renormMultFacNow > 0.) ? renormMultFacNow : renormMultFac;
98  return as2Pi(scale2, orderSave, fac);
99  }
100 
101  // Function determining the argument of the running coupling based on the
102  // splitting variables. Current default: Evolution variable.
103  // DireTimes:alphasScheme = 0 : default
104  // DireTimes:alphasScheme = 1 : collinear kinematic kT for all splittings
105  // involving incoming particles.
106  // DireTimes:alphasScheme = 2 : eikonal factor sij*sjk/sik
107  int asSchemeISR, asSchemeFSR;
108  virtual double couplingScale2 (double z, double pT2, double m2dip,
109  pair<int,bool> radBef, pair<int,bool> recBef) {
110  if ( radBef.second && recBef.second) {
111  if (asSchemeFSR == 0) return pT2;
112  if (asSchemeFSR == 1) return pT2;
113  if (asSchemeFSR == 2) {
114  double ycs = pT2/m2dip/(1.-z);
115  double sij = ycs*m2dip;
116  double sjk = (1.-z)*m2dip;
117  double sik = m2dip - sij - sjk;
118  return sij*sjk/sik;
119  }
120  } else if ( radBef.second && !recBef.second) {
121  if (asSchemeFSR == 0) return pT2;
122  if (asSchemeFSR == 1) {
123  double zcs = z;
124  double xcs = m2dip * zcs * (1.-zcs) / (pT2 + m2dip * zcs * (1.-zcs));
125  double kt2 = m2dip * (1.-xcs) / xcs * zcs * (1.-zcs);
126  return kt2;
127  }
128  if (asSchemeFSR == 2) {
129  double zcs = z;
130  double xcs = m2dip * zcs * (1.-zcs) / (pT2 + m2dip * zcs * (1.-zcs));
131  return (1-zcs)*(1-xcs)/xcs/zcs*m2dip;
132  }
133  } else if (!radBef.second && recBef.second) {
134  if (asSchemeISR == 0) return pT2;
135  if (asSchemeISR == 1) {
136  double xcs = z;
137  double ucs = pT2/m2dip / (1.-z);
138  double kt2 = m2dip * (1-xcs) / xcs * ucs * (1.-ucs);
139  return kt2;
140  }
141  if (asSchemeISR == 2) {
142  double xcs = z;
143  double ucs = pT2/m2dip / (1.-z);
144  return (1-xcs)/xcs*ucs/(1-ucs)*m2dip;
145  }
146  } else if (!radBef.second && !recBef.second) {
147  if (asSchemeISR == 0) return pT2;
148  if (asSchemeISR == 1) {
149  double xcs = ( z * (1.-z) - pT2/m2dip) / (1.-z);
150  double vcs = pT2/m2dip / (1.-z);
151  double kt2 = m2dip * vcs * (1.-xcs-vcs) / xcs;
152  return kt2;
153  }
154  if (asSchemeISR == 2) {
155  double xcs = ( z * (1.-z) - pT2/m2dip) / (1.-z);
156  double vcs = pT2/m2dip / (1.-z);
157  double sab = m2dip/xcs;
158  double saj = vcs*sab;
159  double sjb = sab-saj-m2dip;
160  return abs(saj*sjb/sab);
161  }
162  }
163  return -1.;
164  }
165 
166  // Functions that allow different ordering variables for emissions.
167  // Note: Only works after splitInfo has been properly filled.
168  virtual double getJacobian( const Event& = Event(),
169  PartonSystems* partonSystems = 0);
170  virtual unordered_map<string, double> getPhasespaceVars(
171  const Event& = Event(), PartonSystems* = 0);
172 
173  bool useBackboneGluons, doGeneralizedKernel;
174  double sCoef(int powz) { vector<double> tmp
175  = settingsPtr->pvec("DireGeneralizedKernel:softCoeffs:" + name());
176  return tmp[powz+1]; }
177  double sExp(int powz) { vector<double> tmp
178  = settingsPtr->pvec("DireGeneralizedKernel:softExps:" + name());
179  return tmp[powz+1]; }
180  double kCoef(int powz) { vector<double> tmp
181  = settingsPtr->pvec("DireGeneralizedKernel:kappaCoeffs:" + name());
182  return tmp[powz+1]; }
183  double kExp(int powz){ vector<double> tmp
184  = settingsPtr->pvec("DireGeneralizedKernel:kappaExps:" + name());
185  return tmp[powz+1]; }
186  double cCoef(int powz) { vector<double> tmp
187  = settingsPtr->pvec("DireGeneralizedKernel:collCoeffs:" + name());
188  return tmp[powz+1]; }
189  double cExp(int powz) { vector<double> tmp
190  = settingsPtr->pvec("DireGeneralizedKernel:collExps:" + name());
191  return tmp[powz+1]; }
192  double fCoef() { double tmp
193  = settingsPtr->parm("DireGeneralizedKernel:finCoeffs:" + name());
194  return tmp; }
195 
196  bool hasMECBef(const Event& state, double pT2);
197  bool hasMECAft(const Event& state, double pT2);
198 
199 };
200 
201 //==========================================================================
202 
203 class Dire_fsr_qcd_Q2QGG : public DireSplittingQCD {
204 
205 public:
206 
207  Dire_fsr_qcd_Q2QGG(string idIn, int softRS, Settings* settings,
208  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
209  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
210  DireSplittingQCD(idIn, softRS, settings, particleData, rndm, beamA, beamB,
211  coupSM, info, direInfo), is_sai_endpoint_save(false) {}
212 
213  bool canRadiate ( const Event&, pair<int,int>,
214  unordered_map<string,bool> = unordered_map<string,bool>(),
215  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
216 
217  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
218  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
219 
220  vector <int> radAndEmt(int idDaughter, int) {
221  return createvector<int>(idDaughter)(21)(21);}
222  int nEmissions() { return 2; }
223  int kinMap() { return 2;}
224  bool canUseForBranching() { return true; }
225 
226  vector<pair<int,int> > radAndEmtCols(int iRad, int colType, Event state);
227 
228  // Return colours of recombined radiator (before splitting!)
229  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
230  int colEmtAfter, int acolEmtAfter);
231 
232  // Return id of recombined radiator (before splitting!)
233  int radBefID(int idRadAfter, int idEmtAfter);
234 
235  double gaugeFactor ( int=0, int=0 );
236  double symmetryFactor ( int=0, int=0 );
237 
238  // Pick z for new splitting.
239  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
240 
241  // New overestimates, z-integrated versions.
242  double overestimateInt(double zMinAbs,double zMaxAbs,
243  double pT2Old, double m2dip, int order = -1);
244 
245  // Return kernel for new splitting.
246  double overestimateDiff(double z, double m2dip, int order = -1);
247 
248  // Functions to calculate the kernel from SplitInfo information.
249  bool calc(const Event& state = Event(), int order = -1);
250 
251  double counterTerm(double si1, double si2, double sj1,
252  double sj2, double sij, double s12);
253 
254  // Treatment of additional virtual corrections.
255  bool allow_sai_endpoint_for_kinematics() { return true; }
256  bool allow_xa_endpoint_for_kinematics() { return false; }
257  // Functions to set if kernel should contribute to a kinematical endpoint.
258  void try_sai_endpoint() { is_sai_endpoint_save = (rndmPtr->flat() < 0.5); }
259  void try_xa_endpoint() { return; }
260  // Return endpoint information.
261  bool is_sai_endpoint() { return is_sai_endpoint_save; }
262  bool is_xa_endpoint() { return false; }
263  bool is_sai_endpoint_save;
264 
265 };
266 
267 //==========================================================================
268 
269 class Dire_fsr_qcd_G2GGG : public DireSplittingQCD {
270 
271 public:
272 
273  Dire_fsr_qcd_G2GGG(string idIn, int softRS, Settings* settings,
274  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
275  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
276  DireSplittingQCD(idIn, softRS, settings, particleData, rndm, beamA, beamB,
277  coupSM, info, direInfo), is_sai_endpoint_save(false) {}
278 
279  bool canRadiate ( const Event&, pair<int,int>,
280  unordered_map<string,bool> = unordered_map<string,bool>(),
281  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
282 
283  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
284  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
285 
286  vector <int> radAndEmt(int,int) { return createvector<int>(21)(21)(21);}
287  int nEmissions() { return 2; }
288  int kinMap() { return 2;}
289  bool canUseForBranching() { return true; }
290 
291  vector<pair<int,int> > radAndEmtCols(int iRad, int colType, Event state);
292 
293  // Return colours of recombined radiator (before splitting!)
294  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
295  int colEmtAfter, int acolEmtAfter);
296 
297  // Return id of recombined radiator (before splitting!)
298  int radBefID(int idRadAfter, int idEmtAfter);
299 
300  double gaugeFactor ( int=0, int=0 );
301  double symmetryFactor ( int=0, int=0 );
302 
303  // Pick z for new splitting.
304  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
305 
306  // New overestimates, z-integrated versions.
307  double overestimateInt(double zMinAbs,double zMaxAbs,
308  double pT2Old, double m2dip, int order = -1);
309 
310  // Return kernel for new splitting.
311  double overestimateDiff(double z, double m2dip, int order = -1);
312 
313  // Functions to calculate the kernel from SplitInfo information.
314  bool calc(const Event& state = Event(), int order = -1);
315 
316  double counterTerm(double si1, double si2, double sj1,
317  double sj2, double sij, double s12);
318 
319  // Treatment of additional virtual corrections.
320  bool allow_sai_endpoint_for_kinematics() { return true; }
321  bool allow_xa_endpoint_for_kinematics() { return false; }
322  // Functions to set if kernel should contribute to a kinematical endpoint.
323  void try_sai_endpoint() { is_sai_endpoint_save = (rndmPtr->flat() < 0.5); }
324  void try_xa_endpoint() { return; }
325  // Return endpoint information.
326  bool is_sai_endpoint() { return is_sai_endpoint_save; }
327  bool is_xa_endpoint() { return false; }
328  bool is_sai_endpoint_save;
329 
330 };
331 
332 //==========================================================================
333 
334 class Dire_fsr_qcd_Q2Qqqbar : public DireSplittingQCD {
335 
336 public:
337 
338  Dire_fsr_qcd_Q2Qqqbar(int idEmtAfterIn, string idIn, int softRS,
339  Settings* settings,
340  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
341  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
342  DireSplittingQCD(idIn, softRS, settings, particleData, rndm, beamA, beamB,
343  coupSM, info, direInfo), idEmtAfterSave(idEmtAfterIn),
344  is_sai_endpoint_save(false)
345  { nGluonToQuark = settingsPtr->mode("TimeShower:nGluonToQuark"); }
346 
347  bool canRadiate ( const Event&, pair<int,int>,
348  unordered_map<string,bool> = unordered_map<string,bool>(),
349  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
350 
351  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
352  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
353 
354  virtual vector <int> radAndEmt(int idRadBef, int) {
355  return createvector<int>(idRadBef)(idEmtAfterSave)(-idEmtAfterSave);
356  }
357 
358  int nEmissions() { return 2;}
359  int kinMap() { return 2;}
360  bool canUseForBranching() { return true; }
361 
362  vector<pair<int,int> > radAndEmtCols(int iRad, int colType, Event state);
363 
364  // Return colours of recombined radiator (before splitting!)
365  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
366  int colEmtAfter, int acolEmtAfter);
367 
368  // Return id of recombined radiator (before splitting!)
369  int radBefID(int idRadAfter, int idEmtAfter);
370 
371  double gaugeFactor ( int=0, int=0 );
372  double symmetryFactor ( int=0, int=0 );
373 
374  // Pick z for new splitting.
375  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
376 
377  // New overestimates, z-integrated versions.
378  double overestimateInt(double zMinAbs,double zMaxAbs,
379  double pT2Old, double m2dip, int order = -1);
380 
381  // Return kernel for new splitting.
382  double overestimateDiff(double z, double m2dip, int order = -1);
383 
384  // Functions to calculate the kernel from SplitInfo information.
385  bool calc(const Event& state = Event(), int order = -1);
386 
387  int nGluonToQuark, idEmtAfterSave;
388 
389  double counterTerm(double si1, double si2, double sj1,
390  double sj2, double sij, double s12);
391 
392  // Treatment of additional virtual corrections.
393  bool allow_sai_endpoint_for_kinematics() { return true; }
394  bool allow_xa_endpoint_for_kinematics() { return false; }
395  // Functions to set if kernel should contribute to a kinematical endpoint.
396  void try_sai_endpoint() { is_sai_endpoint_save = (rndmPtr->flat() < 0.5); }
397  void try_xa_endpoint() { return; }
398  // Return endpoint information.
399  bool is_sai_endpoint() { return is_sai_endpoint_save; }
400  bool is_xa_endpoint() { return false; }
401  bool is_sai_endpoint_save;
402 
403 };
404 
405 //==========================================================================
406 
407 class Dire_fsr_qcd_G2Gqqbar : public DireSplittingQCD {
408 
409 public:
410 
411  Dire_fsr_qcd_G2Gqqbar(int idEmtAfterIn, string idIn, int softRS,
412  Settings* settings, ParticleData* particleData, Rndm* rndm,
413  BeamParticle* beamA, BeamParticle* beamB, CoupSM* coupSM, Info* info,
414  DireInfo* direInfo) :
415  DireSplittingQCD(idIn, softRS, settings, particleData, rndm, beamA, beamB,
416  coupSM, info, direInfo),
417  idEmtAfterSave(idEmtAfterIn), is_sai_endpoint_save(false)
418  { nGluonToQuark = settingsPtr->mode("TimeShower:nGluonToQuark"); }
419 
420  bool canRadiate ( const Event&, pair<int,int>,
421  unordered_map<string,bool> = unordered_map<string,bool>(),
422  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
423 
424  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
425  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
426 
427  virtual vector <int> radAndEmt(int, int colType) {
428  int sign = (colType > 0) ? 1 : -1;
429  int idEmtAft = sign * idEmtAfterSave;
430  return createvector<int>(21)(idEmtAft)(-idEmtAft);
431  }
432 
433  int nEmissions() { return 2; }
434  int kinMap() { return 2;}
435  bool canUseForBranching() { return true; }
436 
437  vector<pair<int,int> > radAndEmtCols(int iRad, int colType, Event state);
438 
439  // Return colours of recombined radiator (before splitting!)
440  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
441  int colEmtAfter, int acolEmtAfter);
442 
443  // Return id of recombined radiator (before splitting!)
444  int radBefID(int idRadAfter, int idEmtAfter);
445 
446  double gaugeFactor ( int=0, int=0 );
447  double symmetryFactor ( int=0, int=0 );
448 
449  // Pick z for new splitting.
450  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
451 
452  // New overestimates, z-integrated versions.
453  double overestimateInt(double zMinAbs,double zMaxAbs,
454  double pT2Old, double m2dip, int order = -1);
455 
456  // Return kernel for new splitting.
457  double overestimateDiff(double z, double m2dip, int order = -1);
458 
459  // Functions to calculate the kernel from SplitInfo information.
460  bool calc(const Event& state = Event(), int order = -1);
461 
462  int nGluonToQuark, idEmtAfterSave;
463 
464  double counterTerm(double si1, double si2, double sj1,
465  double sj2, double sij, double s12);
466 
467  // Treatment of additional virtual corrections.
468  bool allow_sai_endpoint_for_kinematics() { return true; }
469  bool allow_xa_endpoint_for_kinematics() { return false; }
470  // Functions to set if kernel should contribute to a kinematical endpoint.
471  void try_sai_endpoint() { is_sai_endpoint_save = (rndmPtr->flat() < 0.5); }
472  void try_xa_endpoint() { return; }
473  // Return endpoint information.
474  bool is_sai_endpoint() { return is_sai_endpoint_save; }
475  bool is_xa_endpoint() { return false; }
476  bool is_sai_endpoint_save;
477 
478 };
479 
480 //==========================================================================
481 
482 class Dire_fsr_qcd_Q2QG : public DireSplittingQCD {
483 
484 public:
485 
486  Dire_fsr_qcd_Q2QG(string idIn, int softRS, Settings* settings,
487  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
488  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
489  DireSplittingQCD(idIn, softRS, settings, particleData, rndm, beamA, beamB,
490  coupSM, info, direInfo){}
491 
492  bool canRadiate ( const Event&, pair<int,int>,
493  unordered_map<string,bool> = unordered_map<string,bool>(),
494  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
495  int nEmissions() { return 1; }
496 
497  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
498  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
499 
500  int kinMap ();
501 
502  // Return id of mother after splitting.
503  int motherID(int idDaughter);
504 
505  // Return id of emission.
506  int sisterID(int idDaughter);
507 
508  // Return id of recombined radiator (before splitting!)
509  int radBefID(int idRadAfter, int idEmtAfter);
510 
511  vector <int> recPositions( const Event&, int, int);
512 
513  // Return colours of recombined radiator (before splitting!)
514  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
515  int colEmtAfter, int acolEmtAfter);
516 
517  double gaugeFactor ( int=0, int=0 );
518  double symmetryFactor ( int=0, int=0 );
519 
520  // Pick z for new splitting.
521  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
522 
523  // New overestimates, z-integrated versions.
524  double overestimateInt(double zMinAbs,double zMaxAbs,
525  double pT2Old, double m2dip, int order = -1);
526 
527  // Return kernel for new splitting.
528  double overestimateDiff(double z, double m2dip, int order = -1);
529 
530  // Functions to calculate the kernel from SplitInfo information.
531  bool calc(const Event& state = Event(), int order = -1);
532 
533 };
534 
535 //==========================================================================
536 
537 class Dire_fsr_qcd_Q2GQ : public DireSplittingQCD {
538 
539 public:
540 
541  Dire_fsr_qcd_Q2GQ(string idIn, int softRS, Settings* settings,
542  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
543  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
544  DireSplittingQCD(idIn, softRS, settings, particleData, rndm, beamA, beamB,
545  coupSM, info, direInfo){}
546 
547  bool canRadiate ( const Event&, pair<int,int>,
548  unordered_map<string,bool> = unordered_map<string,bool>(),
549  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
550 
551  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
552  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
553 
554  int nEmissions() { return 1; }
555 
556  int kinMap ();
557 
558  // Return id of mother after splitting.
559  int motherID(int idDaughter);
560 
561  // Return id of emission.
562  int sisterID(int idDaughter);
563 
564  // Return id of recombined radiator (before splitting!)
565  int radBefID(int idRadAfter, int idEmtAfter);
566 
567  vector <int> recPositions( const Event&, int, int);
568 
569  // Return colours of recombined radiator (before splitting!)
570  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
571  int colEmtAfter, int acolEmtAfter);
572 
573  double gaugeFactor ( int=0, int=0 );
574  double symmetryFactor ( int=0, int=0 );
575 
576  // Pick z for new splitting.
577  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
578 
579  // New overestimates, z-integrated versions.
580  double overestimateInt(double zMinAbs,double zMaxAbs,
581  double pT2Old, double m2dip, int order = -1);
582 
583  // Return kernel for new splitting.
584  double overestimateDiff(double z, double m2dip, int order = -1);
585 
586  // Functions to calculate the kernel from SplitInfo information.
587  bool calc(const Event& state = Event(), int order = -1);
588 
589 };
590 
591 //==========================================================================
592 
593 class Dire_fsr_qcd_G2GG1 : public DireSplittingQCD {
594 
595 public:
596 
597  Dire_fsr_qcd_G2GG1(string idIn, int softRS, Settings* settings,
598  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
599  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
600  DireSplittingQCD(idIn, softRS, settings, particleData, rndm, beamA, beamB,
601  coupSM, info, direInfo){}
602 
603  bool canRadiate ( const Event&, pair<int,int>,
604  unordered_map<string,bool> = unordered_map<string,bool>(),
605  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
606 
607  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
608  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
609 
610  int nEmissions() { return 1; }
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  vector <int> recPositions( const Event&, int, int);
624 
625  // Return colours of recombined radiator (before splitting!)
626  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
627  int colEmtAfter, int acolEmtAfter);
628 
629  double gaugeFactor ( int=0, int=0 );
630  double symmetryFactor ( int=0, int=0 );
631 
632  // Pick z for new splitting.
633  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
634 
635  // New overestimates, z-integrated versions.
636  double overestimateInt(double zMinAbs,double zMaxAbs,
637  double pT2Old, double m2dip, int order = -1);
638 
639  // Return kernel for new splitting.
640  double overestimateDiff(double z, double m2dip, int order = -1);
641 
642  // Functions to calculate the kernel from SplitInfo information.
643  bool calc(const Event& state = Event(), int order = -1);
644 
645 };
646 
647 //==========================================================================
648 
649 class Dire_fsr_qcd_G2GG2 : public DireSplittingQCD {
650 
651 public:
652 
653  Dire_fsr_qcd_G2GG2(string idIn, int softRS, Settings* settings,
654  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
655  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
656  DireSplittingQCD(idIn, softRS, settings, particleData, rndm, beamA, beamB,
657  coupSM, info, direInfo){}
658 
659  bool canRadiate ( const Event&, pair<int,int>,
660  unordered_map<string,bool> = unordered_map<string,bool>(),
661  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
662 
663  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
664  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
665 
666  int nEmissions() { return 1; }
667 
668  int kinMap ();
669 
670  // Return id of mother after splitting.
671  int motherID(int idDaughter);
672 
673  // Return id of emission.
674  int sisterID(int idDaughter);
675 
676  // Return id of recombined radiator (before splitting!)
677  int radBefID(int idRadAfter, int idEmtAfter);
678 
679  vector <int> recPositions( const Event&, int, int);
680 
681  // Return colours of recombined radiator (before splitting!)
682  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
683  int colEmtAfter, int acolEmtAfter);
684 
685  double gaugeFactor ( int=0, int=0 );
686  double symmetryFactor ( int=0, int=0 );
687 
688  // Pick z for new splitting.
689  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
690 
691  // New overestimates, z-integrated versions.
692  double overestimateInt(double zMinAbs,double zMaxAbs,
693  double pT2Old, double m2dip, int order = -1);
694 
695  // Return kernel for new splitting.
696  double overestimateDiff(double z, double m2dip, int order = -1);
697 
698  // Functions to calculate the kernel from SplitInfo information.
699  bool calc(const Event& state = Event(), int order = -1);
700 
701 };
702 
703 //==========================================================================
704 
705 class Dire_fsr_qcd_G2QQ1 : public DireSplittingQCD {
706 
707 public:
708 
709  Dire_fsr_qcd_G2QQ1(string idIn, int softRS, Settings* settings,
710  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
711  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
712  DireSplittingQCD(idIn, softRS, settings, particleData, rndm, beamA, beamB,
713  coupSM, info, direInfo){}
714 
715  bool canRadiate ( const Event&, pair<int,int>,
716  unordered_map<string,bool> = unordered_map<string,bool>(),
717  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
718 
719  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
720  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
721 
722  int nEmissions() { return 1; }
723  bool isPartial() { return false; }
724  int kinMap ();
725 
726  // Return id of mother after splitting.
727  int motherID(int idDaughter);
728 
729  // Return id of emission.
730  int sisterID(int idDaughter);
731 
732  // Return id of recombined radiator (before splitting!)
733  int radBefID(int idRadAfter, int idEmtAfter);
734 
735  vector <int> recPositions( const Event&, int, int);
736 
737  // Return colours of recombined radiator (before splitting!)
738  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
739  int colEmtAfter, int acolEmtAfter);
740 
741  double gaugeFactor ( int=0, int=0 );
742  double symmetryFactor ( int=0, int=0 );
743 
744  // Pick z for new splitting.
745  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
746 
747  // New overestimates, z-integrated versions.
748  double overestimateInt(double zMinAbs,double zMaxAbs,
749  double pT2Old, double m2dip, int order = -1);
750 
751  // Return kernel for new splitting.
752  double overestimateDiff(double z, double m2dip, int order = -1);
753 
754  // Functions to calculate the kernel from SplitInfo information.
755  bool calc(const Event& state = Event(), int order = -1);
756 
757 };
758 
759 //==========================================================================
760 
761 class Dire_fsr_qcd_G2QQ2 : public DireSplittingQCD {
762 
763 public:
764 
765  Dire_fsr_qcd_G2QQ2(string idIn, int softRS, Settings* settings,
766  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
767  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
768  DireSplittingQCD(idIn, softRS, settings, particleData, rndm, beamA, beamB,
769  coupSM, info, direInfo){}
770 
771  bool canRadiate ( const Event&, pair<int,int>,
772  unordered_map<string,bool> = unordered_map<string,bool>(),
773  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
774 
775  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
776  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
777 
778  int nEmissions() { return 1; }
779  bool isPartial() { return false; }
780 
781  int kinMap ();
782 
783  // Return id of mother after splitting.
784  int motherID(int idDaughter);
785 
786  // Return id of emission.
787  int sisterID(int idDaughter);
788 
789  // Return id of recombined radiator (before splitting!)
790  int radBefID(int idRadAfter, int idEmtAfter);
791 
792  vector <int> recPositions( const Event&, int, int);
793 
794  // Return colours of recombined radiator (before splitting!)
795  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
796  int colEmtAfter, int acolEmtAfter);
797 
798  double gaugeFactor ( int=0, int=0 );
799  double symmetryFactor ( int=0, int=0 );
800 
801  // Pick z for new splitting.
802  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
803 
804  // New overestimates, z-integrated versions.
805  double overestimateInt(double zMinAbs,double zMaxAbs,
806  double pT2Old, double m2dip, int order = -1);
807 
808  // Return kernel for new splitting.
809  double overestimateDiff(double z, double m2dip, int order = -1);
810 
811  // Functions to calculate the kernel from SplitInfo information.
812  bool calc(const Event& state = Event(), int order = -1);
813 
814 };
815 
816 //==========================================================================
817 
818 class Dire_fsr_qcd_Q2qQqbarDist : public DireSplittingQCD {
819 
820 public:
821 
822  Dire_fsr_qcd_Q2qQqbarDist(string idIn, int softRS, Settings* settings,
823  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
824  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
825  DireSplittingQCD(idIn, softRS, settings, particleData, rndm, beamA, beamB,
826  coupSM, info, direInfo){}
827 
828  bool canRadiate ( const Event&, pair<int,int>,
829  unordered_map<string,bool> = unordered_map<string,bool>(),
830  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
831 
832  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
833  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
834 
835  int nEmissions() { return 2; }
836  bool isPartial() { return false; }
837 
838  int kinMap ();
839 
840  // Return id of mother after splitting.
841  int motherID(int idDaughter);
842 
843  // Return id of emission.
844  int sisterID(int idDaughter);
845 
846  // Return id of recombined radiator (before splitting!)
847  int radBefID(int idRadAfter, int idEmtAfter);
848 
849  // Return colours of recombined radiator (before splitting!)
850  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
851  int colEmtAfter, int acolEmtAfter);
852 
853  double gaugeFactor ( int=0, int=0 );
854  double symmetryFactor ( int=0, int=0 );
855 
856  // Pick z for new splitting.
857  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
858 
859  // New overestimates, z-integrated versions.
860  double overestimateInt(double zMinAbs,double zMaxAbs,
861  double pT2Old, double m2dip, int order = -1);
862 
863  // Return kernel for new splitting.
864  double overestimateDiff(double z, double m2dip, int order = -1);
865 
866  // Functions to calculate the kernel from SplitInfo information.
867  bool calc(const Event& state = Event(), int order = -1);
868 
869 };
870 
871 //==========================================================================
872 
873 class Dire_fsr_qcd_Q2QbarQQId : public DireSplittingQCD {
874 
875 public:
876 
877  Dire_fsr_qcd_Q2QbarQQId(string idIn, int softRS, Settings* settings,
878  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
879  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
880  DireSplittingQCD(idIn, softRS, settings, particleData, rndm, beamA, beamB,
881  coupSM, info, direInfo){}
882 
883  bool canRadiate ( const Event&, pair<int,int>,
884  unordered_map<string,bool> = unordered_map<string,bool>(),
885  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
886 
887  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
888  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
889 
890  int nEmissions() { return 2; }
891  bool isPartial() { return false; }
892 
893  int kinMap ();
894 
895  // Return id of mother after splitting.
896  int motherID(int idDaughter);
897 
898  // Return id of emission.
899  int sisterID(int idDaughter);
900 
901  // Return id of recombined radiator (before splitting!)
902  int radBefID(int idRadAfter, int idEmtAfter);
903 
904  // Return colours of recombined radiator (before splitting!)
905  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
906  int colEmtAfter, int acolEmtAfter);
907 
908  double gaugeFactor ( int=0, int=0 );
909  double symmetryFactor ( int=0, int=0 );
910 
911  // Pick z for new splitting.
912  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
913 
914  // New overestimates, z-integrated versions.
915  double overestimateInt(double zMinAbs,double zMaxAbs,
916  double pT2Old, double m2dip, int order = -1);
917 
918  // Return kernel for new splitting.
919  double overestimateDiff(double z, double m2dip, int order = -1);
920 
921  // Functions to calculate the kernel from SplitInfo information.
922  bool calc(const Event& state = Event(), int order = -1);
923 
924 };
925 
926 //==========================================================================
927 
928 class Dire_isr_qcd_Q2QG : public DireSplittingQCD {
929 
930 public:
931 
932  Dire_isr_qcd_Q2QG(string idIn, int softRS, Settings* settings,
933  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
934  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
935  DireSplittingQCD(idIn, softRS, settings, particleData, rndm, beamA, beamB,
936  coupSM, info, direInfo){}
937 
938  bool canRadiate ( const Event&, pair<int,int>,
939  unordered_map<string,bool> = unordered_map<string,bool>(),
940  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
941 
942  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
943  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
944 
945  int nEmissions() { return 1; }
946 
947  int kinMap ();
948 
949  // Return id of mother after splitting.
950  int motherID(int idDaughter);
951 
952  // Return id of emission.
953  int sisterID(int idDaughter);
954 
955  // Return id of recombined radiator (before splitting!)
956  int radBefID(int idRadAfter, int idEmtAfter);
957 
958  vector <int> recPositions( const Event&, int, int);
959 
960  // Return colours of recombined radiator (before splitting!)
961  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
962  int colEmtAfter, int acolEmtAfter);
963 
964  double gaugeFactor ( int=0, int=0 );
965  double symmetryFactor ( int=0, int=0 );
966 
967  // Pick z for new splitting.
968  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
969 
970  // New overestimates, z-integrated versions.
971  double overestimateInt(double zMinAbs,double zMaxAbs,
972  double pT2Old, double m2dip, int order = -1);
973 
974  // Return kernel for new splitting.
975  double overestimateDiff(double z, double m2dip, int order = -1);
976 
977  // Functions to calculate the kernel from SplitInfo information.
978  bool calc(const Event& state = Event(), int order = -1);
979 
980 };
981 
982 //==========================================================================
983 
984 class Dire_isr_qcd_G2GG1 : public DireSplittingQCD {
985 
986 public:
987 
988  Dire_isr_qcd_G2GG1(string idIn, int softRS, Settings* settings,
989  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
990  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
991  DireSplittingQCD(idIn, softRS, settings, particleData, rndm, beamA, beamB,
992  coupSM, info, direInfo){}
993 
994  bool canRadiate ( const Event&, pair<int,int>,
995  unordered_map<string,bool> = unordered_map<string,bool>(),
996  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
997 
998  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
999  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
1000 
1001  int nEmissions() { return 1; }
1002 
1003  int kinMap ();
1004 
1005  // Return id of mother after splitting.
1006  int motherID(int idDaughter);
1007 
1008  // Return id of emission.
1009  int sisterID(int idDaughter);
1010 
1011  // Return id of recombined radiator (before splitting!)
1012  int radBefID(int idRadAfter, int idEmtAfter);
1013 
1014  vector <int> recPositions( const Event&, int, int);
1015 
1016  // Return colours of recombined radiator (before splitting!)
1017  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
1018  int colEmtAfter, int acolEmtAfter);
1019 
1020  double gaugeFactor ( int=0, int=0 );
1021  double symmetryFactor ( int=0, int=0 );
1022 
1023  // Pick z for new splitting.
1024  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
1025 
1026  // New overestimates, z-integrated versions.
1027  double overestimateInt(double zMinAbs,double zMaxAbs,
1028  double pT2Old, double m2dip, int order = -1);
1029 
1030  // Return kernel for new splitting.
1031  double overestimateDiff(double z, double m2dip, int order = -1);
1032 
1033  // Functions to calculate the kernel from SplitInfo information.
1034  bool calc(const Event& state = Event(), int order = -1);
1035 
1036 };
1037 
1038 //==========================================================================
1039 
1040 class Dire_isr_qcd_G2GG2 : public DireSplittingQCD {
1041 
1042 public:
1043 
1044  Dire_isr_qcd_G2GG2(string idIn, int softRS, Settings* settings,
1045  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
1046  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
1047  DireSplittingQCD(idIn, softRS, settings, particleData, rndm, beamA, beamB,
1048  coupSM, info, direInfo){}
1049 
1050  bool canRadiate ( const Event&, pair<int,int>,
1051  unordered_map<string,bool> = unordered_map<string,bool>(),
1052  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
1053 
1054  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
1055  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
1056 
1057  int nEmissions() { return 1; }
1058 
1059  int kinMap ();
1060 
1061  // Return id of mother after splitting.
1062  int motherID(int idDaughter);
1063 
1064  // Return id of emission.
1065  int sisterID(int idDaughter);
1066 
1067  // Return id of recombined radiator (before splitting!)
1068  int radBefID(int idRadAfter, int idEmtAfter);
1069 
1070  vector <int> recPositions( const Event&, int, int);
1071 
1072  // Return colours of recombined radiator (before splitting!)
1073  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
1074  int colEmtAfter, int acolEmtAfter);
1075 
1076  double gaugeFactor ( int=0, int=0 );
1077  double symmetryFactor ( int=0, int=0 );
1078 
1079  // Pick z for new splitting.
1080  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
1081 
1082  // New overestimates, z-integrated versions.
1083  double overestimateInt(double zMinAbs,double zMaxAbs,
1084  double pT2Old, double m2dip, int order = -1);
1085 
1086  // Return kernel for new splitting.
1087  double overestimateDiff(double z, double m2dip, int order = -1);
1088 
1089  // Functions to calculate the kernel from SplitInfo information.
1090  bool calc(const Event& state = Event(), int order = -1);
1091 
1092 };
1093 
1094 //==========================================================================
1095 
1096 class Dire_isr_qcd_G2QQ : public DireSplittingQCD {
1097 
1098 public:
1099 
1100  Dire_isr_qcd_G2QQ(string idIn, int softRS, Settings* settings,
1101  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
1102  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
1103  DireSplittingQCD(idIn, softRS, settings, particleData, rndm, beamA, beamB,
1104  coupSM, info, direInfo){}
1105 
1106  bool canRadiate ( const Event&, pair<int,int>,
1107  unordered_map<string,bool> = unordered_map<string,bool>(),
1108  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
1109 
1110  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
1111  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
1112 
1113  int nEmissions() { return 1; }
1114  bool isPartial() { return false; }
1115 
1116  int kinMap ();
1117 
1118  // Return id of mother after splitting.
1119  int motherID(int idDaughter);
1120 
1121  // Return id of emission.
1122  int sisterID(int idDaughter);
1123 
1124  // Return id of recombined radiator (before splitting!)
1125  int radBefID(int idRadAfter, int idEmtAfter);
1126 
1127  vector <int> recPositions( const Event&, int, int);
1128 
1129  // Return colours of recombined radiator (before splitting!)
1130  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
1131  int colEmtAfter, int acolEmtAfter);
1132 
1133  double gaugeFactor ( int=0, int=0 );
1134  double symmetryFactor ( int=0, int=0 );
1135 
1136  // Pick z for new splitting.
1137  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
1138 
1139  // New overestimates, z-integrated versions.
1140  double overestimateInt(double zMinAbs,double zMaxAbs,
1141  double pT2Old, double m2dip, int order = -1);
1142 
1143  // Return kernel for new splitting.
1144  double overestimateDiff(double z, double m2dip, int order = -1);
1145 
1146  // Functions to calculate the kernel from SplitInfo information.
1147  bool calc(const Event& state = Event(), int order = -1);
1148 
1149 };
1150 
1151 //==========================================================================
1152 
1153 class Dire_isr_qcd_Q2GQ : public DireSplittingQCD {
1154 
1155 public:
1156 
1157  Dire_isr_qcd_Q2GQ(string idIn, int softRS, Settings* settings,
1158  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
1159  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
1160  DireSplittingQCD(idIn, softRS, settings, particleData, rndm, beamA, beamB,
1161  coupSM, info, direInfo){}
1162 
1163  bool canRadiate ( const Event&, pair<int,int>,
1164  unordered_map<string,bool> = unordered_map<string,bool>(),
1165  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
1166 
1167  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
1168  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
1169 
1170  int nEmissions() { return 1; }
1171  bool isPartial() { return false; }
1172 
1173  int kinMap ();
1174 
1175  // Return id of mother after splitting.
1176  int motherID(int idDaughter);
1177 
1178  // Return id of emission.
1179  int sisterID(int idDaughter);
1180 
1181  // Return id of recombined radiator (before splitting!)
1182  int radBefID(int idRadAfter, int idEmtAfter);
1183 
1184  vector <int> recPositions( const Event&, int, int);
1185 
1186  // Return colours of recombined radiator (before splitting!)
1187  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
1188  int colEmtAfter, int acolEmtAfter);
1189 
1190  double gaugeFactor ( int=0, int=0 );
1191  double symmetryFactor ( int=0, int=0 );
1192 
1193  // Pick z for new splitting.
1194  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
1195 
1196  // New overestimates, z-integrated versions.
1197  double overestimateInt(double zMinAbs,double zMaxAbs,
1198  double pT2Old, double m2dip, int order = -1);
1199 
1200  // Return kernel for new splitting.
1201  double overestimateDiff(double z, double m2dip, int order = -1);
1202 
1203  // Functions to calculate the kernel from SplitInfo information.
1204  bool calc(const Event& state = Event(), int order = -1);
1205 
1206 };
1207 
1208 //==========================================================================
1209 
1210 // Class inheriting from SplittingQCD class.
1211 class Dire_isr_qcd_Q2qQqbarDist : public DireSplittingQCD {
1212 
1213 public:
1214 
1215  Dire_isr_qcd_Q2qQqbarDist(string idIn, int softRS, Settings* settings,
1216  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
1217  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
1218  DireSplittingQCD(idIn, softRS, settings, particleData, rndm, beamA, beamB,
1219  coupSM, info, direInfo){}
1220 
1221  bool canRadiate ( const Event&, pair<int,int>,
1222  unordered_map<string,bool> = unordered_map<string,bool>(),
1223  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
1224 
1225  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
1226  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
1227 
1228  int nEmissions() { return 2; }
1229  bool isPartial() { return false; }
1230 
1231  int kinMap ();
1232 
1233  // Return id of mother after splitting.
1234  int motherID(int idDaughter);
1235 
1236  // Return id of emission.
1237  int sisterID(int idDaughter);
1238 
1239  // Return id of recombined radiator (before splitting!)
1240  int radBefID(int idRadAfter, int idEmtAfter);
1241 
1242  // Return colours of recombined radiator (before splitting!)
1243  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
1244  int colEmtAfter, int acolEmtAfter);
1245 
1246  double gaugeFactor ( int=0, int=0 );
1247  double symmetryFactor ( int=0, int=0 );
1248 
1249  // Pick z for new splitting.
1250  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
1251 
1252  // New overestimates, z-integrated versions.
1253  double overestimateInt(double zMinAbs,double zMaxAbs,
1254  double pT2Old, double m2dip, int order = -1);
1255 
1256  // Return kernel for new splitting.
1257  double overestimateDiff(double z, double m2dip, int order = -1);
1258 
1259  // Functions to calculate the kernel from SplitInfo information.
1260  bool calc(const Event& state = Event(), int order = -1);
1261 
1262 };
1263 
1264 //==========================================================================
1265 
1266 class Dire_isr_qcd_Q2QbarQQId : public DireSplittingQCD {
1267 
1268 public:
1269 
1270  Dire_isr_qcd_Q2QbarQQId(string idIn, int softRS, Settings* settings,
1271  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
1272  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
1273  DireSplittingQCD(idIn, softRS, settings, particleData, rndm, beamA, beamB,
1274  coupSM, info, direInfo){}
1275 
1276  bool canRadiate ( const Event&, pair<int,int>,
1277  unordered_map<string,bool> = unordered_map<string,bool>(),
1278  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
1279 
1280  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
1281  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
1282 
1283  int nEmissions() { return 2; }
1284  bool isPartial() { return false; }
1285 
1286  int kinMap ();
1287 
1288  // Return id of mother after splitting.
1289  int motherID(int idDaughter);
1290 
1291  // Return id of emission.
1292  int sisterID(int idDaughter);
1293 
1294  // Return id of recombined radiator (before splitting!)
1295  int radBefID(int idRadAfter, int idEmtAfter);
1296 
1297  // Return colours of recombined radiator (before splitting!)
1298  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
1299  int colEmtAfter, int acolEmtAfter);
1300 
1301  double gaugeFactor ( int=0, int=0 );
1302  double symmetryFactor ( int=0, int=0 );
1303 
1304  // Pick z for new splitting.
1305  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
1306 
1307  // New overestimates, z-integrated versions.
1308  double overestimateInt(double zMinAbs,double zMaxAbs,
1309  double pT2Old, double m2dip, int order = -1);
1310 
1311  // Return kernel for new splitting.
1312  double overestimateDiff(double z, double m2dip, int order = -1);
1313 
1314  // Functions to calculate the kernel from SplitInfo information.
1315  bool calc(const Event& state = Event(), int order = -1);
1316 
1317 };
1318 
1319 //==========================================================================
1320 
1321 class Dire_fsr_qcd_Q2QG_notPartial : public DireSplittingQCD {
1322 
1323 public:
1324 
1325  Dire_fsr_qcd_Q2QG_notPartial(string idIn, int softRS, Settings* settings,
1326  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
1327  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
1328  DireSplittingQCD(idIn, softRS, settings, particleData, rndm, beamA, beamB,
1329  coupSM, info, direInfo){}
1330 
1331  bool canRadiate ( const Event&, pair<int,int>,
1332  unordered_map<string,bool> = unordered_map<string,bool>(),
1333  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
1334 
1335  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
1336  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
1337 
1338  int nEmissions() { return 1; }
1339 
1340  int kinMap ();
1341  bool canUseForBranching() { return true; }
1342  bool isPartial() { return false; }
1343  vector<pair<int,int> > radAndEmtCols(int iRad, int, Event state);
1344 
1345  // Return id of mother after splitting.
1346  int motherID(int idDaughter);
1347 
1348  // Return id of emission.
1349  int sisterID(int idDaughter);
1350 
1351  // Return id of recombined radiator (before splitting!)
1352  int radBefID(int idRadAfter, int idEmtAfter);
1353 
1354  vector <int> recPositions( const Event&, int, int);
1355 
1356  // Return colours of recombined radiator (before splitting!)
1357  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
1358  int colEmtAfter, int acolEmtAfter);
1359 
1360  double gaugeFactor ( int=0, int=0 );
1361  double symmetryFactor ( int=0, int=0 );
1362 
1363  // Pick z for new splitting.
1364  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
1365 
1366  // New overestimates, z-integrated versions.
1367  double overestimateInt(double zMinAbs,double zMaxAbs,
1368  double pT2Old, double m2dip, int order = -1);
1369 
1370  // Return kernel for new splitting.
1371  double overestimateDiff(double z, double m2dip, int order = -1);
1372 
1373  // Functions to calculate the kernel from SplitInfo information.
1374  bool calc(const Event& state = Event(), int order = -1);
1375 
1376 };
1377 
1378 
1379 //==========================================================================
1380 
1381 class Dire_fsr_qcd_G2GG_notPartial : public DireSplittingQCD {
1382 
1383 public:
1384 
1385  Dire_fsr_qcd_G2GG_notPartial(string idIn, int softRS, Settings* settings,
1386  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
1387  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
1388  DireSplittingQCD(idIn, softRS, settings, particleData, rndm, beamA, beamB,
1389  coupSM, info, direInfo){}
1390 
1391  bool canRadiate ( const Event&, pair<int,int>,
1392  unordered_map<string,bool> = unordered_map<string,bool>(),
1393  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
1394 
1395  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
1396  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
1397 
1398  int nEmissions() { return 1; }
1399 
1400  int kinMap ();
1401  bool canUseForBranching() { return true; }
1402  bool isPartial() { return false; }
1403  vector<pair<int,int> > radAndEmtCols(int iRad, int, Event state);
1404 
1405  // Return id of mother after splitting.
1406  int motherID(int idDaughter);
1407 
1408  // Return id of emission.
1409  int sisterID(int idDaughter);
1410 
1411  // Return id of recombined radiator (before splitting!)
1412  int radBefID(int idRadAfter, int idEmtAfter);
1413 
1414  vector <int> recPositions( const Event&, int, int);
1415 
1416  // Return colours of recombined radiator (before splitting!)
1417  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
1418  int colEmtAfter, int acolEmtAfter);
1419 
1420  double gaugeFactor ( int=0, int=0 );
1421  double symmetryFactor ( int=0, int=0 );
1422 
1423  // Pick z for new splitting.
1424  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
1425 
1426  // New overestimates, z-integrated versions.
1427  double overestimateInt(double zMinAbs,double zMaxAbs,
1428  double pT2Old, double m2dip, int order = -1);
1429 
1430  // Return kernel for new splitting.
1431  double overestimateDiff(double z, double m2dip, int order = -1);
1432 
1433  // Functions to calculate the kernel from SplitInfo information.
1434  bool calc(const Event& state = Event(), int order = -1);
1435 
1436 };
1437 
1438 //==========================================================================
1439 
1440 class Dire_fsr_qcd_G2QQ_notPartial : public DireSplittingQCD {
1441 
1442 public:
1443 
1444  Dire_fsr_qcd_G2QQ_notPartial(string idIn, int softRS, Settings* settings,
1445  ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
1446  BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
1447  DireSplittingQCD(idIn, softRS, settings, particleData, rndm, beamA, beamB,
1448  coupSM, info, direInfo){}
1449 
1450  bool canRadiate ( const Event&, pair<int,int>,
1451  unordered_map<string,bool> = unordered_map<string,bool>(),
1452  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
1453 
1454  bool canRadiate ( const Event&, int iRadBef, int iRecBef,
1455  Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
1456 
1457  int nEmissions() { return 1; }
1458 
1459  int kinMap ();
1460  bool canUseForBranching() { return true; }
1461  bool isPartial() { return false; }
1462  vector<pair<int,int> > radAndEmtCols(int iRad, int, Event state);
1463 
1464  // Return id of mother after splitting.
1465  int motherID(int idDaughter);
1466 
1467  // Return id of emission.
1468  int sisterID(int idDaughter);
1469 
1470  // Return id of recombined radiator (before splitting!)
1471  int radBefID(int idRadAfter, int idEmtAfter);
1472 
1473  vector <int> recPositions( const Event&, int, int);
1474 
1475  // Return colours of recombined radiator (before splitting!)
1476  pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
1477  int colEmtAfter, int acolEmtAfter);
1478 
1479  double gaugeFactor ( int=0, int=0 );
1480  double symmetryFactor ( int=0, int=0 );
1481 
1482  // Pick z for new splitting.
1483  double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
1484 
1485  // New overestimates, z-integrated versions.
1486  double overestimateInt(double zMinAbs,double zMaxAbs,
1487  double pT2Old, double m2dip, int order = -1);
1488 
1489  // Return kernel for new splitting.
1490  double overestimateDiff(double z, double m2dip, int order = -1);
1491 
1492  // Functions to calculate the kernel from SplitInfo information.
1493  bool calc(const Event& state = Event(), int order = -1);
1494 
1495 };
1496 
1497 //==========================================================================
1498 
1499 } // end namespace Pythia8
1500 
1501 #endif // end Pythia8_DireSplittingsQCD_H
Pythia8::Dire_isr_qcd_G2GG1
Definition: DireSplittingsQCD.h:984
Pythia8::Dire_fsr_qcd_G2GG1
Definition: DireSplittingsQCD.h:593
Pythia8::Dire_isr_qcd_Q2QG
Definition: DireSplittingsQCD.h:928
Pythia8::Dire_isr_qcd_Q2QbarQQId
Definition: DireSplittingsQCD.h:1266
Pythia8::Dire_fsr_qcd_Q2Qqqbar
Definition: DireSplittingsQCD.h:334
Pythia8::Dire_fsr_qcd_Q2QGG
Definition: DireSplittingsQCD.h:203
Pythia8::Dire_isr_qcd_G2GG2
Definition: DireSplittingsQCD.h:1040
Pythia8::Dire_fsr_qcd_G2GG2
Definition: DireSplittingsQCD.h:649
Pythia8::Dire_fsr_qcd_Q2GQ
Definition: DireSplittingsQCD.h:537
Pythia8::Dire_fsr_qcd_Q2QG_notPartial
Definition: DireSplittingsQCD.h:1321
Pythia8::Dire_fsr_qcd_Q2qQqbarDist
Definition: DireSplittingsQCD.h:818
Pythia8::Dire_fsr_qcd_G2GG_notPartial
Definition: DireSplittingsQCD.h:1381
Pythia8::Dire_fsr_qcd_G2QQ1
Definition: DireSplittingsQCD.h:705
Pythia8::Dire_isr_qcd_Q2GQ
Definition: DireSplittingsQCD.h:1153
Pythia8::Dire_fsr_qcd_Q2QbarQQId
Definition: DireSplittingsQCD.h:873
Pythia8::Dire_fsr_qcd_G2QQ2
Definition: DireSplittingsQCD.h:761
Pythia8::Dire_isr_qcd_Q2qQqbarDist
Definition: DireSplittingsQCD.h:1211
Pythia8::Dire_fsr_qcd_G2GGG
Definition: DireSplittingsQCD.h:269
Pythia8::Dire_fsr_qcd_G2QQ_notPartial
Definition: DireSplittingsQCD.h:1440
Pythia8::Dire_fsr_qcd_Q2QG
Definition: DireSplittingsQCD.h:482
Pythia8::Dire_isr_qcd_G2QQ
Definition: DireSplittingsQCD.h:1096
Pythia8::Dire_fsr_qcd_G2Gqqbar
Definition: DireSplittingsQCD.h:407
Generated by   doxygen 1.8.5