a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
NPbase.cpp
Go to the documentation of this file.
1//AG: The following functions were defined:
2// virtual double deltaGV_f_2(const Particle f) const;
3// virtual double deltaGA_f_2(const Particle f) const;
4// virtual double deltaGamma_Zf_Test(const Particle f) const;
5// virtual double deltaGamma_Zf_2(const Particle f) const;
6// virtual double deltaGamma_Z_Test() const;
7// virtual double deltaGamma_Z_2() const;
8// virtual double deltaGamma_Zhad_Test() const;
9// virtual double deltaGamma_Zhad_2() const;
10// virtual double deltaSigmaHadron_Test() const;
11// virtual double deltaSigmaHadron_2() const;
12// virtual double deltaSin2thetaEff_e_2() const;
13// virtual double deltaSin2thetaEff_mu_2() const;
14// virtual double deltaA_f_2(const Particle f) const;
15// virtual double deltaAFB_Test(const Particle f) const;
16// virtual double deltaAFB_2(const Particle f) const;
17// virtual double deltaR0_f_Test(const Particle f) const;
18// virtual double deltaR0_f_2(const Particle f) const;
19
20/*
21 * Copyright (C) 2013 HEPfit Collaboration
22 *
23 *
24 * For the licensing terms see doc/COPYING.
25 */
26
27#include "NPbase.h"
28
29NPbase::NPbase()
30: StandardModel(), trueSM()
31{
32 trueSM.InitializeModel();
33 trueSM.setSliced(true);
34}
35
36bool NPbase::Update(const std::map<std::string, double>& DPars)
37{
38 if (!trueSM.Update(DPars)) return (false);
39 return StandardModel::Update(DPars);
40}
41
42int NPbase::OutputOrder() const {
43 //AG:added
44 // 0 SM
45 // 1 Linear
46 // 2 Linear + Quadratic
47 // 3 Quadratic
48 return 1; //Overwritten in NPSMEFTd6
49}
50
51const double NPbase::alphaMz() const
52{
53 /*AG:begin
54 // FlagMWinput flag to be implemented in NPbase, especially for alphaMz and Mw!
55 double dalphaMz = 0.0;
56 if(FlagMWinput){
57 double alpha = trueSM.alphaMz();
58 double c2 = trueSM.cW2();
59 double s2 = trueSM.sW2();
60
61 dalphaMz = sqrt(2.0)*GF*Mz*Mz/4.0/M_PI*c2*( alpha/2.0*(obliqueS() - 2.0*c2*obliqueT() - (c2-s2)/2.0/s2*obliqueU()) - s2/2.0/(c2-s2)*DeltaGF() );
62 }
63 return (trueSM.alphaMz() + dalphaMz);
64 //AG:end */
65
66 double myAlphaMz = trueSM.alphaMz();
67
68 return myAlphaMz;
69}
70
71const double NPbase::Mw() const
72{
73 double myMw = trueSM.Mw();
74
75 double alpha = trueSM.alphaMz();
76 double c2 = trueSM.cW2();
77 double s2 = trueSM.sW2();
78
79 myMw *= 1.0 - alpha / 4.0 / (c2 - s2)
80 *(obliqueS() - 2.0 * c2 * obliqueT() - (c2 - s2) * obliqueU() / 2.0 / s2)
81 - s2 / 2.0 / (c2 - s2) * DeltaGF();
82
83 //std::cout << "Mw: c_S=" << - alpha/4.0/(c2-s2) << std::endl;
84 //std::cout << "Mw: c_T=" << - alpha/4.0/(c2-s2)*(- 2.0*c2) << std::endl;
85 //std::cout << "Mw: c_U=" << - alpha/4.0/(c2-s2)*(- (c2-s2)/2.0/s2) << std::endl;
86
87 return myMw;
88}
89
90const double NPbase::GammaW(const Particle fi, const Particle fj) const
91{
92 double Gamma_Wij = trueSM.GammaW(fi, fj);
93
94 double alpha = trueSM.alphaMz();
95 double c2 = trueSM.cW2();
96 double s2 = trueSM.sW2();
97
98 Gamma_Wij *= 1.0 - 3.0 * alpha / 4.0 / (c2 - s2)
99 *(obliqueS() - 2.0 * c2 * obliqueT() - (c2 - s2) * obliqueU() / 2.0 / s2)
100 - (1.0 + c2) / 2.0 / (c2 - s2) * DeltaGF();
101
102 //std::cout << "Gw: c_S=" << - 3.0*alpha/4.0/(c2-s2) << std::endl;
103 //std::cout << "Gw: c_T=" << - 3.0*alpha/4.0/(c2-s2)*(- 2.0*c2) << std::endl;
104 //std::cout << "Gw: c_U=" << - 3.0*alpha/4.0/(c2-s2)*(- (c2-s2)/2.0/s2) << std::endl;
105
106 return Gamma_Wij;
107}
108
109const double NPbase::GammaW() const
110{
111 double Gamma_W = trueSM.GammaW();
112
113 double alpha = trueSM.alphaMz();
114 double c2 = trueSM.cW2();
115 double s2 = trueSM.sW2();
116
117 Gamma_W *= 1.0 - 3.0 * alpha / 4.0 / (c2 - s2)
118 *(obliqueS() - 2.0 * c2 * obliqueT() - (c2 - s2) * obliqueU() / 2.0 / s2)
119 - (1.0 + c2) / 2.0 / (c2 - s2) * DeltaGF();
120
121 //std::cout << "Gw: c_S=" << - 3.0*alpha/4.0/(c2-s2) << std::endl;
122 //std::cout << "Gw: c_T=" << - 3.0*alpha/4.0/(c2-s2)*(- 2.0*c2) << std::endl;
123 //std::cout << "Gw: c_U=" << - 3.0*alpha/4.0/(c2-s2)*(- (c2-s2)/2.0/s2) << std::endl;
124
125 return Gamma_W;
126}
127
128const double NPbase::BrW(const Particle fi, const Particle fj) const
129{
130 double GammW = GammaW();
131 double GammWij = GammaW(fi, fj);
132
133 return GammWij/GammW;
134}
135
136
137const double NPbase::RWlilj(const Particle li, const Particle lj) const
138{
139 double GammWli, GammWlj;
140
141 if (li.is("ELECTRON"))
142 GammWli = GammaW(leptons[NEUTRINO_1],li);
143 else if (li.is("MU"))
144 GammWli = GammaW(leptons[NEUTRINO_2],li);
145 else if (li.is("TAU"))
146 GammWli = GammaW(leptons[NEUTRINO_3],li);
147 else
148 throw std::runtime_error("Error in NPbase::RWlilj. li must be a charged lepton");
149
150 if (lj.is("ELECTRON"))
151 GammWlj = GammaW(leptons[NEUTRINO_1],lj);
152 else if (lj.is("MU"))
153 GammWlj = GammaW(leptons[NEUTRINO_2],lj);
154 else if (lj.is("TAU"))
155 GammWlj = GammaW(leptons[NEUTRINO_3],lj);
156 else
157 throw std::runtime_error("Error in NPbase::RWlilj. lj must be a charged lepton");
158
159 return GammWli/GammWlj;
160}
161
162const double NPbase::RWc() const
163{
164 double GammWcX, GammWhad;
165
166// Basic NPBase implementation is only NP universal and respects CKM unitarity.
167// As it directly uses SM implementation of W width, use same definition here
168// (with the modified NPBase implementation of GammaW)
169
170// Add all the W-> cX decays
171// In SM GammaW fermion masses are ignored and CKM=1 but uses that SM CKM is unitary => I only need W->cs
172 GammWcX = GammaW(quarks[CHARM], quarks[STRANGE]);
173
174// For the same reasons, I only need to add the W-> ud decays into the hadronic part
175 GammWhad = GammWcX
176 + GammaW(quarks[UP], quarks[DOWN]);
177
178 return GammWcX/GammWhad;
179}
180
181const double NPbase::deltaGV_f(const Particle f) const
182{
183 if (f.is("TOP")) return 0.;
184
185 /* SM values */
186 double alpha = trueSM.alphaMz();
187 double sW2SM = trueSM.sW2();
188 double cW2SM = trueSM.cW2();
189 double gVSM = trueSM.gV_f(f).real();
190 double gASM = trueSM.gA_f(f).real();
191
192 return ( gVSM * (alpha * obliqueT() - DeltaGF()) / 2.0
193 + (gVSM - gASM) / 4.0 / sW2SM / (cW2SM - sW2SM)
194 *(alpha * (obliqueS() - 4.0 * cW2SM * sW2SM * obliqueT())
195 + 4.0 * cW2SM * sW2SM * DeltaGF()));
196}
197
198const gslpp::complex NPbase::gV_f(const Particle f) const
199{
200 //AG: deltaGV_f_2(f) added below.
201 return ( trueSM.gV_f(f) + deltaGV_f(f) + deltaGV_f_2(f) );
202}
203
204const double NPbase::deltaGA_f(const Particle f) const
205{
206 if (f.is("TOP")) return 0.;
207 /* SM values */
208 double alpha = trueSM.alphaMz();
209 double gASM = trueSM.gA_f(f).real();
210
211 return ( gASM * (alpha * obliqueT() - DeltaGF()) / 2.0);
212}
213
214const gslpp::complex NPbase::gA_f(const Particle f) const
215{
216 //AG: deltaGA_f_2(f) added below
217 return ( trueSM.gA_f(f) + deltaGA_f(f) + deltaGA_f_2(f) );
218}
219
220const gslpp::complex NPbase::rhoZ_f(const Particle f) const
221{
222 return ( gA_f(f) * gA_f(f) / f.getIsospin() / f.getIsospin());
223
224}
225
226const gslpp::complex NPbase::kappaZ_f(const Particle f) const
227{
228 return ( (1.0 - gV_f(f) / gA_f(f)) / (4.0 * fabs(f.getCharge()) * sW2()));
229}
230
231const double NPbase::deltaGL_f_mu(const Particle p, const double mu) const
232{
233 // Default: No scale dependence
234 return 0.5 * ( deltaGV_f(p) + deltaGA_f(p) );
235}
236
237
238const double NPbase::deltaGR_f_mu(const Particle p, const double mu) const
239{
240 // Default: No scale dependence
241 return 0.5 * ( deltaGV_f(p) - deltaGA_f(p) );
242}
243
244gslpp::complex NPbase::deltaGL_Wff_mu(const Particle pbar, const Particle p, const double mu) const
245{
246 // Default: No scale dependence
247 return deltaGL_Wff(pbar, p);
248}
249
250gslpp::complex NPbase::deltaGR_Wff_mu(const Particle pbar, const Particle p, const double mu) const
251{
252 // Default: No scale dependence
253 return deltaGR_Wff(pbar, p);
254}
255
256const double NPbase::deltaGamma_Zf_2(const Particle f) const
257{
258 //AG:added
259 double DeltaGamma_Zf_2=0.0;
260
261 double delGVf = deltaGV_f(f);
262 double delGAf = deltaGA_f(f);
263 double delGVf2 = deltaGV_f_2(f);
264 double delGAf2 = deltaGA_f_2(f);
265
266 bool nonZeroNP = false;
267 if (delGVf2!=0.0 || delGAf2!=0.0) {nonZeroNP = true;}
268
269 if (nonZeroNP) {
270 double Nf;
271 if (f.is("LEPTON")) {
272 Nf = 1.0;
273 } else {
274 Nf = 3.0;
275 }
276
277 double gVf = trueSM.gV_f(f).real();
278 double gAf = trueSM.gA_f(f).real();
279 double DelGammaZf2;
280
281 DelGammaZf2 = Nf * ( 2.0*(gVf*delGVf2 + gAf*delGAf2) + delGVf*delGVf + delGAf*delGAf );
282 //DeltaGamma_Zf_2 = 4.0 * GF * pow(Mz,3.0) / 24.0 / pow(2,0.5) / M_PI * DelGammaZf2;
283 DeltaGamma_Zf_2 = alphaMz()*Mz / 12.0 / trueSM.sW2()/trueSM.cW2() * DelGammaZf2;
284 }
285
286 return DeltaGamma_Zf_2;
287}
288
289const double NPbase::deltaGamma_Zf(const Particle f) const
290{
291 double deltaGamma_Zf = 0.;
292 bool nonZeroNP = false;
293
294 double delGVf = deltaGV_f(f);
295 double delGAf = deltaGA_f(f);
296
297 double gVf = trueSM.gV_f(f).real();
298 double gAf = trueSM.gA_f(f).real();
299
300 double Nf;
301
302 if (f.is("LEPTON")) {
303 Nf = 1.0;
304 } else {
305 Nf = 3.0;
306 }
307
308 double alpha = trueSM.alphaMz();
309 double sW2_SM = trueSM.sW2();
310 double cW2_SM = trueSM.cW2();
311
312 if (delGVf != 0.0 || delGAf != 0.0)
313 nonZeroNP = true;
314
315 if (nonZeroNP) {
316 double delGammaZf = 0.0;
317 delGammaZf = 2.0 * Nf * (gVf * delGVf + gAf * delGAf);
318
319 deltaGamma_Zf = alpha * Mz / 12.0 / sW2_SM / cW2_SM * delGammaZf;
320 }
321
322 return deltaGamma_Zf;
323}
324
325const double NPbase::Gamma_Zf(const Particle f) const //AG:modified
326{
327 //AG:begin
328 if(OutputOrder()==0){ return (trueSM.GammaZ(f) ); }
329 if(OutputOrder()==1){ return (trueSM.GammaZ(f) + deltaGamma_Zf(f)); }
330 if(OutputOrder()==2){ return (trueSM.GammaZ(f) + deltaGamma_Zf(f) + deltaGamma_Zf_2(f) ); }
331 if(OutputOrder()==3){ return (trueSM.GammaZ(f) + deltaGamma_Zf_2(f) ); }
332 else
333 //AG:end
334 //AG: deltaGamma_Zf_2(f) added below
335 return (trueSM.GammaZ(f) + deltaGamma_Zf(f) + deltaGamma_Zf_2(f));
336}
337
338const double NPbase::deltaGamma_Z_2() const
339{
340 //AG:added
341 double deltaGamma_Z_2 = 0.;
342
343 bool nonZeroNP = false;
344 double delGVl2[6], delGAl2[6], delGVq2[6], delGAq2[6];
345 for (int p = 0; p < 6; ++p) {
346 delGVl2[p] = deltaGV_f_2(leptons[p]);
347 delGAl2[p] = deltaGA_f_2(leptons[p]);
348 delGVq2[p] = deltaGV_f_2(quarks[p]);
349 delGAq2[p] = deltaGA_f_2(quarks[p]);
350 if (delGVq2[p]!=0.0 or delGAq2[p]!=0.0 or delGVl2[p]!=0.0 or delGAl2[p]!=0.0)
351 nonZeroNP = true;
352 }
353
354 if (nonZeroNP) {
355 for(int p=0; p<6; p++){
356 deltaGamma_Z_2 += deltaGamma_Zf_2(leptons[p]) + deltaGamma_Zf_2(quarks[p]);
357 }
358 }
359
360 return deltaGamma_Z_2;
361}
362
363const double NPbase::deltaGamma_Z() const
364{
365 double deltaGamma_Z = 0.;
366 bool nonZeroNP = false;
367
368 double delGVl[6], delGAl[6], delGVq[6], delGAq[6];
369 for (int p = 0; p < 6; ++p) {
370 delGVl[p] = deltaGV_f(leptons[p]);
371 delGAl[p] = deltaGA_f(leptons[p]);
372 delGVq[p] = deltaGV_f(quarks[p]);
373 delGAq[p] = deltaGA_f(quarks[p]);
374 if (delGVl[p] != 0.0 || delGAl[p] != 0.0
375 || delGVq[p] != 0.0 || delGAq[p] != 0.0)
376 nonZeroNP = true;
377 }
378
379 if (nonZeroNP) {
380 double gVf, gAf;
381 double deltaGl[6], deltaGq[6];
382 double delGammaZ = 0.0;
383 for (int p = 0; p < 6; ++p) {
384 gVf = trueSM.gV_f(leptons[p]).real();
385 gAf = trueSM.gA_f(leptons[p]).real();
386 deltaGl[p] = 2.0 * (gVf * delGVl[p] + gAf * delGAl[p]);
387
388 gVf = trueSM.gV_f(quarks[p]).real();
389 gAf = trueSM.gA_f(quarks[p]).real();
390 deltaGq[p] = 2.0 * (gVf * delGVq[p] + gAf * delGAq[p]);
391
392 delGammaZ += deltaGl[p] + 3.0 * deltaGq[p];
393 }
394
395 double alpha = trueSM.alphaMz();
396 double sW2_SM = trueSM.sW2();
397 double cW2_SM = trueSM.cW2();
398 deltaGamma_Z = alpha * Mz / 12.0 / sW2_SM / cW2_SM
399 * delGammaZ;
400 }
401
402 return deltaGamma_Z;
403}
404
405const double NPbase::Gamma_Z() const //AG:modified
406{
407 //AG:begin
408 if(OutputOrder()==0){ return (trueSM.Gamma_Z() ); }
409 if(OutputOrder()==1){ return (trueSM.Gamma_Z() + deltaGamma_Z()); }
410 if(OutputOrder()==2){ return (trueSM.Gamma_Z() + deltaGamma_Z() + deltaGamma_Z_2() ); }
411 if(OutputOrder()==3){ return (trueSM.Gamma_Z() + deltaGamma_Z_2() ); }
412 else
413 //AG:end
414 //AG: deltaGamma_Z_2() added below
415 return (trueSM.Gamma_Z() + deltaGamma_Z() + deltaGamma_Z_2());
416}
417
418const double NPbase::deltaRuc_2() const
419{
420 //AG:added
421 double DeltaRuc_2 = 0.0;
422
423 bool nonZeroNP=false;
424 if(deltaR0_f_2(quarks[UP])!=0.0 || deltaR0_f_2(quarks[CHARM])!=0.0) { nonZeroNP = true;}
425
426 if(nonZeroNP){
427 // This keeps the same structure in SM. Should it be modified with a more general CKM assumption?
428 DeltaRuc_2 = 0.5 * ( deltaR0_f_2(quarks[UP]) + deltaR0_f_2(quarks[CHARM]) );
429 }
430
431 return DeltaRuc_2;
432}
433
434const double NPbase::deltaRuc() const
435{
436 //AG:added
437 double DeltaRuc = 0.0;
438
439 bool nonZeroNP=false;
440 if(deltaR0_f(quarks[UP])!=0.0 || deltaR0_f(quarks[CHARM])!=0.0) { nonZeroNP = true;}
441
442 if(nonZeroNP){
443 // This keeps the same structure in SM. Should it be modified with a more general CKM assumption?
444 DeltaRuc = 0.5 * ( deltaR0_f(quarks[UP]) + deltaR0_f(quarks[CHARM]) );
445 }
446
447 return DeltaRuc;
448}
449
450const double NPbase::Ruc() const
451{
452 //AG:added
453 if(OutputOrder()==0){ return (trueSM.Ruc() ); }
454 if(OutputOrder()==1){ return (trueSM.Ruc() + deltaRuc()); }
455 if(OutputOrder()==2){ return (trueSM.Ruc() + deltaRuc() + deltaRuc_2() ); }
456 if(OutputOrder()==3){ return ( deltaRuc_2() ); }
457 else
458 return ( trueSM.Ruc() + deltaRuc() + deltaRuc_2() );
459}
460
461const double NPbase::RZlilj(const Particle li, const Particle lj) const
462{
463 double GammZli, GammZlj;
464
465 if ( li.is("ELECTRON") || li.is("MU") || li.is("TAU") )
466 GammZli = Gamma_Zf(li);
467 else
468 throw std::runtime_error("Error in NPbase::RZlilj. li must be a charged lepton");
469
470 if ( lj.is("ELECTRON") || lj.is("MU") || lj.is("TAU") )
471 GammZlj = Gamma_Zf(lj);
472 else
473 throw std::runtime_error("Error in NPbase::RZlilj. lj must be a charged lepton");
474
475 return GammZli/GammZlj;
476}
477
478const double NPbase::deltaGamma_Zhad_2() const
479{
480 //AG:added
481 double DeltaGamma_Zhad_2 = 0.;
482 bool nonZeroNP = false;
483 double delGVq2[6], delGAq2[6];
484 for (int p = 0; p < 6; ++p) {
485 delGVq2[p] = deltaGV_f_2(quarks[p]);
486 delGAq2[p] = deltaGA_f_2(quarks[p]);
487 if (delGVq2[p] != 0.0 || delGAq2[p] != 0.0) {nonZeroNP = true;}
488 }
489
490 if (nonZeroNP) {
491 for(int p=0; p<6; p++){
492 DeltaGamma_Zhad_2 += deltaGamma_Zf_2(quarks[p]);
493 }
494 }
495
496 return DeltaGamma_Zhad_2;
497}
498
499const double NPbase::deltaGamma_Zhad() const
500{
501 double deltaGamma_Zhad = 0.;
502 bool nonZeroNP = false;
503
504 double delGVq[6], delGAq[6];
505 for (int p = 0; p < 6; ++p) {
506 delGVq[p] = deltaGV_f(quarks[p]);
507 delGAq[p] = deltaGA_f(quarks[p]);
508 if (delGVq[p] != 0.0 || delGAq[p] != 0.0)
509 nonZeroNP = true;
510 }
511
512 if (nonZeroNP) {
513 double gVf, gAf;
514 double deltaGq[6];
515 double delGammaZhad = 0.0;
516 for (int p = 0; p < 6; ++p) {
517
518 gVf = trueSM.gV_f(quarks[p]).real();
519 gAf = trueSM.gA_f(quarks[p]).real();
520 deltaGq[p] = 2.0 * (gVf * delGVq[p] + gAf * delGAq[p]);
521
522 delGammaZhad += 3.0 * deltaGq[p];
523 }
524
525 double alpha = trueSM.alphaMz();
526 double sW2_SM = trueSM.sW2();
527 double cW2_SM = trueSM.cW2();
528 deltaGamma_Zhad = alpha * Mz / 12.0 / sW2_SM / cW2_SM
529 * delGammaZhad;
530 }
531
532 return deltaGamma_Zhad;
533}
534
535const double NPbase::Gamma_had() const
536{
537 //AG: deltaGamma_Zhad_2() added below
538 return (trueSM.Gamma_had() + deltaGamma_Zhad() + deltaGamma_Zhad_2());
539}
540
541const double NPbase::BR_Zf(const Particle f) const
542{
543 double delGammaZTot = deltaGamma_Z();
544 double delGammaZf = deltaGamma_Zf(f);
545
546 double GammaZTotSM = trueSM.Gamma_Z();
547 double GammaZfSM = trueSM.GammaZ(f);
548
549 return (GammaZfSM/GammaZTotSM + delGammaZf/GammaZTotSM - GammaZfSM * delGammaZTot /GammaZTotSM/GammaZTotSM);
550}
551
552const double NPbase::deltaSigmaHadron_2() const
553{
554 //AG:added
555 double sigma_had_2 = 0.;
556
557 bool nonZeroNP = false;
558 double delGVl2[6], delGAl2[6], delGVq2[6], delGAq2[6];
559 for (int p = 0; p < 6; ++p) {
560 delGVl2[p] = deltaGV_f_2(leptons[p]);
561 delGAl2[p] = deltaGA_f_2(leptons[p]);
562 delGVq2[p] = deltaGV_f_2(quarks[p]);
563 delGAq2[p] = deltaGA_f_2(quarks[p]);
564 if (delGVl2[p]!=0.0 || delGAl2[p]!=0.0 || delGVq2[p]!=0.0 || delGAq2[p]!=0.0)
565 nonZeroNP = true;
566 }
567
568 if (nonZeroNP) {
569 //double prefactor = 4.0 * GF*pow(Mz,3.0)/24.0/sqrt(2.0)/M_PI; // It will cancel in the ratio either way
570 double prefactor = alphaMz()*Mz / 12.0 / trueSM.sW2()/trueSM.cW2();
571
572 // tree-level SM:
573 double Gamma_e_SM = 1.0 * prefactor * ( pow(trueSM.gV_f(leptons[ELECTRON]).real(),2.0) + pow(trueSM.gA_f(leptons[ELECTRON]).real(),2.0) );
574
575 double Gamma_lep_SM = 0.0;
576 double Gamma_had_SM = 0.0;
577 for (int p = 0; p < 6; ++p) {
578 Gamma_lep_SM += 1.0 * prefactor * ( pow(trueSM.gV_f(leptons[p]).real(),2.0) + pow(trueSM.gA_f(leptons[p]).real(),2.0) );
579 if (quarks[p].getName()!="TOP") {
580 Gamma_had_SM += 3.0 * prefactor * ( pow(trueSM.gV_f(quarks[p]).real(),2.0) + pow(trueSM.gA_f(quarks[p]).real(),2.0) );
581 }
582 };
583 double Gamma_Z_SM = Gamma_had_SM + Gamma_lep_SM;
584
585 double dGamma_e = deltaGamma_Zf(leptons[ELECTRON]);
586 double dGamma_had = deltaGamma_Zhad();
587 double dGamma_Z = deltaGamma_Z();
588
589 double dGamma_e_2 = deltaGamma_Zf_2(leptons[ELECTRON]);
590 double dGamma_had_2 = deltaGamma_Zhad_2();
591 double dGamma_Z_2 = deltaGamma_Z_2();
592
593 // Then,
594 sigma_had_2 = 12.0*M_PI/pow(Mz,2.0) * Gamma_e_SM*Gamma_had_SM/pow(Gamma_Z_SM,2.0) * (
595 dGamma_e_2/Gamma_e_SM
596 + dGamma_had_2/Gamma_had_SM
597 - 2.0*dGamma_Z_2/Gamma_Z_SM
598 + dGamma_e*dGamma_had/Gamma_e_SM/Gamma_had_SM
599 - 2.0*dGamma_e*dGamma_Z/Gamma_e_SM/Gamma_Z_SM
600 - 2.0*dGamma_had*dGamma_Z/Gamma_had_SM/Gamma_Z_SM
601 + 3.0*pow(dGamma_Z,2.0)/pow(Gamma_Z_SM,2.0)
602 );
603 }
604
605 return sigma_had_2;
606}
607
608const double NPbase::deltaSigmaHadron() const
609{
610 double sigma_had = 0.;
611 bool nonZeroNP = false;
612
613 double delGVl[6], delGAl[6], delGVq[6], delGAq[6];
614 for (int p = 0; p < 6; ++p) {
615 delGVl[p] = deltaGV_f(leptons[p]);
616 delGAl[p] = deltaGA_f(leptons[p]);
617 delGVq[p] = deltaGV_f(quarks[p]);
618 delGAq[p] = deltaGA_f(quarks[p]);
619 if (delGVl[p] != 0.0 || delGAl[p] != 0.0
620 || delGVq[p] != 0.0 || delGAq[p] != 0.0)
621 nonZeroNP = true;
622 }
623
624 if (nonZeroNP) {
625 double gVf, gAf;
626 double Gl[6], deltaGl[6], Gq[6], deltaGq[6];
627 double Gq_sum = 0.0, delGq_sum = 0.0;
628 double Gf_sum = 0.0, delGf_sum = 0.0;
629 for (int p = 0; p < 6; ++p) {
630 gVf = trueSM.gV_f(leptons[p]).real();
631 gAf = trueSM.gA_f(leptons[p]).real();
632 Gl[p] = gVf * gVf + gAf*gAf;
633 deltaGl[p] = 2.0 * (gVf * delGVl[p] + gAf * delGAl[p]);
634
635 gVf = trueSM.gV_f(quarks[p]).real();
636 gAf = trueSM.gA_f(quarks[p]).real();
637 Gq[p] = gVf * gVf + gAf*gAf;
638 deltaGq[p] = 2.0 * (gVf * delGVq[p] + gAf * delGAq[p]);
639
640 Gq_sum += 3.0 * Gq[p];
641 Gf_sum += Gl[p] + 3.0 * Gq[p];
642 delGq_sum += 3.0 * deltaGq[p];
643 delGf_sum += deltaGl[p] + 3.0 * deltaGq[p];
644 }
645
646 sigma_had = 12.0 * M_PI / Mz / Mz
647 * Gl[ELECTRON] * Gq_sum / Gf_sum / Gf_sum
648 * (deltaGl[ELECTRON] / Gl[ELECTRON]
649 + delGq_sum / Gq_sum - 2.0 * delGf_sum / Gf_sum);
650 }
651
652 return sigma_had;
653}
654
655const double NPbase::sigma0_had() const //AG:modified
656{
657 //AG:begin
658 if(OutputOrder()==0){ return (trueSM.sigma0_had() ); }
659 if(OutputOrder()==1){ return (trueSM.sigma0_had() + deltaSigmaHadron()); }
660 if(OutputOrder()==2){ return (trueSM.sigma0_had() + deltaSigmaHadron() + deltaSigmaHadron_2() ); }
661 if(OutputOrder()==3){ return ( deltaSigmaHadron_2() ); }
662 else
663 //AG:end
664 //AG: deltaSigmaHadron_2() added below
665 return (trueSM.sigma0_had() + deltaSigmaHadron() + deltaSigmaHadron_2());
666}
667
668const double NPbase::deltaSin2thetaEff_e_2() const
669{
670 //AG:added
671 double sin2_theta_eff_2=0.0;
672 double delGVf = deltaGV_f(leptons[ELECTRON]);
673 double delGAf = deltaGA_f(leptons[ELECTRON]);
674 double delGVf2 = deltaGV_f_2(leptons[ELECTRON]);
675 double delGAf2 = deltaGA_f_2(leptons[ELECTRON]);
676
677 bool nonZeroNP = false;
678 if (delGVf2!=0.0 || delGAf2!=0.0) {nonZeroNP = true;}
679
680 if (nonZeroNP) {
681 double gVf = trueSM.gV_f(leptons[ELECTRON]).real();
682 double gAf = trueSM.gA_f(leptons[ELECTRON]).real();
683 sin2_theta_eff_2 = 1.0/4.0 * delGVf * delGAf / pow(gAf,2.0)
684 - 1.0/4.0 * gVf * pow(delGAf,2.0) / pow(gAf,3.0)
685 - 1.0/4.0 * ( gAf*delGVf2 - gVf*delGAf2) / pow(gAf,2.0) ;
686 }
687
688 return sin2_theta_eff_2;
689}
690
691const double NPbase::deltaSin2thetaEff_e() const
692{
693 double sin2_theta_eff = 0.;
694 double delGVf = deltaGV_f(leptons[ELECTRON]);
695 double delGAf = deltaGA_f(leptons[ELECTRON]);
696 if (delGVf != 0.0 || delGAf != 0.0) {
697 double gVf = trueSM.gV_f(leptons[ELECTRON]).real();
698 double gAf = trueSM.gA_f(leptons[ELECTRON]).real();
699 double delGVfOverGAf = (gAf * delGVf - gVf * delGAf) / gAf / gAf;
700
701 sin2_theta_eff = -delGVfOverGAf / 4.0;
702 }
703 return sin2_theta_eff;
704}
705
706const double NPbase::deltaSin2thetaEff_mu_2() const
707{
708 //AG:added
709 double sin2_theta_eff_2=0.0;
710 double delGVf = deltaGV_f(leptons[MU]);
711 double delGAf = deltaGA_f(leptons[MU]);
712 double delGVf2 = deltaGV_f_2(leptons[MU]);
713 double delGAf2 = deltaGA_f_2(leptons[MU]);
714
715 bool nonZeroNP = false;
716 if (delGVf2!=0.0 || delGAf2!=0.0) {nonZeroNP = true;}
717
718 if (nonZeroNP) {
719 double gVf = trueSM.gV_f(leptons[MU]).real();
720 double gAf = trueSM.gA_f(leptons[MU]).real();
721 sin2_theta_eff_2 = 1.0/4.0 * delGVf * delGAf / pow(gAf,2.0)
722 - 1.0/4.0 * gVf * pow(delGAf,2.0) / pow(gAf,3.0)
723 - 1.0/4.0 * ( gAf*delGVf2 - gVf*delGAf2) / pow(gAf,2.0) ;
724 }
725
726 return sin2_theta_eff_2;
727}
728
729const double NPbase::deltaSin2thetaEff_mu() const
730{
731 double sin2_theta_eff = 0.;
732 double delGVf = deltaGV_f(leptons[MU]);
733 double delGAf = deltaGA_f(leptons[MU]);
734 if (delGVf != 0.0 || delGAf != 0.0) {
735 double gVf = trueSM.gV_f(leptons[MU]).real();
736 double gAf = trueSM.gA_f(leptons[MU]).real();
737 double delGVfOverGAf = (gAf * delGVf - gVf * delGAf) / gAf / gAf;
738
739 sin2_theta_eff = -delGVfOverGAf / 4.0;
740 }
741 return sin2_theta_eff;
742}
743
744const double NPbase::sin2thetaEff(const Particle f) const //AG:modified
745{
746 if (f.is("ELECTRON")){
747 //AG:begin
748 if(OutputOrder()==0){ return (trueSM.sin2thetaEff(f)); }
749 if(OutputOrder()==1){ return (trueSM.sin2thetaEff(f) + deltaSin2thetaEff_e()); }
750 if(OutputOrder()==2){ return (trueSM.sin2thetaEff(f) + deltaSin2thetaEff_e() + deltaSin2thetaEff_e_2() ); }
751 if(OutputOrder()==3){ return ( deltaSin2thetaEff_e_2() ); }
752 else
753 //AG:end
754 //AG: deltaSin2thetaEff_e_2() added below
755 return (trueSM.sin2thetaEff(f) + deltaSin2thetaEff_e() + deltaSin2thetaEff_e_2());
756 }
757 else if (f.is("MU")){
758 //AG:begin
759 if(OutputOrder()==0){ return (trueSM.sin2thetaEff(f) ); }
760 if(OutputOrder()==1){ return (trueSM.sin2thetaEff(f) + deltaSin2thetaEff_mu()); }
761 if(OutputOrder()==2){ return (trueSM.sin2thetaEff(f) + deltaSin2thetaEff_mu() + deltaSin2thetaEff_mu_2() ); }
762 if(OutputOrder()==3){ return (deltaSin2thetaEff_mu_2() ); }
763 else
764 //AG:end
765 //AG: deltaSin2thetaEff_mu_2() added below
766 return (trueSM.sin2thetaEff(f) + deltaSin2thetaEff_mu() + deltaSin2thetaEff_mu_2());
767 }
768 else
769 return (trueSM.sin2thetaEff(f));
770}
771
772const double NPbase::deltaA_f_2(const Particle f) const
773{
774 //AG:added
775 double dA_2 = 0.0;
776
777 bool nonZeroNP = false;
778 double delGVf = deltaGV_f(f);
779 double delGAf = deltaGA_f(f);
780 double delGVf2 = deltaGV_f_2(f);
781 double delGAf2 = deltaGA_f_2(f);
782 if (delGVf2!=0.0 || delGAf2!=0.0) {nonZeroNP = true;}
783
784 if (nonZeroNP) {
785 double gVf = trueSM.gV_f(f).real();
786 double gAf = trueSM.gA_f(f).real();
787 double Gf = gVf*gVf + gAf*gAf;
788
789 double f2 = -2.0 * ( gVf*gVf - gAf*gAf ) * ( gAf*delGVf2 - gVf*delGAf2) / Gf / Gf;
790 double f1 = 2.0 * ( gVf*gAf*( gAf*gAf - 3.0*gVf*gVf )*delGAf*delGAf
791 + gVf*gAf*( gVf*gVf - 3.0*gAf*gAf )*delGVf*delGVf
792 - ( pow(gAf,4.0) - 6.0*pow(gAf,2.0)*pow(gVf,2.0) + pow(gVf,4.0) )*delGVf*delGAf
793 ) / pow(Gf,3.0);
794
795 dA_2 = f1+f2;
796 }
797 return dA_2;
798}
799
800const double NPbase::deltaA_f(const Particle f) const
801{
802 double dAf = 0.;
803 double delGVf = deltaGV_f(f);
804 double delGAf = deltaGA_f(f);
805 if (delGVf != 0.0 || delGAf != 0.0) {
806 double gVf = trueSM.gV_f(f).real();
807 double gAf = trueSM.gA_f(f).real();
808 double Gf = gVf * gVf + gAf*gAf;
809 double delGVfOverGAf = (gAf * delGVf - gVf * delGAf) / gAf / gAf;
810
811 dAf = -2.0 * (gVf * gVf - gAf * gAf) * gAf * gAf / Gf / Gf*delGVfOverGAf;
812 }
813
814 return dAf;
815}
816
817const double NPbase::A_f(const Particle f) const //AG:modified
818{
819 //AG:begin
820 if(OutputOrder()==0){ return (trueSM.A_f(f) ); }
821 if(OutputOrder()==1){ return (trueSM.A_f(f) + deltaA_f(f)); }
822 if(OutputOrder()==2){ return (trueSM.A_f(f) + deltaA_f(f) + deltaA_f_2(f) ); }
823 if(OutputOrder()==3){ return ( deltaA_f_2(f) ); }
824 else
825 //AG:end
826 //AG: deltaA_f_2(f) added below
827 return (trueSM.A_f(f) + deltaA_f(f) + deltaA_f_2(f));
828}
829
830const double NPbase::deltaAFB_2(const Particle f) const
831{
832 //AG:added
833 double dAFB_2=0.0;
834
835 bool nonZeroNP = false;
836 double delGVf2 = deltaGV_f_2(f);
837 double delGAf2 = deltaGA_f_2(f);
838 if (delGVf2!=0.0 || delGAf2!=0.0) {nonZeroNP = true;}
839
840 if (nonZeroNP) {
841 /*
842 double gVe = trueSM.gV_f(leptons[ELECTRON]).real();
843 double gAe = trueSM.gA_f(leptons[ELECTRON]).real();
844 double gVf = trueSM.gV_f(f).real();
845 double gAf = trueSM.gA_f(f).real();
846
847 double Ge = gVe*gVe + gAe*gAe;
848 double delGVeOverGAe = (gVe*delGAe-gAe*delGVe) ;
849 double Gf = gVf*gVf + gAf*gAf;
850 double delGVfOverGAf = (gVf*delGAf-gAf*delGVf) ;
851
852 double Ae = 2.0*gVe*gAe/(gVe*gVe+gAe*gAe);
853 double deltaAe = deltaA_f(leptons[ELECTRON]);
854 double Af = 2.0*gVf*gAf/(gVf*gVf+gAf*gAf);
855 double deltaAf = deltaA_f(f);
856
857 dAFB_Test = 3.0 * Af/2.0 * deltaAe/2.0 + 3.0 * Ae/2.0 * deltaAf/2.0 ;*/
858
859 double gVe = trueSM.gV_f(leptons[ELECTRON]).real();
860 double gAe = trueSM.gA_f(leptons[ELECTRON]).real();
861 double gVf = trueSM.gV_f(f).real();
862 double gAf = trueSM.gA_f(f).real();
863
864 double Ae = 2.0*gVe*gAe/(gVe*gVe+gAe*gAe);
865 double deltaAe = deltaA_f(leptons[ELECTRON]);
866 double deltaAe2 = deltaA_f_2(leptons[ELECTRON]);
867 double Af = 2.0*gVf*gAf/(gVf*gVf+gAf*gAf);
868 double deltaAf = deltaA_f(f);
869 double deltaAf2 = deltaA_f_2(f);
870
871 if (f.is("ELECTRON"))
872 dAFB_2 = 3.0/4.0 * ( deltaAe*deltaAe + 2.0*Ae*deltaAe2 );
873 else
874 dAFB_2 = 3.0/4.0 * ( deltaAe*deltaAf + Ae*deltaAf2 + Af*deltaAe2 );
875 }
876 return dAFB_2;
877}
878
879const double NPbase::deltaAFB(const Particle f) const
880{
881 double dAFB = 0.;
882 double delGVf = deltaGV_f(f);
883 double delGAf = deltaGA_f(f);
884 if (f.is("ELECTRON")) {
885 if (delGVf != 0.0 || delGAf != 0.0) {
886 double gVe = trueSM.gV_f(f).real();
887 double gAe = trueSM.gA_f(f).real();
888 double Ge = gVe * gVe + gAe*gAe;
889 double delGVeOverGAe = (gAe * delGVf - gVe * delGAf) / gAe / gAe;
890 dAFB = -6.0 * gVe * gAe * (gVe * gVe - gAe * gAe) * gAe * gAe / Ge / Ge / Ge*delGVeOverGAe;
891 }
892 } else {
893 double delGVe = deltaGV_f(leptons[ELECTRON]);
894 double delGAe = deltaGA_f(leptons[ELECTRON]);
895 if (delGVe != 0.0 || delGAe != 0.0 || delGVf != 0.0 || delGAf != 0.0) {
896 double gVe = trueSM.gV_f(leptons[ELECTRON]).real();
897 double gAe = trueSM.gA_f(leptons[ELECTRON]).real();
898 double Ge = gVe * gVe + gAe*gAe;
899 double delGVeOverGAe = (gAe * delGVe - gVe * delGAe) / gAe / gAe;
900 //
901 double gVf = trueSM.gV_f(f).real();
902 double gAf = trueSM.gA_f(f).real();
903 double Gf = gVf * gVf + gAf*gAf;
904 double delGVfOverGAf = (gAf * delGVf - gVf * delGAf) / gAf / gAf;
905
906 dAFB = -(3.0 * gVf * gAf * (gVe * gVe - gAe * gAe) * gAe * gAe / Gf / Ge / Ge * delGVeOverGAe
907 + 3.0 * gVe * gAe * (gVf * gVf - gAf * gAf) * gAf * gAf / Ge / Gf / Gf * delGVfOverGAf);
908 }
909 }
910
911 return dAFB;
912}
913
914const double NPbase::AFB(const Particle f) const //AG:modified
915{
916 //AG: begin
917 if(OutputOrder()==0){ return (trueSM.AFB(f) ); }
918 if(OutputOrder()==1){ return (trueSM.AFB(f) + deltaAFB(f)); }
919 if(OutputOrder()==2){ return (trueSM.AFB(f) + deltaAFB(f) + deltaAFB_2(f) ); }
920 if(OutputOrder()==3){ return ( deltaAFB_2(f) ); }
921 else
922 //AG:end
923 //AG: deltaAFB_2(f) added below
924 return (trueSM.AFB(f) + deltaAFB(f) + deltaAFB_2(f));
925}
926
927const double NPbase::deltaR0_f_2(const Particle f) const
928{
929 //AG:added
930 double dR0_f_2 = 0.;
931 double delGVl2=0.0, delGAl2=0.0, delGVq2[6], delGAq2[6];
932 bool nonZeroNP = false;
933 if (f.is("LEPTON")) {
934 delGAl2 = deltaGA_f_2(f);
935 delGVl2 = deltaGV_f_2(f);
936 if (delGVl2!=0.0 || delGAl2!=0.0) {nonZeroNP = true;}
937 }
938 for (int q = 0; q < 6; ++q) {
939 delGVq2[q] = deltaGV_f_2(quarks[q]);
940 delGAq2[q] = deltaGA_f_2(quarks[q]);
941 if (delGVq2[q]!=0.0 || delGAq2[q]!=0.0) {nonZeroNP = true;}
942 }
943
944 if (nonZeroNP) {
945 //double prefactor = 4.0 * GF*pow(Mz,3.0)/24.0/sqrt(2.0)/M_PI; // It will cancel in the ratio either way
946 double prefactor = alphaMz()*Mz / 12.0 / trueSM.sW2()/trueSM.cW2();
947
948 double Gamma_l_SMtree = 1.0 * prefactor * ( pow(trueSM.gV_f(f).real(),2.0) + pow(trueSM.gA_f(f).real(),2.0) );
949 double Gamma_q_SMtree = 3.0 * prefactor * ( pow(trueSM.gV_f(f).real(),2.0) + pow(trueSM.gA_f(f).real(),2.0) );
950
951 double Gamma_had_SMtree = 0.0;
952 for (int q = 0; q < 6; ++q) {
953 Gamma_had_SMtree += 3.0 * prefactor * ( pow(trueSM.gV_f(quarks[q]).real(),2.0) + pow(trueSM.gA_f(quarks[q]).real(),2.0) );
954 };
955
956 double deltaGamma_f = deltaGamma_Zf(f);
957 double deltaGamma_had = deltaGamma_Zhad();
958
959 double deltaGamma_f_2 = deltaGamma_Zf_2(f);
960 double deltaGamma_had_2 = deltaGamma_Zhad_2();
961
962 // There may be s mistake in the charged leptons case:
963 if(f.is("ELECTRON") || f.is("MU") || f.is("TAU")){
964 dR0_f_2 = Gamma_had_SMtree*pow(deltaGamma_f,2.0) / pow(Gamma_l_SMtree,3.0)
965 - deltaGamma_had*deltaGamma_f / pow(Gamma_l_SMtree,2.0)
966 + (Gamma_l_SMtree*deltaGamma_had_2-Gamma_had_SMtree*deltaGamma_f_2) / pow(Gamma_l_SMtree,2.0);
967 }
968 if(f.is("NEUTRINO_1") || f.is("NEUTRINO_2") || f.is("NEUTRINO_3")){
969 dR0_f_2 = Gamma_l_SMtree*pow(deltaGamma_had,2.0) / pow(Gamma_had_SMtree,3.0)
970 - deltaGamma_f*deltaGamma_had / pow(Gamma_had_SMtree,2.0)
971 + (Gamma_had_SMtree*deltaGamma_f_2-Gamma_l_SMtree*deltaGamma_had_2) / pow(Gamma_had_SMtree,2.0);
972 }
973 if(f.is("QUARK")){
974 dR0_f_2 = Gamma_q_SMtree*pow(deltaGamma_had,2.0) / pow(Gamma_had_SMtree,3.0)
975 - deltaGamma_f*deltaGamma_had / pow(Gamma_had_SMtree,2.0)
976 + (Gamma_had_SMtree*deltaGamma_f_2-Gamma_q_SMtree*deltaGamma_had_2) / pow(Gamma_had_SMtree,2.0);
977 }
978 }
979
980 return dR0_f_2;
981}
982
983const double NPbase::deltaR0_f(const Particle f) const
984{
985 double dR0_f = 0., delGVl = 0., delGAl = 0., deltaGl = 0., Gl = 0.;
986 bool nonZeroNP = false;
987 if (f.is("LEPTON")) {
988 delGVl = deltaGV_f(f);
989 delGAl = deltaGA_f(f);
990 if (delGVl != 0.0 || delGAl != 0.0) nonZeroNP = true;
991 }
992
993 double delGVq[6], delGAq[6];
994 for (int q = 0; q < 6; ++q) {
995 delGVq[q] = deltaGV_f(quarks[q]);
996 delGAq[q] = deltaGA_f(quarks[q]);
997 if (delGVq[q] != 0.0 || delGAq[q] != 0.0) nonZeroNP = true;
998 }
999
1000 if (nonZeroNP) {
1001 double CF = 1.;
1002 if (f.is("LEPTON")) {
1003 double gVl = trueSM.gV_f(f).real();
1004 double gAl = trueSM.gA_f(f).real();
1005 Gl = gVl * gVl + gAl*gAl;
1006 deltaGl = 2.0 * (gVl * delGVl + gAl * delGAl);
1007 CF = 3.;
1008 }
1009 double Gq[6], deltaGq[6];
1010 double gVq, gAq;
1011 double Gq_sum = 0.0, delGq_sum = 0.0;
1012 for (int q = 0; q < 6; ++q) {
1013 gVq = trueSM.gV_f(quarks[q]).real();
1014 gAq = trueSM.gA_f(quarks[q]).real();
1015 Gq[q] = gVq * gVq + gAq*gAq;
1016 deltaGq[q] = 2.0 * (gVq * delGVq[q] + gAq * delGAq[q]);
1017
1018 Gq_sum += CF * Gq[q];
1019 delGq_sum += CF * deltaGq[q];
1020 }
1021 if (f.is("LEPTON"))
1022 if ( f.is("NEUTRINO_1") || f.is("NEUTRINO_2") || f.is("NEUTRINO_3") ) {
1023 dR0_f = deltaGl / Gq_sum - Gl * delGq_sum / Gq_sum / Gq_sum;
1024 } else {
1025 dR0_f = delGq_sum / Gl - Gq_sum * deltaGl / Gl / Gl;
1026 }
1027 else
1028 dR0_f = deltaGq[f.getIndex() - 6] / Gq_sum
1029 - Gq[f.getIndex() - 6] * delGq_sum / Gq_sum / Gq_sum;
1030 }
1031 return dR0_f;
1032}
1033
1034const double NPbase::R0_f(const Particle f) const //AG:modified
1035{
1036 //AG:begin
1037 if(OutputOrder()==0){ return (trueSM.R0_f(f) ); }
1038 if(OutputOrder()==1){ return (trueSM.R0_f(f) + deltaR0_f(f)); }
1039 if(OutputOrder()==2){ return (trueSM.R0_f(f) + deltaR0_f(f) + deltaR0_f_2(f) ); }
1040 if(OutputOrder()==3){ return ( deltaR0_f_2(f) ); }
1041 else
1042 //AG:end
1043 //AG: deltaR0_f_2(f) added below
1044 return (trueSM.R0_f(f) + deltaR0_f(f) + deltaR0_f_2(f));
1045}
1046
1047const double NPbase::deltaR_inv() const
1048{
1049 double dR_inv = 0., delGVe = 0., delGAe = 0., deltaGe = 0., Ge = 0.;
1050 bool nonZeroNP = false;
1051
1052 delGVe = deltaGV_f(leptons[ELECTRON]);
1053 delGAe = deltaGA_f(leptons[ELECTRON]);
1054 if (delGVe != 0.0 || delGAe != 0.0) nonZeroNP = true;
1055
1056 double delGVnu[3], delGAnu[3];
1057 for (int p = 0; p < 3; ++p) {
1058 delGVnu[p] = deltaGV_f(leptons[2*p]);
1059 delGAnu[p] = deltaGA_f(leptons[2*p]);
1060 if (delGVnu[p] != 0.0 || delGAnu[p] != 0.0 ) nonZeroNP = true;
1061 }
1062
1063 if (nonZeroNP) {
1064
1065 double gVe = trueSM.gV_f(leptons[ELECTRON]).real();
1066 double gAe = trueSM.gA_f(leptons[ELECTRON]).real();
1067 Ge = gVe * gVe + gAe * gAe;
1068 deltaGe = 2.0 * (gVe * delGVe + gAe * delGAe);
1069
1070 double Gnu[3], deltaGnu[3];
1071 double gVnu, gAnu;
1072 double Gnu_sum = 0.0, delGnu_sum = 0.0;
1073 for (int p = 0; p < 3; ++p) {
1074 gVnu = trueSM.gV_f(leptons[2*p]).real();
1075 gAnu = trueSM.gA_f(leptons[2*p]).real();
1076
1077
1078 Gnu[p] = gVnu * gVnu + gAnu * gAnu;
1079
1080 deltaGnu[p] = 2.0 * (gVnu * delGVnu[p] + gAnu * delGAnu[p]);
1081
1082 Gnu_sum += Gnu[p];
1083 delGnu_sum += deltaGnu[p];
1084 }
1085
1086 dR_inv = delGnu_sum / Ge - Gnu_sum * deltaGe / Ge / Ge;
1087 }
1088 return dR_inv;
1089}
1090
1091const double NPbase::R_inv() const
1092{
1093 return ( trueSM.R_inv() + deltaR_inv() );
1094}
1095
1096
1097const double NPbase::deltaN_nu() const
1098{
1099 double dNnu = 0.0;
1100 double dGl1, dGl2, dGl3, dGl, dGinv;
1101 double Gl1, Gl2, Gl3, Gl, Ginv;
1102 double dRl1, dRl2, dRl3, dRl;
1103 double Rl1, Rl2, Rl3, Rl;
1104 double shad0;
1105
1106 dGl1 = deltaGamma_Zf(leptons[ELECTRON]);
1107 dGl2 = deltaGamma_Zf(leptons[MU]);
1108 dGl3 = deltaGamma_Zf(leptons[TAU]);
1109
1110 dGl = (1.0/3.0) * (dGl1 + dGl2 + dGl3);
1111
1112 Gl1 = trueSM.GammaZ(leptons[ELECTRON]);
1113 Gl2 = trueSM.GammaZ(leptons[MU]);
1114 Gl3 = trueSM.GammaZ(leptons[TAU]);
1115
1116 Gl = (1.0/3.0) * (Gl1 + Gl2 + Gl3);
1117
1118 dGinv = deltaGamma_Zf(leptons[NEUTRINO_1]) +
1119 deltaGamma_Zf(leptons[NEUTRINO_2]) +
1120 deltaGamma_Zf(leptons[NEUTRINO_3]);
1121
1122 Ginv = trueSM.GammaZ(leptons[NEUTRINO_1]) +
1123 trueSM.GammaZ(leptons[NEUTRINO_2]) +
1124 trueSM.GammaZ(leptons[NEUTRINO_3]);
1125
1126 dRl1 = deltaR0_f(leptons[ELECTRON]);
1127 dRl2 = deltaR0_f(leptons[MU]);
1128 dRl3 = deltaR0_f(leptons[TAU]);
1129
1130 dRl = (1.0/3.0) * (dRl1 + dRl2 + dRl3);
1131
1132 Rl1 = trueSM.R0_f(leptons[ELECTRON]);
1133 Rl2 = trueSM.R0_f(leptons[MU]);
1134 Rl3 = trueSM.R0_f(leptons[TAU]);
1135
1136 Rl = (1.0/3.0) * (Rl1 + Rl2 + Rl3);
1137
1138 shad0 = trueSM.sigma0_had();
1139
1140 dNnu = (trueSM.N_nu())*( dGl/Gl - dGinv/Ginv ) -
1141 3.0*(Gl/Ginv)*dRl +
1142 (Gl/Ginv)*sqrt(3.0*M_PI*Rl/Mz/Mz/shad0)*(-3.0*deltaSigmaHadron()/shad0 + 3.0* dRl/Rl);
1143
1144 return dNnu;
1145}
1146
1147const double NPbase::N_nu() const
1148{
1149 return ( trueSM.N_nu() + deltaN_nu() );
1150}
1151
1152
1153
1154//LEP2 Observables
1155
1156
1157const double NPbase::delta_Dsigma_f(const Particle f, const double pol_e, const double pol_p, const double s, const double cos) const
1158{
1159 return 0.0;
1160}
1161
1162const double NPbase::delta_sigma_f(const Particle f, const double pol_e, const double pol_p, const double s, const double cosmin, const double cosmax) const
1163{
1164 return 0.0;
1165}
1166
1167const double NPbase::delta_sigma_had(const double s, const double pol_e, const double pol_p, const double cosmin, const double cosmax) const
1168{
1169 return 0.0;
1170}
1171
1172// Total cross sections (full acceptance)
1173const double NPbase::delta_sigmaTot_f(const Particle f, const double pol_e, const double pol_p, const double s) const
1174{
1175 return 0.0;
1176}
1177
1178// Forward-Backward asymmetry (full acceptance). Valid for f!=e
1179const double NPbase::delta_AFB_f(const Particle f, const double pol_e, const double pol_p, const double s) const
1180{
1181 return 0.0;
1182}
1183
1184// Expressions for f=e
1185
1186const double NPbase::sigmaSM_ee(const double pol_e, const double pol_p, const double s, const double cosmin, const double cosmax) const
1187{
1188 return 0.0;
1189}
1190
1191const double NPbase::delta_sigma_ee(const double pol_e, const double pol_p, const double s, const double cosmin, const double cosmax) const
1192{
1193 return 0.0;
1194}
1195
1196const double NPbase::delta_sigmaTot_ee(const double pol_e, const double pol_p, const double s) const
1197{
1198 return 0.0;
1199}
1200
1201const double NPbase::delta_AFB_ee(const double pol_e, const double pol_p, const double s) const
1202{
1203 return 0.0;
1204}
1205
1206// Extension of SM observable definitions
1207
1208// Cross sections
1209const double NPbase::eeffsigmaE(const double pol_e, const double pol_p, const double s) const
1210{
1211 return (trueSM.eeffsigmaE(pol_e, pol_p, s) + delta_sigmaTot_ee(pol_e, pol_p, s));
1212}
1213const double NPbase::eeffsigmaEtsub(const double pol_e, const double pol_p, const double s) const
1214{
1215 return (trueSM.eeffsigmaEtsub(pol_e, pol_p, s) + delta_sigmaTot_ee(pol_e, pol_p, s));
1216}
1217const double NPbase::eeffsigmaMu(const double pol_e, const double pol_p, const double s) const
1218{
1219 return (trueSM.eeffsigmaMu(pol_e, pol_p, s) + delta_sigmaTot_f(leptons[MU], pol_e, pol_p, s));
1220}
1221const double NPbase::eeffsigmaTau(const double pol_e, const double pol_p, const double s) const
1222{
1223 return (trueSM.eeffsigmaTau(pol_e, pol_p, s) + delta_sigmaTot_f(leptons[TAU], pol_e, pol_p, s));
1224}
1225const double NPbase::eeffsigmaHadron(const double pol_e, const double pol_p, const double s) const
1226{
1227 return (trueSM.eeffsigmaHadron(pol_e, pol_p, s) + delta_sigma_had(pol_e, pol_p, s, -1.0, 1.0));
1228}
1229const double NPbase::eeffsigmaStrange(const double pol_e, const double pol_p, const double s) const
1230{
1231 return (trueSM.eeffsigmaStrange(pol_e, pol_p, s) + delta_sigmaTot_f(quarks[STRANGE], pol_e, pol_p, s));
1232}
1233const double NPbase::eeffsigmaCharm(const double pol_e, const double pol_p, const double s) const
1234{
1235 return (trueSM.eeffsigmaCharm(pol_e, pol_p, s) + delta_sigmaTot_f(quarks[CHARM], pol_e, pol_p, s));
1236}
1237const double NPbase::eeffsigmaBottom(const double pol_e, const double pol_p, const double s) const
1238{
1239 return (trueSM.eeffsigmaBottom(pol_e, pol_p, s) + delta_sigmaTot_f(quarks[BOTTOM], pol_e, pol_p, s));
1240}
1241
1242// Ratios of cross sections
1243const double NPbase::eeffRelectron(const double pol_e, const double pol_p, const double s) const
1244{
1245 double sigmaHadSM = trueSM.eeffsigmaHadron(pol_e, pol_p, s);
1246 double sigmaffSM = trueSM.eeffsigmaE(pol_e, pol_p, s);
1247 double Rf;
1248
1249 Rf = trueSM.eeffRelectron(pol_e, pol_p, s)
1250 + delta_sigma_had(pol_e, pol_p, s, -1.0, 1.0) / sigmaffSM
1251 - delta_sigmaTot_ee(pol_e, pol_p, s) * sigmaHadSM / sigmaffSM / sigmaffSM;
1252
1253 return Rf;
1254}
1255const double NPbase::eeffRelectrontsub(const double pol_e, const double pol_p, const double s) const
1256{
1257 double sigmaHadSM = trueSM.eeffsigmaHadron(pol_e, pol_p, s);
1258 double sigmaffSM = trueSM.eeffsigmaEtsub(pol_e, pol_p, s);
1259 double Rf;
1260
1261 Rf = trueSM.eeffRelectrontsub(pol_e, pol_p, s)
1262 + delta_sigma_had(pol_e, pol_p, s, -1.0, 1.0) / sigmaffSM
1263 - delta_sigmaTot_ee(pol_e, pol_p, s) * sigmaHadSM / sigmaffSM / sigmaffSM;
1264
1265 return Rf;
1266}
1267const double NPbase::eeffRmuon(const double pol_e, const double pol_p, const double s) const
1268{
1269 double sigmaHadSM = trueSM.eeffsigmaHadron(pol_e, pol_p, s);
1270 double sigmaffSM = trueSM.eeffsigmaMu(pol_e, pol_p, s);
1271 double Rf;
1272
1273 Rf = trueSM.eeffRmuon(pol_e, pol_p, s)
1274 + delta_sigma_had(pol_e, pol_p, s, -1.0, 1.0) / sigmaffSM
1275 - delta_sigmaTot_f(leptons[MU], pol_e, pol_p, s) * sigmaHadSM / sigmaffSM / sigmaffSM;
1276
1277 return Rf;
1278}
1279const double NPbase::eeffRtau(const double pol_e, const double pol_p, const double s) const
1280{
1281 double sigmaHadSM = trueSM.eeffsigmaHadron(pol_e, pol_p, s);
1282 double sigmaffSM = trueSM.eeffsigmaTau(pol_e, pol_p, s);
1283 double Rf;
1284
1285 Rf = trueSM.eeffRtau(pol_e, pol_p, s)
1286 + delta_sigma_had(pol_e, pol_p, s, -1.0, 1.0) / sigmaffSM
1287 - delta_sigmaTot_f(leptons[TAU], pol_e, pol_p, s) * sigmaHadSM / sigmaffSM / sigmaffSM;
1288
1289 return Rf;
1290}
1291const double NPbase::eeffRstrange(const double pol_e, const double pol_p, const double s) const
1292{
1293 double sigmaHadSM = trueSM.eeffsigmaHadron(pol_e, pol_p, s);
1294 double sigmaffSM = trueSM.eeffsigmaStrange(pol_e, pol_p, s);
1295 double Rf;
1296
1297 Rf = trueSM.eeffRstrange(pol_e, pol_p, s)
1298 + delta_sigmaTot_f(quarks[STRANGE], pol_e, pol_p, s) / sigmaHadSM
1299 - delta_sigma_had(pol_e, pol_p, s, -1.0, 1.0) * sigmaffSM / sigmaHadSM / sigmaHadSM;
1300
1301 return Rf;
1302}
1303const double NPbase::eeffRcharm(const double pol_e, const double pol_p, const double s) const
1304{
1305 double sigmaHadSM = trueSM.eeffsigmaHadron(pol_e, pol_p, s);
1306 double sigmaffSM = trueSM.eeffsigmaCharm(pol_e, pol_p, s);
1307 double Rf;
1308
1309 Rf = trueSM.eeffRcharm(pol_e, pol_p, s)
1310 + delta_sigmaTot_f(quarks[CHARM], pol_e, pol_p, s) / sigmaHadSM
1311 - delta_sigma_had(pol_e, pol_p, s, -1.0, 1.0) * sigmaffSM / sigmaHadSM / sigmaHadSM;
1312
1313 return Rf;
1314}
1315const double NPbase::eeffRbottom(const double pol_e, const double pol_p, const double s) const
1316{
1317 double sigmaHadSM = trueSM.eeffsigmaHadron(pol_e, pol_p, s);
1318 double sigmaffSM = trueSM.eeffsigmaBottom(pol_e, pol_p, s);
1319 double Rf;
1320
1321 Rf = trueSM.eeffRbottom(pol_e, pol_p, s)
1322 + delta_sigmaTot_f(quarks[BOTTOM], pol_e, pol_p, s) / sigmaHadSM
1323 - delta_sigma_had(pol_e, pol_p, s, -1.0, 1.0) * sigmaffSM / sigmaHadSM / sigmaHadSM;
1324
1325 return Rf;
1326}
1327
1328
1329// Asymmetries
1330const double NPbase::eeffAFBe(const double pol_e, const double pol_p, const double s) const
1331{
1332 return (trueSM.eeffAFBe(pol_e, pol_p, s) + delta_AFB_ee(pol_e, pol_p, s));
1333}
1334const double NPbase::eeffAFBetsub(const double pol_e, const double pol_p, const double s) const
1335{
1336 return (trueSM.eeffAFBetsub(pol_e, pol_p, s) + delta_AFB_ee(pol_e, pol_p, s));
1337}
1338const double NPbase::eeffAFBmu(const double pol_e, const double pol_p, const double s) const
1339{
1340 return (trueSM.eeffAFBmu(pol_e, pol_p, s) + delta_AFB_f(leptons[MU], pol_e, pol_p, s));
1341}
1342const double NPbase::eeffAFBtau(const double pol_e, const double pol_p, const double s) const
1343{
1344 return (trueSM.eeffAFBtau(pol_e, pol_p, s) + delta_AFB_f(leptons[TAU], pol_e, pol_p, s));
1345}
1346const double NPbase::eeffAFBstrange(const double pol_e, const double pol_p, const double s) const
1347{
1348 return (trueSM.eeffAFBstrange(pol_e, pol_p, s) + delta_AFB_f(quarks[STRANGE], pol_e, pol_p, s));
1349}
1350const double NPbase::eeffAFBcharm(const double pol_e, const double pol_p, const double s) const
1351{
1352 return (trueSM.eeffAFBcharm(pol_e, pol_p, s) + delta_AFB_f(quarks[CHARM], pol_e, pol_p, s));
1353}
1354const double NPbase::eeffAFBbottom(const double pol_e, const double pol_p, const double s) const
1355{
1356 return (trueSM.eeffAFBbottom(pol_e, pol_p, s) + delta_AFB_f(quarks[BOTTOM], pol_e, pol_p, s));
1357}
1358
1359
1360 // LEP2 specific
1361const double NPbase::LEP2sigmaE(const double s) const
1362{
1363 return (trueSM.LEP2sigmaE(s) + delta_sigmaTot_ee(0., 0., s));
1364}
1365
1366const double NPbase::LEP2sigmaMu(const double s) const
1367{
1368 return (trueSM.LEP2sigmaMu(s) + delta_sigmaTot_f(leptons[MU], 0., 0., s));
1369}
1370
1371const double NPbase::LEP2sigmaTau(const double s) const
1372{
1373 return (trueSM.LEP2sigmaTau(s) + delta_sigmaTot_f(leptons[TAU], 0., 0., s));
1374}
1375
1376const double NPbase::LEP2sigmaHadron(const double s) const
1377{
1378 return (trueSM.LEP2sigmaHadron(s) + delta_sigma_had(0., 0., s, -1.0, 1.0));
1379}
1380
1381const double NPbase::LEP2sigmaCharm(const double s) const
1382{
1383 return (trueSM.LEP2sigmaCharm(s) + delta_sigmaTot_f(quarks[CHARM], 0., 0., s));
1384}
1385
1386const double NPbase::LEP2sigmaBottom(const double s) const
1387{
1388 return (trueSM.LEP2sigmaBottom(s) + delta_sigmaTot_f(quarks[BOTTOM], 0., 0., s));
1389}
1390
1391const double NPbase::LEP2AFBe(const double s) const
1392{
1393 return (trueSM.LEP2AFBe(s) + delta_AFB_ee(0., 0., s));
1394}
1395
1396const double NPbase::LEP2AFBmu(const double s) const
1397{
1398 return (trueSM.LEP2AFBmu(s) + delta_AFB_f(leptons[MU], 0., 0., s));
1399}
1400
1401const double NPbase::LEP2AFBtau(const double s) const
1402{
1403 return (trueSM.LEP2AFBtau(s) + delta_AFB_f(leptons[TAU], 0., 0., s));
1404}
1405
1406const double NPbase::LEP2AFBcharm(const double s) const
1407{
1408 return (trueSM.LEP2AFBcharm(s) + delta_AFB_f(quarks[CHARM], 0., 0., s));
1409}
1410
1411const double NPbase::LEP2AFBbottom(const double s) const
1412{
1413 return (trueSM.LEP2AFBbottom(s) + delta_AFB_f(quarks[BOTTOM], 0., 0., s));
1414}
1415
1416const double NPbase::LEP2Rcharm(const double s) const
1417{
1418 return (trueSM.LEP2Rcharm(s));
1419}
1420
1421const double NPbase::LEP2Rbottom(const double s) const
1422{
1423 return (trueSM.LEP2Rbottom(s));
1424}
1425
1426const double NPbase::LEP2dsigmadcosE(const double s, const double cos) const
1427{
1428 return (trueSM.LEP2dsigmadcosE(s,cos) + delta_Dsigma_f(leptons[ELECTRON], 0., 0., s, cos));
1429}
1430
1431const double NPbase::LEP2dsigmadcosMu(const double s, const double cos) const
1432{
1433 return (trueSM.LEP2dsigmadcosMu(s,cos) + delta_Dsigma_f(leptons[MU], 0., 0., s, cos) );
1434}
1435
1436const double NPbase::LEP2dsigmadcosTau(const double s, const double cos) const
1437{
1438 return (trueSM.LEP2dsigmadcosTau(s,cos) + delta_Dsigma_f(leptons[TAU], 0., 0., s, cos) );
1439}
1440
1441const double NPbase::LEP2dsigmadcosBinE(const double s, const double cos, const double cosmin, const double cosmax) const
1442{
1443 double Deltacos = fabs(cosmax-cosmin); // Bin width
1444
1445 // Compute differential cross section as the cross section in the bin/Delta cos (see e.g. hep-ex/0512012)
1446 return (trueSM.LEP2dsigmadcosBinE(s,cos,cosmin,cosmax) + delta_sigma_ee(0., 0., s, cosmin, cosmax) / Deltacos );
1447}
1448
1449const double NPbase::LEP2dsigmadcosBinMu(const double s, const double cos, const double cosmin, const double cosmax) const
1450{
1451 double Deltacos = fabs(cosmax-cosmin); // Bin width
1452
1453 // Compute differential cross section as the cross section in the bin/Delta cos (see e.g. hep-ex/0512012)
1454 return (trueSM.LEP2dsigmadcosBinMu(s,cos,cosmin,cosmax) + delta_sigma_f(leptons[MU], 0., 0., s, cosmin, cosmax) / Deltacos );
1455}
1456
1457const double NPbase::LEP2dsigmadcosBinTau(const double s, const double cos, const double cosmin, const double cosmax) const
1458{
1459 double Deltacos = fabs(cosmax-cosmin);
1460
1461 // Compute differential cross section as the cross section in the bin/Delta cos (see e.g. hep-ex/0512012)
1462 return (trueSM.LEP2dsigmadcosBinTau(s,cos,cosmin,cosmax) + delta_sigma_f(leptons[TAU], 0., 0., s, cosmin, cosmax) / Deltacos );
1463}
1464
1465
1466// EW low-energy observables: Muon g-2
1467
1468const double NPbase::delta_amuon() const
1469{
1470 return 0.;
1471}
1472
1473// EW low-energy observables: Parity violation
1474
1475const double NPbase::delta_Qwemoller(const double q2, const double y) const
1476{
1477 return 0.;
1478}
1479
1480
1481const double NPbase::delta_alrmoller(const double q2, const double y) const
1482{
1483 return 0.;
1484}
1485
1486
1487const double NPbase::delta_Qwp() const
1488{
1489 return 0.;
1490}
1491
1492
1493const double NPbase::delta_Qwn() const
1494{
1495 return 0.;
1496}
1497
1498const double NPbase::delta_gLnuN2() const
1499{
1500 return 0.;
1501}
1502
1503const double NPbase::delta_gRnuN2() const
1504{
1505 return 0.;
1506}
1507
1508const double NPbase::delta_gVnue() const
1509{
1510 return 0.;
1511}
1512
1513const double NPbase::delta_gAnue() const
1514{
1515 return 0.;
1516}
1517
1518
1519// Extension of SM observable definitions
1520const double NPbase::amuon() const
1521{
1522 return (trueSM.amuon() + delta_amuon());
1523}
1524
1525const double NPbase::Qwemoller(const double q2, const double y) const
1526{
1527 return (trueSM.Qwemoller(q2,y) + delta_Qwemoller(q2,y));
1528}
1529
1530const double NPbase::alrmoller(const double q2, const double y) const
1531{
1532 return (trueSM.alrmoller(q2,y) + delta_alrmoller(q2,y));
1533}
1534
1535const double NPbase::Qwp() const
1536{
1537 return (trueSM.Qwp() + delta_Qwp());
1538}
1539
1540const double NPbase::Qwn() const
1541{
1542 return (trueSM.Qwn() + delta_Qwn());
1543}
1544
1545const double NPbase::gLnuN2() const
1546{
1547 return (trueSM.gLnuN2() + delta_gLnuN2());
1548}
1549
1550const double NPbase::gRnuN2() const
1551{
1552 return (trueSM.gRnuN2() + delta_gRnuN2());
1553}
1554
1555const double NPbase::gVnue() const
1556{
1557 return (trueSM.gVnue() + delta_gVnue());
1558}
1559
1560const double NPbase::gAnue() const
1561{
1562 return (trueSM.gAnue() + delta_gAnue());
1563}
1564
1566// Lepton decays
1567
1568// Lepton Flavor universality tests in Tau decays
1569
1570const double NPbase::delta_TauLFU_gmuge() const
1571{
1572 return 0.;
1573}
1574
1575const double NPbase::delta_TauLFU_gtaugmu() const
1576{
1577 return 0.;
1578}
1579
1580const double NPbase::delta_TauLFU_gtauge() const
1581{
1582 return 0.;
1583}
1584
1585const double NPbase::delta_TauLFU_gtaugmuPi() const
1586{
1587 return 0.;
1588}
1589
1590const double NPbase::delta_TauLFU_gtaugmuK() const
1591{
1592 return 0.;
1593}
1594
1595// Extension of SM observable definitions
1596const double NPbase::TauLFU_gmuge() const
1597{
1598 return (trueSM.TauLFU_gmuge() + delta_TauLFU_gmuge());
1599}
1600
1601const double NPbase::TauLFU_gtaugmu() const
1602{
1603 return (trueSM.TauLFU_gtaugmu() + delta_TauLFU_gtaugmu());
1604}
1605
1606const double NPbase::TauLFU_gtauge() const
1607{
1608 return (trueSM.TauLFU_gtauge() + delta_TauLFU_gtauge());
1609}
1610
1611const double NPbase::TauLFU_gtaugmuPi() const
1612{
1613 return (trueSM.TauLFU_gtaugmuPi() + delta_TauLFU_gtaugmuPi());
1614}
1615
1616const double NPbase::TauLFU_gtaugmuK() const
1617{
1618 return (trueSM.TauLFU_gtaugmuK() + delta_TauLFU_gtaugmuK());
1619}
1620
1621
1622// Higgs-related definitions
1623
1624const double NPbase::C1Htot() const
1625{
1626 return ( (trueSM.computeBrHtogg() * C1Hgg) + (trueSM.computeBrHtoWW() * C1HWW) + (trueSM.computeBrHtoZZ() * C1HZZ) + (trueSM.computeBrHtogaga() * C1Hgaga) );
1627 //+ trueSM.computeBrHtoZga() * 0.0 + trueSM.computeBrHtomumu() * 0.0 + trueSM.computeBrHtotautau() * 0.0 + trueSM.computeBrHtocc() * 0.0 + trueSM.computeBrHtoss() * 0.0 + trueSM.computeBrHtobb() * 0.0
1628}
1629
1630const double NPbase::C1eeZH(const double sqrt_s) const
1631{
1632 double C1;
1633
1634 if (sqrt_s <= 0.240) {
1635
1636 C1 = 0.0173302;
1637
1638 } else if (sqrt_s == 0.250) {
1639
1640 C1 = 0.015;
1641
1642 } else if (sqrt_s == 0.350) {
1643
1644 C1 = 0.0057;
1645
1646 } else if (sqrt_s == 0.365) {
1647
1648 C1 = 0.00493549;
1649
1650 } else if (sqrt_s == 0.380) {
1651
1652 C1 = 0.0057; // Use same as 350 GeV
1653
1654 } else if ((sqrt_s == 0.500)||(sqrt_s == 0.550) ) {
1655
1656 C1 = 0.00099;
1657
1658 } else if (sqrt_s == 1.0) {
1659
1660 C1 = -0.0012;
1661
1662 } else if (sqrt_s == 1.4) {
1663
1664 C1 = -0.0011;
1665
1666 } else if (sqrt_s == 1.5) {
1667
1668 C1 = -0.0011; // Use the same as 1400 GeV
1669
1670 } else if (sqrt_s == 3.0) {
1671
1672 C1 = -0.00054;
1673
1674 } else
1675 throw std::runtime_error("Bad argument in NPbase::C1eeZH");
1676
1677 return C1;
1678}
1679
1680const double NPbase::C1eeWBF(const double sqrt_s) const
1681{
1682 double C1;
1683
1684 if (sqrt_s == 0.240) {
1685
1686 C1 = 0.00639683;
1687
1688 } else if (sqrt_s == 0.250) {
1689
1690 C1 = 0.0064;
1691
1692 } else if (sqrt_s == 0.350) {
1693
1694 C1 = 0.0062;
1695
1696 } else if (sqrt_s == 0.365) {
1697
1698 C1 = 0.00618352;
1699
1700 } else if (sqrt_s == 0.380) {
1701
1702 C1 = 0.0062;
1703
1704 } else if (sqrt_s == 0.500) {
1705
1706 C1 = 0.0061;
1707
1708 } else if (sqrt_s == 1.0) {
1709
1710 C1 = 0.0059;
1711
1712 } else if (sqrt_s == 1.4) {
1713
1714 C1 = 0.0058;
1715
1716 } else if (sqrt_s == 1.5) {
1717
1718 C1 = 0.0058;
1719
1720 } else if (sqrt_s == 3.0) {
1721
1722 C1 = 0.0057;
1723
1724 } else
1725 throw std::runtime_error("Bad argument in NPbase::C1eeWBF");
1726
1727 return C1;
1728}
1729
1730const double NPbase::C1eeHvv(const double sqrt_s) const
1731{
1732 double C1;
1733
1734 if (sqrt_s == 0.240) {
1735
1736 C1 = 0.00639683;
1737
1738 } else if (sqrt_s == 0.250) {
1739
1740 C1 = 0.0064;
1741
1742 } else if (sqrt_s == 0.350) {
1743
1744 C1 = 0.0062;
1745
1746 } else if (sqrt_s == 0.365) {
1747
1748 C1 = 0.00618352;
1749
1750 } else if (sqrt_s == 0.380) {
1751
1752 C1 = 0.0062;
1753
1754 } else if (sqrt_s == 0.500) {
1755
1756 C1 = 0.0061;
1757
1758 } else if (sqrt_s == 1.0) {
1759
1760 C1 = 0.0059;
1761
1762 } else if (sqrt_s == 1.4) {
1763
1764 C1 = 0.0058;
1765
1766 } else if (sqrt_s == 1.5) {
1767
1768 C1 = 0.0058;
1769
1770 } else if (sqrt_s == 3.0) {
1771
1772 C1 = 0.0057;
1773
1774 } else
1775 throw std::runtime_error("Bad argument in NPbase::C1eeHvv");
1776
1777 return C1;
1778}
1779
1780const double NPbase::C1eeZBF(const double sqrt_s) const
1781{
1782 double C1;
1783
1784 if (sqrt_s == 0.240) {
1785
1786 C1 = 0.0070;
1787
1788 } else if (sqrt_s == 0.250) {
1789
1790 C1 = 0.0070;
1791
1792 } else if (sqrt_s == 0.350) {
1793
1794 C1 = 0.0069;
1795
1796 } else if (sqrt_s == 0.365) {
1797
1798 C1 = 0.0069;
1799
1800 } else if (sqrt_s == 0.380) {
1801
1802 C1 = 0.0069;
1803
1804 } else if (sqrt_s == 0.500) {
1805
1806 C1 = 0.0067;
1807
1808 } else if (sqrt_s == 1.0) {
1809
1810 C1 = 0.0065;
1811
1812 } else if (sqrt_s == 1.4) {
1813
1814 C1 = 0.0065;
1815
1816 } else if (sqrt_s == 1.5) {
1817
1818 C1 = 0.0065;
1819
1820 } else if (sqrt_s == 3.0) {
1821
1822 C1 = 0.0063;
1823
1824 } else
1825 throw std::runtime_error("Bad argument in NPbase::C1eeZBF");
1826
1827 return C1;
1828}
1829
1830const double NPbase::C1eettH(const double sqrt_s) const
1831{
1832 double C1;
1833
1834 if (sqrt_s == 0.500) {
1835
1836 C1 = 0.086;
1837
1838 } else if (sqrt_s == 1.0) {
1839
1840 C1 = 0.017;
1841
1842 } else if (sqrt_s == 1.4) {
1843
1844 C1 = 0.0094;
1845
1846 } else if (sqrt_s == 1.5) {
1847
1848 C1 = 0.0094;
1849
1850 } else if (sqrt_s == 3.0) {
1851
1852 C1 = 0.0037;
1853
1854 } else
1855 throw std::runtime_error("Bad argument in NPbase::C1eettH");
1856
1857 return C1;
1858}
DPars
std::map< std::string, double > DPars
Definition: Minimal.cpp:11
Model::setSliced
void setSliced(bool Sliced)
Definition: Model.h:245
NPbase::gRnuN2
virtual const double gRnuN2() const
Definition: NPbase.cpp:1550
NPbase::delta_Dsigma_f
virtual const double delta_Dsigma_f(const Particle f, const double pol_e, const double pol_p, const double s, const double cos) const
Definition: NPbase.cpp:1157
NPbase::eeffsigmaStrange
virtual const double eeffsigmaStrange(const double pol_e, const double pol_p, const double s) const
Definition: NPbase.cpp:1229
NPbase::BR_Zf
virtual const double BR_Zf(const Particle f) const
The Branching ratio of the boson into a given fermion pair, .
Definition: NPbase.cpp:541
NPbase::deltaSin2thetaEff_mu
virtual const double deltaSin2thetaEff_mu() const
The new physics contribution to the effective muonic weak angle at the pole.
Definition: NPbase.cpp:729
NPbase::delta_TauLFU_gtauge
virtual const double delta_TauLFU_gtauge() const
The computation of the correction to the LFU ratio .
Definition: NPbase.cpp:1580
NPbase::TauLFU_gtaugmuPi
virtual const double TauLFU_gtaugmuPi() const
Definition: NPbase.cpp:1611
NPbase::deltaR_inv
virtual const double deltaR_inv() const
The new physics contribution to the ratio of invisible and leptonic (electron) decay widths of the b...
Definition: NPbase.cpp:1047
NPbase::R_inv
virtual const double R_inv() const
The ratio of the invisible and leptonic (electron) decay widths of the boson, .
Definition: NPbase.cpp:1091
NPbase::eeffRstrange
virtual const double eeffRstrange(const double pol_e, const double pol_p, const double s) const
Definition: NPbase.cpp:1291
NPbase::deltaGamma_Z
virtual const double deltaGamma_Z() const
The new physics contribution to the total decay width of the boson, .
Definition: NPbase.cpp:363
NPbase::LEP2AFBtau
virtual const double LEP2AFBtau(const double s) const
Definition: NPbase.cpp:1401
NPbase::eeffAFBstrange
virtual const double eeffAFBstrange(const double pol_e, const double pol_p, const double s) const
Definition: NPbase.cpp:1346
NPbase::C1HZZ
double C1HZZ
Definition: NPbase.h:5726
NPbase::OutputOrder
virtual int OutputOrder() const
Definition: NPbase.cpp:42
NPbase::deltaGamma_Zhad
virtual const double deltaGamma_Zhad() const
The new physics contribution to the hadronic decay width of the boson, .
Definition: NPbase.cpp:499
NPbase::eeffRtau
virtual const double eeffRtau(const double pol_e, const double pol_p, const double s) const
Definition: NPbase.cpp:1279
NPbase::eeffsigmaCharm
virtual const double eeffsigmaCharm(const double pol_e, const double pol_p, const double s) const
Definition: NPbase.cpp:1233
NPbase::obliqueT
virtual const double obliqueT() const
The oblique parameter .
Definition: NPbase.h:137
NPbase::LEP2dsigmadcosMu
virtual const double LEP2dsigmadcosMu(const double s, const double cos) const
Definition: NPbase.cpp:1431
NPbase::deltaGamma_Zf
virtual const double deltaGamma_Zf(const Particle f) const
The new physics contribution to the decay width of the boson into a given fermion pair,...
Definition: NPbase.cpp:289
NPbase::LEP2dsigmadcosBinTau
virtual const double LEP2dsigmadcosBinTau(const double s, const double cos, const double cosmin, const double cosmax) const
Definition: NPbase.cpp:1457
NPbase::LEP2Rcharm
virtual const double LEP2Rcharm(const double s) const
Definition: NPbase.cpp:1416
NPbase::LEP2dsigmadcosE
virtual const double LEP2dsigmadcosE(const double s, const double cos) const
Definition: NPbase.cpp:1426
NPbase::gA_f
virtual const gslpp::complex gA_f(const Particle f) const
The total (SM+NP) contribution to the neutral-current axial-vector coupling .
Definition: NPbase.cpp:214
NPbase::kappaZ_f
virtual const gslpp::complex kappaZ_f(const Particle f) const
The effective neutral-current coupling including SM plus NP contributions.
Definition: NPbase.cpp:226
NPbase::AFB
virtual const double AFB(const Particle f) const
The forward-backward asymmetry in at the -pole, .
Definition: NPbase.cpp:914
NPbase::Update
virtual bool Update(const std::map< std::string, double > &DPars)
The update method for NPbase.
Definition: NPbase.cpp:36
NPbase::LEP2AFBbottom
virtual const double LEP2AFBbottom(const double s) const
Definition: NPbase.cpp:1411
NPbase::deltaSigmaHadron_2
virtual const double deltaSigmaHadron_2() const
The new physics contribution to the cross section for the process at the pole, .
Definition: NPbase.cpp:552
NPbase::deltaAFB
virtual const double deltaAFB(const Particle f) const
The new physics contribution to the forward-backward asymmetry in at the -pole, .
Definition: NPbase.cpp:879
NPbase::LEP2sigmaMu
virtual const double LEP2sigmaMu(const double s) const
Definition: NPbase.cpp:1366
NPbase::eeffAFBtau
virtual const double eeffAFBtau(const double pol_e, const double pol_p, const double s) const
Definition: NPbase.cpp:1342
NPbase::eeffsigmaTau
virtual const double eeffsigmaTau(const double pol_e, const double pol_p, const double s) const
Definition: NPbase.cpp:1221
NPbase::deltaGV_f_2
virtual const double deltaGV_f_2(const Particle f) const
Definition: NPbase.h:181
NPbase::TauLFU_gtaugmuK
virtual const double TauLFU_gtaugmuK() const
Definition: NPbase.cpp:1616
NPbase::Gamma_had
virtual const double Gamma_had() const
The hadronic decay width of the boson, .
Definition: NPbase.cpp:535
NPbase::deltaR0_f_2
virtual const double deltaR0_f_2(const Particle f) const
The new physics contribution to the ratio , and , for charged leptons, quarks and neutrinos:
Definition: NPbase.cpp:927
NPbase::alrmoller
virtual const double alrmoller(const double q2, const double y) const
Definition: NPbase.cpp:1530
NPbase::GammaW
virtual const double GammaW() const
The total width of the boson, .
Definition: NPbase.cpp:109
NPbase::deltaGL_Wff_mu
virtual gslpp::complex deltaGL_Wff_mu(const Particle pbar, const Particle p, const double mu) const
New physics contribution to the charged current coupling .
Definition: NPbase.cpp:244
NPbase::deltaGamma_Zf_2
virtual const double deltaGamma_Zf_2(const Particle f) const
The new physics contribution to the decay width of the boson into a given fermion pair,...
Definition: NPbase.cpp:256
NPbase::A_f
virtual const double A_f(const Particle f) const
The left-right asymmetry in at the -pole, .
Definition: NPbase.cpp:817
NPbase::alphaMz
virtual const double alphaMz() const
The electromagnetic coupling at the -mass scale, .
Definition: NPbase.cpp:51
NPbase::eeffRmuon
virtual const double eeffRmuon(const double pol_e, const double pol_p, const double s) const
Definition: NPbase.cpp:1267
NPbase::delta_Qwn
virtual const double delta_Qwn() const
The computation of the neutron weak charge: Qwn.
Definition: NPbase.cpp:1493
NPbase::deltaSigmaHadron
virtual const double deltaSigmaHadron() const
The new physics contribution to the cross section for the process at the pole, .
Definition: NPbase.cpp:608
NPbase::eeffAFBetsub
virtual const double eeffAFBetsub(const double pol_e, const double pol_p, const double s) const
Definition: NPbase.cpp:1334
NPbase::LEP2dsigmadcosBinE
virtual const double LEP2dsigmadcosBinE(const double s, const double cos, const double cosmin, const double cosmax) const
Definition: NPbase.cpp:1441
NPbase::deltaN_nu
virtual const double deltaN_nu() const
The new physics contribution to the number of neutrinos dervied from the pole measurements.
Definition: NPbase.cpp:1097
NPbase::eeffsigmaEtsub
virtual const double eeffsigmaEtsub(const double pol_e, const double pol_p, const double s) const
Definition: NPbase.cpp:1213
NPbase::RZlilj
virtual const double RZlilj(const Particle li, const Particle lj) const
The lepton universality ratio .
Definition: NPbase.cpp:461
NPbase::delta_amuon
virtual const double delta_amuon() const
The computation of the anomalous magnetic moment of the muon .
Definition: NPbase.cpp:1468
NPbase::Mw
virtual const double Mw() const
The mass of the boson, .
Definition: NPbase.cpp:71
NPbase::C1eeZBF
virtual const double C1eeZBF(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
Definition: NPbase.cpp:1780
NPbase::delta_AFB_f
virtual const double delta_AFB_f(const Particle f, const double pol_e, const double pol_p, const double s) const
Definition: NPbase.cpp:1179
NPbase::sigma0_had
virtual const double sigma0_had() const
The cross section for the process at the pole, .
Definition: NPbase.cpp:655
NPbase::delta_TauLFU_gmuge
virtual const double delta_TauLFU_gmuge() const
The computation of the correction to the LFU ratio .
Definition: NPbase.cpp:1570
NPbase::deltaGV_f
virtual const double deltaGV_f(const Particle f) const
New physics contribution to the neutral-current vector coupling .
Definition: NPbase.cpp:181
NPbase::delta_gRnuN2
virtual const double delta_gRnuN2() const
The computation of the correction to the effective neutrino nucleon RH coupling: delta_gRnuN2.
Definition: NPbase.cpp:1503
NPbase::delta_Qwp
virtual const double delta_Qwp() const
The computation of the proton weak charge: Qwp.
Definition: NPbase.cpp:1487
NPbase::C1Hgg
double C1Hgg
Definition: NPbase.h:5726
NPbase::TauLFU_gtaugmu
virtual const double TauLFU_gtaugmu() const
Definition: NPbase.cpp:1601
NPbase::trueSM
StandardModel trueSM
Definition: NPbase.h:5731
NPbase::C1eeWBF
virtual const double C1eeWBF(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
Definition: NPbase.cpp:1680
NPbase::N_nu
virtual const double N_nu() const
The number of neutrinos dervied from the pole measurements, .
Definition: NPbase.cpp:1147
NPbase::deltaGamma_Zhad_2
virtual const double deltaGamma_Zhad_2() const
The new physics contribution to the hadronic decay width of the boson, .
Definition: NPbase.cpp:478
NPbase::delta_alrmoller
virtual const double delta_alrmoller(const double q2, const double y) const
The computation of the parity violating asymmetry in Moller scattering.
Definition: NPbase.cpp:1481
NPbase::BrW
virtual const double BrW(const Particle fi, const Particle fj) const
The branching ratio of the boson decaying into a SM fermion pair, .
Definition: NPbase.cpp:128
NPbase::eeffAFBmu
virtual const double eeffAFBmu(const double pol_e, const double pol_p, const double s) const
Definition: NPbase.cpp:1338
NPbase::TauLFU_gtauge
virtual const double TauLFU_gtauge() const
Definition: NPbase.cpp:1606
NPbase::RWc
virtual const double RWc() const
The ratio .
Definition: NPbase.cpp:162
NPbase::obliqueU
virtual const double obliqueU() const
The oblique parameter .
Definition: NPbase.h:146
NPbase::deltaGA_f
virtual const double deltaGA_f(const Particle f) const
New physics contribution to the neutral-current axial-vector coupling .
Definition: NPbase.cpp:204
NPbase::eeffsigmaBottom
virtual const double eeffsigmaBottom(const double pol_e, const double pol_p, const double s) const
Definition: NPbase.cpp:1237
NPbase::LEP2sigmaTau
virtual const double LEP2sigmaTau(const double s) const
Definition: NPbase.cpp:1371
NPbase::deltaSin2thetaEff_e
virtual const double deltaSin2thetaEff_e() const
The new physics contribution to the effective electron/leptonic weak angle at the pole.
Definition: NPbase.cpp:691
NPbase::deltaGA_f_2
virtual const double deltaGA_f_2(const Particle f) const
Definition: NPbase.h:219
NPbase::eeffRelectrontsub
virtual const double eeffRelectrontsub(const double pol_e, const double pol_p, const double s) const
Definition: NPbase.cpp:1255
NPbase::deltaA_f
virtual const double deltaA_f(const Particle f) const
The new physics contribution to the left-right asymmetry in at the -pole, .
Definition: NPbase.cpp:800
NPbase::LEP2dsigmadcosTau
virtual const double LEP2dsigmadcosTau(const double s, const double cos) const
Definition: NPbase.cpp:1436
NPbase::C1eettH
virtual const double C1eettH(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
Definition: NPbase.cpp:1830
NPbase::deltaAFB_2
virtual const double deltaAFB_2(const Particle f) const
The new physics to the forward-backward asymmetry in at the -pole, .
Definition: NPbase.cpp:830
NPbase::delta_AFB_ee
virtual const double delta_AFB_ee(const double pol_e, const double pol_p, const double s) const
Definition: NPbase.cpp:1201
NPbase::TauLFU_gmuge
virtual const double TauLFU_gmuge() const
Definition: NPbase.cpp:1596
NPbase::deltaGR_Wff_mu
virtual gslpp::complex deltaGR_Wff_mu(const Particle pbar, const Particle p, const double mu) const
New physics contribution to the charged current coupling .
Definition: NPbase.cpp:250
NPbase::R0_f
virtual const double R0_f(const Particle f) const
The ratio , and , for charged leptons, quarks and neutrinos, respectively.
Definition: NPbase.cpp:1034
NPbase::deltaGL_Wff
virtual gslpp::complex deltaGL_Wff(const Particle pbar, const Particle p) const
New physics contribution to the charged current coupling .
Definition: NPbase.h:290
NPbase::eeffsigmaHadron
virtual const double eeffsigmaHadron(const double pol_e, const double pol_p, const double s) const
Definition: NPbase.cpp:1225
NPbase::RWlilj
virtual const double RWlilj(const Particle li, const Particle lj) const
The lepton universality ratio .
Definition: NPbase.cpp:137
NPbase::delta_TauLFU_gtaugmuK
virtual const double delta_TauLFU_gtaugmuK() const
The computation of the correction to the LFU ratio .
Definition: NPbase.cpp:1590
NPbase::C1Hgaga
double C1Hgaga
Definition: NPbase.h:5726
NPbase::C1eeZH
virtual const double C1eeZH(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
Definition: NPbase.cpp:1630
NPbase::deltaGR_Wff
virtual gslpp::complex deltaGR_Wff(const Particle pbar, const Particle p) const
New physics contribution to the charged current coupling .
Definition: NPbase.h:301
NPbase::LEP2sigmaBottom
virtual const double LEP2sigmaBottom(const double s) const
Definition: NPbase.cpp:1386
NPbase::gV_f
virtual const gslpp::complex gV_f(const Particle f) const
The total (SM+NP) contribution to the neutral-current vector coupling .
Definition: NPbase.cpp:198
NPbase::delta_sigma_f
virtual const double delta_sigma_f(const Particle f, const double pol_e, const double pol_p, const double s, const double cosmin, const double cosmax) const
Definition: NPbase.cpp:1162
NPbase::deltaR0_f
virtual const double deltaR0_f(const Particle f) const
The new physics contribution to the ratio , and , for charged leptons, quarks and neutrinos,...
Definition: NPbase.cpp:983
NPbase::delta_sigma_ee
virtual const double delta_sigma_ee(const double pol_e, const double pol_p, const double s, const double cosmin, const double cosmax) const
Definition: NPbase.cpp:1191
NPbase::delta_gAnue
virtual const double delta_gAnue() const
The computation of the correction to the effective (muon) neutrino-electron vector coupling: delta_gA...
Definition: NPbase.cpp:1513
NPbase::deltaRuc_2
virtual const double deltaRuc_2() const
The new physics contribution to the ratio of the width to the -boson hadronic width:
Definition: NPbase.cpp:418
NPbase::Qwn
virtual const double Qwn() const
Definition: NPbase.cpp:1540
NPbase::Gamma_Z
virtual const double Gamma_Z() const
The total decay width of the boson, .
Definition: NPbase.cpp:405
NPbase::delta_sigmaTot_f
virtual const double delta_sigmaTot_f(const Particle f, const double pol_e, const double pol_p, const double s) const
Definition: NPbase.cpp:1173
NPbase::Qwp
virtual const double Qwp() const
Definition: NPbase.cpp:1535
NPbase::delta_gLnuN2
virtual const double delta_gLnuN2() const
The computation of the correction to the effective neutrino nucleon LH coupling: delta_gLnuN2.
Definition: NPbase.cpp:1498
NPbase::delta_TauLFU_gtaugmuPi
virtual const double delta_TauLFU_gtaugmuPi() const
The computation of the correction to the LFU ratio .
Definition: NPbase.cpp:1585
NPbase::sin2thetaEff
virtual const double sin2thetaEff(const Particle f) const
The leptonic effective weak mixing angle at the the pole.
Definition: NPbase.cpp:744
NPbase::obliqueS
virtual const double obliqueS() const
The oblique parameter .
Definition: NPbase.h:128
NPbase::C1eeHvv
virtual const double C1eeHvv(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
Definition: NPbase.cpp:1730
NPbase::eeffsigmaE
virtual const double eeffsigmaE(const double pol_e, const double pol_p, const double s) const
Definition: NPbase.cpp:1209
NPbase::C1HWW
double C1HWW
Definition: NPbase.h:5726
NPbase::deltaSin2thetaEff_mu_2
virtual const double deltaSin2thetaEff_mu_2() const
The new physics contribution to the effective muonic weak angle at the pole.
Definition: NPbase.cpp:706
NPbase::Qwemoller
virtual const double Qwemoller(const double q2, const double y) const
Definition: NPbase.cpp:1525
NPbase::LEP2sigmaHadron
virtual const double LEP2sigmaHadron(const double s) const
Definition: NPbase.cpp:1376
NPbase::eeffAFBe
virtual const double eeffAFBe(const double pol_e, const double pol_p, const double s) const
Definition: NPbase.cpp:1330
NPbase::eeffsigmaMu
virtual const double eeffsigmaMu(const double pol_e, const double pol_p, const double s) const
Definition: NPbase.cpp:1217
NPbase::delta_sigma_had
virtual const double delta_sigma_had(const double pol_e, const double pol_p, const double s, const double cosmin, const double cosmax) const
Definition: NPbase.cpp:1167
NPbase::delta_gVnue
virtual const double delta_gVnue() const
The computation of the correction to the effective (muon) neutrino-electron vector coupling: delta_gV...
Definition: NPbase.cpp:1508
NPbase::delta_sigmaTot_ee
virtual const double delta_sigmaTot_ee(const double pol_e, const double pol_p, const double s) const
Definition: NPbase.cpp:1196
NPbase::deltaGR_f_mu
const double deltaGR_f_mu(const Particle p, const double mu) const
New physics contribution to the neutral-current right-handed coupling .
Definition: NPbase.cpp:238
NPbase::LEP2AFBe
virtual const double LEP2AFBe(const double s) const
Definition: NPbase.cpp:1391
NPbase::eeffAFBbottom
virtual const double eeffAFBbottom(const double pol_e, const double pol_p, const double s) const
Definition: NPbase.cpp:1354
NPbase::LEP2Rbottom
virtual const double LEP2Rbottom(const double s) const
Definition: NPbase.cpp:1421
NPbase::amuon
virtual const double amuon() const
Definition: NPbase.cpp:1520
NPbase::LEP2dsigmadcosBinMu
virtual const double LEP2dsigmadcosBinMu(const double s, const double cos, const double cosmin, const double cosmax) const
Definition: NPbase.cpp:1449
NPbase::eeffRelectron
virtual const double eeffRelectron(const double pol_e, const double pol_p, const double s) const
Definition: NPbase.cpp:1243
NPbase::eeffRcharm
virtual const double eeffRcharm(const double pol_e, const double pol_p, const double s) const
Definition: NPbase.cpp:1303
NPbase::rhoZ_f
virtual const gslpp::complex rhoZ_f(const Particle f) const
The effective neutral-current coupling including SM plus NP contributions.
Definition: NPbase.cpp:220
NPbase::Ruc
virtual const double Ruc() const
The ratio of the width to the -boson hadronic width.
Definition: NPbase.cpp:450
NPbase::gAnue
virtual const double gAnue() const
Definition: NPbase.cpp:1560
NPbase::eeffAFBcharm
virtual const double eeffAFBcharm(const double pol_e, const double pol_p, const double s) const
Definition: NPbase.cpp:1350
NPbase::deltaRuc
virtual const double deltaRuc() const
The new physics contribution to the ratio of the width to the -boson hadronic width:
Definition: NPbase.cpp:434
NPbase::DeltaGF
virtual const double DeltaGF() const
New physics contribution to the Fermi constant.
Definition: NPbase.h:117
NPbase::NPbase
NPbase()
The default constructor.
Definition: NPbase.cpp:29
NPbase::deltaGamma_Z_2
virtual const double deltaGamma_Z_2() const
The new physics contribution to the total decay width of the boson, .
Definition: NPbase.cpp:338
NPbase::deltaGL_f_mu
const double deltaGL_f_mu(const Particle p, const double mu) const
New physics contribution to the neutral-current left-handed coupling .
Definition: NPbase.cpp:231
NPbase::LEP2sigmaE
virtual const double LEP2sigmaE(const double s) const
Definition: NPbase.cpp:1361
NPbase::Gamma_Zf
virtual const double Gamma_Zf(const Particle f) const
The decay width of the boson into a given fermion pair, .
Definition: NPbase.cpp:325
NPbase::deltaA_f_2
virtual const double deltaA_f_2(const Particle f) const
The new physics contribution to the left-right asymmetry in at the -pole, .
Definition: NPbase.cpp:772
NPbase::LEP2AFBcharm
virtual const double LEP2AFBcharm(const double s) const
Definition: NPbase.cpp:1406
NPbase::eeffRbottom
virtual const double eeffRbottom(const double pol_e, const double pol_p, const double s) const
Definition: NPbase.cpp:1315
NPbase::LEP2sigmaCharm
virtual const double LEP2sigmaCharm(const double s) const
Definition: NPbase.cpp:1381
NPbase::gLnuN2
virtual const double gLnuN2() const
Definition: NPbase.cpp:1545
NPbase::C1Htot
const double C1Htot() const
The C1 coefficient controlling the H^3 corrections to the total Higgs width from the Higgs trilinear ...
Definition: NPbase.cpp:1624
NPbase::gVnue
virtual const double gVnue() const
Definition: NPbase.cpp:1555
NPbase::delta_Qwemoller
virtual const double delta_Qwemoller(const double q2, const double y) const
The computation of the electron's weak charge.
Definition: NPbase.cpp:1475
NPbase::sigmaSM_ee
virtual const double sigmaSM_ee(const double pol_e, const double pol_p, const double s, const double cosmin, const double cosmax) const
Definition: NPbase.cpp:1186
NPbase::LEP2AFBmu
virtual const double LEP2AFBmu(const double s) const
Definition: NPbase.cpp:1396
NPbase::deltaSin2thetaEff_e_2
virtual const double deltaSin2thetaEff_e_2() const
The new physics contribution to the effective electron weak angle at the pole.
Definition: NPbase.cpp:668
NPbase::delta_TauLFU_gtaugmu
virtual const double delta_TauLFU_gtaugmu() const
The computation of the correction to the LFU ratio .
Definition: NPbase.cpp:1575
Particle
A class for particles.
Definition: Particle.h:26
Particle::is
bool is(std::string name_i) const
Definition: Particle.cpp:23
Particle::getIsospin
double getIsospin() const
A get method to access the particle isospin.
Definition: Particle.h:115
Particle::getCharge
double getCharge() const
A get method to access the particle charge.
Definition: Particle.h:97
Particle::getIndex
int getIndex() const
Definition: Particle.h:160
QCD::CF
double CF
Definition: QCD.h:1026
QCD::UP
@ UP
Definition: QCD.h:324
QCD::BOTTOM
@ BOTTOM
Definition: QCD.h:329
QCD::DOWN
@ DOWN
Definition: QCD.h:325
QCD::STRANGE
@ STRANGE
Definition: QCD.h:327
QCD::CHARM
@ CHARM
Definition: QCD.h:326
QCD::Nf
const double Nf(const double mu) const
The number of active flavour at scale .
Definition: QCD.cpp:571
QCD::NEUTRINO_2
@ NEUTRINO_2
Definition: QCD.h:313
QCD::NEUTRINO_1
@ NEUTRINO_1
Definition: QCD.h:311
QCD::MU
@ MU
Definition: QCD.h:314
QCD::ELECTRON
@ ELECTRON
Definition: QCD.h:312
QCD::NEUTRINO_3
@ NEUTRINO_3
Definition: QCD.h:315
QCD::TAU
@ TAU
Definition: QCD.h:316
QCD::quarks
Particle quarks[6]
The vector of all SM quarks.
Definition: QCD.h:1027
StandardModel
A model class for the Standard Model.
Definition: StandardModel.h:509
StandardModel::LEP2sigmaCharm
virtual const double LEP2sigmaCharm(const double s) const
Definition: StandardModel/src/StandardModel.cpp:4603
StandardModel::GammaZ
virtual const double GammaZ(const Particle f) const
The partial decay width, .
Definition: StandardModel/src/StandardModel.cpp:1357
StandardModel::computeBrHtoZZ
const double computeBrHtoZZ() const
The Br in the Standard Model.
Definition: StandardModel.h:2775
StandardModel::eeffRelectron
virtual const double eeffRelectron(const double pol_e, const double pol_p, const double s) const
Definition: StandardModel.h:3196
StandardModel::LEP2sigmaHadron
virtual const double LEP2sigmaHadron(const double s) const
Definition: StandardModel/src/StandardModel.cpp:5025
StandardModel::LEP2sigmaTau
virtual const double LEP2sigmaTau(const double s) const
Definition: StandardModel/src/StandardModel.cpp:4345
StandardModel::eeffsigmaCharm
virtual const double eeffsigmaCharm(const double pol_e, const double pol_p, const double s) const
Definition: StandardModel.h:3184
StandardModel::Mz
double Mz
The mass of the boson in GeV.
Definition: StandardModel.h:3446
StandardModel::TauLFU_gtaugmuPi
virtual const double TauLFU_gtaugmuPi() const
The computation of the LFU ratio .
Definition: StandardModel/src/StandardModel.cpp:3235
StandardModel::LEP2AFBtau
virtual const double LEP2AFBtau(const double s) const
Definition: StandardModel/src/StandardModel.cpp:7480
StandardModel::gLnuN2
virtual const double gLnuN2() const
The effective neutrino nucleon LH coupling: gLnuN2.
Definition: StandardModel/src/StandardModel.cpp:3001
StandardModel::LEP2dsigmadcosBinTau
virtual const double LEP2dsigmadcosBinTau(const double s, const double cos, const double cosmin, const double cosmax) const
Definition: StandardModel/src/StandardModel.cpp:9656
StandardModel::LEP2Rbottom
virtual const double LEP2Rbottom(const double s) const
Definition: StandardModel/src/StandardModel.cpp:7977
StandardModel::Qwp
virtual const double Qwp() const
The computation of the proton weak charge: Qwp.
Definition: StandardModel/src/StandardModel.cpp:2781
StandardModel::R_inv
virtual const double R_inv() const
The ratio of the invisible and leptonic (electron) decay widths of the boson, .
Definition: StandardModel/src/StandardModel.cpp:1550
StandardModel::LEP2AFBe
virtual const double LEP2AFBe(const double s) const
Definition: StandardModel/src/StandardModel.cpp:6978
StandardModel::eeffAFBmu
virtual const double eeffAFBmu(const double pol_e, const double pol_p, const double s) const
Definition: StandardModel.h:3241
StandardModel::eeffAFBtau
virtual const double eeffAFBtau(const double pol_e, const double pol_p, const double s) const
Definition: StandardModel.h:3245
StandardModel::eeffsigmaMu
virtual const double eeffsigmaMu(const double pol_e, const double pol_p, const double s) const
Definition: StandardModel.h:3162
StandardModel::Gamma_had
virtual const double Gamma_had() const
The hadronic decay width of the boson, .
Definition: StandardModel/src/StandardModel.cpp:1411
StandardModel::eeffRmuon
virtual const double eeffRmuon(const double pol_e, const double pol_p, const double s) const
Definition: StandardModel.h:3204
StandardModel::LEP2AFBcharm
virtual const double LEP2AFBcharm(const double s) const
Definition: StandardModel/src/StandardModel.cpp:6568
StandardModel::eeffAFBcharm
virtual const double eeffAFBcharm(const double pol_e, const double pol_p, const double s) const
Definition: StandardModel.h:3253
StandardModel::eeffRstrange
virtual const double eeffRstrange(const double pol_e, const double pol_p, const double s) const
Definition: StandardModel.h:3212
StandardModel::gA_f
virtual const gslpp::complex gA_f(const Particle f) const
The effective leptonic neutral-current axial-vector coupling in the SM.
Definition: StandardModel/src/StandardModel.cpp:1583
StandardModel::alrmoller
virtual const double alrmoller(const double q2, const double y) const
The computation of the parity violating asymmetry in Moller scattering.
Definition: StandardModel/src/StandardModel.cpp:2763
StandardModel::eeffsigmaEtsub
virtual const double eeffsigmaEtsub(const double pol_e, const double pol_p, const double s) const
Definition: StandardModel.h:3154
StandardModel::leptons
Particle leptons[6]
An array of Particle objects for the leptons.
Definition: StandardModel.h:3432
StandardModel::Ruc
virtual const double Ruc() const
Definition: StandardModel/src/StandardModel.cpp:1317
StandardModel::sigma0_had
virtual const double sigma0_had() const
The hadronic cross section for at the -pole, .
Definition: StandardModel/src/StandardModel.cpp:1465
StandardModel::computeBrHtogg
const double computeBrHtogg() const
The Br in the Standard Model.
Definition: StandardModel.h:2752
StandardModel::eeffAFBbottom
virtual const double eeffAFBbottom(const double pol_e, const double pol_p, const double s) const
Definition: StandardModel.h:3257
StandardModel::LEP2AFBmu
virtual const double LEP2AFBmu(const double s) const
Definition: StandardModel/src/StandardModel.cpp:6983
StandardModel::LEP2dsigmadcosMu
virtual const double LEP2dsigmadcosMu(const double s, const double cos) const
Definition: StandardModel/src/StandardModel.cpp:9617
StandardModel::Qwemoller
virtual const double Qwemoller(const double q2, const double y) const
The computation of the electron's weak charge.
Definition: StandardModel/src/StandardModel.cpp:2665
StandardModel::LEP2dsigmadcosBinE
virtual const double LEP2dsigmadcosBinE(const double s, const double cos, const double cosmin, const double cosmax) const
Definition: StandardModel/src/StandardModel.cpp:9646
StandardModel::Gamma_Z
virtual const double Gamma_Z() const
The total decay width of the boson, .
Definition: StandardModel/src/StandardModel.cpp:1433
StandardModel::gRnuN2
virtual const double gRnuN2() const
The effective neutrino nucleon RH coupling: gRnuN2.
Definition: StandardModel/src/StandardModel.cpp:3015
StandardModel::eeffAFBetsub
virtual const double eeffAFBetsub(const double pol_e, const double pol_p, const double s) const
Definition: StandardModel.h:3234
StandardModel::TauLFU_gtaugmuK
virtual const double TauLFU_gtaugmuK() const
The computation of the LFU ratio .
Definition: StandardModel/src/StandardModel.cpp:3242
StandardModel::eeffRbottom
virtual const double eeffRbottom(const double pol_e, const double pol_p, const double s) const
Definition: StandardModel.h:3220
StandardModel::LEP2sigmaE
virtual const double LEP2sigmaE(const double s) const
Definition: StandardModel/src/StandardModel.cpp:4083
StandardModel::Mw
virtual const double Mw() const
The SM prediction for the -boson mass in the on-shell scheme, .
Definition: StandardModel/src/StandardModel.cpp:1019
StandardModel::amuon
virtual const double amuon() const
The computation of the anomalous magnetic moment of the muon .
Definition: StandardModel/src/StandardModel.cpp:2435
StandardModel::LEP2Rcharm
virtual const double LEP2Rcharm(const double s) const
Definition: StandardModel/src/StandardModel.cpp:7989
StandardModel::computeBrHtogaga
const double computeBrHtogaga() const
The Br in the Standard Model.
Definition: StandardModel.h:2799
StandardModel::Qwn
virtual const double Qwn() const
The computation of the neutron weak charge: Qwn.
Definition: StandardModel/src/StandardModel.cpp:2889
StandardModel::eeffAFBe
virtual const double eeffAFBe(const double pol_e, const double pol_p, const double s) const
Definition: StandardModel.h:3227
StandardModel::GammaW
virtual const double GammaW(const Particle fi, const Particle fj) const
A partial decay width of the boson decay into a SM fermion pair.
Definition: StandardModel/src/StandardModel.cpp:1242
StandardModel::LEP2sigmaMu
virtual const double LEP2sigmaMu(const double s) const
Definition: StandardModel/src/StandardModel.cpp:4088
StandardModel::R0_f
virtual const double R0_f(const Particle f) const
The ratio .
Definition: StandardModel/src/StandardModel.cpp:1479
StandardModel::eeffRcharm
virtual const double eeffRcharm(const double pol_e, const double pol_p, const double s) const
Definition: StandardModel.h:3216
StandardModel::TauLFU_gtauge
virtual const double TauLFU_gtauge() const
The computation of the LFU ratio .
Definition: StandardModel/src/StandardModel.cpp:3211
StandardModel::eeffsigmaBottom
virtual const double eeffsigmaBottom(const double pol_e, const double pol_p, const double s) const
Definition: StandardModel.h:3189
StandardModel::eeffsigmaE
virtual const double eeffsigmaE(const double pol_e, const double pol_p, const double s) const
Definition: StandardModel.h:3144
StandardModel::cW2
virtual const double cW2(const double Mw_i) const
The square of the cosine of the weak mixing angle in the on-shell scheme, denoted as .
Definition: StandardModel/src/StandardModel.cpp:1076
StandardModel::eeffsigmaStrange
virtual const double eeffsigmaStrange(const double pol_e, const double pol_p, const double s) const
Definition: StandardModel.h:3179
StandardModel::TauLFU_gtaugmu
virtual const double TauLFU_gtaugmu() const
The computation of the LFU ratio .
Definition: StandardModel/src/StandardModel.cpp:3188
StandardModel::N_nu
virtual const double N_nu() const
The number of neutrinos obtained indirectly from the measurements at the Z pole, .
Definition: StandardModel/src/StandardModel.cpp:1556
StandardModel::TauLFU_gmuge
virtual const double TauLFU_gmuge() const
The computation of the LFU ratio .
Definition: StandardModel/src/StandardModel.cpp:3165
StandardModel::delGammaZ
double delGammaZ
The theoretical uncertainty in , denoted as , in GeV.
Definition: StandardModel.h:3456
StandardModel::eeffsigmaTau
virtual const double eeffsigmaTau(const double pol_e, const double pol_p, const double s) const
Definition: StandardModel.h:3167
StandardModel::alphaMz
virtual const double alphaMz() const
The electromagnetic coupling at the -mass scale, .
Definition: StandardModel/src/StandardModel.cpp:938
StandardModel::eeffsigmaHadron
virtual const double eeffsigmaHadron(const double pol_e, const double pol_p, const double s) const
Definition: StandardModel.h:3172
StandardModel::eeffAFBstrange
virtual const double eeffAFBstrange(const double pol_e, const double pol_p, const double s) const
Definition: StandardModel.h:3249
StandardModel::LEP2dsigmadcosTau
virtual const double LEP2dsigmadcosTau(const double s, const double cos) const
Definition: StandardModel/src/StandardModel.cpp:9630
StandardModel::LEP2sigmaBottom
virtual const double LEP2sigmaBottom(const double s) const
Definition: StandardModel/src/StandardModel.cpp:4814
StandardModel::LEP2dsigmadcosE
virtual const double LEP2dsigmadcosE(const double s, const double cos) const
Definition: StandardModel/src/StandardModel.cpp:9604
StandardModel::Update
virtual bool Update(const std::map< std::string, double > &DPars)
The update method for StandardModel.
Definition: StandardModel/src/StandardModel.cpp:225
StandardModel::eeffRelectrontsub
virtual const double eeffRelectrontsub(const double pol_e, const double pol_p, const double s) const
Definition: StandardModel.h:3200
StandardModel::sW2
virtual const double sW2(const double Mw_i) const
The square of the sine of the weak mixing angle in the on-shell scheme, denoted as .
Definition: StandardModel/src/StandardModel.cpp:1087
StandardModel::gV_f
virtual const gslpp::complex gV_f(const Particle f) const
The effective leptonic neutral-current vector coupling in the SM.
Definition: StandardModel/src/StandardModel.cpp:1577
StandardModel::gAnue
virtual const double gAnue() const
The effective (muon) neutrino-electron axial-vector coupling: gAnue.
Definition: StandardModel/src/StandardModel.cpp:3068
StandardModel::InitializeModel
virtual bool InitializeModel()
A method to initialize the model.
Definition: StandardModel/src/StandardModel.cpp:174
StandardModel::computeBrHtoWW
const double computeBrHtoWW() const
The Br in the Standard Model.
Definition: StandardModel.h:2763
StandardModel::LEP2AFBbottom
virtual const double LEP2AFBbottom(const double s) const
Definition: StandardModel/src/StandardModel.cpp:6157
StandardModel::gVnue
virtual const double gVnue() const
The effective (muon) neutrino-electron vector coupling: gVnue.
Definition: StandardModel/src/StandardModel.cpp:3055
StandardModel::LEP2dsigmadcosBinMu
virtual const double LEP2dsigmadcosBinMu(const double s, const double cos, const double cosmin, const double cosmax) const
Definition: StandardModel/src/StandardModel.cpp:9651
StandardModel::eeffRtau
virtual const double eeffRtau(const double pol_e, const double pol_p, const double s) const
Definition: StandardModel.h:3208
s
Test Observable.