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