Line data Source code
1 : // SigmaLeptoquark.cc is a part of the PYTHIA event generator.
2 : // Copyright (C) 2015 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 "Pythia8/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 0 : mRes = particleDataPtr->m0(42);
26 0 : GammaRes = particleDataPtr->mWidth(42);
27 0 : m2Res = mRes*mRes;
28 0 : GamMRat = GammaRes / mRes;
29 :
30 : // Yukawa coupling strength.
31 0 : kCoup = settingsPtr->parm("LeptoQuark:kCoup");
32 :
33 : // Set pointer to particle properties and decay table.
34 0 : LQPtr = particleDataPtr->particleDataEntryPtr(42);
35 :
36 : // Read out quark and lepton the LQ couples to.
37 0 : idQuark = LQPtr->channel(0).product(0);
38 0 : idLepton = LQPtr->channel(0).product(1);
39 :
40 0 : }
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 0 : widthIn = 0.25 * alpEM * kCoup * mH;
50 :
51 : // Set up Breit-Wigner.
52 0 : sigBW = 4. * M_PI/ ( pow2(sH - m2Res) + pow2(sH * GamMRat) );
53 :
54 0 : }
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 0 : if (id1 == idQuark && id2 == idLepton) idLQ = 42;
65 0 : else if (id2 == idQuark && id1 == idLepton) idLQ = 42;
66 0 : else if (id1 == -idQuark && id2 == -idLepton) idLQ = -42;
67 0 : else if (id2 == -idQuark && id1 == -idLepton) idLQ = -42;
68 0 : if (idLQ == 0) return 0.;
69 :
70 : // Outgoing width and total sigma. Done.
71 0 : return widthIn * sigBW * LQPtr->resWidthOpen(idLQ, mH);
72 :
73 0 : }
74 :
75 : //--------------------------------------------------------------------------
76 :
77 : // Select identity, colour and anticolour.
78 :
79 : void Sigma1ql2LeptoQuark::setIdColAcol() {
80 :
81 : // Flavours.
82 0 : int idq = (abs(id1) < 9) ? id1 : id2;
83 0 : int idLQ = (idq > 0) ? 42 : -42;
84 0 : setId( id1, id2, idLQ);
85 :
86 : // Colour flow topology.
87 0 : if (id1 == idq) setColAcol( 1, 0, 0, 0, 1, 0);
88 0 : else setColAcol( 0, 0, 1, 0, 1, 0);
89 0 : if (idq < 0) swapColAcol();
90 :
91 0 : }
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 0 : mRes = particleDataPtr->m0(42);
106 0 : GammaRes = particleDataPtr->mWidth(42);
107 0 : m2Res = mRes*mRes;
108 0 : GamMRat = GammaRes / mRes;
109 :
110 : // Yukawa coupling strength.
111 0 : kCoup = settingsPtr->parm("LeptoQuark:kCoup");
112 :
113 : // Read out quark and lepton the LQ couples to.
114 0 : ParticleDataEntry* LQPtr = particleDataPtr->particleDataEntryPtr(42);
115 0 : idQuark = LQPtr->channel(0).product(0);
116 0 : idLepton = LQPtr->channel(0).product(1);
117 :
118 : // Secondary open width fraction.
119 0 : openFracPos = LQPtr->resOpenFrac( 42);
120 0 : openFracNeg = LQPtr->resOpenFrac(-42);
121 :
122 0 : }
123 :
124 : //--------------------------------------------------------------------------
125 :
126 : // Evaluate sigmaHat(sHat), part independent of incoming flavour.
127 :
128 : void Sigma2qg2LeptoQuarkl::sigmaKin() {
129 :
130 : // Evaluate cross section.
131 0 : sigma0 = (M_PI / sH2) * kCoup * (alpS * alpEM / 6.) * (-tH / sH)
132 0 : * (uH2 + s3 * s3) / pow2(uH - s3);
133 :
134 0 : }
135 :
136 : //--------------------------------------------------------------------------
137 :
138 : // Evaluate sigmaHat(sHat) for specific incoming flavours.
139 :
140 : double Sigma2qg2LeptoQuarkl::sigmaHat() {
141 :
142 : // Check that correct incoming flavour.
143 0 : if (abs(id1) != idQuark && abs(id2) != idQuark) return 0.;
144 :
145 : // Answer, with secondary width correction.
146 0 : double sigma = sigma0;
147 0 : sigma *= (id1 == idQuark || id2 == idQuark) ? openFracPos : openFracNeg;
148 : return sigma;
149 :
150 0 : }
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 0 : int idq = (id2 == 21) ? id1 : id2;
160 0 : int idLQ = (idq > 0) ? 42 : -42;
161 0 : int idlp = (idq > 0) ? -idLepton : idLepton;
162 0 : setId( id1, id2, idLQ, idlp);
163 :
164 : // tH defined between f and f': must swap tHat <-> uHat if q g in.
165 0 : swapTU = (id2 == 21);
166 :
167 : // Colour flow topologies. Swap when antiquarks.
168 0 : if (id2 == 21) setColAcol( 1, 0, 2, 1, 2, 0, 0, 0);
169 0 : else setColAcol( 2, 1, 1, 0, 2, 0, 0, 0);
170 0 : if (idq < 0) swapColAcol();
171 :
172 0 : }
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 0 : mRes = particleDataPtr->m0(42);
187 0 : GammaRes = particleDataPtr->mWidth(42);
188 0 : m2Res = mRes*mRes;
189 0 : GamMRat = GammaRes / mRes;
190 :
191 : // Secondary open width fraction.
192 0 : openFrac = particleDataPtr->resOpenFrac(42, -42);
193 :
194 0 : }
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 0 : double delta = 0.25 * pow2(s3 - s4) / sH;
204 0 : double m2avg = 0.5 * (s3 + s4) - delta;
205 0 : double tHavg = tH - delta;
206 0 : double uHavg = uH - delta;
207 :
208 : // Evaluate cross section. Secondary width for G*.
209 0 : sigma = (M_PI / sH2) * 0.5 * pow2(alpS)
210 0 : * ( 7. / 48. + 3. * pow2(uHavg - tHavg) / (16. * sH2) )
211 0 : * ( 1. + 2. * m2avg * tHavg / pow2(tHavg - m2avg)
212 0 : + 2. * m2avg * uHavg / pow2(uHavg - m2avg)
213 0 : + 4. * m2avg * m2avg / ((tHavg - m2avg) * (uHavg - m2avg)) );
214 0 : sigma *= openFrac;
215 :
216 0 : }
217 :
218 : //--------------------------------------------------------------------------
219 :
220 : // Select identity, colour and anticolour.
221 :
222 : void Sigma2gg2LQLQbar::setIdColAcol() {
223 :
224 : // Flavours trivial.
225 0 : setId( 21, 21, 42, -42);
226 :
227 : // Colour flow topologies: random choice between two mirrors.
228 0 : if (rndmPtr->flat() < 0.5) setColAcol( 1, 2, 2, 3, 1, 0, 0, 3);
229 0 : else setColAcol( 1, 2, 3, 1, 3, 0, 0, 2);
230 :
231 0 : }
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 0 : mRes = particleDataPtr->m0(42);
246 0 : GammaRes = particleDataPtr->mWidth(42);
247 0 : m2Res = mRes*mRes;
248 0 : GamMRat = GammaRes / mRes;
249 :
250 : // Yukawa coupling strength.
251 0 : kCoup = settingsPtr->parm("LeptoQuark:kCoup");
252 :
253 : // Read out quark and lepton the LQ couples to.
254 0 : ParticleDataEntry* LQPtr = particleDataPtr->particleDataEntryPtr(42);
255 0 : idQuark = LQPtr->channel(0).product(0);
256 :
257 : // Secondary open width fraction.
258 0 : openFrac = particleDataPtr->resOpenFrac(42, -42);
259 :
260 0 : }
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 0 : double delta = 0.25 * pow2(s3 - s4) / sH;
270 0 : double m2avg = 0.5 * (s3 + s4) - delta;
271 0 : double tHavg = tH - delta;
272 0 : double uHavg = uH - delta;
273 :
274 : // Evaluate cross section for quark of different flavour than LQ.
275 0 : sigmaDiff = (M_PI / sH2) * (pow2(alpS) / 9.)
276 0 : * ( sH * (sH - 4. * m2avg) - pow2(uHavg - tHavg) ) / sH2;
277 :
278 : // Evaluate cross section for quark of same flavour as LQ.
279 0 : sigmaSame = sigmaDiff + (M_PI / sH2) * (pow2(kCoup * alpEM) / 8.)
280 0 : * (-sH * tHavg - pow2(m2avg-tHavg)) / pow2(tHavg)
281 0 : + (M_PI / sH2) * (kCoup * alpEM * alpS / 18.) * ( (m2avg - tHavg)
282 0 : * (uHavg - tHavg) + sH * (m2avg + tHavg) ) / (sH * tHavg);
283 :
284 : // Open fraction.
285 0 : sigmaDiff *= openFrac;
286 0 : sigmaSame *= openFrac;
287 :
288 0 : }
289 :
290 : //--------------------------------------------------------------------------
291 :
292 : // Select identity, colour and anticolour.
293 :
294 : void Sigma2qqbar2LQLQbar::setIdColAcol() {
295 :
296 : // Flavours trivial.
297 0 : setId( id1, id2, 42, -42);
298 :
299 : // tH defined between f and LQ: must swap tHat <-> uHat if qbar q in.
300 0 : swapTU = (id1 < 0);
301 :
302 : // Colour flow topologies.
303 0 : if (id1 > 0) setColAcol( 1, 0, 0, 2, 1, 0, 0, 2);
304 0 : else setColAcol( 0, 2, 1, 0, 1, 0, 0, 2);
305 :
306 0 : }
307 :
308 : //==========================================================================
309 :
310 : } // end namespace Pythia8
|
