PYTHIA8/pythia8130/src/SigmaLeptoquark.cxx

   1 // SigmaLeptoquark.cc is a part of the PYTHIA event generator.
   2 // Copyright (C) 2008 Torbjorn Sjostrand.
   3 // PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
   4 // Please respect the MCnet Guidelines, see GUIDELINES for details.
   5
   6 // Function definitions (not found in the header) for the
   7 // leptoquark simulation classes.
   8
   9 #include "SigmaLeptoquark.h"
  10
  11 namespace Pythia8 {
  12
  13 //**************************************************************************
  14
  15 // Sigma1ql2LeptoQuark class.
  16 // Cross section for q l -> LQ (leptoquark state).
  17
  18 //*********
  19
  20 // Initialize process.
  21
  22 void Sigma1ql2LeptoQuark::initProc() {
  23
  24   // Store LQ mass and width for propagator.
  25   mRes     = ParticleDataTable::m0(42);
  26   GammaRes = ParticleDataTable::mWidth(42);
  27   m2Res    = mRes*mRes;
  28   GamMRat  = GammaRes / mRes;
  29
  30   // Yukawa coupling strength.
  31   kCoup    = Settings::parm("LeptoQuark:kCoup");
  32
  33   // Set pointer to particle properties and decay table.
  34   LQPtr    = ParticleDataTable::particleDataPtr(42);
  35
  36   // Read out quark and lepton the LQ couples to.
  37   idQuark  = LQPtr->decay[0].product(0);
  38   idLepton = LQPtr->decay[0].product(1);
  39
  40 }
  41
  42 //*********
  43
  44 // Evaluate sigmaHat(sHat), part independent of incoming flavour.
  45
  46 void Sigma1ql2LeptoQuark::sigmaKin() {
  47
  48   // Incoming width for correct quark-lepton pair..
  49   widthIn  = 0.25 * alpEM * kCoup * mH;
  50
  51   // Set up Breit-Wigner.
  52   sigBW    = 4. * M_PI/ ( pow2(sH - m2Res) + pow2(sH * GamMRat) );
  53
  54 }
  55
  56 //*********
  57
  58 // Evaluate sigmaHat(sHat) for specific incoming flavours.
  59
  60 double Sigma1ql2LeptoQuark::sigmaHat() {
  61
  62   // Identify whether correct incoming flavours.
  63   int idLQ = 0;
  64   if      (id1 ==  idQuark && id2 ==  idLepton) idLQ =  42;
  65   else if (id2 ==  idQuark && id1 ==  idLepton) idLQ =  42;
  66   else if (id1 == -idQuark && id2 == -idLepton) idLQ = -42;
  67   else if (id2 == -idQuark && id1 == -idLepton) idLQ = -42;
  68   if (idLQ == 0) return 0.;
  69
  70   // Outgoing width and total sigma. Done.
  71   return widthIn * sigBW * LQPtr->resWidthOpen(idLQ, mH);
  72
  73 }
  74
  75 //*********
  76
  77 // Select identity, colour and anticolour.
  78
  79 void Sigma1ql2LeptoQuark::setIdColAcol() {
  80
  81   // Flavours.
  82   int idq  = (abs(id1) < 9) ? id1 : id2;
  83   int idLQ = (idq > 0) ? 42 : -42;
  84   setId( id1, id2, idLQ);
  85
  86   // Colour flow topology.
  87   if (id1 == idq) setColAcol( 1, 0, 0, 0, 1, 0);
  88   else            setColAcol( 0, 0, 1, 0, 1, 0);
  89   if (idq < 0) swapColAcol();
  90
  91 }
  92
  93 //**************************************************************************
  94
  95 // Sigma2qg2LeptoQuarkl class.
  96 // Cross section for q g -> LQ l (leptoquark state).
  97
  98 //*********
  99
 100 // Initialize process.
 101
 102 void Sigma2qg2LeptoQuarkl::initProc() {
 103
 104   // Store LQ mass and width for propagator.
 105   mRes     = ParticleDataTable::m0(42);
 106   GammaRes = ParticleDataTable::mWidth(42);
 107   m2Res    = mRes*mRes;
 108   GamMRat  = GammaRes / mRes;
 109
 110   // Yukawa coupling strength.
 111   kCoup    = Settings::parm("LeptoQuark:kCoup");
 112
 113   // Read out quark and lepton the LQ couples to.
 114   ParticleDataEntry* LQPtr = ParticleDataTable::particleDataPtr(42);
 115   idQuark  = LQPtr->decay[0].product(0);
 116   idLepton = LQPtr->decay[0].product(1);
 117
 118    // Secondary open width fraction.
 119   openFracPos = LQPtr->resOpenFrac( 42);
 120   openFracNeg = LQPtr->resOpenFrac(-42);
 121
 122 }
 123
 124 //*********
 125
 126 // Evaluate sigmaHat(sHat), part independent of incoming flavour.
 127
 128 void Sigma2qg2LeptoQuarkl::sigmaKin() {
 129
 130   //  Evaluate cross section.
 131   sigma0 = (M_PI / sH2) * kCoup * (alpS * alpEM / 6.) * (-tH / sH)
 132     * (uH2 + s3 * s3) / pow2(uH - s3);
 133
 134 }
 135
 136 //*********
 137
 138 // Evaluate sigmaHat(sHat) for specific incoming flavours.
 139
 140 double Sigma2qg2LeptoQuarkl::sigmaHat() {
 141
 142   // Check that correct incoming flavour.
 143   if (abs(id1) != idQuark && abs(id2) != idQuark) return 0.;
 144
 145   // Answer, with secondary width correction.
 146   double sigma = sigma0;
 147   sigma *= (id1 == idQuark || id2 == idQuark) ? openFracPos : openFracNeg;
 148   return sigma;
 149
 150 }
 151
 152 //*********
 153
 154 // Select identity, colour and anticolour.
 155
 156 void Sigma2qg2LeptoQuarkl::setIdColAcol() {
 157
 158   // Flavour set up for q g -> H q.
 159   int idq = (id2 == 21) ? id1 : id2;
 160   int idLQ = (idq > 0) ? 42 : -42;
 161   int idlp = (idq > 0) ? idLepton : -idLepton;
 162   setId( id1, id2, idLQ, idlp);
 163
 164   // tH defined between f and f': must swap tHat <-> uHat if q g in.
 165   swapTU = (id2 == 21);
 166
 167   // Colour flow topologies. Swap when antiquarks.
 168   if (id2 == 21) setColAcol( 1, 0, 2, 1, 2, 0, 0, 0);
 169   else           setColAcol( 2, 1, 1, 0, 2, 0, 0, 0);
 170   if (idq < 0) swapColAcol();
 171
 172 }
 173
 174 //**************************************************************************
 175
 176 // Sigma2gg2LQLQbar class.
 177 // Cross section for g g -> LQ LQbar (leptoquark state).
 178
 179 //*********
 180
 181 // Initialize process.
 182
 183 void Sigma2gg2LQLQbar::initProc() {
 184
 185   // Store LQ mass and width for propagator.
 186   mRes     = ParticleDataTable::m0(42);
 187   GammaRes = ParticleDataTable::mWidth(42);
 188   m2Res    = mRes*mRes;
 189   GamMRat  = GammaRes / mRes;
 190
 191    // Secondary open width fraction.
 192   openFrac = ParticleDataTable::resOpenFrac(42, -42);
 193
 194 }
 195
 196 //*********
 197
 198 // Evaluate sigmaHat(sHat), part independent of incoming flavour.
 199
 200 void Sigma2gg2LQLQbar::sigmaKin() {
 201
 202   // Average outgoing masses and adjust kinematics accordingly.
 203   double delta = 0.25 * pow2(s3 - s4) / sH;
 204   double m2avg = 0.5 * (s3 + s4) - delta;
 205   double tHavg = tH - delta;
 206   double uHavg = uH - delta;
 207
 208   //  Evaluate cross section. Secondary width for G*.
 209   sigma = (M_PI / sH2) * 0.5 * pow2(alpS)
 210     * ( 7. / 48. + 3. * pow2(uHavg - tHavg) / (16. * sH2) )
 211     * ( 1. + 2. * m2avg * tHavg / pow2(tHavg - m2avg)
 212     + 2. * m2avg * uHavg / pow2(uHavg - m2avg)
 213     + 4. * m2avg * m2avg / ((tHavg - m2avg) * (uHavg - m2avg)) );
 214   sigma *= openFrac;
 215
 216 }
 217
 218 //*********
 219
 220 // Select identity, colour and anticolour.
 221
 222 void Sigma2gg2LQLQbar::setIdColAcol() {
 223
 224   // Flavours trivial.
 225   setId( 21, 21, 42, -42);
 226
 227   // Colour flow topologies: random choice between two mirrors.
 228   if (Rndm::flat() < 0.5) setColAcol( 1, 2, 2, 3, 1, 0, 0, 3);
 229   else                    setColAcol( 1, 2, 3, 1, 3, 0, 0, 2);
 230
 231 }
 232
 233 //**************************************************************************
 234
 235 // Sigma2qqbar2LQLQbar class.
 236 // Cross section for q qbar -> LQ LQbar (leptoquark state).
 237
 238 //*********
 239
 240 // Initialize process.
 241
 242 void Sigma2qqbar2LQLQbar::initProc() {
 243
 244   // Store LQ mass and width for propagator.
 245   mRes     = ParticleDataTable::m0(42);
 246   GammaRes = ParticleDataTable::mWidth(42);
 247   m2Res    = mRes*mRes;
 248   GamMRat  = GammaRes / mRes;
 249
 250   // Yukawa coupling strength.
 251   kCoup    = Settings::parm("LeptoQuark:kCoup");
 252
 253   // Read out quark and lepton the LQ couples to.
 254   ParticleDataEntry* LQPtr = ParticleDataTable::particleDataPtr(42);
 255   idQuark  = LQPtr->decay[0].product(0);
 256
 257    // Secondary open width fraction.
 258   openFrac = ParticleDataTable::resOpenFrac(42, -42);
 259
 260 }
 261
 262 //*********
 263
 264 // Evaluate sigmaHat(sHat), part independent of incoming flavour.
 265
 266 void Sigma2qqbar2LQLQbar::sigmaKin() {
 267
 268   // Average outgoing masses and adjust kinematics accordingly.
 269   double delta = 0.25 * pow2(s3 - s4) / sH;
 270   double m2avg = 0.5 * (s3 + s4) - delta;
 271   double tHavg = tH - delta;
 272   double uHavg = uH - delta;
 273
 274   // Evaluate cross section for quark of different flavour than LQ.
 275   sigmaDiff = (M_PI / sH2) * (pow2(alpS) / 9.)
 276     * ( sH * (sH - 4. * m2avg) - pow2(uHavg - tHavg) ) / sH2;
 277
 278   // Evaluate cross section for quark of same flavour as LQ.
 279   sigmaSame = sigmaDiff + (M_PI / sH2) * (pow2(kCoup * alpEM) / 8.)
 280     * (-sH * tHavg - pow2(m2avg-tHavg)) / pow2(tHavg)
 281     + (M_PI / sH2) * (kCoup * alpEM * alpS / 18.) * ( (m2avg - tHavg)
 282     * (uHavg - tHavg) + sH * (m2avg + tHavg) ) / (sH * tHavg);
 283
 284   // Open fraction.
 285   sigmaDiff *= openFrac;
 286   sigmaSame *= openFrac;
 287
 288 }
 289
 290 //*********
 291
 292 // Select identity, colour and anticolour.
 293
 294 void Sigma2qqbar2LQLQbar::setIdColAcol() {
 295
 296   // Flavours trivial.
 297   setId( id1, id2, 42, -42);
 298
 299   // tH defined between f and LQ: must swap tHat <-> uHat if qbar q in.
 300   swapTU = (id1 < 0);
 301
 302   // Colour flow topologies.
 303   if (id1 > 0) setColAcol( 1, 0, 0, 2, 1, 0, 0, 2);
 304   else         setColAcol( 0, 2, 1, 0, 1, 0, 0, 2);
 305
 306 }
 307
 308 //**************************************************************************
 309
 310 } // end namespace Pythia8