using option '-treename HLTesdTree' for EsdCollector, adding default parameter for...
[u/mrichter/AliRoot.git] / PYTHIA8 / pythia8130 / src / SigmaLeptoquark.cxx
CommitLineData
5ad4eb21 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
11namespace Pythia8 {
12
13//**************************************************************************
14
15// Sigma1ql2LeptoQuark class.
16// Cross section for q l -> LQ (leptoquark state).
17
18//*********
19
20// Initialize process.
21
22void 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
46void 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
60double 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
79void 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
102void 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
128void 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
140double 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
156void 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
183void 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
200void 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
222void 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
242void 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
266void 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
294void 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