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",
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("mneutrino_1", std::cref(leptons[NEUTRINO_1].getMass())));
135 ModelParamMap.insert(std::make_pair("mneutrino_2", std::cref(leptons[NEUTRINO_2].getMass())));
136 ModelParamMap.insert(std::make_pair("mneutrino_3", std::cref(leptons[NEUTRINO_3].getMass())));
137 ModelParamMap.insert(std::make_pair("melectron", std::cref(leptons[ELECTRON].getMass())));
138 ModelParamMap.insert(std::make_pair("mmu", std::cref(leptons[MU].getMass())));
139 ModelParamMap.insert(std::make_pair("mtau", std::cref(leptons[TAU].getMass())));
140 ModelParamMap.insert(std::make_pair("lambda", std::cref(lambda)));
141 ModelParamMap.insert(std::make_pair("A", std::cref(A)));
142 ModelParamMap.insert(std::make_pair("rhob", std::cref(rhob)));
143 ModelParamMap.insert(std::make_pair("etab", std::cref(etab)));
144 ModelParamMap.insert(std::make_pair("muw", std::cref(muw)));
145
146 iterationNo = 0;
147 realorder = LO;
148
149 w_GSL1 = gsl_integration_workspace_alloc (200);
150}
151
152StandardModel::~StandardModel()
153{
154 if (IsModelInitialized()) {
155 if (myEWSMcache != NULL) delete(myEWSMcache);
156 if (myOneLoopEW != NULL) delete(myOneLoopEW);
157 if (myTwoLoopQCD != NULL) delete(myTwoLoopQCD);
158 if (myThreeLoopQCD != NULL) delete(myThreeLoopQCD);
159 if (myTwoLoopEW != NULL) delete(myTwoLoopEW);
160 if (myThreeLoopEW2QCD != NULL) delete(myThreeLoopEW2QCD);
161 if (myThreeLoopEW != NULL) delete(myThreeLoopEW);
162 if (myApproximateFormulae != NULL) delete(myApproximateFormulae);
163 if (myLeptonFlavour != NULL) delete(myLeptonFlavour);
164 /* BEGIN: REMOVE FROM THE PACKAGE */
165 if (myTwoFermionsLEP2 != NULL) delete(myTwoFermionsLEP2);
166 /* END: REMOVE FROM THE PACKAGE */
167 }
168}
169
170
172// Initialization
173
174bool StandardModel::InitializeModel()
175{
176 myEWSMcache = new EWSMcache(*this);
177 myOneLoopEW = new EWSMOneLoopEW(*myEWSMcache);
178 myTwoLoopQCD = new EWSMTwoLoopQCD(*myEWSMcache);
179 myThreeLoopQCD = new EWSMThreeLoopQCD(*myEWSMcache);
180 myTwoLoopEW = new EWSMTwoLoopEW(*myEWSMcache);
181 myThreeLoopEW2QCD = new EWSMThreeLoopEW2QCD(*myEWSMcache);
182 myThreeLoopEW = new EWSMThreeLoopEW(*myEWSMcache);
183 myApproximateFormulae = new EWSMApproximateFormulae(*myEWSMcache);
184 myLeptonFlavour = new LeptonFlavour(*this);
185 /* BEGIN: REMOVE FROM THE PACKAGE */
186 myTwoFermionsLEP2 = new EWSMTwoFermionsLEP2(*myEWSMcache);
187 /* END: REMOVE FROM THE PACKAGE */
188 setModelInitialized(true);
189 return (true);
190}
191
192
194// Parameters
195
196bool StandardModel::Init(const std::map<std::string, double>& DPars)
197{
198 for (std::map<std::string, double>::const_iterator it = DPars.begin(); it != DPars.end(); it++)
199 if (it->first.compare("AlsM") == 0 || it->first.compare("MAls") == 0)
200 throw std::runtime_error("ERROR: inappropriate parameter " + it->first
201 + " in model initialization");
202 else if (FlagFixMuwMut && it->first.compare("mut") == 0)
203 throw std::runtime_error("ERROR: cannot use " + it->first
204 + " when FlagFixMuwMut is true: use only muw");
205
206 std::map<std::string, double> myDPars(DPars);
207 myDPars["AlsM"] = myDPars.at("AlsMz"); // do not change!
208 myDPars["MAls"] = myDPars.at("Mz");
209 if (FlagFixMuwMut)
210 myDPars["mut"] = myDPars.at("muw") * 163. / 80.4 ;
211 return (QCD::Init(myDPars));
212}
213
214bool StandardModel::PreUpdate()
215{
216 requireCKM = false;
217 requireYe = false;
218 requireYn = false;
219
220 if (!QCD::PreUpdate()) return (false);
221
222 return (true);
223}
224
225bool StandardModel::Update(const std::map<std::string, double>& DPars)
226{
227 if (!PreUpdate()) return (false);
228
229 UpdateError = false;
230
231 for (std::map<std::string, double>::const_iterator it = DPars.begin(); it != DPars.end(); it++)
232 setParameter(it->first, it->second);
233
234 if (UpdateError) return (false);
235
236 if (!PostUpdate()) return (false);
237
238 return (true);
239}
240
241bool StandardModel::PostUpdate()
242{
243 if (!QCD::PostUpdate()) return (false);
244
245 SMSuccess = true;
246 /* Set the CKM and PMNS matrices if not already set in the derived classes */
247 if(requireCKM)
248 computeCKM();
249
250 /* Compute the 5-quark contribution to the running of alpha*/
251 dAl5hMz = Dalpha5hMz();
252
253 /* Set the Yukawa matrices */
254 if (!isModelSUSY()) {
255 computeYukawas();
256 }
257
258 /* Check whether the parameters for the EWPO are updated or not */
259 if (!checkSMparamsForEWPO()) {
260 useDeltaAlphaLepton_cache = false;
261 useDeltaAlpha_cache = false;
262 useMw_cache = false;
263 useGammaW_cache = false;
264 for (int i = 0; i < 12; ++i) {
265 useRhoZ_f_cache[i] = false;
266 useKappaZ_f_cache[i] = false;
267 }
268 }
269 SMFlavour.setSMupdated();
270 /* Necessary for updating StandardModel parameters in StandardModelMatching */
271 if (!isModelSUSY()) SMM.getObj().updateSMParameters();
272
273 iterationNo++;
274
275 return (true);
276}
277
278void StandardModel::setParameter(const std::string name, const double& value)
279{
280 if (name.compare("Mz") == 0) {
281 Mz = value;
282 QCD::setParameter("MAls", value);
283 } else if (name.compare("AlsMz") == 0) {
284 AlsMz = value;
285 QCD::setParameter("AlsM", value);
286 } else if (name.compare("GF") == 0)
287 GF = value;
288 else if (name.compare("ale") == 0)
289 ale = value;
290 else if (name.compare("dAle5Mz") == 0 && !FlagMWinput)
291 dAle5Mz = value;
292 else if (name.compare("Mw_inp") == 0 && FlagMWinput)
293 Mw_inp = value;
294 else if (name.compare("mHl") == 0)
295 mHl = value;
296 else if (name.compare("delMw") == 0)
297 delMw = value;
298 else if (name.compare("delSin2th_l") == 0)
299 delSin2th_l = value;
300 else if (name.compare("delSin2th_q") == 0)
301 delSin2th_q = value;
302 else if (name.compare("delSin2th_b") == 0)
303 delSin2th_b = value;
304 else if (name.compare("delGammaZ") == 0)
305 delGammaZ = value;
306 else if (name.compare("delsigma0H") == 0)
307 delsigma0H = value;
308 else if (name.compare("delR0l") == 0)
309 delR0l = value;
310 else if (name.compare("delR0c") == 0)
311 delR0c = value;
312 else if (name.compare("delR0b") == 0)
313 delR0b = value;
314 else if (name.compare("mneutrino_1") == 0)
315 leptons[NEUTRINO_1].setMass(value);
316 else if (name.compare("mneutrino_2") == 0)
317 leptons[NEUTRINO_2].setMass(value);
318 else if (name.compare("mneutrino_3") == 0)
319 leptons[NEUTRINO_3].setMass(value);
320 else if (name.compare("melectron") == 0)
321 leptons[ELECTRON].setMass(value);
322 else if (name.compare("mmu") == 0)
323 leptons[MU].setMass(value);
324 else if (name.compare("mtau") == 0)
325 leptons[TAU].setMass(value);
326 else if (name.compare("lambda") == 0 && FlagWolfenstein) {
327 lambda = value;
328 requireCKM = true;
329 } else if (name.compare("A") == 0 && FlagWolfenstein) {
330 A = value;
331 requireCKM = true;
332 } else if (name.compare("rhob") == 0 && FlagWolfenstein) {
333 rhob = value;
334 requireCKM = true;
335 } else if (name.compare("etab") == 0 && FlagWolfenstein) {
336 etab = value;
337 requireCKM = true;
338 } else if (name.compare("V_us") == 0 && !FlagWolfenstein && !FlagUseVud) {
339 Vus = value;
340 requireCKM = true;
341 } else if (name.compare("V_ud") == 0 && !FlagWolfenstein && FlagUseVud) {
342 Vud = value;
343 requireCKM = true;
344 } else if (name.compare("V_cb") == 0 && !FlagWolfenstein) {
345 Vcb = value;
346 requireCKM = true;
347 } else if (name.compare("V_ub") == 0 && !FlagWolfenstein) {
348 Vub = value;
349 requireCKM = true;
350 } else if (name.compare("gamma") == 0 && !FlagWolfenstein) {
351 gamma = value;
352 requireCKM = true;
353 } else if (name.compare("muw") == 0) {
354 /* Update mut if FlagFixMuwMut is activated */
355 muw = value;
356 if (FlagFixMuwMut) {
357 mut = muw / 80.4 * 163.;
358 }
359 }
360 else
361 QCD::setParameter(name, value);
362}
363
364bool StandardModel::CheckParameters(const std::map<std::string, double>& DPars)
365{
366 for (int i = 0; i < NSMvars; i++) {
367 if (DPars.find(SMvars[i]) == DPars.end()) {
368 std::cout << "ERROR: missing mandatory SM parameter " << SMvars[i] << std::endl;
369 raiseMissingModelParameterCount();
370 addMissingModelParameter(SMvars[i]);
371 }
372 }
373 return (QCD::CheckParameters(DPars));
374}
375
376void StandardModel::computeCKM()
377{
378 if (requireCKM) {
379 if (FlagWolfenstein) {
380 myCKM.computeCKMwithWolfenstein(lambda, A, rhob, etab);
381 Vus = myCKM.getV_us().abs();
382 Vcb = myCKM.getV_cb().abs();
383 Vub = myCKM.getV_ub().abs();
384 gamma = myCKM.computeGamma();
385 } else if (FlagUseVud) {
386 myCKM.computeCKM(Vud, Vcb, Vub, gamma, FlagUseVud);
387 lambda = myCKM.getLambda();
388 A = myCKM.getA();
389 rhob = myCKM.getRhoBar();
390 etab = myCKM.getEtaBar();
391 Vus = myCKM.getV_us().abs();
392 } else {
393 myCKM.computeCKM(Vus, Vcb, Vub, gamma);
394 lambda = myCKM.getLambda();
395 A = myCKM.getA();
396 rhob = myCKM.getRhoBar();
397 etab = myCKM.getEtaBar();
398 Vud = myCKM.getV_ud().abs();
399 }
400 }
401 myPMNS.computePMNS(s12, s13, s23, delta, alpha21, alpha31); // WARNING: This does not do anything since the input values are not set.
402}
403
405
406
407
408
409
410void StandardModel::computeYukawas()
411{
412 if (requireYu || requireCKM) {
413 Yu.reset();
414 for (int i = 0; i < 3; i++) {
415 Yu.assign(i, i, this->getmq(quark(UP + 2 * i), v()/ sqrt(2.))/ v() * sqrt(2.));
416// std::cout << quarks[UP + 2 * i].getName() << " mass at EW scale is " << this->getmq(quark(UP + 2 * i), v() / sqrt(2.)) << std::endl;
417 }
418// std::cout << "(top MSbar mass is " << this->Mp2Mbar(this->getMtpole()) << ")" << std::endl;
419 Yu = Yu * myCKM.getCKM();
420 }
421 if (requireYd) {
422 Yd.reset();
423 for (int i = 0; i < 3; i++) {
424 Yd.assign(i, i, this->getmq(quark(DOWN + 2 * i), v() / sqrt(2.)) / v() * sqrt(2.));
425// std::cout << quarks[DOWN + 2 * i].getName() << " mass at " << v() / sqrt(2) << " is " << this->getmq(quark(DOWN + 2 * i), v() / sqrt(2.)) << std::endl;
426 }
427 }
428 if (requireYe) {
429 Ye = gslpp::matrix<gslpp::complex>::Id(3);
430 for (int i = 0; i < 3; i++)
431 Ye.assign(i, i, this->leptons[ELECTRON + 2 * i].getMass() / v() * sqrt(2.));
432 }
433 if (requireYn) {
434 Yn = gslpp::matrix<gslpp::complex>::Id(3);
435 for (int i = 0; i < 3; i++)
436 Yn.assign(i, i, this->leptons[NEUTRINO_1 + 2 * i].getMass() / v() * sqrt(2.));
437 Yn = Yn * myPMNS.getPMNS().hconjugate();
438 }
439}
440
441
442
443bool StandardModel::setFlag(const std::string name, const bool value)
444{
445 bool res = false;
446 if (name.compare("CacheInStandardModel") == 0) {
447 setFlagCacheInStandardModel(value);
448 res = true;
449 } else if (name.compare("CacheInEWSMcache") == 0) {
450 getMyEWSMcache()->setFlagCacheInEWSMcache(value);
451 res = true;
452 } else if (name.compare("Wolfenstein") == 0) {
453 FlagWolfenstein = value;
454 if(!FlagWolfenstein) {
455 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"lambda"))] = "V_us";
456 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"A"))] = "V_cb";
457 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"rhob"))] = "V_ub";
458 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"etab"))] = "gamma";
459
460 ModelParamMap.insert(std::make_pair("V_us", std::cref(Vus)));
461 ModelParamMap.insert(std::make_pair("V_cb", std::cref(Vcb)));
462 ModelParamMap.insert(std::make_pair("V_ub", std::cref(Vub)));
463 ModelParamMap.insert(std::make_pair("gamma", std::cref(gamma)));
464 }
465 res = true;
466 } else if (name.compare("WithoutNonUniversalVC") == 0) {
467 FlagWithoutNonUniversalVC = value;
468 res = true;
469 } else if (name.compare("NoApproximateGammaZ") == 0) {
470 FlagNoApproximateGammaZ = value;
471 res = true;
472 } else if (name.compare("MWinput") == 0) {
473 FlagMWinput = value;
474 if (FlagMWinput) {
475 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"dAle5Mz"))] = "Mw_inp";
476 ModelParamMap.insert(std::make_pair("Mw_inp", std::cref(Mw_inp)));
477 // Point the different flags towards the approximate formulae, when available
478 FlagNoApproximateGammaZ = false;
479 FlagMw = "APPROXIMATEFORMULA";
480 FlagRhoZ = "NORESUM";
481 FlagKappaZ = "APPROXIMATEFORMULA";
482 }
483 res = true;
484 } else if (name.compare("SMAux") == 0) {
485 FlagSMAux = value;
486 res = true;
487 } else if (name.compare("FixMuwMut") == 0) {
488 FlagFixMuwMut = value;
489 res = true;
490 } else if (name.compare("UseVud") == 0) {
491 FlagUseVud = value;
492 if (FlagUseVud && FlagWolfenstein)
493 throw std::runtime_error("UseVud can only be used when Wolfenstein is false");
494 else if(FlagUseVud) {
495 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"V_us"))] = "V_ud";
496 ModelParamMap.erase("V_us");
497 ModelParamMap.insert(std::make_pair("V_ud", std::cref(Vud)));
498 }
499 res = true;
500 } else
501 res = QCD::setFlag(name, value);
502
503 if (!res) res = SMFlavour.setFlag(name, value);
504
505 return (res);
506}
507
508bool StandardModel::setFlagStr(const std::string name, const std::string value)
509{
510 bool res = false;
511 if (name.compare("Mw") == 0) {
512 if (checkEWPOscheme(value)) {
513 FlagMw = value;
514 res = true;
515 } else
516 throw std::runtime_error("StandardModel::setFlagStr(): Invalid flag "
517 + name + "=" + value);
518
519 } else if (name.compare("RhoZ") == 0) {
520 if (checkEWPOscheme(value)) {
521 FlagRhoZ = value;
522 res = true;
523 } else
524 throw std::runtime_error("StandardModel::setFlagStr(): Invalid flag "
525 + name + "=" + value);
526 } else if (name.compare("KappaZ") == 0) {
527 if (checkEWPOscheme(value)) {
528 FlagKappaZ = value;
529 res = true;
530 } else
531 throw std::runtime_error("StandardModel::setFlagStr(): Invalid flag "
532 + name + "=" + value);
533 } else
534 res = QCD::setFlagStr(name, value);
535
536 if (FlagMWinput) {
537 // Point the different flags towards the approximate formulae, when available
538 FlagNoApproximateGammaZ = false;
539 FlagMw = "APPROXIMATEFORMULA";
540 FlagRhoZ = "NORESUM";
541 FlagKappaZ = "APPROXIMATEFORMULA";
542 }
543
544 return (res);
545}
546
547bool StandardModel::CheckFlags() const
548{
549 return (QCD::CheckFlags());
550}
551
552
554// For EWPO caches
555
556bool StandardModel::checkSMparamsForEWPO()
557{
558 // 11 parameters in QCD:
559 // AlsMz, Mz, mup, mdown, mcharm, mstrange, mtop, mbottom,
560 // mut, mub, muc
561 // 19 parameters in StandardModel
562 // GF, ale, dAle5Mz, mHl,
563 // mneutrino_1, mneutrino_2, mneutrino_3, melectron, mmu, mtau,
564 // delMw, delSin2th_l, delSin2th_q, delSin2th_b, delGammaZ, delsigma0H, delR0l, delR0c, delR0b,
565 // 3 flags in StandardModel
566 // FlagMw_cache, FlagRhoZ_cache, FlagKappaZ_cache
567
568 // Note: When modifying the array below, the constant NumSMParams has to
569 // be modified accordingly.
570 double SMparams[NumSMParamsForEWPO] = {
571 AlsMz, Mz, GF, ale, FlagMWinput? Mw_inp: dAle5Mz,
572 mHl, mtpole,
573 leptons[NEUTRINO_1].getMass(),
574 leptons[NEUTRINO_2].getMass(),
575 leptons[NEUTRINO_3].getMass(),
576 leptons[ELECTRON].getMass(),
577 leptons[MU].getMass(),
578 leptons[TAU].getMass(),
579 quarks[UP].getMass(),
580 quarks[DOWN].getMass(),
581 quarks[CHARM].getMass(),
582 quarks[STRANGE].getMass(),
583 quarks[BOTTOM].getMass(),
584 mut, mub, muc,
585 delMw, delSin2th_l, delSin2th_q, delSin2th_b, delGammaZ, delsigma0H, delR0l, delR0c, delR0b,
586 SchemeToDouble(FlagMw),
587 SchemeToDouble(FlagRhoZ),
588 SchemeToDouble(FlagKappaZ)
589 };
590
591 // check updated parameters
592 bool bNotUpdated = true;
593 for (int i = 0; i < NumSMParamsForEWPO; ++i) {
594 if (SMparamsForEWPO_cache[i] != SMparams[i]) {
595 SMparamsForEWPO_cache[i] = SMparams[i];
596 bNotUpdated &= false;
597 }
598 }
599
600 return bNotUpdated;
601}
602
604
605const double StandardModel::ale_OS(const double mu, orders order) const
606{
607 if (mu < 50.0)
608 throw std::runtime_error("out of range in StandardModel::ale_OS()");
609
610 double N = 20.0 / 3.0;
611 double beta1 = N / 3.0;
612 double beta2 = N / 4.0;
613 double alpha_ini = alphaMz();
614 double v = 1.0 + 2.0 * beta1 * alpha_ini / M_PI * log(Mz / mu);
615
616 switch (order) {
617 case LO:
618 return ( alpha_ini / v);
619 case FULLNLO:
620 return ( alpha_ini / v * (1.0 - beta2 / beta1 * alpha_ini / M_PI * log(v) / v));
621 default:
622 throw std::runtime_error("Error in StandardModel::ale_OS()");
623 }
624}
625
626const double StandardModel::Beta_s(int nm, unsigned int nf) const
627{
628 unsigned int nu = nf % 2 == 0 ? nf / 2 : nf / 2;
629 unsigned int nd = nf % 2 == 0 ? nf / 2 : 1 + nf / 2;
630 double Qu = 2. / 3., Qd = -1. / 3., Qbar2 = nu * Qu * Qu + nd * Qd * Qd,
631 Qbar4 = nu * Qu * Qu * Qu * Qu + nd * Qd * Qd * Qd * Qd;
632
633 switch(nm)
634 {
635 case 00:
636 return(Beta0((double) nf));
637 case 10:
638 return(Beta1((double) nf));
639 case 20:
640 return(Beta2((double) nf));
641 case 30:
642 return(Beta3((double) nf));
643 case 01:
644 return(-4. * TF * Qbar2 );
645 case 11:
646 return((4. * CF - 8. * CA) * TF * Qbar2 );
647 case 02:
648 return(11./3. * TF * Qbar2 * Beta_e(00, nf) + 2. * TF * Qbar4);
649 default:
650 throw std::runtime_error("StandardModel::Beta_s(): case not implemented");
651 }
652}
653
654const double StandardModel::Beta_e(int nm, unsigned int nf) const
655{
656 unsigned int nu = nf % 2 == 0 ? nf / 2 : nf / 2;
657 unsigned int nd = nf % 2 == 0 ? nf / 2 : 1 + nf / 2;
658 double Qu = 2. / 3., Qd = -1. / 3., Qbar2 = nu * Qu * Qu + nd * Qd * Qd,
659 Qbar4 = nu * Qu * Qu * Qu * Qu + nd * Qd * Qd * Qd * Qd;
660
661 switch(nm)
662 {
663 case 00:
664 return(4./3. * (Qbar2 * Nc + 3.)); // QL^2 = 1
665 case 10:
666 return(4. * (Qbar4 * Nc + 3.));
667 case 01:
668 return(4. * CF * Nc * Qbar2);
669 default:
670 throw std::runtime_error("StandardModel::Beta_e(): case not implemented");
671 }
672}
673
674const double StandardModel::AlsE(double mu, orders order, bool Nf_thr) const
675{
676 switch (order)
677 {
678 case FULLNNNLO:
679 realorder = order;
680 return (AlsByOrder(mu, LO, Nf_thr) + AlsByOrder(mu, NLO, Nf_thr) + AlsByOrder(mu, NNLO, Nf_thr) + AlsEByOrder(mu, NNNLO, Nf_thr));
681 default:
682 throw std::runtime_error("StandardModel::AlsE(): " + orderToString(order) + " is not implemented.");
683 }
684}
685
686const double StandardModel::AlsEByOrder(double mu, orders order, bool Nf_thr) const
687{
688 int i, nfAls = (int) Nf(Mz), nfmu = Nf_thr ? (int) Nf(mu) : nfAls;
689 double als, alstmp, mutmp;
690 orders fullord;
691
692 for (i = 0; i < CacheSize; ++i)
693 if ((mu == als_cache[0][i]) && ((double) order == als_cache[1][i]) &&
694 (AlsMz == als_cache[2][i]) && (Mz == als_cache[3][i]) &&
695 (mut == als_cache[4][i]) && (mub == als_cache[5][i]) &&
696 (muc == als_cache[6][i]) && (double) true == als_cache[7][i]
697 && (double) Nf_thr == als_cache[8][i] && alphaMz() == als_cache[9][i])
698 return als_cache[10][i];
699
700 switch (order)
701 {
702 case NNNLO:
703 if (nfAls == nfmu)
704 als = AlsEWithInit(mu, AlsMz, Mz, nfAls, order);
705 fullord = FullOrder(order);
706 if (nfAls > nfmu) {
707 mutmp = BelowTh(Mz);
708 alstmp = AlsEWithInit(mutmp, AlsMz, Mz, nfAls, realorder);
709 alstmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(nfAls), alstmp, nfAls, fullord)); // WARNING: QED threshold corrections not implemented yet
710 for (i = nfAls - 1; i > nfmu; i--) {
711 mutmp = BelowTh(mutmp - MEPS);
712 alstmp = AlsEWithInit(mutmp, alstmp, AboveTh(mutmp) - MEPS, i, realorder);
713 alstmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(i), alstmp, i, fullord)); // WARNING: QED threshold corrections not implemented yet
714 }
715 als = AlsEWithInit(mu, alstmp, AboveTh(mu) - MEPS, nfmu, order);
716 }
717
718 if (nfAls < nfmu) {
719 mutmp = AboveTh(Mz) - MEPS;
720 alstmp = AlsEWithInit(mutmp, AlsMz, Mz, nfAls, realorder);
721 alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(nfAls + 1), alstmp, nfAls + 1, fullord)); // WARNING: QED threshold corrections not implemented yet
722 for (i = nfAls + 1; i < nfmu; i++) {
723 mutmp = AboveTh(mutmp) - MEPS;
724 alstmp = AlsEWithInit(mutmp, alstmp, BelowTh(mutmp) + MEPS, i, realorder);
725 alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(i + 1), alstmp, i + 1, fullord)); // WARNING: QED threshold corrections not implemented yet
726 }
727 als = AlsEWithInit(mu, alstmp, BelowTh(mu) + MEPS, nfmu, order);
728 }
729
730 CacheShift(als_cache, 11);
731 als_cache[0][0] = mu;
732 als_cache[1][0] = (double) order;
733 als_cache[2][0] = AlsMz;
734 als_cache[3][0] = Mz;
735 als_cache[4][0] = mut;
736 als_cache[5][0] = mub;
737 als_cache[6][0] = muc;
738 als_cache[7][0] = (double) true;
739 als_cache[8][0] = (double) Nf_thr;
740 als_cache[9][0] = alphaMz();
741 als_cache[10][0] = als;
742
743 return als;
744 default:
745 throw std::runtime_error("StandardModel::AlsEByOrder(): " + orderToString(order) + " is not implemented.");
746 }
747}
748
749const double StandardModel::AlsEWithInit(double mu, double alsi, double mu_i, const int nf_i, orders order) const
750{
751 double nf = (double) nf_i, alei = Ale(mu_i, FULLNLO); // CHANGE ME!
752 double b00s = Beta_s(00, nf), b00e = Beta_e(00, nf);
753 double v = 1. + b00s * alsi / 2. / M_PI * log(mu / mu_i);
754 double ve = 1. - b00e * alei / 2. / M_PI * log(mu / mu_i);
755 double logv = log(v), logve = log(ve);
756 double rho = 1. / (1. + b00e * alei / b00s / alsi);
757 double als = AlsWithInit(mu, alsi, mu_i, nf, order);
758 double b01s = Beta_s(01,nf), b01s00e = b01s / b00e;
759
760 switch (order)
761 {
762 case NNNLO:
763 als += alsi * alsi * alei / 4. / 4. / M_PI / M_PI / v / v / ve * (Beta_s(02, nf) / b00e *
764 (ve - 1.) + Beta_s(11, nf) / b00s * rho * ve * (logve - logv) + b01s00e * Beta_e(10, nf) /
765 b00e * (logve - ve + 1.) + b01s * Beta_s(10, nf) / b00s / b00s * rho * logv +
766 b01s00e * Beta_e(01, nf) / b00s * (rho * ve * (logv - logve) - logv));
767 break;
768 case FULLNNNLO:
769 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));
770 default:
771 throw std::runtime_error("StandardModel::AlsEWithInit(): " + orderToString(order) + " is not implemented.");
772 }
773
774 return (als);
775}
776
777const double StandardModel::Ale(const double mu, orders order, bool Nf_thr) const
778{
779 int i, nfAle = (int) Nf(Mz), nfmu = Nf_thr ? (int) Nf(mu) : nfAle;
780 double ale, aletmp, mutmp, aleMz = alphaMz();
781 orders fullord;
782
783 for (i = 0; i < CacheSize; ++i)
784 if ((mu == ale_cache[0][i]) && ((double) order == ale_cache[1][i]) &&
785 (AlsMz == ale_cache[2][i]) && (Mz == ale_cache[3][i]) &&
786 (mut == ale_cache[4][i]) && (mub == ale_cache[5][i]) &&
787 (muc == ale_cache[6][i])
788 && (double) Nf_thr == ale_cache[7][i] && aleMz == ale_cache[8][i])
789 return ale_cache[9][i];
790
791 switch (order)
792 {
793 case FULLNLO:
794 return (Ale(mu, LO, Nf_thr) + Ale(mu, NLO, Nf_thr));
795 case FULLNNLO:
796 return (Ale(mu, LO, Nf_thr) + Ale(mu, NLO, Nf_thr) + Ale(mu, NNLO, Nf_thr));
797 case FULLNNNLO:
798 return (Ale(mu, LO, Nf_thr) + Ale(mu, NLO, Nf_thr) + Ale(mu, NNLO, Nf_thr) + Ale(mu, NNNLO, Nf_thr));
799 case LO:
800 if (nfAle == nfmu)
801 return(AleWithInit(mu, aleMz, Mz, order));
802 case NLO:
803 case NNLO:
804 case NNNLO:
805 if (nfAle == nfmu)
806 return(0.);
807 fullord = FullOrder(order);
808 if (nfAle > nfmu) {
809 mutmp = BelowTh(Mz);
810 aletmp = AleWithInit(mutmp, aleMz, Mz, fullord);
811// aletmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(nfAle), alstmp, nfAls, fullord)); // WARNING: QED threshold corrections not implemented yet
812 for (i = nfAle - 1; i > nfmu; i--) {
813 mutmp = BelowTh(mutmp - MEPS);
814 aletmp = AleWithInit(mutmp, aletmp, AboveTh(mutmp) - MEPS, fullord);
815// aletmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(i), aletmp, i, fullord)); // WARNING: QED threshold corrections not implemented yet
816 }
817 ale = AleWithInit(mu, aletmp, AboveTh(mu) - MEPS, order);
818 }
819
820 if (nfAle < nfmu) {
821 mutmp = AboveTh(Mz) - MEPS;
822 aletmp = AleWithInit(mutmp, aleMz, Mz, fullord);
823// alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(nfAls + 1), alstmp, nfAls + 1, fullord)); // WARNING: QED threshold corrections not implemented yet
824 for (i = nfAle + 1; i < nfmu; i++) {
825 mutmp = AboveTh(mutmp) - MEPS;
826 aletmp = AleWithInit(mutmp, aletmp, BelowTh(mutmp) + MEPS, fullord);
827// alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(i + 1), alstmp, i + 1, fullord)); // WARNING: QED threshold corrections not implemented yet
828 }
829 ale = AleWithInit(mu, aletmp, BelowTh(mu) + MEPS, order);
830 }
831
832 CacheShift(ale_cache, 10);
833 ale_cache[0][0] = mu;
834 ale_cache[1][0] = (double) order;
835 ale_cache[2][0] = AlsMz;
836 ale_cache[3][0] = Mz;
837 ale_cache[4][0] = mut;
838 ale_cache[5][0] = mub;
839 ale_cache[6][0] = muc;
840 ale_cache[7][0] = (double) Nf_thr;
841 ale_cache[8][0] = aleMz;
842 ale_cache[9][0] = ale;
843
844 return ale;
845 default:
846 throw std::runtime_error("StandardModel::Ale(): " + orderToString(order) + " is not implemented.");
847 }
848}
849
850const double StandardModel::AleWithInit(double mu, double alei, double mu_i, orders order) const
851{
852 if (fabs(mu - mu_i) < MEPS) return(alei);
853
854 double nf = Nf(mu), alsi = (mu_i == Mz ? AlsMz : Als(mu_i, FULLNNNLO, true, true));
855 double b00e = Beta_e(00, nf), b00s = Beta_s(00, nf);
856 double ve = 1. - b00e * alei / 2. / M_PI * log(mu / mu_i);
857 double logv = log(1. + b00s * alsi / 2. / M_PI * log(mu / mu_i)), logve = log(ve);
858
859 switch (order)
860 {
861 case LO:
862 return (alei / ve);
863 case NLO:
864 return (- alei * alei / 4. / M_PI / ve / ve * (Beta_e(10, nf) / b00e * logve - Beta_e(01, nf) / b00s * logv) );
865 // Higher order terms ? Need to understand eq. (35)
866 case FULLNLO:
867 return (AleWithInit(mu, alei, mu_i, LO) + AleWithInit(mu, alei, mu_i, NLO));
868 default:
869 throw std::runtime_error("StandardModel::AleWithInit(): " + orderToString(order) + " is not implemented.");
870 }
871}
872
873const double StandardModel::DeltaAlphaLepton(const double s) const
874{
875 if (s == Mz * Mz)
876 if (FlagCacheInStandardModel)
877 if (useDeltaAlphaLepton_cache)
878 return DeltaAlphaLepton_cache;
879
880 double DeltaAlphaL = 0.0;
881 if (flag_order[EW1])
882 DeltaAlphaL += myOneLoopEW->DeltaAlpha_l(s);
883 if (flag_order[EW1QCD1])
884 DeltaAlphaL += myTwoLoopQCD->DeltaAlpha_l(s);
885 if (flag_order[EW1QCD2])
886 DeltaAlphaL += myThreeLoopQCD->DeltaAlpha_l(s);
887 if (flag_order[EW2])
888 DeltaAlphaL += myTwoLoopEW->DeltaAlpha_l(s);
889 if (flag_order[EW2QCD1])
890 DeltaAlphaL += myThreeLoopEW2QCD->DeltaAlpha_l(s);
891 if (flag_order[EW3])
892 DeltaAlphaL += myThreeLoopEW->DeltaAlpha_l(s);
893
894 if (s == Mz * Mz) {
895 DeltaAlphaLepton_cache = DeltaAlphaL;
896 useDeltaAlphaLepton_cache = true;
897 }
898 return DeltaAlphaL;
899}
900
901const double StandardModel::DeltaAlphaL5q() const
902{
903 double Mz2 = Mz*Mz;
904 return (DeltaAlphaLepton(Mz2) + dAl5hMz);
905}
906
907const double StandardModel::DeltaAlphaTop(const double s) const
908{
909 double DeltaAlpha = 0.0;
910 if (flag_order[EW1])
911 DeltaAlpha += myOneLoopEW->DeltaAlpha_t(s);
912 if (flag_order[EW1QCD1])
913 DeltaAlpha += myTwoLoopQCD->DeltaAlpha_t(s);
914 if (flag_order[EW1QCD2])
915 DeltaAlpha += myThreeLoopQCD->DeltaAlpha_t(s);
916 if (flag_order[EW2])
917 DeltaAlpha += myTwoLoopEW->DeltaAlpha_t(s);
918 if (flag_order[EW2QCD1])
919 DeltaAlpha += myThreeLoopEW2QCD->DeltaAlpha_t(s);
920 if (flag_order[EW3])
921 DeltaAlpha += myThreeLoopEW->DeltaAlpha_t(s);
922
923 return DeltaAlpha;
924}
925
926const double StandardModel::DeltaAlpha() const
927{
928 if (FlagCacheInStandardModel)
929 if (useDeltaAlpha_cache)
930 return DeltaAlpha_cache;
931
932 double Mz2 = Mz*Mz;
933 DeltaAlpha_cache = DeltaAlphaL5q() + DeltaAlphaTop(Mz2);
934 useDeltaAlpha_cache = true;
935 return DeltaAlpha_cache;
936}
937
938const double StandardModel::alphaMz() const
939{
940 return (ale / (1.0 - DeltaAlpha()));
941// return(1./127.918); // FOR HEFFDF1 TEST: VALUE IN hep-ph/0512066
942// return(1./127.955); // FOR HEFFDF1 TEST: VALUE IN 2007.04191
943}
944
945const double StandardModel::Alstilde5(const double mu) const
946{
947 double mu_0 = Mz;
948 double alphatilde_e = alphaMz()/4./M_PI;
949 double alphatilde_s = AlsMz/4./M_PI;
950 unsigned int nf = 5;
951
952 double B00S = Beta0(nf), B10S = Beta1(nf), B20S = Beta2(nf), B30S = gsl_sf_zeta_int(3) * 352864./81. - 598391./1458,
953 B01S = -22./9., B11S = -308./27., B02S = 4945./243.;
954
955 double B00E = 80./9., B01E = 176./9., B10E = 464./27.;
956
957 double B10soB00s = B10S / B00S;
958 double B01soB00e = B01S/B00E;
959
960 double vs= 1. + 2. * B00S * alphatilde_s * log(mu/ mu_0);
961 double ve= 1. - 2. * B00E * alphatilde_e * log(mu/ mu_0);
962 double ps= B00S * alphatilde_s /(B00S * alphatilde_s + B00E * alphatilde_e);
963
964 double logve = log(ve);
965 double logvs = log(vs);
966 double logeos = log(ve/vs);
967 double logsoe = log(vs/ve);
968 double asovs = alphatilde_s/vs;
969 double aeove = alphatilde_e/ve;
970
971 double result = 0;
972
973 result = asovs - pow(asovs, 2) * (logvs * B10soB00s - logve * B01soB00e)
974 + pow(asovs, 3) * ((1. - vs) * B20S / B00S + B10soB00s * B10soB00s * (logvs * logvs - logvs
975 + vs - 1.) + B01soB00e * B01soB00e * logve * logve + (-2. * logvs * logve
976 + ps * ve * logve) * B01S * B10S/(B00E * B00S))
977 + pow(asovs, 4) * (0.5 * B30S *(1. - vs * vs)/ B00S + ((2. * vs - 3.) * logvs + vs * vs
978 - vs) * B20S * B10soB00s /(B00S) + B10soB00s * B10soB00s * B10soB00s * (- pow(logvs,3)
979 + 5. * pow(logvs,2) / 2. + 2. * (1. - vs) * logvs - (vs - 1.) * (vs - 1.)* 0.5))
980 + pow(asovs, 2) * (aeove) * ((ve - 1.) * B02S / B00E
981 + ps * ve * logeos * B11S /B00S +(logve - ve + 1.) * B01soB00e * B10E/(B00E)
982 + logvs * ps * B01S * B10soB00s/(B00S) +(logsoe * ve * ps - logvs) * B01soB00e * B01E/( B00S));
983 return (result);
984}
985
986
988
989const double StandardModel::v() const
990{
991 return ( 1. / sqrt(sqrt(2.) * GF));
992}
993
994
996
997const double StandardModel::Mw_tree() const
998{
999 if (FlagMWinput){
1000 return Mw_inp;
1001 } else
1002 return ( Mz / sqrt(2.0) * sqrt(1.0 + sqrt(1.0 - 4.0 * M_PI * ale / sqrt(2.0) / GF / Mz / Mz)));
1003}
1004
1005const double StandardModel::s02() const
1006{
1007 double tmp = 1.0 - 4.0 * M_PI * alphaMz() / sqrt(2.0) / GF / Mz / Mz;
1008 if (tmp < 0.0)
1009 throw std::runtime_error("Error in s02()");
1010
1011 return ( (1.0 - sqrt(tmp)) / 2.0);
1012}
1013
1014const double StandardModel::c02() const
1015{
1016 return ( 1.0 - s02());
1017}
1018
1019const double StandardModel::Mw() const
1020{
1021 /* Debug */
1022 //std::cout << std::boolalpha
1023 // << checkScheme(schemeMw_cache,schemeMw,false)
1024 // << " [cache:" << schemeMw_cache
1025 // << " current:" << schemeMw << "]" << std::endl;
1026
1027 if (FlagMWinput)
1028 return Mw_inp;
1029
1030 if (FlagCacheInStandardModel)
1031 if (useMw_cache)
1032 return Mw_cache;
1033
1034 double Mw;
1035 if (FlagMw.compare("APPROXIMATEFORMULA") == 0)
1036 Mw = myApproximateFormulae->Mw();
1037 else {
1038 //std::cout << std::setprecision(12)
1039 // << "TEST: Mw_tree = " << Mw_tree() << std::endl;
1040
1041 double DeltaRho[orders_EW_size], DeltaR_rem[orders_EW_size];
1042 ComputeDeltaRho(Mw_tree(), DeltaRho);
1043 ComputeDeltaR_rem(Mw_tree(), DeltaR_rem);
1044 Mw = resumMw(Mw_tree(), DeltaRho, DeltaR_rem);
1045
1046 /* Mw from iterations */
1047 double Mw_org = Mw_tree();
1048 while (fabs(Mw - Mw_org) > Mw_error) {
1049 Mw_org = Mw;
1050 ComputeDeltaRho(Mw, DeltaRho);
1051 ComputeDeltaR_rem(Mw, DeltaR_rem);
1052 Mw = resumMw(Mw, DeltaRho, DeltaR_rem);
1053 /* TEST */
1054 //int prec_def = std::cout.precision();
1055 //std::cout << std::setprecision(12) << "TEST: Mw_org = " << Mw_org
1056 // << " Mw_new = " << Mw << std::endl;
1057 //std::cout.precision(prec_def);
1058 }
1059 }
1060
1061// Mw = 80.426; // FOR HEFFDF1 TEST: VALUE IN hep-ph/0512066
1062// Mw = 80.379; // FOR HEFFDF1 TEST: VALUE IN 2007.04191
1063 Mw_cache = Mw;
1064 useMw_cache = true;
1065 return Mw;
1066}
1067
1068const double StandardModel::Dalpha5hMz() const
1069{
1070 if (FlagMWinput){
1071 return (myApproximateFormulae->dAlpha5hMw());
1072 } else
1073 return dAle5Mz;
1074}
1075
1076const double StandardModel::cW2(double Mw_i) const
1077{
1078 return ( Mw_i * Mw_i / Mz / Mz);
1079}
1080
1081const double StandardModel::cW2() const
1082{
1083 return ( cW2(Mw()));
1084// return (1.0 - 0.2312); // FOR HEFFDF1 TEST
1085}
1086
1087const double StandardModel::sW2(double Mw_i) const
1088{
1089 return ( 1.0 - cW2(Mw_i));
1090}
1091
1092const double StandardModel::sW2() const
1093{
1094 return ( 1.0 - cW2());
1095}
1096
1097const double StandardModel::sW2_MSbar_Approx() const
1098{
1099 //double rho_t= 3. * getGF() * getMtpole() * getMtpole() / (8. * sqrt(2.) * M_PI * M_PI );
1100 return ( sW2()*1.0351 ); //PDG 22 electroweak review eq. (10.19)
1101}
1102
1103const double StandardModel::sW2_ND() const
1104{
1105 double d = 1. / 3. * (1. / sW2_MSbar_Approx() - 8. / 3.) *
1106 ( (1 + getAlsMz()/M_PI)*log(getMtpole()/getMz()) - 15.*getAlsMz()/(8.*M_PI) );
1107
1108 return sW2_MSbar_Approx()*(1. + Ale(getMz(),FULLNLO)*d/M_PI);
1109
1110}
1111
1112const double StandardModel::DeltaR() const
1113{
1114 /* in the experimental/running-width scheme */
1115 double myMw = Mw();
1116 double sW2 = 1.0 - myMw * myMw / Mz / Mz;
1117 double tmp = sqrt(2.0) * GF * sW2 * myMw * myMw / M_PI / ale;
1118 if (FlagMw.compare("NORESUM") == 0
1119 || FlagMw.compare("APPROXIMATEFORMULA") == 0) {
1120 return (tmp - 1.0);
1121 } else {
1122 return (1.0 - 1.0 / tmp);
1123 }
1124}
1125
1126void StandardModel::ComputeDeltaRho(double Mw_i,
1127 double DeltaRho[orders_EW_size]) const
1128{
1129 if (flag_order[EW1])
1130 DeltaRho[EW1] = myOneLoopEW->DeltaRho(Mw_i);
1131 else
1132 DeltaRho[EW1] = 0.0;
1133 if (flag_order[EW1QCD1])
1134 DeltaRho[EW1QCD1] = myTwoLoopQCD->DeltaRho(Mw_i);
1135 else
1136 DeltaRho[EW1QCD1] = 0.0;
1137 if (flag_order[EW1QCD2])
1138 DeltaRho[EW1QCD2] = myThreeLoopQCD->DeltaRho(Mw_i);
1139 else
1140 DeltaRho[EW1QCD2] = 0.0;
1141 if (flag_order[EW2])
1142 DeltaRho[EW2] = myTwoLoopEW->DeltaRho(Mw_i);
1143 else
1144 DeltaRho[EW2] = 0.0;
1145 if (flag_order[EW2QCD1])
1146 DeltaRho[EW2QCD1] = myThreeLoopEW2QCD->DeltaRho(Mw_i);
1147 else
1148 DeltaRho[EW2QCD1] = 0.0;
1149 if (flag_order[EW3])
1150 DeltaRho[EW3] = myThreeLoopEW->DeltaRho(Mw_i);
1151 else
1152 DeltaRho[EW3] = 0.0;
1153}
1154
1155void StandardModel::ComputeDeltaR_rem(const double Mw_i,
1156 double DeltaR_rem[orders_EW_size]) const
1157{
1158 if (flag_order[EW1])
1159 DeltaR_rem[EW1] = myOneLoopEW->DeltaR_rem(Mw_i);
1160 else
1161 DeltaR_rem[EW1] = 0.0;
1162 if (flag_order[EW1QCD1])
1163 DeltaR_rem[EW1QCD1] = myTwoLoopQCD->DeltaR_rem(Mw_i);
1164 else
1165 DeltaR_rem[EW1QCD1] = 0.0;
1166 if (flag_order[EW1QCD2])
1167 DeltaR_rem[EW1QCD2] = myThreeLoopQCD->DeltaR_rem(Mw_i);
1168 else
1169 DeltaR_rem[EW1QCD2] = 0.0;
1170 if (flag_order[EW2])
1171 DeltaR_rem[EW2] = myTwoLoopEW->DeltaR_rem(Mw_i);
1172 else
1173 DeltaR_rem[EW2] = 0.0;
1174 if (flag_order[EW2QCD1])
1175 DeltaR_rem[EW2QCD1] = myThreeLoopEW2QCD->DeltaR_rem(Mw_i);
1176 else
1177 DeltaR_rem[EW2QCD1] = 0.0;
1178 if (flag_order[EW3])
1179 DeltaR_rem[EW3] = myThreeLoopEW->DeltaR_rem(Mw_i);
1180 else
1181 DeltaR_rem[EW3] = 0.0;
1182}
1183
1184
1186
1187double StandardModel::Mzbar() const
1188{
1189 double G0 = GF * pow(Mz, 3.0) / 24.0 / sqrt(2.0) / M_PI;
1190 double sW2tree = 1.0 - Mw_tree() * Mw_tree() / Mz / Mz;
1191 double Gz = 6.0 * G0; // neutrinos
1192 Gz += 3.0 * G0 * (pow(1.0 - 4.0 * sW2tree, 2.0) + 1.0); // e, mu and tau
1193 Gz += 6.0 * G0 * (pow(1.0 - 8.0 / 3.0 * sW2tree, 2.0) + 1.0)
1194 * (1.0 + AlsMz / M_PI); // u and c
1195 Gz += 9.0 * G0 * (pow(1.0 - 4.0 / 3.0 * sW2tree, 2.0) + 1.0)
1196 * (1.0 + AlsMz / M_PI); // d, s and b
1197
1198 //Gz = 2.4952; // experimental data
1199 //std::cout << "Gz=" << Gz << std::endl; // for test
1200
1201 return ( Mz - Gz * Gz / 2.0 / Mz);
1202}
1203
1204const double StandardModel::MwbarFromMw(const double Mw) const
1205{
1206 double AlsMw = Als(Mw, FULLNLO);
1207 double Gw_SM = 3.0 * GF * pow(Mw, 3.0) / 2.0 / sqrt(2.0) / M_PI
1208 * (1.0 + 2.0 * AlsMw / 3.0 / M_PI);
1209
1210 return ( Mw - Gw_SM * Gw_SM / 2.0 / Mw);
1211}
1212
1213const double StandardModel::MwFromMwbar(const double Mwbar) const
1214{
1215 double AlsMw = Als(Mwbar, FULLNNLO);
1216 double Gw_SM = 3.0 * GF * pow(Mwbar, 3.0) / 2.0 / sqrt(2.0) / M_PI
1217 * (1.0 + 2.0 * AlsMw / 3.0 / M_PI);
1218
1219 return (Mwbar + Gw_SM * Gw_SM / 2.0 / Mwbar);
1220}
1221
1222const double StandardModel::DeltaRbar() const
1223{
1224 double Mwbar_SM = MwbarFromMw(Mw());
1225 double sW2bar = 1.0 - Mwbar_SM * Mwbar_SM / Mzbar() / Mzbar();
1226 double tmp = sqrt(2.0) * GF * sW2bar * Mwbar_SM * Mwbar_SM / M_PI / ale;
1227
1228 return (tmp - 1.0);
1229}
1230
1231
1233
1234const double StandardModel::rho_GammaW(const Particle fi, const Particle fj) const
1235{
1236 double rhoW = 0.0;
1237 if (flag_order[EW1])
1238 rhoW = myOneLoopEW->rho_GammaW(fi, fj, Mw());
1239 return rhoW;
1240}
1241
1242const double StandardModel::GammaW(const Particle fi, const Particle fj) const
1243{
1244 if ((fi.getIndex()) % 2 || (fj.getIndex() + 1) % 2)
1245 throw std::runtime_error("Error in StandardModel::GammaW()");
1246
1247 double G0 = GF * pow(Mw(), 3.0) / 6.0 / sqrt(2.0) / M_PI;
1248 gslpp::complex V(0.0, 0.0, false);
1249
1250 if (fi.is("TOP"))
1251 return (0.0);
1252
1253 if (fj.getIndex() - fi.getIndex() == 1)
1254 V = gslpp::complex(1.0, 0.0, false);
1255 else
1256 V = gslpp::complex(0.0, 0.0, false);
1257
1258 if (fi.is("LEPTON"))
1259 return ( V.abs2() * G0 * rho_GammaW(fi, fj));
1260 else {
1261 double AlsMw = AlsWithInit(Mw(), AlsMz, Mz, 5, FULLNLO);
1262 return ( 3.0 * V.abs2() * G0 * rho_GammaW(fi, fj)*(1.0 + AlsMw / M_PI));
1263 }
1264}
1265
1266const double StandardModel::GammaW() const
1267{
1268 if (FlagCacheInStandardModel)
1269 if (useGammaW_cache)
1270 return GammaW_cache;
1271
1272 double GammaWtmp = 0.;
1273
1274 for (int i = 0; i < 6; i += 2)
1275 GammaWtmp += GammaW(leptons[i], leptons[i + 1]) + GammaW(quarks[i], quarks[i + 1]);
1276
1277 GammaW_cache = GammaWtmp;
1278 useGammaW_cache = true;
1279 return GammaWtmp;
1280}
1281
1282
1283const double StandardModel::BrW(const Particle fi, const Particle fj) const
1284{
1285 double GammW = GammaW();
1286 double GammWij = GammaW(fi, fj);
1287
1288 return GammWij/GammW;
1289}
1290
1291
1292const double StandardModel::RWlilj(const Particle li, const Particle lj) const
1293{
1294 double GammWli, GammWlj;
1295
1296 if (li.is("ELECTRON"))
1297 GammWli = GammaW(leptons[NEUTRINO_1],li);
1298 else if (li.is("MU"))
1299 GammWli = GammaW(leptons[NEUTRINO_2],li);
1300 else if (li.is("TAU"))
1301 GammWli = GammaW(leptons[NEUTRINO_3],li);
1302 else
1303 throw std::runtime_error("Error in StandardModel::RWlilj. li must be a charged lepton");
1304
1305 if (lj.is("ELECTRON"))
1306 GammWlj = GammaW(leptons[NEUTRINO_1],lj);
1307 else if (lj.is("MU"))
1308 GammWlj = GammaW(leptons[NEUTRINO_2],lj);
1309 else if (lj.is("TAU"))
1310 GammWlj = GammaW(leptons[NEUTRINO_3],lj);
1311 else
1312 throw std::runtime_error("Error in StandardModel::RWlilj. lj must be a charged lepton");
1313
1314 return GammWli/GammWlj;
1315}
1316
1317const double StandardModel::Ruc() const //AG:added
1318{
1319 return 0.5 * ( R0_f(quarks[UP]) + R0_f(quarks[CHARM]) );
1320}
1321
1322const double StandardModel::RWc() const
1323{
1324 double GammWcX, GammWhad;
1325
1326// Add all the W-> cX decays
1327// In GammaW fermion masses are ignored and CKM=1 but uses that SM CKM is unitary => I only need W->cs
1328 GammWcX = GammaW(quarks[CHARM], quarks[STRANGE]);
1329
1330// For the same reasons, I only need to add the W-> ud decays into the hadronic part
1331 GammWhad = GammWcX
1332 + GammaW(quarks[UP], quarks[DOWN]);
1333
1334 return GammWcX/GammWhad;
1335}
1336
1338
1339const double StandardModel::A_f(const Particle f) const
1340{
1341 double Re_kappa = kappaZ_f(f).real();
1342 double Re_gV_over_gA = 1.0 - 4.0 * fabs(f.getCharge()) * Re_kappa * sW2();
1343 return ( 2.0 * Re_gV_over_gA / (1.0 + pow(Re_gV_over_gA, 2.0)));
1344}
1345
1346const double StandardModel::AFB(const Particle f) const
1347{
1348 return (3.0 / 4.0 * A_f(leptons[ELECTRON]) * A_f(f));
1349}
1350
1351const double StandardModel::sin2thetaEff(const Particle f) const
1352{
1353 double Re_kappa = kappaZ_f(f).real();
1354 return ( Re_kappa * sW2());
1355}
1356
1357const double StandardModel::GammaZ(const Particle f) const
1358{
1359 if (f.is("TOP"))
1360 return 0.0;
1361 double Gamma;
1362 if (!IsFlagNoApproximateGammaZ()) {
1363
1364 /* SM contribution with the approximate formula */
1365 if (f.is("NEUTRINO_1") || f.is("NEUTRINO_2") || f.is("NEUTRINO_3"))
1366 Gamma = myApproximateFormulae->X_full("Gamma_nu");
1367 else if (f.is("ELECTRON") || f.is("MU"))
1368 Gamma = myApproximateFormulae->X_full("Gamma_e_mu");
1369 else if (f.is("TAU"))
1370 Gamma = myApproximateFormulae->X_full("Gamma_tau");
1371 else if (f.is("UP"))
1372 Gamma = myApproximateFormulae->X_full("Gamma_u");
1373 else if (f.is("CHARM"))
1374 Gamma = myApproximateFormulae->X_full("Gamma_c");
1375 else if (f.is("DOWN") || f.is("STRANGE"))
1376 Gamma = myApproximateFormulae->X_full("Gamma_d_s");
1377 else if (f.is("BOTTOM"))
1378 Gamma = myApproximateFormulae->X_full("Gamma_b");
1379 else
1380 throw std::runtime_error("Error in StandardModel::GammaZ()");
1381
1382 } else {
1383 gslpp::complex myrhoZ_f = rhoZ_f(f);
1384 gslpp::complex gV_over_gA = gV_f(f) / gA_f(f);
1385 double G0 = GF * pow(Mz, 3.0) / 24.0 / sqrt(2.0) / M_PI;
1386 if (f.is("LEPTON")) {
1387 double myalphaMz = alphaMz();
1388 double Q = f.getCharge();
1389 double xl = pow(f.getMass() / Mz, 2.0);
1390 Gamma = G0 * myrhoZ_f.abs() * sqrt(1.0 - 4.0 * xl)
1391 * ((1.0 + 2.0 * xl)*(gV_over_gA.abs2() + 1.0) - 6.0 * xl)
1392 * (1.0 + 3.0 / 4.0 * myalphaMz / M_PI * pow(Q, 2.0));
1393 } else if (f.is("QUARK")) {
1394 Gamma = 3.0 * G0 * myrhoZ_f.abs()*(gV_over_gA.abs2() * RVq((QCD::quark) (f.getIndex() - 6)) + RAq((QCD::quark) (f.getIndex() - 6)));
1395
1396 /* Nonfactorizable EW-QCD corrections */
1397 Gamma += Delta_EWQCD((QCD::quark) (f.getIndex() - 6));
1398 } else
1399 throw std::runtime_error("Error in StandardModel::GammaZ()");
1400 }
1401
1402 return Gamma;
1403}
1404
1405const double StandardModel::Gamma_inv() const
1406{
1407 return ( GammaZ(leptons[NEUTRINO_1]) + GammaZ(leptons[NEUTRINO_2])
1408 + GammaZ(leptons[NEUTRINO_3]));
1409}
1410
1411const double StandardModel::Gamma_had() const
1412{
1413 double Gamma_had_tmp = 0.0;
1414
1415 if (!IsFlagNoApproximateGammaZ()){
1416
1417 /* SM contribution with the approximate formula */
1418 return myApproximateFormulae->X_full("Gamma_had");
1419
1420 } else {
1421
1422 Gamma_had_tmp = GammaZ(quarks[UP]) + GammaZ(quarks[DOWN]) + GammaZ(quarks[CHARM])
1423 + GammaZ(quarks[STRANGE]) + GammaZ(quarks[BOTTOM]);
1424
1425 /* Singlet vector contribution (not included in the approximate formula) */
1426 double G0 = GF * pow(Mz, 3.0) / 24.0 / sqrt(2.0) / M_PI;
1427 Gamma_had_tmp += 4.0 * 3.0 * G0 * RVh();
1428
1429 return Gamma_had_tmp;
1430 }
1431}
1432
1433const double StandardModel::Gamma_Z() const
1434{
1435 if (!IsFlagNoApproximateGammaZ()){
1436
1437 /* SM contribution with the approximate formula */
1438 return myApproximateFormulae->X_full("GammaZ");
1439
1440 } else {
1441 return ( GammaZ(leptons[ELECTRON]) + GammaZ(leptons[MU]) + GammaZ(leptons[TAU])
1442 + Gamma_inv() + Gamma_had());
1443 }
1444}
1445
1446
1447const double StandardModel::RZlilj(const Particle li, const Particle lj) const
1448{
1449 double GammZli, GammZlj;
1450
1451 if ( li.is("ELECTRON") || li.is("MU") || li.is("TAU") )
1452 GammZli = GammaZ(li);
1453 else
1454 throw std::runtime_error("Error in StandardModel::RZlilj. li must be a charged lepton");
1455
1456 if ( lj.is("ELECTRON") || lj.is("MU") || lj.is("TAU") )
1457 GammZlj = GammaZ(lj);
1458 else
1459 throw std::runtime_error("Error in StandardModel::RZlilj. lj must be a charged lepton");
1460
1461 return GammZli/GammZlj;
1462}
1463
1464
1465const double StandardModel::sigma0_had() const
1466{
1467 if (!IsFlagNoApproximateGammaZ()){
1468
1469 /* SM contribution with the approximate formula */
1470 return (myApproximateFormulae->X_full("sigmaHadron")
1471 / GeVminus2_to_nb);
1472
1473 } else {
1474 return (12.0 * M_PI * GammaZ(leptons[ELECTRON]) * Gamma_had()
1475 / Mz / Mz / Gamma_Z() / Gamma_Z());
1476 }
1477}
1478
1479const double StandardModel::R0_f(const Particle f) const
1480{
1481
1482 if (f.is("ELECTRON")) {
1483 if (!IsFlagNoApproximateGammaZ())
1484 /* SM contribution with the approximate formula */
1485 return (myApproximateFormulae->X_full("R0_electron"));
1486 else
1487 return (Gamma_had() / GammaZ(leptons[ELECTRON]));
1488 } else if (f.is("MU")) {
1489 if (!IsFlagNoApproximateGammaZ())
1490 /* SM contribution with the approximate formula */
1491 return (myApproximateFormulae->X_full("R0_muon"));
1492 else
1493 return (Gamma_had() / GammaZ(leptons[MU]));
1494 } else if (f.is("TAU")) {
1495 if (!IsFlagNoApproximateGammaZ())
1496 /* SM contribution with the approximate formula */
1497 return (myApproximateFormulae->X_full("R0_tau"));
1498 else
1499 return (Gamma_had() / GammaZ(leptons[TAU]));
1500 } else if (f.is("NEUTRINO_1")) {
1501 if (!IsFlagNoApproximateGammaZ())
1502 /* SM contribution with the approximate formula */
1503 return (myApproximateFormulae->X_full("R0_neutrino"));
1504 else
1505 return (GammaZ(leptons[NEUTRINO_1]) / Gamma_had());
1506 } else if (f.is("NEUTRINO_2")) {
1507 if (!IsFlagNoApproximateGammaZ())
1508 /* SM contribution with the approximate formula */
1509 return (myApproximateFormulae->X_full("R0_neutrino"));
1510 else
1511 return (GammaZ(leptons[NEUTRINO_2]) / Gamma_had());
1512 } else if (f.is("NEUTRINO_3")) {
1513 if (!IsFlagNoApproximateGammaZ())
1514 /* SM contribution with the approximate formula */
1515 return (myApproximateFormulae->X_full("R0_neutrino"));
1516 else
1517 return (GammaZ(leptons[NEUTRINO_3]) / Gamma_had());
1518 } else if (f.is("UP")) {
1519 if (!IsFlagNoApproximateGammaZ())
1520 /* SM contribution with the approximate formula */
1521 return (myApproximateFormulae->X_full("R0_up"));
1522 else
1523 return (GammaZ(quarks[UP]) / Gamma_had());
1524
1525 } else if (f.is("STRANGE")) {
1526 if (!IsFlagNoApproximateGammaZ())
1527 /* SM contribution with the approximate formula */
1528 return (myApproximateFormulae->X_full("R0_strange"));
1529 else
1530 return (GammaZ(quarks[STRANGE]) / Gamma_had());
1531
1532 } else if (f.is("CHARM")) {
1533 if (!IsFlagNoApproximateGammaZ())
1534 /* SM contribution with the approximate formula */
1535 return (myApproximateFormulae->X_full("R0_charm"));
1536 else
1537 return (GammaZ(quarks[CHARM]) / Gamma_had());
1538
1539 } else if (f.is("BOTTOM")) {
1540 if (!IsFlagNoApproximateGammaZ())
1541 /* SM contribution with the approximate formula */
1542 return (myApproximateFormulae->X_full("R0_bottom"));
1543 else
1544 return (GammaZ(quarks[BOTTOM]) / Gamma_had());
1545
1546 } else throw std::runtime_error("StandardModel::R0_f called with wrong argument");
1547
1548}
1549
1550const double StandardModel::R_inv() const
1551{
1552 return (Gamma_inv() / GammaZ(leptons[ELECTRON]));
1553
1554}
1555
1556const double StandardModel::N_nu() const
1557{
1558 double Nnu = 0.0;
1559 double Gl = 0.0;
1560 double Rl = 0.0;
1561
1562 // Don't assume lepton universality: average over lepton flavours
1563 Gl = GammaZ(leptons[ELECTRON]) + GammaZ(leptons[MU]) + GammaZ(leptons[TAU]);
1564 Rl = (1.0/3.0) * ( R0_f(leptons[ELECTRON]) + R0_f(leptons[MU]) + R0_f(leptons[TAU]) );
1565
1566 Nnu = sqrt( 12.0 * M_PI * Rl / Mz / Mz / sigma0_had() ) - Rl -3.0;
1567
1568 Nnu = (Gl/Gamma_inv()) * Nnu;
1569
1570 return Nnu;
1571
1572}
1573
1574
1576
1577const gslpp::complex StandardModel::gV_f(const Particle f) const
1578{
1579 return ( gA_f(f)
1580 *(1.0 - 4.0 * fabs(f.getCharge())*(kappaZ_f(f)) * sW2()));
1581}
1582
1583const gslpp::complex StandardModel::gA_f(const Particle f) const
1584{
1585 return ( sqrt(rhoZ_f(f)) * f.getIsospin());
1586}
1587
1588const gslpp::complex StandardModel::rhoZ_f(const Particle f) const
1589{
1590 if (f.getName().compare("TOP") == 0) return (gslpp::complex(0.0, 0.0, false));
1591 if (FlagRhoZ.compare("APPROXIMATEFORMULA") == 0)
1592 throw std::runtime_error("No approximate formula is available for rhoZ^f");
1593 else {
1594
1595 if (FlagCacheInStandardModel)
1596 if (useRhoZ_f_cache[f.getIndex()])
1597 return rhoZ_f_cache[f.getIndex()];
1598
1599 double myMw = Mw();
1600
1601 /* compute Delta rho */
1602 double DeltaRho[orders_EW_size];
1603 ComputeDeltaRho(myMw, DeltaRho);
1604
1605 /* compute delta rho_rem^f */
1606 gslpp::complex deltaRho_remf[orders_EW_size];
1607 deltaRho_remf[EW1] = gslpp::complex(0.0, 0.0, false);
1608 deltaRho_remf[EW1QCD1] = gslpp::complex(0.0, 0.0, false);
1609 deltaRho_remf[EW1QCD2] = gslpp::complex(0.0, 0.0, false);
1610 deltaRho_remf[EW2] = gslpp::complex(0.0, 0.0, false);
1611 deltaRho_remf[EW2QCD1] = gslpp::complex(0.0, 0.0, false);
1612 deltaRho_remf[EW3] = gslpp::complex(0.0, 0.0, false);
1613 if (flag_order[EW1])
1614 deltaRho_remf[EW1] = myOneLoopEW->deltaRho_rem_f(f, myMw);
1615 if (flag_order[EW1QCD1])
1616#ifdef WITHIMTWOLOOPQCD
1617 deltaRho_remf[EW1QCD1] = gslpp::complex(myTwoLoopQCD->deltaRho_rem_f(f, myMw).real(),
1618 myTwoLoopQCD->deltaRho_rem_f(f, myMw).imag(), false);
1619#else
1620 deltaRho_remf[EW1QCD1] = gslpp::complex(myTwoLoopQCD->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1621#endif
1622 if (flag_order[EW1QCD2])
1623 deltaRho_remf[EW1QCD2] = gslpp::complex(myThreeLoopQCD->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1624 if (flag_order[EW2])
1625 deltaRho_remf[EW2] = gslpp::complex(myTwoLoopEW->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1626 if (flag_order[EW2QCD1])
1627 deltaRho_remf[EW2QCD1] = gslpp::complex(myThreeLoopEW2QCD->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1628 if (flag_order[EW3])
1629 deltaRho_remf[EW3] = gslpp::complex(myThreeLoopEW->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1630
1631 /* compute Delta rbar_rem */
1632 double DeltaRbar_rem = 0.0;
1633 if (flag_order[EW1])
1634 DeltaRbar_rem = myOneLoopEW->DeltaRbar_rem(myMw);
1635
1636 /* Re[rho_Z^f] with or without resummation */
1637 double deltaRho_rem_f_real[orders_EW_size];
1638 for (int j = 0; j < orders_EW_size; ++j)
1639 deltaRho_rem_f_real[j] = deltaRho_remf[j].real();
1640 double ReRhoZf = resumRhoZ(DeltaRho, deltaRho_rem_f_real, DeltaRbar_rem, f.is("BOTTOM"));
1641
1642 /* Im[rho_Z^f] without resummation */
1643 double ImRhoZf = 0.0;
1644 for (int j = 0; j < orders_EW_size; ++j)
1645 ImRhoZf += deltaRho_remf[j].imag();
1646
1647 rhoZ_f_cache[f.getIndex()] = gslpp::complex(ReRhoZf, ImRhoZf, false);
1648 useRhoZ_f_cache[f.getIndex()] = true;
1649 return (gslpp::complex(ReRhoZf, ImRhoZf, false));
1650 }
1651}
1652
1653const gslpp::complex StandardModel::kappaZ_f(const Particle f) const
1654{
1655 if (f.is("TOP")) return (gslpp::complex(0.0, 0.0, false));
1656
1657 if (FlagCacheInStandardModel)
1658 if (useKappaZ_f_cache[f.getIndex()])
1659 return kappaZ_f_cache[f.getIndex()];
1660
1661 double myMw = Mw();
1662
1663 double ReKappaZf = 0.0, ImKappaZf = 0.0;
1664 if (FlagKappaZ.compare("APPROXIMATEFORMULA") == 0) {
1665
1666// Choose the correct formulae for the effective angle
1667 if ( f.is("BOTTOM") ){
1668 ReKappaZf = myApproximateFormulae->sin2thetaEff_b_full() / sW2();
1669 } else if ( f.is("ELECTRON") || f.is("MU") || f.is("TAU") ) {
1670 ReKappaZf = myApproximateFormulae->sin2thetaEff_l_full() / sW2();
1671 } else {
1672 ReKappaZf = myApproximateFormulae->sin2thetaEff(f) / sW2();
1673 }
1674
1675 ImKappaZf = myOneLoopEW->deltaKappa_rem_f(f, myMw).imag();
1676#ifdef WITHIMTWOLOOPQCD
1677 ImKappaZf += myTwoLoopQCD->deltaKappa_rem_f(f, myMw).imag();
1678
1679 /* TEST */
1680 //ImKappaZf -= myCache->ale()*myCache->alsMz()/24.0/M_PI*(cW2() - sW2())/sW2()/sW2();
1681#endif
1682 } else {
1683 /* compute Delta rho */
1684 double DeltaRho[orders_EW_size];
1685 ComputeDeltaRho(myMw, DeltaRho);
1686
1687 /* compute delta kappa_rem^f */
1688 gslpp::complex deltaKappa_remf[orders_EW_size];
1689 deltaKappa_remf[EW1] = gslpp::complex(0.0, 0.0, false);
1690 deltaKappa_remf[EW1QCD1] = gslpp::complex(0.0, 0.0, false);
1691 deltaKappa_remf[EW1QCD2] = gslpp::complex(0.0, 0.0, false);
1692 deltaKappa_remf[EW2] = gslpp::complex(0.0, 0.0, false);
1693 deltaKappa_remf[EW2QCD1] = gslpp::complex(0.0, 0.0, false);
1694 deltaKappa_remf[EW3] = gslpp::complex(0.0, 0.0, false);
1695 if (flag_order[EW1])
1696 deltaKappa_remf[EW1] = myOneLoopEW->deltaKappa_rem_f(f, myMw);
1697 if (flag_order[EW1QCD1])
1698#ifdef WITHIMTWOLOOPQCD
1699 deltaKappa_remf[EW1QCD1] = gslpp::complex(myTwoLoopQCD->deltaKappa_rem_f(f, myMw).real(),
1700 myTwoLoopQCD->deltaKappa_rem_f(f, myMw).imag(), false);
1701#else
1702 deltaKappa_remf[EW1QCD1] = gslpp::complex(myTwoLoopQCD->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1703#endif
1704 if (flag_order[EW1QCD2])
1705 deltaKappa_remf[EW1QCD2] = gslpp::complex(myThreeLoopQCD->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1706 if (flag_order[EW2])
1707 deltaKappa_remf[EW2] = gslpp::complex(myTwoLoopEW->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1708 if (flag_order[EW2QCD1])
1709 deltaKappa_remf[EW2QCD1] = gslpp::complex(myThreeLoopEW2QCD->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1710 if (flag_order[EW3])
1711 deltaKappa_remf[EW3] = gslpp::complex(myThreeLoopEW->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1712
1713 /* compute Delta rbar_rem */
1714 double DeltaRbar_rem = 0.0;
1715 if (flag_order[EW1])
1716 DeltaRbar_rem = myOneLoopEW->DeltaRbar_rem(myMw);
1717
1718 /* Re[kappa_Z^f] with or without resummation */
1719 double deltaKappa_rem_f_real[orders_EW_size];
1720 for (int j = 0; j < orders_EW_size; ++j)
1721 deltaKappa_rem_f_real[j] = deltaKappa_remf[j].real();
1722
1723 ReKappaZf = resumKappaZ(DeltaRho, deltaKappa_rem_f_real, DeltaRbar_rem, f.is("BOTTOM"));
1724
1725 /* O(alpha^2) correction to Re[kappa_Z^f] from the Z-gamma mixing */
1726 ReKappaZf += 35.0 * alphaMz() * alphaMz() / 18.0 / sW2()
1727 *(1.0 - 8.0 / 3.0 * ReKappaZf * sW2());
1728
1729 /* Im[kappa_Z^f] without resummation */
1730 for (int j = 0; j < orders_EW_size; ++j)
1731 ImKappaZf += deltaKappa_remf[j].imag();
1732 }
1733
1734 kappaZ_f_cache[f.getIndex()] = gslpp::complex(ReKappaZf, ImKappaZf, false);
1735 useKappaZ_f_cache[f.getIndex()] = true;
1736 return (gslpp::complex(ReKappaZf, ImKappaZf, false));
1737}
1738
1739const gslpp::complex StandardModel::deltaRhoZ_f(const Particle f) const
1740{
1741 Particle p1 = f, pe = leptons[ELECTRON];
1742
1743 if (f.is("TOP") || f.is("ELECTRON")) return (gslpp::complex(0.0, 0.0, false));
1744
1745 /* In the case of BOTTOM, the top contribution has to be subtracted.
1746 * The remaining contribution is the same as that for DOWN and STRANGE. */
1747 if (f.is("BOTTOM")) p1 = quarks[DOWN];
1748
1749 double myMw = Mw();
1750 double cW2 = myMw * myMw / Mz / Mz, sW2 = 1.0 - cW2;
1751
1752 gslpp::complex ul = (3.0 * myEWSMcache->v_f(pe, myMw) * myEWSMcache->v_f(pe, myMw)
1753 + myEWSMcache->a_f(pe) * myEWSMcache->a_f(pe)) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1754 + myOneLoopEW->FW(Mz*Mz, pe, myMw);
1755 gslpp::complex uf = (3.0 * myEWSMcache->v_f(p1, myMw) * myEWSMcache->v_f(p1, myMw)
1756 + myEWSMcache->a_f(p1) * myEWSMcache->a_f(p1)) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1757 + myOneLoopEW->FW(Mz*Mz, p1, myMw);
1758
1759 gslpp::complex dRho = 2.0 * (uf - ul);
1760 dRho *= ale / 4.0 / M_PI / sW2;
1761 return dRho;
1762}
1763
1764const gslpp::complex StandardModel::deltaKappaZ_f(const Particle f) const
1765{
1766 Particle p1 = f, pe = leptons[ELECTRON];
1767
1768 if (f.is("TOP") || f.is("ELECTRON")) return (gslpp::complex(0.0, 0.0, false));
1769
1770 /* In the case of BOTTOM, the top contribution has to be subtracted.
1771 * The remaining contribution is the same as that for DOWN and STRANGE. */
1772 if (f.is("BOTTOM")) p1 = quarks[DOWN];
1773
1774 double myMw = Mw();
1775 double cW2 = myMw * myMw / Mz / Mz, sW2 = 1.0 - cW2;
1776 gslpp::complex ul = (3.0 * myEWSMcache->v_f(pe, myMw) * myEWSMcache->v_f(pe, myMw)
1777 + myEWSMcache->a_f(pe) * myEWSMcache->a_f(pe)) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1778 + myOneLoopEW->FW(Mz*Mz, pe, myMw);
1779 double deltal = myEWSMcache->delta_f(pe, myMw);
1780 gslpp::complex uf = (3.0 * myEWSMcache->v_f(p1, myMw) * myEWSMcache->v_f(p1, myMw)
1781 + myEWSMcache->a_f(p1) * myEWSMcache->a_f(p1)) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1782 + myOneLoopEW->FW(Mz*Mz, p1, myMw);
1783 double deltaf = myEWSMcache->delta_f(p1, myMw);
1784
1785 gslpp::complex dKappa = (deltaf * deltaf - deltal * deltal) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1786 - uf + ul;
1787 dKappa *= ale / 4.0 / M_PI / sW2;
1788 return dKappa;
1789}
1790
1791
1793
1794const double StandardModel::epsilon1() const
1795{
1796 double rhoZe = rhoZ_f(leptons[ELECTRON]).real();
1797 double DeltaRhoPrime = 2.0 * (sqrt(rhoZe) - 1.0);
1798
1799 return DeltaRhoPrime;
1800}
1801
1802const double StandardModel::epsilon2() const
1803{
1804 double rhoZe = rhoZ_f(leptons[ELECTRON]).real();
1805 double sin2thetaEff = kappaZ_f(leptons[ELECTRON]).real() * sW2();
1806 double DeltaRhoPrime = 2.0 * (sqrt(rhoZe) - 1.0);
1807 double DeltaKappaPrime = sin2thetaEff / s02() - 1.0;
1808 double DeltaRW = 1.0 - M_PI * alphaMz() / (sqrt(2.0) * GF * Mz * Mz * sW2() * cW2());
1809
1810 return ( c02() * DeltaRhoPrime + s02() * DeltaRW / (c02() - s02())
1811 - 2.0 * s02() * DeltaKappaPrime);
1812}
1813
1814const double StandardModel::epsilon3() const
1815{
1816 double rhoZe = rhoZ_f(leptons[ELECTRON]).real();
1817 double sin2thetaEff = kappaZ_f(leptons[ELECTRON]).real() * sW2();
1818 double DeltaRhoPrime = 2.0 * (sqrt(rhoZe) - 1.0);
1819 double DeltaKappaPrime = sin2thetaEff / s02() - 1.0;
1820
1821 return ( c02() * DeltaRhoPrime + (c02() - s02()) * DeltaKappaPrime);
1822}
1823
1824const double StandardModel::epsilonb() const
1825{
1826 /* epsilon_b from g_A^b
1827 * see Eq.(13) of IJMP A7, 1031 (1998) by Altarelli et al. */
1828 //double rhoZe = rhoZ_l_SM(StandardModel::ELECTRON).real();
1829 //double rhoZb = rhoZ_q_SM(QCD::BOTTOM).real();
1830 //double DeltaRhoPrime = 2.0*( sqrt(rhoZe) - 1.0 );
1831 //double eps1 = DeltaRhoPrime;
1832 //return ( - 1.0 + sqrt(rhoZb)/(1.0 + eps1/2.0) );
1833
1834 /* epsilon_b from Re(g_V^b/g_A^b), i.e. Re(kappaZ_b)
1835 * see Eq.(13) of IJMP A7, 1031 (1998) by Altarelli et al. */
1836 gslpp::complex kappaZe = kappaZ_f(leptons[ELECTRON]);
1837 gslpp::complex kappaZb = kappaZ_f(quarks[BOTTOM]);
1838 if (IsFlagWithoutNonUniversalVC())
1839 return ( kappaZe.real() / kappaZb.real() - 1.0);
1840 else
1841 return ( (kappaZe.real() + deltaKappaZ_f(quarks[BOTTOM]).real())
1842 / kappaZb.real() - 1.0);
1843
1844 /* epsilon_b from Gamma_b via Eqs.(11), (12) and (16) of IJMP A7,
1845 * 1031 (1998) by Altarelli et al.
1846 * Note: mb has to be mb=4.7, since Eq.(16) were derived with this value.
1847 */
1848 //double als_Mz = Als(myCache->Mz(), FULLNNLO);
1849 //double delta_als = (als_Mz - 0.119)/M_PI;
1850 //double delta_alpha = (alphaMz() - 1.0/128.90)/myCache->ale();
1851 //double Gamma_b_Born = 0.3798*( 1.0 + delta_als - 0.42*delta_alpha);
1852 //double a = als_Mz/M_PI;
1853 //double RQCD = 1.0 + 1.2*a - 1.1*a*a - 13.0*a*a*a;
1854 //double mb = Mrun(myCache->Mz(), quarks[QCD::BOTTOM].getMass(), FULLNNLO);// This is wrong!
1855 //double mb = 4.7;
1856 //std::cout << "mb = " << mb << std::endl;
1857 //double beta = sqrt(1.0 - 4.0*mb*mb/myCache->Mz()/myCache->Mz());
1858 //double Nc = 3.0;
1859 //double factor = myCache->GF()*myCache->Mz()*myCache->Mz()*myCache->Mz()/6.0/M_PI/sqrt(2.0);
1860 //double Gamma_b = factor*beta*((3.0 - beta*beta)/2.0*gVq_SM(QCD::BOTTOM).abs2()
1861 // + beta*beta*gAq_SM(QCD::BOTTOM).abs2())
1862 // *Nc*RQCD*(1.0 + alphaMz()/12.0/M_PI);
1863 //return ( (Gamma_b/Gamma_b_Born - 1.0 - 1.42*epsilon1_SM()
1864 // + 0.54*epsilon3_SM() )/2.29 );
1865}
1866
1867
1869
1870double StandardModel::resumMw(const double Mw_i, const double DeltaRho[orders_EW_size],
1871 const double DeltaR_rem[orders_EW_size]) const
1872{
1873 if ((FlagMw.compare("APPROXIMATEFORMULA") == 0)
1874 || (DeltaR_rem[EW2QCD1] != 0.0)
1875 || (DeltaR_rem[EW3] != 0.0))
1876 throw std::runtime_error("Error in StandardModel::resumMw()");
1877
1878 if (!flag_order[EW2] && FlagMw.compare("NORESUM") != 0)
1879 throw std::runtime_error("Error in StandardModel::resumMw()");
1880
1881 double cW2_TMP = Mw_i * Mw_i / Mz / Mz;
1882 double sW2_TMP = 1.0 - cW2_TMP;
1883
1884 double f_AlphaToGF, DeltaRho_sum = 0.0, DeltaRho_G = 0.0;
1885 if (FlagMw.compare("NORESUM") == 0) {
1886 for (int j = 0; j < orders_EW_size; ++j) {
1887 DeltaRho_sum += DeltaRho[(orders_EW) j];
1888 }
1889 } else {
1890 // conversion: alpha(0) --> G_F
1891 f_AlphaToGF = sqrt(2.0) * GF * pow(Mz, 2.0) * sW2_TMP * cW2_TMP / M_PI / ale;
1892 DeltaRho_sum = f_AlphaToGF * DeltaRho[EW1]
1893 + f_AlphaToGF * DeltaRho[EW1QCD1]
1894 + f_AlphaToGF * DeltaRho[EW1QCD2]
1895 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2]
1896 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2QCD1]
1897 + pow(f_AlphaToGF, 3.0) * DeltaRho[EW3];
1898 DeltaRho_G = f_AlphaToGF * DeltaRho[EW1];
1899 }
1900
1901 double R;
1902 double DeltaR_rem_sum = 0.0;
1903 double DeltaR_EW1 = 0.0, DeltaR_EW2_rem = 0.0;
1904 if (FlagMw.compare("NORESUM") == 0) {
1905 for (int j = 0; j < orders_EW_size; ++j)
1906 DeltaR_rem_sum += DeltaR_rem[(orders_EW) j];
1907
1908 // Full EW one-loop contribution (without the full DeltaAlphaL5q)
1909 DeltaR_EW1 = -cW2_TMP / sW2_TMP * DeltaRho[EW1] + DeltaR_rem[EW1];
1910
1911 // Full EW two-loop contribution without reducible corrections
1912 DeltaR_EW2_rem = myApproximateFormulae->DeltaR_TwoLoopEW_rem(Mw_i);
1913
1914 // subtract the EW two-loop contributions from DeltaRho_sum and DeltaR_rem_sum
1915 DeltaRho_sum -= DeltaRho[EW2];
1916 DeltaR_rem_sum -= DeltaR_rem[EW2];
1917
1918 // R = 1 + Delta r, including the full EW two-loop contribution
1919 R = 1.0 + DeltaAlphaL5q() - cW2_TMP / sW2_TMP * DeltaRho_sum
1920 + DeltaR_rem_sum;
1921 R += DeltaAlphaL5q() * DeltaAlphaL5q() + 2.0 * DeltaAlphaL5q() * DeltaR_EW1
1922 + DeltaR_EW2_rem;
1923 } else if (FlagMw.compare("OMSI") == 0) {
1924 // R = 1/(1 - Delta r)
1925 R = 1.0 / (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum)
1926 / (1.0 - DeltaAlphaL5q()
1927 - DeltaR_rem[EW1] - DeltaR_rem[EW1QCD1] - DeltaR_rem[EW2]);
1928 } else if (FlagMw.compare("INTERMEDIATE") == 0) {
1929 // R = 1/(1 - Delta r)
1930 R = 1.0 / ((1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum)
1931 *(1.0 - DeltaAlphaL5q() - DeltaR_rem[EW1])
1932 - DeltaR_rem[EW1QCD1] - DeltaR_rem[EW2]);
1933 } else if (FlagMw.compare("OMSII") == 0) {
1934 // R = 1/(1 - Delta r)
1935 R = 1.0 / ((1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum)*(1.0 - DeltaAlphaL5q())
1936 - (1.0 + cW2_TMP / sW2_TMP * DeltaRho_G) * DeltaR_rem[EW1]
1937 - DeltaR_rem[EW1QCD1] - DeltaR_rem[EW2]);
1938 } else
1939 throw std::runtime_error("Error in StandardModel::resumMw()");
1940
1941 if (FlagMw.compare("NORESUM") == 0) {
1942 /* Mzbar and Mwbar are defined in the complex-pole scheme. */
1943
1944 double tmp = 4.0 * M_PI * ale / sqrt(2.0) / GF / Mzbar() / Mzbar();
1945 if (tmp * R > 1.0) throw std::runtime_error("StandardModel::resumMw(): Negative (1-tmp*R)");
1946 double Mwbar = Mzbar() / sqrt(2.0) * sqrt(1.0 + sqrt(1.0 - tmp * R));
1947
1948 return MwFromMwbar(Mwbar);
1949 } else {
1950 double tmp = 4.0 * M_PI * ale / sqrt(2.0) / GF / Mz / Mz;
1951 if (tmp * R > 1.0) throw std::runtime_error("StandardModel::resumMw(): Negative (1-tmp*R)");
1952
1953 return (Mz / sqrt(2.0) * sqrt(1.0 + sqrt(1.0 - tmp * R)));
1954 }
1955}
1956
1957double StandardModel::resumRhoZ(const double DeltaRho[orders_EW_size],
1958 const double deltaRho_rem[orders_EW_size],
1959 const double DeltaRbar_rem, bool bool_Zbb) const
1960{
1961 if ((FlagRhoZ.compare("APPROXIMATEFORMULA") == 0)
1962 || (deltaRho_rem[EW1QCD2] != 0.0)
1963 || (deltaRho_rem[EW2QCD1] != 0.0)
1964 || (deltaRho_rem[EW3] != 0.0))
1965 throw std::runtime_error("Error in StandardModel::resumRhoZ()");
1966
1967 if (!flag_order[EW2] && FlagRhoZ.compare("NORESUM") != 0)
1968 throw std::runtime_error("Error in StandardModel::resumRhoZ()");
1969
1970 double Mw_TMP = Mw();
1971 double cW2_TMP = cW2();
1972 double sW2_TMP = sW2();
1973
1974 double f_AlphaToGF, DeltaRho_sum = 0.0, DeltaRho_G;
1975 double DeltaRbar_rem_G, deltaRho_rem_G, deltaRho_rem_G2;
1976 // conversion: alpha(0) --> G_F
1977 f_AlphaToGF = sqrt(2.0) * GF * pow(Mz, 2.0)
1978 * sW2_TMP * cW2_TMP / M_PI / ale;
1979 DeltaRho_sum = f_AlphaToGF * DeltaRho[EW1]
1980 + f_AlphaToGF * DeltaRho[EW1QCD1]
1981 + f_AlphaToGF * DeltaRho[EW1QCD2]
1982 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2]
1983 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2QCD1]
1984 + pow(f_AlphaToGF, 3.0) * DeltaRho[EW3];
1985 DeltaRho_G = f_AlphaToGF * DeltaRho[EW1];
1986 DeltaRbar_rem_G = f_AlphaToGF*DeltaRbar_rem;
1987 deltaRho_rem_G = f_AlphaToGF * (deltaRho_rem[EW1]
1988 + deltaRho_rem[EW1QCD1]);
1989 deltaRho_rem_G2 = pow(f_AlphaToGF, 2.0) * deltaRho_rem[EW2];
1990
1991 /* Real parts */
1992 double rhoZ;
1993 if (!bool_Zbb) {
1994 if (FlagRhoZ.compare("OMSI") == 0) {
1995 rhoZ = (1.0 + deltaRho_rem_G + deltaRho_rem_G2)
1996 / (1.0 - DeltaRho_sum * (1.0 - DeltaRbar_rem_G));
1997 } else if (FlagRhoZ.compare("INTERMEDIATE") == 0) {
1998 rhoZ = (1.0 + deltaRho_rem_G)
1999 / (1.0 - DeltaRho_sum * (1.0 - DeltaRbar_rem_G))
2000 + deltaRho_rem_G2;
2001 } else if (FlagRhoZ.compare("NORESUM") == 0
2002 || FlagRhoZ.compare("OMSII") == 0) {
2003 rhoZ = 1.0 + DeltaRho_sum - DeltaRho_G * DeltaRbar_rem_G
2004 + DeltaRho_G * DeltaRho_G
2005 + deltaRho_rem_G * (1.0 + DeltaRho_G) + deltaRho_rem_G2;
2006 } else
2007 throw std::runtime_error("Error in StandardModel::resumRhoZ()");
2008 } else {
2009 /* Z to bb */
2010 double OnePlusTaub = 1.0 + taub();
2011 double OnePlusTaub2 = OnePlusTaub*OnePlusTaub;
2012 double rhoZbL;
2013 deltaRho_rem_G += f_AlphaToGF * ale / 4.0 / M_PI / sW2_TMP
2014 * pow(mtpole / Mw_TMP, 2.0);
2015 if (FlagRhoZ.compare("NORESUM") == 0) {
2016 rhoZ = (1.0 + DeltaRho_sum - DeltaRho_G * DeltaRbar_rem_G
2017 + DeltaRho_G * DeltaRho_G
2018 + deltaRho_rem_G * (1.0 + DeltaRho_G) + deltaRho_rem_G2)
2019 * OnePlusTaub2;
2020 } else if (FlagRhoZ.compare("OMSI") == 0) {
2021 rhoZbL = OnePlusTaub2 / (1.0 - DeltaRho_sum);
2022 rhoZ = rhoZbL / (1.0 - rhoZbL * deltaRho_rem_G);
2023 } else if (FlagRhoZ.compare("INTERMEDIATE") == 0) {
2024 rhoZbL = OnePlusTaub2 / (1.0 - DeltaRho_sum);
2025 rhoZ = rhoZbL * (1.0 + rhoZbL * deltaRho_rem_G);
2026 } else if (FlagRhoZ.compare("OMSII") == 0) {
2027 rhoZbL = OnePlusTaub2 / (1.0 - DeltaRho_sum);
2028 rhoZ = rhoZbL * (1.0 + deltaRho_rem_G);
2029 } else
2030 throw std::runtime_error("Error in StandardModel::resumRhoZ()");
2031 }
2032
2033 return rhoZ;
2034}
2035
2036double StandardModel::resumKappaZ(const double DeltaRho[orders_EW_size],
2037 const double deltaKappa_rem[orders_EW_size],
2038 const double DeltaRbar_rem, const bool bool_Zbb) const
2039{
2040 if ((FlagKappaZ.compare("APPROXIMATEFORMULA") == 0)
2041 || (deltaKappa_rem[EW2QCD1] != 0.0)
2042 || (deltaKappa_rem[EW3] != 0.0))
2043 throw std::runtime_error("Error in StandardModel::resumKappaZ()");
2044
2045 if (!flag_order[EW2] && FlagKappaZ.compare("NORESUM") != 0)
2046 throw std::runtime_error("Error in StandardModel::resumKappaZ()");
2047
2048 double Mw_TMP = Mw();
2049 double cW2_TMP = cW2();
2050 double sW2_TMP = sW2();
2051
2052 double f_AlphaToGF, DeltaRho_sum = 0.0, DeltaRho_G;
2053 double DeltaRbar_rem_G, deltaKappa_rem_G, deltaKappa_rem_G2;
2054 // conversion: alpha(0) --> G_F
2055 f_AlphaToGF = sqrt(2.0) * GF * pow(Mz, 2.0)
2056 * sW2_TMP * cW2_TMP / M_PI / ale;
2057 DeltaRho_sum = f_AlphaToGF * DeltaRho[EW1]
2058 + f_AlphaToGF * DeltaRho[EW1QCD1]
2059 + f_AlphaToGF * DeltaRho[EW1QCD2]
2060 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2]
2061 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2QCD1]
2062 + pow(f_AlphaToGF, 3.0) * DeltaRho[EW3];
2063 DeltaRho_G = f_AlphaToGF * DeltaRho[EW1];
2064 DeltaRbar_rem_G = f_AlphaToGF*DeltaRbar_rem;
2065 deltaKappa_rem_G = f_AlphaToGF * (deltaKappa_rem[EW1]
2066 + deltaKappa_rem[EW1QCD1]
2067 + deltaKappa_rem[EW1QCD2]);
2068 deltaKappa_rem_G2 = pow(f_AlphaToGF, 2.0) * deltaKappa_rem[EW2];
2069
2070 /* Real parts */
2071 double kappaZ;
2072 if (!bool_Zbb) {
2073 if (FlagKappaZ.compare("OMSI") == 0) {
2074 kappaZ = (1.0 + deltaKappa_rem_G + deltaKappa_rem_G2)
2075 *(1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum * (1.0 - DeltaRbar_rem_G));
2076 } else if (FlagKappaZ.compare("INTERMEDIATE") == 0) {
2077 kappaZ = (1.0 + deltaKappa_rem_G)
2078 *(1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum * (1.0 - DeltaRbar_rem_G))
2079 + deltaKappa_rem_G2;
2080 } else if (FlagKappaZ.compare("NORESUM") == 0
2081 || FlagKappaZ.compare("OMSII") == 0) {
2082 kappaZ = 1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum
2083 - cW2_TMP / sW2_TMP * DeltaRho_G * DeltaRbar_rem_G
2084 + deltaKappa_rem_G * (1.0 + cW2_TMP / sW2_TMP * DeltaRho_G)
2085 + deltaKappa_rem_G2;
2086 } else
2087 throw std::runtime_error("Error in StandardModel::resumKappaZ()");
2088 } else {
2089 /* Z to bb */
2090 double OnePlusTaub = 1.0 + taub();
2091 double kappaZbL;
2092 deltaKappa_rem_G -= f_AlphaToGF * ale / 8.0 / M_PI / sW2_TMP
2093 * pow(mtpole / Mw_TMP, 2.0);
2094 if (FlagKappaZ.compare("NORESUM") == 0) {
2095 kappaZ = (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum
2096 - cW2_TMP / sW2_TMP * DeltaRho_G * DeltaRbar_rem_G
2097 + deltaKappa_rem_G * (1.0 + cW2_TMP / sW2_TMP * DeltaRho_G)
2098 + deltaKappa_rem_G2) / OnePlusTaub;
2099 } else if (FlagKappaZ.compare("OMSI") == 0) {
2100 kappaZbL = (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum) / OnePlusTaub;
2101 kappaZ = kappaZbL * (1.0 + deltaKappa_rem_G);
2102 } else if (FlagKappaZ.compare("INTERMEDIATE") == 0
2103 || FlagKappaZ.compare("OMSII") == 0) {
2104 kappaZbL = (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum) / OnePlusTaub;
2105 kappaZ = kappaZbL + deltaKappa_rem_G;
2106 } else
2107 throw std::runtime_error("Error in StandardModel::resumKappaZ()");
2108 }
2109
2110 return kappaZ;
2111}
2112
2113double StandardModel::taub() const
2114{
2115 double taub_tmp = 0.0;
2116 double Xt = myEWSMcache->Xt_GF();
2117 if (flag_order[EW1])
2118 taub_tmp += -2.0 * Xt;
2119 if (flag_order[EW1QCD1])
2120 taub_tmp += 2.0 / 3.0 * M_PI * Xt * myEWSMcache->alsMt();
2121 if (flag_order[EW1QCD2])
2122 taub_tmp += 0.0;
2123 if (flag_order[EW2])
2124 taub_tmp += -2.0 * Xt * Xt * myTwoLoopEW->tau_2();
2125 if (flag_order[EW2QCD1])
2126 taub_tmp += 0.0;
2127 if (flag_order[EW3])
2128 taub_tmp += 0.0;
2129
2130 return taub_tmp;
2131}
2132
2133double StandardModel::Delta_EWQCD(const QCD::quark q) const
2134{
2135 switch (q) {
2136 case QCD::UP:
2137 case QCD::CHARM:
2138 return ( -0.000113);
2139 case QCD::TOP:
2140 return ( 0.0);
2141 case QCD::DOWN:
2142 case QCD::STRANGE:
2143 return ( -0.000160);
2144 case QCD::BOTTOM:
2145 return ( -0.000040);
2146 default:
2147 throw std::runtime_error("Error in StandardModel::Delta_EWQCD");
2148 }
2149}
2150
2151double StandardModel::RVq(const QCD::quark q) const
2152{
2153 if (q == QCD::TOP) return 0.0;
2154
2155 double mcMz, mbMz;
2156 mcMz = myEWSMcache->mf(getQuarks(CHARM), Mz, FULLNNLO);
2157 mbMz = myEWSMcache->mf(getQuarks(BOTTOM), Mz, FULLNNLO);
2158 //mcMz = 0.56381685; /* for debug */
2159 //mbMz = 2.8194352; /* for debug */
2160
2161 double MtPole = mtpole;
2162
2163 /* electric charge squared */
2164 double Qf2 = pow(quarks[q].getCharge(), 2.0);
2165
2166 /* s = Mz^2 */
2167 double s = Mz * Mz;
2168
2169 /* products of the charm and bottom masses at Mz */
2170 double mcMz2 = mcMz*mcMz;
2171 double mbMz2 = mbMz*mbMz;
2172 double mqMz2, mqdash4;
2173 switch (q) {
2174 case QCD::CHARM:
2175 mqMz2 = mcMz*mcMz;
2176 mqdash4 = mbMz2*mbMz2;
2177 break;
2178 case QCD::BOTTOM:
2179 mqMz2 = mbMz*mbMz;
2180 mqdash4 = mcMz2*mcMz2;
2181 break;
2182 default:
2183 mqMz2 = 0.0;
2184 mqdash4 = 0.0;
2185 break;
2186 }
2187
2188 /* Logarithms */
2189 //double log_t = log(pow(quarks[TOP].getMass(),2.0)/s);
2190 double log_t = log(MtPole * MtPole / s); // the pole mass
2191 double log_c = log(mcMz2 / s);
2192 double log_b = log(mbMz2 / s);
2193 double log_q;
2194 switch (q) {
2195 case QCD::CHARM:
2196 case QCD::BOTTOM:
2197 log_q = log(mqMz2 / s);
2198 break;
2199 default:
2200 log_q = 0.0;
2201 break;
2202 }
2203
2204 /* the active number of flavour */
2205 double nf = 5.0;
2206
2207 /* zeta functions */
2208 double zeta2 = getMyEWSMcache()->getZeta2();
2209 double zeta3 = getMyEWSMcache()->getZeta3();
2210 //double zeta4 = getMyCache()->GetZeta4();
2211 double zeta5 = getMyEWSMcache()->getZeta5();
2212
2213 /* massless non-singlet corrections */
2214 double C02 = 365.0 / 24.0 - 11.0 * zeta3 + (-11.0 / 12.0 + 2.0 / 3.0 * zeta3) * nf;
2215 double C03 = 87029.0 / 288.0 - 121.0 / 8.0 * zeta2 - 1103.0 / 4.0 * zeta3
2216 + 275.0 / 6.0 * zeta5
2217 + (-7847.0 / 216.0 + 11.0 / 6.0 * zeta2 + 262.0 / 9.0 * zeta3
2218 - 25.0 / 9.0 * zeta5) * nf
2219 + (151.0 / 162.0 - zeta2 / 18.0 - 19.0 / 27.0 * zeta3) * nf*nf;
2220 double C04 = -156.61 + 18.77 * nf - 0.7974 * nf * nf + 0.0215 * nf * nf*nf;
2221 //std::cout << "TEST: C02 = " << C02 << std::endl;// TEST (should be 1.40923)
2222 //std::cout << "TEST: C03 = " << C03 << std::endl;// TEST (should be -12.7671)
2223 //std::cout << "TEST: C04 = " << C04 << std::endl;// TEST (should be -80.0075)
2224
2225 /* quadratic massive corrections */
2226 double C23 = -80.0 + 60.0 * zeta3 + (32.0 / 9.0 - 8.0 / 3.0 * zeta3) * nf;
2227 double C21V = 12.0;
2228 double C22V = 253.0 / 2.0 - 13.0 / 3.0 * nf;
2229 double C23V = 2522.0 - 855.0 / 2.0 * zeta2 + 310.0 / 3.0 * zeta3 - 5225.0 / 6.0 * zeta5
2230 + (-4942.0 / 27.0 + 34.0 * zeta2 - 394.0 / 27.0 * zeta3
2231 + 1045.0 / 27.0 * zeta5) * nf
2232 + (125.0 / 54.0 - 2.0 / 3.0 * zeta2) * nf*nf;
2233
2234 /* quartic massive corrections */
2235 double C42 = 13.0 / 3.0 - 4.0 * zeta3;
2236 double C40V = -6.0;
2237 double C41V = -22.0;
2238 double C42V = -3029.0 / 12.0 + 162.0 * zeta2 + 112.0 * zeta3
2239 + (143.0 / 18.0 - 4.0 * zeta2 - 8.0 / 3.0 * zeta3) * nf;
2240 double C42VL = -11.0 / 2.0 + nf / 3.0;
2241
2242 /* power suppressed top-mass correction */
2243 //double xt = s/pow(quarks[TOP].getMass(),2.0);
2244 double xt = s / MtPole / MtPole; // the pole mass
2245 double C2t = xt * (44.0 / 675.0 - 2.0 / 135.0 * (-log_t));
2246
2247 /* rescaled strong coupling constant */
2248 double AlsMzPi = AlsMz / M_PI;
2249 double AlsMzPi2 = AlsMzPi*AlsMzPi;
2250 double AlsMzPi3 = AlsMzPi2*AlsMzPi;
2251 double AlsMzPi4 = AlsMzPi3*AlsMzPi;
2252
2253 /* electromagnetic coupling at Mz */
2254 double alpMz = alphaMz();
2255
2256 /* radiator function to the vector current */
2257 double RVf;
2258 RVf = 1.0 + 3.0 / 4.0 * Qf2 * alpMz / M_PI + AlsMzPi - Qf2 / 4.0 * alpMz / M_PI * AlsMzPi
2259 + (C02 + C2t) * AlsMzPi2 + C03 * AlsMzPi3 + C04 * AlsMzPi4
2260 + (mcMz2 + mbMz2) / s * C23 * AlsMzPi3
2261 + mqMz2 / s * (C21V * AlsMzPi + C22V * AlsMzPi2 + C23V * AlsMzPi3)
2262 + mcMz2 * mcMz2 / s / s * (C42 - log_c) * AlsMzPi2
2263 + mbMz2 * mbMz2 / s / s * (C42 - log_b) * AlsMzPi2
2264 + mqMz2 * mqMz2 / s / s * (C40V + C41V * AlsMzPi + (C42V + C42VL * log_q) * AlsMzPi2)
2265 + 12.0 * mqdash4 / s / s * AlsMzPi2
2266 - mqMz2 * mqMz2 * mqMz2 / s / s / s
2267 * (8.0 + 16.0 / 27.0 * (155.0 + 6.0 * log_q) * AlsMzPi);
2268 return RVf;
2269}
2270
2271double StandardModel::RAq(const QCD::quark q) const
2272{
2273 if (q == QCD::TOP) return 0.0;
2274
2275 double mcMz, mbMz;
2276 mcMz = myEWSMcache->mf(getQuarks(CHARM), Mz, FULLNNLO);
2277 mbMz = myEWSMcache->mf(getQuarks(BOTTOM), Mz, FULLNNLO);
2278 //mcMz = 0.56381685; /* for debug */
2279 //mbMz = 2.8194352; /* for debug */
2280
2281 double MtPole = mtpole;
2282
2283 /* z-component of isospin */
2284 double I3q = quarks[q].getIsospin();
2285 /* electric charge squared */
2286 double Qf2 = pow(quarks[q].getCharge(), 2.0);
2287
2288 /* s = Mz^2 */
2289 double s = Mz * Mz;
2290
2291 /* products of the charm and bottom masses at Mz */
2292 double mcMz2 = mcMz*mcMz;
2293 double mbMz2 = mbMz*mbMz;
2294 double mqMz2, mqdash4;
2295 switch (q) {
2296 case QCD::CHARM:
2297 mqMz2 = mcMz*mcMz;
2298 mqdash4 = mbMz2*mbMz2;
2299 break;
2300 case QCD::BOTTOM:
2301 mqMz2 = mbMz*mbMz;
2302 mqdash4 = mcMz2*mcMz2;
2303 break;
2304 default:
2305 mqMz2 = 0.0;
2306 mqdash4 = 0.0;
2307 break;
2308 }
2309
2310 /* Logarithms */
2311 //double log_t = log(pow(quarks[TOP].getMass(),2.0)/s);
2312 double log_t = log(MtPole * MtPole / s); // the pole mass
2313 double log_c = log(mcMz2 / s);
2314 double log_b = log(mbMz2 / s);
2315 double log_q;
2316 switch (q) {
2317 case QCD::CHARM:
2318 case QCD::BOTTOM:
2319 log_q = log(mqMz2 / s);
2320 break;
2321 default:
2322 log_q = 0.0;
2323 break;
2324 }
2325
2326 /* the active number of flavour */
2327 double nf = 5.0;
2328
2329 /* zeta functions */
2330 double zeta2 = getMyEWSMcache()->getZeta2();
2331 double zeta3 = getMyEWSMcache()->getZeta3();
2332 double zeta4 = getMyEWSMcache()->getZeta4();
2333 double zeta5 = getMyEWSMcache()->getZeta5();
2334
2335 /* massless non-singlet corrections */
2336 double C02 = 365.0 / 24.0 - 11.0 * zeta3 + (-11.0 / 12.0 + 2.0 / 3.0 * zeta3) * nf;
2337 double C03 = 87029.0 / 288.0 - 121.0 / 8.0 * zeta2 - 1103.0 / 4.0 * zeta3
2338 + 275.0 / 6.0 * zeta5
2339 + (-7847.0 / 216.0 + 11.0 / 6.0 * zeta2 + 262.0 / 9.0 * zeta3
2340 - 25.0 / 9.0 * zeta5) * nf
2341 + (151.0 / 162.0 - zeta2 / 18.0 - 19.0 / 27.0 * zeta3) * nf*nf;
2342 double C04 = -156.61 + 18.77 * nf - 0.7974 * nf * nf + 0.0215 * nf * nf*nf;
2343 //std::cout << "TEST: C02 = " << C02 << std::endl;// TEST (should be 1.40923)
2344 //std::cout << "TEST: C03 = " << C03 << std::endl;// TEST (should be -12.7671)
2345 //std::cout << "TEST: C04 = " << C04 << std::endl;// TEST (should be -80.0075)
2346
2347 /* quadratic massive corrections */
2348 double C23 = -80.0 + 60.0 * zeta3 + (32.0 / 9.0 - 8.0 / 3.0 * zeta3) * nf;
2349 double C20A = -6.0;
2350 double C21A = -22.0;
2351 double C22A = -8221.0 / 24.0 + 57.0 * zeta2 + 117.0 * zeta3
2352 + (151.0 / 12.0 - 2.0 * zeta2 - 4.0 * zeta3) * nf;
2353 double C23A = -4544045.0 / 864.0 + 1340.0 * zeta2 + 118915.0 / 36.0 * zeta3
2354 - 127.0 * zeta5
2355 + (71621.0 / 162.0 - 209.0 / 2.0 * zeta2 - 216.0 * zeta3
2356 + 5.0 * zeta4 + 55.0 * zeta5) * nf
2357 + (-13171.0 / 1944.0 + 16.0 / 9.0 * zeta2 + 26.0 / 9.0 * zeta3) * nf*nf;
2358
2359 /* quartic massive corrections */
2360 double C42 = 13.0 / 3.0 - 4.0 * zeta3;
2361 double C40A = 6.0;
2362 double C41A = 10.0;
2363 double C42A = 3389.0 / 12.0 - 162.0 * zeta2 - 220.0 * zeta3
2364 + (-41.0 / 6.0 + 4.0 * zeta2 + 16.0 / 3.0 * zeta3) * nf;
2365 double C42AL = 77.0 / 2.0 - 7.0 / 3.0 * nf;
2366
2367 /* power suppressed top-mass correction */
2368 //double xt = s/pow(quarks[TOP].getMass(),2.0);
2369 double xt = s / MtPole / MtPole; // the pole mass
2370 double C2t = xt * (44.0 / 675.0 - 2.0 / 135.0 * (-log_t));
2371
2372 /* singlet axial-vector corrections */
2373 double I2 = -37.0 / 12.0 + (-log_t) + 7.0 / 81.0 * xt + 0.0132 * xt*xt;
2374 double I3 = -5075.0 / 216.0 + 23.0 / 6.0 * zeta2 + zeta3 + 67.0 / 18.0 * (-log_t)
2375 + 23.0 / 12.0 * log_t*log_t;
2376 double I4 = 49.0309 - 17.6637 * (-log_t) + 14.6597 * log_t * log_t
2377 + 3.6736 * (-log_t * log_t * log_t);
2378
2379 /* rescaled strong coupling constant */
2380 double AlsMzPi = AlsMz / M_PI;
2381 double AlsMzPi2 = AlsMzPi*AlsMzPi;
2382 double AlsMzPi3 = AlsMzPi2*AlsMzPi;
2383 double AlsMzPi4 = AlsMzPi3*AlsMzPi;
2384
2385 /* electromagnetic coupling at Mz */
2386 double alpMz = alphaMz();
2387
2388 /* radiator function to the axial-vector current */
2389 double RAf;
2390 RAf = 1.0 + 3.0 / 4.0 * Qf2 * alpMz / M_PI + AlsMzPi - Qf2 / 4.0 * alpMz / M_PI * AlsMzPi
2391 + (C02 + C2t - 2.0 * I3q * I2) * AlsMzPi2
2392 + (C03 - 2.0 * I3q * I3) * AlsMzPi3
2393 + (C04 - 2.0 * I3q * I4) * AlsMzPi4
2394 + (mcMz2 + mbMz2) / s * C23 * AlsMzPi3
2395 + mqMz2 / s * (C20A + C21A * AlsMzPi + C22A * AlsMzPi2
2396 + 6.0 * (3.0 + log_t) * AlsMzPi2 + C23A * AlsMzPi3)
2397 //- 10.0*mqMz2/pow(quarks[TOP].getMass(),2.0)
2398 - 10.0 * mqMz2 / MtPole / MtPole // the pole mass
2399 * (8.0 / 81.0 + log_t / 54.0) * AlsMzPi2
2400 + mcMz2 * mcMz2 / s / s * (C42 - log_c) * AlsMzPi2
2401 + mbMz2 * mbMz2 / s / s * (C42 - log_b) * AlsMzPi2
2402 + mqMz2 * mqMz2 / s / s * (C40A + C41A * AlsMzPi
2403 + (C42A + C42AL * log_q) * AlsMzPi2)
2404 - 12.0 * mqdash4 / s / s*AlsMzPi2;
2405 return RAf;
2406}
2407
2408double StandardModel::RVh() const
2409{
2410 /* rescaled strong coupling constant */
2411 double AlsMzPi = AlsMz / M_PI;
2412 double AlsMzPi2 = AlsMzPi*AlsMzPi;
2413 double AlsMzPi3 = AlsMzPi2*AlsMzPi;
2414 double AlsMzPi4 = AlsMzPi3*AlsMzPi;
2415
2416 gslpp::complex gV_sum(0.0, 0.0);
2417 gslpp::complex gV_q;
2418 for (int q = 0; q < 6; q++) {
2419 gV_q = gV_f(QCD::quarks[(QCD::quark)q]);
2420 if (q == (int) (QCD::TOP))
2421 gV_q = 0.0;
2422 gV_sum += gV_q;
2423 }
2424
2425 // singlet vector corrections
2426 return ( gV_sum.abs2()*(-0.4132 * AlsMzPi3 - 4.9841 * AlsMzPi4));
2427}
2428
2430// EW low-energy observables: Parity violation
2431
2432
2433// The anomalous magnetic moment of the muon a_mu=(g_mu-2)/2
2434
2435const double StandardModel::amuon() const
2436{
2437
2438// output
2439 double amu;
2440
2441// -----------------------------------------------------------------
2442// qed contributions
2443 double amuqed,alfa0pi;
2444
2445// ew contributions
2446 double amuew,amuew1,amuew2b,amuew2f,amuew2,amuew3,cft,cf,corr1amuew2, corr2amuew2,corrwaamuew2,al,aq,b1; //,b2;
2447
2448// qcd contributions
2449 double amuhad,amuhhovp,amuhholbl,amuhho,amuhlo;
2450
2451// -----------------------------------------------------------------
2452// numerical constants
2453 const double sn2=0.2604341;
2454
2455// -----------------------------------------------------------------
2456// SM parameters
2457
2458// light quark masses. constituent masses
2459 const double umass=0.3;
2460 const double dmass=0.3;
2461 const double smass=0.5;
2462
2463 const double mum=leptons[MU].getMass(),taum=leptons[TAU].getMass();
2464 const double cqm=quarks[CHARM].getMass(),bqm=quarks[BOTTOM].getMass();
2465
2466// all fermion masses (constituent masses for u,d,s. for the other from model)
2467 double fermmass[9]={leptons[ELECTRON].getMass(),mum,taum,
2468 dmass,umass,
2469 smass,cqm,
2470 bqm,mtpole};
2471
2472// w mass and on-shell weak angle
2473 double MwSM, s2;
2474
2475// running of alfa_qed and dummy variable
2476 double aqed;
2477
2478// for the 2-loop bosonic corrections
2479 double a2l[4]={0.,0.,0.,0.},b2l[4]={0.,0.,0.,0.},sw2l[4]={0.,0.,0.,0.};
2480
2481// for the 2-loop corrections from the renormalization of weak angle
2482 double c2lren[6]={0.,0.,0.,0.,0.,0.};
2483
2484// w mass
2485 MwSM=Mw();
2486
2487 s2=1.0 - MwSM*MwSM/Mz/Mz;
2488
2489//------------------------------------------------------------------
2490// qed contribution to amu (arxiv: hep-ph/0606174)
2491 alfa0pi=ale/M_PI;
2492
2493 amuqed=alfa0pi*(0.5+alfa0pi*(0.765857410+alfa0pi*(24.05050964+
2494 + alfa0pi*(130.8055+663.0*alfa0pi))));
2495
2496//-----------------------------------------------------------------
2497// one-loop ew correction(phys.rev.lett. 76,3267 (1996))
2498
2499 amuew1=5.0*GF*mum*mum/(24.0*sqrt(2.0)*M_PI*M_PI)*(1.0+
2500 + 0.2*(1.0-4.0*s2)*(1.0-4.0*s2));
2501
2502//-----------------------------------------------------------------
2503// two-loop computation
2504
2505// these depend on aqed and since we are going to include also three-loop
2506// effects we need to include in the two-loop results the running of aqed at
2507// 1-loop up to the scale mum
2508//-----------------------------------------------------------------
2509// running of alpha em down to mu mass (1-loop)
2510
2511 aqed = 1.0/ale + 2.0 * log(fermmass[0]/mum)/3.0/M_PI;
2512
2513 aqed = 1.0/aqed;
2514
2515//-----------------------------------------------------------------
2516// two-loop ew bosonic correction(phys.rev.lett. 76,3267 (1996))
2517
2518// previous definitions
2519 a2l[0]=19.0/36.0-99.0*sn2/8.0-1.0*2.0*log(mHl/MwSM)/24.0;
2520
2521 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;
2522
2523 sw2l[0]=1.0/s2;
2524
2525 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;
2526
2527 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;
2528
2529 sw2l[1]=1.0;
2530
2531 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;
2532
2533 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;
2534
2535 sw2l[2]=s2;
2536
2537 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;
2538
2539 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;
2540
2541 sw2l[3]=s2*s2;
2542
2543// computation
2544
2545 amuew2b=0.0;
2546
2547 for (int i = 0; i < 4; ++i) {
2548 amuew2b=amuew2b+a2l[i]*sw2l[i]+(MwSM*MwSM/mHl/mHl)*b2l[i]*sw2l[i];
2549 }
2550
2551// the contribution with the running of aqed up to the mu scale
2552 amuew2b=mum*mum*aqed*GF*amuew2b/(8.0*sqrt(2.0)*M_PI*M_PI*M_PI);
2553
2554//-----------------------------------------------------------------
2555// two-loop ew fermionic correction(phys.rev.d 52,r2619(1995)
2556
2557// contribution from higgs boson diagram
2558 if (mHl < (mtpole-10.0)) {
2559 cft=-104.0/45.0-16.0*2.0*log(mtpole/mHl)/15.0;
2560 } else if (mHl > (mtpole+10)) {
2561 cft=-(mtpole*mtpole/mHl/mHl)*(24.0/5.0+8.0*M_PI*M_PI/15.0+
2562 + 8.0/5.0*pow(2.0*log(mHl/mtpole)-1.0,2));
2563 } else {
2564 cft=-(32.0/5.0)*(1.0-9.0*sn2/4.0);
2565 }
2566
2567 cf=pow((umass*cqm*Mz),(4.0/3.0));
2568
2569 cf=cf/(pow((dmass*smass*bqm),(1.0/3.0))*mum*mum*taum);
2570
2571 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;
2572
2573// the contribution with the running of aqed up to the mu scale
2574 amuew2f=5.0*GF*mum*mum*cf*aqed/(24.0*sqrt(2.0)*M_PI*M_PI*M_PI);
2575
2576//-----------------------------------------------------------------
2577// corrections from hadronic loops (phys.rev.d 67,073006(2003))
2578// i also include the running here even though in the previous reference seems that it is not included
2579// first family (eqs. (60) and (61))
2580 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);
2581// second family (eqs. (65) and (66))
2582 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);
2583
2584//-----------------------------------------------------------------
2585// corrections from the renormalization of the weak mixing
2586// terms prop. to (1-4s2) included in eq. (7) of phys.rev.d 67,073006(2003)
2587// and neglected in the previous references
2588
2589 corrwaamuew2=-43.0*31.0*(1.0-4.0*s2)*(1.0-4.0*s2)/(215.0*3.0)*log(Mz/mum);
2590
2591 c2lren[0]=(72.0/135.0)*(-1.0+2.0*s2)*(1.0-4.0*s2); //leptons
2592 c2lren[1]=(72.0/135.0)*(-1.0+2.0*s2/3.0)*(1.0-4.0*s2); //d-quark
2593 c2lren[2]=-(144.0/135.0)*(1.0-4.0*s2/3.0)*(1.0-4.0*s2); //u-quark
2594 c2lren[3]=c2lren[1];//d-quark
2595 c2lren[4]=c2lren[2]; //u-quark
2596 c2lren[5]=c2lren[1]; //d-quark
2597
2598 for (int i = 2; i < 8; ++i) {
2599 corrwaamuew2=corrwaamuew2+c2lren[i-2]*log(Mz/fermmass[i]);
2600 }
2601
2602 corrwaamuew2=5*GF*mum*mum*aqed/(24.0*sqrt(2.0)*M_PI*M_PI*M_PI)*corrwaamuew2;
2603
2604// finally i also add the small correction to the eq.8
2605 corrwaamuew2=corrwaamuew2-0.2e-11;
2606
2607//-----------------------------------------------------------------
2608// total 2-loop ew contribution
2609 amuew2=amuew2b+amuew2f+corr1amuew2+corr2amuew2+corrwaamuew2;
2610
2611//-----------------------------------------------------------------
2612// three-loop ew correction(phys.rev.d 67,073006(2003)
2613
2614 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;
2615
2616 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;
2617
2618 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;
2619
2620 // 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
2621 // 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));
2622
2623// the final correction(it is implied aqed at mum for the 2-loop
2624// correction
2625
2626 amuew3=amuew1*(ale*ale/M_PI/M_PI)*(al+aq+b1);
2627
2628//-----------------------------------------------------------------
2629// total ew correction
2630
2631 amuew=amuew1+amuew2+amuew3;
2632
2633//-----------------------------------------------------------------
2634// hadronic contributions (arxiv: 0908.4300 & 1001.5401 [hep-ph])
2635
2636// leading order: vacuum polarization (arxiv: 0908.4300 [hep-ph])
2637 amuhlo=6955.e-11;
2638
2639// higher order: vacuum polarization
2640 amuhhovp=-97.9e-11;
2641
2642// higher order: light-by-light
2643 amuhholbl=105.e-11;
2644
2645 amuhho=amuhhovp+amuhholbl;
2646
2647// total hadronic contribution
2648
2649 amuhad=amuhlo+amuhho;
2650
2651//-----------------------------------------------------------------
2652// final value for the muon (g-2)/2
2653
2654 amu=amuqed+amuew+amuhad;
2655
2656//-----------------------------------------------------------------
2657
2658 return amu;
2659
2660}
2661
2662
2663// The electron's weak charge
2664
2665const double StandardModel::Qwemoller(const double q2, const double y) const
2666{
2667 // Weak charge
2668 double Qwe;
2669
2670 // definitions
2671 double MwSM,f1,fy,f2,af2;
2672 const double mpion=134.9766e-3;
2673
2674 // -----------------------------------------------------------------
2675
2676 double dalfos, dalfms, alfams;
2677 double rhoNC, kappa0, s2MSbar,c2MSbar;
2678 double xi;
2679 double leptk0,quarkk0;
2680 double elm=leptons[ELECTRON].getMass(), mum=leptons[MU].getMass(), taum=leptons[TAU].getMass();
2681
2682 // -----------------------------------------------------------------
2683
2684 // w mass
2685 MwSM=Mw();
2686
2687 // xi factor
2688 xi=mHl*mHl/Mz/Mz;
2689
2690 // -----------------------------------------------------------------
2691
2692 // universal corrections
2693 // ---------------------
2694
2695 // obtaining alfa(mz)_msbar from alfa(mz)_on-shell
2696 // -----------------------------------------------
2697
2698 // on-shell value of delta alpha(mz)
2699 dalfos=1.0-ale/alphaMz();
2700 // msbar value of delta alpha(mz) (formula from PDG, Erler & Langacker ew review)
2701 dalfms=dalfos+ale/M_PI*(100.0/27.0-1.0/6.0-7.0*2.0*log(Mz/MwSM)/4.0);
2702 // msbar value of alfa(mz)
2703 alfams=ale/(1.0-dalfms);
2704
2705 // ms bar weinberg's angle from the effective leptonic angle
2706 // (formula from PDG, Erler & Langacker ew review)
2707 // ---------------------------------------------------------
2708 s2MSbar=(myApproximateFormulae->sin2thetaEff_l_full())-0.00029;
2709 c2MSbar=1.0-s2MSbar;
2710
2711 // rho parameter (expansion in alfams)
2712 // -------------
2713
2714 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)));
2715
2716 // kappa at zero momentum (expansion in alfa)
2717 // ----------------------
2718
2719 // lepton contribution to kappa0
2720 leptk0=((-0.5)*(-1)-2.0*s2MSbar)*2.0*(log(elm/Mz)+log(mum/Mz)+log(taum/Mz))/3.0;
2721
2722 // quark contribution to kappa0 (updated from hep-ph/0302149)
2723 quarkk0=-6.802;
2724
2725 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));
2726
2727 // -----------------------------------------------------------------
2728
2729 // f1(y,q2) (expansion in alfa)
2730 // --------
2731
2732 // f(y)
2733 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)));
2734
2735 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);
2736
2737 // note that i have used 1-4*kappa*s2MSbar instead of 1-4*s2MSbar or an average as suggested in the
2738 // reference
2739
2740
2741 // f2(y,q2) (expansion in alfa)
2742 // --------
2743 // (y=1/2 approximattion using a pion loop calculation)
2744
2745 // af2
2746 af2=sqrt(1.0+4.0*mpion*mpion/q2);
2747 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);
2748
2749
2750 // electron's weak charge
2751 // ----------------------
2752 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));
2753
2754 // again, i have used 1-4*kappa*s2MSbar even in the loop contributions
2755
2756 return Qwe;
2757}
2758
2759
2760
2761// The parity violating asymmetry in Moller scattering
2762
2763const double StandardModel::alrmoller(const double q2, const double y) const
2764{
2765 // functions and inputs
2766 double alrmoller;
2767
2768 // which alfa is this? => alpha(0). is this ale?
2769
2770 // parity violation asymmetry
2771 // --------------------------
2772 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);
2773
2774 return alrmoller;
2775}
2776
2777
2778
2779// The computation of the proton and neutron weak charge: Qwp,Qwn
2780
2781const double StandardModel::Qwp() const
2782{
2783 // Definitions
2784 double qwproton;
2785
2786 double MwSM,alfapi,asMw,dkappa5h,s2MSbar0,deltae,deltaep,boxpww,boxpzz,boxpaz;
2787 // I choose as lambda m_rho (pdg rho(770)) --> caz=3/2
2788 const double lambda=775.49e-3;
2789 const double caz=1.5;
2790
2791 // lepton masses
2792 double mlept[3]={leptons[ELECTRON].getMass(),leptons[MU].getMass(),leptons[TAU].getMass()};
2793
2794 // -----------------------------------------------------------------
2795 double dalfos, dalfms, alfams;
2796 double rhoNC, s2MSbar,c2MSbar;
2797 double xi;
2798 double elm=leptons[ELECTRON].getMass();
2799 // -----------------------------------------------------------------
2800
2801 // W mass
2802 MwSM=Mw();
2803
2804 // xi factor
2805 xi=mHl*mHl/Mz/Mz;
2806
2807 // alfa/pi
2808 alfapi=ale/M_PI;
2809
2810 // alfa_s(Mw)
2811 asMw = Als(MwSM, FULLNLO);
2812
2813 // -----------------------------------------------------------------
2814
2815 // Universal corrections
2816 // ---------------------
2817
2818 // Obtaining alfa(mz)_msbar from alfa(mz)_on-shell
2819 // -----------------------------------------------
2820
2821 // on-shell value of delta alpha(mz)
2822 dalfos=1.0-ale/alphaMz();
2823 // MSbar value of delta alpha(mz) (formula from PDG, Erler & Langacker ew review)
2824 dalfms=dalfos+ale/M_PI*(100.0/27.0-1.0/6.0-7.0*2.0*log(Mz/MwSM)/4.0);
2825 // MSbar value of alfa(mz)
2826 alfams=ale/(1.0-dalfms);
2827
2828 // MS bar weinberg's angle from the effective leptonic angle
2829 // (formula from PDG, Erler & Langacker ew review)
2830 // ---------------------------------------------------------
2831 s2MSbar=(myApproximateFormulae->sin2thetaEff_l_full())-0.00029;
2832 c2MSbar=1.0-s2MSbar;
2833
2834 // rho parameter (expansion in alfams)
2835 // -------------
2836
2837 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)));
2838
2839 // -----------------------------------------------------------------
2840
2841 // sin2w_ms(0) eq.14
2842 // -----------------
2843
2844 // hadronic contribution
2845 dkappa5h=7.9e-3;
2846
2847 s2MSbar0=0.0;
2848
2849 for (int i = 0; i < 3; ++i) {
2850 s2MSbar0=s2MSbar0+2.0*log(Mz/mlept[i]);
2851 }
2852
2853 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);
2854
2855 // -----------------------------------------------------------------
2856
2857 // external leg corrections
2858
2859 deltae=-0.5*alfapi;
2860
2861 deltaep=-alfapi/3.0*(1.0-4.0*s2MSbar)*(2.0*log(Mz/elm)+1.0/6.0);
2862
2863 // -----------------------------------------------------------------
2864
2865 // boxes
2866 // -----
2867
2868 boxpww=alfams*(2.0+5.0*(1.0-asMw/M_PI))/(4.0*M_PI*s2MSbar);
2869
2870 // pure zz and az boxes from prd 17 3055 app.a
2871
2872 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);
2873
2874 boxpaz=5.0*alfams*(1.0-4.0*s2MSbar)*(2.0*log(Mz/lambda)+caz)/(2.0*M_PI);
2875
2876 // i assumme the same caz as in the proton enters for the neutron
2877 // -----------------------------------------------------------------
2878
2879 // weak charges
2880 // ------------
2881
2882 qwproton=(rhoNC+deltae)*(1.0-4.0*s2MSbar0+deltaep)+boxpww+boxpzz+boxpaz;
2883
2884 return qwproton;
2885
2886}
2887
2888
2889const double StandardModel::Qwn() const
2890{
2891 // Definitions
2892 double qwneutron;
2893
2894 double MwSM,alfapi,asMw,dkappa5h,s2MSbar0,deltae,deltaep,boxnww,boxnzz,boxnaz;
2895 // I choose as lambda m_rho (pdg rho(770)) --> caz=3/2
2896 const double lambda=775.49e-3;
2897 const double caz=1.5;
2898
2899 // lepton masses
2900 double mlept[3]={leptons[ELECTRON].getMass(),leptons[MU].getMass(),leptons[TAU].getMass()};
2901
2902 // -----------------------------------------------------------------
2903 double dalfos, dalfms, alfams;
2904 double rhoNC, s2MSbar,c2MSbar;
2905 double xi;
2906 double elm=leptons[ELECTRON].getMass();
2907 // -----------------------------------------------------------------
2908
2909 // W mass
2910 MwSM=Mw();
2911
2912 // xi factor
2913 xi=mHl*mHl/Mz/Mz;
2914
2915 // alfa/pi
2916 alfapi=ale/M_PI;
2917
2918 // alfa_s(Mw)
2919 asMw = Als(MwSM, FULLNLO);
2920
2921 // -----------------------------------------------------------------
2922
2923 // Universal corrections
2924 // ---------------------
2925
2926 // Obtaining alfa(mz)_msbar from alfa(mz)_on-shell
2927 // -----------------------------------------------
2928
2929 // on-shell value of delta alpha(mz)
2930 dalfos=1.0-ale/alphaMz();
2931 // MSbar value of delta alpha(mz) (formula from PDG, Erler & Langacker ew review)
2932 dalfms=dalfos+ale/M_PI*(100.0/27.0-1.0/6.0-7.0*2.0*log(Mz/MwSM)/4.0);
2933 // MSbar value of alfa(mz)
2934 alfams=ale/(1.0-dalfms);
2935
2936 // MS bar weinberg's angle from the effective leptonic angle
2937 // (formula from PDG, Erler & Langacker ew review)
2938 // ---------------------------------------------------------
2939 s2MSbar=(myApproximateFormulae->sin2thetaEff_l_full())-0.00029;
2940 c2MSbar=1.0-s2MSbar;
2941
2942 // rho parameter (expansion in alfams)
2943 // -------------
2944
2945 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)));
2946
2947 // -----------------------------------------------------------------
2948
2949 // sin2w_ms(0) eq.14
2950 // -----------------
2951
2952 // hadronic contribution
2953 dkappa5h=7.9e-3;
2954
2955 s2MSbar0=0.0;
2956
2957 for (int i = 0; i < 3; ++i) {
2958 s2MSbar0=s2MSbar0+2.0*log(Mz/mlept[i]);
2959 }
2960
2961 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);
2962
2963 // -----------------------------------------------------------------
2964
2965 // external leg corrections
2966
2967 deltae=-0.5*alfapi;
2968
2969 deltaep=-alfapi/3.0*(1.0-4.0*s2MSbar)*(2.0*log(Mz/elm)+1.0/6.0);
2970
2971 // -----------------------------------------------------------------
2972
2973 // boxes
2974 // -----
2975
2976 boxnww=alfams*(-2.0+4.0*(1.0-asMw/M_PI))/(4.0*M_PI*s2MSbar);
2977
2978 // pure zz and az boxes from prd 17 3055 app.a
2979
2980 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);
2981
2982 // i assumme the same caz as in the proton enters for the neutron
2983 boxnaz=alfams*(4.0-16.0*s2MSbar)*(2.0*log(Mz/lambda)+caz)/(2.0*M_PI);
2984
2985 // -----------------------------------------------------------------
2986
2987 // weak charges
2988 // ------------
2989
2990 qwneutron=-(rhoNC+deltae)*(1.0+deltaep)+boxnww+boxnzz+boxnaz;
2991
2992 return qwneutron;
2993
2994}
2995
2996
2998 // EW low-energy observables: neutrino-scattering
2999
3000
3001const double StandardModel::gLnuN2() const
3002{
3003 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3004 if (!IsFlagNoApproximateGammaZ()){
3005
3006 /* SM contribution with the approximate formula */
3007 return (myApproximateFormulae->LEgLnuN2Approx());
3008
3009 } else {
3010 throw std::runtime_error("ERROR: StandardModel::gLnuN2, prediction implemented only via semianalytical approximate formula. Check flags!");
3011 }
3012}
3013
3014
3015const double StandardModel::gRnuN2() const
3016{
3017 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3018 if (!IsFlagNoApproximateGammaZ()){
3019
3020 /* SM contribution with the approximate formula */
3021 return (myApproximateFormulae->LEgRnuN2Approx());
3022
3023 } else {
3024 throw std::runtime_error("ERROR: StandardModel::gRnuN2, prediction implemented only via semianalytical approximate formula. Check flags!");
3025 }
3026}
3027
3028const double StandardModel::ThetaLnuN() const
3029{
3030 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3031 if (!IsFlagNoApproximateGammaZ()){
3032
3033 /* SM contribution with the approximate formula */
3034 return (myApproximateFormulae->LEThetaLnuNApprox());
3035
3036 } else {
3037 throw std::runtime_error("ERROR: StandardModel::ThetaLnuN, prediction implemented only via semianalytical approximate formula. Check flags!");
3038 }
3039}
3040
3041
3042const double StandardModel::ThetaRnuN() const
3043{
3044 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3045 if (!IsFlagNoApproximateGammaZ()){
3046
3047 /* SM contribution with the approximate formula */
3048 return (myApproximateFormulae->LEThetaRnuNApprox());
3049
3050 } else {
3051 throw std::runtime_error("ERROR: StandardModel::ThetaRnuN, prediction implemented only via semianalytical approximate formula. Check flags!");
3052 }
3053}
3054
3055const double StandardModel::gVnue() const
3056{
3057 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3058 if (!IsFlagNoApproximateGammaZ()){
3059
3060 /* SM contribution with the approximate formula */
3061 return (myApproximateFormulae->LEgVnueApprox());
3062
3063 } else {
3064 throw std::runtime_error("ERROR: StandardModel::gVnue, prediction implemented only via semianalytical approximate formula. Check flags!");
3065 }
3066}
3067
3068const double StandardModel::gAnue() const
3069{
3070 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3071 if (!IsFlagNoApproximateGammaZ()){
3072
3073 /* SM contribution with the approximate formula */
3074 return (myApproximateFormulae->LEgAnueApprox());
3075
3076 } else {
3077 throw std::runtime_error("ERROR: StandardModel::gAnue, prediction implemented only via semianalytical approximate formula. Check flags!");
3078 }
3079}
3080
3081
3082
3084// Lepton decays
3085
3086// Muon decay
3087
3088const double StandardModel::Gamma_muon() const
3089{
3090 double Gamma;
3091 double me, mmu, x, Fx, H1x, H2x, H3x, zeta3;
3092 double alpha, rEW;
3093 double pi2;
3094
3095 me = leptons[ELECTRON].getMass();
3096 mmu = leptons[MU].getMass();
3097 pi2 = M_PI*M_PI;
3098
3099 x = me*me/mmu/mmu;
3100 Fx = 1. - 8. * x + 8. * x*x*x - x*x*x*x -12. * x*x * log(x);
3101
3102 H1x = 25./8. - pi2/2. - (9. + 4. *pi2 + 12. * log(x) )*x + 16. * pi2 * pow(x,3./2.);
3103
3104 zeta3 = 1.2020569031595942;
3105
3106 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);
3107
3108 H3x = -15.3;
3109
3110 // alpha(m_mu)
3111 alpha = 1./ale - log(x)/3./M_PI; // + 1./6./M_PI;
3112 alpha = 1./alpha;
3113
3114 // Rad. corrections
3115 rEW = 1. + H1x * alpha/M_PI + H2x * alpha*alpha/pi2 + H3x * alpha * alpha *alpha/pi2/M_PI;
3116
3117 // Gamma: PDG formula
3118 Gamma = GF*GF*pow(mmu,5)*Fx*rEW/192./pow(M_PI,3);
3119
3120 return Gamma;
3121}
3122
3123
3124// Tau decays
3125
3126// Leptonic decays
3127
3128const double StandardModel::Gamma_tau_l_nunu(const Particle l) const
3129{
3130 double Gamma;
3131 double ml, mtau, x, Fx, H1x, H2x, H3x, zeta3;
3132 double alpha, rEW;
3133 double pi2;
3134
3135 ml = l.getMass();
3136 mtau = leptons[TAU].getMass();
3137 pi2 = M_PI*M_PI;
3138
3139 x = ml*ml/mtau/mtau;
3140 Fx = 1. - 8. * x + 8. * x*x*x - x*x*x*x -12. * x*x * log(x);
3141
3142 H1x = 25./8. - pi2/2. - (9. + 4. *pi2 + 12. * log(x) )*x + 16. * pi2 * pow(x,3./2.);
3143
3144 zeta3 = 1.2020569031595942;
3145
3146 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);
3147
3148 H3x = -15.3;
3149
3150 // alpha(m_tau)
3151 alpha = 1./133.29; // Improve
3152
3153 // Rad. corrections
3154 rEW = 1. + H1x * alpha/M_PI + H2x * alpha*alpha/pi2 + H3x * alpha * alpha *alpha/pi2/M_PI;
3155
3156 // Gamma: PDG formula
3157 Gamma = GF*GF*pow(mtau,5)*Fx*rEW/192./pow(M_PI,3);
3158
3159 return Gamma;
3160}
3161
3162
3163// Lepton universality tests
3164
3165const double StandardModel::TauLFU_gmuge() const
3166{
3167 double g2LFU;
3168
3169 double me, mmu, mtau, xe, Fxe, xmu, Fxmu;
3170
3171 me = leptons[ELECTRON].getMass();
3172 mmu = leptons[MU].getMass();
3173 mtau = leptons[TAU].getMass();
3174
3175 xe = me*me/mtau/mtau;
3176 Fxe = 1. - 8. * xe + 8. * xe*xe*xe - xe*xe*xe*xe -12. * xe*xe * log(xe);
3177
3178 xmu = mmu*mmu/mtau/mtau;
3179 Fxmu = 1. - 8. * xmu + 8. * xmu*xmu*xmu - xmu*xmu*xmu*xmu -12. * xmu*xmu * log(xmu);
3180
3181 g2LFU = (Gamma_tau_l_nunu(leptons[MU])/Gamma_tau_l_nunu(leptons[ELECTRON]));
3182
3183 g2LFU = g2LFU * (Fxe/Fxmu);
3184
3185 return sqrt(g2LFU);
3186}
3187
3188const double StandardModel::TauLFU_gtaugmu() const
3189{
3190 double g2LFU;
3191
3192 double me, mmu, mtau, xtau, Fxtau, xmu, Fxmu;
3193
3194 me = leptons[ELECTRON].getMass();
3195 mmu = leptons[MU].getMass();
3196 mtau = leptons[TAU].getMass();
3197
3198 xtau = me*me/mtau/mtau;
3199 Fxtau = 1. - 8. * xtau + 8. * xtau*xtau*xtau - xtau*xtau*xtau*xtau -12. * xtau*xtau * log(xtau);
3200
3201 xmu = me*me/mmu/mmu;
3202 Fxmu = 1. - 8. * xmu + 8. * xmu*xmu*xmu - xmu*xmu*xmu*xmu -12. * xmu*xmu * log(xmu);
3203
3204 g2LFU = (Gamma_tau_l_nunu(leptons[ELECTRON])/Gamma_muon());
3205
3206 g2LFU = g2LFU * (pow(mmu,5)*Fxmu/pow(mtau,5)/Fxtau);
3207
3208 return sqrt(g2LFU);
3209}
3210
3211const double StandardModel::TauLFU_gtauge() const
3212{
3213 double g2LFU;
3214
3215 double me, mmu, mtau, xtau, Fxtau, xmu, Fxmu;
3216
3217 me = leptons[ELECTRON].getMass();
3218 mmu = leptons[MU].getMass();
3219 mtau = leptons[TAU].getMass();
3220
3221 xtau = mmu*mmu/mtau/mtau;
3222 Fxtau = 1. - 8. * xtau + 8. * xtau*xtau*xtau - xtau*xtau*xtau*xtau -12. * xtau*xtau * log(xtau);
3223
3224 xmu = me*me/mmu/mmu;
3225 Fxmu = 1. - 8. * xmu + 8. * xmu*xmu*xmu - xmu*xmu*xmu*xmu -12. * xmu*xmu * log(xmu);
3226
3227 g2LFU = (Gamma_tau_l_nunu(leptons[MU])/Gamma_muon());
3228
3229 g2LFU = g2LFU * (pow(mmu,5)*Fxmu/pow(mtau,5)/Fxtau);
3230
3231 return sqrt(g2LFU);
3232}
3233
3234
3235const double StandardModel::TauLFU_gtaugmuPi() const
3236{
3237 // 1st approx.
3238
3239 return 1.0;
3240}
3241
3242const double StandardModel::TauLFU_gtaugmuK() const
3243{
3244 // 1st approx.
3245
3246 return 1.0;
3247}
3248
3249
3251// Higgs processes
3253
3254// Integrals
3255
3256gslpp::complex StandardModel::f_triangle(const double tau) const {
3257 gslpp::complex tmp;
3258 if (tau >= 1.0) {
3259 tmp = asin(1.0 / sqrt(tau));
3260 return (tmp * tmp);
3261 } else {
3262 tmp = log((1.0 + sqrt(1.0 - tau)) / (1.0 - sqrt(1.0 - tau))) - M_PI * gslpp::complex::i();
3263 return (-0.25 * tmp * tmp);
3264 }
3265}
3266
3267gslpp::complex StandardModel::g_triangle(const double tau) const {
3268 gslpp::complex tmp;
3269 if (tau >= 1.0) {
3270 tmp = sqrt(tau - 1.0) * asin(1.0 / sqrt(tau));
3271 return tmp;
3272 } else {
3273 tmp = sqrt(1.0 - tau) * (log((1.0 + sqrt(1.0 - tau)) / (1.0 - sqrt(1.0 - tau))) - M_PI * gslpp::complex::i());
3274 return 0.5 * tmp;
3275 }
3276}
3277
3278gslpp::complex StandardModel::I_triangle_1(const double tau, const double lambda) const {
3279 gslpp::complex tmp;
3280
3281 tmp = (tau * lambda * (f_triangle(tau) - f_triangle(lambda)) + 2.0 * tau * (g_triangle(tau) - g_triangle(lambda))) / (tau - lambda);
3282
3283 tmp = tau * lambda * (1.0 + tmp) / (2.0 * (tau - lambda));
3284
3285 return tmp;
3286}
3287
3288gslpp::complex StandardModel::I_triangle_2(const double tau, const double lambda) const {
3289 gslpp::complex tmp;
3290
3291 tmp = -0.5 * tau * lambda * (f_triangle(tau) - f_triangle(lambda)) / (tau - lambda);
3292
3293 return tmp;
3294}
3295
3296gslpp::complex StandardModel::AH_f(const double tau) const {
3297 return (2.0 * tau * (1.0 + (1.0 - tau) * f_triangle(tau)));
3298}
3299
3300gslpp::complex StandardModel::AH_W(const double tau) const {
3301 return -(2.0 + 3.0 * tau + 3.0 * tau * (2.0 - tau) * f_triangle(tau));
3302}
3303
3304gslpp::complex StandardModel::AHZga_f(const double tau, const double lambda) const {
3305 return I_triangle_1(tau, lambda) - I_triangle_2(tau, lambda);
3306}
3307
3308gslpp::complex StandardModel::AHZga_W(const double tau, const double lambda) const {
3309 gslpp::complex tmp;
3310
3311 double tan2w = sW2() / cW2();
3312
3313 tmp = 4.0 * (3.0 - tan2w) * I_triangle_2(tau, lambda);
3314
3315 tmp = tmp + ((1.0 + 2.0 / tau) * tan2w - (5.0 + 2.0 / tau)) * I_triangle_1(tau, lambda);
3316
3317 return sqrt(cW2()) * tmp;
3318}
3319
3321
3322const double StandardModel::SigmaeeZH(const double sqrt_s, const double Pe, const double Pp) const
3323{
3324 double xsLH, xsRH;
3325 double gL,gR,lam,fact;
3326 double s = sqrt_s*sqrt_s;
3327
3328 // From https://arxiv.org/pdf/hep-ph/9605437
3329
3330 gL = -0.5 + sW2();
3331
3332 gR = sW2();
3333
3334 lam = (1.0-(mHl+Mz)*(mHl+Mz)/s)*(1.0-(mHl-Mz)*(mHl-Mz)/s);
3335
3336 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 );
3337
3338 xsLH = 32.0 * gL * gL * fact;
3339 xsRH = 32.0 * gR * gR * fact;
3340
3341 return 0.25*( (1.0 - Pe)*(1.0 + Pp)*xsLH + (1.0 + Pe)*(1.0 - Pp)*xsRH );
3342}
3343
3344const double StandardModel::SigmaeeHvv(const double sqrt_s, const double Pe, const double Pp) const
3345{
3346 double xsLH=1.0, xsRH=0.0;
3347
3348 return 0.25*( (1.0 - Pe)*(1.0 + Pp)*xsLH + (1.0 + Pe)*(1.0 - Pp)*xsRH );
3349}
3350
3351const double StandardModel::SigmaeeHee(const double sqrt_s, const double Pe, const double Pp) const
3352{
3353 double xsLH=0.0, xsRH=0.0;
3354
3355 return 0.25*( (1.0 - Pe)*(1.0 + Pp)*xsLH + (1.0 + Pe)*(1.0 - Pp)*xsRH );
3356}
3357
3359// Higgs decay widths
3361
3362const double StandardModel::GammaHtogg() const
3363{
3364 double gamma;
3365 double tau_t = 4.0 * pow(quarks[TOP].getMass(),2)/mHl/mHl;
3366 double tau_b = 4.0 * pow(quarks[BOTTOM].getMass(),2)/mHl/mHl;
3367 double tau_c = 4.0 * pow(quarks[CHARM].getMass(),2)/mHl/mHl;
3368 double tau_s = 4.0 * pow(quarks[STRANGE].getMass(),2)/mHl/mHl;
3369 double asMH,LH,Lt,nl,h0,h1,h2, h3,G0;
3370
3371 // alfa_s(MH)
3372 asMH = Als(mHl, FULLNLO);
3373
3374 // NLO corrections ( See https://arxiv.org/pdf/0708.0916 and its REf. [25])
3375 // I only keep up to h3 in expr. (4), and use pole mass in tau factors for the moment
3376 nl = 5;
3377 LH = 0.; // log(mu^2/MH^2) evaluated at mu=MH
3378 Lt = 2.0*log(mHl/(quarks[TOP].getMass()));
3379
3380 h0 = (95./4.) + (11./2.)*LH + nl*(-7./6. - LH/3.);
3381 h1 = 5803./540. + 77.*LH/30. -14.*Lt/15. + nl * (-29./60. - 7. * LH / 45.);
3382 h2 = 1029839./189000. + 16973.*LH/12600. - 1543.*Lt/1575. + nl * ( - 89533./378000 - 1543.*LH/18900. );
3383 h3 = 9075763./2976750. + 1243*LH/1575. - 452.*Lt/575. + nl * ( - 3763./28350. -226. * LH / 4725. );
3384 G0 = GF * pow(mHl,3.0)/(36.*M_PI*sqrt(2.));
3385
3386 gamma = asMH*asMH * (4.0 * GF /sqrt(2.0)) * (mHl*mHl*mHl /64.0/pow(M_PI,3.0)) *
3387 ( AH_f(tau_t) + AH_f(tau_b) + AH_f(tau_c) + AH_f(tau_s) ).abs2()/4.0;
3388
3389 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 );
3390
3391 return gamma;
3392}
3393
3394const double StandardModel::GammaHtoZZstar() const
3395{
3396 double x=Mz/mHl;
3397 double fx;
3398 double g2 = 4.0 * sqrt(2.0) * GF * Mz * Mz;
3399 double gamma;
3400
3401 fx = -fabs(1.0-x*x)*( 47.0*x*x/2.0 - 13.0/2.0 +1.0/x/x ) +
3402 3.0*( 1.0 - 6.0*x*x + 4.0*x*x*x*x )*fabs(log(x)) +
3403 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);
3404
3405 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);
3406
3407 return gamma;
3408}
3409
3410const double StandardModel::GammaHtoWWstar() const
3411{
3412 double x=Mw()/mHl;
3413 double fx;
3414 double g2 = 4.0 * sqrt(2.0) * GF * pow(Mw(),2);
3415 double gamma;
3416
3417 fx = -fabs(1.0-x*x)*( 47.0*x*x/2.0 - 13.0/2.0 +1.0/x/x ) +
3418 3.0*( 1.0 - 6.0*x*x + 4.0*x*x*x*x )*fabs(log(x)) +
3419 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);
3420
3421 gamma = 3.0 * g2*g2 * mHl * fx / 512.0 / pow(M_PI,3.0);
3422
3423 return gamma;
3424}
3425
3426const double StandardModel::GammaHtoZga() const
3427{
3428 double gamma;
3429
3430 double m_t = mtpole;
3431 double m_b = quarks[BOTTOM].getMass();
3432 double m_c = quarks[CHARM].getMass();
3433 double m_s = quarks[STRANGE].getMass();
3434 double m_tau = leptons[TAU].getMass();
3435 double m_mu = leptons[MU].getMass();
3436
3437 double M_w_2 = pow(Mw(),2.0);
3438
3439 double Qt = quarks[TOP].getCharge();
3440 double Qb = quarks[BOTTOM].getCharge();
3441 double Qc = quarks[CHARM].getCharge();
3442 double Qs = quarks[STRANGE].getCharge();
3443 double Qtau = leptons[TAU].getCharge();
3444 double Qmu = leptons[MU].getCharge();
3445
3446 double tau_t = 4.0 * m_t * m_t / mHl / mHl;
3447 double tau_b = 4.0 * m_b * m_b / mHl / mHl;
3448 double tau_c = 4.0 * m_c * m_c / mHl / mHl;
3449 double tau_s = 4.0 * m_s * m_s / mHl / mHl;
3450 double tau_tau = 4.0 * m_tau * m_tau / mHl / mHl;
3451 double tau_mu = 4.0 * m_mu * m_mu / mHl / mHl;
3452 double tau_W = 4.0 * M_w_2 / mHl / mHl;
3453
3454 double lambda_t = 4.0 * m_t * m_t / Mz / Mz;
3455 double lambda_b = 4.0 * m_b * m_b / Mz / Mz;
3456 double lambda_c = 4.0 * m_c * m_c / Mz / Mz;
3457 double lambda_s = 4.0 * m_s * m_s / Mz / Mz;
3458 double lambda_tau = 4.0 * m_tau * m_tau / Mz / Mz;
3459 double lambda_mu = 4.0 * m_mu * m_mu / Mz / Mz;
3460 double lambda_W = 4.0 * M_w_2 / Mz / Mz;
3461
3462 double sc = sqrt(sW2()*cW2());
3463 double vSMt = (2.0 * (quarks[TOP].getIsospin()) - 4.0 * Qt * sW2())/sc;
3464 double vSMb = (2.0 * (quarks[BOTTOM].getIsospin()) - 4.0 * Qb * sW2())/sc;
3465 double vSMc = (2.0 * (quarks[CHARM].getIsospin()) - 4.0 * Qc * sW2())/sc;
3466 double vSMs = (2.0 * (quarks[STRANGE].getIsospin()) - 4.0 * Qs * sW2())/sc;
3467 double vSMtau = (2.0 * (leptons[TAU].getIsospin()) - 4.0 * Qtau * sW2())/sc;
3468 double vSMmu = (2.0 * (leptons[MU].getIsospin()) - 4.0 * Qmu * sW2())/sc;
3469
3470 gslpp::complex MSM;
3471
3472 MSM = (ale/4.0/M_PI) * ((3.0 * vSMt * Qt * AHZga_f(tau_t, lambda_t) +
3473 3.0 * vSMb * Qb * AHZga_f(tau_b, lambda_b) +
3474 3.0 * vSMc * Qc * AHZga_f(tau_c, lambda_c) +
3475 3.0 * vSMs * Qs * AHZga_f(tau_s, lambda_s) +
3476 vSMtau * Qtau * AHZga_f(tau_tau, lambda_tau) +
3477 vSMmu * Qmu * AHZga_f(tau_mu, lambda_mu)) +
3478 AHZga_W(tau_W, lambda_W)/sqrt(sW2()));
3479
3480 gamma = (4.0*sqrt(2)*GF) * (MSM.abs2()) * pow(mHl*(1.0-Mz*Mz/mHl/mHl),3.0)/32.0/M_PI;
3481
3482 return gamma;
3483}
3484
3485const double StandardModel::GammaHtogaga() const
3486{
3487 double gamma;
3488
3489 double m_t = mtpole;
3490 double m_b = quarks[BOTTOM].getMass();
3491 double m_c = quarks[CHARM].getMass();
3492 double m_s = quarks[STRANGE].getMass();
3493 double m_tau = leptons[TAU].getMass();
3494 double m_mu = leptons[MU].getMass();
3495
3496 double M_w_2 = pow(Mw(),2.0);
3497
3498 double Qt = quarks[TOP].getCharge();
3499 double Qb = quarks[BOTTOM].getCharge();
3500 double Qc = quarks[CHARM].getCharge();
3501 double Qs = quarks[STRANGE].getCharge();
3502 double Qtau = leptons[TAU].getCharge();
3503 double Qmu = leptons[MU].getCharge();
3504
3505 double tau_t = 4.0 * m_t * m_t / mHl / mHl;
3506 double tau_b = 4.0 * m_b * m_b / mHl / mHl;
3507 double tau_c = 4.0 * m_c * m_c / mHl / mHl;
3508 double tau_s = 4.0 * m_s * m_s / mHl / mHl;
3509 double tau_tau = 4.0 * m_tau * m_tau / mHl / mHl;
3510 double tau_mu = 4.0 * m_mu * m_mu / mHl / mHl;
3511 double tau_W = 4.0 * M_w_2 / mHl / mHl;
3512
3513 gslpp::complex MSM;
3514
3515 MSM = ale * (3.0 * Qt * Qt * AH_f(tau_t) +
3516 3.0 * Qb * Qb * AH_f(tau_b) +
3517 3.0 * Qc * Qc * AH_f(tau_c) +
3518 3.0 * Qs * Qs * AH_f(tau_s) +
3519 Qtau * Qtau * AH_f(tau_tau) +
3520 Qmu * Qmu * AH_f(tau_mu) +
3521 AH_W(tau_W));
3522
3523 gamma = (4.0*GF/sqrt(2)) * (MSM.abs2()) * pow(mHl,3.0)/512.0/pow(M_PI,3);
3524
3525 return gamma;
3526}
3527
3528const double StandardModel::GammaHtomumu() const
3529{
3530 double mf=leptons[MU].getMass();
3531 double beta=1.0-4.0*mf*mf/mHl/mHl;
3532 double Nc=1.0;
3533 double gamma;
3534
3535 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta;
3536
3537 return gamma;
3538}
3539
3540const double StandardModel::GammaHtotautau() const
3541{
3542 double mf=leptons[TAU].getMass();
3543 double beta=1.0-4.0*mf*mf/mHl/mHl;
3544 double Nc=1.0;
3545 double gamma;
3546
3547 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta;
3548
3549 return gamma;
3550}
3551
3552const double StandardModel::GammaHtocc() const
3553{
3554 double mf0=quarks[CHARM].getMass(), mf;
3555 double beta;
3556 double Nc=3.0;
3557 double gamma;
3558 double asMH,DeltaQCD,Deltamt,NF;
3559
3560 // alfa_s(MH)
3561 asMH = Als(mHl, FULLNLO);
3562
3563 mf = Mrun(mHl, mf0, mf0, CHARM, FULLNLO);
3564
3565 beta=1.0-4.0*mf*mf/mHl/mHl;
3566
3567 NF=5;
3568
3569 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) ) );
3570
3571 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) );
3572
3573 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta * (DeltaQCD + Deltamt);
3574
3575 return gamma;
3576}
3577
3578const double StandardModel::GammaHtoss() const
3579{
3580 double mf0=quarks[STRANGE].getMass(), mf;
3581 double beta;
3582 double Nc=3.0;
3583 double gamma;
3584 double asMH,DeltaQCD,Deltamt,NF;
3585
3586 // alfa_s(MH)
3587 asMH = Als(mHl, FULLNLO);
3588
3589 mf = Mrun(mHl, 2.0, mf0, STRANGE, FULLNLO);
3590
3591 beta=1.0-4.0*mf*mf/mHl/mHl;
3592
3593 NF=5;
3594
3595 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) ) );
3596
3597 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) );
3598
3599 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta * (DeltaQCD + Deltamt);
3600
3601 return gamma;
3602}
3603
3604const double StandardModel::GammaHtobb() const
3605{
3606 double mf0=quarks[BOTTOM].getMass(), mf;
3607 double beta;
3608 double Nc=3.0;
3609 double gamma;
3610 double asMH,DeltaQCD,Deltamt,NF;
3611
3612 // alfa_s(MH)
3613 asMH = Als(mHl, FULLNLO);
3614
3615 mf = Mrun(mHl, mf0, mf0, BOTTOM, FULLNLO);
3616
3617 beta=1.0-4.0*mf*mf/mHl/mHl;
3618
3619 NF=5;
3620
3621 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) ) );
3622
3623 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) );
3624
3625 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta * (DeltaQCD + Deltamt);
3626
3627 return gamma;
3628}
3629
3630const double StandardModel::GammaHTot() const
3631{
3632 double gamma;
3633
3634 gamma = GammaHtobb() + GammaHtocc() + GammaHtoss() +
3635 GammaHtotautau() + GammaHtomumu() +
3636 GammaHtoZZstar() + GammaHtoWWstar() +
3637 GammaHtogg() + GammaHtogaga() + GammaHtoZga();
3638
3639 return gamma;
3640}
3641
3643// Higgs branching ratios
3645
3646const double StandardModel::BrHtogg() const
3647{
3648 return GammaHtogg()/GammaHTot();
3649}
3650
3651const double StandardModel::BrHtoZZstar() const
3652{
3653 return GammaHtoZZstar()/GammaHTot();
3654}
3655
3656const double StandardModel::BrHtoWWstar() const
3657{
3658 return GammaHtoWWstar()/GammaHTot();
3659}
3660
3661const double StandardModel::BrHtoZga() const
3662{
3663 return GammaHtoZga()/GammaHTot();
3664}
3665
3666const double StandardModel::BrHtogaga() const
3667{
3668 return GammaHtogaga()/GammaHTot();
3669}
3670
3671const double StandardModel::BrHtomumu() const
3672{
3673 return GammaHtomumu()/GammaHTot();
3674}
3675
3676const double StandardModel::BrHtotautau() const
3677{
3678 return GammaHtotautau()/GammaHTot();
3679}
3680
3681const double StandardModel::BrHtocc() const
3682{
3683 return GammaHtocc()/GammaHTot();
3684}
3685
3686const double StandardModel::BrHtoss() const
3687{
3688 return GammaHtoss()/GammaHTot();
3689}
3690
3691const double StandardModel::BrHtobb() const
3692{
3693 return GammaHtobb()/GammaHTot();
3694}
3695
3697//Generic e+e- -> ff Inclusive Observables
3698
3699// For f!=e
3700// (f=e also included to define a t-subtracted observable, like in LEP)
3701
3702// Helicity amplitudes squared
3703const double StandardModel::MLR2eeff(const Particle f, const double s) const {
3704
3705 // Definitions
3706 double Qf, geLSM, gfRSM, is2c2, GZ, Mz2s;
3707
3708 double MLR2SM;
3709
3710 // -------------------------------------------
3711
3712 geLSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3713
3714 is2c2 = 1. / s02() / c02();
3715
3716 GZ = Gamma_Z();
3717
3718 Mz2s = Mz * Mz - s;
3719
3720 if (f.is("ELECTRON")) {
3721 Qf = leptons[ELECTRON].getCharge();
3722 gfRSM = - Qf * s02();
3723 } else if (f.is("MU")) {
3724 Qf = leptons[MU].getCharge();
3725 gfRSM = - Qf * s02();
3726 } else if (f.is("TAU")) {
3727 Qf = leptons[TAU].getCharge();
3728 gfRSM = - Qf * s02();
3729 } else if (f.is("UP")) {
3730 Qf = quarks[UP].getCharge();
3731 gfRSM = - Qf * s02();
3732 } else if (f.is("CHARM")) {
3733 Qf = quarks[CHARM].getCharge();
3734 gfRSM = - Qf * s02();
3735 } else if (f.is("DOWN")) {
3736 Qf = quarks[DOWN].getCharge();
3737 gfRSM = - Qf * s02();
3738 } else if (f.is("STRANGE")) {
3739 Qf = quarks[STRANGE].getCharge();
3740 gfRSM = - Qf * s02();
3741 } else if (f.is("BOTTOM")) {
3742 Qf = quarks[BOTTOM].getCharge();
3743 gfRSM = - Qf * s02();
3744 } else
3745 throw std::runtime_error("StandardModel::MLR2eeff: wrong argument");
3746
3747 // LR, RL, LL and RR SM squared amplitudes
3748 MLR2SM = Qf * Qf
3749 + (is2c2 * is2c2 * (geLSM * geLSM * gfRSM * gfRSM) * s * s
3750 + 2.0 * Qf * is2c2 * (geLSM * gfRSM) * Mz2s * s) / (Mz2s * Mz2s + Mz * Mz * GZ * GZ);
3751
3752 return MLR2SM;
3753}
3754const double StandardModel::MRL2eeff(const Particle f, const double s) const{
3755
3756 // Definitions
3757 double Qf, geRSM, gfLSM, is2c2, GZ, Mz2s;
3758
3759 double MRL2SM;
3760
3761 // -------------------------------------------
3762
3763 geRSM = - (leptons[ELECTRON].getCharge()) * s02();
3764
3765 is2c2 = 1. / s02() / c02();
3766
3767 GZ = Gamma_Z();
3768
3769 Mz2s = Mz * Mz - s;
3770
3771 if (f.is("ELECTRON")) {
3772 Qf = leptons[ELECTRON].getCharge();
3773 gfLSM = (leptons[ELECTRON].getIsospin()) - Qf * s02();
3774 } else if (f.is("MU")) {
3775 Qf = leptons[MU].getCharge();
3776 gfLSM = (leptons[MU].getIsospin()) - Qf * s02();
3777 } else if (f.is("TAU")) {
3778 Qf = leptons[TAU].getCharge();
3779 gfLSM = (leptons[TAU].getIsospin()) - Qf * s02();
3780 } else if (f.is("UP")) {
3781 Qf = quarks[UP].getCharge();
3782 gfLSM = (quarks[UP].getIsospin()) - Qf * s02();
3783 } else if (f.is("CHARM")) {
3784 Qf = quarks[CHARM].getCharge();
3785 gfLSM = (quarks[CHARM].getIsospin()) - Qf * s02();
3786 } else if (f.is("DOWN")) {
3787 Qf = quarks[DOWN].getCharge();
3788 gfLSM = (quarks[DOWN].getIsospin()) - Qf * s02();
3789 } else if (f.is("STRANGE")) {
3790 Qf = quarks[STRANGE].getCharge();
3791 gfLSM = (quarks[STRANGE].getIsospin()) - Qf * s02();
3792 } else if (f.is("BOTTOM")) {
3793 Qf = quarks[BOTTOM].getCharge();
3794 gfLSM = (quarks[BOTTOM].getIsospin()) - Qf * s02();
3795 } else
3796 throw std::runtime_error("StandardModel::MRL2eeff: wrong argument");
3797
3798 // RL SM squared amplitude
3799 MRL2SM = Qf * Qf
3800 + (is2c2 * is2c2 * (geRSM * geRSM * gfLSM * gfLSM) * s * s
3801 + 2.0 * Qf * is2c2 * (geRSM * gfLSM) * Mz2s * s) / (Mz2s * Mz2s + Mz * Mz * GZ * GZ);
3802
3803 return MRL2SM;
3804}
3805
3806const double StandardModel::MLL2eeff(const Particle f, const double s, const double t) const{
3807
3808 // Definitions
3809 double Qf, geLSM, gfLSM, is2c2, GZ, Mz2s;
3810
3811 double MLL2SM;
3812
3813 // -------------------------------------------
3814
3815 geLSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3816
3817 is2c2 = 1. / s02() / c02();
3818
3819 GZ = Gamma_Z();
3820
3821 Mz2s = Mz * Mz - s;
3822
3823 if (f.is("ELECTRON")) {
3824 Qf = leptons[ELECTRON].getCharge();
3825 gfLSM = (leptons[ELECTRON].getIsospin()) - Qf * s02();
3826 } else if (f.is("MU")) {
3827 Qf = leptons[MU].getCharge();
3828 gfLSM = (leptons[MU].getIsospin()) - Qf * s02();
3829 } else if (f.is("TAU")) {
3830 Qf = leptons[TAU].getCharge();
3831 gfLSM = (leptons[TAU].getIsospin()) - Qf * s02();
3832 } else if (f.is("UP")) {
3833 Qf = quarks[UP].getCharge();
3834 gfLSM = (quarks[UP].getIsospin()) - Qf * s02();
3835 } else if (f.is("CHARM")) {
3836 Qf = quarks[CHARM].getCharge();
3837 gfLSM = (quarks[CHARM].getIsospin()) - Qf * s02();
3838 } else if (f.is("DOWN")) {
3839 Qf = quarks[DOWN].getCharge();
3840 gfLSM = (quarks[DOWN].getIsospin()) - Qf * s02();
3841 } else if (f.is("STRANGE")) {
3842 Qf = quarks[STRANGE].getCharge();
3843 gfLSM = (quarks[STRANGE].getIsospin()) - Qf * s02();
3844 } else if (f.is("BOTTOM")) {
3845 Qf = quarks[BOTTOM].getCharge();
3846 gfLSM = (quarks[BOTTOM].getIsospin()) - Qf * s02();
3847 } else
3848 throw std::runtime_error("StandardModel::MLL2eeff: wrong argument");
3849
3850 // LL SM squared amplitude
3851 MLL2SM = Qf * Qf
3852 + (is2c2 * is2c2 * (geLSM * geLSM * gfLSM * gfLSM) * s * s
3853 + 2.0 * Qf * is2c2 * (geLSM * gfLSM) * Mz2s * s) / (Mz2s * Mz2s + Mz * Mz * GZ * GZ);
3854
3855 return MLL2SM;
3856
3857}
3858const double StandardModel::MRR2eeff(const Particle f, const double s, const double t) const{
3859
3860 // Definitions
3861 double Qf, geRSM, gfRSM, is2c2, GZ, Mz2s;
3862
3863 double MRR2SM;
3864
3865 // -------------------------------------------
3866
3867 geRSM = - (leptons[ELECTRON].getCharge()) * s02();
3868
3869 is2c2 = 1. / s02() / c02();
3870
3871 GZ = Gamma_Z();
3872
3873 Mz2s = Mz * Mz - s;
3874
3875 if (f.is("ELECTRON")) {
3876 Qf = leptons[ELECTRON].getCharge();
3877 gfRSM = - Qf * s02();
3878 } else if (f.is("MU")) {
3879 Qf = leptons[MU].getCharge();
3880 gfRSM = - Qf * s02();
3881 } else if (f.is("TAU")) {
3882 Qf = leptons[TAU].getCharge();
3883 gfRSM = - Qf * s02();
3884 } else if (f.is("UP")) {
3885 Qf = quarks[UP].getCharge();
3886 gfRSM = - Qf * s02();
3887 } else if (f.is("CHARM")) {
3888 Qf = quarks[CHARM].getCharge();
3889 gfRSM = - Qf * s02();
3890 } else if (f.is("DOWN")) {
3891 Qf = quarks[DOWN].getCharge();
3892 gfRSM = - Qf * s02();
3893 } else if (f.is("STRANGE")) {
3894 Qf = quarks[STRANGE].getCharge();
3895 gfRSM = - Qf * s02();
3896 } else if (f.is("BOTTOM")) {
3897 Qf = quarks[BOTTOM].getCharge();
3898 gfRSM = - Qf * s02();
3899 } else
3900 throw std::runtime_error("StandardModel::MRR2eeff: wrong argument");
3901
3902 // RR SM squared amplitude
3903 MRR2SM = Qf * Qf
3904 + (is2c2 * is2c2 * (geRSM * geRSM * gfRSM * gfRSM) * s * s
3905 + 2.0 * Qf * is2c2 * (geRSM * gfRSM) * Mz2s * s) / (Mz2s * Mz2s + Mz * Mz * GZ * GZ);
3906
3907 return MRR2SM;
3908}
3909
3910// Some simple functions for cos \theta integrals
3911
3912const double StandardModel::tovers2(const double cosmin, const double cosmax) const {
3913 return 0.25 * (cosmax * (1.0 - cosmax * (1.0 - cosmax / 3.0)) - cosmin * (1.0 - cosmin * (1.0 - cosmin / 3.0)));
3914}
3915
3916const double StandardModel::uovers2(const double cosmin, const double cosmax) const {
3917 return 0.25 * (cosmax * (1.0 + cosmax * (1.0 + cosmax / 3.0)) - cosmin * (1.0 + cosmin * (1.0 + cosmin / 3.0)));
3918}
3919
3920// Expressions for f=e
3921
3922// Integrals of the SM squared amplitudes x (t/s)^2, (s/t)^2, (u/s)^2 in [t0, t1]
3923const double StandardModel::intMLR2eeeets2(const double s, const double t0, const double t1) const {
3924
3925 double intM2;
3926 double sw2cw2;
3927 double gLeSM,gReSM;
3928 double GammaZSM;
3929 double Mz2, s2;
3930 double propZSM2,propZSMRe,MeeLR2SM;
3931
3932 sw2cw2 = s02() * c02();
3933 gLeSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3934 gReSM = - (leptons[ELECTRON].getCharge()) * s02();
3935 GammaZSM = Gamma_Z();
3936 Mz2 = Mz * Mz;
3937 s2 = s * s;
3938
3939 propZSM2 = s2/((s - Mz2)*(s - Mz2) + Mz2*GammaZSM*GammaZSM);
3940 propZSMRe = (s*(s - Mz2))/((s - Mz2)*(s - Mz2) + Mz2*GammaZSM*GammaZSM);
3941
3942 MeeLR2SM = 1.0 + (gLeSM*gLeSM*gReSM*gReSM/(sw2cw2*sw2cw2))*propZSM2 + 2.0*(gLeSM*gReSM/sw2cw2)*propZSMRe;
3943
3944 intM2 = MeeLR2SM*(t1*t1*t1 - t0*t0*t0)/(3.0*s*s);
3945
3946 return intM2;
3947}
3948
3949const double StandardModel::intMLRtilde2eeeest2(const double s, const double t0, const double t1) const {
3950
3951 double intM2;
3952 double sw2cw2;
3953 double gLeSM,gReSM;
3954 double Mz2;
3955
3956 sw2cw2 = s02() * c02();
3957 gLeSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3958 gReSM = - (leptons[ELECTRON].getCharge()) * s02();
3959 Mz2 = Mz * Mz;
3960
3961 intM2 = s*s*(((gLeSM*gLeSM*gReSM*gReSM)/sw2cw2/sw2cw2)*(1.0/(Mz2 - t1) - 1.0/(Mz2 - t0)) - 1.0/t1 + 1.0/t0 +
3962 (2.0*gLeSM*gReSM*(-log(t1/t0) + log((-Mz2 + t1)/(-Mz2 + t0))))/(Mz2*sw2cw2));
3963
3964 return intM2;
3965}
3966
3967const double StandardModel::intMLL2eeeeus2(const double s, const double t0, const double t1) const {
3968
3969 double intM2;
3970 double sw2cw2;
3971 double gLeSM;
3972 double GammaZSM;
3973 double Mz2, Mz4, s2;
3974
3975 sw2cw2 = s02() * c02();
3976 gLeSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3977 GammaZSM = Gamma_Z();
3978 Mz2 = Mz * Mz;
3979 Mz4 = Mz2 * Mz2;
3980 s2 = s * s;
3981
3982 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)) +
3983 ((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)) +
3984 (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)) ) +
3985 (2.0*(gLeSM*gLeSM) )/(Mz2*sw2cw2)*(Mz2 *(t1 - t0) - s2*log(t1/t0) + (Mz2 + s)*(Mz2 + s)*log((-Mz2 + t1)/(-Mz2 + t0))) +
3986 (-(s2/t1) + s2/t0 + t1 - t0 + 2.0*s*log(t1/t0)) +
3987 (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)));
3988
3989 return intM2;
3990}
3991
3992const double StandardModel::intMRR2eeeeus2(const double s, const double t0, const double t1) const {
3993
3994 double intM2;
3995 double sw2cw2;
3996 double gReSM;
3997 double GammaZSM;
3998 double Mz2, Mz4, s2;
3999
4000 sw2cw2 = s02() * c02();
4001 gReSM = - (leptons[ELECTRON].getCharge()) * s02();
4002 GammaZSM = Gamma_Z();
4003 Mz2 = Mz * Mz;
4004 Mz4 = Mz2 * Mz2;
4005 s2 = s * s;
4006
4007 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)) +
4008 ((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)) +
4009 (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)) ) +
4010 (2.0*(gReSM*gReSM) )/(Mz2*sw2cw2)*(Mz2 *(t1 - t0) - s2*log(t1/t0) + (Mz2 + s)*(Mz2 + s)*log((-Mz2 + t1)/(-Mz2 + t0))) +
4011 (-(s2/t1) + s2/t0 + t1 - t0 + 2.0*s*log(t1/t0)) +
4012 (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)));
4013
4014 return intM2;
4015}
4016
4017// Cross sections
4018
4019const double StandardModel::eeffsigmaEbin(const double pol_e, const double pol_p, const double s, const double cosmin, const double cosmax) const {
4020
4021 double sumM2, sigma;
4022 double topb = 0.3894e+9;
4023 double t0, t1, lambdaK;
4024
4025 double pLH, pRH; //Polarization factors, minus the 1/4 average
4026
4027 pLH = (1.0 - pol_e) * (1.0 + pol_p);
4028 pRH = (1.0 + pol_e) * (1.0 - pol_p);
4029
4030 // t values for cosmin and cosmax
4031 t0 = 0.5 * s * ( -1.0 + cosmin );
4032 t1 = 0.5 * s * ( -1.0 + cosmax );
4033
4034 // Kähllén function of (s,0,0)
4035 lambdaK = s*s;
4036
4037 // Sum of the integrals of the amplitudes squared x (t/s)^2, (s/t)^2, (u/s)^2
4038 sumM2 = (pLH + pRH) * ( intMLR2eeeets2(s, t0, t1) + intMLRtilde2eeeest2(s, t0, t1) ) +
4039 pLH * intMLL2eeeeus2(s, t0, t1) + pRH * intMRR2eeeeus2(s, t0, t1);
4040
4041 // Build the cross section
4042 sigma = M_PI * (alphaMz())*(alphaMz()) * sumM2 / s / sqrt(lambdaK);
4043
4044 return topb * sigma;
4045
4046}
4047
4048const double StandardModel::eeffsigma(const Particle f, const double pol_e, const double pol_p, const double s, const double cosmin, const double cosmax) const {
4049 // Only valid for f=/=e (MLL2, MRR2 do not depend on t for f=/=e. Simply enter t=1 as argument)
4050 // For f=e this corresponds to t-subtracted definition from LEP
4051 double sumM2, sigma;
4052 double tdumm = 1.;
4053 double topb = 0.3894e+9;
4054
4055 //double cosmin = -1.0;
4056 //double cosmax = 1.0;
4057
4058 double Nf;
4059
4060 double pLH, pRH; //Polarization factors, minus the 1/4 average
4061
4062 pLH = (1.0 - pol_e) * (1.0 + pol_p);
4063 pRH = (1.0 + pol_e) * (1.0 - pol_p);
4064
4065 if (f.is("LEPTON")) {
4066 Nf = 1.0;
4067 } else {
4068 Nf = 3.0;
4069 }
4070
4071 sumM2 = (pLH * MLR2eeff(f, s) + pRH * MRL2eeff(f, s)) * tovers2(cosmin, cosmax)
4072 + (pLH * MLL2eeff(f, s, tdumm) + pRH * MRR2eeff(f, s, tdumm)) * uovers2(cosmin, cosmax);
4073
4074 sigma = Nf * 0.5 * M_PI * (alphaMz())*(alphaMz()) * sumM2 / s;
4075
4076 return topb * sigma;
4077}
4078
4079/* BEGIN: REMOVE FROM THE PACKAGE */
4081//LEP2 Observables
4082
4083const double StandardModel::LEP2sigmaE(const double s) const
4084{
4085 return 0.;
4086}
4087
4088const double StandardModel::LEP2sigmaMu(const double s) const
4089{
4090 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
4091 double relerr = 1.e-8;
4092 double abserr = 1.e-20;
4093
4094 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
4095 if (!IsFlagNoApproximateGammaZ()){
4096
4097 /* SM contribution with the approximate formula */
4098 return (myApproximateFormulae->LEP2sigmaMuApprox(s));
4099
4100 } else {
4101
4102 if(s == 130.*130.){
4103
4104 if (!flagLEP2[ISR]){
4105 SMresult_cache = sigma_NoISR_l(QCD::lepton(MU), s);
4106 } else {
4107 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu130, &(*this), _1));
4108 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4109 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4110 }
4111 SMresult_cache = average;
4112 }
4113
4114 if (flagLEP2[WeakBox]) {
4115 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu130, &(*this), _1));
4116 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4117 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4118 }
4119 double sigma_box = average;
4120 SMresult_cache += sigma_box;
4121 }
4122 } else if (s == 136.*136.) {
4123 if (!flagLEP2[ISR]){
4124 SMresult_cache = sigma_NoISR_l(QCD::lepton(MU), s);
4125 } else {
4126 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu136, &(*this), _1));
4127 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4128 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4129 }
4130 SMresult_cache = average;
4131 }
4132
4133 if (flagLEP2[WeakBox]) {
4134 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu136, &(*this), _1));
4135 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4136 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4137 }
4138 double sigma_box = average;
4139 SMresult_cache += sigma_box;
4140 }
4141 } else if (s == 161.*161.){
4142 if (!flagLEP2[ISR])
4143 SMresult_cache = sigma_NoISR_l(QCD::lepton(MU), s);
4144 else {
4145 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu161, &(*this), _1));
4146 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4147 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4148 }
4149 SMresult_cache = average;
4150 }
4151
4152 if (flagLEP2[WeakBox]) {
4153 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu161, &(*this), _1));
4154 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4155 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4156 }
4157 double sigma_box = average;
4158 SMresult_cache += sigma_box;
4159 }
4160 } else if (s == 172.*172.) {
4161 if (!flagLEP2[ISR])
4162 SMresult_cache = sigma_NoISR_l(QCD::lepton(MU), s);
4163 else {
4164 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu172, &(*this), _1));
4165 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4166 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4167 }
4168 SMresult_cache = average;
4169 }
4170
4171 if (flagLEP2[WeakBox]) {
4172 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu172, &(*this), _1));
4173 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4174 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4175 }
4176 double sigma_box = average;
4177 SMresult_cache += sigma_box;
4178 }
4179 } else if (s == 183.*183.) {
4180 if (!flagLEP2[ISR])
4181 SMresult_cache = sigma_NoISR_l(QCD::lepton(MU), s);
4182 else {
4183 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu183, &(*this), _1));
4184 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4185 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4186 }
4187 SMresult_cache = average;
4188 }
4189
4190 if (flagLEP2[WeakBox]) {
4191 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu183, &(*this), _1));
4192 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4193 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4194 }
4195 double sigma_box = average;
4196 SMresult_cache += sigma_box;
4197 }
4198 } else if (s == 189.*189.) {
4199 if (!flagLEP2[ISR])
4200 SMresult_cache = sigma_NoISR_l(QCD::lepton(MU), s);
4201 else {
4202 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu189, &(*this), _1));
4203 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4204 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4205 }
4206 SMresult_cache = average;
4207 }
4208
4209 if (flagLEP2[WeakBox]) {
4210 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu189, &(*this), _1));
4211 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4212 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4213 }
4214 double sigma_box = average;
4215 SMresult_cache += sigma_box;
4216 }
4217 } else if (s == 192.*192.) {
4218 if (!flagLEP2[ISR])
4219 SMresult_cache = sigma_NoISR_l(QCD::lepton(MU), s);
4220 else {
4221 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu192, &(*this), _1));
4222 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4223 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4224 }
4225 SMresult_cache = average;
4226 }
4227
4228 if (flagLEP2[WeakBox]) {
4229 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu192, &(*this), _1));
4230 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4231 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4232 }
4233 double sigma_box = average;
4234 SMresult_cache += sigma_box;
4235 }
4236 } else if (s == 196.*196.) {
4237 if (!flagLEP2[ISR])
4238 SMresult_cache = sigma_NoISR_l(QCD::lepton(MU), s);
4239 else {
4240 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu196, &(*this), _1));
4241 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4242 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4243 }
4244 SMresult_cache = average;
4245 }
4246
4247 if (flagLEP2[WeakBox]) {
4248 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu196, &(*this), _1));
4249 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4250 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4251 }
4252 double sigma_box = average;
4253 SMresult_cache += sigma_box;
4254 }
4255 } else if (s == 200.*200.) {
4256 if (!flagLEP2[ISR])
4257 SMresult_cache = sigma_NoISR_l(QCD::lepton(MU), s);
4258 else {
4259 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu200, &(*this), _1));
4260 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4261 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4262 }
4263 SMresult_cache = average;
4264 }
4265
4266 if (flagLEP2[WeakBox]) {
4267 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu200, &(*this), _1));
4268 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4269 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4270 }
4271 double sigma_box = average;
4272 SMresult_cache += sigma_box;
4273 }
4274 } else if (s == 202.*202.) {
4275 if (!flagLEP2[ISR])
4276 SMresult_cache = sigma_NoISR_l(QCD::lepton(MU), s);
4277 else {
4278 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu202, &(*this), _1));
4279 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4280 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4281 }
4282 SMresult_cache = average;
4283 }
4284
4285 if (flagLEP2[WeakBox]) {
4286 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu202, &(*this), _1));
4287 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4288 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4289 }
4290 double sigma_box = average;
4291 SMresult_cache += sigma_box;
4292 }
4293 } else if (s == 205.*205.) {
4294 if (!flagLEP2[ISR])
4295 SMresult_cache = sigma_NoISR_l(QCD::lepton(MU), s);
4296 else {
4297 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu205, &(*this), _1));
4298 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4299 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4300 }
4301 SMresult_cache = average;
4302 }
4303
4304 if (flagLEP2[WeakBox]) {
4305 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu205, &(*this), _1));
4306 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4307 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4308 }
4309 double sigma_box = average;
4310 SMresult_cache += sigma_box;
4311 }
4312 } else if (s == 207.*207.) {
4313 if (!flagLEP2[ISR])
4314 SMresult_cache = sigma_NoISR_l(QCD::lepton(MU), s);
4315 else {
4316 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu207, &(*this), _1));
4317 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4318 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4319 }
4320 SMresult_cache = average;
4321 }
4322
4323 if (flagLEP2[WeakBox]) {
4324 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu207, &(*this), _1));
4325 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4326 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4327 }
4328 double sigma_box = average;
4329 SMresult_cache += sigma_box;
4330 }
4331 } else {
4332 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2AFBmu!");
4333 }
4334
4335 double sigma_mu = SMresult_cache;
4336
4337 gsl_set_error_handler(old_handler);
4338
4339 return sigma_mu;
4340
4341 }
4342}
4343
4344
4345const double StandardModel::LEP2sigmaTau(const double s) const
4346{
4347
4348 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
4349 double relerr = 1.e-7;
4350 double abserr = 1.e-17;
4351
4352 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
4353 if (!IsFlagNoApproximateGammaZ()){
4354
4355 /* SM contribution with the approximate formula */
4356 return (myApproximateFormulae->LEP2sigmaTauApprox(s));
4357
4358 } else {
4359
4360 if(s == 130.*130.){
4361
4362 if (!flagLEP2[ISR]){
4363 SMresult_cache = sigma_NoISR_l(QCD::lepton(TAU), s);
4364 } else {
4365 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau130, &(*this), _1));
4366 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4367 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4368 }
4369 SMresult_cache = average;
4370 }
4371
4372 if (flagLEP2[WeakBox]) {
4373 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau130, &(*this), _1));
4374 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4375 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4376 }
4377 double sigma_box = average;
4378 SMresult_cache += sigma_box;
4379 }
4380 } else if (s == 136.*136.) {
4381 if (!flagLEP2[ISR]){
4382 SMresult_cache = sigma_NoISR_l(QCD::lepton(TAU), s);
4383 } else {
4384 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau136, &(*this), _1));
4385 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4386 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4387 }
4388 SMresult_cache = average;
4389 }
4390
4391 if (flagLEP2[WeakBox]) {
4392 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau136, &(*this), _1));
4393 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4394 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4395 }
4396 double sigma_box = average;
4397 SMresult_cache += sigma_box;
4398 }
4399 } else if (s == 161.*161.){
4400 if (!flagLEP2[ISR])
4401 SMresult_cache = sigma_NoISR_l(QCD::lepton(TAU), s);
4402 else {
4403 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau161, &(*this), _1));
4404 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4405 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4406 }
4407 SMresult_cache = average;
4408 }
4409
4410 if (flagLEP2[WeakBox]) {
4411 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau161, &(*this), _1));
4412 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4413 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4414 }
4415 double sigma_box = average;
4416 SMresult_cache += sigma_box;
4417 }
4418 } else if (s == 172.*172.) {
4419 if (!flagLEP2[ISR])
4420 SMresult_cache = sigma_NoISR_l(QCD::lepton(TAU), s);
4421 else {
4422 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau172, &(*this), _1));
4423 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4424 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4425 }
4426 SMresult_cache = average;
4427 }
4428
4429 if (flagLEP2[WeakBox]) {
4430 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau172, &(*this), _1));
4431 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4432 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4433 }
4434 double sigma_box = average;
4435 SMresult_cache += sigma_box;
4436 }
4437 } else if (s == 183.*183.) {
4438 if (!flagLEP2[ISR])
4439 SMresult_cache = sigma_NoISR_l(QCD::lepton(TAU), s);
4440 else {
4441 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau183, &(*this), _1));
4442 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4443 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4444 }
4445 SMresult_cache = average;
4446 }
4447
4448 if (flagLEP2[WeakBox]) {
4449 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau183, &(*this), _1));
4450 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4451 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4452 }
4453 double sigma_box = average;
4454 SMresult_cache += sigma_box;
4455 }
4456 } else if (s == 189.*189.) {
4457 if (!flagLEP2[ISR])
4458 SMresult_cache = sigma_NoISR_l(QCD::lepton(TAU), s);
4459 else {
4460 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau189, &(*this), _1));
4461 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4462 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4463 }
4464 SMresult_cache = average;
4465 }
4466
4467 if (flagLEP2[WeakBox]) {
4468 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau189, &(*this), _1));
4469 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4470 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4471 }
4472 double sigma_box = average;
4473 SMresult_cache += sigma_box;
4474 }
4475 } else if (s == 192.*192.) {
4476 if (!flagLEP2[ISR])
4477 SMresult_cache = sigma_NoISR_l(QCD::lepton(TAU), s);
4478 else {
4479 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau192, &(*this), _1));
4480 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4481 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4482 }
4483 SMresult_cache = average;
4484 }
4485
4486 if (flagLEP2[WeakBox]) {
4487 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau192, &(*this), _1));
4488 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4489 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4490 }
4491 double sigma_box = average;
4492 SMresult_cache += sigma_box;
4493 }
4494 } else if (s == 196.*196.) {
4495 if (!flagLEP2[ISR])
4496 SMresult_cache = sigma_NoISR_l(QCD::lepton(TAU), s);
4497 else {
4498 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau196, &(*this), _1));
4499 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4500 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4501 }
4502 SMresult_cache = average;
4503 }
4504
4505 if (flagLEP2[WeakBox]) {
4506 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau196, &(*this), _1));
4507 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4508 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4509 }
4510 double sigma_box = average;
4511 SMresult_cache += sigma_box;
4512 }
4513 } else if (s == 200.*200.) {
4514 if (!flagLEP2[ISR])
4515 SMresult_cache = sigma_NoISR_l(QCD::lepton(TAU), s);
4516 else {
4517 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau200, &(*this), _1));
4518 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4519 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4520 }
4521 SMresult_cache = average;
4522 }
4523
4524 if (flagLEP2[WeakBox]) {
4525 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau200, &(*this), _1));
4526 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4527 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4528 }
4529 double sigma_box = average;
4530 SMresult_cache += sigma_box;
4531 }
4532 } else if (s == 202.*202.) {
4533 if (!flagLEP2[ISR])
4534 SMresult_cache = sigma_NoISR_l(QCD::lepton(TAU), s);
4535 else {
4536 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau202, &(*this), _1));
4537 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4538 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4539 }
4540 SMresult_cache = average;
4541 }
4542
4543 if (flagLEP2[WeakBox]) {
4544 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau202, &(*this), _1));
4545 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4546 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4547 }
4548 double sigma_box = average;
4549 SMresult_cache += sigma_box;
4550 }
4551 } else if (s == 205.*205.) {
4552 if (!flagLEP2[ISR])
4553 SMresult_cache = sigma_NoISR_l(QCD::lepton(TAU), s);
4554 else {
4555 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau205, &(*this), _1));
4556 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4557 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4558 }
4559 SMresult_cache = average;
4560 }
4561
4562 if (flagLEP2[WeakBox]) {
4563 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau205, &(*this), _1));
4564 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4565 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4566 }
4567 double sigma_box = average;
4568 SMresult_cache += sigma_box;
4569 }
4570 } else if (s == 207.*207.) {
4571 if (!flagLEP2[ISR])
4572 SMresult_cache = sigma_NoISR_l(QCD::lepton(TAU), s);
4573 else {
4574 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau207, &(*this), _1));
4575 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4576 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4577 }
4578 SMresult_cache = average;
4579 }
4580
4581 if (flagLEP2[WeakBox]) {
4582 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau207, &(*this), _1));
4583 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4584 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4585 }
4586 double sigma_box = average;
4587 SMresult_cache += sigma_box;
4588 }
4589 } else {
4590 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2sigmaTau!");
4591 }
4592
4593 double sigma_tau = SMresult_cache;
4594
4595 gsl_set_error_handler(old_handler);
4596
4597 return sigma_tau;
4598
4599 }
4600}
4601
4602
4603const double StandardModel::LEP2sigmaCharm(const double s) const
4604{
4605 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
4606 double relerr = 1.e-8;
4607 double abserr = 1.e-20;
4608
4609 if(s == 133.*133.){
4610
4611 if (!flagLEP2[ISR]){
4612 SMresult_cache = sigma_NoISR_q(QCD::quark(CHARM), s);
4613 } else {
4614 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm133, &(*this), _1));
4615 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4616 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4617 }
4618 SMresult_cache = average;
4619 }
4620
4621 if (flagLEP2[WeakBox]) {
4622 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm133, &(*this), _1));
4623 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4624 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4625 }
4626 double sigma_box = average;
4627 SMresult_cache += sigma_box;
4628 }
4629 } else if (s == 167.*167.){
4630 if (!flagLEP2[ISR])
4631 SMresult_cache = sigma_NoISR_q(QCD::quark(CHARM), s);
4632 else {
4633 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm167, &(*this), _1));
4634 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4635 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4636 }
4637 SMresult_cache = average;
4638 }
4639
4640 if (flagLEP2[WeakBox]) {
4641 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm167, &(*this), _1));
4642 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4643 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4644 }
4645 double sigma_box = average;
4646 SMresult_cache += sigma_box;
4647 }
4648 } else if (s == 183.*183.) {
4649 if (!flagLEP2[ISR])
4650 SMresult_cache = sigma_NoISR_q(QCD::quark(CHARM), s);
4651 else {
4652 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm183, &(*this), _1));
4653 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4654 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4655 }
4656 SMresult_cache = average;
4657 }
4658
4659 if (flagLEP2[WeakBox]) {
4660 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm183, &(*this), _1));
4661 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4662 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4663 }
4664 double sigma_box = average;
4665 SMresult_cache += sigma_box;
4666 }
4667 } else if (s == 189.*189.) {
4668 if (!flagLEP2[ISR])
4669 SMresult_cache = sigma_NoISR_q(QCD::quark(CHARM), s);
4670 else {
4671 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm189, &(*this), _1));
4672 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4673 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4674 }
4675 SMresult_cache = average;
4676 }
4677
4678 if (flagLEP2[WeakBox]) {
4679 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm189, &(*this), _1));
4680 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4681 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4682 }
4683 double sigma_box = average;
4684 SMresult_cache += sigma_box;
4685 }
4686 } else if (s == 192.*192.) {
4687 if (!flagLEP2[ISR])
4688 SMresult_cache = sigma_NoISR_q(QCD::quark(CHARM), s);
4689 else {
4690 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm192, &(*this), _1));
4691 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4692 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4693 }
4694 SMresult_cache = average;
4695 }
4696
4697 if (flagLEP2[WeakBox]) {
4698 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm192, &(*this), _1));
4699 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4700 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4701 }
4702 double sigma_box = average;
4703 SMresult_cache += sigma_box;
4704 }
4705 } else if (s == 196.*196.) {
4706 if (!flagLEP2[ISR])
4707 SMresult_cache = sigma_NoISR_q(QCD::quark(CHARM), s);
4708 else {
4709 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm196, &(*this), _1));
4710 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4711 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4712 }
4713 SMresult_cache = average;
4714 }
4715
4716 if (flagLEP2[WeakBox]) {
4717 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm196, &(*this), _1));
4718 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4719 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4720 }
4721 double sigma_box = average;
4722 SMresult_cache += sigma_box;
4723 }
4724 } else if (s == 200.*200.) {
4725 if (!flagLEP2[ISR])
4726 SMresult_cache = sigma_NoISR_q(QCD::quark(CHARM), s);
4727 else {
4728 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm200, &(*this), _1));
4729 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4730 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4731 }
4732 SMresult_cache = average;
4733 }
4734
4735 if (flagLEP2[WeakBox]) {
4736 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm200, &(*this), _1));
4737 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4738 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4739 }
4740 double sigma_box = average;
4741 SMresult_cache += sigma_box;
4742 }
4743 } else if (s == 202.*202.) {
4744 if (!flagLEP2[ISR])
4745 SMresult_cache = sigma_NoISR_q(QCD::quark(CHARM), s);
4746 else {
4747 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm202, &(*this), _1));
4748 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4749 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4750 }
4751 SMresult_cache = average;
4752 }
4753
4754 if (flagLEP2[WeakBox]) {
4755 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm202, &(*this), _1));
4756 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4757 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4758 }
4759 double sigma_box = average;
4760 SMresult_cache += sigma_box;
4761 }
4762 } else if (s == 205.*205.) {
4763 if (!flagLEP2[ISR])
4764 SMresult_cache = sigma_NoISR_q(QCD::quark(CHARM), s);
4765 else {
4766 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm205, &(*this), _1));
4767 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4768 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4769 }
4770 SMresult_cache = average;
4771 }
4772
4773 if (flagLEP2[WeakBox]) {
4774 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm205, &(*this), _1));
4775 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4776 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4777 }
4778 double sigma_box = average;
4779 SMresult_cache += sigma_box;
4780 }
4781 } else if (s == 207.*207.) {
4782 if (!flagLEP2[ISR])
4783 SMresult_cache = sigma_NoISR_q(QCD::quark(CHARM), s);
4784 else {
4785 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm207, &(*this), _1));
4786 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4787 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4788 }
4789 SMresult_cache = average;
4790 }
4791
4792 if (flagLEP2[WeakBox]) {
4793 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm207, &(*this), _1));
4794 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4795 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4796 }
4797 double sigma_box = average;
4798 SMresult_cache += sigma_box;
4799 }
4800 } else {
4801 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2sigmaCharm!");
4802 }
4803
4804
4805 double sigma_mu = SMresult_cache;
4806
4807 gsl_set_error_handler(old_handler);
4808
4809 return sigma_mu;
4810
4811}
4812
4813
4814const double StandardModel::LEP2sigmaBottom(const double s) const
4815{
4816 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
4817 double relerr = 1.e-8;
4818 double abserr = 1.e-20;
4819
4820 if(s == 133.*133.){
4821
4822 if (!flagLEP2[ISR]){
4823 SMresult_cache = sigma_NoISR_q(QCD::quark(BOTTOM), s);
4824 } else {
4825 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom133, &(*this), _1));
4826 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4827 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4828 }
4829 SMresult_cache = average;
4830 }
4831
4832 if (flagLEP2[WeakBox]) {
4833 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom133, &(*this), _1));
4834 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4835 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4836 }
4837 double sigma_box = average;
4838 SMresult_cache += sigma_box;
4839 }
4840 } else if (s == 167.*167.){
4841 if (!flagLEP2[ISR])
4842 SMresult_cache = sigma_NoISR_q(QCD::quark(BOTTOM), s);
4843 else {
4844 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom167, &(*this), _1));
4845 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4846 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4847 }
4848 SMresult_cache = average;
4849 }
4850
4851 if (flagLEP2[WeakBox]) {
4852 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom167, &(*this), _1));
4853 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4854 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4855 }
4856 double sigma_box = average;
4857 SMresult_cache += sigma_box;
4858 }
4859 } else if (s == 183.*183.) {
4860 if (!flagLEP2[ISR])
4861 SMresult_cache = sigma_NoISR_q(QCD::quark(BOTTOM), s);
4862 else {
4863 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom183, &(*this), _1));
4864 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4865 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4866 }
4867 SMresult_cache = average;
4868 }
4869
4870 if (flagLEP2[WeakBox]) {
4871 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom183, &(*this), _1));
4872 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4873 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4874 }
4875 double sigma_box = average;
4876 SMresult_cache += sigma_box;
4877 }
4878 } else if (s == 189.*189.) {
4879 if (!flagLEP2[ISR])
4880 SMresult_cache = sigma_NoISR_q(QCD::quark(BOTTOM), s);
4881 else {
4882 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom189, &(*this), _1));
4883 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4884 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4885 }
4886 SMresult_cache = average;
4887 }
4888
4889 if (flagLEP2[WeakBox]) {
4890 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom189, &(*this), _1));
4891 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4892 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4893 }
4894 double sigma_box = average;
4895 SMresult_cache += sigma_box;
4896 }
4897 } else if (s == 192.*192.) {
4898 if (!flagLEP2[ISR])
4899 SMresult_cache = sigma_NoISR_q(QCD::quark(BOTTOM), s);
4900 else {
4901 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom192, &(*this), _1));
4902 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4903 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4904 }
4905 SMresult_cache = average;
4906 }
4907
4908 if (flagLEP2[WeakBox]) {
4909 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom192, &(*this), _1));
4910 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4911 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4912 }
4913 double sigma_box = average;
4914 SMresult_cache += sigma_box;
4915 }
4916 } else if (s == 196.*196.) {
4917 if (!flagLEP2[ISR])
4918 SMresult_cache = sigma_NoISR_q(QCD::quark(BOTTOM), s);
4919 else {
4920 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom196, &(*this), _1));
4921 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4922 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4923 }
4924 SMresult_cache = average;
4925 }
4926
4927 if (flagLEP2[WeakBox]) {
4928 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom196, &(*this), _1));
4929 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4930 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4931 }
4932 double sigma_box = average;
4933 SMresult_cache += sigma_box;
4934 }
4935 } else if (s == 200.*200.) {
4936 if (!flagLEP2[ISR])
4937 SMresult_cache = sigma_NoISR_q(QCD::quark(BOTTOM), s);
4938 else {
4939 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom200, &(*this), _1));
4940 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4941 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4942 }
4943 SMresult_cache = average;
4944 }
4945
4946 if (flagLEP2[WeakBox]) {
4947 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom200, &(*this), _1));
4948 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4949 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4950 }
4951 double sigma_box = average;
4952 SMresult_cache += sigma_box;
4953 }
4954 } else if (s == 202.*202.) {
4955 if (!flagLEP2[ISR])
4956 SMresult_cache = sigma_NoISR_q(QCD::quark(BOTTOM), s);
4957 else {
4958 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom202, &(*this), _1));
4959 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4960 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4961 }
4962 SMresult_cache = average;
4963 }
4964
4965 if (flagLEP2[WeakBox]) {
4966 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom202, &(*this), _1));
4967 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4968 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4969 }
4970 double sigma_box = average;
4971 SMresult_cache += sigma_box;
4972 }
4973 } else if (s == 205.*205.) {
4974 if (!flagLEP2[ISR])
4975 SMresult_cache = sigma_NoISR_q(QCD::quark(BOTTOM), s);
4976 else {
4977 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom205, &(*this), _1));
4978 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4979 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4980 }
4981 SMresult_cache = average;
4982 }
4983
4984 if (flagLEP2[WeakBox]) {
4985 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom205, &(*this), _1));
4986 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4987 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4988 }
4989 double sigma_box = average;
4990 SMresult_cache += sigma_box;
4991 }
4992 } else if (s == 207.*207.) {
4993 if (!flagLEP2[ISR])
4994 SMresult_cache = sigma_NoISR_q(QCD::quark(BOTTOM), s);
4995 else {
4996 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom207, &(*this), _1));
4997 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4998 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4999 }
5000 SMresult_cache = average;
5001 }
5002
5003 if (flagLEP2[WeakBox]) {
5004 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom207, &(*this), _1));
5005 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5006 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5007 }
5008 double sigma_box = average;
5009 SMresult_cache += sigma_box;
5010 }
5011 } else {
5012 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2sigmaBottom!");
5013 }
5014
5015
5016 double sigma_mu = SMresult_cache;
5017
5018 gsl_set_error_handler(old_handler);
5019
5020 return sigma_mu;
5021
5022}
5023
5024
5025const double StandardModel::LEP2sigmaHadron(const double s) const
5026{
5027 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
5028 double relerr = 1.e-8;
5029 double abserr = 1.e-20;
5030
5031 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
5032 if (!IsFlagNoApproximateGammaZ()){
5033
5034 /* SM contribution with the approximate formula */
5035 return (myApproximateFormulae->LEP2sigmaHadronApprox(s));
5036
5037 } else {
5038
5039 if(s == 130.*130.){
5040
5041 if (!flagLEP2[ISR]){
5042 SMresult_cache = sigma_NoISR_q(QCD::quark(UP), s);
5043 SMresult_cache += sigma_NoISR_q(QCD::quark(DOWN), s);
5044 SMresult_cache += sigma_NoISR_q(QCD::quark(CHARM), s);
5045 SMresult_cache += sigma_NoISR_q(QCD::quark(STRANGE), s);
5046 SMresult_cache += sigma_NoISR_q(QCD::quark(BOTTOM), s);
5047 } else {
5048
5049 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up130, &(*this), _1));
5050 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5051 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5052 }
5053 SMresult_cache = average;
5054
5055 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down130, &(*this), _1));
5056 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5057 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5058 }
5059 SMresult_cache += average;
5060
5061 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm130, &(*this), _1));
5062 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5063 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5064 }
5065 SMresult_cache += average;
5066
5067 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange130, &(*this), _1));
5068 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5069 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5070 }
5071 SMresult_cache += average;
5072
5073 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom130, &(*this), _1));
5074 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5075 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5076 }
5077 SMresult_cache += average;
5078
5079 }
5080
5081 if (flagLEP2[WeakBox]) {
5082 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up130, &(*this), _1));
5083 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5084 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5085 }
5086 double sigma_box = average;
5087
5088 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down130, &(*this), _1));
5089 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5090 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5091 }
5092 sigma_box += average;
5093
5094 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm130, &(*this), _1));
5095 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5096 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5097 }
5098 sigma_box += average;
5099
5100 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange130, &(*this), _1));
5101 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5102 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5103 }
5104 sigma_box += average;
5105
5106 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom130, &(*this), _1));
5107 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5108 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5109 }
5110 sigma_box += average;
5111 SMresult_cache += sigma_box;
5112 }
5113 } else if (s == 133.*133.) {
5114 if (!flagLEP2[ISR]){
5115 SMresult_cache = sigma_NoISR_q(QCD::quark(UP), s);
5116 SMresult_cache += sigma_NoISR_q(QCD::quark(DOWN), s);
5117 SMresult_cache += sigma_NoISR_q(QCD::quark(CHARM), s);
5118 SMresult_cache += sigma_NoISR_q(QCD::quark(STRANGE), s);
5119 SMresult_cache += sigma_NoISR_q(QCD::quark(BOTTOM), s);
5120 } else {
5121
5122 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up133, &(*this), _1));
5123 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5124 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5125 }
5126 SMresult_cache = average;
5127
5128 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down133, &(*this), _1));
5129 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5130 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5131 }
5132 SMresult_cache += average;
5133
5134 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm133, &(*this), _1));
5135 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5136 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5137 }
5138 SMresult_cache += average;
5139
5140 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange133, &(*this), _1));
5141 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5142 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5143 }
5144 SMresult_cache += average;
5145
5146 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom133, &(*this), _1));
5147 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5148 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5149 }
5150 SMresult_cache += average;
5151 }
5152
5153 if (flagLEP2[WeakBox]) {
5154 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up133, &(*this), _1));
5155 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5156 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5157 }
5158 double sigma_box = average;
5159
5160 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down133, &(*this), _1));
5161 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5162 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5163 }
5164 sigma_box += average;
5165
5166 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm133, &(*this), _1));
5167 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5168 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5169 }
5170 sigma_box += average;
5171
5172 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange133, &(*this), _1));
5173 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5174 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5175 }
5176 sigma_box += average;
5177
5178 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom133, &(*this), _1));
5179 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5180 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5181 }
5182 sigma_box += average;
5183 SMresult_cache += sigma_box;
5184 }
5185 } else if (s == 136.*136.) {
5186 if (!flagLEP2[ISR]){
5187 SMresult_cache = sigma_NoISR_q(QCD::quark(UP), s);
5188 SMresult_cache += sigma_NoISR_q(QCD::quark(DOWN), s);
5189 SMresult_cache += sigma_NoISR_q(QCD::quark(CHARM), s);
5190 SMresult_cache += sigma_NoISR_q(QCD::quark(STRANGE), s);
5191 SMresult_cache += sigma_NoISR_q(QCD::quark(BOTTOM), s);
5192 } else {
5193
5194 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up136, &(*this), _1));
5195 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5196 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5197 }
5198 SMresult_cache = average;
5199
5200 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down136, &(*this), _1));
5201 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5202 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5203 }
5204 SMresult_cache += average;
5205
5206 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm136, &(*this), _1));
5207 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5208 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5209 }
5210 SMresult_cache += average;
5211
5212 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange136, &(*this), _1));
5213 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5214 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5215 }
5216 SMresult_cache += average;
5217
5218 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom136, &(*this), _1));
5219 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5220 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5221 }
5222 SMresult_cache += average;
5223 }
5224
5225 if (flagLEP2[WeakBox]) {
5226 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up136, &(*this), _1));
5227 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5228 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5229 }
5230 double sigma_box = average;
5231
5232 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down136, &(*this), _1));
5233 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5234 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5235 }
5236 sigma_box += average;
5237
5238 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm136, &(*this), _1));
5239 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5240 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5241 }
5242 sigma_box += average;
5243
5244 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange136, &(*this), _1));
5245 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5246 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5247 }
5248 sigma_box += average;
5249
5250 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom136, &(*this), _1));
5251 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5252 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5253 }
5254 sigma_box += average;
5255 SMresult_cache += sigma_box;
5256 }
5257 } else if (s == 161.*161.){
5258 if (!flagLEP2[ISR]){
5259 SMresult_cache = sigma_NoISR_q(QCD::quark(UP), s);
5260 SMresult_cache += sigma_NoISR_q(QCD::quark(DOWN), s);
5261 SMresult_cache += sigma_NoISR_q(QCD::quark(CHARM), s);
5262 SMresult_cache += sigma_NoISR_q(QCD::quark(STRANGE), s);
5263 SMresult_cache += sigma_NoISR_q(QCD::quark(BOTTOM), s);
5264 } else {
5265
5266 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up161, &(*this), _1));
5267 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5268 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5269 }
5270 SMresult_cache = average;
5271
5272 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down161, &(*this), _1));
5273 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5274 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5275 }
5276 SMresult_cache += average;
5277
5278 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm161, &(*this), _1));
5279 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-12, 1.e-6, 100, w_GSL1, &average, &error) != 0){
5280 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5281 }
5282 SMresult_cache += average;
5283
5284 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange161, &(*this), _1));
5285 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 200, w_GSL1, &average, &error) != 0){
5286 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5287 }
5288 SMresult_cache += average;
5289
5290 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom161, &(*this), _1));
5291 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5292 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5293 }
5294 SMresult_cache += average;
5295 }
5296
5297 if (flagLEP2[WeakBox]) {
5298 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up161, &(*this), _1));
5299 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5300 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5301 }
5302 double sigma_box = average;
5303
5304 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down161, &(*this), _1));
5305 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5306 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5307 }
5308 sigma_box += average;
5309
5310 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm161, &(*this), _1));
5311 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5312 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5313 }
5314 sigma_box += average;
5315
5316 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange161, &(*this), _1));
5317 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5318 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5319 }
5320 sigma_box += average;
5321
5322 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom161, &(*this), _1));
5323 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5324 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5325 }
5326 sigma_box += average;
5327 SMresult_cache += sigma_box;
5328 }
5329 } else if (s == 167.*167.) {
5330 if (!flagLEP2[ISR]){
5331 SMresult_cache = sigma_NoISR_q(QCD::quark(UP), s);
5332 SMresult_cache += sigma_NoISR_q(QCD::quark(DOWN), s);
5333 SMresult_cache += sigma_NoISR_q(QCD::quark(CHARM), s);
5334 SMresult_cache += sigma_NoISR_q(QCD::quark(STRANGE), s);
5335 SMresult_cache += sigma_NoISR_q(QCD::quark(BOTTOM), s);
5336 } else {
5337
5338 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up167, &(*this), _1));
5339 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5340 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5341 }
5342
5343 SMresult_cache = average;
5344
5345 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down167, &(*this), _1));
5346 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-15, 1.e-9, 200, w_GSL1, &average, &error) != 0){
5347 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5348 }
5349 SMresult_cache += average;
5350
5351 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm167, &(*this), _1));
5352 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-15, 1.e-9, 200, w_GSL1, &average, &error) != 0){
5353 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5354 }
5355 SMresult_cache += average;
5356
5357 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange167, &(*this), _1));
5358 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-15, 1.e-9, 200, w_GSL1, &average, &error) != 0){
5359 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5360 }
5361 SMresult_cache += average;
5362
5363 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom167, &(*this), _1));
5364 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-15, 1.e-9, 200, w_GSL1, &average, &error) != 0){
5365 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5366 }
5367 SMresult_cache += average;
5368 }
5369
5370 if (flagLEP2[WeakBox]) {
5371 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up167, &(*this), _1));
5372 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5373 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5374 }
5375 double sigma_box = average;
5376
5377 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down167, &(*this), _1));
5378 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5379 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5380 }
5381 sigma_box += average;
5382
5383 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm167, &(*this), _1));
5384 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5385 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5386 }
5387 sigma_box += average;
5388
5389 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange167, &(*this), _1));
5390 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5391 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5392 }
5393 sigma_box += average;
5394
5395 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom167, &(*this), _1));
5396 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5397 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5398 }
5399 sigma_box += average;
5400 SMresult_cache += sigma_box;
5401 }
5402 } else if (s == 172.*172.) {
5403 if (!flagLEP2[ISR]){
5404 SMresult_cache = sigma_NoISR_q(QCD::quark(UP), s);
5405 SMresult_cache += sigma_NoISR_q(QCD::quark(DOWN), s);
5406 SMresult_cache += sigma_NoISR_q(QCD::quark(CHARM), s);
5407 SMresult_cache += sigma_NoISR_q(QCD::quark(STRANGE), s);
5408 SMresult_cache += sigma_NoISR_q(QCD::quark(BOTTOM), s);
5409 } else {
5410
5411 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up172, &(*this), _1));
5412 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5413 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5414 }
5415 SMresult_cache = average;
5416
5417 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down172, &(*this), _1));
5418 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5419 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5420 }
5421 SMresult_cache += average;
5422
5423 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm172, &(*this), _1));
5424 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5425 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5426 }
5427 SMresult_cache += average;
5428
5429 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange172, &(*this), _1));
5430 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5431 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5432 }
5433 SMresult_cache += average;
5434
5435 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom172, &(*this), _1));
5436 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5437 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5438 }
5439 SMresult_cache += average;
5440 }
5441
5442 if (flagLEP2[WeakBox]) {
5443 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up172, &(*this), _1));
5444 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5445 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5446 }
5447 double sigma_box = average;
5448
5449 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down172, &(*this), _1));
5450 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5451 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5452 }
5453 sigma_box += average;
5454
5455 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm172, &(*this), _1));
5456 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5457 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5458 }
5459 sigma_box += average;
5460
5461 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange172, &(*this), _1));
5462 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5463 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5464 }
5465 sigma_box += average;
5466
5467 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom172, &(*this), _1));
5468 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5469 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5470 }
5471 sigma_box += average;
5472 SMresult_cache += sigma_box;
5473 }
5474 } else if (s == 183.*183.) {
5475 if (!flagLEP2[ISR]){
5476 SMresult_cache = sigma_NoISR_q(QCD::quark(UP), s);
5477 SMresult_cache += sigma_NoISR_q(QCD::quark(DOWN), s);
5478 SMresult_cache += sigma_NoISR_q(QCD::quark(CHARM), s);
5479 SMresult_cache += sigma_NoISR_q(QCD::quark(STRANGE), s);
5480 SMresult_cache += sigma_NoISR_q(QCD::quark(BOTTOM), s);
5481 } else {
5482
5483 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up183, &(*this), _1));
5484 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5485 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5486 }
5487 SMresult_cache = average;
5488
5489 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down183, &(*this), _1));
5490 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5491 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5492 }
5493 SMresult_cache += average;
5494
5495 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm183, &(*this), _1));
5496 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5497 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5498 }
5499 SMresult_cache += average;
5500
5501 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange183, &(*this), _1));
5502 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5503 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5504 }
5505 SMresult_cache += average;
5506
5507 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom183, &(*this), _1));
5508 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5509 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5510 }
5511 SMresult_cache += average;
5512 }
5513
5514 if (flagLEP2[WeakBox]) {
5515 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up183, &(*this), _1));
5516 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5517 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5518 }
5519 double sigma_box = average;
5520
5521 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down183, &(*this), _1));
5522 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5523 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5524 }
5525 sigma_box += average;
5526
5527 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm183, &(*this), _1));
5528 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5529 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5530 }
5531 sigma_box += average;
5532
5533 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange183, &(*this), _1));
5534 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5535 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5536 }
5537 sigma_box += average;
5538
5539 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom183, &(*this), _1));
5540 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5541 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5542 }
5543 sigma_box += average;
5544 SMresult_cache += sigma_box;
5545 }
5546 } else if (s == 189.*189.) {
5547 if (!flagLEP2[ISR]){
5548 SMresult_cache = sigma_NoISR_q(QCD::quark(UP), s);
5549 SMresult_cache += sigma_NoISR_q(QCD::quark(DOWN), s);
5550 SMresult_cache += sigma_NoISR_q(QCD::quark(CHARM), s);
5551 SMresult_cache += sigma_NoISR_q(QCD::quark(STRANGE), s);
5552 SMresult_cache += sigma_NoISR_q(QCD::quark(BOTTOM), s);
5553 } else {
5554
5555 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up189, &(*this), _1));
5556 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5557 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5558 }
5559 SMresult_cache = average;
5560
5561 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down189, &(*this), _1));
5562 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5563 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5564 }
5565 SMresult_cache += average;
5566
5567 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm189, &(*this), _1));
5568 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5569 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5570 }
5571 SMresult_cache += average;
5572
5573 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange189, &(*this), _1));
5574 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5575 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5576 }
5577 SMresult_cache += average;
5578
5579 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom189, &(*this), _1));
5580 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5581 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5582 }
5583 SMresult_cache += average;
5584 }
5585
5586 if (flagLEP2[WeakBox]) {
5587 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up189, &(*this), _1));
5588 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5589 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5590 }
5591 double sigma_box = average;
5592
5593 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down189, &(*this), _1));
5594 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5595 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5596 }
5597 sigma_box += average;
5598
5599 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm189, &(*this), _1));
5600 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5601 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5602 }
5603 sigma_box += average;
5604
5605 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange189, &(*this), _1));
5606 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5607 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5608 }
5609 sigma_box += average;
5610
5611 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom189, &(*this), _1));
5612 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5613 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5614 }
5615 sigma_box += average;
5616 SMresult_cache += sigma_box;
5617 }
5618 } else if (s == 192.*192.) {
5619 if (!flagLEP2[ISR]){
5620 SMresult_cache = sigma_NoISR_q(QCD::quark(UP), s);
5621 SMresult_cache += sigma_NoISR_q(QCD::quark(DOWN), s);
5622 SMresult_cache += sigma_NoISR_q(QCD::quark(CHARM), s);
5623 SMresult_cache += sigma_NoISR_q(QCD::quark(STRANGE), s);
5624 SMresult_cache += sigma_NoISR_q(QCD::quark(BOTTOM), s);
5625 } else {
5626
5627 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up192, &(*this), _1));
5628 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5629 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5630 }
5631 SMresult_cache = average;
5632
5633 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down192, &(*this), _1));
5634 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5635 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5636 }
5637 SMresult_cache += average;
5638
5639 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm192, &(*this), _1));
5640
5641 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5642 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5643 }
5644 SMresult_cache += average;
5645
5646 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange192, &(*this), _1));
5647
5648 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5649 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5650 }
5651 SMresult_cache += average;
5652
5653 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom192, &(*this), _1));
5654 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5655 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5656 }
5657 SMresult_cache += average;
5658 }
5659
5660 if (flagLEP2[WeakBox]) {
5661 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up192, &(*this), _1));
5662 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5663 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5664 }
5665 double sigma_box = average;
5666
5667 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down192, &(*this), _1));
5668 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5669 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5670 }
5671 sigma_box += average;
5672
5673 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm192, &(*this), _1));
5674 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5675 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5676 }
5677 sigma_box += average;
5678
5679 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange192, &(*this), _1));
5680 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5681 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5682 }
5683 sigma_box += average;
5684
5685 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom192, &(*this), _1));
5686 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5687 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5688 }
5689 sigma_box += average;
5690 SMresult_cache += sigma_box;
5691 }
5692 } else if (s == 196.*196.) {
5693 if (!flagLEP2[ISR]){
5694 SMresult_cache = sigma_NoISR_q(QCD::quark(UP), s);
5695 SMresult_cache += sigma_NoISR_q(QCD::quark(DOWN), s);
5696 SMresult_cache += sigma_NoISR_q(QCD::quark(CHARM), s);
5697 SMresult_cache += sigma_NoISR_q(QCD::quark(STRANGE), s);
5698 SMresult_cache += sigma_NoISR_q(QCD::quark(BOTTOM), s);
5699 } else {
5700
5701 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up196, &(*this), _1));
5702 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5703 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5704 }
5705 SMresult_cache = average;
5706
5707 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down196, &(*this), _1));
5708 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5709 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5710 }
5711 SMresult_cache += average;
5712
5713 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm196, &(*this), _1));
5714 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5715 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5716 }
5717 SMresult_cache += average;
5718
5719 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange196, &(*this), _1));
5720
5721 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5722 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5723 }
5724 SMresult_cache += average;
5725
5726 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom196, &(*this), _1));
5727 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5728 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5729 }
5730 SMresult_cache += average;
5731 }
5732
5733 if (flagLEP2[WeakBox]) {
5734 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up196, &(*this), _1));
5735 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5736 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5737 }
5738 double sigma_box = average;
5739
5740 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down196, &(*this), _1));
5741 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5742 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5743 }
5744 sigma_box += average;
5745
5746 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm196, &(*this), _1));
5747 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5748 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5749 }
5750 sigma_box += average;
5751
5752 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange196, &(*this), _1));
5753 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5754 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5755 }
5756 sigma_box += average;
5757
5758 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom196, &(*this), _1));
5759 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5760 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5761 }
5762 sigma_box += average;
5763 SMresult_cache += sigma_box;
5764 }
5765 } else if (s == 200.*200.) {
5766 if (!flagLEP2[ISR]){
5767 SMresult_cache = sigma_NoISR_q(QCD::quark(UP), s);
5768 SMresult_cache += sigma_NoISR_q(QCD::quark(DOWN), s);
5769 SMresult_cache += sigma_NoISR_q(QCD::quark(CHARM), s);
5770 SMresult_cache += sigma_NoISR_q(QCD::quark(STRANGE), s);
5771 SMresult_cache += sigma_NoISR_q(QCD::quark(BOTTOM), s);
5772 } else {
5773
5774 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up200, &(*this), _1));
5775 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5776 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5777 }
5778 SMresult_cache = average;
5779
5780 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down200, &(*this), _1));
5781 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5782 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5783 }
5784 SMresult_cache += average;
5785
5786 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm200, &(*this), _1));
5787 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5788 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5789 }
5790 SMresult_cache += average;
5791
5792 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange200, &(*this), _1));
5793 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5794 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5795 }
5796 SMresult_cache += average;
5797
5798 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom200, &(*this), _1));
5799 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5800 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5801 }
5802 SMresult_cache += average;
5803 }
5804
5805 if (flagLEP2[WeakBox]) {
5806 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up200, &(*this), _1));
5807 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5808 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5809 }
5810 double sigma_box = average;
5811
5812 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down200, &(*this), _1));
5813 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5814 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5815 }
5816 sigma_box += average;
5817
5818 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm200, &(*this), _1));
5819 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5820 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5821 }
5822 sigma_box += average;
5823
5824 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange200, &(*this), _1));
5825 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5826 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5827 }
5828 sigma_box += average;
5829
5830 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom200, &(*this), _1));
5831 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5832 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5833 }
5834 sigma_box += average;
5835 SMresult_cache += sigma_box;
5836 }
5837 } else if (s == 202.*202.) {
5838 if (!flagLEP2[ISR]){
5839 SMresult_cache = sigma_NoISR_q(QCD::quark(UP), s);
5840 SMresult_cache += sigma_NoISR_q(QCD::quark(DOWN), s);
5841 SMresult_cache += sigma_NoISR_q(QCD::quark(CHARM), s);
5842 SMresult_cache += sigma_NoISR_q(QCD::quark(STRANGE), s);
5843 SMresult_cache += sigma_NoISR_q(QCD::quark(BOTTOM), s);
5844 } else {
5845
5846 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up202, &(*this), _1));
5847
5848
5849
5850 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5851 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5852 }
5853 SMresult_cache = average;
5854
5855 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down202, &(*this), _1));
5856
5857
5858
5859 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5860 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5861 }
5862 SMresult_cache += average;
5863
5864 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm202, &(*this), _1));
5865
5866
5867
5868 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5869 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5870 }
5871 SMresult_cache += average;
5872
5873 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange202, &(*this), _1));
5874
5875
5876
5877 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5878 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5879 }
5880 SMresult_cache += average;
5881
5882 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom202, &(*this), _1));
5883
5884
5885
5886 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5887 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5888 }
5889 SMresult_cache += average;
5890 }
5891
5892 if (flagLEP2[WeakBox]) {
5893 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up202, &(*this), _1));
5894
5895
5896
5897 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5898 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5899 }
5900 double sigma_box = average;
5901
5902 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down202, &(*this), _1));
5903
5904
5905
5906 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5907 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5908 }
5909 sigma_box += average;
5910
5911 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm202, &(*this), _1));
5912
5913
5914
5915 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5916 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5917 }
5918 sigma_box += average;
5919
5920 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange202, &(*this), _1));
5921
5922
5923
5924 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5925 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5926 }
5927 sigma_box += average;
5928
5929 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom202, &(*this), _1));
5930
5931
5932
5933 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5934 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5935 }
5936 sigma_box += average;
5937 SMresult_cache += sigma_box;
5938 }
5939 } else if (s == 205.*205.) {
5940 if (!flagLEP2[ISR]){
5941 SMresult_cache = sigma_NoISR_q(QCD::quark(UP), s);
5942 SMresult_cache += sigma_NoISR_q(QCD::quark(DOWN), s);
5943 SMresult_cache += sigma_NoISR_q(QCD::quark(CHARM), s);
5944 SMresult_cache += sigma_NoISR_q(QCD::quark(STRANGE), s);
5945 SMresult_cache += sigma_NoISR_q(QCD::quark(BOTTOM), s);
5946 } else {
5947
5948 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up205, &(*this), _1));
5949
5950
5951
5952 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5953 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5954 }
5955 SMresult_cache = average;
5956
5957 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down205, &(*this), _1));
5958
5959
5960
5961 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5962 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5963 }
5964 SMresult_cache += average;
5965
5966 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm205, &(*this), _1));
5967
5968
5969
5970 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5971 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5972 }
5973 SMresult_cache += average;
5974
5975 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange205, &(*this), _1));
5976
5977
5978
5979 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5980 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5981 }
5982 SMresult_cache += average;
5983
5984 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom205, &(*this), _1));
5985
5986
5987
5988 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5989 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5990 }
5991 SMresult_cache += average;
5992 }
5993
5994 if (flagLEP2[WeakBox]) {
5995 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up205, &(*this), _1));
5996
5997
5998
5999 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6000 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6001 }
6002 double sigma_box = average;
6003
6004 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down205, &(*this), _1));
6005
6006
6007
6008 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6009 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6010 }
6011 sigma_box += average;
6012
6013 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm205, &(*this), _1));
6014
6015
6016
6017 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6018 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6019 }
6020 sigma_box += average;
6021
6022 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange205, &(*this), _1));
6023
6024
6025
6026 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6027 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6028 }
6029 sigma_box += average;
6030
6031 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom205, &(*this), _1));
6032
6033
6034
6035 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6036 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6037 }
6038 sigma_box += average;
6039 SMresult_cache += sigma_box;
6040 }
6041 } else if (s == 207.*207.) {
6042 if (!flagLEP2[ISR]){
6043 SMresult_cache = sigma_NoISR_q(QCD::quark(UP), s);
6044 SMresult_cache += sigma_NoISR_q(QCD::quark(DOWN), s);
6045 SMresult_cache += sigma_NoISR_q(QCD::quark(CHARM), s);
6046 SMresult_cache += sigma_NoISR_q(QCD::quark(STRANGE), s);
6047 SMresult_cache += sigma_NoISR_q(QCD::quark(BOTTOM), s);
6048 } else {
6049
6050 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up207, &(*this), _1));
6051
6052
6053
6054 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6055 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6056 }
6057 SMresult_cache = average;
6058
6059 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down207, &(*this), _1));
6060
6061
6062
6063 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6064 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6065 }
6066 SMresult_cache += average;
6067
6068 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm207, &(*this), _1));
6069
6070
6071
6072 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6073 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6074 }
6075 SMresult_cache += average;
6076
6077 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange207, &(*this), _1));
6078
6079
6080
6081 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6082 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6083 }
6084 SMresult_cache += average;
6085
6086 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom207, &(*this), _1));
6087
6088
6089
6090 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6091 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6092 }
6093 SMresult_cache += average;
6094 }
6095
6096 if (flagLEP2[WeakBox]) {
6097 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up207, &(*this), _1));
6098
6099
6100
6101 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6102 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6103 }
6104 double sigma_box = average;
6105
6106 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down207, &(*this), _1));
6107
6108
6109
6110 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6111 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6112 }
6113 sigma_box += average;
6114
6115 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm207, &(*this), _1));
6116
6117
6118
6119 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6120 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6121 }
6122 sigma_box += average;
6123
6124 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange207, &(*this), _1));
6125
6126
6127
6128 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6129 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6130 }
6131 sigma_box += average;
6132
6133 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom207, &(*this), _1));
6134
6135
6136
6137 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6138 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6139 }
6140 sigma_box += average;
6141 SMresult_cache += sigma_box;
6142 }
6143 } else {
6144 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2sigmaHadron!");
6145 }
6146
6147 double sigma_had = SMresult_cache;
6148
6149 gsl_set_error_handler(old_handler);
6150
6151 return sigma_had;
6152
6153 }
6154}
6155
6156
6157const double StandardModel::LEP2AFBbottom(const double s) const
6158{
6159
6160 bSigmaForAFB = true;
6161 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
6162 double relerr = 1.e-7;
6163 double abserr = 1.e-17;
6164
6165 if(s == 133.*133.){
6166 double AFB_noBox, sigma = 0.0;
6167 if (!flagLEP2[ISR])
6168 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6169 else {
6170 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom133, &(*this), _1));
6171 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6172 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6173 }
6174 double numerator = average; // interval
6175
6176
6177 sigma = LEP2sigmaBottom(s);
6178
6179 AFB_noBox = numerator/sigma;
6180 }
6181 SMresult_cache = AFB_noBox;
6182
6183 if (flagLEP2[WeakBox]) {
6184 // numerator
6185 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom133, &(*this), _1));
6186 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6187 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6188 }
6189 double sigma_box_F = average; // interval
6190 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom133, &(*this), _1));
6191 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6192 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6193 }
6194 double sigma_box_B = average; // interval
6195
6196 // denominator
6197 if (!flagLEP2[ISR]) {
6198
6199 sigma = LEP2sigmaBottom(s);
6200 }
6201
6202 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6203 }
6204 } else if (s == 167.*167.){
6205 double AFB_noBox, sigma = 0.0;
6206 if (!flagLEP2[ISR])
6207 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6208 else {
6209 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom167, &(*this), _1));
6210 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6211 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6212 }
6213 double numerator = average; // interval
6214
6215
6216 sigma = LEP2sigmaBottom(s);
6217
6218 AFB_noBox = numerator/sigma;
6219 }
6220 SMresult_cache = AFB_noBox;
6221
6222 if (flagLEP2[WeakBox]) {
6223 // numerator
6224 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom167, &(*this), _1));
6225 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6226 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6227 }
6228 double sigma_box_F = average; // interval
6229 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom167, &(*this), _1));
6230 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6231 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6232 }
6233 double sigma_box_B = average; // interval
6234
6235 // denominator
6236 if (!flagLEP2[ISR]) {
6237
6238 sigma = LEP2sigmaBottom(s);
6239 }
6240
6241 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6242 }
6243 } else if (s == 183.*183.) {
6244 double AFB_noBox, sigma = 0.0;
6245 if (!flagLEP2[ISR])
6246 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6247 else {
6248 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom183, &(*this), _1));
6249 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6250 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6251 }
6252 double numerator = average; // interval
6253
6254
6255 sigma = LEP2sigmaBottom(s);
6256
6257 AFB_noBox = numerator/sigma;
6258 }
6259 SMresult_cache = AFB_noBox;
6260
6261 if (flagLEP2[WeakBox]) {
6262 // numerator
6263 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom183, &(*this), _1));
6264 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6265 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6266 }
6267 double sigma_box_F = average; // interval
6268 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom183, &(*this), _1));
6269 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6270 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6271 }
6272 double sigma_box_B = average; // interval
6273
6274 // denominator
6275 if (!flagLEP2[ISR]) {
6276
6277 sigma = LEP2sigmaBottom(s);
6278 }
6279
6280 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6281 }
6282 } else if (s == 189.*189.) {
6283 double AFB_noBox, sigma = 0.0;
6284 if (!flagLEP2[ISR])
6285 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6286 else {
6287 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom189, &(*this), _1));
6288 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6289 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6290 }
6291 double numerator = average; // interval
6292
6293
6294 sigma = LEP2sigmaBottom(s);
6295
6296 AFB_noBox = numerator/sigma;
6297 }
6298 SMresult_cache = AFB_noBox;
6299
6300 if (flagLEP2[WeakBox]) {
6301 // numerator
6302 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom189, &(*this), _1));
6303 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6304 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6305 }
6306 double sigma_box_F = average; // interval
6307 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom189, &(*this), _1));
6308 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6309 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6310 }
6311 double sigma_box_B = average; // interval
6312
6313 // denominator
6314 if (!flagLEP2[ISR]) {
6315
6316 sigma = LEP2sigmaBottom(s);
6317 }
6318
6319 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6320 }
6321 } else if (s == 192.*192.) {
6322 double AFB_noBox, sigma = 0.0;
6323 if (!flagLEP2[ISR])
6324 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6325 else {
6326 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom192, &(*this), _1));
6327 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6328 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6329 }
6330 double numerator = average; // interval
6331
6332
6333 sigma = LEP2sigmaBottom(s);
6334
6335 AFB_noBox = numerator/sigma;
6336 }
6337 SMresult_cache = AFB_noBox;
6338
6339 if (flagLEP2[WeakBox]) {
6340 // numerator
6341 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom192, &(*this), _1));
6342 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6343 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6344 }
6345 double sigma_box_F = average; // interval
6346 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom192, &(*this), _1));
6347 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6348 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6349 }
6350 double sigma_box_B = average; // interval
6351
6352 // denominator
6353 if (!flagLEP2[ISR]) {
6354
6355 sigma = LEP2sigmaBottom(s);
6356 }
6357
6358 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6359 }
6360 } else if (s == 196.*196.) {
6361 double AFB_noBox, sigma = 0.0;
6362 if (!flagLEP2[ISR])
6363 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6364 else {
6365 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom196, &(*this), _1));
6366 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6367 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6368 }
6369 double numerator = average; // interval
6370
6371
6372 sigma = LEP2sigmaBottom(s);
6373
6374 AFB_noBox = numerator/sigma;
6375 }
6376 SMresult_cache = AFB_noBox;
6377
6378 if (flagLEP2[WeakBox]) {
6379 // numerator
6380 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom196, &(*this), _1));
6381 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6382 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6383 }
6384 double sigma_box_F = average; // interval
6385 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom196, &(*this), _1));
6386 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6387 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6388 }
6389 double sigma_box_B = average; // interval
6390
6391 // denominator
6392 if (!flagLEP2[ISR]) {
6393
6394 sigma = LEP2sigmaBottom(s);
6395 }
6396
6397 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6398 }
6399 } else if (s == 200.*200.) {
6400 double AFB_noBox, sigma = 0.0;
6401 if (!flagLEP2[ISR])
6402 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6403 else {
6404 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom200, &(*this), _1));
6405 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6406 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6407 }
6408 double numerator = average; // interval
6409
6410
6411 sigma = LEP2sigmaBottom(s);
6412
6413 AFB_noBox = numerator/sigma;
6414 }
6415 SMresult_cache = AFB_noBox;
6416
6417 if (flagLEP2[WeakBox]) {
6418 // numerator
6419 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom200, &(*this), _1));
6420 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6421 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6422 }
6423 double sigma_box_F = average; // interval
6424 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom200, &(*this), _1));
6425 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6426 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6427 }
6428 double sigma_box_B = average; // interval
6429
6430 // denominator
6431 if (!flagLEP2[ISR]) {
6432
6433 sigma = LEP2sigmaBottom(s);
6434 }
6435
6436 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6437 }
6438 } else if (s == 202.*202.) {
6439 double AFB_noBox, sigma = 0.0;
6440 if (!flagLEP2[ISR])
6441 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6442 else {
6443 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom202, &(*this), _1));
6444 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6445 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6446 }
6447 double numerator = average; // interval
6448
6449
6450 sigma = LEP2sigmaBottom(s);
6451
6452 AFB_noBox = numerator/sigma;
6453 }
6454 SMresult_cache = AFB_noBox;
6455
6456 if (flagLEP2[WeakBox]) {
6457 // numerator
6458 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom202, &(*this), _1));
6459 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6460 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6461 }
6462 double sigma_box_F = average; // interval
6463 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom202, &(*this), _1));
6464 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6465 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6466 }
6467 double sigma_box_B = average; // interval
6468
6469 // denominator
6470 if (!flagLEP2[ISR]) {
6471
6472 sigma = LEP2sigmaBottom(s);
6473 }
6474
6475 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6476 }
6477 } else if (s == 205.*205.) {
6478 double AFB_noBox, sigma = 0.0;
6479 if (!flagLEP2[ISR])
6480 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6481 else {
6482 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom205, &(*this), _1));
6483 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6484 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6485 }
6486 double numerator = average; // interval
6487
6488
6489 sigma = LEP2sigmaBottom(s);
6490
6491 AFB_noBox = numerator/sigma;
6492 }
6493 SMresult_cache = AFB_noBox;
6494
6495 if (flagLEP2[WeakBox]) {
6496 // numerator
6497 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom205, &(*this), _1));
6498 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6499 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6500 }
6501 double sigma_box_F = average; // interval
6502 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom205, &(*this), _1));
6503 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6504 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6505 }
6506 double sigma_box_B = average; // interval
6507
6508 // denominator
6509 if (!flagLEP2[ISR]) {
6510
6511 sigma = LEP2sigmaBottom(s);
6512 }
6513
6514 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6515 }
6516 } else if (s == 207.*207.) {
6517 double AFB_noBox, sigma = 0.0;
6518 if (!flagLEP2[ISR])
6519 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6520 else {
6521 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom207, &(*this), _1));
6522 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6523 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6524 }
6525 double numerator = average; // interval
6526
6527
6528 sigma = LEP2sigmaBottom(s);
6529
6530 AFB_noBox = numerator/sigma;
6531 }
6532 SMresult_cache = AFB_noBox;
6533
6534 if (flagLEP2[WeakBox]) {
6535 // numerator
6536 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom207, &(*this), _1));
6537 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6538 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6539 }
6540 double sigma_box_F = average; // interval
6541 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom207, &(*this), _1));
6542 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6543 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6544 }
6545 double sigma_box_B = average; // interval
6546
6547 // denominator
6548 if (!flagLEP2[ISR]) {
6549
6550 sigma = LEP2sigmaBottom(s);
6551 }
6552
6553 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6554 }
6555 } else {
6556 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2AFBbottom!");
6557 }
6558
6559 double AFBbottom = SMresult_cache;
6560
6561 gsl_set_error_handler(old_handler);
6562 bSigmaForAFB = false;
6563 return AFBbottom;
6564
6565}
6566
6567
6568const double StandardModel::LEP2AFBcharm(const double s) const
6569{
6570
6571 bSigmaForAFB = true;
6572 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
6573 double relerr = 1.e-7;
6574 double abserr = 1.e-17;
6575
6576 if(s == 133.*133.){
6577 double AFB_noBox, sigma = 0.0;
6578 if (!flagLEP2[ISR])
6579 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6580 else {
6581 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm133, &(*this), _1));
6582 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6583 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6584 }
6585 double numerator = average; // interval
6586
6587
6588 sigma = LEP2sigmaCharm(s);
6589
6590 AFB_noBox = numerator/sigma;
6591 }
6592 SMresult_cache = AFB_noBox;
6593
6594 if (flagLEP2[WeakBox]) {
6595 // numerator
6596 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm133, &(*this), _1));
6597 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6598 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6599 }
6600 double sigma_box_F = average; // interval
6601 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm133, &(*this), _1));
6602 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6603 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6604 }
6605 double sigma_box_B = average; // interval
6606
6607 // denominator
6608 if (!flagLEP2[ISR]) {
6609
6610 sigma = LEP2sigmaCharm(s);
6611 }
6612
6613 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6614 }
6615 } else if (s == 167.*167.){
6616 double AFB_noBox, sigma = 0.0;
6617 if (!flagLEP2[ISR])
6618 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6619 else {
6620 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm167, &(*this), _1));
6621 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6622 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6623 }
6624 double numerator = average; // interval
6625
6626
6627 sigma = LEP2sigmaCharm(s);
6628
6629 AFB_noBox = numerator/sigma;
6630 }
6631 SMresult_cache = AFB_noBox;
6632
6633 if (flagLEP2[WeakBox]) {
6634 // numerator
6635 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm167, &(*this), _1));
6636 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6637 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6638 }
6639 double sigma_box_F = average; // interval
6640 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm167, &(*this), _1));
6641 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6642 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6643 }
6644 double sigma_box_B = average; // interval
6645
6646 // denominator
6647 if (!flagLEP2[ISR]) {
6648
6649 sigma = LEP2sigmaCharm(s);
6650 }
6651
6652 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6653 }
6654 } else if (s == 183.*183.) {
6655 double AFB_noBox, sigma = 0.0;
6656 if (!flagLEP2[ISR])
6657 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6658 else {
6659 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm183, &(*this), _1));
6660 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6661 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6662 }
6663 double numerator = average; // interval
6664
6665
6666 sigma = LEP2sigmaCharm(s);
6667
6668 AFB_noBox = numerator/sigma;
6669 }
6670 SMresult_cache = AFB_noBox;
6671
6672 if (flagLEP2[WeakBox]) {
6673 // numerator
6674 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm183, &(*this), _1));
6675 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6676 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6677 }
6678 double sigma_box_F = average; // interval
6679 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm183, &(*this), _1));
6680 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6681 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6682 }
6683 double sigma_box_B = average; // interval
6684
6685 // denominator
6686 if (!flagLEP2[ISR]) {
6687
6688 sigma = LEP2sigmaCharm(s);
6689 }
6690
6691 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6692 }
6693 } else if (s == 189.*189.) {
6694 double AFB_noBox, sigma = 0.0;
6695 if (!flagLEP2[ISR])
6696 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6697 else {
6698 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm189, &(*this), _1));
6699 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6700 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6701 }
6702 double numerator = average; // interval
6703
6704
6705 sigma = LEP2sigmaCharm(s);
6706
6707 AFB_noBox = numerator/sigma;
6708 }
6709 SMresult_cache = AFB_noBox;
6710
6711 if (flagLEP2[WeakBox]) {
6712 // numerator
6713 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm189, &(*this), _1));
6714 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6715 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6716 }
6717 double sigma_box_F = average; // interval
6718 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm189, &(*this), _1));
6719 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6720 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6721 }
6722 double sigma_box_B = average; // interval
6723
6724 // denominator
6725 if (!flagLEP2[ISR]) {
6726
6727 sigma = LEP2sigmaCharm(s);
6728 }
6729
6730 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6731 }
6732 } else if (s == 192.*192.) {
6733 double AFB_noBox, sigma = 0.0;
6734 if (!flagLEP2[ISR])
6735 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6736 else {
6737 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm192, &(*this), _1));
6738 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6739 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6740 }
6741 double numerator = average; // interval
6742
6743
6744 sigma = LEP2sigmaCharm(s);
6745
6746 AFB_noBox = numerator/sigma;
6747 }
6748 SMresult_cache = AFB_noBox;
6749
6750 if (flagLEP2[WeakBox]) {
6751 // numerator
6752 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm192, &(*this), _1));
6753 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6754 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6755 }
6756 double sigma_box_F = average; // interval
6757 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm192, &(*this), _1));
6758 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6759 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6760 }
6761 double sigma_box_B = average; // interval
6762
6763 // denominator
6764 if (!flagLEP2[ISR]) {
6765
6766 sigma = LEP2sigmaCharm(s);
6767 }
6768
6769 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6770 }
6771 } else if (s == 196.*196.) {
6772 double AFB_noBox, sigma = 0.0;
6773 if (!flagLEP2[ISR])
6774 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6775 else {
6776 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm196, &(*this), _1));
6777 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6778 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6779 }
6780 double numerator = average; // interval
6781
6782
6783 sigma = LEP2sigmaCharm(s);
6784
6785 AFB_noBox = numerator/sigma;
6786 }
6787 SMresult_cache = AFB_noBox;
6788
6789 if (flagLEP2[WeakBox]) {
6790 // numerator
6791 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm196, &(*this), _1));
6792 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6793 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6794 }
6795 double sigma_box_F = average; // interval
6796 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm196, &(*this), _1));
6797 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6798 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6799 }
6800 double sigma_box_B = average; // interval
6801
6802 // denominator
6803 if (!flagLEP2[ISR]) {
6804
6805 sigma = LEP2sigmaCharm(s);
6806 }
6807
6808 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6809 }
6810 } else if (s == 200.*200.) {
6811 double AFB_noBox, sigma = 0.0;
6812 if (!flagLEP2[ISR])
6813 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6814 else {
6815 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm200, &(*this), _1));
6816 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6817 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6818 }
6819 double numerator = average; // interval
6820
6821
6822 sigma = LEP2sigmaCharm(s);
6823
6824 AFB_noBox = numerator/sigma;
6825 }
6826 SMresult_cache = AFB_noBox;
6827
6828 if (flagLEP2[WeakBox]) {
6829 // numerator
6830 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm200, &(*this), _1));
6831 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6832 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6833 }
6834 double sigma_box_F = average; // interval
6835 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm200, &(*this), _1));
6836 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6837 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6838 }
6839 double sigma_box_B = average; // interval
6840
6841 // denominator
6842 if (!flagLEP2[ISR]) {
6843
6844 sigma = LEP2sigmaCharm(s);
6845 }
6846
6847 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6848 }
6849 } else if (s == 202.*202.) {
6850 double AFB_noBox, sigma = 0.0;
6851 if (!flagLEP2[ISR])
6852 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6853 else {
6854 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm202, &(*this), _1));
6855 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6856 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6857 }
6858 double numerator = average; // interval
6859
6860
6861 sigma = LEP2sigmaCharm(s);
6862
6863 AFB_noBox = numerator/sigma;
6864 }
6865 SMresult_cache = AFB_noBox;
6866
6867 if (flagLEP2[WeakBox]) {
6868 // numerator
6869 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm202, &(*this), _1));
6870 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6871 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6872 }
6873 double sigma_box_F = average; // interval
6874 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm202, &(*this), _1));
6875 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6876 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6877 }
6878 double sigma_box_B = average; // interval
6879
6880 // denominator
6881 if (!flagLEP2[ISR]) {
6882
6883 sigma = LEP2sigmaCharm(s);
6884 }
6885
6886 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6887 }
6888 } else if (s == 205.*205.) {
6889 double AFB_noBox, sigma = 0.0;
6890 if (!flagLEP2[ISR])
6891 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6892 else {
6893 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm205, &(*this), _1));
6894 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6895 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6896 }
6897 double numerator = average; // interval
6898
6899
6900 sigma = LEP2sigmaCharm(s);
6901
6902 AFB_noBox = numerator/sigma;
6903 }
6904 SMresult_cache = AFB_noBox;
6905
6906 if (flagLEP2[WeakBox]) {
6907 // numerator
6908 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm205, &(*this), _1));
6909 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6910 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6911 }
6912 double sigma_box_F = average; // interval
6913 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm205, &(*this), _1));
6914 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6915 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6916 }
6917 double sigma_box_B = average; // interval
6918
6919 // denominator
6920 if (!flagLEP2[ISR]) {
6921
6922 sigma = LEP2sigmaCharm(s);
6923 }
6924
6925 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6926 }
6927 } else if (s == 207.*207.) {
6928 double AFB_noBox, sigma = 0.0;
6929 if (!flagLEP2[ISR])
6930 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6931 else {
6932 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm205, &(*this), _1));
6933 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6934 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6935 }
6936 double numerator = average; // interval
6937
6938
6939 sigma = LEP2sigmaCharm(s);
6940
6941 AFB_noBox = numerator/sigma;
6942 }
6943 SMresult_cache = AFB_noBox;
6944
6945 if (flagLEP2[WeakBox]) {
6946 // numerator
6947 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm207, &(*this), _1));
6948 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6949 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6950 }
6951 double sigma_box_F = average; // interval
6952 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm207, &(*this), _1));
6953 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6954 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6955 }
6956 double sigma_box_B = average; // interval
6957
6958 // denominator
6959 if (!flagLEP2[ISR]) {
6960
6961 sigma = LEP2sigmaCharm(s);
6962 }
6963
6964 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6965 }
6966 } else {
6967 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2AFBcharm!");
6968 }
6969
6970 double AFBcharm = SMresult_cache;
6971
6972 gsl_set_error_handler(old_handler);
6973 bSigmaForAFB = false;
6974 return AFBcharm;
6975
6976}
6977
6978const double StandardModel::LEP2AFBe(const double s) const
6979{
6980 return 0.;
6981}
6982
6983const double StandardModel::LEP2AFBmu(const double s) const
6984{
6985
6986 bSigmaForAFB = true;
6987 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
6988 double relerr = 1.e-7;
6989 double abserr = 1.e-17;
6990
6991 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
6992 if (!IsFlagNoApproximateGammaZ()){
6993
6994 /* SM contribution with the approximate formula */
6995 return (myApproximateFormulae->LEP2AFBmuApprox(s));
6996
6997 } else {
6998
6999 if(s == 130.*130.){
7000 double AFB_noBox, sigma = 0.0;
7001 if (!flagLEP2[ISR])
7002 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7003 else {
7004 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu130, &(*this), _1));
7005 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7006 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7007 }
7008 double numerator = average; // interval
7009
7010
7011 sigma = LEP2sigmaMu(s);
7012
7013 AFB_noBox = numerator/sigma;
7014 }
7015 SMresult_cache = AFB_noBox;
7016
7017 if (flagLEP2[WeakBox]) {
7018 // numerator
7019 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu130, &(*this), _1));
7020 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7021 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7022 }
7023 double sigma_box_F = average; // interval
7024 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu130, &(*this), _1));
7025 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7026 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7027 }
7028 double sigma_box_B = average; // interval
7029
7030 // denominator
7031 if (!flagLEP2[ISR]) {
7032
7033 sigma = LEP2sigmaMu(s);
7034 }
7035
7036 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7037 }
7038 } else if (s == 136.*136.){
7039 double AFB_noBox, sigma = 0.0;
7040 if (!flagLEP2[ISR])
7041 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7042 else {
7043 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu136, &(*this), _1));
7044 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7045 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7046 }
7047 double numerator = average; // interval
7048
7049
7050 sigma = LEP2sigmaMu(s);
7051
7052 AFB_noBox = numerator/sigma;
7053 }
7054 SMresult_cache = AFB_noBox;
7055
7056 if (flagLEP2[WeakBox]) {
7057 // numerator
7058 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu136, &(*this), _1));
7059 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7060 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7061 }
7062 double sigma_box_F = average; // interval
7063 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu136, &(*this), _1));
7064 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7065 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7066 }
7067 double sigma_box_B = average; // interval
7068
7069 // denominator
7070 if (!flagLEP2[ISR]) {
7071
7072 sigma = LEP2sigmaMu(s);
7073 }
7074
7075 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7076 }
7077 } else if (s == 161.*161.){
7078 double AFB_noBox, sigma = 0.0;
7079 if (!flagLEP2[ISR])
7080 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7081 else {
7082 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu161, &(*this), _1));
7083 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7084 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7085 }
7086 double numerator = average; // interval
7087
7088
7089 sigma = LEP2sigmaMu(s);
7090
7091 AFB_noBox = numerator/sigma;
7092 }
7093 SMresult_cache = AFB_noBox;
7094
7095 if (flagLEP2[WeakBox]) {
7096 // numerator
7097 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu161, &(*this), _1));
7098 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7099 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7100 }
7101 double sigma_box_F = average; // interval
7102 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu161, &(*this), _1));
7103 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7104 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7105 }
7106 double sigma_box_B = average; // interval
7107
7108 // denominator
7109 if (!flagLEP2[ISR]) {
7110
7111 sigma = LEP2sigmaMu(s);
7112 }
7113
7114 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7115 }
7116 } else if (s == 172.*172.){
7117 double AFB_noBox, sigma = 0.0;
7118 if (!flagLEP2[ISR])
7119 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7120 else {
7121 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu172, &(*this), _1));
7122 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7123 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7124 }
7125 double numerator = average; // interval
7126
7127
7128 sigma = LEP2sigmaMu(s);
7129
7130 AFB_noBox = numerator/sigma;
7131 }
7132 SMresult_cache = AFB_noBox;
7133
7134 if (flagLEP2[WeakBox]) {
7135 // numerator
7136 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu172, &(*this), _1));
7137 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7138 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7139 }
7140 double sigma_box_F = average; // interval
7141 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu172, &(*this), _1));
7142 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7143 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7144 }
7145 double sigma_box_B = average; // interval
7146
7147 // denominator
7148 if (!flagLEP2[ISR]) {
7149
7150 sigma = LEP2sigmaMu(s);
7151 }
7152
7153 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7154 }
7155 } else if (s == 183.*183.) {
7156 double AFB_noBox, sigma = 0.0;
7157 if (!flagLEP2[ISR])
7158 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7159 else {
7160 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu183, &(*this), _1));
7161 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7162 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7163 }
7164 double numerator = average; // interval
7165
7166
7167 sigma = LEP2sigmaMu(s);
7168
7169 AFB_noBox = numerator/sigma;
7170 }
7171 SMresult_cache = AFB_noBox;
7172
7173 if (flagLEP2[WeakBox]) {
7174 // numerator
7175 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu183, &(*this), _1));
7176 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7177 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7178 }
7179 double sigma_box_F = average; // interval
7180 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu183, &(*this), _1));
7181 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7182 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7183 }
7184 double sigma_box_B = average; // interval
7185
7186 // denominator
7187 if (!flagLEP2[ISR]) {
7188
7189 sigma = LEP2sigmaMu(s);
7190 }
7191
7192 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7193 }
7194 } else if (s == 189.*189.) {
7195 double AFB_noBox, sigma = 0.0;
7196 if (!flagLEP2[ISR])
7197 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7198 else {
7199 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu189, &(*this), _1));
7200 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7201 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7202 }
7203 double numerator = average; // interval
7204
7205
7206 sigma = LEP2sigmaMu(s);
7207
7208 AFB_noBox = numerator/sigma;
7209 }
7210 SMresult_cache = AFB_noBox;
7211
7212 if (flagLEP2[WeakBox]) {
7213 // numerator
7214 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu189, &(*this), _1));
7215 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7216 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7217 }
7218 double sigma_box_F = average; // interval
7219 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu189, &(*this), _1));
7220 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7221 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7222 }
7223 double sigma_box_B = average; // interval
7224
7225 // denominator
7226 if (!flagLEP2[ISR]) {
7227
7228 sigma = LEP2sigmaMu(s);
7229 }
7230
7231 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7232 }
7233 } else if (s == 192.*192.) {
7234 double AFB_noBox, sigma = 0.0;
7235 if (!flagLEP2[ISR])
7236 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7237 else {
7238 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu192, &(*this), _1));
7239 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7240 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7241 }
7242 double numerator = average; // interval
7243
7244
7245 sigma = LEP2sigmaMu(s);
7246
7247 AFB_noBox = numerator/sigma;
7248 }
7249 SMresult_cache = AFB_noBox;
7250
7251 if (flagLEP2[WeakBox]) {
7252 // numerator
7253 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu192, &(*this), _1));
7254 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7255 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7256 }
7257 double sigma_box_F = average; // interval
7258 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu192, &(*this), _1));
7259 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7260 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7261 }
7262 double sigma_box_B = average; // interval
7263
7264 // denominator
7265 if (!flagLEP2[ISR]) {
7266
7267 sigma = LEP2sigmaMu(s);
7268 }
7269
7270 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7271 }
7272 } else if (s == 196.*196.) {
7273 double AFB_noBox, sigma = 0.0;
7274 if (!flagLEP2[ISR])
7275 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7276 else {
7277 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu196, &(*this), _1));
7278 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7279 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7280 }
7281 double numerator = average; // interval
7282
7283
7284 sigma = LEP2sigmaMu(s);
7285
7286 AFB_noBox = numerator/sigma;
7287 }
7288 SMresult_cache = AFB_noBox;
7289
7290 if (flagLEP2[WeakBox]) {
7291 // numerator
7292 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu196, &(*this), _1));
7293 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7294 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7295 }
7296 double sigma_box_F = average; // interval
7297 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu196, &(*this), _1));
7298 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7299 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7300 }
7301 double sigma_box_B = average; // interval
7302
7303 // denominator
7304 if (!flagLEP2[ISR]) {
7305
7306 sigma = LEP2sigmaMu(s);
7307 }
7308
7309 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7310 }
7311 } else if (s == 200.*200.) {
7312 double AFB_noBox, sigma = 0.0;
7313 if (!flagLEP2[ISR])
7314 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7315 else {
7316 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu200, &(*this), _1));
7317 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7318 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7319 }
7320 double numerator = average; // interval
7321
7322
7323 sigma = LEP2sigmaMu(s);
7324
7325 AFB_noBox = numerator/sigma;
7326 }
7327 SMresult_cache = AFB_noBox;
7328
7329 if (flagLEP2[WeakBox]) {
7330 // numerator
7331 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu200, &(*this), _1));
7332 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7333 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7334 }
7335 double sigma_box_F = average; // interval
7336 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu200, &(*this), _1));
7337 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7338 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7339 }
7340 double sigma_box_B = average; // interval
7341
7342 // denominator
7343 if (!flagLEP2[ISR]) {
7344
7345 sigma = LEP2sigmaMu(s);
7346 }
7347
7348 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7349 }
7350 } else if (s == 202.*202.) {
7351 double AFB_noBox, sigma = 0.0;
7352 if (!flagLEP2[ISR])
7353 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7354 else {
7355 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu202, &(*this), _1));
7356 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7357 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7358 }
7359 double numerator = average; // interval
7360
7361
7362 sigma = LEP2sigmaMu(s);
7363
7364 AFB_noBox = numerator/sigma;
7365 }
7366 SMresult_cache = AFB_noBox;
7367
7368 if (flagLEP2[WeakBox]) {
7369 // numerator
7370 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu202, &(*this), _1));
7371 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7372 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7373 }
7374 double sigma_box_F = average; // interval
7375 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu202, &(*this), _1));
7376 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7377 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7378 }
7379 double sigma_box_B = average; // interval
7380
7381 // denominator
7382 if (!flagLEP2[ISR]) {
7383
7384 sigma = LEP2sigmaMu(s);
7385 }
7386
7387 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7388 }
7389 } else if (s == 205.*205.) {
7390 double AFB_noBox, sigma = 0.0;
7391 if (!flagLEP2[ISR])
7392 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7393 else {
7394 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu205, &(*this), _1));
7395 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7396 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7397 }
7398 double numerator = average; // interval
7399
7400
7401 sigma = LEP2sigmaMu(s);
7402
7403 AFB_noBox = numerator/sigma;
7404 }
7405 SMresult_cache = AFB_noBox;
7406
7407 if (flagLEP2[WeakBox]) {
7408 // numerator
7409 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu205, &(*this), _1));
7410 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7411 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7412 }
7413 double sigma_box_F = average; // interval
7414 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu205, &(*this), _1));
7415 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7416 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7417 }
7418 double sigma_box_B = average; // interval
7419
7420 // denominator
7421 if (!flagLEP2[ISR]) {
7422
7423 sigma = LEP2sigmaMu(s);
7424 }
7425
7426 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7427 }
7428 } else if (s == 207.*207.) {
7429 double AFB_noBox, sigma = 0.0;
7430 if (!flagLEP2[ISR])
7431 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7432 else {
7433 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu207, &(*this), _1));
7434 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7435 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7436 }
7437 double numerator = average; // interval
7438
7439
7440 sigma = LEP2sigmaMu(s);
7441
7442 AFB_noBox = numerator/sigma;
7443 }
7444 SMresult_cache = AFB_noBox;
7445
7446 if (flagLEP2[WeakBox]) {
7447 // numerator
7448 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu207, &(*this), _1));
7449 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7450 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7451 }
7452 double sigma_box_F = average; // interval
7453 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu207, &(*this), _1));
7454 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7455 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7456 }
7457 double sigma_box_B = average; // interval
7458
7459 // denominator
7460 if (!flagLEP2[ISR]) {
7461
7462 sigma = LEP2sigmaMu(s);
7463 }
7464
7465 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7466 }
7467 } else {
7468 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::AFBmu!");
7469 }
7470
7471 double AFBmu = SMresult_cache;
7472
7473 gsl_set_error_handler(old_handler);
7474 bSigmaForAFB = false;
7475 return AFBmu;
7476 }
7477}
7478
7479
7480const double StandardModel::LEP2AFBtau(const double s) const
7481{
7482
7483 bSigmaForAFB = true;
7484 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
7485 double relerr = 1.e-7;
7486 double abserr = 1.e-17;
7487
7488 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
7489 if (!IsFlagNoApproximateGammaZ()){
7490
7491 /* SM contribution with the approximate formula */
7492 return (myApproximateFormulae->LEP2AFBtauApprox(s));
7493
7494 } else {
7495
7496 if(s == 130.*130.){
7497 double AFB_noBox, sigma = 0.0;
7498 if (!flagLEP2[ISR])
7499 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7500 else {
7501 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau130, &(*this), _1));
7502 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7503 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7504 }
7505 double numerator = average; // interval
7506
7507
7508 sigma = LEP2sigmaTau(s);
7509
7510 AFB_noBox = numerator/sigma;
7511 }
7512 SMresult_cache = AFB_noBox;
7513
7514 if (flagLEP2[WeakBox]) {
7515 // numerator
7516 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau130, &(*this), _1));
7517 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7518 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7519 }
7520 double sigma_box_F = average; // interval
7521 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau130, &(*this), _1));
7522 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7523 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7524 }
7525 double sigma_box_B = average; // interval
7526
7527 // denominator
7528 if (!flagLEP2[ISR]) {
7529
7530 sigma = LEP2sigmaTau(s);
7531 }
7532
7533 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7534 }
7535 } else if (s == 136.*136.){
7536 double AFB_noBox, sigma = 0.0;
7537 if (!flagLEP2[ISR])
7538 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7539 else {
7540 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau136, &(*this), _1));
7541 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7542 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7543 }
7544 double numerator = average; // interval
7545
7546
7547 sigma = LEP2sigmaTau(s);
7548
7549 AFB_noBox = numerator/sigma;
7550 }
7551 SMresult_cache = AFB_noBox;
7552
7553 if (flagLEP2[WeakBox]) {
7554 // numerator
7555 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau136, &(*this), _1));
7556 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7557 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7558 }
7559 double sigma_box_F = average; // interval
7560 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau136, &(*this), _1));
7561 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7562 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7563 }
7564 double sigma_box_B = average; // interval
7565
7566 // denominator
7567 if (!flagLEP2[ISR]) {
7568
7569 sigma = LEP2sigmaTau(s);
7570 }
7571
7572 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7573 }
7574 } else if (s == 161.*161.){
7575 double AFB_noBox, sigma = 0.0;
7576 if (!flagLEP2[ISR])
7577 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7578 else {
7579 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau161, &(*this), _1));
7580 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7581 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7582 }
7583 double numerator = average; // interval
7584
7585
7586 sigma = LEP2sigmaTau(s);
7587
7588 AFB_noBox = numerator/sigma;
7589 }
7590 SMresult_cache = AFB_noBox;
7591
7592 if (flagLEP2[WeakBox]) {
7593 // numerator
7594 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau161, &(*this), _1));
7595 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7596 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7597 }
7598 double sigma_box_F = average; // interval
7599 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau161, &(*this), _1));
7600 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7601 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7602 }
7603 double sigma_box_B = average; // interval
7604
7605 // denominator
7606 if (!flagLEP2[ISR]) {
7607
7608 sigma = LEP2sigmaTau(s);
7609 }
7610
7611 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7612 }
7613 } else if (s == 172.*172.){
7614 double AFB_noBox, sigma = 0.0;
7615 if (!flagLEP2[ISR])
7616 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7617 else {
7618 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau172, &(*this), _1));
7619 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7620 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7621 }
7622 double numerator = average; // interval
7623
7624
7625 sigma = LEP2sigmaTau(s);
7626
7627 AFB_noBox = numerator/sigma;
7628 }
7629 SMresult_cache = AFB_noBox;
7630
7631 if (flagLEP2[WeakBox]) {
7632 // numerator
7633 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau172, &(*this), _1));
7634 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7635 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7636 }
7637 double sigma_box_F = average; // interval
7638 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau172, &(*this), _1));
7639 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7640 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7641 }
7642 double sigma_box_B = average; // interval
7643
7644 // denominator
7645 if (!flagLEP2[ISR]) {
7646
7647 sigma = LEP2sigmaTau(s);
7648 }
7649
7650 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7651 }
7652 } else if (s == 183.*183.) {
7653 double AFB_noBox, sigma = 0.0;
7654 if (!flagLEP2[ISR])
7655 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7656 else {
7657 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau183, &(*this), _1));
7658 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7659 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7660 }
7661 double numerator = average; // interval
7662
7663
7664 sigma = LEP2sigmaTau(s);
7665
7666 AFB_noBox = numerator/sigma;
7667 }
7668 SMresult_cache = AFB_noBox;
7669
7670 if (flagLEP2[WeakBox]) {
7671 // numerator
7672 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau183, &(*this), _1));
7673 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7674 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7675 }
7676 double sigma_box_F = average; // interval
7677 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau183, &(*this), _1));
7678 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7679 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7680 }
7681 double sigma_box_B = average; // interval
7682
7683 // denominator
7684 if (!flagLEP2[ISR]) {
7685
7686 sigma = LEP2sigmaTau(s);
7687 }
7688
7689 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7690 }
7691 } else if (s == 189.*189.) {
7692 double AFB_noBox, sigma = 0.0;
7693 if (!flagLEP2[ISR])
7694 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7695 else {
7696 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau189, &(*this), _1));
7697 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7698 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7699 }
7700 double numerator = average; // interval
7701
7702
7703 sigma = LEP2sigmaTau(s);
7704
7705 AFB_noBox = numerator/sigma;
7706 }
7707 SMresult_cache = AFB_noBox;
7708
7709 if (flagLEP2[WeakBox]) {
7710 // numerator
7711 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau189, &(*this), _1));
7712 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7713 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7714 }
7715 double sigma_box_F = average; // interval
7716 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau189, &(*this), _1));
7717 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7718 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7719 }
7720 double sigma_box_B = average; // interval
7721
7722 // denominator
7723 if (!flagLEP2[ISR]) {
7724
7725 sigma = LEP2sigmaTau(s);
7726 }
7727
7728 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7729 }
7730 } else if (s == 192.*192.) {
7731 double AFB_noBox, sigma = 0.0;
7732 if (!flagLEP2[ISR])
7733 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7734 else {
7735 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau192, &(*this), _1));
7736 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7737 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7738 }
7739 double numerator = average; // interval
7740
7741
7742 sigma = LEP2sigmaTau(s);
7743
7744 AFB_noBox = numerator/sigma;
7745 }
7746 SMresult_cache = AFB_noBox;
7747
7748 if (flagLEP2[WeakBox]) {
7749 // numerator
7750 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau192, &(*this), _1));
7751 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7752 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7753 }
7754 double sigma_box_F = average; // interval
7755 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau192, &(*this), _1));
7756 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7757 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7758 }
7759 double sigma_box_B = average; // interval
7760
7761 // denominator
7762 if (!flagLEP2[ISR]) {
7763
7764 sigma = LEP2sigmaTau(s);
7765 }
7766
7767 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7768 }
7769 } else if (s == 196.*196.) {
7770 double AFB_noBox, sigma = 0.0;
7771 if (!flagLEP2[ISR])
7772 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7773 else {
7774 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau196, &(*this), _1));
7775 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7776 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7777 }
7778 double numerator = average; // interval
7779
7780
7781 sigma = LEP2sigmaTau(s);
7782
7783 AFB_noBox = numerator/sigma;
7784 }
7785 SMresult_cache = AFB_noBox;
7786
7787 if (flagLEP2[WeakBox]) {
7788 // numerator
7789 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau196, &(*this), _1));
7790 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7791 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7792 }
7793 double sigma_box_F = average; // interval
7794 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau196, &(*this), _1));
7795 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7796 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7797 }
7798 double sigma_box_B = average; // interval
7799
7800 // denominator
7801 if (!flagLEP2[ISR]) {
7802
7803 sigma = LEP2sigmaTau(s);
7804 }
7805
7806 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7807 }
7808 } else if (s == 200.*200.) {
7809 double AFB_noBox, sigma = 0.0;
7810 if (!flagLEP2[ISR])
7811 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7812 else {
7813 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau200, &(*this), _1));
7814 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7815 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7816 }
7817 double numerator = average; // interval
7818
7819
7820 sigma = LEP2sigmaTau(s);
7821
7822 AFB_noBox = numerator/sigma;
7823 }
7824 SMresult_cache = AFB_noBox;
7825
7826 if (flagLEP2[WeakBox]) {
7827 // numerator
7828 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau200, &(*this), _1));
7829 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7830 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7831 }
7832 double sigma_box_F = average; // interval
7833 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau200, &(*this), _1));
7834 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7835 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7836 }
7837 double sigma_box_B = average; // interval
7838
7839 // denominator
7840 if (!flagLEP2[ISR]) {
7841
7842 sigma = LEP2sigmaTau(s);
7843 }
7844
7845 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7846 }
7847 } else if (s == 202.*202.) {
7848 double AFB_noBox, sigma = 0.0;
7849 if (!flagLEP2[ISR])
7850 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7851 else {
7852 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau202, &(*this), _1));
7853 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7854 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7855 }
7856 double numerator = average; // interval
7857
7858
7859 sigma = LEP2sigmaTau(s);
7860
7861 AFB_noBox = numerator/sigma;
7862 }
7863 SMresult_cache = AFB_noBox;
7864
7865 if (flagLEP2[WeakBox]) {
7866 // numerator
7867 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau202, &(*this), _1));
7868 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7869 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7870 }
7871 double sigma_box_F = average; // interval
7872 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau202, &(*this), _1));
7873 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7874 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7875 }
7876 double sigma_box_B = average; // interval
7877
7878 // denominator
7879 if (!flagLEP2[ISR]) {
7880
7881 sigma = LEP2sigmaTau(s);
7882 }
7883
7884 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7885 }
7886 } else if (s == 205.*205.) {
7887 double AFB_noBox, sigma = 0.0;
7888 if (!flagLEP2[ISR])
7889 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7890 else {
7891 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau205, &(*this), _1));
7892 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7893 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7894 }
7895 double numerator = average; // interval
7896
7897
7898 sigma = LEP2sigmaTau(s);
7899
7900 AFB_noBox = numerator/sigma;
7901 }
7902 SMresult_cache = AFB_noBox;
7903
7904 if (flagLEP2[WeakBox]) {
7905 // numerator
7906 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau205, &(*this), _1));
7907 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7908 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7909 }
7910 double sigma_box_F = average; // interval
7911 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau205, &(*this), _1));
7912 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7913 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7914 }
7915 double sigma_box_B = average; // interval
7916
7917 // denominator
7918 if (!flagLEP2[ISR]) {
7919
7920 sigma = LEP2sigmaTau(s);
7921 }
7922
7923 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7924 }
7925 } else if (s == 207.*207.) {
7926 double AFB_noBox, sigma = 0.0;
7927 if (!flagLEP2[ISR])
7928 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7929 else {
7930 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau207, &(*this), _1));
7931 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7932 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7933 }
7934 double numerator = average; // interval
7935
7936
7937 sigma = LEP2sigmaTau(s);
7938
7939 AFB_noBox = numerator/sigma;
7940 }
7941 SMresult_cache = AFB_noBox;
7942
7943 if (flagLEP2[WeakBox]) {
7944 // numerator
7945 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau207, &(*this), _1));
7946 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7947 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7948 }
7949 double sigma_box_F = average; // interval
7950 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau207, &(*this), _1));
7951 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7952 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7953 }
7954 double sigma_box_B = average; // interval
7955
7956 // denominator
7957 if (!flagLEP2[ISR]) {
7958
7959 sigma = LEP2sigmaTau(s);
7960 }
7961
7962 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7963 }
7964 } else {
7965 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2AFBtau!");
7966 }
7967
7968 double AFBtau = SMresult_cache;
7969
7970 gsl_set_error_handler(old_handler);
7971 bSigmaForAFB = false;
7972 return AFBtau;
7973 }
7974}
7975
7976
7977const double StandardModel::LEP2Rbottom(const double s) const
7978{
7979
7980 double sigma_b = LEP2sigmaBottom(s);
7981 double sigma_had = LEP2sigmaHadron(s);
7982 SMresult_cache = sigma_b / sigma_had;
7983 double R_bottom = SMresult_cache;
7984
7985 return R_bottom;
7986}
7987
7988
7989const double StandardModel::LEP2Rcharm(const double s) const
7990{
7991
7992 double sigma_c = LEP2sigmaCharm(s);
7993 double sigma_had = LEP2sigmaHadron(s);
7994 SMresult_cache = sigma_c / sigma_had;
7995 double R_charm = SMresult_cache;
7996
7997 return R_charm;
7998}
7999
8000
8001const double StandardModel::sigma_NoISR_l(const QCD::lepton l_flavor, const double s) const
8002{
8003 double ml = getLeptons(l_flavor).getMass();
8004 double l_charge = getLeptons(l_flavor).getCharge();
8005 double sigma = myTwoFermionsLEP2->sigma_l(l_flavor, ml, s, Mw(), Gamma_Z(), flagLEP2[Weak]);
8006
8007 if (!bSigmaForAFB && flagLEP2[QEDFSR])
8008 sigma *= myTwoFermionsLEP2->QED_FSR_forSigma(s, l_charge);
8009
8010 return sigma;
8011}
8012
8013const double StandardModel::sigma_NoISR_q(const QCD::quark q_flavor, const double s) const
8014{
8015 double mq = m_q(q_flavor, sqrt(s));
8016 double q_charge = getQuarks(q_flavor).getCharge();
8017 double sigma = myTwoFermionsLEP2->sigma_q(q_flavor, mq, s, Mw(), Gamma_Z(), flagLEP2[Weak]);
8018
8019 if (!bSigmaForAFB && flagLEP2[QEDFSR])
8020 sigma *= myTwoFermionsLEP2->QED_FSR_forSigma(s, q_charge);
8021
8022 if (!bSigmaForAFB && flagLEP2[QCDFSR])
8023 sigma *= myTwoFermionsLEP2->QCD_FSR_forSigma(s);
8024
8025 return sigma;
8026}
8027
8028const double StandardModel::AFB_NoISR_l(const QCD::lepton l_flavor, const double s) const
8029{
8030 double ml = getLeptons(l_flavor).getMass();
8031 double AFB = myTwoFermionsLEP2->AFB_l(l_flavor, ml, s, Mw(), Gamma_Z(), flagLEP2[Weak]);
8032
8033 return AFB;
8034}
8035
8036const double StandardModel::AFB_NoISR_q(const QCD::quark q_flavor, const double s) const
8037{
8038 double mq = m_q(q_flavor, sqrt(s));
8039 double AFB = myTwoFermionsLEP2->AFB_q(q_flavor, mq, s, Mw(), Gamma_Z(), flagLEP2[Weak]);
8040
8041 if (flagLEP2[QCDFSR])
8042 AFB *= myTwoFermionsLEP2->QCD_FSR_forAFB(q_flavor, mq, s);
8043
8044 return AFB;
8045}
8046
8047const double StandardModel::Integrand_sigmaWithISR_l(double x, const QCD::lepton l_flavor, const double s) const
8048{
8049 double sprime = (1.0 - x)*s;
8050 double ml = getLeptons(l_flavor).getMass();
8051 double l_charge = getLeptons(l_flavor).getCharge();
8052 double sigma = myTwoFermionsLEP2->sigma_l(l_flavor, ml, sprime, Mw(), Gamma_Z(),
8053 flagLEP2[Weak]);
8054 double H = myTwoFermionsLEP2->H_ISR(x, s);
8055
8056 if (!bSigmaForAFB && flagLEP2[QEDFSR])
8057 sigma *= myTwoFermionsLEP2->QED_FSR_forSigma(sprime, l_charge);
8058
8059 return ( H*sigma );
8060}
8061
8062const double StandardModel::getIntegrand_sigmaWithISR_mu130(double x) const
8063{
8064 double s = 130. * 130.;
8065 return (Integrand_sigmaWithISR_l(x, QCD::lepton(MU), s));
8066}
8067
8068const double StandardModel::getIntegrand_sigmaWithISR_mu136(double x) const
8069{
8070 double s = 136. * 136.;
8071 return (Integrand_sigmaWithISR_l(x, QCD::lepton(MU), s));
8072}
8073
8074const double StandardModel::getIntegrand_sigmaWithISR_mu161(double x) const
8075{
8076 double s = 161. * 161.;
8077 return (Integrand_sigmaWithISR_l(x, QCD::lepton(MU), s));
8078}
8079
8080const double StandardModel::getIntegrand_sigmaWithISR_mu172(double x) const
8081{
8082 double s = 172. * 172.;
8083 return (Integrand_sigmaWithISR_l(x, QCD::lepton(MU), s));
8084}
8085
8086const double StandardModel::getIntegrand_sigmaWithISR_mu183(double x) const
8087{
8088 double s = 183. * 183.;
8089 return (Integrand_sigmaWithISR_l(x, QCD::lepton(MU), s));
8090}
8091
8092const double StandardModel::getIntegrand_sigmaWithISR_mu189(double x) const
8093{
8094 double s = 189. * 189.;
8095 return (Integrand_sigmaWithISR_l(x, QCD::lepton(MU), s));
8096}
8097
8098const double StandardModel::getIntegrand_sigmaWithISR_mu192(double x) const
8099{
8100 double s = 192. * 192.;
8101 return (Integrand_sigmaWithISR_l(x, QCD::lepton(MU), s));
8102}
8103
8104const double StandardModel::getIntegrand_sigmaWithISR_mu196(double x) const
8105{
8106 double s = 196. * 196.;
8107 return (Integrand_sigmaWithISR_l(x, QCD::lepton(MU), s));
8108}
8109
8110const double StandardModel::getIntegrand_sigmaWithISR_mu200(double x) const
8111{
8112 double s = 200. * 200.;
8113 return (Integrand_sigmaWithISR_l(x, QCD::lepton(MU), s));
8114}
8115
8116const double StandardModel::getIntegrand_sigmaWithISR_mu202(double x) const
8117{
8118 double s = 202. * 202.;
8119 return (Integrand_sigmaWithISR_l(x, QCD::lepton(MU), s));
8120}
8121
8122const double StandardModel::getIntegrand_sigmaWithISR_mu205(double x) const
8123{
8124 double s = 205. * 205.;
8125 return (Integrand_sigmaWithISR_l(x, QCD::lepton(MU), s));
8126}
8127
8128const double StandardModel::getIntegrand_sigmaWithISR_mu207(double x) const
8129{
8130 double s = 207. * 207.;
8131 return (Integrand_sigmaWithISR_l(x, QCD::lepton(MU), s));
8132}
8133
8134
8135const double StandardModel::getIntegrand_sigmaWithISR_tau130(double x) const
8136{
8137 double s = 130. * 130.;
8138 return (Integrand_sigmaWithISR_l(x, QCD::lepton(TAU), s));
8139}
8140
8141const double StandardModel::getIntegrand_sigmaWithISR_tau136(double x) const
8142{
8143 double s = 136. * 136.;
8144 return (Integrand_sigmaWithISR_l(x, QCD::lepton(TAU), s));
8145}
8146
8147const double StandardModel::getIntegrand_sigmaWithISR_tau161(double x) const
8148{
8149 double s = 161. * 161.;
8150 return (Integrand_sigmaWithISR_l(x, QCD::lepton(TAU), s));
8151}
8152
8153const double StandardModel::getIntegrand_sigmaWithISR_tau172(double x) const
8154{
8155 double s = 172. * 172.;
8156 return (Integrand_sigmaWithISR_l(x, QCD::lepton(TAU), s));
8157}
8158
8159const double StandardModel::getIntegrand_sigmaWithISR_tau183(double x) const
8160{
8161 double s = 183. * 183.;
8162 return (Integrand_sigmaWithISR_l(x, QCD::lepton(TAU), s));
8163}
8164
8165const double StandardModel::getIntegrand_sigmaWithISR_tau189(double x) const
8166{
8167 double s = 189. * 189.;
8168 return (Integrand_sigmaWithISR_l(x, QCD::lepton(TAU), s));
8169}
8170
8171const double StandardModel::getIntegrand_sigmaWithISR_tau192(double x) const
8172{
8173 double s = 192. * 192.;
8174 return (Integrand_sigmaWithISR_l(x, QCD::lepton(TAU), s));
8175}
8176
8177const double StandardModel::getIntegrand_sigmaWithISR_tau196(double x) const
8178{
8179 double s = 196. * 196.;
8180 return (Integrand_sigmaWithISR_l(x, QCD::lepton(TAU), s));
8181}
8182
8183const double StandardModel::getIntegrand_sigmaWithISR_tau200(double x) const
8184{
8185 double s = 200. * 200.;
8186 return (Integrand_sigmaWithISR_l(x, QCD::lepton(TAU), s));
8187}
8188
8189const double StandardModel::getIntegrand_sigmaWithISR_tau202(double x) const
8190{
8191 double s = 202. * 202.;
8192 return (Integrand_sigmaWithISR_l(x, QCD::lepton(TAU), s));
8193}
8194
8195const double StandardModel::getIntegrand_sigmaWithISR_tau205(double x) const
8196{
8197 double s = 205. * 205.;
8198 return (Integrand_sigmaWithISR_l(x, QCD::lepton(TAU), s));
8199}
8200
8201const double StandardModel::getIntegrand_sigmaWithISR_tau207(double x) const
8202{
8203 double s = 207. * 207.;
8204 return (Integrand_sigmaWithISR_l(x, QCD::lepton(TAU), s));
8205}
8206
8207const double StandardModel::Integrand_sigmaWithISR_q(double x, const QCD::quark q_flavor, const double s) const
8208{
8209 double sprime = (1.0 - x)*s;
8210 double mq = m_q(q_flavor, sqrt(s));
8211 double q_charge = getQuarks(q_flavor).getCharge();
8212 double sigma = myTwoFermionsLEP2->sigma_q(q_flavor, mq, sprime, Mw(), Gamma_Z(),
8213 flagLEP2[Weak]);
8214 double H = myTwoFermionsLEP2->H_ISR(x, s);
8215
8216 if (!bSigmaForAFB && flagLEP2[QEDFSR])
8217 sigma *= myTwoFermionsLEP2->QED_FSR_forSigma(sprime, q_charge);
8218
8219 if (!bSigmaForAFB && flagLEP2[QCDFSR])
8220 sigma *= myTwoFermionsLEP2->QCD_FSR_forSigma(sprime);
8221
8222 return ( H*sigma );
8223}
8224
8225
8226
8227
8228//up
8229
8230
8231const double StandardModel::getIntegrand_sigmaWithISR_up130(double x) const
8232{
8233 double s = 130. * 130.;
8234 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8235}
8236
8237const double StandardModel::getIntegrand_sigmaWithISR_up133(double x) const
8238{
8239 double s = 133. * 133.;
8240 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8241}
8242
8243const double StandardModel::getIntegrand_sigmaWithISR_up136(double x) const
8244{
8245 double s = 136. * 136.;
8246 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8247}
8248
8249const double StandardModel::getIntegrand_sigmaWithISR_up161(double x) const
8250{
8251 double s = 161. * 161.;
8252 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8253}
8254
8255const double StandardModel::getIntegrand_sigmaWithISR_up167(double x) const
8256{
8257 double s = 167. * 167.;
8258 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8259}
8260
8261const double StandardModel::getIntegrand_sigmaWithISR_up172(double x) const
8262{
8263 double s = 172. * 172.;
8264 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8265}
8266
8267const double StandardModel::getIntegrand_sigmaWithISR_up183(double x) const
8268{
8269 double s = 183. * 183.;
8270 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8271}
8272
8273const double StandardModel::getIntegrand_sigmaWithISR_up189(double x) const
8274{
8275 double s = 189. * 189.;
8276 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8277}
8278
8279const double StandardModel::getIntegrand_sigmaWithISR_up192(double x) const
8280{
8281 double s = 192. * 192.;
8282 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8283}
8284
8285const double StandardModel::getIntegrand_sigmaWithISR_up196(double x) const
8286{
8287 double s = 196. * 196.;
8288 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8289}
8290
8291const double StandardModel::getIntegrand_sigmaWithISR_up200(double x) const
8292{
8293 double s = 200. * 200.;
8294 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8295}
8296
8297const double StandardModel::getIntegrand_sigmaWithISR_up202(double x) const
8298{
8299 double s = 202. * 202.;
8300 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8301}
8302
8303const double StandardModel::getIntegrand_sigmaWithISR_up205(double x) const
8304{
8305 double s = 205. * 205.;
8306 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8307}
8308
8309const double StandardModel::getIntegrand_sigmaWithISR_up207(double x) const
8310{
8311 double s = 207. * 207.;
8312 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8313}
8314
8315
8316//down
8317
8318const double StandardModel::getIntegrand_sigmaWithISR_down130(double x) const
8319{
8320 double s = 130. * 130.;
8321 return (Integrand_sigmaWithISR_q(x, QCD::quark(DOWN), s));
8322}
8323
8324const double StandardModel::getIntegrand_sigmaWithISR_down133(double x) const
8325{
8326 double s = 133. * 133.;
8327 return (Integrand_sigmaWithISR_q(x, QCD::quark(DOWN), s));
8328}
8329
8330
8331const double StandardModel::getIntegrand_sigmaWithISR_down136(double x) const
8332{
8333 double s = 136. * 136.;
8334 return (Integrand_sigmaWithISR_q(x, QCD::quark(DOWN), s));
8335}
8336
8337const double StandardModel::getIntegrand_sigmaWithISR_down161(double x) const
8338{
8339 double s = 161. * 161.;
8340 return (Integrand_sigmaWithISR_q(x, QCD::quark(DOWN), s));
8341}
8342
8343const double StandardModel::getIntegrand_sigmaWithISR_down167(double x) const
8344{
8345 double s = 167. * 167.;
8346 return (Integrand_sigmaWithISR_q(x, QCD::quark(DOWN), s));
8347}
8348
8349const double StandardModel::getIntegrand_sigmaWithISR_down172(double x) const
8350{
8351 double s = 172. * 172.;
8352 return (Integrand_sigmaWithISR_q(x, QCD::quark(DOWN), s));
8353}
8354
8355const double StandardModel::getIntegrand_sigmaWithISR_down183(double x) const
8356{
8357 double s = 183. * 183.;
8358 return (Integrand_sigmaWithISR_q(x, QCD::quark(DOWN), s));
8359}
8360
8361const double StandardModel::getIntegrand_sigmaWithISR_down189(double x) const
8362{
8363 double s = 189. * 189.;
8364 return (Integrand_sigmaWithISR_q(x, QCD::quark(DOWN), s));
8365}
8366
8367const double StandardModel::getIntegrand_sigmaWithISR_down192(double x) const
8368{
8369 double s = 192. * 192.;
8370 return (Integrand_sigmaWithISR_q(x, QCD::quark(DOWN), s));
8371}
8372
8373const double StandardModel::getIntegrand_sigmaWithISR_down196(double x) const
8374{
8375 double s = 196. * 196.;
8376 return (Integrand_sigmaWithISR_q(x, QCD::quark(DOWN), s));
8377}
8378
8379const double StandardModel::getIntegrand_sigmaWithISR_down200(double x) const
8380{
8381 double s = 200. * 200.;
8382 return (Integrand_sigmaWithISR_q(x, QCD::quark(DOWN), s));
8383}
8384
8385const double StandardModel::getIntegrand_sigmaWithISR_down202(double x) const
8386{
8387 double s = 202. * 202.;
8388 return (Integrand_sigmaWithISR_q(x, QCD::quark(DOWN), s));
8389}
8390
8391const double StandardModel::getIntegrand_sigmaWithISR_down205(double x) const
8392{
8393 double s = 205. * 205.;
8394 return (Integrand_sigmaWithISR_q(x, QCD::quark(DOWN), s));
8395}
8396
8397const double StandardModel::getIntegrand_sigmaWithISR_down207(double x) const
8398{
8399 double s = 207. * 207.;
8400 return (Integrand_sigmaWithISR_q(x, QCD::quark(DOWN), s));
8401}
8402
8403
8404//charm
8405
8406
8407const double StandardModel::getIntegrand_sigmaWithISR_charm130(double x) const
8408{
8409 double s = 130. * 130.;
8410 return (Integrand_sigmaWithISR_q(x, QCD::quark(CHARM), s));
8411}
8412
8413const double StandardModel::getIntegrand_sigmaWithISR_charm133(double x) const
8414{
8415 double s = 133. * 133.;
8416 return (Integrand_sigmaWithISR_q(x, QCD::quark(CHARM), s));
8417}
8418
8419const double StandardModel::getIntegrand_sigmaWithISR_charm136(double x) const
8420{
8421 double s = 136. * 136.;
8422 return (Integrand_sigmaWithISR_q(x, QCD::quark(CHARM), s));
8423}
8424
8425const double StandardModel::getIntegrand_sigmaWithISR_charm161(double x) const
8426{
8427 double s = 161. * 161.;
8428 return (Integrand_sigmaWithISR_q(x, QCD::quark(CHARM), s));
8429}
8430
8431const double StandardModel::getIntegrand_sigmaWithISR_charm167(double x) const
8432{
8433 double s = 167. * 167.;
8434 return (Integrand_sigmaWithISR_q(x, QCD::quark(CHARM), s));
8435}
8436
8437const double StandardModel::getIntegrand_sigmaWithISR_charm172(double x) const
8438{
8439 double s = 172. * 172.;
8440 return (Integrand_sigmaWithISR_q(x, QCD::quark(CHARM), s));
8441}
8442
8443const double StandardModel::getIntegrand_sigmaWithISR_charm183(double x) const
8444{
8445 double s = 183. * 183.;
8446 return (Integrand_sigmaWithISR_q(x, QCD::quark(CHARM), s));
8447}
8448
8449const double StandardModel::getIntegrand_sigmaWithISR_charm189(double x) const
8450{
8451 double s = 189. * 189.;
8452 return (Integrand_sigmaWithISR_q(x, QCD::quark(CHARM), s));
8453}
8454
8455const double StandardModel::getIntegrand_sigmaWithISR_charm192(double x) const
8456{
8457 double s = 192. * 192.;
8458 return (Integrand_sigmaWithISR_q(x, QCD::quark(CHARM), s));
8459}
8460
8461const double StandardModel::getIntegrand_sigmaWithISR_charm196(double x) const
8462{
8463 double s = 196. * 196.;
8464 return (Integrand_sigmaWithISR_q(x, QCD::quark(CHARM), s));
8465}
8466
8467const double StandardModel::getIntegrand_sigmaWithISR_charm200(double x) const
8468{
8469 double s = 200. * 200.;
8470 return (Integrand_sigmaWithISR_q(x, QCD::quark(CHARM), s));
8471}
8472
8473const double StandardModel::getIntegrand_sigmaWithISR_charm202(double x) const
8474{
8475 double s = 202. * 202.;
8476 return (Integrand_sigmaWithISR_q(x, QCD::quark(CHARM), s));
8477}
8478
8479const double StandardModel::getIntegrand_sigmaWithISR_charm205(double x) const
8480{
8481 double s = 205. * 205.;
8482 return (Integrand_sigmaWithISR_q(x, QCD::quark(CHARM), s));
8483}
8484
8485const double StandardModel::getIntegrand_sigmaWithISR_charm207(double x) const
8486{
8487 double s = 207. * 207.;
8488 return (Integrand_sigmaWithISR_q(x, QCD::quark(CHARM), s));
8489}
8490
8491
8492//strange
8493
8494
8495const double StandardModel::getIntegrand_sigmaWithISR_strange130(double x) const
8496{
8497 double s = 130. * 130.;
8498 return (Integrand_sigmaWithISR_q(x, QCD::quark(STRANGE), s));
8499}
8500
8501const double StandardModel::getIntegrand_sigmaWithISR_strange133(double x) const
8502{
8503 double s = 133. * 133.;
8504 return (Integrand_sigmaWithISR_q(x, QCD::quark(STRANGE), s));
8505}
8506
8507const double StandardModel::getIntegrand_sigmaWithISR_strange136(double x) const
8508{
8509 double s = 136. * 136.;
8510 return (Integrand_sigmaWithISR_q(x, QCD::quark(STRANGE), s));
8511}
8512
8513const double StandardModel::getIntegrand_sigmaWithISR_strange161(double x) const
8514{
8515 double s = 161. * 161.;
8516 return (Integrand_sigmaWithISR_q(x, QCD::quark(STRANGE), s));
8517}
8518
8519const double StandardModel::getIntegrand_sigmaWithISR_strange167(double x) const
8520{
8521 double s = 167. * 167.;
8522 return (Integrand_sigmaWithISR_q(x, QCD::quark(STRANGE), s));
8523}
8524
8525const double StandardModel::getIntegrand_sigmaWithISR_strange172(double x) const
8526{
8527 double s = 172. * 172.;
8528 return (Integrand_sigmaWithISR_q(x, QCD::quark(STRANGE), s));
8529}
8530
8531const double StandardModel::getIntegrand_sigmaWithISR_strange183(double x) const
8532{
8533 double s = 183. * 183.;
8534 return (Integrand_sigmaWithISR_q(x, QCD::quark(STRANGE), s));
8535}
8536
8537const double StandardModel::getIntegrand_sigmaWithISR_strange189(double x) const
8538{
8539 double s = 189. * 189.;
8540 return (Integrand_sigmaWithISR_q(x, QCD::quark(STRANGE), s));
8541}
8542
8543const double StandardModel::getIntegrand_sigmaWithISR_strange192(double x) const
8544{
8545 double s = 192. * 192.;
8546 return (Integrand_sigmaWithISR_q(x, QCD::quark(STRANGE), s));
8547}
8548
8549const double StandardModel::getIntegrand_sigmaWithISR_strange196(double x) const
8550{
8551 double s = 196. * 196.;
8552 return (Integrand_sigmaWithISR_q(x, QCD::quark(STRANGE), s));
8553}
8554
8555const double StandardModel::getIntegrand_sigmaWithISR_strange200(double x) const
8556{
8557 double s = 200. * 200.;
8558 return (Integrand_sigmaWithISR_q(x, QCD::quark(STRANGE), s));
8559}
8560
8561const double StandardModel::getIntegrand_sigmaWithISR_strange202(double x) const
8562{
8563 double s = 202. * 202.;
8564 return (Integrand_sigmaWithISR_q(x, QCD::quark(STRANGE), s));
8565}
8566
8567const double StandardModel::getIntegrand_sigmaWithISR_strange205(double x) const
8568{
8569 double s = 205. * 205.;
8570 return (Integrand_sigmaWithISR_q(x, QCD::quark(STRANGE), s));
8571}
8572
8573const double StandardModel::getIntegrand_sigmaWithISR_strange207(double x) const
8574{
8575 double s = 207. * 207.;
8576 return (Integrand_sigmaWithISR_q(x, QCD::quark(STRANGE), s));
8577}
8578
8579
8580//bottom
8581
8582
8583const double StandardModel::getIntegrand_sigmaWithISR_bottom130(double x) const
8584{
8585 double s = 130. * 130.;
8586 return (Integrand_sigmaWithISR_q(x, QCD::quark(BOTTOM), s));
8587}
8588
8589const double StandardModel::getIntegrand_sigmaWithISR_bottom133(double x) const
8590{
8591 double s = 133. * 133.;
8592 return (Integrand_sigmaWithISR_q(x, QCD::quark(BOTTOM), s));
8593}
8594
8595const double StandardModel::getIntegrand_sigmaWithISR_bottom136(double x) const
8596{
8597 double s = 136. * 136.;
8598 return (Integrand_sigmaWithISR_q(x, QCD::quark(BOTTOM), s));
8599}
8600
8601const double StandardModel::getIntegrand_sigmaWithISR_bottom161(double x) const
8602{
8603 double s = 161. * 161.;
8604 return (Integrand_sigmaWithISR_q(x, QCD::quark(BOTTOM), s));
8605}
8606
8607const double StandardModel::getIntegrand_sigmaWithISR_bottom167(double x) const
8608{
8609 double s = 167. * 167.;
8610 return (Integrand_sigmaWithISR_q(x, QCD::quark(BOTTOM), s));
8611}
8612
8613const double StandardModel::getIntegrand_sigmaWithISR_bottom172(double x) const
8614{
8615 double s = 172. * 172.;
8616 return (Integrand_sigmaWithISR_q(x, QCD::quark(BOTTOM), s));
8617}
8618
8619const double StandardModel::getIntegrand_sigmaWithISR_bottom183(double x) const
8620{
8621 double s = 183. * 183.;
8622 return (Integrand_sigmaWithISR_q(x, QCD::quark(BOTTOM), s));
8623}
8624
8625const double StandardModel::getIntegrand_sigmaWithISR_bottom189(double x) const
8626{
8627 double s = 189. * 189.;
8628 return (Integrand_sigmaWithISR_q(x, QCD::quark(BOTTOM), s));
8629}
8630
8631const double StandardModel::getIntegrand_sigmaWithISR_bottom192(double x) const
8632{
8633 double s = 192. * 192.;
8634 return (Integrand_sigmaWithISR_q(x, QCD::quark(BOTTOM), s));
8635}
8636
8637const double StandardModel::getIntegrand_sigmaWithISR_bottom196(double x) const
8638{
8639 double s = 196. * 196.;
8640 return (Integrand_sigmaWithISR_q(x, QCD::quark(BOTTOM), s));
8641}
8642
8643const double StandardModel::getIntegrand_sigmaWithISR_bottom200(double x) const
8644{
8645 double s = 200. * 200.;
8646 return (Integrand_sigmaWithISR_q(x, QCD::quark(BOTTOM), s));
8647}
8648
8649const double StandardModel::getIntegrand_sigmaWithISR_bottom202(double x) const
8650{
8651 double s = 202. * 202.;
8652 return (Integrand_sigmaWithISR_q(x, QCD::quark(BOTTOM), s));
8653}
8654
8655const double StandardModel::getIntegrand_sigmaWithISR_bottom205(double x) const
8656{
8657 double s = 205. * 205.;
8658 return (Integrand_sigmaWithISR_q(x, QCD::quark(BOTTOM), s));
8659}
8660
8661const double StandardModel::getIntegrand_sigmaWithISR_bottom207(double x) const
8662{
8663 double s = 207. * 207.;
8664 return (Integrand_sigmaWithISR_q(x, QCD::quark(BOTTOM), s));
8665}
8666
8667
8668
8669
8670
8671const double StandardModel::Integrand_dsigmaBox_l(double cosTheta, const QCD::lepton l_flavor, const double s) const
8672{
8673 double ml = getLeptons(l_flavor).getMass();
8674 return ( myTwoFermionsLEP2->dsigma_l_box(l_flavor, ml, s, cosTheta, Mw(), Gamma_Z()) );
8675}
8676
8677const double StandardModel::getIntegrand_dsigmaBox_mu130(double x) const
8678{
8679 double s = 130. * 130.;
8680 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8681}
8682
8683const double StandardModel::getIntegrand_dsigmaBox_mu136(double x) const
8684{
8685 double s = 136. * 136.;
8686 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8687}
8688
8689const double StandardModel::getIntegrand_dsigmaBox_mu161(double x) const
8690{
8691 double s = 161. * 161.;
8692 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8693}
8694
8695const double StandardModel::getIntegrand_dsigmaBox_mu172(double x) const
8696{
8697 double s = 172. * 172.;
8698 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8699}
8700
8701const double StandardModel::getIntegrand_dsigmaBox_mu183(double x) const
8702{
8703 double s = 183. * 183.;
8704 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8705}
8706
8707const double StandardModel::getIntegrand_dsigmaBox_mu189(double x) const
8708{
8709 double s = 189. * 189.;
8710 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8711}
8712
8713const double StandardModel::getIntegrand_dsigmaBox_mu192(double x) const
8714{
8715 double s = 192. * 192.;
8716 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8717}
8718
8719const double StandardModel::getIntegrand_dsigmaBox_mu196(double x) const
8720{
8721 double s = 196. * 196.;
8722 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8723}
8724
8725const double StandardModel::getIntegrand_dsigmaBox_mu200(double x) const
8726{
8727 double s = 200. * 200.;
8728 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8729}
8730
8731const double StandardModel::getIntegrand_dsigmaBox_mu202(double x) const
8732{
8733 double s = 202. * 202.;
8734 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8735}
8736
8737const double StandardModel::getIntegrand_dsigmaBox_mu205(double x) const
8738{
8739 double s = 205. * 205.;
8740 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8741}
8742
8743const double StandardModel::getIntegrand_dsigmaBox_mu207(double x) const
8744{
8745 double s = 207. * 207.;
8746 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8747}
8748
8749
8750
8751
8752
8753const double StandardModel::getIntegrand_dsigmaBox_tau130(double x) const
8754{
8755 double s = 130. * 130.;
8756 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8757}
8758
8759const double StandardModel::getIntegrand_dsigmaBox_tau136(double x) const
8760{
8761 double s = 136. * 136.;
8762 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8763}
8764
8765const double StandardModel::getIntegrand_dsigmaBox_tau161(double x) const
8766{
8767 double s = 161. * 161.;
8768 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8769}
8770
8771const double StandardModel::getIntegrand_dsigmaBox_tau172(double x) const
8772{
8773 double s = 172. * 172.;
8774 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8775}
8776
8777const double StandardModel::getIntegrand_dsigmaBox_tau183(double x) const
8778{
8779 double s = 183. * 183.;
8780 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8781}
8782
8783const double StandardModel::getIntegrand_dsigmaBox_tau189(double x) const
8784{
8785 double s = 189. * 189.;
8786 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8787}
8788
8789const double StandardModel::getIntegrand_dsigmaBox_tau192(double x) const
8790{
8791 double s = 192. * 192.;
8792 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8793}
8794
8795const double StandardModel::getIntegrand_dsigmaBox_tau196(double x) const
8796{
8797 double s = 196. * 196.;
8798 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8799}
8800
8801const double StandardModel::getIntegrand_dsigmaBox_tau200(double x) const
8802{
8803 double s = 200. * 200.;
8804 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8805}
8806
8807const double StandardModel::getIntegrand_dsigmaBox_tau202(double x) const
8808{
8809 double s = 202. * 202.;
8810 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8811}
8812
8813const double StandardModel::getIntegrand_dsigmaBox_tau205(double x) const
8814{
8815 double s = 205. * 205.;
8816 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8817}
8818
8819const double StandardModel::getIntegrand_dsigmaBox_tau207(double x) const
8820{
8821 double s = 207. * 207.;
8822 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8823}
8824
8825
8826
8827
8828
8829
8830const double StandardModel::Integrand_dsigmaBox_q(double cosTheta, const QCD::quark q_flavor, const double s) const
8831{
8832 double mq = m_q(q_flavor, sqrt(s));
8833 return ( myTwoFermionsLEP2->dsigma_q_box(q_flavor, mq, s, cosTheta, Mw(), Gamma_Z()) );
8834}
8835
8836
8837
8838
8839//up
8840
8841
8842const double StandardModel::getIntegrand_dsigmaBox_up130(double x) const
8843{
8844 double s = 130. * 130.;
8845 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8846}
8847
8848const double StandardModel::getIntegrand_dsigmaBox_up133(double x) const
8849{
8850 double s = 133. * 133.;
8851 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8852}
8853
8854const double StandardModel::getIntegrand_dsigmaBox_up136(double x) const
8855{
8856 double s = 136. * 136.;
8857 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8858}
8859
8860const double StandardModel::getIntegrand_dsigmaBox_up161(double x) const
8861{
8862 double s = 161. * 161.;
8863 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8864}
8865
8866const double StandardModel::getIntegrand_dsigmaBox_up167(double x) const
8867{
8868 double s = 167. * 167.;
8869 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8870}
8871
8872const double StandardModel::getIntegrand_dsigmaBox_up172(double x) const
8873{
8874 double s = 172. * 172.;
8875 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8876}
8877
8878const double StandardModel::getIntegrand_dsigmaBox_up183(double x) const
8879{
8880 double s = 183. * 183.;
8881 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8882}
8883
8884const double StandardModel::getIntegrand_dsigmaBox_up189(double x) const
8885{
8886 double s = 189. * 189.;
8887 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8888}
8889
8890const double StandardModel::getIntegrand_dsigmaBox_up192(double x) const
8891{
8892 double s = 192. * 192.;
8893 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8894}
8895
8896const double StandardModel::getIntegrand_dsigmaBox_up196(double x) const
8897{
8898 double s = 196. * 196.;
8899 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8900}
8901
8902const double StandardModel::getIntegrand_dsigmaBox_up200(double x) const
8903{
8904 double s = 200. * 200.;
8905 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8906}
8907
8908const double StandardModel::getIntegrand_dsigmaBox_up202(double x) const
8909{
8910 double s = 202. * 202.;
8911 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8912}
8913
8914const double StandardModel::getIntegrand_dsigmaBox_up205(double x) const
8915{
8916 double s = 205. * 205.;
8917 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8918}
8919
8920const double StandardModel::getIntegrand_dsigmaBox_up207(double x) const
8921{
8922 double s = 207. * 207.;
8923 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8924}
8925
8926
8927//down
8928
8929const double StandardModel::getIntegrand_dsigmaBox_down130(double x) const
8930{
8931 double s = 130. * 130.;
8932 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8933}
8934
8935const double StandardModel::getIntegrand_dsigmaBox_down133(double x) const
8936{
8937 double s = 133. * 133.;
8938 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8939}
8940
8941const double StandardModel::getIntegrand_dsigmaBox_down136(double x) const
8942{
8943 double s = 136. * 136.;
8944 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8945}
8946
8947const double StandardModel::getIntegrand_dsigmaBox_down161(double x) const
8948{
8949 double s = 161. * 161.;
8950 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8951}
8952
8953const double StandardModel::getIntegrand_dsigmaBox_down167(double x) const
8954{
8955 double s = 167. * 167.;
8956 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8957}
8958
8959const double StandardModel::getIntegrand_dsigmaBox_down172(double x) const
8960{
8961 double s = 172. * 172.;
8962 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8963}
8964
8965const double StandardModel::getIntegrand_dsigmaBox_down183(double x) const
8966{
8967 double s = 183. * 183.;
8968 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8969}
8970
8971const double StandardModel::getIntegrand_dsigmaBox_down189(double x) const
8972{
8973 double s = 189. * 189.;
8974 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8975}
8976
8977const double StandardModel::getIntegrand_dsigmaBox_down192(double x) const
8978{
8979 double s = 192. * 192.;
8980 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8981}
8982
8983const double StandardModel::getIntegrand_dsigmaBox_down196(double x) const
8984{
8985 double s = 196. * 196.;
8986 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8987}
8988
8989const double StandardModel::getIntegrand_dsigmaBox_down200(double x) const
8990{
8991 double s = 200. * 200.;
8992 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8993}
8994
8995const double StandardModel::getIntegrand_dsigmaBox_down202(double x) const
8996{
8997 double s = 202. * 202.;
8998 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8999}
9000
9001const double StandardModel::getIntegrand_dsigmaBox_down205(double x) const
9002{
9003 double s = 205. * 205.;
9004 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
9005}
9006
9007const double StandardModel::getIntegrand_dsigmaBox_down207(double x) const
9008{
9009 double s = 207. * 207.;
9010 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
9011}
9012
9013
9014//charm
9015
9016
9017const double StandardModel::getIntegrand_dsigmaBox_charm130(double x) const
9018{
9019 double s = 130. * 130.;
9020 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9021}
9022
9023const double StandardModel::getIntegrand_dsigmaBox_charm133(double x) const
9024{
9025 double s = 133. * 133.;
9026 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9027}
9028
9029const double StandardModel::getIntegrand_dsigmaBox_charm136(double x) const
9030{
9031 double s = 136. * 136.;
9032 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9033}
9034
9035const double StandardModel::getIntegrand_dsigmaBox_charm161(double x) const
9036{
9037 double s = 161. * 161.;
9038 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9039}
9040
9041const double StandardModel::getIntegrand_dsigmaBox_charm167(double x) const
9042{
9043 double s = 167. * 167.;
9044 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9045}
9046
9047const double StandardModel::getIntegrand_dsigmaBox_charm172(double x) const
9048{
9049 double s = 172. * 172.;
9050 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9051}
9052
9053const double StandardModel::getIntegrand_dsigmaBox_charm183(double x) const
9054{
9055 double s = 183. * 183.;
9056 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9057}
9058
9059const double StandardModel::getIntegrand_dsigmaBox_charm189(double x) const
9060{
9061 double s = 189. * 189.;
9062 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9063}
9064
9065const double StandardModel::getIntegrand_dsigmaBox_charm192(double x) const
9066{
9067 double s = 192. * 192.;
9068 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9069}
9070
9071const double StandardModel::getIntegrand_dsigmaBox_charm196(double x) const
9072{
9073 double s = 196. * 196.;
9074 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9075}
9076
9077const double StandardModel::getIntegrand_dsigmaBox_charm200(double x) const
9078{
9079 double s = 200. * 200.;
9080 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9081}
9082
9083const double StandardModel::getIntegrand_dsigmaBox_charm202(double x) const
9084{
9085 double s = 202. * 202.;
9086 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9087}
9088
9089const double StandardModel::getIntegrand_dsigmaBox_charm205(double x) const
9090{
9091 double s = 205. * 205.;
9092 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9093}
9094
9095const double StandardModel::getIntegrand_dsigmaBox_charm207(double x) const
9096{
9097 double s = 207. * 207.;
9098 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9099}
9100
9101
9102//strange
9103
9104
9105const double StandardModel::getIntegrand_dsigmaBox_strange130(double x) const
9106{
9107 double s = 130. * 130.;
9108 return (Integrand_dsigmaBox_q(x, QCD::quark(STRANGE), s));
9109}
9110
9111const double StandardModel::getIntegrand_dsigmaBox_strange133(double x) const
9112{
9113 double s = 133. * 133.;
9114 return (Integrand_dsigmaBox_q(x, QCD::quark(STRANGE), s));
9115}
9116
9117const double StandardModel::getIntegrand_dsigmaBox_strange136(double x) const
9118{
9119 double s = 136. * 136.;
9120 return (Integrand_dsigmaBox_q(x, QCD::quark(STRANGE), s));
9121}
9122
9123const double StandardModel::getIntegrand_dsigmaBox_strange161(double x) const
9124{
9125 double s = 161. * 161.;
9126 return (Integrand_dsigmaBox_q(x, QCD::quark(STRANGE), s));
9127}
9128
9129const double StandardModel::getIntegrand_dsigmaBox_strange167(double x) const
9130{
9131 double s = 167. * 167.;
9132 return (Integrand_dsigmaBox_q(x, QCD::quark(STRANGE), s));
9133}
9134
9135
9136
9137const double StandardModel::getIntegrand_dsigmaBox_strange172(double x) const
9138{
9139 double s = 172. * 172.;
9140 return (Integrand_dsigmaBox_q(x, QCD::quark(STRANGE), s));
9141}
9142
9143const double StandardModel::getIntegrand_dsigmaBox_strange183(double x) const
9144{
9145 double s = 183. * 183.;
9146 return (Integrand_dsigmaBox_q(x, QCD::quark(STRANGE), s));
9147}
9148
9149const double StandardModel::getIntegrand_dsigmaBox_strange189(double x) const
9150{
9151 double s = 189. * 189.;
9152 return (Integrand_dsigmaBox_q(x, QCD::quark(STRANGE), s));
9153}
9154
9155const double StandardModel::getIntegrand_dsigmaBox_strange192(double x) const
9156{
9157 double s = 192. * 192.;
9158 return (Integrand_dsigmaBox_q(x, QCD::quark(STRANGE), s));
9159}
9160
9161const double StandardModel::getIntegrand_dsigmaBox_strange196(double x) const
9162{
9163 double s = 196. * 196.;
9164 return (Integrand_dsigmaBox_q(x, QCD::quark(STRANGE), s));
9165}
9166
9167const double StandardModel::getIntegrand_dsigmaBox_strange200(double x) const
9168{
9169 double s = 200. * 200.;
9170 return (Integrand_dsigmaBox_q(x, QCD::quark(STRANGE), s));
9171}
9172
9173const double StandardModel::getIntegrand_dsigmaBox_strange202(double x) const
9174{
9175 double s = 202. * 202.;
9176 return (Integrand_dsigmaBox_q(x, QCD::quark(STRANGE), s));
9177}
9178
9179const double StandardModel::getIntegrand_dsigmaBox_strange205(double x) const
9180{
9181 double s = 205. * 205.;
9182 return (Integrand_dsigmaBox_q(x, QCD::quark(STRANGE), s));
9183}
9184
9185const double StandardModel::getIntegrand_dsigmaBox_strange207(double x) const
9186{
9187 double s = 207. * 207.;
9188 return (Integrand_dsigmaBox_q(x, QCD::quark(STRANGE), s));
9189}
9190
9191
9192//bottom
9193
9194
9195const double StandardModel::getIntegrand_dsigmaBox_bottom130(double x) const
9196{
9197 double s = 130. * 130.;
9198 return (Integrand_dsigmaBox_q(x, QCD::quark(BOTTOM), s));
9199}
9200
9201const double StandardModel::getIntegrand_dsigmaBox_bottom133(double x) const
9202{
9203 double s = 133. * 133.;
9204 return (Integrand_dsigmaBox_q(x, QCD::quark(BOTTOM), s));
9205}
9206
9207const double StandardModel::getIntegrand_dsigmaBox_bottom136(double x) const
9208{
9209 double s = 136. * 136.;
9210 return (Integrand_dsigmaBox_q(x, QCD::quark(BOTTOM), s));
9211}
9212
9213const double StandardModel::getIntegrand_dsigmaBox_bottom161(double x) const
9214{
9215 double s = 161. * 161.;
9216 return (Integrand_dsigmaBox_q(x, QCD::quark(BOTTOM), s));
9217}
9218
9219const double StandardModel::getIntegrand_dsigmaBox_bottom167(double x) const
9220{
9221 double s = 167. * 167.;
9222 return (Integrand_dsigmaBox_q(x, QCD::quark(BOTTOM), s));
9223}
9224
9225const double StandardModel::getIntegrand_dsigmaBox_bottom172(double x) const
9226{
9227 double s = 172. * 172.;
9228 return (Integrand_dsigmaBox_q(x, QCD::quark(BOTTOM), s));
9229}
9230
9231const double StandardModel::getIntegrand_dsigmaBox_bottom183(double x) const
9232{
9233 double s = 183. * 183.;
9234 return (Integrand_dsigmaBox_q(x, QCD::quark(BOTTOM), s));
9235}
9236
9237const double StandardModel::getIntegrand_dsigmaBox_bottom189(double x) const
9238{
9239 double s = 189. * 189.;
9240 return (Integrand_dsigmaBox_q(x, QCD::quark(BOTTOM), s));
9241}
9242
9243const double StandardModel::getIntegrand_dsigmaBox_bottom192(double x) const
9244{
9245 double s = 192. * 192.;
9246 return (Integrand_dsigmaBox_q(x, QCD::quark(BOTTOM), s));
9247}
9248
9249const double StandardModel::getIntegrand_dsigmaBox_bottom196(double x) const
9250{
9251 double s = 196. * 196.;
9252 return (Integrand_dsigmaBox_q(x, QCD::quark(BOTTOM), s));
9253}
9254
9255const double StandardModel::getIntegrand_dsigmaBox_bottom200(double x) const
9256{
9257 double s = 200. * 200.;
9258 return (Integrand_dsigmaBox_q(x, QCD::quark(BOTTOM), s));
9259}
9260
9261const double StandardModel::getIntegrand_dsigmaBox_bottom202(double x) const
9262{
9263 double s = 202. * 202.;
9264 return (Integrand_dsigmaBox_q(x, QCD::quark(BOTTOM), s));
9265}
9266
9267const double StandardModel::getIntegrand_dsigmaBox_bottom205(double x) const
9268{
9269 double s = 205. * 205.;
9270 return (Integrand_dsigmaBox_q(x, QCD::quark(BOTTOM), s));
9271}
9272
9273const double StandardModel::getIntegrand_dsigmaBox_bottom207(double x) const
9274{
9275 double s = 207. * 207.;
9276 return (Integrand_dsigmaBox_q(x, QCD::quark(BOTTOM), s));
9277}
9278
9279
9280
9281
9282
9283
9284
9285
9286
9287
9288
9289
9290
9291const double StandardModel::Integrand_AFBnumeratorWithISR_l(double x, const QCD::lepton l_flavor, const double s) const
9292{
9293 double sprime = (1.0 - x)*s;
9294 double Ncf = 1.0;
9295 double ml = getLeptons(l_flavor).getMass();
9296 double G3prime = myTwoFermionsLEP2->G_3prime_l(l_flavor, ml, sprime, Mw(), Gamma_Z(),flagLEP2[Weak]);
9297 double H = myTwoFermionsLEP2->H_ISR_FB(x, s);
9298
9299 return ( M_PI*ale*ale*Ncf*H*G3prime/sprime );
9300}
9301
9302
9303 const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu130(double x) const
9304{
9305 double s = 130. * 130.;
9306 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(MU), s));
9307}
9308
9309const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu136(double x) const
9310{
9311 double s = 136. * 136.;
9312 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(MU), s));
9313}
9314
9315const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu161(double x) const
9316{
9317 double s = 161. * 161.;
9318 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(MU), s));
9319}
9320
9321const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu172(double x) const
9322{
9323 double s = 172. * 172.;
9324 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(MU), s));
9325}
9326
9327const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu183(double x) const
9328{
9329 double s = 183. * 183.;
9330 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(MU), s));
9331}
9332
9333const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu189(double x) const
9334{
9335 double s = 189. * 189.;
9336 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(MU), s));
9337}
9338
9339const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu192(double x) const
9340{
9341 double s = 192. * 192.;
9342 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(MU), s));
9343}
9344
9345const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu196(double x) const
9346{
9347 double s = 196. * 196.;
9348 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(MU), s));
9349}
9350
9351const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu200(double x) const
9352{
9353 double s = 200. * 200.;
9354 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(MU), s));
9355}
9356
9357const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu202(double x) const
9358{
9359 double s = 202. * 202.;
9360 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(MU), s));
9361}
9362
9363const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu205(double x) const
9364{
9365 double s = 205. * 205.;
9366 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(MU), s));
9367}
9368
9369const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu207(double x) const
9370{
9371 double s = 207. * 207.;
9372 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(MU), s));
9373}
9374
9375
9376const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau130(double x) const
9377{
9378 double s = 130. * 130.;
9379 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(TAU), s));
9380}
9381
9382const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau136(double x) const
9383{
9384 double s = 136. * 136.;
9385 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(TAU), s));
9386}
9387
9388const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau161(double x) const
9389{
9390 double s = 161. * 161.;
9391 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(TAU), s));
9392}
9393
9394const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau172(double x) const
9395{
9396 double s = 172. * 172.;
9397 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(TAU), s));
9398}
9399
9400const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau183(double x) const
9401{
9402 double s = 183. * 183.;
9403 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(TAU), s));
9404}
9405
9406const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau189(double x) const
9407{
9408 double s = 189. * 189.;
9409 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(TAU), s));
9410}
9411
9412const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau192(double x) const
9413{
9414 double s = 192. * 192.;
9415 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(TAU), s));
9416}
9417
9418const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau196(double x) const
9419{
9420 double s = 196. * 196.;
9421 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(TAU), s));
9422}
9423
9424const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau200(double x) const
9425{
9426 double s = 200. * 200.;
9427 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(TAU), s));
9428}
9429
9430const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau202(double x) const
9431{
9432 double s = 202. * 202.;
9433 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(TAU), s));
9434}
9435
9436const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau205(double x) const
9437{
9438 double s = 205. * 205.;
9439 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(TAU), s));
9440}
9441
9442const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau207(double x) const
9443{
9444 double s = 207. * 207.;
9445 return (Integrand_AFBnumeratorWithISR_l(x, QCD::lepton(TAU), s));
9446}
9447
9448
9449
9450const double StandardModel::Integrand_AFBnumeratorWithISR_q(double x, const QCD::quark q_flavor, const double s) const
9451{
9452 double sprime = (1.0 - x)*s;
9453 double Ncf = 3.0;
9454 double mq = m_q(q_flavor, sqrt(s));
9455 double G3prime = myTwoFermionsLEP2->G_3prime_q(q_flavor, mq, sprime, Mw(), Gamma_Z(),flagLEP2[Weak]);
9456 double H = myTwoFermionsLEP2->H_ISR_FB(x, s);
9457
9458 if (flagLEP2[QCDFSR])
9459 G3prime *= myTwoFermionsLEP2->QCD_FSR_forAFB(q_flavor, mq, sprime);
9460
9461 return ( M_PI*ale*ale*Ncf*H*G3prime/sprime );
9462}
9463
9464
9465const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm133(double x) const
9466{
9467 double s = 133. * 133.;
9468 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(CHARM), s));
9469}
9470
9471const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm167(double x) const
9472{
9473 double s = 167. * 167.;
9474 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(CHARM), s));
9475}
9476
9477const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm172(double x) const
9478{
9479 double s = 172. * 172.;
9480 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(CHARM), s));
9481}
9482
9483const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm183(double x) const
9484{
9485 double s = 183. * 183.;
9486 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(CHARM), s));
9487}
9488
9489const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm189(double x) const
9490{
9491 double s = 189. * 189.;
9492 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(CHARM), s));
9493}
9494
9495const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm192(double x) const
9496{
9497 double s = 192. * 192.;
9498 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(CHARM), s));
9499}
9500
9501const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm196(double x) const
9502{
9503 double s = 196. * 196.;
9504 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(CHARM), s));
9505}
9506
9507const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm200(double x) const
9508{
9509 double s = 200. * 200.;
9510 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(CHARM), s));
9511}
9512
9513const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm202(double x) const
9514{
9515 double s = 202. * 202.;
9516 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(CHARM), s));
9517}
9518
9519const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm205(double x) const
9520{
9521 double s = 205. * 205.;
9522 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(CHARM), s));
9523}
9524
9525const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm207(double x) const
9526{
9527 double s = 207. * 207.;
9528 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(CHARM), s));
9529}
9530
9531
9532
9533
9534const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom133(double x) const
9535{
9536 double s = 133. * 133.;
9537 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(BOTTOM), s));
9538}
9539
9540const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom167(double x) const
9541{
9542 double s = 167. * 167.;
9543 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(BOTTOM), s));
9544}
9545
9546const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom172(double x) const
9547{
9548 double s = 172. * 172.;
9549 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(BOTTOM), s));
9550}
9551
9552const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom183(double x) const
9553{
9554 double s = 183. * 183.;
9555 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(BOTTOM), s));
9556}
9557
9558const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom189(double x) const
9559{
9560 double s = 189. * 189.;
9561 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(BOTTOM), s));
9562}
9563
9564const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom192(double x) const
9565{
9566 double s = 192. * 192.;
9567 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(BOTTOM), s));
9568}
9569
9570const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom196(double x) const
9571{
9572 double s = 196. * 196.;
9573 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(BOTTOM), s));
9574}
9575
9576const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom200(double x) const
9577{
9578 double s = 200. * 200.;
9579 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(BOTTOM), s));
9580}
9581
9582const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom202(double x) const
9583{
9584 double s = 202. * 202.;
9585 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(BOTTOM), s));
9586}
9587
9588const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom205(double x) const
9589{
9590 double s = 205. * 205.;
9591 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(BOTTOM), s));
9592}
9593
9594const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom207(double x) const
9595{
9596 double s = 207. * 207.;
9597 return (Integrand_AFBnumeratorWithISR_q(x, QCD::quark(BOTTOM), s));
9598}
9599
9600
9601
9602// LEP2 differential observables
9603
9604const double StandardModel::LEP2dsigmadcosE(const double s, const double cos) const
9605{
9606 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
9607 if (!IsFlagNoApproximateGammaZ()){
9608
9609 /* SM contribution with the approximate formula */
9610 return (myApproximateFormulae->LEP2dsigmadcosEApprox(s, cos));
9611
9612 } else {
9613 throw std::runtime_error("ERROR: StandardModel::LEP2dsigmadcosE only implemented via semi-analytical approx");
9614 }
9615}
9616
9617const double StandardModel::LEP2dsigmadcosMu(double s, double cos) const
9618{
9619 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
9620 if (!IsFlagNoApproximateGammaZ()){
9621
9622 /* SM contribution with the approximate formula */
9623 return (myApproximateFormulae->LEP2dsigmadcosMuApprox(s, cos));
9624
9625 } else {
9626 throw std::runtime_error("ERROR: StandardModel::LEP2dsigmadcosMu only implemented via semi-analytical approx");
9627 }
9628}
9629
9630const double StandardModel::LEP2dsigmadcosTau(double s, double cos) const
9631{
9632 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
9633 if (!IsFlagNoApproximateGammaZ()){
9634
9635 /* SM contribution with the approximate formula */
9636 return (myApproximateFormulae->LEP2dsigmadcosTauApprox(s, cos));
9637
9638 } else {
9639 throw std::runtime_error("ERROR: StandardModel::LEP2dsigmadcosTau only implemented via semi-analytical approx");
9640 }
9641}
9642
9643
9644// LEP2 differential observables: Defined in bins. SM prediction given already by the above
9645
9646const double StandardModel::LEP2dsigmadcosBinE(const double s, const double cos, const double cosmin, const double cosmax) const
9647{
9648 return LEP2dsigmadcosE(s, cos);
9649}
9650
9651const double StandardModel::LEP2dsigmadcosBinMu(double s, double cos, const double cosmin, const double cosmax) const
9652{
9653 return LEP2dsigmadcosMu(s, cos);
9654}
9655
9656const double StandardModel::LEP2dsigmadcosBinTau(double s, double cos, const double cosmin, const double cosmax) const
9657{
9658 return LEP2dsigmadcosTau(s, cos);
9659}
9660
9661
9662/* 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:373
Flavour::setFlag
bool setFlag(const std::string name, const bool value)
Definition: Flavour.cpp:37
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:8355
StandardModel::LEP2sigmaCharm
virtual const double LEP2sigmaCharm(const double s) const
Definition: StandardModel/src/StandardModel.cpp:4603
StandardModel::dAle5Mz
double dAle5Mz
The five-flavour hadronic contribution to the electromagnetic coupling, , used as input for FlagMWinp...
Definition: StandardModel.h:3450
StandardModel::myThreeLoopEW
EWSMThreeLoopEW * myThreeLoopEW
A pointer to an object of type EWSMThreeLoopEW.
Definition: StandardModel.h:4020
StandardModel::getIntegrand_dsigmaBox_strange167
const double getIntegrand_dsigmaBox_strange167(double x) const
Definition: StandardModel/src/StandardModel.cpp:9129
StandardModel::dAl5hMz
double dAl5hMz
The five-flavour hadronic contribution to the electromagnetic coupling, . (Non-input parameter)
Definition: StandardModel.h:3474
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:2133
StandardModel::getIntegrand_sigmaWithISR_strange167
const double getIntegrand_sigmaWithISR_strange167(double x) const
Definition: StandardModel/src/StandardModel.cpp:8519
StandardModel::delSin2th_b
double delSin2th_b
The theoretical uncertainty in , denoted as .
Definition: StandardModel.h:3455
StandardModel::GammaHtoZZstar
virtual const double GammaHtoZZstar() const
The in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3394
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:3344
StandardModel::Vub
double Vub
used as an input for FlagWolfenstein = FALSE
Definition: StandardModel.h:3468
StandardModel::BrHtocc
virtual const double BrHtocc() const
The Br in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3681
StandardModel::taub
double taub() const
Top-mass corrections to the vertex, denoted by .
Definition: StandardModel/src/StandardModel.cpp:2113
StandardModel::SMvars
static std::string SMvars[NSMvars]
A string array containing the labels of the model parameters in StandardModel.
Definition: StandardModel.h:544
StandardModel::MRL2eeff
const double MRL2eeff(const Particle f, const double s) const
Definition: StandardModel/src/StandardModel.cpp:3754
StandardModel::getIntegrand_sigmaWithISR_strange189
const double getIntegrand_sigmaWithISR_strange189(double x) const
Definition: StandardModel/src/StandardModel.cpp:8537
StandardModel::getIntegrand_dsigmaBox_mu200
const double getIntegrand_dsigmaBox_mu200(double x) const
Definition: StandardModel/src/StandardModel.cpp:8725
StandardModel::A
double A
The CKM parameter in the Wolfenstein parameterization.
Definition: StandardModel.h:3462
StandardModel::getIntegrand_sigmaWithISR_strange161
const double getIntegrand_sigmaWithISR_strange161(double x) const
Definition: StandardModel/src/StandardModel.cpp:8513
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:1351
StandardModel::getMyEWSMcache
EWSMcache * getMyEWSMcache() const
A get method to retrieve the member pointer of type EWSMcache.
Definition: StandardModel.h:974
StandardModel::requireCKM
bool requireCKM
An internal flag to control whether the CKM matrix has to be recomputed.
Definition: StandardModel.h:3714
StandardModel::GammaHtotautau
virtual const double GammaHtotautau() const
The in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3540
StandardModel::getIntegrand_AFBnumeratorWithISR_tau130
const double getIntegrand_AFBnumeratorWithISR_tau130(double x) const
Definition: StandardModel/src/StandardModel.cpp:9376
StandardModel::GammaZ
virtual const double GammaZ(const Particle f) const
The partial decay width, .
Definition: StandardModel/src/StandardModel.cpp:1357
StandardModel::uovers2
const double uovers2(const double cosmin, const double cosmax) const
Definition: StandardModel/src/StandardModel.cpp:3916
StandardModel::computeCKM
virtual void computeCKM()
The method to compute the CKM matrix.
Definition: StandardModel/src/StandardModel.cpp:376
StandardModel::getIntegrand_AFBnumeratorWithISR_charm133
const double getIntegrand_AFBnumeratorWithISR_charm133(double x) const
Definition: StandardModel/src/StandardModel.cpp:9465
StandardModel::getIntegrand_sigmaWithISR_charm192
const double getIntegrand_sigmaWithISR_charm192(double x) const
Definition: StandardModel/src/StandardModel.cpp:8455
StandardModel::getIntegrand_AFBnumeratorWithISR_tau200
const double getIntegrand_AFBnumeratorWithISR_tau200(double x) const
Definition: StandardModel/src/StandardModel.cpp:9424
StandardModel::gamma
double gamma
used as an input for FlagWolfenstein = FALSE
Definition: StandardModel.h:3469
StandardModel::Vud
double Vud
used as an input for FlagWolfenstein = FALSE and FlagUseVud = TRUE
Definition: StandardModel.h:3466
StandardModel::getIntegrand_dsigmaBox_up130
const double getIntegrand_dsigmaBox_up130(double x) const
Definition: StandardModel/src/StandardModel.cpp:8842
StandardModel::getIntegrand_dsigmaBox_down207
const double getIntegrand_dsigmaBox_down207(double x) const
Definition: StandardModel/src/StandardModel.cpp:9007
StandardModel::BrHtoZZstar
virtual const double BrHtoZZstar() const
The Br in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3651
StandardModel::getIntegrand_dsigmaBox_tau136
const double getIntegrand_dsigmaBox_tau136(double x) const
Definition: StandardModel/src/StandardModel.cpp:8759
StandardModel::IsFlagNoApproximateGammaZ
const bool IsFlagNoApproximateGammaZ() const
A method to retrieve the model flag NoApproximateGammaZ.
Definition: StandardModel.h:679
StandardModel::PreUpdate
virtual bool PreUpdate()
The pre-update method for StandardModel.
Definition: StandardModel/src/StandardModel.cpp:214
StandardModel::getIntegrand_AFBnumeratorWithISR_mu192
const double getIntegrand_AFBnumeratorWithISR_mu192(double x) const
Definition: StandardModel/src/StandardModel.cpp:9339
StandardModel::getIntegrand_sigmaWithISR_tau207
const double getIntegrand_sigmaWithISR_tau207(double x) const
Definition: StandardModel/src/StandardModel.cpp:8201
StandardModel::getLeptons
const Particle & getLeptons(const QCD::lepton p) const
A get method to retrieve the member object of a lepton.
Definition: StandardModel.h:744
StandardModel::getIntegrand_AFBnumeratorWithISR_bottom192
const double getIntegrand_AFBnumeratorWithISR_bottom192(double x) const
Definition: StandardModel/src/StandardModel.cpp:9564
StandardModel::getIntegrand_dsigmaBox_down200
const double getIntegrand_dsigmaBox_down200(double x) const
Definition: StandardModel/src/StandardModel.cpp:8989
StandardModel::tovers2
const double tovers2(const double cosmin, const double cosmax) const
Definition: StandardModel/src/StandardModel.cpp:3912
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:3308
StandardModel::getIntegrand_dsigmaBox_strange172
const double getIntegrand_dsigmaBox_strange172(double x) const
Definition: StandardModel/src/StandardModel.cpp:9137
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:1097
StandardModel::getIntegrand_dsigmaBox_mu207
const double getIntegrand_dsigmaBox_mu207(double x) const
Definition: StandardModel/src/StandardModel.cpp:8743
StandardModel::~StandardModel
virtual ~StandardModel()
The default destructor.
Definition: StandardModel/src/StandardModel.cpp:152
StandardModel::LEP2sigmaHadron
virtual const double LEP2sigmaHadron(const double s) const
Definition: StandardModel/src/StandardModel.cpp:5025
StandardModel::getIntegrand_dsigmaBox_up202
const double getIntegrand_dsigmaBox_up202(double x) const
Definition: StandardModel/src/StandardModel.cpp:8908
StandardModel::getIntegrand_sigmaWithISR_down192
const double getIntegrand_sigmaWithISR_down192(double x) const
Definition: StandardModel/src/StandardModel.cpp:8367
StandardModel::FlagRhoZ
std::string FlagRhoZ
A string for the model flag RhoZ.
Definition: StandardModel.h:4030
StandardModel::getIntegrand_AFBnumeratorWithISR_mu207
const double getIntegrand_AFBnumeratorWithISR_mu207(double x) const
Definition: StandardModel/src/StandardModel.cpp:9369
StandardModel::BrHtomumu
virtual const double BrHtomumu() const
The Br in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3671
StandardModel::getIntegrand_dsigmaBox_strange130
const double getIntegrand_dsigmaBox_strange130(double x) const
Definition: StandardModel/src/StandardModel.cpp:9105
StandardModel::getIntegrand_AFBnumeratorWithISR_charm183
const double getIntegrand_AFBnumeratorWithISR_charm183(double x) const
Definition: StandardModel/src/StandardModel.cpp:9483
StandardModel::LEP2sigmaTau
virtual const double LEP2sigmaTau(const double s) const
Definition: StandardModel/src/StandardModel.cpp:4345
StandardModel::Mz
double Mz
The mass of the boson in GeV.
Definition: StandardModel.h:3446
StandardModel::myThreeLoopQCD
EWSMThreeLoopQCD * myThreeLoopQCD
A pointer to an object of type EWSMThreeLoopQCD.
Definition: StandardModel.h:4017
StandardModel::TauLFU_gtaugmuPi
virtual const double TauLFU_gtaugmuPi() const
The computation of the LFU ratio .
Definition: StandardModel/src/StandardModel.cpp:3235
StandardModel::GammaHtogaga
virtual const double GammaHtogaga() const
The in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3485
StandardModel::getIntegrand_AFBnumeratorWithISR_tau172
const double getIntegrand_AFBnumeratorWithISR_tau172(double x) const
Definition: StandardModel/src/StandardModel.cpp:9394
StandardModel::MLL2eeff
const double MLL2eeff(const Particle f, const double s, const double t) const
Definition: StandardModel/src/StandardModel.cpp:3806
StandardModel::getIntegrand_sigmaWithISR_tau205
const double getIntegrand_sigmaWithISR_tau205(double x) const
Definition: StandardModel/src/StandardModel.cpp:8195
StandardModel::m_q
double m_q(const QCD::quark q, const double mu, const orders order=FULLNLO) const
Definition: StandardModel.h:3531
StandardModel::getIntegrand_AFBnumeratorWithISR_bottom196
const double getIntegrand_AFBnumeratorWithISR_bottom196(double x) const
Definition: StandardModel/src/StandardModel.cpp:9570
StandardModel::getIntegrand_sigmaWithISR_strange136
const double getIntegrand_sigmaWithISR_strange136(double x) const
Definition: StandardModel/src/StandardModel.cpp:8507
StandardModel::getIntegrand_sigmaWithISR_down207
const double getIntegrand_sigmaWithISR_down207(double x) const
Definition: StandardModel/src/StandardModel.cpp:8397
StandardModel::getIntegrand_sigmaWithISR_tau196
const double getIntegrand_sigmaWithISR_tau196(double x) const
Definition: StandardModel/src/StandardModel.cpp:8177
StandardModel::getIntegrand_dsigmaBox_down136
const double getIntegrand_dsigmaBox_down136(double x) const
Definition: StandardModel/src/StandardModel.cpp:8941
StandardModel::getIntegrand_dsigmaBox_strange189
const double getIntegrand_dsigmaBox_strange189(double x) const
Definition: StandardModel/src/StandardModel.cpp:9149
StandardModel::getIntegrand_sigmaWithISR_bottom200
const double getIntegrand_sigmaWithISR_bottom200(double x) const
Definition: StandardModel/src/StandardModel.cpp:8643
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:1213
StandardModel::getIntegrand_sigmaWithISR_up183
const double getIntegrand_sigmaWithISR_up183(double x) const
Definition: StandardModel/src/StandardModel.cpp:8267
StandardModel::GammaHtobb
virtual const double GammaHtobb() const
The in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3604
StandardModel::getIntegrand_dsigmaBox_mu136
const double getIntegrand_dsigmaBox_mu136(double x) const
Definition: StandardModel/src/StandardModel.cpp:8683
StandardModel::getIntegrand_sigmaWithISR_strange183
const double getIntegrand_sigmaWithISR_strange183(double x) const
Definition: StandardModel/src/StandardModel.cpp:8531
StandardModel::AFB
virtual const double AFB(const Particle f) const
Definition: StandardModel/src/StandardModel.cpp:1346
StandardModel::getIntegrand_dsigmaBox_down183
const double getIntegrand_dsigmaBox_down183(double x) const
Definition: StandardModel/src/StandardModel.cpp:8965
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:2271
StandardModel::getIntegrand_dsigmaBox_charm130
const double getIntegrand_dsigmaBox_charm130(double x) const
Definition: StandardModel/src/StandardModel.cpp:9017
StandardModel::getMz
const double getMz() const
A get method to access the mass of the boson .
Definition: StandardModel.h:753
StandardModel::getIntegrand_AFBnumeratorWithISR_tau192
const double getIntegrand_AFBnumeratorWithISR_tau192(double x) const
Definition: StandardModel/src/StandardModel.cpp:9412
StandardModel::getIntegrand_sigmaWithISR_strange200
const double getIntegrand_sigmaWithISR_strange200(double x) const
Definition: StandardModel/src/StandardModel.cpp:8555
StandardModel::getIntegrand_AFBnumeratorWithISR_charm205
const double getIntegrand_AFBnumeratorWithISR_charm205(double x) const
Definition: StandardModel/src/StandardModel.cpp:9519
StandardModel::setFlagCacheInStandardModel
void setFlagCacheInStandardModel(bool FlagCacheInStandardModel)
A set method to change the model flag CacheInStandardModel of StandardModel.
Definition: StandardModel.h:730
StandardModel::getIntegrand_sigmaWithISR_tau161
const double getIntegrand_sigmaWithISR_tau161(double x) const
Definition: StandardModel/src/StandardModel.cpp:8147
StandardModel::getIntegrand_sigmaWithISR_up167
const double getIntegrand_sigmaWithISR_up167(double x) const
Definition: StandardModel/src/StandardModel.cpp:8255
StandardModel::GammaW_cache
double GammaW_cache
A cache of the value of .
Definition: StandardModel.h:4048
StandardModel::delMw
double delMw
The theoretical uncertainty in , denoted as , in GeV.
Definition: StandardModel.h:3452
StandardModel::LEP2AFBtau
virtual const double LEP2AFBtau(const double s) const
Definition: StandardModel/src/StandardModel.cpp:7480
StandardModel::getIntegrand_AFBnumeratorWithISR_tau196
const double getIntegrand_AFBnumeratorWithISR_tau196(double x) const
Definition: StandardModel/src/StandardModel.cpp:9418
StandardModel::flag_order
bool flag_order[orders_EW_size]
An array of internal flags controlling the inclusions of higher-order corrections.
Definition: StandardModel.h:3485
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:1588
StandardModel::getIntegrand_AFBnumeratorWithISR_charm200
const double getIntegrand_AFBnumeratorWithISR_charm200(double x) const
Definition: StandardModel/src/StandardModel.cpp:9507
StandardModel::gLnuN2
virtual const double gLnuN2() const
The effective neutrino nucleon LH coupling: gLnuN2.
Definition: StandardModel/src/StandardModel.cpp:3001
StandardModel::getIntegrand_sigmaWithISR_strange207
const double getIntegrand_sigmaWithISR_strange207(double x) const
Definition: StandardModel/src/StandardModel.cpp:8573
StandardModel::getIntegrand_AFBnumeratorWithISR_mu196
const double getIntegrand_AFBnumeratorWithISR_mu196(double x) const
Definition: StandardModel/src/StandardModel.cpp:9345
StandardModel::getIntegrand_dsigmaBox_mu189
const double getIntegrand_dsigmaBox_mu189(double x) const
Definition: StandardModel/src/StandardModel.cpp:8707
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:777
StandardModel::getIntegrand_dsigmaBox_down161
const double getIntegrand_dsigmaBox_down161(double x) const
Definition: StandardModel/src/StandardModel.cpp:8947
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:3128
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:9185
StandardModel::getIntegrand_sigmaWithISR_down202
const double getIntegrand_sigmaWithISR_down202(double x) const
Definition: StandardModel/src/StandardModel.cpp:8385
StandardModel::f_GSL
gsl_function f_GSL
Definition: StandardModel.h:4067
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:8830
StandardModel::LEP2dsigmadcosBinTau
virtual const double LEP2dsigmadcosBinTau(const double s, const double cos, const double cosmin, const double cosmax) const
Definition: StandardModel/src/StandardModel.cpp:9656
StandardModel::getIntegrand_dsigmaBox_bottom189
const double getIntegrand_dsigmaBox_bottom189(double x) const
Definition: StandardModel/src/StandardModel.cpp:9237
StandardModel::myTwoLoopEW
EWSMTwoLoopEW * myTwoLoopEW
A pointer to an object of type EWSMTwoLoopEW.
Definition: StandardModel.h:4018
StandardModel::getIntegrand_AFBnumeratorWithISR_mu136
const double getIntegrand_AFBnumeratorWithISR_mu136(double x) const
Definition: StandardModel/src/StandardModel.cpp:9309
StandardModel::getIntegrand_AFBnumeratorWithISR_mu130
const double getIntegrand_AFBnumeratorWithISR_mu130(double x) const
Definition: StandardModel/src/StandardModel.cpp:9303
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:364
StandardModel::CheckFlags
virtual bool CheckFlags() const
A method to check the sanity of the set of model flags.
Definition: StandardModel/src/StandardModel.cpp:547
StandardModel::getIntegrand_dsigmaBox_charm161
const double getIntegrand_dsigmaBox_charm161(double x) const
Definition: StandardModel/src/StandardModel.cpp:9035
StandardModel::getIntegrand_dsigmaBox_up192
const double getIntegrand_dsigmaBox_up192(double x) const
Definition: StandardModel/src/StandardModel.cpp:8890
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:1126
StandardModel::getIntegrand_sigmaWithISR_strange202
const double getIntegrand_sigmaWithISR_strange202(double x) const
Definition: StandardModel/src/StandardModel.cpp:8561
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:2151
StandardModel::LEP2Rbottom
virtual const double LEP2Rbottom(const double s) const
Definition: StandardModel/src/StandardModel.cpp:7977
StandardModel::getIntegrand_sigmaWithISR_tau183
const double getIntegrand_sigmaWithISR_tau183(double x) const
Definition: StandardModel/src/StandardModel.cpp:8159
StandardModel::FlagFixMuwMut
bool FlagFixMuwMut
A boolean for the model flag FixMuwMut.
Definition: StandardModel.h:3719
StandardModel::AlsEByOrder
const double AlsEByOrder(double mu, orders order, bool Nf_thr) const
Definition: StandardModel/src/StandardModel.cpp:686
StandardModel::getAlsMz
const double getAlsMz() const
A get method to access the value of .
Definition: StandardModel.h:771
StandardModel::getIntegrand_sigmaWithISR_tau130
const double getIntegrand_sigmaWithISR_tau130(double x) const
Definition: StandardModel/src/StandardModel.cpp:8135
StandardModel::getIntegrand_AFBnumeratorWithISR_bottom172
const double getIntegrand_AFBnumeratorWithISR_bottom172(double x) const
Definition: StandardModel/src/StandardModel.cpp:9546
StandardModel::RWlilj
virtual const double RWlilj(const Particle li, const Particle lj) const
The lepton universality ratio .
Definition: StandardModel/src/StandardModel.cpp:1292
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:3296
StandardModel::Gamma_inv
virtual const double Gamma_inv() const
The invisible partial decay width of the boson, .
Definition: StandardModel/src/StandardModel.cpp:1405
StandardModel::getIntegrand_dsigmaBox_bottom207
const double getIntegrand_dsigmaBox_bottom207(double x) const
Definition: StandardModel/src/StandardModel.cpp:9273
StandardModel::getIntegrand_AFBnumeratorWithISR_mu172
const double getIntegrand_AFBnumeratorWithISR_mu172(double x) const
Definition: StandardModel/src/StandardModel.cpp:9321
StandardModel::Qwp
virtual const double Qwp() const
The computation of the proton weak charge: Qwp.
Definition: StandardModel/src/StandardModel.cpp:2781
StandardModel::getIntegrand_dsigmaBox_tau183
const double getIntegrand_dsigmaBox_tau183(double x) const
Definition: StandardModel/src/StandardModel.cpp:8777
StandardModel::getIntegrand_AFBnumeratorWithISR_mu202
const double getIntegrand_AFBnumeratorWithISR_mu202(double x) const
Definition: StandardModel/src/StandardModel.cpp:9357
StandardModel::getIntegrand_AFBnumeratorWithISR_charm172
const double getIntegrand_AFBnumeratorWithISR_charm172(double x) const
Definition: StandardModel/src/StandardModel.cpp:9477
StandardModel::getIntegrand_dsigmaBox_down202
const double getIntegrand_dsigmaBox_down202(double x) const
Definition: StandardModel/src/StandardModel.cpp:8995
StandardModel::R_inv
virtual const double R_inv() const
The ratio of the invisible and leptonic (electron) decay widths of the boson, .
Definition: StandardModel/src/StandardModel.cpp:1550
StandardModel::Init
virtual bool Init(const std::map< std::string, double > &DPars)
A method to initialize the model parameters.
Definition: StandardModel/src/StandardModel.cpp:196
StandardModel::myCKM
CKM myCKM
An object of type CKM.
Definition: StandardModel.h:3433
StandardModel::LEP2AFBe
virtual const double LEP2AFBe(const double s) const
Definition: StandardModel/src/StandardModel.cpp:6978
StandardModel::SMresult_cache
double SMresult_cache
Definition: StandardModel.h:4061
StandardModel::getIntegrand_sigmaWithISR_charm183
const double getIntegrand_sigmaWithISR_charm183(double x) const
Definition: StandardModel/src/StandardModel.cpp:8443
StandardModel::getIntegrand_dsigmaBox_bottom202
const double getIntegrand_dsigmaBox_bottom202(double x) const
Definition: StandardModel/src/StandardModel.cpp:9261
StandardModel::getIntegrand_dsigmaBox_bottom200
const double getIntegrand_dsigmaBox_bottom200(double x) const
Definition: StandardModel/src/StandardModel.cpp:9255
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:3518
StandardModel::getIntegrand_dsigmaBox_bottom205
const double getIntegrand_dsigmaBox_bottom205(double x) const
Definition: StandardModel/src/StandardModel.cpp:9267
StandardModel::useDeltaAlpha_cache
bool useDeltaAlpha_cache
Definition: StandardModel.h:4052
StandardModel::getIntegrand_dsigmaBox_tau196
const double getIntegrand_dsigmaBox_tau196(double x) const
Definition: StandardModel/src/StandardModel.cpp:8795
StandardModel::getIntegrand_sigmaWithISR_tau200
const double getIntegrand_sigmaWithISR_tau200(double x) const
Definition: StandardModel/src/StandardModel.cpp:8183
StandardModel::getIntegrand_sigmaWithISR_bottom207
const double getIntegrand_sigmaWithISR_bottom207(double x) const
Definition: StandardModel/src/StandardModel.cpp:8661
StandardModel::getIntegrand_dsigmaBox_bottom183
const double getIntegrand_dsigmaBox_bottom183(double x) const
Definition: StandardModel/src/StandardModel.cpp:9231
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:508
StandardModel::requireYn
bool requireYn
An internal flag to control whether the neutrino Yukawa matrix has to be recomputed.
Definition: StandardModel.h:3716
StandardModel::getIntegrand_dsigmaBox_mu161
const double getIntegrand_dsigmaBox_mu161(double x) const
Definition: StandardModel/src/StandardModel.cpp:8689
StandardModel::eeffsigma
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:4048
StandardModel::BrHtotautau
virtual const double BrHtotautau() const
The Br in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3676
StandardModel::Gamma_muon
virtual const double Gamma_muon() const
The computation of the muon decay.
Definition: StandardModel/src/StandardModel.cpp:3088
StandardModel::getIntegrand_dsigmaBox_up200
const double getIntegrand_dsigmaBox_up200(double x) const
Definition: StandardModel/src/StandardModel.cpp:8902
StandardModel::intMLR2eeeets2
const double intMLR2eeeets2(const double s, const double t0, const double t1) const
Definition: StandardModel/src/StandardModel.cpp:3923
StandardModel::getIntegrand_dsigmaBox_tau192
const double getIntegrand_dsigmaBox_tau192(double x) const
Definition: StandardModel/src/StandardModel.cpp:8789
StandardModel::getIntegrand_AFBnumeratorWithISR_bottom207
const double getIntegrand_AFBnumeratorWithISR_bottom207(double x) const
Definition: StandardModel/src/StandardModel.cpp:9594
StandardModel::getIntegrand_AFBnumeratorWithISR_tau136
const double getIntegrand_AFBnumeratorWithISR_tau136(double x) const
Definition: StandardModel/src/StandardModel.cpp:9382
StandardModel::DeltaAlphaTop
const double DeltaAlphaTop(const double s) const
Top-quark contribution to the electromagnetic coupling , denoted as .
Definition: StandardModel/src/StandardModel.cpp:907
StandardModel::getIntegrand_sigmaWithISR_charm205
const double getIntegrand_sigmaWithISR_charm205(double x) const
Definition: StandardModel/src/StandardModel.cpp:8479
StandardModel::getIntegrand_dsigmaBox_tau189
const double getIntegrand_dsigmaBox_tau189(double x) const
Definition: StandardModel/src/StandardModel.cpp:8783
StandardModel::BrHtogaga
virtual const double BrHtogaga() const
The Br in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3666
StandardModel::getIntegrand_AFBnumeratorWithISR_charm207
const double getIntegrand_AFBnumeratorWithISR_charm207(double x) const
Definition: StandardModel/src/StandardModel.cpp:9525
StandardModel::w_GSL1
gsl_integration_workspace * w_GSL1
Definition: StandardModel.h:4068
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:3322
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:1653
StandardModel::Yn
gslpp::matrix< gslpp::complex > Yn
The Yukawa matrix of the neutrinos.
Definition: StandardModel.h:3440
StandardModel::getIntegrand_AFBnumeratorWithISR_charm202
const double getIntegrand_AFBnumeratorWithISR_charm202(double x) const
Definition: StandardModel/src/StandardModel.cpp:9513
StandardModel::myTwoFermionsLEP2
EWSMTwoFermionsLEP2 * myTwoFermionsLEP2
A pointer to an object of type EWSMTwoFermionsLEP2.
Definition: StandardModel.h:4024
StandardModel::SMM
Matching< StandardModelMatching, StandardModel > SMM
An object of type Matching.
Definition: StandardModel.h:3437
StandardModel::Gamma_had
virtual const double Gamma_had() const
The hadronic decay width of the boson, .
Definition: StandardModel/src/StandardModel.cpp:1411
StandardModel::getIntegrand_sigmaWithISR_charm207
const double getIntegrand_sigmaWithISR_charm207(double x) const
Definition: StandardModel/src/StandardModel.cpp:8485
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:605
StandardModel::computeYukawas
virtual void computeYukawas()
The method to compute the Yukawas matrix.
Definition: StandardModel/src/StandardModel.cpp:410
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:1234
StandardModel::AleWithInit
const double AleWithInit(double mu, double alsi, double mu_i, orders order) const
Definition: StandardModel/src/StandardModel.cpp:850
StandardModel::getIntegrand_sigmaWithISR_bottom136
const double getIntegrand_sigmaWithISR_bottom136(double x) const
Definition: StandardModel/src/StandardModel.cpp:8595
StandardModel::getIntegrand_sigmaWithISR_charm202
const double getIntegrand_sigmaWithISR_charm202(double x) const
Definition: StandardModel/src/StandardModel.cpp:8473
StandardModel::Yu
gslpp::matrix< gslpp::complex > Yu
The Yukawa matrix of the up-type quarks.
Definition: StandardModel.h:3438
StandardModel::LEP2AFBcharm
virtual const double LEP2AFBcharm(const double s) const
Definition: StandardModel/src/StandardModel.cpp:6568
StandardModel::FlagMw
std::string FlagMw
A string for the model flag Mw.
Definition: StandardModel.h:4029
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:8047
StandardModel::getIntegrand_AFBnumeratorWithISR_tau183
const double getIntegrand_AFBnumeratorWithISR_tau183(double x) const
Definition: StandardModel/src/StandardModel.cpp:9400
StandardModel::GammaHtogg
virtual const double GammaHtogg() const
The in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3362
StandardModel::delsigma0H
double delsigma0H
The theoretical uncertainty in , denoted as in nb.
Definition: StandardModel.h:3457
StandardModel::BrHtobb
virtual const double BrHtobb() const
The Br in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3691
StandardModel::gA_f
virtual const gslpp::complex gA_f(const Particle f) const
The effective leptonic neutral-current axial-vector coupling in the SM.
Definition: StandardModel/src/StandardModel.cpp:1583
StandardModel::getIntegrand_sigmaWithISR_bottom130
const double getIntegrand_sigmaWithISR_bottom130(double x) const
Definition: StandardModel/src/StandardModel.cpp:8583
StandardModel::getIntegrand_sigmaWithISR_charm161
const double getIntegrand_sigmaWithISR_charm161(double x) const
Definition: StandardModel/src/StandardModel.cpp:8425
StandardModel::getIntegrand_sigmaWithISR_mu207
const double getIntegrand_sigmaWithISR_mu207(double x) const
Definition: StandardModel/src/StandardModel.cpp:8128
StandardModel::GammaHtoZga
virtual const double GammaHtoZga() const
The in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3426
StandardModel::getIntegrand_sigmaWithISR_bottom192
const double getIntegrand_sigmaWithISR_bottom192(double x) const
Definition: StandardModel/src/StandardModel.cpp:8631
StandardModel::alrmoller
virtual const double alrmoller(const double q2, const double y) const
The computation of the parity violating asymmetry in Moller scattering.
Definition: StandardModel/src/StandardModel.cpp:2763
StandardModel::rhob
double rhob
The CKM parameter in the Wolfenstein parameterization.
Definition: StandardModel.h:3463
StandardModel::leptons
Particle leptons[6]
An array of Particle objects for the leptons.
Definition: StandardModel.h:3432
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:9450
StandardModel::getIntegrand_sigmaWithISR_charm172
const double getIntegrand_sigmaWithISR_charm172(double x) const
Definition: StandardModel/src/StandardModel.cpp:8437
StandardModel::getIntegrand_sigmaWithISR_charm200
const double getIntegrand_sigmaWithISR_charm200(double x) const
Definition: StandardModel/src/StandardModel.cpp:8467
StandardModel::getIntegrand_dsigmaBox_up167
const double getIntegrand_dsigmaBox_up167(double x) const
Definition: StandardModel/src/StandardModel.cpp:8866
StandardModel::getIntegrand_dsigmaBox_mu183
const double getIntegrand_dsigmaBox_mu183(double x) const
Definition: StandardModel/src/StandardModel.cpp:8701
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:4019
StandardModel::delSin2th_l
double delSin2th_l
The theoretical uncertainty in , denoted as .
Definition: StandardModel.h:3453
StandardModel::getIntegrand_dsigmaBox_charm167
const double getIntegrand_dsigmaBox_charm167(double x) const
Definition: StandardModel/src/StandardModel.cpp:9041
StandardModel::RWc
virtual const double RWc() const
The ratio .
Definition: StandardModel/src/StandardModel.cpp:1322
StandardModel::getIntegrand_sigmaWithISR_mu172
const double getIntegrand_sigmaWithISR_mu172(double x) const
Definition: StandardModel/src/StandardModel.cpp:8080
StandardModel::getIntegrand_sigmaWithISR_mu136
const double getIntegrand_sigmaWithISR_mu136(double x) const
Definition: StandardModel/src/StandardModel.cpp:8068
StandardModel::sigma_NoISR_q
const double sigma_NoISR_q(const QCD::quark q_flavor, const double s) const
Definition: StandardModel/src/StandardModel.cpp:8013
StandardModel::FlagMWinput
bool FlagMWinput
A boolean for the model flag MWinput.
Definition: StandardModel.h:4035
StandardModel::Ruc
virtual const double Ruc() const
Definition: StandardModel/src/StandardModel.cpp:1317
StandardModel::getIntegrand_dsigmaBox_strange200
const double getIntegrand_dsigmaBox_strange200(double x) const
Definition: StandardModel/src/StandardModel.cpp:9167
StandardModel::getIntegrand_dsigmaBox_mu172
const double getIntegrand_dsigmaBox_mu172(double x) const
Definition: StandardModel/src/StandardModel.cpp:8695
StandardModel::getIntegrand_sigmaWithISR_bottom196
const double getIntegrand_sigmaWithISR_bottom196(double x) const
Definition: StandardModel/src/StandardModel.cpp:8637
StandardModel::sigma0_had
virtual const double sigma0_had() const
The hadronic cross section for at the -pole, .
Definition: StandardModel/src/StandardModel.cpp:1465
StandardModel::GammaW
virtual const double GammaW() const
The total width of the boson, .
Definition: StandardModel/src/StandardModel.cpp:1266
StandardModel::intMLRtilde2eeeest2
const double intMLRtilde2eeeest2(const double s, const double t0, const double t1) const
Definition: StandardModel/src/StandardModel.cpp:3949
StandardModel::getIntegrand_dsigmaBox_strange196
const double getIntegrand_dsigmaBox_strange196(double x) const
Definition: StandardModel/src/StandardModel.cpp:9161
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:1005
StandardModel::SMFlavour
Flavour SMFlavour
An object of type Flavour.
Definition: StandardModel.h:3718
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:3267
StandardModel::getIntegrand_dsigmaBox_up207
const double getIntegrand_dsigmaBox_up207(double x) const
Definition: StandardModel/src/StandardModel.cpp:8920
StandardModel::getIntegrand_sigmaWithISR_charm133
const double getIntegrand_sigmaWithISR_charm133(double x) const
Definition: StandardModel/src/StandardModel.cpp:8413
StandardModel::FlagWithoutNonUniversalVC
bool FlagWithoutNonUniversalVC
A boolean for the model flag WithoutNonUniversalVC.
Definition: StandardModel.h:4027
StandardModel::getIntegrand_sigmaWithISR_down200
const double getIntegrand_sigmaWithISR_down200(double x) const
Definition: StandardModel/src/StandardModel.cpp:8379
StandardModel::FlagSMAux
bool FlagSMAux
A boolean for the model flag SMAux.
Definition: StandardModel.h:4036
StandardModel::getIntegrand_sigmaWithISR_charm130
const double getIntegrand_sigmaWithISR_charm130(double x) const
Definition: StandardModel/src/StandardModel.cpp:8407
StandardModel::getIntegrand_sigmaWithISR_down196
const double getIntegrand_sigmaWithISR_down196(double x) const
Definition: StandardModel/src/StandardModel.cpp:8373
StandardModel::getIntegrand_sigmaWithISR_bottom172
const double getIntegrand_sigmaWithISR_bottom172(double x) const
Definition: StandardModel/src/StandardModel.cpp:8613
StandardModel::Yd
gslpp::matrix< gslpp::complex > Yd
The Yukawa matrix of the down-type quarks.
Definition: StandardModel.h:3439
StandardModel::getIntegrand_sigmaWithISR_up133
const double getIntegrand_sigmaWithISR_up133(double x) const
Definition: StandardModel/src/StandardModel.cpp:8237
StandardModel::LEP2AFBmu
virtual const double LEP2AFBmu(const double s) const
Definition: StandardModel/src/StandardModel.cpp:6983
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:1283
StandardModel::getIntegrand_dsigmaBox_down189
const double getIntegrand_dsigmaBox_down189(double x) const
Definition: StandardModel/src/StandardModel.cpp:8971
StandardModel::getIntegrand_AFBnumeratorWithISR_bottom200
const double getIntegrand_AFBnumeratorWithISR_bottom200(double x) const
Definition: StandardModel/src/StandardModel.cpp:9576
StandardModel::getIntegrand_sigmaWithISR_charm167
const double getIntegrand_sigmaWithISR_charm167(double x) const
Definition: StandardModel/src/StandardModel.cpp:8431
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:8671
StandardModel::myOneLoopEW
EWSMOneLoopEW * myOneLoopEW
A pointer to an object of type EWSMOneLoopEW.
Definition: StandardModel.h:4015
StandardModel::delR0c
double delR0c
The theoretical uncertainty in , denoted as .
Definition: StandardModel.h:3459
StandardModel::epsilon2
virtual const double epsilon2() const
The SM contribution to the epsilon parameter .
Definition: StandardModel/src/StandardModel.cpp:1802
StandardModel::getIntegrand_dsigmaBox_charm205
const double getIntegrand_dsigmaBox_charm205(double x) const
Definition: StandardModel/src/StandardModel.cpp:9089
StandardModel::getIntegrand_sigmaWithISR_up172
const double getIntegrand_sigmaWithISR_up172(double x) const
Definition: StandardModel/src/StandardModel.cpp:8261
StandardModel::LEP2dsigmadcosMu
virtual const double LEP2dsigmadcosMu(const double s, const double cos) const
Definition: StandardModel/src/StandardModel.cpp:9617
StandardModel::getIntegrand_dsigmaBox_up161
const double getIntegrand_dsigmaBox_up161(double x) const
Definition: StandardModel/src/StandardModel.cpp:8860
StandardModel::Qwemoller
virtual const double Qwemoller(const double q2, const double y) const
The computation of the electron's weak charge.
Definition: StandardModel/src/StandardModel.cpp:2665
StandardModel::getIntegrand_dsigmaBox_tau202
const double getIntegrand_dsigmaBox_tau202(double x) const
Definition: StandardModel/src/StandardModel.cpp:8807
StandardModel::DeltaR
virtual const double DeltaR() const
The SM prediction for derived from that for the boson mass.
Definition: StandardModel/src/StandardModel.cpp:1112
StandardModel::FlagKappaZ
std::string FlagKappaZ
A string for the model flag KappaZ.
Definition: StandardModel.h:4031
StandardModel::getIntegrand_dsigmaBox_charm183
const double getIntegrand_dsigmaBox_charm183(double x) const
Definition: StandardModel/src/StandardModel.cpp:9053
StandardModel::getIntegrand_dsigmaBox_bottom196
const double getIntegrand_dsigmaBox_bottom196(double x) const
Definition: StandardModel/src/StandardModel.cpp:9249
StandardModel::LEP2dsigmadcosBinE
virtual const double LEP2dsigmadcosBinE(const double s, const double cos, const double cosmin, const double cosmax) const
Definition: StandardModel/src/StandardModel.cpp:9646
StandardModel::getIntegrand_sigmaWithISR_strange205
const double getIntegrand_sigmaWithISR_strange205(double x) const
Definition: StandardModel/src/StandardModel.cpp:8567
StandardModel::getIntegrand_dsigmaBox_bottom172
const double getIntegrand_dsigmaBox_bottom172(double x) const
Definition: StandardModel/src/StandardModel.cpp:9225
StandardModel::Gamma_Z
virtual const double Gamma_Z() const
The total decay width of the boson, .
Definition: StandardModel/src/StandardModel.cpp:1433
StandardModel::getIntegrand_dsigmaBox_down133
const double getIntegrand_dsigmaBox_down133(double x) const
Definition: StandardModel/src/StandardModel.cpp:8935
StandardModel::getIntegrand_dsigmaBox_mu192
const double getIntegrand_dsigmaBox_mu192(double x) const
Definition: StandardModel/src/StandardModel.cpp:8713
StandardModel::getIntegrand_dsigmaBox_down167
const double getIntegrand_dsigmaBox_down167(double x) const
Definition: StandardModel/src/StandardModel.cpp:8953
StandardModel::getIntegrand_dsigmaBox_mu196
const double getIntegrand_dsigmaBox_mu196(double x) const
Definition: StandardModel/src/StandardModel.cpp:8719
StandardModel::gRnuN2
virtual const double gRnuN2() const
The effective neutrino nucleon RH coupling: gRnuN2.
Definition: StandardModel/src/StandardModel.cpp:3015
StandardModel::getIntegrand_sigmaWithISR_strange133
const double getIntegrand_sigmaWithISR_strange133(double x) const
Definition: StandardModel/src/StandardModel.cpp:8501
StandardModel::IsFlagWithoutNonUniversalVC
const bool IsFlagWithoutNonUniversalVC() const
A method to retrieve the model flag WithoutNonUniversalVC.
Definition: StandardModel.h:666
StandardModel::getIntegrand_sigmaWithISR_tau189
const double getIntegrand_sigmaWithISR_tau189(double x) const
Definition: StandardModel/src/StandardModel.cpp:8165
StandardModel::getIntegrand_AFBnumeratorWithISR_bottom205
const double getIntegrand_AFBnumeratorWithISR_bottom205(double x) const
Definition: StandardModel/src/StandardModel.cpp:9588
StandardModel::GF
double GF
The Fermi constant in .
Definition: StandardModel.h:3448
StandardModel::getIntegrand_sigmaWithISR_down130
const double getIntegrand_sigmaWithISR_down130(double x) const
Definition: StandardModel/src/StandardModel.cpp:8318
StandardModel::getIntegrand_sigmaWithISR_strange192
const double getIntegrand_sigmaWithISR_strange192(double x) const
Definition: StandardModel/src/StandardModel.cpp:8543
StandardModel::epsilonb
virtual const double epsilonb() const
The SM contribution to the epsilon parameter .
Definition: StandardModel/src/StandardModel.cpp:1824
StandardModel::myApproximateFormulae
EWSMApproximateFormulae * myApproximateFormulae
A pointer to an object of type EWSMApproximateFormulae.
Definition: StandardModel.h:4021
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:1739
StandardModel::getIntegrand_dsigmaBox_bottom130
const double getIntegrand_dsigmaBox_bottom130(double x) const
Definition: StandardModel/src/StandardModel.cpp:9195
StandardModel::GammaHtocc
virtual const double GammaHtocc() const
The in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3552
StandardModel::getIntegrand_sigmaWithISR_strange130
const double getIntegrand_sigmaWithISR_strange130(double x) const
Definition: StandardModel/src/StandardModel.cpp:8495
StandardModel::getIntegrand_AFBnumeratorWithISR_bottom189
const double getIntegrand_AFBnumeratorWithISR_bottom189(double x) const
Definition: StandardModel/src/StandardModel.cpp:9558
StandardModel::getIntegrand_dsigmaBox_tau172
const double getIntegrand_dsigmaBox_tau172(double x) const
Definition: StandardModel/src/StandardModel.cpp:8771
StandardModel::intMRR2eeeeus2
const double intMRR2eeeeus2(const double s, const double t0, const double t1) const
Definition: StandardModel/src/StandardModel.cpp:3992
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:2036
StandardModel::TauLFU_gtaugmuK
virtual const double TauLFU_gtaugmuK() const
The computation of the LFU ratio .
Definition: StandardModel/src/StandardModel.cpp:3242
StandardModel::getIntegrand_dsigmaBox_strange161
const double getIntegrand_dsigmaBox_strange161(double x) const
Definition: StandardModel/src/StandardModel.cpp:9123
StandardModel::LEP2sigmaE
virtual const double LEP2sigmaE(const double s) const
Definition: StandardModel/src/StandardModel.cpp:4083
StandardModel::getIntegrand_sigmaWithISR_down136
const double getIntegrand_sigmaWithISR_down136(double x) const
Definition: StandardModel/src/StandardModel.cpp:8331
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:626
StandardModel::AFB_NoISR_q
const double AFB_NoISR_q(const QCD::quark q_flavor, const double s) const
Definition: StandardModel/src/StandardModel.cpp:8036
StandardModel::BrHtoWWstar
virtual const double BrHtoWWstar() const
The Br in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3656
StandardModel::getIntegrand_sigmaWithISR_bottom205
const double getIntegrand_sigmaWithISR_bottom205(double x) const
Definition: StandardModel/src/StandardModel.cpp:8655
StandardModel::getIntegrand_dsigmaBox_tau200
const double getIntegrand_dsigmaBox_tau200(double x) const
Definition: StandardModel/src/StandardModel.cpp:8801
StandardModel::Mw
virtual const double Mw() const
The SM prediction for the -boson mass in the on-shell scheme, .
Definition: StandardModel/src/StandardModel.cpp:1019
StandardModel::setFlag
virtual bool setFlag(const std::string name, const bool value)
A method to set a flag of StandardModel.
Definition: StandardModel/src/StandardModel.cpp:443
StandardModel::getIntegrand_sigmaWithISR_up192
const double getIntegrand_sigmaWithISR_up192(double x) const
Definition: StandardModel/src/StandardModel.cpp:8279
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:1339
StandardModel::MRR2eeff
const double MRR2eeff(const Particle f, const double s, const double t) const
Definition: StandardModel/src/StandardModel.cpp:3858
StandardModel::Mw_cache
double Mw_cache
A cache of the value of .
Definition: StandardModel.h:4047
StandardModel::DeltaAlphaLepton_cache
double DeltaAlphaLepton_cache
A cache of the value of .
Definition: StandardModel.h:4045
StandardModel::getIntegrand_AFBnumeratorWithISR_mu205
const double getIntegrand_AFBnumeratorWithISR_mu205(double x) const
Definition: StandardModel/src/StandardModel.cpp:9363
StandardModel::getIntegrand_dsigmaBox_bottom133
const double getIntegrand_dsigmaBox_bottom133(double x) const
Definition: StandardModel/src/StandardModel.cpp:9201
StandardModel::getIntegrand_dsigmaBox_strange205
const double getIntegrand_dsigmaBox_strange205(double x) const
Definition: StandardModel/src/StandardModel.cpp:9179
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:1764
StandardModel::getIntegrand_AFBnumeratorWithISR_tau202
const double getIntegrand_AFBnumeratorWithISR_tau202(double x) const
Definition: StandardModel/src/StandardModel.cpp:9430
StandardModel::getIntegrand_dsigmaBox_bottom167
const double getIntegrand_dsigmaBox_bottom167(double x) const
Definition: StandardModel/src/StandardModel.cpp:9219
StandardModel::amuon
virtual const double amuon() const
The computation of the anomalous magnetic moment of the muon .
Definition: StandardModel/src/StandardModel.cpp:2435
StandardModel::BrHtoZga
virtual const double BrHtoZga() const
The Br in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3661
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:3278
StandardModel::epsilon1
virtual const double epsilon1() const
The SM contribution to the epsilon parameter .
Definition: StandardModel/src/StandardModel.cpp:1794
StandardModel::delSin2th_q
double delSin2th_q
The theoretical uncertainty in , denoted as .
Definition: StandardModel.h:3454
StandardModel::FlagUseVud
bool FlagUseVud
A boolean for the model flag UseVud.
Definition: StandardModel.h:4033
StandardModel::getIntegrand_sigmaWithISR_bottom133
const double getIntegrand_sigmaWithISR_bottom133(double x) const
Definition: StandardModel/src/StandardModel.cpp:8589
StandardModel::getIntegrand_sigmaWithISR_mu161
const double getIntegrand_sigmaWithISR_mu161(double x) const
Definition: StandardModel/src/StandardModel.cpp:8074
StandardModel::Mzbar
double Mzbar() const
The -boson mass in the complex-pole/fixed-width scheme.
Definition: StandardModel/src/StandardModel.cpp:1187
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:552
StandardModel::NSMvars
static const int NSMvars
The number of the model parameters in StandardModel.
Definition: StandardModel.h:540
StandardModel::getIntegrand_dsigmaBox_mu202
const double getIntegrand_dsigmaBox_mu202(double x) const
Definition: StandardModel/src/StandardModel.cpp:8731
StandardModel::getIntegrand_sigmaWithISR_up200
const double getIntegrand_sigmaWithISR_up200(double x) const
Definition: StandardModel/src/StandardModel.cpp:8291
StandardModel::sigma_NoISR_l
const double sigma_NoISR_l(const QCD::lepton l_flavor, const double s) const
Definition: StandardModel/src/StandardModel.cpp:8001
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:8207
StandardModel::getIntegrand_dsigmaBox_up183
const double getIntegrand_dsigmaBox_up183(double x) const
Definition: StandardModel/src/StandardModel.cpp:8878
StandardModel::LEP2Rcharm
virtual const double LEP2Rcharm(const double s) const
Definition: StandardModel/src/StandardModel.cpp:7989
StandardModel::SMparamsForEWPO_cache
double SMparamsForEWPO_cache[NumSMParamsForEWPO]
Definition: StandardModel.h:4044
StandardModel::FlagNoApproximateGammaZ
bool FlagNoApproximateGammaZ
A boolean for the model flag NoApproximateGammaZ.
Definition: StandardModel.h:4028
StandardModel::getIntegrand_sigmaWithISR_bottom202
const double getIntegrand_sigmaWithISR_bottom202(double x) const
Definition: StandardModel/src/StandardModel.cpp:8649
StandardModel::getIntegrand_sigmaWithISR_mu130
const double getIntegrand_sigmaWithISR_mu130(double x) const
Definition: StandardModel/src/StandardModel.cpp:8062
StandardModel::getIntegrand_dsigmaBox_strange183
const double getIntegrand_dsigmaBox_strange183(double x) const
Definition: StandardModel/src/StandardModel.cpp:9143
StandardModel::kappaZ_f_cache
gslpp::complex kappaZ_f_cache[12]
A cache of the value of .
Definition: StandardModel.h:4050
StandardModel::getIntegrand_dsigmaBox_up133
const double getIntegrand_dsigmaBox_up133(double x) const
Definition: StandardModel/src/StandardModel.cpp:8848
StandardModel::GammaHtoss
virtual const double GammaHtoss() const
The in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3578
StandardModel::lambda
double lambda
The CKM parameter in the Wolfenstein parameterization.
Definition: StandardModel.h:3461
StandardModel::getIntegrand_sigmaWithISR_strange172
const double getIntegrand_sigmaWithISR_strange172(double x) const
Definition: StandardModel/src/StandardModel.cpp:8525
StandardModel::Qwn
virtual const double Qwn() const
The computation of the neutron weak charge: Qwn.
Definition: StandardModel/src/StandardModel.cpp:2889
StandardModel::als_cache
double als_cache[11][CacheSize]
Cache for .
Definition: StandardModel.h:4079
StandardModel::getIntegrand_AFBnumeratorWithISR_mu189
const double getIntegrand_AFBnumeratorWithISR_mu189(double x) const
Definition: StandardModel/src/StandardModel.cpp:9333
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:1155
StandardModel::getIntegrand_AFBnumeratorWithISR_bottom202
const double getIntegrand_AFBnumeratorWithISR_bottom202(double x) const
Definition: StandardModel/src/StandardModel.cpp:9582
StandardModel::getIntegrand_dsigmaBox_strange202
const double getIntegrand_dsigmaBox_strange202(double x) const
Definition: StandardModel/src/StandardModel.cpp:9173
StandardModel::getIntegrand_sigmaWithISR_mu202
const double getIntegrand_sigmaWithISR_mu202(double x) const
Definition: StandardModel/src/StandardModel.cpp:8116
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:9291
StandardModel::getIntegrand_sigmaWithISR_up189
const double getIntegrand_sigmaWithISR_up189(double x) const
Definition: StandardModel/src/StandardModel.cpp:8273
StandardModel::getIntegrand_dsigmaBox_down172
const double getIntegrand_dsigmaBox_down172(double x) const
Definition: StandardModel/src/StandardModel.cpp:8959
StandardModel::getIntegrand_dsigmaBox_tau161
const double getIntegrand_dsigmaBox_tau161(double x) const
Definition: StandardModel/src/StandardModel.cpp:8765
StandardModel::getIntegrand_sigmaWithISR_tau192
const double getIntegrand_sigmaWithISR_tau192(double x) const
Definition: StandardModel/src/StandardModel.cpp:8171
StandardModel::RZlilj
virtual const double RZlilj(const Particle li, const Particle lj) const
The lepton universality ratio .
Definition: StandardModel/src/StandardModel.cpp:1447
StandardModel::getIntegrand_dsigmaBox_strange136
const double getIntegrand_dsigmaBox_strange136(double x) const
Definition: StandardModel/src/StandardModel.cpp:9117
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:1088
StandardModel::getIntegrand_AFBnumeratorWithISR_charm189
const double getIntegrand_AFBnumeratorWithISR_charm189(double x) const
Definition: StandardModel/src/StandardModel.cpp:9489
StandardModel::getIntegrand_sigmaWithISR_up136
const double getIntegrand_sigmaWithISR_up136(double x) const
Definition: StandardModel/src/StandardModel.cpp:8243
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:654
StandardModel::getIntegrand_dsigmaBox_bottom192
const double getIntegrand_dsigmaBox_bottom192(double x) const
Definition: StandardModel/src/StandardModel.cpp:9243
StandardModel::Vcb
double Vcb
used as an input for FlagWolfenstein = FALSE
Definition: StandardModel.h:3467
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:1014
StandardModel::LEP2sigmaMu
virtual const double LEP2sigmaMu(const double s) const
Definition: StandardModel/src/StandardModel.cpp:4088
StandardModel::getIntegrand_dsigmaBox_mu205
const double getIntegrand_dsigmaBox_mu205(double x) const
Definition: StandardModel/src/StandardModel.cpp:8737
StandardModel::getIntegrand_sigmaWithISR_strange196
const double getIntegrand_sigmaWithISR_strange196(double x) const
Definition: StandardModel/src/StandardModel.cpp:8549
StandardModel::getIntegrand_sigmaWithISR_tau136
const double getIntegrand_sigmaWithISR_tau136(double x) const
Definition: StandardModel/src/StandardModel.cpp:8141
StandardModel::R0_f
virtual const double R0_f(const Particle f) const
The ratio .
Definition: StandardModel/src/StandardModel.cpp:1479
StandardModel::getIntegrand_dsigmaBox_up205
const double getIntegrand_dsigmaBox_up205(double x) const
Definition: StandardModel/src/StandardModel.cpp:8914
StandardModel::Mw_tree
const double Mw_tree() const
The tree-level mass of the boson, .
Definition: StandardModel/src/StandardModel.cpp:997
StandardModel::AlsE
const double AlsE(double mu, orders order, bool Nf_thr) const
Definition: StandardModel/src/StandardModel.cpp:674
StandardModel::getIntegrand_AFBnumeratorWithISR_mu200
const double getIntegrand_AFBnumeratorWithISR_mu200(double x) const
Definition: StandardModel/src/StandardModel.cpp:9351
StandardModel::getIntegrand_sigmaWithISR_up202
const double getIntegrand_sigmaWithISR_up202(double x) const
Definition: StandardModel/src/StandardModel.cpp:8297
StandardModel::useDeltaAlphaLepton_cache
bool useDeltaAlphaLepton_cache
Definition: StandardModel.h:4051
StandardModel::TauLFU_gtauge
virtual const double TauLFU_gtauge() const
The computation of the LFU ratio .
Definition: StandardModel/src/StandardModel.cpp:3211
StandardModel::etab
double etab
The CKM parameter in the Wolfenstein parameterization.
Definition: StandardModel.h:3464
StandardModel::getIntegrand_sigmaWithISR_down167
const double getIntegrand_sigmaWithISR_down167(double x) const
Definition: StandardModel/src/StandardModel.cpp:8343
StandardModel::getIntegrand_sigmaWithISR_mu205
const double getIntegrand_sigmaWithISR_mu205(double x) const
Definition: StandardModel/src/StandardModel.cpp:8122
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:3351
StandardModel::getIntegrand_sigmaWithISR_down133
const double getIntegrand_sigmaWithISR_down133(double x) const
Definition: StandardModel/src/StandardModel.cpp:8324
StandardModel::BrHtogg
virtual const double BrHtogg() const
The Br in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3646
StandardModel::myEWSMcache
EWSMcache * myEWSMcache
A pointer to an object of type EWSMcache.
Definition: StandardModel.h:4014
StandardModel::rhoZ_f_cache
gslpp::complex rhoZ_f_cache[12]
A cache of the value of .
Definition: StandardModel.h:4049
StandardModel::getIntegrand_AFBnumeratorWithISR_tau207
const double getIntegrand_AFBnumeratorWithISR_tau207(double x) const
Definition: StandardModel/src/StandardModel.cpp:9442
StandardModel::AFB_NoISR_l
const double AFB_NoISR_l(const QCD::lepton l_flavor, const double s) const
Definition: StandardModel/src/StandardModel.cpp:8028
StandardModel::epsilon3
virtual const double epsilon3() const
The SM contribution to the epsilon parameter .
Definition: StandardModel/src/StandardModel.cpp:1814
StandardModel::myLeptonFlavour
LeptonFlavour * myLeptonFlavour
A pointer to an object of the type LeptonFlavour.
Definition: StandardModel.h:4022
StandardModel::ale_cache
double ale_cache[10][CacheSize]
Cache for .
Definition: StandardModel.h:4080
StandardModel::getIntegrand_sigmaWithISR_charm136
const double getIntegrand_sigmaWithISR_charm136(double x) const
Definition: StandardModel/src/StandardModel.cpp:8419
StandardModel::getIntegrand_dsigmaBox_down130
const double getIntegrand_dsigmaBox_down130(double x) const
Definition: StandardModel/src/StandardModel.cpp:8929
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:1068
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:1957
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:3288
StandardModel::TauLFU_gtaugmu
virtual const double TauLFU_gtaugmu() const
The computation of the LFU ratio .
Definition: StandardModel/src/StandardModel.cpp:3188
StandardModel::getIntegrand_dsigmaBox_strange192
const double getIntegrand_dsigmaBox_strange192(double x) const
Definition: StandardModel/src/StandardModel.cpp:9155
StandardModel::N_nu
virtual const double N_nu() const
The number of neutrinos obtained indirectly from the measurements at the Z pole, .
Definition: StandardModel/src/StandardModel.cpp:1556
StandardModel::getIntegrand_sigmaWithISR_down189
const double getIntegrand_sigmaWithISR_down189(double x) const
Definition: StandardModel/src/StandardModel.cpp:8361
StandardModel::TauLFU_gmuge
virtual const double TauLFU_gmuge() const
The computation of the LFU ratio .
Definition: StandardModel/src/StandardModel.cpp:3165
StandardModel::ThetaLnuN
virtual const double ThetaLnuN() const
The effective neutrino nucleon LH parameter: ThetaLnuN.
Definition: StandardModel/src/StandardModel.cpp:3028
StandardModel::getIntegrand_dsigmaBox_charm196
const double getIntegrand_dsigmaBox_charm196(double x) const
Definition: StandardModel/src/StandardModel.cpp:9071
StandardModel::checkSMparamsForEWPO
bool checkSMparamsForEWPO()
A method to check whether the parameters relevant to the EWPO are updated.
Definition: StandardModel/src/StandardModel.cpp:556
StandardModel::getIntegrand_dsigmaBox_bottom161
const double getIntegrand_dsigmaBox_bottom161(double x) const
Definition: StandardModel/src/StandardModel.cpp:9213
StandardModel::BrHtoss
virtual const double BrHtoss() const
The Br in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3686
StandardModel::getIntegrand_sigmaWithISR_up207
const double getIntegrand_sigmaWithISR_up207(double x) const
Definition: StandardModel/src/StandardModel.cpp:8309
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:945
StandardModel::getIntegrand_sigmaWithISR_charm196
const double getIntegrand_sigmaWithISR_charm196(double x) const
Definition: StandardModel/src/StandardModel.cpp:8461
StandardModel::getIntegrand_AFBnumeratorWithISR_tau205
const double getIntegrand_AFBnumeratorWithISR_tau205(double x) const
Definition: StandardModel/src/StandardModel.cpp:9436
StandardModel::getIntegrand_sigmaWithISR_mu189
const double getIntegrand_sigmaWithISR_mu189(double x) const
Definition: StandardModel/src/StandardModel.cpp:8092
StandardModel::getIntegrand_sigmaWithISR_mu196
const double getIntegrand_sigmaWithISR_mu196(double x) const
Definition: StandardModel/src/StandardModel.cpp:8104
StandardModel::getIntegrand_AFBnumeratorWithISR_bottom167
const double getIntegrand_AFBnumeratorWithISR_bottom167(double x) const
Definition: StandardModel/src/StandardModel.cpp:9540
StandardModel::getIntegrand_sigmaWithISR_tau202
const double getIntegrand_sigmaWithISR_tau202(double x) const
Definition: StandardModel/src/StandardModel.cpp:8189
StandardModel::Mw_inp
double Mw_inp
The mass of the boson in GeV used as input for FlagMWinput = TRUE.
Definition: StandardModel.h:3447
StandardModel::getIntegrand_dsigmaBox_charm172
const double getIntegrand_dsigmaBox_charm172(double x) const
Definition: StandardModel/src/StandardModel.cpp:9047
StandardModel::orders_EW
orders_EW
An enumerated type representing perturbative orders of radiative corrections to EW precision observab...
Definition: StandardModel.h:527
StandardModel::EW1
@ EW1
One-loop of .
Definition: StandardModel.h:528
StandardModel::EW2QCD1
@ EW2QCD1
Three-loop of .
Definition: StandardModel.h:532
StandardModel::EW2
@ EW2
Two-loop of .
Definition: StandardModel.h:531
StandardModel::orders_EW_size
@ orders_EW_size
The size of this enum.
Definition: StandardModel.h:534
StandardModel::EW3
@ EW3
Three-loop of .
Definition: StandardModel.h:533
StandardModel::EW1QCD1
@ EW1QCD1
Two-loop of .
Definition: StandardModel.h:529
StandardModel::EW1QCD2
@ EW1QCD2
Three-loop of .
Definition: StandardModel.h:530
StandardModel::getIntegrand_dsigmaBox_charm136
const double getIntegrand_dsigmaBox_charm136(double x) const
Definition: StandardModel/src/StandardModel.cpp:9029
StandardModel::mHl
double mHl
The Higgs mass in GeV.
Definition: StandardModel.h:3451
StandardModel::getIntegrand_sigmaWithISR_up205
const double getIntegrand_sigmaWithISR_up205(double x) const
Definition: StandardModel/src/StandardModel.cpp:8303
StandardModel::getIntegrand_AFBnumeratorWithISR_charm196
const double getIntegrand_AFBnumeratorWithISR_charm196(double x) const
Definition: StandardModel/src/StandardModel.cpp:9501
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:3300
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:3497
StandardModel::getIntegrand_sigmaWithISR_bottom167
const double getIntegrand_sigmaWithISR_bottom167(double x) const
Definition: StandardModel/src/StandardModel.cpp:8607
StandardModel::getIntegrand_dsigmaBox_charm133
const double getIntegrand_dsigmaBox_charm133(double x) const
Definition: StandardModel/src/StandardModel.cpp:9023
StandardModel::getIntegrand_dsigmaBox_charm192
const double getIntegrand_dsigmaBox_charm192(double x) const
Definition: StandardModel/src/StandardModel.cpp:9065
StandardModel::getIntegrand_dsigmaBox_tau207
const double getIntegrand_dsigmaBox_tau207(double x) const
Definition: StandardModel/src/StandardModel.cpp:8819
StandardModel::ale
double ale
The fine-structure constant .
Definition: StandardModel.h:3449
StandardModel::flagLEP2
bool flagLEP2[NUMofLEP2RCs]
Definition: StandardModel.h:3728
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:901
StandardModel::getIntegrand_sigmaWithISR_bottom183
const double getIntegrand_sigmaWithISR_bottom183(double x) const
Definition: StandardModel/src/StandardModel.cpp:8619
StandardModel::AlsMz
double AlsMz
The strong coupling constant at the Z-boson mass, .
Definition: StandardModel.h:3445
StandardModel::delGammaZ
double delGammaZ
The theoretical uncertainty in , denoted as , in GeV.
Definition: StandardModel.h:3456
StandardModel::getIntegrand_AFBnumeratorWithISR_mu161
const double getIntegrand_AFBnumeratorWithISR_mu161(double x) const
Definition: StandardModel/src/StandardModel.cpp:9315
StandardModel::Ye
gslpp::matrix< gslpp::complex > Ye
The Yukawa matrix of the charged leptons.
Definition: StandardModel.h:3441
StandardModel::getIntegrand_dsigmaBox_down196
const double getIntegrand_dsigmaBox_down196(double x) const
Definition: StandardModel/src/StandardModel.cpp:8983
StandardModel::PostUpdate
virtual bool PostUpdate()
The post-update method for StandardModel.
Definition: StandardModel/src/StandardModel.cpp:241
StandardModel::getIntegrand_dsigmaBox_charm189
const double getIntegrand_dsigmaBox_charm189(double x) const
Definition: StandardModel/src/StandardModel.cpp:9059
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:1103
StandardModel::muw
double muw
A matching scale around the weak scale in GeV.
Definition: StandardModel.h:3470
StandardModel::RVh
double RVh() const
The singlet vector corrections to the hadronic -boson width, denoted as .
Definition: StandardModel/src/StandardModel.cpp:2408
StandardModel::useRhoZ_f_cache
bool useRhoZ_f_cache[12]
Definition: StandardModel.h:4055
StandardModel::alphaMz
virtual const double alphaMz() const
The electromagnetic coupling at the -mass scale, .
Definition: StandardModel/src/StandardModel.cpp:938
StandardModel::delR0b
double delR0b
The theoretical uncertainty in , denoted as .
Definition: StandardModel.h:3460
StandardModel::getIntegrand_AFBnumeratorWithISR_bottom133
const double getIntegrand_AFBnumeratorWithISR_bottom133(double x) const
Definition: StandardModel/src/StandardModel.cpp:9534
StandardModel::DeltaAlpha
const double DeltaAlpha() const
The total corrections to the electromagnetic coupling at the -mass scale, denoted as .
Definition: StandardModel/src/StandardModel.cpp:926
StandardModel::getIntegrand_sigmaWithISR_up161
const double getIntegrand_sigmaWithISR_up161(double x) const
Definition: StandardModel/src/StandardModel.cpp:8249
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:278
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:3256
StandardModel::getIntegrand_dsigmaBox_mu130
const double getIntegrand_dsigmaBox_mu130(double x) const
Definition: StandardModel/src/StandardModel.cpp:8677
StandardModel::getIntegrand_sigmaWithISR_mu200
const double getIntegrand_sigmaWithISR_mu200(double x) const
Definition: StandardModel/src/StandardModel.cpp:8110
StandardModel::getIntegrand_dsigmaBox_charm207
const double getIntegrand_dsigmaBox_charm207(double x) const
Definition: StandardModel/src/StandardModel.cpp:9095
StandardModel::CacheSize
static const int CacheSize
Defines the depth of the cache.
Definition: StandardModel.h:4078
StandardModel::getIntegrand_AFBnumeratorWithISR_tau189
const double getIntegrand_AFBnumeratorWithISR_tau189(double x) const
Definition: StandardModel/src/StandardModel.cpp:9406
StandardModel::NumSMParamsForEWPO
static const int NumSMParamsForEWPO
The number of the SM parameters that are relevant to the EW precision observables.
Definition: StandardModel.h:2100
StandardModel::getIntegrand_sigmaWithISR_tau172
const double getIntegrand_sigmaWithISR_tau172(double x) const
Definition: StandardModel/src/StandardModel.cpp:8153
StandardModel::Vus
double Vus
used as an input for FlagWolfenstein = FALSE
Definition: StandardModel.h:3465
StandardModel::GammaHtoWWstar
virtual const double GammaHtoWWstar() const
The in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3410
StandardModel::getIntegrand_AFBnumeratorWithISR_charm167
const double getIntegrand_AFBnumeratorWithISR_charm167(double x) const
Definition: StandardModel/src/StandardModel.cpp:9471
StandardModel::getIntegrand_sigmaWithISR_mu183
const double getIntegrand_sigmaWithISR_mu183(double x) const
Definition: StandardModel/src/StandardModel.cpp:8086
StandardModel::myTwoLoopQCD
EWSMTwoLoopQCD * myTwoLoopQCD
A pointer to an object of type EWSMTwoLoopQCD.
Definition: StandardModel.h:4016
StandardModel::LEP2dsigmadcosTau
virtual const double LEP2dsigmadcosTau(const double s, const double cos) const
Definition: StandardModel/src/StandardModel.cpp:9630
StandardModel::GammaHtomumu
virtual const double GammaHtomumu() const
The in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3528
StandardModel::getIntegrand_AFBnumeratorWithISR_tau161
const double getIntegrand_AFBnumeratorWithISR_tau161(double x) const
Definition: StandardModel/src/StandardModel.cpp:9388
StandardModel::GeVminus2_to_nb
static const double GeVminus2_to_nb
Definition: StandardModel.h:546
StandardModel::FlagWolfenstein
bool FlagWolfenstein
A boolean for the model flag Wolfenstein.
Definition: StandardModel.h:4032
StandardModel::getIntegrand_sigmaWithISR_down172
const double getIntegrand_sigmaWithISR_down172(double x) const
Definition: StandardModel/src/StandardModel.cpp:8349
StandardModel::LEP2sigmaBottom
virtual const double LEP2sigmaBottom(const double s) const
Definition: StandardModel/src/StandardModel.cpp:4814
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:3310
StandardModel::getIntegrand_dsigmaBox_tau130
const double getIntegrand_dsigmaBox_tau130(double x) const
Definition: StandardModel/src/StandardModel.cpp:8753
StandardModel::DeltaRbar
virtual const double DeltaRbar() const
The SM prediction for derived from that for the -boson mass.
Definition: StandardModel/src/StandardModel.cpp:1222
StandardModel::getIntegrand_dsigmaBox_strange133
const double getIntegrand_dsigmaBox_strange133(double x) const
Definition: StandardModel/src/StandardModel.cpp:9111
StandardModel::getIntegrand_dsigmaBox_tau205
const double getIntegrand_dsigmaBox_tau205(double x) const
Definition: StandardModel/src/StandardModel.cpp:8813
StandardModel::requireYe
bool requireYe
An internal flag to control whether the charged-lepton Yukawa matrix has to be recomputed.
Definition: StandardModel.h:3715
StandardModel::myThreeLoopEW2QCD
EWSMThreeLoopEW2QCD * myThreeLoopEW2QCD
A pointer to an object of type EWSMThreeLoopEW2QCD.
Definition: StandardModel.h:4019
StandardModel::getIntegrand_dsigmaBox_charm200
const double getIntegrand_dsigmaBox_charm200(double x) const
Definition: StandardModel/src/StandardModel.cpp:9077
StandardModel::v
const double v() const
The Higgs vacuum expectation value.
Definition: StandardModel/src/StandardModel.cpp:989
StandardModel::getIntegrand_sigmaWithISR_up196
const double getIntegrand_sigmaWithISR_up196(double x) const
Definition: StandardModel/src/StandardModel.cpp:8285
StandardModel::getIntegrand_dsigmaBox_up196
const double getIntegrand_dsigmaBox_up196(double x) const
Definition: StandardModel/src/StandardModel.cpp:8896
StandardModel::getIntegrand_sigmaWithISR_bottom189
const double getIntegrand_sigmaWithISR_bottom189(double x) const
Definition: StandardModel/src/StandardModel.cpp:8625
StandardModel::getIntegrand_AFBnumeratorWithISR_bottom183
const double getIntegrand_AFBnumeratorWithISR_bottom183(double x) const
Definition: StandardModel/src/StandardModel.cpp:9552
StandardModel::LEP2dsigmadcosE
virtual const double LEP2dsigmadcosE(const double s, const double cos) const
Definition: StandardModel/src/StandardModel.cpp:9604
StandardModel::Update
virtual bool Update(const std::map< std::string, double > &DPars)
The update method for StandardModel.
Definition: StandardModel/src/StandardModel.cpp:225
StandardModel::getIntegrand_sigmaWithISR_bottom161
const double getIntegrand_sigmaWithISR_bottom161(double x) const
Definition: StandardModel/src/StandardModel.cpp:8601
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:3304
StandardModel::getIntegrand_sigmaWithISR_mu192
const double getIntegrand_sigmaWithISR_mu192(double x) const
Definition: StandardModel/src/StandardModel.cpp:8098
StandardModel::getIntegrand_dsigmaBox_up189
const double getIntegrand_dsigmaBox_up189(double x) const
Definition: StandardModel/src/StandardModel.cpp:8884
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:1204
StandardModel::getIntegrand_AFBnumeratorWithISR_mu183
const double getIntegrand_AFBnumeratorWithISR_mu183(double x) const
Definition: StandardModel/src/StandardModel.cpp:9327
StandardModel::getIntegrand_dsigmaBox_up136
const double getIntegrand_dsigmaBox_up136(double x) const
Definition: StandardModel/src/StandardModel.cpp:8854
StandardModel::useKappaZ_f_cache
bool useKappaZ_f_cache[12]
Definition: StandardModel.h:4056
StandardModel::getIntegrand_dsigmaBox_charm202
const double getIntegrand_dsigmaBox_charm202(double x) const
Definition: StandardModel/src/StandardModel.cpp:9083
StandardModel::ThetaRnuN
virtual const double ThetaRnuN() const
The effective neutrino nucleon RH parameter: ThetaRnuN.
Definition: StandardModel/src/StandardModel.cpp:3042
StandardModel::intMLL2eeeeus2
const double intMLL2eeeeus2(const double s, const double t0, const double t1) const
Definition: StandardModel/src/StandardModel.cpp:3967
StandardModel::DeltaAlphaLepton
const double DeltaAlphaLepton(const double s) const
Leptonic contribution to the electromagnetic coupling , denoted as .
Definition: StandardModel/src/StandardModel.cpp:873
StandardModel::getIntegrand_sigmaWithISR_charm189
const double getIntegrand_sigmaWithISR_charm189(double x) const
Definition: StandardModel/src/StandardModel.cpp:8449
StandardModel::getIntegrand_sigmaWithISR_down205
const double getIntegrand_sigmaWithISR_down205(double x) const
Definition: StandardModel/src/StandardModel.cpp:8391
StandardModel::gV_f
virtual const gslpp::complex gV_f(const Particle f) const
The effective leptonic neutral-current vector coupling in the SM.
Definition: StandardModel/src/StandardModel.cpp:1577
StandardModel::getIntegrand_dsigmaBox_up172
const double getIntegrand_dsigmaBox_up172(double x) const
Definition: StandardModel/src/StandardModel.cpp:8872
StandardModel::getIntegrand_sigmaWithISR_up130
const double getIntegrand_sigmaWithISR_up130(double x) const
Definition: StandardModel/src/StandardModel.cpp:8231
StandardModel::MLR2eeff
const double MLR2eeff(const Particle f, const double s) const
Definition: StandardModel/src/StandardModel.cpp:3703
StandardModel::gAnue
virtual const double gAnue() const
The effective (muon) neutrino-electron axial-vector coupling: gAnue.
Definition: StandardModel/src/StandardModel.cpp:3068
StandardModel::FlagCacheInStandardModel
bool FlagCacheInStandardModel
A flag for caching (true by default).
Definition: StandardModel.h:4043
StandardModel::SMSuccess
bool SMSuccess
A boolean for the success of the Standard Model update and matching.
Definition: StandardModel.h:4038
StandardModel::InitializeModel
virtual bool InitializeModel()
A method to initialize the model.
Definition: StandardModel/src/StandardModel.cpp:174
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:1870
StandardModel::getIntegrand_AFBnumeratorWithISR_charm192
const double getIntegrand_AFBnumeratorWithISR_charm192(double x) const
Definition: StandardModel/src/StandardModel.cpp:9495
StandardModel::getIntegrand_dsigmaBox_down205
const double getIntegrand_dsigmaBox_down205(double x) const
Definition: StandardModel/src/StandardModel.cpp:9001
StandardModel::cW2
virtual const double cW2() const
Definition: StandardModel/src/StandardModel.cpp:1081
StandardModel::getIntegrand_dsigmaBox_down192
const double getIntegrand_dsigmaBox_down192(double x) const
Definition: StandardModel/src/StandardModel.cpp:8977
StandardModel::GammaHTot
virtual const double GammaHTot() const
The total Higgs width in the Standard Model.
Definition: StandardModel/src/StandardModel.cpp:3630
StandardModel::LEP2AFBbottom
virtual const double LEP2AFBbottom(const double s) const
Definition: StandardModel/src/StandardModel.cpp:6157
StandardModel::DeltaAlpha_cache
double DeltaAlpha_cache
A cache of the value of .
Definition: StandardModel.h:4046
StandardModel::gVnue
virtual const double gVnue() const
The effective (muon) neutrino-electron vector coupling: gVnue.
Definition: StandardModel/src/StandardModel.cpp:3055
StandardModel::AlsEWithInit
const double AlsEWithInit(double mu, double alsi, double mu_i, const int nf_i, orders order) const
Definition: StandardModel/src/StandardModel.cpp:749
StandardModel::delR0l
double delR0l
The theoretical uncertainty in , denoted as .
Definition: StandardModel.h:3458
StandardModel::LEP2dsigmadcosBinMu
virtual const double LEP2dsigmadcosBinMu(const double s, const double cos, const double cosmin, const double cosmax) const
Definition: StandardModel/src/StandardModel.cpp:9651
StandardModel::getIntegrand_sigmaWithISR_down161
const double getIntegrand_sigmaWithISR_down161(double x) const
Definition: StandardModel/src/StandardModel.cpp:8337
StandardModel::getIntegrand_dsigmaBox_bottom136
const double getIntegrand_dsigmaBox_bottom136(double x) const
Definition: StandardModel/src/StandardModel.cpp:9207
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