include/Pythia8/DireSplittingsEW.h

0001 // DireSplittingsEW.h is a part of the PYTHIA event generator.
0002 // Copyright (C) 2024 Stefan Prestel, Torbjorn Sjostrand.
0003 // PYTHIA is licenced under the GNU GPL v2 or later, see COPYING for details.
0004 // Please respect the MCnet Guidelines, see GUIDELINES for details.
0005
0006 // Header file for the Dire electroweak splitings.
0007
0008 #ifndef Pythia8_DireSplittingsEW_H
0009 #define Pythia8_DireSplittingsEW_H
0010
0011 #define DIRE_SPLITTINGSEW_VERSION "2.002"
0012
0013 #include "Pythia8/Basics.h"
0014 #include "Pythia8/BeamParticle.h"
0015 #include "Pythia8/ParticleData.h"
0016 #include "Pythia8/PythiaStdlib.h"
0017 #include "Pythia8/Settings.h"
0018
0019 #include "Pythia8/DireSplittingsQCD.h"
0020
0021 namespace Pythia8 {
0022
0023 //==========================================================================
0024
0025 class DireSplittingEW : public DireSplittingQCD {
0026
0027 public:
0028
0029   // Constructor and destructor.
0030   DireSplittingEW(string idIn, int softRS, Settings* settings,
0031     ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
0032     BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
0033     DireSplittingQCD(idIn,
0034       softRS,settings,particleData,rndm,beamA,beamB,coupSM,info, direInfo)
0035     { init(); }
0036   virtual ~DireSplittingEW() {}
0037
0038   void init();
0039
0040   // Z0 and W+- properties needed for gamma/Z0 mixing and weak showers.
0041   double mZ, gammaZ, thetaW, mW, gammaW, aem0, enhance;
0042   bool doQEDshowerByQ, doQEDshowerByL;
0043
0044   AlphaEM     alphaEM;
0045
0046   // Function to calculate the correct running coupling/2*Pi value, including
0047   // renormalisation scale variations + threshold matching.
0048   double aem2Pi ( double pT2);
0049
0050   bool useFastFunctions() { return true; }
0051
0052   virtual vector <int> radAndEmt(int idDaughter, int)
0053    { return createvector<int>(motherID(idDaughter))(sisterID(idDaughter)); }
0054   virtual int nEmissions()  { return 1; }
0055   virtual bool isPartial()  { return true; }
0056
0057   virtual bool canUseForBranching() { return true; }
0058
0059   virtual int couplingType (int, int) { return 2; }
0060   virtual double coupling (double = 0., double = 0., double = 0., double = -1.,
0061     pair<int,bool> = pair<int,bool>(), pair<int,bool> = pair<int,bool>()) {
0062     return (aem0 / (2.*M_PI));
0063   }
0064   virtual double couplingScale2 (double = 0., double = 0., double = 0.,
0065     pair<int,bool> = pair<int,bool>(), pair<int,bool> = pair<int,bool>()) {
0066     return -1.;
0067   }
0068
0069 };
0070
0071 //==========================================================================
0072
0073 class Dire_fsr_ew_Q2QZ : public DireSplittingEW {
0074
0075 public:
0076
0077   Dire_fsr_ew_Q2QZ(string idIn, int softRS, Settings* settings,
0078     ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
0079     BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
0080     DireSplittingEW(idIn, softRS, settings, particleData, rndm, beamA, beamB,
0081       coupSM, info, direInfo){}
0082
0083   bool canRadiate ( const Event&, pair<int,int>,
0084     unordered_map<string,bool> = unordered_map<string,bool>(),
0085     Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
0086   bool canRadiate ( const Event&, int, int,
0087     Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL)
0088     {return false;}
0089
0090   int kinMap ();
0091
0092   // Return id of mother after splitting.
0093   int motherID(int idDaughter);
0094
0095   // Return id of emission.
0096   int sisterID(int idDaughter);
0097
0098   // Return id of recombined radiator (before splitting!)
0099   int radBefID(int idRadAfter, int idEmtAfter);
0100
0101   // Return colours of recombined radiator (before splitting!)
0102   pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
0103     int colEmtAfter, int acolEmtAfter);
0104
0105   double gaugeFactor ( int=0, int=0);
0106   double symmetryFactor ( int=0, int=0);
0107
0108   // Pick z for new splitting.
0109   double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
0110
0111   // New overestimates, z-integrated versions.
0112   double overestimateInt(double zMinAbs,double zMaxAbs,
0113     double pT2Old, double m2dip, int order = -1);
0114
0115   // Return kernel for new splitting.
0116   double overestimateDiff(double z, double m2dip, int order = -1);
0117
0118   // Functions to calculate the kernel from SplitInfo information.
0119   bool calc(const Event& state = Event(), int order = -1);
0120
0121 };
0122
0123 class Dire_fsr_ew_Q2ZQ : public DireSplittingEW {
0124
0125 public:
0126
0127   Dire_fsr_ew_Q2ZQ(string idIn, int softRS, Settings* settings,
0128     ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
0129     BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
0130     DireSplittingEW(idIn, softRS, settings, particleData, rndm, beamA, beamB,
0131       coupSM, info, direInfo){}
0132
0133   bool canRadiate ( const Event&, pair<int,int>,
0134     unordered_map<string,bool> = unordered_map<string,bool>(),
0135     Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
0136   bool canRadiate ( const Event&, int, int,
0137     Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL)
0138     {return false;}
0139
0140   int kinMap ();
0141
0142   // Return id of mother after splitting.
0143   int motherID(int idDaughter);
0144
0145   // Return id of emission.
0146   int sisterID(int idDaughter);
0147
0148   // Return id of recombined radiator (before splitting!)
0149   int radBefID(int idRadAfter, int idEmtAfter);
0150
0151   // Return colours of recombined radiator (before splitting!)
0152   pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
0153     int colEmtAfter, int acolEmtAfter);
0154
0155   double gaugeFactor ( int=0, int=0);
0156   double symmetryFactor ( int=0, int=0);
0157
0158   // Pick z for new splitting.
0159   double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
0160
0161   // New overestimates, z-integrated versions.
0162   double overestimateInt(double zMinAbs,double zMaxAbs,
0163     double pT2Old, double m2dip, int order = -1);
0164
0165   // Return kernel for new splitting.
0166   double overestimateDiff(double z, double m2dip, int order = -1);
0167
0168   // Functions to calculate the kernel from SplitInfo information.
0169   bool calc(const Event& state = Event(), int order = -1);
0170
0171 };
0172
0173 class Dire_fsr_ew_Z2QQ1 : public DireSplittingEW {
0174
0175 public:
0176
0177   Dire_fsr_ew_Z2QQ1(string idIn, int softRS, Settings* settings,
0178     ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
0179     BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
0180     DireSplittingEW(idIn, softRS, settings, particleData, rndm, beamA, beamB,
0181       coupSM, info, direInfo){}
0182
0183   bool canRadiate ( const Event&, pair<int,int>,
0184     unordered_map<string,bool> = unordered_map<string,bool>(),
0185     Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
0186   bool canRadiate ( const Event&, int, int,
0187     Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL)
0188     {return false;}
0189
0190   int kinMap ();
0191
0192   // Return id of mother after splitting.
0193   int motherID(int idDaughter);
0194
0195   // Return id of emission.
0196   int sisterID(int idDaughter);
0197
0198   // Return id of recombined radiator (before splitting!)
0199   int radBefID(int idRadAfter, int idEmtAfter);
0200
0201   // Return colours of recombined radiator (before splitting!)
0202   pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
0203     int colEmtAfter, int acolEmtAfter);
0204
0205   double gaugeFactor ( int=0, int=0);
0206   double symmetryFactor ( int=0, int=0);
0207
0208   // Pick z for new splitting.
0209   double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
0210
0211   // New overestimates, z-integrated versions.
0212   double overestimateInt(double zMinAbs,double zMaxAbs,
0213     double pT2Old, double m2dip, int order = -1);
0214
0215   // Return kernel for new splitting.
0216   double overestimateDiff(double z, double m2dip, int order = -1);
0217
0218   // Functions to calculate the kernel from SplitInfo information.
0219   bool calc(const Event& state = Event(), int order = -1);
0220
0221 };
0222
0223 class Dire_fsr_ew_Z2QQ2 : public DireSplittingEW {
0224
0225 public:
0226
0227   Dire_fsr_ew_Z2QQ2(string idIn, int softRS, Settings* settings,
0228     ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
0229     BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
0230     DireSplittingEW(idIn, softRS, settings, particleData, rndm, beamA, beamB,
0231       coupSM, info, direInfo){}
0232
0233   bool canRadiate ( const Event&, pair<int,int>,
0234     unordered_map<string,bool> = unordered_map<string,bool>(),
0235     Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
0236   bool canRadiate ( const Event&, int, int,
0237     Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL)
0238     {return false;}
0239
0240   int kinMap ();
0241
0242   // Return id of mother after splitting.
0243   int motherID(int idDaughter);
0244
0245   // Return id of emission.
0246   int sisterID(int idDaughter);
0247
0248   // Return id of recombined radiator (before splitting!)
0249   int radBefID(int idRadAfter, int idEmtAfter);
0250
0251   // Return colours of recombined radiator (before splitting!)
0252   pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
0253     int colEmtAfter, int acolEmtAfter);
0254
0255   double gaugeFactor ( int=0, int=0);
0256   double symmetryFactor ( int=0, int=0);
0257
0258   // Pick z for new splitting.
0259   double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
0260
0261   // New overestimates, z-integrated versions.
0262   double overestimateInt(double zMinAbs,double zMaxAbs,
0263     double pT2Old, double m2dip, int order = -1);
0264
0265   // Return kernel for new splitting.
0266   double overestimateDiff(double z, double m2dip, int order = -1);
0267
0268   // Functions to calculate the kernel from SplitInfo information.
0269   bool calc(const Event& state = Event(), int order = -1);
0270
0271 };
0272
0273 class Dire_fsr_ew_W2QQ1 : public DireSplittingEW {
0274
0275 public:
0276
0277   Dire_fsr_ew_W2QQ1(string idIn, int softRS, Settings* settings,
0278     ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
0279     BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
0280     DireSplittingEW(idIn, softRS, settings, particleData, rndm, beamA, beamB,
0281       coupSM, info, direInfo){}
0282
0283   bool canRadiate ( const Event&, pair<int,int>,
0284     unordered_map<string,bool> = unordered_map<string,bool>(),
0285     Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
0286   bool canRadiate ( const Event&, int, int,
0287     Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL)
0288     {return false;}
0289
0290   int kinMap ();
0291
0292   // Return id of mother after splitting.
0293   int motherID(int idDaughter);
0294
0295   // Return id of emission.
0296   int sisterID(int idDaughter);
0297
0298   // Return id of recombined radiator (before splitting!)
0299   int radBefID(int idRadAfter, int idEmtAfter);
0300
0301   // Return colours of recombined radiator (before splitting!)
0302   pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
0303     int colEmtAfter, int acolEmtAfter);
0304
0305   double gaugeFactor ( int=0, int=0);
0306   double symmetryFactor ( int=0, int=0);
0307
0308   // Pick z for new splitting.
0309   double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
0310
0311   // New overestimates, z-integrated versions.
0312   double overestimateInt(double zMinAbs,double zMaxAbs,
0313     double pT2Old, double m2dip, int order = -1);
0314
0315   // Return kernel for new splitting.
0316   double overestimateDiff(double z, double m2dip, int order = -1);
0317
0318   // Functions to calculate the kernel from SplitInfo information.
0319   bool calc(const Event& state = Event(), int order = -1);
0320
0321 };
0322
0323 class Dire_fsr_ew_W2QQ2 : public DireSplittingEW {
0324
0325 public:
0326
0327   Dire_fsr_ew_W2QQ2(string idIn, int softRS, Settings* settings,
0328     ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
0329     BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
0330     DireSplittingEW(idIn, softRS, settings, particleData, rndm, beamA, beamB,
0331       coupSM, info, direInfo){}
0332
0333   bool canRadiate ( const Event&, pair<int,int>,
0334     unordered_map<string,bool> = unordered_map<string,bool>(),
0335     Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
0336   bool canRadiate ( const Event&, int, int,
0337     Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL)
0338     {return false;}
0339
0340   int kinMap ();
0341
0342   // Return id of mother after splitting.
0343   int motherID(int idDaughter);
0344
0345   // Return id of emission.
0346   int sisterID(int idDaughter);
0347
0348   // Return id of recombined radiator (before splitting!)
0349   int radBefID(int idRadAfter, int idEmtAfter);
0350
0351   // Return colours of recombined radiator (before splitting!)
0352   pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
0353     int colEmtAfter, int acolEmtAfter);
0354
0355   double gaugeFactor ( int=0, int=0);
0356   double symmetryFactor ( int=0, int=0);
0357
0358   // Pick z for new splitting.
0359   double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
0360
0361   // New overestimates, z-integrated versions.
0362   double overestimateInt(double zMinAbs,double zMaxAbs,
0363     double pT2Old, double m2dip, int order = -1);
0364
0365   // Return kernel for new splitting.
0366   double overestimateDiff(double z, double m2dip, int order = -1);
0367
0368   // Functions to calculate the kernel from SplitInfo information.
0369   bool calc(const Event& state = Event(), int order = -1);
0370
0371 };
0372
0373 //==========================================================================
0374
0375 class Dire_fsr_ew_H2WW : public DireSplittingEW {
0376
0377 public:
0378
0379   Dire_fsr_ew_H2WW(string idIn, int softRS, Settings* settings,
0380     ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
0381     BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
0382     DireSplittingEW(idIn, softRS, settings, particleData, rndm, beamA, beamB,
0383       coupSM, info, direInfo){}
0384
0385   bool canRadiate ( const Event&, pair<int,int>,
0386     unordered_map<string,bool> = unordered_map<string,bool>(),
0387     Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
0388   bool canRadiate ( const Event&, int, int,
0389     Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL)
0390     {return false;}
0391
0392   int kinMap ();
0393
0394   // Return id of mother after splitting.
0395   int motherID(int idDaughter);
0396
0397   // Return id of emission.
0398   int sisterID(int idDaughter);
0399
0400   // Return id of recombined radiator (before splitting!)
0401   int radBefID(int idRadAfter, int idEmtAfter);
0402
0403   // Return colours of recombined radiator (before splitting!)
0404   pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
0405     int colEmtAfter, int acolEmtAfter);
0406
0407   double gaugeFactor ( int=0, int=0);
0408   double symmetryFactor ( int=0, int=0);
0409
0410   // Pick z for new splitting.
0411   double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
0412
0413   // New overestimates, z-integrated versions.
0414   double overestimateInt(double zMinAbs,double zMaxAbs,
0415     double pT2Old, double m2dip, int order = -1);
0416
0417   // Return kernel for new splitting.
0418   double overestimateDiff(double z, double m2dip, int order = -1);
0419
0420   // Functions to calculate the kernel from SplitInfo information.
0421   bool calc(const Event& state = Event(), int order = -1);
0422
0423 };
0424
0425 //==========================================================================
0426
0427 class Dire_fsr_ew_H2AA : public DireSplittingEW {
0428
0429 public:
0430
0431   Dire_fsr_ew_H2AA(string idIn, int softRS, Settings* settings,
0432     ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
0433     BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
0434     DireSplittingEW(idIn, softRS, settings, particleData, rndm, beamA, beamB,
0435       coupSM, info, direInfo) {
0436     widthToAA = particleDataPtr->particleDataEntryPtr(25)->resWidthChan(
0437       particleDataPtr->m0(25), 22, 22);
0438     widthTot = settings->parm("MEM:WidthH");
0439   }
0440
0441   bool canRadiate ( const Event&, pair<int,int>,
0442     unordered_map<string,bool> = unordered_map<string,bool>(),
0443     Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
0444   bool canRadiate ( const Event&, int iRadBef, int iRecBef,
0445     Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
0446   bool isPartial()  { return false; }
0447
0448   bool isSymmetric( const Particle* rad, const Particle* emt) {
0449    if (rad->id() == 22 && emt->id() == 22) return true;
0450    return false;
0451   }
0452
0453   int couplingType (int, int);
0454   double coupling (double = 0., double = 0., double = 0., double = -1.,
0455   pair<int,bool> = pair<int,bool>(), pair<int,bool> = pair<int,bool>());
0456
0457   int kinMap ();
0458
0459   // Return id of mother after splitting.
0460   int motherID(int idDaughter);
0461
0462   // Return id of emission.
0463   int sisterID(int idDaughter);
0464
0465   // Return id of recombined radiator (before splitting!)
0466   int radBefID(int idRadAfter, int idEmtAfter);
0467
0468   vector <int> recPositions( const Event& state, int iRad, int iEmt);
0469
0470   // Return colours of recombined radiator (before splitting!)
0471   pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
0472     int colEmtAfter, int acolEmtAfter);
0473
0474   double gaugeFactor ( int=0, int=0);
0475   double symmetryFactor ( int=0, int=0);
0476
0477   // Pick z for new splitting.
0478   double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
0479
0480   // New overestimates, z-integrated versions.
0481   double overestimateInt(double zMinAbs,double zMaxAbs,
0482     double pT2Old, double m2dip, int order = -1);
0483
0484   // Return kernel for new splitting.
0485   double overestimateDiff(double z, double m2dip, int order = -1);
0486
0487   // Functions to calculate the kernel from SplitInfo information.
0488   bool calc(const Event& state = Event(), int order = -1);
0489
0490   double widthToAA, widthTot;
0491
0492 };
0493
0494 //==========================================================================
0495
0496 class Dire_fsr_ew_H2GG : public DireSplittingEW {
0497
0498 public:
0499
0500   Dire_fsr_ew_H2GG(string idIn, int softRS, Settings* settings,
0501     ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
0502     BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
0503     DireSplittingEW(idIn, softRS, settings, particleData, rndm, beamA, beamB,
0504       coupSM, info, direInfo) {
0505     widthToGG = particleDataPtr->particleDataEntryPtr(25)->resWidthChan(
0506       particleDataPtr->m0(25), 21, 21);
0507     widthTot = settings->parm("MEM:WidthH");
0508   }
0509
0510   bool canRadiate ( const Event&, pair<int,int>,
0511     unordered_map<string,bool> = unordered_map<string,bool>(),
0512     Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
0513   bool canRadiate ( const Event&, int iRadBef, int iRecBef,
0514     Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
0515   bool isPartial()  { return false; }
0516
0517   bool isSymmetric( const Particle* rad, const Particle* emt) {
0518    if (rad->id() == 21 && emt->id() == 21) return true;
0519    return false;
0520   }
0521
0522   int couplingType (int, int);
0523   double coupling (double = 0., double = 0., double = 0., double = -1.,
0524   pair<int,bool> = pair<int,bool>(), pair<int,bool> = pair<int,bool>());
0525
0526   int kinMap ();
0527
0528   // Return id of mother after splitting.
0529   int motherID(int idDaughter);
0530
0531   // Return id of emission.
0532   int sisterID(int idDaughter);
0533
0534   // Return id of recombined radiator (before splitting!)
0535   int radBefID(int idRadAfter, int idEmtAfter);
0536
0537   vector <int> recPositions( const Event& state, int iRad, int iEmt);
0538
0539   // Return colours of recombined radiator (before splitting!)
0540   pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
0541     int colEmtAfter, int acolEmtAfter);
0542
0543   double gaugeFactor ( int=0, int=0);
0544   double symmetryFactor ( int=0, int=0);
0545
0546   // Pick z for new splitting.
0547   double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
0548
0549   // New overestimates, z-integrated versions.
0550   double overestimateInt(double zMinAbs,double zMaxAbs,
0551     double pT2Old, double m2dip, int order = -1);
0552
0553   // Return kernel for new splitting.
0554   double overestimateDiff(double z, double m2dip, int order = -1);
0555
0556   // Functions to calculate the kernel from SplitInfo information.
0557   bool calc(const Event& state = Event(), int order = -1);
0558
0559   double widthToGG, widthTot;
0560
0561 };
0562
0563 //==========================================================================
0564
0565 class Dire_fsr_ew_W2WA : public DireSplittingEW {
0566
0567 public:
0568
0569   Dire_fsr_ew_W2WA(string idIn, int softRS, Settings* settings,
0570     ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
0571     BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
0572     DireSplittingEW(idIn, softRS, settings, particleData, rndm, beamA, beamB,
0573       coupSM, info, direInfo){}
0574
0575   bool canRadiate ( const Event&, pair<int,int>,
0576     unordered_map<string,bool> = unordered_map<string,bool>(),
0577     Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
0578   bool canRadiate ( const Event&, int iRadBef, int iRecBef,
0579     Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
0580
0581   int kinMap ();
0582
0583   // Return id of mother after splitting.
0584   int motherID(int idDaughter);
0585
0586   // Return id of emission.
0587   int sisterID(int idDaughter);
0588
0589   // Return id of recombined radiator (before splitting!)
0590   int radBefID(int idRadAfter, int idEmtAfter);
0591
0592   vector <int> recPositions( const Event& state, int iRad, int iEmt);
0593
0594   // Return colours of recombined radiator (before splitting!)
0595   pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
0596     int colEmtAfter, int acolEmtAfter);
0597
0598   vector<pair<int,int> > radAndEmtCols(int iRad, int, Event state) {
0599     vector< pair<int,int> > ret;
0600     if (state[iRad].idAbs() != 24) return ret;
0601     ret = createvector<pair<int,int> >(make_pair(0, 0))(make_pair(0, 0));
0602     return ret;
0603   }
0604
0605   double gaugeFactor ( int=0, int=0);
0606   double symmetryFactor ( int=0, int=0);
0607
0608   // Pick z for new splitting.
0609   double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
0610
0611   // New overestimates, z-integrated versions.
0612   double overestimateInt(double zMinAbs,double zMaxAbs,
0613     double pT2Old, double m2dip, int order = -1);
0614
0615   // Return kernel for new splitting.
0616   double overestimateDiff(double z, double m2dip, int order = -1);
0617
0618   // Functions to calculate the kernel from SplitInfo information.
0619   bool calc(const Event& state = Event(), int order = -1);
0620
0621 };
0622
0623 //==========================================================================
0624
0625 class Dire_isr_ew_Q2QZ : public DireSplittingEW {
0626
0627 public:
0628
0629   Dire_isr_ew_Q2QZ(string idIn, int softRS, Settings* settings,
0630     ParticleData* particleData, Rndm* rndm, BeamParticle* beamA,
0631     BeamParticle* beamB, CoupSM* coupSM, Info* info, DireInfo* direInfo) :
0632     DireSplittingEW(idIn, softRS, settings, particleData, rndm, beamA, beamB,
0633       coupSM, info, direInfo){}
0634
0635   bool canRadiate ( const Event&, pair<int,int>,
0636     unordered_map<string,bool> = unordered_map<string,bool>(),
0637     Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL);
0638   bool canRadiate ( const Event&, int, int,
0639     Settings* = NULL, PartonSystems* = NULL, BeamParticle* = NULL)
0640     {return false;}
0641
0642   int kinMap ();
0643
0644   // Return id of mother after splitting.
0645   int motherID(int idDaughter);
0646
0647   // Return id of emission.
0648   int sisterID(int idDaughter);
0649
0650   // Return id of recombined radiator (before splitting!)
0651   int radBefID(int idRadAfter, int idEmtAfter);
0652
0653   // Return colours of recombined radiator (before splitting!)
0654   pair<int,int> radBefCols(int colRadAfter, int acolRadAfter,
0655     int colEmtAfter, int acolEmtAfter);
0656
0657   double gaugeFactor ( int=0, int=0);
0658   double symmetryFactor ( int=0, int=0);
0659
0660   // Pick z for new splitting.
0661   double zSplit(double zMinAbs, double zMaxAbs, double m2dip);
0662
0663   // New overestimates, z-integrated versions.
0664   double overestimateInt(double zMinAbs,double zMaxAbs,
0665     double pT2Old, double m2dip, int order = -1);
0666
0667   // Return kernel for new splitting.
0668   double overestimateDiff(double z, double m2dip, int order = -1);
0669
0670   // Functions to calculate the kernel from SplitInfo information.
0671   bool calc(const Event& state = Event(), int order = -1);
0672
0673 };
0674
0675 } // end namespace Pythia8
0676
0677 #endif // Pythia8_DireSplittingLibrary_H