a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
GeneralTHDMZ2Unitarity.cpp
Go to the documentation of this file.
1/*
2 * Copyright (C) 2025 HEPfit Collaboration
3 *
4 *
5 * For the licensing terms see doc/COPYING.
6 */
7
8#include "GeneralTHDMZ2Unitarity.h"
9#include "GeneralTHDMZ2Runner.h"
10
11unitarity_Z2::unitarity_Z2(const StandardModel& SM_i)
12: ThObservable(SM_i), myGTHDM(SM_i), myZ2_at_Q(3, 5, 0.)
13{}
14
15void unitarity_Z2::computeZ2_at_Q()
16{
17 myZ2_at_Q = myGTHDM.getGTHDMZ2_at_Q();
18}
19
20/************************************/
21/* Eigenvalues of the even 00 block */
22/************************************/
23
24unitarity00eveP_Z2::unitarity00eveP_Z2(const StandardModel& SM_i)
25: unitarity_Z2(SM_i)
26{}
27
28double unitarity00eveP_Z2::computeThValue()
29{
30 gslpp::complex i = gslpp::complex::i();
31
32 computeZ2_at_Q();
33
34 double la1Q = myZ2_at_Q(0, 0);
35 double la2Q = myZ2_at_Q(0, 1);
36 double la3Q = myZ2_at_Q(0, 2);
37 double la4Q = myZ2_at_Q(0, 3);
38 double la5Q = myZ2_at_Q(0, 4);
39
40 double YtQ = myZ2_at_Q(1, 0);
41 double Yb1Q = myZ2_at_Q(1, 1);
42 double Yb2Q = myZ2_at_Q(1, 2);
43 double Ytau1Q = myZ2_at_Q(1, 3);
44 double Ytau2Q = myZ2_at_Q(1, 4);
45
46 double WFRc1 = myZ2_at_Q(2, 0);
47 double WFRc2 = myZ2_at_Q(2, 1);
48
49 double beta1 = myGTHDM.betalambda1_Z2(la1Q, la3Q, la4Q, la5Q, Yb1Q, Ytau1Q);
50 double beta2 = myGTHDM.betalambda2_Z2(la2Q, la3Q, la4Q, la5Q, YtQ, Yb2Q, Ytau2Q);
51 double beta3 = myGTHDM.betalambda3_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
52 double beta4 = myGTHDM.betalambda4_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
53
54 gslpp::complex B1 = -3.*la1Q + 9.*beta1/2. + (i*M_PI - 1.)*(9.*la1Q*la1Q +
55 (2.*la3Q + la4Q)*(2.*la3Q + la4Q))/16./M_PI/M_PI -
56 3.*la1Q*WFRc1/32./M_PI/M_PI;
57
58 gslpp::complex B2 = -3.*la2Q + 9.*beta2/2. + (i*M_PI - 1.)*(9.*la2Q*la2Q +
59 (2.*la3Q + la4Q)*(2.*la3Q + la4Q))/16./M_PI/M_PI -
60 3.*la2Q*(-WFRc1 + 2.*WFRc2)/32./M_PI/M_PI;
61
62 gslpp::complex B3 = -2.*la3Q - la4Q + 3.*(2.*beta3 + beta4)/2. + 3.*(i*M_PI -
63 1.)*(la1Q + la2Q)*(2.*la3Q + la4Q)/16./M_PI/M_PI -
64 (2.*la3Q + la4Q)*WFRc2/32./M_PI/M_PI;
65
66 return ((B1 + B2 + sqrt((B1 - B2)*(B1 - B2) + 4.*B3*B3))/32./M_PI - i/2.).abs();
67}
68
69unitarity00eveM_Z2::unitarity00eveM_Z2(const StandardModel& SM_i)
70: unitarity_Z2(SM_i)
71{}
72
73double unitarity00eveM_Z2::computeThValue()
74{
75 gslpp::complex i = gslpp::complex::i();
76
77 computeZ2_at_Q();
78
79 double la1Q = myZ2_at_Q(0, 0);
80 double la2Q = myZ2_at_Q(0, 1);
81 double la3Q = myZ2_at_Q(0, 2);
82 double la4Q = myZ2_at_Q(0, 3);
83 double la5Q = myZ2_at_Q(0, 4);
84
85 double YtQ = myZ2_at_Q(1, 0);
86 double Yb1Q = myZ2_at_Q(1, 1);
87 double Yb2Q = myZ2_at_Q(1, 2);
88 double Ytau1Q = myZ2_at_Q(1, 3);
89 double Ytau2Q = myZ2_at_Q(1, 4);
90
91 double WFRc1 = myZ2_at_Q(2, 0);
92 double WFRc2 = myZ2_at_Q(2, 1);
93
94 double beta1 = myGTHDM.betalambda1_Z2(la1Q, la3Q, la4Q, la5Q, Yb1Q, Ytau1Q);
95 double beta2 = myGTHDM.betalambda2_Z2(la2Q, la3Q, la4Q, la5Q, YtQ, Yb2Q, Ytau2Q);
96 double beta3 = myGTHDM.betalambda3_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
97 double beta4 = myGTHDM.betalambda4_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
98
99 gslpp::complex B1 = -3.*la1Q + 9.*beta1/2. + (i*M_PI - 1.)*(9.*la1Q*la1Q +
100 (2.*la3Q + la4Q)*(2.*la3Q + la4Q))/16./M_PI/M_PI -
101 3.*la1Q*WFRc1/32./M_PI/M_PI;
102
103 gslpp::complex B2 = -3.*la2Q + 9.*beta2/2. + (i*M_PI - 1.)*(9.*la2Q*la2Q +
104 (2.*la3Q + la4Q)*(2.*la3Q + la4Q))/16./M_PI/M_PI -
105 3.*la2Q*(-WFRc1 + 2.*WFRc2)/32./M_PI/M_PI;
106
107 gslpp::complex B3 = -2.*la3Q - la4Q + 3.*(2.*beta3 + beta4)/2. + 3.*(i*M_PI -
108 1.)*(la1Q + la2Q)*(2.*la3Q + la4Q)/16./M_PI/M_PI -
109 (2.*la3Q + la4Q)*WFRc2/32./M_PI/M_PI;
110
111 return ((B1 + B2 - sqrt((B1 - B2)*(B1 - B2) + 4.*B3*B3))/32./M_PI - i/2.).abs();
112}
113
114
115/***********************************/
116/* Eigenvalues of the odd 00 block */
117/***********************************/
118
119unitarity00oddP_Z2::unitarity00oddP_Z2(const StandardModel& SM_i)
120: unitarity_Z2(SM_i)
121{}
122
123double unitarity00oddP_Z2::computeThValue()
124{
125 gslpp::complex i = gslpp::complex::i();
126
127 computeZ2_at_Q();
128
129 double la1Q = myZ2_at_Q(0, 0);
130 double la2Q = myZ2_at_Q(0, 1);
131 double la3Q = myZ2_at_Q(0, 2);
132 double la4Q = myZ2_at_Q(0, 3);
133 double la5Q = myZ2_at_Q(0, 4);
134
135 double YtQ = myZ2_at_Q(1, 0);
136 double Yb1Q = myZ2_at_Q(1, 1);
137 double Yb2Q = myZ2_at_Q(1, 2);
138 double Ytau1Q = myZ2_at_Q(1, 3);
139 double Ytau2Q = myZ2_at_Q(1, 4);
140
141 double WFRc2 = myZ2_at_Q(2, 1);
142
143 double beta3 = myGTHDM.betalambda3_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
144 double beta4 = myGTHDM.betalambda4_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
145 double beta5 = myGTHDM.betalambda5_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
146
147 gslpp::complex B4 = -la3Q - 2.*la4Q + 3.*(beta3 + 2.*beta4)/2. + (i*M_PI - 1.)*(la3Q*la3Q +
148 4.*la3Q*la4Q + 4.*la4Q*la4Q + 9.*la5Q*la5Q)/16./M_PI/M_PI -
149 (la3Q + la4Q + la5Q)*WFRc2/32./M_PI/M_PI;
150
151 gslpp::complex B6 = -3.*la5Q + 9.*beta5/2. + 6.*(i*M_PI - 1.)*(la3Q + 2.*la4Q)*la5Q/16./M_PI/M_PI -
152 (la4Q + 2.*la5Q)*WFRc2/32./M_PI/M_PI;
153
154 return ((B4 + B6)/16./M_PI - i/2.).abs();
155}
156
157unitarity00oddM_Z2::unitarity00oddM_Z2(const StandardModel& SM_i)
158: unitarity_Z2(SM_i)
159{}
160
161double unitarity00oddM_Z2::computeThValue()
162{
163 gslpp::complex i = gslpp::complex::i();
164
165 computeZ2_at_Q();
166
167 double la1Q = myZ2_at_Q(0, 0);
168 double la2Q = myZ2_at_Q(0, 1);
169 double la3Q = myZ2_at_Q(0, 2);
170 double la4Q = myZ2_at_Q(0, 3);
171 double la5Q = myZ2_at_Q(0, 4);
172
173 double YtQ = myZ2_at_Q(1, 0);
174 double Yb1Q = myZ2_at_Q(1, 1);
175 double Yb2Q = myZ2_at_Q(1, 2);
176 double Ytau1Q = myZ2_at_Q(1, 3);
177 double Ytau2Q = myZ2_at_Q(1, 4);
178
179 double WFRc2 = myZ2_at_Q(2, 1);
180
181 double beta3 = myGTHDM.betalambda3_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
182 double beta4 = myGTHDM.betalambda4_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
183 double beta5 = myGTHDM.betalambda5_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
184
185 gslpp::complex B4 = -la3Q - 2.*la4Q + 3.*(beta3 + 2.*beta4)/2. + (i*M_PI - 1.)*(la3Q*la3Q +
186 4.*la3Q*la4Q + 4.*la4Q*la4Q + 9.*la5Q*la5Q)/16./M_PI/M_PI -
187 (la3Q + la4Q + la5Q)*WFRc2/32./M_PI/M_PI;
188
189 gslpp::complex B6 = -3.*la5Q + 9.*beta5/2. + 6.*(i*M_PI - 1.)*(la3Q + 2.*la4Q)*la5Q/16./M_PI/M_PI -
190 (la4Q + 2.*la5Q)*WFRc2/32./M_PI/M_PI;
191
192 return ((B4 - B6)/16./M_PI - i/2.).abs();
193}
194
195
196/************************************/
197/* Eigenvalues of the even 01 block */
198/************************************/
199
200unitarity01eveP_Z2::unitarity01eveP_Z2(const StandardModel& SM_i)
201: unitarity_Z2(SM_i)
202{}
203
204double unitarity01eveP_Z2::computeThValue()
205{
206 gslpp::complex i = gslpp::complex::i();
207
208 computeZ2_at_Q();
209
210 double la1Q = myZ2_at_Q(0, 0);
211 double la2Q = myZ2_at_Q(0, 1);
212 double la3Q = myZ2_at_Q(0, 2);
213 double la4Q = myZ2_at_Q(0, 3);
214 double la5Q = myZ2_at_Q(0, 4);
215
216 double YtQ = myZ2_at_Q(1, 0);
217 double Yb1Q = myZ2_at_Q(1, 1);
218 double Yb2Q = myZ2_at_Q(1, 2);
219 double Ytau1Q = myZ2_at_Q(1, 3);
220 double Ytau2Q = myZ2_at_Q(1, 4);
221
222 double WFRc1 = myZ2_at_Q(2, 0);
223 double WFRc2 = myZ2_at_Q(2, 1);
224
225 double beta1 = myGTHDM.betalambda1_Z2(la1Q, la3Q, la4Q, la5Q, Yb1Q, Ytau1Q);
226 double beta2 = myGTHDM.betalambda2_Z2(la2Q, la3Q, la4Q, la5Q, YtQ, Yb2Q, Ytau2Q);
227 double beta4 = myGTHDM.betalambda4_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
228
229 gslpp::complex B7 = -la1Q + 3.*beta1/2. + (i*M_PI - 1.)*(la1Q*la1Q + la4Q*la4Q)/16./M_PI/M_PI -
230 la1Q*WFRc1/32./M_PI/M_PI;
231
232 gslpp::complex B8 = -la2Q + 3.*beta2/2. + (i*M_PI - 1.)*(la2Q*la2Q + la4Q*la4Q)/16./M_PI/M_PI -
233 la2Q*(-WFRc1 + 2.*WFRc2)/32./M_PI/M_PI;
234
235 gslpp::complex B9 = -la4Q + 3.*beta4/2. + (i*M_PI - 1.)*(la1Q + la2Q)*la4Q/16./M_PI/M_PI -
236 la4Q*WFRc2/32./M_PI/M_PI;
237
238 return ((B7 + B8 + sqrt((B7 - B8)*(B7 - B8) + 4.*B9*B9))/32./M_PI - i/2.).abs();
239}
240
241unitarity01eveM_Z2::unitarity01eveM_Z2(const StandardModel& SM_i)
242: unitarity_Z2(SM_i)
243{}
244
245double unitarity01eveM_Z2::computeThValue()
246{
247 gslpp::complex i = gslpp::complex::i();
248
249 computeZ2_at_Q();
250
251 double la1Q = myZ2_at_Q(0, 0);
252 double la2Q = myZ2_at_Q(0, 1);
253 double la3Q = myZ2_at_Q(0, 2);
254 double la4Q = myZ2_at_Q(0, 3);
255 double la5Q = myZ2_at_Q(0, 4);
256
257 double YtQ = myZ2_at_Q(1, 0);
258 double Yb1Q = myZ2_at_Q(1, 1);
259 double Yb2Q = myZ2_at_Q(1, 2);
260 double Ytau1Q = myZ2_at_Q(1, 3);
261 double Ytau2Q = myZ2_at_Q(1, 4);
262
263 double WFRc1 = myZ2_at_Q(2, 0);
264 double WFRc2 = myZ2_at_Q(2, 1);
265
266 double beta1 = myGTHDM.betalambda1_Z2(la1Q, la3Q, la4Q, la5Q, Yb1Q, Ytau1Q);
267 double beta2 = myGTHDM.betalambda2_Z2(la2Q, la3Q, la4Q, la5Q, YtQ, Yb2Q, Ytau2Q);
268 double beta4 = myGTHDM.betalambda4_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
269
270 gslpp::complex B7 = -la1Q + 3.*beta1/2. + (i*M_PI - 1.)*(la1Q*la1Q + la4Q*la4Q)/16./M_PI/M_PI -
271 la1Q*WFRc1/32./M_PI/M_PI;
272
273 gslpp::complex B8 = -la2Q + 3.*beta2/2. + (i*M_PI - 1.)*(la2Q*la2Q + la4Q*la4Q)/16./M_PI/M_PI -
274 la2Q*(-WFRc1 + 2.*WFRc2)/32./M_PI/M_PI;
275
276 gslpp::complex B9 = -la4Q + 3.*beta4/2. + (i*M_PI - 1.)*(la1Q + la2Q)*la4Q/16./M_PI/M_PI -
277 la4Q*WFRc2/32./M_PI/M_PI;
278
279 return ((B7 + B8 - sqrt((B7 - B8)*(B7 - B8) + 4.*B9*B9))/32./M_PI - i/2.).abs();
280}
281
282
283/***********************************/
284/* Eigenvalues of the odd 01 block */
285/***********************************/
286
287unitarity01oddP_Z2::unitarity01oddP_Z2(const StandardModel& SM_i)
288: unitarity_Z2(SM_i)
289{}
290
291double unitarity01oddP_Z2::computeThValue()
292{
293 gslpp::complex i = gslpp::complex::i();
294
295 computeZ2_at_Q();
296
297 double la1Q = myZ2_at_Q(0, 0);
298 double la2Q = myZ2_at_Q(0, 1);
299 double la3Q = myZ2_at_Q(0, 2);
300 double la4Q = myZ2_at_Q(0, 3);
301 double la5Q = myZ2_at_Q(0, 4);
302
303 double YtQ = myZ2_at_Q(1, 0);
304 double Yb1Q = myZ2_at_Q(1, 1);
305 double Yb2Q = myZ2_at_Q(1, 2);
306 double Ytau1Q = myZ2_at_Q(1, 3);
307 double Ytau2Q = myZ2_at_Q(1, 4);
308
309 double WFRc2 = myZ2_at_Q(2, 1);
310
311 double beta3 = myGTHDM.betalambda3_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
312 double beta5 = myGTHDM.betalambda5_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
313
314 gslpp::complex B13 = -la3Q + 3.*beta3/2. + (i*M_PI - 1.)*(la3Q*la3Q + la5Q*la5Q)/16./M_PI/M_PI -
315 (la3Q + la4Q - la5Q)*WFRc2/32./M_PI/M_PI;
316
317 gslpp::complex B15 = -la5Q + 3.*beta5/2. + 2.*(i*M_PI - 1.)*la3Q*la5Q/16./M_PI/M_PI -
318 (la4Q - 2.*la5Q)*WFRc2/32./M_PI/M_PI;
319
320 return ((B13 + B15)/16./M_PI - i/2.).abs();
321}
322
323unitarity01oddM_Z2::unitarity01oddM_Z2(const StandardModel& SM_i)
324: unitarity_Z2(SM_i)
325{}
326
327double unitarity01oddM_Z2::computeThValue()
328{
329 gslpp::complex i = gslpp::complex::i();
330
331 computeZ2_at_Q();
332
333 double la1Q = myZ2_at_Q(0, 0);
334 double la2Q = myZ2_at_Q(0, 1);
335 double la3Q = myZ2_at_Q(0, 2);
336 double la4Q = myZ2_at_Q(0, 3);
337 double la5Q = myZ2_at_Q(0, 4);
338
339 double YtQ = myZ2_at_Q(1, 0);
340 double Yb1Q = myZ2_at_Q(1, 1);
341 double Yb2Q = myZ2_at_Q(1, 2);
342 double Ytau1Q = myZ2_at_Q(1, 3);
343 double Ytau2Q = myZ2_at_Q(1, 4);
344
345 double WFRc2 = myZ2_at_Q(2, 1);
346
347 double beta3 = myGTHDM.betalambda3_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
348 double beta5 = myGTHDM.betalambda5_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
349
350 gslpp::complex B13 = -la3Q + 3.*beta3/2. + (i*M_PI - 1.)*(la3Q*la3Q + la5Q*la5Q)/16./M_PI/M_PI -
351 (la3Q + la4Q - la5Q)*WFRc2/32./M_PI/M_PI;
352
353 gslpp::complex B15 = -la5Q + 3.*beta5/2. + 2.*(i*M_PI - 1.)*la3Q*la5Q/16./M_PI/M_PI -
354 (la4Q - 2.*la5Q)*WFRc2/32./M_PI/M_PI;
355
356 return ((B13 - B15)/16./M_PI - i/2.).abs();
357}
358
359
360/**********************************/
361/* Eigenvalue of the odd 10 block */
362/**********************************/
363
364unitarity10odd_Z2::unitarity10odd_Z2(const StandardModel& SM_i)
365: unitarity_Z2(SM_i)
366{}
367
368double unitarity10odd_Z2::computeThValue()
369{
370 gslpp::complex i = gslpp::complex::i();
371
372 computeZ2_at_Q();
373
374 double la1Q = myZ2_at_Q(0, 0);
375 double la2Q = myZ2_at_Q(0, 1);
376 double la3Q = myZ2_at_Q(0, 2);
377 double la4Q = myZ2_at_Q(0, 3);
378 double la5Q = myZ2_at_Q(0, 4);
379
380 double YtQ = myZ2_at_Q(1, 0);
381 double Yb1Q = myZ2_at_Q(1, 1);
382 double Yb2Q = myZ2_at_Q(1, 2);
383 double Ytau1Q = myZ2_at_Q(1, 3);
384 double Ytau2Q = myZ2_at_Q(1, 4);
385
386 double WFRc2 = myZ2_at_Q(2, 1);
387
388 double beta3 = myGTHDM.betalambda3_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
389 double beta4 = myGTHDM.betalambda4_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
390
391 gslpp::complex B19 = -la3Q + la4Q + 3.*(beta3 - beta4)/2. + (i*M_PI - 1.)*(la3Q -
392 la4Q)*(la3Q - la4Q)/16./M_PI/M_PI - (la3Q - la5Q)*WFRc2/32./M_PI/M_PI;
393
394 return (B19/16./M_PI - i/2.).abs();
395}
396
397
398/************************************/
399/* Eigenvalues of the even 11 block */
400/************************************/
401
402unitarity11eveP_Z2::unitarity11eveP_Z2(const StandardModel& SM_i)
403: unitarity_Z2(SM_i)
404{}
405
406double unitarity11eveP_Z2::computeThValue()
407{
408 gslpp::complex i = gslpp::complex::i();
409
410 computeZ2_at_Q();
411
412 double la1Q = myZ2_at_Q(0, 0);
413 double la2Q = myZ2_at_Q(0, 1);
414 double la3Q = myZ2_at_Q(0, 2);
415 double la4Q = myZ2_at_Q(0, 3);
416 double la5Q = myZ2_at_Q(0, 4);
417
418 double YtQ = myZ2_at_Q(1, 0);
419 double Yb1Q = myZ2_at_Q(1, 1);
420 double Yb2Q = myZ2_at_Q(1, 2);
421 double Ytau1Q = myZ2_at_Q(1, 3);
422 double Ytau2Q = myZ2_at_Q(1, 4);
423
424 double WFRc1 = myZ2_at_Q(2, 0);
425 double WFRc2 = myZ2_at_Q(2, 1);
426 double WFRc3 = myZ2_at_Q(2, 2);
427 double WFRc4 = myZ2_at_Q(2, 3);
428
429 double beta1 = myGTHDM.betalambda1_Z2(la1Q, la3Q, la4Q, la5Q, Yb1Q, Ytau1Q);
430 double beta2 = myGTHDM.betalambda2_Z2(la2Q, la3Q, la4Q, la5Q, YtQ, Yb2Q, Ytau2Q);
431 double beta5 = myGTHDM.betalambda5_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
432
433 gslpp::complex B20 = -la1Q + 3.*beta1/2. + (i*M_PI - 1.)*(la1Q*la1Q + la5Q*la5Q)/16./M_PI/M_PI -
434 la1Q*(WFRc1 - 2.*WFRc2 + WFRc3 + 2.*WFRc4)/32./M_PI/M_PI;
435
436 gslpp::complex B21 = -la2Q + 3.*beta2/2. + (i*M_PI - 1.)*(la2Q*la2Q + la5Q*la5Q)/16./M_PI/M_PI -
437 la2Q*(-WFRc1 + 2.*WFRc2 - WFRc3 + 2.*WFRc4)/32./M_PI/M_PI;
438
439 gslpp::complex B22 = -la5Q + 3.*beta5/2. + (i*M_PI - 1.)*(la1Q + la2Q)*la5Q/16./M_PI/M_PI -
440 la5Q*2.*WFRc4/32./M_PI/M_PI;
441
442 return ((B20 + B21 + sqrt((B20 - B21)*(B20 - B21) + 4.*B22*B22))/32./M_PI - i/2.).abs();
443}
444
445unitarity11eveM_Z2::unitarity11eveM_Z2(const StandardModel& SM_i)
446: unitarity_Z2(SM_i)
447{}
448
449double unitarity11eveM_Z2::computeThValue()
450{
451 gslpp::complex i = gslpp::complex::i();
452
453 computeZ2_at_Q();
454
455 double la1Q = myZ2_at_Q(0, 0);
456 double la2Q = myZ2_at_Q(0, 1);
457 double la3Q = myZ2_at_Q(0, 2);
458 double la4Q = myZ2_at_Q(0, 3);
459 double la5Q = myZ2_at_Q(0, 4);
460
461 double YtQ = myZ2_at_Q(1, 0);
462 double Yb1Q = myZ2_at_Q(1, 1);
463 double Yb2Q = myZ2_at_Q(1, 2);
464 double Ytau1Q = myZ2_at_Q(1, 3);
465 double Ytau2Q = myZ2_at_Q(1, 4);
466
467 double WFRc1 = myZ2_at_Q(2, 0);
468 double WFRc2 = myZ2_at_Q(2, 1);
469 double WFRc3 = myZ2_at_Q(2, 2);
470 double WFRc4 = myZ2_at_Q(2, 3);
471
472 double beta1 = myGTHDM.betalambda1_Z2(la1Q, la3Q, la4Q, la5Q, Yb1Q, Ytau1Q);
473 double beta2 = myGTHDM.betalambda2_Z2(la2Q, la3Q, la4Q, la5Q, YtQ, Yb2Q, Ytau2Q);
474 double beta5 = myGTHDM.betalambda5_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
475
476 gslpp::complex B20 = -la1Q + 3.*beta1/2. + (i*M_PI - 1.)*(la1Q*la1Q + la5Q*la5Q)/16./M_PI/M_PI -
477 la1Q*(WFRc1 - 2.*WFRc2 + WFRc3 + 2.*WFRc4)/32./M_PI/M_PI;
478
479 gslpp::complex B21 = -la2Q + 3.*beta2/2. + (i*M_PI - 1.)*(la2Q*la2Q + la5Q*la5Q)/16./M_PI/M_PI -
480 la2Q*(-WFRc1 + 2.*WFRc2 - WFRc3 + 2.*WFRc4)/32./M_PI/M_PI;
481
482 gslpp::complex B22 = -la5Q + 3.*beta5/2. + (i*M_PI - 1.)*(la1Q + la2Q)*la5Q/16./M_PI/M_PI -
483 la5Q*2.*WFRc4/32./M_PI/M_PI;
484
485 return ((B20 + B21 - sqrt((B20 - B21)*(B20 - B21) + 4.*B22*B22))/32./M_PI - i/2.).abs();
486}
487
488
489/**********************************/
490/* Eigenvalue of the odd 11 block */
491/**********************************/
492
493unitarity11odd_Z2::unitarity11odd_Z2(const StandardModel& SM_i)
494: unitarity_Z2(SM_i)
495{}
496
497double unitarity11odd_Z2::computeThValue()
498{
499 gslpp::complex i = gslpp::complex::i();
500
501 computeZ2_at_Q();
502
503 double la1Q = myZ2_at_Q(0, 0);
504 double la2Q = myZ2_at_Q(0, 1);
505 double la3Q = myZ2_at_Q(0, 2);
506 double la4Q = myZ2_at_Q(0, 3);
507 double la5Q = myZ2_at_Q(0, 4);
508
509 double YtQ = myZ2_at_Q(1, 0);
510 double Yb1Q = myZ2_at_Q(1, 1);
511 double Yb2Q = myZ2_at_Q(1, 2);
512 double Ytau1Q = myZ2_at_Q(1, 3);
513 double Ytau2Q = myZ2_at_Q(1, 4);
514
515 double WFRc4 = myZ2_at_Q(2, 3);
516
517 double beta3 = myGTHDM.betalambda3_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
518 double beta4 = myGTHDM.betalambda4_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
519
520 gslpp::complex B30 = -la3Q - la4Q + 3.*(beta3 + beta4)/2. + (i*M_PI - 1.)*(la3Q +
521 la4Q)*(la3Q + la4Q)/16./M_PI/M_PI - (la3Q + la4Q)*2.*WFRc4/32./M_PI/M_PI;
522
523 return (B30/16./M_PI - i/2.).abs();
524}
525
526
527/***********************************/
528/* R1p ratios of the even 00 block */
529/***********************************/
530
531R1p00eveP_Z2::R1p00eveP_Z2(const StandardModel& SM_i)
532: unitarity_Z2(SM_i), myGTHDMZ2(static_cast<const GeneralTHDMZ2*> (&SM_i))
533{}
534
535double R1p00eveP_Z2::computeThValue()
536{
537 gslpp::complex i = gslpp::complex::i();
538
539 computeZ2_at_Q();
540
541 double la1Q = myZ2_at_Q(0, 0);
542 double la2Q = myZ2_at_Q(0, 1);
543 double la3Q = myZ2_at_Q(0, 2);
544 double la4Q = myZ2_at_Q(0, 3);
545 double la5Q = myZ2_at_Q(0, 4);
546
547 double YtQ = myZ2_at_Q(1, 0);
548 double Yb1Q = myZ2_at_Q(1, 1);
549 double Yb2Q = myZ2_at_Q(1, 2);
550 double Ytau1Q = myZ2_at_Q(1, 3);
551 double Ytau2Q = myZ2_at_Q(1, 4);
552
553 double WFRc1 = myZ2_at_Q(2, 0);
554 double WFRc2 = myZ2_at_Q(2, 1);
555
556 double beta1 = myGTHDM.betalambda1_Z2(la1Q, la3Q, la4Q, la5Q, Yb1Q, Ytau1Q);
557 double beta2 = myGTHDM.betalambda2_Z2(la2Q, la3Q, la4Q, la5Q, YtQ, Yb2Q, Ytau2Q);
558 double beta3 = myGTHDM.betalambda3_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
559 double beta4 = myGTHDM.betalambda4_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
560
561 gslpp::complex B1 = -3.*la1Q + 9.*beta1/2. + (i*M_PI - 1.)*(9.*la1Q*la1Q +
562 (2.*la3Q + la4Q)*(2.*la3Q + la4Q))/16./M_PI/M_PI -
563 3.*la1Q*WFRc1/32./M_PI/M_PI;
564
565 gslpp::complex B2 = -3.*la2Q + 9.*beta2/2. + (i*M_PI - 1.)*(9.*la2Q*la2Q +
566 (2.*la3Q + la4Q)*(2.*la3Q + la4Q))/16./M_PI/M_PI -
567 3.*la2Q*(-WFRc1 + 2.*WFRc2)/32./M_PI/M_PI;
568
569 gslpp::complex B3 = -2.*la3Q - la4Q + 3.*(2.*beta3 + beta4)/2. + 3.*(i*M_PI -
570 1.)*(la1Q + la2Q)*(2.*la3Q + la4Q)/16./M_PI/M_PI -
571 (2.*la3Q + la4Q)*WFRc2/32./M_PI/M_PI;
572
573 gslpp::complex a_NLO = ((B1 + B2 + sqrt((B1 - B2)*(B1 - B2) + 4.*B3*B3))/32./M_PI);
574
575 // LO eigenvalue, as defined in Cacchio:2016qyh (Sign difference in front of the square-roots compared to Grinstein:2015rtl)
576
577 double la1 = myGTHDMZ2->getlambda1_Z2();
578 double la2 = myGTHDMZ2->getlambda2_Z2();
579 double la3 = myGTHDMZ2->getlambda3_Z2();
580 double la4 = myGTHDMZ2->getlambda4_Z2();
581
582 double a_LO = (-3.*la1 - 3.*la2 + sqrt((3.*la1 - 3.*la2)*(3.*la1 - 3.*la2) +
583 4.*(2.*la3 + la4)*(2.*la3 + la4))) / 32. / M_PI;
584
585 // To avoid applying the condition for accidentally small LO contributions
586 if(std::fabs(a_LO) > 1./16./M_PI)
587 return ((a_NLO - a_LO) / a_LO).abs();
588 else
589 return 0.009; // To allow perturbativity constraints as stringent as 1%
590}
591
592
593//R1p00eveP_Z2::R1p00eveP_Z2(const StandardModel& SM_i)
594//: ThObservable(SM_i), myGTHDMZ2(static_cast<const GeneralTHDMZ2*> (&SM_i)), a_NLO(SM_i)
595//{}
596//
597//double R1p00eveP_Z2::computeThValue()
598//{
599// double la1 = myGTHDMZ2->getlambda1_Z2();
600// double la2 = myGTHDMZ2->getlambda2_Z2();
601// double la3 = myGTHDMZ2->getlambda3_Z2();
602// double la4 = myGTHDMZ2->getlambda4_Z2();
603//
604// // LO eigenvalue, as defined in Cacchio:2016qyh (Sign difference in front of the square-roots compared to Grinstein:2015rtl)
605// double a_LO = -(3.*la1 + 3.*la2 - sqrt((3.*la1 - 3.*la2)*(3.*la1 - 3.*la2) +
606// 4.*(2.*la3 + la4)*(2.*la3 + la4))) / 32. / M_PI;
607//
608// std::cout << a_LO<<std::endl;
609// std::cout << a_NLO.computeThValue()<<std::endl;
610//
611// // To avoid applying the condition for accidentally small LO contributions
612// if(std::fabs(a_LO) > 1./16./M_PI)
613// return std::fabs((a_NLO.computeThValue() - a_LO) / a_LO);
614// else
615// return 0.009; // To allow perturbativity constraints as stringent as 1%
616//}
617
618R1p00eveM_Z2::R1p00eveM_Z2(const StandardModel& SM_i)
619: unitarity_Z2(SM_i), myGTHDMZ2(static_cast<const GeneralTHDMZ2*> (&SM_i))
620{}
621
622double R1p00eveM_Z2::computeThValue()
623{
624 gslpp::complex i = gslpp::complex::i();
625
626 computeZ2_at_Q();
627
628 double la1Q = myZ2_at_Q(0, 0);
629 double la2Q = myZ2_at_Q(0, 1);
630 double la3Q = myZ2_at_Q(0, 2);
631 double la4Q = myZ2_at_Q(0, 3);
632 double la5Q = myZ2_at_Q(0, 4);
633
634 double YtQ = myZ2_at_Q(1, 0);
635 double Yb1Q = myZ2_at_Q(1, 1);
636 double Yb2Q = myZ2_at_Q(1, 2);
637 double Ytau1Q = myZ2_at_Q(1, 3);
638 double Ytau2Q = myZ2_at_Q(1, 4);
639
640 double WFRc1 = myZ2_at_Q(2, 0);
641 double WFRc2 = myZ2_at_Q(2, 1);
642
643 double beta1 = myGTHDM.betalambda1_Z2(la1Q, la3Q, la4Q, la5Q, Yb1Q, Ytau1Q);
644 double beta2 = myGTHDM.betalambda2_Z2(la2Q, la3Q, la4Q, la5Q, YtQ, Yb2Q, Ytau2Q);
645 double beta3 = myGTHDM.betalambda3_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
646 double beta4 = myGTHDM.betalambda4_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
647
648 gslpp::complex B1 = -3.*la1Q + 9.*beta1/2. + (i*M_PI - 1.)*(9.*la1Q*la1Q +
649 (2.*la3Q + la4Q)*(2.*la3Q + la4Q))/16./M_PI/M_PI -
650 3.*la1Q*WFRc1/32./M_PI/M_PI;
651
652 gslpp::complex B2 = -3.*la2Q + 9.*beta2/2. + (i*M_PI - 1.)*(9.*la2Q*la2Q +
653 (2.*la3Q + la4Q)*(2.*la3Q + la4Q))/16./M_PI/M_PI -
654 3.*la2Q*(-WFRc1 + 2.*WFRc2)/32./M_PI/M_PI;
655
656 gslpp::complex B3 = -2.*la3Q - la4Q + 3.*(2.*beta3 + beta4)/2. + 3.*(i*M_PI -
657 1.)*(la1Q + la2Q)*(2.*la3Q + la4Q)/16./M_PI/M_PI -
658 (2.*la3Q + la4Q)*WFRc2/32./M_PI/M_PI;
659
660 gslpp::complex a_NLO = (B1 + B2 - sqrt((B1 - B2)*(B1 - B2) + 4.*B3*B3))/32./M_PI;
661
662 // LO eigenvalue, as defined in Cacchio:2016qyh (Sign difference in front of the square-roots compared to Grinstein:2015rtl)
663 double la1 = myGTHDMZ2->getlambda1_Z2();
664 double la2 = myGTHDMZ2->getlambda2_Z2();
665 double la3 = myGTHDMZ2->getlambda3_Z2();
666 double la4 = myGTHDMZ2->getlambda4_Z2();
667
668 double a_LO = (-3.*la1 - 3.*la2 - sqrt((3.*la1 - 3.*la2)*(3.*la1 - 3.*la2) +
669 4.*(2.*la3 + la4)*(2.*la3 + la4))) / 32. / M_PI;
670
671 // To avoid applying the condition for accidentally small LO contributions
672 if(std::fabs(a_LO) > 1./16./M_PI)
673 return ((a_NLO - a_LO) / a_LO).abs();
674 else
675 return 0.009; // To allow perturbativity constraints as stringent as 1%
676}
677
678
679/**********************************/
680/* R1p ratios of the odd 00 block */
681/**********************************/
682
683R1p00oddP_Z2::R1p00oddP_Z2(const StandardModel& SM_i)
684: unitarity_Z2(SM_i), myGTHDMZ2(static_cast<const GeneralTHDMZ2*> (&SM_i))
685{}
686
687double R1p00oddP_Z2::computeThValue()
688{
689 gslpp::complex i = gslpp::complex::i();
690
691 computeZ2_at_Q();
692
693 double la1Q = myZ2_at_Q(0, 0);
694 double la2Q = myZ2_at_Q(0, 1);
695 double la3Q = myZ2_at_Q(0, 2);
696 double la4Q = myZ2_at_Q(0, 3);
697 double la5Q = myZ2_at_Q(0, 4);
698
699 double YtQ = myZ2_at_Q(1, 0);
700 double Yb1Q = myZ2_at_Q(1, 1);
701 double Yb2Q = myZ2_at_Q(1, 2);
702 double Ytau1Q = myZ2_at_Q(1, 3);
703 double Ytau2Q = myZ2_at_Q(1, 4);
704
705 double WFRc2 = myZ2_at_Q(2, 1);
706
707 double beta3 = myGTHDM.betalambda3_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
708 double beta4 = myGTHDM.betalambda4_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
709 double beta5 = myGTHDM.betalambda5_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
710
711 gslpp::complex B4 = -la3Q - 2.*la4Q + 3.*(beta3 + 2.*beta4)/2. + (i*M_PI - 1.)*(la3Q*la3Q +
712 4.*la3Q*la4Q + 4.*la4Q*la4Q + 9.*la5Q*la5Q)/16./M_PI/M_PI -
713 (la3Q + la4Q + la5Q)*WFRc2/32./M_PI/M_PI;
714
715 gslpp::complex B6 = -3.*la5Q + 9.*beta5/2. + 6.*(i*M_PI - 1.)*(la3Q + 2.*la4Q)*la5Q/16./M_PI/M_PI -
716 (la4Q + 2.*la5Q)*WFRc2/32./M_PI/M_PI;
717
718 gslpp::complex a_NLO = (B4 + B6)/16./M_PI ;
719
720 // LO eigenvalue, as defined in Grinstein:2015rtl
721 double la3 = myGTHDMZ2->getlambda3_Z2();
722 double la4 = myGTHDMZ2->getlambda4_Z2();
723 double la5 = myGTHDMZ2->getlambda5_Z2();
724
725 double a_LO = -(la3 + 2.*la4 + 3.*la5) / 16. / M_PI;
726
727 // To avoid applying the condition for accidentally small LO contributions
728 if(std::fabs(a_LO) > 1./16./M_PI)
729 return ((a_NLO - a_LO) / a_LO).abs();
730 else
731 return 0.009; // To allow perturbativity constraints as stringent as 1%
732}
733
734R1p00oddM_Z2::R1p00oddM_Z2(const StandardModel& SM_i)
735: unitarity_Z2(SM_i), myGTHDMZ2(static_cast<const GeneralTHDMZ2*> (&SM_i))
736{}
737
738double R1p00oddM_Z2::computeThValue()
739{
740 gslpp::complex i = gslpp::complex::i();
741
742 computeZ2_at_Q();
743
744 double la1Q = myZ2_at_Q(0, 0);
745 double la2Q = myZ2_at_Q(0, 1);
746 double la3Q = myZ2_at_Q(0, 2);
747 double la4Q = myZ2_at_Q(0, 3);
748 double la5Q = myZ2_at_Q(0, 4);
749
750 double YtQ = myZ2_at_Q(1, 0);
751 double Yb1Q = myZ2_at_Q(1, 1);
752 double Yb2Q = myZ2_at_Q(1, 2);
753 double Ytau1Q = myZ2_at_Q(1, 3);
754 double Ytau2Q = myZ2_at_Q(1, 4);
755
756 double WFRc2 = myZ2_at_Q(2, 1);
757
758 double beta3 = myGTHDM.betalambda3_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
759 double beta4 = myGTHDM.betalambda4_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
760 double beta5 = myGTHDM.betalambda5_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
761
762 gslpp::complex B4 = -la3Q - 2.*la4Q + 3.*(beta3 + 2.*beta4)/2. + (i*M_PI - 1.)*(la3Q*la3Q +
763 4.*la3Q*la4Q + 4.*la4Q*la4Q + 9.*la5Q*la5Q)/16./M_PI/M_PI -
764 (la3Q + la4Q + la5Q)*WFRc2/32./M_PI/M_PI;
765
766 gslpp::complex B6 = -3.*la5Q + 9.*beta5/2. + 6.*(i*M_PI - 1.)*(la3Q + 2.*la4Q)*la5Q/16./M_PI/M_PI -
767 (la4Q + 2.*la5Q)*WFRc2/32./M_PI/M_PI;
768
769 gslpp::complex a_NLO = (B4 - B6)/16./M_PI;
770
771 // LO eigenvalue, as defined in Grinstein:2015rtl
772 double la3 = myGTHDMZ2->getlambda3_Z2();
773 double la4 = myGTHDMZ2->getlambda4_Z2();
774 double la5 = myGTHDMZ2->getlambda5_Z2();
775
776 double a_LO = -(la3 + 2.*la4 - 3.*la5) / 16. / M_PI;
777
778 // To avoid applying the condition for accidentally small LO contributions
779 if(std::fabs(a_LO) > 1./16./M_PI)
780 return ((a_NLO - a_LO) / a_LO).abs();
781 else
782 return 0.009; // To allow perturbativity constraints as stringent as 1%
783}
784
785
786/***********************************/
787/* R1p ratios of the even 01 block */
788/***********************************/
789
790R1p01eveP_Z2::R1p01eveP_Z2(const StandardModel& SM_i)
791: unitarity_Z2(SM_i), myGTHDMZ2(static_cast<const GeneralTHDMZ2*> (&SM_i))
792{}
793
794double R1p01eveP_Z2::computeThValue()
795{
796 gslpp::complex i = gslpp::complex::i();
797
798 computeZ2_at_Q();
799
800 double la1Q = myZ2_at_Q(0, 0);
801 double la2Q = myZ2_at_Q(0, 1);
802 double la3Q = myZ2_at_Q(0, 2);
803 double la4Q = myZ2_at_Q(0, 3);
804 double la5Q = myZ2_at_Q(0, 4);
805
806 double YtQ = myZ2_at_Q(1, 0);
807 double Yb1Q = myZ2_at_Q(1, 1);
808 double Yb2Q = myZ2_at_Q(1, 2);
809 double Ytau1Q = myZ2_at_Q(1, 3);
810 double Ytau2Q = myZ2_at_Q(1, 4);
811
812 double WFRc1 = myZ2_at_Q(2, 0);
813 double WFRc2 = myZ2_at_Q(2, 1);
814
815 double beta1 = myGTHDM.betalambda1_Z2(la1Q, la3Q, la4Q, la5Q, Yb1Q, Ytau1Q);
816 double beta2 = myGTHDM.betalambda2_Z2(la2Q, la3Q, la4Q, la5Q, YtQ, Yb2Q, Ytau2Q);
817 double beta4 = myGTHDM.betalambda4_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
818
819 gslpp::complex B7 = -la1Q + 3.*beta1/2. + (i*M_PI - 1.)*(la1Q*la1Q + la4Q*la4Q)/16./M_PI/M_PI -
820 la1Q*WFRc1/32./M_PI/M_PI;
821
822 gslpp::complex B8 = -la2Q + 3.*beta2/2. + (i*M_PI - 1.)*(la2Q*la2Q + la4Q*la4Q)/16./M_PI/M_PI -
823 la2Q*(-WFRc1 + 2.*WFRc2)/32./M_PI/M_PI;
824
825 gslpp::complex B9 = -la4Q + 3.*beta4/2. + (i*M_PI - 1.)*(la1Q + la2Q)*la4Q/16./M_PI/M_PI -
826 la4Q*WFRc2/32./M_PI/M_PI;
827
828 gslpp::complex a_NLO = (B7 + B8 + sqrt((B7 - B8)*(B7 - B8) + 4.*B9*B9))/32./M_PI;
829
830 // LO eigenvalue, as defined in Cacchio:2016qyh (Sign difference in front of the square-roots compared to Grinstein:2015rtl)
831 double la1 = myGTHDMZ2->getlambda1_Z2();
832 double la2 = myGTHDMZ2->getlambda2_Z2();
833 double la4 = myGTHDMZ2->getlambda4_Z2();
834
835 double a_LO = (-la1 - la2 + sqrt((la1 - la2)*(la1 - la2) + 4.*la4*la4)) / 32. / M_PI;
836
837 // To avoid applying the condition for accidentally small LO contributions
838 if(std::fabs(a_LO) > 1./16./M_PI)
839 return ((a_NLO - a_LO) / a_LO).abs();
840 else
841 return 0.009; // To allow perturbativity constraints as stringent as 1%
842}
843
844R1p01eveM_Z2::R1p01eveM_Z2(const StandardModel& SM_i)
845: unitarity_Z2(SM_i), myGTHDMZ2(static_cast<const GeneralTHDMZ2*> (&SM_i))
846{}
847
848double R1p01eveM_Z2::computeThValue()
849{
850 gslpp::complex i = gslpp::complex::i();
851
852 computeZ2_at_Q();
853
854 double la1Q = myZ2_at_Q(0, 0);
855 double la2Q = myZ2_at_Q(0, 1);
856 double la3Q = myZ2_at_Q(0, 2);
857 double la4Q = myZ2_at_Q(0, 3);
858 double la5Q = myZ2_at_Q(0, 4);
859
860 double YtQ = myZ2_at_Q(1, 0);
861 double Yb1Q = myZ2_at_Q(1, 1);
862 double Yb2Q = myZ2_at_Q(1, 2);
863 double Ytau1Q = myZ2_at_Q(1, 3);
864 double Ytau2Q = myZ2_at_Q(1, 4);
865
866 double WFRc1 = myZ2_at_Q(2, 0);
867 double WFRc2 = myZ2_at_Q(2, 1);
868
869 double beta1 = myGTHDM.betalambda1_Z2(la1Q, la3Q, la4Q, la5Q, Yb1Q, Ytau1Q);
870 double beta2 = myGTHDM.betalambda2_Z2(la2Q, la3Q, la4Q, la5Q, YtQ, Yb2Q, Ytau2Q);
871 double beta4 = myGTHDM.betalambda4_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
872
873 gslpp::complex B7 = -la1Q + 3.*beta1/2. + (i*M_PI - 1.)*(la1Q*la1Q + la4Q*la4Q)/16./M_PI/M_PI -
874 la1Q*WFRc1/32./M_PI/M_PI;
875
876 gslpp::complex B8 = -la2Q + 3.*beta2/2. + (i*M_PI - 1.)*(la2Q*la2Q + la4Q*la4Q)/16./M_PI/M_PI -
877 la2Q*(-WFRc1 + 2.*WFRc2)/32./M_PI/M_PI;
878
879 gslpp::complex B9 = -la4Q + 3.*beta4/2. + (i*M_PI - 1.)*(la1Q + la2Q)*la4Q/16./M_PI/M_PI -
880 la4Q*WFRc2/32./M_PI/M_PI;
881
882 gslpp::complex a_NLO = (B7 + B8 - sqrt((B7 - B8)*(B7 - B8) + 4.*B9*B9))/32./M_PI;
883
884 // LO eigenvalue, as defined in Cacchio:2016qyh (Sign difference in front of the square-roots compared to Grinstein:2015rtl)
885
886 double la1 = myGTHDMZ2->getlambda1_Z2();
887 double la2 = myGTHDMZ2->getlambda2_Z2();
888 double la4 = myGTHDMZ2->getlambda4_Z2();
889
890 double a_LO = (-la1 - la2 - sqrt((la1 - la2)*(la1 - la2) + 4.*la4*la4)) / 32. / M_PI;
891
892 // To avoid applying the condition for accidentally small LO contributions
893 if(std::fabs(a_LO) > 1./16./M_PI)
894 return ((a_NLO - a_LO) / a_LO).abs();
895 else
896 return 0.009; // To allow perturbativity constraints as stringent as 1%
897}
898
899
900/**********************************/
901/* R1p ratios of the odd 01 block */
902/**********************************/
903
904R1p01oddP_Z2::R1p01oddP_Z2(const StandardModel& SM_i)
905: unitarity_Z2(SM_i), myGTHDMZ2(static_cast<const GeneralTHDMZ2*> (&SM_i))
906{}
907
908double R1p01oddP_Z2::computeThValue()
909{
910 gslpp::complex i = gslpp::complex::i();
911
912 computeZ2_at_Q();
913
914 double la1Q = myZ2_at_Q(0, 0);
915 double la2Q = myZ2_at_Q(0, 1);
916 double la3Q = myZ2_at_Q(0, 2);
917 double la4Q = myZ2_at_Q(0, 3);
918 double la5Q = myZ2_at_Q(0, 4);
919
920 double YtQ = myZ2_at_Q(1, 0);
921 double Yb1Q = myZ2_at_Q(1, 1);
922 double Yb2Q = myZ2_at_Q(1, 2);
923 double Ytau1Q = myZ2_at_Q(1, 3);
924 double Ytau2Q = myZ2_at_Q(1, 4);
925
926 double WFRc2 = myZ2_at_Q(2, 1);
927
928 double beta3 = myGTHDM.betalambda3_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
929 double beta5 = myGTHDM.betalambda5_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
930
931 gslpp::complex B13 = -la3Q + 3.*beta3/2. + (i*M_PI - 1.)*(la3Q*la3Q + la5Q*la5Q)/16./M_PI/M_PI -
932 (la3Q + la4Q - la5Q)*WFRc2/32./M_PI/M_PI;
933
934 gslpp::complex B15 = -la5Q + 3.*beta5/2. + 2.*(i*M_PI - 1.)*la3Q*la5Q/16./M_PI/M_PI -
935 (la4Q - 2.*la5Q)*WFRc2/32./M_PI/M_PI;
936
937 gslpp::complex a_NLO = (B13 + B15)/16./M_PI ;
938
939 // LO eigenvalue, as defined in Grinstein:2015rtl
940 double la3 = myGTHDMZ2->getlambda3_Z2();
941 double la5 = myGTHDMZ2->getlambda5_Z2();
942
943 double a_LO = -(la3 + la5) / 16. / M_PI;
944
945 // To avoid applying the condition for accidentally small LO contributions
946 if(std::fabs(a_LO) > 1./16./M_PI)
947 return ((a_NLO - a_LO) / a_LO).abs();
948 else
949 return 0.009; // To allow perturbativity constraints as stringent as 1%
950}
951
952R1p01oddM_Z2::R1p01oddM_Z2(const StandardModel& SM_i)
953: unitarity_Z2(SM_i), myGTHDMZ2(static_cast<const GeneralTHDMZ2*> (&SM_i))
954{}
955
956double R1p01oddM_Z2::computeThValue()
957{
958 gslpp::complex i = gslpp::complex::i();
959
960 computeZ2_at_Q();
961
962 double la1Q = myZ2_at_Q(0, 0);
963 double la2Q = myZ2_at_Q(0, 1);
964 double la3Q = myZ2_at_Q(0, 2);
965 double la4Q = myZ2_at_Q(0, 3);
966 double la5Q = myZ2_at_Q(0, 4);
967
968 double YtQ = myZ2_at_Q(1, 0);
969 double Yb1Q = myZ2_at_Q(1, 1);
970 double Yb2Q = myZ2_at_Q(1, 2);
971 double Ytau1Q = myZ2_at_Q(1, 3);
972 double Ytau2Q = myZ2_at_Q(1, 4);
973
974 double WFRc2 = myZ2_at_Q(2, 1);
975
976 double beta3 = myGTHDM.betalambda3_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
977 double beta5 = myGTHDM.betalambda5_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
978
979 gslpp::complex B13 = -la3Q + 3.*beta3/2. + (i*M_PI - 1.)*(la3Q*la3Q + la5Q*la5Q)/16./M_PI/M_PI -
980 (la3Q + la4Q - la5Q)*WFRc2/32./M_PI/M_PI;
981
982 gslpp::complex B15 = -la5Q + 3.*beta5/2. + 2.*(i*M_PI - 1.)*la3Q*la5Q/16./M_PI/M_PI -
983 (la4Q - 2.*la5Q)*WFRc2/32./M_PI/M_PI;
984
985 gslpp::complex a_NLO = (B13 - B15)/16./M_PI;
986
987 // LO eigenvalue, as defined in Grinstein:2015rtl
988
989 double la3 = myGTHDMZ2->getlambda3_Z2();
990 double la5 = myGTHDMZ2->getlambda5_Z2();
991
992 double a_LO = -(la3 - la5) / 16. / M_PI;
993
994 // To avoid applying the condition for accidentally small LO contributions
995 if(std::fabs(a_LO) > 1./16./M_PI)
996 return ((a_NLO - a_LO) / a_LO).abs();
997 else
998 return 0.009; // To allow perturbativity constraints as stringent as 1%
999}
1000
1001
1002/*********************************/
1003/* R1p ratio of the odd 10 block */
1004/*********************************/
1005
1006R1p10odd_Z2::R1p10odd_Z2(const StandardModel& SM_i)
1007: unitarity_Z2(SM_i), myGTHDMZ2(static_cast<const GeneralTHDMZ2*> (&SM_i))
1008{}
1009
1010double R1p10odd_Z2::computeThValue()
1011{
1012 gslpp::complex i = gslpp::complex::i();
1013
1014 computeZ2_at_Q();
1015
1016 double la1Q = myZ2_at_Q(0, 0);
1017 double la2Q = myZ2_at_Q(0, 1);
1018 double la3Q = myZ2_at_Q(0, 2);
1019 double la4Q = myZ2_at_Q(0, 3);
1020 double la5Q = myZ2_at_Q(0, 4);
1021
1022 double YtQ = myZ2_at_Q(1, 0);
1023 double Yb1Q = myZ2_at_Q(1, 1);
1024 double Yb2Q = myZ2_at_Q(1, 2);
1025 double Ytau1Q = myZ2_at_Q(1, 3);
1026 double Ytau2Q = myZ2_at_Q(1, 4);
1027
1028 double WFRc2 = myZ2_at_Q(2, 1);
1029
1030 double beta3 = myGTHDM.betalambda3_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
1031 double beta4 = myGTHDM.betalambda4_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
1032
1033 gslpp::complex B19 = -la3Q + la4Q + 3.*(beta3 - beta4)/2. + (i*M_PI - 1.)*(la3Q -
1034 la4Q)*(la3Q - la4Q)/16./M_PI/M_PI - (la3Q - la5Q)*WFRc2/32./M_PI/M_PI;
1035
1036 gslpp::complex a_NLO = B19/16./M_PI;
1037
1038 // LO eigenvalue, as defined in Grinstein:2015rtl
1039
1040 double la3 = myGTHDMZ2->getlambda3_Z2();
1041 double la4 = myGTHDMZ2->getlambda4_Z2();
1042
1043 double a_LO = -(la3 - la4) / 16. / M_PI;
1044
1045 // To avoid applying the condition for accidentally small LO contributions
1046 if(std::fabs(a_LO) > 1./16./M_PI)
1047 return ((a_NLO - a_LO) / a_LO).abs();
1048 else
1049 return 0.009; // To allow perturbativity constraints as stringent as 1%
1050}
1051
1052
1053/***********************************/
1054/* R1p ratios of the even 11 block */
1055/***********************************/
1056
1057R1p11eveP_Z2::R1p11eveP_Z2(const StandardModel& SM_i)
1058: unitarity_Z2(SM_i), myGTHDMZ2(static_cast<const GeneralTHDMZ2*> (&SM_i))
1059{}
1060
1061double R1p11eveP_Z2::computeThValue()
1062{
1063 gslpp::complex i = gslpp::complex::i();
1064
1065 computeZ2_at_Q();
1066
1067 double la1Q = myZ2_at_Q(0, 0);
1068 double la2Q = myZ2_at_Q(0, 1);
1069 double la3Q = myZ2_at_Q(0, 2);
1070 double la4Q = myZ2_at_Q(0, 3);
1071 double la5Q = myZ2_at_Q(0, 4);
1072
1073 double YtQ = myZ2_at_Q(1, 0);
1074 double Yb1Q = myZ2_at_Q(1, 1);
1075 double Yb2Q = myZ2_at_Q(1, 2);
1076 double Ytau1Q = myZ2_at_Q(1, 3);
1077 double Ytau2Q = myZ2_at_Q(1, 4);
1078
1079 double WFRc1 = myZ2_at_Q(2, 0);
1080 double WFRc2 = myZ2_at_Q(2, 1);
1081 double WFRc3 = myZ2_at_Q(2, 2);
1082 double WFRc4 = myZ2_at_Q(2, 3);
1083
1084 double beta1 = myGTHDM.betalambda1_Z2(la1Q, la3Q, la4Q, la5Q, Yb1Q, Ytau1Q);
1085 double beta2 = myGTHDM.betalambda2_Z2(la2Q, la3Q, la4Q, la5Q, YtQ, Yb2Q, Ytau2Q);
1086 double beta5 = myGTHDM.betalambda5_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
1087
1088 gslpp::complex B20 = -la1Q + 3.*beta1/2. + (i*M_PI - 1.)*(la1Q*la1Q + la5Q*la5Q)/16./M_PI/M_PI -
1089 la1Q*(WFRc1 - 2.*WFRc2 + WFRc3 + 2.*WFRc4)/32./M_PI/M_PI;
1090
1091 gslpp::complex B21 = -la2Q + 3.*beta2/2. + (i*M_PI - 1.)*(la2Q*la2Q + la5Q*la5Q)/16./M_PI/M_PI -
1092 la2Q*(-WFRc1 + 2.*WFRc2 - WFRc3 + 2.*WFRc4)/32./M_PI/M_PI;
1093
1094 gslpp::complex B22 = -la5Q + 3.*beta5/2. + (i*M_PI - 1.)*(la1Q + la2Q)*la5Q/16./M_PI/M_PI -
1095 la5Q*2.*WFRc4/32./M_PI/M_PI;
1096
1097 gslpp::complex a_NLO = (B20 + B21 + sqrt((B20 - B21)*(B20 - B21) + 4.*B22*B22))/32./M_PI;
1098
1099 // LO eigenvalue, as defined in Cacchio:2016qyh (Sign difference in front of the square-roots compared to Grinstein:2015rtl)
1100
1101 double la1 = myGTHDMZ2->getlambda1_Z2();
1102 double la2 = myGTHDMZ2->getlambda2_Z2();
1103 double la5 = myGTHDMZ2->getlambda5_Z2();
1104
1105 double a_LO = (-la1 - la2 + sqrt((la1 - la2)*(la1 - la2) + 4.*la5*la5)) / 32. / M_PI;
1106
1107 // To avoid applying the condition for accidentally small LO contributions
1108 if(std::fabs(a_LO) > 1./16./M_PI)
1109 return ((a_NLO - a_LO) / a_LO).abs();
1110 else
1111 return 0.009; // To allow perturbativity constraints as stringent as 1%
1112}
1113
1114R1p11eveM_Z2::R1p11eveM_Z2(const StandardModel& SM_i)
1115: unitarity_Z2(SM_i), myGTHDMZ2(static_cast<const GeneralTHDMZ2*> (&SM_i))
1116{}
1117
1118double R1p11eveM_Z2::computeThValue()
1119{
1120 gslpp::complex i = gslpp::complex::i();
1121
1122 computeZ2_at_Q();
1123
1124 double la1Q = myZ2_at_Q(0, 0);
1125 double la2Q = myZ2_at_Q(0, 1);
1126 double la3Q = myZ2_at_Q(0, 2);
1127 double la4Q = myZ2_at_Q(0, 3);
1128 double la5Q = myZ2_at_Q(0, 4);
1129
1130 double YtQ = myZ2_at_Q(1, 0);
1131 double Yb1Q = myZ2_at_Q(1, 1);
1132 double Yb2Q = myZ2_at_Q(1, 2);
1133 double Ytau1Q = myZ2_at_Q(1, 3);
1134 double Ytau2Q = myZ2_at_Q(1, 4);
1135
1136 double WFRc1 = myZ2_at_Q(2, 0);
1137 double WFRc2 = myZ2_at_Q(2, 1);
1138 double WFRc3 = myZ2_at_Q(2, 2);
1139 double WFRc4 = myZ2_at_Q(2, 3);
1140
1141 double beta1 = myGTHDM.betalambda1_Z2(la1Q, la3Q, la4Q, la5Q, Yb1Q, Ytau1Q);
1142 double beta2 = myGTHDM.betalambda2_Z2(la2Q, la3Q, la4Q, la5Q, YtQ, Yb2Q, Ytau2Q);
1143 double beta5 = myGTHDM.betalambda5_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
1144
1145 gslpp::complex B20 = -la1Q + 3.*beta1/2. + (i*M_PI - 1.)*(la1Q*la1Q + la5Q*la5Q)/16./M_PI/M_PI -
1146 la1Q*(WFRc1 - 2.*WFRc2 + WFRc3 + 2.*WFRc4)/32./M_PI/M_PI;
1147
1148 gslpp::complex B21 = -la2Q + 3.*beta2/2. + (i*M_PI - 1.)*(la2Q*la2Q + la5Q*la5Q)/16./M_PI/M_PI -
1149 la2Q*(-WFRc1 + 2.*WFRc2 - WFRc3 + 2.*WFRc4)/32./M_PI/M_PI;
1150
1151 gslpp::complex B22 = -la5Q + 3.*beta5/2. + (i*M_PI - 1.)*(la1Q + la2Q)*la5Q/16./M_PI/M_PI -
1152 la5Q*2.*WFRc4/32./M_PI/M_PI;
1153
1154 gslpp::complex a_NLO = (B20 + B21 - sqrt((B20 - B21)*(B20 - B21) + 4.*B22*B22))/32./M_PI;
1155
1156 // LO eigenvalue, as defined in Cacchio:2016qyh (Sign difference in front of the square-roots compared to Grinstein:2015rtl)
1157
1158 double la1 = myGTHDMZ2->getlambda1_Z2();
1159 double la2 = myGTHDMZ2->getlambda2_Z2();
1160 double la5 = myGTHDMZ2->getlambda5_Z2();
1161
1162 double a_LO = (-la1 - la2 - sqrt((la1 - la2)*(la1 - la2) + 4.*la5*la5)) / 32. / M_PI;
1163
1164 // To avoid applying the condition for accidentally small LO contributions
1165 if(std::fabs(a_LO) > 1./16./M_PI)
1166 return ((a_NLO - a_LO) / a_LO).abs();
1167 else
1168 return 0.009; // To allow perturbativity constraints as stringent as 1%
1169}
1170
1171
1172/*********************************/
1173/* R1p ratio of the odd 11 block */
1174/*********************************/
1175
1176R1p11odd_Z2::R1p11odd_Z2(const StandardModel& SM_i)
1177: unitarity_Z2(SM_i), myGTHDMZ2(static_cast<const GeneralTHDMZ2*> (&SM_i))
1178{}
1179
1180double R1p11odd_Z2::computeThValue()
1181{
1182 gslpp::complex i = gslpp::complex::i();
1183
1184 computeZ2_at_Q();
1185
1186 double la1Q = myZ2_at_Q(0, 0);
1187 double la2Q = myZ2_at_Q(0, 1);
1188 double la3Q = myZ2_at_Q(0, 2);
1189 double la4Q = myZ2_at_Q(0, 3);
1190 double la5Q = myZ2_at_Q(0, 4);
1191
1192 double YtQ = myZ2_at_Q(1, 0);
1193 double Yb1Q = myZ2_at_Q(1, 1);
1194 double Yb2Q = myZ2_at_Q(1, 2);
1195 double Ytau1Q = myZ2_at_Q(1, 3);
1196 double Ytau2Q = myZ2_at_Q(1, 4);
1197
1198 double WFRc4 = myZ2_at_Q(2, 3);
1199
1200 double beta3 = myGTHDM.betalambda3_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
1201 double beta4 = myGTHDM.betalambda4_Z2(la1Q, la2Q, la3Q, la4Q, la5Q, YtQ, Yb1Q, Yb2Q, Ytau1Q, Ytau2Q);
1202
1203 gslpp::complex B30 = -la3Q - la4Q + 3.*(beta3 + beta4)/2. + (i*M_PI - 1.)*(la3Q +
1204 la4Q)*(la3Q + la4Q)/16./M_PI/M_PI - (la3Q + la4Q)*2.*WFRc4/32./M_PI/M_PI;
1205
1206 gslpp::complex a_NLO = B30/16./M_PI;
1207
1208 // LO eigenvalue, as defined in Grinstein:2015rtl
1209
1210 double la3 = myGTHDMZ2->getlambda3_Z2();
1211 double la4 = myGTHDMZ2->getlambda4_Z2();
1212
1213 double a_LO = -(la3 + la4) / 16. / M_PI;
1214
1215 // To avoid applying the condition for accidentally small LO contributions
1216 if(std::fabs(a_LO) > 1./16./M_PI)
1217 return ((a_NLO - a_LO) / a_LO).abs();
1218 else
1219 return 0.009; // To allow perturbativity constraints as stringent as 1%
1220}
1221
1222
1224// An observable for tanb
1225
1226tanbetaZ2::tanbetaZ2(const StandardModel& SM_i)
1227: ThObservable(SM_i), myGTHDMZ2(static_cast<const GeneralTHDMZ2*> (&SM_i))
1228{}
1229
1230double tanbetaZ2::computeThValue()
1231{
1232 return myGTHDMZ2->gettanb_Z2();
1233}
myGTHDM
const GeneralTHDM & myGTHDM
Definition: GeneralTHDMHeavyHiggs.h:7169
GeneralTHDMZ2::getlambda2_Z2
double getlambda2_Z2() const
A getter for the parameter of the scalar potential .
Definition: GeneralTHDMZ2.h:155
GeneralTHDMZ2::getlambda4_Z2
double getlambda4_Z2() const
A getter for the parameter of the scalar potential .
Definition: GeneralTHDMZ2.h:174
GeneralTHDMZ2::gettanb_Z2
double gettanb_Z2() const
A getter for the tangent of .
Definition: GeneralTHDMZ2.h:100
GeneralTHDMZ2::getlambda5_Z2
double getlambda5_Z2() const
A getter for the parameter of the scalar potential .
Definition: GeneralTHDMZ2.h:183
GeneralTHDMZ2::getlambda3_Z2
double getlambda3_Z2() const
A getter for the parameter of the scalar potential .
Definition: GeneralTHDMZ2.h:165
GeneralTHDMZ2::getlambda1_Z2
double getlambda1_Z2() const
A getter for the parameter of the scalar potential .
Definition: GeneralTHDMZ2.h:145
GeneralTHDMZ2Runner::betalambda2_Z2
double betalambda2_Z2(double la2, double la3, double la4, double la5, double Yt, double Yb2, double Ytau2)
The beta function of appearing in unitarity conditions.
Definition: GeneralTHDMZ2Runner.h:52
GeneralTHDMZ2Runner::getGTHDMZ2_at_Q
gslpp::matrix< double > getGTHDMZ2_at_Q()
The public function which contains all relevant GTHDMZ2 parameter after running.
Definition: GeneralTHDMZ2Runner.cpp:1108
GeneralTHDMZ2Runner::betalambda3_Z2
double betalambda3_Z2(double la1, double la2, double la3, double la4, double la5, double Yt, double Yb1, double Yb2, double Ytau1, double Ytau2)
The beta function of appearing in unitarity conditions.
Definition: GeneralTHDMZ2Runner.h:63
GeneralTHDMZ2Runner::betalambda1_Z2
double betalambda1_Z2(double la1, double la3, double la4, double la5, double Yb1, double Ytau1)
The beta function of appearing in unitarity conditions.
Definition: GeneralTHDMZ2Runner.h:41
GeneralTHDMZ2Runner::betalambda5_Z2
double betalambda5_Z2(double la1, double la2, double la3, double la4, double la5, double Yt, double Yb1, double Yb2, double Ytau1, double Ytau2)
The beta function of appearing in unitarity conditions.
Definition: GeneralTHDMZ2Runner.h:85
GeneralTHDMZ2Runner::betalambda4_Z2
double betalambda4_Z2(double la1, double la2, double la3, double la4, double la5, double Yt, double Yb1, double Yb2, double Ytau1, double Ytau2)
The beta function of appearing in unitarity conditions.
Definition: GeneralTHDMZ2Runner.h:74
R1p00eveM_Z2::myGTHDMZ2
const GeneralTHDMZ2 * myGTHDMZ2
Definition: GeneralTHDMZ2Unitarity.h:374
R1p00eveM_Z2::R1p00eveM_Z2
R1p00eveM_Z2(const StandardModel &SM_i)
R1p00eveM_Z2 constructor.
Definition: GeneralTHDMZ2Unitarity.cpp:618
R1p00eveM_Z2::computeThValue
double computeThValue()
Definition: GeneralTHDMZ2Unitarity.cpp:622
R1p00eveP_Z2::R1p00eveP_Z2
R1p00eveP_Z2(const StandardModel &SM_i)
R1p00eveP_Z2 constructor.
Definition: GeneralTHDMZ2Unitarity.cpp:531
R1p00eveP_Z2::computeThValue
double computeThValue()
Definition: GeneralTHDMZ2Unitarity.cpp:535
R1p00eveP_Z2::myGTHDMZ2
const GeneralTHDMZ2 * myGTHDMZ2
Definition: GeneralTHDMZ2Unitarity.h:352
R1p00oddM_Z2::myGTHDMZ2
const GeneralTHDMZ2 * myGTHDMZ2
Definition: GeneralTHDMZ2Unitarity.h:423
R1p00oddM_Z2::R1p00oddM_Z2
R1p00oddM_Z2(const StandardModel &SM_i)
R1p00oddM_Z2 constructor.
Definition: GeneralTHDMZ2Unitarity.cpp:734
R1p00oddM_Z2::computeThValue
double computeThValue()
Definition: GeneralTHDMZ2Unitarity.cpp:738
R1p00oddP_Z2::computeThValue
double computeThValue()
Definition: GeneralTHDMZ2Unitarity.cpp:687
R1p00oddP_Z2::R1p00oddP_Z2
R1p00oddP_Z2(const StandardModel &SM_i)
R1p00oddP_Z2 constructor.
Definition: GeneralTHDMZ2Unitarity.cpp:683
R1p00oddP_Z2::myGTHDMZ2
const GeneralTHDMZ2 * myGTHDMZ2
Definition: GeneralTHDMZ2Unitarity.h:401
R1p01eveM_Z2::computeThValue
double computeThValue()
Definition: GeneralTHDMZ2Unitarity.cpp:848
R1p01eveM_Z2::R1p01eveM_Z2
R1p01eveM_Z2(const StandardModel &SM_i)
R1p01eveM_Z2 constructor.
Definition: GeneralTHDMZ2Unitarity.cpp:844
R1p01eveM_Z2::myGTHDMZ2
const GeneralTHDMZ2 * myGTHDMZ2
Definition: GeneralTHDMZ2Unitarity.h:472
R1p01eveP_Z2::computeThValue
double computeThValue()
Definition: GeneralTHDMZ2Unitarity.cpp:794
R1p01eveP_Z2::myGTHDMZ2
const GeneralTHDMZ2 * myGTHDMZ2
Definition: GeneralTHDMZ2Unitarity.h:450
R1p01eveP_Z2::R1p01eveP_Z2
R1p01eveP_Z2(const StandardModel &SM_i)
R1p01eveP_Z2 constructor.
Definition: GeneralTHDMZ2Unitarity.cpp:790
R1p01oddM_Z2::myGTHDMZ2
const GeneralTHDMZ2 * myGTHDMZ2
Definition: GeneralTHDMZ2Unitarity.h:521
R1p01oddM_Z2::computeThValue
double computeThValue()
Definition: GeneralTHDMZ2Unitarity.cpp:956
R1p01oddM_Z2::R1p01oddM_Z2
R1p01oddM_Z2(const StandardModel &SM_i)
R1p01oddM_Z2 constructor.
Definition: GeneralTHDMZ2Unitarity.cpp:952
R1p01oddP_Z2::myGTHDMZ2
const GeneralTHDMZ2 * myGTHDMZ2
Definition: GeneralTHDMZ2Unitarity.h:499
R1p01oddP_Z2::computeThValue
double computeThValue()
Definition: GeneralTHDMZ2Unitarity.cpp:908
R1p01oddP_Z2::R1p01oddP_Z2
R1p01oddP_Z2(const StandardModel &SM_i)
R1p01oddP_Z2 constructor.
Definition: GeneralTHDMZ2Unitarity.cpp:904
R1p10odd_Z2::computeThValue
double computeThValue()
Definition: GeneralTHDMZ2Unitarity.cpp:1010
R1p10odd_Z2::R1p10odd_Z2
R1p10odd_Z2(const StandardModel &SM_i)
R1p10odd_Z2 constructor.
Definition: GeneralTHDMZ2Unitarity.cpp:1006
R1p10odd_Z2::myGTHDMZ2
const GeneralTHDMZ2 * myGTHDMZ2
Definition: GeneralTHDMZ2Unitarity.h:548
R1p11eveM_Z2::myGTHDMZ2
const GeneralTHDMZ2 * myGTHDMZ2
Definition: GeneralTHDMZ2Unitarity.h:597
R1p11eveM_Z2::R1p11eveM_Z2
R1p11eveM_Z2(const StandardModel &SM_i)
R1p11eveM_Z2 constructor.
Definition: GeneralTHDMZ2Unitarity.cpp:1114
R1p11eveM_Z2::computeThValue
double computeThValue()
Definition: GeneralTHDMZ2Unitarity.cpp:1118
R1p11eveP_Z2::R1p11eveP_Z2
R1p11eveP_Z2(const StandardModel &SM_i)
R1p11eveP_Z2 constructor.
Definition: GeneralTHDMZ2Unitarity.cpp:1057
R1p11eveP_Z2::computeThValue
double computeThValue()
Definition: GeneralTHDMZ2Unitarity.cpp:1061
R1p11eveP_Z2::myGTHDMZ2
const GeneralTHDMZ2 * myGTHDMZ2
Definition: GeneralTHDMZ2Unitarity.h:575
R1p11odd_Z2::myGTHDMZ2
const GeneralTHDMZ2 * myGTHDMZ2
Definition: GeneralTHDMZ2Unitarity.h:624
R1p11odd_Z2::computeThValue
double computeThValue()
Definition: GeneralTHDMZ2Unitarity.cpp:1180
R1p11odd_Z2::R1p11odd_Z2
R1p11odd_Z2(const StandardModel &SM_i)
R1p11odd_Z2 constructor.
Definition: GeneralTHDMZ2Unitarity.cpp:1176
StandardModel
A model class for the Standard Model.
Definition: StandardModel.h:521
ThObservable
A class for a model prediction of an observable.
Definition: ThObservable.h:25
tanbetaZ2::myGTHDMZ2
const GeneralTHDMZ2 * myGTHDMZ2
Definition: GeneralTHDMZ2Unitarity.h:650
tanbetaZ2::tanbetaZ2
tanbetaZ2(const StandardModel &SM_i)
tanbetaZ2 constructor.
Definition: GeneralTHDMZ2Unitarity.cpp:1226
unitarity00eveM_Z2::computeThValue
double computeThValue()
Definition: GeneralTHDMZ2Unitarity.cpp:73
unitarity00eveM_Z2::unitarity00eveM_Z2
unitarity00eveM_Z2(const StandardModel &SM_i)
unitarity00eveM_Z2 constructor.
Definition: GeneralTHDMZ2Unitarity.cpp:69
unitarity00eveP_Z2::computeThValue
double computeThValue()
Definition: GeneralTHDMZ2Unitarity.cpp:28
unitarity00eveP_Z2::unitarity00eveP_Z2
unitarity00eveP_Z2(const StandardModel &SM_i)
unitarity00eveP_Z2 constructor.
Definition: GeneralTHDMZ2Unitarity.cpp:24
unitarity00oddM_Z2::computeThValue
double computeThValue()
Definition: GeneralTHDMZ2Unitarity.cpp:161
unitarity00oddM_Z2::unitarity00oddM_Z2
unitarity00oddM_Z2(const StandardModel &SM_i)
unitarity00oddM_Z2 constructor.
Definition: GeneralTHDMZ2Unitarity.cpp:157
unitarity00oddP_Z2::unitarity00oddP_Z2
unitarity00oddP_Z2(const StandardModel &SM_i)
unitarity00oddP_Z2 constructor.
Definition: GeneralTHDMZ2Unitarity.cpp:119
unitarity00oddP_Z2::computeThValue
double computeThValue()
Definition: GeneralTHDMZ2Unitarity.cpp:123
unitarity01eveM_Z2::unitarity01eveM_Z2
unitarity01eveM_Z2(const StandardModel &SM_i)
unitarity01eveM_Z2 constructor.
Definition: GeneralTHDMZ2Unitarity.cpp:241
unitarity01eveM_Z2::computeThValue
double computeThValue()
Definition: GeneralTHDMZ2Unitarity.cpp:245
unitarity01eveP_Z2::computeThValue
double computeThValue()
Definition: GeneralTHDMZ2Unitarity.cpp:204
unitarity01eveP_Z2::unitarity01eveP_Z2
unitarity01eveP_Z2(const StandardModel &SM_i)
unitarity01eveP_Z2 constructor.
Definition: GeneralTHDMZ2Unitarity.cpp:200
unitarity01oddM_Z2::computeThValue
double computeThValue()
Definition: GeneralTHDMZ2Unitarity.cpp:327
unitarity01oddM_Z2::unitarity01oddM_Z2
unitarity01oddM_Z2(const StandardModel &SM_i)
unitarity01oddM_Z2 constructor.
Definition: GeneralTHDMZ2Unitarity.cpp:323
unitarity01oddP_Z2::unitarity01oddP_Z2
unitarity01oddP_Z2(const StandardModel &SM_i)
unitarity01oddP_Z2 constructor.
Definition: GeneralTHDMZ2Unitarity.cpp:287
unitarity01oddP_Z2::computeThValue
double computeThValue()
Definition: GeneralTHDMZ2Unitarity.cpp:291
unitarity10odd_Z2::computeThValue
double computeThValue()
Definition: GeneralTHDMZ2Unitarity.cpp:368
unitarity10odd_Z2::unitarity10odd_Z2
unitarity10odd_Z2(const StandardModel &SM_i)
unitarity10odd_Z2 constructor.
Definition: GeneralTHDMZ2Unitarity.cpp:364
unitarity11eveM_Z2::computeThValue
double computeThValue()
Definition: GeneralTHDMZ2Unitarity.cpp:449
unitarity11eveM_Z2::unitarity11eveM_Z2
unitarity11eveM_Z2(const StandardModel &SM_i)
unitarity11eveM_Z2 constructor.
Definition: GeneralTHDMZ2Unitarity.cpp:445
unitarity11eveP_Z2::computeThValue
double computeThValue()
Definition: GeneralTHDMZ2Unitarity.cpp:406
unitarity11eveP_Z2::unitarity11eveP_Z2
unitarity11eveP_Z2(const StandardModel &SM_i)
unitarity11eveP_Z2 constructor.
Definition: GeneralTHDMZ2Unitarity.cpp:402
unitarity11odd_Z2::computeThValue
double computeThValue()
Definition: GeneralTHDMZ2Unitarity.cpp:497
unitarity11odd_Z2::unitarity11odd_Z2
unitarity11odd_Z2(const StandardModel &SM_i)
unitarity11odd_Z2 constructor.
Definition: GeneralTHDMZ2Unitarity.cpp:493
unitarity_Z2
An observable class for NLO perturbative unitarity conditions to the THDM with a Z2 symmetry.
Definition: GeneralTHDMZ2Unitarity.h:33
unitarity_Z2::computeZ2_at_Q
void computeZ2_at_Q()
Definition: GeneralTHDMZ2Unitarity.cpp:15
unitarity_Z2::unitarity_Z2
unitarity_Z2(const StandardModel &SM_i)
unitarity_Z2 constructor.
Definition: GeneralTHDMZ2Unitarity.cpp:11
unitarity_Z2::myZ2_at_Q
gslpp::matrix< double > myZ2_at_Q
Definition: GeneralTHDMZ2Unitarity.h:43
unitarity_Z2::myGTHDM
GeneralTHDMZ2Runner myGTHDM
Definition: GeneralTHDMZ2Unitarity.h:41