Line data Source code
1 : // SigmaEW.h 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 : // Header file for electroweak process differential cross sections.
7 : // Contains classes derived from SigmaProcess via Sigma(1/2)Process.
8 :
9 : #ifndef Pythia8_SigmaEW_H
10 : #define Pythia8_SigmaEW_H
11 :
12 : #include "Pythia8/PythiaComplex.h"
13 : #include "Pythia8/SigmaProcess.h"
14 :
15 : namespace Pythia8 {
16 :
17 :
18 : //==========================================================================
19 :
20 : // A derived class for q g -> q gamma (q = u, d, s, c, b).
21 : // Use massless approximation also for Q since no alternative.
22 :
23 0 : class Sigma2qg2qgamma : public Sigma2Process {
24 :
25 : public:
26 :
27 : // Constructor.
28 0 : Sigma2qg2qgamma() {}
29 :
30 : // Calculate flavour-independent parts of cross section.
31 : virtual void sigmaKin();
32 :
33 : // Evaluate d(sigmaHat)/d(tHat).
34 : virtual double sigmaHat();
35 :
36 : // Select flavour, colour and anticolour.
37 : virtual void setIdColAcol();
38 :
39 : // Info on the subprocess.
40 0 : virtual string name() const {return "q g -> q gamma (udscb)";}
41 0 : virtual int code() const {return 201;}
42 0 : virtual string inFlux() const {return "qg";}
43 :
44 : private:
45 :
46 : // Values stored for later use.
47 : double sigUS, sigma0;
48 :
49 : };
50 :
51 : //==========================================================================
52 :
53 : // A derived class for q qbar -> g gamma.
54 :
55 0 : class Sigma2qqbar2ggamma : public Sigma2Process {
56 :
57 : public:
58 :
59 : // Constructor.
60 0 : Sigma2qqbar2ggamma() {}
61 :
62 : // Calculate flavour-independent parts of cross section.
63 : virtual void sigmaKin();
64 :
65 : // Evaluate d(sigmaHat)/d(tHat).
66 : virtual double sigmaHat();
67 :
68 : // Select flavour, colour and anticolour.
69 : virtual void setIdColAcol();
70 :
71 : // Info on the subprocess.
72 0 : virtual string name() const {return "q qbar -> g gamma";}
73 0 : virtual int code() const {return 202;}
74 0 : virtual string inFlux() const {return "qqbarSame";}
75 :
76 : private:
77 :
78 : // Values stored for later use.
79 : double sigma0;
80 :
81 : };
82 :
83 : //==========================================================================
84 :
85 : // A derived class for g g -> g gamma.
86 :
87 0 : class Sigma2gg2ggamma : public Sigma2Process {
88 :
89 : public:
90 :
91 : // Constructor.
92 0 : Sigma2gg2ggamma() {}
93 :
94 : // Initialize process.
95 : virtual void initProc();
96 :
97 : // Calculate flavour-independent parts of cross section.
98 : virtual void sigmaKin();
99 :
100 : // Evaluate d(sigmaHat)/d(tHat).
101 0 : virtual double sigmaHat() {return sigma;}
102 :
103 : // Select flavour, colour and anticolour.
104 : virtual void setIdColAcol();
105 :
106 : // Info on the subprocess.
107 0 : virtual string name() const {return "g g -> g gamma";}
108 0 : virtual int code() const {return 203;}
109 0 : virtual string inFlux() const {return "gg";}
110 :
111 : private:
112 :
113 : // Values stored for later use.
114 : double chargeSum, sigma;
115 :
116 : };
117 :
118 : //==========================================================================
119 :
120 : // A derived class for f fbar -> gamma gamma.
121 :
122 0 : class Sigma2ffbar2gammagamma : public Sigma2Process {
123 :
124 : public:
125 :
126 : // Constructor.
127 0 : Sigma2ffbar2gammagamma() {}
128 :
129 : // Calculate flavour-independent parts of cross section.
130 : virtual void sigmaKin();
131 :
132 : // Evaluate d(sigmaHat)/d(tHat).
133 : virtual double sigmaHat();
134 :
135 : // Select flavour, colour and anticolour.
136 : virtual void setIdColAcol();
137 :
138 : // Info on the subprocess.
139 0 : virtual string name() const {return "f fbar -> gamma gamma";}
140 0 : virtual int code() const {return 204;}
141 0 : virtual string inFlux() const {return "ffbarSame";}
142 :
143 : private:
144 :
145 : // Values stored for later use.
146 : double sigTU, sigma0;
147 :
148 : };
149 :
150 : //==========================================================================
151 :
152 : // A derived class for g g -> gamma gamma.
153 :
154 0 : class Sigma2gg2gammagamma : public Sigma2Process {
155 :
156 : public:
157 :
158 : // Constructor.
159 0 : Sigma2gg2gammagamma() {}
160 :
161 : // Initialize process.
162 : virtual void initProc();
163 :
164 : // Calculate flavour-independent parts of cross section.
165 : virtual void sigmaKin();
166 :
167 : // Evaluate d(sigmaHat)/d(tHat).
168 0 : virtual double sigmaHat() {return sigma;}
169 :
170 : // Select flavour, colour and anticolour.
171 : virtual void setIdColAcol();
172 :
173 : // Info on the subprocess.
174 0 : virtual string name() const {return "g g -> gamma gamma";}
175 0 : virtual int code() const {return 205;}
176 0 : virtual string inFlux() const {return "gg";}
177 :
178 : private:
179 :
180 : double charge2Sum, sigma;
181 :
182 : };
183 :
184 : //==========================================================================
185 :
186 : // A derived class for f f' -> f f' via t-channel gamma*/Z0 exchange.
187 :
188 0 : class Sigma2ff2fftgmZ : public Sigma2Process {
189 :
190 : public:
191 :
192 : // Constructor.
193 0 : Sigma2ff2fftgmZ() {}
194 :
195 : // Initialize process.
196 : virtual void initProc();
197 :
198 : // Calculate flavour-independent parts of cross section.
199 : virtual void sigmaKin();
200 :
201 : // Evaluate sigmaHat(sHat).
202 : virtual double sigmaHat();
203 :
204 : // Select flavour, colour and anticolour.
205 : virtual void setIdColAcol();
206 :
207 : // Info on the subprocess.
208 0 : virtual string name() const {return "f f' -> f f' (t-channel gamma*/Z0)";}
209 0 : virtual int code() const {return 211;}
210 0 : virtual string inFlux() const {return "ff";}
211 :
212 : private:
213 :
214 : // Z parameters for propagator.
215 : int gmZmode;
216 : double mZ, mZS, thetaWRat, sigmagmgm, sigmagmZ, sigmaZZ;
217 :
218 : };
219 :
220 : //==========================================================================
221 :
222 : // A derived class for f_1 f_2 -> f_3 f_4 via t-channel W+- exchange.
223 :
224 0 : class Sigma2ff2fftW : public Sigma2Process {
225 :
226 : public:
227 :
228 : // Constructor.
229 0 : Sigma2ff2fftW() {}
230 :
231 : // Initialize process.
232 : virtual void initProc();
233 :
234 : // Calculate flavour-independent parts of cross section.
235 : virtual void sigmaKin();
236 :
237 : // Evaluate sigmaHat(sHat).
238 : virtual double sigmaHat();
239 :
240 : // Select flavour, colour and anticolour.
241 : virtual void setIdColAcol();
242 :
243 : // Info on the subprocess.
244 0 : virtual string name() const {return "f_1 f_2 -> f_3 f_4 (t-channel W+-)";}
245 0 : virtual int code() const {return 212;}
246 0 : virtual string inFlux() const {return "ff";}
247 :
248 : private:
249 :
250 : // W parameters for propagator.
251 : double mW, mWS, thetaWRat, sigma0;
252 :
253 : };
254 :
255 : //==========================================================================
256 :
257 : // A derived class for q q' -> Q q" via t-channel W+- exchange.
258 : // Related to Sigma2ff2fftW class, but with massive matrix elements.
259 :
260 0 : class Sigma2qq2QqtW : public Sigma2Process {
261 :
262 : public:
263 :
264 : // Constructor.
265 0 : Sigma2qq2QqtW(int idIn, int codeIn) : idNew(idIn), codeSave(codeIn) {}
266 :
267 : // Initialize process.
268 : virtual void initProc();
269 :
270 : // Calculate flavour-independent parts of cross section.
271 : virtual void sigmaKin();
272 :
273 : // Evaluate sigmaHat(sHat).
274 : virtual double sigmaHat();
275 :
276 : // Select flavour, colour and anticolour.
277 : virtual void setIdColAcol();
278 :
279 : // Evaluate weight for W decay angles in top decay (else inactive).
280 : virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
281 :
282 : // Info on the subprocess.
283 0 : virtual string name() const {return nameSave;}
284 0 : virtual int code() const {return codeSave;}
285 0 : virtual string inFlux() const {return "ff";}
286 0 : virtual int id3Mass() const {return idNew;}
287 :
288 : private:
289 :
290 : // Values stored for process type. W parameters for propagator.
291 : int idNew, codeSave;
292 : string nameSave;
293 : double mW, mWS, thetaWRat, sigma0, openFracPos, openFracNeg;
294 :
295 : };
296 :
297 : //==========================================================================
298 :
299 : // A derived class for f fbar -> gamma*/Z0.
300 :
301 0 : class Sigma1ffbar2gmZ : public Sigma1Process {
302 :
303 : public:
304 :
305 : // Constructor.
306 0 : Sigma1ffbar2gmZ() {}
307 :
308 : // Initialize process.
309 : virtual void initProc();
310 :
311 : // Calculate flavour-independent parts of cross section.
312 : virtual void sigmaKin();
313 :
314 : // Evaluate sigmaHat(sHat).
315 : virtual double sigmaHat();
316 :
317 : // Select flavour, colour and anticolour.
318 : virtual void setIdColAcol();
319 :
320 : // Evaluate weight for Z decay angle.
321 : virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
322 :
323 : // Info on the subprocess.
324 0 : virtual string name() const {return "f fbar -> gamma*/Z0";}
325 0 : virtual int code() const {return 221;}
326 0 : virtual string inFlux() const {return "ffbarSame";}
327 0 : virtual int resonanceA() const {return 23;}
328 :
329 : private:
330 :
331 : // Parameters set at initialization or for each new event.
332 : int gmZmode;
333 : double mRes, GammaRes, m2Res, GamMRat, thetaWRat,
334 : gamSum, intSum, resSum, gamProp, intProp, resProp;
335 :
336 : // Pointer to properties of the particle species, to access decay channels.
337 : ParticleDataEntry* particlePtr;
338 :
339 : };
340 :
341 : //==========================================================================
342 :
343 : // A derived class for f fbar' -> W+-.
344 :
345 0 : class Sigma1ffbar2W : public Sigma1Process {
346 :
347 : public:
348 :
349 : // Constructor.
350 0 : Sigma1ffbar2W() {}
351 :
352 : // Initialize process.
353 : virtual void initProc();
354 :
355 : // Calculate flavour-independent parts of cross section.
356 : virtual void sigmaKin();
357 :
358 : // Evaluate sigmaHat(sHat).
359 : virtual double sigmaHat();
360 :
361 : // Select flavour, colour and anticolour.
362 : virtual void setIdColAcol();
363 :
364 : // Evaluate weight for W decay angle.
365 : virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
366 :
367 : // Info on the subprocess.
368 0 : virtual string name() const {return "f fbar' -> W+-";}
369 0 : virtual int code() const {return 222;}
370 0 : virtual string inFlux() const {return "ffbarChg";}
371 0 : virtual int resonanceA() const {return 24;}
372 :
373 : private:
374 :
375 : // Parameters set at initialization.
376 : double mRes, GammaRes, m2Res, GamMRat, thetaWRat, sigma0Pos, sigma0Neg;
377 :
378 : // Pointer to properties of the particle species, to access decay channels.
379 : ParticleDataEntry* particlePtr;
380 :
381 : };
382 :
383 : //==========================================================================
384 :
385 : // A derived class for f fbar -> gamma* -> f' fbar', summed over light f'.
386 : // Allows pT-ordered evolution for multiparton interactions.
387 :
388 0 : class Sigma2ffbar2ffbarsgm : public Sigma2Process {
389 :
390 : public:
391 :
392 : // Constructor.
393 0 : Sigma2ffbar2ffbarsgm() {}
394 :
395 : // Calculate flavour-independent parts of cross section.
396 : virtual void sigmaKin();
397 :
398 : // Evaluate sigmaHat(sHat).
399 : virtual double sigmaHat();
400 :
401 : // Select flavour, colour and anticolour.
402 : virtual void setIdColAcol();
403 :
404 : // Info on the subprocess.
405 : virtual string name() const {
406 0 : return "f fbar -> f' fbar' (s-channel gamma*)";}
407 0 : virtual int code() const {return 223;}
408 0 : virtual string inFlux() const {return "ffbarSame";}
409 0 : virtual bool isSChannel() const {return true;}
410 :
411 : private:
412 :
413 : // Values stored for later use.
414 : int idNew;
415 : double sigma0;
416 :
417 : };
418 :
419 : //==========================================================================
420 :
421 : // A derived class for f fbar -> gamma*/Z0 -> f' fbar', summed over light f.
422 :
423 0 : class Sigma2ffbar2ffbarsgmZ : public Sigma2Process {
424 :
425 : public:
426 :
427 : // Constructor.
428 0 : Sigma2ffbar2ffbarsgmZ() {}
429 :
430 : // Initialize process.
431 : virtual void initProc();
432 :
433 : // Calculate flavour-independent parts of cross section.
434 : virtual void sigmaKin();
435 :
436 : // Evaluate sigmaHat(sHat).
437 : virtual double sigmaHat();
438 :
439 : // Select flavour, colour and anticolour.
440 : virtual void setIdColAcol();
441 :
442 : // Info on the subprocess.
443 : virtual string name() const {
444 0 : return "f fbar -> f' fbar' (s-channel gamma*/Z0)";}
445 0 : virtual int code() const {return 224;}
446 0 : virtual string inFlux() const {return "ffbarSame";}
447 0 : virtual bool isSChannel() const {return true;}
448 0 : virtual int idSChannel() const {return 23;}
449 0 : virtual int resonanceA() const {return 23;}
450 :
451 : private:
452 :
453 : // Parameters set at initialization or for each new event.
454 : int gmZmode;
455 : double mRes, GammaRes, m2Res, GamMRat, thetaWRat, colQ,
456 : gamSumT, gamSumL, intSumT, intSumL, intSumA, resSumT, resSumL,
457 : resSumA, gamProp, intProp, resProp, cThe;
458 : vector<int> idVec;
459 : vector<double> gamT, gamL, intT, intL, intA, resT, resL, resA, sigTLA;
460 :
461 : // Pointer to properties of the particle species, to access decay channels.
462 : ParticleDataEntry* particlePtr;
463 :
464 : };
465 :
466 : //==========================================================================
467 :
468 : // A derived class for f_1 fbar_2 -> W+- -> f_3 fbar_4, summed over light f.
469 :
470 0 : class Sigma2ffbar2ffbarsW : public Sigma2Process {
471 :
472 : public:
473 :
474 : // Constructor.
475 0 : Sigma2ffbar2ffbarsW() {}
476 :
477 : // Initialize process.
478 : virtual void initProc();
479 :
480 : // Calculate flavour-independent parts of cross section.
481 : virtual void sigmaKin();
482 :
483 : // Evaluate sigmaHat(sHat).
484 : virtual double sigmaHat();
485 :
486 : // Select flavour, colour and anticolour.
487 : virtual void setIdColAcol();
488 :
489 : // Info on the subprocess.
490 : virtual string name() const {
491 0 : return "f_1 fbar_2 -> f_3 fbar_4 (s-channel W+-)";}
492 0 : virtual int code() const {return 225;}
493 0 : virtual string inFlux() const {return "ffbarChg";}
494 0 : virtual bool isSChannel() const {return true;}
495 0 : virtual int idSChannel() const {return 24;}
496 0 : virtual int resonanceA() const {return 24;}
497 :
498 : private:
499 :
500 : // Parameters set at initialization or stored for later use.
501 : int id3New, id4New;
502 : double mRes, GammaRes, m2Res, GamMRat, thetaWRat, sigma0;
503 :
504 : // Pointer to properties of the particle species, to access decay channels.
505 : ParticleDataEntry* particlePtr;
506 :
507 : };
508 :
509 : //==========================================================================
510 :
511 : // A derived class for f fbar -> gamma*/Z0 -> F Fbar, for one heavy F.
512 : // Allows pT cuts as for other 2 -> 2 processes.
513 :
514 0 : class Sigma2ffbar2FFbarsgmZ : public Sigma2Process {
515 :
516 : public:
517 :
518 : // Constructor.
519 0 : Sigma2ffbar2FFbarsgmZ(int idIn, int codeIn) : idNew(idIn),
520 0 : codeSave(codeIn) {}
521 :
522 : // Initialize process.
523 : virtual void initProc();
524 :
525 : // Calculate flavour-independent parts of cross section.
526 : virtual void sigmaKin();
527 :
528 : // Evaluate sigmaHat(sHat).
529 : virtual double sigmaHat();
530 :
531 : // Select flavour, colour and anticolour.
532 : virtual void setIdColAcol();
533 :
534 : // Evaluate weight for W decay angles in top decay (else inactive).
535 : virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
536 :
537 : // Info on the subprocess.
538 0 : virtual string name() const {return nameSave;}
539 0 : virtual int code() const {return codeSave;}
540 0 : virtual string inFlux() const {return "ffbarSame";}
541 0 : virtual bool isSChannel() const {return true;}
542 0 : virtual int id3Mass() const {return idNew;}
543 0 : virtual int id4Mass() const {return idNew;}
544 0 : virtual int resonanceA() const {return 23;}
545 :
546 : private:
547 :
548 : // Values stored for process type. Z parameters for propagator.
549 : int idNew, codeSave, gmZmode;
550 : string nameSave;
551 : bool isPhysical;
552 : double ef, vf, af, mRes, GammaRes, m2Res, GamMRat, thetaWRat,
553 : mr, betaf, cosThe, gamProp, intProp, resProp, openFracPair;
554 :
555 : };
556 :
557 : //==========================================================================
558 :
559 : // A derived class for f fbar' -> W+- -> F fbar", for one or two heavy F.
560 : // Allows pT cuts as for other 2 -> 2 processes.
561 :
562 0 : class Sigma2ffbar2FfbarsW : public Sigma2Process {
563 :
564 : public:
565 :
566 : // Constructor.
567 0 : Sigma2ffbar2FfbarsW(int idIn, int idIn2, int codeIn) : idNew(idIn),
568 0 : idNew2(idIn2), codeSave(codeIn) {}
569 :
570 : // Initialize process.
571 : virtual void initProc();
572 :
573 : // Calculate flavour-independent parts of cross section.
574 : virtual void sigmaKin();
575 :
576 : // Evaluate sigmaHat(sHat).
577 : virtual double sigmaHat();
578 :
579 : // Select flavour, colour and anticolour.
580 : virtual void setIdColAcol();
581 :
582 : // Evaluate weight for W decay angles in top decay (else inactive).
583 : virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
584 :
585 : // Info on the subprocess.
586 0 : virtual string name() const {return nameSave;}
587 0 : virtual int code() const {return codeSave;}
588 0 : virtual string inFlux() const {return "ffbarChg";}
589 0 : virtual bool isSChannel() const {return true;}
590 0 : virtual int id3Mass() const {return idNew;}
591 0 : virtual int id4Mass() const {return idPartner;}
592 0 : virtual int resonanceA() const {return 24;}
593 :
594 : private:
595 :
596 : // Values stored for process type. W parameters for propagator.
597 : int idNew, idNew2, codeSave, idPartner;
598 : string nameSave;
599 : bool isPhysical;
600 : double V2New, mRes, GammaRes, m2Res, GamMRat, thetaWRat, sigma0,
601 : openFracPos, openFracNeg;
602 :
603 : };
604 :
605 : //==========================================================================
606 :
607 : // An intermediate class for f fbar -> gamma*/Z0/W+- gamma*/Z0/W-+.
608 :
609 0 : class Sigma2ffbargmZWgmZW : public Sigma2Process {
610 :
611 : public:
612 :
613 : // Constructor.
614 0 : Sigma2ffbargmZWgmZW() {}
615 :
616 : protected:
617 :
618 : // Internal products.
619 : Vec4 pRot[7];
620 : complex hA[7][7];
621 : complex hC[7][7];
622 :
623 : // Calculate and store internal products.
624 : void setupProd( Event& process, int i1, int i2, int i3, int i4,
625 : int i5, int i6);
626 :
627 : // Evaluate the F function of Gunion and Kunszt.
628 : complex fGK(int i1, int i2, int i3, int i4, int i5, int i6);
629 :
630 : // Evaluate the Xi function of Gunion and Kunszt.
631 : double xiGK( double tHnow, double uHnow);
632 :
633 : // Evaluate the Xj function of Gunion and Kunszt.
634 : double xjGK( double tHnow, double uHnow);
635 :
636 : private:
637 :
638 : };
639 :
640 : //==========================================================================
641 :
642 : // A derived class for f fbar -> gamma*/Z0 gamma*/Z0.
643 :
644 0 : class Sigma2ffbar2gmZgmZ : public Sigma2ffbargmZWgmZW {
645 :
646 : public:
647 :
648 : // Constructor.
649 0 : Sigma2ffbar2gmZgmZ() {}
650 :
651 : // Initialize process.
652 : virtual void initProc();
653 :
654 : // Calculate flavour-independent parts of cross section.
655 : virtual void sigmaKin();
656 :
657 : // Evaluate d(sigmaHat)/d(tHat).
658 : virtual double sigmaHat();
659 :
660 : // Select flavour, colour and anticolour.
661 : virtual void setIdColAcol();
662 :
663 : // Evaluate weight for simultaneous flavour choices.
664 : virtual double weightDecayFlav( Event& process);
665 :
666 : // Evaluate weight for decay angles of the two gamma*/Z0.
667 : virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
668 :
669 : // Info on the subprocess.
670 0 : virtual string name() const {return "f fbar -> gamma*/Z0 gamma*/Z0";}
671 0 : virtual int code() const {return 231;}
672 0 : virtual string inFlux() const {return "ffbarSame";}
673 0 : virtual int id3Mass() const {return 23;}
674 0 : virtual int id4Mass() const {return 23;}
675 :
676 : private:
677 :
678 : // Parameters set at initialization or for each new event.
679 : int gmZmode, i1, i2, i3, i4, i5, i6;
680 : double mRes, GammaRes, m2Res, GamMRat, thetaWRat, sigma0,
681 : gamSum3, intSum3, resSum3, gamProp3, intProp3, resProp3,
682 : gamSum4, intSum4, resSum4, gamProp4, intProp4, resProp4,
683 : c3LL, c3LR, c3RL, c3RR, c4LL, c4LR, c4RL, c4RR, flavWt;
684 :
685 : // Pointer to properties of the particle species, to access decay channels.
686 : ParticleDataEntry* particlePtr;
687 :
688 : };
689 :
690 : //==========================================================================
691 :
692 : // A derived class for f fbar' -> Z0 W+-. (Here pure Z0, unfortunately.)
693 :
694 0 : class Sigma2ffbar2ZW : public Sigma2ffbargmZWgmZW {
695 :
696 : public:
697 :
698 : // Constructor.
699 0 : Sigma2ffbar2ZW() {}
700 :
701 : // Initialize process.
702 : virtual void initProc();
703 :
704 : // Calculate flavour-independent parts of cross section.
705 : virtual void sigmaKin();
706 :
707 : // Evaluate d(sigmaHat)/d(tHat).
708 : virtual double sigmaHat();
709 :
710 : // Select flavour, colour and anticolour.
711 : virtual void setIdColAcol();
712 :
713 : // Evaluate weight for Z0 and W+- decay angles.
714 : virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
715 :
716 : // Info on the subprocess.
717 0 : virtual string name() const {return "f fbar' -> Z0 W+- (no gamma*!)";}
718 0 : virtual int code() const {return 232;}
719 0 : virtual string inFlux() const {return "ffbarChg";}
720 0 : virtual int id3Mass() const {return 23;}
721 0 : virtual int id4Mass() const {return 24;}
722 0 : virtual int resonanceA() const {return 24;}
723 :
724 : private:
725 :
726 : // Store W+- mass and width, and couplings.
727 : double mW, widW, mWS, mwWS, sin2thetaW, cos2thetaW, thetaWRat, cotT,
728 : thetaWpt, thetaWmm, lun, lde, sigma0, openFracPos, openFracNeg;
729 :
730 : };
731 :
732 : //==========================================================================
733 :
734 : // A derived class for f fbar -> W+ W-.
735 :
736 0 : class Sigma2ffbar2WW : public Sigma2ffbargmZWgmZW {
737 :
738 : public:
739 :
740 : // Constructor.
741 0 : Sigma2ffbar2WW() {}
742 :
743 : // Initialize process.
744 : virtual void initProc();
745 :
746 : // Calculate flavour-independent parts of cross section.
747 : virtual void sigmaKin();
748 :
749 : // Evaluate d(sigmaHat)/d(tHat).
750 : virtual double sigmaHat();
751 :
752 : // Select flavour, colour and anticolour.
753 : virtual void setIdColAcol();
754 :
755 : // Evaluate weight for W+ and W- decay angles.
756 : virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
757 :
758 : // Info on the subprocess.
759 0 : virtual string name() const {return "f fbar -> W+ W-";}
760 0 : virtual int code() const {return 233;}
761 0 : virtual string inFlux() const {return "ffbarSame";}
762 0 : virtual int id3Mass() const {return 24;}
763 0 : virtual int id4Mass() const {return -24;}
764 0 : virtual int resonanceA() const {return 23;}
765 :
766 : private:
767 :
768 : // Store Z0 mass and width.
769 : double mZ, widZ, mZS, mwZS, thetaWRat, sigma0, cgg, cgZ, cZZ, cfg,
770 : cfZ, cff, gSS, gTT, gST, gUU, gSU, openFracPair;
771 :
772 : };
773 :
774 : //==========================================================================
775 :
776 : // An intermediate class for f fbar -> gamma*/Z0 g/gamma and permutations.
777 :
778 0 : class Sigma2ffbargmZggm : public Sigma2Process {
779 :
780 : public:
781 :
782 : // Constructor.
783 0 : Sigma2ffbargmZggm() {}
784 :
785 : // Initialize process.
786 : virtual void initProc();
787 :
788 : // Evaluate weight for gamma&/Z0 decay angle.
789 : virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
790 :
791 : protected:
792 :
793 : // Parameters set at initialization or for each new event.
794 : int gmZmode;
795 : double mRes, GammaRes, m2Res, GamMRat, thetaWRat,
796 : gamSum, intSum, resSum, gamProp, intProp, resProp;
797 :
798 : // Evaluate current sum of flavour couplings times phase space.
799 : void flavSum();
800 :
801 : // Evaluate current propagator terms of cross section.
802 : void propTerm();
803 :
804 : private:
805 :
806 : // Pointer to properties of the particle species, to access decay channels.
807 : ParticleDataEntry* particlePtr;
808 :
809 : };
810 :
811 : //==========================================================================
812 :
813 : // A derived class for q qbar -> gamma*/Z0 g.
814 :
815 0 : class Sigma2qqbar2gmZg : public Sigma2ffbargmZggm {
816 :
817 : public:
818 :
819 : // Constructor.
820 0 : Sigma2qqbar2gmZg() {}
821 :
822 : // Calculate flavour-independent parts of cross section.
823 : virtual void sigmaKin();
824 :
825 : // Evaluate d(sigmaHat)/d(tHat).
826 : virtual double sigmaHat();
827 :
828 : // Select flavour, colour and anticolour.
829 : virtual void setIdColAcol();
830 :
831 : // Info on the subprocess.
832 0 : virtual string name() const {return "q qbar -> gamma*/Z0 g";}
833 0 : virtual int code() const {return 241;}
834 0 : virtual string inFlux() const {return "qqbarSame";}
835 0 : virtual int id3Mass() const {return 23;}
836 :
837 : private:
838 :
839 : // Values stored for later use.
840 : double sigma0;
841 :
842 : };
843 :
844 : //==========================================================================
845 :
846 : // A derived class for q g -> gamma*/Z0 q.
847 :
848 0 : class Sigma2qg2gmZq : public Sigma2ffbargmZggm {
849 :
850 : public:
851 :
852 : // Constructor.
853 0 : Sigma2qg2gmZq() {}
854 :
855 : // Calculate flavour-independent parts of cross section.
856 : virtual void sigmaKin();
857 :
858 : // Evaluate d(sigmaHat)/d(tHat).
859 : virtual double sigmaHat();
860 :
861 : // Select flavour, colour and anticolour.
862 : virtual void setIdColAcol();
863 :
864 : // Info on the subprocess.
865 0 : virtual string name() const {return "q g-> gamma*/Z0 q";}
866 0 : virtual int code() const {return 242;}
867 0 : virtual string inFlux() const {return "qg";}
868 0 : virtual int id3Mass() const {return 23;}
869 :
870 : private:
871 :
872 : // Values stored for later use.
873 : double sigma0;
874 :
875 : };
876 :
877 : //==========================================================================
878 :
879 : // A derived class for f fbar' -> gamma*/Z0 gamma.
880 :
881 0 : class Sigma2ffbar2gmZgm : public Sigma2ffbargmZggm {
882 :
883 : public:
884 :
885 : // Constructor.
886 0 : Sigma2ffbar2gmZgm() {}
887 :
888 : // Calculate flavour-independent parts of cross section.
889 : virtual void sigmaKin();
890 :
891 : // Evaluate d(sigmaHat)/d(tHat).
892 : virtual double sigmaHat();
893 :
894 : // Select flavour, colour and anticolour.
895 : virtual void setIdColAcol();
896 :
897 : // Info on the subprocess.
898 0 : virtual string name() const {return "f fbar -> gamma*/Z0 gamma";}
899 0 : virtual int code() const {return 243;}
900 0 : virtual string inFlux() const {return "ffbarSame";}
901 0 : virtual int id3Mass() const {return 23;}
902 :
903 : private:
904 :
905 : // Values stored for later use.
906 : double sigma0;
907 :
908 : };
909 :
910 : //==========================================================================
911 :
912 : // A derived class for f gamma -> gamma*/Z0 f.
913 :
914 0 : class Sigma2fgm2gmZf : public Sigma2ffbargmZggm {
915 :
916 : public:
917 :
918 : // Constructor.
919 0 : Sigma2fgm2gmZf() {}
920 :
921 : // Calculate flavour-independent parts of cross section.
922 : virtual void sigmaKin();
923 :
924 : // Evaluate d(sigmaHat)/d(tHat).
925 : virtual double sigmaHat();
926 :
927 : // Select flavour, colour and anticolour.
928 : virtual void setIdColAcol();
929 :
930 : // Info on the subprocess.
931 0 : virtual string name() const {return "f gamma -> gamma*/Z0 f";}
932 0 : virtual int code() const {return 244;}
933 0 : virtual string inFlux() const {return "fgm";}
934 0 : virtual int id3Mass() const {return 23;}
935 :
936 : private:
937 :
938 : // Values stored for later use.
939 : double sigma0;
940 :
941 : };
942 :
943 : //==========================================================================
944 :
945 : // An intermediate class for f fbar -> W+- g/gamma and permutations.
946 :
947 0 : class Sigma2ffbarWggm : public Sigma2Process {
948 :
949 : public:
950 :
951 : // Constructor.
952 0 : Sigma2ffbarWggm() {}
953 :
954 : // Evaluate weight for gamma&/Z0 decay angle.
955 : virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
956 :
957 : private:
958 :
959 : };
960 :
961 : //==========================================================================
962 :
963 : // A derived class for q qbar' -> W+- g.
964 :
965 0 : class Sigma2qqbar2Wg : public Sigma2ffbarWggm {
966 :
967 : public:
968 :
969 : // Constructor.
970 0 : Sigma2qqbar2Wg() {}
971 :
972 : // Initialize process.
973 : virtual void initProc();
974 :
975 : // Calculate flavour-independent parts of cross section.
976 : virtual void sigmaKin();
977 :
978 : // Evaluate d(sigmaHat)/d(tHat).
979 : virtual double sigmaHat();
980 :
981 : // Select flavour, colour and anticolour.
982 : virtual void setIdColAcol();
983 :
984 : // Info on the subprocess.
985 0 : virtual string name() const {return "q qbar' -> W+- g";}
986 0 : virtual int code() const {return 251;}
987 0 : virtual string inFlux() const {return "ffbarChg";}
988 0 : virtual int id3Mass() const {return 24;}
989 :
990 : private:
991 :
992 : // Values stored for later use.
993 : double sigma0, openFracPos, openFracNeg;
994 :
995 : };
996 :
997 : //==========================================================================
998 :
999 : // A derived class for q g -> W+- q'.
1000 :
1001 0 : class Sigma2qg2Wq : public Sigma2ffbarWggm {
1002 :
1003 : public:
1004 :
1005 : // Constructor.
1006 0 : Sigma2qg2Wq() {}
1007 :
1008 : // Initialize process.
1009 : virtual void initProc();
1010 :
1011 : // Calculate flavour-independent parts of cross section.
1012 : virtual void sigmaKin();
1013 :
1014 : // Evaluate d(sigmaHat)/d(tHat).
1015 : virtual double sigmaHat();
1016 :
1017 : // Select flavour, colour and anticolour.
1018 : virtual void setIdColAcol();
1019 :
1020 : // Info on the subprocess.
1021 0 : virtual string name() const {return "q g-> W+- q'";}
1022 0 : virtual int code() const {return 252;}
1023 0 : virtual string inFlux() const {return "qg";}
1024 0 : virtual int id3Mass() const {return 24;}
1025 :
1026 : private:
1027 :
1028 : // Values stored for later use.
1029 : double sigma0, openFracPos, openFracNeg;
1030 :
1031 : };
1032 :
1033 : //==========================================================================
1034 :
1035 : // A derived class for f fbar' -> W+- gamma.
1036 :
1037 0 : class Sigma2ffbar2Wgm : public Sigma2ffbarWggm {
1038 :
1039 : public:
1040 :
1041 : // Constructor.
1042 0 : Sigma2ffbar2Wgm() {}
1043 :
1044 : // Initialize process.
1045 : virtual void initProc();
1046 :
1047 : // Calculate flavour-independent parts of cross section.
1048 : virtual void sigmaKin();
1049 :
1050 : // Evaluate d(sigmaHat)/d(tHat).
1051 : virtual double sigmaHat();
1052 :
1053 : // Select flavour, colour and anticolour.
1054 : virtual void setIdColAcol();
1055 :
1056 : // Info on the subprocess.
1057 0 : virtual string name() const {return "f fbar' -> W+- gamma";}
1058 0 : virtual int code() const {return 253;}
1059 0 : virtual string inFlux() const {return "ffbarChg";}
1060 0 : virtual int id3Mass() const {return 24;}
1061 :
1062 : private:
1063 :
1064 : // Values stored for later use.
1065 : double sigma0, openFracPos, openFracNeg;
1066 :
1067 : };
1068 :
1069 : //==========================================================================
1070 :
1071 : // A derived class for f gamma -> W+- f'.
1072 :
1073 0 : class Sigma2fgm2Wf : public Sigma2ffbarWggm {
1074 :
1075 : public:
1076 :
1077 : // Constructor.
1078 0 : Sigma2fgm2Wf() {}
1079 :
1080 : // Initialize process.
1081 : virtual void initProc();
1082 :
1083 : // Calculate flavour-independent parts of cross section.
1084 : virtual void sigmaKin();
1085 :
1086 : // Evaluate d(sigmaHat)/d(tHat).
1087 : virtual double sigmaHat();
1088 :
1089 : // Select flavour, colour and anticolour.
1090 : virtual void setIdColAcol();
1091 :
1092 : // Info on the subprocess.
1093 0 : virtual string name() const {return "f gamma -> W+- f'";}
1094 0 : virtual int code() const {return 254;}
1095 0 : virtual string inFlux() const {return "fgm";}
1096 0 : virtual int id3Mass() const {return 24;}
1097 :
1098 : private:
1099 :
1100 : // Values stored for later use.
1101 : double sigma0, openFracPos, openFracNeg;
1102 :
1103 : };
1104 : //==========================================================================
1105 :
1106 : // A derived class for gamma gamma -> f fbar.
1107 :
1108 0 : class Sigma2gmgm2ffbar : public Sigma2Process {
1109 :
1110 : public:
1111 :
1112 : // Constructor.
1113 0 : Sigma2gmgm2ffbar(int idIn, int codeIn) : idNew(idIn), codeSave(codeIn) {}
1114 :
1115 : // Initialize process.
1116 : virtual void initProc();
1117 :
1118 : // Calculate flavour-independent parts of cross section.
1119 : virtual void sigmaKin();
1120 :
1121 : // Evaluate d(sigmaHat)/d(tHat).
1122 0 : virtual double sigmaHat() {return sigma;}
1123 :
1124 : // Select flavour, colour and anticolour.
1125 : virtual void setIdColAcol();
1126 :
1127 : // Info on the subprocess.
1128 0 : virtual string name() const {return nameSave;}
1129 0 : virtual int code() const {return codeSave;}
1130 0 : virtual string inFlux() const {return "gmgm";}
1131 0 : virtual int id3Mass() const {return idMass;}
1132 0 : virtual int id4Mass() const {return idMass;}
1133 :
1134 : private:
1135 :
1136 : // Member variables.
1137 : int idNew, codeSave, idMass, idNow;
1138 : string nameSave;
1139 : double ef4, s34Avg, sigTU, sigma, openFracPair;
1140 :
1141 : };
1142 :
1143 : //==========================================================================
1144 :
1145 : } // end namespace Pythia8
1146 :
1147 : #endif // Pythia8_SigmaEW_H
|
