a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
EWSM_Output Class Reference

A class for testing SM radiative corrections to the EW precision obsrvables. More...

#include <EWSM_Output.h>

+ Inheritance diagram for EWSM_Output:

Detailed Description

A class for testing SM radiative corrections to the EW precision obsrvables.

Author
HEPfit Collaboration

Definition at line 22 of file EWSM_Output.h.

Public Member Functions

 EWSM_Output (const StandardModel &SM_in)
 Constructor. More...
 
void outputEachDeltaKappaZ (const double f_AlphaToGF, const double cW2overSW2, const double DeltaRho[StandardModel::orders_EW_size], const double deltaKappa_rem[StandardModel::orders_EW_size], const double DeltaRbar_rem, const bool bool_Zbb, const double taub[StandardModel::orders_EW_size], const double ZbbSubtract, const double Zgamma_EW2) const
 
void outputEachDeltaKappaZ_l (const QCD::lepton l, const double Mw_i) const
 
void outputEachDeltaKappaZ_q (const QCD::quark q, const double Mw_i) const
 
void outputEachDeltaR (const double Mw_i) const
 
void outputEachDeltaRhoZ (const double f_AlphaToGF, const double DeltaRho[StandardModel::orders_EW_size], const double deltaRho_rem[StandardModel::orders_EW_size], const double DeltaRbar_rem, const bool bool_Zbb, const double taub[StandardModel::orders_EW_size], const double ZbbSubtract) const
 
void outputEachDeltaRhoZ_l (const QCD::lepton l, const double Mw_i) const
 
void outputEachDeltaRhoZ_q (const QCD::quark q, const double Mw_i) const
 
- Public Member Functions inherited from StandardModel
virtual double A_f (const Particle f) const
 The left-right asymmetry in \(e^+e^-\to Z\to \ell \bar{\ell}\) at the \(Z\)-pole, \(\mathcal{A}_\ell\). More...
 
virtual double AFB (const Particle f) const
 
double Ale (double mu, orders order, bool Nf_thr=true) const
 The running electromagnetic coupling \(\alpha_e(\mu)\) in the \(\overline{MS}\) scheme. More...
 
double ale_OS (const double mu, orders order=FULLNLO) const
 The running electromagnetic coupling \(\alpha(\mu)\) in the on-shell scheme. More...
 
double alphaMz () const
 The electromagnetic coupling at the \(Z\)-mass scale, \(\alpha(M_Z^2)=\alpha/(1-\Delta\alpha(M_Z^2))\). More...
 
double Als (double mu, orders order=FULLNLO, bool qed_flag=false, bool Nf_thr=true) const
 The running QCD coupling \(\alpha(\mu)\) in the \(\overline{MS}\) scheme including QED corrections. More...
 
double AlsByOrder (double mu, orders order=FULLNLO, bool qed_flag=false, bool Nf_thr=true) const
 
double Alstilde5 (const double mu) const
 The value of \(\frac{\alpha_s^{\mathrm{FULLNLO}}}{4\pi}\) at any scale \(\mu\) with the number of flavours \(n_f = 4\) and full EW corrections. More...
 
double Beta_e (int nm, unsigned int nf) const
 QED beta function coefficients - eq. (36) hep-ph/0512066. More...
 
double Beta_s (int nm, unsigned int nf) const
 QCD beta function coefficients including QED corrections - eq. (36) hep-ph/0512066. More...
 
double c02 () const
 The square of the cosine of the weak mixing angle \(c_0^2\) defined without weak radiative corrections. More...
 
virtual bool CheckFlags () const
 A method to check the sanity of the set of model flags. More...
 
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 initialization. More...
 
bool checkSMparamsForEWPO ()
 A method to check whether the parameters relevant to the EWPO are updated. More...
 
double computeBrHtobb () const
 The Br \((H\to bb)\) in the Standard Model. More...
 
double computeBrHtocc () const
 The Br \((H\to cc)\) in the Standard Model. More...
 
double computeBrHtogaga () const
 The Br \((H\to\gamma\gamma)\) in the Standard Model. More...
 
double computeBrHtogg () const
 The Br \((H\to gg)\) in the Standard Model. More...
 
double computeBrHtomumu () const
 The Br \((H\to \mu\mu)\) in the Standard Model. More...
 
double computeBrHtoss () const
 The Br \((H\to ss)\) in the Standard Model. More...
 
double computeBrHtotautau () const
 The Br \((H\to \tau\tau)\) in the Standard Model. More...
 
double computeBrHtoWW () const
 The Br \((H\to WW)\) in the Standard Model. More...
 
double computeBrHtoZga () const
 The Br \((H\to Z\gamma)\) in the Standard Model. More...
 
double computeBrHtoZZ () const
 The Br \((H\to ZZ)\) in the Standard Model. More...
 
double computeBrHtoZZinv () const
 The Br \((H\to ZZ \to inv)\) in the Standard Model. More...
 
void ComputeDeltaR_rem (const double Mw_i, double DeltaR_rem[orders_EW_size]) const
 A method to collect \(\Delta r_{\mathrm{rem}}\) computed via subclasses. More...
 
void ComputeDeltaRho (const double Mw_i, double DeltaRho[orders_EW_size]) const
 A method to collect \(\Delta\rho\) computed via subclasses. More...
 
double computeGammaHgaga_tt () const
 The top loop contribution to \(H\to\gamma\gamma\) in the Standard Model. More...
 
double computeGammaHgaga_tW () const
 The mixed \(t-W\) loop contribution to \(H\to\gamma\gamma\) in the Standard Model. More...
 
double computeGammaHgaga_WW () const
 The \(W\) loop contribution to \(H\to\gamma\gamma\) in the Standard Model. More...
 
double computeGammaHgg_bb () const
 The bottom loop contribution to \(H\to gg\) in the Standard Model. More...
 
double computeGammaHgg_tb () const
 The top-bottom interference contribution to \(H\to gg\) in the Standard Model. More...
 
double computeGammaHgg_tt () const
 The top loop contribution to \(H\to gg\) in the Standard Model. More...
 
double computeGammaHTotal () const
 The Higgs total width in the Standard Model. More...
 
double computeGammaHZga_tt () const
 The top loop contribution to \(H\to Z\gamma\) in the Standard Model. More...
 
double computeGammaHZga_tW () const
 The mixed \(t-W\) loop contribution to \(H\to Z\gamma\) in the Standard Model. More...
 
double computeGammaHZga_WW () const
 The \(W\) loop contribution to \(H\to Z\gamma\) in the Standard Model. Currently it returns the value of tab 41 in ref. [137]. More...
 
double computeSigmaggH (const double sqrt_s) const
 The ggH cross section in the Standard Model. More...
 
double computeSigmaggH_bb (const double sqrt_s) const
 The square of the bottom-quark contribution to the ggH cross section in the Standard Model. More...
 
double computeSigmaggH_tb (const double sqrt_s) const
 The top-bottom interference contribution to the ggH cross section in the Standard Model. More...
 
double computeSigmaggH_tt (const double sqrt_s) const
 The square of the top-quark contribution to the ggH cross section in the Standard Model. More...
 
double computeSigmattH (const double sqrt_s) const
 The ttH production cross section in the Standard Model. More...
 
double computeSigmaVBF (const double sqrt_s) const
 The VBF cross section in the Standard Model. More...
 
double computeSigmaWF (const double sqrt_s) const
 The W fusion contribution \(\sigma_{WF}\) to higgs-production cross section in the Standard Model. More...
 
double computeSigmaWH (const double sqrt_s) const
 The WH production cross section in the Standard Model. More...
 
double computeSigmaZF (const double sqrt_s) const
 The Z fusion contribution \(\sigma_{ZF}\) to higgs-production cross section in the Standard Model. More...
 
double computeSigmaZH (const double sqrt_s) const
 The ZH production cross section in the Standard Model. More...
 
double computeSigmaZWF (const double sqrt_s) const
 The Z W interference fusion contribution \(\sigma_{ZWF}\) to higgs-production cross section in the Standard Model. More...
 
virtual double cW2 () const
 
virtual double cW2 (const double Mw_i) const
 The square of the cosine of the weak mixing angle in the on-shell scheme, denoted as \(c_W^2\). More...
 
double DeltaAlpha () const
 The total corrections to the electromagnetic coupling \(\alpha\) at the \(Z\)-mass scale, denoted as \(\Delta\alpha(M_Z^2)\). More...
 
double DeltaAlphaL5q () const
 The sum of the leptonic and the five-flavour hadronic corrections to the electromagnetic coupling \(\alpha\) at the \(Z\)-mass scale, denoted as \(\Delta\alpha^{\ell+5q}(M_Z^2)\). More...
 
double DeltaAlphaLepton (const double s) const
 Leptonic contribution to the electromagnetic coupling \(\alpha\), denoted as \(\Delta\alpha_{\mathrm{lept}}(s)\). More...
 
double DeltaAlphaTop (const double s) const
 Top-quark contribution to the electromagnetic coupling \(\alpha\), denoted as \(\Delta\alpha_{\mathrm{top}}(s)\). More...
 
virtual gslpp::complex deltaKappaZ_f (const Particle f) const
 Flavour non-universal vertex corrections to \(\kappa_Z^l\), denoted by \(\Delta\kappa_Z^l\). More...
 
virtual double DeltaR () const
 The SM prediction for \(\Delta r\) derived from that for the \(W\) boson mass. More...
 
virtual double DeltaRbar () const
 The SM prediction for \(\Delta \overline{r}\) derived from that for the \(W\)-boson mass. More...
 
virtual gslpp::complex deltaRhoZ_f (const Particle f) const
 Flavour non-universal vertex corrections to \(\rho_Z^l\), denoted by \(\Delta\rho_Z^l\). More...
 
virtual double epsilon1 () const
 The SM contribution to the epsilon parameter \(\varepsilon_1\). More...
 
virtual double epsilon2 () const
 The SM contribution to the epsilon parameter \(\varepsilon_2\). More...
 
virtual double epsilon3 () const
 The SM contribution to the epsilon parameter \(\varepsilon_3\). More...
 
virtual double epsilonb () const
 The SM contribution to the epsilon parameter \(\varepsilon_b\). More...
 
virtual gslpp::complex gA_f (const Particle f) const
 The effective leptonic neutral-current axial-vector coupling \(g_A^l\) in the SM. More...
 
virtual double Gamma_had () const
 The hadronic decay width of the \(Z\) boson, \(\Gamma_{h}\). More...
 
virtual double Gamma_inv () const
 The invisible partial decay width of the \(Z\) boson, \(\Gamma_{\mathrm{inv}}\). More...
 
virtual double Gamma_Z () const
 The total decay width of the \(Z\) boson, \(\Gamma_Z\). More...
 
virtual double GammaW () const
 The total width of the \(W\) boson, \(\Gamma_W\). More...
 
virtual double GammaW (const Particle fi, const Particle fj) const
 A partial decay width of the \(W\) boson decay into a SM fermion pair. More...
 
virtual double GammaZ (const Particle f) const
 The \(Z\to \ell\bar{\ell}\) partial decay width, \(\Gamma_\ell\). More...
 
double getAle () const
 A get method to retrieve the fine-structure constant \(\alpha\). More...
 
double getAlsMz () const
 A get method to access the value of \(\alpha_s(M_Z)\). More...
 
virtual double getCBd () const
 The ratio of the absolute value of the $B_d$ mixing amplitude over the Standard Model value. More...
 
virtual double getCBs () const
 The ratio of the absolute value of the $B_s$ mixing amplitude over the Standard Model value. More...
 
virtual double getCCC1 () const
 A virtual implementation for the RealWeakEFTCC class. More...
 
virtual double getCCC2 () const
 A virtual implementation for the RealWeakEFTCC class. More...
 
virtual double getCCC3 () const
 A virtual implementation for the RealWeakEFTCC class. More...
 
virtual double getCCC4 () const
 A virtual implementation for the RealWeakEFTCC class. More...
 
virtual double getCCC5 () const
 A virtual implementation for the RealWeakEFTCC class. More...
 
virtual double getCDMK () const
 The ratio of the real part of the $K$ mixing amplitude over the Standard Model value. More...
 
virtual double getCepsK () const
 The ratio of the imaginary part of the $K$ mixing amplitude over the Standard Model value. More...
 
CKM getCKM () const
 A get method to retrieve the member object of type CKM. More...
 
double getDAle5Mz () const
 A get method to retrieve the five-flavour hadronic contribution to the electromagnetic coupling, \(\Delta\alpha_{\mathrm{had}}^{(5)}(M_Z^2)\). More...
 
double getDelGammaZ () const
 A get method to retrieve the theoretical uncertainty in \(\Gamma_Z\), denoted as \(\delta\,\Gamma_Z\). More...
 
double getDelMw () const
 A get method to retrieve the theoretical uncertainty in \(M_W\), denoted as \(\delta\,M_W\). More...
 
double getDelR0b () const
 A get method to retrieve the theoretical uncertainty in \(R_b^0\), denoted as \(\delta\,R_b^0\). More...
 
double getDelR0c () const
 A get method to retrieve the theoretical uncertainty in \(R_c^0\), denoted as \(\delta\,R_c^0\). More...
 
double getDelR0l () const
 A get method to retrieve the theoretical uncertainty in \(R_l^0\), denoted as \(\delta\,R_l^0\). More...
 
double getDelSigma0H () const
 A get method to retrieve the theoretical uncertainty in \(\sigma_{Hadron}^0\), denoted as \(\delta\,\sigma_{Hadron}^0\). More...
 
double getDelSin2th_b () const
 A get method to retrieve the theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{b}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{b}\). More...
 
double getDelSin2th_l () const
 A get method to retrieve the theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{\rm lept}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{\rm lept}\). More...
 
double getDelSin2th_q () const
 A get method to retrieve the theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{q\not = b,t}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{q\not = b,t}\). More...
 
std::string getFlagKappaZ () const
 A method to retrieve the model flag KappaZ. More...
 
std::string getFlagMw () const
 A method to retrieve the model flag Mw. More...
 
std::string getFlagRhoZ () const
 A method to retrieve the model flag RhoZ. More...
 
const FlavourgetFlavour () const
 
double getGF () const
 A get method to retrieve the Fermi constant \(G_\mu\). More...
 
int getIterationNo () const
 
Particle getLeptons (const QCD::lepton p) const
 A get method to retrieve the member object of a lepton. More...
 
virtual StandardModelMatchinggetMatching () const
 A get method to access the member reference of type StandardModelMatching. More...
 
virtual double getMHl () const
 A get method to retrieve the Higgs mass \(m_h\). More...
 
virtual double getmq (const QCD::quark q, const double mu) const
 
double getMuw () const
 A get method to retrieve the matching scale \(\mu_W\) around the weak scale. More...
 
EWSMApproximateFormulaegetMyApproximateFormulae () const
 A get method to retrieve the member pointer of type EWSMApproximateFormulae. More...
 
EWSMcachegetMyEWSMcache () const
 A get method to retrieve the member pointer of type EWSMcache. More...
 
LeptonFlavourgetMyLeptonFlavour () const
 
EWSMOneLoopEWgetMyOneLoopEW () const
 A get method to retrieve the member pointer of type EWSMOneLoopEW,. More...
 
EWSMThreeLoopEWgetMyThreeLoopEW () const
 
EWSMThreeLoopEW2QCDgetMyThreeLoopEW2QCD () const
 
EWSMThreeLoopQCDgetMyThreeLoopQCD () const
 
EWSMTwoLoopEWgetMyTwoLoopEW () const
 
EWSMTwoLoopQCDgetMyTwoLoopQCD () const
 
double getMz () const
 A get method to access the mass of the \(Z\) boson \(M_Z\). More...
 
virtual double getPhiBd () const
 Half the relative phase of the $B_d$ mixing amplitude w.r.t. the Standard Model one. More...
 
virtual double getPhiBs () const
 Half the relative phase of the $B_s$ mixing amplitude w.r.t. the Standard Model one. More...
 
virtual StandardModel getTrueSM () const
 
gslpp::matrix< gslpp::complexgetUPMNS () const
 A get method to retrieve the object of the PMNS matrix. More...
 
gslpp::matrix< gslpp::complexgetVCKM () const
 A get method to retrieve the CKM matrix. More...
 
gslpp::matrix< gslpp::complexgetYd () const
 A get method to retrieve the Yukawa matrix of the down-type quarks, \(Y_d\). More...
 
gslpp::matrix< gslpp::complexgetYe () const
 A get method to retrieve the Yukawa matrix of the charged leptons, \(Y_e\). More...
 
gslpp::matrix< gslpp::complexgetYn () const
 A get method to retrieve the Yukawa matrix of the neutrinos, \(Y_\nu\). More...
 
gslpp::matrix< gslpp::complexgetYu () const
 A get method to retrieve the Yukawa matrix of the up-type quarks, \(Y_u\). More...
 
virtual gslpp::complex gV_f (const Particle f) const
 The effective leptonic neutral-current vector coupling \(g_V^l\) in the SM. More...
 
virtual bool Init (const std::map< std::string, double > &DPars)
 A method to initialize the model parameters. More...
 
virtual bool InitializeModel ()
 A method to initialize the model. More...
 
bool IsFlagNoApproximateGammaZ () const
 A method to retrieve the model flag NoApproximateGammaZ. More...
 
bool IsFlagWithoutNonUniversalVC () const
 A method to retrieve the model flag WithoutNonUniversalVC. More...
 
virtual gslpp::complex kappaZ_f (const Particle f) const
 The effective leptonic neutral-current coupling \(\kappa_Z^l\) in the SM. More...
 
virtual double Mw () const
 The SM prediction for the \(W\)-boson mass in the on-shell scheme, \(M_{W,\mathrm{SM}}\). More...
 
virtual double Mw_tree () const
 The tree-level mass of the \(W\) boson, \(M_W^{\mathrm{tree}}\). More...
 
double MwbarFromMw (const double Mw) const
 A method to convert the \(W\)-boson mass in the experimental/running-width scheme to that in the complex-pole/fixed-width scheme. More...
 
double MwFromMwbar (const double Mwbar) const
 A method to convert the \(W\)-boson mass in the complex-pole/fixed-width scheme to that in the experimental/running-width scheme. More...
 
double Mzbar () const
 The \(Z\)-boson mass \(\overline{M}_Z\) in the complex-pole/fixed-width scheme. More...
 
virtual double N_nu () const
 The number of neutrinos obtained indirectly from the measurements at the Z pole, \(N_{\nu}\). More...
 
virtual bool PostUpdate ()
 The post-update method for StandardModel. More...
 
virtual bool PreUpdate ()
 The pre-update method for StandardModel. More...
 
virtual double R0_f (const Particle f) const
 The ratio \(R_\ell^0=\Gamma(Z\to {\rm hadrons})/\Gamma(Z\to \ell^+ \ell^-)\). More...
 
virtual double R_inv () const
 The ratio of the invisible and leptonic (electron) decay widths of the \(Z\) boson, \(R_{inv}\). More...
 
virtual double rho_GammaW (const Particle fi, const Particle fj) const
 EW radiative corrections to the width of \(W \to f_i \bar{f}_j\), denoted as \(\rho^W_{ij}\). More...
 
virtual gslpp::complex rhoZ_f (const Particle f) const
 The effective leptonic neutral-current coupling \(\rho_Z^l\) in the SM. More...
 
double s02 () const
 The square of the sine of the weak mixing angle \(s_0^2\) defined without weak radiative corrections. More...
 
virtual bool setFlag (const std::string name, const bool value)
 A method to set a flag of StandardModel. More...
 
void setFlagCacheInStandardModel (bool FlagCacheInStandardModel)
 A set method to change the model flag CacheInStandardModel of StandardModel. More...
 
void setFlagNoApproximateGammaZ (bool FlagNoApproximateGammaZ)
 
virtual bool setFlagStr (const std::string name, const std::string value)
 A method to set a flag of StandardModel. More...
 
virtual double sigma0_had () const
 The hadronic cross section for \(e^+e^- \to Z \to \mathrm{hadrons}\) at the \(Z\)-pole, \(\sigma_h^0\). More...
 
virtual double sin2thetaEff (const Particle f) const
 The effective weak mixing angle \(\sin^2\theta_{\rm eff}^{\,\ell}\) for \(Z\ell\bar{\ell}\) at the the \(Z\)-mass scale. More...
 
 StandardModel ()
 The default constructor. More...
 
double sW2 () const
 
virtual double sW2 (const double Mw_i) const
 The square of the sine of the weak mixing angle in the on-shell scheme, denoted as \(s_W^2\). More...
 
virtual bool Update (const std::map< std::string, double > &DPars)
 The update method for StandardModel. More...
 
virtual double v () const
 The Higgs vacuum expectation value. More...
 
virtual ~StandardModel ()
 The default destructor. More...
 
- Public Member Functions inherited from QCD
double AboveTh (const double mu) const
 The active flavour threshold above the scale \(\mu\) as defined in QCD::Thresholds(). More...
 
void addParameters (std::vector< std::string > params_i)
 A method to add parameters that are specific to only one set of observables. More...
 
virtual double Als (const double mu, const orders order=FULLNLO, bool Nf_thr=true) const
 
double Als4 (const double mu) const
 The value of \(\alpha_s^{\mathrm{FULLNLO}}\) at any scale \(\mu\) with the number of flavours \(n_f = 4\). More...
 
virtual double AlsByOrder (const double mu, const orders order=FULLNLO, bool Nf_thr=true) const
 
double AlsOLD (const double mu, const orders order=FULLNLO) const
 Computes the running strong coupling \(\alpha_s(\mu)\) in the \(\overline{\mathrm{MS}}\) scheme. In the cases of LO, NLO and FULLNNLO, the coupling is computed with AlsWithInit(). On the other hand, in the cases of NNLO and FULLNNLO, the coupling is computed with AlsWithLambda(). More...
 
double AlsWithInit (const double mu, const double alsi, const double mu_i, const orders order) const
 Computes the running strong coupling \(\alpha_s(\mu)\) from \(\alpha_s(\mu_i)\) in the \(\overline{\mathrm{MS}}\) scheme, where it is forbidden to across a flavour threshold in the RG running from \(\mu_i\) to \(\mu\). More...
 
double AlsWithLambda (const double mu, const orders order) const
 Computes the running strong coupling \(\alpha_s(\mu)\) in the \(\overline{\mathrm{MS}}\) scheme with the use of \(\Lambda_{\rm QCD}\). More...
 
double BelowTh (const double mu) const
 The active flavour threshold below the scale \(\mu\) as defined in QCD::Thresholds(). More...
 
double Beta0 (const double nf) const
 The \(\beta_0(n_f)\) coefficient for a certain number of flavours \(n_f\). More...
 
double Beta1 (const double nf) const
 The \(\beta_1(n_f)\) coefficient for a certain number of flavours \(n_f\). More...
 
double Beta2 (const double nf) const
 The \(\beta_2(n_f)\) coefficient for a certain number of flavours \(n_f\). More...
 
double Beta3 (const double nf) const
 The \(\beta_3(n_f)\) coefficient for a certain number of flavours \(n_f\). More...
 
void CacheShift (double cache[][5], int n) const
 A member used to manage the caching for this class. More...
 
void CacheShift (int cache[][5], int n) const
 
orders FullOrder (orders order) const
 Return the FULLORDER enum corresponding to order. More...
 
double Gamma0 (const double nf) const
 The \(\gamma_0\) coefficient used to compute the running of a mass. More...
 
double Gamma1 (const double nf) const
 The \(\gamma_1\) coefficient used to compute the running of a mass. More...
 
double Gamma2 (const double nf) const
 The \(\gamma_2\) coefficient used to compute the running of a mass. More...
 
double getAlsM () const
 A get method to access the value of \(\alpha_s(M_{\alpha_s})\). More...
 
BParameter getBBd () const
 For getting the bag parameters corresponding to the operator basis \(O_1 -O_5\) in \(\Delta b = 2\) process in the \(B_d\) meson system. More...
 
BParameter getBBs () const
 For getting the bag parameters corresponding to the operator basis \(O_1 -O_5\) in \(\Delta b = 2\) process in the \(B_s\) meson system. More...
 
BParameter getBD () const
 For getting the bag parameters corresponding to the operator basis \(O_1 -O_5\) in \(\Delta c = 2\) process in the \(D^0\) meson system. More...
 
BParameter getBK () const
 For getting the bag parameters corresponding to the operator basis \(O_1 -O_5\) in \(\Delta s = 2\) process in the \(K^0\) meson system. More...
 
BParameter getBKd1 () const
 
BParameter getBKd3 () const
 
double getCF () const
 A get method to access the Casimir factor of QCD. More...
 
double getMAls () const
 A get method to access the mass scale \(M_{\alpha_s}\) at which the strong coupling constant measurement is provided. More...
 
Meson getMesons (const QCD::meson m) const
 A get method to access a meson as an object of the type Meson. More...
 
double getMtpole () const
 A get method to access the pole mass of the top quark. More...
 
double getMub () const
 A get method to access the threshold between five- and four-flavour theory in GeV. More...
 
double getMuc () const
 A get method to access the threshold between four- and three-flavour theory in GeV. More...
 
double getMut () const
 A get method to access the threshold between six- and five-flavour theory in GeV. More...
 
double getNc () const
 A get method to access the number of colours \(N_c\). More...
 
double getOptionalParameter (std::string name) const
 A method to get parameters that are specific to only one set of observables. More...
 
Particle getQuarks (const QCD::quark q) const
 A get method to access a quark as an object of the type Particle. More...
 
std::vector< std::string > getUnknownParameters ()
 A method to get the vector of the parameters that have been specified in the configuration file but not being used. More...
 
void initializeBParameter (std::string name_i) const
 A method to initialize B Parameter and the corresponding meson. More...
 
void initializeMeson (QCD::meson meson_i) const
 A method to initialize a meson. More...
 
double logLambda (const double nf, orders order) const
 Computes \(\ln\Lambda_\mathrm{QCD}\) with nf flavours in GeV. More...
 
double Mbar2Mp (const double mbar, const orders order=FULLNNLO) const
 Converts the \(\overline{\mathrm{MS}}\) mass \(m(m)\) to the pole mass. More...
 
double Mp2Mbar (const double mp, const orders order=FULLNNLO) const
 Converts a quark pole mass to the corresponding \(\overline{\mathrm{MS}}\) mass \(m(m)\). More...
 
double Mrun (const double mu, const double m, const orders order=FULLNNLO) const
 Computes a running quark mass \(m(\mu)\) from \(m(m)\). More...
 
double Mrun (const double mu_f, const double mu_i, const double m, const orders order=FULLNNLO) const
 Runs a quark mass from \(\mu_i\) to \(\mu_f\). More...
 
double Mrun4 (const double mu_f, const double mu_i, const double m) const
 The running of a mass with the number of flavours \(n_f = 4\). More...
 
double MS2DRqmass (const double MSbar) const
 Converts a quark mass from the \(\overline{\mathrm{MS}}\) scheme to the \(\overline{\mathrm{DR}}\) scheme. More...
 
double MS2DRqmass (const double MSscale, const double MSbar) const
 Converts a quark mass from the \(\overline{\mathrm{MS}}\) scheme to the \(\overline{\mathrm{DR}}\) scheme. More...
 
double Nf (const double mu) const
 The number of active flavour at scale \(\mu\). More...
 
double NfThresholdCorrections (double mu, double M, double als, int nf, orders order) const
 Threshold corrections in matching \(\alpha_s(n_f+1)\) with \(\alpha_s(n_f)\) from eq. (34) of hep-ph/0512060. More...
 
std::string orderToString (const orders order) const
 Converts an object of the enum type "orders" to the corresponding string. More...
 
 QCD ()
 Constructor. More...
 
void setNc (double Nc)
 A set method to change the number of colours \(N_c\). More...
 
void setOptionalParameter (std::string name, double value)
 A method to set the parameter value for the parameters that are specific to only one set of observables. More...
 
double Thresholds (const int i) const
 For accessing the active flavour threshold scales. More...
 
- Public Member Functions inherited from Model
void addMissingModelParameter (const std::string &missingParameterName)
 
std::vector< std::string > getmissingModelParameters ()
 
unsigned int getMissingModelParametersCount ()
 
std::string getModelName () const
 A method to fetch the name of the model. More...
 
const double & getModelParam (std::string name) const
 
bool isModelGeneralTHDM () const
 
bool isModelGeorgiMachacek () const
 
bool IsModelInitialized () const
 A method to check if the model is initialized. More...
 
bool isModelLinearized () const
 
bool isModelParam (std::string name) const
 
bool isModelSUSY () const
 
bool isModelTHDM () const
 
bool isModelTHDMW () const
 
bool IsUpdateError () const
 A method to check if there was any error in the model update process. More...
 
 Model ()
 The default constructor. More...
 
void raiseMissingModelParameterCount ()
 
void setModelGeneralTHDM ()
 
void setModelGeorgiMachacek ()
 
void setModelInitialized (bool ModelInitialized)
 A set method to fix the failure or success of the initialization of the model. More...
 
void setModelLinearized (bool linearized=true)
 
void setModelName (const std::string name)
 A method to set the name of the model. More...
 
void setModelSUSY ()
 
void setModelTHDM ()
 
void setModelTHDMW ()
 
void setSliced (bool Sliced)
 
void setUpdateError (bool UpdateError)
 A set method to fix the update status as success or failure. More...
 
virtual ~Model ()
 The default destructor. More...
 

Additional Inherited Members

- Public Types inherited from StandardModel
enum  LEP2RCs { Weak = 0, WeakBox, ISR, QEDFSR, QCDFSR, NUMofLEP2RCs }
 
enum  orders_EW { EW1 = 0, EW1QCD1, EW1QCD2, EW2, EW2QCD1, EW3, orders_EW_size }
 An enumerated type representing perturbative orders of radiative corrections to EW precision observables. More...
 
- Public Types inherited from QCD
enum  lepton { NEUTRINO_1, ELECTRON, NEUTRINO_2, MU, NEUTRINO_3, TAU, NOLEPTON }
 An enum type for leptons. More...
 
enum  meson { P_0, P_P, K_0, K_P, D_0, D_P, B_D, B_P, B_S, B_C, PHI, K_star, K_star_P, D_star_P, RHO, RHO_P, OMEGA, MESON_END }
 An enum type for mesons. More...
 
enum  quark { UP, DOWN, CHARM, STRANGE, TOP, BOTTOM }
 An enum type for quarks. More...
 
- Static Public Attributes inherited from StandardModel
static const double GeVminus2_to_nb = 389379.338
 
static const double Mw_error = 0.00001
 The target accuracy of the iterative calculation of the \(W\)-boson mass in units of GeV. More...
 
static const int NSMvars = 26
 The number of the model parameters in StandardModel. More...
 
static const int NumSMParamsForEWPO = 33
 The number of the SM parameters that are relevant to the EW precision observables. More...
 
static std::string SMvars [NSMvars]
 A string array containing the labels of the model parameters in StandardModel. More...
 
- Static Public Attributes inherited from QCD
static const int NQCDvars = 11
 The number of model parameters in QCD. More...
 
static std::string QCDvars [NQCDvars]
 An array containing the labels under which all QCD parameters are stored in a vector of ModelParameter via InputParser::ReadParameters(). More...
 
- Protected Member Functions inherited from StandardModel
bool checkEWPOscheme (const std::string scheme) const
 A method to check if a given scheme name in string form is valid. More...
 
virtual void computeCKM ()
 The method to compute the CKM matrix. More...
 
virtual void computeYukawas ()
 The method to compute the Yukawa matrices. More...
 
double Delta_EWQCD (const QCD::quark q) const
 The non-factorizable EW-QCD corrections to the partial widths for \(Z\to q\bar{q}\), denoted as \(\Delta_{\mathrm{EW/QCD}}\). More...
 
double m_q (const QCD::quark q, const double mu, const orders order=FULLNLO) const
 
double RAq (const QCD::quark q) const
 The radiator factor associated with the final-state QED and QCD corrections to the the axial-vector-current interactions, \(R_A^q(M_Z^2)\). More...
 
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 \(\kappa_Z^f\) from \(\Delta\rho\), \(\delta\rho_{\rm rem}^{f}\) and \(\Delta r_{\mathrm{rem}}\). More...
 
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 \(W\)-boson mass from \(\Delta\rho\) and \(\Delta r_{\mathrm{rem}}\). More...
 
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 \(\rho_Z^f\) from \(\Delta\rho\), \(\delta\rho_{\rm rem}^{f}\) and \(\Delta r_{\mathrm{rem}}\). More...
 
double RVh () const
 The singlet vector corrections to the hadronic \(Z\)-boson width, denoted as \(R_V^h\). More...
 
double RVq (const QCD::quark q) const
 The radiator factor associated with the final-state QED and QCD corrections to the the vector-current interactions, \(R_V^q(M_Z^2)\). More...
 
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 precision. More...
 
virtual void setParameter (const std::string name, const double &value)
 A method to set the value of a parameter of StandardModel. More...
 
double taub () const
 Top-mass corrections to the \(Zb\bar{b}\) vertex, denoted by \(\tau_b\). More...
 
- Protected Member Functions inherited from QCD
double MassOfNf (int nf) const
 The Mbar mass of the heaviest quark in the theory with Nf active flavour. More...
 
- Protected Attributes inherited from StandardModel
double A
 The CKM parameter \(A\) in the Wolfenstein parameterization. More...
 
double ale
 The fine-structure constant \(\alpha\). More...
 
double alpha21
 
double alpha31
 
double AlsMz
 The strong coupling constant at the Z-boson mass, \(\alpha_s(M_Z)\). More...
 
double dAle5Mz
 The five-flavour hadronic contribution to the electromagnetic coupling, \(\Delta\alpha_{\mathrm{had}}^{(5)}(M_Z^2)\). More...
 
double delGammaZ
 The theoretical uncertainty in \(\Gamma_Z\), denoted as \(\delta\,\Gamma_Z\), in GeV. More...
 
double delMw
 The theoretical uncertainty in \(M_W\), denoted as \(\delta\,M_W\), in GeV. More...
 
double delR0b
 The theoretical uncertainty in \(R_b^0\), denoted as \(\delta\,R_b^0\). More...
 
double delR0c
 The theoretical uncertainty in \(R_c^0\), denoted as \(\delta\,R_c^0\). More...
 
double delR0l
 The theoretical uncertainty in \(R_l^0\), denoted as \(\delta\,R_l^0\). More...
 
double delsigma0H
 The theoretical uncertainty in \(\sigma_{Hadron}^0\), denoted as \(\delta\,\sigma_{Hadron}^0\) in nb. More...
 
double delSin2th_b
 The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{b}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{b}\). More...
 
double delSin2th_l
 The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{\rm lept}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{\rm lept}\). More...
 
double delSin2th_q
 The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{q\not = b,t}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{q\not = b,t}\). More...
 
double delta
 
double etab
 The CKM parameter \(\bar{\eta}\) in the Wolfenstein parameterization. More...
 
bool flag_order [orders_EW_size]
 An array of internal flags controlling the inclusions of higher-order corrections. More...
 
double gamma
 \(\gamma \) used as an input for FlagWolfenstein = FALSE More...
 
double GF
 The Fermi constant \(G_\mu\) in \({\rm GeV}^{-2}\). More...
 
double lambda
 The CKM parameter \(\lambda\) in the Wolfenstein parameterization. More...
 
Particle leptons [6]
 An array of Particle objects for the leptons. More...
 
double mHl
 The Higgs mass \(m_h\) in GeV. More...
 
double muw
 A matching scale \(\mu_W\) around the weak scale in GeV. More...
 
CKM myCKM
 An object of type CKM. More...
 
PMNS myPMNS
 
double Mz
 The mass of the \(Z\) boson in GeV. More...
 
bool requireCKM
 An internal flag to control whether the CKM matrix has to be recomputed. More...
 
bool requireYe
 An internal flag to control whether the charged-lepton Yukawa matrix has to be recomputed. More...
 
bool requireYn
 An internal flag to control whether the neutrino Yukawa matrix has to be recomputed. More...
 
double rhob
 The CKM parameter \(\bar{\rho}\) in the Wolfenstein parameterization. More...
 
double s12
 
double s13
 
double s23
 
Flavour SMFlavour
 An object of type Flavour. More...
 
Matching< StandardModelMatching, StandardModelSMM
 An object of type Matching. More...
 
double Vcb
 \(\vert V_{cb} \vert \) used as an input for FlagWolfenstein = FALSE More...
 
double Vub
 \(\vert V_{ub} \vert \) used as an input for FlagWolfenstein = FALSE More...
 
double Vus
 \(\vert V_{us} \vert \) used as an input for FlagWolfenstein = FALSE More...
 
gslpp::matrix< gslpp::complexYd
 The Yukawa matrix of the down-type quarks. More...
 
gslpp::matrix< gslpp::complexYe
 The Yukawa matrix of the charged leptons. More...
 
gslpp::matrix< gslpp::complexYn
 The Yukawa matrix of the neutrinos. More...
 
gslpp::matrix< gslpp::complexYu
 The Yukawa matrix of the up-type quarks. More...
 
- Protected Attributes inherited from QCD
double AlsM
 The strong coupling constant at the mass scale MAls, \(\alpha_s(M_{\alpha_s})\). More...
 
double CA
 
double CF
 
bool computemt
 Switch for computing the \(\overline{\mathrm{MS}}\) mass of the top quark. More...
 
double dAdA_NA
 
double dFdA_NA
 
double dFdF_NA
 
double MAls
 The mass scale in GeV at which the strong coupling measurement is provided. More...
 
double mtpole
 The pole mass of the top quark. More...
 
double mub
 The threshold between five- and four-flavour theory in GeV. More...
 
double muc
 The threshold between four- and three-flavour theory in GeV. More...
 
double mut
 The threshold between six- and five-flavour theory in GeV. More...
 
double NA
 
double Nc
 The number of colours. More...
 
Particle quarks [6]
 The vector of all SM quarks. More...
 
bool requireYd
 Switch for generating the Yukawa couplings to the down-type quarks. More...
 
bool requireYu
 Switch for generating the Yukawa couplings to the up-type quarks. More...
 
double TF
 
- Protected Attributes inherited from Model
bool isSliced
 A boolean set to true if the current istance is a slice of an extended object. More...
 
std::map< std::string, std::reference_wrapper< const double > > ModelParamMap
 
bool UpdateError
 A boolean set to false if update is successful. More...
 

Constructor & Destructor Documentation

◆ EWSM_Output()

EWSM_Output::EWSM_Output ( const StandardModel SM_in)

Constructor.

Parameters
[in]EWSM_ina reference to an object of type EWSM

Definition at line 19 of file EWSM_Output.cpp.

20 : StandardModel(SM_in)
21 {
22 }

Member Function Documentation

◆ outputEachDeltaKappaZ()

void EWSM_Output::outputEachDeltaKappaZ ( const double  f_AlphaToGF,
const double  cW2overSW2,
const double  DeltaRho[StandardModel::orders_EW_size],
const double  deltaKappa_rem[StandardModel::orders_EW_size],
const double  DeltaRbar_rem,
const bool  bool_Zbb,
const double  taub[StandardModel::orders_EW_size],
const double  ZbbSubtract,
const double  Zgamma_EW2 
) const

Definition at line 582 of file EWSM_Output.cpp.

591 {
592  /* rescale */
593  double DeltaRho_new[StandardModel::orders_EW_size];
594  for (int j = 0; j < StandardModel::orders_EW_size; ++j)
595  DeltaRho_new[j] = cW2overSW2 * DeltaRho[j];
596 
597  if (getFlagKappaZ().compare("APPROXIMATEFORMULA") == 0) {
598  std::cout << "Delta kappaZb (from the approximate formula of sin2thb) = "
599  << kappaZ_f(getQuarks(QCD::BOTTOM)) - 1.0 << std::endl;
600  } else if (getFlagKappaZ().compare("NORESUM") == 0) {
601  std::cout << "Leading contributions: alpha or Gmu" << std::endl;
602  std::cout << " DeltaRho[EW1]=" << DeltaRho_new[StandardModel::EW1] << " "
603  << f_AlphaToGF * DeltaRho_new[StandardModel::EW1] << std::endl;
604  std::cout << " DeltaRho[EW1QCD1]=" << DeltaRho_new[StandardModel::EW1QCD1] << " "
605  << f_AlphaToGF * DeltaRho_new[StandardModel::EW1QCD1] << std::endl;
606  std::cout << " DeltaRho[EW1QCD2]=" << DeltaRho_new[StandardModel::EW1QCD2] << " "
607  << f_AlphaToGF * DeltaRho_new[StandardModel::EW1QCD2] << std::endl;
608  std::cout << " DeltaRho[EW2]=" << DeltaRho_new[StandardModel::EW2] << " "
609  << pow(f_AlphaToGF, 2.0) * DeltaRho_new[StandardModel::EW2] << std::endl;
610  std::cout << " DeltaRho[EW2QCD1]=" << DeltaRho_new[StandardModel::EW2QCD1] << " "
611  << pow(f_AlphaToGF, 2.0) * DeltaRho_new[StandardModel::EW2QCD1] << std::endl;
612  std::cout << " DeltaRho[EW3]=" << DeltaRho_new[StandardModel::EW3] << " "
613  << pow(f_AlphaToGF, 3.0) * DeltaRho_new[StandardModel::EW3] << std::endl;
614  std::cout << "EW2 from Z-gamma = " << Zgamma_EW2 << std::endl;
615  std::cout << "Remainder contributions: alpha or Gmu" << std::endl;
616  std::cout << " DeltaRbar_rem[EW1]=" << DeltaRbar_rem << " "
617  << f_AlphaToGF * DeltaRbar_rem << std::endl;
618  std::cout << " deltaKappa_rem[EW1]=" << deltaKappa_rem[StandardModel::EW1] - ZbbSubtract << " "
619  << f_AlphaToGF * (deltaKappa_rem[StandardModel::EW1] - ZbbSubtract) << std::endl;
620  std::cout << " deltaKappa_rem[EW1QCD1]=" << deltaKappa_rem[StandardModel::EW1QCD1] << " "
621  << f_AlphaToGF * deltaKappa_rem[StandardModel::EW1QCD1] << std::endl;
622  std::cout << " deltaKappa_rem[EW1QCD2]=" << deltaKappa_rem[StandardModel::EW1QCD2] << " "
623  << f_AlphaToGF * deltaKappa_rem[StandardModel::EW1QCD2] << std::endl;
624  std::cout << " deltaKappa_rem[EW2]=" << deltaKappa_rem[StandardModel::EW2] << " "
625  << pow(f_AlphaToGF, 2.0) * deltaKappa_rem[StandardModel::EW2] << std::endl;
626  if (bool_Zbb) {
627  std::cout << "Taub: alpha or Gmu" << std::endl;
628  std::cout << " taub[EW1]=" << taub[StandardModel::EW1] << " "
629  << f_AlphaToGF * taub[StandardModel::EW1] << std::endl;
630  std::cout << " taub[EW1QCD1]=" << taub[StandardModel::EW1QCD1] << " "
631  << f_AlphaToGF * taub[StandardModel::EW1QCD1] << std::endl;
632  std::cout << " taub[EW2]=" << taub[StandardModel::EW2] << " "
633  << pow(f_AlphaToGF, 2.0) * taub[StandardModel::EW2] << std::endl;
634  }
635  std::cout << "Each order: alpha or Gmu" << std::endl;
636  double dKappa_EW1 = DeltaRho_new[StandardModel::EW1] + deltaKappa_rem[StandardModel::EW1] - ZbbSubtract;
637  double dKappa_EW1QCD1 = DeltaRho_new[StandardModel::EW1QCD1] + deltaKappa_rem[StandardModel::EW1QCD1];
638  double dKappa_EW2 = (deltaKappa_rem[StandardModel::EW1] - ZbbSubtract) * DeltaRho_new[StandardModel::EW1]
639  - DeltaRho_new[StandardModel::EW1] * DeltaRbar_rem
640  + DeltaRho_new[StandardModel::EW2]
641  + deltaKappa_rem[StandardModel::EW2];
642  double dKappa_EW1QCD2 = DeltaRho_new[StandardModel::EW1QCD2] + deltaKappa_rem[StandardModel::EW1QCD2];
643  double dKappa_EW2QCD1 = DeltaRho_new[StandardModel::EW2QCD1] + deltaKappa_rem[StandardModel::EW1QCD1] * DeltaRho_new[StandardModel::EW1];
644  double dKappa_EW3 = DeltaRho_new[StandardModel::EW3];
645  double dKappa_EW2QCD2 = deltaKappa_rem[StandardModel::EW1QCD2] * DeltaRho_new[StandardModel::EW1];
646  //
647  double dKappa_EW1_TMP = dKappa_EW1;
648  double dKappa_EW1QCD1_TMP = dKappa_EW1QCD1;
649  double dKappa_EW2_TMP = dKappa_EW2;
650  double dKappa_EW1QCD2_TMP = dKappa_EW1QCD2;
651  double dKappa_EW2QCD1_TMP = dKappa_EW2QCD1;
652  double dKappa_EW3_TMP = dKappa_EW3;
653  double dKappa_EW2QCD2_TMP = dKappa_EW2QCD2;
654  //
655  if (bool_Zbb) {
656  dKappa_EW1 = dKappa_EW1_TMP - taub[StandardModel::EW1];
657  dKappa_EW1QCD1 = dKappa_EW1QCD1_TMP - taub[StandardModel::EW1QCD1];
658  dKappa_EW2 = dKappa_EW2_TMP - taub[StandardModel::EW2] + taub[StandardModel::EW1] * taub[StandardModel::EW1]
659  - dKappa_EW1_TMP * taub[StandardModel::EW1];
660  dKappa_EW1QCD2 = dKappa_EW1QCD2_TMP;
661  dKappa_EW2QCD1 = dKappa_EW2QCD1_TMP - dKappa_EW1_TMP * taub[StandardModel::EW1QCD1]
662  - dKappa_EW1QCD1_TMP * taub[StandardModel::EW1] + 2.0 * taub[StandardModel::EW1] * taub[StandardModel::EW1QCD1];
663  dKappa_EW3 = dKappa_EW3_TMP - dKappa_EW1_TMP * taub[StandardModel::EW2]
664  - dKappa_EW2_TMP * taub[StandardModel::EW1] + 2.0 * taub[StandardModel::EW2] * taub[StandardModel::EW1];
665  dKappa_EW2QCD2 = dKappa_EW2QCD2_TMP - dKappa_EW1QCD2_TMP * taub[StandardModel::EW1]
666  - dKappa_EW1QCD1_TMP * taub[StandardModel::EW1QCD1]
668  }
669  std::cout << " EW1: " << dKappa_EW1 << " " << f_AlphaToGF * dKappa_EW1 << std::endl;
670  std::cout << " EW1QCD1: " << dKappa_EW1QCD1 << " " << f_AlphaToGF * dKappa_EW1QCD1 << std::endl;
671  std::cout << " EW2: " << dKappa_EW2 + Zgamma_EW2
672  << " " << pow(f_AlphaToGF, 2.0) * dKappa_EW2 + Zgamma_EW2 << std::endl;
673  std::cout << " EW1QCD2: " << dKappa_EW1QCD2 << " " << f_AlphaToGF * dKappa_EW1QCD2 << std::endl;
674  std::cout << " EW2QCD1: " << dKappa_EW2QCD1 << " " << pow(f_AlphaToGF, 2.0) * dKappa_EW2QCD1 << std::endl;
675  std::cout << " EW3: " << dKappa_EW3 << " " << pow(f_AlphaToGF, 3.0) * dKappa_EW3 << std::endl;
676  std::cout << " EW2QCD2: " << dKappa_EW2QCD2 << " " << pow(f_AlphaToGF, 2.0) * dKappa_EW2QCD2 << std::endl;
677  std::cout << "Total contribution: alpha or Gmu" << std::endl;
678  std::cout << " kappaZ="
679  << 1.0 + dKappa_EW1 + dKappa_EW1QCD1 + dKappa_EW2
680  + dKappa_EW1QCD2 + dKappa_EW2QCD1 + dKappa_EW3
681  + dKappa_EW2QCD2 + Zgamma_EW2
682  << " "
683  << 1.0 + f_AlphaToGF * dKappa_EW1 + f_AlphaToGF * dKappa_EW1QCD1
684  + pow(f_AlphaToGF, 2.0) * dKappa_EW2 + f_AlphaToGF * dKappa_EW1QCD2
685  + pow(f_AlphaToGF, 2.0) * dKappa_EW2QCD1
686  + pow(f_AlphaToGF, 3.0) * dKappa_EW3
687  + pow(f_AlphaToGF, 2.0) * dKappa_EW2QCD2
688  + Zgamma_EW2 << std::endl;
689  if (bool_Zbb) {
690  std::cout << " kappaZ(taub resummed)="
691  << (1.0 + dKappa_EW1_TMP + dKappa_EW1QCD1_TMP
692  + dKappa_EW2_TMP + dKappa_EW1QCD2_TMP
693  + dKappa_EW2QCD1_TMP + dKappa_EW3_TMP
694  + dKappa_EW2QCD2_TMP)
696  + Zgamma_EW2
697  << " "
698  << (1.0 + f_AlphaToGF * dKappa_EW1_TMP
699  + f_AlphaToGF * dKappa_EW1QCD1_TMP
700  + pow(f_AlphaToGF, 2.0) * dKappa_EW2_TMP
701  + f_AlphaToGF * dKappa_EW1QCD2_TMP
702  + pow(f_AlphaToGF, 2.0) * dKappa_EW2QCD1_TMP
703  + pow(f_AlphaToGF, 3.0) * dKappa_EW3_TMP
704  + pow(f_AlphaToGF, 2.0) * dKappa_EW2QCD2_TMP)
705  / (1.0 + f_AlphaToGF * taub[StandardModel::EW1]
706  + f_AlphaToGF * taub[StandardModel::EW1QCD1]
707  + pow(f_AlphaToGF, 2.0) * taub[StandardModel::EW2])
708  + Zgamma_EW2
709  << std::endl;
710  }
711  } else
712  std::cout << "EWSM_Output::outputEachDeltaKappaZ(): Not implemented for schemeKappaZ="
713  << getFlagKappaZ() << std::endl;
714 }

◆ outputEachDeltaKappaZ_l()

void EWSM_Output::outputEachDeltaKappaZ_l ( const QCD::lepton  l,
const double  Mw_i 
) const

Definition at line 442 of file EWSM_Output.cpp.

443 {
444  std::cout << "================================================" << std::endl;
445  std::cout << "kappaZ_l[(QCD::lepton)" << l << "]" << std::endl;
446  std::cout << "Mw(input) = " << Mw_i << std::endl;
447 
448  double cW2_TMP = Mw_i * Mw_i / getMz() / getMz();
449  double sW2_TMP = 1.0 - cW2_TMP;
450 
451  double DeltaRho[StandardModel::orders_EW_size];
452  DeltaRho[StandardModel::EW1] = getMyOneLoopEW()->DeltaRho(Mw_i);
453  DeltaRho[StandardModel::EW1QCD1] = getMyTwoLoopQCD()->DeltaRho(Mw_i);
455  DeltaRho[StandardModel::EW2] = getMyTwoLoopEW()->DeltaRho(Mw_i);
457  DeltaRho[StandardModel::EW3] = getMyThreeLoopEW()->DeltaRho(Mw_i);
458 
459  /* compute delta kappa_rem^f */
461  deltaKappa_rem_f[StandardModel::EW1] = getMyOneLoopEW()->deltaKappa_rem_f(getLeptons(l), Mw_i);
462 #ifdef WITHIMTWOLOOPQCD
463  deltaKappa_rem_f[StandardModel::EW1QCD1] = gslpp::complex(getMyTwoLoopQCD()->deltaKappa_rem_f(getLeptons(l), Mw_i).real(),
464  getMyTwoLoopQCD()->deltaKappa_rem_f(getLeptons(l), Mw_i).imag(), false);
465 #else
466  deltaKappa_rem_f[StandardModel::EW1QCD1] = gslpp::complex(getMyTwoLoopQCD()->deltaKappa_rem_f(getLeptons(l), Mw_i).real(), 0.0, false);
467 #endif
468  deltaKappa_rem_f[StandardModel::EW1QCD2] = gslpp::complex(getMyThreeLoopQCD()->deltaKappa_rem_f(getLeptons(l), Mw_i).real(), 0.0, false);
469  deltaKappa_rem_f[StandardModel::EW2] = gslpp::complex(getMyTwoLoopEW()->deltaKappa_rem_f(getLeptons(l), Mw_i).real(), 0.0, false);
470  deltaKappa_rem_f[StandardModel::EW2QCD1] = gslpp::complex(getMyThreeLoopEW2QCD()->deltaKappa_rem_f(getLeptons(l), Mw_i).real(), 0.0, false);
471  deltaKappa_rem_f[StandardModel::EW3] = gslpp::complex(getMyThreeLoopEW()->deltaKappa_rem_f(getLeptons(l), Mw_i).real(), 0.0, false);
472 
473  /* compute Delta rbar_rem */
474  double DeltaRbar_rem = getMyOneLoopEW()->DeltaRbar_rem(Mw_i);
475 
476  /* conversion factor */
477  double f_AlphaToGF = sqrt(2.0) * getGF() * pow(getMz(), 2.0)
478  * sW2_TMP * cW2_TMP / M_PI / getAle();
479 
480  /* Re[Kappa_Z^f] with or without resummation */
481  double deltaKappa_rem_f_real[StandardModel::orders_EW_size];
482  for (int j = 0; j < StandardModel::orders_EW_size; ++j)
483  deltaKappa_rem_f_real[j] = deltaKappa_rem_f[j].real();
484 
485  /* O(alpha^2) correction to Re[kappa_Z^f] from the Z-gamma mixing */
486  double ReKappaZf = resumKappaZ(DeltaRho, deltaKappa_rem_f_real,
487  DeltaRbar_rem, false);
488  double Zgamma_EW2 = 35.0 * alphaMz() * alphaMz() / 18.0 / sW2_TMP
489  * (1.0 - 8.0 / 3.0 * ReKappaZf * sW2_TMP);
490 
491  double dummy[StandardModel::orders_EW_size];
492  outputEachDeltaKappaZ(f_AlphaToGF, cW2_TMP / sW2_TMP,
493  DeltaRho, deltaKappa_rem_f_real,
494  DeltaRbar_rem, false, dummy, 0.0, Zgamma_EW2);
495 
496  /* Im[kappa_Z^f] without resummation */
497  double ImKappaZf = 0.0;
498  for (int j = 0; j < StandardModel::orders_EW_size; ++j)
499  ImKappaZf += deltaKappa_rem_f[j].imag();
500  std::cout << "ImKappaZf(with alpha)=" << ImKappaZf << std::endl;
501 
502  std::cout << "================================================" << std::endl;
503 }

◆ outputEachDeltaKappaZ_q()

void EWSM_Output::outputEachDeltaKappaZ_q ( const QCD::quark  q,
const double  Mw_i 
) const

Definition at line 505 of file EWSM_Output.cpp.

506 {
507  std::cout << "================================================" << std::endl;
508  std::cout << "kappaZ_q[(QCD::quark)" << q << "]" << std::endl;
509  std::cout << "Mw(input) = " << Mw_i << std::endl;
510 
511  double cW2_TMP = Mw_i * Mw_i / getMz() / getMz();
512  double sW2_TMP = 1.0 - cW2_TMP;
513 
514  double DeltaRho[StandardModel::orders_EW_size];
515  DeltaRho[StandardModel::EW1] = getMyOneLoopEW()->DeltaRho(Mw_i);
516  DeltaRho[StandardModel::EW1QCD1] = getMyTwoLoopQCD()->DeltaRho(Mw_i);
518  DeltaRho[StandardModel::EW2] = getMyTwoLoopEW()->DeltaRho(Mw_i);
520  DeltaRho[StandardModel::EW3] = getMyThreeLoopEW()->DeltaRho(Mw_i);
521 
522  /* compute delta kappa_rem^f */
524  deltaKappa_rem_f[StandardModel::EW1] = getMyOneLoopEW()->deltaKappa_rem_f(getQuarks(q), Mw_i);
525 #ifdef WITHIMTWOLOOPQCD
526  deltaKappa_rem_f[StandardModel::EW1QCD1] = gslpp::complex(getMyTwoLoopQCD()->deltaKappa_rem_f(getQuarks(q), Mw_i).real(),
527  getMyTwoLoopQCD()->deltaKappa_rem_f(getQuarks(q), Mw_i).imag(), false);
528 #else
529  deltaKappa_rem_f[StandardModel::EW1QCD1] = gslpp::complex(getMyTwoLoopQCD()->deltaKappa_rem_f(getQuarks(q), Mw_i).real(), 0.0, false);
530 #endif
531  deltaKappa_rem_f[StandardModel::EW1QCD2] = gslpp::complex(getMyThreeLoopQCD()->deltaKappa_rem_f(getQuarks(q), Mw_i).real(), 0.0, false);
532  deltaKappa_rem_f[StandardModel::EW2] = gslpp::complex(getMyTwoLoopEW()->deltaKappa_rem_f(getQuarks(q), Mw_i).real(), 0.0, false);
533  deltaKappa_rem_f[StandardModel::EW2QCD1] = gslpp::complex(getMyThreeLoopEW2QCD()->deltaKappa_rem_f(getQuarks(q), Mw_i).real(), 0.0, false);
534  deltaKappa_rem_f[StandardModel::EW3] = gslpp::complex(getMyThreeLoopEW()->deltaKappa_rem_f(getQuarks(q), Mw_i).real(), 0.0, false);
535 
536  /* compute Delta rbar_rem */
537  double DeltaRbar_rem = getMyOneLoopEW()->DeltaRbar_rem(Mw_i);
538 
539  /* conversion factor */
540  double f_AlphaToGF = sqrt(2.0) * getGF() * pow(getMz(), 2.0)
541  * sW2_TMP * cW2_TMP / M_PI / getAle();
542 
543  /* Zbb */
544  bool bool_Zbb = false;
545  if (q == QCD::BOTTOM) bool_Zbb = true;
546  double ZbbSubtract = 0.0;
547  if (bool_Zbb)
548  ZbbSubtract = getAle() / 8.0 / M_PI / sW2_TMP
549  * pow(getMtpole() / Mw_i, 2.0);
551  double Xt = getMyEWSMcache()->Xt_alpha(Mw_i);
552  if (bool_Zbb) {
553  taub[StandardModel::EW1] = -2.0 * Xt;
554  taub[StandardModel::EW1QCD1] = 2.0 / 3.0 * M_PI * Xt * getMyEWSMcache()->alsMt();
555  taub[StandardModel::EW2] = -2.0 * Xt * Xt * getMyTwoLoopEW()->tau_2();
556  }
557 
558  /* Re[Kappa_Z^f] with or without resummation */
559  double deltaKappa_rem_f_real[StandardModel::orders_EW_size];
560  for (int j = 0; j < StandardModel::orders_EW_size; ++j)
561  deltaKappa_rem_f_real[j] = deltaKappa_rem_f[j].real();
562 
563  /* O(alpha^2) correction to Re[kappa_Z^f] from the Z-gamma mixing */
564  double ReKappaZf = resumKappaZ(DeltaRho, deltaKappa_rem_f_real,
565  DeltaRbar_rem, bool_Zbb);
566  double Zgamma_EW2 = 35.0 * alphaMz() * alphaMz() / 18.0 / sW2_TMP
567  * (1.0 - 8.0 / 3.0 * ReKappaZf * sW2_TMP);
568 
569  outputEachDeltaKappaZ(f_AlphaToGF, cW2_TMP / sW2_TMP,
570  DeltaRho, deltaKappa_rem_f_real,
571  DeltaRbar_rem, bool_Zbb, taub, ZbbSubtract, Zgamma_EW2);
572 
573  /* Im[kappa_Z^f] without resummation */
574  double ImKappaZf = 0.0;
575  for (int j = 0; j < StandardModel::orders_EW_size; ++j)
576  ImKappaZf += deltaKappa_rem_f[j].imag();
577  std::cout << "ImKappaZf(with alpha)=" << ImKappaZf << std::endl;
578 
579  std::cout << "================================================" << std::endl;
580 }

◆ outputEachDeltaR()

void EWSM_Output::outputEachDeltaR ( const double  Mw_i) const

Definition at line 24 of file EWSM_Output.cpp.

25 {
26  std::cout << "Mw_SM = " << Mw() << std::endl;
27  std::cout << "DeltaR_SM() = " << DeltaR() << std::endl;
28  std::cout << "DeltaRbar_SM() = " << DeltaRbar() << std::endl;
29  std::cout << "Mw(input) = " << Mw_i << std::endl;
30 
31  double cW2_TMP = Mw_i * Mw_i / getMz() / getMz();
32  double sW2_TMP = 1.0 - cW2_TMP;
33 
34  double DeltaRho[StandardModel::orders_EW_size];
35  DeltaRho[StandardModel::EW1] = getMyOneLoopEW()->DeltaRho(Mw_i);
36  DeltaRho[StandardModel::EW1QCD1] = getMyTwoLoopQCD()->DeltaRho(Mw_i);
38  DeltaRho[StandardModel::EW2] = getMyTwoLoopEW()->DeltaRho(Mw_i);
40  DeltaRho[StandardModel::EW3] = getMyThreeLoopEW()->DeltaRho(Mw_i);
41 
42  double DeltaR_rem[StandardModel::orders_EW_size];
43  DeltaR_rem[StandardModel::EW1] = getMyOneLoopEW()->DeltaR_rem(Mw_i);
44  DeltaR_rem[StandardModel::EW1QCD1] = getMyTwoLoopQCD()->DeltaR_rem(Mw_i);
46  DeltaR_rem[StandardModel::EW2] = getMyTwoLoopEW()->DeltaR_rem(Mw_i);
48  DeltaR_rem[StandardModel::EW3] = getMyThreeLoopEW()->DeltaR_rem(Mw_i);
49 
50  double f_AlphaToGF = sqrt(2.0) * getGF() * pow(getMz(), 2.0) * sW2_TMP * cW2_TMP / M_PI / getAle();
51  //f_AlphaToGF = 1.0; /* for test */
52  double DeltaRho_sum = f_AlphaToGF * DeltaRho[StandardModel::EW1]
53  + f_AlphaToGF * DeltaRho[StandardModel::EW1QCD1]
54  + f_AlphaToGF * DeltaRho[StandardModel::EW1QCD2]
55  + pow(f_AlphaToGF, 2.0) * DeltaRho[StandardModel::EW2]
56  + pow(f_AlphaToGF, 2.0) * DeltaRho[StandardModel::EW2QCD1]
57  + pow(f_AlphaToGF, 3.0) * DeltaRho[StandardModel::EW3];
58  double DeltaRho_G = f_AlphaToGF * DeltaRho[StandardModel::EW1];
59 
60  if (getFlagMw().compare("NORESUM") == 0) {
61 
62  f_AlphaToGF = 1.0;
63  DeltaRho[StandardModel::EW1QCD2] *= f_AlphaToGF;
64  DeltaRho[StandardModel::EW2QCD1] *= pow(f_AlphaToGF, 2.0);
65  DeltaRho[StandardModel::EW3] *= pow(f_AlphaToGF, 3.0);
66 
67  // Full EW one-loop contribution (without the full DeltaAlphaL5q)
68  double DeltaR_EW1 = -cW2_TMP / sW2_TMP * DeltaRho[StandardModel::EW1] + DeltaR_rem[StandardModel::EW1];
69 
70  // Full EW two-loop contribution with reducible corrections
71  double DeltaR_EW2_rem = getMyApproximateFormulae()->DeltaR_TwoLoopEW_rem(Mw_i);
72 
73  // EW two-loop irreducible contributions with large-mt expansion
74  double DeltaR_EW2_old_red = DeltaAlphaL5q() * DeltaAlphaL5q()
75  - 2.0 * cW2_TMP / sW2_TMP * DeltaAlphaL5q() * DeltaRho[StandardModel::EW1]
76  + pow(cW2_TMP / sW2_TMP * DeltaRho[StandardModel::EW1], 2.0);
77  double DeltaR_EW2_old_irred = -cW2_TMP / sW2_TMP * DeltaRho[StandardModel::EW2] + DeltaR_rem[StandardModel::EW2];
78 
79  // Delta r, including the full EW two-loop contribution
80  double deltaR = DeltaAlphaL5q();
81  for (int j = 0; j < StandardModel::orders_EW_size; ++j) {
82  deltaR += -cW2_TMP / sW2_TMP * DeltaRho[(StandardModel::orders_EW)j];
83  deltaR += DeltaR_rem[(StandardModel::orders_EW)j];
84  }
85  deltaR -= -cW2_TMP / sW2_TMP * DeltaRho[StandardModel::EW2];
86  deltaR -= DeltaR_rem[StandardModel::EW2];
87  deltaR += DeltaAlphaL5q() * DeltaAlphaL5q() + 2.0 * DeltaAlphaL5q() * DeltaR_EW1 + DeltaR_EW2_rem;
88 
89  std::cout << "(1+dr) - 1 = " << deltaR << std::endl;
90  std::cout << " EW1 = " << DeltaAlphaL5q() + DeltaR_EW1 << std::endl;
91  std::cout << " DeltaAlphaL5q = " << DeltaAlphaL5q() << std::endl;
92  std::cout << " dR = " << DeltaR_EW1 << std::endl;
93  std::cout << " EW1QCD1 = " << -cW2_TMP / sW2_TMP * DeltaRho[StandardModel::EW1QCD1] + DeltaR_rem[StandardModel::EW1QCD1] << std::endl;
94  std::cout << " EW2(full) = " << DeltaR_EW2_rem + DeltaAlphaL5q() * DeltaAlphaL5q() + 2.0 * DeltaAlphaL5q() * DeltaR_EW1 << std::endl;
95  std::cout << " dAle*dAle = " << DeltaAlphaL5q() * DeltaAlphaL5q() << std::endl;
96  std::cout << " 2*dAle*dR = " << 2.0 * DeltaAlphaL5q() * DeltaR_EW1 << std::endl;
97  std::cout << " others = " << DeltaR_EW2_rem << std::endl;
98  std::cout << " EW1QCD2 = " << -cW2_TMP / sW2_TMP * DeltaRho[StandardModel::EW1QCD2] + DeltaR_rem[StandardModel::EW1QCD2] << std::endl;
99  std::cout << " EW2QCD1 = " << -cW2_TMP / sW2_TMP * DeltaRho[StandardModel::EW2QCD1] + DeltaR_rem[StandardModel::EW2QCD1] << std::endl;
100  std::cout << " EW3 = " << -cW2_TMP / sW2_TMP * DeltaRho[StandardModel::EW3] + DeltaR_rem[StandardModel::EW3] << std::endl;
101  std::cout << " EW2(old,irreducible) = " << DeltaR_EW2_old_irred << std::endl;
102  std::cout << " EW2(old,red+irred) = " << DeltaR_EW2_old_red + DeltaR_EW2_old_irred << std::endl;
103  std::cout << " EW2(old,red+irred-dAle*dAle-2*dAle*dR) = "
104  << DeltaR_EW2_old_red + DeltaR_EW2_old_irred
106  - 2.0 * DeltaAlphaL5q() * DeltaR_EW1 << std::endl;
107 
108  } else if (getFlagMw().compare("OMSI") == 0) {
109 
110  // R = 1/(1 - Delta r)
111  double R = 1.0 / (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum)
112  / (1.0 - DeltaAlphaL5q() - DeltaR_rem[StandardModel::EW1] - DeltaR_rem[StandardModel::EW1QCD1] - DeltaR_rem[StandardModel::EW2]);
113 
114  std::cout << "1/(1-dr) - 1 (exact) = " << R - 1.0 << std::endl;
115  std::cout << " --> dr = " << 1.0 - 1.0 / R << std::endl;
116 
117  // each contribution
118  double DeltaR_EW1 = DeltaAlphaL5q() - cW2_TMP / sW2_TMP * f_AlphaToGF * DeltaRho[StandardModel::EW1] + DeltaR_rem[StandardModel::EW1];
119  double DeltaR_EW1QCD1 = -cW2_TMP / sW2_TMP * f_AlphaToGF * DeltaRho[StandardModel::EW1QCD1] + DeltaR_rem[StandardModel::EW1QCD1];
120  double DeltaR_EW2 = -cW2_TMP / sW2_TMP * pow(f_AlphaToGF, 2.0) * DeltaRho[StandardModel::EW2]
121  + DeltaR_rem[StandardModel::EW2]
122  + cW2_TMP / sW2_TMP * f_AlphaToGF * DeltaRho[StandardModel::EW1]
123  *(DeltaAlphaL5q() + DeltaR_rem[StandardModel::EW1])
124  + DeltaR_EW1*DeltaR_EW1;
125  double DeltaR_EW1QCD2 = -cW2_TMP / sW2_TMP * f_AlphaToGF * DeltaRho[StandardModel::EW1QCD2];
126  double DeltaR_EW2QCD1 = -cW2_TMP / sW2_TMP * pow(f_AlphaToGF, 2.0) * DeltaRho[StandardModel::EW2QCD1]
127  + cW2_TMP / sW2_TMP * f_AlphaToGF * DeltaRho[StandardModel::EW1QCD1]
128  *(DeltaAlphaL5q() + DeltaR_rem[StandardModel::EW1])
129  + 2.0 * DeltaR_EW1*DeltaR_EW1QCD1;
130  double DeltaR_EW3 = -cW2_TMP / sW2_TMP * pow(f_AlphaToGF, 3.0) * DeltaRho[StandardModel::EW3]
131  + cW2_TMP / sW2_TMP * pow(f_AlphaToGF, 2.0) * DeltaRho[StandardModel::EW2]
132  *(DeltaAlphaL5q() + DeltaR_rem[StandardModel::EW1])
133  + pow(DeltaR_EW1, 3.0)
134  + 2.0 * DeltaR_EW1 * (DeltaR_EW2 - DeltaR_EW1 * DeltaR_EW1);
135 
136  std::cout << " EW1 = " << DeltaR_EW1 << std::endl;
137  std::cout << " DeltaAlphaL5q = " << DeltaAlphaL5q() << std::endl;
138  std::cout << " -cW2/sW2*dRho1= " << -cW2_TMP / sW2_TMP * f_AlphaToGF * DeltaRho[StandardModel::EW1] << std::endl;
139  std::cout << " DeltaR1_rem = " << DeltaR_rem[StandardModel::EW1] << std::endl;
140  std::cout << " EW1QCD1 = " << DeltaR_EW1QCD1 << std::endl;
141  std::cout << " EW2(full) = " << DeltaR_EW2 << std::endl;
142  std::cout << " EW1*EW1 = " << DeltaR_EW1 * DeltaR_EW1 << std::endl;
143  std::cout << " dAle*dAle = " << DeltaAlphaL5q() * DeltaAlphaL5q() << std::endl;
144  std::cout << " others = " << DeltaR_EW1 * DeltaR_EW1 - DeltaAlphaL5q() * DeltaAlphaL5q() << std::endl;
145  std::cout << " -cW2/sW2*dRho2= " << -cW2_TMP / sW2_TMP * pow(f_AlphaToGF, 2.0) * DeltaRho[StandardModel::EW2] << std::endl;
146  std::cout << " DeltaR2_rem = " << DeltaR_rem[StandardModel::EW2] << std::endl;
147  std::cout << " others = " << cW2_TMP / sW2_TMP * f_AlphaToGF * DeltaRho[StandardModel::EW1]*(DeltaAlphaL5q() + DeltaR_rem[StandardModel::EW1]) << std::endl;
148  std::cout << " EW1QCD2 = " << DeltaR_EW1QCD2 << std::endl;
149  std::cout << " EW2QCD1 = " << DeltaR_EW2QCD1 << std::endl;
150  std::cout << " EW3 = " << DeltaR_EW3 << std::endl;
151  std::cout << " -cW2/sW2*dRho3= " << -cW2_TMP / sW2_TMP * pow(f_AlphaToGF, 3.0) * DeltaRho[StandardModel::EW3] << std::endl;
152  std::cout << " EW1^3 = " << pow(DeltaR_EW1, 3.0) << std::endl;
153  std::cout << " 2*EW1*(EW2-EW1^2)=" << 2.0 * DeltaR_EW1 * (DeltaR_EW2 - DeltaR_EW1 * DeltaR_EW1) << std::endl;
154  std::cout << " others = " << cW2_TMP / sW2_TMP * pow(f_AlphaToGF, 2.0) * DeltaRho[StandardModel::EW2]*(DeltaAlphaL5q() + DeltaR_rem[StandardModel::EW1]) << std::endl;
155 
156  } else if (getFlagMw().compare("OMSII") == 0) {
157 
158  // R = 1/(1 - Delta r)
159  double R = 1.0 / ((1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum)*(1.0 - DeltaAlphaL5q())
160  - (1.0 + cW2_TMP / sW2_TMP * DeltaRho_G) * DeltaR_rem[StandardModel::EW1]
161  - DeltaR_rem[StandardModel::EW1QCD1] - DeltaR_rem[StandardModel::EW2]);
162 
163  // each contribution
164  double DeltaR_EW1 = DeltaAlphaL5q() - cW2_TMP / sW2_TMP * f_AlphaToGF * DeltaRho[StandardModel::EW1] + DeltaR_rem[StandardModel::EW1];
165  double DeltaR_EW1QCD1 = -cW2_TMP / sW2_TMP * f_AlphaToGF * DeltaRho[StandardModel::EW1QCD1] + DeltaR_rem[StandardModel::EW1QCD1];
166  double DeltaR_EW2 = -cW2_TMP / sW2_TMP * pow(f_AlphaToGF, 2.0) * DeltaRho[StandardModel::EW2]
167  + DeltaR_rem[StandardModel::EW2]
168  + cW2_TMP / sW2_TMP * f_AlphaToGF * DeltaRho[StandardModel::EW1]
169  *(DeltaAlphaL5q() + DeltaR_rem[StandardModel::EW1])
170  + DeltaR_EW1*DeltaR_EW1;
171  double DeltaR_EW1QCD2 = -cW2_TMP / sW2_TMP * f_AlphaToGF * DeltaRho[StandardModel::EW1QCD2];
172  double DeltaR_EW2QCD1 = -cW2_TMP / sW2_TMP * pow(f_AlphaToGF, 2.0) * DeltaRho[StandardModel::EW2QCD1]
173  + cW2_TMP / sW2_TMP * f_AlphaToGF * DeltaRho[StandardModel::EW1QCD1] * DeltaAlphaL5q()
174  + 2.0 * DeltaR_EW1*DeltaR_EW1QCD1;
175  double DeltaR_EW3 = -cW2_TMP / sW2_TMP * pow(f_AlphaToGF, 3.0) * DeltaRho[StandardModel::EW3]
176  + cW2_TMP / sW2_TMP * pow(f_AlphaToGF, 2.0) * DeltaRho[StandardModel::EW2] * DeltaAlphaL5q()
177  + pow(DeltaR_EW1, 3.0)
178  + 2.0 * DeltaR_EW1 * (DeltaR_EW2 - DeltaR_EW1 * DeltaR_EW1);
179 
180  std::cout << "1/(1-dr) - 1 (exact) = " << R - 1.0 << std::endl;
181  std::cout << " --> dr = " << 1.0 - 1.0 / R << std::endl;
182  std::cout << "1/(1-dr) - 1 (sum of expanded terms) = "
183  << DeltaR_EW1 + DeltaR_EW1QCD1 + DeltaR_EW2 + DeltaR_EW1QCD2
184  + DeltaR_EW2QCD1 + DeltaR_EW3 << std::endl;
185  std::cout << " EW1 = " << DeltaR_EW1 << std::endl;
186  std::cout << " DeltaAlphaL5q = " << DeltaAlphaL5q() << std::endl;
187  std::cout << " -cW2/sW2*dRho1= " << -cW2_TMP / sW2_TMP * f_AlphaToGF * DeltaRho[StandardModel::EW1] << std::endl;
188  std::cout << " DeltaR1_rem = " << DeltaR_rem[StandardModel::EW1] << std::endl;
189  std::cout << " EW1QCD1 = " << DeltaR_EW1QCD1 << std::endl;
190  std::cout << " EW2(full) = " << DeltaR_EW2 << std::endl;
191  std::cout << " EW1*EW1 = " << DeltaR_EW1 * DeltaR_EW1 << std::endl;
192  std::cout << " dAle*dAle = " << DeltaAlphaL5q() * DeltaAlphaL5q() << std::endl;
193  std::cout << " others = " << DeltaR_EW1 * DeltaR_EW1 - DeltaAlphaL5q() * DeltaAlphaL5q() << std::endl;
194  std::cout << " -cW2/sW2*dRho2= " << -cW2_TMP / sW2_TMP * pow(f_AlphaToGF, 2.0) * DeltaRho[StandardModel::EW2] << std::endl;
195  std::cout << " DeltaR2_rem = " << DeltaR_rem[StandardModel::EW2] << std::endl;
196  std::cout << " others = " << cW2_TMP / sW2_TMP * f_AlphaToGF * DeltaRho[StandardModel::EW1]*(DeltaAlphaL5q() + DeltaR_rem[StandardModel::EW1]) << std::endl;
197  std::cout << " EW1QCD2 = " << DeltaR_EW1QCD2 << std::endl;
198  std::cout << " EW2QCD1 = " << DeltaR_EW2QCD1 << std::endl;
199  std::cout << " EW3 = " << DeltaR_EW3 << std::endl;
200  std::cout << " -cW2/sW2*dRho3= " << -cW2_TMP / sW2_TMP * pow(f_AlphaToGF, 3.0) * DeltaRho[StandardModel::EW3] << std::endl;
201  std::cout << " EW1^3 = " << pow(DeltaR_EW1, 3.0) << std::endl;
202  std::cout << " 2*EW1*(EW2-EW1^2)=" << 2.0 * DeltaR_EW1 * (DeltaR_EW2 - DeltaR_EW1 * DeltaR_EW1) << std::endl;
203  std::cout << " others = " << cW2_TMP / sW2_TMP * pow(f_AlphaToGF, 2.0) * DeltaRho[StandardModel::EW2] * DeltaAlphaL5q() << std::endl;
204 
205  } else
206  std::cout << "EWSM_Output::outputEachDeltaR(): Not implemented for schemeMw="
207  << getFlagMw() << std::endl;
208 }

◆ outputEachDeltaRhoZ()

void EWSM_Output::outputEachDeltaRhoZ ( const double  f_AlphaToGF,
const double  DeltaRho[StandardModel::orders_EW_size],
const double  deltaRho_rem[StandardModel::orders_EW_size],
const double  DeltaRbar_rem,
const bool  bool_Zbb,
const double  taub[StandardModel::orders_EW_size],
const double  ZbbSubtract 
) const

Definition at line 335 of file EWSM_Output.cpp.

342 {
343  if (getFlagRhoZ().compare("APPROXIMATEFORMULA") == 0) {
344 
345  } else if (getFlagRhoZ().compare("NORESUM") == 0) {
346  std::cout << "Leading contributions: alpha or Gmu" << std::endl;
347  std::cout << " DeltaRho[EW1]=" << DeltaRho[StandardModel::EW1] << " "
348  << f_AlphaToGF * DeltaRho[StandardModel::EW1] << std::endl;
349  std::cout << " DeltaRho[EW1QCD1]=" << DeltaRho[StandardModel::EW1QCD1] << " "
350  << f_AlphaToGF * DeltaRho[StandardModel::EW1QCD1] << std::endl;
351  std::cout << " DeltaRho[EW1QCD2]=" << DeltaRho[StandardModel::EW1QCD2] << " "
352  << f_AlphaToGF * DeltaRho[StandardModel::EW1QCD2] << std::endl;
353  std::cout << " DeltaRho[EW2]=" << DeltaRho[StandardModel::EW2] << " "
354  << pow(f_AlphaToGF, 2.0) * DeltaRho[StandardModel::EW2] << std::endl;
355  std::cout << " DeltaRho[EW2QCD1]=" << DeltaRho[StandardModel::EW2QCD1] << " "
356  << pow(f_AlphaToGF, 2.0) * DeltaRho[StandardModel::EW2QCD1] << std::endl;
357  std::cout << " DeltaRho[EW3]=" << DeltaRho[StandardModel::EW3] << " "
358  << pow(f_AlphaToGF, 3.0) * DeltaRho[StandardModel::EW3] << std::endl;
359  std::cout << "Remainder contributions: alpha or Gmu" << std::endl;
360  std::cout << " DeltaRbar_rem[EW1]=" << DeltaRbar_rem << " "
361  << f_AlphaToGF * DeltaRbar_rem << std::endl;
362  std::cout << " deltaRho_rem[EW1]=" << deltaRho_rem[StandardModel::EW1] - ZbbSubtract << " "
363  << f_AlphaToGF * (deltaRho_rem[StandardModel::EW1] - ZbbSubtract) << std::endl;
364  std::cout << " deltaRho_rem[EW1QCD1]=" << deltaRho_rem[StandardModel::EW1QCD1] << " "
365  << f_AlphaToGF * deltaRho_rem[StandardModel::EW1QCD1] << std::endl;
366  std::cout << " deltaRho_rem[EW2]=" << deltaRho_rem[StandardModel::EW2] << " "
367  << pow(f_AlphaToGF, 2.0) * deltaRho_rem[StandardModel::EW2] << std::endl;
368  if (bool_Zbb) {
369  std::cout << "Taub: alpha or Gmu" << std::endl;
370  std::cout << " taub[EW1]=" << taub[StandardModel::EW1] << " "
371  << f_AlphaToGF * taub[StandardModel::EW1] << std::endl;
372  std::cout << " taub[EW1QCD1]=" << taub[StandardModel::EW1QCD1] << " "
373  << f_AlphaToGF * taub[StandardModel::EW1QCD1] << std::endl;
374  std::cout << " taub[EW2]=" << taub[StandardModel::EW2] << " "
375  << pow(f_AlphaToGF, 2.0) * taub[StandardModel::EW2] << std::endl;
376  }
377  std::cout << "Each order: alpha or Gmu" << std::endl;
378  double dRho_EW1 = DeltaRho[StandardModel::EW1] + deltaRho_rem[StandardModel::EW1] - ZbbSubtract;
379  double dRho_EW1QCD1 = DeltaRho[StandardModel::EW1QCD1] + deltaRho_rem[StandardModel::EW1QCD1];
380  double dRho_EW2 = DeltaRho[StandardModel::EW1] * DeltaRho[StandardModel::EW1]
381  + (deltaRho_rem[StandardModel::EW1] - ZbbSubtract) * DeltaRho[StandardModel::EW1]
382  - DeltaRho[StandardModel::EW1] * DeltaRbar_rem
383  + DeltaRho[StandardModel::EW2]
384  + deltaRho_rem[StandardModel::EW2];
385  double dRho_EW1QCD2 = DeltaRho[StandardModel::EW1QCD2];
386  double dRho_EW2QCD1 = DeltaRho[StandardModel::EW2QCD1] + deltaRho_rem[StandardModel::EW1QCD1] * DeltaRho[StandardModel::EW1];
387  double dRho_EW3 = DeltaRho[StandardModel::EW3];
388  //
389  double dRho_EW1_TMP = dRho_EW1;
390  double dRho_EW1QCD1_TMP = dRho_EW1QCD1;
391  double dRho_EW2_TMP = dRho_EW2;
392  double dRho_EW1QCD2_TMP = dRho_EW1QCD2;
393  double dRho_EW2QCD1_TMP = dRho_EW2QCD1;
394  double dRho_EW3_TMP = dRho_EW3;
395  //
396  if (bool_Zbb) {
397  dRho_EW1 = dRho_EW1_TMP + 2.0 * taub[StandardModel::EW1];
398  dRho_EW1QCD1 = dRho_EW1QCD1_TMP + 2.0 * taub[StandardModel::EW1QCD1];
399  dRho_EW2 = dRho_EW2_TMP + 2.0 * taub[StandardModel::EW2] + taub[StandardModel::EW1] * taub[StandardModel::EW1]
400  + dRho_EW1_TMP * 2.0 * taub[StandardModel::EW1];
401  dRho_EW1QCD2 = dRho_EW1QCD2_TMP;
402  dRho_EW2QCD1 = dRho_EW2QCD1_TMP + dRho_EW1_TMP * 2.0 * taub[StandardModel::EW1QCD1]
403  + dRho_EW1QCD1_TMP * 2.0 * taub[StandardModel::EW1] + 2.0 * taub[StandardModel::EW1] * taub[StandardModel::EW1QCD1];
404  dRho_EW3 = dRho_EW3_TMP + dRho_EW1_TMP * 2.0 * taub[StandardModel::EW2]
405  + dRho_EW2_TMP * 2.0 * taub[StandardModel::EW1] + 2.0 * taub[StandardModel::EW2] * taub[StandardModel::EW1];
406  }
407  std::cout << " EW1: " << dRho_EW1 << " " << f_AlphaToGF * dRho_EW1 << std::endl;
408  std::cout << " EW1QCD1: " << dRho_EW1QCD1 << " " << f_AlphaToGF * dRho_EW1QCD1 << std::endl;
409  std::cout << " EW2: " << dRho_EW2 << " " << pow(f_AlphaToGF, 2.0) * dRho_EW2 << std::endl;
410  std::cout << " EW1QCD2: " << dRho_EW1QCD2 << " " << f_AlphaToGF * dRho_EW1QCD2 << std::endl;
411  std::cout << " EW2QCD1: " << dRho_EW2QCD1 << " " << pow(f_AlphaToGF, 2.0) * dRho_EW2QCD1 << std::endl;
412  std::cout << " EW3: " << dRho_EW3 << " " << pow(f_AlphaToGF, 3.0) * dRho_EW3 << std::endl;
413  std::cout << "Total contribution: alpha or Gmu" << std::endl;
414  std::cout << " rhoZ="
415  << 1.0 + dRho_EW1 + dRho_EW1QCD1 + dRho_EW2
416  + dRho_EW1QCD2 + dRho_EW2QCD1 + dRho_EW3
417  << " "
418  << 1.0 + f_AlphaToGF * dRho_EW1 + f_AlphaToGF * dRho_EW1QCD1
419  + pow(f_AlphaToGF, 2.0) * dRho_EW2
420  + f_AlphaToGF * dRho_EW1QCD2 + pow(f_AlphaToGF, 2.0) * dRho_EW2QCD1
421  + pow(f_AlphaToGF, 3.0) * dRho_EW3
422  << std::endl;
423  if (bool_Zbb) {
424  std::cout << " rhoZ(taub resummed)="
425  << (1.0 + dRho_EW1_TMP + dRho_EW1QCD1_TMP + dRho_EW2_TMP
426  + dRho_EW1QCD2_TMP + dRho_EW2QCD1_TMP + dRho_EW3_TMP)
428  << " "
429  << (1.0 + f_AlphaToGF * dRho_EW1_TMP + f_AlphaToGF * dRho_EW1QCD1_TMP
430  + pow(f_AlphaToGF, 2.0) * dRho_EW2_TMP
431  + f_AlphaToGF * dRho_EW1QCD2_TMP + pow(f_AlphaToGF, 2.0) * dRho_EW2QCD1_TMP
432  + pow(f_AlphaToGF, 3.0) * dRho_EW3_TMP)
433  * pow(1.0 + f_AlphaToGF * taub[StandardModel::EW1] + f_AlphaToGF * taub[StandardModel::EW1QCD1]
434  + pow(f_AlphaToGF, 2.0) * taub[StandardModel::EW2], 2.0)
435  << std::endl;
436  }
437  } else
438  std::cout << "EWSM_Output::outputEachDeltaRhoZ(): Not implemented for schemeRhoZ="
439  << getFlagRhoZ() << std::endl;
440 }

◆ outputEachDeltaRhoZ_l()

void EWSM_Output::outputEachDeltaRhoZ_l ( const QCD::lepton  l,
const double  Mw_i 
) const

Definition at line 210 of file EWSM_Output.cpp.

211 {
212  std::cout << "================================================" << std::endl;
213  std::cout << "rhoZ_l[(QCD::lepton)" << l << "]" << std::endl;
214  std::cout << "Mw(input) = " << Mw_i << std::endl;
215 
216  double cW2_TMP = Mw_i * Mw_i / getMz() / getMz();
217  double sW2_TMP = 1.0 - cW2_TMP;
218 
219  double DeltaRho[StandardModel::orders_EW_size];
220  DeltaRho[StandardModel::EW1] = getMyOneLoopEW()->DeltaRho(Mw_i);
221  DeltaRho[StandardModel::EW1QCD1] = getMyTwoLoopQCD()->DeltaRho(Mw_i);
223  DeltaRho[StandardModel::EW2] = getMyTwoLoopEW()->DeltaRho(Mw_i);
225  DeltaRho[StandardModel::EW3] = getMyThreeLoopEW()->DeltaRho(Mw_i);
226 
227  /* compute delta rho_rem^f */
229  deltaRho_rem_f[StandardModel::EW1] = getMyOneLoopEW()->deltaRho_rem_f(getLeptons(l), Mw_i);
230 #ifdef WITHIMTWOLOOPQCD
231  deltaRho_rem_f[StandardModel::EW1QCD1] = gslpp::complex(getMyTwoLoopQCD()->deltaRho_rem_f(getLeptons(l), Mw_i).real(),
232  getMyTwoLoopQCD()->deltaRho_rem_f(getLeptons(l), Mw_i).imag(), false);
233 #else
234  deltaRho_rem_f[StandardModel::EW1QCD1] = gslpp::complex(getMyTwoLoopQCD()->deltaRho_rem_f(getLeptons(l), Mw_i).real(), 0.0, false);
235 #endif
236  deltaRho_rem_f[StandardModel::EW1QCD2] = gslpp::complex(getMyThreeLoopQCD()->deltaRho_rem_f(getLeptons(l), Mw_i).real(), 0.0, false);
237  deltaRho_rem_f[StandardModel::EW2] = gslpp::complex(getMyTwoLoopEW()->deltaRho_rem_f(getLeptons(l), Mw_i).real(), 0.0, false);
238  deltaRho_rem_f[StandardModel::EW2QCD1] = gslpp::complex(getMyThreeLoopEW2QCD()->deltaRho_rem_f(getLeptons(l), Mw_i).real(), 0.0, false);
239  deltaRho_rem_f[StandardModel::EW3] = gslpp::complex(getMyThreeLoopEW()->deltaRho_rem_f(getLeptons(l), Mw_i).real(), 0.0, false);
240 
241  /* compute Delta rbar_rem */
242  double DeltaRbar_rem = getMyOneLoopEW()->DeltaRbar_rem(Mw_i);
243 
244  double f_AlphaToGF = sqrt(2.0) * getGF() * pow(getMz(), 2.0)
245  * sW2_TMP * cW2_TMP / M_PI / getAle();
246 
247  /* Re[rho_Z^f] with or without resummation */
248  double deltaRho_rem_f_real[StandardModel::orders_EW_size];
249  for (int j = 0; j < StandardModel::orders_EW_size; ++j)
250  deltaRho_rem_f_real[j] = deltaRho_rem_f[j].real();
251 
252  double dummy[StandardModel::orders_EW_size];
253  outputEachDeltaRhoZ(f_AlphaToGF, DeltaRho, deltaRho_rem_f_real,
254  DeltaRbar_rem, false, dummy, 0.0);
255 
256  /* Im[rho_Z^f] without resummation */
257  double ImRhoZf = 0.0;
258  for (int j = 0; j < StandardModel::orders_EW_size; ++j)
259  ImRhoZf += deltaRho_rem_f[j].imag();
260  std::cout << "ImRhoZf(with alpha)=" << ImRhoZf << std::endl;
261 
262  std::cout << "================================================" << std::endl;
263 }

◆ outputEachDeltaRhoZ_q()

void EWSM_Output::outputEachDeltaRhoZ_q ( const QCD::quark  q,
const double  Mw_i 
) const

Definition at line 265 of file EWSM_Output.cpp.

266 {
267  std::cout << "================================================" << std::endl;
268  std::cout << "rhoZ_q[(QCD::quark)" << q << "]" << std::endl;
269  std::cout << "Mw(input) = " << Mw_i << std::endl;
270 
271  double cW2_TMP = Mw_i * Mw_i / getMz() / getMz();
272  double sW2_TMP = 1.0 - cW2_TMP;
273 
274  double DeltaRho[StandardModel::orders_EW_size];
275  DeltaRho[StandardModel::EW1] = getMyOneLoopEW()->DeltaRho(Mw_i);
276  DeltaRho[StandardModel::EW1QCD1] = getMyTwoLoopQCD()->DeltaRho(Mw_i);
278  DeltaRho[StandardModel::EW2] = getMyTwoLoopEW()->DeltaRho(Mw_i);
280  DeltaRho[StandardModel::EW3] = getMyThreeLoopEW()->DeltaRho(Mw_i);
281 
282  /* compute delta rho_rem^f */
284  deltaRho_rem_f[StandardModel::EW1] = getMyOneLoopEW()->deltaRho_rem_f(getQuarks(q), Mw_i);
285 #ifdef WITHIMTWOLOOPQCD
286  deltaRho_rem_f[StandardModel::EW1QCD1] = gslpp::complex(getMyTwoLoopQCD()->deltaRho_rem_f(getQuarks(q), Mw_i).real(),
287  getMyTwoLoopQCD()->deltaRho_rem_f(getQuarks(q), Mw_i).imag(), false);
288 #else
289  deltaRho_rem_f[StandardModel::EW1QCD1] = gslpp::complex(getMyTwoLoopQCD()->deltaRho_rem_f(getQuarks(q), Mw_i).real(), 0.0, false);
290 #endif
291  deltaRho_rem_f[StandardModel::EW1QCD2] = gslpp::complex(getMyThreeLoopQCD()->deltaRho_rem_f(getQuarks(q), Mw_i).real(), 0.0, false);
292  deltaRho_rem_f[StandardModel::EW2] = gslpp::complex(getMyTwoLoopEW()->deltaRho_rem_f(getQuarks(q), Mw_i).real(), 0.0, false);
293  deltaRho_rem_f[StandardModel::EW2QCD1] = gslpp::complex(getMyThreeLoopEW2QCD()->deltaRho_rem_f(getQuarks(q), Mw_i).real(), 0.0, false);
294  deltaRho_rem_f[StandardModel::EW3] = gslpp::complex(getMyThreeLoopEW()->deltaRho_rem_f(getQuarks(q), Mw_i).real(), 0.0, false);
295 
296  /* compute Delta rbar_rem */
297  double DeltaRbar_rem = getMyOneLoopEW()->DeltaRbar_rem(Mw_i);
298 
299  /* conversion factor */
300  double f_AlphaToGF = sqrt(2.0) * getGF() * pow(getMz(), 2.0)
301  * sW2_TMP * cW2_TMP / M_PI / getAle();
302 
303  /* Zbb */
304  bool bool_Zbb = false;
305  if (q == QCD::BOTTOM) bool_Zbb = true;
306  double ZbbSubtract = 0.0;
307  if (bool_Zbb)
308  ZbbSubtract = -getAle() / 4.0 / M_PI / sW2_TMP
309  * pow(getMtpole() / Mw_i, 2.0);
311  double Xt = getMyEWSMcache()->Xt_alpha(Mw_i);
312  if (bool_Zbb) {
313  taub[StandardModel::EW1] = -2.0 * Xt;
314  taub[StandardModel::EW1QCD1] = 2.0 / 3.0 * M_PI * Xt * getMyEWSMcache()->alsMt();
315  taub[StandardModel::EW2] = -2.0 * Xt * Xt * getMyTwoLoopEW()->tau_2();
316  }
317 
318  /* Re[rho_Z^f] with or without resummation */
319  double deltaRho_rem_f_real[StandardModel::orders_EW_size];
320  for (int j = 0; j < StandardModel::orders_EW_size; ++j)
321  deltaRho_rem_f_real[j] = deltaRho_rem_f[j].real();
322 
323  outputEachDeltaRhoZ(f_AlphaToGF, DeltaRho, deltaRho_rem_f_real,
324  DeltaRbar_rem, bool_Zbb, taub, ZbbSubtract);
325 
326  /* Im[rho_Z^f] without resummation */
327  double ImRhoZf = 0.0;
328  for (int j = 0; j < StandardModel::orders_EW_size; ++j)
329  ImRhoZf += deltaRho_rem_f[j].imag();
330  std::cout << "ImRhoZf(with alpha)=" << ImRhoZf << std::endl;
331 
332  std::cout << "================================================" << std::endl;
333 }

The documentation for this class was generated from the following files:
EWSMThreeLoopEW::DeltaR_rem
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
Definition: EWSMThreeLoopEW.cpp:109
StandardModel::getMyOneLoopEW
EWSMOneLoopEW * getMyOneLoopEW() const
A get method to retrieve the member pointer of type EWSMOneLoopEW,.
Definition: StandardModel.h:967
StandardModel::EW2
Two-loop of .
Definition: StandardModel.h:496
StandardModel::taub
double taub() const
Top-mass corrections to the vertex, denoted by .
Definition: StandardModel.cpp:2078
QCD::BOTTOM
Definition: QCD.h:329
StandardModel::DeltaRbar
virtual double DeltaRbar() const
The SM prediction for derived from that for the -boson mass.
Definition: StandardModel.cpp:1120
EWSMThreeLoopEW::DeltaRho
double DeltaRho(const double Mw_i) const
Leading three-loop contribution of to , denoted as .
Definition: EWSMThreeLoopEW.cpp:70
EWSMOneLoopEW::DeltaRbar_rem
double DeltaRbar_rem(const double Mw_i) const
.
Definition: EWSMOneLoopEW.cpp:73
EWSM_Output::outputEachDeltaRhoZ
void outputEachDeltaRhoZ(const double f_AlphaToGF, const double DeltaRho[StandardModel::orders_EW_size], const double deltaRho_rem[StandardModel::orders_EW_size], const double DeltaRbar_rem, const bool bool_Zbb, const double taub[StandardModel::orders_EW_size], const double ZbbSubtract) const
Definition: EWSM_Output.cpp:335
EWSMOneLoopEW::DeltaRho
double DeltaRho(const double Mw_i) const
Leading one-loop contribution of to , denoted as .
Definition: EWSMOneLoopEW.cpp:43
StandardModel::getFlagRhoZ
std::string getFlagRhoZ() const
A method to retrieve the model flag RhoZ.
Definition: StandardModel.h:669
StandardModel::EW1
One-loop of .
Definition: StandardModel.h:493
StandardModel::getMyEWSMcache
EWSMcache * getMyEWSMcache() const
A get method to retrieve the member pointer of type EWSMcache.
Definition: StandardModel.h:958
StandardModel::getMyTwoLoopQCD
EWSMTwoLoopQCD * getMyTwoLoopQCD() const
Definition: StandardModel.h:1001
StandardModel::getMyThreeLoopQCD
EWSMThreeLoopQCD * getMyThreeLoopQCD() const
Definition: StandardModel.h:991
StandardModel::alphaMz
double alphaMz() const
The electromagnetic coupling at the -mass scale, .
Definition: StandardModel.cpp:867
StandardModel::DeltaAlphaL5q
double DeltaAlphaL5q() const
The sum of the leptonic and the five-flavour hadronic corrections to the electromagnetic coupling at...
Definition: StandardModel.cpp:830
gslpp::complex
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35
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
StandardModel::getMyThreeLoopEW
EWSMThreeLoopEW * getMyThreeLoopEW() const
Definition: StandardModel.h:981
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::DeltaRho
double DeltaRho(const double Mw_i) const
Leading three-loop contribution of to , denoted as .
Definition: EWSMThreeLoopEW2QCD.cpp:29
StandardModel::DeltaR
virtual double DeltaR() const
The SM prediction for derived from that for the boson mass.
Definition: StandardModel.cpp:1010
EWSMTwoLoopQCD::DeltaR_rem
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
Definition: EWSMTwoLoopQCD.cpp:44
StandardModel::StandardModel
StandardModel()
The default constructor.
Definition: StandardModel.cpp:35
StandardModel::EW1QCD1
Two-loop of .
Definition: StandardModel.h:494
gslpp::pow
complex pow(const complex &z1, const complex &z2)
Definition: gslpp_complex.cpp:395
StandardModel::getGF
double getGF() const
A get method to retrieve the Fermi constant .
Definition: StandardModel.h:736
gslpp::sqrt
complex sqrt(const complex &z)
Definition: gslpp_complex.cpp:385
EWSMThreeLoopQCD::DeltaRho
double DeltaRho(const double Mw_i) const
Leading three-loop QCD contribution of to , denoted as .
Definition: EWSMThreeLoopQCD.cpp:42
EWSM_Output::outputEachDeltaKappaZ
void outputEachDeltaKappaZ(const double f_AlphaToGF, const double cW2overSW2, const double DeltaRho[StandardModel::orders_EW_size], const double deltaKappa_rem[StandardModel::orders_EW_size], const double DeltaRbar_rem, const bool bool_Zbb, const double taub[StandardModel::orders_EW_size], const double ZbbSubtract, const double Zgamma_EW2) const
Definition: EWSM_Output.cpp:582
StandardModel::EW3
Three-loop of .
Definition: StandardModel.h:498
QCD::getMtpole
double getMtpole() const
A get method to access the pole mass of the top quark.
Definition: QCD.h:588
EWSMTwoLoopQCD::DeltaRho
double DeltaRho(const double Mw_i) const
Leading two-loop QCD contribution of to , denoted as .
Definition: EWSMTwoLoopQCD.cpp:38
EWSMThreeLoopEW2QCD::DeltaR_rem
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
Definition: EWSMThreeLoopEW2QCD.cpp:63
StandardModel::getMyTwoLoopEW
EWSMTwoLoopEW * getMyTwoLoopEW() const
Definition: StandardModel.h:996
EWSMTwoLoopEW::tau_2
double tau_2() const
The function .
Definition: EWSMTwoLoopEW.cpp:151
QCD::getQuarks
Particle getQuarks(const QCD::quark q) const
A get method to access a quark as an object of the type Particle.
Definition: QCD.h:534
StandardModel::getMyApproximateFormulae
EWSMApproximateFormulae * getMyApproximateFormulae() const
A get method to retrieve the member pointer of type EWSMApproximateFormulae.
Definition: StandardModel.h:976
EWSMApproximateFormulae::DeltaR_TwoLoopEW_rem
double DeltaR_TwoLoopEW_rem(const double Mw_i) const
.
Definition: EWSMApproximateFormulae.cpp:252
EWSMTwoLoopEW::DeltaRho
double DeltaRho(const double Mw_i) const
Leading two-loop contribution of to , denoted as .
Definition: EWSMTwoLoopEW.cpp:54
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.cpp:2001
StandardModel::getMz
double getMz() const
A get method to access the mass of the boson .
Definition: StandardModel.h:718
EWSMOneLoopEW::DeltaR_rem
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
Definition: EWSMOneLoopEW.cpp:49
StandardModel::getFlagKappaZ
std::string getFlagKappaZ() const
A method to retrieve the model flag KappaZ.
Definition: StandardModel.h:679
EWSMThreeLoopQCD::DeltaR_rem
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
Definition: EWSMThreeLoopQCD.cpp:48
StandardModel::getFlagMw
std::string getFlagMw() const
A method to retrieve the model flag Mw.
Definition: StandardModel.h:659
StandardModel::EW2QCD1
Three-loop of .
Definition: StandardModel.h:497
StandardModel::Mw
virtual double Mw() const
The SM prediction for the -boson mass in the on-shell scheme, .
Definition: StandardModel.cpp:944
EWSMcache::alsMt
double alsMt() const
The strong coupling at NNLO.
Definition: EWSMcache.h:378
StandardModel::kappaZ_f
virtual gslpp::complex kappaZ_f(const Particle f) const
The effective leptonic neutral-current coupling in the SM.
Definition: StandardModel.cpp:1618
StandardModel::EW1QCD2
Three-loop of .
Definition: StandardModel.h:495
EWSMcache::Xt_alpha
double Xt_alpha(const double Mw_i) const
The quantity with the coupling .
Definition: EWSMcache.h:355
StandardModel::getAle
double getAle() const
A get method to retrieve the fine-structure constant .
Definition: StandardModel.h:745
StandardModel::orders_EW_size
The size of this enum.
Definition: StandardModel.h:499
EWSMTwoLoopEW::DeltaR_rem
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
Definition: EWSMTwoLoopEW.cpp:81
StandardModel::getMyThreeLoopEW2QCD
EWSMThreeLoopEW2QCD * getMyThreeLoopEW2QCD() const
Definition: StandardModel.h:986
StandardModel::getLeptons
Particle getLeptons(const QCD::lepton p) const
A get method to retrieve the member object of a lepton.
Definition: StandardModel.h:709
StandardModel::orders_EW
orders_EW
An enumerated type representing perturbative orders of radiative corrections to EW precision observab...
Definition: StandardModel.h:492