a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
StandardModel/src/StandardModel.cpp
Go to the documentation of this file.
1/*
2 * Copyright (C) 2012 HEPfit Collaboration
3 *
4 *
5 * For the licensing terms see doc/COPYING.
6 */
7
8#include <iostream>
9#include <math.h>
10#include <stdlib.h>
11#include <stdexcept>
12#include <gsl/gsl_sf_zeta.h>
13#include <algorithm>
14#include "StandardModel.h"
15#include "EWSMcache.h"
16#include "EWSMOneLoopEW.h"
17#include "EWSMTwoLoopQCD.h"
18#include "EWSMThreeLoopQCD.h"
19#include "EWSMTwoLoopEW.h"
20#include "EWSMThreeLoopEW2QCD.h"
21#include "EWSMThreeLoopEW.h"
22#include "EWSMApproximateFormulae.h"
23#include "LeptonFlavour.h"
24#include "gslpp_function_adapter.h"
25/* BEGIN: REMOVE FROM THE PACKAGE */
26#include "EWSMTwoFermionsLEP2.h"
27#include <functional>
28#include <boost/bind/bind.hpp>
29using namespace boost::placeholders;
30/* END: REMOVE FROM THE PACKAGE */
31
32std::string StandardModel::SMvars[NSMvars] = {
33 "lambda", "A", "rhob", "etab", "Mz", "AlsMz", "GF", "ale", "dAle5Mz", "mHl",
34 "delMw", "delSin2th_l", "delSin2th_q", "delSin2th_b", "delGammaZ", "delsigma0H", "delR0l", "delR0c", "delR0b", "delGammaWlv", "delGammaWqq",
35 "mneutrino_1", "mneutrino_2", "mneutrino_3", "melectron", "mmu", "mtau", "muw"
36};
37
38const double StandardModel::GeVminus2_to_nb = 389379.338;
39const double StandardModel::Mw_error = 0.00001; /* 0.01 MeV */
40
41StandardModel::StandardModel()
42: QCD(), Yu(3, 3, 0.), Yd(3, 3, 0.), Yn(3, 3, 0.),
43SMM(*this), SMFlavour(*this), Ye(3, 3, 0.)
44{
45 setModelName("StandardModel");
46 requireCKM = false;
47 requireYe = false;
48 requireYn = false;
49
50 FlagWithoutNonUniversalVC = false;
51 FlagNoApproximateGammaZ = false;
52 FlagMw = "APPROXIMATEFORMULA";
53 FlagRhoZ = "NORESUM";
54 FlagKappaZ = "APPROXIMATEFORMULA";
55 FlagWolfenstein = true;
56 FlagUseVud = false;
57 FlagFixMuwMut = false;
58
59 FlagMWinput = false;
60
61 FlagSMAux = false;
62
63 /* Internal flags for EWPO (for debugging) */
64 flag_order[EW1] = true;
65 flag_order[EW1QCD1] = true;
66 flag_order[EW1QCD2] = true;
67 flag_order[EW2] = true;
68 flag_order[EW2QCD1] = true;
69 flag_order[EW3] = true;
70
71 //Flags for LEP2 observables
72 flagLEP2[Weak] = true;
73 flagLEP2[WeakBox] = true;
74 flagLEP2[ISR] = true;
75 flagLEP2[QEDFSR] = true;
76 flagLEP2[QCDFSR] = true;
77
78 bSigmaForAFB = false;
79 bSigmaForR = false;
80
81 // Caches for EWPO
82 FlagCacheInStandardModel = true; // use caches in the current class
83 useDeltaAlphaLepton_cache = false;
84 useDeltaAlpha_cache = false;
85 useMw_cache = false;
86 useGammaW_cache = false;
87 DeltaAlphaLepton_cache = 0.0;
88 DeltaAlpha_cache = 0.0;
89 Mw_cache = 0.0;
90 GammaW_cache = 0.0;
91 for (int i = 0; i < 12; ++i) {
92 useRhoZ_f_cache[i] = false;
93 useKappaZ_f_cache[i] = false;
94 rhoZ_f_cache[i] = gslpp::complex(0.0, 0.0, false);
95 kappaZ_f_cache[i] = gslpp::complex(0.0, 0.0, false);
96 }
97
98 myEWSMcache = NULL;
99 myOneLoopEW = NULL;
100 myTwoLoopQCD = NULL;
101 myThreeLoopQCD = NULL;
102 myTwoLoopEW = NULL;
103 myThreeLoopEW2QCD = NULL;
104 myThreeLoopEW = NULL;
105 myApproximateFormulae = NULL;
106 /* BEGIN: REMOVE FROM THE PACKAGE */
107 myTwoFermionsLEP2 = NULL;
108 /* END: REMOVE FROM THE PACKAGE */
109
110 // Particle(std::string name, double mass, double mass_scale = 0., double width = 0., double charge = 0.,double isospin = 0.);
111 leptons[NEUTRINO_1] = Particle("NEUTRINO_1", 0., 0., 0., 0., .5);
112 leptons[NEUTRINO_2] = Particle("NEUTRINO_2", 0., 0., 0., 0., .5);
113 leptons[NEUTRINO_3] = Particle("NEUTRINO_3", 0., 0., 0., 0., .5);
114 leptons[ELECTRON] = Particle("ELECTRON", 0., 0., 0., -1., -.5);
115 leptons[MU] = Particle("MU", 0., 0., 0., -1., -.5);
116 leptons[TAU] = Particle("TAU", 0., 0., 0., -1., -.5);
117
118 ModelParamMap.insert(std::make_pair("Mz", std::cref(Mz)));
119 ModelParamMap.insert(std::make_pair("AlsMz", std::cref(AlsMz)));
120 ModelParamMap.insert(std::make_pair("GF", std::cref(GF)));
121 ModelParamMap.insert(std::make_pair("ale", std::cref(ale)));
122 ModelParamMap.insert(std::make_pair("dAle5Mz", std::cref(dAle5Mz)));
123// ModelParamMap.insert(std::make_pair("Mw_inp", std::cref(Mw_inp)));
124 ModelParamMap.insert(std::make_pair("mHl", std::cref(mHl)));
125 ModelParamMap.insert(std::make_pair("delMw", std::cref(delMw)));
126 ModelParamMap.insert(std::make_pair("delSin2th_l", std::cref(delSin2th_l)));
127 ModelParamMap.insert(std::make_pair("delSin2th_q", std::cref(delSin2th_q)));
128 ModelParamMap.insert(std::make_pair("delSin2th_b", std::cref(delSin2th_b)));
129 ModelParamMap.insert(std::make_pair("delGammaZ", std::cref(delGammaZ)));
130 ModelParamMap.insert(std::make_pair("delsigma0H", std::cref(delsigma0H)));
131 ModelParamMap.insert(std::make_pair("delR0l", std::cref(delR0l)));
132 ModelParamMap.insert(std::make_pair("delR0c", std::cref(delR0c)));
133 ModelParamMap.insert(std::make_pair("delR0b", std::cref(delR0b)));
134 ModelParamMap.insert(std::make_pair("delGammaWlv", std::cref(delGammaWlv)));
135 ModelParamMap.insert(std::make_pair("delGammaWqq", std::cref(delGammaWqq)));
136 ModelParamMap.insert(std::make_pair("mneutrino_1", std::cref(leptons[NEUTRINO_1].getMass())));
137 ModelParamMap.insert(std::make_pair("mneutrino_2", std::cref(leptons[NEUTRINO_2].getMass())));
138 ModelParamMap.insert(std::make_pair("mneutrino_3", std::cref(leptons[NEUTRINO_3].getMass())));
139 ModelParamMap.insert(std::make_pair("melectron", std::cref(leptons[ELECTRON].getMass())));
140 ModelParamMap.insert(std::make_pair("mmu", std::cref(leptons[MU].getMass())));
141 ModelParamMap.insert(std::make_pair("mtau", std::cref(leptons[TAU].getMass())));
142 ModelParamMap.insert(std::make_pair("lambda", std::cref(lambda)));
143 ModelParamMap.insert(std::make_pair("A", std::cref(A)));
144 ModelParamMap.insert(std::make_pair("rhob", std::cref(rhob)));
145 ModelParamMap.insert(std::make_pair("etab", std::cref(etab)));
146 ModelParamMap.insert(std::make_pair("muw", std::cref(muw)));
147
148 iterationNo = 0;
149 realorder = LO;
150
151 w_GSL1 = gsl_integration_workspace_alloc (200);
152}
153
154StandardModel::~StandardModel()
155{
156 if (IsModelInitialized()) {
157 if (myEWSMcache != NULL) delete(myEWSMcache);
158 if (myOneLoopEW != NULL) delete(myOneLoopEW);
159 if (myTwoLoopQCD != NULL) delete(myTwoLoopQCD);
160 if (myThreeLoopQCD != NULL) delete(myThreeLoopQCD);
161 if (myTwoLoopEW != NULL) delete(myTwoLoopEW);
162 if (myThreeLoopEW2QCD != NULL) delete(myThreeLoopEW2QCD);
163 if (myThreeLoopEW != NULL) delete(myThreeLoopEW);
164 if (myApproximateFormulae != NULL) delete(myApproximateFormulae);
165 if (myLeptonFlavour != NULL) delete(myLeptonFlavour);
166 /* BEGIN: REMOVE FROM THE PACKAGE */
167 if (myTwoFermionsLEP2 != NULL) delete(myTwoFermionsLEP2);
168 /* END: REMOVE FROM THE PACKAGE */
169 }
170}
171
172
174// Initialization
175
176bool StandardModel::InitializeModel()
177{
178 myEWSMcache = new EWSMcache(*this);
179 myOneLoopEW = new EWSMOneLoopEW(*myEWSMcache);
180 myTwoLoopQCD = new EWSMTwoLoopQCD(*myEWSMcache);
181 myThreeLoopQCD = new EWSMThreeLoopQCD(*myEWSMcache);
182 myTwoLoopEW = new EWSMTwoLoopEW(*myEWSMcache);
183 myThreeLoopEW2QCD = new EWSMThreeLoopEW2QCD(*myEWSMcache);
184 myThreeLoopEW = new EWSMThreeLoopEW(*myEWSMcache);
185 myApproximateFormulae = new EWSMApproximateFormulae(*myEWSMcache);
186 myLeptonFlavour = new LeptonFlavour(*this);
187 /* BEGIN: REMOVE FROM THE PACKAGE */
188 myTwoFermionsLEP2 = new EWSMTwoFermionsLEP2(*myEWSMcache);
189 /* END: REMOVE FROM THE PACKAGE */
190 setModelInitialized(true);
191 return (true);
192}
193
194
196// Parameters
197
198bool StandardModel::Init(const std::map<std::string, double>& DPars)
199{
200 for (std::map<std::string, double>::const_iterator it = DPars.begin(); it != DPars.end(); it++)
201 if (it->first.compare("AlsM") == 0 || it->first.compare("MAls") == 0)
202 throw std::runtime_error("ERROR: inappropriate parameter " + it->first
203 + " in model initialization");
204 else if (FlagFixMuwMut && it->first.compare("mut") == 0)
205 throw std::runtime_error("ERROR: cannot use " + it->first
206 + " when FlagFixMuwMut is true: use only muw");
207
208 std::map<std::string, double> myDPars(DPars);
209 myDPars["AlsM"] = myDPars.at("AlsMz"); // do not change!
210 myDPars["MAls"] = myDPars.at("Mz");
211 if (FlagFixMuwMut)
212 myDPars["mut"] = myDPars.at("muw") * 163. / 80.4 ;
213 return (QCD::Init(myDPars));
214}
215
216bool StandardModel::PreUpdate()
217{
218 requireCKM = false;
219 requireYe = false;
220 requireYn = false;
221
222 if (!QCD::PreUpdate()) return (false);
223
224 return (true);
225}
226
227bool StandardModel::Update(const std::map<std::string, double>& DPars)
228{
229 if (!PreUpdate()) return (false);
230
231 UpdateError = false;
232
233 for (std::map<std::string, double>::const_iterator it = DPars.begin(); it != DPars.end(); it++)
234 setParameter(it->first, it->second);
235
236 if (UpdateError) return (false);
237
238 if (!PostUpdate()) return (false);
239
240 return (true);
241}
242
243bool StandardModel::PostUpdate()
244{
245 if (!QCD::PostUpdate()) return (false);
246
247 SMSuccess = true;
248 /* Set the CKM and PMNS matrices if not already set in the derived classes */
249 if(requireCKM)
250 computeCKM();
251
252 /* Compute the 5-quark contribution to the running of alpha*/
253 dAl5hMz = Dalpha5hMz();
254
255 /* Set the Yukawa matrices */
256 if (!isModelSUSY()) {
257 computeYukawas();
258 }
259
260 /* Check whether the parameters for the EWPO are updated or not */
261 if (!checkSMparamsForEWPO()) {
262 useDeltaAlphaLepton_cache = false;
263 useDeltaAlpha_cache = false;
264 useMw_cache = false;
265 useGammaW_cache = false;
266 for (int i = 0; i < 12; ++i) {
267 useRhoZ_f_cache[i] = false;
268 useKappaZ_f_cache[i] = false;
269 }
270 }
271 SMFlavour.setSMupdated();
272 /* Necessary for updating StandardModel parameters in StandardModelMatching */
273 if (!isModelSUSY()) SMM.getObj().updateSMParameters();
274
275 iterationNo++;
276
277 return (true);
278}
279
280void StandardModel::setParameter(const std::string name, const double& value)
281{
282 if (name.compare("Mz") == 0) {
283 Mz = value;
284 QCD::setParameter("MAls", value);
285 } else if (name.compare("AlsMz") == 0) {
286 AlsMz = value;
287 QCD::setParameter("AlsM", value);
288 } else if (name.compare("GF") == 0)
289 GF = value;
290 else if (name.compare("ale") == 0)
291 ale = value;
292 else if (name.compare("dAle5Mz") == 0 && !FlagMWinput)
293 dAle5Mz = value;
294 else if (name.compare("Mw_inp") == 0 && FlagMWinput)
295 Mw_inp = value;
296 else if (name.compare("mHl") == 0)
297 mHl = value;
298 else if (name.compare("delMw") == 0)
299 delMw = value;
300 else if (name.compare("delSin2th_l") == 0)
301 delSin2th_l = value;
302 else if (name.compare("delSin2th_q") == 0)
303 delSin2th_q = value;
304 else if (name.compare("delSin2th_b") == 0)
305 delSin2th_b = value;
306 else if (name.compare("delGammaZ") == 0)
307 delGammaZ = value;
308 else if (name.compare("delsigma0H") == 0)
309 delsigma0H = value;
310 else if (name.compare("delR0l") == 0)
311 delR0l = value;
312 else if (name.compare("delR0c") == 0)
313 delR0c = value;
314 else if (name.compare("delR0b") == 0)
315 delR0b = value;
316 else if (name.compare("delGammaWlv") == 0)
317 delGammaWlv = value;
318 else if (name.compare("delGammaWqq") == 0)
319 delGammaWqq = value;
320 else if (name.compare("mneutrino_1") == 0)
321 leptons[NEUTRINO_1].setMass(value);
322 else if (name.compare("mneutrino_2") == 0)
323 leptons[NEUTRINO_2].setMass(value);
324 else if (name.compare("mneutrino_3") == 0)
325 leptons[NEUTRINO_3].setMass(value);
326 else if (name.compare("melectron") == 0)
327 leptons[ELECTRON].setMass(value);
328 else if (name.compare("mmu") == 0)
329 leptons[MU].setMass(value);
330 else if (name.compare("mtau") == 0)
331 leptons[TAU].setMass(value);
332 else if (name.compare("lambda") == 0 && FlagWolfenstein) {
333 lambda = value;
334 requireCKM = true;
335 } else if (name.compare("A") == 0 && FlagWolfenstein) {
336 A = value;
337 requireCKM = true;
338 } else if (name.compare("rhob") == 0 && FlagWolfenstein) {
339 rhob = value;
340 requireCKM = true;
341 } else if (name.compare("etab") == 0 && FlagWolfenstein) {
342 etab = value;
343 requireCKM = true;
344 } else if (name.compare("V_us") == 0 && !FlagWolfenstein && !FlagUseVud) {
345 Vus = value;
346 requireCKM = true;
347 } else if (name.compare("V_ud") == 0 && !FlagWolfenstein && FlagUseVud) {
348 Vud = value;
349 requireCKM = true;
350 } else if (name.compare("V_cb") == 0 && !FlagWolfenstein) {
351 Vcb = value;
352 requireCKM = true;
353 } else if (name.compare("V_ub") == 0 && !FlagWolfenstein) {
354 Vub = value;
355 requireCKM = true;
356 } else if (name.compare("gamma") == 0 && !FlagWolfenstein) {
357 gamma = value;
358 requireCKM = true;
359 } else if (name.compare("muw") == 0) {
360 /* Update mut if FlagFixMuwMut is activated */
361 muw = value;
362 if (FlagFixMuwMut) {
363 mut = muw / 80.4 * 163.;
364 }
365 }
366 else
367 QCD::setParameter(name, value);
368}
369
370bool StandardModel::CheckParameters(const std::map<std::string, double>& DPars)
371{
372 for (int i = 0; i < NSMvars; i++) {
373 if (DPars.find(SMvars[i]) == DPars.end()) {
374 std::cout << "ERROR: missing mandatory SM parameter " << SMvars[i] << std::endl;
375 raiseMissingModelParameterCount();
376 addMissingModelParameter(SMvars[i]);
377 }
378 }
379 return (QCD::CheckParameters(DPars));
380}
381
382void StandardModel::computeCKM()
383{
384 if (requireCKM) {
385 if (FlagWolfenstein) {
386 myCKM.computeCKMwithWolfenstein(lambda, A, rhob, etab);
387 Vus = myCKM.getV_us().abs();
388 Vcb = myCKM.getV_cb().abs();
389 Vub = myCKM.getV_ub().abs();
390 gamma = myCKM.computeGamma();
391 } else if (FlagUseVud) {
392 myCKM.computeCKM(Vud, Vcb, Vub, gamma, FlagUseVud);
393 lambda = myCKM.getLambda();
394 A = myCKM.getA();
395 rhob = myCKM.getRhoBar();
396 etab = myCKM.getEtaBar();
397 Vus = myCKM.getV_us().abs();
398 } else {
399 myCKM.computeCKM(Vus, Vcb, Vub, gamma);
400 lambda = myCKM.getLambda();
401 A = myCKM.getA();
402 rhob = myCKM.getRhoBar();
403 etab = myCKM.getEtaBar();
404 Vud = myCKM.getV_ud().abs();
405 }
406 }
407 myPMNS.computePMNS(s12, s13, s23, delta, alpha21, alpha31); // WARNING: This does not do anything since the input values are not set.
408}
409
411
412
413
414
415
416void StandardModel::computeYukawas()
417{
418 if (requireYu || requireCKM) {
419 Yu.reset();
420 for (int i = 0; i < 3; i++) {
421 Yu.assign(i, i, this->getmq(quark(UP + 2 * i), v()/ sqrt(2.))/ v() * sqrt(2.));
422// std::cout << quarks[UP + 2 * i].getName() << " mass at EW scale is " << this->getmq(quark(UP + 2 * i), v() / sqrt(2.)) << std::endl;
423 }
424// std::cout << "(top MSbar mass is " << this->Mp2Mbar(this->getMtpole()) << ")" << std::endl;
425 Yu = Yu * myCKM.getCKM();
426 }
427 if (requireYd) {
428 Yd.reset();
429 for (int i = 0; i < 3; i++) {
430 Yd.assign(i, i, this->getmq(quark(DOWN + 2 * i), v() / sqrt(2.)) / v() * sqrt(2.));
431// std::cout << quarks[DOWN + 2 * i].getName() << " mass at " << v() / sqrt(2) << " is " << this->getmq(quark(DOWN + 2 * i), v() / sqrt(2.)) << std::endl;
432 }
433 }
434 if (requireYe) {
435 Ye = gslpp::matrix<gslpp::complex>::Id(3);
436 for (int i = 0; i < 3; i++)
437 Ye.assign(i, i, this->leptons[ELECTRON + 2 * i].getMass() / v() * sqrt(2.));
438 }
439 if (requireYn) {
440 Yn = gslpp::matrix<gslpp::complex>::Id(3);
441 for (int i = 0; i < 3; i++)
442 Yn.assign(i, i, this->leptons[NEUTRINO_1 + 2 * i].getMass() / v() * sqrt(2.));
443 Yn = Yn * myPMNS.getPMNS().hconjugate();
444 }
445}
446
447
448
449bool StandardModel::setFlag(const std::string name, const bool value)
450{
451 bool res = false;
452 if (name.compare("CacheInStandardModel") == 0) {
453 setFlagCacheInStandardModel(value);
454 res = true;
455 } else if (name.compare("CacheInEWSMcache") == 0) {
456 getMyEWSMcache()->setFlagCacheInEWSMcache(value);
457 res = true;
458 } else if (name.compare("Wolfenstein") == 0) {
459 FlagWolfenstein = value;
460 if(!FlagWolfenstein) {
461 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"lambda"))] = "V_us";
462 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"A"))] = "V_cb";
463 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"rhob"))] = "V_ub";
464 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"etab"))] = "gamma";
465
466 ModelParamMap.insert(std::make_pair("V_us", std::cref(Vus)));
467 ModelParamMap.insert(std::make_pair("V_cb", std::cref(Vcb)));
468 ModelParamMap.insert(std::make_pair("V_ub", std::cref(Vub)));
469 ModelParamMap.insert(std::make_pair("gamma", std::cref(gamma)));
470 }
471 res = true;
472 } else if (name.compare("WithoutNonUniversalVC") == 0) {
473 FlagWithoutNonUniversalVC = value;
474 res = true;
475 } else if (name.compare("NoApproximateGammaZ") == 0) {
476 FlagNoApproximateGammaZ = value;
477 res = true;
478 } else if (name.compare("MWinput") == 0) {
479 FlagMWinput = value;
480 if (FlagMWinput) {
481 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"dAle5Mz"))] = "Mw_inp";
482 ModelParamMap.insert(std::make_pair("Mw_inp", std::cref(Mw_inp)));
483 // Point the different flags towards the approximate formulae, when available
484 FlagNoApproximateGammaZ = false;
485 FlagMw = "APPROXIMATEFORMULA";
486 FlagRhoZ = "NORESUM";
487 FlagKappaZ = "APPROXIMATEFORMULA";
488 }
489 res = true;
490 } else if (name.compare("SMAux") == 0) {
491 FlagSMAux = value;
492 res = true;
493 } else if (name.compare("FixMuwMut") == 0) {
494 FlagFixMuwMut = value;
495 res = true;
496 } else if (name.compare("UseVud") == 0) {
497 FlagUseVud = value;
498 if (FlagUseVud && FlagWolfenstein)
499 throw std::runtime_error("UseVud can only be used when Wolfenstein is false");
500 else if(FlagUseVud) {
501 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"V_us"))] = "V_ud";
502 ModelParamMap.erase("V_us");
503 ModelParamMap.insert(std::make_pair("V_ud", std::cref(Vud)));
504 }
505 res = true;
506 } else
507 res = QCD::setFlag(name, value);
508
509 if (!res) res = SMFlavour.setFlag(name, value);
510
511 return (res);
512}
513
514bool StandardModel::setFlagStr(const std::string name, const std::string value)
515{
516 bool res = false;
517 if (name.compare("Mw") == 0) {
518 if (checkEWPOscheme(value)) {
519 FlagMw = value;
520 res = true;
521 } else
522 throw std::runtime_error("StandardModel::setFlagStr(): Invalid flag "
523 + name + "=" + value);
524
525 } else if (name.compare("RhoZ") == 0) {
526 if (checkEWPOscheme(value)) {
527 FlagRhoZ = value;
528 res = true;
529 } else
530 throw std::runtime_error("StandardModel::setFlagStr(): Invalid flag "
531 + name + "=" + value);
532 } else if (name.compare("KappaZ") == 0) {
533 if (checkEWPOscheme(value)) {
534 FlagKappaZ = value;
535 res = true;
536 } else
537 throw std::runtime_error("StandardModel::setFlagStr(): Invalid flag "
538 + name + "=" + value);
539 } else
540 res = QCD::setFlagStr(name, value);
541
542 if (FlagMWinput) {
543 // Point the different flags towards the approximate formulae, when available
544 FlagNoApproximateGammaZ = false;
545 FlagMw = "APPROXIMATEFORMULA";
546 FlagRhoZ = "NORESUM";
547 FlagKappaZ = "APPROXIMATEFORMULA";
548 }
549
550 return (res);
551}
552
553bool StandardModel::CheckFlags() const
554{
555 return (QCD::CheckFlags());
556}
557
558
560// For EWPO caches
561
562bool StandardModel::checkSMparamsForEWPO()
563{
564 // 11 parameters in QCD:
565 // AlsMz, Mz, mup, mdown, mcharm, mstrange, mtop, mbottom,
566 // mut, mub, muc
567 // 21 parameters in StandardModel
568 // GF, ale, dAle5Mz, mHl,
569 // mneutrino_1, mneutrino_2, mneutrino_3, melectron, mmu, mtau,
570 // delMw, delSin2th_l, delSin2th_q, delSin2th_b, delGammaZ, delsigma0H, delR0l, delR0c, delR0b, delGammaWlv, delGammaWqq,
571 // 3 flags in StandardModel
572 // FlagMw_cache, FlagRhoZ_cache, FlagKappaZ_cache
573
574 // Note: When modifying the array below, the constant NumSMParams has to
575 // be modified accordingly.
576 double SMparams[NumSMParamsForEWPO] = {
577 AlsMz, Mz, GF, ale, FlagMWinput? Mw_inp: dAle5Mz,
578 mHl, mtpole,
579 leptons[NEUTRINO_1].getMass(),
580 leptons[NEUTRINO_2].getMass(),
581 leptons[NEUTRINO_3].getMass(),
582 leptons[ELECTRON].getMass(),
583 leptons[MU].getMass(),
584 leptons[TAU].getMass(),
585 quarks[UP].getMass(),
586 quarks[DOWN].getMass(),
587 quarks[CHARM].getMass(),
588 quarks[STRANGE].getMass(),
589 quarks[BOTTOM].getMass(),
590 mut, mub, muc,
591 delMw, delSin2th_l, delSin2th_q, delSin2th_b, delGammaZ, delsigma0H, delR0l, delR0c, delR0b, delGammaWlv, delGammaWqq,
592 SchemeToDouble(FlagMw),
593 SchemeToDouble(FlagRhoZ),
594 SchemeToDouble(FlagKappaZ)
595 };
596
597 // check updated parameters
598 bool bNotUpdated = true;
599 for (int i = 0; i < NumSMParamsForEWPO; ++i) {
600 if (SMparamsForEWPO_cache[i] != SMparams[i]) {
601 SMparamsForEWPO_cache[i] = SMparams[i];
602 bNotUpdated &= false;
603 }
604 }
605
606 return bNotUpdated;
607}
608
610
611const double StandardModel::ale_OS(const double mu, orders order) const
612{
613 if (mu < 50.0)
614 throw std::runtime_error("out of range in StandardModel::ale_OS()");
615
616 double N = 20.0 / 3.0;
617 double beta1 = N / 3.0;
618 double beta2 = N / 4.0;
619 double alpha_ini = alphaMz();
620 double v = 1.0 + 2.0 * beta1 * alpha_ini / M_PI * log(Mz / mu);
621
622 switch (order) {
623 case LO:
624 return ( alpha_ini / v);
625 case FULLNLO:
626 return ( alpha_ini / v * (1.0 - beta2 / beta1 * alpha_ini / M_PI * log(v) / v));
627 default:
628 throw std::runtime_error("Error in StandardModel::ale_OS()");
629 }
630}
631
632const double StandardModel::Beta_s(int nm, unsigned int nf) const
633{
634 unsigned int nu = nf % 2 == 0 ? nf / 2 : nf / 2;
635 unsigned int nd = nf % 2 == 0 ? nf / 2 : 1 + nf / 2;
636 double Qu = 2. / 3., Qd = -1. / 3., Qbar2 = nu * Qu * Qu + nd * Qd * Qd,
637 Qbar4 = nu * Qu * Qu * Qu * Qu + nd * Qd * Qd * Qd * Qd;
638
639 switch(nm)
640 {
641 case 00:
642 return(Beta0((double) nf));
643 case 10:
644 return(Beta1((double) nf));
645 case 20:
646 return(Beta2((double) nf));
647 case 30:
648 return(Beta3((double) nf));
649 case 01:
650 return(-4. * TF * Qbar2 );
651 case 11:
652 return((4. * CF - 8. * CA) * TF * Qbar2 );
653 case 02:
654 return(11./3. * TF * Qbar2 * Beta_e(00, nf) + 2. * TF * Qbar4);
655 default:
656 throw std::runtime_error("StandardModel::Beta_s(): case not implemented");
657 }
658}
659
660const double StandardModel::Beta_e(int nm, unsigned int nf) const
661{
662 unsigned int nu = nf % 2 == 0 ? nf / 2 : nf / 2;
663 unsigned int nd = nf % 2 == 0 ? nf / 2 : 1 + nf / 2;
664 double Qu = 2. / 3., Qd = -1. / 3., Qbar2 = nu * Qu * Qu + nd * Qd * Qd,
665 Qbar4 = nu * Qu * Qu * Qu * Qu + nd * Qd * Qd * Qd * Qd;
666
667 switch(nm)
668 {
669 case 00:
670 return(4./3. * (Qbar2 * Nc + 3.)); // QL^2 = 1
671 case 10:
672 return(4. * (Qbar4 * Nc + 3.));
673 case 01:
674 return(4. * CF * Nc * Qbar2);
675 default:
676 throw std::runtime_error("StandardModel::Beta_e(): case not implemented");
677 }
678}
679
680const double StandardModel::AlsE(double mu, orders order, bool Nf_thr) const
681{
682 switch (order)
683 {
684 case FULLNNNLO:
685 realorder = order;
686 return (AlsByOrder(mu, LO, Nf_thr) + AlsByOrder(mu, NLO, Nf_thr) + AlsByOrder(mu, NNLO, Nf_thr) + AlsEByOrder(mu, NNNLO, Nf_thr));
687 default:
688 throw std::runtime_error("StandardModel::AlsE(): " + orderToString(order) + " is not implemented.");
689 }
690}
691
692const double StandardModel::AlsEByOrder(double mu, orders order, bool Nf_thr) const
693{
694 int i, nfAls = (int) Nf(Mz), nfmu = Nf_thr ? (int) Nf(mu) : nfAls;
695 double als, alstmp, mutmp;
696 orders fullord;
697
698 for (i = 0; i < CacheSize; ++i)
699 if ((mu == als_cache[0][i]) && ((double) order == als_cache[1][i]) &&
700 (AlsMz == als_cache[2][i]) && (Mz == als_cache[3][i]) &&
701 (mut == als_cache[4][i]) && (mub == als_cache[5][i]) &&
702 (muc == als_cache[6][i]) && (double) true == als_cache[7][i]
703 && (double) Nf_thr == als_cache[8][i] && alphaMz() == als_cache[9][i])
704 return als_cache[10][i];
705
706 switch (order)
707 {
708 case NNNLO:
709 if (nfAls == nfmu)
710 als = AlsEWithInit(mu, AlsMz, Mz, nfAls, order);
711 fullord = FullOrder(order);
712 if (nfAls > nfmu) {
713 mutmp = BelowTh(Mz);
714 alstmp = AlsEWithInit(mutmp, AlsMz, Mz, nfAls, realorder);
715 alstmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(nfAls), alstmp, nfAls, fullord)); // WARNING: QED threshold corrections not implemented yet
716 for (i = nfAls - 1; i > nfmu; i--) {
717 mutmp = BelowTh(mutmp - MEPS);
718 alstmp = AlsEWithInit(mutmp, alstmp, AboveTh(mutmp) - MEPS, i, realorder);
719 alstmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(i), alstmp, i, fullord)); // WARNING: QED threshold corrections not implemented yet
720 }
721 als = AlsEWithInit(mu, alstmp, AboveTh(mu) - MEPS, nfmu, order);
722 }
723
724 if (nfAls < nfmu) {
725 mutmp = AboveTh(Mz) - MEPS;
726 alstmp = AlsEWithInit(mutmp, AlsMz, Mz, nfAls, realorder);
727 alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(nfAls + 1), alstmp, nfAls + 1, fullord)); // WARNING: QED threshold corrections not implemented yet
728 for (i = nfAls + 1; i < nfmu; i++) {
729 mutmp = AboveTh(mutmp) - MEPS;
730 alstmp = AlsEWithInit(mutmp, alstmp, BelowTh(mutmp) + MEPS, i, realorder);
731 alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(i + 1), alstmp, i + 1, fullord)); // WARNING: QED threshold corrections not implemented yet
732 }
733 als = AlsEWithInit(mu, alstmp, BelowTh(mu) + MEPS, nfmu, order);
734 }
735
736 CacheShift(als_cache, 11);
737 als_cache[0][0] = mu;
738 als_cache[1][0] = (double) order;
739 als_cache[2][0] = AlsMz;
740 als_cache[3][0] = Mz;
741 als_cache[4][0] = mut;
742 als_cache[5][0] = mub;
743 als_cache[6][0] = muc;
744 als_cache[7][0] = (double) true;
745 als_cache[8][0] = (double) Nf_thr;
746 als_cache[9][0] = alphaMz();
747 als_cache[10][0] = als;
748
749 return als;
750 default:
751 throw std::runtime_error("StandardModel::AlsEByOrder(): " + orderToString(order) + " is not implemented.");
752 }
753}
754
755const double StandardModel::AlsEWithInit(double mu, double alsi, double mu_i, const int nf_i, orders order) const
756{
757 double nf = (double) nf_i, alei = Ale(mu_i, FULLNLO); // CHANGE ME!
758 double b00s = Beta_s(00, nf), b00e = Beta_e(00, nf);
759 double v = 1. + b00s * alsi / 2. / M_PI * log(mu / mu_i);
760 double ve = 1. - b00e * alei / 2. / M_PI * log(mu / mu_i);
761 double logv = log(v), logve = log(ve);
762 double rho = 1. / (1. + b00e * alei / b00s / alsi);
763 double als = AlsWithInit(mu, alsi, mu_i, nf, order);
764 double b01s = Beta_s(01,nf), b01s00e = b01s / b00e;
765
766 switch (order)
767 {
768 case NNNLO:
769 als += alsi * alsi * alei / 4. / 4. / M_PI / M_PI / v / v / ve * (Beta_s(02, nf) / b00e *
770 (ve - 1.) + Beta_s(11, nf) / b00s * rho * ve * (logve - logv) + b01s00e * Beta_e(10, nf) /
771 b00e * (logve - ve + 1.) + b01s * Beta_s(10, nf) / b00s / b00s * rho * logv +
772 b01s00e * Beta_e(01, nf) / b00s * (rho * ve * (logv - logve) - logv));
773 break;
774 case FULLNNNLO:
775 return (AlsWithInit(mu, alsi, mu_i, nf_i, LO) + AlsWithInit(mu, alsi, mu_i, nf_i, NLO)+ AlsWithInit(mu, alsi, mu_i, nf_i, NNLO) + AlsEWithInit(mu, alsi, mu_i, nf_i, NNNLO));
776 default:
777 throw std::runtime_error("StandardModel::AlsEWithInit(): " + orderToString(order) + " is not implemented.");
778 }
779
780 return (als);
781}
782
783const double StandardModel::Ale(const double mu, orders order, bool Nf_thr) const
784{
785 int i, nfAle = (int) Nf(Mz), nfmu = Nf_thr ? (int) Nf(mu) : nfAle;
786 double ale, aletmp, mutmp, aleMz = alphaMz();
787 orders fullord;
788
789 for (i = 0; i < CacheSize; ++i)
790 if ((mu == ale_cache[0][i]) && ((double) order == ale_cache[1][i]) &&
791 (AlsMz == ale_cache[2][i]) && (Mz == ale_cache[3][i]) &&
792 (mut == ale_cache[4][i]) && (mub == ale_cache[5][i]) &&
793 (muc == ale_cache[6][i])
794 && (double) Nf_thr == ale_cache[7][i] && aleMz == ale_cache[8][i])
795 return ale_cache[9][i];
796
797 switch (order)
798 {
799 case FULLNLO:
800 return (Ale(mu, LO, Nf_thr) + Ale(mu, NLO, Nf_thr));
801 case FULLNNLO:
802 return (Ale(mu, LO, Nf_thr) + Ale(mu, NLO, Nf_thr) + Ale(mu, NNLO, Nf_thr));
803 case FULLNNNLO:
804 return (Ale(mu, LO, Nf_thr) + Ale(mu, NLO, Nf_thr) + Ale(mu, NNLO, Nf_thr) + Ale(mu, NNNLO, Nf_thr));
805 case LO:
806 if (nfAle == nfmu)
807 return(AleWithInit(mu, aleMz, Mz, order));
808 case NLO:
809 case NNLO:
810 case NNNLO:
811 if (nfAle == nfmu)
812 return(0.);
813 fullord = FullOrder(order);
814 if (nfAle > nfmu) {
815 mutmp = BelowTh(Mz);
816 aletmp = AleWithInit(mutmp, aleMz, Mz, fullord);
817// aletmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(nfAle), alstmp, nfAls, fullord)); // WARNING: QED threshold corrections not implemented yet
818 for (i = nfAle - 1; i > nfmu; i--) {
819 mutmp = BelowTh(mutmp - MEPS);
820 aletmp = AleWithInit(mutmp, aletmp, AboveTh(mutmp) - MEPS, fullord);
821// aletmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(i), aletmp, i, fullord)); // WARNING: QED threshold corrections not implemented yet
822 }
823 ale = AleWithInit(mu, aletmp, AboveTh(mu) - MEPS, order);
824 }
825
826 if (nfAle < nfmu) {
827 mutmp = AboveTh(Mz) - MEPS;
828 aletmp = AleWithInit(mutmp, aleMz, Mz, fullord);
829// alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(nfAls + 1), alstmp, nfAls + 1, fullord)); // WARNING: QED threshold corrections not implemented yet
830 for (i = nfAle + 1; i < nfmu; i++) {
831 mutmp = AboveTh(mutmp) - MEPS;
832 aletmp = AleWithInit(mutmp, aletmp, BelowTh(mutmp) + MEPS, fullord);
833// alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(i + 1), alstmp, i + 1, fullord)); // WARNING: QED threshold corrections not implemented yet
834 }
835 ale = AleWithInit(mu, aletmp, BelowTh(mu) + MEPS, order);
836 }
837
838 CacheShift(ale_cache, 10);
839 ale_cache[0][0] = mu;
840 ale_cache[1][0] = (double) order;
841 ale_cache[2][0] = AlsMz;
842 ale_cache[3][0] = Mz;
843 ale_cache[4][0] = mut;
844 ale_cache[5][0] = mub;
845 ale_cache[6][0] = muc;
846 ale_cache[7][0] = (double) Nf_thr;
847 ale_cache[8][0] = aleMz;
848 ale_cache[9][0] = ale;
849
850 return ale;
851 default:
852 throw std::runtime_error("StandardModel::Ale(): " + orderToString(order) + " is not implemented.");
853 }
854}
855
856const double StandardModel::AleWithInit(double mu, double alei, double mu_i, orders order) const
857{
858 if (fabs(mu - mu_i) < MEPS) return(alei);
859
860 double nf = Nf(mu), alsi = (mu_i == Mz ? AlsMz : Als(mu_i, FULLNNNLO, true, true));
861 double b00e = Beta_e(00, nf), b00s = Beta_s(00, nf);
862 double ve = 1. - b00e * alei / 2. / M_PI * log(mu / mu_i);
863 double logv = log(1. + b00s * alsi / 2. / M_PI * log(mu / mu_i)), logve = log(ve);
864
865 switch (order)
866 {
867 case LO:
868 return (alei / ve);
869 case NLO:
870 return (- alei * alei / 4. / M_PI / ve / ve * (Beta_e(10, nf) / b00e * logve - Beta_e(01, nf) / b00s * logv) );
871 // Higher order terms ? Need to understand eq. (35)
872 case FULLNLO:
873 return (AleWithInit(mu, alei, mu_i, LO) + AleWithInit(mu, alei, mu_i, NLO));
874 default:
875 throw std::runtime_error("StandardModel::AleWithInit(): " + orderToString(order) + " is not implemented.");
876 }
877}
878
879const double StandardModel::DeltaAlphaLepton(const double s) const
880{
881 if (s == Mz * Mz)
882 if (FlagCacheInStandardModel)
883 if (useDeltaAlphaLepton_cache)
884 return DeltaAlphaLepton_cache;
885
886 double DeltaAlphaL = 0.0;
887 if (flag_order[EW1])
888 DeltaAlphaL += myOneLoopEW->DeltaAlpha_l(s);
889 if (flag_order[EW1QCD1])
890 DeltaAlphaL += myTwoLoopQCD->DeltaAlpha_l(s);
891 if (flag_order[EW1QCD2])
892 DeltaAlphaL += myThreeLoopQCD->DeltaAlpha_l(s);
893 if (flag_order[EW2])
894 DeltaAlphaL += myTwoLoopEW->DeltaAlpha_l(s);
895 if (flag_order[EW2QCD1])
896 DeltaAlphaL += myThreeLoopEW2QCD->DeltaAlpha_l(s);
897 if (flag_order[EW3])
898 DeltaAlphaL += myThreeLoopEW->DeltaAlpha_l(s);
899
900 if (s == Mz * Mz) {
901 DeltaAlphaLepton_cache = DeltaAlphaL;
902 useDeltaAlphaLepton_cache = true;
903 }
904 return DeltaAlphaL;
905}
906
907const double StandardModel::DeltaAlphaL5q() const
908{
909 double Mz2 = Mz*Mz;
910 return (DeltaAlphaLepton(Mz2) + dAl5hMz);
911}
912
913const double StandardModel::DeltaAlphaTop(const double s) const
914{
915 double DeltaAlpha = 0.0;
916 if (flag_order[EW1])
917 DeltaAlpha += myOneLoopEW->DeltaAlpha_t(s);
918 if (flag_order[EW1QCD1])
919 DeltaAlpha += myTwoLoopQCD->DeltaAlpha_t(s);
920 if (flag_order[EW1QCD2])
921 DeltaAlpha += myThreeLoopQCD->DeltaAlpha_t(s);
922 if (flag_order[EW2])
923 DeltaAlpha += myTwoLoopEW->DeltaAlpha_t(s);
924 if (flag_order[EW2QCD1])
925 DeltaAlpha += myThreeLoopEW2QCD->DeltaAlpha_t(s);
926 if (flag_order[EW3])
927 DeltaAlpha += myThreeLoopEW->DeltaAlpha_t(s);
928
929 return DeltaAlpha;
930}
931
932const double StandardModel::DeltaAlpha() const
933{
934 if (FlagCacheInStandardModel)
935 if (useDeltaAlpha_cache)
936 return DeltaAlpha_cache;
937
938 double Mz2 = Mz*Mz;
939 DeltaAlpha_cache = DeltaAlphaL5q() + DeltaAlphaTop(Mz2);
940 useDeltaAlpha_cache = true;
941 return DeltaAlpha_cache;
942}
943
944const double StandardModel::alphaMz() const
945{
946 return (ale / (1.0 - DeltaAlpha()));
947// return(1./127.918); // FOR HEFFDF1 TEST: VALUE IN hep-ph/0512066
948// return(1./127.955); // FOR HEFFDF1 TEST: VALUE IN 2007.04191
949}
950
951const double StandardModel::Alstilde5(const double mu) const
952{
953 double mu_0 = Mz;
954 double alphatilde_e = alphaMz()/4./M_PI;
955 double alphatilde_s = AlsMz/4./M_PI;
956 unsigned int nf = 5;
957
958 double B00S = Beta0(nf), B10S = Beta1(nf), B20S = Beta2(nf), B30S = gsl_sf_zeta_int(3) * 352864./81. - 598391./1458,
959 B01S = -22./9., B11S = -308./27., B02S = 4945./243.;
960
961 double B00E = 80./9., B01E = 176./9., B10E = 464./27.;
962
963 double B10soB00s = B10S / B00S;
964 double B01soB00e = B01S/B00E;
965
966 double vs= 1. + 2. * B00S * alphatilde_s * log(mu/ mu_0);
967 double ve= 1. - 2. * B00E * alphatilde_e * log(mu/ mu_0);
968 double ps= B00S * alphatilde_s /(B00S * alphatilde_s + B00E * alphatilde_e);
969
970 double logve = log(ve);
971 double logvs = log(vs);
972 double logeos = log(ve/vs);
973 double logsoe = log(vs/ve);
974 double asovs = alphatilde_s/vs;
975 double aeove = alphatilde_e/ve;
976
977 double result = 0;
978
979 result = asovs - pow(asovs, 2) * (logvs * B10soB00s - logve * B01soB00e)
980 + pow(asovs, 3) * ((1. - vs) * B20S / B00S + B10soB00s * B10soB00s * (logvs * logvs - logvs
981 + vs - 1.) + B01soB00e * B01soB00e * logve * logve + (-2. * logvs * logve
982 + ps * ve * logve) * B01S * B10S/(B00E * B00S))
983 + pow(asovs, 4) * (0.5 * B30S *(1. - vs * vs)/ B00S + ((2. * vs - 3.) * logvs + vs * vs
984 - vs) * B20S * B10soB00s /(B00S) + B10soB00s * B10soB00s * B10soB00s * (- pow(logvs,3)
985 + 5. * pow(logvs,2) / 2. + 2. * (1. - vs) * logvs - (vs - 1.) * (vs - 1.)* 0.5))
986 + pow(asovs, 2) * (aeove) * ((ve - 1.) * B02S / B00E
987 + ps * ve * logeos * B11S /B00S +(logve - ve + 1.) * B01soB00e * B10E/(B00E)
988 + logvs * ps * B01S * B10soB00s/(B00S) +(logsoe * ve * ps - logvs) * B01soB00e * B01E/( B00S));
989 return (result);
990}
991
992
994
995const double StandardModel::v() const
996{
997 return ( 1. / sqrt(sqrt(2.) * GF));
998}
999
1000
1002
1003const double StandardModel::Mw_tree() const
1004{
1005 if (FlagMWinput){
1006 return Mw_inp;
1007 } else
1008 return ( Mz / sqrt(2.0) * sqrt(1.0 + sqrt(1.0 - 4.0 * M_PI * ale / sqrt(2.0) / GF / Mz / Mz)));
1009}
1010
1011const double StandardModel::s02() const
1012{
1013 double tmp = 1.0 - 4.0 * M_PI * alphaMz() / sqrt(2.0) / GF / Mz / Mz;
1014 if (tmp < 0.0)
1015 throw std::runtime_error("Error in s02()");
1016
1017 return ( (1.0 - sqrt(tmp)) / 2.0);
1018}
1019
1020const double StandardModel::c02() const
1021{
1022 return ( 1.0 - s02());
1023}
1024
1025const double StandardModel::Mw() const
1026{
1027 /* Debug */
1028 //std::cout << std::boolalpha
1029 // << checkScheme(schemeMw_cache,schemeMw,false)
1030 // << " [cache:" << schemeMw_cache
1031 // << " current:" << schemeMw << "]" << std::endl;
1032
1033 if (FlagMWinput)
1034 return Mw_inp;
1035
1036 if (FlagCacheInStandardModel)
1037 if (useMw_cache)
1038 return Mw_cache;
1039
1040 double Mw;
1041 if (FlagMw.compare("APPROXIMATEFORMULA") == 0)
1042 Mw = myApproximateFormulae->Mw();
1043 else {
1044 //std::cout << std::setprecision(12)
1045 // << "TEST: Mw_tree = " << Mw_tree() << std::endl;
1046
1047 double DeltaRho[orders_EW_size], DeltaR_rem[orders_EW_size];
1048 ComputeDeltaRho(Mw_tree(), DeltaRho);
1049 ComputeDeltaR_rem(Mw_tree(), DeltaR_rem);
1050 Mw = resumMw(Mw_tree(), DeltaRho, DeltaR_rem);
1051
1052 /* Mw from iterations */
1053 double Mw_org = Mw_tree();
1054 while (fabs(Mw - Mw_org) > Mw_error) {
1055 Mw_org = Mw;
1056 ComputeDeltaRho(Mw, DeltaRho);
1057 ComputeDeltaR_rem(Mw, DeltaR_rem);
1058 Mw = resumMw(Mw, DeltaRho, DeltaR_rem);
1059 /* TEST */
1060 //int prec_def = std::cout.precision();
1061 //std::cout << std::setprecision(12) << "TEST: Mw_org = " << Mw_org
1062 // << " Mw_new = " << Mw << std::endl;
1063 //std::cout.precision(prec_def);
1064 }
1065 }
1066
1067// Mw = 80.426; // FOR HEFFDF1 TEST: VALUE IN hep-ph/0512066
1068// Mw = 80.379; // FOR HEFFDF1 TEST: VALUE IN 2007.04191
1069 Mw_cache = Mw;
1070 useMw_cache = true;
1071 return Mw;
1072}
1073
1074const double StandardModel::Dalpha5hMz() const
1075{
1076 if (FlagMWinput){
1077 return (myApproximateFormulae->dAlpha5hMw());
1078 } else
1079 return dAle5Mz;
1080}
1081
1082const double StandardModel::cW2(double Mw_i) const
1083{
1084 return ( Mw_i * Mw_i / Mz / Mz);
1085}
1086
1087const double StandardModel::cW2() const
1088{
1089 return ( cW2(Mw()));
1090// return (1.0 - 0.2312); // FOR HEFFDF1 TEST
1091}
1092
1093const double StandardModel::sW2(double Mw_i) const
1094{
1095 return ( 1.0 - cW2(Mw_i));
1096}
1097
1098const double StandardModel::sW2() const
1099{
1100 return ( 1.0 - cW2());
1101}
1102
1103const double StandardModel::sW2_MSbar_Approx() const
1104{
1105 //double rho_t= 3. * getGF() * getMtpole() * getMtpole() / (8. * sqrt(2.) * M_PI * M_PI );
1106 return ( sW2()*1.0351 ); //PDG 22 electroweak review eq. (10.19)
1107}
1108
1109const double StandardModel::sW2_ND() const
1110{
1111 double d = 1. / 3. * (1. / sW2_MSbar_Approx() - 8. / 3.) *
1112 ( (1 + getAlsMz()/M_PI)*log(getMtpole()/getMz()) - 15.*getAlsMz()/(8.*M_PI) );
1113
1114 return sW2_MSbar_Approx()*(1. + Ale(getMz(),FULLNLO)*d/M_PI);
1115
1116}
1117
1118const double StandardModel::DeltaR() const
1119{
1120 /* in the experimental/running-width scheme */
1121 double myMw = Mw();
1122 double sW2 = 1.0 - myMw * myMw / Mz / Mz;
1123 double tmp = sqrt(2.0) * GF * sW2 * myMw * myMw / M_PI / ale;
1124 if (FlagMw.compare("NORESUM") == 0
1125 || FlagMw.compare("APPROXIMATEFORMULA") == 0) {
1126 return (tmp - 1.0);
1127 } else {
1128 return (1.0 - 1.0 / tmp);
1129 }
1130}
1131
1132void StandardModel::ComputeDeltaRho(double Mw_i,
1133 double DeltaRho[orders_EW_size]) const
1134{
1135 if (flag_order[EW1])
1136 DeltaRho[EW1] = myOneLoopEW->DeltaRho(Mw_i);
1137 else
1138 DeltaRho[EW1] = 0.0;
1139 if (flag_order[EW1QCD1])
1140 DeltaRho[EW1QCD1] = myTwoLoopQCD->DeltaRho(Mw_i);
1141 else
1142 DeltaRho[EW1QCD1] = 0.0;
1143 if (flag_order[EW1QCD2])
1144 DeltaRho[EW1QCD2] = myThreeLoopQCD->DeltaRho(Mw_i);
1145 else
1146 DeltaRho[EW1QCD2] = 0.0;
1147 if (flag_order[EW2])
1148 DeltaRho[EW2] = myTwoLoopEW->DeltaRho(Mw_i);
1149 else
1150 DeltaRho[EW2] = 0.0;
1151 if (flag_order[EW2QCD1])
1152 DeltaRho[EW2QCD1] = myThreeLoopEW2QCD->DeltaRho(Mw_i);
1153 else
1154 DeltaRho[EW2QCD1] = 0.0;
1155 if (flag_order[EW3])
1156 DeltaRho[EW3] = myThreeLoopEW->DeltaRho(Mw_i);
1157 else
1158 DeltaRho[EW3] = 0.0;
1159}
1160
1161void StandardModel::ComputeDeltaR_rem(const double Mw_i,
1162 double DeltaR_rem[orders_EW_size]) const
1163{
1164 if (flag_order[EW1])
1165 DeltaR_rem[EW1] = myOneLoopEW->DeltaR_rem(Mw_i);
1166 else
1167 DeltaR_rem[EW1] = 0.0;
1168 if (flag_order[EW1QCD1])
1169 DeltaR_rem[EW1QCD1] = myTwoLoopQCD->DeltaR_rem(Mw_i);
1170 else
1171 DeltaR_rem[EW1QCD1] = 0.0;
1172 if (flag_order[EW1QCD2])
1173 DeltaR_rem[EW1QCD2] = myThreeLoopQCD->DeltaR_rem(Mw_i);
1174 else
1175 DeltaR_rem[EW1QCD2] = 0.0;
1176 if (flag_order[EW2])
1177 DeltaR_rem[EW2] = myTwoLoopEW->DeltaR_rem(Mw_i);
1178 else
1179 DeltaR_rem[EW2] = 0.0;
1180 if (flag_order[EW2QCD1])
1181 DeltaR_rem[EW2QCD1] = myThreeLoopEW2QCD->DeltaR_rem(Mw_i);
1182 else
1183 DeltaR_rem[EW2QCD1] = 0.0;
1184 if (flag_order[EW3])
1185 DeltaR_rem[EW3] = myThreeLoopEW->DeltaR_rem(Mw_i);
1186 else
1187 DeltaR_rem[EW3] = 0.0;
1188}
1189
1190
1192
1193double StandardModel::Mzbar() const
1194{
1195 double G0 = GF * pow(Mz, 3.0) / 24.0 / sqrt(2.0) / M_PI;
1196 double sW2tree = 1.0 - Mw_tree() * Mw_tree() / Mz / Mz;
1197 double Gz = 6.0 * G0; // neutrinos
1198 Gz += 3.0 * G0 * (pow(1.0 - 4.0 * sW2tree, 2.0) + 1.0); // e, mu and tau
1199 Gz += 6.0 * G0 * (pow(1.0 - 8.0 / 3.0 * sW2tree, 2.0) + 1.0)
1200 * (1.0 + AlsMz / M_PI); // u and c
1201 Gz += 9.0 * G0 * (pow(1.0 - 4.0 / 3.0 * sW2tree, 2.0) + 1.0)
1202 * (1.0 + AlsMz / M_PI); // d, s and b
1203
1204 //Gz = 2.4952; // experimental data
1205 //std::cout << "Gz=" << Gz << std::endl; // for test
1206
1207 return ( Mz - Gz * Gz / 2.0 / Mz);
1208}
1209
1210const double StandardModel::MwbarFromMw(const double Mw) const
1211{
1212 double AlsMw = Als(Mw, FULLNLO);
1213 double Gw_SM = 3.0 * GF * pow(Mw, 3.0) / 2.0 / sqrt(2.0) / M_PI
1214 * (1.0 + 2.0 * AlsMw / 3.0 / M_PI);
1215
1216 return ( Mw - Gw_SM * Gw_SM / 2.0 / Mw);
1217}
1218
1219const double StandardModel::MwFromMwbar(const double Mwbar) const
1220{
1221 double AlsMw = Als(Mwbar, FULLNNLO);
1222 double Gw_SM = 3.0 * GF * pow(Mwbar, 3.0) / 2.0 / sqrt(2.0) / M_PI
1223 * (1.0 + 2.0 * AlsMw / 3.0 / M_PI);
1224
1225 return (Mwbar + Gw_SM * Gw_SM / 2.0 / Mwbar);
1226}
1227
1228const double StandardModel::DeltaRbar() const
1229{
1230 double Mwbar_SM = MwbarFromMw(Mw());
1231 double sW2bar = 1.0 - Mwbar_SM * Mwbar_SM / Mzbar() / Mzbar();
1232 double tmp = sqrt(2.0) * GF * sW2bar * Mwbar_SM * Mwbar_SM / M_PI / ale;
1233
1234 return (tmp - 1.0);
1235}
1236
1237
1239
1240const double StandardModel::rho_GammaW(const Particle fi, const Particle fj) const
1241{
1242 double rhoW = 0.0;
1243 if (flag_order[EW1])
1244 rhoW = myOneLoopEW->rho_GammaW(fi, fj, Mw());
1245 return rhoW;
1246}
1247
1248const double StandardModel::GammaW(const Particle fi, const Particle fj) const
1249{
1250 if ((fi.getIndex()) % 2 || (fj.getIndex() + 1) % 2)
1251 throw std::runtime_error("Error in StandardModel::GammaW()");
1252
1253 double G0 = GF * pow(Mw(), 3.0) / 6.0 / sqrt(2.0) / M_PI;
1254 gslpp::complex V(0.0, 0.0, false);
1255
1256 if (fi.is("TOP"))
1257 return (0.0);
1258
1259 if (fj.getIndex() - fi.getIndex() == 1)
1260 V = gslpp::complex(1.0, 0.0, false);
1261 else
1262 V = gslpp::complex(0.0, 0.0, false);
1263
1264 if (fi.is("LEPTON"))
1265 return ( V.abs2() * G0 * rho_GammaW(fi, fj) * ( 1.0 + delGammaWlv ) );
1266 else {
1267 double AlsMw = AlsWithInit(Mw(), AlsMz, Mz, 5, FULLNLO);
1268 return ( 3.0 * V.abs2() * G0 * rho_GammaW(fi, fj) * (1.0 + AlsMw / M_PI) * ( 1.0 + delGammaWqq ) );
1269 }
1270}
1271
1272const double StandardModel::GammaW() const
1273{
1274 if (FlagCacheInStandardModel)
1275 if (useGammaW_cache)
1276 return GammaW_cache;
1277
1278 double GammaWtmp = 0.;
1279
1280 for (int i = 0; i < 6; i += 2)
1281 GammaWtmp += GammaW(leptons[i], leptons[i + 1]) + GammaW(quarks[i], quarks[i + 1]);
1282
1283 GammaW_cache = GammaWtmp;
1284 useGammaW_cache = true;
1285 return GammaWtmp;
1286}
1287
1288
1289const double StandardModel::BrW(const Particle fi, const Particle fj) const
1290{
1291 double GammW = GammaW();
1292 double GammWij = GammaW(fi, fj);
1293
1294 return GammWij/GammW;
1295}
1296
1297
1298const double StandardModel::RWlilj(const Particle li, const Particle lj) const
1299{
1300 double GammWli, GammWlj;
1301
1302 if (li.is("ELECTRON"))
1303 GammWli = GammaW(leptons[NEUTRINO_1],li);
1304 else if (li.is("MU"))
1305 GammWli = GammaW(leptons[NEUTRINO_2],li);
1306 else if (li.is("TAU"))
1307 GammWli = GammaW(leptons[NEUTRINO_3],li);
1308 else
1309 throw std::runtime_error("Error in StandardModel::RWlilj. li must be a charged lepton");
1310
1311 if (lj.is("ELECTRON"))
1312 GammWlj = GammaW(leptons[NEUTRINO_1],lj);
1313 else if (lj.is("MU"))
1314 GammWlj = GammaW(leptons[NEUTRINO_2],lj);
1315 else if (lj.is("TAU"))
1316 GammWlj = GammaW(leptons[NEUTRINO_3],lj);
1317 else
1318 throw std::runtime_error("Error in StandardModel::RWlilj. lj must be a charged lepton");
1319
1320 return GammWli/GammWlj;
1321}
1322
1323const double StandardModel::Ruc() const //AG:added
1324{
1325 return 0.5 * ( R0_f(quarks[UP]) + R0_f(quarks[CHARM]) );
1326}
1327
1328const double StandardModel::RWc() const
1329{
1330 double GammWcX, GammWhad;
1331
1332// Add all the W-> cX decays
1333// In GammaW fermion masses are ignored and CKM=1 but uses that SM CKM is unitary => I only need W->cs
1334 GammWcX = GammaW(quarks[CHARM], quarks[STRANGE]);
1335
1336// For the same reasons, I only need to add the W-> ud decays into the hadronic part
1337 GammWhad = GammWcX
1338 + GammaW(quarks[UP], quarks[DOWN]);
1339
1340 return GammWcX/GammWhad;
1341}
1342
1344
1345const double StandardModel::A_f(const Particle f) const
1346{
1347 double Re_kappa = kappaZ_f(f).real();
1348 double Re_gV_over_gA = 1.0 - 4.0 * fabs(f.getCharge()) * Re_kappa * sW2();
1349 return ( 2.0 * Re_gV_over_gA / (1.0 + pow(Re_gV_over_gA, 2.0)));
1350}
1351
1352const double StandardModel::AFB(const Particle f) const
1353{
1354 return (3.0 / 4.0 * A_f(leptons[ELECTRON]) * A_f(f));
1355}
1356
1357const double StandardModel::sin2thetaEff(const Particle f) const
1358{
1359 double Re_kappa = kappaZ_f(f).real();
1360 return ( Re_kappa * sW2());
1361}
1362
1363const double StandardModel::GammaZ(const Particle f) const
1364{
1365 if (f.is("TOP"))
1366 return 0.0;
1367 double Gamma;
1368 if (!IsFlagNoApproximateGammaZ()) {
1369
1370 /* SM contribution with the approximate formula */
1371 if (f.is("NEUTRINO_1") || f.is("NEUTRINO_2") || f.is("NEUTRINO_3"))
1372 Gamma = myApproximateFormulae->X_full("Gamma_nu");
1373 else if (f.is("ELECTRON") || f.is("MU"))
1374 Gamma = myApproximateFormulae->X_full("Gamma_e_mu");
1375 else if (f.is("TAU"))
1376 Gamma = myApproximateFormulae->X_full("Gamma_tau");
1377 else if (f.is("UP"))
1378 Gamma = myApproximateFormulae->X_full("Gamma_u");
1379 else if (f.is("CHARM"))
1380 Gamma = myApproximateFormulae->X_full("Gamma_c");
1381 else if (f.is("DOWN") || f.is("STRANGE"))
1382 Gamma = myApproximateFormulae->X_full("Gamma_d_s");
1383 else if (f.is("BOTTOM"))
1384 Gamma = myApproximateFormulae->X_full("Gamma_b");
1385 else
1386 throw std::runtime_error("Error in StandardModel::GammaZ()");
1387
1388 } else {
1389 gslpp::complex myrhoZ_f = rhoZ_f(f);
1390 gslpp::complex gV_over_gA = gV_f(f) / gA_f(f);
1391 double G0 = GF * pow(Mz, 3.0) / 24.0 / sqrt(2.0) / M_PI;
1392 if (f.is("LEPTON")) {
1393 double myalphaMz = alphaMz();
1394 double Q = f.getCharge();
1395 double xl = pow(f.getMass() / Mz, 2.0);
1396 Gamma = G0 * myrhoZ_f.abs() * sqrt(1.0 - 4.0 * xl)
1397 * ((1.0 + 2.0 * xl)*(gV_over_gA.abs2() + 1.0) - 6.0 * xl)
1398 * (1.0 + 3.0 / 4.0 * myalphaMz / M_PI * pow(Q, 2.0));
1399 } else if (f.is("QUARK")) {
1400 Gamma = 3.0 * G0 * myrhoZ_f.abs()*(gV_over_gA.abs2() * RVq((QCD::quark) (f.getIndex() - 6)) + RAq((QCD::quark) (f.getIndex() - 6)));
1401
1402 /* Nonfactorizable EW-QCD corrections */
1403 Gamma += Delta_EWQCD((QCD::quark) (f.getIndex() - 6));
1404 } else
1405 throw std::runtime_error("Error in StandardModel::GammaZ()");
1406 }
1407
1408 return Gamma;
1409}
1410
1411const double StandardModel::Gamma_inv() const
1412{
1413 return ( GammaZ(leptons[NEUTRINO_1]) + GammaZ(leptons[NEUTRINO_2])
1414 + GammaZ(leptons[NEUTRINO_3]));
1415}
1416
1417const double StandardModel::Gamma_had() const
1418{
1419 double Gamma_had_tmp = 0.0;
1420
1421 if (!IsFlagNoApproximateGammaZ()){
1422
1423 /* SM contribution with the approximate formula */
1424 return myApproximateFormulae->X_full("Gamma_had");
1425
1426 } else {
1427
1428 Gamma_had_tmp = GammaZ(quarks[UP]) + GammaZ(quarks[DOWN]) + GammaZ(quarks[CHARM])
1429 + GammaZ(quarks[STRANGE]) + GammaZ(quarks[BOTTOM]);
1430
1431 /* Singlet vector contribution (not included in the approximate formula) */
1432 double G0 = GF * pow(Mz, 3.0) / 24.0 / sqrt(2.0) / M_PI;
1433 Gamma_had_tmp += 4.0 * 3.0 * G0 * RVh();
1434
1435 return Gamma_had_tmp;
1436 }
1437}
1438
1439const double StandardModel::Gamma_Z() const
1440{
1441 if (!IsFlagNoApproximateGammaZ()){
1442
1443 /* SM contribution with the approximate formula */
1444 return myApproximateFormulae->X_full("GammaZ");
1445
1446 } else {
1447 return ( GammaZ(leptons[ELECTRON]) + GammaZ(leptons[MU]) + GammaZ(leptons[TAU])
1448 + Gamma_inv() + Gamma_had());
1449 }
1450}
1451
1452
1453const double StandardModel::RZlilj(const Particle li, const Particle lj) const
1454{
1455 double GammZli, GammZlj;
1456
1457 if ( li.is("ELECTRON") || li.is("MU") || li.is("TAU") )
1458 GammZli = GammaZ(li);
1459 else
1460 throw std::runtime_error("Error in StandardModel::RZlilj. li must be a charged lepton");
1461
1462 if ( lj.is("ELECTRON") || lj.is("MU") || lj.is("TAU") )
1463 GammZlj = GammaZ(lj);
1464 else
1465 throw std::runtime_error("Error in StandardModel::RZlilj. lj must be a charged lepton");
1466
1467 return GammZli/GammZlj;
1468}
1469
1470
1471const double StandardModel::sigma0_had() const
1472{
1473 if (!IsFlagNoApproximateGammaZ()){
1474
1475 /* SM contribution with the approximate formula */
1476 return (myApproximateFormulae->X_full("sigmaHadron")
1477 / GeVminus2_to_nb);
1478
1479 } else {
1480 return (12.0 * M_PI * GammaZ(leptons[ELECTRON]) * Gamma_had()
1481 / Mz / Mz / Gamma_Z() / Gamma_Z());
1482 }
1483}
1484
1485const double StandardModel::R0_f(const Particle f) const
1486{
1487
1488 if (f.is("ELECTRON")) {
1489 if (!IsFlagNoApproximateGammaZ())
1490 /* SM contribution with the approximate formula */
1491 return (myApproximateFormulae->X_full("R0_electron"));
1492 else
1493 return (Gamma_had() / GammaZ(leptons[ELECTRON]));
1494 } else if (f.is("MU")) {
1495 if (!IsFlagNoApproximateGammaZ())
1496 /* SM contribution with the approximate formula */
1497 return (myApproximateFormulae->X_full("R0_muon"));
1498 else
1499 return (Gamma_had() / GammaZ(leptons[MU]));
1500 } else if (f.is("TAU")) {
1501 if (!IsFlagNoApproximateGammaZ())
1502 /* SM contribution with the approximate formula */
1503 return (myApproximateFormulae->X_full("R0_tau"));
1504 else
1505 return (Gamma_had() / GammaZ(leptons[TAU]));
1506 } else if (f.is("NEUTRINO_1")) {
1507 if (!IsFlagNoApproximateGammaZ())
1508 /* SM contribution with the approximate formula */
1509 return (myApproximateFormulae->X_full("R0_neutrino"));
1510 else
1511 return (GammaZ(leptons[NEUTRINO_1]) / Gamma_had());
1512 } else if (f.is("NEUTRINO_2")) {
1513 if (!IsFlagNoApproximateGammaZ())
1514 /* SM contribution with the approximate formula */
1515 return (myApproximateFormulae->X_full("R0_neutrino"));
1516 else
1517 return (GammaZ(leptons[NEUTRINO_2]) / Gamma_had());
1518 } else if (f.is("NEUTRINO_3")) {
1519 if (!IsFlagNoApproximateGammaZ())
1520 /* SM contribution with the approximate formula */
1521 return (myApproximateFormulae->X_full("R0_neutrino"));
1522 else
1523 return (GammaZ(leptons[NEUTRINO_3]) / Gamma_had());
1524 } else if (f.is("UP")) {
1525 if (!IsFlagNoApproximateGammaZ())
1526 /* SM contribution with the approximate formula */
1527 return (myApproximateFormulae->X_full("R0_up"));
1528 else
1529 return (GammaZ(quarks[UP]) / Gamma_had());
1530
1531 } else if (f.is("STRANGE")) {
1532 if (!IsFlagNoApproximateGammaZ())
1533 /* SM contribution with the approximate formula */
1534 return (myApproximateFormulae->X_full("R0_strange"));
1535 else
1536 return (GammaZ(quarks[STRANGE]) / Gamma_had());
1537
1538 } else if (f.is("CHARM")) {
1539 if (!IsFlagNoApproximateGammaZ())
1540 /* SM contribution with the approximate formula */
1541 return (myApproximateFormulae->X_full("R0_charm"));
1542 else
1543 return (GammaZ(quarks[CHARM]) / Gamma_had());
1544
1545 } else if (f.is("BOTTOM")) {
1546 if (!IsFlagNoApproximateGammaZ())
1547 /* SM contribution with the approximate formula */
1548 return (myApproximateFormulae->X_full("R0_bottom"));
1549 else
1550 return (GammaZ(quarks[BOTTOM]) / Gamma_had());
1551
1552 } else throw std::runtime_error("StandardModel::R0_f called with wrong argument");
1553
1554}
1555
1556const double StandardModel::R_inv() const
1557{
1558 return (Gamma_inv() / GammaZ(leptons[ELECTRON]));
1559
1560}
1561
1562const double StandardModel::N_nu() const
1563{
1564 double Nnu = 0.0;
1565 double Gl = 0.0;
1566 double Rl = 0.0;
1567
1568 // Don't assume lepton universality: average over lepton flavours
1569 Gl = GammaZ(leptons[ELECTRON]) + GammaZ(leptons[MU]) + GammaZ(leptons[TAU]);
1570 Rl = (1.0/3.0) * ( R0_f(leptons[ELECTRON]) + R0_f(leptons[MU]) + R0_f(leptons[TAU]) );
1571
1572 Nnu = sqrt( 12.0 * M_PI * Rl / Mz / Mz / sigma0_had() ) - Rl -3.0;
1573
1574 Nnu = (Gl/Gamma_inv()) * Nnu;
1575
1576 return Nnu;
1577
1578}
1579
1580
1582
1583const gslpp::complex StandardModel::gV_f(const Particle f) const
1584{
1585 return ( gA_f(f)
1586 *(1.0 - 4.0 * fabs(f.getCharge())*(kappaZ_f(f)) * sW2()));
1587}
1588
1589const gslpp::complex StandardModel::gA_f(const Particle f) const
1590{
1591 return ( sqrt(rhoZ_f(f)) * f.getIsospin());
1592}
1593
1594const gslpp::complex StandardModel::rhoZ_f(const Particle f) const
1595{
1596 if (f.getName().compare("TOP") == 0) return (gslpp::complex(0.0, 0.0, false));
1597 if (FlagRhoZ.compare("APPROXIMATEFORMULA") == 0)
1598 throw std::runtime_error("No approximate formula is available for rhoZ^f");
1599 else {
1600
1601 if (FlagCacheInStandardModel)
1602 if (useRhoZ_f_cache[f.getIndex()])
1603 return rhoZ_f_cache[f.getIndex()];
1604
1605 double myMw = Mw();
1606
1607 /* compute Delta rho */
1608 double DeltaRho[orders_EW_size];
1609 ComputeDeltaRho(myMw, DeltaRho);
1610
1611 /* compute delta rho_rem^f */
1612 gslpp::complex deltaRho_remf[orders_EW_size];
1613 deltaRho_remf[EW1] = gslpp::complex(0.0, 0.0, false);
1614 deltaRho_remf[EW1QCD1] = gslpp::complex(0.0, 0.0, false);
1615 deltaRho_remf[EW1QCD2] = gslpp::complex(0.0, 0.0, false);
1616 deltaRho_remf[EW2] = gslpp::complex(0.0, 0.0, false);
1617 deltaRho_remf[EW2QCD1] = gslpp::complex(0.0, 0.0, false);
1618 deltaRho_remf[EW3] = gslpp::complex(0.0, 0.0, false);
1619 if (flag_order[EW1])
1620 deltaRho_remf[EW1] = myOneLoopEW->deltaRho_rem_f(f, myMw);
1621 if (flag_order[EW1QCD1])
1622#ifdef WITHIMTWOLOOPQCD
1623 deltaRho_remf[EW1QCD1] = gslpp::complex(myTwoLoopQCD->deltaRho_rem_f(f, myMw).real(),
1624 myTwoLoopQCD->deltaRho_rem_f(f, myMw).imag(), false);
1625#else
1626 deltaRho_remf[EW1QCD1] = gslpp::complex(myTwoLoopQCD->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1627#endif
1628 if (flag_order[EW1QCD2])
1629 deltaRho_remf[EW1QCD2] = gslpp::complex(myThreeLoopQCD->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1630 if (flag_order[EW2])
1631 deltaRho_remf[EW2] = gslpp::complex(myTwoLoopEW->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1632 if (flag_order[EW2QCD1])
1633 deltaRho_remf[EW2QCD1] = gslpp::complex(myThreeLoopEW2QCD->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1634 if (flag_order[EW3])
1635 deltaRho_remf[EW3] = gslpp::complex(myThreeLoopEW->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1636
1637 /* compute Delta rbar_rem */
1638 double DeltaRbar_rem = 0.0;
1639 if (flag_order[EW1])
1640 DeltaRbar_rem = myOneLoopEW->DeltaRbar_rem(myMw);
1641
1642 /* Re[rho_Z^f] with or without resummation */
1643 double deltaRho_rem_f_real[orders_EW_size];
1644 for (int j = 0; j < orders_EW_size; ++j)
1645 deltaRho_rem_f_real[j] = deltaRho_remf[j].real();
1646 double ReRhoZf = resumRhoZ(DeltaRho, deltaRho_rem_f_real, DeltaRbar_rem, f.is("BOTTOM"));
1647
1648 /* Im[rho_Z^f] without resummation */
1649 double ImRhoZf = 0.0;
1650 for (int j = 0; j < orders_EW_size; ++j)
1651 ImRhoZf += deltaRho_remf[j].imag();
1652
1653 rhoZ_f_cache[f.getIndex()] = gslpp::complex(ReRhoZf, ImRhoZf, false);
1654 useRhoZ_f_cache[f.getIndex()] = true;
1655 return (gslpp::complex(ReRhoZf, ImRhoZf, false));
1656 }
1657}
1658
1659const gslpp::complex StandardModel::kappaZ_f(const Particle f) const
1660{
1661 if (f.is("TOP")) return (gslpp::complex(0.0, 0.0, false));
1662
1663 if (FlagCacheInStandardModel)
1664 if (useKappaZ_f_cache[f.getIndex()])
1665 return kappaZ_f_cache[f.getIndex()];
1666
1667 double myMw = Mw();
1668
1669 double ReKappaZf = 0.0, ImKappaZf = 0.0;
1670 if (FlagKappaZ.compare("APPROXIMATEFORMULA") == 0) {
1671
1672// Choose the correct formulae for the effective angle
1673 if ( f.is("BOTTOM") ){
1674 ReKappaZf = myApproximateFormulae->sin2thetaEff_b_full() / sW2();
1675 } else if ( f.is("ELECTRON") || f.is("MU") || f.is("TAU") ) {
1676 ReKappaZf = myApproximateFormulae->sin2thetaEff_l_full() / sW2();
1677 } else {
1678 ReKappaZf = myApproximateFormulae->sin2thetaEff(f) / sW2();
1679 }
1680
1681 ImKappaZf = myOneLoopEW->deltaKappa_rem_f(f, myMw).imag();
1682#ifdef WITHIMTWOLOOPQCD
1683 ImKappaZf += myTwoLoopQCD->deltaKappa_rem_f(f, myMw).imag();
1684
1685 /* TEST */
1686 //ImKappaZf -= myCache->ale()*myCache->alsMz()/24.0/M_PI*(cW2() - sW2())/sW2()/sW2();
1687#endif
1688 } else {
1689 /* compute Delta rho */
1690 double DeltaRho[orders_EW_size];
1691 ComputeDeltaRho(myMw, DeltaRho);
1692
1693 /* compute delta kappa_rem^f */
1694 gslpp::complex deltaKappa_remf[orders_EW_size];
1695 deltaKappa_remf[EW1] = gslpp::complex(0.0, 0.0, false);
1696 deltaKappa_remf[EW1QCD1] = gslpp::complex(0.0, 0.0, false);
1697 deltaKappa_remf[EW1QCD2] = gslpp::complex(0.0, 0.0, false);
1698 deltaKappa_remf[EW2] = gslpp::complex(0.0, 0.0, false);
1699 deltaKappa_remf[EW2QCD1] = gslpp::complex(0.0, 0.0, false);
1700 deltaKappa_remf[EW3] = gslpp::complex(0.0, 0.0, false);
1701 if (flag_order[EW1])
1702 deltaKappa_remf[EW1] = myOneLoopEW->deltaKappa_rem_f(f, myMw);
1703 if (flag_order[EW1QCD1])
1704#ifdef WITHIMTWOLOOPQCD
1705 deltaKappa_remf[EW1QCD1] = gslpp::complex(myTwoLoopQCD->deltaKappa_rem_f(f, myMw).real(),
1706 myTwoLoopQCD->deltaKappa_rem_f(f, myMw).imag(), false);
1707#else
1708 deltaKappa_remf[EW1QCD1] = gslpp::complex(myTwoLoopQCD->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1709#endif
1710 if (flag_order[EW1QCD2])
1711 deltaKappa_remf[EW1QCD2] = gslpp::complex(myThreeLoopQCD->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1712 if (flag_order[EW2])
1713 deltaKappa_remf[EW2] = gslpp::complex(myTwoLoopEW->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1714 if (flag_order[EW2QCD1])
1715 deltaKappa_remf[EW2QCD1] = gslpp::complex(myThreeLoopEW2QCD->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1716 if (flag_order[EW3])
1717 deltaKappa_remf[EW3] = gslpp::complex(myThreeLoopEW->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1718
1719 /* compute Delta rbar_rem */
1720 double DeltaRbar_rem = 0.0;
1721 if (flag_order[EW1])
1722 DeltaRbar_rem = myOneLoopEW->DeltaRbar_rem(myMw);
1723
1724 /* Re[kappa_Z^f] with or without resummation */
1725 double deltaKappa_rem_f_real[orders_EW_size];
1726 for (int j = 0; j < orders_EW_size; ++j)
1727 deltaKappa_rem_f_real[j] = deltaKappa_remf[j].real();
1728
1729 ReKappaZf = resumKappaZ(DeltaRho, deltaKappa_rem_f_real, DeltaRbar_rem, f.is("BOTTOM"));
1730
1731 /* O(alpha^2) correction to Re[kappa_Z^f] from the Z-gamma mixing */
1732 ReKappaZf += 35.0 * alphaMz() * alphaMz() / 18.0 / sW2()
1733 *(1.0 - 8.0 / 3.0 * ReKappaZf * sW2());
1734
1735 /* Im[kappa_Z^f] without resummation */
1736 for (int j = 0; j < orders_EW_size; ++j)
1737 ImKappaZf += deltaKappa_remf[j].imag();
1738 }
1739
1740 kappaZ_f_cache[f.getIndex()] = gslpp::complex(ReKappaZf, ImKappaZf, false);
1741 useKappaZ_f_cache[f.getIndex()] = true;
1742 return (gslpp::complex(ReKappaZf, ImKappaZf, false));
1743}
1744
1745const gslpp::complex StandardModel::deltaRhoZ_f(const Particle f) const
1746{
1747 Particle p1 = f, pe = leptons[ELECTRON];
1748
1749 if (f.is("TOP") || f.is("ELECTRON")) return (gslpp::complex(0.0, 0.0, false));
1750
1751 /* In the case of BOTTOM, the top contribution has to be subtracted.
1752 * The remaining contribution is the same as that for DOWN and STRANGE. */
1753 if (f.is("BOTTOM")) p1 = quarks[DOWN];
1754
1755 double myMw = Mw();
1756 double cW2 = myMw * myMw / Mz / Mz, sW2 = 1.0 - cW2;
1757
1758 gslpp::complex ul = (3.0 * myEWSMcache->v_f(pe, myMw) * myEWSMcache->v_f(pe, myMw)
1759 + myEWSMcache->a_f(pe) * myEWSMcache->a_f(pe)) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1760 + myOneLoopEW->FW(Mz*Mz, pe, myMw);
1761 gslpp::complex uf = (3.0 * myEWSMcache->v_f(p1, myMw) * myEWSMcache->v_f(p1, myMw)
1762 + myEWSMcache->a_f(p1) * myEWSMcache->a_f(p1)) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1763 + myOneLoopEW->FW(Mz*Mz, p1, myMw);
1764
1765 gslpp::complex dRho = 2.0 * (uf - ul);
1766 dRho *= ale / 4.0 / M_PI / sW2;
1767 return dRho;
1768}
1769
1770const gslpp::complex StandardModel::deltaKappaZ_f(const Particle f) const
1771{
1772 Particle p1 = f, pe = leptons[ELECTRON];
1773
1774 if (f.is("TOP") || f.is("ELECTRON")) return (gslpp::complex(0.0, 0.0, false));
1775
1776 /* In the case of BOTTOM, the top contribution has to be subtracted.
1777 * The remaining contribution is the same as that for DOWN and STRANGE. */
1778 if (f.is("BOTTOM")) p1 = quarks[DOWN];
1779
1780 double myMw = Mw();
1781 double cW2 = myMw * myMw / Mz / Mz, sW2 = 1.0 - cW2;
1782 gslpp::complex ul = (3.0 * myEWSMcache->v_f(pe, myMw) * myEWSMcache->v_f(pe, myMw)
1783 + myEWSMcache->a_f(pe) * myEWSMcache->a_f(pe)) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1784 + myOneLoopEW->FW(Mz*Mz, pe, myMw);
1785 double deltal = myEWSMcache->delta_f(pe, myMw);
1786 gslpp::complex uf = (3.0 * myEWSMcache->v_f(p1, myMw) * myEWSMcache->v_f(p1, myMw)
1787 + myEWSMcache->a_f(p1) * myEWSMcache->a_f(p1)) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1788 + myOneLoopEW->FW(Mz*Mz, p1, myMw);
1789 double deltaf = myEWSMcache->delta_f(p1, myMw);
1790
1791 gslpp::complex dKappa = (deltaf * deltaf - deltal * deltal) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1792 - uf + ul;
1793 dKappa *= ale / 4.0 / M_PI / sW2;
1794 return dKappa;
1795}
1796
1797
1799
1800const double StandardModel::epsilon1() const
1801{
1802 double rhoZe = rhoZ_f(leptons[ELECTRON]).real();
1803 double DeltaRhoPrime = 2.0 * (sqrt(rhoZe) - 1.0);
1804
1805 return DeltaRhoPrime;
1806}
1807
1808const double StandardModel::epsilon2() const
1809{
1810 double rhoZe = rhoZ_f(leptons[ELECTRON]).real();
1811 double sin2thetaEff = kappaZ_f(leptons[ELECTRON]).real() * sW2();
1812 double DeltaRhoPrime = 2.0 * (sqrt(rhoZe) - 1.0);
1813 double DeltaKappaPrime = sin2thetaEff / s02() - 1.0;
1814 double DeltaRW = 1.0 - M_PI * alphaMz() / (sqrt(2.0) * GF * Mz * Mz * sW2() * cW2());
1815
1816 return ( c02() * DeltaRhoPrime + s02() * DeltaRW / (c02() - s02())
1817 - 2.0 * s02() * DeltaKappaPrime);
1818}
1819
1820const double StandardModel::epsilon3() const
1821{
1822 double rhoZe = rhoZ_f(leptons[ELECTRON]).real();
1823 double sin2thetaEff = kappaZ_f(leptons[ELECTRON]).real() * sW2();
1824 double DeltaRhoPrime = 2.0 * (sqrt(rhoZe) - 1.0);
1825 double DeltaKappaPrime = sin2thetaEff / s02() - 1.0;
1826
1827 return ( c02() * DeltaRhoPrime + (c02() - s02()) * DeltaKappaPrime);
1828}
1829
1830const double StandardModel::epsilonb() const
1831{
1832 /* epsilon_b from g_A^b
1833 * see Eq.(13) of IJMP A7, 1031 (1998) by Altarelli et al. */
1834 //double rhoZe = rhoZ_l_SM(StandardModel::ELECTRON).real();
1835 //double rhoZb = rhoZ_q_SM(QCD::BOTTOM).real();
1836 //double DeltaRhoPrime = 2.0*( sqrt(rhoZe) - 1.0 );
1837 //double eps1 = DeltaRhoPrime;
1838 //return ( - 1.0 + sqrt(rhoZb)/(1.0 + eps1/2.0) );
1839
1840 /* epsilon_b from Re(g_V^b/g_A^b), i.e. Re(kappaZ_b)
1841 * see Eq.(13) of IJMP A7, 1031 (1998) by Altarelli et al. */
1842 gslpp::complex kappaZe = kappaZ_f(leptons[ELECTRON]);
1843 gslpp::complex kappaZb = kappaZ_f(quarks[BOTTOM]);
1844 if (IsFlagWithoutNonUniversalVC())
1845 return ( kappaZe.real() / kappaZb.real() - 1.0);
1846 else
1847 return ( (kappaZe.real() + deltaKappaZ_f(quarks[BOTTOM]).real())
1848 / kappaZb.real() - 1.0);
1849
1850 /* epsilon_b from Gamma_b via Eqs.(11), (12) and (16) of IJMP A7,
1851 * 1031 (1998) by Altarelli et al.
1852 * Note: mb has to be mb=4.7, since Eq.(16) were derived with this value.
1853 */
1854 //double als_Mz = Als(myCache->Mz(), FULLNNLO);
1855 //double delta_als = (als_Mz - 0.119)/M_PI;
1856 //double delta_alpha = (alphaMz() - 1.0/128.90)/myCache->ale();
1857 //double Gamma_b_Born = 0.3798*( 1.0 + delta_als - 0.42*delta_alpha);
1858 //double a = als_Mz/M_PI;
1859 //double RQCD = 1.0 + 1.2*a - 1.1*a*a - 13.0*a*a*a;
1860 //double mb = Mrun(myCache->Mz(), quarks[QCD::BOTTOM].getMass(), FULLNNLO);// This is wrong!
1861 //double mb = 4.7;
1862 //std::cout << "mb = " << mb << std::endl;
1863 //double beta = sqrt(1.0 - 4.0*mb*mb/myCache->Mz()/myCache->Mz());
1864 //double Nc = 3.0;
1865 //double factor = myCache->GF()*myCache->Mz()*myCache->Mz()*myCache->Mz()/6.0/M_PI/sqrt(2.0);
1866 //double Gamma_b = factor*beta*((3.0 - beta*beta)/2.0*gVq_SM(QCD::BOTTOM).abs2()
1867 // + beta*beta*gAq_SM(QCD::BOTTOM).abs2())
1868 // *Nc*RQCD*(1.0 + alphaMz()/12.0/M_PI);
1869 //return ( (Gamma_b/Gamma_b_Born - 1.0 - 1.42*epsilon1_SM()
1870 // + 0.54*epsilon3_SM() )/2.29 );
1871}
1872
1873
1875
1876double StandardModel::resumMw(const double Mw_i, const double DeltaRho[orders_EW_size],
1877 const double DeltaR_rem[orders_EW_size]) const
1878{
1879 if ((FlagMw.compare("APPROXIMATEFORMULA") == 0)
1880 || (DeltaR_rem[EW2QCD1] != 0.0)
1881 || (DeltaR_rem[EW3] != 0.0))
1882 throw std::runtime_error("Error in StandardModel::resumMw()");
1883
1884 if (!flag_order[EW2] && FlagMw.compare("NORESUM") != 0)
1885 throw std::runtime_error("Error in StandardModel::resumMw()");
1886
1887 double cW2_TMP = Mw_i * Mw_i / Mz / Mz;
1888 double sW2_TMP = 1.0 - cW2_TMP;
1889
1890 double f_AlphaToGF, DeltaRho_sum = 0.0, DeltaRho_G = 0.0;
1891 if (FlagMw.compare("NORESUM") == 0) {
1892 for (int j = 0; j < orders_EW_size; ++j) {
1893 DeltaRho_sum += DeltaRho[(orders_EW) j];
1894 }
1895 } else {
1896 // conversion: alpha(0) --> G_F
1897 f_AlphaToGF = sqrt(2.0) * GF * pow(Mz, 2.0) * sW2_TMP * cW2_TMP / M_PI / ale;
1898 DeltaRho_sum = f_AlphaToGF * DeltaRho[EW1]
1899 + f_AlphaToGF * DeltaRho[EW1QCD1]
1900 + f_AlphaToGF * DeltaRho[EW1QCD2]
1901 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2]
1902 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2QCD1]
1903 + pow(f_AlphaToGF, 3.0) * DeltaRho[EW3];
1904 DeltaRho_G = f_AlphaToGF * DeltaRho[EW1];
1905 }
1906
1907 double R;
1908 double DeltaR_rem_sum = 0.0;
1909 double DeltaR_EW1 = 0.0, DeltaR_EW2_rem = 0.0;
1910 if (FlagMw.compare("NORESUM") == 0) {
1911 for (int j = 0; j < orders_EW_size; ++j)
1912 DeltaR_rem_sum += DeltaR_rem[(orders_EW) j];
1913
1914 // Full EW one-loop contribution (without the full DeltaAlphaL5q)
1915 DeltaR_EW1 = -cW2_TMP / sW2_TMP * DeltaRho[EW1] + DeltaR_rem[EW1];
1916
1917 // Full EW two-loop contribution without reducible corrections
1918 DeltaR_EW2_rem = myApproximateFormulae->DeltaR_TwoLoopEW_rem(Mw_i);
1919
1920 // subtract the EW two-loop contributions from DeltaRho_sum and DeltaR_rem_sum
1921 DeltaRho_sum -= DeltaRho[EW2];
1922 DeltaR_rem_sum -= DeltaR_rem[EW2];
1923
1924 // R = 1 + Delta r, including the full EW two-loop contribution
1925 R = 1.0 + DeltaAlphaL5q() - cW2_TMP / sW2_TMP * DeltaRho_sum
1926 + DeltaR_rem_sum;
1927 R += DeltaAlphaL5q() * DeltaAlphaL5q() + 2.0 * DeltaAlphaL5q() * DeltaR_EW1
1928 + DeltaR_EW2_rem;
1929 } else if (FlagMw.compare("OMSI") == 0) {
1930 // R = 1/(1 - Delta r)
1931 R = 1.0 / (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum)
1932 / (1.0 - DeltaAlphaL5q()
1933 - DeltaR_rem[EW1] - DeltaR_rem[EW1QCD1] - DeltaR_rem[EW2]);
1934 } else if (FlagMw.compare("INTERMEDIATE") == 0) {
1935 // R = 1/(1 - Delta r)
1936 R = 1.0 / ((1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum)
1937 *(1.0 - DeltaAlphaL5q() - DeltaR_rem[EW1])
1938 - DeltaR_rem[EW1QCD1] - DeltaR_rem[EW2]);
1939 } else if (FlagMw.compare("OMSII") == 0) {
1940 // R = 1/(1 - Delta r)
1941 R = 1.0 / ((1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum)*(1.0 - DeltaAlphaL5q())
1942 - (1.0 + cW2_TMP / sW2_TMP * DeltaRho_G) * DeltaR_rem[EW1]
1943 - DeltaR_rem[EW1QCD1] - DeltaR_rem[EW2]);
1944 } else
1945 throw std::runtime_error("Error in StandardModel::resumMw()");
1946
1947 if (FlagMw.compare("NORESUM") == 0) {
1948 /* Mzbar and Mwbar are defined in the complex-pole scheme. */
1949
1950 double tmp = 4.0 * M_PI * ale / sqrt(2.0) / GF / Mzbar() / Mzbar();
1951 if (tmp * R > 1.0) throw std::runtime_error("StandardModel::resumMw(): Negative (1-tmp*R)");
1952 double Mwbar = Mzbar() / sqrt(2.0) * sqrt(1.0 + sqrt(1.0 - tmp * R));
1953
1954 return MwFromMwbar(Mwbar);
1955 } else {
1956 double tmp = 4.0 * M_PI * ale / sqrt(2.0) / GF / Mz / Mz;
1957 if (tmp * R > 1.0) throw std::runtime_error("StandardModel::resumMw(): Negative (1-tmp*R)");
1958
1959 return (Mz / sqrt(2.0) * sqrt(1.0 + sqrt(1.0 - tmp * R)));
1960 }
1961}
1962
1963double StandardModel::resumRhoZ(const double DeltaRho[orders_EW_size],
1964 const double deltaRho_rem[orders_EW_size],
1965 const double DeltaRbar_rem, bool bool_Zbb) const
1966{
1967 if ((FlagRhoZ.compare("APPROXIMATEFORMULA") == 0)
1968 || (deltaRho_rem[EW1QCD2] != 0.0)
1969 || (deltaRho_rem[EW2QCD1] != 0.0)
1970 || (deltaRho_rem[EW3] != 0.0))
1971 throw std::runtime_error("Error in StandardModel::resumRhoZ()");
1972
1973 if (!flag_order[EW2] && FlagRhoZ.compare("NORESUM") != 0)
1974 throw std::runtime_error("Error in StandardModel::resumRhoZ()");
1975
1976 double Mw_TMP = Mw();
1977 double cW2_TMP = cW2();
1978 double sW2_TMP = sW2();
1979
1980 double f_AlphaToGF, DeltaRho_sum = 0.0, DeltaRho_G;
1981 double DeltaRbar_rem_G, deltaRho_rem_G, deltaRho_rem_G2;
1982 // conversion: alpha(0) --> G_F
1983 f_AlphaToGF = sqrt(2.0) * GF * pow(Mz, 2.0)
1984 * sW2_TMP * cW2_TMP / M_PI / ale;
1985 DeltaRho_sum = f_AlphaToGF * DeltaRho[EW1]
1986 + f_AlphaToGF * DeltaRho[EW1QCD1]
1987 + f_AlphaToGF * DeltaRho[EW1QCD2]
1988 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2]
1989 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2QCD1]
1990 + pow(f_AlphaToGF, 3.0) * DeltaRho[EW3];
1991 DeltaRho_G = f_AlphaToGF * DeltaRho[EW1];
1992 DeltaRbar_rem_G = f_AlphaToGF*DeltaRbar_rem;
1993 deltaRho_rem_G = f_AlphaToGF * (deltaRho_rem[EW1]
1994 + deltaRho_rem[EW1QCD1]);
1995 deltaRho_rem_G2 = pow(f_AlphaToGF, 2.0) * deltaRho_rem[EW2];
1996
1997 /* Real parts */
1998 double rhoZ;
1999 if (!bool_Zbb) {
2000 if (FlagRhoZ.compare("OMSI") == 0) {
2001 rhoZ = (1.0 + deltaRho_rem_G + deltaRho_rem_G2)
2002 / (1.0 - DeltaRho_sum * (1.0 - DeltaRbar_rem_G));
2003 } else if (FlagRhoZ.compare("INTERMEDIATE") == 0) {
2004 rhoZ = (1.0 + deltaRho_rem_G)
2005 / (1.0 - DeltaRho_sum * (1.0 - DeltaRbar_rem_G))
2006 + deltaRho_rem_G2;
2007 } else if (FlagRhoZ.compare("NORESUM") == 0
2008 || FlagRhoZ.compare("OMSII") == 0) {
2009 rhoZ = 1.0 + DeltaRho_sum - DeltaRho_G * DeltaRbar_rem_G
2010 + DeltaRho_G * DeltaRho_G
2011 + deltaRho_rem_G * (1.0 + DeltaRho_G) + deltaRho_rem_G2;
2012 } else
2013 throw std::runtime_error("Error in StandardModel::resumRhoZ()");
2014 } else {
2015 /* Z to bb */
2016 double OnePlusTaub = 1.0 + taub();
2017 double OnePlusTaub2 = OnePlusTaub*OnePlusTaub;
2018 double rhoZbL;
2019 deltaRho_rem_G += f_AlphaToGF * ale / 4.0 / M_PI / sW2_TMP
2020 * pow(mtpole / Mw_TMP, 2.0);
2021 if (FlagRhoZ.compare("NORESUM") == 0) {
2022 rhoZ = (1.0 + DeltaRho_sum - DeltaRho_G * DeltaRbar_rem_G
2023 + DeltaRho_G * DeltaRho_G
2024 + deltaRho_rem_G * (1.0 + DeltaRho_G) + deltaRho_rem_G2)
2025 * OnePlusTaub2;
2026 } else if (FlagRhoZ.compare("OMSI") == 0) {
2027 rhoZbL = OnePlusTaub2 / (1.0 - DeltaRho_sum);
2028 rhoZ = rhoZbL / (1.0 - rhoZbL * deltaRho_rem_G);
2029 } else if (FlagRhoZ.compare("INTERMEDIATE") == 0) {
2030 rhoZbL = OnePlusTaub2 / (1.0 - DeltaRho_sum);
2031 rhoZ = rhoZbL * (1.0 + rhoZbL * deltaRho_rem_G);
2032 } else if (FlagRhoZ.compare("OMSII") == 0) {
2033 rhoZbL = OnePlusTaub2 / (1.0 - DeltaRho_sum);
2034 rhoZ = rhoZbL * (1.0 + deltaRho_rem_G);
2035 } else
2036 throw std::runtime_error("Error in StandardModel::resumRhoZ()");
2037 }
2038
2039 return rhoZ;
2040}
2041
2042double StandardModel::resumKappaZ(const double DeltaRho[orders_EW_size],
2043 const double deltaKappa_rem[orders_EW_size],
2044 const double DeltaRbar_rem, const bool bool_Zbb) const
2045{
2046 if ((FlagKappaZ.compare("APPROXIMATEFORMULA") == 0)
2047 || (deltaKappa_rem[EW2QCD1] != 0.0)
2048 || (deltaKappa_rem[EW3] != 0.0))
2049 throw std::runtime_error("Error in StandardModel::resumKappaZ()");
2050
2051 if (!flag_order[EW2] && FlagKappaZ.compare("NORESUM") != 0)
2052 throw std::runtime_error("Error in StandardModel::resumKappaZ()");
2053
2054 double Mw_TMP = Mw();
2055 double cW2_TMP = cW2();
2056 double sW2_TMP = sW2();
2057
2058 double f_AlphaToGF, DeltaRho_sum = 0.0, DeltaRho_G;
2059 double DeltaRbar_rem_G, deltaKappa_rem_G, deltaKappa_rem_G2;
2060 // conversion: alpha(0) --> G_F
2061 f_AlphaToGF = sqrt(2.0) * GF * pow(Mz, 2.0)
2062 * sW2_TMP * cW2_TMP / M_PI / ale;
2063 DeltaRho_sum = f_AlphaToGF * DeltaRho[EW1]
2064 + f_AlphaToGF * DeltaRho[EW1QCD1]
2065 + f_AlphaToGF * DeltaRho[EW1QCD2]
2066 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2]
2067 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2QCD1]
2068 + pow(f_AlphaToGF, 3.0) * DeltaRho[EW3];
2069 DeltaRho_G = f_AlphaToGF * DeltaRho[EW1];
2070 DeltaRbar_rem_G = f_AlphaToGF*DeltaRbar_rem;
2071 deltaKappa_rem_G = f_AlphaToGF * (deltaKappa_rem[EW1]
2072 + deltaKappa_rem[EW1QCD1]
2073 + deltaKappa_rem[EW1QCD2]);
2074 deltaKappa_rem_G2 = pow(f_AlphaToGF, 2.0) * deltaKappa_rem[EW2];
2075
2076 /* Real parts */
2077 double kappaZ;
2078 if (!bool_Zbb) {
2079 if (FlagKappaZ.compare("OMSI") == 0) {
2080 kappaZ = (1.0 + deltaKappa_rem_G + deltaKappa_rem_G2)
2081 *(1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum * (1.0 - DeltaRbar_rem_G));
2082 } else if (FlagKappaZ.compare("INTERMEDIATE") == 0) {
2083 kappaZ = (1.0 + deltaKappa_rem_G)
2084 *(1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum * (1.0 - DeltaRbar_rem_G))
2085 + deltaKappa_rem_G2;
2086 } else if (FlagKappaZ.compare("NORESUM") == 0
2087 || FlagKappaZ.compare("OMSII") == 0) {
2088 kappaZ = 1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum
2089 - cW2_TMP / sW2_TMP * DeltaRho_G * DeltaRbar_rem_G
2090 + deltaKappa_rem_G * (1.0 + cW2_TMP / sW2_TMP * DeltaRho_G)
2091 + deltaKappa_rem_G2;
2092 } else
2093 throw std::runtime_error("Error in StandardModel::resumKappaZ()");
2094 } else {
2095 /* Z to bb */
2096 double OnePlusTaub = 1.0 + taub();
2097 double kappaZbL;
2098 deltaKappa_rem_G -= f_AlphaToGF * ale / 8.0 / M_PI / sW2_TMP
2099 * pow(mtpole / Mw_TMP, 2.0);
2100 if (FlagKappaZ.compare("NORESUM") == 0) {
2101 kappaZ = (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum
2102 - cW2_TMP / sW2_TMP * DeltaRho_G * DeltaRbar_rem_G
2103 + deltaKappa_rem_G * (1.0 + cW2_TMP / sW2_TMP * DeltaRho_G)
2104 + deltaKappa_rem_G2) / OnePlusTaub;
2105 } else if (FlagKappaZ.compare("OMSI") == 0) {
2106 kappaZbL = (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum) / OnePlusTaub;
2107 kappaZ = kappaZbL * (1.0 + deltaKappa_rem_G);
2108 } else if (FlagKappaZ.compare("INTERMEDIATE") == 0
2109 || FlagKappaZ.compare("OMSII") == 0) {
2110 kappaZbL = (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum) / OnePlusTaub;
2111 kappaZ = kappaZbL + deltaKappa_rem_G;
2112 } else
2113 throw std::runtime_error("Error in StandardModel::resumKappaZ()");
2114 }
2115
2116 return kappaZ;
2117}
2118
2119double StandardModel::taub() const
2120{
2121 double taub_tmp = 0.0;
2122 double Xt = myEWSMcache->Xt_GF();
2123 if (flag_order[EW1])
2124 taub_tmp += -2.0 * Xt;
2125 if (flag_order[EW1QCD1])
2126 taub_tmp += 2.0 / 3.0 * M_PI * Xt * myEWSMcache->alsMt();
2127 if (flag_order[EW1QCD2])
2128 taub_tmp += 0.0;
2129 if (flag_order[EW2])
2130 taub_tmp += -2.0 * Xt * Xt * myTwoLoopEW->tau_2();
2131 if (flag_order[EW2QCD1])
2132 taub_tmp += 0.0;
2133 if (flag_order[EW3])
2134 taub_tmp += 0.0;
2135
2136 return taub_tmp;
2137}
2138
2139double StandardModel::Delta_EWQCD(const QCD::quark q) const
2140{
2141 switch (q) {
2142 case QCD::UP:
2143 case QCD::CHARM:
2144 return ( -0.000113);
2145 case QCD::TOP:
2146 return ( 0.0);
2147 case QCD::DOWN:
2148 case QCD::STRANGE:
2149 return ( -0.000160);
2150 case QCD::BOTTOM:
2151 return ( -0.000040);
2152 default:
2153 throw std::runtime_error("Error in StandardModel::Delta_EWQCD");
2154 }
2155}
2156
2157double StandardModel::RVq(const QCD::quark q) const
2158{
2159 if (q == QCD::TOP) return 0.0;
2160
2161 double mcMz, mbMz;
2162 mcMz = myEWSMcache->mf(getQuarks(CHARM), Mz, FULLNNLO);
2163 mbMz = myEWSMcache->mf(getQuarks(BOTTOM), Mz, FULLNNLO);
2164 //mcMz = 0.56381685; /* for debug */
2165 //mbMz = 2.8194352; /* for debug */
2166
2167 double MtPole = mtpole;
2168
2169 /* electric charge squared */
2170 double Qf2 = pow(quarks[q].getCharge(), 2.0);
2171
2172 /* s = Mz^2 */
2173 double s = Mz * Mz;
2174
2175 /* products of the charm and bottom masses at Mz */
2176 double mcMz2 = mcMz*mcMz;
2177 double mbMz2 = mbMz*mbMz;
2178 double mqMz2, mqdash4;
2179 switch (q) {
2180 case QCD::CHARM:
2181 mqMz2 = mcMz*mcMz;
2182 mqdash4 = mbMz2*mbMz2;
2183 break;
2184 case QCD::BOTTOM:
2185 mqMz2 = mbMz*mbMz;
2186 mqdash4 = mcMz2*mcMz2;
2187 break;
2188 default:
2189 mqMz2 = 0.0;
2190 mqdash4 = 0.0;
2191 break;
2192 }
2193
2194 /* Logarithms */
2195 //double log_t = log(pow(quarks[TOP].getMass(),2.0)/s);
2196 double log_t = log(MtPole * MtPole / s); // the pole mass
2197 double log_c = log(mcMz2 / s);
2198 double log_b = log(mbMz2 / s);
2199 double log_q;
2200 switch (q) {
2201 case QCD::CHARM:
2202 case QCD::BOTTOM:
2203 log_q = log(mqMz2 / s);
2204 break;
2205 default:
2206 log_q = 0.0;
2207 break;
2208 }
2209
2210 /* the active number of flavour */
2211 double nf = 5.0;
2212
2213 /* zeta functions */
2214 double zeta2 = getMyEWSMcache()->getZeta2();
2215 double zeta3 = getMyEWSMcache()->getZeta3();
2216 //double zeta4 = getMyCache()->GetZeta4();
2217 double zeta5 = getMyEWSMcache()->getZeta5();
2218
2219 /* massless non-singlet corrections */
2220 double C02 = 365.0 / 24.0 - 11.0 * zeta3 + (-11.0 / 12.0 + 2.0 / 3.0 * zeta3) * nf;
2221 double C03 = 87029.0 / 288.0 - 121.0 / 8.0 * zeta2 - 1103.0 / 4.0 * zeta3
2222 + 275.0 / 6.0 * zeta5
2223 + (-7847.0 / 216.0 + 11.0 / 6.0 * zeta2 + 262.0 / 9.0 * zeta3
2224 - 25.0 / 9.0 * zeta5) * nf
2225 + (151.0 / 162.0 - zeta2 / 18.0 - 19.0 / 27.0 * zeta3) * nf*nf;
2226 double C04 = -156.61 + 18.77 * nf - 0.7974 * nf * nf + 0.0215 * nf * nf*nf;
2227 //std::cout << "TEST: C02 = " << C02 << std::endl;// TEST (should be 1.40923)
2228 //std::cout << "TEST: C03 = " << C03 << std::endl;// TEST (should be -12.7671)
2229 //std::cout << "TEST: C04 = " << C04 << std::endl;// TEST (should be -80.0075)
2230
2231 /* quadratic massive corrections */
2232 double C23 = -80.0 + 60.0 * zeta3 + (32.0 / 9.0 - 8.0 / 3.0 * zeta3) * nf;
2233 double C21V = 12.0;
2234 double C22V = 253.0 / 2.0 - 13.0 / 3.0 * nf;
2235 double C23V = 2522.0 - 855.0 / 2.0 * zeta2 + 310.0 / 3.0 * zeta3 - 5225.0 / 6.0 * zeta5
2236 + (-4942.0 / 27.0 + 34.0 * zeta2 - 394.0 / 27.0 * zeta3
2237 + 1045.0 / 27.0 * zeta5) * nf
2238 + (125.0 / 54.0 - 2.0 / 3.0 * zeta2) * nf*nf;
2239
2240 /* quartic massive corrections */
2241 double C42 = 13.0 / 3.0 - 4.0 * zeta3;
2242 double C40V = -6.0;
2243 double C41V = -22.0;
2244 double C42V = -3029.0 / 12.0 + 162.0 * zeta2 + 112.0 * zeta3
2245 + (143.0 / 18.0 - 4.0 * zeta2 - 8.0 / 3.0 * zeta3) * nf;
2246 double C42VL = -11.0 / 2.0 + nf / 3.0;
2247
2248 /* power suppressed top-mass correction */
2249 //double xt = s/pow(quarks[TOP].getMass(),2.0);
2250 double xt = s / MtPole / MtPole; // the pole mass
2251 double C2t = xt * (44.0 / 675.0 - 2.0 / 135.0 * (-log_t));
2252
2253 /* rescaled strong coupling constant */
2254 double AlsMzPi = AlsMz / M_PI;
2255 double AlsMzPi2 = AlsMzPi*AlsMzPi;
2256 double AlsMzPi3 = AlsMzPi2*AlsMzPi;
2257 double AlsMzPi4 = AlsMzPi3*AlsMzPi;
2258
2259 /* electromagnetic coupling at Mz */
2260 double alpMz = alphaMz();
2261
2262 /* radiator function to the vector current */
2263 double RVf;
2264 RVf = 1.0 + 3.0 / 4.0 * Qf2 * alpMz / M_PI + AlsMzPi - Qf2 / 4.0 * alpMz / M_PI * AlsMzPi
2265 + (C02 + C2t) * AlsMzPi2 + C03 * AlsMzPi3 + C04 * AlsMzPi4
2266 + (mcMz2 + mbMz2) / s * C23 * AlsMzPi3
2267 + mqMz2 / s * (C21V * AlsMzPi + C22V * AlsMzPi2 + C23V * AlsMzPi3)
2268 + mcMz2 * mcMz2 / s / s * (C42 - log_c) * AlsMzPi2
2269 + mbMz2 * mbMz2 / s / s * (C42 - log_b) * AlsMzPi2
2270 + mqMz2 * mqMz2 / s / s * (C40V + C41V * AlsMzPi + (C42V + C42VL * log_q) * AlsMzPi2)
2271 + 12.0 * mqdash4 / s / s * AlsMzPi2
2272 - mqMz2 * mqMz2 * mqMz2 / s / s / s
2273 * (8.0 + 16.0 / 27.0 * (155.0 + 6.0 * log_q) * AlsMzPi);
2274 return RVf;
2275}
2276
2277double StandardModel::RAq(const QCD::quark q) const
2278{
2279 if (q == QCD::TOP) return 0.0;
2280
2281 double mcMz, mbMz;
2282 mcMz = myEWSMcache->mf(getQuarks(CHARM), Mz, FULLNNLO);
2283 mbMz = myEWSMcache->mf(getQuarks(BOTTOM), Mz, FULLNNLO);
2284 //mcMz = 0.56381685; /* for debug */
2285 //mbMz = 2.8194352; /* for debug */
2286
2287 double MtPole = mtpole;
2288
2289 /* z-component of isospin */
2290 double I3q = quarks[q].getIsospin();
2291 /* electric charge squared */
2292 double Qf2 = pow(quarks[q].getCharge(), 2.0);
2293
2294 /* s = Mz^2 */
2295 double s = Mz * Mz;
2296
2297 /* products of the charm and bottom masses at Mz */
2298 double mcMz2 = mcMz*mcMz;
2299 double mbMz2 = mbMz*mbMz;
2300 double mqMz2, mqdash4;
2301 switch (q) {
2302 case QCD::CHARM:
2303 mqMz2 = mcMz*mcMz;
2304 mqdash4 = mbMz2*mbMz2;
2305 break;
2306 case QCD::BOTTOM:
2307 mqMz2 = mbMz*mbMz;
2308 mqdash4 = mcMz2*mcMz2;
2309 break;
2310 default:
2311 mqMz2 = 0.0;
2312 mqdash4 = 0.0;
2313 break;
2314 }
2315
2316 /* Logarithms */
2317 //double log_t = log(pow(quarks[TOP].getMass(),2.0)/s);
2318 double log_t = log(MtPole * MtPole / s); // the pole mass
2319 double log_c = log(mcMz2 / s);
2320 double log_b = log(mbMz2 / s);
2321 double log_q;
2322 switch (q) {
2323 case QCD::CHARM:
2324 case QCD::BOTTOM:
2325 log_q = log(mqMz2 / s);
2326 break;
2327 default:
2328 log_q = 0.0;
2329 break;
2330 }
2331
2332 /* the active number of flavour */
2333 double nf = 5.0;
2334
2335 /* zeta functions */
2336 double zeta2 = getMyEWSMcache()->getZeta2();
2337 double zeta3 = getMyEWSMcache()->getZeta3();
2338 double zeta4 = getMyEWSMcache()->getZeta4();
2339 double zeta5 = getMyEWSMcache()->getZeta5();
2340
2341 /* massless non-singlet corrections */
2342 double C02 = 365.0 / 24.0 - 11.0 * zeta3 + (-11.0 / 12.0 + 2.0 / 3.0 * zeta3) * nf;
2343 double C03 = 87029.0 / 288.0 - 121.0 / 8.0 * zeta2 - 1103.0 / 4.0 * zeta3
2344 + 275.0 / 6.0 * zeta5
2345 + (-7847.0 / 216.0 + 11.0 / 6.0 * zeta2 + 262.0 / 9.0 * zeta3
2346 - 25.0 / 9.0 * zeta5) * nf
2347 + (151.0 / 162.0 - zeta2 / 18.0 - 19.0 / 27.0 * zeta3) * nf*nf;
2348 double C04 = -156.61 + 18.77 * nf - 0.7974 * nf * nf + 0.0215 * nf * nf*nf;
2349 //std::cout << "TEST: C02 = " << C02 << std::endl;// TEST (should be 1.40923)
2350 //std::cout << "TEST: C03 = " << C03 << std::endl;// TEST (should be -12.7671)
2351 //std::cout << "TEST: C04 = " << C04 << std::endl;// TEST (should be -80.0075)
2352
2353 /* quadratic massive corrections */
2354 double C23 = -80.0 + 60.0 * zeta3 + (32.0 / 9.0 - 8.0 / 3.0 * zeta3) * nf;
2355 double C20A = -6.0;
2356 double C21A = -22.0;
2357 double C22A = -8221.0 / 24.0 + 57.0 * zeta2 + 117.0 * zeta3
2358 + (151.0 / 12.0 - 2.0 * zeta2 - 4.0 * zeta3) * nf;
2359 double C23A = -4544045.0 / 864.0 + 1340.0 * zeta2 + 118915.0 / 36.0 * zeta3
2360 - 127.0 * zeta5
2361 + (71621.0 / 162.0 - 209.0 / 2.0 * zeta2 - 216.0 * zeta3
2362 + 5.0 * zeta4 + 55.0 * zeta5) * nf
2363 + (-13171.0 / 1944.0 + 16.0 / 9.0 * zeta2 + 26.0 / 9.0 * zeta3) * nf*nf;
2364
2365 /* quartic massive corrections */
2366 double C42 = 13.0 / 3.0 - 4.0 * zeta3;
2367 double C40A = 6.0;
2368 double C41A = 10.0;
2369 double C42A = 3389.0 / 12.0 - 162.0 * zeta2 - 220.0 * zeta3
2370 + (-41.0 / 6.0 + 4.0 * zeta2 + 16.0 / 3.0 * zeta3) * nf;
2371 double C42AL = 77.0 / 2.0 - 7.0 / 3.0 * nf;
2372
2373 /* power suppressed top-mass correction */
2374 //double xt = s/pow(quarks[TOP].getMass(),2.0);
2375 double xt = s / MtPole / MtPole; // the pole mass
2376 double C2t = xt * (44.0 / 675.0 - 2.0 / 135.0 * (-log_t));
2377
2378 /* singlet axial-vector corrections */
2379 double I2 = -37.0 / 12.0 + (-log_t) + 7.0 / 81.0 * xt + 0.0132 * xt*xt;
2380 double I3 = -5075.0 / 216.0 + 23.0 / 6.0 * zeta2 + zeta3 + 67.0 / 18.0 * (-log_t)
2381 + 23.0 / 12.0 * log_t*log_t;
2382 double I4 = 49.0309 - 17.6637 * (-log_t) + 14.6597 * log_t * log_t
2383 + 3.6736 * (-log_t * log_t * log_t);
2384
2385 /* rescaled strong coupling constant */
2386 double AlsMzPi = AlsMz / M_PI;
2387 double AlsMzPi2 = AlsMzPi*AlsMzPi;
2388 double AlsMzPi3 = AlsMzPi2*AlsMzPi;
2389 double AlsMzPi4 = AlsMzPi3*AlsMzPi;
2390
2391 /* electromagnetic coupling at Mz */
2392 double alpMz = alphaMz();
2393
2394 /* radiator function to the axial-vector current */
2395 double RAf;
2396 RAf = 1.0 + 3.0 / 4.0 * Qf2 * alpMz / M_PI + AlsMzPi - Qf2 / 4.0 * alpMz / M_PI * AlsMzPi
2397 + (C02 + C2t - 2.0 * I3q * I2) * AlsMzPi2
2398 + (C03 - 2.0 * I3q * I3) * AlsMzPi3
2399 + (C04 - 2.0 * I3q * I4) * AlsMzPi4
2400 + (mcMz2 + mbMz2) / s * C23 * AlsMzPi3
2401 + mqMz2 / s * (C20A + C21A * AlsMzPi + C22A * AlsMzPi2
2402 + 6.0 * (3.0 + log_t) * AlsMzPi2 + C23A * AlsMzPi3)
2403 //- 10.0*mqMz2/pow(quarks[TOP].getMass(),2.0)
2404 - 10.0 * mqMz2 / MtPole / MtPole // the pole mass
2405 * (8.0 / 81.0 + log_t / 54.0) * AlsMzPi2
2406 + mcMz2 * mcMz2 / s / s * (C42 - log_c) * AlsMzPi2
2407 + mbMz2 * mbMz2 / s / s * (C42 - log_b) * AlsMzPi2
2408 + mqMz2 * mqMz2 / s / s * (C40A + C41A * AlsMzPi
2409 + (C42A + C42AL * log_q) * AlsMzPi2)
2410 - 12.0 * mqdash4 / s / s*AlsMzPi2;
2411 return RAf;
2412}
2413
2414double StandardModel::RVh() const
2415{
2416 /* rescaled strong coupling constant */
2417 double AlsMzPi = AlsMz / M_PI;
2418 double AlsMzPi2 = AlsMzPi*AlsMzPi;
2419 double AlsMzPi3 = AlsMzPi2*AlsMzPi;
2420 double AlsMzPi4 = AlsMzPi3*AlsMzPi;
2421
2422 gslpp::complex gV_sum(0.0, 0.0);
2423 gslpp::complex gV_q;
2424 for (int q = 0; q < 6; q++) {
2425 gV_q = gV_f(QCD::quarks[(QCD::quark)q]);
2426 if (q == (int) (QCD::TOP))
2427 gV_q = 0.0;
2428 gV_sum += gV_q;
2429 }
2430
2431 // singlet vector corrections
2432 return ( gV_sum.abs2()*(-0.4132 * AlsMzPi3 - 4.9841 * AlsMzPi4));
2433}
2434
2436// EW low-energy observables: Parity violation
2437
2438
2439// The anomalous magnetic moment of the muon a_mu=(g_mu-2)/2
2440
2441const double StandardModel::amuon() const
2442{
2443
2444// output
2445 double amu;
2446
2447// -----------------------------------------------------------------
2448// qed contributions
2449 double amuqed,alfa0pi;
2450
2451// ew contributions
2452 double amuew,amuew1,amuew2b,amuew2f,amuew2,amuew3,cft,cf,corr1amuew2, corr2amuew2,corrwaamuew2,al,aq,b1; //,b2;
2453
2454// qcd contributions
2455 double amuhad,amuhhovp,amuhholbl,amuhho,amuhlo;
2456
2457// -----------------------------------------------------------------
2458// numerical constants
2459 const double sn2=0.2604341;
2460
2461// -----------------------------------------------------------------
2462// SM parameters
2463
2464// light quark masses. constituent masses
2465 const double umass=0.3;
2466 const double dmass=0.3;
2467 const double smass=0.5;
2468
2469 const double mum=leptons[MU].getMass(),taum=leptons[TAU].getMass();
2470 const double cqm=quarks[CHARM].getMass(),bqm=quarks[BOTTOM].getMass();
2471
2472// all fermion masses (constituent masses for u,d,s. for the other from model)
2473 double fermmass[9]={leptons[ELECTRON].getMass(),mum,taum,
2474 dmass,umass,
2475 smass,cqm,
2476 bqm,mtpole};
2477
2478// w mass and on-shell weak angle
2479 double MwSM, s2;
2480
2481// running of alfa_qed and dummy variable
2482 double aqed;
2483
2484// for the 2-loop bosonic corrections
2485 double a2l[4]={0.,0.,0.,0.},b2l[4]={0.,0.,0.,0.},sw2l[4]={0.,0.,0.,0.};
2486
2487// for the 2-loop corrections from the renormalization of weak angle
2488 double c2lren[6]={0.,0.,0.,0.,0.,0.};
2489
2490// w mass
2491 MwSM=Mw();
2492
2493 s2=1.0 - MwSM*MwSM/Mz/Mz;
2494
2495//------------------------------------------------------------------
2496// qed contribution to amu (arxiv: hep-ph/0606174)
2497 alfa0pi=ale/M_PI;
2498
2499 amuqed=alfa0pi*(0.5+alfa0pi*(0.765857410+alfa0pi*(24.05050964+
2500 + alfa0pi*(130.8055+663.0*alfa0pi))));
2501
2502//-----------------------------------------------------------------
2503// one-loop ew correction(phys.rev.lett. 76,3267 (1996))
2504
2505 amuew1=5.0*GF*mum*mum/(24.0*sqrt(2.0)*M_PI*M_PI)*(1.0+
2506 + 0.2*(1.0-4.0*s2)*(1.0-4.0*s2));
2507
2508//-----------------------------------------------------------------
2509// two-loop computation
2510
2511// these depend on aqed and since we are going to include also three-loop
2512// effects we need to include in the two-loop results the running of aqed at
2513// 1-loop up to the scale mum
2514//-----------------------------------------------------------------
2515// running of alpha em down to mu mass (1-loop)
2516
2517 aqed = 1.0/ale + 2.0 * log(fermmass[0]/mum)/3.0/M_PI;
2518
2519 aqed = 1.0/aqed;
2520
2521//-----------------------------------------------------------------
2522// two-loop ew bosonic correction(phys.rev.lett. 76,3267 (1996))
2523
2524// previous definitions
2525 a2l[0]=19.0/36.0-99.0*sn2/8.0-1.0*2.0*log(mHl/MwSM)/24.0;
2526
2527 b2l[0]=155.0/192.0+3.0*M_PI*M_PI/8.0-9.0*sn2/8.0+3.0*2.0*pow(log(mHl/MwSM),2)/2.0-21.0*2.0*log(mHl/MwSM)/16.0;
2528
2529 sw2l[0]=1.0/s2;
2530
2531 a2l[1]=-859.0/18.0+11.0*M_PI/sqrt(3.0)+20.0*M_PI*M_PI/9.0+ 393.0*sn2/8.0-65.0*2.0*log(MwSM/mum)/9.0+ 31.0*2.0*log(mHl/MwSM)/72.0;
2532
2533 b2l[1]=433.0/36.0+5.0*M_PI*M_PI/24.0-51.0*sn2/8.0+ 3.0*4.0*pow(log(mHl/MwSM),2)/8.0+9.0*2.0*log(mHl/MwSM)/4.0;
2534
2535 sw2l[1]=1.0;
2536
2537 a2l[2]=165169.0/1080.0-385.0*M_PI/(6.0*sqrt(3.0))-29.0*M_PI*M_PI/6.0+ 33.0*sn2/8.0+92.0*2.0*log(MwSM/mum)/9.0- 133.0*2.0*log(mHl/MwSM)/72.0;
2538
2539 b2l[2]=-431.0/144.0+3.0*M_PI*M_PI/8.0+315.0*sn2/8.0+ 3.0*4.0*pow(log(mHl/MwSM),2)/2.0-11.0*2.0*log(mHl/MwSM)/8.0;
2540
2541 sw2l[2]=s2;
2542
2543 a2l[3]=-195965.0/864.0+265.0*M_PI/(3.0*sqrt(3.0))+163.0*M_PI*M_PI/18.0+ 223.0*sn2/12.0-184.0*2.0*log(MwSM/mum)/9.0- 5.0*2.0*log(mHl/MwSM)/8.0;
2544
2545 b2l[3]=433.0/216.0+13.0*M_PI*M_PI/24.0+349.0*sn2/24.0+ 21.0*4.0*pow(log(mHl/MwSM),2)/8.0-49.0*2.0*log(mHl/MwSM)/12.0;
2546
2547 sw2l[3]=s2*s2;
2548
2549// computation
2550
2551 amuew2b=0.0;
2552
2553 for (int i = 0; i < 4; ++i) {
2554 amuew2b=amuew2b+a2l[i]*sw2l[i]+(MwSM*MwSM/mHl/mHl)*b2l[i]*sw2l[i];
2555 }
2556
2557// the contribution with the running of aqed up to the mu scale
2558 amuew2b=mum*mum*aqed*GF*amuew2b/(8.0*sqrt(2.0)*M_PI*M_PI*M_PI);
2559
2560//-----------------------------------------------------------------
2561// two-loop ew fermionic correction(phys.rev.d 52,r2619(1995)
2562
2563// contribution from higgs boson diagram
2564 if (mHl < (mtpole-10.0)) {
2565 cft=-104.0/45.0-16.0*2.0*log(mtpole/mHl)/15.0;
2566 } else if (mHl > (mtpole+10)) {
2567 cft=-(mtpole*mtpole/mHl/mHl)*(24.0/5.0+8.0*M_PI*M_PI/15.0+
2568 + 8.0/5.0*pow(2.0*log(mHl/mtpole)-1.0,2));
2569 } else {
2570 cft=-(32.0/5.0)*(1.0-9.0*sn2/4.0);
2571 }
2572
2573 cf=pow((umass*cqm*Mz),(4.0/3.0));
2574
2575 cf=cf/(pow((dmass*smass*bqm),(1.0/3.0))*mum*mum*taum);
2576
2577 cf=-18.0*log(cf)/5.0-3.0*mtpole*mtpole/(16.0*s2*MwSM*MwSM)- 3.0*2.0*log(mtpole/MwSM)/(10.0*s2)- 8.0*2.0*log(mtpole/Mz)/5.0-41.0/5.0-7.0/(10.0*s2)+ 8.0*M_PI*M_PI/15.0+cft;
2578
2579// the contribution with the running of aqed up to the mu scale
2580 amuew2f=5.0*GF*mum*mum*cf*aqed/(24.0*sqrt(2.0)*M_PI*M_PI*M_PI);
2581
2582//-----------------------------------------------------------------
2583// corrections from hadronic loops (phys.rev.d 67,073006(2003))
2584// i also include the running here even though in the previous reference seems that it is not included
2585// first family (eqs. (60) and (61))
2586 corr1amuew2=-aqed*GF*mum*mum/(8.0*M_PI*M_PI*M_PI*sqrt(2.0))*(8.41- log(pow(umass,8)/(pow(mum,6)*pow(dmass,2)))-17.0/2.0);
2587// second family (eqs. (65) and (66))
2588 corr2amuew2=-aqed*GF*mum*mum/(8.0*M_PI*M_PI*M_PI*sqrt(2.0))*(17.1- log(pow(cqm,8)/(pow(mum,6)*pow(smass,2)))-47.0/6.0+8.0*M_PI*M_PI/9.0);
2589
2590//-----------------------------------------------------------------
2591// corrections from the renormalization of the weak mixing
2592// terms prop. to (1-4s2) included in eq. (7) of phys.rev.d 67,073006(2003)
2593// and neglected in the previous references
2594
2595 corrwaamuew2=-43.0*31.0*(1.0-4.0*s2)*(1.0-4.0*s2)/(215.0*3.0)*log(Mz/mum);
2596
2597 c2lren[0]=(72.0/135.0)*(-1.0+2.0*s2)*(1.0-4.0*s2); //leptons
2598 c2lren[1]=(72.0/135.0)*(-1.0+2.0*s2/3.0)*(1.0-4.0*s2); //d-quark
2599 c2lren[2]=-(144.0/135.0)*(1.0-4.0*s2/3.0)*(1.0-4.0*s2); //u-quark
2600 c2lren[3]=c2lren[1];//d-quark
2601 c2lren[4]=c2lren[2]; //u-quark
2602 c2lren[5]=c2lren[1]; //d-quark
2603
2604 for (int i = 2; i < 8; ++i) {
2605 corrwaamuew2=corrwaamuew2+c2lren[i-2]*log(Mz/fermmass[i]);
2606 }
2607
2608 corrwaamuew2=5*GF*mum*mum*aqed/(24.0*sqrt(2.0)*M_PI*M_PI*M_PI)*corrwaamuew2;
2609
2610// finally i also add the small correction to the eq.8
2611 corrwaamuew2=corrwaamuew2-0.2e-11;
2612
2613//-----------------------------------------------------------------
2614// total 2-loop ew contribution
2615 amuew2=amuew2b+amuew2f+corr1amuew2+corr2amuew2+corrwaamuew2;
2616
2617//-----------------------------------------------------------------
2618// three-loop ew correction(phys.rev.d 67,073006(2003)
2619
2620 al=2789.0*log(Mz/mum)*log(Mz/mum)/90.0- 302.0*log(Mz/taum)*log(Mz/taum)/45.0+ 72.0*log(Mz/taum)*log(Mz/mum)/5.0;
2621
2622 aq=-2662.0*log(Mz/bqm)*log(Mz/bqm)/1215.0+11216.0*log(Mz/cqm)*log(Mz/cqm)/1215.0+1964.0*log(Mz/umass)*log(Mz/umass)/405.0+24.0*log(Mz/bqm)*log(Mz/mum)/5.0-96.0*log(Mz/cqm)*log(Mz/mum)/5.0-48.0*log(Mz/umass)*log(Mz/mum)/5.0+32.0*log(Mz/bqm)*log(Mz/cqm)/405.0+32.0*log(Mz/bqm)*log(Mz/umass)/135.0;
2623
2624 b1=-179.0/45.0*(log(Mz/bqm)*log(Mz/bqm)/3.0+log(Mz/taum)*log(Mz/taum)+4.0*log(Mz/cqm)*log(Mz/cqm)/3.0+2.0*log(Mz/umass)*log(Mz/umass)+2.0*log(Mz/mum)*log(Mz/mum))+2.0/5.0*(log(bqm/taum)*log(bqm/taum)+4.0/3.0*log(bqm/cqm)*log(bqm/cqm)+2.0*log(bqm/umass)*log(bqm/umass)+2.0*log(bqm/mum)*log(bqm/mum) )-8.0/5.0*(2.0*log(cqm/umass)*log(cqm/umass)+2.0*log(cqm/mum)*log(cqm/mum))+6.0/5.0*(4.0/3.0*log(taum/cqm)*log(taum/cqm)+2.0*log(taum/umass)*log(taum/umass)+2.0*log(taum/mum)*log(taum/mum))-8.0*log(umass/mum)*log(umass/mum)/5.0;
2625
2626 // b2 is not used, as it can be absorved in the two loop part if alpha(m_mu) is used instead of alpha(Mz), as done above
2627 // b2=2.0/5.0*(2.0*log(Mz/mum)+2.0*log(Mz/umass)+4.0*log(Mz/cqm)/3.0+log(Mz/taum)+log(Mz/bqm)/3.0)*(215.0*log(Mz/mum)/9.0-4.0*log(Mz/umass)-8.0*log(Mz/cqm)+6.0*log(Mz/taum)+2.0*log(Mz/bqm));
2628
2629// the final correction(it is implied aqed at mum for the 2-loop
2630// correction
2631
2632 amuew3=amuew1*(ale*ale/M_PI/M_PI)*(al+aq+b1);
2633
2634//-----------------------------------------------------------------
2635// total ew correction
2636
2637 amuew=amuew1+amuew2+amuew3;
2638
2639//-----------------------------------------------------------------
2640// hadronic contributions (arxiv: 0908.4300 & 1001.5401 [hep-ph])
2641
2642// leading order: vacuum polarization (arxiv: 0908.4300 [hep-ph])
2643 amuhlo=6955.e-11;
2644
2645// higher order: vacuum polarization
2646 amuhhovp=-97.9e-11;
2647
2648// higher order: light-by-light
2649 amuhholbl=105.e-11;
2650
2651 amuhho=amuhhovp+amuhholbl;
2652
2653// total hadronic contribution
2654
2655 amuhad=amuhlo+amuhho;
2656
2657//-----------------------------------------------------------------
2658// final value for the muon (g-2)/2
2659
2660 amu=amuqed+amuew+amuhad;
2661
2662//-----------------------------------------------------------------
2663
2664 return amu;
2665
2666}
2667
2668
2669// The electron's weak charge
2670
2671const double StandardModel::Qwemoller(const double q2, const double y) const
2672{
2673 // Weak charge
2674 double Qwe;
2675
2676 // definitions
2677 double MwSM,f1,fy,f2,af2;
2678 const double mpion=134.9766e-3;
2679
2680 // -----------------------------------------------------------------
2681
2682 double dalfos, dalfms, alfams;
2683 double rhoNC, kappa0, s2MSbar,c2MSbar;
2684 double xi;
2685 double leptk0,quarkk0;
2686 double elm=leptons[ELECTRON].getMass(), mum=leptons[MU].getMass(), taum=leptons[TAU].getMass();
2687
2688 // -----------------------------------------------------------------
2689
2690 // w mass
2691 MwSM=Mw();
2692
2693 // xi factor
2694 xi=mHl*mHl/Mz/Mz;
2695
2696 // -----------------------------------------------------------------
2697
2698 // universal corrections
2699 // ---------------------
2700
2701 // obtaining alfa(mz)_msbar from alfa(mz)_on-shell
2702 // -----------------------------------------------
2703
2704 // on-shell value of delta alpha(mz)
2705 dalfos=1.0-ale/alphaMz();
2706 // msbar value of delta alpha(mz) (formula from PDG, Erler & Langacker ew review)
2707 dalfms=dalfos+ale/M_PI*(100.0/27.0-1.0/6.0-7.0*2.0*log(Mz/MwSM)/4.0);
2708 // msbar value of alfa(mz)
2709 alfams=ale/(1.0-dalfms);
2710
2711 // ms bar weinberg's angle from the effective leptonic angle
2712 // (formula from PDG, Erler & Langacker ew review)
2713 // ---------------------------------------------------------
2714 s2MSbar=(myApproximateFormulae->sin2thetaEff_l_full())-0.00029;
2715 c2MSbar=1.0-s2MSbar;
2716
2717 // rho parameter (expansion in alfams)
2718 // -------------
2719
2720 rhoNC=1.0+alfams/(4.0*M_PI)*(3.0/(4.0*s2MSbar*s2MSbar)*log(c2MSbar)-7.0/(4.0*s2MSbar)+3.0*mtpole*mtpole/(4.0*s2MSbar*MwSM*MwSM) + 3.0*xi/(4.0*s2MSbar)*(log(c2MSbar/xi)/(c2MSbar-xi)+(1.0/c2MSbar)*log(xi)/(1.0-xi)));
2721
2722 // kappa at zero momentum (expansion in alfa)
2723 // ----------------------
2724
2725 // lepton contribution to kappa0
2726 leptk0=((-0.5)*(-1)-2.0*s2MSbar)*2.0*(log(elm/Mz)+log(mum/Mz)+log(taum/Mz))/3.0;
2727
2728 // quark contribution to kappa0 (updated from hep-ph/0302149)
2729 quarkk0=-6.802;
2730
2731 kappa0=1.0-ale/(2.0*M_PI*s2MSbar)*(leptk0+quarkk0-(7.0*c2MSbar/2.0+1.0/12.0)*log(c2MSbar)+(7.0/9.0-s2MSbar/3.0));
2732
2733 // -----------------------------------------------------------------
2734
2735 // f1(y,q2) (expansion in alfa)
2736 // --------
2737
2738 // f(y)
2739 fy=-2.0*log(y*(1.0-y))/3.0+1.0/pow((1.0-y+y*y),2)*(-2.0*(1.0-y)*(3.0-3.0*y+4.0*y*y*y- 3.0*y*y*y*y)*log(1.0-y)-2.0*y*(1.0+3.0*y-6.0*y*y+8.0*y*y*y-3.0*y*y*y*y)*log(y)+ (1.0-y)*(2.0-2.0*y-7.0*y*y+10.0*y*y*y-8.0*y*y*y*y+3.0*y*y*y*y*y)*log(1.0-y)*log(1.0-y)- y*(2.0-3.0*y-5.0*y*y+8.0*y*y*y-7.0*y*y*y*y+3.0*y*y*y*y*y)*log(y)*log(y)+ (2.0-4.0*y+11.0*y*y*y-13.0*y*y*y*y+9.0*y*y*y*y*y-3.0*y*y*y*y*y*y)*(M_PI*M_PI-2.0*log(1.0-y)*log(y)));
2740
2741 f1=-ale/(4.0*M_PI)*(1.0-4.0*kappa0*s2MSbar)*(22.0*log(y*Mz*Mz/q2)/3.0+85.0/9.0+fy);
2742
2743 // note that i have used 1-4*kappa*s2MSbar instead of 1-4*s2MSbar or an average as suggested in the
2744 // reference
2745
2746
2747 // f2(y,q2) (expansion in alfa)
2748 // --------
2749 // (y=1/2 approximattion using a pion loop calculation)
2750
2751 // af2
2752 af2=sqrt(1.0+4.0*mpion*mpion/q2);
2753 f2=ale/(4.0*M_PI)*(af2*af2*af2/3.0*log((af2+1.0)/(af2-1.0))-2.0/9.0-2.0*af2*af2/3.0);
2754
2755
2756 // electron's weak charge
2757 // ----------------------
2758 Qwe=-rhoNC*(1.0-4.0*kappa0*s2MSbar+alfams/(4.0*M_PI*s2MSbar)+f1+f2- 3.0*alfams*(1.0-4.0*kappa0*s2MSbar)*(1.0+(1.0-4.0*kappa0*s2MSbar)*(1.0-4.0*kappa0*s2MSbar))/(32.0*M_PI*s2MSbar*c2MSbar));
2759
2760 // again, i have used 1-4*kappa*s2MSbar even in the loop contributions
2761
2762 return Qwe;
2763}
2764
2765
2766
2767// The parity violating asymmetry in Moller scattering
2768
2769const double StandardModel::alrmoller(const double q2, const double y) const
2770{
2771 // functions and inputs
2772 double alrmoller;
2773
2774 // which alfa is this? => alpha(0). is this ale?
2775
2776 // parity violation asymmetry
2777 // --------------------------
2778 alrmoller=-GF*q2*(1.0-y)/(sqrt(2.0)*M_PI*ale*(1.0+pow(y,4)+pow(1.0-y,4)))*Qwemoller(q2,y);
2779
2780 return alrmoller;
2781}
2782
2783
2784
2785// The computation of the proton and neutron weak charge: Qwp,Qwn
2786
2787const double StandardModel::Qwp() const
2788{
2789 // Definitions
2790 double qwproton;
2791
2792 double MwSM,alfapi,asMw,dkappa5h,s2MSbar0,deltae,deltaep,boxpww,boxpzz,boxpaz;
2793 // I choose as lambda m_rho (pdg rho(770)) --> caz=3/2
2794 const double lambda=775.49e-3;
2795 const double caz=1.5;
2796
2797 // lepton masses
2798 double mlept[3]={leptons[ELECTRON].getMass(),leptons[MU].getMass(),leptons[TAU].getMass()};
2799
2800 // -----------------------------------------------------------------
2801 double dalfos, dalfms, alfams;
2802 double rhoNC, s2MSbar,c2MSbar;
2803 double xi;
2804 double elm=leptons[ELECTRON].getMass();
2805 // -----------------------------------------------------------------
2806
2807 // W mass
2808 MwSM=Mw();
2809
2810 // xi factor
2811 xi=mHl*mHl/Mz/Mz;
2812
2813 // alfa/pi
2814 alfapi=ale/M_PI;
2815
2816 // alfa_s(Mw)
2817 asMw = Als(MwSM, FULLNLO);
2818
2819 // -----------------------------------------------------------------
2820
2821 // Universal corrections
2822 // ---------------------
2823
2824 // Obtaining alfa(mz)_msbar from alfa(mz)_on-shell
2825 // -----------------------------------------------
2826
2827 // on-shell value of delta alpha(mz)
2828 dalfos=1.0-ale/alphaMz();
2829 // MSbar value of delta alpha(mz) (formula from PDG, Erler & Langacker ew review)
2830 dalfms=dalfos+ale/M_PI*(100.0/27.0-1.0/6.0-7.0*2.0*log(Mz/MwSM)/4.0);
2831 // MSbar value of alfa(mz)
2832 alfams=ale/(1.0-dalfms);
2833
2834 // MS bar weinberg's angle from the effective leptonic angle
2835 // (formula from PDG, Erler & Langacker ew review)
2836 // ---------------------------------------------------------
2837 s2MSbar=(myApproximateFormulae->sin2thetaEff_l_full())-0.00029;
2838 c2MSbar=1.0-s2MSbar;
2839
2840 // rho parameter (expansion in alfams)
2841 // -------------
2842
2843 rhoNC=1.0+alfams/(4.0*M_PI)*(3.0/(4.0*s2MSbar*s2MSbar)*log(c2MSbar)-7.0/(4.0*s2MSbar)+3.0*mtpole*mtpole/(4.0*s2MSbar*MwSM*MwSM) + 3.0*xi/(4.0*s2MSbar)*(log(c2MSbar/xi)/(c2MSbar-xi)+(1.0/c2MSbar)*log(xi)/(1.0-xi)));
2844
2845 // -----------------------------------------------------------------
2846
2847 // sin2w_ms(0) eq.14
2848 // -----------------
2849
2850 // hadronic contribution
2851 dkappa5h=7.9e-3;
2852
2853 s2MSbar0=0.0;
2854
2855 for (int i = 0; i < 3; ++i) {
2856 s2MSbar0=s2MSbar0+2.0*log(Mz/mlept[i]);
2857 }
2858
2859 s2MSbar0=s2MSbar+dkappa5h+alfapi*((s2MSbar0*(1.0+0.75*alfapi)+135.0*alfapi/32.0)*(1.0-4.0*s2MSbar)/12.0- (7.0*c2MSbar/4.0+1.0/24.0)*2.0*log(Mz/MwSM)+s2MSbar/6.0-7.0/18.0);
2860
2861 // -----------------------------------------------------------------
2862
2863 // external leg corrections
2864
2865 deltae=-0.5*alfapi;
2866
2867 deltaep=-alfapi/3.0*(1.0-4.0*s2MSbar)*(2.0*log(Mz/elm)+1.0/6.0);
2868
2869 // -----------------------------------------------------------------
2870
2871 // boxes
2872 // -----
2873
2874 boxpww=alfams*(2.0+5.0*(1.0-asMw/M_PI))/(4.0*M_PI*s2MSbar);
2875
2876 // pure zz and az boxes from prd 17 3055 app.a
2877
2878 boxpzz=alfams*(9.0/4.0-14.0*s2MSbar+38.0*s2MSbar*s2MSbar-40.0*s2MSbar*s2MSbar*s2MSbar)*(1.0-AlsMz/M_PI)/(4.0*M_PI*s2MSbar*c2MSbar);
2879
2880 boxpaz=5.0*alfams*(1.0-4.0*s2MSbar)*(2.0*log(Mz/lambda)+caz)/(2.0*M_PI);
2881
2882 // i assumme the same caz as in the proton enters for the neutron
2883 // -----------------------------------------------------------------
2884
2885 // weak charges
2886 // ------------
2887
2888 qwproton=(rhoNC+deltae)*(1.0-4.0*s2MSbar0+deltaep)+boxpww+boxpzz+boxpaz;
2889
2890 return qwproton;
2891
2892}
2893
2894
2895const double StandardModel::Qwn() const
2896{
2897 // Definitions
2898 double qwneutron;
2899
2900 double MwSM,alfapi,asMw,dkappa5h,s2MSbar0,deltae,deltaep,boxnww,boxnzz,boxnaz;
2901 // I choose as lambda m_rho (pdg rho(770)) --> caz=3/2
2902 const double lambda=775.49e-3;
2903 const double caz=1.5;
2904
2905 // lepton masses
2906 double mlept[3]={leptons[ELECTRON].getMass(),leptons[MU].getMass(),leptons[TAU].getMass()};
2907
2908 // -----------------------------------------------------------------
2909 double dalfos, dalfms, alfams;
2910 double rhoNC, s2MSbar,c2MSbar;
2911 double xi;
2912 double elm=leptons[ELECTRON].getMass();
2913 // -----------------------------------------------------------------
2914
2915 // W mass
2916 MwSM=Mw();
2917
2918 // xi factor
2919 xi=mHl*mHl/Mz/Mz;
2920
2921 // alfa/pi
2922 alfapi=ale/M_PI;
2923
2924 // alfa_s(Mw)
2925 asMw = Als(MwSM, FULLNLO);
2926
2927 // -----------------------------------------------------------------
2928
2929 // Universal corrections
2930 // ---------------------
2931
2932 // Obtaining alfa(mz)_msbar from alfa(mz)_on-shell
2933 // -----------------------------------------------
2934
2935 // on-shell value of delta alpha(mz)
2936 dalfos=1.0-ale/alphaMz();
2937 // MSbar value of delta alpha(mz) (formula from PDG, Erler & Langacker ew review)
2938 dalfms=dalfos+ale/M_PI*(100.0/27.0-1.0/6.0-7.0*2.0*log(Mz/MwSM)/4.0);
2939 // MSbar value of alfa(mz)
2940 alfams=ale/(1.0-dalfms);
2941
2942 // MS bar weinberg's angle from the effective leptonic angle
2943 // (formula from PDG, Erler & Langacker ew review)
2944 // ---------------------------------------------------------
2945 s2MSbar=(myApproximateFormulae->sin2thetaEff_l_full())-0.00029;
2946 c2MSbar=1.0-s2MSbar;
2947
2948 // rho parameter (expansion in alfams)
2949 // -------------
2950
2951 rhoNC=1.0+alfams/(4.0*M_PI)*(3.0/(4.0*s2MSbar*s2MSbar)*log(c2MSbar)-7.0/(4.0*s2MSbar)+3.0*mtpole*mtpole/(4.0*s2MSbar*MwSM*MwSM) + 3.0*xi/(4.0*s2MSbar)*(log(c2MSbar/xi)/(c2MSbar-xi)+(1.0/c2MSbar)*log(xi)/(1.0-xi)));
2952
2953 // -----------------------------------------------------------------
2954
2955 // sin2w_ms(0) eq.14
2956 // -----------------
2957
2958 // hadronic contribution
2959 dkappa5h=7.9e-3;
2960
2961 s2MSbar0=0.0;
2962
2963 for (int i = 0; i < 3; ++i) {
2964 s2MSbar0=s2MSbar0+2.0*log(Mz/mlept[i]);
2965 }
2966
2967 s2MSbar0=s2MSbar+dkappa5h+alfapi*((s2MSbar0*(1.0+0.75*alfapi)+135.0*alfapi/32.0)*(1.0-4.0*s2MSbar)/12.0- (7.0*c2MSbar/4.0+1.0/24.0)*2.0*log(Mz/MwSM)+s2MSbar/6.0-7.0/18.0);
2968
2969 // -----------------------------------------------------------------
2970
2971 // external leg corrections
2972
2973 deltae=-0.5*alfapi;
2974
2975 deltaep=-alfapi/3.0*(1.0-4.0*s2MSbar)*(2.0*log(Mz/elm)+1.0/6.0);
2976
2977 // -----------------------------------------------------------------
2978
2979 // boxes
2980 // -----
2981
2982 boxnww=alfams*(-2.0+4.0*(1.0-asMw/M_PI))/(4.0*M_PI*s2MSbar);
2983
2984 // pure zz and az boxes from prd 17 3055 app.a
2985
2986 boxnzz=alfams*(9.0/4.0-13.0*s2MSbar+34.0*s2MSbar*s2MSbar-32.0*s2MSbar*s2MSbar*s2MSbar)*(1.0-AlsMz/M_PI)/(4.0*M_PI*s2MSbar*c2MSbar);
2987
2988 // i assumme the same caz as in the proton enters for the neutron
2989 boxnaz=alfams*(4.0-16.0*s2MSbar)*(2.0*log(Mz/lambda)+caz)/(2.0*M_PI);
2990
2991 // -----------------------------------------------------------------
2992
2993 // weak charges
2994 // ------------
2995
2996 qwneutron=-(rhoNC+deltae)*(1.0+deltaep)+boxnww+boxnzz+boxnaz;
2997
2998 return qwneutron;
2999
3000}
3001
3002
3004 // EW low-energy observables: neutrino-scattering
3005
3006
3007const double StandardModel::gLnuN2() const
3008{
3009 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3010 if (!IsFlagNoApproximateGammaZ()){
3011
3012 /* SM contribution with the approximate formula */
3013 return (myApproximateFormulae->LEgLnuN2Approx());
3014
3015 } else {
3016 throw std::runtime_error("ERROR: StandardModel::gLnuN2, prediction implemented only via semianalytical approximate formula. Check flags!");
3017 }
3018}
3019
3020
3021const double StandardModel::gRnuN2() const
3022{
3023 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3024 if (!IsFlagNoApproximateGammaZ()){
3025
3026 /* SM contribution with the approximate formula */
3027 return (myApproximateFormulae->LEgRnuN2Approx());
3028
3029 } else {
3030 throw std::runtime_error("ERROR: StandardModel::gRnuN2, prediction implemented only via semianalytical approximate formula. Check flags!");
3031 }
3032}
3033
3034const double StandardModel::ThetaLnuN() const
3035{
3036 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3037 if (!IsFlagNoApproximateGammaZ()){
3038
3039 /* SM contribution with the approximate formula */
3040 return (myApproximateFormulae->LEThetaLnuNApprox());
3041
3042 } else {
3043 throw std::runtime_error("ERROR: StandardModel::ThetaLnuN, prediction implemented only via semianalytical approximate formula. Check flags!");
3044 }
3045}
3046
3047
3048const double StandardModel::ThetaRnuN() const
3049{
3050 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3051 if (!IsFlagNoApproximateGammaZ()){
3052
3053 /* SM contribution with the approximate formula */
3054 return (myApproximateFormulae->LEThetaRnuNApprox());
3055
3056 } else {
3057 throw std::runtime_error("ERROR: StandardModel::ThetaRnuN, prediction implemented only via semianalytical approximate formula. Check flags!");
3058 }
3059}
3060
3061const double StandardModel::gVnue() const
3062{
3063 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3064 if (!IsFlagNoApproximateGammaZ()){
3065
3066 /* SM contribution with the approximate formula */
3067 return (myApproximateFormulae->LEgVnueApprox());
3068
3069 } else {
3070 throw std::runtime_error("ERROR: StandardModel::gVnue, prediction implemented only via semianalytical approximate formula. Check flags!");
3071 }
3072}
3073
3074const double StandardModel::gAnue() const
3075{
3076 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3077 if (!IsFlagNoApproximateGammaZ()){
3078
3079 /* SM contribution with the approximate formula */
3080 return (myApproximateFormulae->LEgAnueApprox());
3081
3082 } else {
3083 throw std::runtime_error("ERROR: StandardModel::gAnue, prediction implemented only via semianalytical approximate formula. Check flags!");
3084 }
3085}
3086
3087
3088
3090// Lepton decays
3091
3092// Muon decay
3093
3094const double StandardModel::Gamma_muon() const
3095{
3096 double Gamma;
3097 double me, mmu, x, Fx, H1x, H2x, H3x, zeta3;
3098 double alpha, rEW;
3099 double pi2;
3100
3101 me = leptons[ELECTRON].getMass();
3102 mmu = leptons[MU].getMass();
3103 pi2 = M_PI*M_PI;
3104
3105 x = me*me/mmu/mmu;
3106 Fx = 1. - 8. * x + 8. * x*x*x - x*x*x*x -12. * x*x * log(x);
3107
3108 H1x = 25./8. - pi2/2. - (9. + 4. *pi2 + 12. * log(x) )*x + 16. * pi2 * pow(x,3./2.);
3109
3110 zeta3 = 1.2020569031595942;
3111
3112 H2x= 156815./5184. - 518. * pi2/81. - 895. *zeta3/36. + 67.*pi2*pi2/720. + 53. *pi2*log(2.)/6. - 0.042 - (5./4.) * pi2*sqrt(x);
3113
3114 H3x = -15.3;
3115
3116 // alpha(m_mu)
3117 alpha = 1./ale - log(x)/3./M_PI; // + 1./6./M_PI;
3118 alpha = 1./alpha;
3119
3120 // Rad. corrections
3121 rEW = 1. + H1x * alpha/M_PI + H2x * alpha*alpha/pi2 + H3x * alpha * alpha *alpha/pi2/M_PI;
3122
3123 // Gamma: PDG formula
3124 Gamma = GF*GF*pow(mmu,5)*Fx*rEW/192./pow(M_PI,3);
3125
3126 return Gamma;
3127}
3128
3129
3130// Tau decays
3131
3132// Leptonic decays
3133
3134const double StandardModel::Gamma_tau_l_nunu(const Particle l) const
3135{
3136 double Gamma;
3137 double ml, mtau, x, Fx, H1x, H2x, H3x, zeta3;
3138 double alpha, rEW;
3139 double pi2;
3140
3141 ml = l.getMass();
3142 mtau = leptons[TAU].getMass();
3143 pi2 = M_PI*M_PI;
3144
3145 x = ml*ml/mtau/mtau;
3146 Fx = 1. - 8. * x + 8. * x*x*x - x*x*x*x -12. * x*x * log(x);
3147
3148 H1x = 25./8. - pi2/2. - (9. + 4. *pi2 + 12. * log(x) )*x + 16. * pi2 * pow(x,3./2.);
3149
3150 zeta3 = 1.2020569031595942;
3151
3152 H2x= 156815./5184. - 518. * pi2/81. - 895. *zeta3/36. + 67.*pi2*pi2/720. + 53. *pi2*log(2.)/6. - 0.042 - (5./4.) * pi2*sqrt(x);
3153
3154 H3x = -15.3;
3155
3156 // alpha(m_tau)
3157 alpha = 1./133.29; // Improve
3158
3159 // Rad. corrections
3160 rEW = 1. + H1x * alpha/M_PI + H2x * alpha*alpha/pi2 + H3x * alpha * alpha *alpha/pi2/M_PI;
3161
3162 // Gamma: PDG formula
3163 Gamma = GF*GF*pow(mtau,5)*Fx*rEW/192./pow(M_PI,3);
3164
3165 return Gamma;
3166}
3167
3168
3169// Lepton universality tests
3170
3171const double StandardModel::TauLFU_gmuge() const
3172{
3173 double g2LFU;
3174
3175 double me, mmu, mtau, xe, Fxe, xmu, Fxmu;
3176
3177 me = leptons[ELECTRON].getMass();
3178 mmu = leptons[MU].getMass();
3179 mtau = leptons[TAU].getMass();
3180
3181 xe = me*me/mtau/mtau;
3182 Fxe = 1. - 8. * xe + 8. * xe*xe*xe - xe*xe*xe*xe -12. * xe*xe * log(xe);
3183
3184 xmu = mmu*mmu/mtau/mtau;
3185 Fxmu = 1. - 8. * xmu + 8. * xmu*xmu*xmu - xmu*xmu*xmu*xmu -12. * xmu*xmu * log(xmu);
3186
3187 g2LFU = (Gamma_tau_l_nunu(leptons[MU])/Gamma_tau_l_nunu(leptons[ELECTRON]));
3188
3189 g2LFU = g2LFU * (Fxe/Fxmu);
3190
3191 return sqrt(g2LFU);
3192}
3193
3194const double StandardModel::TauLFU_gtaugmu() const
3195{
3196 double g2LFU;
3197
3198 double me, mmu, mtau, xtau, Fxtau, xmu, Fxmu;
3199
3200 me = leptons[ELECTRON].getMass();
3201 mmu = leptons[MU].getMass();
3202 mtau = leptons[TAU].getMass();
3203
3204 xtau = me*me/mtau/mtau;
3205 Fxtau = 1. - 8. * xtau + 8. * xtau*xtau*xtau - xtau*xtau*xtau*xtau -12. * xtau*xtau * log(xtau);
3206
3207 xmu = me*me/mmu/mmu;
3208 Fxmu = 1. - 8. * xmu + 8. * xmu*xmu*xmu - xmu*xmu*xmu*xmu -12. * xmu*xmu * log(xmu);
3209
3210 g2LFU = (Gamma_tau_l_nunu(leptons[ELECTRON])/Gamma_muon());
3211
3212 g2LFU = g2LFU * (pow(mmu,5)*Fxmu/pow(mtau,5)/Fxtau);
3213
3214 return sqrt(g2LFU);
3215}
3216
3217const double StandardModel::TauLFU_gtauge() const
3218{
3219 double g2LFU;
3220
3221 double me, mmu, mtau, xtau, Fxtau, xmu, Fxmu;
3222
3223 me = leptons[ELECTRON].getMass();
3224 mmu = leptons[MU].getMass();
3225 mtau = leptons[TAU].getMass();
3226
3227 xtau = mmu*mmu/mtau/mtau;
3228 Fxtau = 1. - 8. * xtau + 8. * xtau*xtau*xtau - xtau*xtau*xtau*xtau -12. * xtau*xtau * log(xtau);
3229
3230 xmu = me*me/mmu/mmu;
3231 Fxmu = 1. - 8. * xmu + 8. * xmu*xmu*xmu - xmu*xmu*xmu*xmu -12. * xmu*xmu * log(xmu);
3232
3233 g2LFU = (Gamma_tau_l_nunu(leptons[MU])/Gamma_muon());
3234
3235 g2LFU = g2LFU * (pow(mmu,5)*Fxmu/pow(mtau,5)/Fxtau);
3236
3237 return sqrt(g2LFU);
3238}
3239
3240
3241const double StandardModel::TauLFU_gtaugmuPi() const
3242{
3243 // 1st approx.
3244
3245 return 1.0;
3246}
3247
3248const double StandardModel::TauLFU_gtaugmuK() const
3249{
3250 // 1st approx.
3251
3252 return 1.0;
3253}
3254
3255
3257// Higgs processes
3259
3260// Integrals
3261
3262gslpp::complex StandardModel::f_triangle(const double tau) const {
3263 gslpp::complex tmp;
3264 if (tau >= 1.0) {
3265 tmp = asin(1.0 / sqrt(tau));
3266 return (tmp * tmp);
3267 } else {
3268 tmp = log((1.0 + sqrt(1.0 - tau)) / (1.0 - sqrt(1.0 - tau))) - M_PI * gslpp::complex::i();
3269 return (-0.25 * tmp * tmp);
3270 }
3271}
3272
3273gslpp::complex StandardModel::g_triangle(const double tau) const {
3274 gslpp::complex tmp;
3275 if (tau >= 1.0) {
3276 tmp = sqrt(tau - 1.0) * asin(1.0 / sqrt(tau));
3277 return tmp;
3278 } else {
3279 tmp = sqrt(1.0 - tau) * (log((1.0 + sqrt(1.0 - tau)) / (1.0 - sqrt(1.0 - tau))) - M_PI * gslpp::complex::i());
3280 return 0.5 * tmp;
3281 }
3282}
3283
3284gslpp::complex StandardModel::I_triangle_1(const double tau, const double lambda) const {
3285 gslpp::complex tmp;
3286
3287 tmp = (tau * lambda * (f_triangle(tau) - f_triangle(lambda)) + 2.0 * tau * (g_triangle(tau) - g_triangle(lambda))) / (tau - lambda);
3288
3289 tmp = tau * lambda * (1.0 + tmp) / (2.0 * (tau - lambda));
3290
3291 return tmp;
3292}
3293
3294gslpp::complex StandardModel::I_triangle_2(const double tau, const double lambda) const {
3295 gslpp::complex tmp;
3296
3297 tmp = -0.5 * tau * lambda * (f_triangle(tau) - f_triangle(lambda)) / (tau - lambda);
3298
3299 return tmp;
3300}
3301
3302gslpp::complex StandardModel::AH_f(const double tau) const {
3303 return (2.0 * tau * (1.0 + (1.0 - tau) * f_triangle(tau)));
3304}
3305
3306gslpp::complex StandardModel::AH_W(const double tau) const {
3307 return -(2.0 + 3.0 * tau + 3.0 * tau * (2.0 - tau) * f_triangle(tau));
3308}
3309
3310gslpp::complex StandardModel::AHZga_f(const double tau, const double lambda) const {
3311 return I_triangle_1(tau, lambda) - I_triangle_2(tau, lambda);
3312}
3313
3314gslpp::complex StandardModel::AHZga_W(const double tau, const double lambda) const {
3315 gslpp::complex tmp;
3316
3317 double tan2w = sW2() / cW2();
3318
3319 tmp = 4.0 * (3.0 - tan2w) * I_triangle_2(tau, lambda);
3320
3321 tmp = tmp + ((1.0 + 2.0 / tau) * tan2w - (5.0 + 2.0 / tau)) * I_triangle_1(tau, lambda);
3322
3323 return sqrt(cW2()) * tmp;
3324}
3325
3327
3328const double StandardModel::SigmaeeZH(const double sqrt_s, const double Pe, const double Pp) const
3329{
3330 double xsLH, xsRH;
3331 double gL,gR,lam,fact;
3332 double s = sqrt_s*sqrt_s;
3333
3334 // From https://arxiv.org/pdf/hep-ph/9605437
3335
3336 gL = -0.5 + sW2();
3337
3338 gR = sW2();
3339
3340 lam = (1.0-(mHl+Mz)*(mHl+Mz)/s)*(1.0-(mHl-Mz)*(mHl-Mz)/s);
3341
3342 fact = (pow(GF*Mz*Mz,2.0)/96.0/M_PI/s) * sqrt(lam)*( lam + 12.0*Mz*Mz/s )/( 1.0 - Mz*Mz/s )/( 1.0 - Mz*Mz/s );
3343
3344 xsLH = 32.0 * gL * gL * fact;
3345 xsRH = 32.0 * gR * gR * fact;
3346
3347 return 0.25*( (1.0 - Pe)*(1.0 + Pp)*xsLH + (1.0 + Pe)*(1.0 - Pp)*xsRH );
3348}
3349
3350const double StandardModel::SigmaeeHvv(const double sqrt_s, const double Pe, const double Pp) const
3351{
3352 double xsLH=1.0, xsRH=0.0;
3353
3354 return 0.25*( (1.0 - Pe)*(1.0 + Pp)*xsLH + (1.0 + Pe)*(1.0 - Pp)*xsRH );
3355}
3356
3357const double StandardModel::SigmaeeHee(const double sqrt_s, const double Pe, const double Pp) const
3358{
3359 double xsLH=0.0, xsRH=0.0;
3360
3361 return 0.25*( (1.0 - Pe)*(1.0 + Pp)*xsLH + (1.0 + Pe)*(1.0 - Pp)*xsRH );
3362}
3363
3365// Higgs decay widths
3367
3368const double StandardModel::GammaHtogg() const
3369{
3370 double gamma;
3371 double tau_t = 4.0 * pow(quarks[TOP].getMass(),2)/mHl/mHl;
3372 double tau_b = 4.0 * pow(quarks[BOTTOM].getMass(),2)/mHl/mHl;
3373 double tau_c = 4.0 * pow(quarks[CHARM].getMass(),2)/mHl/mHl;
3374 double tau_s = 4.0 * pow(quarks[STRANGE].getMass(),2)/mHl/mHl;
3375 double asMH,LH,Lt,nl,h0,h1,h2, h3,G0;
3376
3377 // alfa_s(MH)
3378 asMH = Als(mHl, FULLNLO);
3379
3380 // NLO corrections ( See https://arxiv.org/pdf/0708.0916 and its REf. [25])
3381 // I only keep up to h3 in expr. (4), and use pole mass in tau factors for the moment
3382 nl = 5;
3383 LH = 0.; // log(mu^2/MH^2) evaluated at mu=MH
3384 Lt = 2.0*log(mHl/(quarks[TOP].getMass()));
3385
3386 h0 = (95./4.) + (11./2.)*LH + nl*(-7./6. - LH/3.);
3387 h1 = 5803./540. + 77.*LH/30. -14.*Lt/15. + nl * (-29./60. - 7. * LH / 45.);
3388 h2 = 1029839./189000. + 16973.*LH/12600. - 1543.*Lt/1575. + nl * ( - 89533./378000 - 1543.*LH/18900. );
3389 h3 = 9075763./2976750. + 1243*LH/1575. - 452.*Lt/575. + nl * ( - 3763./28350. -226. * LH / 4725. );
3390 G0 = GF * pow(mHl,3.0)/(36.*M_PI*sqrt(2.));
3391
3392 gamma = asMH*asMH * (4.0 * GF /sqrt(2.0)) * (mHl*mHl*mHl /64.0/pow(M_PI,3.0)) *
3393 ( AH_f(tau_t) + AH_f(tau_b) + AH_f(tau_c) + AH_f(tau_s) ).abs2()/4.0;
3394
3395 gamma = gamma + G0 * (asMH/M_PI) * (asMH/M_PI) * (asMH/M_PI) * (h0 + h1/tau_t + h2/tau_t/tau_t + h3/tau_t/tau_t/tau_t );
3396
3397 return gamma;
3398}
3399
3400const double StandardModel::GammaHtoZZstar() const
3401{
3402 double x=Mz/mHl;
3403 double fx;
3404 double g2 = 4.0 * sqrt(2.0) * GF * Mz * Mz;
3405 double gamma;
3406
3407 fx = -fabs(1.0-x*x)*( 47.0*x*x/2.0 - 13.0/2.0 +1.0/x/x ) +
3408 3.0*( 1.0 - 6.0*x*x + 4.0*x*x*x*x )*fabs(log(x)) +
3409 3.0*( 1.0 - 8.0*x*x + 20.0*x*x*x*x )*acos(( 3.0*x*x - 1.0 )/2.0/x/x/x)/sqrt( 4.0*x*x- 1.0);
3410
3411 gamma = g2*g2 * mHl * fx * ( 7.0 - 40.0*sW2()/3.0 + 160.0 *sW2()*sW2()/9.0 ) / 2048.0 / pow(M_PI,3.0);
3412
3413 return gamma;
3414}
3415
3416const double StandardModel::GammaHtoWWstar() const
3417{
3418 double x=Mw()/mHl;
3419 double fx;
3420 double g2 = 4.0 * sqrt(2.0) * GF * pow(Mw(),2);
3421 double gamma;
3422
3423 fx = -fabs(1.0-x*x)*( 47.0*x*x/2.0 - 13.0/2.0 +1.0/x/x ) +
3424 3.0*( 1.0 - 6.0*x*x + 4.0*x*x*x*x )*fabs(log(x)) +
3425 3.0*( 1.0 - 8.0*x*x + 20.0*x*x*x*x )*acos(( 3.0*x*x - 1.0 )/2.0/x/x/x)/sqrt( 4.0*x*x- 1.0);
3426
3427 gamma = 3.0 * g2*g2 * mHl * fx / 512.0 / pow(M_PI,3.0);
3428
3429 return gamma;
3430}
3431
3432const double StandardModel::GammaHtoZga() const
3433{
3434 double gamma;
3435
3436 double m_t = mtpole;
3437 double m_b = quarks[BOTTOM].getMass();
3438 double m_c = quarks[CHARM].getMass();
3439 double m_s = quarks[STRANGE].getMass();
3440 double m_tau = leptons[TAU].getMass();
3441 double m_mu = leptons[MU].getMass();
3442
3443 double M_w_2 = pow(Mw(),2.0);
3444
3445 double Qt = quarks[TOP].getCharge();
3446 double Qb = quarks[BOTTOM].getCharge();
3447 double Qc = quarks[CHARM].getCharge();
3448 double Qs = quarks[STRANGE].getCharge();
3449 double Qtau = leptons[TAU].getCharge();
3450 double Qmu = leptons[MU].getCharge();
3451
3452 double tau_t = 4.0 * m_t * m_t / mHl / mHl;
3453 double tau_b = 4.0 * m_b * m_b / mHl / mHl;
3454 double tau_c = 4.0 * m_c * m_c / mHl / mHl;
3455 double tau_s = 4.0 * m_s * m_s / mHl / mHl;
3456 double tau_tau = 4.0 * m_tau * m_tau / mHl / mHl;
3457 double tau_mu = 4.0 * m_mu * m_mu / mHl / mHl;
3458 double tau_W = 4.0 * M_w_2 / mHl / mHl;
3459
3460 double lambda_t = 4.0 * m_t * m_t / Mz / Mz;
3461 double lambda_b = 4.0 * m_b * m_b / Mz / Mz;
3462 double lambda_c = 4.0 * m_c * m_c / Mz / Mz;
3463 double lambda_s = 4.0 * m_s * m_s / Mz / Mz;
3464 double lambda_tau = 4.0 * m_tau * m_tau / Mz / Mz;
3465 double lambda_mu = 4.0 * m_mu * m_mu / Mz / Mz;
3466 double lambda_W = 4.0 * M_w_2 / Mz / Mz;
3467
3468 double sc = sqrt(sW2()*cW2());
3469 double vSMt = (2.0 * (quarks[TOP].getIsospin()) - 4.0 * Qt * sW2())/sc;
3470 double vSMb = (2.0 * (quarks[BOTTOM].getIsospin()) - 4.0 * Qb * sW2())/sc;
3471 double vSMc = (2.0 * (quarks[CHARM].getIsospin()) - 4.0 * Qc * sW2())/sc;
3472 double vSMs = (2.0 * (quarks[STRANGE].getIsospin()) - 4.0 * Qs * sW2())/sc;
3473 double vSMtau = (2.0 * (leptons[TAU].getIsospin()) - 4.0 * Qtau * sW2())/sc;
3474 double vSMmu = (2.0 * (leptons[MU].getIsospin()) - 4.0 * Qmu * sW2())/sc;
3475
3476 gslpp::complex MSM;
3477
3478 MSM = (ale/4.0/M_PI) * ((3.0 * vSMt * Qt * AHZga_f(tau_t, lambda_t) +
3479 3.0 * vSMb * Qb * AHZga_f(tau_b, lambda_b) +
3480 3.0 * vSMc * Qc * AHZga_f(tau_c, lambda_c) +
3481 3.0 * vSMs * Qs * AHZga_f(tau_s, lambda_s) +
3482 vSMtau * Qtau * AHZga_f(tau_tau, lambda_tau) +
3483 vSMmu * Qmu * AHZga_f(tau_mu, lambda_mu)) +
3484 AHZga_W(tau_W, lambda_W)/sqrt(sW2()));
3485
3486 gamma = (4.0*sqrt(2)*GF) * (MSM.abs2()) * pow(mHl*(1.0-Mz*Mz/mHl/mHl),3.0)/32.0/M_PI;
3487
3488 return gamma;
3489}
3490
3491const double StandardModel::GammaHtogaga() const
3492{
3493 double gamma;
3494
3495 double m_t = mtpole;
3496 double m_b = quarks[BOTTOM].getMass();
3497 double m_c = quarks[CHARM].getMass();
3498 double m_s = quarks[STRANGE].getMass();
3499 double m_tau = leptons[TAU].getMass();
3500 double m_mu = leptons[MU].getMass();
3501
3502 double M_w_2 = pow(Mw(),2.0);
3503
3504 double Qt = quarks[TOP].getCharge();
3505 double Qb = quarks[BOTTOM].getCharge();
3506 double Qc = quarks[CHARM].getCharge();
3507 double Qs = quarks[STRANGE].getCharge();
3508 double Qtau = leptons[TAU].getCharge();
3509 double Qmu = leptons[MU].getCharge();
3510
3511 double tau_t = 4.0 * m_t * m_t / mHl / mHl;
3512 double tau_b = 4.0 * m_b * m_b / mHl / mHl;
3513 double tau_c = 4.0 * m_c * m_c / mHl / mHl;
3514 double tau_s = 4.0 * m_s * m_s / mHl / mHl;
3515 double tau_tau = 4.0 * m_tau * m_tau / mHl / mHl;
3516 double tau_mu = 4.0 * m_mu * m_mu / mHl / mHl;
3517 double tau_W = 4.0 * M_w_2 / mHl / mHl;
3518
3519 gslpp::complex MSM;
3520
3521 MSM = ale * (3.0 * Qt * Qt * AH_f(tau_t) +
3522 3.0 * Qb * Qb * AH_f(tau_b) +
3523 3.0 * Qc * Qc * AH_f(tau_c) +
3524 3.0 * Qs * Qs * AH_f(tau_s) +
3525 Qtau * Qtau * AH_f(tau_tau) +
3526 Qmu * Qmu * AH_f(tau_mu) +
3527 AH_W(tau_W));
3528
3529 gamma = (4.0*GF/sqrt(2)) * (MSM.abs2()) * pow(mHl,3.0)/512.0/pow(M_PI,3);
3530
3531 return gamma;
3532}
3533
3534const double StandardModel::GammaHtomumu() const
3535{
3536 double mf=leptons[MU].getMass();
3537 double beta=1.0-4.0*mf*mf/mHl/mHl;
3538 double Nc=1.0;
3539 double gamma;
3540
3541 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta;
3542
3543 return gamma;
3544}
3545
3546const double StandardModel::GammaHtotautau() const
3547{
3548 double mf=leptons[TAU].getMass();
3549 double beta=1.0-4.0*mf*mf/mHl/mHl;
3550 double Nc=1.0;
3551 double gamma;
3552
3553 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta;
3554
3555 return gamma;
3556}
3557
3558const double StandardModel::GammaHtocc() const
3559{
3560 double mf0=quarks[CHARM].getMass(), mf;
3561 double beta;
3562 double Nc=3.0;
3563 double gamma;
3564 double asMH,DeltaQCD,Deltamt,NF;
3565
3566 // alfa_s(MH)
3567 asMH = Als(mHl, FULLNLO);
3568
3569 mf = Mrun(mHl, mf0, mf0, CHARM, FULLNLO);
3570
3571 beta=1.0-4.0*mf*mf/mHl/mHl;
3572
3573 NF=5;
3574
3575 DeltaQCD = 1 + (asMH/M_PI) * ( 17.0/3.0 + (asMH/M_PI) * ( (35.94 - 1.36*NF) + (164.14 - 25.77*NF + 0.26*NF*NF)*(asMH/M_PI) ) );
3576
3577 Deltamt = (asMH/M_PI) * (asMH/M_PI) * ( 1.57 + (4.0/3.0)*log(mHl/mtpole) + (4.0/9.0) * log(mf/mHl) * log(mf/mHl) );
3578
3579 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta * (DeltaQCD + Deltamt);
3580
3581 return gamma;
3582}
3583
3584const double StandardModel::GammaHtoss() const
3585{
3586 double mf0=quarks[STRANGE].getMass(), mf;
3587 double beta;
3588 double Nc=3.0;
3589 double gamma;
3590 double asMH,DeltaQCD,Deltamt,NF;
3591
3592 // alfa_s(MH)
3593 asMH = Als(mHl, FULLNLO);
3594
3595 mf = Mrun(mHl, 2.0, mf0, STRANGE, FULLNLO);
3596
3597 beta=1.0-4.0*mf*mf/mHl/mHl;
3598
3599 NF=5;
3600
3601 DeltaQCD = 1 + (asMH/M_PI) * ( 17.0/3.0 + (asMH/M_PI) * ( (35.94 - 1.36*NF) + (164.14 - 25.77*NF + 0.26*NF*NF)*(asMH/M_PI) ) );
3602
3603 Deltamt = (asMH/M_PI) * (asMH/M_PI) * ( 1.57 + (4.0/3.0)*log(mHl/mtpole) + (4.0/9.0) * log(mf/mHl) * log(mf/mHl) );
3604
3605 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta * (DeltaQCD + Deltamt);
3606
3607 return gamma;
3608}
3609
3610const double StandardModel::GammaHtobb() const
3611{
3612 double mf0=quarks[BOTTOM].getMass(), mf;
3613 double beta;
3614 double Nc=3.0;
3615 double gamma;
3616 double asMH,DeltaQCD,Deltamt,NF;
3617
3618 // alfa_s(MH)
3619 asMH = Als(mHl, FULLNLO);
3620
3621 mf = Mrun(mHl, mf0, mf0, BOTTOM, FULLNLO);
3622
3623 beta=1.0-4.0*mf*mf/mHl/mHl;
3624
3625 NF=5;
3626
3627 DeltaQCD = 1 + (asMH/M_PI) * ( 17.0/3.0 + (asMH/M_PI) * ( (35.94 - 1.36*NF) + (164.14 - 25.77*NF + 0.26*NF*NF)*(asMH/M_PI) ) );
3628
3629 Deltamt = (asMH/M_PI) * (asMH/M_PI) * ( 1.57 + (4.0/3.0)*log(mHl/mtpole) + (4.0/9.0) * log(mf/mHl) * log(mf/mHl) );
3630
3631 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta * (DeltaQCD + Deltamt);
3632
3633 return gamma;
3634}
3635
3636const double StandardModel::GammaHTot() const
3637{
3638 double gamma;
3639
3640 gamma = GammaHtobb() + GammaHtocc() + GammaHtoss() +
3641 GammaHtotautau() + GammaHtomumu() +
3642 GammaHtoZZstar() + GammaHtoWWstar() +
3643 GammaHtogg() + GammaHtogaga() + GammaHtoZga();
3644
3645 return gamma;
3646}
3647
3649// Higgs branching ratios
3651
3652const double StandardModel::BrHtogg() const
3653{
3654 return GammaHtogg()/GammaHTot();
3655}
3656
3657const double StandardModel::BrHtoZZstar() const
3658{
3659 return GammaHtoZZstar()/GammaHTot();
3660}
3661
3662const double StandardModel::BrHtoWWstar() const
3663{
3664 return GammaHtoWWstar()/GammaHTot();
3665}
3666
3667const double StandardModel::BrHtoZga() const
3668{
3669 return GammaHtoZga()/GammaHTot();
3670}
3671
3672const double StandardModel::BrHtogaga() const
3673{
3674 return GammaHtogaga()/GammaHTot();
3675}
3676
3677const double StandardModel::BrHtomumu() const
3678{
3679 return GammaHtomumu()/GammaHTot();
3680}
3681
3682const double StandardModel::BrHtotautau() const
3683{
3684 return GammaHtotautau()/GammaHTot();
3685}
3686
3687const double StandardModel::BrHtocc() const
3688{
3689 return GammaHtocc()/GammaHTot();
3690}
3691
3692const double StandardModel::BrHtoss() const
3693{
3694 return GammaHtoss()/GammaHTot();
3695}
3696
3697const double StandardModel::BrHtobb() const
3698{
3699 return GammaHtobb()/GammaHTot();
3700}
3701
3703//Generic e+e- -> ff Inclusive Observables
3704
3705// For f!=e
3706// (f=e also included to define a t-subtracted observable, like in LEP)
3707
3708// Helicity amplitudes squared
3709const double StandardModel::MLR2eeff(const Particle f, const double s) const {
3710
3711 // Definitions
3712 double Qf, geLSM, gfRSM, is2c2, GZ, Mz2s;
3713
3714 double MLR2SM;
3715
3716 // -------------------------------------------
3717
3718 geLSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3719
3720 is2c2 = 1. / s02() / c02();
3721
3722 GZ = Gamma_Z();
3723
3724 Mz2s = Mz * Mz - s;
3725
3726 if (f.is("ELECTRON")) {
3727 Qf = leptons[ELECTRON].getCharge();
3728 gfRSM = - Qf * s02();
3729 } else if (f.is("MU")) {
3730 Qf = leptons[MU].getCharge();
3731 gfRSM = - Qf * s02();
3732 } else if (f.is("TAU")) {
3733 Qf = leptons[TAU].getCharge();
3734 gfRSM = - Qf * s02();
3735 } else if (f.is("UP")) {
3736 Qf = quarks[UP].getCharge();
3737 gfRSM = - Qf * s02();
3738 } else if (f.is("CHARM")) {
3739 Qf = quarks[CHARM].getCharge();
3740 gfRSM = - Qf * s02();
3741 } else if (f.is("DOWN")) {
3742 Qf = quarks[DOWN].getCharge();
3743 gfRSM = - Qf * s02();
3744 } else if (f.is("STRANGE")) {
3745 Qf = quarks[STRANGE].getCharge();
3746 gfRSM = - Qf * s02();
3747 } else if (f.is("BOTTOM")) {
3748 Qf = quarks[BOTTOM].getCharge();
3749 gfRSM = - Qf * s02();
3750 } else
3751 throw std::runtime_error("StandardModel::MLR2eeff: wrong argument");
3752
3753 // LR, RL, LL and RR SM squared amplitudes
3754 MLR2SM = Qf * Qf
3755 + (is2c2 * is2c2 * (geLSM * geLSM * gfRSM * gfRSM) * s * s
3756 + 2.0 * Qf * is2c2 * (geLSM * gfRSM) * Mz2s * s) / (Mz2s * Mz2s + Mz * Mz * GZ * GZ);
3757
3758 return MLR2SM;
3759}
3760const double StandardModel::MRL2eeff(const Particle f, const double s) const{
3761
3762 // Definitions
3763 double Qf, geRSM, gfLSM, is2c2, GZ, Mz2s;
3764
3765 double MRL2SM;
3766
3767 // -------------------------------------------
3768
3769 geRSM = - (leptons[ELECTRON].getCharge()) * s02();
3770
3771 is2c2 = 1. / s02() / c02();
3772
3773 GZ = Gamma_Z();
3774
3775 Mz2s = Mz * Mz - s;
3776
3777 if (f.is("ELECTRON")) {
3778 Qf = leptons[ELECTRON].getCharge();
3779 gfLSM = (leptons[ELECTRON].getIsospin()) - Qf * s02();
3780 } else if (f.is("MU")) {
3781 Qf = leptons[MU].getCharge();
3782 gfLSM = (leptons[MU].getIsospin()) - Qf * s02();
3783 } else if (f.is("TAU")) {
3784 Qf = leptons[TAU].getCharge();
3785 gfLSM = (leptons[TAU].getIsospin()) - Qf * s02();
3786 } else if (f.is("UP")) {
3787 Qf = quarks[UP].getCharge();
3788 gfLSM = (quarks[UP].getIsospin()) - Qf * s02();
3789 } else if (f.is("CHARM")) {
3790 Qf = quarks[CHARM].getCharge();
3791 gfLSM = (quarks[CHARM].getIsospin()) - Qf * s02();
3792 } else if (f.is("DOWN")) {
3793 Qf = quarks[DOWN].getCharge();
3794 gfLSM = (quarks[DOWN].getIsospin()) - Qf * s02();
3795 } else if (f.is("STRANGE")) {
3796 Qf = quarks[STRANGE].getCharge();
3797 gfLSM = (quarks[STRANGE].getIsospin()) - Qf * s02();
3798 } else if (f.is("BOTTOM")) {
3799 Qf = quarks[BOTTOM].getCharge();
3800 gfLSM = (quarks[BOTTOM].getIsospin()) - Qf * s02();
3801 } else
3802 throw std::runtime_error("StandardModel::MRL2eeff: wrong argument");
3803
3804 // RL SM squared amplitude
3805 MRL2SM = Qf * Qf
3806 + (is2c2 * is2c2 * (geRSM * geRSM * gfLSM * gfLSM) * s * s
3807 + 2.0 * Qf * is2c2 * (geRSM * gfLSM) * Mz2s * s) / (Mz2s * Mz2s + Mz * Mz * GZ * GZ);
3808
3809 return MRL2SM;
3810}
3811
3812const double StandardModel::MLL2eeff(const Particle f, const double s, const double t) const{
3813
3814 // Definitions
3815 double Qf, geLSM, gfLSM, is2c2, GZ, Mz2s;
3816
3817 double MLL2SM;
3818
3819 // -------------------------------------------
3820
3821 geLSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3822
3823 is2c2 = 1. / s02() / c02();
3824
3825 GZ = Gamma_Z();
3826
3827 Mz2s = Mz * Mz - s;
3828
3829 if (f.is("ELECTRON")) {
3830 Qf = leptons[ELECTRON].getCharge();
3831 gfLSM = (leptons[ELECTRON].getIsospin()) - Qf * s02();
3832 } else if (f.is("MU")) {
3833 Qf = leptons[MU].getCharge();
3834 gfLSM = (leptons[MU].getIsospin()) - Qf * s02();
3835 } else if (f.is("TAU")) {
3836 Qf = leptons[TAU].getCharge();
3837 gfLSM = (leptons[TAU].getIsospin()) - Qf * s02();
3838 } else if (f.is("UP")) {
3839 Qf = quarks[UP].getCharge();
3840 gfLSM = (quarks[UP].getIsospin()) - Qf * s02();
3841 } else if (f.is("CHARM")) {
3842 Qf = quarks[CHARM].getCharge();
3843 gfLSM = (quarks[CHARM].getIsospin()) - Qf * s02();
3844 } else if (f.is("DOWN")) {
3845 Qf = quarks[DOWN].getCharge();
3846 gfLSM = (quarks[DOWN].getIsospin()) - Qf * s02();
3847 } else if (f.is("STRANGE")) {
3848 Qf = quarks[STRANGE].getCharge();
3849 gfLSM = (quarks[STRANGE].getIsospin()) - Qf * s02();
3850 } else if (f.is("BOTTOM")) {
3851 Qf = quarks[BOTTOM].getCharge();
3852 gfLSM = (quarks[BOTTOM].getIsospin()) - Qf * s02();
3853 } else
3854 throw std::runtime_error("StandardModel::MLL2eeff: wrong argument");
3855
3856 // LL SM squared amplitude
3857 MLL2SM = Qf * Qf
3858 + (is2c2 * is2c2 * (geLSM * geLSM * gfLSM * gfLSM) * s * s
3859 + 2.0 * Qf * is2c2 * (geLSM * gfLSM) * Mz2s * s) / (Mz2s * Mz2s + Mz * Mz * GZ * GZ);
3860
3861 return MLL2SM;
3862
3863}
3864const double StandardModel::MRR2eeff(const Particle f, const double s, const double t) const{
3865
3866 // Definitions
3867 double Qf, geRSM, gfRSM, is2c2, GZ, Mz2s;
3868
3869 double MRR2SM;
3870
3871 // -------------------------------------------
3872
3873 geRSM = - (leptons[ELECTRON].getCharge()) * s02();
3874
3875 is2c2 = 1. / s02() / c02();
3876
3877 GZ = Gamma_Z();
3878
3879 Mz2s = Mz * Mz - s;
3880
3881 if (f.is("ELECTRON")) {
3882 Qf = leptons[ELECTRON].getCharge();
3883 gfRSM = - Qf * s02();
3884 } else if (f.is("MU")) {
3885 Qf = leptons[MU].getCharge();
3886 gfRSM = - Qf * s02();
3887 } else if (f.is("TAU")) {
3888 Qf = leptons[TAU].getCharge();
3889 gfRSM = - Qf * s02();
3890 } else if (f.is("UP")) {
3891 Qf = quarks[UP].getCharge();
3892 gfRSM = - Qf * s02();
3893 } else if (f.is("CHARM")) {
3894 Qf = quarks[CHARM].getCharge();
3895 gfRSM = - Qf * s02();
3896 } else if (f.is("DOWN")) {
3897 Qf = quarks[DOWN].getCharge();
3898 gfRSM = - Qf * s02();
3899 } else if (f.is("STRANGE")) {
3900 Qf = quarks[STRANGE].getCharge();
3901 gfRSM = - Qf * s02();
3902 } else if (f.is("BOTTOM")) {
3903 Qf = quarks[BOTTOM].getCharge();
3904 gfRSM = - Qf * s02();
3905 } else
3906 throw std::runtime_error("StandardModel::MRR2eeff: wrong argument");
3907
3908 // RR SM squared amplitude
3909 MRR2SM = Qf * Qf
3910 + (is2c2 * is2c2 * (geRSM * geRSM * gfRSM * gfRSM) * s * s
3911 + 2.0 * Qf * is2c2 * (geRSM * gfRSM) * Mz2s * s) / (Mz2s * Mz2s + Mz * Mz * GZ * GZ);
3912
3913 return MRR2SM;
3914}
3915
3916// Some simple functions for cos \theta integrals
3917
3918const double StandardModel::tovers2(const double cosmin, const double cosmax) const {
3919 return 0.25 * (cosmax * (1.0 - cosmax * (1.0 - cosmax / 3.0)) - cosmin * (1.0 - cosmin * (1.0 - cosmin / 3.0)));
3920}
3921
3922const double StandardModel::uovers2(const double cosmin, const double cosmax) const {
3923 return 0.25 * (cosmax * (1.0 + cosmax * (1.0 + cosmax / 3.0)) - cosmin * (1.0 + cosmin * (1.0 + cosmin / 3.0)));
3924}
3925
3926// Expressions for f=e
3927
3928// Integrals of the SM squared amplitudes x (t/s)^2, (s/t)^2, (u/s)^2 in [t0, t1]
3929const double StandardModel::intMLR2eeeets2(const double s, const double t0, const double t1) const {
3930
3931 double intM2;
3932 double sw2cw2;
3933 double gLeSM,gReSM;
3934 double GammaZSM;
3935 double Mz2, s2;
3936 double propZSM2,propZSMRe,MeeLR2SM;
3937
3938 sw2cw2 = s02() * c02();
3939 gLeSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3940 gReSM = - (leptons[ELECTRON].getCharge()) * s02();
3941 GammaZSM = Gamma_Z();
3942 Mz2 = Mz * Mz;
3943 s2 = s * s;
3944
3945 propZSM2 = s2/((s - Mz2)*(s - Mz2) + Mz2*GammaZSM*GammaZSM);
3946 propZSMRe = (s*(s - Mz2))/((s - Mz2)*(s - Mz2) + Mz2*GammaZSM*GammaZSM);
3947
3948 MeeLR2SM = 1.0 + (gLeSM*gLeSM*gReSM*gReSM/(sw2cw2*sw2cw2))*propZSM2 + 2.0*(gLeSM*gReSM/sw2cw2)*propZSMRe;
3949
3950 intM2 = MeeLR2SM*(t1*t1*t1 - t0*t0*t0)/(3.0*s*s);
3951
3952 return intM2;
3953}
3954
3955const double StandardModel::intMLRtilde2eeeest2(const double s, const double t0, const double t1) const {
3956
3957 double intM2;
3958 double sw2cw2;
3959 double gLeSM,gReSM;
3960 double Mz2;
3961
3962 sw2cw2 = s02() * c02();
3963 gLeSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3964 gReSM = - (leptons[ELECTRON].getCharge()) * s02();
3965 Mz2 = Mz * Mz;
3966
3967 intM2 = s*s*(((gLeSM*gLeSM*gReSM*gReSM)/sw2cw2/sw2cw2)*(1.0/(Mz2 - t1) - 1.0/(Mz2 - t0)) - 1.0/t1 + 1.0/t0 +
3968 (2.0*gLeSM*gReSM*(-log(t1/t0) + log((-Mz2 + t1)/(-Mz2 + t0))))/(Mz2*sw2cw2));
3969
3970 return intM2;
3971}
3972
3973const double StandardModel::intMLL2eeeeus2(const double s, const double t0, const double t1) const {
3974
3975 double intM2;
3976 double sw2cw2;
3977 double gLeSM;
3978 double GammaZSM;
3979 double Mz2, Mz4, s2;
3980
3981 sw2cw2 = s02() * c02();
3982 gLeSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3983 GammaZSM = Gamma_Z();
3984 Mz2 = Mz * Mz;
3985 Mz4 = Mz2 * Mz2;
3986 s2 = s * s;
3987
3988 intM2 = (gLeSM*gLeSM*gLeSM*gLeSM*s2 + 2.0*gLeSM*gLeSM*s*(-Mz2 + s)*sw2cw2 + sw2cw2*sw2cw2*(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM)))/(3.0*s2*sw2cw2*sw2cw2*(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM)))*(pow(s + t1,3.0) - pow(s + t0,3.0)) +
3989 ((2.0*(1.0 + (gLeSM*gLeSM*s*(-Mz2 + s))/(sw2cw2*(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM)))) )/s)*(2.0*s *(t1 - t0) + (t1*t1 - t0*t0)/2.0 + s2*log(t1/t0)) +
3990 (2.0*gLeSM*gLeSM* (-sw2cw2 + (gLeSM*gLeSM*(Mz2 - s)*s)/(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM))))/(s*sw2cw2*sw2cw2)* (-(1.0/2.0)*t1*(2.0*Mz2 + 4.0*s + t1) + (1.0/2.0)*t0*(2.0*Mz2 + 4.0*s + t0) - (Mz2 + s)*(Mz2 + s)*log((-Mz2 + t1)/(-Mz2 + t0)) ) +
3991 (2.0*(gLeSM*gLeSM) )/(Mz2*sw2cw2)*(Mz2 *(t1 - t0) - s2*log(t1/t0) + (Mz2 + s)*(Mz2 + s)*log((-Mz2 + t1)/(-Mz2 + t0))) +
3992 (-(s2/t1) + s2/t0 + t1 - t0 + 2.0*s*log(t1/t0)) +
3993 (gLeSM*gLeSM*gLeSM*gLeSM /sw2cw2/sw2cw2)*((Mz2 + s)*(Mz2 + s)*(1.0/(Mz2 - t1) - 1.0/(Mz2 - t0)) + t1 - t0 + 2.0*(Mz2 + s)*log((-Mz2 + t1)/(-Mz2 + t0)));
3994
3995 return intM2;
3996}
3997
3998const double StandardModel::intMRR2eeeeus2(const double s, const double t0, const double t1) const {
3999
4000 double intM2;
4001 double sw2cw2;
4002 double gReSM;
4003 double GammaZSM;
4004 double Mz2, Mz4, s2;
4005
4006 sw2cw2 = s02() * c02();
4007 gReSM = - (leptons[ELECTRON].getCharge()) * s02();
4008 GammaZSM = Gamma_Z();
4009 Mz2 = Mz * Mz;
4010 Mz4 = Mz2 * Mz2;
4011 s2 = s * s;
4012
4013 intM2 = (gReSM*gReSM*gReSM*gReSM*s2 + 2.0*gReSM*gReSM*s*(-Mz2 + s)*sw2cw2 + sw2cw2*sw2cw2*(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM)))/(3.0*s2*sw2cw2*sw2cw2*(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM)))*(pow(s + t1,3.0) - pow(s + t0,3.0)) +
4014 ((2.0*(1.0 + (gReSM*gReSM*s*(-Mz2 + s))/(sw2cw2*(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM)))) )/s)*(2.0*s *(t1 - t0) + (t1*t1 - t0*t0)/2.0 + s2*log(t1/t0)) +
4015 (2.0*gReSM*gReSM* (-sw2cw2 + (gReSM*gReSM*(Mz2 - s)*s)/(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM))))/(s*sw2cw2*sw2cw2)* (-(1.0/2.0)*t1*(2.0*Mz2 + 4.0*s + t1) + (1.0/2.0)*t0*(2.0*Mz2 + 4.0*s + t0) - (Mz2 + s)*(Mz2 + s)*log((-Mz2 + t1)/(-Mz2 + t0)) ) +
4016 (2.0*(gReSM*gReSM) )/(Mz2*sw2cw2)*(Mz2 *(t1 - t0) - s2*log(t1/t0) + (Mz2 + s)*(Mz2 + s)*log((-Mz2 + t1)/(-Mz2 + t0))) +
4017 (-(s2/t1) + s2/t0 + t1 - t0 + 2.0*s*log(t1/t0)) +
4018 (gReSM*gReSM*gReSM*gReSM /sw2cw2/sw2cw2)*((Mz2 + s)*(Mz2 + s)*(1.0/(Mz2 - t1) - 1.0/(Mz2 - t0)) + t1 - t0 + 2.0*(Mz2 + s)*log((-Mz2 + t1)/(-Mz2 + t0)));
4019
4020 return intM2;
4021}
4022
4023// Cross sections
4024
4025const double StandardModel::eeffsigmaEbin(const double pol_e, const double pol_p, const double s, const double cosmin, const double cosmax) const {
4026
4027 double sumM2, sigma;
4028 double topb = 0.3894e+9;
4029 double t0, t1, lambdaK;
4030
4031 double pLH, pRH; //Polarization factors, minus the 1/4 average
4032 double pLLH, pRRH;
4033
4034 pLH = (1.0 - pol_e) * (1.0 + pol_p);
4035 pRH = (1.0 + pol_e) * (1.0 - pol_p);
4036
4037 pLLH = (1.0 - pol_e) * (1.0 - pol_p);
4038 pRRH = (1.0 + pol_e) * (1.0 + pol_p);
4039
4040 // t values for cosmin and cosmax
4041 t0 = 0.5 * s * ( -1.0 + cosmin );
4042 t1 = 0.5 * s * ( -1.0 + cosmax );
4043
4044 // Kähllén function of (s,0,0)
4045 lambdaK = s*s;
4046
4047 // Sum of the integrals of the amplitudes squared x (t/s)^2, (s/t)^2, (u/s)^2
4048 sumM2 = (pLH + pRH) * ( intMLR2eeeets2(s, t0, t1) ) +
4049 (pLLH + pRRH) * ( intMLRtilde2eeeest2(s, t0, t1) ) +
4050 pLH * intMLL2eeeeus2(s, t0, t1) + pRH * intMRR2eeeeus2(s, t0, t1);
4051
4052 // Build the cross section
4053 sigma = M_PI * (alphaMz())*(alphaMz()) * sumM2 / s / sqrt(lambdaK);
4054
4055 return topb * sigma;
4056
4057}
4058
4059const double StandardModel::eeffsigma(const Particle f, const double pol_e, const double pol_p, const double s, const double cosmin, const double cosmax) const {
4060 // Only valid for f=/=e (MLL2, MRR2 do not depend on t for f=/=e. Simply enter t=1 as argument)
4061 // For f=e this corresponds to t-subtracted definition from LEP
4062 double sumM2, sigma;
4063 double tdumm = 1.;
4064 double topb = 0.3894e+9;
4065
4066 //double cosmin = -1.0;
4067 //double cosmax = 1.0;
4068
4069 double Nf;
4070
4071 double pLH, pRH; //Polarization factors, minus the 1/4 average
4072
4073 pLH = (1.0 - pol_e) * (1.0 + pol_p);
4074 pRH = (1.0 + pol_e) * (1.0 - pol_p);
4075
4076 if (f.is("LEPTON")) {
4077 Nf = 1.0;
4078 } else {
4079 Nf = 3.0;
4080 }
4081
4082 sumM2 = (pLH * MLR2eeff(f, s) + pRH * MRL2eeff(f, s)) * tovers2(cosmin, cosmax)
4083 + (pLH * MLL2eeff(f, s, tdumm) + pRH * MRR2eeff(f, s, tdumm)) * uovers2(cosmin, cosmax);
4084
4085 sigma = Nf * 0.5 * M_PI * (alphaMz())*(alphaMz()) * sumM2 / s;
4086
4087 return topb * sigma;
4088}
4089
4090/* BEGIN: REMOVE FROM THE PACKAGE */
4092//LEP2 Observables
4093
4094const double StandardModel::LEP2sigmaE(const double s) const
4095{
4096 return 0.;
4097}
4098
4099const double StandardModel::LEP2sigmaMu(const double s) const
4100{
4101 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
4102 double relerr = 1.e-8;
4103 double abserr = 1.e-20;
4104
4105 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
4106 if (!IsFlagNoApproximateGammaZ()){
4107
4108 /* SM contribution with the approximate formula */
4109 return (myApproximateFormulae->LEP2sigmaMuApprox(s));
4110
4111 } else {
4112
4113 if(s == 130.*130.){
4114
4115 if (!flagLEP2[ISR]){
4116 SMresult_cache = sigma_NoISR_l(QCD::lepton(MU), s);
4117 } else {
4118 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu130, &(*this), _1));
4119 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4120 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4121 }
4122 SMresult_cache = average;
4123 }
4124
4125 if (flagLEP2[WeakBox]) {
4126 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu130, &(*this), _1));
4127 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4128 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4129 }
4130 double sigma_box = average;
4131 SMresult_cache += sigma_box;
4132 }
4133 } else if (s == 136.*136.) {
4134 if (!flagLEP2[ISR]){
4135 SMresult_cache = sigma_NoISR_l(QCD::lepton(MU), s);
4136 } else {
4137 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu136, &(*this), _1));
4138 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4139 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4140 }
4141 SMresult_cache = average;
4142 }
4143
4144 if (flagLEP2[WeakBox]) {
4145 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu136, &(*this), _1));
4146 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4147 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4148 }
4149 double sigma_box = average;
4150 SMresult_cache += sigma_box;
4151 }
4152 } else if (s == 161.*161.){
4153 if (!flagLEP2[ISR])
4154 SMresult_cache = sigma_NoISR_l(QCD::lepton(MU), s);
4155 else {
4156 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu161, &(*this), _1));
4157 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4158 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4159 }
4160 SMresult_cache = average;
4161 }
4162
4163 if (flagLEP2[WeakBox]) {
4164 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu161, &(*this), _1));
4165 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4166 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4167 }
4168 double sigma_box = average;
4169 SMresult_cache += sigma_box;
4170 }
4171 } else if (s == 172.*172.) {
4172 if (!flagLEP2[ISR])
4173 SMresult_cache = sigma_NoISR_l(QCD::lepton(MU), s);
4174 else {
4175 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu172, &(*this), _1));
4176 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4177 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4178 }
4179 SMresult_cache = average;
4180 }
4181
4182 if (flagLEP2[WeakBox]) {
4183 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu172, &(*this), _1));
4184 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4185 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4186 }
4187 double sigma_box = average;
4188 SMresult_cache += sigma_box;
4189 }
4190 } else if (s == 183.*183.) {
4191 if (!flagLEP2[ISR])
4192 SMresult_cache = sigma_NoISR_l(QCD::lepton(MU), s);
4193 else {
4194 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu183, &(*this), _1));
4195 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4196 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4197 }
4198 SMresult_cache = average;
4199 }
4200
4201 if (flagLEP2[WeakBox]) {
4202 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu183, &(*this), _1));
4203 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4204 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4205 }
4206 double sigma_box = average;
4207 SMresult_cache += sigma_box;
4208 }
4209 } else if (s == 189.*189.) {
4210 if (!flagLEP2[ISR])
4211 SMresult_cache = sigma_NoISR_l(QCD::lepton(MU), s);
4212 else {
4213 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu189, &(*this), _1));
4214 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4215 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4216 }
4217 SMresult_cache = average;
4218 }
4219
4220 if (flagLEP2[WeakBox]) {
4221 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu189, &(*this), _1));
4222 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4223 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4224 }
4225 double sigma_box = average;
4226 SMresult_cache += sigma_box;
4227 }
4228 } else if (s == 192.*192.) {
4229 if (!flagLEP2[ISR])
4230 SMresult_cache = sigma_NoISR_l(QCD::lepton(MU), s);
4231 else {
4232 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu192, &(*this), _1));
4233 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4234 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4235 }
4236 SMresult_cache = average;
4237 }
4238
4239 if (flagLEP2[WeakBox]) {
4240 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu192, &(*this), _1));
4241 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4242 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4243 }
4244 double sigma_box = average;
4245 SMresult_cache += sigma_box;
4246 }
4247 } else if (s == 196.*196.) {
4248 if (!flagLEP2[ISR])
4249 SMresult_cache = sigma_NoISR_l(QCD::lepton(MU), s);
4250 else {
4251 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu196, &(*this), _1));
4252 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4253 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4254 }
4255 SMresult_cache = average;
4256 }
4257
4258 if (flagLEP2[WeakBox]) {
4259 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu196, &(*this), _1));
4260 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4261 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4262 }
4263 double sigma_box = average;
4264 SMresult_cache += sigma_box;
4265 }
4266 } else if (s == 200.*200.) {
4267 if (!flagLEP2[ISR])
4268 SMresult_cache = sigma_NoISR_l(QCD::lepton(MU), s);
4269 else {
4270 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu200, &(*this), _1));
4271 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4272 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4273 }
4274 SMresult_cache = average;
4275 }
4276
4277 if (flagLEP2[WeakBox]) {
4278 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu200, &(*this), _1));
4279 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4280 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4281 }
4282 double sigma_box = average;
4283 SMresult_cache += sigma_box;
4284 }
4285 } else if (s == 202.*202.) {
4286 if (!flagLEP2[ISR])
4287 SMresult_cache = sigma_NoISR_l(QCD::lepton(MU), s);
4288 else {
4289 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu202, &(*this), _1));
4290 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4291 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4292 }
4293 SMresult_cache = average;
4294 }
4295
4296 if (flagLEP2[WeakBox]) {
4297 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu202, &(*this), _1));
4298 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4299 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4300 }
4301 double sigma_box = average;
4302 SMresult_cache += sigma_box;
4303 }
4304 } else if (s == 205.*205.) {
4305 if (!flagLEP2[ISR])
4306 SMresult_cache = sigma_NoISR_l(QCD::lepton(MU), s);
4307 else {
4308 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu205, &(*this), _1));
4309 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4310 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4311 }
4312 SMresult_cache = average;
4313 }
4314
4315 if (flagLEP2[WeakBox]) {
4316 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu205, &(*this), _1));
4317 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4318 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4319 }
4320 double sigma_box = average;
4321 SMresult_cache += sigma_box;
4322 }
4323 } else if (s == 207.*207.) {
4324 if (!flagLEP2[ISR])
4325 SMresult_cache = sigma_NoISR_l(QCD::lepton(MU), s);
4326 else {
4327 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu207, &(*this), _1));
4328 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4329 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4330 }
4331 SMresult_cache = average;
4332 }
4333
4334 if (flagLEP2[WeakBox]) {
4335 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu207, &(*this), _1));
4336 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4337 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4338 }
4339 double sigma_box = average;
4340 SMresult_cache += sigma_box;
4341 }
4342 } else {
4343 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2AFBmu!");
4344 }
4345
4346 double sigma_mu = SMresult_cache;
4347
4348 gsl_set_error_handler(old_handler);
4349
4350 return sigma_mu;
4351
4352 }
4353}
4354
4355
4356const double StandardModel::LEP2sigmaTau(const double s) const
4357{
4358
4359 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
4360 double relerr = 1.e-7;
4361 double abserr = 1.e-17;
4362
4363 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
4364 if (!IsFlagNoApproximateGammaZ()){
4365
4366 /* SM contribution with the approximate formula */
4367 return (myApproximateFormulae->LEP2sigmaTauApprox(s));
4368
4369 } else {
4370
4371 if(s == 130.*130.){
4372
4373 if (!flagLEP2[ISR]){
4374 SMresult_cache = sigma_NoISR_l(QCD::lepton(TAU), s);
4375 } else {
4376 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau130, &(*this), _1));
4377 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4378 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4379 }
4380 SMresult_cache = average;
4381 }
4382
4383 if (flagLEP2[WeakBox]) {
4384 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau130, &(*this), _1));
4385 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4386 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4387 }
4388 double sigma_box = average;
4389 SMresult_cache += sigma_box;
4390 }
4391 } else if (s == 136.*136.) {
4392 if (!flagLEP2[ISR]){
4393 SMresult_cache = sigma_NoISR_l(QCD::lepton(TAU), s);
4394 } else {
4395 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau136, &(*this), _1));
4396 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4397 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4398 }
4399 SMresult_cache = average;
4400 }
4401
4402 if (flagLEP2[WeakBox]) {
4403 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau136, &(*this), _1));
4404 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4405 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4406 }
4407 double sigma_box = average;
4408 SMresult_cache += sigma_box;
4409 }
4410 } else if (s == 161.*161.){
4411 if (!flagLEP2[ISR])
4412 SMresult_cache = sigma_NoISR_l(QCD::lepton(TAU), s);
4413 else {
4414 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau161, &(*this), _1));
4415 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4416 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4417 }
4418 SMresult_cache = average;
4419 }
4420
4421 if (flagLEP2[WeakBox]) {
4422 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau161, &(*this), _1));
4423 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4424 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4425 }
4426 double sigma_box = average;
4427 SMresult_cache += sigma_box;
4428 }
4429 } else if (s == 172.*172.) {
4430 if (!flagLEP2[ISR])
4431 SMresult_cache = sigma_NoISR_l(QCD::lepton(TAU), s);
4432 else {
4433 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau172, &(*this), _1));
4434 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4435 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4436 }
4437 SMresult_cache = average;
4438 }
4439
4440 if (flagLEP2[WeakBox]) {
4441 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau172, &(*this), _1));
4442 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4443 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4444 }
4445 double sigma_box = average;
4446 SMresult_cache += sigma_box;
4447 }
4448 } else if (s == 183.*183.) {
4449 if (!flagLEP2[ISR])
4450 SMresult_cache = sigma_NoISR_l(QCD::lepton(TAU), s);
4451 else {
4452 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau183, &(*this), _1));
4453 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4454 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4455 }
4456 SMresult_cache = average;
4457 }
4458
4459 if (flagLEP2[WeakBox]) {
4460 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau183, &(*this), _1));
4461 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4462 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4463 }
4464 double sigma_box = average;
4465 SMresult_cache += sigma_box;
4466 }
4467 } else if (s == 189.*189.) {
4468 if (!flagLEP2[ISR])
4469 SMresult_cache = sigma_NoISR_l(QCD::lepton(TAU), s);
4470 else {
4471 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau189, &(*this), _1));
4472 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4473 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4474 }
4475 SMresult_cache = average;
4476 }
4477
4478 if (flagLEP2[WeakBox]) {
4479 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau189, &(*this), _1));
4480 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4481 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4482 }
4483 double sigma_box = average;
4484 SMresult_cache += sigma_box;
4485 }
4486 } else if (s == 192.*192.) {
4487 if (!flagLEP2[ISR])
4488 SMresult_cache = sigma_NoISR_l(QCD::lepton(TAU), s);
4489 else {
4490 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau192, &(*this), _1));
4491 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4492 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4493 }
4494 SMresult_cache = average;
4495 }
4496
4497 if (flagLEP2[WeakBox]) {
4498 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau192, &(*this), _1));
4499 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4500 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4501 }
4502 double sigma_box = average;
4503 SMresult_cache += sigma_box;
4504 }
4505 } else if (s == 196.*196.) {
4506 if (!flagLEP2[ISR])
4507 SMresult_cache = sigma_NoISR_l(QCD::lepton(TAU), s);
4508 else {
4509 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau196, &(*this), _1));
4510 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4511 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4512 }
4513 SMresult_cache = average;
4514 }
4515
4516 if (flagLEP2[WeakBox]) {
4517 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau196, &(*this), _1));
4518 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4519 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4520 }
4521 double sigma_box = average;
4522 SMresult_cache += sigma_box;
4523 }
4524 } else if (s == 200.*200.) {
4525 if (!flagLEP2[ISR])
4526 SMresult_cache = sigma_NoISR_l(QCD::lepton(TAU), s);
4527 else {
4528 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau200, &(*this), _1));
4529 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4530 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4531 }
4532 SMresult_cache = average;
4533 }
4534
4535 if (flagLEP2[WeakBox]) {
4536 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau200, &(*this), _1));
4537 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4538 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4539 }
4540 double sigma_box = average;
4541 SMresult_cache += sigma_box;
4542 }
4543 } else if (s == 202.*202.) {
4544 if (!flagLEP2[ISR])
4545 SMresult_cache = sigma_NoISR_l(QCD::lepton(TAU), s);
4546 else {
4547 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau202, &(*this), _1));
4548 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4549 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4550 }
4551 SMresult_cache = average;
4552 }
4553
4554 if (flagLEP2[WeakBox]) {
4555 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau202, &(*this), _1));
4556 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4557 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4558 }
4559 double sigma_box = average;
4560 SMresult_cache += sigma_box;
4561 }
4562 } else if (s == 205.*205.) {
4563 if (!flagLEP2[ISR])
4564 SMresult_cache = sigma_NoISR_l(QCD::lepton(TAU), s);
4565 else {
4566 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau205, &(*this), _1));
4567 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4568 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4569 }
4570 SMresult_cache = average;
4571 }
4572
4573 if (flagLEP2[WeakBox]) {
4574 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau205, &(*this), _1));
4575 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4576 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4577 }
4578 double sigma_box = average;
4579 SMresult_cache += sigma_box;
4580 }
4581 } else if (s == 207.*207.) {
4582 if (!flagLEP2[ISR])
4583 SMresult_cache = sigma_NoISR_l(QCD::lepton(TAU), s);
4584 else {
4585 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau207, &(*this), _1));
4586 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4587 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4588 }
4589 SMresult_cache = average;
4590 }
4591
4592 if (flagLEP2[WeakBox]) {
4593 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau207, &(*this), _1));
4594 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4595 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4596 }
4597 double sigma_box = average;
4598 SMresult_cache += sigma_box;
4599 }
4600 } else {
4601 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2sigmaTau!");
4602 }
4603
4604 double sigma_tau = SMresult_cache;
4605
4606 gsl_set_error_handler(old_handler);
4607
4608 return sigma_tau;
4609
4610 }
4611}
4612
4613
4614const double StandardModel::LEP2sigmaCharm(const double s) const
4615{
4616 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
4617 double relerr = 1.e-8;
4618 double abserr = 1.e-20;
4619
4620 if(s == 133.*133.){
4621
4622 if (!flagLEP2[ISR]){
4623 SMresult_cache = sigma_NoISR_q(QCD::quark(CHARM), s);
4624 } else {
4625 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm133, &(*this), _1));
4626 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4627 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4628 }
4629 SMresult_cache = average;
4630 }
4631
4632 if (flagLEP2[WeakBox]) {
4633 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm133, &(*this), _1));
4634 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4635 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4636 }
4637 double sigma_box = average;
4638 SMresult_cache += sigma_box;
4639 }
4640 } else if (s == 167.*167.){
4641 if (!flagLEP2[ISR])
4642 SMresult_cache = sigma_NoISR_q(QCD::quark(CHARM), s);
4643 else {
4644 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm167, &(*this), _1));
4645 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4646 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4647 }
4648 SMresult_cache = average;
4649 }
4650
4651 if (flagLEP2[WeakBox]) {
4652 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm167, &(*this), _1));
4653 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4654 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4655 }
4656 double sigma_box = average;
4657 SMresult_cache += sigma_box;
4658 }
4659 } else if (s == 183.*183.) {
4660 if (!flagLEP2[ISR])
4661 SMresult_cache = sigma_NoISR_q(QCD::quark(CHARM), s);
4662 else {
4663 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm183, &(*this), _1));
4664 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4665 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4666 }
4667 SMresult_cache = average;
4668 }
4669
4670 if (flagLEP2[WeakBox]) {
4671 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm183, &(*this), _1));
4672 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4673 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4674 }
4675 double sigma_box = average;
4676 SMresult_cache += sigma_box;
4677 }
4678 } else if (s == 189.*189.) {
4679 if (!flagLEP2[ISR])
4680 SMresult_cache = sigma_NoISR_q(QCD::quark(CHARM), s);
4681 else {
4682 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm189, &(*this), _1));
4683 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4684 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4685 }
4686 SMresult_cache = average;
4687 }
4688
4689 if (flagLEP2[WeakBox]) {
4690 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm189, &(*this), _1));
4691 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4692 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4693 }
4694 double sigma_box = average;
4695 SMresult_cache += sigma_box;
4696 }
4697 } else if (s == 192.*192.) {
4698 if (!flagLEP2[ISR])
4699 SMresult_cache = sigma_NoISR_q(QCD::quark(CHARM), s);
4700 else {
4701 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm192, &(*this), _1));
4702 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4703 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4704 }
4705 SMresult_cache = average;
4706 }
4707
4708 if (flagLEP2[WeakBox]) {
4709 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm192, &(*this), _1));
4710 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4711 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4712 }
4713 double sigma_box = average;
4714 SMresult_cache += sigma_box;
4715 }
4716 } else if (s == 196.*196.) {
4717 if (!flagLEP2[ISR])
4718 SMresult_cache = sigma_NoISR_q(QCD::quark(CHARM), s);
4719 else {
4720 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm196, &(*this), _1));
4721 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4722 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4723 }
4724 SMresult_cache = average;
4725 }
4726
4727 if (flagLEP2[WeakBox]) {
4728 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm196, &(*this), _1));
4729 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4730 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4731 }
4732 double sigma_box = average;
4733 SMresult_cache += sigma_box;
4734 }
4735 } else if (s == 200.*200.) {
4736 if (!flagLEP2[ISR])
4737 SMresult_cache = sigma_NoISR_q(QCD::quark(CHARM), s);
4738 else {
4739 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm200, &(*this), _1));
4740 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4741 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4742 }
4743 SMresult_cache = average;
4744 }
4745
4746 if (flagLEP2[WeakBox]) {
4747 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm200, &(*this), _1));
4748 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4749 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4750 }
4751 double sigma_box = average;
4752 SMresult_cache += sigma_box;
4753 }
4754 } else if (s == 202.*202.) {
4755 if (!flagLEP2[ISR])
4756 SMresult_cache = sigma_NoISR_q(QCD::quark(CHARM), s);
4757 else {
4758 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm202, &(*this), _1));
4759 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4760 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4761 }
4762 SMresult_cache = average;
4763 }
4764
4765 if (flagLEP2[WeakBox]) {
4766 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm202, &(*this), _1));
4767 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4768 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4769 }
4770 double sigma_box = average;
4771 SMresult_cache += sigma_box;
4772 }
4773 } else if (s == 205.*205.) {
4774 if (!flagLEP2[ISR])
4775 SMresult_cache = sigma_NoISR_q(QCD::quark(CHARM), s);
4776 else {
4777 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm205, &(*this), _1));
4778 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4779 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4780 }
4781 SMresult_cache = average;
4782 }
4783
4784 if (flagLEP2[WeakBox]) {
4785 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm205, &(*this), _1));
4786 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4787 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4788 }
4789 double sigma_box = average;
4790 SMresult_cache += sigma_box;
4791 }
4792 } else if (s == 207.*207.) {
4793 if (!flagLEP2[ISR])
4794 SMresult_cache = sigma_NoISR_q(QCD::quark(CHARM), s);
4795 else {
4796 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm207, &(*this), _1));
4797 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4798 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4799 }
4800 SMresult_cache = average;
4801 }
4802
4803 if (flagLEP2[WeakBox]) {
4804 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm207, &(*this), _1));
4805 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4806 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4807 }
4808 double sigma_box = average;
4809 SMresult_cache += sigma_box;
4810 }
4811 } else {
4812 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2sigmaCharm!");
4813 }
4814
4815
4816 double sigma_mu = SMresult_cache;
4817
4818 gsl_set_error_handler(old_handler);
4819
4820 return sigma_mu;
4821
4822}
4823
4824
4825const double StandardModel::LEP2sigmaBottom(const double s) const
4826{
4827 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
4828 double relerr = 1.e-8;
4829 double abserr = 1.e-20;
4830
4831 if(s == 133.*133.){
4832
4833 if (!flagLEP2[ISR]){
4834 SMresult_cache = sigma_NoISR_q(QCD::quark(BOTTOM), s);
4835 } else {
4836 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom133, &(*this), _1));
4837 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4838 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4839 }
4840 SMresult_cache = average;
4841 }
4842
4843 if (flagLEP2[WeakBox]) {
4844 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom133, &(*this), _1));
4845 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4846 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4847 }
4848 double sigma_box = average;
4849 SMresult_cache += sigma_box;
4850 }
4851 } else if (s == 167.*167.){
4852 if (!flagLEP2[ISR])
4853 SMresult_cache = sigma_NoISR_q(QCD::quark(BOTTOM), s);
4854 else {
4855 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom167, &(*this), _1));
4856 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4857 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4858 }
4859 SMresult_cache = average;
4860 }
4861
4862 if (flagLEP2[WeakBox]) {
4863 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom167, &(*this), _1));
4864 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4865 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4866 }
4867 double sigma_box = average;
4868 SMresult_cache += sigma_box;
4869 }
4870 } else if (s == 183.*183.) {
4871 if (!flagLEP2[ISR])
4872 SMresult_cache = sigma_NoISR_q(QCD::quark(BOTTOM), s);
4873 else {
4874 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom183, &(*this), _1));
4875 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4876 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4877 }
4878 SMresult_cache = average;
4879 }
4880
4881 if (flagLEP2[WeakBox]) {
4882 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom183, &(*this), _1));
4883 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4884 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4885 }
4886 double sigma_box = average;
4887 SMresult_cache += sigma_box;
4888 }
4889 } else if (s == 189.*189.) {
4890 if (!flagLEP2[ISR])
4891 SMresult_cache = sigma_NoISR_q(QCD::quark(BOTTOM), s);
4892 else {
4893 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom189, &(*this), _1));
4894 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4895 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4896 }
4897 SMresult_cache = average;
4898 }
4899
4900 if (flagLEP2[WeakBox]) {
4901 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom189, &(*this), _1));
4902 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4903 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4904 }
4905 double sigma_box = average;
4906 SMresult_cache += sigma_box;
4907 }
4908 } else if (s == 192.*192.) {
4909 if (!flagLEP2[ISR])
4910 SMresult_cache = sigma_NoISR_q(QCD::quark(BOTTOM), s);
4911 else {
4912 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom192, &(*this), _1));
4913 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4914 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4915 }
4916 SMresult_cache = average;
4917 }
4918
4919 if (flagLEP2[WeakBox]) {
4920 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom192, &(*this), _1));
4921 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4922 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4923 }
4924 double sigma_box = average;
4925 SMresult_cache += sigma_box;
4926 }
4927 } else if (s == 196.*196.) {
4928 if (!flagLEP2[ISR])
4929 SMresult_cache = sigma_NoISR_q(QCD::quark(BOTTOM), s);
4930 else {
4931 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom196, &(*this), _1));
4932 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4933 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4934 }
4935 SMresult_cache = average;
4936 }
4937
4938 if (flagLEP2[WeakBox]) {
4939 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom196, &(*this), _1));
4940 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4941 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4942 }
4943 double sigma_box = average;
4944 SMresult_cache += sigma_box;
4945 }
4946 } else if (s == 200.*200.) {
4947 if (!flagLEP2[ISR])
4948 SMresult_cache = sigma_NoISR_q(QCD::quark(BOTTOM), s);
4949 else {
4950 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom200, &(*this), _1));
4951 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4952 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4953 }
4954 SMresult_cache = average;
4955 }
4956
4957 if (flagLEP2[WeakBox]) {
4958 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom200, &(*this), _1));
4959 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4960 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4961 }
4962 double sigma_box = average;
4963 SMresult_cache += sigma_box;
4964 }
4965 } else if (s == 202.*202.) {
4966 if (!flagLEP2[ISR])
4967 SMresult_cache = sigma_NoISR_q(QCD::quark(BOTTOM), s);
4968 else {
4969 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom202, &(*this), _1));
4970 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4971 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4972 }
4973 SMresult_cache = average;
4974 }
4975
4976 if (flagLEP2[WeakBox]) {
4977 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom202, &(*this), _1));
4978 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4979 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4980 }
4981 double sigma_box = average;
4982 SMresult_cache += sigma_box;
4983 }
4984 } else if (s == 205.*205.) {
4985 if (!flagLEP2[ISR])
4986 SMresult_cache = sigma_NoISR_q(QCD::quark(BOTTOM), s);
4987 else {
4988 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom205, &(*this), _1));
4989 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4990 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4991 }
4992 SMresult_cache = average;
4993 }
4994
4995 if (flagLEP2[WeakBox]) {
4996 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom205, &(*this), _1));
4997 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4998 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4999 }
5000 double sigma_box = average;
5001 SMresult_cache += sigma_box;
5002 }
5003 } else if (s == 207.*207.) {
5004 if (!flagLEP2[ISR])
5005 SMresult_cache = sigma_NoISR_q(QCD::quark(BOTTOM), s);
5006 else {
5007 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom207, &(*this), _1));
5008 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5009 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5010 }
5011 SMresult_cache = average;
5012 }
5013
5014 if (flagLEP2[WeakBox]) {
5015 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom207, &(*this), _1));
5016 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5017 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5018 }
5019 double sigma_box = average;
5020 SMresult_cache += sigma_box;
5021 }
5022 } else {
5023 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2sigmaBottom!");
5024 }
5025
5026
5027 double sigma_mu = SMresult_cache;
5028
5029 gsl_set_error_handler(old_handler);
5030
5031 return sigma_mu;
5032
5033}
5034
5035
5036const double StandardModel::LEP2sigmaHadron(const double s) const
5037{
5038 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
5039 double relerr = 1.e-8;
5040 double abserr = 1.e-20;
5041
5042 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
5043 if (!IsFlagNoApproximateGammaZ()){
5044
5045 /* SM contribution with the approximate formula */
5046 return (myApproximateFormulae->LEP2sigmaHadronApprox(s));
5047
5048 } else {
5049
5050 if(s == 130.*130.){
5051
5052 if (!flagLEP2[ISR]){
5053 SMresult_cache = sigma_NoISR_q(QCD::quark(UP), s);
5054 SMresult_cache += sigma_NoISR_q(QCD::quark(DOWN), s);
5055 SMresult_cache += sigma_NoISR_q(QCD::quark(CHARM), s);
5056 SMresult_cache += sigma_NoISR_q(QCD::quark(STRANGE), s);
5057 SMresult_cache += sigma_NoISR_q(QCD::quark(BOTTOM), s);
5058 } else {
5059
5060 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up130, &(*this), _1));
5061 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5062 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5063 }
5064 SMresult_cache = average;
5065
5066 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down130, &(*this), _1));
5067 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5068 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5069 }
5070 SMresult_cache += average;
5071
5072 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm130, &(*this), _1));
5073 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5074 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5075 }
5076 SMresult_cache += average;
5077
5078 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange130, &(*this), _1));
5079 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5080 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5081 }
5082 SMresult_cache += average;
5083
5084 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom130, &(*this), _1));
5085 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5086 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5087 }
5088 SMresult_cache += average;
5089
5090 }
5091
5092 if (flagLEP2[WeakBox]) {
5093 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up130, &(*this), _1));
5094 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5095 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5096 }
5097 double sigma_box = average;
5098
5099 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down130, &(*this), _1));
5100 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5101 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5102 }
5103 sigma_box += average;
5104
5105 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm130, &(*this), _1));
5106 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5107 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5108 }
5109 sigma_box += average;
5110
5111 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange130, &(*this), _1));
5112 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5113 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5114 }
5115 sigma_box += average;
5116
5117 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom130, &(*this), _1));
5118 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5119 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5120 }
5121 sigma_box += average;
5122 SMresult_cache += sigma_box;
5123 }
5124 } else if (s == 133.*133.) {
5125 if (!flagLEP2[ISR]){
5126 SMresult_cache = sigma_NoISR_q(QCD::quark(UP), s);
5127 SMresult_cache += sigma_NoISR_q(QCD::quark(DOWN), s);
5128 SMresult_cache += sigma_NoISR_q(QCD::quark(CHARM), s);
5129 SMresult_cache += sigma_NoISR_q(QCD::quark(STRANGE), s);
5130 SMresult_cache += sigma_NoISR_q(QCD::quark(BOTTOM), s);
5131 } else {
5132
5133 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up133, &(*this), _1));
5134 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5135 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5136 }
5137 SMresult_cache = average;
5138
5139 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down133, &(*this), _1));
5140 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5141 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5142 }
5143 SMresult_cache += average;
5144
5145 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm133, &(*this), _1));
5146 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5147 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5148 }
5149 SMresult_cache += average;
5150
5151 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange133, &(*this), _1));
5152 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5153 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5154 }
5155 SMresult_cache += average;
5156
5157 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom133, &(*this), _1));
5158 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5159 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5160 }
5161 SMresult_cache += average;
5162 }
5163
5164 if (flagLEP2[WeakBox]) {
5165 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up133, &(*this), _1));
5166 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5167 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5168 }
5169 double sigma_box = average;
5170
5171 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down133, &(*this), _1));
5172 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5173 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5174 }
5175 sigma_box += average;
5176
5177 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm133, &(*this), _1));
5178 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5179 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5180 }
5181 sigma_box += average;
5182
5183 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange133, &(*this), _1));
5184 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5185 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5186 }
5187 sigma_box += average;
5188
5189 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom133, &(*this), _1));
5190 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5191 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5192 }
5193 sigma_box += average;
5194 SMresult_cache += sigma_box;
5195 }
5196 } else if (s == 136.*136.) {
5197 if (!flagLEP2[ISR]){
5198 SMresult_cache = sigma_NoISR_q(QCD::quark(UP), s);
5199 SMresult_cache += sigma_NoISR_q(QCD::quark(DOWN), s);
5200 SMresult_cache += sigma_NoISR_q(QCD::quark(CHARM), s);
5201 SMresult_cache += sigma_NoISR_q(QCD::quark(STRANGE), s);
5202 SMresult_cache += sigma_NoISR_q(QCD::quark(BOTTOM), s);
5203 } else {
5204
5205 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up136, &(*this), _1));
5206 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5207 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5208 }
5209 SMresult_cache = average;
5210
5211 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down136, &(*this), _1));
5212 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5213 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5214 }
5215 SMresult_cache += average;
5216
5217 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm136, &(*this), _1));
5218 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5219 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5220 }
5221 SMresult_cache += average;
5222
5223 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange136, &(*this), _1));
5224 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5225 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5226 }
5227 SMresult_cache += average;
5228
5229 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom136, &(*this), _1));
5230 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5231 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5232 }
5233 SMresult_cache += average;
5234 }
5235
5236 if (flagLEP2[WeakBox]) {
5237 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up136, &(*this), _1));
5238 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5239 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5240 }
5241 double sigma_box = average;
5242
5243 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down136, &(*this), _1));
5244 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5245 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5246 }
5247 sigma_box += average;
5248
5249 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm136, &(*this), _1));
5250 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5251 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5252 }
5253 sigma_box += average;
5254
5255 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange136, &(*this), _1));
5256 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5257 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5258 }
5259 sigma_box += average;
5260
5261 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom136, &(*this), _1));
5262 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5263 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5264 }
5265 sigma_box += average;
5266 SMresult_cache += sigma_box;
5267 }
5268 } else if (s == 161.*161.){
5269 if (!flagLEP2[ISR]){
5270 SMresult_cache = sigma_NoISR_q(QCD::quark(UP), s);
5271 SMresult_cache += sigma_NoISR_q(QCD::quark(DOWN), s);
5272 SMresult_cache += sigma_NoISR_q(QCD::quark(CHARM), s);
5273 SMresult_cache += sigma_NoISR_q(QCD::quark(STRANGE), s);
5274 SMresult_cache += sigma_NoISR_q(QCD::quark(BOTTOM), s);
5275 } else {
5276
5277 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up161, &(*this), _1));
5278 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5279 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5280 }
5281 SMresult_cache = average;
5282
5283 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down161, &(*this), _1));
5284 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5285 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5286 }
5287 SMresult_cache += average;
5288
5289 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm161, &(*this), _1));
5290 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-12, 1.e-6, 100, w_GSL1, &average, &error) != 0){
5291 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5292 }
5293 SMresult_cache += average;
5294
5295 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange161, &(*this), _1));
5296 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 200, w_GSL1, &average, &error) != 0){
5297 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5298 }
5299 SMresult_cache += average;
5300
5301 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom161, &(*this), _1));
5302 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5303 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5304 }
5305 SMresult_cache += average;
5306 }
5307
5308 if (flagLEP2[WeakBox]) {
5309 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up161, &(*this), _1));
5310 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5311 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5312 }
5313 double sigma_box = average;
5314
5315 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down161, &(*this), _1));
5316 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5317 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5318 }
5319 sigma_box += average;
5320
5321 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm161, &(*this), _1));
5322 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5323 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5324 }
5325 sigma_box += average;
5326
5327 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange161, &(*this), _1));
5328 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5329 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5330 }
5331 sigma_box += average;
5332
5333 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom161, &(*this), _1));
5334 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5335 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5336 }
5337 sigma_box += average;
5338 SMresult_cache += sigma_box;
5339 }
5340 } else if (s == 167.*167.) {
5341 if (!flagLEP2[ISR]){
5342 SMresult_cache = sigma_NoISR_q(QCD::quark(UP), s);
5343 SMresult_cache += sigma_NoISR_q(QCD::quark(DOWN), s);
5344 SMresult_cache += sigma_NoISR_q(QCD::quark(CHARM), s);
5345 SMresult_cache += sigma_NoISR_q(QCD::quark(STRANGE), s);
5346 SMresult_cache += sigma_NoISR_q(QCD::quark(BOTTOM), s);
5347 } else {
5348
5349 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up167, &(*this), _1));
5350 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5351 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5352 }
5353
5354 SMresult_cache = average;
5355
5356 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down167, &(*this), _1));
5357 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-15, 1.e-9, 200, w_GSL1, &average, &error) != 0){
5358 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5359 }
5360 SMresult_cache += average;
5361
5362 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm167, &(*this), _1));
5363 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-15, 1.e-9, 200, w_GSL1, &average, &error) != 0){
5364 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5365 }
5366 SMresult_cache += average;
5367
5368 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange167, &(*this), _1));
5369 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-15, 1.e-9, 200, w_GSL1, &average, &error) != 0){
5370 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5371 }
5372 SMresult_cache += average;
5373
5374 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom167, &(*this), _1));
5375 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-15, 1.e-9, 200, w_GSL1, &average, &error) != 0){
5376 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5377 }
5378 SMresult_cache += average;
5379 }
5380
5381 if (flagLEP2[WeakBox]) {
5382 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up167, &(*this), _1));
5383 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5384 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5385 }
5386 double sigma_box = average;
5387
5388 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down167, &(*this), _1));
5389 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5390 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5391 }
5392 sigma_box += average;
5393
5394 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm167, &(*this), _1));
5395 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5396 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5397 }
5398 sigma_box += average;
5399
5400 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange167, &(*this), _1));
5401 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5402 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5403 }
5404 sigma_box += average;
5405
5406 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom167, &(*this), _1));
5407 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5408 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5409 }
5410 sigma_box += average;
5411 SMresult_cache += sigma_box;
5412 }
5413 } else if (s == 172.*172.) {
5414 if (!flagLEP2[ISR]){
5415 SMresult_cache = sigma_NoISR_q(QCD::quark(UP), s);
5416 SMresult_cache += sigma_NoISR_q(QCD::quark(DOWN), s);
5417 SMresult_cache += sigma_NoISR_q(QCD::quark(CHARM), s);
5418 SMresult_cache += sigma_NoISR_q(QCD::quark(STRANGE), s);
5419 SMresult_cache += sigma_NoISR_q(QCD::quark(BOTTOM), s);
5420 } else {
5421
5422 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up172, &(*this), _1));
5423 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5424 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5425 }
5426 SMresult_cache = average;
5427
5428 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down172, &(*this), _1));
5429 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5430 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5431 }
5432 SMresult_cache += average;
5433
5434 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm172, &(*this), _1));
5435 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5436 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5437 }
5438 SMresult_cache += average;
5439
5440 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange172, &(*this), _1));
5441 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5442 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5443 }
5444 SMresult_cache += average;
5445
5446 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom172, &(*this), _1));
5447 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5448 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5449 }
5450 SMresult_cache += average;
5451 }
5452
5453 if (flagLEP2[WeakBox]) {
5454 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up172, &(*this), _1));
5455 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5456 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5457 }
5458 double sigma_box = average;
5459
5460 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down172, &(*this), _1));
5461 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5462 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5463 }
5464 sigma_box += average;
5465
5466 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm172, &(*this), _1));
5467 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5468 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5469 }
5470 sigma_box += average;
5471
5472 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange172, &(*this), _1));
5473 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5474 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5475 }
5476 sigma_box += average;
5477
5478 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom172, &(*this), _1));
5479 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5480 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5481 }
5482 sigma_box += average;
5483 SMresult_cache += sigma_box;
5484 }
5485 } else if (s == 183.*183.) {
5486 if (!flagLEP2[ISR]){
5487 SMresult_cache = sigma_NoISR_q(QCD::quark(UP), s);
5488 SMresult_cache += sigma_NoISR_q(QCD::quark(DOWN), s);
5489 SMresult_cache += sigma_NoISR_q(QCD::quark(CHARM), s);
5490 SMresult_cache += sigma_NoISR_q(QCD::quark(STRANGE), s);
5491 SMresult_cache += sigma_NoISR_q(QCD::quark(BOTTOM), s);
5492 } else {
5493
5494 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up183, &(*this), _1));
5495 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5496 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5497 }
5498 SMresult_cache = average;
5499
5500 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down183, &(*this), _1));
5501 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5502 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5503 }
5504 SMresult_cache += average;
5505
5506 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm183, &(*this), _1));
5507 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5508 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5509 }
5510 SMresult_cache += average;
5511
5512 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange183, &(*this), _1));
5513 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5514 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5515 }
5516 SMresult_cache += average;
5517
5518 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom183, &(*this), _1));
5519 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5520 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5521 }
5522 SMresult_cache += average;
5523 }
5524
5525 if (flagLEP2[WeakBox]) {
5526 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up183, &(*this), _1));
5527 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5528 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5529 }
5530 double sigma_box = average;
5531
5532 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down183, &(*this), _1));
5533 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5534 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5535 }
5536 sigma_box += average;
5537
5538 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm183, &(*this), _1));
5539 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5540 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5541 }
5542 sigma_box += average;
5543
5544 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange183, &(*this), _1));
5545 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5546 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5547 }
5548 sigma_box += average;
5549
5550 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom183, &(*this), _1));
5551 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5552 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5553 }
5554 sigma_box += average;
5555 SMresult_cache += sigma_box;
5556 }
5557 } else if (s == 189.*189.) {
5558 if (!flagLEP2[ISR]){
5559 SMresult_cache = sigma_NoISR_q(QCD::quark(UP), s);
5560 SMresult_cache += sigma_NoISR_q(QCD::quark(DOWN), s);
5561 SMresult_cache += sigma_NoISR_q(QCD::quark(CHARM), s);
5562 SMresult_cache += sigma_NoISR_q(QCD::quark(STRANGE), s);
5563 SMresult_cache += sigma_NoISR_q(QCD::quark(BOTTOM), s);
5564 } else {
5565
5566 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up189, &(*this), _1));
5567 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5568 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5569 }
5570 SMresult_cache = average;
5571
5572 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down189, &(*this), _1));
5573 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5574 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5575 }
5576 SMresult_cache += average;
5577
5578 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm189, &(*this), _1));
5579 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5580 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5581 }
5582 SMresult_cache += average;
5583
5584 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange189, &(*this), _1));
5585 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5586 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5587 }
5588 SMresult_cache += average;
5589
5590 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom189, &(*this), _1));
5591 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5592 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5593 }
5594 SMresult_cache += average;
5595 }
5596
5597 if (flagLEP2[WeakBox]) {
5598 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up189, &(*this), _1));
5599 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5600 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5601 }
5602 double sigma_box = average;
5603
5604 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down189, &(*this), _1));
5605 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5606 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5607 }
5608 sigma_box += average;
5609
5610 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm189, &(*this), _1));
5611 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5612 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5613 }
5614 sigma_box += average;
5615
5616 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange189, &(*this), _1));
5617 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5618 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5619 }
5620 sigma_box += average;
5621
5622 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom189, &(*this), _1));
5623 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5624 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5625 }
5626 sigma_box += average;
5627 SMresult_cache += sigma_box;
5628 }
5629 } else if (s == 192.*192.) {
5630 if (!flagLEP2[ISR]){
5631 SMresult_cache = sigma_NoISR_q(QCD::quark(UP), s);
5632 SMresult_cache += sigma_NoISR_q(QCD::quark(DOWN), s);
5633 SMresult_cache += sigma_NoISR_q(QCD::quark(CHARM), s);
5634 SMresult_cache += sigma_NoISR_q(QCD::quark(STRANGE), s);
5635 SMresult_cache += sigma_NoISR_q(QCD::quark(BOTTOM), s);
5636 } else {
5637
5638 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up192, &(*this), _1));
5639 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5640 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5641 }
5642 SMresult_cache = average;
5643
5644 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down192, &(*this), _1));
5645 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5646 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5647 }
5648 SMresult_cache += average;
5649
5650 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm192, &(*this), _1));
5651
5652 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5653 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5654 }
5655 SMresult_cache += average;
5656
5657 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange192, &(*this), _1));
5658
5659 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5660 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5661 }
5662 SMresult_cache += average;
5663
5664 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom192, &(*this), _1));
5665 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5666 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5667 }
5668 SMresult_cache += average;
5669 }
5670
5671 if (flagLEP2[WeakBox]) {
5672 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up192, &(*this), _1));
5673 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5674 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5675 }
5676 double sigma_box = average;
5677
5678 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down192, &(*this), _1));
5679 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5680 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5681 }
5682 sigma_box += average;
5683
5684 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm192, &(*this), _1));
5685 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5686 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5687 }
5688 sigma_box += average;
5689
5690 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange192, &(*this), _1));
5691 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5692 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5693 }
5694 sigma_box += average;
5695
5696 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom192, &(*this), _1));
5697 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5698 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5699 }
5700 sigma_box += average;
5701 SMresult_cache += sigma_box;
5702 }
5703 } else if (s == 196.*196.) {
5704 if (!flagLEP2[ISR]){
5705 SMresult_cache = sigma_NoISR_q(QCD::quark(UP), s);
5706 SMresult_cache += sigma_NoISR_q(QCD::quark(DOWN), s);
5707 SMresult_cache += sigma_NoISR_q(QCD::quark(CHARM), s);
5708 SMresult_cache += sigma_NoISR_q(QCD::quark(STRANGE), s);
5709 SMresult_cache += sigma_NoISR_q(QCD::quark(BOTTOM), s);
5710 } else {
5711
5712 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up196, &(*this), _1));
5713 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5714 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5715 }
5716 SMresult_cache = average;
5717
5718 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down196, &(*this), _1));
5719 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5720 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5721 }
5722 SMresult_cache += average;
5723
5724 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm196, &(*this), _1));
5725 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5726 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5727 }
5728 SMresult_cache += average;
5729
5730 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange196, &(*this), _1));
5731
5732 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5733 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5734 }
5735 SMresult_cache += average;
5736
5737 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom196, &(*this), _1));
5738 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5739 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5740 }
5741 SMresult_cache += average;
5742 }
5743
5744 if (flagLEP2[WeakBox]) {
5745 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up196, &(*this), _1));
5746 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5747 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5748 }
5749 double sigma_box = average;
5750
5751 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down196, &(*this), _1));
5752 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5753 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5754 }
5755 sigma_box += average;
5756
5757 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm196, &(*this), _1));
5758 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5759 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5760 }
5761 sigma_box += average;
5762
5763 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange196, &(*this), _1));
5764 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5765 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5766 }
5767 sigma_box += average;
5768
5769 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom196, &(*this), _1));
5770 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5771 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5772 }
5773 sigma_box += average;
5774 SMresult_cache += sigma_box;
5775 }
5776 } else if (s == 200.*200.) {
5777 if (!flagLEP2[ISR]){
5778 SMresult_cache = sigma_NoISR_q(QCD::quark(UP), s);
5779 SMresult_cache += sigma_NoISR_q(QCD::quark(DOWN), s);
5780 SMresult_cache += sigma_NoISR_q(QCD::quark(CHARM), s);
5781 SMresult_cache += sigma_NoISR_q(QCD::quark(STRANGE), s);
5782 SMresult_cache += sigma_NoISR_q(QCD::quark(BOTTOM), s);
5783 } else {
5784
5785 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up200, &(*this), _1));
5786 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5787 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5788 }
5789 SMresult_cache = average;
5790
5791 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down200, &(*this), _1));
5792 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5793 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5794 }
5795 SMresult_cache += average;
5796
5797 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm200, &(*this), _1));
5798 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5799 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5800 }
5801 SMresult_cache += average;
5802
5803 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange200, &(*this), _1));
5804 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5805 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5806 }
5807 SMresult_cache += average;
5808
5809 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom200, &(*this), _1));
5810 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5811 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5812 }
5813 SMresult_cache += average;
5814 }
5815
5816 if (flagLEP2[WeakBox]) {
5817 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up200, &(*this), _1));
5818 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5819 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5820 }
5821 double sigma_box = average;
5822
5823 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down200, &(*this), _1));
5824 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5825 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5826 }
5827 sigma_box += average;
5828
5829 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm200, &(*this), _1));
5830 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5831 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5832 }
5833 sigma_box += average;
5834
5835 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange200, &(*this), _1));
5836 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5837 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5838 }
5839 sigma_box += average;
5840
5841 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom200, &(*this), _1));
5842 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5843 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5844 }
5845 sigma_box += average;
5846 SMresult_cache += sigma_box;
5847 }
5848 } else if (s == 202.*202.) {
5849 if (!flagLEP2[ISR]){
5850 SMresult_cache = sigma_NoISR_q(QCD::quark(UP), s);
5851 SMresult_cache += sigma_NoISR_q(QCD::quark(DOWN), s);
5852 SMresult_cache += sigma_NoISR_q(QCD::quark(CHARM), s);
5853 SMresult_cache += sigma_NoISR_q(QCD::quark(STRANGE), s);
5854 SMresult_cache += sigma_NoISR_q(QCD::quark(BOTTOM), s);
5855 } else {
5856
5857 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up202, &(*this), _1));
5858
5859
5860
5861 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5862 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5863 }
5864 SMresult_cache = average;
5865
5866 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down202, &(*this), _1));
5867
5868
5869
5870 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5871 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5872 }
5873 SMresult_cache += average;
5874
5875 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm202, &(*this), _1));
5876
5877
5878
5879 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5880 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5881 }
5882 SMresult_cache += average;
5883
5884 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange202, &(*this), _1));
5885
5886
5887
5888 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5889 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5890 }
5891 SMresult_cache += average;
5892
5893 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom202, &(*this), _1));
5894
5895
5896
5897 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5898 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5899 }
5900 SMresult_cache += average;
5901 }
5902
5903 if (flagLEP2[WeakBox]) {
5904 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up202, &(*this), _1));
5905
5906
5907
5908 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5909 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5910 }
5911 double sigma_box = average;
5912
5913 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down202, &(*this), _1));
5914
5915
5916
5917 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5918 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5919 }
5920 sigma_box += average;
5921
5922 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm202, &(*this), _1));
5923
5924
5925
5926 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5927 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5928 }
5929 sigma_box += average;
5930
5931 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange202, &(*this), _1));
5932
5933
5934
5935 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5936 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5937 }
5938 sigma_box += average;
5939
5940 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom202, &(*this), _1));
5941
5942
5943
5944 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5945 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5946 }
5947 sigma_box += average;
5948 SMresult_cache += sigma_box;
5949 }
5950 } else if (s == 205.*205.) {
5951 if (!flagLEP2[ISR]){
5952 SMresult_cache = sigma_NoISR_q(QCD::quark(UP), s);
5953 SMresult_cache += sigma_NoISR_q(QCD::quark(DOWN), s);
5954 SMresult_cache += sigma_NoISR_q(QCD::quark(CHARM), s);
5955 SMresult_cache += sigma_NoISR_q(QCD::quark(STRANGE), s);
5956 SMresult_cache += sigma_NoISR_q(QCD::quark(BOTTOM), s);
5957 } else {
5958
5959 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up205, &(*this), _1));
5960
5961
5962
5963 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5964 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5965 }
5966 SMresult_cache = average;
5967
5968 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down205, &(*this), _1));
5969
5970
5971
5972 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5973 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5974 }
5975 SMresult_cache += average;
5976
5977 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm205, &(*this), _1));
5978
5979
5980
5981 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5982 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5983 }
5984 SMresult_cache += average;
5985
5986 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange205, &(*this), _1));
5987
5988
5989
5990 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5991 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5992 }
5993 SMresult_cache += average;
5994
5995 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom205, &(*this), _1));
5996
5997
5998
5999 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6000 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6001 }
6002 SMresult_cache += average;
6003 }
6004
6005 if (flagLEP2[WeakBox]) {
6006 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up205, &(*this), _1));
6007
6008
6009
6010 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6011 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6012 }
6013 double sigma_box = average;
6014
6015 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down205, &(*this), _1));
6016
6017
6018
6019 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6020 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6021 }
6022 sigma_box += average;
6023
6024 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm205, &(*this), _1));
6025
6026
6027
6028 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6029 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6030 }
6031 sigma_box += average;
6032
6033 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange205, &(*this), _1));
6034
6035
6036
6037 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6038 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6039 }
6040 sigma_box += average;
6041
6042 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom205, &(*this), _1));
6043
6044
6045
6046 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6047 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6048 }
6049 sigma_box += average;
6050 SMresult_cache += sigma_box;
6051 }
6052 } else if (s == 207.*207.) {
6053 if (!flagLEP2[ISR]){
6054 SMresult_cache = sigma_NoISR_q(QCD::quark(UP), s);
6055 SMresult_cache += sigma_NoISR_q(QCD::quark(DOWN), s);
6056 SMresult_cache += sigma_NoISR_q(QCD::quark(CHARM), s);
6057 SMresult_cache += sigma_NoISR_q(QCD::quark(STRANGE), s);
6058 SMresult_cache += sigma_NoISR_q(QCD::quark(BOTTOM), s);
6059 } else {
6060
6061 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up207, &(*this), _1));
6062
6063
6064
6065 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6066 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6067 }
6068 SMresult_cache = average;
6069
6070 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down207, &(*this), _1));
6071
6072
6073
6074 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6075 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6076 }
6077 SMresult_cache += average;
6078
6079 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm207, &(*this), _1));
6080
6081
6082
6083 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6084 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6085 }
6086 SMresult_cache += average;
6087
6088 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange207, &(*this), _1));
6089
6090
6091
6092 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6093 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6094 }
6095 SMresult_cache += average;
6096
6097 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom207, &(*this), _1));
6098
6099
6100
6101 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6102 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6103 }
6104 SMresult_cache += average;
6105 }
6106
6107 if (flagLEP2[WeakBox]) {
6108 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up207, &(*this), _1));
6109
6110
6111
6112 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6113 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6114 }
6115 double sigma_box = average;
6116
6117 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down207, &(*this), _1));
6118
6119
6120
6121 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6122 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6123 }
6124 sigma_box += average;
6125
6126 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm207, &(*this), _1));
6127
6128
6129
6130 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6131 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6132 }
6133 sigma_box += average;
6134
6135 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange207, &(*this), _1));
6136
6137
6138
6139 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6140 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6141 }
6142 sigma_box += average;
6143
6144 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom207, &(*this), _1));
6145
6146
6147
6148 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6149 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6150 }
6151 sigma_box += average;
6152 SMresult_cache += sigma_box;
6153 }
6154 } else {
6155 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2sigmaHadron!");
6156 }
6157
6158 double sigma_had = SMresult_cache;
6159
6160 gsl_set_error_handler(old_handler);
6161
6162 return sigma_had;
6163
6164 }
6165}
6166
6167
6168const double StandardModel::LEP2AFBbottom(const double s) const
6169{
6170
6171 bSigmaForAFB = true;
6172 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
6173 double relerr = 1.e-7;
6174 double abserr = 1.e-17;
6175
6176 if(s == 133.*133.){
6177 double AFB_noBox, sigma = 0.0;
6178 if (!flagLEP2[ISR])
6179 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6180 else {
6181 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom133, &(*this), _1));
6182 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6183 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6184 }
6185 double numerator = average; // interval
6186
6187
6188 sigma = LEP2sigmaBottom(s);
6189
6190 AFB_noBox = numerator/sigma;
6191 }
6192 SMresult_cache = AFB_noBox;
6193
6194 if (flagLEP2[WeakBox]) {
6195 // numerator
6196 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom133, &(*this), _1));
6197 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6198 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6199 }
6200 double sigma_box_F = average; // interval
6201 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom133, &(*this), _1));
6202 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6203 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6204 }
6205 double sigma_box_B = average; // interval
6206
6207 // denominator
6208 if (!flagLEP2[ISR]) {
6209
6210 sigma = LEP2sigmaBottom(s);
6211 }
6212
6213 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6214 }
6215 } else if (s == 167.*167.){
6216 double AFB_noBox, sigma = 0.0;
6217 if (!flagLEP2[ISR])
6218 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6219 else {
6220 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom167, &(*this), _1));
6221 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6222 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6223 }
6224 double numerator = average; // interval
6225
6226
6227 sigma = LEP2sigmaBottom(s);
6228
6229 AFB_noBox = numerator/sigma;
6230 }
6231 SMresult_cache = AFB_noBox;
6232
6233 if (flagLEP2[WeakBox]) {
6234 // numerator
6235 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom167, &(*this), _1));
6236 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6237 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6238 }
6239 double sigma_box_F = average; // interval
6240 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom167, &(*this), _1));
6241 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6242 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6243 }
6244 double sigma_box_B = average; // interval
6245
6246 // denominator
6247 if (!flagLEP2[ISR]) {
6248
6249 sigma = LEP2sigmaBottom(s);
6250 }
6251
6252 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6253 }
6254 } else if (s == 183.*183.) {
6255 double AFB_noBox, sigma = 0.0;
6256 if (!flagLEP2[ISR])
6257 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6258 else {
6259 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom183, &(*this), _1));
6260 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6261 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6262 }
6263 double numerator = average; // interval
6264
6265
6266 sigma = LEP2sigmaBottom(s);
6267
6268 AFB_noBox = numerator/sigma;
6269 }
6270 SMresult_cache = AFB_noBox;
6271
6272 if (flagLEP2[WeakBox]) {
6273 // numerator
6274 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom183, &(*this), _1));
6275 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6276 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6277 }
6278 double sigma_box_F = average; // interval
6279 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom183, &(*this), _1));
6280 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6281 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6282 }
6283 double sigma_box_B = average; // interval
6284
6285 // denominator
6286 if (!flagLEP2[ISR]) {
6287
6288 sigma = LEP2sigmaBottom(s);
6289 }
6290
6291 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6292 }
6293 } else if (s == 189.*189.) {
6294 double AFB_noBox, sigma = 0.0;
6295 if (!flagLEP2[ISR])
6296 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6297 else {
6298 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom189, &(*this), _1));
6299 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6300 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6301 }
6302 double numerator = average; // interval
6303
6304
6305 sigma = LEP2sigmaBottom(s);
6306
6307 AFB_noBox = numerator/sigma;
6308 }
6309 SMresult_cache = AFB_noBox;
6310
6311 if (flagLEP2[WeakBox]) {
6312 // numerator
6313 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom189, &(*this), _1));
6314 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6315 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6316 }
6317 double sigma_box_F = average; // interval
6318 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom189, &(*this), _1));
6319 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6320 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6321 }
6322 double sigma_box_B = average; // interval
6323
6324 // denominator
6325 if (!flagLEP2[ISR]) {
6326
6327 sigma = LEP2sigmaBottom(s);
6328 }
6329
6330 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6331 }
6332 } else if (s == 192.*192.) {
6333 double AFB_noBox, sigma = 0.0;
6334 if (!flagLEP2[ISR])
6335 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6336 else {
6337 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom192, &(*this), _1));
6338 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6339 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6340 }
6341 double numerator = average; // interval
6342
6343
6344 sigma = LEP2sigmaBottom(s);
6345
6346 AFB_noBox = numerator/sigma;
6347 }
6348 SMresult_cache = AFB_noBox;
6349
6350 if (flagLEP2[WeakBox]) {
6351 // numerator
6352 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom192, &(*this), _1));
6353 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6354 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6355 }
6356 double sigma_box_F = average; // interval
6357 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom192, &(*this), _1));
6358 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6359 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6360 }
6361 double sigma_box_B = average; // interval
6362
6363 // denominator
6364 if (!flagLEP2[ISR]) {
6365
6366 sigma = LEP2sigmaBottom(s);
6367 }
6368
6369 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6370 }
6371 } else if (s == 196.*196.) {
6372 double AFB_noBox, sigma = 0.0;
6373 if (!flagLEP2[ISR])
6374 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6375 else {
6376 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom196, &(*this), _1));
6377 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6378 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6379 }
6380 double numerator = average; // interval
6381
6382
6383 sigma = LEP2sigmaBottom(s);
6384
6385 AFB_noBox = numerator/sigma;
6386 }
6387 SMresult_cache = AFB_noBox;
6388
6389 if (flagLEP2[WeakBox]) {
6390 // numerator
6391 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom196, &(*this), _1));
6392 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6393 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6394 }
6395 double sigma_box_F = average; // interval
6396 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom196, &(*this), _1));
6397 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6398 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6399 }
6400 double sigma_box_B = average; // interval
6401
6402 // denominator
6403 if (!flagLEP2[ISR]) {
6404
6405 sigma = LEP2sigmaBottom(s);
6406 }
6407
6408 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6409 }
6410 } else if (s == 200.*200.) {
6411 double AFB_noBox, sigma = 0.0;
6412 if (!flagLEP2[ISR])
6413 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6414 else {
6415 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom200, &(*this), _1));
6416 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6417 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6418 }
6419 double numerator = average; // interval
6420
6421
6422 sigma = LEP2sigmaBottom(s);
6423
6424 AFB_noBox = numerator/sigma;
6425 }
6426 SMresult_cache = AFB_noBox;
6427
6428 if (flagLEP2[WeakBox]) {
6429 // numerator
6430 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom200, &(*this), _1));
6431 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6432 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6433 }
6434 double sigma_box_F = average; // interval
6435 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom200, &(*this), _1));
6436 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6437 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6438 }
6439 double sigma_box_B = average; // interval
6440
6441 // denominator
6442 if (!flagLEP2[ISR]) {
6443
6444 sigma = LEP2sigmaBottom(s);
6445 }
6446
6447 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6448 }
6449 } else if (s == 202.*202.) {
6450 double AFB_noBox, sigma = 0.0;
6451 if (!flagLEP2[ISR])
6452 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6453 else {
6454 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom202, &(*this), _1));
6455 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6456 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6457 }
6458 double numerator = average; // interval
6459
6460
6461 sigma = LEP2sigmaBottom(s);
6462
6463 AFB_noBox = numerator/sigma;
6464 }
6465 SMresult_cache = AFB_noBox;
6466
6467 if (flagLEP2[WeakBox]) {
6468 // numerator
6469 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom202, &(*this), _1));
6470 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6471 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6472 }
6473 double sigma_box_F = average; // interval
6474 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom202, &(*this), _1));
6475 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6476 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6477 }
6478 double sigma_box_B = average; // interval
6479
6480 // denominator
6481 if (!flagLEP2[ISR]) {
6482
6483 sigma = LEP2sigmaBottom(s);
6484 }
6485
6486 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6487 }
6488 } else if (s == 205.*205.) {
6489 double AFB_noBox, sigma = 0.0;
6490 if (!flagLEP2[ISR])
6491 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6492 else {
6493 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom205, &(*this), _1));
6494 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6495 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6496 }
6497 double numerator = average; // interval
6498
6499
6500 sigma = LEP2sigmaBottom(s);
6501
6502 AFB_noBox = numerator/sigma;
6503 }
6504 SMresult_cache = AFB_noBox;
6505
6506 if (flagLEP2[WeakBox]) {
6507 // numerator
6508 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom205, &(*this), _1));
6509 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6510 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6511 }
6512 double sigma_box_F = average; // interval
6513 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom205, &(*this), _1));
6514 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6515 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6516 }
6517 double sigma_box_B = average; // interval
6518
6519 // denominator
6520 if (!flagLEP2[ISR]) {
6521
6522 sigma = LEP2sigmaBottom(s);
6523 }
6524
6525 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6526 }
6527 } else if (s == 207.*207.) {
6528 double AFB_noBox, sigma = 0.0;
6529 if (!flagLEP2[ISR])
6530 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6531 else {
6532 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom207, &(*this), _1));
6533 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6534 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6535 }
6536 double numerator = average; // interval
6537
6538
6539 sigma = LEP2sigmaBottom(s);
6540
6541 AFB_noBox = numerator/sigma;
6542 }
6543 SMresult_cache = AFB_noBox;
6544
6545 if (flagLEP2[WeakBox]) {
6546 // numerator
6547 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom207, &(*this), _1));
6548 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6549 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6550 }
6551 double sigma_box_F = average; // interval
6552 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom207, &(*this), _1));
6553 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6554 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6555 }
6556 double sigma_box_B = average; // interval
6557
6558 // denominator
6559 if (!flagLEP2[ISR]) {
6560
6561 sigma = LEP2sigmaBottom(s);
6562 }
6563
6564 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6565 }
6566 } else {
6567 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2AFBbottom!");
6568 }
6569
6570 double AFBbottom = SMresult_cache;
6571
6572 gsl_set_error_handler(old_handler);
6573 bSigmaForAFB = false;
6574 return AFBbottom;
6575
6576}
6577
6578
6579const double StandardModel::LEP2AFBcharm(const double s) const
6580{
6581
6582 bSigmaForAFB = true;
6583 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
6584 double relerr = 1.e-7;
6585 double abserr = 1.e-17;
6586
6587 if(s == 133.*133.){
6588 double AFB_noBox, sigma = 0.0;
6589 if (!flagLEP2[ISR])
6590 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6591 else {
6592 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm133, &(*this), _1));
6593 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6594 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6595 }
6596 double numerator = average; // interval
6597
6598
6599 sigma = LEP2sigmaCharm(s);
6600
6601 AFB_noBox = numerator/sigma;
6602 }
6603 SMresult_cache = AFB_noBox;
6604
6605 if (flagLEP2[WeakBox]) {
6606 // numerator
6607 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm133, &(*this), _1));
6608 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6609 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6610 }
6611 double sigma_box_F = average; // interval
6612 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm133, &(*this), _1));
6613 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6614 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6615 }
6616 double sigma_box_B = average; // interval
6617
6618 // denominator
6619 if (!flagLEP2[ISR]) {
6620
6621 sigma = LEP2sigmaCharm(s);
6622 }
6623
6624 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6625 }
6626 } else if (s == 167.*167.){
6627 double AFB_noBox, sigma = 0.0;
6628 if (!flagLEP2[ISR])
6629 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6630 else {
6631 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm167, &(*this), _1));
6632 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6633 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6634 }
6635 double numerator = average; // interval
6636
6637
6638 sigma = LEP2sigmaCharm(s);
6639
6640 AFB_noBox = numerator/sigma;
6641 }
6642 SMresult_cache = AFB_noBox;
6643
6644 if (flagLEP2[WeakBox]) {
6645 // numerator
6646 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm167, &(*this), _1));
6647 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6648 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6649 }
6650 double sigma_box_F = average; // interval
6651 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm167, &(*this), _1));
6652 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6653 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6654 }
6655 double sigma_box_B = average; // interval
6656
6657 // denominator
6658 if (!flagLEP2[ISR]) {
6659
6660 sigma = LEP2sigmaCharm(s);
6661 }
6662
6663 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6664 }
6665 } else if (s == 183.*183.) {
6666 double AFB_noBox, sigma = 0.0;
6667 if (!flagLEP2[ISR])
6668 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6669 else {
6670 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm183, &(*this), _1));
6671 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6672 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6673 }
6674 double numerator = average; // interval
6675
6676
6677 sigma = LEP2sigmaCharm(s);
6678
6679 AFB_noBox = numerator/sigma;
6680 }
6681 SMresult_cache = AFB_noBox;
6682
6683 if (flagLEP2[WeakBox]) {
6684 // numerator
6685 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm183, &(*this), _1));
6686 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6687 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6688 }
6689 double sigma_box_F = average; // interval
6690 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm183, &(*this), _1));
6691 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6692 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6693 }
6694 double sigma_box_B = average; // interval
6695
6696 // denominator
6697 if (!flagLEP2[ISR]) {
6698
6699 sigma = LEP2sigmaCharm(s);
6700 }
6701
6702 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6703 }
6704 } else if (s == 189.*189.) {
6705 double AFB_noBox, sigma = 0.0;
6706 if (!flagLEP2[ISR])
6707 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6708 else {
6709 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm189, &(*this), _1));
6710 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6711 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6712 }
6713 double numerator = average; // interval
6714
6715
6716 sigma = LEP2sigmaCharm(s);
6717
6718 AFB_noBox = numerator/sigma;
6719 }
6720 SMresult_cache = AFB_noBox;
6721
6722 if (flagLEP2[WeakBox]) {
6723 // numerator
6724 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm189, &(*this), _1));
6725 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6726 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6727 }
6728 double sigma_box_F = average; // interval
6729 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm189, &(*this), _1));
6730 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6731 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6732 }
6733 double sigma_box_B = average; // interval
6734
6735 // denominator
6736 if (!flagLEP2[ISR]) {
6737
6738 sigma = LEP2sigmaCharm(s);
6739 }
6740
6741 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6742 }
6743 } else if (s == 192.*192.) {
6744 double AFB_noBox, sigma = 0.0;
6745 if (!flagLEP2[ISR])
6746 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6747 else {
6748 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm192, &(*this), _1));
6749 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6750 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6751 }
6752 double numerator = average; // interval
6753
6754
6755 sigma = LEP2sigmaCharm(s);
6756
6757 AFB_noBox = numerator/sigma;
6758 }
6759 SMresult_cache = AFB_noBox;
6760
6761 if (flagLEP2[WeakBox]) {
6762 // numerator
6763 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm192, &(*this), _1));
6764 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6765 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6766 }
6767 double sigma_box_F = average; // interval
6768 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm192, &(*this), _1));
6769 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6770 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6771 }
6772 double sigma_box_B = average; // interval
6773
6774 // denominator
6775 if (!flagLEP2[ISR]) {
6776
6777 sigma = LEP2sigmaCharm(s);
6778 }
6779
6780 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6781 }
6782 } else if (s == 196.*196.) {
6783 double AFB_noBox, sigma = 0.0;
6784 if (!flagLEP2[ISR])
6785 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6786 else {
6787 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm196, &(*this), _1));
6788 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6789 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6790 }
6791 double numerator = average; // interval
6792
6793
6794 sigma = LEP2sigmaCharm(s);
6795
6796 AFB_noBox = numerator/sigma;
6797 }
6798 SMresult_cache = AFB_noBox;
6799
6800 if (flagLEP2[WeakBox]) {
6801 // numerator
6802 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm196, &(*this), _1));
6803 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6804 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6805 }
6806 double sigma_box_F = average; // interval
6807 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm196, &(*this), _1));
6808 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6809 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6810 }
6811 double sigma_box_B = average; // interval
6812
6813 // denominator
6814 if (!flagLEP2[ISR]) {
6815
6816 sigma = LEP2sigmaCharm(s);
6817 }
6818
6819 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6820 }
6821 } else if (s == 200.*200.) {
6822 double AFB_noBox, sigma = 0.0;
6823 if (!flagLEP2[ISR])
6824 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6825 else {
6826 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm200, &(*this), _1));
6827 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6828 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6829 }
6830 double numerator = average; // interval
6831
6832
6833 sigma = LEP2sigmaCharm(s);
6834
6835 AFB_noBox = numerator/sigma;
6836 }
6837 SMresult_cache = AFB_noBox;
6838
6839 if (flagLEP2[WeakBox]) {
6840 // numerator
6841 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm200, &(*this), _1));
6842 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6843 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6844 }
6845 double sigma_box_F = average; // interval
6846 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm200, &(*this), _1));
6847 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6848 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6849 }
6850 double sigma_box_B = average; // interval
6851
6852 // denominator
6853 if (!flagLEP2[ISR]) {
6854
6855 sigma = LEP2sigmaCharm(s);
6856 }
6857
6858 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6859 }
6860 } else if (s == 202.*202.) {
6861 double AFB_noBox, sigma = 0.0;
6862 if (!flagLEP2[ISR])
6863 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6864 else {
6865 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm202, &(*this), _1));
6866 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6867 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6868 }
6869 double numerator = average; // interval
6870
6871
6872 sigma = LEP2sigmaCharm(s);
6873
6874 AFB_noBox = numerator/sigma;
6875 }
6876 SMresult_cache = AFB_noBox;
6877
6878 if (flagLEP2[WeakBox]) {
6879 // numerator
6880 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm202, &(*this), _1));
6881 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6882 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6883 }
6884 double sigma_box_F = average; // interval
6885 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm202, &(*this), _1));
6886 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6887 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6888 }
6889 double sigma_box_B = average; // interval
6890
6891 // denominator
6892 if (!flagLEP2[ISR]) {
6893
6894 sigma = LEP2sigmaCharm(s);
6895 }
6896
6897 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6898 }
6899 } else if (s == 205.*205.) {
6900 double AFB_noBox, sigma = 0.0;
6901 if (!flagLEP2[ISR])
6902 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6903 else {
6904 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm205, &(*this), _1));
6905 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6906 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6907 }
6908 double numerator = average; // interval
6909
6910
6911 sigma = LEP2sigmaCharm(s);
6912
6913 AFB_noBox = numerator/sigma;
6914 }
6915 SMresult_cache = AFB_noBox;
6916
6917 if (flagLEP2[WeakBox]) {
6918 // numerator
6919 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm205, &(*this), _1));
6920 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6921 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6922 }
6923 double sigma_box_F = average; // interval
6924 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm205, &(*this), _1));
6925 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6926 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6927 }
6928 double sigma_box_B = average; // interval
6929
6930 // denominator
6931 if (!flagLEP2[ISR]) {
6932
6933 sigma = LEP2sigmaCharm(s);
6934 }
6935
6936 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6937 }
6938 } else if (s == 207.*207.) {
6939 double AFB_noBox, sigma = 0.0;
6940 if (!flagLEP2[ISR])
6941 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6942 else {
6943 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm205, &(*this), _1));
6944 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6945 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6946 }
6947 double numerator = average; // interval
6948
6949
6950 sigma = LEP2sigmaCharm(s);
6951
6952 AFB_noBox = numerator/sigma;
6953 }
6954 SMresult_cache = AFB_noBox;
6955
6956 if (flagLEP2[WeakBox]) {
6957 // numerator
6958 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm207, &(*this), _1));
6959 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6960 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6961 }
6962 double sigma_box_F = average; // interval
6963 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm207, &(*this), _1));
6964 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6965 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6966 }
6967 double sigma_box_B = average; // interval
6968
6969 // denominator
6970 if (!flagLEP2[ISR]) {
6971
6972 sigma = LEP2sigmaCharm(s);
6973 }
6974
6975 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6976 }
6977 } else {
6978 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2AFBcharm!");
6979 }
6980
6981 double AFBcharm = SMresult_cache;
6982
6983 gsl_set_error_handler(old_handler);
6984 bSigmaForAFB = false;
6985 return AFBcharm;
6986
6987}
6988
6989const double StandardModel::LEP2AFBe(const double s) const
6990{
6991 return 0.;
6992}
6993
6994const double StandardModel::LEP2AFBmu(const double s) const
6995{
6996
6997 bSigmaForAFB = true;
6998 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
6999 double relerr = 1.e-7;
7000 double abserr = 1.e-17;
7001
7002 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
7003 if (!IsFlagNoApproximateGammaZ()){
7004
7005 /* SM contribution with the approximate formula */
7006 return (myApproximateFormulae->LEP2AFBmuApprox(s));
7007
7008 } else {
7009
7010 if(s == 130.*130.){
7011 double AFB_noBox, sigma = 0.0;
7012 if (!flagLEP2[ISR])
7013 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7014 else {
7015 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu130, &(*this), _1));
7016 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7017 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7018 }
7019 double numerator = average; // interval
7020
7021
7022 sigma = LEP2sigmaMu(s);
7023
7024 AFB_noBox = numerator/sigma;
7025 }
7026 SMresult_cache = AFB_noBox;
7027
7028 if (flagLEP2[WeakBox]) {
7029 // numerator
7030 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu130, &(*this), _1));
7031 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7032 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7033 }
7034 double sigma_box_F = average; // interval
7035 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu130, &(*this), _1));
7036 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7037 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7038 }
7039 double sigma_box_B = average; // interval
7040
7041 // denominator
7042 if (!flagLEP2[ISR]) {
7043
7044 sigma = LEP2sigmaMu(s);
7045 }
7046
7047 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7048 }
7049 } else if (s == 136.*136.){
7050 double AFB_noBox, sigma = 0.0;
7051 if (!flagLEP2[ISR])
7052 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7053 else {
7054 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu136, &(*this), _1));
7055 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7056 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7057 }
7058 double numerator = average; // interval
7059
7060
7061 sigma = LEP2sigmaMu(s);
7062
7063 AFB_noBox = numerator/sigma;
7064 }
7065 SMresult_cache = AFB_noBox;
7066
7067 if (flagLEP2[WeakBox]) {
7068 // numerator
7069 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu136, &(*this), _1));
7070 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7071 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7072 }
7073 double sigma_box_F = average; // interval
7074 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu136, &(*this), _1));
7075 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7076 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7077 }
7078 double sigma_box_B = average; // interval
7079
7080 // denominator
7081 if (!flagLEP2[ISR]) {
7082
7083 sigma = LEP2sigmaMu(s);
7084 }
7085
7086 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7087 }
7088 } else if (s == 161.*161.){
7089 double AFB_noBox, sigma = 0.0;
7090 if (!flagLEP2[ISR])
7091 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7092 else {
7093 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu161, &(*this), _1));
7094 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7095 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7096 }
7097 double numerator = average; // interval
7098
7099
7100 sigma = LEP2sigmaMu(s);
7101
7102 AFB_noBox = numerator/sigma;
7103 }
7104 SMresult_cache = AFB_noBox;
7105
7106 if (flagLEP2[WeakBox]) {
7107 // numerator
7108 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu161, &(*this), _1));
7109 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7110 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7111 }
7112 double sigma_box_F = average; // interval
7113 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu161, &(*this), _1));
7114 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7115 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7116 }
7117 double sigma_box_B = average; // interval
7118
7119 // denominator
7120 if (!flagLEP2[ISR]) {
7121
7122 sigma = LEP2sigmaMu(s);
7123 }
7124
7125 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7126 }
7127 } else if (s == 172.*172.){
7128 double AFB_noBox, sigma = 0.0;
7129 if (!flagLEP2[ISR])
7130 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7131 else {
7132 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu172, &(*this), _1));
7133 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7134 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7135 }
7136 double numerator = average; // interval
7137
7138
7139 sigma = LEP2sigmaMu(s);
7140
7141 AFB_noBox = numerator/sigma;
7142 }
7143 SMresult_cache = AFB_noBox;
7144
7145 if (flagLEP2[WeakBox]) {
7146 // numerator
7147 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu172, &(*this), _1));
7148 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7149 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7150 }
7151 double sigma_box_F = average; // interval
7152 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu172, &(*this), _1));
7153 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7154 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7155 }
7156 double sigma_box_B = average; // interval
7157
7158 // denominator
7159 if (!flagLEP2[ISR]) {
7160
7161 sigma = LEP2sigmaMu(s);
7162 }
7163
7164 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7165 }
7166 } else if (s == 183.*183.) {
7167 double AFB_noBox, sigma = 0.0;
7168 if (!flagLEP2[ISR])
7169 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7170 else {
7171 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu183, &(*this), _1));
7172 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7173 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7174 }
7175 double numerator = average; // interval
7176
7177
7178 sigma = LEP2sigmaMu(s);
7179
7180 AFB_noBox = numerator/sigma;
7181 }
7182 SMresult_cache = AFB_noBox;
7183
7184 if (flagLEP2[WeakBox]) {
7185 // numerator
7186 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu183, &(*this), _1));
7187 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7188 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7189 }
7190 double sigma_box_F = average; // interval
7191 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu183, &(*this), _1));
7192 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7193 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7194 }
7195 double sigma_box_B = average; // interval
7196
7197 // denominator
7198 if (!flagLEP2[ISR]) {
7199
7200 sigma = LEP2sigmaMu(s);
7201 }
7202
7203 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7204 }
7205 } else if (s == 189.*189.) {
7206 double AFB_noBox, sigma = 0.0;
7207 if (!flagLEP2[ISR])
7208 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7209 else {
7210 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu189, &(*this), _1));
7211 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7212 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7213 }
7214 double numerator = average; // interval
7215
7216
7217 sigma = LEP2sigmaMu(s);
7218
7219 AFB_noBox = numerator/sigma;
7220 }
7221 SMresult_cache = AFB_noBox;
7222
7223 if (flagLEP2[WeakBox]) {
7224 // numerator
7225 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu189, &(*this), _1));
7226 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7227 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7228 }
7229 double sigma_box_F = average; // interval
7230 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu189, &(*this), _1));
7231 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7232 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7233 }
7234 double sigma_box_B = average; // interval
7235
7236 // denominator
7237 if (!flagLEP2[ISR]) {
7238
7239 sigma = LEP2sigmaMu(s);
7240 }
7241
7242 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7243 }
7244 } else if (s == 192.*192.) {
7245 double AFB_noBox, sigma = 0.0;
7246 if (!flagLEP2[ISR])
7247 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7248 else {
7249 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu192, &(*this), _1));
7250 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7251 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7252 }
7253 double numerator = average; // interval
7254
7255
7256 sigma = LEP2sigmaMu(s);
7257
7258 AFB_noBox = numerator/sigma;
7259 }
7260 SMresult_cache = AFB_noBox;
7261
7262 if (flagLEP2[WeakBox]) {
7263 // numerator
7264 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu192, &(*this), _1));
7265 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7266 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7267 }
7268 double sigma_box_F = average; // interval
7269 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu192, &(*this), _1));
7270 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7271 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7272 }
7273 double sigma_box_B = average; // interval
7274
7275 // denominator
7276 if (!flagLEP2[ISR]) {
7277
7278 sigma = LEP2sigmaMu(s);
7279 }
7280
7281 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7282 }
7283 } else if (s == 196.*196.) {
7284 double AFB_noBox, sigma = 0.0;
7285 if (!flagLEP2[ISR])
7286 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7287 else {
7288 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu196, &(*this), _1));
7289 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7290 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7291 }
7292 double numerator = average; // interval
7293
7294
7295 sigma = LEP2sigmaMu(s);
7296
7297 AFB_noBox = numerator/sigma;
7298 }
7299 SMresult_cache = AFB_noBox;
7300
7301 if (flagLEP2[WeakBox]) {
7302 // numerator
7303 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu196, &(*this), _1));
7304 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7305 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7306 }
7307 double sigma_box_F = average; // interval
7308 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu196, &(*this), _1));
7309 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7310 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7311 }
7312 double sigma_box_B = average; // interval
7313
7314 // denominator
7315 if (!flagLEP2[ISR]) {
7316
7317 sigma = LEP2sigmaMu(s);
7318 }
7319
7320 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7321 }
7322 } else if (s == 200.*200.) {
7323 double AFB_noBox, sigma = 0.0;
7324 if (!flagLEP2[ISR])
7325 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7326 else {
7327 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu200, &(*this), _1));
7328 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7329 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7330 }
7331 double numerator = average; // interval
7332
7333
7334 sigma = LEP2sigmaMu(s);
7335
7336 AFB_noBox = numerator/sigma;
7337 }
7338 SMresult_cache = AFB_noBox;
7339
7340 if (flagLEP2[WeakBox]) {
7341 // numerator
7342 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu200, &(*this), _1));
7343 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7344 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7345 }
7346 double sigma_box_F = average; // interval
7347 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu200, &(*this), _1));
7348 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7349 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7350 }
7351 double sigma_box_B = average; // interval
7352
7353 // denominator
7354 if (!flagLEP2[ISR]) {
7355
7356 sigma = LEP2sigmaMu(s);
7357 }
7358
7359 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7360 }
7361 } else if (s == 202.*202.) {
7362 double AFB_noBox, sigma = 0.0;
7363 if (!flagLEP2[ISR])
7364 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7365 else {
7366 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu202, &(*this), _1));
7367 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7368 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7369 }
7370 double numerator = average; // interval
7371
7372
7373 sigma = LEP2sigmaMu(s);
7374
7375 AFB_noBox = numerator/sigma;
7376 }
7377 SMresult_cache = AFB_noBox;
7378
7379 if (flagLEP2[WeakBox]) {
7380 // numerator
7381 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu202, &(*this), _1));
7382 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7383 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7384 }
7385 double sigma_box_F = average; // interval
7386 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu202, &(*this), _1));
7387 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7388 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7389 }
7390 double sigma_box_B = average; // interval
7391
7392 // denominator
7393 if (!flagLEP2[ISR]) {
7394
7395 sigma = LEP2sigmaMu(s);
7396 }
7397
7398 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7399 }
7400 } else if (s == 205.*205.) {
7401 double AFB_noBox, sigma = 0.0;
7402 if (!flagLEP2[ISR])
7403 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7404 else {
7405 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu205, &(*this), _1));
7406 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7407 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7408 }
7409 double numerator = average; // interval
7410
7411
7412 sigma = LEP2sigmaMu(s);
7413
7414 AFB_noBox = numerator/sigma;
7415 }
7416 SMresult_cache = AFB_noBox;
7417
7418 if (flagLEP2[WeakBox]) {
7419 // numerator
7420 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu205, &(*this), _1));
7421 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7422 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7423 }
7424 double sigma_box_F = average; // interval
7425 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu205, &(*this), _1));
7426 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7427 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7428 }
7429 double sigma_box_B = average; // interval
7430
7431 // denominator
7432 if (!flagLEP2[ISR]) {
7433
7434 sigma = LEP2sigmaMu(s);
7435 }
7436
7437 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7438 }
7439 } else if (s == 207.*207.) {
7440 double AFB_noBox, sigma = 0.0;
7441 if (!flagLEP2[ISR])
7442 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7443 else {
7444 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu207, &(*this), _1));
7445 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7446 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7447 }
7448 double numerator = average; // interval
7449
7450
7451 sigma = LEP2sigmaMu(s);
7452
7453 AFB_noBox = numerator/sigma;
7454 }
7455 SMresult_cache = AFB_noBox;
7456
7457 if (flagLEP2[WeakBox]) {
7458 // numerator
7459 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu207, &(*this), _1));
7460 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7461 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7462 }
7463 double sigma_box_F = average; // interval
7464 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu207, &(*this), _1));
7465 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7466 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7467 }
7468 double sigma_box_B = average; // interval
7469
7470 // denominator
7471 if (!flagLEP2[ISR]) {
7472
7473 sigma = LEP2sigmaMu(s);
7474 }
7475
7476 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7477 }
7478 } else {
7479 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::AFBmu!");
7480 }
7481
7482 double AFBmu = SMresult_cache;
7483
7484 gsl_set_error_handler(old_handler);
7485 bSigmaForAFB = false;
7486 return AFBmu;
7487 }
7488}
7489
7490
7491const double StandardModel::LEP2AFBtau(const double s) const
7492{
7493
7494 bSigmaForAFB = true;
7495 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
7496 double relerr = 1.e-7;
7497 double abserr = 1.e-17;
7498
7499 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
7500 if (!IsFlagNoApproximateGammaZ()){
7501
7502 /* SM contribution with the approximate formula */
7503 return (myApproximateFormulae->LEP2AFBtauApprox(s));
7504
7505 } else {
7506
7507 if(s == 130.*130.){
7508 double AFB_noBox, sigma = 0.0;
7509 if (!flagLEP2[ISR])
7510 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7511 else {
7512 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau130, &(*this), _1));
7513 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7514 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7515 }
7516 double numerator = average; // interval
7517
7518
7519 sigma = LEP2sigmaTau(s);
7520
7521 AFB_noBox = numerator/sigma;
7522 }
7523 SMresult_cache = AFB_noBox;
7524
7525 if (flagLEP2[WeakBox]) {
7526 // numerator
7527 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau130, &(*this), _1));
7528 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7529 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7530 }
7531 double sigma_box_F = average; // interval
7532 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau130, &(*this), _1));
7533 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7534 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7535 }
7536 double sigma_box_B = average; // interval
7537
7538 // denominator
7539 if (!flagLEP2[ISR]) {
7540
7541 sigma = LEP2sigmaTau(s);
7542 }
7543
7544 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7545 }
7546 } else if (s == 136.*136.){
7547 double AFB_noBox, sigma = 0.0;
7548 if (!flagLEP2[ISR])
7549 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7550 else {
7551 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau136, &(*this), _1));
7552 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7553 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7554 }
7555 double numerator = average; // interval
7556
7557
7558 sigma = LEP2sigmaTau(s);
7559
7560 AFB_noBox = numerator/sigma;
7561 }
7562 SMresult_cache = AFB_noBox;
7563
7564 if (flagLEP2[WeakBox]) {
7565 // numerator
7566 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau136, &(*this), _1));
7567 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7568 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7569 }
7570 double sigma_box_F = average; // interval
7571 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau136, &(*this), _1));
7572 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7573 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7574 }
7575 double sigma_box_B = average; // interval
7576
7577 // denominator
7578 if (!flagLEP2[ISR]) {
7579
7580 sigma = LEP2sigmaTau(s);
7581 }
7582
7583 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7584 }
7585 } else if (s == 161.*161.){
7586 double AFB_noBox, sigma = 0.0;
7587 if (!flagLEP2[ISR])
7588 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7589 else {
7590 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau161, &(*this), _1));
7591 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7592 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7593 }
7594 double numerator = average; // interval
7595
7596
7597 sigma = LEP2sigmaTau(s);
7598
7599 AFB_noBox = numerator/sigma;
7600 }
7601 SMresult_cache = AFB_noBox;
7602
7603 if (flagLEP2[WeakBox]) {
7604 // numerator
7605 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau161, &(*this), _1));
7606 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7607 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7608 }
7609 double sigma_box_F = average; // interval
7610 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau161, &(*this), _1));
7611 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7612 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7613 }
7614 double sigma_box_B = average; // interval
7615
7616 // denominator
7617 if (!flagLEP2[ISR]) {
7618
7619 sigma = LEP2sigmaTau(s);
7620 }
7621
7622 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7623 }
7624 } else if (s == 172.*172.){
7625 double AFB_noBox, sigma = 0.0;
7626 if (!flagLEP2[ISR])
7627 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7628 else {
7629 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau172, &(*this), _1));
7630 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7631 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7632 }
7633 double numerator = average; // interval
7634
7635
7636 sigma = LEP2sigmaTau(s);
7637
7638 AFB_noBox = numerator/sigma;
7639 }
7640 SMresult_cache = AFB_noBox;
7641
7642 if (flagLEP2[WeakBox]) {
7643 // numerator
7644 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau172, &(*this), _1));
7645 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7646 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7647 }
7648 double sigma_box_F = average; // interval
7649 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau172, &(*this), _1));
7650 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7651 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7652 }
7653 double sigma_box_B = average; // interval
7654
7655 // denominator
7656 if (!flagLEP2[ISR]) {
7657
7658 sigma = LEP2sigmaTau(s);
7659 }
7660
7661 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7662 }
7663 } else if (s == 183.*183.) {
7664 double AFB_noBox, sigma = 0.0;
7665 if (!flagLEP2[ISR])
7666 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7667 else {
7668 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau183, &(*this), _1));
7669 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7670 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7671 }
7672 double numerator = average; // interval
7673
7674
7675 sigma = LEP2sigmaTau(s);
7676
7677 AFB_noBox = numerator/sigma;
7678 }
7679 SMresult_cache = AFB_noBox;
7680
7681 if (flagLEP2[WeakBox]) {
7682 // numerator
7683 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau183, &(*this), _1));
7684 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7685 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7686 }
7687 double sigma_box_F = average; // interval
7688 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau183, &(*this), _1));
7689 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7690 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7691 }
7692 double sigma_box_B = average; // interval
7693
7694 // denominator
7695 if (!flagLEP2[ISR]) {
7696
7697 sigma = LEP2sigmaTau(s);
7698 }
7699
7700 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7701 }
7702 } else if (s == 189.*189.) {
7703 double AFB_noBox, sigma = 0.0;
7704 if (!flagLEP2[ISR])
7705 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7706 else {
7707 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau189, &(*this), _1));
7708 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7709 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7710 }
7711 double numerator = average; // interval
7712
7713
7714 sigma = LEP2sigmaTau(s);
7715
7716 AFB_noBox = numerator/sigma;
7717 }
7718 SMresult_cache = AFB_noBox;
7719
7720 if (flagLEP2[WeakBox]) {
7721 // numerator
7722 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau189, &(*this), _1));
7723 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7724 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7725 }
7726 double sigma_box_F = average; // interval
7727 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau189, &(*this), _1));
7728 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7729 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7730 }
7731 double sigma_box_B = average; // interval
7732
7733 // denominator
7734 if (!flagLEP2[ISR]) {
7735
7736 sigma = LEP2sigmaTau(s);
7737 }
7738
7739 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7740 }
7741 } else if (s == 192.*192.) {
7742 double AFB_noBox, sigma = 0.0;
7743 if (!flagLEP2[ISR])
7744 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7745 else {
7746 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau192, &(*this), _1));
7747 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7748 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7749 }
7750 double numerator = average; // interval
7751
7752
7753 sigma = LEP2sigmaTau(s);
7754
7755 AFB_noBox = numerator/sigma;
7756 }
7757 SMresult_cache = AFB_noBox;
7758
7759 if (flagLEP2[WeakBox]) {
7760 // numerator
7761 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau192, &(*this), _1));
7762 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7763 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7764 }
7765 double sigma_box_F = average; // interval
7766 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau192, &(*this), _1));
7767 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7768 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7769 }
7770 double sigma_box_B = average; // interval
7771
7772 // denominator
7773 if (!flagLEP2[ISR]) {
7774
7775 sigma = LEP2sigmaTau(s);
7776 }
7777
7778 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7779 }
7780 } else if (s == 196.*196.) {
7781 double AFB_noBox, sigma = 0.0;
7782 if (!flagLEP2[ISR])
7783 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7784 else {
7785 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau196, &(*this), _1));
7786 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7787 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7788 }
7789 double numerator = average; // interval
7790
7791
7792 sigma = LEP2sigmaTau(s);
7793
7794 AFB_noBox = numerator/sigma;
7795 }
7796 SMresult_cache = AFB_noBox;
7797
7798 if (flagLEP2[WeakBox]) {
7799 // numerator
7800 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau196, &(*this), _1));
7801 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7802 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7803 }
7804 double sigma_box_F = average; // interval
7805 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau196, &(*this), _1));
7806 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7807 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7808 }
7809 double sigma_box_B = average; // interval
7810
7811 // denominator
7812 if (!flagLEP2[ISR]) {
7813
7814 sigma = LEP2sigmaTau(s);
7815 }
7816
7817 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7818 }
7819 } else if (s == 200.*200.) {
7820 double AFB_noBox, sigma = 0.0;
7821 if (!flagLEP2[ISR])
7822 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7823 else {
7824 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau200, &(*this), _1));
7825 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7826 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7827 }
7828 double numerator = average; // interval
7829
7830
7831 sigma = LEP2sigmaTau(s);
7832
7833 AFB_noBox = numerator/sigma;
7834 }
7835 SMresult_cache = AFB_noBox;
7836
7837 if (flagLEP2[WeakBox]) {
7838 // numerator
7839 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau200, &(*this), _1));
7840 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7841 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7842 }
7843 double sigma_box_F = average; // interval
7844 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau200, &(*this), _1));
7845 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7846 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7847 }
7848 double sigma_box_B = average; // interval
7849
7850 // denominator
7851 if (!flagLEP2[ISR]) {
7852
7853 sigma = LEP2sigmaTau(s);
7854 }
7855
7856 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7857 }
7858 } else if (s == 202.*202.) {
7859 double AFB_noBox, sigma = 0.0;
7860 if (!flagLEP2[ISR])
7861 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7862 else {
7863 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau202, &(*this), _1));
7864 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7865 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7866 }
7867 double numerator = average; // interval
7868
7869
7870 sigma = LEP2sigmaTau(s);
7871
7872 AFB_noBox = numerator/sigma;
7873 }
7874 SMresult_cache = AFB_noBox;
7875
7876 if (flagLEP2[WeakBox]) {
7877 // numerator
7878 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau202, &(*this), _1));
7879 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7880 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7881 }
7882 double sigma_box_F = average; // interval
7883 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau202, &(*this), _1));
7884 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7885 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7886 }
7887 double sigma_box_B = average; // interval
7888
7889 // denominator
7890 if (!flagLEP2[ISR]) {
7891
7892 sigma = LEP2sigmaTau(s);
7893 }
7894
7895 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7896 }
7897 } else if (s == 205.*205.) {
7898 double AFB_noBox, sigma = 0.0;
7899 if (!flagLEP2[ISR])
7900 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7901 else {
7902 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau205, &(*this), _1));
7903 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7904 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7905 }
7906 double numerator = average; // interval
7907
7908
7909 sigma = LEP2sigmaTau(s);
7910
7911 AFB_noBox = numerator/sigma;
7912 }
7913 SMresult_cache = AFB_noBox;
7914
7915 if (flagLEP2[WeakBox]) {
7916 // numerator
7917 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau205, &(*this), _1));
7918 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7919 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7920 }
7921 double sigma_box_F = average; // interval
7922 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau205, &(*this), _1));
7923 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7924 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7925 }
7926 double sigma_box_B = average; // interval
7927
7928 // denominator
7929 if (!flagLEP2[ISR]) {
7930
7931 sigma = LEP2sigmaTau(s);
7932 }
7933
7934 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7935 }
7936 } else if (s == 207.*207.) {
7937 double AFB_noBox, sigma = 0.0;
7938 if (!flagLEP2[ISR])
7939 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7940 else {
7941 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau207, &(*this), _1));
7942 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7943 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7944 }
7945 double numerator = average; // interval
7946
7947
7948 sigma = LEP2sigmaTau(s);
7949
7950 AFB_noBox = numerator/sigma;
7951 }
7952 SMresult_cache = AFB_noBox;
7953
7954 if (flagLEP2[WeakBox]) {
7955 // numerator
7956 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau207, &(*this), _1));
7957 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7958 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7959 }
7960 double sigma_box_F = average; // interval
7961 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau207, &(*this), _1));
7962 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7963 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7964 }
7965 double sigma_box_B = average; // interval
7966
7967 // denominator
7968 if (!flagLEP2[ISR]) {
7969
7970 sigma = LEP2sigmaTau(s);
7971 }
7972
7973 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7974 }
7975 } else {
7976 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2AFBtau!");
7977 }
7978
7979 double AFBtau = SMresult_cache;
7980
7981 gsl_set_error_handler(old_handler);
7982 bSigmaForAFB = false;
7983 return AFBtau;
7984 }
7985}
7986
7987
7988const double StandardModel::LEP2Rbottom(const double s) const
7989{
7990
7991 double sigma_b = LEP2sigmaBottom(s);
7992 double sigma_had = LEP2sigmaHadron(s);
7993 SMresult_cache = sigma_b / sigma_had;
7994 double R_bottom = SMresult_cache;
7995
7996 return R_bottom;
7997}
7998
7999
8000const double StandardModel::LEP2Rcharm(const double s) const
8001{
8002
8003 double sigma_c = LEP2sigmaCharm(s);
8004 double sigma_had = LEP2sigmaHadron(s);
8005 SMresult_cache = sigma_c / sigma_had;
8006 double R_charm = SMresult_cache;
8007
8008 return R_charm;
8009}
8010
8011
8012const double StandardModel::sigma_NoISR_l(const QCD::lepton l_flavor, const double s) const
8013{
8014 double ml = getLeptons(l_flavor).getMass();
8015 double l_charge = getLeptons(l_flavor).getCharge();
8016 double sigma = myTwoFermionsLEP2->sigma_l(l_flavor, ml, s, Mw(), Gamma_Z(), flagLEP2[Weak]);
8017
8018 if (!bSigmaForAFB && flagLEP2[QEDFSR])
8019 sigma *= myTwoFermionsLEP2->QED_FSR_forSigma(s, l_charge);
8020
8021 return sigma;
8022}
8023
8024const double StandardModel::sigma_NoISR_q(const QCD::quark q_flavor, const double s) const
8025{
8026 double mq = m_q(q_flavor, sqrt(s));
8027 double q_charge = getQuarks(q_flavor).getCharge();
8028 double sigma = myTwoFermionsLEP2->sigma_q(q_flavor, mq, s, Mw(), Gamma_Z(), flagLEP2[Weak]);
8029
8030 if (!bSigmaForAFB && flagLEP2[QEDFSR])
8031 sigma *= myTwoFermionsLEP2->QED_FSR_forSigma(s, q_charge);
8032
8033 if (!bSigmaForAFB && flagLEP2[QCDFSR])
8034 sigma *= myTwoFermionsLEP2->QCD_FSR_forSigma(s);
8035
8036 return sigma;
8037}
8038
8039const double StandardModel::AFB_NoISR_l(const QCD::lepton l_flavor, const double s) const
8040{
8041 double ml = getLeptons(l_flavor).getMass();
8042 double AFB = myTwoFermionsLEP2->AFB_l(l_flavor, ml, s, Mw(), Gamma_Z(), flagLEP2[Weak]);
8043
8044 return AFB;
8045}
8046
8047const double StandardModel::AFB_NoISR_q(const QCD::quark q_flavor, const double s) const
8048{
8049 double mq = m_q(q_flavor, sqrt(s));
8050 double AFB = myTwoFermionsLEP2->AFB_q(q_flavor, mq, s, Mw(), Gamma_Z(), flagLEP2[Weak]);
8051
8052 if (flagLEP2[QCDFSR])
8053 AFB *= myTwoFermionsLEP2->QCD_FSR_forAFB(q_flavor, mq, s);
8054
8055 return AFB;
8056}
8057
8058const double StandardModel::Integrand_sigmaWithISR_l(double x, const QCD::lepton l_flavor, const double s) const
8059{
8060 double sprime = (1.0 - x)*s;
8061 double ml = getLeptons(l_flavor).getMass();
8062 double l_charge = getLeptons(l_flavor).getCharge();
8063 double sigma = myTwoFermionsLEP2->sigma_l(l_flavor, ml, sprime, Mw(), Gamma_Z(),
8064 flagLEP2[Weak]);
8065 double H = myTwoFermionsLEP2->H_ISR(x, s);
8066
8067 if (!bSigmaForAFB && flagLEP2[QEDFSR])
8068 sigma *= myTwoFermionsLEP2->QED_FSR_forSigma(sprime, l_charge);
8069
8070 return ( H*sigma );
8071}
8072
8073const double StandardModel::getIntegrand_sigmaWithISR_mu130(double x) const
8074{
8075 double s = 130. * 130.;
8076 return (Integrand_sigmaWithISR_l(x, QCD::lepton(MU), s));
8077}
8078
8079const double StandardModel::getIntegrand_sigmaWithISR_mu136(double x) const
8080{
8081 double s = 136. * 136.;
8082 return (Integrand_sigmaWithISR_l(x, QCD::lepton(MU), s));
8083}
8084
8085const double StandardModel::getIntegrand_sigmaWithISR_mu161(double x) const
8086{
8087 double s = 161. * 161.;
8088 return (Integrand_sigmaWithISR_l(x, QCD::lepton(MU), s));
8089}
8090
8091const double StandardModel::getIntegrand_sigmaWithISR_mu172(double x) const
8092{
8093 double s = 172. * 172.;
8094 return (Integrand_sigmaWithISR_l(x, QCD::lepton(MU), s));
8095}
8096
8097const double StandardModel::getIntegrand_sigmaWithISR_mu183(double x) const
8098{
8099 double s = 183. * 183.;
8100 return (Integrand_sigmaWithISR_l(x, QCD::lepton(MU), s));
8101}
8102
8103const double StandardModel::getIntegrand_sigmaWithISR_mu189(double x) const
8104{
8105 double s = 189. * 189.;
8106 return (Integrand_sigmaWithISR_l(x, QCD::lepton(MU), s));
8107}
8108
8109const double StandardModel::getIntegrand_sigmaWithISR_mu192(double x) const
8110{
8111 double s = 192. * 192.;
8112 return (Integrand_sigmaWithISR_l(x, QCD::lepton(MU), s));
8113}
8114
8115const double StandardModel::getIntegrand_sigmaWithISR_mu196(double x) const
8116{
8117 double s = 196. * 196.;
8118 return (Integrand_sigmaWithISR_l(x, QCD::lepton(MU), s));
8119}
8120
8121const double StandardModel::getIntegrand_sigmaWithISR_mu200(double x) const
8122{
8123 double s = 200. * 200.;
8124 return (Integrand_sigmaWithISR_l(x, QCD::lepton(MU), s));
8125}
8126
8127const double StandardModel::getIntegrand_sigmaWithISR_mu202(double x) const
8128{
8129 double s = 202. * 202.;
8130 return (Integrand_sigmaWithISR_l(x, QCD::lepton(MU), s));
8131}
8132
8133const double StandardModel::getIntegrand_sigmaWithISR_mu205(double x) const
8134{
8135 double s = 205. * 205.;
8136 return (Integrand_sigmaWithISR_l(x, QCD::lepton(MU), s));
8137}
8138
8139const double StandardModel::getIntegrand_sigmaWithISR_mu207(double x) const
8140{
8141 double s = 207. * 207.;
8142 return (Integrand_sigmaWithISR_l(x, QCD::lepton(MU), s));
8143}
8144
8145
8146const double StandardModel::getIntegrand_sigmaWithISR_tau130(double x) const
8147{
8148 double s = 130. * 130.;
8149 return (Integrand_sigmaWithISR_l(x, QCD::lepton(TAU), s));
8150}
8151
8152const double StandardModel::getIntegrand_sigmaWithISR_tau136(double x) const
8153{
8154 double s = 136. * 136.;
8155 return (Integrand_sigmaWithISR_l(x, QCD::lepton(TAU), s));
8156}
8157
8158const double StandardModel::getIntegrand_sigmaWithISR_tau161(double x) const
8159{
8160 double s = 161. * 161.;
8161 return (Integrand_sigmaWithISR_l(x, QCD::lepton(TAU), s));
8162}
8163
8164const double StandardModel::getIntegrand_sigmaWithISR_tau172(double x) const
8165{
8166 double s = 172. * 172.;
8167 return (Integrand_sigmaWithISR_l(x, QCD::lepton(TAU), s));
8168}
8169
8170const double StandardModel::getIntegrand_sigmaWithISR_tau183(double x) const
8171{
8172 double s = 183. * 183.;
8173 return (Integrand_sigmaWithISR_l(x, QCD::lepton(TAU), s));
8174}
8175
8176const double StandardModel::getIntegrand_sigmaWithISR_tau189(double x) const
8177{
8178 double s = 189. * 189.;
8179 return (Integrand_sigmaWithISR_l(x, QCD::lepton(TAU), s));
8180}
8181
8182const double StandardModel::getIntegrand_sigmaWithISR_tau192(double x) const
8183{
8184 double s = 192. * 192.;
8185 return (Integrand_sigmaWithISR_l(x, QCD::lepton(TAU), s));
8186}
8187
8188const double StandardModel::getIntegrand_sigmaWithISR_tau196(double x) const
8189{
8190 double s = 196. * 196.;
8191 return (Integrand_sigmaWithISR_l(x, QCD::lepton(TAU), s));
8192}
8193
8194const double StandardModel::getIntegrand_sigmaWithISR_tau200(double x) const
8195{
8196 double s = 200. * 200.;
8197 return (Integrand_sigmaWithISR_l(x, QCD::lepton(TAU), s));
8198}
8199
8200const double StandardModel::getIntegrand_sigmaWithISR_tau202(double x) const
8201{
8202 double s = 202. * 202.;
8203 return (Integrand_sigmaWithISR_l(x, QCD::lepton(TAU), s));
8204}
8205
8206const double StandardModel::getIntegrand_sigmaWithISR_tau205(double x) const
8207{
8208 double s = 205. * 205.;
8209 return (Integrand_sigmaWithISR_l(x, QCD::lepton(TAU), s));
8210}
8211
8212const double StandardModel::getIntegrand_sigmaWithISR_tau207(double x) const
8213{
8214 double s = 207. * 207.;
8215 return (Integrand_sigmaWithISR_l(x, QCD::lepton(TAU), s));
8216}
8217
8218const double StandardModel::Integrand_sigmaWithISR_q(double x, const QCD::quark q_flavor, const double s) const
8219{
8220 double sprime = (1.0 - x)*s;
8221 double mq = m_q(q_flavor, sqrt(s));
8222 double q_charge = getQuarks(q_flavor).getCharge();
8223 double sigma = myTwoFermionsLEP2->sigma_q(q_flavor, mq, sprime, Mw(), Gamma_Z(),
8224 flagLEP2[Weak]);
8225 double H = myTwoFermionsLEP2->H_ISR(x, s);
8226
8227 if (!bSigmaForAFB && flagLEP2[QEDFSR])
8228 sigma *= myTwoFermionsLEP2->QED_FSR_forSigma(sprime, q_charge);
8229
8230 if (!bSigmaForAFB && flagLEP2[QCDFSR])
8231 sigma *= myTwoFermionsLEP2->QCD_FSR_forSigma(sprime);
8232
8233 return ( H*sigma );
8234}
8235
8236
8237
8238
8239//up
8240
8241
8242const double StandardModel::getIntegrand_sigmaWithISR_up130(double x) const
8243{
8244 double s = 130. * 130.;
8245 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8246}
8247
8248const double StandardModel::getIntegrand_sigmaWithISR_up133(double x) const
8249{
8250 double s = 133. * 133.;
8251 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8252}
8253
8254const double StandardModel::getIntegrand_sigmaWithISR_up136(double x) const
8255{
8256 double s = 136. * 136.;
8257 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8258}
8259
8260const double StandardModel::getIntegrand_sigmaWithISR_up161(double x) const
8261{
8262 double s = 161. * 161.;
8263 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8264}
8265
8266const double StandardModel::getIntegrand_sigmaWithISR_up167(double x) const
8267{
8268 double s = 167. * 167.;
8269 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8270}
8271
8272const double StandardModel::getIntegrand_sigmaWithISR_up172(double x) const
8273{
8274 double s = 172. * 172.;
8275 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8276}
8277
8278const double StandardModel::getIntegrand_sigmaWithISR_up183(double x) const
8279{
8280 double s = 183. * 183.;
8281 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8282}
8283
8284const double StandardModel::getIntegrand_sigmaWithISR_up189(double x) const
8285{
8286 double s = 189. * 189.;
8287 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8288}
8289
8290const double StandardModel::getIntegrand_sigmaWithISR_up192(double x) const
8291{
8292 double s = 192. * 192.;
8293 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8294}
8295
8296const double StandardModel::getIntegrand_sigmaWithISR_up196(double x) const
8297{
8298 double s = 196. * 196.;
8299 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8300}
8301
8302const double StandardModel::getIntegrand_sigmaWithISR_up200(double x) const
8303{
8304 double s = 200. * 200.;
8305 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8306}
8307
8308const double StandardModel::getIntegrand_sigmaWithISR_up202(double x) const
8309{
8310 double s = 202. * 202.;
8311 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8312}
8313
8314const double StandardModel::getIntegrand_sigmaWithISR_up205(double x) const
8315{
8316 double s = 205. * 205.;
8317 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8318}
8319
8320const double StandardModel::getIntegrand_sigmaWithISR_up207(double x) const
8321{
8322 double s = 207. * 207.;
8323 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8324}
8325
8326
8327//down
8328
8329const double StandardModel::getIntegrand_sigmaWithISR_down130(double x) const
8330{
8331 double s = 130. * 130.;
8332 return (Integrand_sigmaWithISR_q(x, QCD::quark(DOWN), s));
8333}
8334
8335const double StandardModel::getIntegrand_sigmaWithISR_down133(double x) const
8336{
8337 double s = 133. * 133.;
8338 return (Integrand_sigmaWithISR_q(x, QCD::quark(DOWN), s));
8339}
8340
8341
8342const double StandardModel::getIntegrand_sigmaWithISR_down136(double x) const
8343{
8344 double s = 136. * 136.;
8345 return (Integrand_sigmaWithISR_q(x, QCD::quark(DOWN), s));
8346}
8347
8348const double StandardModel::getIntegrand_sigmaWithISR_down161(double x) const
8349{
8350 double s = 161. * 161.;
8351 return (Integrand_sigmaWithISR_q(x, QCD::quark(DOWN), s));
8352}
8353
8354const double StandardModel::getIntegrand_sigmaWithISR_down167(double x) const
8355{
8356 double s = 167. * 167.;
8357 return (Integrand_sigmaWithISR_q(x, QCD::quark(DOWN), s));
8358}
8359
8360const double StandardModel::getIntegrand_sigmaWithISR_down172(double x) const
8361{
8362 double s = 172. * 172.;
8363 return (Integrand_sigmaWithISR_q(x, QCD::quark(DOWN), s));
8364}
8365
8366const double StandardModel::getIntegrand_sigmaWithISR_down183(double x) const
8367{
8368 double s = 183. * 183.;
8369 return (Integrand_sigmaWithISR_q(x, QCD::quark(DOWN), s));
8370}
8371
8372const double StandardModel::getIntegrand_sigmaWithISR_down189(double x) const
8373{
8374 double s = 189. * 189.;
8375 return (Integrand_sigmaWithISR_q(x, QCD::quark(DOWN), s));
8376}
8377
8378const double StandardModel::getIntegrand_sigmaWithISR_down192(double x) const
8379{
8380 double s = 192. * 192.;
8381 return (Integrand_sigmaWithISR_q(x, QCD::quark(DOWN), s));
8382}
8383
8384const double StandardModel::getIntegrand_sigmaWithISR_down196(double x) const
8385{
8386 double s = 196. * 196.;
8387 return (Integrand_sigmaWithISR_q(x, QCD::quark(DOWN), s));
8388}
8389
8390const double StandardModel::getIntegrand_sigmaWithISR_down200(double x) const
8391{
8392 double s = 200. * 200.;
8393 return (Integrand_sigmaWithISR_q(x, QCD::quark(DOWN), s));
8394}
8395
8396const double StandardModel::getIntegrand_sigmaWithISR_down202(double x) const
8397{
8398 double s = 202. * 202.;
8399 return (Integrand_sigmaWithISR_q(x, QCD::quark(DOWN), s));
8400}
8401
8402const double StandardModel::getIntegrand_sigmaWithISR_down205(double x) const
8403{
8404 double s = 205. * 205.;
8405 return (Integrand_sigmaWithISR_q(x, QCD::quark(DOWN), s));
8406}
8407
8408const double StandardModel::getIntegrand_sigmaWithISR_down207(double x) const
8409{
8410 double s = 207. * 207.;
8411 return (Integrand_sigmaWithISR_q(x, QCD::quark(DOWN), s));
8412}
8413
8414
8415//charm
8416
8417
8418const double StandardModel::getIntegrand_sigmaWithISR_charm130(double x) const
8419{
8420 double s = 130. * 130.;
8421 return (Integrand_sigmaWithISR_q(x, QCD::quark(CHARM), s));
8422}
8423
8424const double StandardModel::getIntegrand_sigmaWithISR_charm133(double x) const
8425{
8426 double s = 133. * 133.;
8427 return (Integrand_sigmaWithISR_q(x, QCD::quark(CHARM), s));
8428}
8429
8430const double StandardModel::getIntegrand_sigmaWithISR_charm136(double x) const
8431{
8432 double s = 136. * 136.;
8433 return (Integrand_sigmaWithISR_q(x, QCD::quark(CHARM), s));
8434}
8435
8436const double StandardModel::getIntegrand_sigmaWithISR_charm161(double x) const
8437{
8438 double s = 161. * 161.;
8439 return (Integrand_sigmaWithISR_q(x, QCD::quark(CHARM), s));
8440}
8441
8442const double StandardModel::getIntegrand_sigmaWithISR_charm167(double x) const
8443{
8444 double s = 167. * 167.;
8445 return (Integrand_sigmaWithISR_q(x, QCD::quark(CHARM), s));
8446}
8447
8448const double StandardModel::getIntegrand_sigmaWithISR_charm172(double x) const
8449{
8450 double s = 172. * 172.;
8451 return (Integrand_sigmaWithISR_q(x, QCD::quark(CHARM), s));
8452}
8453
8454const double StandardModel::getIntegrand_sigmaWithISR_charm183(double x) const
8455{
8456 double s = 183. * 183.;
8457 return (Integrand_sigmaWithISR_q(x, QCD::quark(CHARM), s));
8458}
8459
8460const double StandardModel::getIntegrand_sigmaWithISR_charm189(double x) const
8461{
8462 double s = 189. * 189.;
8463 return (Integrand_sigmaWithISR_q(x, QCD::quark(CHARM), s));
8464}
8465
8466const double StandardModel::getIntegrand_sigmaWithISR_charm192(double x) const
8467{
8468 double s = 192. * 192.;
8469 return (Integrand_sigmaWithISR_q(x, QCD::quark(CHARM), s));
8470}
8471
8472const double StandardModel::getIntegrand_sigmaWithISR_charm196(double x) const
8473{
8474 double s = 196. * 196.;
8475 return (Integrand_sigmaWithISR_q(x, QCD::quark(CHARM), s));
8476}
8477
8478const double StandardModel::getIntegrand_sigmaWithISR_charm200(double x) const
8479{
8480 double s = 200. * 200.;
8481 return (Integrand_sigmaWithISR_q(x, QCD::quark(CHARM), s));
8482}
8483
8484const double StandardModel::getIntegrand_sigmaWithISR_charm202(double x) const
8485{
8486 double s = 202. * 202.;
8487 return (Integrand_sigmaWithISR_q(x, QCD::quark(CHARM), s));
8488}
8489
8490const double StandardModel::getIntegrand_sigmaWithISR_charm205(double x) const
8491{
8492 double s = 205. * 205.;
8493 return (Integrand_sigmaWithISR_q(x, QCD::quark(CHARM), s));
8494}
8495
8496const double StandardModel::getIntegrand_sigmaWithISR_charm207(double x) const
8497{
8498 double s = 207. * 207.;
8499 return (Integrand_sigmaWithISR_q(x, QCD::quark(CHARM), s));
8500}
8501
8502
8503//strange
8504
8505
8506const double StandardModel::getIntegrand_sigmaWithISR_strange130(double x) const
8507{
8508 double s = 130. * 130.;
8509 return (Integrand_sigmaWithISR_q(x, QCD::quark(STRANGE), s));
8510}
8511
8512const double StandardModel::getIntegrand_sigmaWithISR_strange133(double x) const
8513{
8514 double s = 133. * 133.;
8515 return (Integrand_sigmaWithISR_q(x, QCD::quark(STRANGE), s));
8516}
8517
8518const double StandardModel::getIntegrand_sigmaWithISR_strange136(double x) const
8519{
8520 double s = 136. * 136.;
8521 return (Integrand_sigmaWithISR_q(x, QCD::quark(STRANGE), s));
8522}
8523
8524const double StandardModel::getIntegrand_sigmaWithISR_strange161(double x) const
8525{
8526 double s = 161. * 161.;
8527 return (Integrand_sigmaWithISR_q(x, QCD::quark(STRANGE), s));
8528}
8529
8530const double StandardModel::getIntegrand_sigmaWithISR_strange167(double x) const
8531{
8532 double s = 167. * 167.;
8533 return (Integrand_sigmaWithISR_q(x, QCD::quark(STRANGE), s));
8534}
8535
8536const double StandardModel::getIntegrand_sigmaWithISR_strange172(double x) const
8537{
8538 double s = 172. * 172.;
8539 return (Integrand_sigmaWithISR_q(x, QCD::quark(STRANGE), s));
8540}
8541
8542const double StandardModel::getIntegrand_sigmaWithISR_strange183(double x) const
8543{
8544 double s = 183. * 183.;
8545 return (Integrand_sigmaWithISR_q(x, QCD::quark(STRANGE), s));
8546}
8547
8548const double StandardModel::getIntegrand_sigmaWithISR_strange189(double x) const
8549{
8550 double s = 189. * 189.;
8551 return (Integrand_sigmaWithISR_q(x, QCD::quark(STRANGE), s));
8552}
8553
8554const double StandardModel::getIntegrand_sigmaWithISR_strange192(double x) const
8555{
8556 double s = 192. * 192.;
8557 return (Integrand_sigmaWithISR_q(x, QCD::quark(STRANGE), s));
8558}
8559
8560const double StandardModel::getIntegrand_sigmaWithISR_strange196(double x) const
8561{
8562 double s = 196. * 196.;
8563 return (Integrand_sigmaWithISR_q(x, QCD::quark(STRANGE), s));
8564}
8565
8566const double StandardModel::getIntegrand_sigmaWithISR_strange200(double x) const
8567{
8568 double s = 200. * 200.;
8569 return (Integrand_sigmaWithISR_q(x, QCD::quark(STRANGE), s));
8570}
8571
8572const double StandardModel::getIntegrand_sigmaWithISR_strange202(double x) const
8573{
8574 double s = 202. * 202.;
8575 return (Integrand_sigmaWithISR_q(x, QCD::quark(STRANGE), s));
8576}
8577
8578const double StandardModel::getIntegrand_sigmaWithISR_strange205(double x) const
8579{
8580 double s = 205. * 205.;
8581 return (Integrand_sigmaWithISR_q(x, QCD::quark(STRANGE), s));
8582}
8583
8584const double StandardModel::getIntegrand_sigmaWithISR_strange207(double x) const
8585{
8586 double s = 207. * 207.;
8587 return (Integrand_sigmaWithISR_q(x, QCD::quark(STRANGE), s));
8588}
8589
8590
8591//bottom
8592
8593
8594const double StandardModel::getIntegrand_sigmaWithISR_bottom130(double x) const
8595{
8596 double s = 130. * 130.;
8597 return (Integrand_sigmaWithISR_q(x, QCD::quark(BOTTOM), s));
8598}
8599
8600const double StandardModel::getIntegrand_sigmaWithISR_bottom133(double x) const
8601{
8602 double s = 133. * 133.;
8603 return (Integrand_sigmaWithISR_q(x, QCD::quark(BOTTOM), s));
8604}
8605
8606const double StandardModel::getIntegrand_sigmaWithISR_bottom136(double x) const
8607{
8608 double s = 136. * 136.;
8609 return (Integrand_sigmaWithISR_q(x, QCD::quark(BOTTOM), s));
8610}
8611
8612const double StandardModel::getIntegrand_sigmaWithISR_bottom161(double x) const
8613{
8614 double s = 161. * 161.;
8615 return (Integrand_sigmaWithISR_q(x, QCD::quark(BOTTOM), s));
8616}
8617
8618const double StandardModel::getIntegrand_sigmaWithISR_bottom167(double x) const
8619{
8620 double s = 167. * 167.;
8621 return (Integrand_sigmaWithISR_q(x, QCD::quark(BOTTOM), s));
8622}
8623
8624const double StandardModel::getIntegrand_sigmaWithISR_bottom172(double x) const
8625{
8626 double s = 172. * 172.;
8627 return (Integrand_sigmaWithISR_q(x, QCD::quark(BOTTOM), s));
8628}
8629
8630const double StandardModel::getIntegrand_sigmaWithISR_bottom183(double x) const
8631{
8632 double s = 183. * 183.;
8633 return (Integrand_sigmaWithISR_q(x, QCD::quark(BOTTOM), s));
8634}
8635
8636const double StandardModel::getIntegrand_sigmaWithISR_bottom189(double x) const
8637{
8638 double s = 189. * 189.;
8639 return (Integrand_sigmaWithISR_q(x, QCD::quark(BOTTOM), s));
8640}
8641
8642const double StandardModel::getIntegrand_sigmaWithISR_bottom192(double x) const
8643{
8644 double s = 192. * 192.;
8645 return (Integrand_sigmaWithISR_q(x, QCD::quark(BOTTOM), s));
8646}
8647
8648const double StandardModel::getIntegrand_sigmaWithISR_bottom196(double x) const
8649{
8650 double s = 196. * 196.;
8651 return (Integrand_sigmaWithISR_q(x, QCD::quark(BOTTOM), s));
8652}
8653
8654const double StandardModel::getIntegrand_sigmaWithISR_bottom200(double x) const
8655{
8656 double s = 200. * 200.;
8657 return (Integrand_sigmaWithISR_q(x, QCD::quark(BOTTOM), s));
8658}
8659
8660const double StandardModel::getIntegrand_sigmaWithISR_bottom202(double x) const
8661{
8662 double s = 202. * 202.;
8663 return (Integrand_sigmaWithISR_q(x, QCD::quark(BOTTOM), s));
8664}
8665
8666const double StandardModel::getIntegrand_sigmaWithISR_bottom205(double x) const
8667{
8668 double s = 205. * 205.;
8669 return (Integrand_sigmaWithISR_q(x, QCD::quark(BOTTOM), s));
8670}
8671
8672const double StandardModel::getIntegrand_sigmaWithISR_bottom207(double x) const
8673{
8674 double s = 207. * 207.;
8675 return (Integrand_sigmaWithISR_q(x, QCD::quark(BOTTOM), s));
8676}
8677
8678
8679
8680
8681
8682const double StandardModel::Integrand_dsigmaBox_l(double cosTheta, const QCD::lepton l_flavor, const double s) const
8683{
8684 double ml = getLeptons(l_flavor).getMass();
8685 return ( myTwoFermionsLEP2->dsigma_l_box(l_flavor, ml, s, cosTheta, Mw(), Gamma_Z()) );
8686}
8687
8688const double StandardModel::getIntegrand_dsigmaBox_mu130(double x) const
8689{
8690 double s = 130. * 130.;
8691 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8692}
8693
8694const double StandardModel::getIntegrand_dsigmaBox_mu136(double x) const
8695{
8696 double s = 136. * 136.;
8697 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8698}
8699
8700const double StandardModel::getIntegrand_dsigmaBox_mu161(double x) const
8701{
8702 double s = 161. * 161.;
8703 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8704}
8705
8706const double StandardModel::getIntegrand_dsigmaBox_mu172(double x) const
8707{
8708 double s = 172. * 172.;
8709 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8710}
8711
8712const double StandardModel::getIntegrand_dsigmaBox_mu183(double x) const
8713{
8714 double s = 183. * 183.;
8715 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8716}
8717
8718const double StandardModel::getIntegrand_dsigmaBox_mu189(double x) const
8719{
8720 double s = 189. * 189.;
8721 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8722}
8723
8724const double StandardModel::getIntegrand_dsigmaBox_mu192(double x) const
8725{
8726 double s = 192. * 192.;
8727 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8728}
8729
8730const double StandardModel::getIntegrand_dsigmaBox_mu196(double x) const
8731{
8732 double s = 196. * 196.;
8733 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8734}
8735
8736const double StandardModel::getIntegrand_dsigmaBox_mu200(double x) const
8737{
8738 double s = 200. * 200.;
8739 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8740}
8741
8742const double StandardModel::getIntegrand_dsigmaBox_mu202(double x) const
8743{
8744 double s = 202. * 202.;
8745 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8746}
8747
8748const double StandardModel::getIntegrand_dsigmaBox_mu205(double x) const
8749{
8750 double s = 205. * 205.;
8751 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8752}
8753
8754const double StandardModel::getIntegrand_dsigmaBox_mu207(double x) const
8755{
8756 double s = 207. * 207.;
8757 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8758}
8759
8760
8761
8762
8763
8764const double StandardModel::getIntegrand_dsigmaBox_tau130(double x) const
8765{
8766 double s = 130. * 130.;
8767 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8768}
8769
8770const double StandardModel::getIntegrand_dsigmaBox_tau136(double x) const
8771{
8772 double s = 136. * 136.;
8773 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8774}
8775
8776const double StandardModel::getIntegrand_dsigmaBox_tau161(double x) const
8777{
8778 double s = 161. * 161.;
8779 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8780}
8781
8782const double StandardModel::getIntegrand_dsigmaBox_tau172(double x) const
8783{
8784 double s = 172. * 172.;
8785 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8786}
8787
8788const double StandardModel::getIntegrand_dsigmaBox_tau183(double x) const
8789{
8790 double s = 183. * 183.;
8791 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8792}
8793
8794const double StandardModel::getIntegrand_dsigmaBox_tau189(double x) const
8795{
8796 double s = 189. * 189.;
8797 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8798}
8799
8800const double StandardModel::getIntegrand_dsigmaBox_tau192(double x) const
8801{
8802 double s = 192. * 192.;
8803 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8804}
8805
8806const double StandardModel::getIntegrand_dsigmaBox_tau196(double x) const
8807{
8808 double s = 196. * 196.;
8809 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8810}
8811
8812const double StandardModel::getIntegrand_dsigmaBox_tau200(double x) const
8813{
8814 double s = 200. * 200.;
8815 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8816}
8817
8818const double StandardModel::getIntegrand_dsigmaBox_tau202(double x) const
8819{
8820 double s = 202. * 202.;
8821 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8822}
8823
8824const double StandardModel::getIntegrand_dsigmaBox_tau205(double x) const
8825{
8826 double s = 205. * 205.;
8827 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8828}
8829
8830const double StandardModel::getIntegrand_dsigmaBox_tau207(double x) const
8831{
8832 double s = 207. * 207.;
8833 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8834}
8835
8836
8837
8838
8839
8840
8841const double StandardModel::Integrand_dsigmaBox_q(double cosTheta, const QCD::quark q_flavor, const double s) const
8842{
8843 double mq = m_q(q_flavor, sqrt(s));
8844 return ( myTwoFermionsLEP2->dsigma_q_box(q_flavor, mq, s, cosTheta, Mw(), Gamma_Z()) );
8845}
8846
8847
8848
8849
8850//up
8851
8852
8853const double StandardModel::getIntegrand_dsigmaBox_up130(double x) const
8854{
8855 double s = 130. * 130.;
8856 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8857}
8858
8859const double StandardModel::getIntegrand_dsigmaBox_up133(double x) const
8860{
8861 double s = 133. * 133.;
8862 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8863}
8864
8865const double StandardModel::getIntegrand_dsigmaBox_up136(double x) const
8866{
8867 double s = 136. * 136.;
8868 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8869}
8870
8871const double StandardModel::getIntegrand_dsigmaBox_up161(double x) const
8872{
8873 double s = 161. * 161.;
8874 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8875}
8876
8877const double StandardModel::getIntegrand_dsigmaBox_up167(double x) const
8878{
8879 double s = 167. * 167.;
8880 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8881}
8882
8883const double StandardModel::getIntegrand_dsigmaBox_up172(double x) const
8884{
8885 double s = 172. * 172.;
8886 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8887}
8888
8889const double StandardModel::getIntegrand_dsigmaBox_up183(double x) const
8890{
8891 double s = 183. * 183.;
8892 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8893}
8894
8895const double StandardModel::getIntegrand_dsigmaBox_up189(double x) const
8896{
8897 double s = 189. * 189.;
8898 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8899}
8900
8901const double StandardModel::getIntegrand_dsigmaBox_up192(double x) const
8902{
8903 double s = 192. * 192.;
8904 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8905}
8906
8907const double StandardModel::getIntegrand_dsigmaBox_up196(double x) const
8908{
8909 double s = 196. * 196.;
8910 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8911}
8912
8913const double StandardModel::getIntegrand_dsigmaBox_up200(double x) const
8914{
8915 double s = 200. * 200.;
8916 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8917}
8918
8919const double StandardModel::getIntegrand_dsigmaBox_up202(double x) const
8920{
8921 double s = 202. * 202.;
8922 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8923}
8924
8925const double StandardModel::getIntegrand_dsigmaBox_up205(double x) const
8926{
8927 double s = 205. * 205.;
8928 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8929}
8930
8931const double StandardModel::getIntegrand_dsigmaBox_up207(double x) const
8932{
8933 double s = 207. * 207.;
8934 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8935}
8936
8937
8938//down
8939
8940const double StandardModel::getIntegrand_dsigmaBox_down130(double x) const
8941{
8942 double s = 130. * 130.;
8943 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8944}
8945
8946const double StandardModel::getIntegrand_dsigmaBox_down133(double x) const
8947{
8948 double s = 133. * 133.;
8949 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8950}
8951
8952const double StandardModel::getIntegrand_dsigmaBox_down136(double x) const
8953{
8954 double s = 136. * 136.;
8955 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8956}
8957
8958const double StandardModel::getIntegrand_dsigmaBox_down161(double x) const
8959{
8960 double s = 161. * 161.;
8961 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8962}
8963
8964const double StandardModel::getIntegrand_dsigmaBox_down167(double x) const
8965{
8966 double s = 167. * 167.;
8967 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8968}
8969
8970const double StandardModel::getIntegrand_dsigmaBox_down172(double x) const
8971{
8972 double s = 172. * 172.;
8973 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8974}
8975
8976const double StandardModel::getIntegrand_dsigmaBox_down183(double x) const
8977{
8978 double s = 183. * 183.;
8979 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8980}
8981
8982const double StandardModel::getIntegrand_dsigmaBox_down189(double x) const
8983{
8984 double s = 189. * 189.;
8985 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8986}
8987
8988const double StandardModel::getIntegrand_dsigmaBox_down192(double x) const
8989{
8990 double s = 192. * 192.;
8991 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8992}
8993
8994const double StandardModel::getIntegrand_dsigmaBox_down196(double x) const
8995{
8996 double s = 196. * 196.;
8997 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8998}
8999
9000const double StandardModel::getIntegrand_dsigmaBox_down200(double x) const
9001{
9002 double s = 200. * 200.;
9003 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
9004}
9005
9006const double StandardModel::getIntegrand_dsigmaBox_down202(double x) const
9007{
9008 double s = 202. * 202.;
9009 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
9010}
9011
9012const double StandardModel::getIntegrand_dsigmaBox_down205(double x) const
9013{
9014 double s = 205. * 205.;
9015 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
9016}
9017
9018const double StandardModel::getIntegrand_dsigmaBox_down207(double x) const
9019{
9020 double s = 207. * 207.;
9021 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
9022}
9023
9024
9025//charm
9026
9027
9028const double StandardModel::getIntegrand_dsigmaBox_charm130(double x) const
9029{
9030 double s = 130. * 130.;
9031 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9032}
9033
9034const double StandardModel::getIntegrand_dsigmaBox_charm133(double x) const
9035{
9036 double s = 133. * 133.;
9037 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9038}
9039
9040const double StandardModel::getIntegrand_dsigmaBox_charm136(double x) const
9041{
9042 double s = 136. * 136.;
9043 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9044}
9045
9046const double StandardModel::getIntegrand_dsigmaBox_charm161(double x) const
9047{
9048 double s = 161. * 161.;
9049 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9050}
9051
9052const double StandardModel::getIntegrand_dsigmaBox_charm167(double x) const
9053{
9054 double s = 167. * 167.;
9055 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9056}
9057
9058const double StandardModel::getIntegrand_dsigmaBox_charm172(double x) const
9059{
9060 double s = 172. * 172.;
9061 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9062}
9063
9064const double StandardModel::getIntegrand_dsigmaBox_charm183(double x) const
9065{
9066 double s = 183. * 183.;
9067 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9068}
9069
9070const double StandardModel::getIntegrand_dsigmaBox_charm189(double x) const
9071{
9072 double s = 189. * 189.;
9073 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9074}
9075
9076const double StandardModel::getIntegrand_dsigmaBox_charm192(double x) const
9077{
9078 double s = 192. * 192.;
9079 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9080}
9081
9082const double StandardModel::getIntegrand_dsigmaBox_charm196(double x) const
9083{
9084 double s = 196. * 196.;
9085 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9086}
9087
9088const double StandardModel::getIntegrand_dsigmaBox_charm200(double x) const
9089{
9090 double s = 200. * 200.;
9091 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9092}
9093
9094const double StandardModel::getIntegrand_dsigmaBox_charm202(double x) const
9095{
9096 double s = 202. * 202.;
9097 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9098}
9099
9100const double StandardModel::getIntegrand_dsigmaBox_charm205(double x) const
9101{
9102 double s = 205. * 205.;
9103 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9104}
9105
9106const double StandardModel::getIntegrand_dsigmaBox_charm207(double x) const
9107{
9108 double s = 207. * 207.;
9109 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9110}
9111
9112
9113//strange
9114
9115
9116const double StandardModel::getIntegrand_dsigmaBox_strange130(double x) const
9117{
9118 double s = 130. * 130.;
9119 return (Integrand_dsigmaBox_q(x, QCD::quark(STRANGE), s));
9120}
9121
9122const double StandardModel::getIntegrand_dsigmaBox_strange133(double x) const
9123{
9124 double s = 133. * 133.;
9125 return (Integrand_dsigmaBox_q(x, QCD::quark(STRANGE), s));
9126}
9127
9128const double StandardModel::getIntegrand_dsigmaBox_strange136(double x) const
9129{
9130 double s = 136. * 136.;
9131 return (Integrand_dsigmaBox_q(x, QCD::quark(STRANGE), s));
9132}
9133
9134const double StandardModel::getIntegrand_dsigmaBox_strange161(double x) const
9135{
9136 double s = 161. * 161.;
9137 return (Integrand_dsigmaBox_q(x, QCD::quark(STRANGE), s));
9138}
9139
9140const double StandardModel::getIntegrand_dsigmaBox_strange167(double x) const
9141{
9142 double s = 167. * 167.;
9143 return (Integrand_dsigmaBox_q(x, QCD::quark(STRANGE), s));
9144}
9145
9146
9147
9148const double StandardModel::getIntegrand_dsigmaBox_strange172(double x) const
9149{
9150 double s = 172. * 172.;
9151 return (Integrand_dsigmaBox_q(x, QCD::quark(STRANGE), s));
9152}
9153
9154const double StandardModel::getIntegrand_dsigmaBox_strange183(double x) const
9155{
9156 double s = 183. * 183.;
9157 return (Integrand_dsigmaBox_q(x, QCD::quark(STRANGE), s));
9158}
9159
9160const double StandardModel::getIntegrand_dsigmaBox_strange189(double x) const
9161{
9162 double s = 189. * 189.;
9163 return (Integrand_dsigmaBox_q(x, QCD::quark(STRANGE), s));
9164}
9165
9166const double StandardModel::getIntegrand_dsigmaBox_strange192(double x) const
9167{
9168 double s = 192. * 192.;
9169 return (Integrand_dsigmaBox_q(x, QCD::quark(STRANGE), s));
9170}
9171
9172const double StandardModel::getIntegrand_dsigmaBox_strange196(double x) const
9173{
9174 double s = 196. * 196.;
9175 return (Integrand_dsigmaBox_q(x, QCD::quark(STRANGE), s));
9176}
9177
9178const double StandardModel::getIntegrand_dsigmaBox_strange200(double x) const
9179{
9180 double s = 200. * 200.;
9181 return (Integrand_dsigmaBox_q(x, QCD::quark(STRANGE), s));
9182}
9183
9184const double StandardModel::getIntegrand_dsigmaBox_strange202(double x) const
9185{
9186 double s = 202. * 202.;
9187 return (Integrand_dsigmaBox_q(x, QCD::quark(STRANGE), s));
9188}
9189
9190const double StandardModel::getIntegrand_dsigmaBox_strange205(double x) const
9191{
9192 double s = 205. * 205.;
9193 return (Integrand_dsigmaBox_q(x, QCD::quark(STRANGE), s));
9194}
9195
9196const double StandardModel::getIntegrand_dsigmaBox_strange207(double x) const
9197{
9198 double s = 207. * 207.;
9199 return (Integrand_dsigmaBox_q(x, QCD::quark(STRANGE), s));
9200}
9201
9202
9203//bottom
9204
9205
9206const double StandardModel::getIntegrand_dsigmaBox_bottom130(double x) const
9207{
9208 double s = 130. * 130.;
9209 return (Integrand_dsigmaBox_q(x, QCD::quark(BOTTOM), s));
9210}
9211
9212const double StandardModel::getIntegrand_dsigmaBox_bottom133(double x) const
9213{
9214 double s = 133. * 133.;
9215 return (Integrand_dsigmaBox_q(x, QCD::quark(BOTTOM), s));
9216}
9217
9218const double StandardModel::getIntegrand_dsigmaBox_bottom136(double x) const
9219{
9220 double s = 136. * 136.;
9221 return (Integrand_dsigmaBox_q(x, QCD::quark(BOTTOM), s));
9222}
9223
9224const double StandardModel::getIntegrand_dsigmaBox_bottom161(double x) const
9225{
9226 double s = 161. * 161.;
9227 return (Integrand_dsigmaBox_q(x, QCD::quark(BOTTOM), s));
9228}
9229
9230const double StandardModel::getIntegrand_dsigmaBox_bottom167(double x) const
9231{
9232 double s = 167. * 167.;
9233 return (Integrand_dsigmaBox_q(x, QCD::quark(BOTTOM), s));
9234}
9235
9236const double StandardModel::getIntegrand_dsigmaBox_bottom172(double x) const
9237{
9238 double s = 172. * 172.;
9239 return (Integrand_dsigmaBox_q(x, QCD::quark(BOTTOM), s));
9240}
9241
9242const double StandardModel::getIntegrand_dsigmaBox_bottom183(double x) const
9243{
9244 double s = 183. * 183.;
9245 return (Integrand_dsigmaBox_q(x, QCD::quark(BOTTOM), s));
9246}
9247
9248const double StandardModel::getIntegrand_dsigmaBox_bottom189(double x) const
9249{
9250 double s = 189. * 189.;
9251 return (Integrand_dsigmaBox_q(x, QCD::quark(BOTTOM), s));
9252}
9253
9254const double StandardModel::getIntegrand_dsigmaBox_bottom192(double x) const
9255{
9256 double s = 192. * 192.;
9257 return (Integrand_dsigmaBox_q(x, QCD::quark(BOTTOM), s));
9258}
9259
9260const double StandardModel::getIntegrand_dsigmaBox_bottom196(double x) const
9261{
9262 double s = 196. * 196.;
9263 return (Integrand_dsigmaBox_q(x, QCD::quark(BOTTOM), s));
9264}
9265
9266const double StandardModel::getIntegrand_dsigmaBox_bottom200(double x) const
9267{
9268 double s = 200. * 200.;
9269 return (Integrand_dsigmaBox_q(x, QCD::quark(BOTTOM), s));
9270}
9271
9272const double StandardModel::getIntegrand_dsigmaBox_bottom202(double x) const
9273{
9274 double s = 202. * 202.;
9275 return (Integrand_dsigmaBox_q(x, QCD::quark(BOTTOM), s));
9276}
9277
9278const double StandardModel::getIntegrand_dsigmaBox_bottom205(double x) const
9279{
9280 double s = 205. * 205.;
9281 return (Integrand_dsigmaBox_q(x, QCD::quark(BOTTOM), s));
9282}
9283
9284const double StandardModel::getIntegrand_dsigmaBox_bottom207(double x) const
9285{
9286 double s = 207. * 207.;
9287 return (Integrand_dsigmaBox_q(x, QCD::quark(BOTTOM), s));
9288}
9289
9290
9291
9292
9293
9294
9295
9296
9297
9298
9299
9300
9301
9302const double StandardModel::Integrand_AFBnumeratorWithISR_l(double x, const QCD::lepton l_flavor, const double s) const
9303{
9304 double sprime = (1.0 - x)*s;
9305 double Ncf = 1.0;
9306 double ml = getLeptons(l_flavor).getMass();
9307 double G3prime = myTwoFermionsLEP2->G_3prime_l(l_flavor, ml, sprime, Mw(), Gamma_Z(),flagLEP2[Weak]);
9308 double H = myTwoFermionsLEP2->H_ISR_FB(x, s);
9309
9310 return ( M_PI*ale*ale*Ncf*H*G3prime/sprime );
9311}
9312
9313
9314 const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu130(double x) const
9315{
9316 double s = 130. * 130.;
9317 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(MU), s));
9318}
9319
9320const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu136(double x) const
9321{
9322 double s = 136. * 136.;
9323 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(MU), s));
9324}
9325
9326const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu161(double x) const
9327{
9328 double s = 161. * 161.;
9329 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(MU), s));
9330}
9331
9332const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu172(double x) const
9333{
9334 double s = 172. * 172.;
9335 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(MU), s));
9336}
9337
9338const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu183(double x) const
9339{
9340 double s = 183. * 183.;
9341 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(MU), s));
9342}
9343
9344const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu189(double x) const
9345{
9346 double s = 189. * 189.;
9347 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(MU), s));
9348}
9349
9350const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu192(double x) const
9351{
9352 double s = 192. * 192.;
9353 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(MU), s));
9354}
9355
9356const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu196(double x) const
9357{
9358 double s = 196. * 196.;
9359 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(MU), s));
9360}
9361
9362const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu200(double x) const
9363{
9364 double s = 200. * 200.;
9365 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(MU), s));
9366}
9367
9368const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu202(double x) const
9369{
9370 double s = 202. * 202.;
9371 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(MU), s));
9372}
9373
9374const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu205(double x) const
9375{
9376 double s = 205. * 205.;
9377 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(MU), s));
9378}
9379
9380const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu207(double x) const
9381{
9382 double s = 207. * 207.;
9383 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(MU), s));
9384}
9385
9386
9387const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau130(double x) const
9388{
9389 double s = 130. * 130.;
9390 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(TAU), s));
9391}
9392
9393const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau136(double x) const
9394{
9395 double s = 136. * 136.;
9396 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(TAU), s));
9397}
9398
9399const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau161(double x) const
9400{
9401 double s = 161. * 161.;
9402 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(TAU), s));
9403}
9404
9405const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau172(double x) const
9406{
9407 double s = 172. * 172.;
9408 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(TAU), s));
9409}
9410
9411const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau183(double x) const
9412{
9413 double s = 183. * 183.;
9414 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(TAU), s));
9415}
9416
9417const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau189(double x) const
9418{
9419 double s = 189. * 189.;
9420 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(TAU), s));
9421}
9422
9423const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau192(double x) const
9424{
9425 double s = 192. * 192.;
9426 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(TAU), s));
9427}
9428
9429const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau196(double x) const
9430{
9431 double s = 196. * 196.;
9432 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(TAU), s));
9433}
9434
9435const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau200(double x) const
9436{
9437 double s = 200. * 200.;
9438 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(TAU), s));
9439}
9440
9441const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau202(double x) const
9442{
9443 double s = 202. * 202.;
9444 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(TAU), s));
9445}
9446
9447const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau205(double x) const
9448{
9449 double s = 205. * 205.;
9450 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(TAU), s));
9451}
9452
9453const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau207(double x) const
9454{
9455 double s = 207. * 207.;
9456 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(TAU), s));
9457}
9458
9459
9460
9461const double StandardModel::Integrand_AFBnumeratorWithISR_q(double x, const QCD::quark q_flavor, const double s) const
9462{
9463 double sprime = (1.0 - x)*s;
9464 double Ncf = 3.0;
9465 double mq = m_q(q_flavor, sqrt(s));
9466 double G3prime = myTwoFermionsLEP2->G_3prime_q(q_flavor, mq, sprime, Mw(), Gamma_Z(),flagLEP2[Weak]);
9467 double H = myTwoFermionsLEP2->H_ISR_FB(x, s);
9468
9469 if (flagLEP2[QCDFSR])
9470 G3prime *= myTwoFermionsLEP2->QCD_FSR_forAFB(q_flavor, mq, sprime);
9471
9472 return ( M_PI*ale*ale*Ncf*H*G3prime/sprime );
9473}
9474
9475
9476const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm133(double x) const
9477{
9478 double s = 133. * 133.;
9479 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(CHARM), s));
9480}
9481
9482const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm167(double x) const
9483{
9484 double s = 167. * 167.;
9485 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(CHARM), s));
9486}
9487
9488const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm172(double x) const
9489{
9490 double s = 172. * 172.;
9491 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(CHARM), s));
9492}
9493
9494const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm183(double x) const
9495{
9496 double s = 183. * 183.;
9497 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(CHARM), s));
9498}
9499
9500const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm189(double x) const
9501{
9502 double s = 189. * 189.;
9503 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(CHARM), s));
9504}
9505
9506const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm192(double x) const
9507{
9508 double s = 192. * 192.;
9509 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(CHARM), s));
9510}
9511
9512const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm196(double x) const
9513{
9514 double s = 196. * 196.;
9515 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(CHARM), s));
9516}
9517
9518const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm200(double x) const
9519{
9520 double s = 200. * 200.;
9521 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(CHARM), s));
9522}
9523
9524const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm202(double x) const
9525{
9526 double s = 202. * 202.;
9527 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(CHARM), s));
9528}
9529
9530const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm205(double x) const
9531{
9532 double s = 205. * 205.;
9533 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(CHARM), s));
9534}
9535
9536const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm207(double x) const
9537{
9538 double s = 207. * 207.;
9539 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(CHARM), s));
9540}
9541
9542
9543
9544
9545const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom133(double x) const
9546{
9547 double s = 133. * 133.;
9548 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(BOTTOM), s));
9549}
9550
9551const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom167(double x) const
9552{
9553 double s = 167. * 167.;
9554 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(BOTTOM), s));
9555}
9556
9557const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom172(double x) const
9558{
9559 double s = 172. * 172.;
9560 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(BOTTOM), s));
9561}
9562
9563const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom183(double x) const
9564{
9565 double s = 183. * 183.;
9566 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(BOTTOM), s));
9567}
9568
9569const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom189(double x) const
9570{
9571 double s = 189. * 189.;
9572 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(BOTTOM), s));
9573}
9574
9575const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom192(double x) const
9576{
9577 double s = 192. * 192.;
9578 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(BOTTOM), s));
9579}
9580
9581const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom196(double x) const
9582{
9583 double s = 196. * 196.;
9584 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(BOTTOM), s));
9585}
9586
9587const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom200(double x) const
9588{
9589 double s = 200. * 200.;
9590 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(BOTTOM), s));
9591}
9592
9593const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom202(double x) const
9594{
9595 double s = 202. * 202.;
9596 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(BOTTOM), s));
9597}
9598
9599const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom205(double x) const
9600{
9601 double s = 205. * 205.;
9602 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(BOTTOM), s));
9603}
9604
9605const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom207(double x) const
9606{
9607 double s = 207. * 207.;
9608 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(BOTTOM), s));
9609}
9610
9611
9612
9613// LEP2 differential observables
9614
9615const double StandardModel::LEP2dsigmadcosE(const double s, const double cos) const
9616{
9617 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
9618 if (!IsFlagNoApproximateGammaZ()){
9619
9620 /* SM contribution with the approximate formula */
9621 return (myApproximateFormulae->LEP2dsigmadcosEApprox(s, cos));
9622
9623 } else {
9624 throw std::runtime_error("ERROR: StandardModel::LEP2dsigmadcosE only implemented via semi-analytical approx");
9625 }
9626}
9627
9628const double StandardModel::LEP2dsigmadcosMu(double s, double cos) const
9629{
9630 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
9631 if (!IsFlagNoApproximateGammaZ()){
9632
9633 /* SM contribution with the approximate formula */
9634 return (myApproximateFormulae->LEP2dsigmadcosMuApprox(s, cos));
9635
9636 } else {
9637 throw std::runtime_error("ERROR: StandardModel::LEP2dsigmadcosMu only implemented via semi-analytical approx");
9638 }
9639}
9640
9641const double StandardModel::LEP2dsigmadcosTau(double s, double cos) const
9642{
9643 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
9644 if (!IsFlagNoApproximateGammaZ()){
9645
9646 /* SM contribution with the approximate formula */
9647 return (myApproximateFormulae->LEP2dsigmadcosTauApprox(s, cos));
9648
9649 } else {
9650 throw std::runtime_error("ERROR: StandardModel::LEP2dsigmadcosTau only implemented via semi-analytical approx");
9651 }
9652}
9653
9654
9655// LEP2 differential observables: Defined in bins. SM prediction given already by the above
9656
9657const double StandardModel::LEP2dsigmadcosBinE(const double s, const double cos, const double cosmin, const double cosmax) const
9658{
9659 return LEP2dsigmadcosE(s, cos);
9660}
9661
9662const double StandardModel::LEP2dsigmadcosBinMu(double s, double cos, const double cosmin, const double cosmax) const
9663{
9664 return LEP2dsigmadcosMu(s, cos);
9665}
9666
9667const double StandardModel::LEP2dsigmadcosBinTau(double s, double cos, const double cosmin, const double cosmax) const
9668{
9669 return LEP2dsigmadcosTau(s, cos);
9670}
9671
9672
9673/* END: REMOVE FROM THE PACKAGE */
DPars
std::map< std::string, double > DPars
Definition: Minimal.cpp:11
FULLNNNLO
@ FULLNNNLO
Definition: OrderScheme.h:40
NNLO
@ NNLO
Definition: OrderScheme.h:36
LO
@ LO
Definition: OrderScheme.h:34
NNNLO
@ NNNLO
Definition: OrderScheme.h:37
NLO
@ NLO
Definition: OrderScheme.h:35
FULLNNLO
@ FULLNNLO
Definition: OrderScheme.h:39
FULLNLO
@ FULLNLO
Definition: OrderScheme.h:38
AFBbottom
An observable class for the forward-backward asymmetry in at the pole.
Definition: AFBbottom.h:39
AFBcharm
An observable class for the forward-backward asymmetry in at the pole.
Definition: AFBcharm.h:32
AFBtau
An observable class for the forward-backward asymmetry in at the pole.
Definition: AFBlepton.h:160
CKM::computeCKMwithWolfenstein
void computeCKMwithWolfenstein(double Lambda_v, double A_v, double Rho_v, double Eta_v)
A set method to calculate the CKM matrix from Wolfenstein parameters.
Definition: CKM.cpp:13
CKM::getV_ud
const gslpp::complex getV_ud() const
A member for returning the value of the CKM element .
Definition: CKM.h:202
CKM::getV_us
const gslpp::complex getV_us() const
A member for returning the value of the CKM element .
Definition: CKM.h:211
CKM::computeGamma
const double computeGamma() const
The CKM angle .
Definition: CKM.cpp:125
CKM::getV_cb
const gslpp::complex getV_cb() const
A member for returning the value of the CKM element .
Definition: CKM.h:247
CKM::getV_ub
const gslpp::complex getV_ub() const
A member for returning the value of the CKM element .
Definition: CKM.h:220
CKM::getCKM
const gslpp::matrix< gslpp::complex > getCKM() const
A member for returning the CKM matrix.
Definition: CKM.h:59
CKM::getA
const double getA() const
A member for returning the value of the Wolfenstein parameter .
Definition: CKM.h:97
CKM::computeCKM
void computeCKM(double Vus_v, double Vcb_v, double Vub_v, double gamma_v, bool useVud=false)
A set method to calculate the CKM matrix from CKM elements and .
Definition: CKM.cpp:86
CKM::getRhoBar
const double getRhoBar() const
A member for returning the value of the Wolfenstein parameter .
Definition: CKM.h:70
CKM::getLambda
const double getLambda() const
A member for returning the value of the Wolfenstein parameter .
Definition: CKM.h:88
CKM::getEtaBar
const double getEtaBar() const
A member for returning the value of the Wolfenstein parameter .
Definition: CKM.h:79
EWSMApproximateFormulae
A class for approximate formulae of the EW precision observables.
Definition: EWSMApproximateFormulae.h:33
EWSMApproximateFormulae::LEP2AFBmuApprox
double LEP2AFBmuApprox(const double s) const
The forward-backward asymmetry at LEP2.
Definition: EWSMApproximateFormulae.cpp:1806
EWSMApproximateFormulae::LEThetaLnuNApprox
double LEThetaLnuNApprox() const
The effective neutrino nucleon LH parameter: ThetaLnuN.
Definition: EWSMApproximateFormulae.cpp:6012
EWSMApproximateFormulae::LEgAnueApprox
double LEgAnueApprox() const
The effective (muon) neutrino-electron axial-vector coupling: gAnue.
Definition: EWSMApproximateFormulae.cpp:6096
EWSMApproximateFormulae::LEP2AFBtauApprox
double LEP2AFBtauApprox(const double s) const
The forward-backward asymmetry at LEP2.
Definition: EWSMApproximateFormulae.cpp:2132
EWSMApproximateFormulae::LEP2sigmaHadronApprox
double LEP2sigmaHadronApprox(const double s) const
The cross section at LEP2.
Definition: EWSMApproximateFormulae.cpp:2295
EWSMApproximateFormulae::LEP2dsigmadcosTauApprox
double LEP2dsigmadcosTauApprox(const double s, const double cos) const
The differential cross section at LEP2.
Definition: EWSMApproximateFormulae.cpp:4902
EWSMApproximateFormulae::sin2thetaEff
double sin2thetaEff(const Particle p) const
The value of the effective weak mixing anlge for a given fermion.
Definition: EWSMApproximateFormulae.h:83
EWSMApproximateFormulae::Mw
double Mw() const
The -boson mass with the full two-loop EW corrections.
Definition: EWSMApproximateFormulae.cpp:23
EWSMApproximateFormulae::sin2thetaEff_b_full
double sin2thetaEff_b_full() const
with the full two-loop EW corrections.
Definition: EWSMApproximateFormulae.cpp:1540
EWSMApproximateFormulae::LEgVnueApprox
double LEgVnueApprox() const
The effective (muon) neutrino-electron vector coupling: gVnue.
Definition: EWSMApproximateFormulae.cpp:6068
EWSMApproximateFormulae::sin2thetaEff_l_full
double sin2thetaEff_l_full() const
with the full two-loop EW corrections.
Definition: EWSMApproximateFormulae.cpp:1590
EWSMApproximateFormulae::LEgLnuN2Approx
double LEgLnuN2Approx() const
The effective neutrino nucleon LH coupling: gLnuN2.
Definition: EWSMApproximateFormulae.cpp:5956
EWSMApproximateFormulae::X_full
double X_full(const std::string observable) const
, , , , , , , , , , , or .
Definition: EWSMApproximateFormulae.cpp:1227
EWSMApproximateFormulae::LEP2dsigmadcosMuApprox
double LEP2dsigmadcosMuApprox(const double s, const double cos) const
The differential cross section at LEP2.
Definition: EWSMApproximateFormulae.cpp:3851
EWSMApproximateFormulae::dAlpha5hMw
double dAlpha5hMw() const
The value of obtained from the -boson mass, using the full two-loop EW corrections.
Definition: EWSMApproximateFormulae.cpp:74
EWSMApproximateFormulae::LEP2dsigmadcosEApprox
double LEP2dsigmadcosEApprox(const double s, const double cos) const
The differential cross section at LEP2.
Definition: EWSMApproximateFormulae.cpp:2461
EWSMApproximateFormulae::LEThetaRnuNApprox
double LEThetaRnuNApprox() const
The effective neutrino nucleon RH parameter: ThetaRnuN.
Definition: EWSMApproximateFormulae.cpp:6040
EWSMApproximateFormulae::LEP2sigmaTauApprox
double LEP2sigmaTauApprox(const double s) const
The cross section at LEP2.
Definition: EWSMApproximateFormulae.cpp:1969
EWSMApproximateFormulae::DeltaR_TwoLoopEW_rem
double DeltaR_TwoLoopEW_rem(const double Mw_i) const
.
Definition: EWSMApproximateFormulae.cpp:310
EWSMApproximateFormulae::LEP2sigmaMuApprox
double LEP2sigmaMuApprox(const double s) const
The cross section at LEP2.
Definition: EWSMApproximateFormulae.cpp:1643
EWSMApproximateFormulae::LEgRnuN2Approx
double LEgRnuN2Approx() const
The effective neutrino nucleon RH coupling: gRnuN2.
Definition: EWSMApproximateFormulae.cpp:5984
EWSMOneLoopEW
A class for one-loop corrections to the EW precision observables.
Definition: EWSMOneLoopEW.h:105
EWSMOneLoopEW::deltaKappa_rem_f
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
Definition: EWSMOneLoopEW.cpp:143
EWSMOneLoopEW::rho_GammaW
double rho_GammaW(const Particle fi, const Particle fj, const double Mw_i) const
EW radiative corrections to the width of , denoted as .
Definition: EWSMOneLoopEW.cpp:190
EWSMOneLoopEW::DeltaRbar_rem
double DeltaRbar_rem(const double Mw_i) const
.
Definition: EWSMOneLoopEW.cpp:73
EWSMOneLoopEW::DeltaR_rem
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
Definition: EWSMOneLoopEW.cpp:49
EWSMOneLoopEW::FZ
gslpp::complex FZ(const double s, const double Mw_i) const
The unified form factor .
Definition: EWSMOneLoopEW.cpp:1065
EWSMOneLoopEW::DeltaAlpha_t
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .
Definition: EWSMOneLoopEW.cpp:35
EWSMOneLoopEW::DeltaRho
double DeltaRho(const double Mw_i) const
Leading one-loop contribution of to , denoted as .
Definition: EWSMOneLoopEW.cpp:43
EWSMOneLoopEW::DeltaAlpha_l
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .
Definition: EWSMOneLoopEW.cpp:19
EWSMOneLoopEW::FW
gslpp::complex FW(const double s, const Particle f, const double Mw_i) const
The unified form factor for .
Definition: EWSMOneLoopEW.cpp:1070
EWSMOneLoopEW::deltaRho_rem_f
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
Definition: EWSMOneLoopEW.cpp:113
EWSMThreeLoopEW2QCD
A class for three-loop corrections to the EW precision observables.
Definition: EWSMThreeLoopEW2QCD.h:34
EWSMThreeLoopEW2QCD::DeltaAlpha_l
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .
Definition: EWSMThreeLoopEW2QCD.cpp:19
EWSMThreeLoopEW2QCD::DeltaRho
double DeltaRho(const double Mw_i) const
Leading three-loop contribution of to , denoted as .
Definition: EWSMThreeLoopEW2QCD.cpp:29
EWSMThreeLoopEW2QCD::DeltaR_rem
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
Definition: EWSMThreeLoopEW2QCD.cpp:63
EWSMThreeLoopEW2QCD::deltaRho_rem_f
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
Definition: EWSMThreeLoopEW2QCD.cpp:68
EWSMThreeLoopEW2QCD::DeltaAlpha_t
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .
Definition: EWSMThreeLoopEW2QCD.cpp:24
EWSMThreeLoopEW2QCD::deltaKappa_rem_f
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
Definition: EWSMThreeLoopEW2QCD.cpp:74
EWSMThreeLoopEW
A class for three-loop corrections to the EW precision observables.
Definition: EWSMThreeLoopEW.h:35
EWSMThreeLoopEW::DeltaRho
double DeltaRho(const double Mw_i) const
Leading three-loop contribution of to , denoted as .
Definition: EWSMThreeLoopEW.cpp:70
EWSMThreeLoopEW::DeltaAlpha_t
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .
Definition: EWSMThreeLoopEW.cpp:65
EWSMThreeLoopEW::DeltaAlpha_l
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .
Definition: EWSMThreeLoopEW.cpp:19
EWSMThreeLoopEW::deltaKappa_rem_f
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
Definition: EWSMThreeLoopEW.cpp:120
EWSMThreeLoopEW::DeltaR_rem
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
Definition: EWSMThreeLoopEW.cpp:109
EWSMThreeLoopEW::deltaRho_rem_f
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
Definition: EWSMThreeLoopEW.cpp:114
EWSMThreeLoopQCD
A class for three-loop corrections to the EW precision observables.
Definition: EWSMThreeLoopQCD.h:33
EWSMThreeLoopQCD::DeltaR_rem
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
Definition: EWSMThreeLoopQCD.cpp:48
EWSMThreeLoopQCD::DeltaAlpha_t
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .
Definition: EWSMThreeLoopQCD.cpp:23
EWSMThreeLoopQCD::DeltaRho
double DeltaRho(const double Mw_i) const
Leading three-loop QCD contribution of to , denoted as .
Definition: EWSMThreeLoopQCD.cpp:42
EWSMThreeLoopQCD::deltaKappa_rem_f
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
Definition: EWSMThreeLoopQCD.cpp:72
EWSMThreeLoopQCD::deltaRho_rem_f
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
Definition: EWSMThreeLoopQCD.cpp:66
EWSMThreeLoopQCD::DeltaAlpha_l
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .
Definition: EWSMThreeLoopQCD.cpp:18
EWSMTwoFermionsLEP2
A class for the form factors , and in the processes at LEP-II.
Definition: EWSMTwoFermionsLEP2.h:25
EWSMTwoFermionsLEP2::dsigma_q_box
double dsigma_q_box(const QCD::quark q, const double mf, const double s, const double cosTheta, const double Mw, const double GammaZ) const
Definition: EWSMTwoFermionsLEP2.cpp:1191
EWSMTwoFermionsLEP2::G_3prime_l
double G_3prime_l(const QCD::lepton l, const double mf, const double s, const double Mw, const double GammaZ, const bool bWeak) const
Definition: EWSMTwoFermionsLEP2.cpp:1319
EWSMTwoFermionsLEP2::sigma_q
double sigma_q(const QCD::quark q, const double mf, const double s, const double Mw, const double GammaZ, const bool bWeak) const
Definition: EWSMTwoFermionsLEP2.cpp:1220
EWSMTwoFermionsLEP2::QED_FSR_forSigma
double QED_FSR_forSigma(const double s, const double Qf) const
Definition: EWSMTwoFermionsLEP2.cpp:1280
EWSMTwoFermionsLEP2::AFB_q
double AFB_q(const QCD::quark q, const double mf, const double s, const double Mw, const double GammaZ, const bool bWeak) const
Definition: EWSMTwoFermionsLEP2.cpp:1249
EWSMTwoFermionsLEP2::QCD_FSR_forAFB
double QCD_FSR_forAFB(const QCD::quark q, const double mf, const double s) const
Definition: EWSMTwoFermionsLEP2.cpp:1273
EWSMTwoFermionsLEP2::QCD_FSR_forSigma
double QCD_FSR_forSigma(const double s) const
Definition: EWSMTwoFermionsLEP2.cpp:1267
EWSMTwoFermionsLEP2::AFB_l
double AFB_l(const QCD::lepton l, const double mf, const double s, const double Mw, const double GammaZ, const bool bWeak) const
Definition: EWSMTwoFermionsLEP2.cpp:1238
EWSMTwoFermionsLEP2::sigma_l
double sigma_l(const QCD::lepton l, const double mf, const double s, const double Mw, const double GammaZ, const bool bWeak) const
Definition: EWSMTwoFermionsLEP2.cpp:1209
EWSMTwoFermionsLEP2::H_ISR_FB
double H_ISR_FB(const double x, const double s) const
Definition: EWSMTwoFermionsLEP2.cpp:1303
EWSMTwoFermionsLEP2::dsigma_l_box
double dsigma_l_box(const QCD::lepton l, const double mf, const double s, const double cosTheta, const double Mw, const double GammaZ) const
Definition: EWSMTwoFermionsLEP2.cpp:1180
EWSMTwoFermionsLEP2::G_3prime_q
double G_3prime_q(const QCD::quark q, const double mf, const double s, const double Mw, const double GammaZ, const bool bWeak) const
Definition: EWSMTwoFermionsLEP2.cpp:1333
EWSMTwoFermionsLEP2::H_ISR
double H_ISR(const double x, const double s) const
Definition: EWSMTwoFermionsLEP2.cpp:1289
EWSMTwoLoopEW
A class for two-loop corrections to the EW precision observables.
Definition: EWSMTwoLoopEW.h:57
EWSMTwoLoopEW::deltaRho_rem_f
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
Definition: EWSMTwoLoopEW.cpp:96
EWSMTwoLoopEW::DeltaRho
double DeltaRho(const double Mw_i) const
Leading two-loop contribution of to , denoted as .
Definition: EWSMTwoLoopEW.cpp:54
EWSMTwoLoopEW::DeltaAlpha_t
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .
Definition: EWSMTwoLoopEW.cpp:49
EWSMTwoLoopEW::tau_2
double tau_2() const
The function .
Definition: EWSMTwoLoopEW.cpp:151
EWSMTwoLoopEW::DeltaAlpha_l
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .
Definition: EWSMTwoLoopEW.cpp:23
EWSMTwoLoopEW::DeltaR_rem
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
Definition: EWSMTwoLoopEW.cpp:81
EWSMTwoLoopEW::deltaKappa_rem_f
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
Definition: EWSMTwoLoopEW.cpp:115
EWSMTwoLoopQCD
A class for two-loop corrections to the EW precision observables.
Definition: EWSMTwoLoopQCD.h:55
EWSMTwoLoopQCD::DeltaAlpha_t
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .
Definition: EWSMTwoLoopQCD.cpp:25
EWSMTwoLoopQCD::DeltaR_rem
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
Definition: EWSMTwoLoopQCD.cpp:44
EWSMTwoLoopQCD::deltaRho_rem_f
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
Definition: EWSMTwoLoopQCD.cpp:51
EWSMTwoLoopQCD::DeltaRho
double DeltaRho(const double Mw_i) const
Leading two-loop QCD contribution of to , denoted as .
Definition: EWSMTwoLoopQCD.cpp:38
EWSMTwoLoopQCD::deltaKappa_rem_f
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
Definition: EWSMTwoLoopQCD.cpp:58
EWSMTwoLoopQCD::DeltaAlpha_l
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .
Definition: EWSMTwoLoopQCD.cpp:20
EWSMcache
A class for cache variables used in computing radiative corrections to the EW precision observables.
Definition: EWSMcache.h:40
EWSMcache::a_f
double a_f(const Particle f) const
The tree-level axial-vector coupling for , denoted as .
Definition: EWSMcache.h:301
EWSMcache::getZeta4
double getZeta4() const
A get method to access the value of the zeta function .
Definition: EWSMcache.h:155
EWSMcache::v_f
double v_f(const Particle f, const double Mw_i) const
The tree-level vector coupling for , denoted as .
Definition: EWSMcache.h:290
EWSMcache::delta_f
double delta_f(const Particle f, const double Mw_i) const
.
Definition: EWSMcache.h:323
EWSMcache::getZeta5
double getZeta5() const
A get method to access the value of the zeta function .
Definition: EWSMcache.h:164
EWSMcache::getZeta3
double getZeta3() const
A get method to access the value of the zeta function .
Definition: EWSMcache.h:146
EWSMcache::Xt_GF
double Xt_GF() const
The quantity with the coupling .
Definition: EWSMcache.h:343
EWSMcache::alsMt
double alsMt() const
The strong coupling at NNLO.
Definition: EWSMcache.h:378
EWSMcache::setFlagCacheInEWSMcache
void setFlagCacheInEWSMcache(bool FlagCacheInEWSMcache)
A set method to change the model flag CacheInEWSMcache in StandardModel.
Definition: EWSMcache.h:83
EWSMcache::mf
double mf(const Particle f, const double mu=0.0, const orders order=FULLNNLO) const
The mass of an SM fermion.
Definition: EWSMcache.cpp:49
EWSMcache::getZeta2
double getZeta2() const
A get method to access the value of the zeta function .
Definition: EWSMcache.h:137
Flavour::setSMupdated
void setSMupdated() const
a member used for the caching for .
Definition: Flavour.cpp:379
Flavour::setFlag
bool setFlag(const std::string name, const bool value)
Definition: Flavour.cpp:38
LeptonFlavour
The parent class in LeptonFlavour for calculating all the Wilson coefficients for various Lepton Flav...
Definition: LeptonFlavour.h:26
Model::addMissingModelParameter
void addMissingModelParameter(const std::string &missingParameterName)
Definition: Model.h:250
Model::isModelSUSY
bool isModelSUSY() const
Definition: Model.h:182
Model::ModelParamMap
std::map< std::string, std::reference_wrapper< const double > > ModelParamMap
Definition: Model.h:280
Model::setModelInitialized
void setModelInitialized(bool ModelInitialized)
A set method to fix the failure or success of the initialization of the model.
Definition: Model.h:145
Model::IsModelInitialized
bool IsModelInitialized() const
A method to check if the model is initialized.
Definition: Model.h:136
Model::name
std::string name
The name of the model.
Definition: Model.h:285
Model::setModelName
void setModelName(const std::string name)
A method to set the name of the model.
Definition: Model.h:50
Model::UpdateError
bool UpdateError
A boolean set to false if update is successful.
Definition: Model.h:272
Model::raiseMissingModelParameterCount
void raiseMissingModelParameterCount()
Definition: Model.h:260
Mw
An observable class for the -boson mass.
Definition: Mw.h:22
PMNS::computePMNS
void computePMNS(double s12_v, double s13_v, double s23_v, double delta_v, double alpha21_v, double alpha31_v)
A set method to calculate the PMNS matrix from PMNS parameters.
Definition: PMNS.cpp:13
PMNS::getPMNS
gslpp::matrix< gslpp::complex > getPMNS() const
A member for returning the PMNS matrix.
Definition: PMNS.h:42
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::getMass
const double & getMass() const
A get method to access the particle mass.
Definition: Particle.h:61
Particle::getName
std::string getName() const
Definition: Particle.h:147
Particle::setMass
void setMass(double mass)
A set method to fix the particle mass.
Definition: Particle.h:70
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
A class for parameters related to QCD, hadrons and quarks.
Definition: QCD.h:304
QCD::CheckParameters
virtual bool CheckParameters(const std::map< std::string, double > &DPars)
A method to check if all the mandatory parameters for QCD have been provided in model initialization.
Definition: QCD.cpp:421
QCD::requireYu
bool requireYu
Switch for generating the Yukawa couplings to the up-type quarks.
Definition: QCD.h:1012
QCD::mut
double mut
The threshold between six- and five-flavour theory in GeV.
Definition: QCD.h:1021
QCD::CF
double CF
Definition: QCD.h:1026
QCD::PostUpdate
virtual bool PostUpdate()
The post-update method for QCD.
Definition: QCD.cpp:158
QCD::Beta2
const double Beta2(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:611
QCD::zeta2
double zeta2
computed with the GSL.
Definition: QCD.h:1032
QCD::Nc
double Nc
The number of colours.
Definition: QCD.h:1025
QCD::zeta3
double zeta3
computed with the GSL.
Definition: QCD.h:1033
QCD::muc
double muc
The threshold between four- and three-flavour theory in GeV.
Definition: QCD.h:1023
QCD::CA
double CA
Definition: QCD.h:1026
QCD::PreUpdate
virtual bool PreUpdate()
The pre-update method for QCD.
Definition: QCD.cpp:130
QCD::setFlag
virtual bool setFlag(const std::string name, const bool value)
A method to set a flag of QCD.
Definition: QCD.cpp:479
QCD::Beta1
const double Beta1(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:606
QCD::Mrun
const double Mrun(const double mu, const double m, const quark q, const orders order=FULLNNLO) const
Computes a running quark mass from .
Definition: QCD.cpp:1353
QCD::quark
quark
An enum type for quarks.
Definition: QCD.h:323
QCD::UP
@ UP
Definition: QCD.h:324
QCD::BOTTOM
@ BOTTOM
Definition: QCD.h:329
QCD::TOP
@ TOP
Definition: QCD.h:328
QCD::DOWN
@ DOWN
Definition: QCD.h:325
QCD::STRANGE
@ STRANGE
Definition: QCD.h:327
QCD::CHARM
@ CHARM
Definition: QCD.h:326
QCD::setFlagStr
virtual bool setFlagStr(const std::string name, const std::string value)
A method to set a flag of QCD.
Definition: QCD.cpp:511
QCD::CheckFlags
virtual bool CheckFlags() const
A method to check the sanity of the set of model flags.
Definition: QCD.cpp:517
QCD::Init
virtual bool Init(const std::map< std::string, double > &DPars)
Initializes the QCD parameters found in the argument.
Definition: QCD.cpp:120
QCD::BelowTh
const double BelowTh(const double mu) const
The active flavour threshold below the scale as defined in QCD::Thresholds().
Definition: QCD.cpp:559
QCD::TF
double TF
Definition: QCD.h:1026
QCD::setParameter
virtual void setParameter(const std::string name, const double &value)
A method to set the value of a parameter of QCD.
Definition: QCD.cpp:343
QCD::Beta0
const double Beta0(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:601
QCD::orderToString
const std::string orderToString(const orders order) const
Converts an object of the enum type "orders" to the corresponding string.
Definition: QCD.cpp:95
QCD::Beta3
const double Beta3(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:618
QCD::requireYd
bool requireYd
Switch for generating the Yukawa couplings to the down-type quarks.
Definition: QCD.h:1013
QCD::getMtpole
const double getMtpole() const
A get method to access the pole mass of the top quark.
Definition: QCD.h:600
QCD::AboveTh
const double AboveTh(const double mu) const
The active flavour threshold above the scale as defined in QCD::Thresholds().
Definition: QCD.cpp:547
QCD::Nf
const double Nf(const double mu) const
The number of active flavour at scale .
Definition: QCD.cpp:571
QCD::AlsWithInit
const double AlsWithInit(const double mu, const double alsi, const double mu_i, const int nf, const orders order) const
Computes the running strong coupling from in the scheme, where it is forbidden to across a flavour...
Definition: QCD.cpp:627
QCD::NfThresholdCorrections
const double NfThresholdCorrections(double mu, double M, double als, int nf, orders order) const
Threshold corrections in matching with from eq. (34) of hep-ph/0512060.
Definition: QCD.cpp:709
QCD::FullOrder
const orders FullOrder(orders order) const
Return the FULLORDER enum corresponding to order.
Definition: QCD.cpp:728
QCD::lepton
lepton
An enum type for leptons.
Definition: QCD.h:310
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::getQuarks
const Particle & getQuarks(const QCD::quark q) const
A get method to access a quark as an object of the type Particle.
Definition: QCD.h:536
QCD::AlsByOrder
const double AlsByOrder(const double mu, const orders order=FULLNLO, bool Nf_thr=true) const
Definition: QCD.cpp:804
QCD::quarks
Particle quarks[6]
The vector of all SM quarks.
Definition: QCD.h:1027
QCD::MassOfNf
const double MassOfNf(int nf) const
The Mbar mass of the heaviest quark in the theory with Nf active flavour.
Definition: QCD.cpp:745
QCD::mtpole
double mtpole
The pole mass of the top quark.
Definition: QCD.h:1020
QCD::mub
double mub
The threshold between five- and four-flavour theory in GeV.
Definition: QCD.h:1022
QCD::CacheShift
void CacheShift(double cache[][5], int n) const
A member used to manage the caching for this class.
StandardModel::getIntegrand_sigmaWithISR_down183
const double getIntegrand_sigmaWithISR_down183(double x) const
Definition: StandardModel/src/StandardModel.cpp:8366
StandardModel::LEP2sigmaCharm
virtual const double LEP2sigmaCharm(const double s) const
Definition: StandardModel/src/StandardModel.cpp:4614
StandardModel::dAle5Mz
double dAle5Mz
The five-flavour hadronic contribution to the electromagnetic coupling, , used as input for FlagMWinp...
Definition: StandardModel.h:3482
StandardModel::myThreeLoopEW
EWSMThreeLoopEW * myThreeLoopEW
A pointer to an object of type EWSMThreeLoopEW.
Definition: StandardModel.h:4054
StandardModel::getIntegrand_dsigmaBox_strange167
const double getIntegrand_dsigmaBox_strange167(double x) const
Definition: StandardModel/src/StandardModel.cpp:9140
StandardModel::dAl5hMz
double dAl5hMz
The five-flavour hadronic contribution to the electromagnetic coupling, . (Non-input parameter)
Definition: StandardModel.h:3508
StandardModel::Delta_EWQCD
double Delta_EWQCD(const QCD::quark q) const
The non-factorizable EW-QCD corrections to the partial widths for , denoted as .
Definition: StandardModel/src/StandardModel.cpp:2139
StandardModel::getIntegrand_sigmaWithISR_strange167
const double getIntegrand_sigmaWithISR_strange167(double x) const
Definition: StandardModel/src/StandardModel.cpp:8530
StandardModel::delSin2th_b
double delSin2th_b
The theoretical uncertainty in , denoted as .
Definition: StandardModel.h:3487
StandardModel::GammaHtoZZstar
virtual const double GammaHtoZZstar() const
The in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3400
StandardModel::SigmaeeHvv
virtual const double SigmaeeHvv(const double sqrt_s, const double Pe, const double Pp) const
The in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3350
StandardModel::Vub
double Vub
used as an input for FlagWolfenstein = FALSE
Definition: StandardModel.h:3502
StandardModel::BrHtocc
virtual const double BrHtocc() const
The Br in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3687
StandardModel::taub
double taub() const
Top-mass corrections to the vertex, denoted by .
Definition: StandardModel/src/StandardModel.cpp:2119
StandardModel::SMvars
static std::string SMvars[NSMvars]
A string array containing the labels of the model parameters in StandardModel.
Definition: StandardModel.h:556
StandardModel::MRL2eeff
const double MRL2eeff(const Particle f, const double s) const
Definition: StandardModel/src/StandardModel.cpp:3760
StandardModel::getIntegrand_sigmaWithISR_strange189
const double getIntegrand_sigmaWithISR_strange189(double x) const
Definition: StandardModel/src/StandardModel.cpp:8548
StandardModel::getIntegrand_dsigmaBox_mu200
const double getIntegrand_dsigmaBox_mu200(double x) const
Definition: StandardModel/src/StandardModel.cpp:8736
StandardModel::A
double A
The CKM parameter in the Wolfenstein parameterization.
Definition: StandardModel.h:3496
StandardModel::getIntegrand_sigmaWithISR_strange161
const double getIntegrand_sigmaWithISR_strange161(double x) const
Definition: StandardModel/src/StandardModel.cpp:8524
StandardModel::sin2thetaEff
virtual const double sin2thetaEff(const Particle f) const
The effective weak mixing angle for at the the -mass scale.
Definition: StandardModel/src/StandardModel.cpp:1357
StandardModel::getMyEWSMcache
EWSMcache * getMyEWSMcache() const
A get method to retrieve the member pointer of type EWSMcache.
Definition: StandardModel.h:1006
StandardModel::requireCKM
bool requireCKM
An internal flag to control whether the CKM matrix has to be recomputed.
Definition: StandardModel.h:3748
StandardModel::GammaHtotautau
virtual const double GammaHtotautau() const
The in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3546
StandardModel::getIntegrand_AFBnumeratorWithISR_tau130
const double getIntegrand_AFBnumeratorWithISR_tau130(double x) const
Definition: StandardModel/src/StandardModel.cpp:9387
StandardModel::GammaZ
virtual const double GammaZ(const Particle f) const
The partial decay width, .
Definition: StandardModel/src/StandardModel.cpp:1363
StandardModel::uovers2
const double uovers2(const double cosmin, const double cosmax) const
Definition: StandardModel/src/StandardModel.cpp:3922
StandardModel::computeCKM
virtual void computeCKM()
The method to compute the CKM matrix.
Definition: StandardModel/src/StandardModel.cpp:382
StandardModel::getIntegrand_AFBnumeratorWithISR_charm133
const double getIntegrand_AFBnumeratorWithISR_charm133(double x) const
Definition: StandardModel/src/StandardModel.cpp:9476
StandardModel::getIntegrand_sigmaWithISR_charm192
const double getIntegrand_sigmaWithISR_charm192(double x) const
Definition: StandardModel/src/StandardModel.cpp:8466
StandardModel::getIntegrand_AFBnumeratorWithISR_tau200
const double getIntegrand_AFBnumeratorWithISR_tau200(double x) const
Definition: StandardModel/src/StandardModel.cpp:9435
StandardModel::gamma
double gamma
used as an input for FlagWolfenstein = FALSE
Definition: StandardModel.h:3503
StandardModel::Vud
double Vud
used as an input for FlagWolfenstein = FALSE and FlagUseVud = TRUE
Definition: StandardModel.h:3500
StandardModel::getIntegrand_dsigmaBox_up130
const double getIntegrand_dsigmaBox_up130(double x) const
Definition: StandardModel/src/StandardModel.cpp:8853
StandardModel::getIntegrand_dsigmaBox_down207
const double getIntegrand_dsigmaBox_down207(double x) const
Definition: StandardModel/src/StandardModel.cpp:9018
StandardModel::BrHtoZZstar
virtual const double BrHtoZZstar() const
The Br in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3657
StandardModel::getIntegrand_dsigmaBox_tau136
const double getIntegrand_dsigmaBox_tau136(double x) const
Definition: StandardModel/src/StandardModel.cpp:8770
StandardModel::IsFlagNoApproximateGammaZ
const bool IsFlagNoApproximateGammaZ() const
A method to retrieve the model flag NoApproximateGammaZ.
Definition: StandardModel.h:691
StandardModel::PreUpdate
virtual bool PreUpdate()
The pre-update method for StandardModel.
Definition: StandardModel/src/StandardModel.cpp:216
StandardModel::getIntegrand_AFBnumeratorWithISR_mu192
const double getIntegrand_AFBnumeratorWithISR_mu192(double x) const
Definition: StandardModel/src/StandardModel.cpp:9350
StandardModel::getIntegrand_sigmaWithISR_tau207
const double getIntegrand_sigmaWithISR_tau207(double x) const
Definition: StandardModel/src/StandardModel.cpp:8212
StandardModel::getLeptons
const Particle & getLeptons(const QCD::lepton p) const
A get method to retrieve the member object of a lepton.
Definition: StandardModel.h:756
StandardModel::getIntegrand_AFBnumeratorWithISR_bottom192
const double getIntegrand_AFBnumeratorWithISR_bottom192(double x) const
Definition: StandardModel/src/StandardModel.cpp:9575
StandardModel::getIntegrand_dsigmaBox_down200
const double getIntegrand_dsigmaBox_down200(double x) const
Definition: StandardModel/src/StandardModel.cpp:9000
StandardModel::tovers2
const double tovers2(const double cosmin, const double cosmax) const
Definition: StandardModel/src/StandardModel.cpp:3918
StandardModel::AHZga_W
gslpp::complex AHZga_W(const double tau, const double lambda) const
W loop function entering in the calculation of the effective coupling.
Definition: StandardModel/src/StandardModel.cpp:3314
StandardModel::getIntegrand_dsigmaBox_strange172
const double getIntegrand_dsigmaBox_strange172(double x) const
Definition: StandardModel/src/StandardModel.cpp:9148
StandardModel::sW2_MSbar_Approx
const double sW2_MSbar_Approx() const
The (approximated formula for the) square of the sine of the weak mixing angle in the MSbar scheme,...
Definition: StandardModel/src/StandardModel.cpp:1103
StandardModel::getIntegrand_dsigmaBox_mu207
const double getIntegrand_dsigmaBox_mu207(double x) const
Definition: StandardModel/src/StandardModel.cpp:8754
StandardModel::~StandardModel
virtual ~StandardModel()
The default destructor.
Definition: StandardModel/src/StandardModel.cpp:154
StandardModel::LEP2sigmaHadron
virtual const double LEP2sigmaHadron(const double s) const
Definition: StandardModel/src/StandardModel.cpp:5036
StandardModel::getIntegrand_dsigmaBox_up202
const double getIntegrand_dsigmaBox_up202(double x) const
Definition: StandardModel/src/StandardModel.cpp:8919
StandardModel::getIntegrand_sigmaWithISR_down192
const double getIntegrand_sigmaWithISR_down192(double x) const
Definition: StandardModel/src/StandardModel.cpp:8378
StandardModel::FlagRhoZ
std::string FlagRhoZ
A string for the model flag RhoZ.
Definition: StandardModel.h:4064
StandardModel::getIntegrand_AFBnumeratorWithISR_mu207
const double getIntegrand_AFBnumeratorWithISR_mu207(double x) const
Definition: StandardModel/src/StandardModel.cpp:9380
StandardModel::BrHtomumu
virtual const double BrHtomumu() const
The Br in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3677
StandardModel::getIntegrand_dsigmaBox_strange130
const double getIntegrand_dsigmaBox_strange130(double x) const
Definition: StandardModel/src/StandardModel.cpp:9116
StandardModel::getIntegrand_AFBnumeratorWithISR_charm183
const double getIntegrand_AFBnumeratorWithISR_charm183(double x) const
Definition: StandardModel/src/StandardModel.cpp:9494
StandardModel::LEP2sigmaTau
virtual const double LEP2sigmaTau(const double s) const
Definition: StandardModel/src/StandardModel.cpp:4356
StandardModel::Mz
double Mz
The mass of the boson in GeV.
Definition: StandardModel.h:3478
StandardModel::myThreeLoopQCD
EWSMThreeLoopQCD * myThreeLoopQCD
A pointer to an object of type EWSMThreeLoopQCD.
Definition: StandardModel.h:4051
StandardModel::TauLFU_gtaugmuPi
virtual const double TauLFU_gtaugmuPi() const
The computation of the LFU ratio .
Definition: StandardModel/src/StandardModel.cpp:3241
StandardModel::delGammaWlv
double delGammaWlv
The theoretical uncertainty in , denoted as .
Definition: StandardModel.h:3493
StandardModel::GammaHtogaga
virtual const double GammaHtogaga() const
The in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3491
StandardModel::getIntegrand_AFBnumeratorWithISR_tau172
const double getIntegrand_AFBnumeratorWithISR_tau172(double x) const
Definition: StandardModel/src/StandardModel.cpp:9405
StandardModel::MLL2eeff
const double MLL2eeff(const Particle f, const double s, const double t) const
Definition: StandardModel/src/StandardModel.cpp:3812
StandardModel::getIntegrand_sigmaWithISR_tau205
const double getIntegrand_sigmaWithISR_tau205(double x) const
Definition: StandardModel/src/StandardModel.cpp:8206
StandardModel::m_q
double m_q(const QCD::quark q, const double mu, const orders order=FULLNLO) const
Definition: StandardModel.h:3565
StandardModel::getIntegrand_AFBnumeratorWithISR_bottom196
const double getIntegrand_AFBnumeratorWithISR_bottom196(double x) const
Definition: StandardModel/src/StandardModel.cpp:9581
StandardModel::getIntegrand_sigmaWithISR_strange136
const double getIntegrand_sigmaWithISR_strange136(double x) const
Definition: StandardModel/src/StandardModel.cpp:8518
StandardModel::getIntegrand_sigmaWithISR_down207
const double getIntegrand_sigmaWithISR_down207(double x) const
Definition: StandardModel/src/StandardModel.cpp:8408
StandardModel::getIntegrand_sigmaWithISR_tau196
const double getIntegrand_sigmaWithISR_tau196(double x) const
Definition: StandardModel/src/StandardModel.cpp:8188
StandardModel::getIntegrand_dsigmaBox_down136
const double getIntegrand_dsigmaBox_down136(double x) const
Definition: StandardModel/src/StandardModel.cpp:8952
StandardModel::getIntegrand_dsigmaBox_strange189
const double getIntegrand_dsigmaBox_strange189(double x) const
Definition: StandardModel/src/StandardModel.cpp:9160
StandardModel::getIntegrand_sigmaWithISR_bottom200
const double getIntegrand_sigmaWithISR_bottom200(double x) const
Definition: StandardModel/src/StandardModel.cpp:8654
StandardModel::MwFromMwbar
const double MwFromMwbar(const double Mwbar) const
A method to convert the -boson mass in the complex-pole/fixed-width scheme to that in the experimenta...
Definition: StandardModel/src/StandardModel.cpp:1219
StandardModel::getIntegrand_sigmaWithISR_up183
const double getIntegrand_sigmaWithISR_up183(double x) const
Definition: StandardModel/src/StandardModel.cpp:8278
StandardModel::GammaHtobb
virtual const double GammaHtobb() const
The in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3610
StandardModel::getIntegrand_dsigmaBox_mu136
const double getIntegrand_dsigmaBox_mu136(double x) const
Definition: StandardModel/src/StandardModel.cpp:8694
StandardModel::getIntegrand_sigmaWithISR_strange183
const double getIntegrand_sigmaWithISR_strange183(double x) const
Definition: StandardModel/src/StandardModel.cpp:8542
StandardModel::AFB
virtual const double AFB(const Particle f) const
Definition: StandardModel/src/StandardModel.cpp:1352
StandardModel::getIntegrand_dsigmaBox_down183
const double getIntegrand_dsigmaBox_down183(double x) const
Definition: StandardModel/src/StandardModel.cpp:8976
StandardModel::RAq
double RAq(const QCD::quark q) const
The radiator factor associated with the final-state QED and QCD corrections to the the axial-vector-c...
Definition: StandardModel/src/StandardModel.cpp:2277
StandardModel::getIntegrand_dsigmaBox_charm130
const double getIntegrand_dsigmaBox_charm130(double x) const
Definition: StandardModel/src/StandardModel.cpp:9028
StandardModel::getMz
const double getMz() const
A get method to access the mass of the boson .
Definition: StandardModel.h:765
StandardModel::getIntegrand_AFBnumeratorWithISR_tau192
const double getIntegrand_AFBnumeratorWithISR_tau192(double x) const
Definition: StandardModel/src/StandardModel.cpp:9423
StandardModel::getIntegrand_sigmaWithISR_strange200
const double getIntegrand_sigmaWithISR_strange200(double x) const
Definition: StandardModel/src/StandardModel.cpp:8566
StandardModel::getIntegrand_AFBnumeratorWithISR_charm205
const double getIntegrand_AFBnumeratorWithISR_charm205(double x) const
Definition: StandardModel/src/StandardModel.cpp:9530
StandardModel::setFlagCacheInStandardModel
void setFlagCacheInStandardModel(bool FlagCacheInStandardModel)
A set method to change the model flag CacheInStandardModel of StandardModel.
Definition: StandardModel.h:742
StandardModel::getIntegrand_sigmaWithISR_tau161
const double getIntegrand_sigmaWithISR_tau161(double x) const
Definition: StandardModel/src/StandardModel.cpp:8158
StandardModel::getIntegrand_sigmaWithISR_up167
const double getIntegrand_sigmaWithISR_up167(double x) const
Definition: StandardModel/src/StandardModel.cpp:8266
StandardModel::GammaW_cache
double GammaW_cache
A cache of the value of .
Definition: StandardModel.h:4082
StandardModel::delMw
double delMw
The theoretical uncertainty in , denoted as , in GeV.
Definition: StandardModel.h:3484
StandardModel::LEP2AFBtau
virtual const double LEP2AFBtau(const double s) const
Definition: StandardModel/src/StandardModel.cpp:7491
StandardModel::getIntegrand_AFBnumeratorWithISR_tau196
const double getIntegrand_AFBnumeratorWithISR_tau196(double x) const
Definition: StandardModel/src/StandardModel.cpp:9429
StandardModel::flag_order
bool flag_order[orders_EW_size]
An array of internal flags controlling the inclusions of higher-order corrections.
Definition: StandardModel.h:3519
StandardModel::rhoZ_f
virtual const gslpp::complex rhoZ_f(const Particle f) const
The effective leptonic neutral-current coupling in the SM.
Definition: StandardModel/src/StandardModel.cpp:1594
StandardModel::getIntegrand_AFBnumeratorWithISR_charm200
const double getIntegrand_AFBnumeratorWithISR_charm200(double x) const
Definition: StandardModel/src/StandardModel.cpp:9518
StandardModel::gLnuN2
virtual const double gLnuN2() const
The effective neutrino nucleon LH coupling: gLnuN2.
Definition: StandardModel/src/StandardModel.cpp:3007
StandardModel::getIntegrand_sigmaWithISR_strange207
const double getIntegrand_sigmaWithISR_strange207(double x) const
Definition: StandardModel/src/StandardModel.cpp:8584
StandardModel::getIntegrand_AFBnumeratorWithISR_mu196
const double getIntegrand_AFBnumeratorWithISR_mu196(double x) const
Definition: StandardModel/src/StandardModel.cpp:9356
StandardModel::getIntegrand_dsigmaBox_mu189
const double getIntegrand_dsigmaBox_mu189(double x) const
Definition: StandardModel/src/StandardModel.cpp:8718
StandardModel::Ale
const double Ale(double mu, orders order, bool Nf_thr=true) const
The running electromagnetic coupling in the scheme.
Definition: StandardModel/src/StandardModel.cpp:783
StandardModel::getIntegrand_dsigmaBox_down161
const double getIntegrand_dsigmaBox_down161(double x) const
Definition: StandardModel/src/StandardModel.cpp:8958
StandardModel::Gamma_tau_l_nunu
virtual const double Gamma_tau_l_nunu(const Particle l) const
The computation of the leptonic tau decays.
Definition: StandardModel/src/StandardModel.cpp:3134
StandardModel::StandardModel
StandardModel()
The default constructor.
Definition: StandardModel/src/StandardModel.cpp:41
StandardModel::getIntegrand_dsigmaBox_strange207
const double getIntegrand_dsigmaBox_strange207(double x) const
Definition: StandardModel/src/StandardModel.cpp:9196
StandardModel::getIntegrand_sigmaWithISR_down202
const double getIntegrand_sigmaWithISR_down202(double x) const
Definition: StandardModel/src/StandardModel.cpp:8396
StandardModel::f_GSL
gsl_function f_GSL
Definition: StandardModel.h:4101
StandardModel::Integrand_dsigmaBox_q
const double Integrand_dsigmaBox_q(double cosTheta, const QCD::quark q_flavor, const double s) const
Definition: StandardModel/src/StandardModel.cpp:8841
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::getIntegrand_dsigmaBox_bottom189
const double getIntegrand_dsigmaBox_bottom189(double x) const
Definition: StandardModel/src/StandardModel.cpp:9248
StandardModel::myTwoLoopEW
EWSMTwoLoopEW * myTwoLoopEW
A pointer to an object of type EWSMTwoLoopEW.
Definition: StandardModel.h:4052
StandardModel::getIntegrand_AFBnumeratorWithISR_mu136
const double getIntegrand_AFBnumeratorWithISR_mu136(double x) const
Definition: StandardModel/src/StandardModel.cpp:9320
StandardModel::getIntegrand_AFBnumeratorWithISR_mu130
const double getIntegrand_AFBnumeratorWithISR_mu130(double x) const
Definition: StandardModel/src/StandardModel.cpp:9314
StandardModel::CheckParameters
virtual bool CheckParameters(const std::map< std::string, double > &DPars)
A method to check if all the mandatory parameters for StandardModel have been provided in model initi...
Definition: StandardModel/src/StandardModel.cpp:370
StandardModel::CheckFlags
virtual bool CheckFlags() const
A method to check the sanity of the set of model flags.
Definition: StandardModel/src/StandardModel.cpp:553
StandardModel::getIntegrand_dsigmaBox_charm161
const double getIntegrand_dsigmaBox_charm161(double x) const
Definition: StandardModel/src/StandardModel.cpp:9046
StandardModel::getIntegrand_dsigmaBox_up192
const double getIntegrand_dsigmaBox_up192(double x) const
Definition: StandardModel/src/StandardModel.cpp:8901
StandardModel::ComputeDeltaRho
void ComputeDeltaRho(const double Mw_i, double DeltaRho[orders_EW_size]) const
A method to collect computed via subclasses.
Definition: StandardModel/src/StandardModel.cpp:1132
StandardModel::getIntegrand_sigmaWithISR_strange202
const double getIntegrand_sigmaWithISR_strange202(double x) const
Definition: StandardModel/src/StandardModel.cpp:8572
StandardModel::RVq
double RVq(const QCD::quark q) const
The radiator factor associated with the final-state QED and QCD corrections to the the vector-current...
Definition: StandardModel/src/StandardModel.cpp:2157
StandardModel::LEP2Rbottom
virtual const double LEP2Rbottom(const double s) const
Definition: StandardModel/src/StandardModel.cpp:7988
StandardModel::getIntegrand_sigmaWithISR_tau183
const double getIntegrand_sigmaWithISR_tau183(double x) const
Definition: StandardModel/src/StandardModel.cpp:8170
StandardModel::FlagFixMuwMut
bool FlagFixMuwMut
A boolean for the model flag FixMuwMut.
Definition: StandardModel.h:3753
StandardModel::AlsEByOrder
const double AlsEByOrder(double mu, orders order, bool Nf_thr) const
Definition: StandardModel/src/StandardModel.cpp:692
StandardModel::getAlsMz
const double getAlsMz() const
A get method to access the value of .
Definition: StandardModel.h:783
StandardModel::getIntegrand_sigmaWithISR_tau130
const double getIntegrand_sigmaWithISR_tau130(double x) const
Definition: StandardModel/src/StandardModel.cpp:8146
StandardModel::getIntegrand_AFBnumeratorWithISR_bottom172
const double getIntegrand_AFBnumeratorWithISR_bottom172(double x) const
Definition: StandardModel/src/StandardModel.cpp:9557
StandardModel::RWlilj
virtual const double RWlilj(const Particle li, const Particle lj) const
The lepton universality ratio .
Definition: StandardModel/src/StandardModel.cpp:1298
StandardModel::AH_f
gslpp::complex AH_f(const double tau) const
Fermionic loop function entering in the calculation of the effective and couplings.
Definition: StandardModel/src/StandardModel.cpp:3302
StandardModel::Gamma_inv
virtual const double Gamma_inv() const
The invisible partial decay width of the boson, .
Definition: StandardModel/src/StandardModel.cpp:1411
StandardModel::getIntegrand_dsigmaBox_bottom207
const double getIntegrand_dsigmaBox_bottom207(double x) const
Definition: StandardModel/src/StandardModel.cpp:9284
StandardModel::getIntegrand_AFBnumeratorWithISR_mu172
const double getIntegrand_AFBnumeratorWithISR_mu172(double x) const
Definition: StandardModel/src/StandardModel.cpp:9332
StandardModel::Qwp
virtual const double Qwp() const
The computation of the proton weak charge: Qwp.
Definition: StandardModel/src/StandardModel.cpp:2787
StandardModel::getIntegrand_dsigmaBox_tau183
const double getIntegrand_dsigmaBox_tau183(double x) const
Definition: StandardModel/src/StandardModel.cpp:8788
StandardModel::getIntegrand_AFBnumeratorWithISR_mu202
const double getIntegrand_AFBnumeratorWithISR_mu202(double x) const
Definition: StandardModel/src/StandardModel.cpp:9368
StandardModel::getIntegrand_AFBnumeratorWithISR_charm172
const double getIntegrand_AFBnumeratorWithISR_charm172(double x) const
Definition: StandardModel/src/StandardModel.cpp:9488
StandardModel::getIntegrand_dsigmaBox_down202
const double getIntegrand_dsigmaBox_down202(double x) const
Definition: StandardModel/src/StandardModel.cpp:9006
StandardModel::R_inv
virtual const double R_inv() const
The ratio of the invisible and leptonic (electron) decay widths of the boson, .
Definition: StandardModel/src/StandardModel.cpp:1556
StandardModel::Init
virtual bool Init(const std::map< std::string, double > &DPars)
A method to initialize the model parameters.
Definition: StandardModel/src/StandardModel.cpp:198
StandardModel::myCKM
CKM myCKM
An object of type CKM.
Definition: StandardModel.h:3465
StandardModel::LEP2AFBe
virtual const double LEP2AFBe(const double s) const
Definition: StandardModel/src/StandardModel.cpp:6989
StandardModel::SMresult_cache
double SMresult_cache
Definition: StandardModel.h:4095
StandardModel::getIntegrand_sigmaWithISR_charm183
const double getIntegrand_sigmaWithISR_charm183(double x) const
Definition: StandardModel/src/StandardModel.cpp:8454
StandardModel::getIntegrand_dsigmaBox_bottom202
const double getIntegrand_dsigmaBox_bottom202(double x) const
Definition: StandardModel/src/StandardModel.cpp:9272
StandardModel::getIntegrand_dsigmaBox_bottom200
const double getIntegrand_dsigmaBox_bottom200(double x) const
Definition: StandardModel/src/StandardModel.cpp:9266
StandardModel::checkEWPOscheme
bool checkEWPOscheme(const std::string scheme) const
A method to check if a given scheme name in string form is valid.
Definition: StandardModel.h:3552
StandardModel::getIntegrand_dsigmaBox_bottom205
const double getIntegrand_dsigmaBox_bottom205(double x) const
Definition: StandardModel/src/StandardModel.cpp:9278
StandardModel::useDeltaAlpha_cache
bool useDeltaAlpha_cache
Definition: StandardModel.h:4086
StandardModel::getIntegrand_dsigmaBox_tau196
const double getIntegrand_dsigmaBox_tau196(double x) const
Definition: StandardModel/src/StandardModel.cpp:8806
StandardModel::getIntegrand_sigmaWithISR_tau200
const double getIntegrand_sigmaWithISR_tau200(double x) const
Definition: StandardModel/src/StandardModel.cpp:8194
StandardModel::getIntegrand_sigmaWithISR_bottom207
const double getIntegrand_sigmaWithISR_bottom207(double x) const
Definition: StandardModel/src/StandardModel.cpp:8672
StandardModel::getIntegrand_dsigmaBox_bottom183
const double getIntegrand_dsigmaBox_bottom183(double x) const
Definition: StandardModel/src/StandardModel.cpp:9242
StandardModel::setFlagStr
virtual bool setFlagStr(const std::string name, const std::string value)
A method to set a flag of StandardModel.
Definition: StandardModel/src/StandardModel.cpp:514
StandardModel::requireYn
bool requireYn
An internal flag to control whether the neutrino Yukawa matrix has to be recomputed.
Definition: StandardModel.h:3750
StandardModel::getIntegrand_dsigmaBox_mu161
const double getIntegrand_dsigmaBox_mu161(double x) const
Definition: StandardModel/src/StandardModel.cpp:8700
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::BrHtotautau
virtual const double BrHtotautau() const
The Br in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3682
StandardModel::Gamma_muon
virtual const double Gamma_muon() const
The computation of the muon decay.
Definition: StandardModel/src/StandardModel.cpp:3094
StandardModel::getIntegrand_dsigmaBox_up200
const double getIntegrand_dsigmaBox_up200(double x) const
Definition: StandardModel/src/StandardModel.cpp:8913
StandardModel::intMLR2eeeets2
const double intMLR2eeeets2(const double s, const double t0, const double t1) const
Definition: StandardModel/src/StandardModel.cpp:3929
StandardModel::getIntegrand_dsigmaBox_tau192
const double getIntegrand_dsigmaBox_tau192(double x) const
Definition: StandardModel/src/StandardModel.cpp:8800
StandardModel::getIntegrand_AFBnumeratorWithISR_bottom207
const double getIntegrand_AFBnumeratorWithISR_bottom207(double x) const
Definition: StandardModel/src/StandardModel.cpp:9605
StandardModel::getIntegrand_AFBnumeratorWithISR_tau136
const double getIntegrand_AFBnumeratorWithISR_tau136(double x) const
Definition: StandardModel/src/StandardModel.cpp:9393
StandardModel::DeltaAlphaTop
const double DeltaAlphaTop(const double s) const
Top-quark contribution to the electromagnetic coupling , denoted as .
Definition: StandardModel/src/StandardModel.cpp:913
StandardModel::getIntegrand_sigmaWithISR_charm205
const double getIntegrand_sigmaWithISR_charm205(double x) const
Definition: StandardModel/src/StandardModel.cpp:8490
StandardModel::getIntegrand_dsigmaBox_tau189
const double getIntegrand_dsigmaBox_tau189(double x) const
Definition: StandardModel/src/StandardModel.cpp:8794
StandardModel::BrHtogaga
virtual const double BrHtogaga() const
The Br in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3672
StandardModel::getIntegrand_AFBnumeratorWithISR_charm207
const double getIntegrand_AFBnumeratorWithISR_charm207(double x) const
Definition: StandardModel/src/StandardModel.cpp:9536
StandardModel::w_GSL1
gsl_integration_workspace * w_GSL1
Definition: StandardModel.h:4102
StandardModel::SigmaeeZH
virtual const double SigmaeeZH(const double sqrt_s, const double Pe, const double Pp) const
The in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3328
StandardModel::kappaZ_f
virtual const gslpp::complex kappaZ_f(const Particle f) const
The effective leptonic neutral-current coupling in the SM.
Definition: StandardModel/src/StandardModel.cpp:1659
StandardModel::Yn
gslpp::matrix< gslpp::complex > Yn
The Yukawa matrix of the neutrinos.
Definition: StandardModel.h:3472
StandardModel::getIntegrand_AFBnumeratorWithISR_charm202
const double getIntegrand_AFBnumeratorWithISR_charm202(double x) const
Definition: StandardModel/src/StandardModel.cpp:9524
StandardModel::myTwoFermionsLEP2
EWSMTwoFermionsLEP2 * myTwoFermionsLEP2
A pointer to an object of type EWSMTwoFermionsLEP2.
Definition: StandardModel.h:4058
StandardModel::SMM
Matching< StandardModelMatching, StandardModel > SMM
An object of type Matching.
Definition: StandardModel.h:3469
StandardModel::Gamma_had
virtual const double Gamma_had() const
The hadronic decay width of the boson, .
Definition: StandardModel/src/StandardModel.cpp:1417
StandardModel::getIntegrand_sigmaWithISR_charm207
const double getIntegrand_sigmaWithISR_charm207(double x) const
Definition: StandardModel/src/StandardModel.cpp:8496
StandardModel::ale_OS
const double ale_OS(const double mu, orders order=FULLNLO) const
The running electromagnetic coupling in the on-shell scheme.
Definition: StandardModel/src/StandardModel.cpp:611
StandardModel::computeYukawas
virtual void computeYukawas()
The method to compute the Yukawas matrix.
Definition: StandardModel/src/StandardModel.cpp:416
StandardModel::rho_GammaW
virtual const double rho_GammaW(const Particle fi, const Particle fj) const
EW radiative corrections to the width of , denoted as .
Definition: StandardModel/src/StandardModel.cpp:1240
StandardModel::AleWithInit
const double AleWithInit(double mu, double alsi, double mu_i, orders order) const
Definition: StandardModel/src/StandardModel.cpp:856
StandardModel::getIntegrand_sigmaWithISR_bottom136
const double getIntegrand_sigmaWithISR_bottom136(double x) const
Definition: StandardModel/src/StandardModel.cpp:8606
StandardModel::getIntegrand_sigmaWithISR_charm202
const double getIntegrand_sigmaWithISR_charm202(double x) const
Definition: StandardModel/src/StandardModel.cpp:8484
StandardModel::Yu
gslpp::matrix< gslpp::complex > Yu
The Yukawa matrix of the up-type quarks.
Definition: StandardModel.h:3470
StandardModel::LEP2AFBcharm
virtual const double LEP2AFBcharm(const double s) const
Definition: StandardModel/src/StandardModel.cpp:6579
StandardModel::FlagMw
std::string FlagMw
A string for the model flag Mw.
Definition: StandardModel.h:4063
StandardModel::Integrand_sigmaWithISR_l
const double Integrand_sigmaWithISR_l(double x, const QCD::lepton l_flavor, const double s) const
Definition: StandardModel/src/StandardModel.cpp:8058
StandardModel::getIntegrand_AFBnumeratorWithISR_tau183
const double getIntegrand_AFBnumeratorWithISR_tau183(double x) const
Definition: StandardModel/src/StandardModel.cpp:9411
StandardModel::GammaHtogg
virtual const double GammaHtogg() const
The in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3368
StandardModel::delsigma0H
double delsigma0H
The theoretical uncertainty in , denoted as in nb.
Definition: StandardModel.h:3489
StandardModel::BrHtobb
virtual const double BrHtobb() const
The Br in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3697
StandardModel::gA_f
virtual const gslpp::complex gA_f(const Particle f) const
The effective leptonic neutral-current axial-vector coupling in the SM.
Definition: StandardModel/src/StandardModel.cpp:1589
StandardModel::getIntegrand_sigmaWithISR_bottom130
const double getIntegrand_sigmaWithISR_bottom130(double x) const
Definition: StandardModel/src/StandardModel.cpp:8594
StandardModel::getIntegrand_sigmaWithISR_charm161
const double getIntegrand_sigmaWithISR_charm161(double x) const
Definition: StandardModel/src/StandardModel.cpp:8436
StandardModel::getIntegrand_sigmaWithISR_mu207
const double getIntegrand_sigmaWithISR_mu207(double x) const
Definition: StandardModel/src/StandardModel.cpp:8139
StandardModel::GammaHtoZga
virtual const double GammaHtoZga() const
The in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3432
StandardModel::getIntegrand_sigmaWithISR_bottom192
const double getIntegrand_sigmaWithISR_bottom192(double x) const
Definition: StandardModel/src/StandardModel.cpp:8642
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::rhob
double rhob
The CKM parameter in the Wolfenstein parameterization.
Definition: StandardModel.h:3497
StandardModel::leptons
Particle leptons[6]
An array of Particle objects for the leptons.
Definition: StandardModel.h:3464
StandardModel::Integrand_AFBnumeratorWithISR_q
const double Integrand_AFBnumeratorWithISR_q(double x, const QCD::quark q_flavor, const double s) const
Definition: StandardModel/src/StandardModel.cpp:9461
StandardModel::getIntegrand_sigmaWithISR_charm172
const double getIntegrand_sigmaWithISR_charm172(double x) const
Definition: StandardModel/src/StandardModel.cpp:8448
StandardModel::getIntegrand_sigmaWithISR_charm200
const double getIntegrand_sigmaWithISR_charm200(double x) const
Definition: StandardModel/src/StandardModel.cpp:8478
StandardModel::getIntegrand_dsigmaBox_up167
const double getIntegrand_dsigmaBox_up167(double x) const
Definition: StandardModel/src/StandardModel.cpp:8877
StandardModel::getIntegrand_dsigmaBox_mu183
const double getIntegrand_dsigmaBox_mu183(double x) const
Definition: StandardModel/src/StandardModel.cpp:8712
StandardModel::eeffsigmaEbin
const double eeffsigmaEbin(const double pol_e, const double pol_p, const double s, const double cosmin, const double cosmax) const
Definition: StandardModel/src/StandardModel.cpp:4025
StandardModel::delSin2th_l
double delSin2th_l
The theoretical uncertainty in , denoted as .
Definition: StandardModel.h:3485
StandardModel::getIntegrand_dsigmaBox_charm167
const double getIntegrand_dsigmaBox_charm167(double x) const
Definition: StandardModel/src/StandardModel.cpp:9052
StandardModel::RWc
virtual const double RWc() const
The ratio .
Definition: StandardModel/src/StandardModel.cpp:1328
StandardModel::getIntegrand_sigmaWithISR_mu172
const double getIntegrand_sigmaWithISR_mu172(double x) const
Definition: StandardModel/src/StandardModel.cpp:8091
StandardModel::getIntegrand_sigmaWithISR_mu136
const double getIntegrand_sigmaWithISR_mu136(double x) const
Definition: StandardModel/src/StandardModel.cpp:8079
StandardModel::sigma_NoISR_q
const double sigma_NoISR_q(const QCD::quark q_flavor, const double s) const
Definition: StandardModel/src/StandardModel.cpp:8024
StandardModel::FlagMWinput
bool FlagMWinput
A boolean for the model flag MWinput.
Definition: StandardModel.h:4069
StandardModel::Ruc
virtual const double Ruc() const
Definition: StandardModel/src/StandardModel.cpp:1323
StandardModel::getIntegrand_dsigmaBox_strange200
const double getIntegrand_dsigmaBox_strange200(double x) const
Definition: StandardModel/src/StandardModel.cpp:9178
StandardModel::getIntegrand_dsigmaBox_mu172
const double getIntegrand_dsigmaBox_mu172(double x) const
Definition: StandardModel/src/StandardModel.cpp:8706
StandardModel::getIntegrand_sigmaWithISR_bottom196
const double getIntegrand_sigmaWithISR_bottom196(double x) const
Definition: StandardModel/src/StandardModel.cpp:8648
StandardModel::sigma0_had
virtual const double sigma0_had() const
The hadronic cross section for at the -pole, .
Definition: StandardModel/src/StandardModel.cpp:1471
StandardModel::GammaW
virtual const double GammaW() const
The total width of the boson, .
Definition: StandardModel/src/StandardModel.cpp:1272
StandardModel::intMLRtilde2eeeest2
const double intMLRtilde2eeeest2(const double s, const double t0, const double t1) const
Definition: StandardModel/src/StandardModel.cpp:3955
StandardModel::getIntegrand_dsigmaBox_strange196
const double getIntegrand_dsigmaBox_strange196(double x) const
Definition: StandardModel/src/StandardModel.cpp:9172
StandardModel::s02
const double s02() const
The square of the sine of the weak mixing angle defined without weak radiative corrections.
Definition: StandardModel/src/StandardModel.cpp:1011
StandardModel::SMFlavour
Flavour SMFlavour
An object of type Flavour.
Definition: StandardModel.h:3752
StandardModel::g_triangle
gslpp::complex g_triangle(const double tau) const
Loop function entering in the calculation of the effective coupling.
Definition: StandardModel/src/StandardModel.cpp:3273
StandardModel::getIntegrand_dsigmaBox_up207
const double getIntegrand_dsigmaBox_up207(double x) const
Definition: StandardModel/src/StandardModel.cpp:8931
StandardModel::getIntegrand_sigmaWithISR_charm133
const double getIntegrand_sigmaWithISR_charm133(double x) const
Definition: StandardModel/src/StandardModel.cpp:8424
StandardModel::FlagWithoutNonUniversalVC
bool FlagWithoutNonUniversalVC
A boolean for the model flag WithoutNonUniversalVC.
Definition: StandardModel.h:4061
StandardModel::getIntegrand_sigmaWithISR_down200
const double getIntegrand_sigmaWithISR_down200(double x) const
Definition: StandardModel/src/StandardModel.cpp:8390
StandardModel::FlagSMAux
bool FlagSMAux
A boolean for the model flag SMAux.
Definition: StandardModel.h:4070
StandardModel::getIntegrand_sigmaWithISR_charm130
const double getIntegrand_sigmaWithISR_charm130(double x) const
Definition: StandardModel/src/StandardModel.cpp:8418
StandardModel::getIntegrand_sigmaWithISR_down196
const double getIntegrand_sigmaWithISR_down196(double x) const
Definition: StandardModel/src/StandardModel.cpp:8384
StandardModel::getIntegrand_sigmaWithISR_bottom172
const double getIntegrand_sigmaWithISR_bottom172(double x) const
Definition: StandardModel/src/StandardModel.cpp:8624
StandardModel::Yd
gslpp::matrix< gslpp::complex > Yd
The Yukawa matrix of the down-type quarks.
Definition: StandardModel.h:3471
StandardModel::getIntegrand_sigmaWithISR_up133
const double getIntegrand_sigmaWithISR_up133(double x) const
Definition: StandardModel/src/StandardModel.cpp:8248
StandardModel::LEP2AFBmu
virtual const double LEP2AFBmu(const double s) const
Definition: StandardModel/src/StandardModel.cpp:6994
StandardModel::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: StandardModel/src/StandardModel.cpp:1289
StandardModel::getIntegrand_dsigmaBox_down189
const double getIntegrand_dsigmaBox_down189(double x) const
Definition: StandardModel/src/StandardModel.cpp:8982
StandardModel::getIntegrand_AFBnumeratorWithISR_bottom200
const double getIntegrand_AFBnumeratorWithISR_bottom200(double x) const
Definition: StandardModel/src/StandardModel.cpp:9587
StandardModel::getIntegrand_sigmaWithISR_charm167
const double getIntegrand_sigmaWithISR_charm167(double x) const
Definition: StandardModel/src/StandardModel.cpp:8442
StandardModel::Integrand_dsigmaBox_l
const double Integrand_dsigmaBox_l(double cosTheta, const QCD::lepton l_flavor, const double s) const
Definition: StandardModel/src/StandardModel.cpp:8682
StandardModel::myOneLoopEW
EWSMOneLoopEW * myOneLoopEW
A pointer to an object of type EWSMOneLoopEW.
Definition: StandardModel.h:4049
StandardModel::delR0c
double delR0c
The theoretical uncertainty in , denoted as .
Definition: StandardModel.h:3491
StandardModel::epsilon2
virtual const double epsilon2() const
The SM contribution to the epsilon parameter .
Definition: StandardModel/src/StandardModel.cpp:1808
StandardModel::getIntegrand_dsigmaBox_charm205
const double getIntegrand_dsigmaBox_charm205(double x) const
Definition: StandardModel/src/StandardModel.cpp:9100
StandardModel::getIntegrand_sigmaWithISR_up172
const double getIntegrand_sigmaWithISR_up172(double x) const
Definition: StandardModel/src/StandardModel.cpp:8272
StandardModel::LEP2dsigmadcosMu
virtual const double LEP2dsigmadcosMu(const double s, const double cos) const
Definition: StandardModel/src/StandardModel.cpp:9628
StandardModel::getIntegrand_dsigmaBox_up161
const double getIntegrand_dsigmaBox_up161(double x) const
Definition: StandardModel/src/StandardModel.cpp:8871
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::getIntegrand_dsigmaBox_tau202
const double getIntegrand_dsigmaBox_tau202(double x) const
Definition: StandardModel/src/StandardModel.cpp:8818
StandardModel::DeltaR
virtual const double DeltaR() const
The SM prediction for derived from that for the boson mass.
Definition: StandardModel/src/StandardModel.cpp:1118
StandardModel::FlagKappaZ
std::string FlagKappaZ
A string for the model flag KappaZ.
Definition: StandardModel.h:4065
StandardModel::getIntegrand_dsigmaBox_charm183
const double getIntegrand_dsigmaBox_charm183(double x) const
Definition: StandardModel/src/StandardModel.cpp:9064
StandardModel::getIntegrand_dsigmaBox_bottom196
const double getIntegrand_dsigmaBox_bottom196(double x) const
Definition: StandardModel/src/StandardModel.cpp:9260
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::getIntegrand_sigmaWithISR_strange205
const double getIntegrand_sigmaWithISR_strange205(double x) const
Definition: StandardModel/src/StandardModel.cpp:8578
StandardModel::getIntegrand_dsigmaBox_bottom172
const double getIntegrand_dsigmaBox_bottom172(double x) const
Definition: StandardModel/src/StandardModel.cpp:9236
StandardModel::Gamma_Z
virtual const double Gamma_Z() const
The total decay width of the boson, .
Definition: StandardModel/src/StandardModel.cpp:1439
StandardModel::getIntegrand_dsigmaBox_down133
const double getIntegrand_dsigmaBox_down133(double x) const
Definition: StandardModel/src/StandardModel.cpp:8946
StandardModel::getIntegrand_dsigmaBox_mu192
const double getIntegrand_dsigmaBox_mu192(double x) const
Definition: StandardModel/src/StandardModel.cpp:8724
StandardModel::getIntegrand_dsigmaBox_down167
const double getIntegrand_dsigmaBox_down167(double x) const
Definition: StandardModel/src/StandardModel.cpp:8964
StandardModel::getIntegrand_dsigmaBox_mu196
const double getIntegrand_dsigmaBox_mu196(double x) const
Definition: StandardModel/src/StandardModel.cpp:8730
StandardModel::gRnuN2
virtual const double gRnuN2() const
The effective neutrino nucleon RH coupling: gRnuN2.
Definition: StandardModel/src/StandardModel.cpp:3021
StandardModel::getIntegrand_sigmaWithISR_strange133
const double getIntegrand_sigmaWithISR_strange133(double x) const
Definition: StandardModel/src/StandardModel.cpp:8512
StandardModel::IsFlagWithoutNonUniversalVC
const bool IsFlagWithoutNonUniversalVC() const
A method to retrieve the model flag WithoutNonUniversalVC.
Definition: StandardModel.h:678
StandardModel::getIntegrand_sigmaWithISR_tau189
const double getIntegrand_sigmaWithISR_tau189(double x) const
Definition: StandardModel/src/StandardModel.cpp:8176
StandardModel::getIntegrand_AFBnumeratorWithISR_bottom205
const double getIntegrand_AFBnumeratorWithISR_bottom205(double x) const
Definition: StandardModel/src/StandardModel.cpp:9599
StandardModel::GF
double GF
The Fermi constant in .
Definition: StandardModel.h:3480
StandardModel::getIntegrand_sigmaWithISR_down130
const double getIntegrand_sigmaWithISR_down130(double x) const
Definition: StandardModel/src/StandardModel.cpp:8329
StandardModel::getIntegrand_sigmaWithISR_strange192
const double getIntegrand_sigmaWithISR_strange192(double x) const
Definition: StandardModel/src/StandardModel.cpp:8554
StandardModel::epsilonb
virtual const double epsilonb() const
The SM contribution to the epsilon parameter .
Definition: StandardModel/src/StandardModel.cpp:1830
StandardModel::myApproximateFormulae
EWSMApproximateFormulae * myApproximateFormulae
A pointer to an object of type EWSMApproximateFormulae.
Definition: StandardModel.h:4055
StandardModel::deltaRhoZ_f
virtual const gslpp::complex deltaRhoZ_f(const Particle f) const
Flavour non-universal vertex corrections to , denoted by .
Definition: StandardModel/src/StandardModel.cpp:1745
StandardModel::getIntegrand_dsigmaBox_bottom130
const double getIntegrand_dsigmaBox_bottom130(double x) const
Definition: StandardModel/src/StandardModel.cpp:9206
StandardModel::GammaHtocc
virtual const double GammaHtocc() const
The in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3558
StandardModel::getIntegrand_sigmaWithISR_strange130
const double getIntegrand_sigmaWithISR_strange130(double x) const
Definition: StandardModel/src/StandardModel.cpp:8506
StandardModel::getIntegrand_AFBnumeratorWithISR_bottom189
const double getIntegrand_AFBnumeratorWithISR_bottom189(double x) const
Definition: StandardModel/src/StandardModel.cpp:9569
StandardModel::getIntegrand_dsigmaBox_tau172
const double getIntegrand_dsigmaBox_tau172(double x) const
Definition: StandardModel/src/StandardModel.cpp:8782
StandardModel::intMRR2eeeeus2
const double intMRR2eeeeus2(const double s, const double t0, const double t1) const
Definition: StandardModel/src/StandardModel.cpp:3998
StandardModel::resumKappaZ
double resumKappaZ(const double DeltaRho[orders_EW_size], const double deltaKappa_rem[orders_EW_size], const double DeltaRbar_rem, const bool bool_Zbb) const
A method to compute the real part of the effetvive coupling from , and .
Definition: StandardModel/src/StandardModel.cpp:2042
StandardModel::TauLFU_gtaugmuK
virtual const double TauLFU_gtaugmuK() const
The computation of the LFU ratio .
Definition: StandardModel/src/StandardModel.cpp:3248
StandardModel::getIntegrand_dsigmaBox_strange161
const double getIntegrand_dsigmaBox_strange161(double x) const
Definition: StandardModel/src/StandardModel.cpp:9134
StandardModel::LEP2sigmaE
virtual const double LEP2sigmaE(const double s) const
Definition: StandardModel/src/StandardModel.cpp:4094
StandardModel::getIntegrand_sigmaWithISR_down136
const double getIntegrand_sigmaWithISR_down136(double x) const
Definition: StandardModel/src/StandardModel.cpp:8342
StandardModel::Beta_s
const double Beta_s(int nm, unsigned int nf) const
QCD beta function coefficients including QED corrections - eq. (36) hep-ph/0512066.
Definition: StandardModel/src/StandardModel.cpp:632
StandardModel::AFB_NoISR_q
const double AFB_NoISR_q(const QCD::quark q_flavor, const double s) const
Definition: StandardModel/src/StandardModel.cpp:8047
StandardModel::BrHtoWWstar
virtual const double BrHtoWWstar() const
The Br in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3662
StandardModel::getIntegrand_sigmaWithISR_bottom205
const double getIntegrand_sigmaWithISR_bottom205(double x) const
Definition: StandardModel/src/StandardModel.cpp:8666
StandardModel::getIntegrand_dsigmaBox_tau200
const double getIntegrand_dsigmaBox_tau200(double x) const
Definition: StandardModel/src/StandardModel.cpp:8812
StandardModel::Mw
virtual const double Mw() const
The SM prediction for the -boson mass in the on-shell scheme, .
Definition: StandardModel/src/StandardModel.cpp:1025
StandardModel::setFlag
virtual bool setFlag(const std::string name, const bool value)
A method to set a flag of StandardModel.
Definition: StandardModel/src/StandardModel.cpp:449
StandardModel::getIntegrand_sigmaWithISR_up192
const double getIntegrand_sigmaWithISR_up192(double x) const
Definition: StandardModel/src/StandardModel.cpp:8290
StandardModel::A_f
virtual const double A_f(const Particle f) const
The left-right asymmetry in at the -pole, .
Definition: StandardModel/src/StandardModel.cpp:1345
StandardModel::MRR2eeff
const double MRR2eeff(const Particle f, const double s, const double t) const
Definition: StandardModel/src/StandardModel.cpp:3864
StandardModel::Mw_cache
double Mw_cache
A cache of the value of .
Definition: StandardModel.h:4081
StandardModel::DeltaAlphaLepton_cache
double DeltaAlphaLepton_cache
A cache of the value of .
Definition: StandardModel.h:4079
StandardModel::getIntegrand_AFBnumeratorWithISR_mu205
const double getIntegrand_AFBnumeratorWithISR_mu205(double x) const
Definition: StandardModel/src/StandardModel.cpp:9374
StandardModel::getIntegrand_dsigmaBox_bottom133
const double getIntegrand_dsigmaBox_bottom133(double x) const
Definition: StandardModel/src/StandardModel.cpp:9212
StandardModel::getIntegrand_dsigmaBox_strange205
const double getIntegrand_dsigmaBox_strange205(double x) const
Definition: StandardModel/src/StandardModel.cpp:9190
StandardModel::deltaKappaZ_f
virtual const gslpp::complex deltaKappaZ_f(const Particle f) const
Flavour non-universal vertex corrections to , denoted by .
Definition: StandardModel/src/StandardModel.cpp:1770
StandardModel::getIntegrand_AFBnumeratorWithISR_tau202
const double getIntegrand_AFBnumeratorWithISR_tau202(double x) const
Definition: StandardModel/src/StandardModel.cpp:9441
StandardModel::getIntegrand_dsigmaBox_bottom167
const double getIntegrand_dsigmaBox_bottom167(double x) const
Definition: StandardModel/src/StandardModel.cpp:9230
StandardModel::amuon
virtual const double amuon() const
The computation of the anomalous magnetic moment of the muon .
Definition: StandardModel/src/StandardModel.cpp:2441
StandardModel::BrHtoZga
virtual const double BrHtoZga() const
The Br in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3667
StandardModel::delGammaWqq
double delGammaWqq
The theoretical uncertainty in , denoted as .
Definition: StandardModel.h:3494
StandardModel::I_triangle_1
gslpp::complex I_triangle_1(const double tau, const double lambda) const
Loop function entering in the calculation of the effective coupling.
Definition: StandardModel/src/StandardModel.cpp:3284
StandardModel::epsilon1
virtual const double epsilon1() const
The SM contribution to the epsilon parameter .
Definition: StandardModel/src/StandardModel.cpp:1800
StandardModel::delSin2th_q
double delSin2th_q
The theoretical uncertainty in , denoted as .
Definition: StandardModel.h:3486
StandardModel::FlagUseVud
bool FlagUseVud
A boolean for the model flag UseVud.
Definition: StandardModel.h:4067
StandardModel::getIntegrand_sigmaWithISR_bottom133
const double getIntegrand_sigmaWithISR_bottom133(double x) const
Definition: StandardModel/src/StandardModel.cpp:8600
StandardModel::getIntegrand_sigmaWithISR_mu161
const double getIntegrand_sigmaWithISR_mu161(double x) const
Definition: StandardModel/src/StandardModel.cpp:8085
StandardModel::Mzbar
double Mzbar() const
The -boson mass in the complex-pole/fixed-width scheme.
Definition: StandardModel/src/StandardModel.cpp:1193
StandardModel::Mw_error
static const double Mw_error
The target accuracy of the iterative calculation of the -boson mass in units of GeV.
Definition: StandardModel.h:564
StandardModel::NSMvars
static const int NSMvars
The number of the model parameters in StandardModel.
Definition: StandardModel.h:552
StandardModel::getIntegrand_dsigmaBox_mu202
const double getIntegrand_dsigmaBox_mu202(double x) const
Definition: StandardModel/src/StandardModel.cpp:8742
StandardModel::getIntegrand_sigmaWithISR_up200
const double getIntegrand_sigmaWithISR_up200(double x) const
Definition: StandardModel/src/StandardModel.cpp:8302
StandardModel::sigma_NoISR_l
const double sigma_NoISR_l(const QCD::lepton l_flavor, const double s) const
Definition: StandardModel/src/StandardModel.cpp:8012
StandardModel::Integrand_sigmaWithISR_q
const double Integrand_sigmaWithISR_q(double x, const QCD::quark q_flavor, const double s) const
Definition: StandardModel/src/StandardModel.cpp:8218
StandardModel::getIntegrand_dsigmaBox_up183
const double getIntegrand_dsigmaBox_up183(double x) const
Definition: StandardModel/src/StandardModel.cpp:8889
StandardModel::LEP2Rcharm
virtual const double LEP2Rcharm(const double s) const
Definition: StandardModel/src/StandardModel.cpp:8000
StandardModel::SMparamsForEWPO_cache
double SMparamsForEWPO_cache[NumSMParamsForEWPO]
Definition: StandardModel.h:4078
StandardModel::FlagNoApproximateGammaZ
bool FlagNoApproximateGammaZ
A boolean for the model flag NoApproximateGammaZ.
Definition: StandardModel.h:4062
StandardModel::getIntegrand_sigmaWithISR_bottom202
const double getIntegrand_sigmaWithISR_bottom202(double x) const
Definition: StandardModel/src/StandardModel.cpp:8660
StandardModel::getIntegrand_sigmaWithISR_mu130
const double getIntegrand_sigmaWithISR_mu130(double x) const
Definition: StandardModel/src/StandardModel.cpp:8073
StandardModel::getIntegrand_dsigmaBox_strange183
const double getIntegrand_dsigmaBox_strange183(double x) const
Definition: StandardModel/src/StandardModel.cpp:9154
StandardModel::kappaZ_f_cache
gslpp::complex kappaZ_f_cache[12]
A cache of the value of .
Definition: StandardModel.h:4084
StandardModel::getIntegrand_dsigmaBox_up133
const double getIntegrand_dsigmaBox_up133(double x) const
Definition: StandardModel/src/StandardModel.cpp:8859
StandardModel::GammaHtoss
virtual const double GammaHtoss() const
The in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3584
StandardModel::lambda
double lambda
The CKM parameter in the Wolfenstein parameterization.
Definition: StandardModel.h:3495
StandardModel::getIntegrand_sigmaWithISR_strange172
const double getIntegrand_sigmaWithISR_strange172(double x) const
Definition: StandardModel/src/StandardModel.cpp:8536
StandardModel::Qwn
virtual const double Qwn() const
The computation of the neutron weak charge: Qwn.
Definition: StandardModel/src/StandardModel.cpp:2895
StandardModel::als_cache
double als_cache[11][CacheSize]
Cache for .
Definition: StandardModel.h:4113
StandardModel::getIntegrand_AFBnumeratorWithISR_mu189
const double getIntegrand_AFBnumeratorWithISR_mu189(double x) const
Definition: StandardModel/src/StandardModel.cpp:9344
StandardModel::ComputeDeltaR_rem
void ComputeDeltaR_rem(const double Mw_i, double DeltaR_rem[orders_EW_size]) const
A method to collect computed via subclasses.
Definition: StandardModel/src/StandardModel.cpp:1161
StandardModel::getIntegrand_AFBnumeratorWithISR_bottom202
const double getIntegrand_AFBnumeratorWithISR_bottom202(double x) const
Definition: StandardModel/src/StandardModel.cpp:9593
StandardModel::getIntegrand_dsigmaBox_strange202
const double getIntegrand_dsigmaBox_strange202(double x) const
Definition: StandardModel/src/StandardModel.cpp:9184
StandardModel::getIntegrand_sigmaWithISR_mu202
const double getIntegrand_sigmaWithISR_mu202(double x) const
Definition: StandardModel/src/StandardModel.cpp:8127
StandardModel::Integrand_AFBnumeratorWithISR_l
const double Integrand_AFBnumeratorWithISR_l(double x, const QCD::lepton l_flavor, const double s) const
Definition: StandardModel/src/StandardModel.cpp:9302
StandardModel::getIntegrand_sigmaWithISR_up189
const double getIntegrand_sigmaWithISR_up189(double x) const
Definition: StandardModel/src/StandardModel.cpp:8284
StandardModel::getIntegrand_dsigmaBox_down172
const double getIntegrand_dsigmaBox_down172(double x) const
Definition: StandardModel/src/StandardModel.cpp:8970
StandardModel::getIntegrand_dsigmaBox_tau161
const double getIntegrand_dsigmaBox_tau161(double x) const
Definition: StandardModel/src/StandardModel.cpp:8776
StandardModel::getIntegrand_sigmaWithISR_tau192
const double getIntegrand_sigmaWithISR_tau192(double x) const
Definition: StandardModel/src/StandardModel.cpp:8182
StandardModel::RZlilj
virtual const double RZlilj(const Particle li, const Particle lj) const
The lepton universality ratio .
Definition: StandardModel/src/StandardModel.cpp:1453
StandardModel::getIntegrand_dsigmaBox_strange136
const double getIntegrand_dsigmaBox_strange136(double x) const
Definition: StandardModel/src/StandardModel.cpp:9128
StandardModel::Als
const double Als(const double mu, const orders order, const bool Nf_thr, const bool qed_flag) const
The running QCD coupling in the scheme including QED corrections.
Definition: StandardModel.h:1120
StandardModel::getIntegrand_AFBnumeratorWithISR_charm189
const double getIntegrand_AFBnumeratorWithISR_charm189(double x) const
Definition: StandardModel/src/StandardModel.cpp:9500
StandardModel::getIntegrand_sigmaWithISR_up136
const double getIntegrand_sigmaWithISR_up136(double x) const
Definition: StandardModel/src/StandardModel.cpp:8254
StandardModel::Beta_e
const double Beta_e(int nm, unsigned int nf) const
QED beta function coefficients - eq. (36) hep-ph/0512066.
Definition: StandardModel/src/StandardModel.cpp:660
StandardModel::getIntegrand_dsigmaBox_bottom192
const double getIntegrand_dsigmaBox_bottom192(double x) const
Definition: StandardModel/src/StandardModel.cpp:9254
StandardModel::Vcb
double Vcb
used as an input for FlagWolfenstein = FALSE
Definition: StandardModel.h:3501
StandardModel::c02
const double c02() const
The square of the cosine of the weak mixing angle defined without weak radiative corrections.
Definition: StandardModel/src/StandardModel.cpp:1020
StandardModel::LEP2sigmaMu
virtual const double LEP2sigmaMu(const double s) const
Definition: StandardModel/src/StandardModel.cpp:4099
StandardModel::getIntegrand_dsigmaBox_mu205
const double getIntegrand_dsigmaBox_mu205(double x) const
Definition: StandardModel/src/StandardModel.cpp:8748
StandardModel::getIntegrand_sigmaWithISR_strange196
const double getIntegrand_sigmaWithISR_strange196(double x) const
Definition: StandardModel/src/StandardModel.cpp:8560
StandardModel::getIntegrand_sigmaWithISR_tau136
const double getIntegrand_sigmaWithISR_tau136(double x) const
Definition: StandardModel/src/StandardModel.cpp:8152
StandardModel::R0_f
virtual const double R0_f(const Particle f) const
The ratio .
Definition: StandardModel/src/StandardModel.cpp:1485
StandardModel::getIntegrand_dsigmaBox_up205
const double getIntegrand_dsigmaBox_up205(double x) const
Definition: StandardModel/src/StandardModel.cpp:8925
StandardModel::Mw_tree
const double Mw_tree() const
The tree-level mass of the boson, .
Definition: StandardModel/src/StandardModel.cpp:1003
StandardModel::AlsE
const double AlsE(double mu, orders order, bool Nf_thr) const
Definition: StandardModel/src/StandardModel.cpp:680
StandardModel::getIntegrand_AFBnumeratorWithISR_mu200
const double getIntegrand_AFBnumeratorWithISR_mu200(double x) const
Definition: StandardModel/src/StandardModel.cpp:9362
StandardModel::getIntegrand_sigmaWithISR_up202
const double getIntegrand_sigmaWithISR_up202(double x) const
Definition: StandardModel/src/StandardModel.cpp:8308
StandardModel::useDeltaAlphaLepton_cache
bool useDeltaAlphaLepton_cache
Definition: StandardModel.h:4085
StandardModel::TauLFU_gtauge
virtual const double TauLFU_gtauge() const
The computation of the LFU ratio .
Definition: StandardModel/src/StandardModel.cpp:3217
StandardModel::etab
double etab
The CKM parameter in the Wolfenstein parameterization.
Definition: StandardModel.h:3498
StandardModel::getIntegrand_sigmaWithISR_down167
const double getIntegrand_sigmaWithISR_down167(double x) const
Definition: StandardModel/src/StandardModel.cpp:8354
StandardModel::getIntegrand_sigmaWithISR_mu205
const double getIntegrand_sigmaWithISR_mu205(double x) const
Definition: StandardModel/src/StandardModel.cpp:8133
StandardModel::SigmaeeHee
virtual const double SigmaeeHee(const double sqrt_s, const double Pe, const double Pp) const
The in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3357
StandardModel::getIntegrand_sigmaWithISR_down133
const double getIntegrand_sigmaWithISR_down133(double x) const
Definition: StandardModel/src/StandardModel.cpp:8335
StandardModel::BrHtogg
virtual const double BrHtogg() const
The Br in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3652
StandardModel::myEWSMcache
EWSMcache * myEWSMcache
A pointer to an object of type EWSMcache.
Definition: StandardModel.h:4048
StandardModel::rhoZ_f_cache
gslpp::complex rhoZ_f_cache[12]
A cache of the value of .
Definition: StandardModel.h:4083
StandardModel::getIntegrand_AFBnumeratorWithISR_tau207
const double getIntegrand_AFBnumeratorWithISR_tau207(double x) const
Definition: StandardModel/src/StandardModel.cpp:9453
StandardModel::AFB_NoISR_l
const double AFB_NoISR_l(const QCD::lepton l_flavor, const double s) const
Definition: StandardModel/src/StandardModel.cpp:8039
StandardModel::epsilon3
virtual const double epsilon3() const
The SM contribution to the epsilon parameter .
Definition: StandardModel/src/StandardModel.cpp:1820
StandardModel::myLeptonFlavour
LeptonFlavour * myLeptonFlavour
A pointer to an object of the type LeptonFlavour.
Definition: StandardModel.h:4056
StandardModel::ale_cache
double ale_cache[10][CacheSize]
Cache for .
Definition: StandardModel.h:4114
StandardModel::getIntegrand_sigmaWithISR_charm136
const double getIntegrand_sigmaWithISR_charm136(double x) const
Definition: StandardModel/src/StandardModel.cpp:8430
StandardModel::getIntegrand_dsigmaBox_down130
const double getIntegrand_dsigmaBox_down130(double x) const
Definition: StandardModel/src/StandardModel.cpp:8940
StandardModel::Dalpha5hMz
virtual const double Dalpha5hMz() const
The 5-quark contribution to the running of the em constant to the pole. .
Definition: StandardModel/src/StandardModel.cpp:1074
StandardModel::resumRhoZ
double resumRhoZ(const double DeltaRho[orders_EW_size], const double deltaRho_rem[orders_EW_size], const double DeltaRbar_rem, const bool bool_Zbb) const
A method to compute the real part of the effective coupling from , and .
Definition: StandardModel/src/StandardModel.cpp:1963
StandardModel::I_triangle_2
gslpp::complex I_triangle_2(const double tau, const double lambda) const
Loop function entering in the calculation of the effective coupling.
Definition: StandardModel/src/StandardModel.cpp:3294
StandardModel::TauLFU_gtaugmu
virtual const double TauLFU_gtaugmu() const
The computation of the LFU ratio .
Definition: StandardModel/src/StandardModel.cpp:3194
StandardModel::getIntegrand_dsigmaBox_strange192
const double getIntegrand_dsigmaBox_strange192(double x) const
Definition: StandardModel/src/StandardModel.cpp:9166
StandardModel::N_nu
virtual const double N_nu() const
The number of neutrinos obtained indirectly from the measurements at the Z pole, .
Definition: StandardModel/src/StandardModel.cpp:1562
StandardModel::getIntegrand_sigmaWithISR_down189
const double getIntegrand_sigmaWithISR_down189(double x) const
Definition: StandardModel/src/StandardModel.cpp:8372
StandardModel::TauLFU_gmuge
virtual const double TauLFU_gmuge() const
The computation of the LFU ratio .
Definition: StandardModel/src/StandardModel.cpp:3171
StandardModel::ThetaLnuN
virtual const double ThetaLnuN() const
The effective neutrino nucleon LH parameter: ThetaLnuN.
Definition: StandardModel/src/StandardModel.cpp:3034
StandardModel::getIntegrand_dsigmaBox_charm196
const double getIntegrand_dsigmaBox_charm196(double x) const
Definition: StandardModel/src/StandardModel.cpp:9082
StandardModel::checkSMparamsForEWPO
bool checkSMparamsForEWPO()
A method to check whether the parameters relevant to the EWPO are updated.
Definition: StandardModel/src/StandardModel.cpp:562
StandardModel::getIntegrand_dsigmaBox_bottom161
const double getIntegrand_dsigmaBox_bottom161(double x) const
Definition: StandardModel/src/StandardModel.cpp:9224
StandardModel::BrHtoss
virtual const double BrHtoss() const
The Br in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3692
StandardModel::getIntegrand_sigmaWithISR_up207
const double getIntegrand_sigmaWithISR_up207(double x) const
Definition: StandardModel/src/StandardModel.cpp:8320
StandardModel::Alstilde5
const double Alstilde5(const double mu) const
The value of at any scale with the number of flavours and full EW corrections.
Definition: StandardModel/src/StandardModel.cpp:951
StandardModel::getIntegrand_sigmaWithISR_charm196
const double getIntegrand_sigmaWithISR_charm196(double x) const
Definition: StandardModel/src/StandardModel.cpp:8472
StandardModel::getIntegrand_AFBnumeratorWithISR_tau205
const double getIntegrand_AFBnumeratorWithISR_tau205(double x) const
Definition: StandardModel/src/StandardModel.cpp:9447
StandardModel::getIntegrand_sigmaWithISR_mu189
const double getIntegrand_sigmaWithISR_mu189(double x) const
Definition: StandardModel/src/StandardModel.cpp:8103
StandardModel::getIntegrand_sigmaWithISR_mu196
const double getIntegrand_sigmaWithISR_mu196(double x) const
Definition: StandardModel/src/StandardModel.cpp:8115
StandardModel::getIntegrand_AFBnumeratorWithISR_bottom167
const double getIntegrand_AFBnumeratorWithISR_bottom167(double x) const
Definition: StandardModel/src/StandardModel.cpp:9551
StandardModel::getIntegrand_sigmaWithISR_tau202
const double getIntegrand_sigmaWithISR_tau202(double x) const
Definition: StandardModel/src/StandardModel.cpp:8200
StandardModel::Mw_inp
double Mw_inp
The mass of the boson in GeV used as input for FlagMWinput = TRUE.
Definition: StandardModel.h:3479
StandardModel::getIntegrand_dsigmaBox_charm172
const double getIntegrand_dsigmaBox_charm172(double x) const
Definition: StandardModel/src/StandardModel.cpp:9058
StandardModel::orders_EW
orders_EW
An enumerated type representing perturbative orders of radiative corrections to EW precision observab...
Definition: StandardModel.h:539
StandardModel::EW1
@ EW1
One-loop of .
Definition: StandardModel.h:540
StandardModel::EW2QCD1
@ EW2QCD1
Three-loop of .
Definition: StandardModel.h:544
StandardModel::EW2
@ EW2
Two-loop of .
Definition: StandardModel.h:543
StandardModel::orders_EW_size
@ orders_EW_size
The size of this enum.
Definition: StandardModel.h:546
StandardModel::EW3
@ EW3
Three-loop of .
Definition: StandardModel.h:545
StandardModel::EW1QCD1
@ EW1QCD1
Two-loop of .
Definition: StandardModel.h:541
StandardModel::EW1QCD2
@ EW1QCD2
Three-loop of .
Definition: StandardModel.h:542
StandardModel::getIntegrand_dsigmaBox_charm136
const double getIntegrand_dsigmaBox_charm136(double x) const
Definition: StandardModel/src/StandardModel.cpp:9040
StandardModel::mHl
double mHl
The Higgs mass in GeV.
Definition: StandardModel.h:3483
StandardModel::getIntegrand_sigmaWithISR_up205
const double getIntegrand_sigmaWithISR_up205(double x) const
Definition: StandardModel/src/StandardModel.cpp:8314
StandardModel::getIntegrand_AFBnumeratorWithISR_charm196
const double getIntegrand_AFBnumeratorWithISR_charm196(double x) const
Definition: StandardModel/src/StandardModel.cpp:9512
StandardModel::AH_W
gslpp::complex AH_W(const double tau) const
W loop function entering in the calculation of the effective coupling.
Definition: StandardModel/src/StandardModel.cpp:3306
StandardModel::SchemeToDouble
double SchemeToDouble(const std::string scheme) const
A method to convert a given scheme name in string form into a floating-point number with double preci...
Definition: StandardModel.h:3531
StandardModel::getIntegrand_sigmaWithISR_bottom167
const double getIntegrand_sigmaWithISR_bottom167(double x) const
Definition: StandardModel/src/StandardModel.cpp:8618
StandardModel::getIntegrand_dsigmaBox_charm133
const double getIntegrand_dsigmaBox_charm133(double x) const
Definition: StandardModel/src/StandardModel.cpp:9034
StandardModel::getIntegrand_dsigmaBox_charm192
const double getIntegrand_dsigmaBox_charm192(double x) const
Definition: StandardModel/src/StandardModel.cpp:9076
StandardModel::getIntegrand_dsigmaBox_tau207
const double getIntegrand_dsigmaBox_tau207(double x) const
Definition: StandardModel/src/StandardModel.cpp:8830
StandardModel::ale
double ale
The fine-structure constant .
Definition: StandardModel.h:3481
StandardModel::flagLEP2
bool flagLEP2[NUMofLEP2RCs]
Definition: StandardModel.h:3762
StandardModel::DeltaAlphaL5q
const double DeltaAlphaL5q() const
The sum of the leptonic and the five-flavour hadronic corrections to the electromagnetic coupling at...
Definition: StandardModel/src/StandardModel.cpp:907
StandardModel::getIntegrand_sigmaWithISR_bottom183
const double getIntegrand_sigmaWithISR_bottom183(double x) const
Definition: StandardModel/src/StandardModel.cpp:8630
StandardModel::AlsMz
double AlsMz
The strong coupling constant at the Z-boson mass, .
Definition: StandardModel.h:3477
StandardModel::delGammaZ
double delGammaZ
The theoretical uncertainty in , denoted as , in GeV.
Definition: StandardModel.h:3488
StandardModel::getIntegrand_AFBnumeratorWithISR_mu161
const double getIntegrand_AFBnumeratorWithISR_mu161(double x) const
Definition: StandardModel/src/StandardModel.cpp:9326
StandardModel::Ye
gslpp::matrix< gslpp::complex > Ye
The Yukawa matrix of the charged leptons.
Definition: StandardModel.h:3473
StandardModel::getIntegrand_dsigmaBox_down196
const double getIntegrand_dsigmaBox_down196(double x) const
Definition: StandardModel/src/StandardModel.cpp:8994
StandardModel::PostUpdate
virtual bool PostUpdate()
The post-update method for StandardModel.
Definition: StandardModel/src/StandardModel.cpp:243
StandardModel::getIntegrand_dsigmaBox_charm189
const double getIntegrand_dsigmaBox_charm189(double x) const
Definition: StandardModel/src/StandardModel.cpp:9070
StandardModel::sW2_ND
const double sW2_ND() const
The square of the sine of the weak mixing angle in the MSbar-ND scheme (w/o decoupling $\alpha\ln(m_t...
Definition: StandardModel/src/StandardModel.cpp:1109
StandardModel::muw
double muw
A matching scale around the weak scale in GeV.
Definition: StandardModel.h:3504
StandardModel::RVh
double RVh() const
The singlet vector corrections to the hadronic -boson width, denoted as .
Definition: StandardModel/src/StandardModel.cpp:2414
StandardModel::useRhoZ_f_cache
bool useRhoZ_f_cache[12]
Definition: StandardModel.h:4089
StandardModel::alphaMz
virtual const double alphaMz() const
The electromagnetic coupling at the -mass scale, .
Definition: StandardModel/src/StandardModel.cpp:944
StandardModel::delR0b
double delR0b
The theoretical uncertainty in , denoted as .
Definition: StandardModel.h:3492
StandardModel::getIntegrand_AFBnumeratorWithISR_bottom133
const double getIntegrand_AFBnumeratorWithISR_bottom133(double x) const
Definition: StandardModel/src/StandardModel.cpp:9545
StandardModel::DeltaAlpha
const double DeltaAlpha() const
The total corrections to the electromagnetic coupling at the -mass scale, denoted as .
Definition: StandardModel/src/StandardModel.cpp:932
StandardModel::getIntegrand_sigmaWithISR_up161
const double getIntegrand_sigmaWithISR_up161(double x) const
Definition: StandardModel/src/StandardModel.cpp:8260
StandardModel::setParameter
virtual void setParameter(const std::string name, const double &value)
A method to set the value of a parameter of StandardModel.
Definition: StandardModel/src/StandardModel.cpp:280
StandardModel::f_triangle
gslpp::complex f_triangle(const double tau) const
Loop function entering in the calculation of the effective and couplings.
Definition: StandardModel/src/StandardModel.cpp:3262
StandardModel::getIntegrand_dsigmaBox_mu130
const double getIntegrand_dsigmaBox_mu130(double x) const
Definition: StandardModel/src/StandardModel.cpp:8688
StandardModel::getIntegrand_sigmaWithISR_mu200
const double getIntegrand_sigmaWithISR_mu200(double x) const
Definition: StandardModel/src/StandardModel.cpp:8121
StandardModel::getIntegrand_dsigmaBox_charm207
const double getIntegrand_dsigmaBox_charm207(double x) const
Definition: StandardModel/src/StandardModel.cpp:9106
StandardModel::CacheSize
static const int CacheSize
Defines the depth of the cache.
Definition: StandardModel.h:4112
StandardModel::getIntegrand_AFBnumeratorWithISR_tau189
const double getIntegrand_AFBnumeratorWithISR_tau189(double x) const
Definition: StandardModel/src/StandardModel.cpp:9417
StandardModel::NumSMParamsForEWPO
static const int NumSMParamsForEWPO
The number of the SM parameters that are relevant to the EW precision observables.
Definition: StandardModel.h:2132
StandardModel::getIntegrand_sigmaWithISR_tau172
const double getIntegrand_sigmaWithISR_tau172(double x) const
Definition: StandardModel/src/StandardModel.cpp:8164
StandardModel::Vus
double Vus
used as an input for FlagWolfenstein = FALSE
Definition: StandardModel.h:3499
StandardModel::GammaHtoWWstar
virtual const double GammaHtoWWstar() const
The in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3416
StandardModel::getIntegrand_AFBnumeratorWithISR_charm167
const double getIntegrand_AFBnumeratorWithISR_charm167(double x) const
Definition: StandardModel/src/StandardModel.cpp:9482
StandardModel::getIntegrand_sigmaWithISR_mu183
const double getIntegrand_sigmaWithISR_mu183(double x) const
Definition: StandardModel/src/StandardModel.cpp:8097
StandardModel::myTwoLoopQCD
EWSMTwoLoopQCD * myTwoLoopQCD
A pointer to an object of type EWSMTwoLoopQCD.
Definition: StandardModel.h:4050
StandardModel::LEP2dsigmadcosTau
virtual const double LEP2dsigmadcosTau(const double s, const double cos) const
Definition: StandardModel/src/StandardModel.cpp:9641
StandardModel::GammaHtomumu
virtual const double GammaHtomumu() const
The in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3534
StandardModel::getIntegrand_AFBnumeratorWithISR_tau161
const double getIntegrand_AFBnumeratorWithISR_tau161(double x) const
Definition: StandardModel/src/StandardModel.cpp:9399
StandardModel::GeVminus2_to_nb
static const double GeVminus2_to_nb
Definition: StandardModel.h:558
StandardModel::FlagWolfenstein
bool FlagWolfenstein
A boolean for the model flag Wolfenstein.
Definition: StandardModel.h:4066
StandardModel::getIntegrand_sigmaWithISR_down172
const double getIntegrand_sigmaWithISR_down172(double x) const
Definition: StandardModel/src/StandardModel.cpp:8360
StandardModel::LEP2sigmaBottom
virtual const double LEP2sigmaBottom(const double s) const
Definition: StandardModel/src/StandardModel.cpp:4825
StandardModel::getmq
virtual const double getmq(const QCD::quark q, const double mu) const
The MSbar running quark mass computed at NLO.
Definition: StandardModel.h:3342
StandardModel::getIntegrand_dsigmaBox_tau130
const double getIntegrand_dsigmaBox_tau130(double x) const
Definition: StandardModel/src/StandardModel.cpp:8764
StandardModel::DeltaRbar
virtual const double DeltaRbar() const
The SM prediction for derived from that for the -boson mass.
Definition: StandardModel/src/StandardModel.cpp:1228
StandardModel::getIntegrand_dsigmaBox_strange133
const double getIntegrand_dsigmaBox_strange133(double x) const
Definition: StandardModel/src/StandardModel.cpp:9122
StandardModel::getIntegrand_dsigmaBox_tau205
const double getIntegrand_dsigmaBox_tau205(double x) const
Definition: StandardModel/src/StandardModel.cpp:8824
StandardModel::requireYe
bool requireYe
An internal flag to control whether the charged-lepton Yukawa matrix has to be recomputed.
Definition: StandardModel.h:3749
StandardModel::myThreeLoopEW2QCD
EWSMThreeLoopEW2QCD * myThreeLoopEW2QCD
A pointer to an object of type EWSMThreeLoopEW2QCD.
Definition: StandardModel.h:4053
StandardModel::getIntegrand_dsigmaBox_charm200
const double getIntegrand_dsigmaBox_charm200(double x) const
Definition: StandardModel/src/StandardModel.cpp:9088
StandardModel::v
const double v() const
The Higgs vacuum expectation value.
Definition: StandardModel/src/StandardModel.cpp:995
StandardModel::getIntegrand_sigmaWithISR_up196
const double getIntegrand_sigmaWithISR_up196(double x) const
Definition: StandardModel/src/StandardModel.cpp:8296
StandardModel::getIntegrand_dsigmaBox_up196
const double getIntegrand_dsigmaBox_up196(double x) const
Definition: StandardModel/src/StandardModel.cpp:8907
StandardModel::getIntegrand_sigmaWithISR_bottom189
const double getIntegrand_sigmaWithISR_bottom189(double x) const
Definition: StandardModel/src/StandardModel.cpp:8636
StandardModel::getIntegrand_AFBnumeratorWithISR_bottom183
const double getIntegrand_AFBnumeratorWithISR_bottom183(double x) const
Definition: StandardModel/src/StandardModel.cpp:9563
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::getIntegrand_sigmaWithISR_bottom161
const double getIntegrand_sigmaWithISR_bottom161(double x) const
Definition: StandardModel/src/StandardModel.cpp:8612
StandardModel::AHZga_f
gslpp::complex AHZga_f(const double tau, const double lambda) const
Fermionic loop function entering in the calculation of the effective coupling.
Definition: StandardModel/src/StandardModel.cpp:3310
StandardModel::getIntegrand_sigmaWithISR_mu192
const double getIntegrand_sigmaWithISR_mu192(double x) const
Definition: StandardModel/src/StandardModel.cpp:8109
StandardModel::getIntegrand_dsigmaBox_up189
const double getIntegrand_dsigmaBox_up189(double x) const
Definition: StandardModel/src/StandardModel.cpp:8895
StandardModel::MwbarFromMw
const double MwbarFromMw(const double Mw) const
A method to convert the -boson mass in the experimental/running-width scheme to that in the complex-p...
Definition: StandardModel/src/StandardModel.cpp:1210
StandardModel::getIntegrand_AFBnumeratorWithISR_mu183
const double getIntegrand_AFBnumeratorWithISR_mu183(double x) const
Definition: StandardModel/src/StandardModel.cpp:9338
StandardModel::getIntegrand_dsigmaBox_up136
const double getIntegrand_dsigmaBox_up136(double x) const
Definition: StandardModel/src/StandardModel.cpp:8865
StandardModel::useKappaZ_f_cache
bool useKappaZ_f_cache[12]
Definition: StandardModel.h:4090
StandardModel::getIntegrand_dsigmaBox_charm202
const double getIntegrand_dsigmaBox_charm202(double x) const
Definition: StandardModel/src/StandardModel.cpp:9094
StandardModel::ThetaRnuN
virtual const double ThetaRnuN() const
The effective neutrino nucleon RH parameter: ThetaRnuN.
Definition: StandardModel/src/StandardModel.cpp:3048
StandardModel::intMLL2eeeeus2
const double intMLL2eeeeus2(const double s, const double t0, const double t1) const
Definition: StandardModel/src/StandardModel.cpp:3973
StandardModel::DeltaAlphaLepton
const double DeltaAlphaLepton(const double s) const
Leptonic contribution to the electromagnetic coupling , denoted as .
Definition: StandardModel/src/StandardModel.cpp:879
StandardModel::getIntegrand_sigmaWithISR_charm189
const double getIntegrand_sigmaWithISR_charm189(double x) const
Definition: StandardModel/src/StandardModel.cpp:8460
StandardModel::getIntegrand_sigmaWithISR_down205
const double getIntegrand_sigmaWithISR_down205(double x) const
Definition: StandardModel/src/StandardModel.cpp:8402
StandardModel::gV_f
virtual const gslpp::complex gV_f(const Particle f) const
The effective leptonic neutral-current vector coupling in the SM.
Definition: StandardModel/src/StandardModel.cpp:1583
StandardModel::getIntegrand_dsigmaBox_up172
const double getIntegrand_dsigmaBox_up172(double x) const
Definition: StandardModel/src/StandardModel.cpp:8883
StandardModel::getIntegrand_sigmaWithISR_up130
const double getIntegrand_sigmaWithISR_up130(double x) const
Definition: StandardModel/src/StandardModel.cpp:8242
StandardModel::MLR2eeff
const double MLR2eeff(const Particle f, const double s) const
Definition: StandardModel/src/StandardModel.cpp:3709
StandardModel::gAnue
virtual const double gAnue() const
The effective (muon) neutrino-electron axial-vector coupling: gAnue.
Definition: StandardModel/src/StandardModel.cpp:3074
StandardModel::FlagCacheInStandardModel
bool FlagCacheInStandardModel
A flag for caching (true by default).
Definition: StandardModel.h:4077
StandardModel::SMSuccess
bool SMSuccess
A boolean for the success of the Standard Model update and matching.
Definition: StandardModel.h:4072
StandardModel::InitializeModel
virtual bool InitializeModel()
A method to initialize the model.
Definition: StandardModel/src/StandardModel.cpp:176
StandardModel::resumMw
double resumMw(const double Mw_i, const double DeltaRho[orders_EW_size], const double DeltaR_rem[orders_EW_size]) const
A method to compute the -boson mass from and .
Definition: StandardModel/src/StandardModel.cpp:1876
StandardModel::getIntegrand_AFBnumeratorWithISR_charm192
const double getIntegrand_AFBnumeratorWithISR_charm192(double x) const
Definition: StandardModel/src/StandardModel.cpp:9506
StandardModel::getIntegrand_dsigmaBox_down205
const double getIntegrand_dsigmaBox_down205(double x) const
Definition: StandardModel/src/StandardModel.cpp:9012
StandardModel::cW2
virtual const double cW2() const
Definition: StandardModel/src/StandardModel.cpp:1087
StandardModel::getIntegrand_dsigmaBox_down192
const double getIntegrand_dsigmaBox_down192(double x) const
Definition: StandardModel/src/StandardModel.cpp:8988
StandardModel::GammaHTot
virtual const double GammaHTot() const
The total Higgs width in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3636
StandardModel::LEP2AFBbottom
virtual const double LEP2AFBbottom(const double s) const
Definition: StandardModel/src/StandardModel.cpp:6168
StandardModel::DeltaAlpha_cache
double DeltaAlpha_cache
A cache of the value of .
Definition: StandardModel.h:4080
StandardModel::gVnue
virtual const double gVnue() const
The effective (muon) neutrino-electron vector coupling: gVnue.
Definition: StandardModel/src/StandardModel.cpp:3061
StandardModel::AlsEWithInit
const double AlsEWithInit(double mu, double alsi, double mu_i, const int nf_i, orders order) const
Definition: StandardModel/src/StandardModel.cpp:755
StandardModel::delR0l
double delR0l
The theoretical uncertainty in , denoted as .
Definition: StandardModel.h:3490
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::getIntegrand_sigmaWithISR_down161
const double getIntegrand_sigmaWithISR_down161(double x) const
Definition: StandardModel/src/StandardModel.cpp:8348
StandardModel::getIntegrand_dsigmaBox_bottom136
const double getIntegrand_dsigmaBox_bottom136(double x) const
Definition: StandardModel/src/StandardModel.cpp:9218
deltae
An observable class for the relative deviation from the SM of the EM coupling .
Definition: NP_couplings.h:3647
mtpole
A class for , the pole mass of the top quark.
Definition: masses.h:164
s
Test Observable.
sin2thetaEff
An observable class for the leptonic effective weak mixing angle at the pole. To be used for the el...
Definition: sin2thetaEff.h:29
t
Test Observable.
xi
A class for , relevant for mesons mixing in the Standard Model.
Definition: xi.h:23
orders
orders
An enum type for orders in QCD.
Definition: OrderScheme.h:33