]>
Commit | Line | Data |
---|---|---|
5ad4eb21 | 1 | // SigmaLeftRightSym.h is a part of the PYTHIA event generator. |
2 | // Copyright (C) 2008 Torbjorn Sjostrand. | |
3 | // PYTHIA is licenced under the GNU GPL version 2, see COPYING for details. | |
4 | // Please respect the MCnet Guidelines, see GUIDELINES for details. | |
5 | ||
6 | // Header file for left-rights-symmetry differential cross sections. | |
7 | // Contains classes derived from SigmaProcess via Sigma(1/2/3)Process. | |
8 | ||
9 | #ifndef Pythia8_SigmaLeftRightSym_H | |
10 | #define Pythia8_SigmaLeftRightSym_H | |
11 | ||
12 | #include "SigmaProcess.h" | |
13 | ||
14 | namespace Pythia8 { | |
15 | ||
16 | //************************************************************************** | |
17 | ||
18 | // A derived class for f fbar -> Z_R^0 (righthanded gauge boson). | |
19 | ||
20 | class Sigma1ffbar2ZRight : public Sigma1Process { | |
21 | ||
22 | public: | |
23 | ||
24 | // Constructor. | |
25 | Sigma1ffbar2ZRight() {} | |
26 | ||
27 | // Initialize process. | |
28 | virtual void initProc(); | |
29 | ||
30 | // Calculate flavour-independent parts of cross section. | |
31 | virtual void sigmaKin(); | |
32 | ||
33 | // Evaluate sigmaHat(sHat). | |
34 | virtual double sigmaHat(); | |
35 | ||
36 | // Select flavour, colour and anticolour. | |
37 | virtual void setIdColAcol(); | |
38 | ||
39 | // Evaluate weight for G* decay angle. | |
40 | virtual double weightDecay( Event& process, int iResBeg, int iResEnd); | |
41 | ||
42 | // Info on the subprocess. | |
43 | virtual string name() const {return "f fbar -> Z_R^0";} | |
44 | virtual int code() const {return 3101;} | |
45 | virtual string inFlux() const {return "ffbarSame";} | |
46 | virtual int resonanceA() const {return idZR;} | |
47 | ||
48 | private: | |
49 | ||
50 | // Parameters set at initialization or for current kinematics. | |
51 | int idZR; | |
52 | double mRes, GammaRes, m2Res, GamMRat, sin2tW, sigma0; | |
53 | ||
54 | // Pointer to properties of the particle species, to access decay channels. | |
55 | ParticleDataEntry* ZRPtr; | |
56 | ||
57 | }; | |
58 | ||
59 | //************************************************************************** | |
60 | ||
61 | // A derived class for f fbar' -> W_R^+- (righthanded gauge boson). | |
62 | ||
63 | class Sigma1ffbar2WRight : public Sigma1Process { | |
64 | ||
65 | public: | |
66 | ||
67 | // Constructor. | |
68 | Sigma1ffbar2WRight() {} | |
69 | ||
70 | // Initialize process. | |
71 | virtual void initProc(); | |
72 | ||
73 | // Calculate flavour-independent parts of cross section. | |
74 | virtual void sigmaKin(); | |
75 | ||
76 | // Evaluate sigmaHat(sHat). | |
77 | virtual double sigmaHat(); | |
78 | ||
79 | // Select flavour, colour and anticolour. | |
80 | virtual void setIdColAcol(); | |
81 | ||
82 | // Evaluate weight for W decay angle. | |
83 | virtual double weightDecay( Event& process, int iResBeg, int iResEnd); | |
84 | ||
85 | // Info on the subprocess. | |
86 | virtual string name() const {return "f fbar' -> W_R^+-";} | |
87 | virtual int code() const {return 3102;} | |
88 | virtual string inFlux() const {return "ffbarChg";} | |
89 | virtual int resonanceA() const {return idWR;} | |
90 | ||
91 | private: | |
92 | ||
93 | // Parameters set at initialization. | |
94 | int idWR; | |
95 | double mRes, GammaRes, m2Res, GamMRat, thetaWRat, sigma0Pos, sigma0Neg; | |
96 | ||
97 | // Pointer to properties of the particle species, to access decay channels. | |
98 | ParticleDataEntry* particlePtr; | |
99 | ||
100 | }; | |
101 | ||
102 | //************************************************************************** | |
103 | ||
104 | // A derived class for l l -> H_L^++-- or H_R^++-- (doubly charged Higgs). | |
105 | ||
106 | class Sigma1ll2Hchgchg : public Sigma1Process { | |
107 | ||
108 | public: | |
109 | ||
110 | // Constructor. | |
111 | Sigma1ll2Hchgchg(int leftRightIn ) : leftRight(leftRightIn) {} | |
112 | ||
113 | // Initialize process. | |
114 | virtual void initProc(); | |
115 | ||
116 | // Evaluate sigmaHat(sHat). | |
117 | virtual double sigmaHat(); | |
118 | ||
119 | // Select flavour, colour and anticolour. | |
120 | virtual void setIdColAcol(); | |
121 | ||
122 | // Evaluate weight for W decay angle. | |
123 | virtual double weightDecay( Event& process, int iResBeg, int iResEnd); | |
124 | ||
125 | // Info on the subprocess. | |
126 | virtual string name() const {return nameSave;} | |
127 | virtual int code() const {return codeSave;} | |
128 | virtual string inFlux() const {return "ff";} | |
129 | virtual int resonanceA() const {return idHLR;} | |
130 | ||
131 | private: | |
132 | ||
133 | // Parameters set at initialization. | |
134 | int leftRight, idHLR, codeSave; | |
135 | string nameSave; | |
136 | double mRes, GammaRes, m2Res, GamMRat, thetaWRat, yukawa[4][4]; | |
137 | ||
138 | // Pointer to properties of the particle species, to access decay channels. | |
139 | ParticleDataEntry* particlePtr; | |
140 | ||
141 | }; | |
142 | ||
143 | //************************************************************************** | |
144 | ||
145 | // A derived class for l- gamma -> H_(L/R)^-- l+ (doubly charged Higgs). | |
146 | ||
147 | class Sigma2lgm2Hchgchgl : public Sigma2Process { | |
148 | ||
149 | public: | |
150 | ||
151 | // Constructor. | |
152 | Sigma2lgm2Hchgchgl(int leftRightIn, int idLepIn ) : leftRight(leftRightIn), | |
153 | idLep(idLepIn) {} | |
154 | ||
155 | // Initialize process. | |
156 | virtual void initProc(); | |
157 | ||
158 | // Evaluate sigmaHat(sHat). | |
159 | virtual double sigmaHat(); | |
160 | ||
161 | // Select flavour, colour and anticolour. | |
162 | virtual void setIdColAcol(); | |
163 | ||
164 | // Evaluate weight for W decay angle. | |
165 | virtual double weightDecay( Event& process, int iResBeg, int iResEnd); | |
166 | ||
167 | // Info on the subprocess. | |
168 | virtual string name() const {return nameSave;} | |
169 | virtual int code() const {return codeSave;} | |
170 | virtual string inFlux() const {return "fgm";} | |
171 | virtual int resonanceA() const {return idHLR;} | |
172 | ||
173 | private: | |
174 | ||
175 | // Parameters set at initialization. | |
176 | int leftRight, idHLR, idLep, codeSave; | |
177 | string nameSave; | |
178 | double yukawa[4], openFracPos, openFracNeg; | |
179 | ||
180 | }; | |
181 | ||
182 | //************************************************************************** | |
183 | ||
184 | // A derived class for f_1 f_2 -> H_(L/R)^++-- f_3 f_4 (W+- W+- fusion). | |
185 | ||
186 | class Sigma3ff2HchgchgfftWW : public Sigma3Process { | |
187 | ||
188 | public: | |
189 | ||
190 | // Constructor. | |
191 | Sigma3ff2HchgchgfftWW(int leftRightIn) : leftRight(leftRightIn) {} | |
192 | ||
193 | // Initialize process. | |
194 | virtual void initProc(); | |
195 | ||
196 | // Calculate flavour-independent parts of cross section. | |
197 | virtual void sigmaKin(); | |
198 | ||
199 | // Evaluate sigmaHat(sHat). | |
200 | virtual double sigmaHat(); | |
201 | ||
202 | // Select flavour, colour and anticolour. | |
203 | virtual void setIdColAcol(); | |
204 | ||
205 | // Evaluate weight for decay angles. | |
206 | virtual double weightDecay( Event& process, int iResBeg, int iResEnd); | |
207 | ||
208 | // Info on the subprocess. | |
209 | virtual string name() const {return nameSave;} | |
210 | virtual int code() const {return codeSave;} | |
211 | virtual string inFlux() const {return "ff";} | |
212 | virtual int id3Mass() const {return idHLR;} | |
213 | ||
214 | // Instructions for 3-body phase space with t-channel propagators. | |
215 | virtual int idTchan1() const {return 9900024;} | |
216 | virtual int idTchan2() const {return 9900024;} | |
217 | virtual double tChanFracPow1() const {return 0.05;} | |
218 | virtual double tChanFracPow2() const {return 0.9;} | |
219 | virtual bool useMirrorWeight() const {return true;} | |
220 | ||
221 | private: | |
222 | ||
223 | // Store standard prefactor. | |
224 | int leftRight, idHLR, codeSave; | |
225 | string nameSave; | |
226 | double mWS, prefac, sigma0TU, sigma0T, openFracPos, openFracNeg; | |
227 | ||
228 | }; | |
229 | ||
230 | //************************************************************************** | |
231 | ||
232 | // A derived class for f fbar -> H_(L/R)^++ H_(L/R)^-- (doubly charged Higgs). | |
233 | ||
234 | class Sigma2ffbar2HchgchgHchgchg : public Sigma2Process { | |
235 | ||
236 | public: | |
237 | ||
238 | // Constructor. | |
239 | Sigma2ffbar2HchgchgHchgchg(int leftRightIn) : leftRight(leftRightIn) {} | |
240 | ||
241 | // Initialize process. | |
242 | virtual void initProc(); | |
243 | ||
244 | // Evaluate sigmaHat(sHat). | |
245 | virtual double sigmaHat(); | |
246 | ||
247 | // Select flavour, colour and anticolour. | |
248 | virtual void setIdColAcol(); | |
249 | ||
250 | // Evaluate weight for W decay angle. | |
251 | virtual double weightDecay( Event& process, int iResBeg, int iResEnd); | |
252 | ||
253 | // Info on the subprocess. | |
254 | virtual string name() const {return nameSave;} | |
255 | virtual int code() const {return codeSave;} | |
256 | virtual string inFlux() const {return "ffbarSame";} | |
257 | virtual int id3Mass() const {return idHLR;} | |
258 | virtual int id4Mass() const {return idHLR;} | |
259 | virtual int resonanceA() const {return 23;} | |
260 | ||
261 | private: | |
262 | ||
263 | // Parameters set at initialization. | |
264 | int leftRight, idHLR, codeSave; | |
265 | string nameSave; | |
266 | double mRes, GammaRes, m2Res, GamMRat, sin2tW, preFac, yukawa[4][4], | |
267 | openFrac; | |
268 | ||
269 | }; | |
270 | ||
271 | //************************************************************************** | |
272 | ||
273 | } // end namespace Pythia8 | |
274 | ||
275 | #endif // Pythia8_SigmaLeftRightSym_H |