Line data Source code
1 : // SusyResonanceWidths.cc is a part of the PYTHIA event generator.
2 : // Copyright (C) 2015 Torbjorn Sjostrand
3 : // Authors: N. Desai, P. Skands
4 : // PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
5 : // Please respect the MCnet Guidelines, see GUIDELINES for details.
6 :
7 : // Function definitions (not found in the header) for the
8 : // SUSY Resonance widths classes.
9 :
10 : #include "Pythia8/SusyResonanceWidths.h"
11 : #include "Pythia8/SusyWidthFunctions.h"
12 : #include "Pythia8/SusyCouplings.h"
13 : #include "Pythia8/ParticleData.h"
14 : #include "Pythia8/PythiaComplex.h"
15 :
16 : namespace Pythia8 {
17 :
18 : //==========================================================================
19 :
20 : // The SUSYResonanceWidths Class
21 : // Derived class for SUSY resonances
22 :
23 : const bool SUSYResonanceWidths::DBSUSY = false;
24 :
25 : //--------------------------------------------------------------------------
26 :
27 : bool SUSYResonanceWidths::initBSM(){
28 :
29 0 : if (couplingsPtr->isSUSY) {
30 0 : coupSUSYPtr = (CoupSUSY *) couplingsPtr;
31 0 : return true;
32 : }
33 :
34 0 : return false;
35 0 : }
36 :
37 : //--------------------------------------------------------------------------
38 :
39 : bool SUSYResonanceWidths::allowCalc(){
40 :
41 : // Check if decay calculations at all possible
42 0 : if ( !couplingsPtr->isSUSY ) return false;
43 0 : if ( (idRes == 45 || idRes == 46 || idRes == 1000045)
44 0 : && !coupSUSYPtr->isNMSSM ) return false;
45 :
46 0 : if (settingsPtr->flag("SLHA:useDecayTable") ) {
47 :
48 : // Next check if decay table was read in via SLHA and takes precedence
49 0 : for ( int iDec = 1; iDec < int((coupSUSYPtr->slhaPtr)->decays.size());
50 0 : ++iDec)
51 0 : if ( (coupSUSYPtr->slhaPtr)->decays[iDec].getId() == abs(idRes) ) {
52 : if (DBSUSY) cout<<"Using external decay table for:"<<idRes<<endl;
53 0 : return false;
54 : }
55 :
56 : }
57 :
58 : // Else we should do the calculation; set available channels
59 0 : bool done = getChannels(idRes);
60 0 : stringstream idStream;
61 0 : idStream << "ID = " << idRes ;
62 0 : if (!done) infoPtr->errorMsg("Error in SusyResonanceWidths::allowcalc: "
63 0 : "unable to reset decay table.", idStream.str(), true);
64 : return done;
65 0 : }
66 :
67 : //==========================================================================
68 :
69 : // The ResonanceSquark class
70 : // Derived class for Squark resonances
71 :
72 : //--------------------------------------------------------------------------
73 :
74 : // Set up channels
75 :
76 : bool ResonanceSquark::getChannels(int idPDG){
77 :
78 0 : idPDG = abs(idPDG);
79 :
80 : int ksusy = 1000000;
81 0 : if (idPDG < ksusy) return false;
82 0 : if(idPDG % ksusy >= 7 || idPDG % ksusy < 1) return false;
83 :
84 : ParticleDataEntry* squarkEntryPtr
85 0 : = particleDataPtr->particleDataEntryPtr(idPDG);
86 :
87 : // Delete any decay channels read
88 0 : squarkEntryPtr->clearChannels();
89 :
90 0 : if(idPDG % 2 == 0) { // up-type squarks
91 :
92 : /*
93 : // Gravitino
94 : squarkEntryPtr->addChannel(1, 0.0, 103, 1000039, 2);
95 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000039, 4);
96 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000039, 6);
97 : */
98 :
99 : // Gaugino - quark
100 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000024, 3);
101 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000024, 5);
102 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000037, 1);
103 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000037, 3);
104 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000037, 5);
105 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000022, 2);
106 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000022, 4);
107 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000022, 6);
108 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000023, 2);
109 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000023, 4);
110 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000023, 6);
111 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000025, 2);
112 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000025, 4);
113 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000025, 6);
114 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000035, 2);
115 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000035, 4);
116 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000035, 6);
117 :
118 : // Squark - Gauge boson
119 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000001, -24);
120 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000003, -24);
121 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000005, -24);
122 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 2000001, -24);
123 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 2000003, -24);
124 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 2000005, -24);
125 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000001, -37);
126 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000003, -37);
127 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000005, -37);
128 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 2000001, -37);
129 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 2000003, -37);
130 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 2000005, -37);
131 :
132 : // Gluino - quark
133 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000021, 2);
134 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000021, 4);
135 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000021, 6);
136 :
137 : // lepton - quark via LQD
138 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -11, 1);
139 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -11, 3);
140 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -11, 5);
141 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -13, 1);
142 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -13, 3);
143 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -13, 5);
144 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -15, 1);
145 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -15, 3);
146 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -15, 5);
147 :
148 : // quark - quark via UDD
149 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -1 ,-3);
150 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -1 ,-5);
151 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -3 ,-5);
152 :
153 :
154 0 : } else { //down-type squarks
155 :
156 : // Gaugino - quark
157 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -1000024, 2);
158 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -1000037, 2);
159 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -1000024, 4);
160 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -1000037, 4);
161 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -1000024, 6);
162 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -1000037, 6);
163 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000022, 1);
164 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000022, 3);
165 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000022, 5);
166 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000023, 1);
167 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000023, 3);
168 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000023, 5);
169 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000025, 1);
170 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000025, 3);
171 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000025, 5);
172 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000035, 1);
173 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000035, 3);
174 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000035, 5);
175 :
176 : // Squark - Gauge boson
177 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000002, -24);
178 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000004, -24);
179 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000006, -24);
180 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 2000002, -24);
181 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 2000004, -24);
182 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 2000006, -24);
183 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000002, -37);
184 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000004, -37);
185 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000006, -37);
186 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 2000002, -37);
187 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 2000004, -37);
188 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 2000006, -37);
189 :
190 : // Gluino - quark
191 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000021, 1);
192 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000021, 2);
193 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 1000021, 5);
194 :
195 : // lepton - quark via LQD
196 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -12, 1);
197 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -12, 3);
198 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -12, 5);
199 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -14, 1);
200 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -14, 3);
201 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -14, 5);
202 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -16, 1);
203 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -16, 3);
204 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -16, 5);
205 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 12 ,1);
206 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 11 ,2);
207 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 12, 3);
208 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 11, 4);
209 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 12, 5);
210 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 11, 6);
211 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 14, 1);
212 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 13, 2);
213 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 14, 3);
214 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 13, 4);
215 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 14, 5);
216 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 13, 6);
217 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 16, 1);
218 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 15, 2);
219 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 16, 3);
220 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 15, 4);
221 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 16, 5);
222 0 : squarkEntryPtr->addChannel(1, 0.0, 0, 15, 6);
223 :
224 :
225 : // quark - quark via UDD
226 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -2, -1);
227 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -2, -3);
228 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -2, -5);
229 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -4, -1);
230 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -4, -3);
231 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -4, -5);
232 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -6, -1);
233 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -6, -3);
234 0 : squarkEntryPtr->addChannel(1, 0.0, 0, -6, -5);
235 : }
236 :
237 : return true;
238 :
239 0 : }
240 :
241 : //--------------------------------------------------------------------------
242 :
243 : // Initialize constants.
244 :
245 : void ResonanceSquark::initConstants() {
246 :
247 : // Locally stored properties and couplings.
248 0 : s2W = coupSUSYPtr->sin2W;
249 :
250 0 : }
251 :
252 : //--------------------------------------------------------------------------
253 :
254 : // Calculate various common prefactors for the current mass.
255 :
256 : void ResonanceSquark::calcPreFac(bool) {
257 :
258 : // Common coupling factors.
259 0 : alpS = coupSUSYPtr->alphaS(mHat * mHat );
260 0 : alpEM = coupSUSYPtr->alphaEM(mHat * mHat);
261 0 : preFac = 1.0 / (s2W * pow(mHat,3));
262 0 : ps *= mHat * mHat;
263 :
264 0 : }
265 :
266 : //--------------------------------------------------------------------------
267 :
268 : // Calculate width for currently considered channel.
269 :
270 : void ResonanceSquark::calcWidth(bool) {
271 :
272 : // Squark type -- in u_i/d_i and generation
273 : int ksusy = 1000000;
274 0 : bool idown = (abs(idRes)%2 == 0 ? false : true);
275 0 : int isq = (abs(idRes)/ksusy == 2) ?
276 0 : (abs(idRes)%10+1)/2 + 3: (abs(idRes)%10+1)/2;
277 : // int isqgen = (abs(idRes)%10 + 1)/2;
278 :
279 : // Check that mass is above threshold.
280 0 : if (ps == 0.) return;
281 : else{
282 : // Two-body decays
283 0 : kinFac = (mHat * mHat - mf1 * mf1 - mf2 * mf2);
284 :
285 : double fac = 0.0 , wid = 0.0;
286 :
287 : //RPV decays
288 : //Case 1a: UDD-type
289 0 : if (id1Abs < 7 && id2Abs < 7){
290 :
291 : // Quark generations
292 0 : int iq1 = (id1Abs + 1)/2;
293 0 : int iq2 = (id2Abs + 1)/2;
294 :
295 : // Check for RPV UDD couplings
296 0 : if (!coupSUSYPtr->isUDD) {widNow = 0; return;}
297 :
298 : // ~q -> q_i + q_j
299 :
300 0 : fac = 2.0 * kinFac / (16.0 * M_PI * pow(mHat,3));
301 : wid = 0.0;
302 0 : if (idown) {
303 0 : if ((id1Abs+id2Abs)%2 == 1){
304 0 : if (id1Abs%2==1)
305 0 : for (int isq2 = 1; isq2 < 4; isq2++)
306 0 : wid += norm(coupSUSYPtr->rvUDD[iq2][iq1][isq2]
307 0 : * coupSUSYPtr->Rdsq[isq][isq2+3]);
308 : else
309 0 : for (int isq2 = 1; isq2 < 4; isq2++)
310 0 : wid += norm(coupSUSYPtr->rvUDD[iq1][iq2][isq2]
311 0 : * coupSUSYPtr->Rdsq[isq][isq2+3]);
312 : }
313 : }
314 : else {
315 0 : if ((id1Abs+id2Abs)%2 != 0) widNow = 0.0;
316 : else
317 0 : for (int isq2 = 1; isq2 < 4; isq2++)
318 0 : wid += norm(coupSUSYPtr->rvUDD[isq2][iq1][iq2]
319 0 : * coupSUSYPtr->Rusq[isq][isq2+3]);
320 : }
321 0 : }
322 :
323 : //Case 1b: LQD-type
324 0 : else if (id1Abs < 17 && id2Abs < 7){
325 0 : if (!coupSUSYPtr->isLQD) {widNow = 0; return;}
326 :
327 0 : int ilep = (id1Abs - 9)/2;
328 0 : int iq = (id2Abs + 1)/2;
329 :
330 0 : fac = kinFac / (16.0 * M_PI * pow(mHat,3));
331 : wid = 0.0;
332 0 : if (idown){
333 0 : if (iq%2 == 0){
334 : // q is up-type; ~q is right-handed down type
335 0 : for (int isq2=1; isq2<3; isq2++)
336 0 : wid += norm(coupSUSYPtr->Rdsq[isq][isq2+3]
337 0 : * coupSUSYPtr->rvLQD[ilep][iq][isq2]);
338 0 : }else{
339 : //q is down type; ~q left-handed down-type
340 0 : for (int isq2=1; isq2<3; isq2++)
341 0 : wid += norm(coupSUSYPtr->Rdsq[isq][isq2]
342 0 : * coupSUSYPtr->rvLQD[ilep][isq2][isq2]);
343 : }
344 : }
345 : else{
346 0 : if (iq%2 == 0) {widNow = 0.0; return;}
347 : // q is down type; ~q is left-handed up-type
348 0 : for (int isq2=1; isq2<3; isq2++)
349 0 : wid += norm(coupSUSYPtr->Rusq[isq][isq2]
350 0 : * coupSUSYPtr->rvLQD[ilep][isq2][iq]);
351 : }
352 0 : }
353 :
354 : //Case 2: quark + gaugino
355 0 : else if (id1Abs > ksusy && id2Abs < 7) {
356 :
357 0 : int iq = (id2Abs + 1)/2;
358 :
359 : // ~q -> ~g + q
360 0 : if (id1Abs == 1000021 && idRes%10 == id2Abs) {
361 : // Removed factor of s2W in denominator: strong process -- no EW
362 0 : fac = 2.0 * alpS / (3.0 * pow3(mHat));
363 0 : if (idown)
364 0 : wid = kinFac * (norm(coupSUSYPtr->LsddG[isq][iq])
365 0 : + norm(coupSUSYPtr->RsddG[isq][iq]))
366 0 : - 4.0 * mHat * mf2 * real(coupSUSYPtr->LsddG[isq][iq]
367 0 : * conj(coupSUSYPtr->RsddG[isq][iq]));
368 : else
369 0 : wid = kinFac * (norm(coupSUSYPtr->LsuuG[isq][iq])
370 0 : + norm(coupSUSYPtr->RsuuG[isq][iq]))
371 0 : - 4.0 * mHat * mf2 * real(coupSUSYPtr->LsuuG[isq][iq]
372 0 : * conj(coupSUSYPtr->RsuuG[isq][iq]));
373 : }
374 : else
375 0 : for (int i=1; i<6 ; i++){
376 : // ~q -> ~chi0 + q
377 0 : if (coupSUSYPtr->idNeut(i)==id1Abs && idRes%2 == id2Abs%2){
378 0 : fac = alpEM * preFac / (2.0 * (1 - s2W));
379 0 : if (idown)
380 0 : wid = kinFac * (norm(coupSUSYPtr->LsddX[isq][iq][i])
381 0 : + norm(coupSUSYPtr->RsddX[isq][iq][i]))
382 0 : - 4.0 * mHat * mf2 * real(coupSUSYPtr->LsddX[isq][iq][i]
383 0 : * conj(coupSUSYPtr->RsddX[isq][iq][i]));
384 : else
385 0 : wid = kinFac * (norm(coupSUSYPtr->LsuuX[isq][iq][i])
386 0 : + norm(coupSUSYPtr->RsuuX[isq][iq][i]))
387 0 : - 4.0 * mHat * mf2 * real(coupSUSYPtr->LsuuX[isq][iq][i]
388 0 : * conj(coupSUSYPtr->RsuuX[isq][iq][i]));
389 : }
390 :
391 : // ~q -> chi- + q
392 0 : else if (i < 3 && coupSUSYPtr->idChar(i)==id1Abs
393 0 : && idRes%2 != id2Abs%2){
394 :
395 0 : fac = alpEM * preFac / (4.0 * (1 - s2W));
396 0 : if (idown)
397 0 : wid = kinFac * (norm(coupSUSYPtr->LsduX[isq][iq][i])
398 0 : + norm(coupSUSYPtr->RsduX[isq][iq][i]))
399 0 : - 4.0 * mHat * mf2 * real(coupSUSYPtr->LsduX[isq][iq][i]
400 0 : * conj(coupSUSYPtr->RsduX[isq][iq][i]));
401 : else
402 0 : wid = kinFac * (norm(coupSUSYPtr->LsudX[isq][iq][i])
403 0 : + norm(coupSUSYPtr->RsudX[isq][iq][i]))
404 0 : - 4.0 * mHat * mf2 * real(coupSUSYPtr->LsudX[isq][iq][i]
405 0 : * conj(coupSUSYPtr->RsudX[isq][iq][i]));
406 : }
407 : }
408 0 : }
409 :
410 : //Case 3: ~q_i -> ~q_j + Z/W
411 0 : else if (id1Abs > ksusy && id1Abs%100 < 7
412 0 : && (id2Abs == 23 || id2Abs == 24)){
413 :
414 : // factor of lambda^(3/2) = ps^(3/2) ;
415 0 : fac = alpEM * preFac/(16.0 * pow2(particleDataPtr->m0(id2Abs))
416 0 : * (1.0 - s2W)) * pow2(ps) ;
417 :
418 0 : int isq2 = (id1Abs/ksusy == 2) ? (id1Abs%10+1)/2 + 3: (id1Abs%10+1)/2;
419 :
420 0 : if (id2Abs == 23 && id1Abs%2 == idRes%2){
421 0 : if (idown)
422 0 : wid = norm(coupSUSYPtr->LsdsdZ[isq][isq2]
423 0 : + coupSUSYPtr->RsdsdZ[isq][isq2]);
424 : else
425 0 : wid = norm(coupSUSYPtr->LsusuZ[isq][isq2]
426 0 : + coupSUSYPtr->RsusuZ[isq][isq2]);
427 : }
428 0 : else if (id2Abs == 24 && id1Abs%2 != idRes%2){
429 0 : if (idown)
430 0 : wid = norm(coupSUSYPtr->LsusdW[isq2][isq]);
431 : else
432 0 : wid = norm(coupSUSYPtr->LsusdW[isq][isq2]);
433 : }
434 0 : }
435 :
436 : // TODO: Case ~q_i -> ~q_j + h/H
437 0 : widNow = fac * wid * ps * pow2(mHat);
438 : if (DBSUSY) cout<<idRes<<":: id1:"<<id1Abs<<" id2:"<<id2Abs
439 : <<" Width: "<<widNow<<endl;
440 0 : return;
441 : }
442 :
443 0 : }
444 :
445 : //==========================================================================
446 :
447 : // The ResonanceGluino class
448 : // Derived class for Gluino resonances
449 :
450 : //--------------------------------------------------------------------------
451 :
452 : // Set up Channels
453 :
454 : bool ResonanceGluino::getChannels(int idPDG){
455 :
456 0 : idPDG = abs(idPDG);
457 0 : if (idPDG != 1000021) return false;
458 :
459 : ParticleDataEntry* gluinoEntryPtr
460 0 : = particleDataPtr->particleDataEntryPtr(idPDG);
461 :
462 : // Delete any decay channels read
463 0 : gluinoEntryPtr->clearChannels();
464 :
465 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 1000001, -1);
466 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -1000001, 1);
467 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 1000001 ,-3);
468 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -1000001, 3);
469 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 1000001 ,-5);
470 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -1000001, 5);
471 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 2000001 ,-1);
472 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -2000001, 1);
473 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 2000001 ,-3);
474 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -2000001, 3);
475 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 2000001 ,-5);
476 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -2000001, 5);
477 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 1000002 ,-2);
478 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -1000002, 2);
479 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 1000002 ,-4);
480 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -1000002, 4);
481 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 1000002 ,-6);
482 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -1000002, 6);
483 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 2000002 ,-2);
484 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -2000002, 2);
485 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 2000002 ,-4);
486 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -2000002, 4);
487 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 2000002 ,-6);
488 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -2000002, 6);
489 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 1000003 ,-1);
490 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -1000003, 1);
491 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 1000003 ,-3);
492 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -1000003, 3);
493 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 1000003 ,-5);
494 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -1000003, 5);
495 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 2000003 ,-1);
496 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -2000003, 1);
497 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 2000003 ,-3);
498 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -2000003, 3);
499 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 2000003 ,-5);
500 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -2000003, 5);
501 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 1000004 ,-2);
502 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -1000004, 2);
503 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 1000004 ,-4);
504 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -1000004, 4);
505 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 1000004 ,-6);
506 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -1000004, 6);
507 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 2000004 ,-2);
508 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -2000004, 2);
509 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 2000004 ,-4);
510 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -2000004, 4);
511 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 2000004 ,-6);
512 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -2000004, 6);
513 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 1000005 ,-1);
514 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -1000005, 1);
515 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 1000005 ,-3);
516 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -1000005, 3);
517 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 1000005 ,-5);
518 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -1000005, 5);
519 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 2000005 ,-1);
520 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -2000005, 1);
521 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 2000005 ,-3);
522 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -2000005, 3);
523 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 2000005 ,-5);
524 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -2000005, 5);
525 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 1000006 ,-6);
526 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -1000006, 6);
527 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 1000006 ,-2);
528 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -1000006, 2);
529 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 1000006 ,-4);
530 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -1000006, 4);
531 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, 2000006 ,-6);
532 0 : gluinoEntryPtr->addChannel(1, 0.0, 0, -2000006, 6);
533 :
534 : return true;
535 0 : }
536 :
537 : //--------------------------------------------------------------------------
538 :
539 : // Initialize constants.
540 :
541 : void ResonanceGluino::initConstants() {
542 0 : return;
543 : }
544 :
545 : //--------------------------------------------------------------------------
546 :
547 : // Calculate various common prefactors for the current mass.
548 :
549 : void ResonanceGluino::calcPreFac(bool) {
550 :
551 : // Common coupling factors.
552 0 : alpS = coupSUSYPtr->alphaS(mHat * mHat);
553 0 : preFac = alpS /( 8.0 * pow(mHat,3));
554 0 : return;
555 :
556 : }
557 :
558 :
559 : //--------------------------------------------------------------------------
560 :
561 : // Calculate width for currently considered channel.
562 :
563 : void ResonanceGluino::calcWidth(bool) {
564 :
565 0 : widNow = 0.0;
566 0 : if (ps == 0.) return;
567 0 : kinFac = (mHat * mHat - mf1 * mf1 + mf2 * mf2);
568 :
569 0 : if (id1Abs > 1000000 && (id1Abs % 100) < 7 && id2Abs < 7) {
570 :
571 0 : int isq = (abs(id1Abs)/1000000 == 2) ? (abs(id1Abs)%10+1)/2 + 3
572 : : (abs(id1Abs)%10+1)/2;
573 0 : bool idown = id2Abs%2;
574 0 : int iq = (id2Abs + 1)/2;
575 :
576 : // ~g -> ~q + q
577 0 : if (idown){
578 0 : widNow = kinFac * (norm(coupSUSYPtr->LsddG[isq][iq])
579 0 : + norm(coupSUSYPtr->RsddG[isq][iq]))
580 0 : + 4.0 * mHat * mf2 * real(coupSUSYPtr->LsddG[isq][iq]
581 0 : * conj(coupSUSYPtr->RsddG[isq][iq]));
582 0 : }
583 : else{
584 0 : widNow = kinFac * (norm(coupSUSYPtr->LsuuG[isq][iq])
585 0 : + norm(coupSUSYPtr->RsuuG[isq][iq]))
586 0 : + 4.0 * mHat * mf2 * real(coupSUSYPtr->LsuuG[isq][iq]
587 0 : * conj(coupSUSYPtr->RsuuG[isq][iq]));
588 : }
589 0 : widNow = widNow * preFac * ps * pow2(mHat);
590 : if (DBSUSY) {
591 : cout<<"Gluino:: id1:"<<id1Abs<<" id2:"<<id2Abs<<" Width: ";
592 : cout<<scientific<<widNow<<endl;
593 : }
594 : return;
595 : }
596 0 : }
597 :
598 : //==========================================================================
599 :
600 : // Class ResonanceNeut
601 : // Derived class for Neutralino Resonances
602 : //
603 : //--------------------------------------------------------------------------
604 :
605 : // Set up Channels
606 :
607 : bool ResonanceNeut::getChannels(int idPDG){
608 :
609 0 : idPDG = abs(idPDG);
610 :
611 0 : int iNeut = coupSUSYPtr->typeNeut(idPDG);
612 0 : if (iNeut < 1) return false;
613 :
614 : ParticleDataEntry* neutEntryPtr
615 0 : = particleDataPtr->particleDataEntryPtr(idPDG);
616 :
617 : // Delete any decay channels read
618 0 : neutEntryPtr->clearChannels();
619 :
620 : // RPV channels
621 :
622 0 : neutEntryPtr->addChannel(1, 0.0, 0, -12, -13, 11);
623 0 : neutEntryPtr->addChannel(1, 0.0, 0, 12, 13, -11);
624 0 : neutEntryPtr->addChannel(1, 0.0, 0, -12, -13, 13);
625 0 : neutEntryPtr->addChannel(1, 0.0, 0, 12, 13, -13);
626 0 : neutEntryPtr->addChannel(1, 0.0, 0, -12, -13, 15);
627 0 : neutEntryPtr->addChannel(1, 0.0, 0, 12, 13, -15);
628 0 : neutEntryPtr->addChannel(1, 0.0, 0, -12, -15, 11);
629 0 : neutEntryPtr->addChannel(1, 0.0, 0, 12, 15, -11);
630 0 : neutEntryPtr->addChannel(1, 0.0, 0, -12, -15, 13);
631 0 : neutEntryPtr->addChannel(1, 0.0, 0, 12, 15, -13);
632 0 : neutEntryPtr->addChannel(1, 0.0, 0, -12, -15, 15);
633 0 : neutEntryPtr->addChannel(1, 0.0, 0, 12, 15, -15);
634 0 : neutEntryPtr->addChannel(1, 0.0, 0, -14, -11, 11);
635 0 : neutEntryPtr->addChannel(1, 0.0, 0, 14, 11, -11);
636 0 : neutEntryPtr->addChannel(1, 0.0, 0, -14, -11, 13);
637 0 : neutEntryPtr->addChannel(1, 0.0, 0, 14, 11, -13);
638 0 : neutEntryPtr->addChannel(1, 0.0, 0, -14, -11, 15);
639 0 : neutEntryPtr->addChannel(1, 0.0, 0, 14, 11, -15);
640 0 : neutEntryPtr->addChannel(1, 0.0, 0, -14, -15, 11);
641 0 : neutEntryPtr->addChannel(1, 0.0, 0, 14, 15, -11);
642 0 : neutEntryPtr->addChannel(1, 0.0, 0, -14, -15, 13);
643 0 : neutEntryPtr->addChannel(1, 0.0, 0, 14, 15, -13);
644 0 : neutEntryPtr->addChannel(1, 0.0, 0, -14, -15, 15);
645 0 : neutEntryPtr->addChannel(1, 0.0, 0, 14, 15, -15);
646 0 : neutEntryPtr->addChannel(1, 0.0, 0, -16, -11, 11);
647 0 : neutEntryPtr->addChannel(1, 0.0, 0, 16, 11, -11);
648 0 : neutEntryPtr->addChannel(1, 0.0, 0, -16, -11, 13);
649 0 : neutEntryPtr->addChannel(1, 0.0, 0, 16, 11, -13);
650 0 : neutEntryPtr->addChannel(1, 0.0, 0, -16, -11, 15);
651 0 : neutEntryPtr->addChannel(1, 0.0, 0, 16, 11, -15);
652 0 : neutEntryPtr->addChannel(1, 0.0, 0, -16, -13, 11);
653 0 : neutEntryPtr->addChannel(1, 0.0, 0, 16, 13, -11);
654 0 : neutEntryPtr->addChannel(1, 0.0, 0, -16, -13, 13);
655 0 : neutEntryPtr->addChannel(1, 0.0, 0, 16, 13, -13);
656 0 : neutEntryPtr->addChannel(1, 0.0, 0, -16, -13, 15);
657 0 : neutEntryPtr->addChannel(1, 0.0, 0, 16, 13, -15);
658 0 : neutEntryPtr->addChannel(1, 0.0, 0, -12, -1, 1);
659 0 : neutEntryPtr->addChannel(1, 0.0, 0, 12, 1, -1);
660 0 : neutEntryPtr->addChannel(1, 0.0, 0, -11, -2, 1);
661 0 : neutEntryPtr->addChannel(1, 0.0, 0, 11, 2, -1);
662 0 : neutEntryPtr->addChannel(1, 0.0, 0, -12, -1, 3);
663 0 : neutEntryPtr->addChannel(1, 0.0, 0, 12, 1, -3);
664 0 : neutEntryPtr->addChannel(1, 0.0, 0, -11, -2, 3);
665 0 : neutEntryPtr->addChannel(1, 0.0, 0, 11, 2, -3);
666 0 : neutEntryPtr->addChannel(1, 0.0, 0, -12, -1, 5);
667 0 : neutEntryPtr->addChannel(1, 0.0, 0, 12, 1, -5);
668 0 : neutEntryPtr->addChannel(1, 0.0, 0, -11, -2, 5);
669 0 : neutEntryPtr->addChannel(1, 0.0, 0, 11, 2, -5);
670 0 : neutEntryPtr->addChannel(1, 0.0, 0, -12, -3, 1);
671 0 : neutEntryPtr->addChannel(1, 0.0, 0, 12, 3, -1);
672 0 : neutEntryPtr->addChannel(1, 0.0, 0, -11, -4, 1);
673 0 : neutEntryPtr->addChannel(1, 0.0, 0, 11, 4, -1);
674 0 : neutEntryPtr->addChannel(1, 0.0, 0, -12, -3, 3);
675 0 : neutEntryPtr->addChannel(1, 0.0, 0, 12, 3, -3);
676 0 : neutEntryPtr->addChannel(1, 0.0, 0, -11, -4, 3);
677 0 : neutEntryPtr->addChannel(1, 0.0, 0, 11, 4, -3);
678 0 : neutEntryPtr->addChannel(1, 0.0, 0, -12, -3, 5);
679 0 : neutEntryPtr->addChannel(1, 0.0, 0, 12, 3, -5);
680 0 : neutEntryPtr->addChannel(1, 0.0, 0, -11, -4, 5);
681 0 : neutEntryPtr->addChannel(1, 0.0, 0, 11, 4, -5);
682 0 : neutEntryPtr->addChannel(1, 0.0, 0, -12, -5, 1);
683 0 : neutEntryPtr->addChannel(1, 0.0, 0, 12, 5, -1);
684 0 : neutEntryPtr->addChannel(1, 0.0, 0, -11, -6, 1);
685 0 : neutEntryPtr->addChannel(1, 0.0, 0, 11, 6, -1);
686 0 : neutEntryPtr->addChannel(1, 0.0, 0, -12, -5, 3);
687 0 : neutEntryPtr->addChannel(1, 0.0, 0, 12, 5, -3);
688 0 : neutEntryPtr->addChannel(1, 0.0, 0, -11, -6, 3);
689 0 : neutEntryPtr->addChannel(1, 0.0, 0, 11, 6, -3);
690 0 : neutEntryPtr->addChannel(1, 0.0, 0, 12 ,-5 ,5);
691 0 : neutEntryPtr->addChannel(1, 0.0, 0, 12, 5, -5);
692 0 : neutEntryPtr->addChannel(1, 0.0, 0, -11, -6, 5);
693 0 : neutEntryPtr->addChannel(1, 0.0, 0, 11, 6, -5);
694 0 : neutEntryPtr->addChannel(1, 0.0, 0, -14, -1, 1);
695 0 : neutEntryPtr->addChannel(1, 0.0, 0, 14, 1, -1);
696 0 : neutEntryPtr->addChannel(1, 0.0, 0, -13, -2, 1);
697 0 : neutEntryPtr->addChannel(1, 0.0, 0, 13, 2, -1);
698 0 : neutEntryPtr->addChannel(1, 0.0, 0, -14, -1, 3);
699 0 : neutEntryPtr->addChannel(1, 0.0, 0, 14, 1, -3);
700 0 : neutEntryPtr->addChannel(1, 0.0, 0, -13, -2, 3);
701 0 : neutEntryPtr->addChannel(1, 0.0, 0, 13, 2, -3);
702 0 : neutEntryPtr->addChannel(1, 0.0, 0, -14, -1, 5);
703 0 : neutEntryPtr->addChannel(1, 0.0, 0, 14, 1, -5);
704 0 : neutEntryPtr->addChannel(1, 0.0, 0, -13, -2, 5);
705 0 : neutEntryPtr->addChannel(1, 0.0, 0, 13, 2, -5);
706 0 : neutEntryPtr->addChannel(1, 0.0, 0, -14, -3, 1);
707 0 : neutEntryPtr->addChannel(1, 0.0, 0, 14, 3, -1);
708 0 : neutEntryPtr->addChannel(1, 0.0, 0, -13, -4, 1);
709 0 : neutEntryPtr->addChannel(1, 0.0, 0, 13, 4, -1);
710 0 : neutEntryPtr->addChannel(1, 0.0, 0, -14, -3, 3);
711 0 : neutEntryPtr->addChannel(1, 0.0, 0, 14, 3, -3);
712 0 : neutEntryPtr->addChannel(1, 0.0, 0, -13, -4, 3);
713 0 : neutEntryPtr->addChannel(1, 0.0, 0, 13, 4, -3);
714 0 : neutEntryPtr->addChannel(1, 0.0, 0, -14, -3, 5);
715 0 : neutEntryPtr->addChannel(1, 0.0, 0, 14, 3, -5);
716 0 : neutEntryPtr->addChannel(1, 0.0, 0, -13, -4, 5);
717 0 : neutEntryPtr->addChannel(1, 0.0, 0, 13, 4, -5);
718 0 : neutEntryPtr->addChannel(1, 0.0, 0, -14, -5, 1);
719 0 : neutEntryPtr->addChannel(1, 0.0, 0, 14, 5, -1);
720 0 : neutEntryPtr->addChannel(1, 0.0, 0, -13, -6, 1);
721 0 : neutEntryPtr->addChannel(1, 0.0, 0, 13, 6, -1);
722 0 : neutEntryPtr->addChannel(1, 0.0, 0, -14, -5, 3);
723 0 : neutEntryPtr->addChannel(1, 0.0, 0, 14, 5, -3);
724 0 : neutEntryPtr->addChannel(1, 0.0, 0, -13, -6, 3);
725 0 : neutEntryPtr->addChannel(1, 0.0, 0, 13, 6, -3);
726 0 : neutEntryPtr->addChannel(1, 0.0, 0, -14, -5, 5);
727 0 : neutEntryPtr->addChannel(1, 0.0, 0, 14, 5, -5);
728 0 : neutEntryPtr->addChannel(1, 0.0, 0, -13, -6, 5);
729 0 : neutEntryPtr->addChannel(1, 0.0, 0, 13, 6, -5);
730 0 : neutEntryPtr->addChannel(1, 0.0, 0, -16, -1, 1);
731 0 : neutEntryPtr->addChannel(1, 0.0, 0, 16, 1, -1);
732 0 : neutEntryPtr->addChannel(1, 0.0, 0, -15, -2, 1);
733 0 : neutEntryPtr->addChannel(1, 0.0, 0, 15, 2, -1);
734 0 : neutEntryPtr->addChannel(1, 0.0, 0, -16, -1, 3);
735 0 : neutEntryPtr->addChannel(1, 0.0, 0, 16, 1, -3);
736 0 : neutEntryPtr->addChannel(1, 0.0, 0, -15, -2, 3);
737 0 : neutEntryPtr->addChannel(1, 0.0, 0, 15, 2, -3);
738 0 : neutEntryPtr->addChannel(1, 0.0, 0, -16, -1, 5);
739 0 : neutEntryPtr->addChannel(1, 0.0, 0, 16, 1, -5);
740 0 : neutEntryPtr->addChannel(1, 0.0, 0, -15, -2, 5);
741 0 : neutEntryPtr->addChannel(1, 0.0, 0, 15, 2, -5);
742 0 : neutEntryPtr->addChannel(1, 0.0, 0, -16, -3, 1);
743 0 : neutEntryPtr->addChannel(1, 0.0, 0, 16, 3, -1);
744 0 : neutEntryPtr->addChannel(1, 0.0, 0, -15, -4, 1);
745 0 : neutEntryPtr->addChannel(1, 0.0, 0, 15, 4, -1);
746 0 : neutEntryPtr->addChannel(1, 0.0, 0, -16, -3, 3);
747 0 : neutEntryPtr->addChannel(1, 0.0, 0, 16, 3, -3);
748 0 : neutEntryPtr->addChannel(1, 0.0, 0, -15, -4, 3);
749 0 : neutEntryPtr->addChannel(1, 0.0, 0, 15, 4, -3);
750 0 : neutEntryPtr->addChannel(1, 0.0, 0, -16, -3, 5);
751 0 : neutEntryPtr->addChannel(1, 0.0, 0, 16, 3, -5);
752 0 : neutEntryPtr->addChannel(1, 0.0, 0, -15, -4, 5);
753 0 : neutEntryPtr->addChannel(1, 0.0, 0, 15, 4, -5);
754 0 : neutEntryPtr->addChannel(1, 0.0, 0, -16, -5, 1);
755 0 : neutEntryPtr->addChannel(1, 0.0, 0, 16, 5, -1);
756 0 : neutEntryPtr->addChannel(1, 0.0, 0, -15, -6, 1);
757 0 : neutEntryPtr->addChannel(1, 0.0, 0, 15, 6, -1);
758 0 : neutEntryPtr->addChannel(1, 0.0, 0, -16, -5, 3);
759 0 : neutEntryPtr->addChannel(1, 0.0, 0, 16, 5, -3);
760 0 : neutEntryPtr->addChannel(1, 0.0, 0, -15, -6, 3);
761 0 : neutEntryPtr->addChannel(1, 0.0, 0, 15, 6, -3);
762 0 : neutEntryPtr->addChannel(1, 0.0, 0, -16, -5, 5);
763 0 : neutEntryPtr->addChannel(1, 0.0, 0, 16, 5, -5);
764 0 : neutEntryPtr->addChannel(1, 0.0, 0, -15, -6, 5);
765 0 : neutEntryPtr->addChannel(1, 0.0, 0, 15, 6, -5);
766 0 : neutEntryPtr->addChannel(1, 0.0, 0, -2 ,-1 ,-3);
767 0 : neutEntryPtr->addChannel(1, 0.0, 0, 2, 1, 3);
768 0 : neutEntryPtr->addChannel(1, 0.0, 0, -2, -1, -5);
769 0 : neutEntryPtr->addChannel(1, 0.0, 0, 2, 1, 5);
770 0 : neutEntryPtr->addChannel(1, 0.0, 0, -2, -3, -5);
771 0 : neutEntryPtr->addChannel(1, 0.0, 0, 2, 3, 5);
772 0 : neutEntryPtr->addChannel(1, 0.0, 0, -4, -1, -3);
773 0 : neutEntryPtr->addChannel(1, 0.0, 0, 4, 1, 3);
774 0 : neutEntryPtr->addChannel(1, 0.0, 0, -4, -1, -5);
775 0 : neutEntryPtr->addChannel(1, 0.0, 0, 4, 1, 5);
776 0 : neutEntryPtr->addChannel(1, 0.0, 0, -4, -3, -5);
777 0 : neutEntryPtr->addChannel(1, 0.0, 0, 4, 3, 5);
778 0 : neutEntryPtr->addChannel(1, 0.0, 0, -6, -1, -3);
779 0 : neutEntryPtr->addChannel(1, 0.0, 0, 6, 1, 3);
780 0 : neutEntryPtr->addChannel(1, 0.0, 0, -6, -1, -5);
781 0 : neutEntryPtr->addChannel(1, 0.0, 0, 6, 1, 5);
782 0 : neutEntryPtr->addChannel(1, 0.0, 0, -6, -3, -5);
783 0 : neutEntryPtr->addChannel(1, 0.0, 0, 6, 3, 5);
784 :
785 0 : if (iNeut > 1) {
786 :
787 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000022, 22);
788 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000022, 23);
789 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000022, 25);
790 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000022, 35);
791 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000022, 36);
792 :
793 0 : if ( iNeut > 2) {
794 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000023, 22);
795 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000023, 23);
796 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000023, 25);
797 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000023, 35);
798 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000023, 36);
799 0 : }
800 :
801 0 : if (iNeut > 3) {
802 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000025, 22);
803 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000025, 23);
804 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000025, 25);
805 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000025, 35);
806 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000025, 36);
807 0 : }
808 :
809 0 : if (iNeut > 4) {
810 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000035, 22);
811 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000035, 23);
812 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000035, 25);
813 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000035, 35);
814 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000035, 36);
815 0 : }
816 :
817 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000024, -24);
818 0 : neutEntryPtr->addChannel(1, 0.0, 0, -1000024, 24);
819 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000037, -24);
820 0 : neutEntryPtr->addChannel(1, 0.0, 0, -1000037, 24);
821 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000024, -37);
822 0 : neutEntryPtr->addChannel(1, 0.0, 0, -1000024, 37);
823 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000037, -37);
824 0 : neutEntryPtr->addChannel(1, 0.0, 0, -1000037, 37);
825 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000011, -11);
826 0 : neutEntryPtr->addChannel(1, 0.0, 0, -1000011, 11);
827 0 : neutEntryPtr->addChannel(1, 0.0, 0, 2000011, -11);
828 0 : neutEntryPtr->addChannel(1, 0.0, 0, -2000011, 11);
829 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000012, -12);
830 0 : neutEntryPtr->addChannel(1, 0.0, 0, -1000012, 12);
831 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000013, -13);
832 0 : neutEntryPtr->addChannel(1, 0.0, 0, -1000013, 13);
833 0 : neutEntryPtr->addChannel(1, 0.0, 0, 2000013, -13);
834 0 : neutEntryPtr->addChannel(1, 0.0, 0, -2000013, 13);
835 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000014, -14);
836 0 : neutEntryPtr->addChannel(1, 0.0, 0, -1000014, 14);
837 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000015, -15);
838 0 : neutEntryPtr->addChannel(1, 0.0, 0, -1000015, 15);
839 0 : neutEntryPtr->addChannel(1, 0.0, 0, 2000015, -15);
840 0 : neutEntryPtr->addChannel(1, 0.0, 0, -2000015, 15);
841 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000016, -16);
842 0 : neutEntryPtr->addChannel(1, 0.0, 0, -1000016, 16);
843 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000001, -1);
844 0 : neutEntryPtr->addChannel(1, 0.0, 0, -1000001, 1);
845 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000001, -3);
846 0 : neutEntryPtr->addChannel(1, 0.0, 0, -1000001, 3);
847 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000001, -5);
848 0 : neutEntryPtr->addChannel(1, 0.0, 0, -1000001, 5);
849 0 : neutEntryPtr->addChannel(1, 0.0, 0, 2000001, -1);
850 0 : neutEntryPtr->addChannel(1, 0.0, 0, -2000001, 1);
851 0 : neutEntryPtr->addChannel(1, 0.0, 0, 2000001, -3);
852 0 : neutEntryPtr->addChannel(1, 0.0, 0, -2000001, 3);
853 0 : neutEntryPtr->addChannel(1, 0.0, 0, 2000001, -5);
854 0 : neutEntryPtr->addChannel(1, 0.0, 0, -2000001, 5);
855 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000002, -2);
856 0 : neutEntryPtr->addChannel(1, 0.0, 0, -1000002, 2);
857 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000002, -4);
858 0 : neutEntryPtr->addChannel(1, 0.0, 0, -1000002, 4);
859 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000002, -6);
860 0 : neutEntryPtr->addChannel(1, 0.0, 0, -1000002, 6);
861 0 : neutEntryPtr->addChannel(1, 0.0, 0, 2000002, -2);
862 0 : neutEntryPtr->addChannel(1, 0.0, 0, -2000002, 2);
863 0 : neutEntryPtr->addChannel(1, 0.0, 0, 2000002, -4);
864 0 : neutEntryPtr->addChannel(1, 0.0, 0, -2000002, 4);
865 0 : neutEntryPtr->addChannel(1, 0.0, 0, 2000002, -6);
866 0 : neutEntryPtr->addChannel(1, 0.0, 0, -2000002, 6);
867 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000003, -1);
868 0 : neutEntryPtr->addChannel(1, 0.0, 0, -1000003, 1);
869 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000003, -3);
870 0 : neutEntryPtr->addChannel(1, 0.0, 0, -1000003, 3);
871 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000003, -5);
872 0 : neutEntryPtr->addChannel(1, 0.0, 0, -1000003, 5);
873 0 : neutEntryPtr->addChannel(1, 0.0, 0, 2000003, -1);
874 0 : neutEntryPtr->addChannel(1, 0.0, 0, -2000003, 1);
875 0 : neutEntryPtr->addChannel(1, 0.0, 0, 2000003, -3);
876 0 : neutEntryPtr->addChannel(1, 0.0, 0, -2000003, 3);
877 0 : neutEntryPtr->addChannel(1, 0.0, 0, 2000003, -5);
878 0 : neutEntryPtr->addChannel(1, 0.0, 0, -2000003, 5);
879 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000004, -2);
880 0 : neutEntryPtr->addChannel(1, 0.0, 0, -1000004, 2);
881 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000004, -4);
882 0 : neutEntryPtr->addChannel(1, 0.0, 0, -1000004, 4);
883 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000004, -6);
884 0 : neutEntryPtr->addChannel(1, 0.0, 0, -1000004, 6);
885 0 : neutEntryPtr->addChannel(1, 0.0, 0, 2000004, -2);
886 0 : neutEntryPtr->addChannel(1, 0.0, 0, -2000004, 2);
887 0 : neutEntryPtr->addChannel(1, 0.0, 0, 2000004, -4);
888 0 : neutEntryPtr->addChannel(1, 0.0, 0, -2000004, 4);
889 0 : neutEntryPtr->addChannel(1, 0.0, 0, 2000004, -6);
890 0 : neutEntryPtr->addChannel(1, 0.0, 0, -2000004, 6);
891 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000005, -1);
892 0 : neutEntryPtr->addChannel(1, 0.0, 0, -1000005, 1);
893 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000005, -3);
894 0 : neutEntryPtr->addChannel(1, 0.0, 0, -1000005, 3);
895 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000005, -5);
896 0 : neutEntryPtr->addChannel(1, 0.0, 0, -1000005, 5);
897 0 : neutEntryPtr->addChannel(1, 0.0, 0, 2000005, -1);
898 0 : neutEntryPtr->addChannel(1, 0.0, 0, -2000005, 1);
899 0 : neutEntryPtr->addChannel(1, 0.0, 0, 2000005, -3);
900 0 : neutEntryPtr->addChannel(1, 0.0, 0, -2000005, 3);
901 0 : neutEntryPtr->addChannel(1, 0.0, 0, 2000005, -5);
902 0 : neutEntryPtr->addChannel(1, 0.0, 0, -2000005, 5);
903 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000006, -6);
904 0 : neutEntryPtr->addChannel(1, 0.0, 0, -1000006, 6);
905 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000006, -2);
906 0 : neutEntryPtr->addChannel(1, 0.0, 0, -1000006, 2);
907 0 : neutEntryPtr->addChannel(1, 0.0, 0, 1000006, -4);
908 0 : neutEntryPtr->addChannel(1, 0.0, 0, -1000006, 4);
909 0 : neutEntryPtr->addChannel(1, 0.0, 0, 2000006, -6);
910 0 : neutEntryPtr->addChannel(1, 0.0, 0, -2000006, 6);
911 :
912 : // Modes involving right-handed sneutrinos are not included by default,
913 : // but can be added by hand, by uncommenting the following lines.
914 : // neutEntryPtr->addChannel(1, 0.0, 0, 2000012, -12);
915 : // neutEntryPtr->addChannel(1, 0.0, 0, -2000012, 12);
916 : // neutEntryPtr->addChannel(1, 0.0, 0, 2000014, -14);
917 : // neutEntryPtr->addChannel(1, 0.0, 0, -2000014, 14);
918 : // neutEntryPtr->addChannel(1, 0.0, 0, 2000016, -16);
919 : // neutEntryPtr->addChannel(1, 0.0, 0, -2000016, 16);
920 :
921 :
922 :
923 0 : }
924 : return true;
925 0 : }
926 :
927 : //--------------------------------------------------------------------------
928 :
929 : void ResonanceNeut::initConstants() {
930 :
931 0 : s2W = coupSUSYPtr->sin2W;
932 :
933 : // Initialize functions for calculating 3-body widths
934 : // psi.setPointers(particleDataPtr,coupSUSYPtr,infoPtr);
935 : // phi.setPointers(particleDataPtr,coupSUSYPtr,infoPtr);
936 : // upsil.setPointers(particleDataPtr,coupSUSYPtr,infoPtr);
937 :
938 0 : }
939 :
940 : //--------------------------------------------------------------------------
941 :
942 : // Calculate various common prefactors for the current mass.
943 :
944 : void ResonanceNeut::calcPreFac(bool) {
945 :
946 : // Common coupling factors.
947 0 : alpEM = coupSUSYPtr->alphaEM(mHat * mHat);
948 0 : preFac = alpEM / (8.0 * s2W * pow(mHat,3));
949 0 : return;
950 :
951 : }
952 :
953 : //--------------------------------------------------------------------------
954 :
955 : // Calculate width for currently considered channel.
956 : void ResonanceNeut::calcWidth(bool){
957 :
958 0 : widNow = 0.0;
959 :
960 0 : if (ps == 0.) return;
961 0 : else if (mult ==2){
962 : // Two-body decays
963 :
964 0 : kinFac = mHat * mHat - mf1 * mf1 + mf2 * mf2;
965 0 : kinFac2 = pow(mHat,4) + pow(mf1,4) - 2.0 * pow(mf2,4)
966 0 : + pow2(mHat) * pow2(mf2) + pow2(mf1) * pow2(mf2)
967 0 : - 2.0 * pow2(mHat) * pow2(mf1);
968 :
969 : // Stable lightest neutralino
970 0 : if (idRes == 1000022) return;
971 :
972 : double fac = 0.0;
973 0 : int iNeut1 = coupSUSYPtr->typeNeut(idRes);
974 0 : int iNeut2 = coupSUSYPtr->typeNeut(id1Abs);
975 0 : int iChar1 = coupSUSYPtr->typeChar(id1Abs);
976 :
977 0 : if (iNeut2>0 && id2Abs == 23){
978 : // ~chi0_i -> chi0_j + Z
979 0 : fac = kinFac2 * (norm(coupSUSYPtr->OLpp[iNeut1][iNeut2])
980 0 : + norm(coupSUSYPtr->ORpp[iNeut1][iNeut2]));
981 0 : fac -= 12.0 * mHat * mf1 * pow2(mf2)
982 0 : * real(coupSUSYPtr->OLpp[iNeut1][iNeut2]
983 0 : * conj(coupSUSYPtr->ORpp[iNeut1][iNeut2]));
984 0 : fac /= pow2(mf2) * (1.0 - s2W);
985 0 : }
986 0 : else if (iChar1>0 && id2Abs==24){
987 : // ~chi0_i -> chi+_j + W- (or c.c.)
988 :
989 0 : fac = kinFac2 * (norm(coupSUSYPtr->OL[iNeut1][iChar1])
990 0 : + norm(coupSUSYPtr->OR[iNeut1][iChar1]));
991 0 : fac -= 12.0 * mHat * mf1 * pow2(mf2)
992 0 : * real(coupSUSYPtr->OL[iNeut1][iChar1]
993 0 : * conj(coupSUSYPtr->OR[iNeut1][iChar1]));
994 0 : fac /= pow2(mf2);
995 0 : }
996 0 : else if (id1Abs > 1000000 && id1Abs%100 < 7 && id2Abs < 7){
997 : // ~chi0_k -> ~q + q
998 0 : bool idown = (id1Abs%2 == 1);
999 0 : int iq = (id2Abs + 1 )/ 2;
1000 0 : int isq = (abs(id1Abs)/1000000 == 2) ? (abs(id1Abs)%10+1)/2 + 3
1001 : : (abs(id1Abs)%10+1)/2;
1002 :
1003 0 : if (idown){
1004 0 : fac = kinFac * (norm(coupSUSYPtr->LsddX[isq][iq][iNeut1])
1005 0 : + norm(coupSUSYPtr->RsddX[isq][iq][iNeut1]));
1006 0 : fac += 4.0 * mHat * mf2 * real(coupSUSYPtr->LsddX[isq][iq][iNeut1]
1007 0 : * conj(coupSUSYPtr->RsddX[isq][iq][iNeut1]));
1008 0 : }
1009 : else{
1010 0 : fac = kinFac * (norm(coupSUSYPtr->LsuuX[isq][iq][iNeut1])
1011 0 : + norm(coupSUSYPtr->RsuuX[isq][iq][iNeut1]));
1012 0 : fac += 4.0 * mHat * mf2 * real(coupSUSYPtr->LsuuX[isq][iq][iNeut1]
1013 0 : * conj(coupSUSYPtr->RsuuX[isq][iq][iNeut1]));
1014 : }
1015 : // Extra multiplicative factor of 3 over sleptons
1016 0 : fac *= 6.0/(1 - s2W);
1017 0 : }
1018 0 : else if (id1Abs > 2000010 && id1Abs%2 == 0 ) {
1019 : // Check for right-handed neutralinos.
1020 0 : widNow = 0;
1021 0 : }
1022 0 : else if (id1Abs > 1000000 && id1Abs%100 > 10 && id1Abs%100 < 17
1023 0 : && id2Abs < 17){
1024 :
1025 : // ~chi0_k -> ~l + l
1026 0 : bool idown = id2Abs%2;
1027 0 : int il = (id2Abs - 9)/ 2;
1028 0 : int isl = (abs(id1Abs)/1000000 == 2) ? (abs(id1Abs)%10+1)/2 + 3
1029 : : (abs(id1Abs)%10+1)/2;
1030 :
1031 0 : if (idown){
1032 0 : fac = kinFac * (norm(coupSUSYPtr->LsllX[isl][il][iNeut1])
1033 0 : + norm(coupSUSYPtr->RsllX[isl][il][iNeut1]));
1034 0 : fac += 4.0 * mHat * mf2 * real(coupSUSYPtr->LsllX[isl][il][iNeut1]
1035 0 : * conj(coupSUSYPtr->RsllX[isl][il][iNeut1]));
1036 0 : }
1037 : else{
1038 0 : fac = kinFac * (norm(coupSUSYPtr->LsvvX[isl][il][iNeut1]));
1039 : }
1040 0 : fac *= 2.0/(1 - s2W);
1041 0 : }
1042 : // TODO: Decays in higgs
1043 : // Final width for 2-body decays
1044 0 : widNow = fac * preFac * ps * pow2(mHat);
1045 : if (DBSUSY) {
1046 : cout<<idRes<<":: id1:"<<id1Abs<<" id2:"<<id2Abs<<" Width: ";
1047 : cout<<scientific<<widNow<<endl;
1048 : }
1049 : }
1050 : else {
1051 : //RPV 3-body decays
1052 :
1053 : //Case: UDD-type (TO BE RE-DONE to fix bug)
1054 : return;
1055 :
1056 : }
1057 :
1058 : // Normalisation. Extra factor of 2 to account for the fact that
1059 : // d_i, d_j will always be ordered in ascending order. N_c! = 6
1060 0 : widNow *= 12.0 /(pow3(2.0 * M_PI * mHat) * 32.0);
1061 :
1062 0 : return;
1063 0 : }
1064 :
1065 : //==========================================================================
1066 :
1067 : // Class ResonanceChar
1068 : // Derived class for Neutralino Resonances
1069 : // Decays into higgses/sleptons not yet implemented
1070 :
1071 : //--------------------------------------------------------------------------
1072 :
1073 : // Set up Channels
1074 :
1075 : bool ResonanceChar::getChannels(int idPDG){
1076 :
1077 0 : idPDG = abs(idPDG);
1078 0 : int iChar = coupSUSYPtr->typeChar(idPDG);
1079 0 : if (iChar < 1) return false;
1080 :
1081 : ParticleDataEntry* charEntryPtr
1082 0 : = particleDataPtr->particleDataEntryPtr(idPDG);
1083 :
1084 : // Delete any decay channels read
1085 0 : charEntryPtr->clearChannels();
1086 :
1087 0 : charEntryPtr->addChannel(1, 0.0, 0, 1000022, 24);
1088 0 : charEntryPtr->addChannel(1, 0.0, 0, 1000023, 24);
1089 0 : charEntryPtr->addChannel(1, 0.0, 0, 1000025, 24);
1090 0 : charEntryPtr->addChannel(1, 0.0, 0, 1000035, 24);
1091 0 : charEntryPtr->addChannel(1, 0.0, 0, 1000022, 37);
1092 0 : charEntryPtr->addChannel(1, 0.0, 0, 1000023, 37);
1093 0 : charEntryPtr->addChannel(1, 0.0, 0, 1000025, 37);
1094 0 : charEntryPtr->addChannel(1, 0.0, 0, 1000035, 37);
1095 0 : charEntryPtr->addChannel(1, 0.0, 0, 1000012, -11);
1096 0 : charEntryPtr->addChannel(1, 0.0, 0, -1000011, 12);
1097 0 : charEntryPtr->addChannel(1, 0.0, 0, -2000011, 12);
1098 0 : charEntryPtr->addChannel(1, 0.0, 0, 1000014, -13);
1099 0 : charEntryPtr->addChannel(1, 0.0, 0, -1000013, 14);
1100 0 : charEntryPtr->addChannel(1, 0.0, 0, -2000013, 14);
1101 0 : charEntryPtr->addChannel(1, 0.0, 0, 1000016, -15);
1102 0 : charEntryPtr->addChannel(1, 0.0, 0, -1000015, 16);
1103 0 : charEntryPtr->addChannel(1, 0.0, 0, -2000015, 16);
1104 0 : charEntryPtr->addChannel(1, 0.0, 0, 1000002, -1);
1105 0 : charEntryPtr->addChannel(1, 0.0, 0, 1000002, -3);
1106 0 : charEntryPtr->addChannel(1, 0.0, 0, 1000002, -5);
1107 0 : charEntryPtr->addChannel(1, 0.0, 0, 2000002, -1);
1108 0 : charEntryPtr->addChannel(1, 0.0, 0, 2000002, -3);
1109 0 : charEntryPtr->addChannel(1, 0.0, 0, 2000002, -5);
1110 0 : charEntryPtr->addChannel(1, 0.0, 0, -1000001, 2);
1111 0 : charEntryPtr->addChannel(1, 0.0, 0, -1000001, 4);
1112 0 : charEntryPtr->addChannel(1, 0.0, 0, -1000001, 6);
1113 0 : charEntryPtr->addChannel(1, 0.0, 0, -2000001, 2);
1114 0 : charEntryPtr->addChannel(1, 0.0, 0, -2000001, 4);
1115 0 : charEntryPtr->addChannel(1, 0.0, 0, -2000001, 6);
1116 0 : charEntryPtr->addChannel(1, 0.0, 0, 1000004, -1);
1117 0 : charEntryPtr->addChannel(1, 0.0, 0, 1000004, -3);
1118 0 : charEntryPtr->addChannel(1, 0.0, 0, 1000004, -5);
1119 0 : charEntryPtr->addChannel(1, 0.0, 0, 2000004, -1);
1120 0 : charEntryPtr->addChannel(1, 0.0, 0, 2000004, -3);
1121 0 : charEntryPtr->addChannel(1, 0.0, 0, 2000004, -5);
1122 0 : charEntryPtr->addChannel(1, 0.0, 0, -1000003, 2);
1123 0 : charEntryPtr->addChannel(1, 0.0, 0, -1000003, 4);
1124 0 : charEntryPtr->addChannel(1, 0.0, 0, -1000003, 6);
1125 0 : charEntryPtr->addChannel(1, 0.0, 0, -2000003, 2);
1126 0 : charEntryPtr->addChannel(1, 0.0, 0, -2000003, 4);
1127 0 : charEntryPtr->addChannel(1, 0.0, 0, -2000003, 6);
1128 0 : charEntryPtr->addChannel(1, 0.0, 0, 1000006, -1);
1129 0 : charEntryPtr->addChannel(1, 0.0, 0, 1000006, -3);
1130 0 : charEntryPtr->addChannel(1, 0.0, 0, 1000006, -5);
1131 0 : charEntryPtr->addChannel(1, 0.0, 0, 2000006, -1);
1132 0 : charEntryPtr->addChannel(1, 0.0, 0, 2000006, -3);
1133 0 : charEntryPtr->addChannel(1, 0.0, 0, 2000006, -5);
1134 0 : charEntryPtr->addChannel(1, 0.0, 0, -1000005, 2);
1135 0 : charEntryPtr->addChannel(1, 0.0, 0, -1000005, 4);
1136 0 : charEntryPtr->addChannel(1, 0.0, 0, -1000005, 6);
1137 0 : charEntryPtr->addChannel(1, 0.0, 0, -2000005, 2);
1138 0 : charEntryPtr->addChannel(1, 0.0, 0, -2000005, 4);
1139 0 : charEntryPtr->addChannel(1, 0.0, 0, -2000005, 6);
1140 :
1141 0 : if (iChar > 1) {
1142 0 : charEntryPtr->addChannel(1, 0.0, 0, 1000024, 23);
1143 0 : charEntryPtr->addChannel(1, 0.0, 0, 1000024, 25);
1144 0 : charEntryPtr->addChannel(1, 0.0, 0, 1000024, 35);
1145 0 : charEntryPtr->addChannel(1, 0.0, 0, 1000024, 36);
1146 0 : }
1147 :
1148 : // Modes involving right-handed sneutrinos are not included by default,
1149 : // but can be added by hand, by uncommenting the following lines.
1150 : // charEntryPtr->addChannel(1, 0.0, 0, 2000012, -11);
1151 : // charEntryPtr->addChannel(1, 0.0, 0, 2000014, -13);
1152 : // charEntryPtr->addChannel(1, 0.0, 0, 2000016, -15);
1153 :
1154 : return true;
1155 :
1156 0 : }
1157 :
1158 : //--------------------------------------------------------------------------
1159 :
1160 : void ResonanceChar::initConstants() {
1161 :
1162 0 : s2W = coupSUSYPtr->sin2W;
1163 0 : return;
1164 :
1165 : }
1166 :
1167 : //--------------------------------------------------------------------------
1168 :
1169 : // Calculate various common prefactors for the current mass.
1170 :
1171 : void ResonanceChar::calcPreFac(bool) {
1172 :
1173 0 : alpEM = coupSUSYPtr->alphaEM(mHat * mHat);
1174 0 : preFac = alpEM / (8.0 * s2W * pow(mHat,3));
1175 0 : return;
1176 :
1177 : }
1178 :
1179 : //--------------------------------------------------------------------------
1180 :
1181 : // Calculate width for currently considered channel.
1182 :
1183 : void ResonanceChar::calcWidth(bool) {
1184 :
1185 0 : widNow = 0.0;
1186 0 : if (ps == 0.) return;
1187 :
1188 0 : if (mult ==2){
1189 : double fac = 0.0;
1190 0 : kinFac = mHat * mHat - mf1 * mf1 + mf2 * mf2;
1191 0 : kinFac2 = pow(mHat,4) + pow(mf1,4) - 2.0 * pow(mf2,4)
1192 0 : + pow2(mHat) * pow2(mf2) + pow2(mf1)
1193 0 : * pow2(mf2) - 2.0 * pow2(mHat) * pow2(mf1);
1194 :
1195 0 : int idChar1 = coupSUSYPtr->typeChar(idRes);
1196 0 : int idChar2 = coupSUSYPtr->typeChar(id1Abs);
1197 0 : int idNeut1 = coupSUSYPtr->typeNeut(id1Abs);
1198 :
1199 0 : if (idChar2>0 && id2Abs == 23){
1200 : // ~chi_i -> chi_j + Z
1201 0 : fac = kinFac2 * (norm(coupSUSYPtr->OLp[idChar1][idChar2])
1202 0 : + norm(coupSUSYPtr->ORp[idChar1][idChar2]));
1203 0 : fac -= 12.0 * mHat * mf1 * pow2(mf2)
1204 0 : * real(coupSUSYPtr->OLp[idChar1][idChar2]
1205 0 : * conj(coupSUSYPtr->ORp[idChar1][idChar2]));
1206 0 : fac /= pow2(mf2) * (1.0 - s2W);
1207 0 : }
1208 0 : else if (idNeut1>0 && id2Abs==24){
1209 : // ~chi_i -> chi0_j + W- (or c.c.)
1210 :
1211 0 : fac = kinFac2 * (norm(coupSUSYPtr->OL[idNeut1][idChar1])
1212 0 : + norm(coupSUSYPtr->OR[idNeut1][idChar1]));
1213 0 : fac -= 12.0 * mHat * mf1 * pow2(mf2)
1214 0 : * real(coupSUSYPtr->OL[idNeut1][idChar1]
1215 0 : * conj(coupSUSYPtr->OR[idNeut1][idChar1]));
1216 0 : fac /= pow2(mf2);
1217 0 : }
1218 0 : else if (id1Abs > 1000000 && id1Abs%100 < 7 && id2Abs < 7){
1219 : // ~chi0_k -> ~q + q
1220 0 : bool idown = (id1Abs%2 == 1);
1221 0 : int iq = (id2Abs + 1 )/ 2;
1222 0 : int isq = (abs(id1Abs)/1000000 == 2) ? (abs(id1Abs)%10+1)/2 + 3
1223 : : (abs(id1Abs)%10+1)/2;
1224 :
1225 0 : if (idown){
1226 0 : fac = kinFac * (norm(coupSUSYPtr->LsduX[isq][iq][idChar1])
1227 0 : + norm(coupSUSYPtr->RsduX[isq][iq][idChar1]));
1228 0 : fac += 4.0 * mHat * mf2
1229 0 : * real(coupSUSYPtr->LsduX[isq][iq][idChar1]
1230 0 : * conj(coupSUSYPtr->RsduX[isq][iq][idChar1]));
1231 0 : }
1232 : else{
1233 0 : fac = kinFac * (norm(coupSUSYPtr->LsudX[isq][iq][idChar1])
1234 0 : + norm(coupSUSYPtr->RsudX[isq][iq][idChar1]));
1235 0 : fac += 4.0 * mHat * mf2
1236 0 : * real(coupSUSYPtr->LsudX[isq][iq][idChar1]
1237 0 : * conj(coupSUSYPtr->RsudX[isq][iq][idChar1]));
1238 : }
1239 0 : fac *= 6.0/(1 - s2W);
1240 0 : }
1241 0 : else if (id1Abs > 2000010 && id1Abs%2 == 0 ) {
1242 : // Check for right-handed neutralinos.
1243 0 : widNow = 0;
1244 0 : }
1245 0 : else if (id1Abs > 1000000 && id1Abs%100 > 10 && id1Abs%100 < 17
1246 0 : && id2Abs < 17){
1247 : // ~chi+_k -> ~l + l
1248 0 : bool idown = id2Abs%2;
1249 0 : int il = (id2Abs - 9)/ 2;
1250 0 : int isl = (abs(id1Abs)/1000000 == 2) ? (abs(id1Abs)%10+1)/2 + 3
1251 : : (abs(id1Abs)%10+1)/2;
1252 :
1253 0 : if (idown){
1254 0 : fac = kinFac * (norm(coupSUSYPtr->LslvX[isl][il][idChar1])
1255 0 : + norm(coupSUSYPtr->RslvX[isl][il][idChar1]));
1256 0 : fac += 4.0 * mHat * mf2 * real(coupSUSYPtr->LslvX[isl][il][idChar1]
1257 0 : * conj(coupSUSYPtr->RslvX[isl][il][idChar1]));
1258 0 : }
1259 : else{
1260 0 : fac = kinFac * (norm(coupSUSYPtr->LsvlX[isl][il][idChar1]));
1261 : }
1262 0 : fac *= 2.0/(1 - s2W);
1263 0 : }
1264 :
1265 : // TODO: Decays in higgs
1266 0 : widNow = fac * preFac * ps * pow2(mHat);
1267 : if (DBSUSY) {
1268 : cout<<idRes<<":: id1:"<<id1Abs<<" id2:"<<id2Abs<<" Width: ";
1269 : cout<<scientific<<widNow<<endl;
1270 : }
1271 0 : }else{
1272 : //TODO: Implement Chargino 3-body decays
1273 : }
1274 : return;
1275 0 : }
1276 :
1277 : //==========================================================================
1278 : // The ResonanceSlepton class
1279 : // Derived class for Slepton (and sneutrino) resonances
1280 :
1281 : //--------------------------------------------------------------------------
1282 :
1283 : // Set up Channels
1284 :
1285 : bool ResonanceSlepton::getChannels(int idPDG){
1286 :
1287 0 : idPDG = abs(idPDG);
1288 :
1289 : int ksusy = 1000000;
1290 0 : if (idPDG < ksusy) return false;
1291 0 : if(idPDG % ksusy < 7 || idPDG % ksusy > 17) return false;
1292 :
1293 : ParticleDataEntry* slepEntryPtr
1294 0 : = particleDataPtr->particleDataEntryPtr(idPDG);
1295 :
1296 : // Delete any decay channels read
1297 0 : slepEntryPtr->clearChannels();
1298 :
1299 0 : if(idPDG % 2 == 1) {
1300 :
1301 0 : slepEntryPtr->addChannel(1, 0.0, 0, -1000024, 16);
1302 0 : slepEntryPtr->addChannel(1, 0.0, 0, -1000037, 16);
1303 0 : slepEntryPtr->addChannel(1, 0.0, 0, 1000022, 15);
1304 0 : slepEntryPtr->addChannel(1, 0.0, 0, 1000023, 15);
1305 0 : slepEntryPtr->addChannel(1, 0.0, 0, 1000025, 15);
1306 0 : slepEntryPtr->addChannel(1, 0.0, 0, 1000035, 15);
1307 0 : slepEntryPtr->addChannel(1, 0.0, 0, 1000016, -24);
1308 0 : slepEntryPtr->addChannel(1, 0.0, 0, 2000016, -24);
1309 0 : slepEntryPtr->addChannel(1, 0.0, 0, 1000016, -37);
1310 0 : slepEntryPtr->addChannel(1, 0.0, 0, 2000016, -37);
1311 0 : slepEntryPtr->addChannel(1, 0.0, 0, 12, 13);
1312 0 : slepEntryPtr->addChannel(1, 0.0, 0, 12, 15);
1313 0 : slepEntryPtr->addChannel(1, 0.0, 0, 14, 11);
1314 0 : slepEntryPtr->addChannel(1, 0.0, 0, 14, 15);
1315 0 : slepEntryPtr->addChannel(1, 0.0, 0, 16, 11);
1316 0 : slepEntryPtr->addChannel(1, 0.0, 0, 16, 13);
1317 0 : slepEntryPtr->addChannel(1, 0.0, 0, -12, 11);
1318 0 : slepEntryPtr->addChannel(1, 0.0, 0, -12, 13);
1319 0 : slepEntryPtr->addChannel(1, 0.0, 0, -12, 15);
1320 0 : slepEntryPtr->addChannel(1, 0.0, 0, -14, 11);
1321 0 : slepEntryPtr->addChannel(1, 0.0, 0, -14, 13);
1322 0 : slepEntryPtr->addChannel(1, 0.0, 0, -14, 15);
1323 0 : slepEntryPtr->addChannel(1, 0.0, 0, -2, 1);
1324 0 : slepEntryPtr->addChannel(1, 0.0, 0, -2, 3);
1325 0 : slepEntryPtr->addChannel(1, 0.0, 0, -2, 5);
1326 0 : slepEntryPtr->addChannel(1, 0.0, 0, -4, 1);
1327 0 : slepEntryPtr->addChannel(1, 0.0, 0, -4, 3);
1328 0 : slepEntryPtr->addChannel(1, 0.0, 0, -4, 5);
1329 0 : slepEntryPtr->addChannel(1, 0.0, 0, -6, 1);
1330 0 : slepEntryPtr->addChannel(1, 0.0, 0, -6, 3);
1331 0 : slepEntryPtr->addChannel(1, 0.0, 0, -6, 5);
1332 0 : slepEntryPtr->addChannel(1, 0.0, 0, 1000022, 111, 16);
1333 0 : slepEntryPtr->addChannel(1, 0.0, 0, 1000022, 113, 16);
1334 0 : slepEntryPtr->addChannel(1, 0.0, 0, 1000022, 900111, 16);
1335 0 : slepEntryPtr->addChannel(1, 0.0, 0, 1000022, 16, 12, 11);
1336 0 : slepEntryPtr->addChannel(1, 0.0, 0, 1000022, 16, 14, 13);
1337 :
1338 0 : } else {
1339 0 : slepEntryPtr->addChannel(1, 0.0, 0, 1000024, 15);
1340 0 : slepEntryPtr->addChannel(1, 0.0, 0, 1000037, 15);
1341 0 : slepEntryPtr->addChannel(1, 0.0, 0, 1000022, 16);
1342 0 : slepEntryPtr->addChannel(1, 0.0, 0, 1000023, 16);
1343 0 : slepEntryPtr->addChannel(1, 0.0, 0, 1000025, 16);
1344 0 : slepEntryPtr->addChannel(1, 0.0, 0, 1000035, 16);
1345 0 : slepEntryPtr->addChannel(1, 0.0, 0, 1000015, 24);
1346 0 : slepEntryPtr->addChannel(1, 0.0, 0, 2000015, 24);
1347 0 : slepEntryPtr->addChannel(1, 0.0, 0, 1000015, 37);
1348 0 : slepEntryPtr->addChannel(1, 0.0, 0, 2000015, 37);
1349 0 : slepEntryPtr->addChannel(1, 0.0, 0, -11, 11);
1350 0 : slepEntryPtr->addChannel(1, 0.0, 0, -11, 13);
1351 0 : slepEntryPtr->addChannel(1, 0.0, 0, -11, 15);
1352 0 : slepEntryPtr->addChannel(1, 0.0, 0, -13, 11);
1353 0 : slepEntryPtr->addChannel(1, 0.0, 0, -13, 13);
1354 0 : slepEntryPtr->addChannel(1, 0.0, 0, -13, 15);
1355 0 : slepEntryPtr->addChannel(1, 0.0, 0, -1, 1);
1356 0 : slepEntryPtr->addChannel(1, 0.0, 0, -1, 3);
1357 0 : slepEntryPtr->addChannel(1, 0.0, 0, -1, 5);
1358 0 : slepEntryPtr->addChannel(1, 0.0, 0, -3, 1);
1359 0 : slepEntryPtr->addChannel(1, 0.0, 0, -3, 3);
1360 0 : slepEntryPtr->addChannel(1, 0.0, 0, -3, 5);
1361 0 : slepEntryPtr->addChannel(1, 0.0, 0, -5, 1);
1362 0 : slepEntryPtr->addChannel(1, 0.0, 0, -5, 3);
1363 0 : slepEntryPtr->addChannel(1, 0.0, 0, -5, 5);
1364 : }
1365 :
1366 : return true;
1367 0 : }
1368 :
1369 : //--------------------------------------------------------------------------
1370 :
1371 : // Initialize constants.
1372 :
1373 : void ResonanceSlepton::initConstants() {
1374 :
1375 : // Locally stored properties and couplings.
1376 0 : s2W = coupSUSYPtr->sin2W;
1377 :
1378 : // Initialize functions for calculating 3-body widths
1379 0 : stauWidths.setPointers(particleDataPtr,coupSUSYPtr,infoPtr);
1380 :
1381 0 : }
1382 :
1383 : //--------------------------------------------------------------------------
1384 :
1385 : // Calculate various common prefactors for the current mass.
1386 :
1387 : void ResonanceSlepton::calcPreFac(bool) {
1388 :
1389 : // Common coupling factors.
1390 0 : alpEM = coupSUSYPtr->alphaEM(mHat * mHat);
1391 0 : preFac = 1.0 / (s2W * pow(mHat,3));
1392 :
1393 0 : }
1394 :
1395 : //--------------------------------------------------------------------------
1396 :
1397 : // Calculate width for currently considered channel.
1398 :
1399 : void ResonanceSlepton::calcWidth(bool) {
1400 :
1401 : // Slepton type -- in u_i/d_i and generation
1402 : int ksusy = 1000000;
1403 0 : int isl = (abs(idRes)/ksusy == 2) ? (abs(idRes)%10+1)/2 + 3
1404 : : (abs(idRes)%10+1)/2;
1405 0 : int il = (id2Abs-9)/2;
1406 0 : bool islep = abs(idRes)%2;
1407 :
1408 : // Check that mass is above threshold.
1409 0 : if (ps == 0.) return;
1410 0 : widNow = 0.0;
1411 :
1412 : double fac = 0.0 , wid = 0.0;
1413 :
1414 0 : if (mult == 2) {
1415 : // Two-body decays
1416 :
1417 0 : kinFac = (mHat * mHat - mf1 * mf1 - mf2 * mf2);
1418 0 : fac = kinFac / (16.0 * M_PI * pow(mHat,3));
1419 :
1420 : // Case 1: RPV decays
1421 0 : if (id1Abs < 17 && id2Abs < 17) {
1422 :
1423 : wid = 0;
1424 0 : int il2 = (id1Abs - 9)/2;
1425 :
1426 : //Case 1a: RPV LLE
1427 0 : if(id1Abs > 10 && id2Abs > 10) {
1428 0 : if (!coupSUSYPtr->isLLE) { widNow = 0.0; return;}
1429 :
1430 0 : if (!islep){ // sneutrino
1431 0 : for (int isl2=1; isl2<3; isl2++)
1432 0 : wid += norm(coupSUSYPtr->Rsv[isl][isl2]
1433 0 : * coupSUSYPtr->rvLLE[il][isl2][il2]);
1434 0 : } else {
1435 0 : for (int isl2=1; isl2<3; isl2++)
1436 0 : wid += norm(coupSUSYPtr->Rsl[isl][isl2+3]
1437 0 : * coupSUSYPtr->rvLLE[isl2][il][il2]);
1438 : }
1439 : }
1440 : //Case 1b: RPV LQD
1441 0 : if(id1Abs < 10 && id2Abs < 10) {
1442 0 : if (!coupSUSYPtr->isLQD) { widNow = 0.0; return;}
1443 0 : if (!islep){ // sneutrino
1444 0 : for (int isl2=1; isl2<3; isl2++)
1445 0 : wid += norm(coupSUSYPtr->Rsv[isl][isl2]
1446 0 : * coupSUSYPtr->rvLQD[isl2][id1Abs][id2Abs]);
1447 0 : wid *= 3.0; // colour factor
1448 :
1449 0 : } else {
1450 0 : for (int isl2=1; isl2<3; isl2++)
1451 0 : wid += norm(coupSUSYPtr->Rsl[isl][isl2+3]
1452 0 : * coupSUSYPtr->rvLLE[isl2][id1Abs][id2Abs]);
1453 0 : wid *= 3.0; // colour factor
1454 : }
1455 : }
1456 0 : }
1457 :
1458 : //Case 2: lepton + gaugino
1459 :
1460 0 : if (id1Abs > ksusy && id2Abs > 10 && id2Abs < 17) {
1461 0 : for (int i=1; i<6 ; i++){
1462 : // ~ell/~nu -> ~chi0 + ell/nu
1463 0 : if (coupSUSYPtr->idNeut(i)==id1Abs && idRes%2 == id2Abs%2){
1464 0 : fac = alpEM * preFac / (2.0 * (1 - s2W));
1465 0 : if (islep)
1466 0 : wid = kinFac * (norm(coupSUSYPtr->LsllX[isl][il][i])
1467 0 : + norm(coupSUSYPtr->RsllX[isl][il][i]))
1468 0 : - 4.0 * mHat * mf2 * real(coupSUSYPtr->LsllX[isl][il][i]
1469 0 : * conj(coupSUSYPtr->RsllX[isl][il][i]));
1470 : else
1471 0 : wid = kinFac * (norm(coupSUSYPtr->LsvvX[isl][il][i])
1472 0 : + norm(coupSUSYPtr->RsvvX[isl][il][i]))
1473 0 : - 4.0 * mHat * mf2 * real(coupSUSYPtr->LsvvX[isl][il][i]
1474 0 : * conj(coupSUSYPtr->RsvvX[isl][il][i]));
1475 : }
1476 :
1477 : // ~ell/~nu -> ~chi- + nu/ell
1478 0 : else if (i < 3 && coupSUSYPtr->idChar(i)==id1Abs
1479 0 : && idRes%2 != id2Abs%2){
1480 :
1481 0 : fac = alpEM * preFac / (4.0 * (1 - s2W));
1482 0 : if (islep)
1483 0 : wid = kinFac * (norm(coupSUSYPtr->LslvX[isl][il][i])
1484 0 : + norm(coupSUSYPtr->RslvX[isl][il][i]))
1485 0 : - 4.0 * mHat * mf2 * real(coupSUSYPtr->LslvX[isl][il][i]
1486 0 : * conj(coupSUSYPtr->RslvX[isl][il][i]));
1487 : else
1488 : wid = kinFac * (norm(coupSUSYPtr->LslvX[isl][il][i])
1489 : + norm(coupSUSYPtr->RslvX[isl][il][i]))
1490 0 : - 4.0 * mHat * mf2 * real(coupSUSYPtr->LslvX[isl][il][i]
1491 0 : * conj(coupSUSYPtr->RslvX[isl][il][i]));
1492 : }
1493 : }
1494 0 : }
1495 :
1496 : //Case 3: ~l_i -> ~l_j + Z/W
1497 0 : else if (id1Abs > ksusy+10 && id1Abs%100 < 17
1498 0 : && (id2Abs == 23 || id2Abs == 24)){
1499 :
1500 : // factor of lambda^(3/2) = ps^3;
1501 0 : fac = alpEM * preFac/(16.0 * pow2(mf2) * (1.0 - s2W)) * pow2(ps) ;
1502 :
1503 0 : int isl2 = (id1Abs/ksusy == 2) ? (id1Abs%10+1)/2 + 3: (id1Abs%10+1)/2;
1504 :
1505 0 : if (id2Abs == 23 && id1Abs%2 == idRes%2){
1506 0 : if (islep)
1507 0 : wid = norm(coupSUSYPtr->LslslZ[isl][isl2]
1508 0 : + coupSUSYPtr->RslslZ[isl][isl2]);
1509 : else
1510 0 : wid = norm(coupSUSYPtr->LsvsvZ[isl][isl2]
1511 0 : + coupSUSYPtr->RsvsvZ[isl][isl2]);
1512 : }
1513 0 : else if (id2Abs == 24 && id1Abs%2 != idRes%2){
1514 0 : if (islep)
1515 0 : wid = norm(coupSUSYPtr->LslsvW[isl2][isl]);
1516 : else
1517 0 : wid = norm(coupSUSYPtr->LslsvW[isl][isl2]);
1518 : }
1519 0 : }
1520 :
1521 : // TODO: Case ~l_i -> ~l_j + h/H
1522 :
1523 0 : widNow = fac * wid * ps * pow2(mHat);
1524 :
1525 : if (DBSUSY) cout<<idRes<<":: id1:"<<id1Abs<<" id2:"<<id2Abs
1526 : <<" Width: "<<widNow<<endl;
1527 0 : }
1528 : else { // Case 4: special many-body stau decays
1529 : // Case 4a: ~tau -> pi0 nu_tau ~chi0
1530 : // Case 4b: ~tau -> rho/a1 nu_tau ~chi0
1531 : // Case 4c: ~tau -> l nu_l nu_tau ~chi0
1532 :
1533 : // Check that there is a stau component
1534 0 : double staufac = norm(coupSUSYPtr->Rsl[isl][3])
1535 0 : + norm(coupSUSYPtr->Rsl[isl][6]);
1536 0 : if (staufac < 1.0e-6 || abs(mRes - particleDataPtr->m0(15)) > 0.0 ) return;
1537 0 : if(id2Abs > 17)
1538 0 : widNow = stauWidths.getWidth(idRes, id2Abs);
1539 : else
1540 0 : widNow = stauWidths.getWidth(idRes, id3Abs);
1541 :
1542 0 : widNow *= staufac;
1543 :
1544 0 : }
1545 :
1546 0 : return;
1547 :
1548 0 : }
1549 :
1550 : //==========================================================================
1551 :
1552 : } //end namespace Pythia8
|
