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::eeffsigma(const Particle f, const double pol_e, const double pol_p, const double s, const double cosmin, const double cosmax) const
1210{
1211 return (trueSM.eeffsigma(f, pol_e, pol_p, s, cosmin, cosmax) + delta_sigma_f(f, pol_e, pol_p, s, cosmin, cosmax));
1212
1213}
1214
1215const double NPbase::eeffsigmaE(const double pol_e, const double pol_p, const double s) const
1216{
1217 return (trueSM.eeffsigmaE(pol_e, pol_p, s) + delta_sigmaTot_ee(pol_e, pol_p, s));
1218}
1219const double NPbase::eeffsigmaEtsub(const double pol_e, const double pol_p, const double s) const
1220{
1221 return (trueSM.eeffsigmaEtsub(pol_e, pol_p, s) + delta_sigmaTot_ee(pol_e, pol_p, s));
1222}
1223const double NPbase::eeffsigmaMu(const double pol_e, const double pol_p, const double s) const
1224{
1225 return (trueSM.eeffsigmaMu(pol_e, pol_p, s) + delta_sigmaTot_f(leptons[MU], pol_e, pol_p, s));
1226}
1227const double NPbase::eeffsigmaTau(const double pol_e, const double pol_p, const double s) const
1228{
1229 return (trueSM.eeffsigmaTau(pol_e, pol_p, s) + delta_sigmaTot_f(leptons[TAU], pol_e, pol_p, s));
1230}
1231const double NPbase::eeffsigmaHadron(const double pol_e, const double pol_p, const double s) const
1232{
1233 return (trueSM.eeffsigmaHadron(pol_e, pol_p, s) + delta_sigma_had(pol_e, pol_p, s, -1.0, 1.0));
1234}
1235const double NPbase::eeffsigmaStrange(const double pol_e, const double pol_p, const double s) const
1236{
1237 return (trueSM.eeffsigmaStrange(pol_e, pol_p, s) + delta_sigmaTot_f(quarks[STRANGE], pol_e, pol_p, s));
1238}
1239const double NPbase::eeffsigmaCharm(const double pol_e, const double pol_p, const double s) const
1240{
1241 return (trueSM.eeffsigmaCharm(pol_e, pol_p, s) + delta_sigmaTot_f(quarks[CHARM], pol_e, pol_p, s));
1242}
1243const double NPbase::eeffsigmaBottom(const double pol_e, const double pol_p, const double s) const
1244{
1245 return (trueSM.eeffsigmaBottom(pol_e, pol_p, s) + delta_sigmaTot_f(quarks[BOTTOM], pol_e, pol_p, s));
1246}
1247
1248// Ratios of cross sections
1249const double NPbase::eeffRelectron(const double pol_e, const double pol_p, const double s) const
1250{
1251 double sigmaHadSM = trueSM.eeffsigmaHadron(pol_e, pol_p, s);
1252 double sigmaffSM = trueSM.eeffsigmaE(pol_e, pol_p, s);
1253 double Rf;
1254
1255 Rf = trueSM.eeffRelectron(pol_e, pol_p, s)
1256 + delta_sigma_had(pol_e, pol_p, s, -1.0, 1.0) / sigmaffSM
1257 - delta_sigmaTot_ee(pol_e, pol_p, s) * sigmaHadSM / sigmaffSM / sigmaffSM;
1258
1259 return Rf;
1260}
1261const double NPbase::eeffRelectrontsub(const double pol_e, const double pol_p, const double s) const
1262{
1263 double sigmaHadSM = trueSM.eeffsigmaHadron(pol_e, pol_p, s);
1264 double sigmaffSM = trueSM.eeffsigmaEtsub(pol_e, pol_p, s);
1265 double Rf;
1266
1267 Rf = trueSM.eeffRelectrontsub(pol_e, pol_p, s)
1268 + delta_sigma_had(pol_e, pol_p, s, -1.0, 1.0) / sigmaffSM
1269 - delta_sigmaTot_ee(pol_e, pol_p, s) * sigmaHadSM / sigmaffSM / sigmaffSM;
1270
1271 return Rf;
1272}
1273const double NPbase::eeffRmuon(const double pol_e, const double pol_p, const double s) const
1274{
1275 double sigmaHadSM = trueSM.eeffsigmaHadron(pol_e, pol_p, s);
1276 double sigmaffSM = trueSM.eeffsigmaMu(pol_e, pol_p, s);
1277 double Rf;
1278
1279 Rf = trueSM.eeffRmuon(pol_e, pol_p, s)
1280 + delta_sigma_had(pol_e, pol_p, s, -1.0, 1.0) / sigmaffSM
1281 - delta_sigmaTot_f(leptons[MU], pol_e, pol_p, s) * sigmaHadSM / sigmaffSM / sigmaffSM;
1282
1283 return Rf;
1284}
1285const double NPbase::eeffRtau(const double pol_e, const double pol_p, const double s) const
1286{
1287 double sigmaHadSM = trueSM.eeffsigmaHadron(pol_e, pol_p, s);
1288 double sigmaffSM = trueSM.eeffsigmaTau(pol_e, pol_p, s);
1289 double Rf;
1290
1291 Rf = trueSM.eeffRtau(pol_e, pol_p, s)
1292 + delta_sigma_had(pol_e, pol_p, s, -1.0, 1.0) / sigmaffSM
1293 - delta_sigmaTot_f(leptons[TAU], pol_e, pol_p, s) * sigmaHadSM / sigmaffSM / sigmaffSM;
1294
1295 return Rf;
1296}
1297const double NPbase::eeffRstrange(const double pol_e, const double pol_p, const double s) const
1298{
1299 double sigmaHadSM = trueSM.eeffsigmaHadron(pol_e, pol_p, s);
1300 double sigmaffSM = trueSM.eeffsigmaStrange(pol_e, pol_p, s);
1301 double Rf;
1302
1303 Rf = trueSM.eeffRstrange(pol_e, pol_p, s)
1304 + delta_sigmaTot_f(quarks[STRANGE], pol_e, pol_p, s) / sigmaHadSM
1305 - delta_sigma_had(pol_e, pol_p, s, -1.0, 1.0) * sigmaffSM / sigmaHadSM / sigmaHadSM;
1306
1307 return Rf;
1308}
1309const double NPbase::eeffRcharm(const double pol_e, const double pol_p, const double s) const
1310{
1311 double sigmaHadSM = trueSM.eeffsigmaHadron(pol_e, pol_p, s);
1312 double sigmaffSM = trueSM.eeffsigmaCharm(pol_e, pol_p, s);
1313 double Rf;
1314
1315 Rf = trueSM.eeffRcharm(pol_e, pol_p, s)
1316 + delta_sigmaTot_f(quarks[CHARM], pol_e, pol_p, s) / sigmaHadSM
1317 - delta_sigma_had(pol_e, pol_p, s, -1.0, 1.0) * sigmaffSM / sigmaHadSM / sigmaHadSM;
1318
1319 return Rf;
1320}
1321const double NPbase::eeffRbottom(const double pol_e, const double pol_p, const double s) const
1322{
1323 double sigmaHadSM = trueSM.eeffsigmaHadron(pol_e, pol_p, s);
1324 double sigmaffSM = trueSM.eeffsigmaBottom(pol_e, pol_p, s);
1325 double Rf;
1326
1327 Rf = trueSM.eeffRbottom(pol_e, pol_p, s)
1328 + delta_sigmaTot_f(quarks[BOTTOM], pol_e, pol_p, s) / sigmaHadSM
1329 - delta_sigma_had(pol_e, pol_p, s, -1.0, 1.0) * sigmaffSM / sigmaHadSM / sigmaHadSM;
1330
1331 return Rf;
1332}
1333
1334
1335// Asymmetries
1336const double NPbase::eeffAFBe(const double pol_e, const double pol_p, const double s) const
1337{
1338 return (trueSM.eeffAFBe(pol_e, pol_p, s) + delta_AFB_ee(pol_e, pol_p, s));
1339}
1340const double NPbase::eeffAFBetsub(const double pol_e, const double pol_p, const double s) const
1341{
1342 return (trueSM.eeffAFBetsub(pol_e, pol_p, s) + delta_AFB_ee(pol_e, pol_p, s));
1343}
1344const double NPbase::eeffAFBmu(const double pol_e, const double pol_p, const double s) const
1345{
1346 return (trueSM.eeffAFBmu(pol_e, pol_p, s) + delta_AFB_f(leptons[MU], pol_e, pol_p, s));
1347}
1348const double NPbase::eeffAFBtau(const double pol_e, const double pol_p, const double s) const
1349{
1350 return (trueSM.eeffAFBtau(pol_e, pol_p, s) + delta_AFB_f(leptons[TAU], pol_e, pol_p, s));
1351}
1352const double NPbase::eeffAFBstrange(const double pol_e, const double pol_p, const double s) const
1353{
1354 return (trueSM.eeffAFBstrange(pol_e, pol_p, s) + delta_AFB_f(quarks[STRANGE], pol_e, pol_p, s));
1355}
1356const double NPbase::eeffAFBcharm(const double pol_e, const double pol_p, const double s) const
1357{
1358 return (trueSM.eeffAFBcharm(pol_e, pol_p, s) + delta_AFB_f(quarks[CHARM], pol_e, pol_p, s));
1359}
1360const double NPbase::eeffAFBbottom(const double pol_e, const double pol_p, const double s) const
1361{
1362 return (trueSM.eeffAFBbottom(pol_e, pol_p, s) + delta_AFB_f(quarks[BOTTOM], pol_e, pol_p, s));
1363}
1364
1365
1366 // LEP2 specific
1367const double NPbase::LEP2sigmaE(const double s) const
1368{
1369 return (trueSM.LEP2sigmaE(s) + delta_sigmaTot_ee(0., 0., s));
1370}
1371
1372const double NPbase::LEP2sigmaMu(const double s) const
1373{
1374 return (trueSM.LEP2sigmaMu(s) + delta_sigmaTot_f(leptons[MU], 0., 0., s));
1375}
1376
1377const double NPbase::LEP2sigmaTau(const double s) const
1378{
1379 return (trueSM.LEP2sigmaTau(s) + delta_sigmaTot_f(leptons[TAU], 0., 0., s));
1380}
1381
1382const double NPbase::LEP2sigmaHadron(const double s) const
1383{
1384 return (trueSM.LEP2sigmaHadron(s) + delta_sigma_had(0., 0., s, -1.0, 1.0));
1385}
1386
1387const double NPbase::LEP2sigmaCharm(const double s) const
1388{
1389 return (trueSM.LEP2sigmaCharm(s) + delta_sigmaTot_f(quarks[CHARM], 0., 0., s));
1390}
1391
1392const double NPbase::LEP2sigmaBottom(const double s) const
1393{
1394 return (trueSM.LEP2sigmaBottom(s) + delta_sigmaTot_f(quarks[BOTTOM], 0., 0., s));
1395}
1396
1397const double NPbase::LEP2AFBe(const double s) const
1398{
1399 return (trueSM.LEP2AFBe(s) + delta_AFB_ee(0., 0., s));
1400}
1401
1402const double NPbase::LEP2AFBmu(const double s) const
1403{
1404 return (trueSM.LEP2AFBmu(s) + delta_AFB_f(leptons[MU], 0., 0., s));
1405}
1406
1407const double NPbase::LEP2AFBtau(const double s) const
1408{
1409 return (trueSM.LEP2AFBtau(s) + delta_AFB_f(leptons[TAU], 0., 0., s));
1410}
1411
1412const double NPbase::LEP2AFBcharm(const double s) const
1413{
1414 return (trueSM.LEP2AFBcharm(s) + delta_AFB_f(quarks[CHARM], 0., 0., s));
1415}
1416
1417const double NPbase::LEP2AFBbottom(const double s) const
1418{
1419 return (trueSM.LEP2AFBbottom(s) + delta_AFB_f(quarks[BOTTOM], 0., 0., s));
1420}
1421
1422const double NPbase::LEP2Rcharm(const double s) const
1423{
1424 return (trueSM.LEP2Rcharm(s));
1425}
1426
1427const double NPbase::LEP2Rbottom(const double s) const
1428{
1429 return (trueSM.LEP2Rbottom(s));
1430}
1431
1432const double NPbase::LEP2dsigmadcosE(const double s, const double cos) const
1433{
1434 return (trueSM.LEP2dsigmadcosE(s,cos) + delta_Dsigma_f(leptons[ELECTRON], 0., 0., s, cos));
1435}
1436
1437const double NPbase::LEP2dsigmadcosMu(const double s, const double cos) const
1438{
1439 return (trueSM.LEP2dsigmadcosMu(s,cos) + delta_Dsigma_f(leptons[MU], 0., 0., s, cos) );
1440}
1441
1442const double NPbase::LEP2dsigmadcosTau(const double s, const double cos) const
1443{
1444 return (trueSM.LEP2dsigmadcosTau(s,cos) + delta_Dsigma_f(leptons[TAU], 0., 0., s, cos) );
1445}
1446
1447const double NPbase::LEP2dsigmadcosBinE(const double s, const double cos, const double cosmin, const double cosmax) const
1448{
1449 double Deltacos = fabs(cosmax-cosmin); // Bin width
1450
1451 // Compute differential cross section as the cross section in the bin/Delta cos (see e.g. hep-ex/0512012)
1452 return (trueSM.LEP2dsigmadcosBinE(s,cos,cosmin,cosmax) + delta_sigma_ee(0., 0., s, cosmin, cosmax) / Deltacos );
1453}
1454
1455const double NPbase::LEP2dsigmadcosBinMu(const double s, const double cos, const double cosmin, const double cosmax) const
1456{
1457 double Deltacos = fabs(cosmax-cosmin); // Bin width
1458
1459 // Compute differential cross section as the cross section in the bin/Delta cos (see e.g. hep-ex/0512012)
1460 return (trueSM.LEP2dsigmadcosBinMu(s,cos,cosmin,cosmax) + delta_sigma_f(leptons[MU], 0., 0., s, cosmin, cosmax) / Deltacos );
1461}
1462
1463const double NPbase::LEP2dsigmadcosBinTau(const double s, const double cos, const double cosmin, const double cosmax) const
1464{
1465 double Deltacos = fabs(cosmax-cosmin);
1466
1467 // Compute differential cross section as the cross section in the bin/Delta cos (see e.g. hep-ex/0512012)
1468 return (trueSM.LEP2dsigmadcosBinTau(s,cos,cosmin,cosmax) + delta_sigma_f(leptons[TAU], 0., 0., s, cosmin, cosmax) / Deltacos );
1469}
1470
1471
1472// EW low-energy observables: Muon g-2
1473
1474const double NPbase::delta_amuon() const
1475{
1476 return 0.;
1477}
1478
1479// EW low-energy observables: Parity violation
1480
1481const double NPbase::delta_Qwemoller(const double q2, const double y) const
1482{
1483 return 0.;
1484}
1485
1486
1487const double NPbase::delta_alrmoller(const double q2, const double y) const
1488{
1489 return 0.;
1490}
1491
1492
1493const double NPbase::delta_Qwp() const
1494{
1495 return 0.;
1496}
1497
1498
1499const double NPbase::delta_Qwn() const
1500{
1501 return 0.;
1502}
1503
1504const double NPbase::delta_gLnuN2() const
1505{
1506 return 0.;
1507}
1508
1509const double NPbase::delta_gRnuN2() const
1510{
1511 return 0.;
1512}
1513
1514const double NPbase::delta_gVnue() const
1515{
1516 return 0.;
1517}
1518
1519const double NPbase::delta_gAnue() const
1520{
1521 return 0.;
1522}
1523
1524
1525// Extension of SM observable definitions
1526const double NPbase::amuon() const
1527{
1528 return (trueSM.amuon() + delta_amuon());
1529}
1530
1531const double NPbase::Qwemoller(const double q2, const double y) const
1532{
1533 return (trueSM.Qwemoller(q2,y) + delta_Qwemoller(q2,y));
1534}
1535
1536const double NPbase::alrmoller(const double q2, const double y) const
1537{
1538 return (trueSM.alrmoller(q2,y) + delta_alrmoller(q2,y));
1539}
1540
1541const double NPbase::Qwp() const
1542{
1543 return (trueSM.Qwp() + delta_Qwp());
1544}
1545
1546const double NPbase::Qwn() const
1547{
1548 return (trueSM.Qwn() + delta_Qwn());
1549}
1550
1551const double NPbase::gLnuN2() const
1552{
1553 return (trueSM.gLnuN2() + delta_gLnuN2());
1554}
1555
1556const double NPbase::gRnuN2() const
1557{
1558 return (trueSM.gRnuN2() + delta_gRnuN2());
1559}
1560
1561const double NPbase::gVnue() const
1562{
1563 return (trueSM.gVnue() + delta_gVnue());
1564}
1565
1566const double NPbase::gAnue() const
1567{
1568 return (trueSM.gAnue() + delta_gAnue());
1569}
1570
1572// Lepton decays
1573
1574// Lepton Flavor universality tests in Tau decays
1575
1576const double NPbase::delta_TauLFU_gmuge() const
1577{
1578 return 0.;
1579}
1580
1581const double NPbase::delta_TauLFU_gtaugmu() const
1582{
1583 return 0.;
1584}
1585
1586const double NPbase::delta_TauLFU_gtauge() const
1587{
1588 return 0.;
1589}
1590
1591const double NPbase::delta_TauLFU_gtaugmuPi() const
1592{
1593 return 0.;
1594}
1595
1596const double NPbase::delta_TauLFU_gtaugmuK() const
1597{
1598 return 0.;
1599}
1600
1601// Extension of SM observable definitions
1602const double NPbase::TauLFU_gmuge() const
1603{
1604 return (trueSM.TauLFU_gmuge() + delta_TauLFU_gmuge());
1605}
1606
1607const double NPbase::TauLFU_gtaugmu() const
1608{
1609 return (trueSM.TauLFU_gtaugmu() + delta_TauLFU_gtaugmu());
1610}
1611
1612const double NPbase::TauLFU_gtauge() const
1613{
1614 return (trueSM.TauLFU_gtauge() + delta_TauLFU_gtauge());
1615}
1616
1617const double NPbase::TauLFU_gtaugmuPi() const
1618{
1619 return (trueSM.TauLFU_gtaugmuPi() + delta_TauLFU_gtaugmuPi());
1620}
1621
1622const double NPbase::TauLFU_gtaugmuK() const
1623{
1624 return (trueSM.TauLFU_gtaugmuK() + delta_TauLFU_gtaugmuK());
1625}
1626
1627
1628// Higgs-related definitions
1629
1630const double NPbase::C1Htot() const
1631{
1632 return ( (trueSM.computeBrHtogg() * C1Hgg) + (trueSM.computeBrHtoWW() * C1HWW) + (trueSM.computeBrHtoZZ() * C1HZZ) + (trueSM.computeBrHtogaga() * C1Hgaga) );
1633 //+ trueSM.computeBrHtoZga() * 0.0 + trueSM.computeBrHtomumu() * 0.0 + trueSM.computeBrHtotautau() * 0.0 + trueSM.computeBrHtocc() * 0.0 + trueSM.computeBrHtoss() * 0.0 + trueSM.computeBrHtobb() * 0.0
1634}
1635
1636const double NPbase::C1eeZH(const double sqrt_s) const
1637{
1638 double C1;
1639
1640 if (sqrt_s <= 0.240) {
1641
1642 C1 = 0.0173302;
1643
1644 } else if (sqrt_s == 0.250) {
1645
1646 C1 = 0.015;
1647
1648 } else if (sqrt_s == 0.350) {
1649
1650 C1 = 0.0057;
1651
1652 } else if (sqrt_s == 0.365) {
1653
1654 C1 = 0.00493549;
1655
1656 } else if (sqrt_s == 0.380) {
1657
1658 C1 = 0.0057; // Use same as 350 GeV
1659
1660 } else if ((sqrt_s == 0.500)||(sqrt_s == 0.550) ) {
1661
1662 C1 = 0.00099;
1663
1664 } else if (sqrt_s == 1.0) {
1665
1666 C1 = -0.0012;
1667
1668 } else if (sqrt_s == 1.4) {
1669
1670 C1 = -0.0011;
1671
1672 } else if (sqrt_s == 1.5) {
1673
1674 C1 = -0.0011; // Use the same as 1400 GeV
1675
1676 } else if (sqrt_s == 3.0) {
1677
1678 C1 = -0.00054;
1679
1680 } else
1681 throw std::runtime_error("Bad argument in NPbase::C1eeZH");
1682
1683 return C1;
1684}
1685
1686const double NPbase::C1eeWBF(const double sqrt_s) const
1687{
1688 double C1;
1689
1690 if (sqrt_s == 0.240) {
1691
1692 C1 = 0.00639683;
1693
1694 } else if (sqrt_s == 0.250) {
1695
1696 C1 = 0.0064;
1697
1698 } else if (sqrt_s == 0.350) {
1699
1700 C1 = 0.0062;
1701
1702 } else if (sqrt_s == 0.365) {
1703
1704 C1 = 0.00618352;
1705
1706 } else if (sqrt_s == 0.380) {
1707
1708 C1 = 0.0062;
1709
1710 } else if (sqrt_s == 0.500) {
1711
1712 C1 = 0.0061;
1713
1714 } else if (sqrt_s == 1.0) {
1715
1716 C1 = 0.0059;
1717
1718 } else if (sqrt_s == 1.4) {
1719
1720 C1 = 0.0058;
1721
1722 } else if (sqrt_s == 1.5) {
1723
1724 C1 = 0.0058;
1725
1726 } else if (sqrt_s == 3.0) {
1727
1728 C1 = 0.0057;
1729
1730 } else
1731 throw std::runtime_error("Bad argument in NPbase::C1eeWBF");
1732
1733 return C1;
1734}
1735
1736const double NPbase::C1eeHvv(const double sqrt_s) const
1737{
1738 double C1;
1739
1740 if (sqrt_s == 0.240) {
1741
1742 C1 = 0.00639683;
1743
1744 } else if (sqrt_s == 0.250) {
1745
1746 C1 = 0.0064;
1747
1748 } else if (sqrt_s == 0.350) {
1749
1750 C1 = 0.0062;
1751
1752 } else if (sqrt_s == 0.365) {
1753
1754 C1 = 0.00618352;
1755
1756 } else if (sqrt_s == 0.380) {
1757
1758 C1 = 0.0062;
1759
1760 } else if (sqrt_s == 0.500) {
1761
1762 C1 = 0.0061;
1763
1764 } else if (sqrt_s == 1.0) {
1765
1766 C1 = 0.0059;
1767
1768 } else if (sqrt_s == 1.4) {
1769
1770 C1 = 0.0058;
1771
1772 } else if (sqrt_s == 1.5) {
1773
1774 C1 = 0.0058;
1775
1776 } else if (sqrt_s == 3.0) {
1777
1778 C1 = 0.0057;
1779
1780 } else
1781 throw std::runtime_error("Bad argument in NPbase::C1eeHvv");
1782
1783 return C1;
1784}
1785
1786const double NPbase::C1eeZBF(const double sqrt_s) const
1787{
1788 double C1;
1789
1790 if (sqrt_s == 0.240) {
1791
1792 C1 = 0.0070;
1793
1794 } else if (sqrt_s == 0.250) {
1795
1796 C1 = 0.0070;
1797
1798 } else if (sqrt_s == 0.350) {
1799
1800 C1 = 0.0069;
1801
1802 } else if (sqrt_s == 0.365) {
1803
1804 C1 = 0.0069;
1805
1806 } else if (sqrt_s == 0.380) {
1807
1808 C1 = 0.0069;
1809
1810 } else if (sqrt_s == 0.500) {
1811
1812 C1 = 0.0067;
1813
1814 } else if (sqrt_s == 1.0) {
1815
1816 C1 = 0.0065;
1817
1818 } else if (sqrt_s == 1.4) {
1819
1820 C1 = 0.0065;
1821
1822 } else if (sqrt_s == 1.5) {
1823
1824 C1 = 0.0065;
1825
1826 } else if (sqrt_s == 3.0) {
1827
1828 C1 = 0.0063;
1829
1830 } else
1831 throw std::runtime_error("Bad argument in NPbase::C1eeZBF");
1832
1833 return C1;
1834}
1835
1836const double NPbase::C1eettH(const double sqrt_s) const
1837{
1838 double C1;
1839
1840 if (sqrt_s == 0.500) {
1841
1842 C1 = 0.086;
1843
1844 } else if (sqrt_s == 1.0) {
1845
1846 C1 = 0.017;
1847
1848 } else if (sqrt_s == 1.4) {
1849
1850 C1 = 0.0094;
1851
1852 } else if (sqrt_s == 1.5) {
1853
1854 C1 = 0.0094;
1855
1856 } else if (sqrt_s == 3.0) {
1857
1858 C1 = 0.0037;
1859
1860 } else
1861 throw std::runtime_error("Bad argument in NPbase::C1eettH");
1862
1863 return C1;
1864}
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: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::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::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::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::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:289
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::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::deltaGV_f_2
virtual const double deltaGV_f_2(const Particle f) const
Definition: NPbase.h:181
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::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::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::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::RZlilj
virtual const double RZlilj(const Particle li, const Particle lj) const
The lepton universality ratio .
Definition: NPbase.cpp:461
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:1786
NPbase::sigma0_had
virtual const double sigma0_had() const
The cross section for the process at the pole, .
Definition: NPbase.cpp:655
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::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:1686
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::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::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::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::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::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:1836
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::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::RWlilj
virtual const double RWlilj(const Particle li, const Particle lj) const
The lepton universality ratio .
Definition: NPbase.cpp:137
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:1636
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::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::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::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::Gamma_Z
virtual const double Gamma_Z() const
The total decay width of the boson, .
Definition: NPbase.cpp:405
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:1736
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::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::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::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::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::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
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.