QCD Class Reference

A class for parameters related to QCD, hadrons and quarks. More...

#include <QCD.h>

Inheritance diagram for QCD:

Detailed Description

A class for parameters related to QCD, hadrons and quarks.

Author

HEPfit Collaboration

Copyright

GNU General Public License

This class is a Model class that assigns and updates parameters related to and derived from QCD. A complete list of parameters in the QCD class can be found below. This class includes, but is not limited to, the running of the strong coupling constant (Full NNLO), running of the quark masses and conversions between pole mass and \(\overline{\mathrm{MS}}\) mass. All hadronization parameters like the bag parameters for the mesons and their decay constants are assigned and updated by this class.

Initialization

The constructor QCD() sets the charge and isospin of the quarks. It also sets the mass scale of the light quarks UP, DOWN and STRANGE to 2 GeV. The cache is initialized too along with the computation of \(\zeta(2)\) and \(\zeta(3)\).

The initializations and updates of the model parameters and flags are explained below.

Model parameters

The model parameters of QCD are summarized below:

Label	LaTeX symbol	Description
AlsM	\(\alpha_s(M_{\alpha_s})\)	The strong coupling constant at the scale \(M_{\alpha_s}\).
MAls	\(M_{\alpha_s}\)	The mass scale in GeV at which the strong coupling constant measurement is provided. Must be in the 5 flavour energy range.
mup	\(m_{u}(2\,\mathrm{GeV})\)	The \(\overline{\mathrm{MS}}\) mass of the up quark at 2 GeV, \(m_u(2\,\mathrm{GeV})\), in GeV.
mdown	\(m_{d}(2\,\mathrm{GeV})\)	The \(\overline{\mathrm{MS}}\) mass of the down quark at 2 GeV, \(m_d(2\,\mathrm{GeV})\), in GeV.
mcharm	\(m_{c}(m_c)\)	The \(\overline{\mathrm{MS}}\) scale-invariant mass of the charm quark, \(m_c(m_c)\), in GeV.
mstrange	\(m_{s}(2\,\mathrm{GeV})\)	The \(\overline{\mathrm{MS}}\) mass of the strange quark at 2 GeV , \(m_s(2\,\mathrm{GeV})\), in GeV.
mtop	\(m_{t}\)	The pole mass of the top quark in GeV.
mbottom	\(m_{b}(m_b)\)	The \(\overline{\mathrm{MS}}\) scale-invariant mass of the bottom quark, \(m_b(m_b)\), in GeV.
muc	\(\mu_c\)	The threshold between three- and four-flavour theory in GeV.
mub	\(\mu_b\)	The threshold between four- and five-flavour theory in GeV.
mut	\(\mu_t\)	The threshold between five- and six-flavour theory in GeV.

Attention

The parameters AlsM and MAls are not used in StandardModel and the model classes inherited from it.

The set of the model parameters are initialized and updated with the methods Init() and Update(), respectively, where the former calls the latter. In Update(), the methods PreUpdate() and PostUpdate() are called to run all the procedures that are need to be executed before and after the model parameters are updated. The \(\overline{\mathrm{MS}}\) mass for the top quark is computed and the scale set in PostUpdate() with the updated parameters. Inside the Update() method, the individual model parameter is assigned with the protected member function setParameter().

Computation of the strong coupling constant \(\alpha_s\):

The strong coupling constant \(\alpha_s\) at an arbitrary scale can be computed with the member functions:

• AlsWithInit(const double mu, const double alsi, const double mu_i, const int nf, const orders order),
• AlsWithLambda(const double mu, const orders order),

where another function

• Als(const double mu, const orders order = FULLNLO)

calls AlsWithInit() for order=LO/FULLNLO(NLO), and AlsWithLambda() for order=FULLNNLO(NNLO).

The function AlsWithInit() computes \(\alpha_s(\mu)\) with a given initial value \(\alpha_s(\mu_i)\):

\[ \alpha_s(\mu)=\frac{\alpha_s(\mu_i)}{v(\mu)},\qquad \alpha_s(\mu)=\frac{\alpha_s(\mu_i)}{v(\mu)} \left[1-\frac{\beta_1}{\beta_0}\frac{\alpha_s(\mu_i)}{4\pi} \frac{\ln v(\mu)}{v(\mu)}\right], \]

at LO and FULLNLO (NLO) respectively, where

\[ v(\mu) = 1- \beta_0\frac{\alpha_s(\mu_i)}{2\pi}\ln\frac{\mu_i}{\mu}, \]

and the one-loop and two-loop beta functions are given by

\[ \beta_0 = \frac{11N_c-2N_f}{3},\qquad \beta_1 = \frac{34}{3}N_c^2-\frac{10}{3}N_cN_f-2C_FN_f. \]

The function AlsWithLambda() computes \(\alpha_s(\mu)\) with the use of \(\Lambda_{\rm QCD}\), where the value of \(\Lambda_{\rm QCD}\) for \(N_f=5\) is derived from \(\alpha_s(M_{\alpha_s})\) by solving the equation (see e.g., [Chetyrkin:1997sg], which follows the convention in [Buras:1977qg] for \(\ln(\mu^2/\Lambda^2)\)):

\[ \frac{\alpha_s(\mu)}{4\pi}=\frac{1}{\beta_0L}-\frac{\beta_1\ln L}{\beta_0^3L^2}+ \frac{1}{\left(\beta_0L\right)^3}\left[\frac{\beta_1^2}{\beta_0^2}\left(\ln^2L-\ln L-1\right)+ \frac{\beta_2}{\beta_0}\right]+O\left(\frac{\ln^3L}{L^4}\right), \]

where \(L\equiv\ln(\mu^2/\Lambda^2)\), and the three-loop beta function is given by

\[ \beta_2 = \frac{2857}{54}N_c^3+C_F^2N_f-\frac{205}{18}C_FN_cN_f -\frac{1415}{54}N_c^2N_f+\frac{11}{9}C_FN_f^2 + \frac{79}{54}N_cN_f^2. \]

For \(N_f < 5\), \(\Lambda_{QCD}\) can be obtained by solving the following matching condition at \(\mu\) [Chetyrkin:1997sg] [Chetyrkin:2000yt] :

\begin{eqnarray} \beta_0^{'}\ln\frac{\Lambda^{'2}}{\Lambda^2} &=& (\beta_0^{'}-\beta_0)L+\left(\frac{\beta_1^{'}}{\beta_0^{'}}- \frac{\beta_1}{\beta_0}\right)\ln L-\frac{\beta_1^{'}}{\beta_0^{'}}\ln\frac{\beta_0^{'}}{\beta_0} - C_1 \\ &&+ \frac{1}{\beta_0L}\left[\frac{\beta_1}{\beta_0}\left(\frac{\beta_1^{'}}{\beta_0^{'}}-\frac{\beta_1}{\beta_0} \right)\ln L + \frac{\beta_1^{'2}}{\beta_0^{'2}}-\frac{\beta_1^2}{\beta_0^2}-\frac{\beta_2^{'2}}{\beta_0^{'2}} +\frac{\beta_2^2}{\beta_0^2}+\frac{\beta_1^{'}}{\beta_0^{'}}C_1-C_1^2-C_2\right]+ O\left(\frac{\ln^2L}{L^2}\right), \end{eqnarray}

where the primed (unprimed) quantities refer to those pertaining to \(N_f-1\) \((N_f)\). The terms \(C_1\) and \(C_2\) are given by

\[ C_1 = \frac{2}{3}\ln\frac{\mu^2}{\mu_f^2},\qquad C_2 = -16\left(\frac{1}{36}\ln^2\frac{\mu^2}{\mu_f^2}-\frac{19}{24}\ln\frac{\mu^2}{\mu_f^2}+\frac{11}{72}\right). \]

where \(\mu_f=m_f(\mu_f)\) denotes the \(\overline{\mathrm{MS}}\) invariant mass of the \(N_f\)-th flavour. Moreover, the matching condition at a flavour threshold is given by

\[ \alpha_s^{(N_f-1)}(\mu) = (\zeta_g^f)^2\alpha_s^{(N_f)}(\mu), \]

where

\[ (\zeta_g^f)^2 = 1+\frac{\alpha_s^{(N_f)}(\mu)}{\pi}\left(-\frac{1}{6}\ln\frac{\mu^2}{\mu_f^2}\right)+ \left(\frac{\alpha_s^{(N_f)}(\mu)}{\pi}\right)^2\left(\frac{1}{36}\ln^2\frac{\mu^2}{\mu_f^2} - \frac{19}{24}\ln\frac{\mu^2}{\mu_f^2} + \frac{11}{72}\right) + O\left(\left(\frac{\alpha_s}{\pi} \right)^3\right). \]

For the top quark mass, the pole mass \(m_t\) is used as an input instead of the \(\overline{\mathrm{MS}}\) invariant mass. Then the \(\overline{\mathrm{MS}}\) invariant mass is computed from the pole mass with the computed value of \(\alpha_s^{(6)}(m_t)\), which in turn is computed from \(\alpha_s^{(5)}(M_Z)\). Hence, the matching condition from \(N_f = 6\) to \(N_f = 5\) has to be free from the \(\overline{\mathrm{MS}}\) invariant mass of the top quark. In this case we use the following matching condition

\[ \alpha_s^{(6)}(\mu_t) = \frac{1}{(\zeta_g^{OS,t})^2}\alpha_s^{(5)}(\mu_t), \]

where

\[ \frac{1}{(\zeta_g^{OS,t})^2} = 1+\frac{\alpha_s^{(5)}(\mu)}{\pi}\left(\frac{1}{6}\ln\frac{\mu^2}{m_t^2}\right)+ \left(\frac{\alpha_s^{(5)}(\mu)}{\pi}\right)^2\left(\frac{1}{36}\ln^2\frac{\mu^2}{m_t^2} + \frac{19}{24}\ln\frac{\mu^2}{m_t^2} + \frac{7}{24}\right) + O\left(\left(\frac{\alpha_s}{\pi}\right)^3\right). \]

Besides, \(\Lambda_{QCD}\) for \(N_f=6\) is derived from that for \(N_f=5\) with the relation:

\begin{eqnarray} \beta_0\ln\frac{\Lambda^{2}}{\Lambda^{'2}} &=& (\beta_0-\beta_0^{'})L^{'}+\left(\frac{\beta_1}{\beta_0}- \frac{\beta_1^{'}}{\beta_0^{'}}\right)\ln L^{'}-\frac{\beta_1}{\beta_0}\ln\frac{\beta_0}{\beta_0^{'}}-C_1^{'} \\ && + \frac{1}{\beta_0^{'}L^{'}}\left[\frac{\beta_1^{'}}{\beta_0^{'}}\left(\frac{\beta_1}{\beta_0}-\frac{\beta_1^{'}} {\beta_0^{'}}\right)\ln L^{'}+\frac{\beta_1^{2}}{\beta_0^{2}}-\frac{\beta_1^{'2}}{\beta_0^{'2}}- \frac{\beta_2^{2}}{\beta_0^{2}}+\frac{\beta_2^{'2}}{\beta_0^{'2}}+\frac{\beta_1}{\beta_0}C_1^{'}-C_1^{'2}- C_2^{'}\right]+O\left(\frac{\ln^2L}{L^2}\right), \end{eqnarray}

where

\[ C_1^{'} = -\frac{2}{3}\ln\frac{\mu^2}{m_t^2},\qquad C_2^{'} = -16\left(\frac{1}{36}\ln^2\frac{\mu^2}{m_t^2}+\frac{19}{24}\ln\frac{\mu^2}{m_t^2}+\frac{7}{24}\right). \]

Computation of the running of the quark masses:

In the \(\overline{\mathrm{MS}}\) scheme the quark mass at a scale \(\mu\) is given by (see e.g., [Chetyrkin:1997dh])

\[ m_q(\mu) = m_q(\mu_0)\left[\frac{\alpha_s(\mu)}{\alpha_s(\mu_0)}\right]^{\frac{\gamma^{(0)}_m}{2\beta_0}} \left\{1+A_1\frac{\alpha_s(\mu)-\alpha_s(\mu_0)}{4\pi}+\frac{A_1^2}{2}\left(\frac{\alpha_s(\mu)-\alpha_s(\mu_0)}{4\pi} \right)^2+\frac{A_2}{2}\left[\left(\frac{\alpha_s(\mu)}{4\pi}\right)^2-\left(\frac{\alpha_s(\mu_0)}{4\pi} \right)^2\right]\right\}, \]

where

\[ A_1 = \frac{\gamma^{(1)}_m}{2\beta_0} - \frac{\beta_1\gamma^{(0)}_m}{2\beta_0^2},\qquad A_2 = \frac{\beta_1^2\gamma^{(0)}_m}{2\beta_0^3}-\frac{\beta_2\gamma^{(0)}_m}{2\beta_0^2}- \frac{\beta_1\gamma^{(1)}_m}{2\beta_0^2}+\frac{\gamma^{(2)}_m}{2\beta_0}, \]

and

\[ \gamma_m^{(0)} = 6C_F,\qquad \gamma_m^{(1)} = C_F\left(3C_F+\frac{97}{3}N_c-\frac{10}{3}N_f\right),\\ \gamma_m^{(2)} = 129C_F^3-\frac{129}{2}C_F^2N_c+\frac{11413}{54}C_FN_c^2+C_F^2N_f(-46+48\zeta(3))+ C_FN_CN_f\left(-\frac{556}{27}-48\zeta(3)\right)-\frac{70}{27}C_FN_f^2, \]

in the \(\overline{\mathrm{MS}}\) scheme. The threshold conditions are given by [Chetyrkin:2000yt]

\[ m_q^{(N_f-1)}(\mu)=\zeta_m^f\, m_q^{(N_f)}(\mu),\qquad m_q^{(N_f)}(\mu)=\frac{1}{\zeta_m^f}\, m_q^{(N_f-1)}(\mu), \]

where

\[ \zeta^f_m=1+\left(\frac{\alpha_s^{(N_f)}(\mu)}{\pi}\right)^2\left(\frac{1}{12}\ln^2\frac{\mu^2}{\mu_f^2} -\frac{5}{36}\ln\frac{\mu^2}{\mu_f^2}+\frac{89}{432}\right),\\ \frac{1}{\zeta^f_m}=1+\left(\frac{\alpha_s^{(N_f-1)}(\mu)}{\pi}\right)^2\left(-\frac{1}{12}\ln^2\frac{\mu^2} {\mu_f^2}+\frac{5}{36}\ln\frac{\mu^2}{\mu_f^2}-\frac{89}{432}\right), \]

with \(\mu_f=m_f(\mu_f)\).

Pole mass vs. \( \overline{\mathrm{MS}} \) scale invariant mass:

The pole mass \(M_q\) of a heavy quark is related to the \(\overline{\mathrm{MS}}\) scale invariant mass \(m_q(m_q)\) as [Chetyrkin:2000yt]

\[ m_q(m_q)=M_q\left\{1-\frac{4}{3}\frac{\alpha_s(M_q)}{\pi}+\left[-\frac{2251}{268}-2\zeta(2) -\frac{2}{3}\zeta(2)\ln2+\frac{\zeta(3)}{6}+\frac{n_l}{3}\left(\zeta(2)+\frac{71}{48}\right) -\frac{4}{3}\sum_{1\le i \le n_l}\Delta\left(\frac{M_i}{M_q}\right)\right]\left(\frac{\alpha_s(M_q)}{\pi} \right)^2\right\}, \]

where \(n_l\) is the number of the light quarks, and \(\Delta(x)\) is given by

\[ \Delta(x)=\frac{\pi^2}{8}x-0.597x^2+0.230x^3+O\left(x^4\right). \]

It should be noted that the above formula requires the light quark pole masses which are not well defined. The pole mass in terms of the \(\overline{\mathrm{MS}}\) mass is given by

\[ M_q=m_q(m_q)\left\{1+\frac{4}{3}\frac{\alpha_s(m_q)}{\pi}+\left[\frac{307}{32}+2\zeta(2) +\frac{2}{3}\zeta(2)\ln2-\frac{\zeta(3)}{6}-\frac{n_l}{3}\left(\zeta(2)+\frac{71}{48}\right) +\frac{4}{3}\sum_{1\le i \le n_l}\Delta\left(\frac{m_i}{m_q}\right)\right]\left(\frac{\alpha_s(m_q)}{\pi} \right)^2\right\} \]

To get the pole mass of the light quarks we solve the above equation numerically and derive it from the corresponding \(\overline{\mathrm{MS}}\) mass.

Definition at line 304 of file QCD.h.

Public Types
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 , D_S , B_D , B_P , B_S , B_C , PHI , K_star , K_star_P , K_S , 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...

Public Member Functions
const 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...
const double	Als (const double mu, const int Nf_in, const orders order=FULLNLO) const
	Computes the running strong coupling \(\alpha_s(\mu)\) with \(N_f\) active flavours in the \(\overline{\mathrm{MS}}\) scheme. In the cases of LO, NLO and FULLNLO, the coupling is computed with AlsWithInit(). On the other hand, in the cases of NNLO and FULLNNLO, the coupling is computed with AlsWithLambda(). More...
const double	Als (const double mu, const orders order=FULLNLO, const bool Nf_thr=true) const
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...
const double	AlsByOrder (const double mu, const int Nf_in, const orders order=FULLNLO) const
const double	AlsByOrder (const double mu, const orders order=FULLNLO, bool Nf_thr=true) const
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...
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 \(\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...
const 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...
const double	BelowTh (const double mu) const
	The active flavour threshold below the scale \(\mu\) as defined in QCD::Thresholds(). More...
const double	Beta0 (const double nf) const
	The \(\beta_0(n_f)\) coefficient for a certain number of flavours \(n_f\). More...
const double	Beta1 (const double nf) const
	The \(\beta_1(n_f)\) coefficient for a certain number of flavours \(n_f\). More...
const double	Beta2 (const double nf) const
	The \(\beta_2(n_f)\) coefficient for a certain number of flavours \(n_f\). More...
const 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
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 QCD have been provided in model initialization. More...
const orders	FullOrder (orders order) const
	Return the FULLORDER enum corresponding to order. More...
const double	Gamma0 (const double nf) const
	The \(\gamma_0\) coefficient used to compute the running of a mass. More...
const double	Gamma1 (const double nf) const
	The \(\gamma_1\) coefficient used to compute the running of a mass. More...
const double	Gamma2 (const double nf) const
	The \(\gamma_2\) coefficient used to compute the running of a mass. More...
const double	getAlsM () const
	A get method to access the value of \(\alpha_s(M_{\alpha_s})\). More...
const 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...
const BParameter &	getBBd_subleading () const
	For getting the subleading bag parameters \(R_2 - R_3\) in \(\Delta b = 2\) process in the \(B_d\) meson system. More...
const 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...
const BParameter &	getBBs_subleading () const
	For getting the subleading bag parameters \(R_2 - R_3\) in \(\Delta b = 2\) process in the \(B_s\) meson system. More...
const 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...
const 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...
const BParameter &	getBKd1 () const
const BParameter &	getBKd3 () const
const double	getCF () const
	A get method to access the Casimir factor of QCD. More...
const double	getMAls () const
	A get method to access the mass scale \(M_{\alpha_s}\) at which the strong coupling constant measurement is provided. More...
const Meson &	getMesons (const QCD::meson m) const
	A get method to access a meson as an object of the type Meson. More...
const double	getMtpole () const
	A get method to access the pole mass of the top quark. More...
const double	getMub () const
	A get method to access the threshold between five- and four-flavour theory in GeV. More...
const double	getMuc () const
	A get method to access the threshold between four- and three-flavour theory in GeV. More...
const double	getMut () const
	A get method to access the threshold between six- and five-flavour theory in GeV. More...
const double	getNc () const
	A get method to access the number of colours \(N_c\). More...
const double	getOptionalParameter (std::string name) const
	A method to get parameters that are specific to only one set of observables. More...
const 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...
virtual bool	Init (const std::map< std::string, double > &DPars)
	Initializes the QCD parameters found in the argument. 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...
bool	isQCDsuccess () const
	A getter for the QCDsuccess flag. More...
const double	logLambda (const double nf, orders order) const
	Computes \(\ln\Lambda_\mathrm{QCD}\) with nf flavours in GeV. More...
const double	Mbar2Mp (const double mbar, const quark q, const orders order=FULLNNLO) const
	Converts the \(\overline{\mathrm{MS}}\) mass \(m(m)\) to the pole mass. More...
const double	Mofmu2Mbar (const double m, const double mu, const quark q) const
	Converts a quark running mass at an arbitrary scale to the corresponding \(\overline{\mathrm{MS}}\) mass \(m(m)\). More...
const double	Mp2Mbar (const double mp, const quark q, orders order=FULLNNLO) const
	Converts a quark pole mass to the corresponding \(\overline{\mathrm{MS}}\) mass \(m(m)\). More...
const double	Mrun (const double mu, const double m, const quark q, const orders order=FULLNNLO) const
	Computes a running quark mass \(m(\mu)\) from \(m(m)\). More...
const double	Mrun (const double mu_f, const double mu_i, const double m, const quark q, const orders order=FULLNNLO) const
	Runs a quark mass from \(\mu_i\) to \(\mu_f\). More...
const 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...
const double	MS2DRqmass (const double MSbar) const
	Converts a quark mass from the \(\overline{\mathrm{MS}}\) scheme to the \(\overline{\mathrm{DR}}\) scheme. More...
const 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...
const double	Nf (const double mu) const
	The number of active flavour at scale \(\mu\). More...
const 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...
const std::string	orderToString (const orders order) const
	Converts an object of the enum type "orders" to the corresponding string. More...
virtual bool	PostUpdate ()
	The post-update method for QCD. More...
virtual bool	PreUpdate ()
	The pre-update method for QCD. More...
	QCD ()
	Constructor. More...
void	setComputemt (bool computemt)
	A set method to change the value of computemt. More...
virtual bool	setFlag (const std::string name, const bool value)
	A method to set a flag of QCD. More...
virtual bool	setFlagStr (const std::string name, const std::string value)
	A method to set a flag of QCD. More...
void	setMtpole (double mtpole_in)
	A method to set the pole mass of the top quark. 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...
void	setQuarkMass (const quark q, const double mass)
	A set method to change the mass of a quark. More...
const double	Thresholds (const int i) const
	For accessing the active flavour threshold scales. More...
virtual bool	Update (const std::map< std::string, double > &DPars)
	The update method for QCD. 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	isModelFWC_DF2 () const
bool	isModelGeneralTHDM () const
bool	isModelGeorgiMachacek () const
bool	IsModelInitialized () const
	A method to check if the model is initialized. More...
bool	isModelLinearized () const
bool	isModelNPquadratic () 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	setModelFWC_DF2 ()
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	setModelNPquadratic (bool NPquadratic=true)
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...

Static Public Attributes
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
const double	MassOfNf (int nf) const
	The Mbar mass of the heaviest quark in the theory with Nf active flavour. More...
virtual void	setParameter (const std::string name, const double &value)
	A method to set the value of a parameter of QCD. More...

Protected Attributes
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
bool	FlagMpole2MbarNumeric
	A flag to determine whether the pole mass to \(\over \mathrm{MS}\) mass conversion is done numerically. More...
bool	FlagMtPole
	A flag to determine whether the pole mass of the top quark is used as input. More...
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...
bool	QCDsuccess =true
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 = false
	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 = false
	A boolean set to false if update is successful. More...

Private Member Functions
const double	AlsWithLambda (const double mu, const double logLambda, const orders order) const
	The strong coupling constant computed with using \(\Lambda_{\rm QCD}\). More...
double	DeltaMass (double x) const
	A method to compute the correction due to light quarks to the conversion between pole and \(\overline{\mathrm{MS}}\) mass. More...
const double	logLambda (const double muMatching, const double mf, const double nfNEW, const double nfORG, const double logLambdaORG, orders order) const
	\(\log(\Lambda_{\rm QCD})\) used for computation of \(\alpha_s\) at FULLNNLO. More...
const double	logLambda5 (orders order) const
	\(\log(\Lambda_{\rm QCD})\) for \(n_f = 5\). More...
const double	logLambdaNLO (const double nfNEW, const double nfORG, const double logLambdaORG) const
	\(\log(\Lambda_{\rm QCD})\) used for computation of \(\alpha_s\) at FULLNLO. More...
const double	Mofmu2MbarTMP (double *mu, double *params) const
	The member used for finding the numerical solution to the \(\overline{\rm MS}\) mass from \(m(\mu_i)\) mass. More...
const double	Mp2Mbar_bar (const double mp, const quark q, const orders order=FULLNNLO) const
	Converts the bottom pole mass to the corresponding \(\overline{\mathrm{MS}}\) mass \(m_t(m_t)\) by iteration. More...
const double	Mp2Mbar_pole (const double mp, const orders order=FULLNNLO) const
	Converts the top pole mass to the corresponding \(\overline{\mathrm{MS}}\) mass \(m_t(m_t)\) using eq. (16) of hep-ph/0004189. More...
const double	Mp2MbarTMP (double *mu, double *params) const
	The member used for finding the numerical solution to the pole mass from the \(\overline{\rm MS}\) mass. More...
const double	MrunTMP (const double mu_f, const double mu_i, const double m, const int nf, const orders order) const
	A function to calculate the running of the mass between flavour thresholds. More...
const double	threCorrForMass (const double nf_f, const double nf_i) const
	The threshold correction for running of a mass when crossing a flavour threshold. More...
const double	ZeroNf3NLO (double *logLambda3, double *logLambda4_in) const
	A member for calculating the difference in \(\alpha_s^{\mathrm{FULLNLO}}\) across the three-four flavour threshold using AlsWithLambda(). More...
const double	ZeroNf4NLO (double *logLambda4, double *logLambda5_in) const
	A member for calculating the difference in \(\alpha_s^{\mathrm{FULLNLO}}\) across the four-five flavour threshold using AlsWithLambda(). More...
const double	ZeroNf5 (double *logLambda5, double *order) const
	A member for calculating the difference in \(\alpha_s\) using AlsWithLambda() and the input value of \(\alpha_s(M_{\alpha_s})\) given as a model parameter. More...
const double	ZeroNf6NLO (double *logLambda6, double *logLambda5_in) const
	A member for calculating the difference in \(\alpha_s^{\mathrm{FULLNLO}}\) across the six-five flavour threshold using AlsWithLambda(). More...

Private Attributes
double	als_cache [9][CacheSize]
	Cache for \(\alpha_s\). More...
std::map< std::string, BParameter >	BParameterMap
bool	computeBd
	Switch for computing \(B_{B_d}\) from \(B_{B_s}\). More...
bool	computeBs
	Switch for computing \(B_{B_s}\) from \(F_{B_s}\sqrt{B_{B_s}}\). More...
bool	computeFBd
	Switch for computing \(F_{B_d}\) from \(F_{B_s}\). More...
bool	computeFBp
	Switch for computing \(F_{B^+}\) from \(F_{B_s}\). More...
bool	FlagCsi
	A flag to determine whether \(B_{B_s}\) and \(B_{B_s}/B_{B_d}\) or \(F_{B_s}\sqrt{B_{B_s}}\) (false) and \(\xi \equiv F_{B_s}\sqrt{B_{B_s}}/(F_{B_d}\sqrt{B_{B_d}})\) (default, true) are used as inputs. More...
double	logLambda5_cache [4][CacheSize]
double	logLambdaNLO_cache [9][CacheSize]
std::map< const QCD::meson, Meson >	mesonsMap
	The map of defined mesons. More...
double	mp2mbar_cache [6][CacheSize]
	Cache for pole mass to msbar mass conversion. More...
double	mrun_cache [11][CacheSize]
	Cache for running quark mass. More...
std::map< std::string, double >	optionalParameters
	A map for containing the list and values of the parameters that are used only by a specific set of observables. More...
orders	realorder
std::vector< std::string >	unknownParameters
	A vector for containing the names of the parameters that are not being used but specified in the configuration file. More...
bool	unknownParameterWarning
	A flag to stop the unknown parameter warning after the first time. More...
double	zeta2
	\(\zeta(2)\) computed with the GSL. More...
double	zeta3
	\(\zeta(3)\) computed with the GSL. More...

Static Private Attributes
static const int	CacheSize = 5
	Defines the depth of the cache. More...

Member Enumeration Documentation

lepton

enum QCD::lepton

An enum type for leptons.

Enumerator
NEUTRINO_1	The 1st-generation neutrino
ELECTRON	Electron
NEUTRINO_2	The 2nd-generation neutrino
MU	Muon
NEUTRINO_3	The 3rd-generation neutrino
TAU	Tau
NOLEPTON	a lepton when none is needed

Definition at line 310 of file QCD.h.

                {
        NEUTRINO_1, 
        ELECTRON, 
        NEUTRINO_2, 
        MU, 
        NEUTRINO_3, 
        TAU, 
        NOLEPTON  
    };

meson

enum QCD::meson

An enum type for mesons.

Enumerator
P_0	\(\pi^0\) meson
P_P	\(\pi^\pm\) meson
K_0	\(K^0\) meson
K_P	\(K^\pm\) meson
D_0	\(D^0\) meson
D_P	\(D^\pm\) meson
D_S	\(D^\pm_s\) meson
B_D	\(B_d\) meson
B_P	\(B^\pm\) meson
B_S	\(B_s\) meson
B_C	\(B_c\) meson
PHI	\(\phi\) meson
K_star	\(K^*\) meson
K_star_P	\(K^{*,\pm}\) meson
K_S	\(K_S\) meson
D_star_P	\(D^{*,\pm}\) meson
RHO	\(\rho\) meson
RHO_P	\(\rho\) meson
OMEGA	\(\omega\) meson
MESON_END	The size of this enum.

Definition at line 336 of file QCD.h.

               {
        P_0, 
        P_P, 
        K_0, 
        K_P, 
        D_0, 
        D_P, 
        D_S, 
        B_D, 
        B_P, 
        B_S, 
        B_C, 
        PHI, 
        K_star, 
        K_star_P, 
        K_S, 
        D_star_P, 
        RHO, 
        RHO_P, 
        OMEGA, 
        MESON_END 
    };

quark

enum QCD::quark

An enum type for quarks.

Enumerator
UP	Up quark
DOWN	Down quark
CHARM	Charm quark
STRANGE	Strange quark
TOP	Top quark
BOTTOM	Bottom quark

Definition at line 323 of file QCD.h.

               {
        UP, 
        DOWN, 
        CHARM, 
        STRANGE, 
        TOP, 
        BOTTOM 
    };

Constructor & Destructor Documentation

QCD()

QCD::QCD

(

)

Constructor.

Definition at line 29 of file QCD.cpp.

{
    setModelName("QCD");
    FlagCsi = true;
    std::cout << "Warning: use of pole top mass as input is now deprecated. By default, the MSbar mass is used."  << std::endl;
    std::cout << "To use the pole mass, set FlagMtPole to true. (to be removed in future releases)" << std::endl;
    FlagMtPole = false;
    FlagMpole2MbarNumeric = true;
    computeFBd = false;
    computeFBp = false;
    computeBd = false;
    computeBs = false;
    computemt = false;
    requireYu = false;
    requireYd = false;
    Nc = 3.;
    TF = 0.5;
    CF = Nc / 2. - 1. / (2. * Nc);
    CA = Nc;
    dFdA_NA = Nc * (Nc * Nc + 6.) / 48.;
    dAdA_NA = Nc * Nc * (Nc * Nc + 36.) / 24.;
    dFdF_NA = (Nc * Nc - 6. + 18. / Nc / Nc) / 96.;
    NA = Nc * Nc - 1.;
 
    //    Particle(std::string name, double mass, double mass_scale = 0., double width = 0., double charge = 0.,double isospin = 0.);
    quarks[UP] = Particle("UP", 0., 2., 0., 2. / 3., .5);
    quarks[CHARM] = Particle("CHARM", 0., 0., 0., 2. / 3., .5);
    quarks[TOP] = Particle("TOP", 0., 0., 0., 2. / 3., .5);
    quarks[DOWN] = Particle("DOWN", 0., 2., 0., -1. / 3., -.5);
    quarks[STRANGE] = Particle("STRANGE", 0., 2., 0., -1. / 3., -.5);
    quarks[BOTTOM] = Particle("BOTTOM", 0., 0., 0., -1. / 3., -.5);
 
    zeta2 = gslpp_special_functions::zeta(2);
    zeta3 = gslpp_special_functions::zeta(3);
    for (int i = 0; i < CacheSize; i++)
    {
        for (int j = 0; j < 9; j++)
            als_cache[j][i] = 0.;
        for (int j = 0; j < 4; j++)
            logLambda5_cache[j][i] = 0.;
        for (int j = 0; j < 10; j++)
            mrun_cache[j][i] = 0.;
        for (int j = 0; j < 6; j++)
            mp2mbar_cache[j][i] = 0.;
    }
 
    ModelParamMap.insert(std::make_pair("AlsM", std::cref(AlsM)));
    ModelParamMap.insert(std::make_pair("MAls", std::cref(MAls)));
    ModelParamMap.insert(std::make_pair("mup", std::cref(quarks[UP].getMass())));
    ModelParamMap.insert(std::make_pair("mdown", std::cref(quarks[DOWN].getMass())));
    ModelParamMap.insert(std::make_pair("mcharm", std::cref(quarks[CHARM].getMass())));
    ModelParamMap.insert(std::make_pair("mstrange", std::cref(quarks[STRANGE].getMass())));
    if (FlagMtPole)
        ModelParamMap.insert(std::make_pair("mtop", std::cref(mtpole)));
    else
        ModelParamMap.insert(std::make_pair("mtop", std::cref(quarks[TOP].getMass())));
 
    ModelParamMap.insert(std::make_pair("mbottom", std::cref(quarks[BOTTOM].getMass())));
    ModelParamMap.insert(std::make_pair("muc", std::cref(muc)));
    ModelParamMap.insert(std::make_pair("mub", std::cref(mub)));
    ModelParamMap.insert(std::make_pair("mut", std::cref(mut)));
 
    unknownParameterWarning = true;
    realorder = LO;
}

Member Function Documentation

AboveTh()

const double QCD::AboveTh

(

const double

mu

)

const

The active flavour threshold above the scale \(\mu\) as defined in QCD::Thresholds().

Parameters

[in]

mu

a scale \(\mu\) in GeV

Returns

the higher active flavour threshold

Definition at line 547 of file QCD.cpp.

{
    int i;
    for (i = 4; i >= 0; i--)
        if (mu < Thresholds(i))
            return (Thresholds(i));
 
    QCDsuccess = false;
    std::cout << "Error in QCD::AboveTh()! QCDsuccess set to false" << std::endl;
    return (0.);
}

addParameters()

void QCD::addParameters

(

std::vector< std::string >

params_i

)

A method to add parameters that are specific to only one set of observables.

Parameters

[in]

params_i

a vector of parameters to be added (including parameters that are varied and those that are held constant)

Definition at line 199 of file QCD.cpp.

{
    for (std::vector<std::string>::iterator it = params_i.begin(); it < params_i.end(); it++)
    {
        if (optionalParameters.find(*it) == optionalParameters.end())
        {
            optionalParameters[*it] = 0.;
            ModelParamMap.insert(std::make_pair(*it, std::cref(optionalParameters[*it])));
        }
    }
}

Als() [1/2]

const double QCD::Als	(	const double	mu,
		const int	Nf_in,
		const orders	order = FULLNLO
	)		const

Computes the running strong coupling \(\alpha_s(\mu)\) with \(N_f\) active flavours in the \(\overline{\mathrm{MS}}\) scheme. In the cases of LO, NLO and FULLNLO, the coupling is computed with AlsWithInit(). On the other hand, in the cases of NNLO and FULLNNLO, the coupling is computed with AlsWithLambda().

Parameters

[in]	mu	the scale \(\mu\) in GeV
[in]	Nf_in	number of active flavours
[in]	order	order in the \(\alpha_s\) expansion as defined in OrderScheme

Returns

the strong coupling constant \(\alpha_s(\mu)\) in the \(\overline{\mathrm{MS}}\) scheme with \(N_f\) active flavours

Definition at line 783 of file QCD.cpp.

{
    switch (order)
    {
    case LO:
        realorder = order;
        return AlsByOrder(mu, Nf, LO);
    case FULLNLO:
        realorder = order;
        return (AlsByOrder(mu, Nf, LO) + AlsByOrder(mu, Nf, NLO));
    case FULLNNLO:
        realorder = order;
        return (AlsByOrder(mu, Nf, LO) + AlsByOrder(mu, Nf, NLO) + AlsByOrder(mu, Nf, NNLO));
    case FULLNNNLO:
        realorder = order;
        return (AlsByOrder(mu, Nf, LO) + AlsByOrder(mu, Nf, NLO) + AlsByOrder(mu, Nf, NNLO) + AlsByOrder(mu, Nf, NNNLO));
    default:
        throw std::runtime_error("QCD::Als(): " + orderToString(order) + " is not implemented.");
    }
}

Als() [2/2]

const double QCD::Als	(	const double	mu,
		const orders	order = FULLNLO,
		const bool	Nf_thr = true
	)		const

Definition at line 762 of file QCD.cpp.

{
    switch (order)
    {
    case LO:
        realorder = order;
        return AlsByOrder(mu, LO, Nf_thr);
    case FULLNLO:
        realorder = order;
        return (AlsByOrder(mu, LO, Nf_thr) + AlsByOrder(mu, NLO, Nf_thr));
    case FULLNNLO:
        realorder = order;
        return (AlsByOrder(mu, LO, Nf_thr) + AlsByOrder(mu, NLO, Nf_thr) + AlsByOrder(mu, NNLO, Nf_thr));
    case FULLNNNLO:
        realorder = order;
        return (AlsByOrder(mu, LO, Nf_thr) + AlsByOrder(mu, NLO, Nf_thr) + AlsByOrder(mu, NNLO, Nf_thr) + AlsByOrder(mu, NNNLO, Nf_thr));
    default:
        throw std::runtime_error("QCD::Als(): " + orderToString(order) + " is not implemented.");
    }
}

Als4()

const double QCD::Als4

(

const double

mu

)

const

The value of \(\alpha_s^{\mathrm{FULLNLO}}\) at any scale \(\mu\) with the number of flavours \(n_f = 4\).

Parameters

[in]

mu

the scale at which \(\alpha_s\) has to be computed

Returns

\(\alpha_s^{\mathrm{FULLNLO}}(\mu)\) with \(n_f = 4\)

Attention

Temporary function waiting for the implementation of NNLO exact.

Definition at line 657 of file QCD.cpp.

{
    double v = 1. - Beta0(4.) * AlsM / 2. / M_PI * log(MAls / mu);
    return (AlsM / v * (1. - Beta1(4.) / Beta0(4.) * AlsM / 4. / M_PI * log(v) / v));
}

AlsByOrder() [1/2]

const double QCD::AlsByOrder	(	const double	mu,
		const int	Nf_in,
		const orders	order = FULLNLO
	)		const

Definition at line 979 of file QCD.cpp.

{
    int i, nfAls = (int)Nf(MAls), nfmu = Nf_in;
    double als, alstmp, mutmp;
    orders fullord;
 
    for (i = 0; i < CacheSize; ++i)
        if ((mu == als_cache[0][i]) && ((double)order == als_cache[1][i]) &&
            (AlsM == als_cache[2][i]) && (MAls == als_cache[3][i]) &&
            (mut == als_cache[4][i]) && (mub == als_cache[5][i]) &&
            (muc == als_cache[6][i]) && (Nf_in == (int)als_cache[7][i]))
            return als_cache[8][i];
 
    switch (order)
    {
    case LO:
    case NLO:
    case NNLO:
    case NNNLO:
        if (nfAls == nfmu)
            als = AlsWithInit(mu, AlsM, MAls, nfmu, order);
        fullord = FullOrder(order);
        if (nfAls > nfmu)
        {
            mutmp = BelowTh(MAls);
            alstmp = AlsWithInit(mutmp, AlsM, MAls, nfAls, realorder);
            alstmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(nfAls), alstmp, nfAls, fullord));
            for (i = nfAls - 1; i > nfmu; i--)
            {
                mutmp = BelowTh(mutmp - MEPS);
                alstmp = AlsWithInit(mutmp, alstmp, AboveTh(mutmp) - MEPS, i, realorder);
                alstmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(i), alstmp, i, fullord));
            }
            als = AlsWithInit(mu, alstmp, mutmp, nfmu, order);
        }
 
        if (nfAls < nfmu)
        {
            mutmp = AboveTh(MAls) - MEPS;
            alstmp = AlsWithInit(mutmp, AlsM, MAls, nfAls, realorder);
            alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(nfAls + 1), alstmp, nfAls + 1, fullord));
            for (i = nfAls + 1; i < nfmu; i++)
            {
                double oldmu = mutmp;
                mutmp = AboveTh(mutmp + 2. * MEPS) - MEPS;
                alstmp = AlsWithInit(mutmp, alstmp, oldmu, i, realorder);
                alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(i + 1), alstmp, i + 1, fullord));
            }
            als = AlsWithInit(mu, alstmp, mutmp + 2. * MEPS, nfmu, order);
        }
 
        CacheShift(als_cache, 9);
        als_cache[0][0] = mu;
        als_cache[1][0] = (double)order;
        als_cache[2][0] = AlsM;
        als_cache[3][0] = MAls;
        als_cache[4][0] = mut;
        als_cache[5][0] = mub;
        als_cache[6][0] = muc;
        als_cache[7][0] = Nf_in;
        als_cache[8][0] = als;
 
        return als;
    default:
        throw std::runtime_error("QCD::Als(): " + orderToString(order) + " is not implemented.");
    }
}

AlsByOrder() [2/2]

const double QCD::AlsByOrder	(	const double	mu,
		const orders	order = FULLNLO,
		bool	Nf_thr = true
	)		const

Definition at line 804 of file QCD.cpp.

{
    int i, nfAls = (int)Nf(MAls), nfmu = Nf_thr ? (int)Nf(mu) : nfAls;
    double als, alstmp, mutmp;
    orders fullord;
 
    for (i = 0; i < CacheSize; ++i)
        if ((mu == als_cache[0][i]) && ((double)order == als_cache[1][i]) &&
            (AlsM == als_cache[2][i]) && (MAls == als_cache[3][i]) &&
            (mut == als_cache[4][i]) && (mub == als_cache[5][i]) &&
            (muc == als_cache[6][i]) && (Nf_thr == (bool)als_cache[7][i]))
            return als_cache[8][i];
 
    switch (order)
    {
    case LO:
    case NLO:
    case NNLO:
    case NNNLO:
        if (nfAls == nfmu)
            als = AlsWithInit(mu, AlsM, MAls, nfmu, order);
        fullord = FullOrder(order);
        if (nfAls > nfmu)
        {
            mutmp = BelowTh(MAls);
            alstmp = AlsWithInit(mutmp, AlsM, MAls, nfAls, realorder);
            alstmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(nfAls), alstmp, nfAls, fullord));
            for (i = nfAls - 1; i > nfmu; i--)
            {
                mutmp = BelowTh(mutmp - MEPS);
                alstmp = AlsWithInit(mutmp, alstmp, AboveTh(mutmp) - MEPS, i, realorder);
                alstmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(i), alstmp, i, fullord));
            }
            als = AlsWithInit(mu, alstmp, AboveTh(mu) - MEPS, nfmu, order);
        }
 
        if (nfAls < nfmu)
        {
            mutmp = AboveTh(MAls) - MEPS;
            alstmp = AlsWithInit(mutmp, AlsM, MAls, nfAls, realorder);
            alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(nfAls + 1), alstmp, nfAls + 1, fullord));
            for (i = nfAls + 1; i < nfmu; i++)
            {
                mutmp = AboveTh(mutmp) - MEPS;
                alstmp = AlsWithInit(mutmp, alstmp, BelowTh(mutmp) + MEPS, i, realorder);
                alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(i + 1), alstmp, i + 1, fullord));
            }
            als = AlsWithInit(mu, alstmp, BelowTh(mu) + MEPS, nfmu, order);
        }
 
        CacheShift(als_cache, 9);
        als_cache[0][0] = mu;
        als_cache[1][0] = (double)order;
        als_cache[2][0] = AlsM;
        als_cache[3][0] = MAls;
        als_cache[4][0] = mut;
        als_cache[5][0] = mub;
        als_cache[6][0] = muc;
        als_cache[7][0] = (int)Nf_thr;
        als_cache[8][0] = als;
 
        return als;
    default:
        throw std::runtime_error("QCD::Als(): " + orderToString(order) + " is not implemented.");
    }
}

AlsOLD()

const double QCD::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().

Parameters

[in]	mu	the scale \(\mu\) in GeV
[in]	order	order in the \(\alpha_s\) expansion as defined in OrderScheme
[in]	order_qed	order in the \(\alpha_e\) expansion as defined in OrderScheme. Default to NO_QED.
[in]	Nf_thr	true (default): \(n_f\) = Nf(mu), false: \(n_f\) = Nf(AlsM)

Returns

the strong coupling constant \(\alpha_s(\mu)\) in the \(\overline{\mathrm{MS}}\) scheme

Definition at line 871 of file QCD.cpp.

{
    int i;
    for (i = 0; i < CacheSize; ++i)
        if ((mu == als_cache[0][i]) && ((double)order == als_cache[1][i]) &&
            (AlsM == als_cache[2][i]) && (MAls == als_cache[3][i]) &&
            (mut == als_cache[4][i]) && (mub == als_cache[5][i]) &&
            (muc == als_cache[6][i]) && -1 == (int)als_cache[7][i])
            return als_cache[8][i];
 
    double nfmu = Nf(mu), nfz = Nf(MAls), mu_thre1, mu_thre2, Als_tmp, mf;
    double als;
 
    switch (order)
    {
    case LO:
    case FULLNLO:
    case NLO:
        if (nfmu == nfz)
            als = AlsWithInit(mu, AlsM, MAls, nfmu, order);
        else if (nfmu > nfz)
        {
            if (order == NLO)
                throw std::runtime_error("NLO is not implemented in QCD::Als(mu,order).");
            if (nfmu == nfz + 1.)
            {
                mu_thre1 = AboveTh(MAls); // mut
                Als_tmp = AlsWithInit(mu_thre1 - MEPS, AlsM, MAls, nfz, order);
                if (order == FULLNLO)
                {
                    mf = getQuarks(TOP).getMass(); // mf = mtpole;
                    Als_tmp = (1. + Als_tmp / M_PI * log(mu_thre1 / mf) / 3.) * Als_tmp;
                }
                als = AlsWithInit(mu, Als_tmp, mu_thre1 + MEPS, nfmu, order);
            }
            else
            {
                QCDsuccess = false;
                std::cout << "Error in QCD::Als(mu,order)! QCDsuccess set to false" << std::endl;
                als = 0.;
            }
        }
        else
        {
            if (order == NLO)
                throw std::runtime_error("NLO is not implemented in QCD::Als(mu,order).");
            if (nfmu == nfz - 1.)
            {
                mu_thre1 = BelowTh(MAls); // mub
                Als_tmp = AlsWithInit(mu_thre1 + MEPS, AlsM, MAls, nfz, order);
                if (order == FULLNLO)
                {
                    mf = getQuarks(BOTTOM).getMass();
                    Als_tmp = (1. - Als_tmp / M_PI * log(mu_thre1 / mf) / 3.) * Als_tmp;
                }
                als = AlsWithInit(mu, Als_tmp, mu_thre1 - MEPS, nfmu, order);
            }
            else if (nfmu == nfz - 2.)
            {
                mu_thre1 = BelowTh(MAls); // mub
                mu_thre2 = AboveTh(mu);   // muc
                Als_tmp = Als(mu_thre1 + MEPS, order);
                if (order == FULLNLO)
                {
                    mf = getQuarks(BOTTOM).getMass();
                    Als_tmp = (1. - Als_tmp / M_PI * log(mu_thre1 / mf) / 3.) * Als_tmp;
                }
                Als_tmp = AlsWithInit(mu_thre2, Als_tmp, mu_thre1 - MEPS, nfz-1, order);
                if (order == FULLNLO)
                {
                    mf = getQuarks(CHARM).getMass();
                    Als_tmp = (1. - Als_tmp / M_PI * log(mu_thre2 / mf) / 3.) * Als_tmp;
                }
                als = AlsWithInit(mu, Als_tmp, mu_thre2 - MEPS, nfmu, order);
            }
            else
            {
                QCDsuccess = false;
                std::cout << "Error in QCD::Als(mu,order)! QCDsuccess set to false" << std::endl;
                als = 0.;
            }
        }
        break;
    case NNLO:
        //        case NNNLO:
    case FULLNNLO:
        //        case FULLNNNLO:
        /* alpha_s(mu) computed with Lambda_QCD for Nf=nfmu */
        als = AlsWithLambda(mu, order);
        break;
    default:
        throw std::runtime_error(orderToString(order) + " is not implemented in QCD::Als(mu,order).");
    }
 
    CacheShift(als_cache, 9);
    als_cache[0][0] = mu;
    als_cache[1][0] = (double)order;
    als_cache[2][0] = AlsM;
    als_cache[3][0] = MAls;
    als_cache[4][0] = mut;
    als_cache[5][0] = mub;
    als_cache[6][0] = muc;
    als_cache[7][0] = -1;
    als_cache[8][0] = als;
 
    return als;
}

AlsWithInit()

const double QCD::AlsWithInit	(	const double	mu,
		const double	alsi,
		const double	mu_i,
		const int	nf,
		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\).

Parameters

[in]	mu	a scale \(\mu\) in GeV
[in]	alsi	the initial value for the coupling at the scale given below
[in]	mu_i	the initial scale \(\mu_i\) in GeV
[in]	nf	the number of active flavours \(n_f\)
[in]	order	LO, NLO or FULLNLO in the \(\alpha_s\) expansion defined in OrderScheme

Returns

the strong coupling constant \(\alpha_s(\mu)\) in the \(\overline{\mathrm{MS}}\) scheme

Definition at line 627 of file QCD.cpp.

{
 
    double b1_b0 = Beta1((double)nf) / Beta0((double)nf);
    double v = 1. - Beta0((double)nf) * alsi / 2. / M_PI * log(mu_i / mu);
    double logv = log(v);
 
    switch (order)
    {
    case LO:
        return (alsi / v);
    case NLO:
        return (-alsi * alsi / 4. / M_PI / v / v * b1_b0 * logv);
    case NNLO:
        return (alsi * alsi * alsi / 4. / 4. / M_PI / M_PI / v / v / v * (Beta2((double)nf) / Beta0((double)nf) * (1. - v) + b1_b0 * b1_b0 * (logv * logv - logv + v - 1.)));
    case NNNLO:
        return (alsi * alsi * alsi * alsi / 4. / 4. / 4. / M_PI / M_PI / M_PI /
                v / v / v / v * (Beta3((double)nf) / Beta0((double)nf) * (1. - v * v) / 2. + b1_b0 * Beta2((double)nf) / Beta0((double)nf) * ((2. * v - 3.) * logv + v * v - v) + b1_b0 * b1_b0 * b1_b0 * (-logv * logv * logv + 2.5 * logv * logv + 2. * (1. - v) * logv - 0.5 * (v - 1.) * (v - 1.))));
    case FULLNLO:
        return (AlsWithInit(mu, alsi, mu_i, nf, LO) + AlsWithInit(mu, alsi, mu_i, nf, NLO));
    case FULLNNLO:
        return (AlsWithInit(mu, alsi, mu_i, nf, LO) + AlsWithInit(mu, alsi, mu_i, nf, NLO) + AlsWithInit(mu, alsi, mu_i, nf, NNLO));
    case FULLNNNLO:
        return (AlsWithInit(mu, alsi, mu_i, nf, LO) + AlsWithInit(mu, alsi, mu_i, nf, NLO) + AlsWithInit(mu, alsi, mu_i, nf, NNLO) + AlsWithInit(mu, alsi, mu_i, nf, NNNLO));
    default:
        throw std::runtime_error("QCD::AlsWithInit(): " + orderToString(order) + " is not implemented.");
    }
}

AlsWithLambda() [1/2]

const double QCD::AlsWithLambda ( const double  mu, const double  logLambda, const orders  order  ) const

private

The strong coupling constant computed with using \(\Lambda_{\rm QCD}\).

Parameters

[in]	mu	the scale of the strong coupling constant
[in]	logLambda	\(\log(\Lambda_{\rm QCD})\)
[in]	order	the QCD order at which \(\alpha_s\) is required

Returns

\(\alpha_s(\mu)\) for the specified order

Definition at line 663 of file QCD.cpp.

{
    double nf = Nf(mu);
    double L = 2. * (log(mu) - logLambda);
 
    // LO contribution
    double b0 = Beta0(nf);
    double b0L = b0 * L;
    double alsLO = 4. * M_PI / b0L;
    if (order == LO)
        return alsLO;
 
    // NLO contribution
    double b1 = Beta1(nf);
    double log_L = log(L);
    double alsNLO = 4. * M_PI / b0L * (-b1 * log_L / b0 / b0L);
    if (order == NLO)
        return alsNLO;
    if (order == FULLNLO)
        return (alsLO + alsNLO);
 
    // NNLO contribution
    double b2 = Beta2(nf);
    double alsNNLO = 4. * M_PI / b0L * (1. / b0L / b0L * (b1 * b1 / b0 / b0 * (log_L * log_L - log_L - 1.) + b2 / b0));
    if (order == NNLO)
        return alsNNLO;
    if (order == FULLNNLO)
        return (alsLO + alsNLO + alsNNLO);
 
    // NNNLO contribution
    double b3 = Beta3(nf);
    double alsNNNLO = 4. * M_PI / b0L * (-1. / b0L / b0L / b0L * (b1 * b1 * b1 / b0 / b0 / b0 * (log_L * log_L * log_L - 5. / 2. * log_L * log_L - 2. * log_L - 0.5) + 3. * b1 * b2 * log_L / b0 / b0 - 0.5 * b3 / b0));
    if (order == NNNLO)
        return alsNNNLO;
    if (order == FULLNNNLO)
        return (alsLO + alsNLO + alsNNLO + alsNNNLO);
 
    throw std::runtime_error(orderToString(order) + " is not implemented in QCD::AlsWithLambda().");
}

AlsWithLambda() [2/2]

const double QCD::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}\).

Parameters

[in]	mu	A scale \(\mu\) in GeV
[in]	order	LO, NLO, FULLNLO, NNLO or FULLNNLO in the \(\alpha_s\) expansion defined in OrderScheme

Returns

the strong coupling constant \(\alpha_s(\mu)\) in the \(\overline{\mathrm{MS}}\) scheme

Definition at line 704 of file QCD.cpp.

{
    return AlsWithLambda(mu, logLambda(Nf(mu), order), order);
}

BelowTh()

const double QCD::BelowTh

(

const double

mu

)

const

The active flavour threshold below the scale \(\mu\) as defined in QCD::Thresholds().

Parameters

[in]

mu

a scale \(\mu\) in GeV

Returns

the lower active flavour threshold

Definition at line 559 of file QCD.cpp.

{
    int i;
    for (i = 0; i < 5; i++)
        if (mu >= Thresholds(i))
            return (Thresholds(i));
 
    QCDsuccess = false;
    std::cout << "Error in QCD::BelowTh()! QCDsuccess set to false" << std::endl;
    return (0.);
}

Beta0()

const double QCD::Beta0

(

const double

nf

)

const

The \(\beta_0(n_f)\) coefficient for a certain number of flavours \(n_f\).

Parameters

[in]

nf

the number of active flavours \(n_f\)

Returns

\(\beta_0(n_f)\)

Definition at line 601 of file QCD.cpp.

{
    return ((11. * CA - 4. * TF * nf) / 3.);
}

Beta1()

const double QCD::Beta1

(

const double

nf

)

const

The \(\beta_1(n_f)\) coefficient for a certain number of flavours \(n_f\).

Parameters

[in]

nf

the number of active flavours \(n_f\)

Returns

\(\beta_1(n_f)\)

Definition at line 606 of file QCD.cpp.

{
    return (34. / 3. * CA * CA - (20. / 3. * CA + 4. * CF) * TF * nf);
}

Beta2()

const double QCD::Beta2

(

const double

nf

)

const

The \(\beta_2(n_f)\) coefficient for a certain number of flavours \(n_f\).

Parameters

[in]

nf

the number of active flavours \(n_f\)

Returns

\(\beta_2(n_f)\)

Definition at line 611 of file QCD.cpp.

{
    return (2857. / 54. * CA * CA * CA - (1415. / 27. * CA * CA + 205. / 9. * CF * CA - 2. * CF * CF) * TF * nf +
            (158. / 27. * CA + 44. / 9. * CF) * TF * TF * nf * nf);
}

Beta3()

const double QCD::Beta3

(

const double

nf

)

const

The \(\beta_3(n_f)\) coefficient for a certain number of flavours \(n_f\).

Parameters

[in]

nf

the number of active flavours \(n_f\)

Returns

\(\beta_3(n_f)\)

Definition at line 618 of file QCD.cpp.

{
    return (CA * CF * TF * TF * nf * nf * (17152. / 243. + 448. / 9. * zeta3) +
            CA * CF * CF * TF * nf * (-4204. / 27. + 352. / 9. * zeta3) +
            424. / 243. * CA * TF * TF * TF * nf * nf * nf + CA * CA * CF * TF * nf * (7073. / 243. - 656. / 9. * zeta3) + CA * CA * TF * TF * nf * nf * (7930. / 81. + 224. / 9. * zeta3) + 1232. / 243. * CF * TF * TF * TF * nf * nf * nf +
            CA * CA * CA * TF * nf * (-39143. / 81. + 136. / 3. * zeta3) + CA * CA * CA * CA * (150653. / 486. - 44. / 9. * zeta3) + CF * CF * TF * TF * nf * nf * (1352. / 27. - 704. / 9. * zeta3) + 46. * CF * CF * CF * TF * nf +
            nf * dFdA_NA * (512. / 9. - 1664. / 3. * zeta3) + nf * nf * dFdF_NA * (-704. / 9. + 512. / 3. * zeta3) + dAdA_NA * (-80. / 9. + 704. / 3. * zeta3));
}

CacheShift() [1/2]

void QCD::CacheShift	(	double	cache[][5],
		int	n
	)		const

A member used to manage the caching for this class.

Parameters

[in]	cache	the cache to be moved
[in]	n	the dimension of the cache to be shifted

CacheShift() [2/2]

void QCD::CacheShift	(	int	cache[][5],
		int	n
	)		const

CheckFlags()

bool QCD::CheckFlags ( ) const

virtual

A method to check the sanity of the set of model flags.

Returns

a boolean that is true if the set of model flags is sane

Implements Model.

Reimplemented in StandardModel.

Definition at line 517 of file QCD.cpp.

{
    return (true);
}

CheckParameters()

bool QCD::CheckParameters ( const std::map< std::string, double > &  DPars )

virtual

A method to check if all the mandatory parameters for QCD have been provided in model initialization.

Parameters

[in]

DPars

a map of the parameters that are being updated in the Monte Carlo run (including parameters that are varied and those that are held constant)

Returns

a boolean that is true if the execution is successful

Implements Model.

Reimplemented in CMFV, FlavourWilsonCoefficient, FlavourWilsonCoefficient_DF2, LoopMediators, NPDF2, RealWeakEFTCC, RealWeakEFTLFV, GeneralSUSY, GeorgiMachacek, LeftRightSymmetricModel, MFV, HiggsChiral, HiggsKigen, NPEpsilons, NPEpsilons_pureNP, NPHiggs, NPSMEFTd6, NPSTU, NPSTUVWXY, NPSTUZbbbarLR, NPZbbbar, NPZbbbarLinearized, SigmaBR, pMSSM, StandardModel, SUSY, SUSYMassInsertion, THDM, and THDMW.

Definition at line 421 of file QCD.cpp.

{
    for (int i = 0; i < NQCDvars; i++)
        if (DPars.find(QCDvars[i]) == DPars.end())
        {
            std::cout << "ERROR: missing mandatory QCD parameter " << QCDvars[i] << std::endl;
            raiseMissingModelParameterCount();
            addMissingModelParameter(QCDvars[i]);
        }
    for (std::map<std::string, double>::iterator it = optionalParameters.begin(); it != optionalParameters.end(); it++)
    {
        if (DPars.find(it->first) == DPars.end())
        {
            std::cout << "ERROR: missing optional parameter " << it->first << std::endl;
            raiseMissingModelParameterCount();
            addMissingModelParameter(it->first);
        }
    }
    if (!BParameterMap.empty())
    {
        for (std::map<std::string, BParameter>::iterator it = BParameterMap.begin(); it != BParameterMap.end(); it++)
        {
            std::vector<std::string> parameters = it->second.parameterList(it->first);
            for (std::vector<std::string>::iterator it1 = parameters.begin(); it1 != parameters.end(); it1++)
            {
                if (DPars.find(*it1) == DPars.end())
                {
                    std::cout << "ERROR: missing parameter for " << it->first << ": " << *it1 << std::endl;
                    raiseMissingModelParameterCount();
                    addMissingModelParameter(*it1);
                }
            }
        }
    }
    if (!mesonsMap.empty())
    {
        for (std::map<const QCD::meson, Meson>::iterator it = mesonsMap.begin(); it != mesonsMap.end(); it++)
        {
            std::vector<std::string> parameters = it->second.parameterList(it->second.getName());
            for (std::vector<std::string>::iterator it1 = parameters.begin(); it1 != parameters.end(); it1++)
            {
                if (DPars.find(*it1) == DPars.end())
                {
                    std::cout << "ERROR: missing parameter for " << mesonsMap.at(it->first).getName() << ": " << *it1 << std::endl;
                    raiseMissingModelParameterCount();
                    addMissingModelParameter(*it1);
                }
            }
        }
    }
    if (getMissingModelParametersCount() > 0)
        return false;
    else
        return true;
}

DeltaMass()

double QCD::DeltaMass ( double  x ) const

private

A method to compute the correction due to light quarks to the conversion between pole and \(\overline{\mathrm{MS}}\) mass.

Parameters

[in]

x

a mass ratio return the correction \(\Delta (x)\) computed with the approximate formula by Chetyrkin et al. (hep-ph/0004189)

Definition at line 1611 of file QCD.cpp.

{
    return M_PI * M_PI / 8. * x - 0.597 * x * x + 0.230 * x * x * x;
}

FullOrder()

const orders QCD::FullOrder

(

orders

order

)

const

Return the FULLORDER enum corresponding to order.

Parameters

[in]

order

of the expansion in \(\alpha_s\)

Returns

the FULLORDER enum corresponding to order

Definition at line 728 of file QCD.cpp.

{
    switch (order)
    {
    case LO:
        return (LO);
    case NLO:
        return (FULLNLO);
    case NNLO:
        return (FULLNNLO);
    case NNNLO:
        return (FULLNNNLO);
    default:
        throw std::runtime_error("QCD::FullOrder(): " + orderToString(order) + " is not implemented.");
    }
}

Gamma0()

const double QCD::Gamma0

(

const double

nf

)

const

The \(\gamma_0\) coefficient used to compute the running of a mass.

Parameters

[in]

nf

the number of active flavours \(n_f\)

Returns

the \(\gamma_0\) coefficient.

Definition at line 1271 of file QCD.cpp.

{
    return (6. * CF);
}

Gamma1()

const double QCD::Gamma1

(

const double

nf

)

const

The \(\gamma_1\) coefficient used to compute the running of a mass.

Parameters

[in]

nf

the number of active flavours \(n_f\)

Returns

the \(\gamma_1\) coefficient

Definition at line 1276 of file QCD.cpp.

{
    return (CF * (3. * CF + 97. / 3. * Nc - 10. / 3. * nf));
}

Gamma2()

const double QCD::Gamma2

(

const double

nf

)

const

The \(\gamma_2\) coefficient used to compute the running of a mass.

Parameters

[in]

nf

The number of active flavours \(n_f\)

Returns

the \(\gamma_2\) coefficient

Definition at line 1281 of file QCD.cpp.

{
    return (129. * CF * CF * CF - 129. / 2. * CF * CF * Nc + 11413. / 54. * CF * Nc * Nc + CF * CF * nf * (-46. + 48. * zeta3) + CF * Nc * nf * (-556. / 27. - 48. * zeta3) - 70. / 27. * CF * nf * nf);
}

getAlsM()

const double QCD::getAlsM ( ) const

inline

A get method to access the value of \(\alpha_s(M_{\alpha_s})\).

Returns

the strong coupling constant at \(M_{\alpha_s}\), \(\alpha_s(M_{\alpha_s})\)

Definition at line 555 of file QCD.h.

    {
        return AlsM;
    }

getBBd()

const BParameter & QCD::getBBd ( ) const

inline

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.

Returns

the vector of bag parameters

Definition at line 629 of file QCD.h.

    {
        return BParameterMap.at("BBd");
    }

getBBd_subleading()

const BParameter & QCD::getBBd_subleading ( ) const

inline

For getting the subleading bag parameters \(R_2 - R_3\) in \(\Delta b = 2\) process in the \(B_d\) meson system.

Returns

the vector of bag parameters

Definition at line 651 of file QCD.h.

    {
        return BParameterMap.at("BBd_subleading");
    }  

getBBs()

const BParameter & QCD::getBBs ( ) const

inline

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.

Returns

the vector of bag parameters

Definition at line 640 of file QCD.h.

    {
        return BParameterMap.at("BBs");
    }

getBBs_subleading()

const BParameter & QCD::getBBs_subleading ( ) const

inline

For getting the subleading bag parameters \(R_2 - R_3\) in \(\Delta b = 2\) process in the \(B_s\) meson system.

Returns

the vector of bag parameters

Definition at line 662 of file QCD.h.

    {
        return BParameterMap.at("BBs_subleading");
    }    

getBD()

const BParameter & QCD::getBD ( ) const

inline

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.

Returns

the vector of bag parameters

Definition at line 673 of file QCD.h.

    {
        return BParameterMap.at("BD");
    }

getBK()

const BParameter & QCD::getBK ( ) const

inline

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.

Returns

the vector of bag parameters

Definition at line 684 of file QCD.h.

    {
        return BParameterMap.at("BK");
    }

getBKd1()

const BParameter & QCD::getBKd1 ( ) const

inline

Returns

Definition at line 692 of file QCD.h.

    {
        return BParameterMap.at("BKd1");
    }

getBKd3()

const BParameter & QCD::getBKd3 ( ) const

inline

Returns

Definition at line 700 of file QCD.h.

    {
        return BParameterMap.at("BKd3");
    }

getCF()

const double QCD::getCF ( ) const

inline

A get method to access the Casimir factor of QCD.

Returns

the Casimir factor

Definition at line 618 of file QCD.h.

    {
        return CF;
    }

getMAls()

const double QCD::getMAls ( ) const

inline

A get method to access the mass scale \(M_{\alpha_s}\) at which the strong coupling constant measurement is provided.

Returns

the mass scale in GeV \(M_{\alpha_s}\) at which the strong coupling constant measurement is provided

Definition at line 564 of file QCD.h.

    {
        return MAls;
    }

getMesons()

const Meson & QCD::getMesons ( const QCD::meson  m ) const

inline

A get method to access a meson as an object of the type Meson.

Parameters

[in]

m

the name of a meson

Returns

the object of the meson specified in the argument

Definition at line 526 of file QCD.h.

    {
        return mesonsMap.at(m);
    }

getMtpole()

const double QCD::getMtpole ( ) const

inline

A get method to access the pole mass of the top quark.

Returns

the pole mass of the top quark \(m_t^{pole}\)

Definition at line 600 of file QCD.h.

    {
        return mtpole;
    }

getMub()

const double QCD::getMub ( ) const

inline

A get method to access the threshold between five- and four-flavour theory in GeV.

Returns

the threshold \(\mu_b\)

Definition at line 582 of file QCD.h.

    {
        return mub;
    }

getMuc()

const double QCD::getMuc ( ) const

inline

A get method to access the threshold between four- and three-flavour theory in GeV.

Returns

the threshold \(\mu_c\)

Definition at line 591 of file QCD.h.

    {
        return muc;
    }

getMut()

const double QCD::getMut ( ) const

inline

A get method to access the threshold between six- and five-flavour theory in GeV.

Returns

the threshold \(\mu_t\)

Definition at line 573 of file QCD.h.

    {
        return mut;
    }

getNc()

const double QCD::getNc ( ) const

inline

A get method to access the number of colours \(N_c\).

Returns

the number of colours

Definition at line 507 of file QCD.h.

    {
        return Nc;
    }

getOptionalParameter()

const double QCD::getOptionalParameter ( std::string  name ) const

inline

A method to get parameters that are specific to only one set of observables.

Parameters

[in]

name

the name of the parameter

Returns

a double that is the value of the parameter

Definition at line 450 of file QCD.h.

    {
        return optionalParameters.at(name);
    }

getQuarks()

const Particle & QCD::getQuarks ( const QCD::quark  q ) const

inline

A get method to access a quark as an object of the type Particle.

Parameters

[in]

q

the name of a quark

Returns

the object of the quark found in the argument

Definition at line 536 of file QCD.h.

    {
        return quarks[q];
    }

getUnknownParameters()

std::vector< std::string > QCD::getUnknownParameters ( )

inline

A method to get the vector of the parameters that have been specified in the configuration file but not being used.

Returns

a vector of strings that contain the names of the parameters

Definition at line 469 of file QCD.h.

    {
        return unknownParameters;
    }

Init()

bool QCD::Init ( const std::map< std::string, double > &  DPars )

virtual

Initializes the QCD parameters found in the argument.

Parameters

[in]

DPars

a map containing the parameters (all as double) to be used in Monte Carlo

Implements Model.

Reimplemented in FlavourWilsonCoefficient, LoopMediators, RealWeakEFTCC, RealWeakEFTLFV, GeneralSUSY, GeorgiMachacek, LeftRightSymmetricModel, MFV, NPSMEFTd6General, pMSSM, StandardModel, SUSY, SUSYMassInsertion, THDM, and THDMW.

Definition at line 120 of file QCD.cpp.

{
    bool check = CheckParameters(DPars);
    if (!check)
        return (check);
    check *= Update(DPars) * QCDsuccess;
    unknownParameterWarning = false;
    return (check);
}

initializeBParameter()

void QCD::initializeBParameter

(

std::string

name_i

)

const

A method to initialize B Parameter and the corresponding meson.

Parameters

[in]

name_i

name of the B parameters set

Definition at line 211 of file QCD.cpp.

{
    if (BParameterMap.find(name_i) != BParameterMap.end())
        return;
 
    if (name_i.compare("BBs") == 0 || name_i.compare("BBd") == 0)
    {
        BParameterMap.insert(std::pair<std::string, BParameter>("BBs", BParameter(5, "BBs")));
        BParameterMap.at("BBs").setFlagCsi(FlagCsi);
        BParameterMap.at("BBs").ModelParameterMapInsert(ModelParamMap);
        computeBs = true;
        initializeMeson(QCD::B_S);
 
        BParameterMap.insert(std::pair<std::string, BParameter>("BBd", BParameter(5, "BBd")));
        BParameterMap.at("BBd").setFlagCsi(FlagCsi);
        BParameterMap.at("BBd").ModelParameterMapInsert(ModelParamMap);
        computeBd = true;
        initializeMeson(QCD::B_D);
        return;
    }
    if (name_i.compare("BBs_subleading") == 0)
    {
        BParameterMap.insert(std::pair<std::string, BParameter>(name_i, BParameter(2, name_i)));
        BParameterMap.at(name_i).ModelParameterMapInsert(ModelParamMap);
        return;
    }
    if (name_i.compare("BBd_subleading") == 0)
    {
        BParameterMap.insert(std::pair<std::string, BParameter>(name_i, BParameter(2, name_i)));
        BParameterMap.at(name_i).ModelParameterMapInsert(ModelParamMap);
        return;
    }
    if (name_i.compare("BD") == 0)
    {
        BParameterMap.insert(std::pair<std::string, BParameter>(name_i, BParameter(5, name_i)));
        BParameterMap.at(name_i).ModelParameterMapInsert(ModelParamMap);
        initializeMeson(QCD::D_0);
        return;
    }
    if (name_i.compare("BK") == 0)
    {
        BParameterMap.insert(std::pair<std::string, BParameter>(name_i, BParameter(5, name_i)));
        BParameterMap.at(name_i).ModelParameterMapInsert(ModelParamMap);
        initializeMeson(QCD::K_0);
        return;
    }
    if (name_i.compare("BKd1") == 0)
    {
        BParameterMap.insert(std::pair<std::string, BParameter>(name_i, BParameter(10, name_i)));
        BParameterMap.at(name_i).ModelParameterMapInsert(ModelParamMap);
        initializeMeson(QCD::K_0);
        initializeMeson(QCD::K_P);
        initializeMeson(QCD::K_S);
        initializeMeson(QCD::P_0);
        initializeMeson(QCD::P_P);
        return;
    }
    if (name_i.compare("BKd3") == 0)
    {
        BParameterMap.insert(std::pair<std::string, BParameter>(name_i, BParameter(10, name_i)));
        BParameterMap.at(name_i).ModelParameterMapInsert(ModelParamMap);
        initializeMeson(QCD::K_0);
        initializeMeson(QCD::K_P);
        initializeMeson(QCD::P_0);
        initializeMeson(QCD::P_P);
        return;
    }
}

initializeMeson()

void QCD::initializeMeson

(

QCD::meson

meson_i

)

const

A method to initialize a meson.

Parameters

[in]

meson_i

the enumerator corresponding to the meson

Definition at line 280 of file QCD.cpp.

{
    if (mesonsMap.find(meson_i) != mesonsMap.end())
        return;
 
    mesonsMap.insert(std::pair<const QCD::meson, Meson>(meson_i, Meson()));
 
    if (meson_i == QCD::P_0)
        mesonsMap.at(meson_i).setName("P_0");
    else if (meson_i == QCD::P_P)
        mesonsMap.at(meson_i).setName("P_P");
    else if (meson_i == QCD::K_0)
        mesonsMap.at(meson_i).setName("K_0");
    else if (meson_i == QCD::K_P)
        mesonsMap.at(meson_i).setName("K_P");
    else if (meson_i == QCD::K_S)
        mesonsMap.at(meson_i).setName("K_S");
    else if (meson_i == QCD::D_0)
        mesonsMap.at(meson_i).setName("D_0");
    else if (meson_i == QCD::D_P)
        mesonsMap.at(meson_i).setName("D_P");
    else if (meson_i == QCD::D_S)
        mesonsMap.at(meson_i).setName("D_S");
    else if (meson_i == QCD::B_D)
        mesonsMap.at(meson_i).setName("B_D");
    else if (meson_i == QCD::B_P)
        mesonsMap.at(meson_i).setName("B_P");
    else if (meson_i == QCD::B_S)
        mesonsMap.at(meson_i).setName("B_S");
    else if (meson_i == QCD::B_C)
        mesonsMap.at(meson_i).setName("B_C");
    else if (meson_i == QCD::PHI)
        mesonsMap.at(meson_i).setName("PHI");
    else if (meson_i == QCD::K_star)
        mesonsMap.at(meson_i).setName("K_star");
    else if (meson_i == QCD::K_star_P)
        mesonsMap.at(meson_i).setName("K_star_P");
    else if (meson_i == QCD::D_star_P)
        mesonsMap.at(meson_i).setName("D_star_P");
    else if (meson_i == QCD::RHO)
        mesonsMap.at(meson_i).setName("RHO");
    else if (meson_i == QCD::RHO_P)
        mesonsMap.at(meson_i).setName("RHO_P");
    else if (meson_i == QCD::OMEGA)
        mesonsMap.at(meson_i).setName("OMEGA");
    else
    {
        std::stringstream out;
        out << meson_i;
        throw std::runtime_error("QCD::initializeMeson() meson " + out.str() + " not implemented");
    }
 
    if (meson_i == QCD::B_D)
        computeFBd = true;
    if (meson_i == QCD::B_P)
        computeFBp = true;
 
    if ((computeFBd || computeFBp) && (mesonsMap.find(QCD::B_S) == mesonsMap.end()))
        initializeMeson(QCD::B_S);
 
    mesonsMap.at(meson_i).ModelParameterMapInsert(ModelParamMap);
}

isQCDsuccess()

bool QCD::isQCDsuccess ( ) const

inline

A getter for the QCDsuccess flag.

Returns

the value of the QCDsuccess flag

Definition at line 979 of file QCD.h.

    {
        return QCDsuccess;
    }

logLambda() [1/2]

const double QCD::logLambda ( const double  muMatching, const double  mf, const double  nfNEW, const double  nfORG, const double  logLambdaORG, orders  order  ) const

private

\(\log(\Lambda_{\rm QCD})\) used for computation of \(\alpha_s\) at FULLNNLO.

Parameters

[in]	muMatching	the scale at which the matching is done during crossing a flavour threshold
[in]	mf	the mass of the quark sitting at the flavour threshold being crossed
[in]	nfNEW	the number of flavours after crossing the flavour threshold, \(n_{f}^{\mathrm{NEW}}\)
[in]	nfORG	the number of flavours before crossing the flavour threshold, \(n_{f}^{\mathrm{ORG}}\)
[in]	logLambdaORG	the value of \(\log(\Lambda_{\rm QCD})\) with \(n_f = n_{f}^{\mathrm{ORG}}\)
[in]	order	the QCD order of the calculation

Returns

\(\log(\Lambda_{\rm QCD})\) for \(n_f = n_{f}^{\mathrm{NEW}}\)

Definition at line 1163 of file QCD.cpp.

{
    if (fabs(nfNEW - nfORG) != 1.)
    {
        QCDsuccess = false;
        std::cout << "Error in QCD::logLambda()! QCDsuccess set to false" << std::endl;
    }
 
    if (order == NLO)
        order = FULLNLO;
    if (order == NNLO)
        order = FULLNNLO;
 
    /* We do not use the codes below for FULLNLO, since threshold corrections
     * can be regarded as an NNLO effect as long as setting the matching scale
     * to be close to the mass scale of the decoupling quark. In order to use
     * the relation als^{nf+1} = als^{nf} exactly, we use logLambdaNLO method.
     */
    if (order == FULLNLO)
        return logLambdaNLO(nfNEW, nfORG, logLambdaORG);
 
    double logMuMatching = log(muMatching);
    double L = 2. * (logMuMatching - logLambdaORG);
    double rNEW = 0.0, rORG = 0.0, log_mu2_mf2 = 0.0, log_L = 0.0;
    double C1 = 0.0, C2 = 0.0; // threshold corrections
    double logLambdaNEW;
 
    // LO contribution
    logLambdaNEW = 1. / 2. / Beta0(nfNEW) * (Beta0(nfNEW) - Beta0(nfORG)) * L + logLambdaORG;
 
    // NLO contribution
    if (order == FULLNLO || order == FULLNNLO)
    {
        rNEW = Beta1(nfNEW) / Beta0(nfNEW);
        rORG = Beta1(nfORG) / Beta0(nfORG);
        log_mu2_mf2 = 2. * (logMuMatching - log(mf));
        log_L = log(L);
        if (nfNEW < nfORG)
            C1 = 2. / 3. * log_mu2_mf2;
        else
            C1 = -2. / 3. * log_mu2_mf2;
        logLambdaNEW += 1. / 2. / Beta0(nfNEW) * ((rNEW - rORG) * log_L - rNEW * log(Beta0(nfNEW) / Beta0(nfORG)) - C1);
    }
 
    // NNLO contribution
    if (order == FULLNNLO)
    {
        if (nfNEW == 5. && nfORG == 6.)
            C2 = -16. * (log_mu2_mf2 * log_mu2_mf2 / 36. - 19. / 24. * log_mu2_mf2 - 7. / 24.);
        else if (nfNEW == 6. && nfORG == 5.)
            C2 = -16. * (log_mu2_mf2 * log_mu2_mf2 / 36. + 19. / 24. * log_mu2_mf2 + 7. / 24.);
        else
        {
            if (nfNEW < nfORG)
                C2 = -16. * (log_mu2_mf2 * log_mu2_mf2 / 36. - 19. / 24. * log_mu2_mf2 + 11. / 72.);
            else
                C2 = -16. * (log_mu2_mf2 * log_mu2_mf2 / 36. + 19. / 24. * log_mu2_mf2 - 11. / 72.);
        }
        logLambdaNEW += 1. / 2. / Beta0(nfNEW) / Beta0(nfORG) / L * (rORG * (rNEW - rORG) * log_L + rNEW * rNEW - rORG * rORG - Beta2(nfNEW) / Beta0(nfNEW) + Beta2(nfORG) / Beta0(nfORG) + rNEW * C1 - C1 * C1 - C2);
    }
 
    return logLambdaNEW;
}

logLambda() [2/2]

const double QCD::logLambda	(	const double	nf,
		orders	order
	)		const

Computes \(\ln\Lambda_\mathrm{QCD}\) with nf flavours in GeV.

Parameters

[in]	nf	the number of active flavours \(n_f\)
[in]	order	LO, NLO, FULLNLO, NNLO or FULLNNLO in the \(\alpha_s\) expansion defined in OrderScheme

Returns

\(\ln\Lambda_\mathrm{QCD}\) with nf flavours in GeV

Definition at line 1229 of file QCD.cpp.

{
    if (order == NLO)
        order = FULLNLO;
    if (order == NNLO)
        order = FULLNNLO;
 
    double muMatching, mf, logLambdaORG, logLambdaNEW;
    if (nf == 5.)
        return logLambda5(order);
    else if (nf == 6.)
    {
        muMatching = Thresholds(1); // mut
        /* matching condition from Nf=5 to Nf=6 is given in terms of the top pole mass. */
        mf = mtpole; // top pole mass
        return logLambda(muMatching, mf, 6., 5., logLambda5(order), order);
    }
    else if (nf == 4. || nf == 3.)
    {
        muMatching = Thresholds(2);       // mub
        mf = getQuarks(BOTTOM).getMass(); // m_b(m_b)
        logLambdaORG = logLambda5(order);
        logLambdaNEW = logLambda(muMatching, mf, 4., 5., logLambdaORG, order);
        if (nf == 3.)
        {
            muMatching = Thresholds(3);      // muc
            mf = getQuarks(CHARM).getMass(); // m_c(m_c)
            logLambdaORG = logLambdaNEW;
            logLambdaNEW = logLambda(muMatching, mf, 3., 4., logLambdaORG, order);
        }
        return logLambdaNEW;
    }
    else
    {
        QCDsuccess = false;
        std::cout << "Error in QCD::logLambda()! QCDsuccess set to false" << std::endl;
    }
    return 0.;
}

logLambda5()

const double QCD::logLambda5 ( orders  order ) const

private

\(\log(\Lambda_{\rm QCD})\) for \(n_f = 5\).

Parameters

[in]

order

the QCD order of the computation

Returns

\(\log(\Lambda_{\rm QCD}^{(5)})\)

Definition at line 1067 of file QCD.cpp.

{
    if (order == NLO)
        order = FULLNLO;
    if (order == NNLO)
        order = FULLNNLO;
 
    for (int i = 0; i < CacheSize; ++i)
        if ((AlsM == logLambda5_cache[0][i]) && (MAls == logLambda5_cache[1][i]) && ((double)order == logLambda5_cache[2][i]))
            return logLambda5_cache[3][i];
 
    CacheShift(logLambda5_cache, 4);
    logLambda5_cache[0][0] = AlsM;
    logLambda5_cache[1][0] = MAls;
    logLambda5_cache[2][0] = (double)order;
 
    if (order == LO)
        logLambda5_cache[3][0] = log(MAls) - 2. * M_PI / Beta0(5.) / AlsM;
    else
    {
        double xmin = -4., xmax = -0.2;
        TF1 f = TF1("f", this, &QCD::ZeroNf5, xmin, xmax, 1, "QCD", "zeroNf5");
 
        ROOT::Math::WrappedTF1 wf1(f);
        double ledouble = (double)order;
        wf1.SetParameters(&ledouble);
 
        ROOT::Math::BrentRootFinder brf;
        brf.SetFunction(wf1, xmin, xmax);
 
        if (brf.Solve())
            logLambda5_cache[3][0] = brf.Root();
        else
        {
            QCDsuccess = false;
            std::cout << "Error in QCD::logLambda5()! QCDsuccess set to false" << std::endl;
        }
    }
    return (logLambda5_cache[3][0]);
}

logLambdaNLO()

const double QCD::logLambdaNLO ( const double  nfNEW, const double  nfORG, const double  logLambdaORG  ) const

private

\(\log(\Lambda_{\rm QCD})\) used for computation of \(\alpha_s\) at FULLNLO.

Parameters

[in]	nfNEW	the number of flavours after crossing the flavour threshold, \(n_{f}^{\mathrm{NEW}}\)
[in]	nfORG	the number of flavours before crossing the flavour threshold, \(n_{f}^{\mathrm{ORG}}\)
[in]	logLambdaORG	the value of \(\log(\Lambda_{\rm QCD})\) with \(n_f = n_{f}^{\mathrm{ORG}}\)

Returns

\(\log(\Lambda_{\rm QCD})\) for \(n_f = n_{f}^{\mathrm{NEW}}\)

Definition at line 1108 of file QCD.cpp.

{
    for (int i = 0; i < CacheSize; ++i)
        if ((AlsM == logLambdaNLO_cache[0][i]) && (MAls == logLambdaNLO_cache[1][i]) && (mut == logLambdaNLO_cache[2][i]) && (mub == logLambdaNLO_cache[3][i]) && (muc == logLambdaNLO_cache[4][i]) && (nfNEW == logLambdaNLO_cache[5][i]) && (nfORG == logLambdaNLO_cache[6][i]) && (logLambdaORG == logLambdaNLO_cache[7][i]))
            return logLambdaNLO_cache[8][i];
 
    CacheShift(logLambdaNLO_cache, 9);
    logLambdaNLO_cache[0][0] = AlsM;
    logLambdaNLO_cache[1][0] = MAls;
    logLambdaNLO_cache[2][0] = mut;
    logLambdaNLO_cache[3][0] = mub;
    logLambdaNLO_cache[4][0] = muc;
    logLambdaNLO_cache[5][0] = nfNEW;
    logLambdaNLO_cache[6][0] = nfORG;
    logLambdaNLO_cache[7][0] = logLambdaORG;
 
    double xmin = -4., xmax = -0.2;
 
    TF1 f;
    if (nfNEW == 6. && nfORG == 5.)
    {
        f = TF1("f", this, &QCD::ZeroNf6NLO, xmin, xmax, 1, "QCD", "zeroNf6NLO");
    }
    else if (nfNEW == 4. && nfORG == 5.)
    {
        f = TF1("f", this, &QCD::ZeroNf4NLO, xmin, xmax, 1, "QCD", "zeroNf4NLO");
    }
    else if (nfNEW == 3. && nfORG == 4.)
    {
        f = TF1("f", this, &QCD::ZeroNf3NLO, xmin, xmax, 1, "QCD", "zeroNf3NLO");
    }
    else
    {
        QCDsuccess = false;
        std::cout << "Error in QCD::logLambdaNLO()! QCDsuccess set to false" << std::endl;
    }
 
    ROOT::Math::WrappedTF1 wf1(f);
    wf1.SetParameters(&logLambdaORG);
 
    ROOT::Math::BrentRootFinder brf;
    brf.SetFunction(wf1, xmin, xmax);
 
    if (brf.Solve())
        logLambdaNLO_cache[8][0] = brf.Root();
    else
    {
        QCDsuccess = false;
        std::cout << "Error in QCD::logLambdaNLO()! QCDsuccess set to false" << std::endl;
    }
 
    return (logLambdaNLO_cache[8][0]);
}

MassOfNf()

const double QCD::MassOfNf ( int  nf ) const

protected

The Mbar mass of the heaviest quark in the theory with Nf active flavour.

Parameters

[in]

Nf

the number of active flavour

Returns

MSbar \(m_q(m_q)\)

Definition at line 745 of file QCD.cpp.

{
    switch (nf)
    {
    case 6:
        return (quarks[TOP].getMass());
    case 5:
        return (quarks[BOTTOM].getMass());
    case 4:
        return (quarks[CHARM].getMass());
    case 3:
        return (quarks[STRANGE].getMass());
    default:
        throw std::runtime_error("QCD::MassOfNf(): no running masses for light quarks");
    }
}

Mbar2Mp()

const double QCD::Mbar2Mp	(	const double	mbar,
		const quark	q,
		const orders	order = FULLNNLO
	)		const

Converts the \(\overline{\mathrm{MS}}\) mass \(m(m)\) to the pole mass.

Parameters

[in]	mbar	the \(\overline{\mathrm{MS}}\) mass \(m(m)\) in GeV
[in]	q	the quark for which the conversion is done
[in]	order	LO, NLO, FULLNLO, NNLO or FULLNNLO in the \(\alpha_s\) expansion defined in OrderScheme

Returns

the pole mass in GeV

Attention

Can only be used for conversion of mass of the top and bottom quarks.

Definition at line 1552 of file QCD.cpp.

{
    int Nf_m;
    double nl;
    std::vector<double> x = {0.0};
 
    if (q == CHARM)
        Nf_m = 4;
    else if (q == BOTTOM)
        Nf_m = 5; 
    else if (q == TOP)
        Nf_m = 6;
    else
        throw std::runtime_error("QCD::Mbar2Mp() can convert only top, bottom and charm masses");
 
    nl = Nf_m-1;
 
    // LO contribution
    double MpLO = mbar;
    if (order == LO)
        return MpLO;
 
    // alpha_s(mbar)/pi
    orders orderForAls;
    if (order == NLO || order == FULLNLO)
        orderForAls = FULLNLO;
    if (order == NNLO || order == FULLNNLO)
        orderForAls = FULLNNLO;
    double a = Als(mbar, Nf_m, orderForAls) / M_PI;
 
    // NLO contribution
    double MpNLO = mbar * 4. / 3. * a;
    if (order == NLO)
        return MpNLO;
    if (order == FULLNLO)
        return (MpLO + MpNLO);
 
    // NNLO contribution
 
    x.push_back(quarks[STRANGE].getMass() / mbar); 
    if (nl >3)
        x.push_back(quarks[CHARM].getMass() / mbar);
    if (nl > 4)
        x.push_back(quarks[BOTTOM].getMass() / mbar);
    
    double Delta = 0.;
    for (int i = 0; i < x.size(); i++)
        Delta += DeltaMass(x[i]);
 
    double MpNNLO = mbar * (307. / 32. + 2. * zeta2 + 2. / 3. * zeta2 * log(2.0) - zeta3 / 6. - nl / 3. * (zeta2 + 71. / 48.) + 4. / 3. * Delta) * a * a;
 
    if (order == NNLO)
        return MpNNLO;
    if (order == FULLNNLO)
        return (MpLO + MpNLO + MpNNLO);
 
    throw std::runtime_error(orderToString(order) + " is not implemented in QCD::Mbar2Mp().");
}

Mofmu2Mbar()

const double QCD::Mofmu2Mbar	(	const double	m,
		const double	mu,
		const quark	q
	)		const

Converts a quark running mass at an arbitrary scale to the corresponding \(\overline{\mathrm{MS}}\) mass \(m(m)\).

Parameters

[in]	m	the running mass at the scale \(\mu\) in GeV
[in]	mu	the scale \(\mu\) in GeV
[in]	q	the quark for which the conversion is done

Returns

the \(\overline{\mathrm{MS}}\) mass \(m(m)\) in GeV

Definition at line 1738 of file QCD.cpp.

{
 
    // First move to the right region
 
    double mutmp=0.;
    switch (q)
    {
    case TOP:
        mutmp = mut;
        break;
    case BOTTOM:
        mutmp = mub;
        break;
    case CHARM:
        mutmp = muc;
        break;
    default:
        QCDsuccess = false;
        std::cout << "Error in QCD::Mofmu2Mbar()! QCDsuccess set to false" << std::endl;
        break;
    }
    double mlow = Mrun(mutmp, mu, m, q);
    TF1 f("f", this, &QCD::Mofmu2MbarTMP, mlow / 2., 2. * mlow, 3, "QCD", "mofmu2mbara");
 
    ROOT::Math::WrappedTF1 wf1(f);
 
    double params[3];
    params[0] = mlow;
    params[1] = mutmp;
    params[2] = (double)q;
    wf1.SetParameters(params);
 
    ROOT::Math::BrentRootFinder brf;
    brf.SetNpx(5);
    brf.SetFunction(wf1, .5 * mlow, 2. * mlow);
    if (brf.Solve())
        mlow = brf.Root();
    else
        {
            QCDsuccess = false;
            std::cout << "Error in QCD::Mofmu2Mbar()! QCDsuccess set to false" << std::endl;
            mlow = 0.;
        }
 
    return (mlow);
}

Mofmu2MbarTMP()

const double QCD::Mofmu2MbarTMP ( double *  mu, double *  params  ) const

private

The member used for finding the numerical solution to the \(\overline{\rm MS}\) mass from \(m(\mu_i)\) mass.

Parameters

[in]	mu	a pointer to the \(\overline{\rm MS}\) mass
[in]	params	a pointer to a vector containing \(m(\mu_i)\) and \(\mu_i\)

Returns

the difference of mass and \(m(\mu)\) and \(\mu\)

Definition at line 1730 of file QCD.cpp.

{
    double mofmu = params[0];
    double muI = params[1];
    quark q = (quark)params[2];
    return (*mu - Mrun(*mu, muI, mofmu, q));
}

Mp2Mbar()

const double QCD::Mp2Mbar	(	const double	mp,
		const quark	q,
		orders	order = FULLNNLO
	)		const

Converts a quark pole mass to the corresponding \(\overline{\mathrm{MS}}\) mass \(m(m)\).

Parameters

[in]	mp	the pole mass of the bottom or top quark in GeV
[in]	q	the quark for which the conversion is done
[in]	order	LO, NLO, FULLNLO, NNLO or FULLNNLO in the \(\alpha_s\) expansion defined in OrderScheme

Returns

the \(\overline{\mathrm{MS}}\) mass \(m(m)\) in GeV

Definition at line 1672 of file QCD.cpp.

{
    if (q == TOP)
//        return Mp2Mbar_pole(mp, order);
        return Mp2Mbar_bar(mp, q, order);
    else if (q == BOTTOM || q == CHARM)
        return Mp2Mbar_bar(mp, q, order);
    else
        throw std::runtime_error("QCD::Mp2Mbar() can convert only top, bottom and charm masses");
}

Mp2Mbar_bar()

const double QCD::Mp2Mbar_bar ( const double  mp, const quark  q, const orders  order = FULLNNLO  ) const

private

Converts the bottom pole mass to the corresponding \(\overline{\mathrm{MS}}\) mass \(m_t(m_t)\) by iteration.

Parameters

[in]	mp	the pole mass of bottom quark in GeV
[in]	q	the quark for which the conversion is done (bottom or charm)
[in]	order	LO, NLO, FULLNLO, NNLO or FULLNNLO in the \(\alpha_s\) expansion defined in OrderScheme

Returns

the \(\overline{\mathrm{MS}}\) mass \(m_t(m_t)\) in GeV

Definition at line 1625 of file QCD.cpp.

{
    if (order == NLO || order == NNLO)
        throw std::runtime_error(orderToString(order) + " is not implemented in QCD::Mp2Mbar().");
 
    int i;
    double ms = quarks[STRANGE].getMass(), mc = quarks[CHARM].getMass(),
        mb = quarks[BOTTOM].getMass();
    double alsmp = Als(mp, order);
    for (i = 0; i < CacheSize; ++i)
        if (alsmp == mp2mbar_cache[0][i] && ms == mp2mbar_cache[1][i] &&
            mc == mp2mbar_cache[2][i] && mb == mp2mbar_cache[3][i]
            && (double)order == mp2mbar_cache[4][i])
            return mp2mbar_cache[5][i];
 
    TF1 f("f", this, &QCD::Mp2MbarTMP, mp / 2., 2. * mp, 3, "QCD", "Mp2MbarTMP");
 
    ROOT::Math::WrappedTF1 wf1(f);
    double params[3];
    params[0] = mp;
    params[1] = (double)q; 
    params[2] = (double)order;
    wf1.SetParameters(params);
 
    ROOT::Math::BrentRootFinder brf;
 
    brf.SetNpx(5);
    brf.SetFunction(wf1, .5 * mp, 2. * mp);
    if (brf.Solve())
    {
        CacheShift(mp2mbar_cache, 6);
        mp2mbar_cache[0][0] = alsmp;
        mp2mbar_cache[1][0] = ms;
        mp2mbar_cache[2][0] = mc;
        mp2mbar_cache[3][0] = mb;
        mp2mbar_cache[4][0] = (double)order;
        mp2mbar_cache[5][0] = brf.Root();
    }
    else
    {
        QCDsuccess = false;
        std::cout << "Error in QCD::Mp2Mbar()! QCDsuccess set to false" << std::endl;
    }
 
    return (mp2mbar_cache[5][0]);
}

Mp2Mbar_pole()

const double QCD::Mp2Mbar_pole ( const double  mp, const orders  order = FULLNNLO  ) const

private

Converts the top pole mass to the corresponding \(\overline{\mathrm{MS}}\) mass \(m_t(m_t)\) using eq. (16) of hep-ph/0004189.

Parameters

[in]	mp	the pole mass of top quark in GeV
[in]	order	LO, NLO, FULLNLO, NNLO or FULLNNLO in the \(\alpha_s\) expansion defined in OrderScheme

Returns

the \(\overline{\mathrm{MS}}\) mass \(m_t(m_t)\) in GeV

Definition at line 1683 of file QCD.cpp.

{
    int Nfmp = 6;
        // LO contribution
        double mbarLO = mp;
        if (order == LO)
            return mbarLO;
 
        // alpha_s(mp)/pi
        orders orderForAls;
        if (order == NLO || order == FULLNLO)
            orderForAls = FULLNLO;
        if (order == NNLO || order == FULLNNLO)
            orderForAls = FULLNNLO;
        double a = Als(mp, Nfmp, orderForAls) / M_PI;
 
        // NLO contribution
        double mbarNLO = mp * (-4. / 3.) * a;
        if (order == NLO)
            return mbarNLO;
        if (order == FULLNLO)
            return (mbarLO + mbarNLO);
 
        double mbarNNLO = mp * ((-1111. * CA * CF) / 384. + (199. * CF * CF) / 128. + (143. * CF * TF) / 96. +
                                    (71. * CF * ((double)Nfmp - 1.) * TF) / 96. + (CA * CF * zeta2) / 2. - (15. * CF * CF * zeta2) / 8. -
                                    (3. * CA * CF * log(2.) * zeta2) / 2. + 3. * CF * CF * log(2.) * zeta2 - CF * TF * zeta2 +
                                    (CF * ((double)Nfmp - 1.) * TF * zeta2) / 2. + (3. * CA * CF * zeta3) / 8. - (3. * CF * CF * zeta3) / 4.) * a * a;
        
        //for the top, the correction from light quark masses is negligible
        if (order == NNLO)
            return mbarNNLO;
        if (order == FULLNNLO)
            return (mbarLO + mbarNLO + mbarNNLO);
 
    throw std::runtime_error(orderToString(order) + " is not implemented in QCD::Mp2Mbar_new().");
}

Mp2MbarTMP()

const double QCD::Mp2MbarTMP ( double *  mu, double *  params  ) const

private

The member used for finding the numerical solution to the pole mass from the \(\overline{\rm MS}\) mass.

Parameters

[in]	mu	a pointer to the \(\overline{\rm MS}\) mass
[in]	params	a pointer to a vector containing the pole mass and the QCD order of the computation

Returns

the difference in the pole mass and the pole mass as computed from the \(\overline{\rm MS}\) mass

Definition at line 1617 of file QCD.cpp.

{
    double mp = params[0];
    quark q = (quark)params[1];
    orders order = (orders)params[2];
    return (mp - Mbar2Mp(*mu, q, order));
}

Mrun() [1/2]

const double QCD::Mrun	(	const double	mu,
		const double	m,
		const quark	q,
		const orders	order = FULLNNLO
	)		const

Computes a running quark mass \(m(\mu)\) from \(m(m)\).

Parameters

[in]	mu	a scale \(\mu\) in GeV
[in]	m	the \(\overline{\mathrm{MS}}\) mass \(m(m)\) in GeV
[in]	q	the quark for which the running mass is computed
[in]	order	LO, NLO, FULLNLO, NNLO or FULLNNLO in the \(\alpha_s\) expansion defined in OrderScheme

Returns

the running quark mass \(m(\mu)\) in GeV

Definition at line 1353 of file QCD.cpp.

{
    return Mrun(mu, m, m, q, order);
}

Mrun() [2/2]

const double QCD::Mrun	(	const double	mu_f,
		const double	mu_i,
		const double	m,
		const quark	q,
		const orders	order = FULLNNLO
	)		const

Runs a quark mass from \(\mu_i\) to \(\mu_f\).

Parameters

[in]	mu_f	a scale \(\mu_f\) in GeV
[in]	mu_i	a scale \(\mu_i\) in GeV
[in]	m	the \(\overline{\mathrm{MS}}\) mass \(m(\mu_i)\) in GeV
[in]	q	the quark for which the running mass is computed
[in]	order	LO, NLO, FULLNLO, NNLO or FULLNNLO in the \(\alpha_s\) expansion defined in OrderScheme

Returns

the running quark mass \(m(\mu_f)\) in GeV

Definition at line 1358 of file QCD.cpp.

{
    // Note: When the scale evolves across a flavour threshold, the definitions
    //       of the outputs for "NLO" and "NNLO" become complicated.
 
    int i;
    for (i = 0; i < CacheSize; ++i)
    {
        if ((mu_f == mrun_cache[0][i]) && (mu_i == mrun_cache[1][i]) &&
            (m == mrun_cache[2][i]) && ((double)order == mrun_cache[3][i]) &&
            ((double)q == mrun_cache[4][i]) && 
            (AlsM == mrun_cache[5][i]) && (MAls == mrun_cache[6][i]) &&
            (mut == mrun_cache[7][i]) && (mub == mrun_cache[8][i]) &&
            (muc == mrun_cache[9][i]))
            return mrun_cache[10][i];
    }
 
    double nfi = Nf(mu_i), nff = Nf(mu_f);
    double nfq;
    if (q == TOP)
        nfq = 6.;
    else if (q == BOTTOM)
        nfq = 5.;
    else if (q == CHARM)
        nfq = 4.;
    else 
        nfq = 3.;
 
    nfi = (nfi > nfq) ? nfi : nfq;
    nff = (nff > nfq) ? nff : nfq;
 
    double mu_threshold, mu_threshold2, mu_threshold3, mrun;
    if (nff == nfi)
        mrun = MrunTMP(mu_f, mu_i, m, lround(nfi), order);
    else if (nff > nfi)
    {
        if (order == NLO || order == NNLO)
            throw std::runtime_error(orderToString(order) + " is not implemented in QCD::Mrun(mu_f,mu_i,m,q,order)");
        mu_threshold = Nf(mu_i) < nfi ? Thresholds(6-lround(nfi)): AboveTh(mu_i) ;
        mrun = MrunTMP(mu_threshold - MEPS, mu_i, m, lround(nfi), order);
        if (order == FULLNNLO)
            mrun *= threCorrForMass(nfi + 1., nfi); // threshold corrections
        if (nff == nfi + 1.)
        {
            mrun = MrunTMP(mu_f, mu_threshold + MEPS, mrun, lround(nff), order);
        }
        else if (nff == nfi + 2.)
        {
            mu_threshold2 = BelowTh(mu_f);
            mrun = MrunTMP(mu_threshold2 - MEPS, mu_threshold + MEPS, mrun, lround(nfi) + 1, order);
            if (order == FULLNNLO)
                mrun *= threCorrForMass(nff, nfi + 1.); // threshold corrections
            mrun = MrunTMP(mu_f, mu_threshold2 + MEPS, mrun, lround(nff), order);
        }
        else if (nff == nfi + 3.)
        {
            mu_threshold2 = AboveTh(mu_threshold);
            mrun = MrunTMP(mu_threshold2 - MEPS, mu_threshold + MEPS, mrun, lround(nfi) + 1, order);
            if (order == FULLNNLO)
                mrun *= threCorrForMass(nfi + 2., nfi + 1.); // threshold corrections
            mu_threshold3 = BelowTh(mu_f);
            mrun = MrunTMP(mu_threshold3 - MEPS, mu_threshold2 + MEPS, mrun, lround(nff) - 1, order);
            if (order == FULLNNLO)
                mrun *= threCorrForMass(nff, nfi + 2.); // threshold corrections
            mrun = MrunTMP(mu_f, mu_threshold3 + MEPS, mrun, lround(nff), order);
        }
        else
        {
            QCDsuccess = false;
            std::cout << "Error in QCD::Mrun(mu_f,mu_i,m,order)! QCDsuccess set to false" << std::endl;
            mrun = 0.;
        }
    }
    else
    {
        if (order == NLO || order == NNLO)
            throw std::runtime_error(orderToString(order) + " is not implemented in QCD::Mrun(mu_f,mu_i,m,order)");
        mu_threshold = BelowTh(mu_i);
        mrun = MrunTMP(mu_threshold + MEPS, mu_i, m, lround(nfi), order);
        if (order == FULLNNLO)
            mrun *= threCorrForMass(nfi - 1., nfi); // threshold corrections
        if (nff == nfi - 1.)
            mrun = MrunTMP(mu_f, mu_threshold - MEPS, mrun, lround(nff), order);
        else if (nff == nfi - 2.)
        {
            mu_threshold2 = Nf(mu_f) < nff ? Thresholds(6-lround(nff)) : AboveTh(mu_f);
            mrun = MrunTMP(mu_threshold2 + MEPS, mu_threshold - MEPS, mrun, lround(nfi) - 1, order);
            if (order == FULLNNLO)
                mrun *= threCorrForMass(nff, nfi - 1.); // threshold corrections
            mrun = MrunTMP(mu_f, mu_threshold2 - MEPS, mrun, lround(nff), order);
        }
        else
        {
            QCDsuccess = false;
            std::cout << "Error in QCD::Mrun(mu_f,mu_i,m,order)! QCDsuccess set to false" << std::endl;
            mrun = 0.;
        }
    }
 
    if (mrun < 0.0)
    {
        std::stringstream out;
        out << "QCD::Mrun(): A quark mass becomes tachyonic in QCD::Mrun("
            << mu_f << ", " << mu_i << ", " << m << ", " << orderToString(order) << ")"
            << std::endl
            << "             Als(" << mu_i << ", " << orderToString(order) << ")/(4pi)="
            << Als(mu_i, order) / (4. * M_PI) << std::endl
            << "             Als(" << mu_f << ", " << orderToString(order) << ")/(4pi)="
            << Als(mu_f, order) / (4. * M_PI);
        QCDsuccess = false;
        std::cout << "Error in QCD::Mrun(mu_f,mu_i,m,order)! QCDsuccess set to false" << std::endl;
        mrun = 0.;
    }
 
    CacheShift(mrun_cache, 11);
    mrun_cache[0][0] = mu_f;
    mrun_cache[1][0] = mu_i;
    mrun_cache[2][0] = m;
    mrun_cache[3][0] = (double)order;
    mrun_cache[4][0] = (double)q;
    mrun_cache[5][0] = AlsM;
    mrun_cache[6][0] = MAls;
    mrun_cache[7][0] = mut;
    mrun_cache[8][0] = mub;
    mrun_cache[9][0] = muc;
    mrun_cache[10][0] = mrun;
 
    return mrun;
}

Mrun4()

const double QCD::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\).

Parameters

[in]	mu_f	the final scale \(\mu_f\) to which the mass is run
[in]	mu_i	the initial scale \(\mu_i\) from which the mass is run
[in]	m	the mass at the scale \(\mu_i\)

Returns

the mass at the scale \(\mu_f\) with \(n_f = 4\)

Attention

Temporary function waiting for the implementation of NNLO exact.

Definition at line 1531 of file QCD.cpp.

{
    double nf = 4.;
 
    // alpha_s/(4pi)
    double ai = Als4(mu_i) / (4. * M_PI);
    double af = Als4(mu_f) / (4. * M_PI);
 
    // LO contribution
    double b0 = Beta0(nf), g0 = Gamma0(nf);
    double mLO = m * pow(af / ai, g0 / (2. * b0));
 
    // NLO contribution
    double b1 = Beta1(nf), g1 = Gamma1(nf);
    double A1 = g1 / (2. * b0) - b1 * g0 / (2. * b0 * b0);
    double mNLO = mLO * A1 * (af - ai);
    return (mLO + mNLO);
}

MrunTMP()

const double QCD::MrunTMP ( const double  mu_f, const double  mu_i, const double  m, const int  nf, const orders  order  ) const

private

A function to calculate the running of the mass between flavour thresholds.

Parameters

[in]	mu_f	the final scale \(\mu_f\) to which the mass if run
[in]	mu_i	the initial scale \(\mu_i\) from which the mass if run
[in]	m	the mass at the scale \(\mu_i\)
[in]	nf	the number of active flavours
[in]	order	the QCD order at which the running is being calculated

Returns

the mass evolved from \(\mu_i\) to \(\mu_f\)

Definition at line 1489 of file QCD.cpp.

{
 
    // alpha_s/(4pi)
    orders orderForAls;
    if (order == LO)
        orderForAls = LO;
    if (order == NLO || order == FULLNLO)
        orderForAls = FULLNLO;
    if (order == NNLO || order == FULLNNLO)
        orderForAls = FULLNNLO;
    double ai = Als(mu_i, nf, orderForAls) / (4. * M_PI);
    double af = Als(mu_f, nf, orderForAls) / (4. * M_PI);
 
    // LO contribution
    double b0 = Beta0((double) nf), g0 = Gamma0((double) nf);
    double mLO = m * pow(af / ai, g0 / (2. * b0));
    if (order == LO)
        return mLO;
 
    // NLO contribution
    double b1 = Beta1((double) nf), g1 = Gamma1((double) nf);
    double A1 = g1 / (2. * b0) - b1 * g0 / (2. * b0 * b0);
    double mNLO = mLO * A1 * (af - ai);
    if (order == NLO)
        return mNLO;
    if (order == FULLNLO)
        return (mLO + mNLO);
 
    // NNLO contribution: Chetyrkin, hep-ph/9703278v1  eq. (15)
    double b2 = Beta2((double) nf), g2 = Gamma2((double) nf);
    double A2 = b1 * b1 * g0 / (2. * b0 * b0 * b0) - b2 * g0 / (2. * b0 * b0) - b1 * g1 / (2. * b0 * b0) + g2 / (2. * b0);
    double mNNLO = mLO * (A1 * A1 / 2. * (af - ai) * (af - ai) + A2 / 2. * (af * af - ai * ai));
    if (order == NNLO)
        return mNNLO;
    if (order == FULLNNLO)
        return (mLO + mNLO + mNNLO);
 
    throw std::runtime_error(orderToString(order) + " is not implemented in QCD::MrunTMP()");
}

MS2DRqmass() [1/2]

const double QCD::MS2DRqmass

(

const double

MSbar

)

const

Converts a quark mass from the \(\overline{\mathrm{MS}}\) scheme to the \(\overline{\mathrm{DR}}\) scheme.

Parameters

[in]

MSbar

The \(\overline{\mathrm{MS}}\) mass \(m(m)\) in GeV

Returns

The \(\overline{\mathrm{DR}}\) mass \(m(m)\) in GeV

Definition at line 1720 of file QCD.cpp.

{
    return (MSbar / (1. + Als(MSbar, FULLNLO) / 4. / M_PI * CF));
}

MS2DRqmass() [2/2]

const double QCD::MS2DRqmass	(	const double	MSscale,
		const double	MSbar
	)		const

Converts a quark mass from the \(\overline{\mathrm{MS}}\) scheme to the \(\overline{\mathrm{DR}}\) scheme.

Parameters

[in]	MSscale	the scale at which the \(\overline{\mathrm{MS}}\) mass is defined
[in]	MSbar	the \(\overline{\mathrm{MS}}\) mass \(m(m)\) in GeV

Returns

the \(\overline{\mathrm{DR}}\) mass \(m(m)\) in GeV

Definition at line 1725 of file QCD.cpp.

{
    return (MSbar / (1. + Als(MSscale, FULLNLO) / 4. / M_PI * CF));
}

Nf()

const double QCD::Nf

(

const double

mu

)

const

The number of active flavour at scale \(\mu\).

Parameters

[in]

mu

a scale \(\mu\) in GeV

Returns

active N_f

Definition at line 571 of file QCD.cpp.

{
    int i;
    for (i = 1; i < 5; i++)
        if (mu >= Thresholds(i))
            return (7. - (double)i);
 
    QCDsuccess = false;
    std::cout << "Error in QCD::Nf(" << mu <<")! QCDsuccess set to false" << std::endl;
    return (0.);
}

NfThresholdCorrections()

const double QCD::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.

Parameters

[in]	mu	the matching scale
[in]	M	the running quark mass
[in]	als	value of \(\alpha_s(\mu)\) in the \(n_f\) flavour theory
[in]	nf	number of active flavour
[in]	order	order of the expansion in \(\alpha_s\)

Returns

Threshold correction (without the leading term equal to 1)

Definition at line 709 of file QCD.cpp.

{
    double lmM = 2. * log(mu / M), res = 0.;
    switch (order)
    {
    case FULLNNNLO:
        res += als * als * als / M_PI / M_PI / M_PI * (-564731. / 124416. + 82043. / 27648. * gslpp_special_functions::zeta(3) + 2191. / 576. * lmM + 511. / 576. * lmM * lmM + lmM * lmM * lmM / 216. + ((double)nf - 1.) * (2633. / 31104. - 281. / 1728. * lmM));
    case FULLNNLO:
        res += als * als / M_PI / M_PI * (-11. / 72. + 19. / 24. * lmM + lmM * lmM / 36.);
    case FULLNLO:
        res += als / M_PI * lmM / 6.;
    case LO:
        break;
    default:
        throw std::runtime_error("QCD::ThresholdCorrections(): order not implemented.");
    }
    return (res);
}

orderToString()

const std::string QCD::orderToString

(

const orders

order

)

const

Converts an object of the enum type "orders" to the corresponding string.

Parameters

[in]

order

an object of the enum type "orders"

Returns

the string of the given "order"

Definition at line 95 of file QCD.cpp.

{
    switch (order)
    {
    case LO:
        return "LO";
    case NLO:
        return "NLO";
    case FULLNLO:
        return "FULLNLO";
    case NNLO:
        return "NNLO";
    case FULLNNLO:
        return "FULLNNLO";
    case NNNLO:
        return "NNNLO";
    case FULLNNNLO:
        return "FULLNNNLO";
    default:
        throw std::runtime_error("QCD::orderToString(): order not implemented.");
    }
}

PostUpdate()

bool QCD::PostUpdate ( )

virtual

The post-update method for QCD.

This method runs all the procedures that are need to be executed after the model is successfully updated. This includes

• computing the decay constant \(F_{B_D}\) from \(F_{B_s}\)
• computing the bag parameters \(B_{B_d}\) from \(B_{B_s}\)
• computing the \(\overline{\rm MS}\) mass of the top quark at the \(\overline{\rm MS}\) mass, \(m_t^{\overline{\rm MS}}(m_t^{\overline{\rm MS}})\) and setting the scale at the same value.

  Returns

  a boolean that is true if the execution is successful

Implements Model.

Reimplemented in FlavourWilsonCoefficient, FlavourWilsonCoefficient_DF2, LoopMediators, RealWeakEFTCC, RealWeakEFTLFV, GeneralSUSY, GeorgiMachacek, LeftRightSymmetricModel, MFV, HiggsChiral, HiggsKigen, NPd6SILH, NPEpsilons, NPSMEFTd6, NPSMEFTd6General, NPSMEFTd6U2, NPSMEFTd6U2qU1le, NPSMEFTd6U3, NPZbbbar, NPZbbbarLinearized, pMSSM, StandardModel, SUSY, SUSYMassInsertion, THDM, and THDMW.

Definition at line 158 of file QCD.cpp.

{
    if (computeFBd)
        mesonsMap.at(QCD::B_D).setDecayconst(mesonsMap.at(QCD::B_S).getDecayconst() / mesonsMap.at(QCD::B_D).getFBsoFBd());
    if (computeFBp)
        mesonsMap.at(QCD::B_P).setDecayconst(mesonsMap.at(QCD::B_S).getDecayconst() / mesonsMap.at(QCD::B_P).getFBsoFBd()); /**** FOR NOW FB+ = FBd ****/
    if (computeBs && FlagCsi)
    {
        BParameterMap.at("BBs").setBpars(0, BParameterMap.at("BBs").getFBsSqrtBBs1() * BParameterMap.at("BBs").getFBsSqrtBBs1() / mesonsMap.at(QCD::B_S).getDecayconst() / mesonsMap.at(QCD::B_S).getDecayconst());
        BParameterMap.at("BBs").setBpars(1, BParameterMap.at("BBs").getFBsSqrtBBs2() * BParameterMap.at("BBs").getFBsSqrtBBs2() / mesonsMap.at(QCD::B_S).getDecayconst() / mesonsMap.at(QCD::B_S).getDecayconst());
        BParameterMap.at("BBs").setBpars(2, BParameterMap.at("BBs").getFBsSqrtBBs3() * BParameterMap.at("BBs").getFBsSqrtBBs3() / mesonsMap.at(QCD::B_S).getDecayconst() / mesonsMap.at(QCD::B_S).getDecayconst());
        BParameterMap.at("BBs").setBpars(3, BParameterMap.at("BBs").getFBsSqrtBBs4() * BParameterMap.at("BBs").getFBsSqrtBBs4() / mesonsMap.at(QCD::B_S).getDecayconst() / mesonsMap.at(QCD::B_S).getDecayconst());
        BParameterMap.at("BBs").setBpars(4, BParameterMap.at("BBs").getFBsSqrtBBs5() * BParameterMap.at("BBs").getFBsSqrtBBs5() / mesonsMap.at(QCD::B_S).getDecayconst() / mesonsMap.at(QCD::B_S).getDecayconst());
    }
    if (computeBd)
    {
        if (FlagCsi)
        {
            BParameterMap.at("BBd").setBpars(0, mesonsMap.at(QCD::B_D).getFBsoFBd() * mesonsMap.at(QCD::B_D).getFBsoFBd() * BParameterMap.at("BBs").getBpars()(0) / BParameterMap.at("BBd").getcsi() / BParameterMap.at("BBd").getcsi());
            BParameterMap.at("BBd").setBBsoBBd(BParameterMap.at("BBs").getBpars()(0) / BParameterMap.at("BBd").getBpars()(0));
            BParameterMap.at("BBd").setBpars(1, BParameterMap.at("BBd").getFBdSqrtBBd2() * BParameterMap.at("BBd").getFBdSqrtBBd2() / mesonsMap.at(QCD::B_D).getDecayconst() / mesonsMap.at(QCD::B_D).getDecayconst());
            BParameterMap.at("BBd").setBpars(2, BParameterMap.at("BBd").getFBdSqrtBBd3() * BParameterMap.at("BBd").getFBdSqrtBBd3() / mesonsMap.at(QCD::B_D).getDecayconst() / mesonsMap.at(QCD::B_D).getDecayconst());
            BParameterMap.at("BBd").setBpars(3, BParameterMap.at("BBd").getFBdSqrtBBd4() * BParameterMap.at("BBd").getFBdSqrtBBd4() / mesonsMap.at(QCD::B_D).getDecayconst() / mesonsMap.at(QCD::B_D).getDecayconst());
            BParameterMap.at("BBd").setBpars(4, BParameterMap.at("BBd").getFBdSqrtBBd5() * BParameterMap.at("BBd").getFBdSqrtBBd5() / mesonsMap.at(QCD::B_D).getDecayconst() / mesonsMap.at(QCD::B_D).getDecayconst());
        }
        else
            BParameterMap.at("BBd").setBpars(0, BParameterMap.at("BBs").getBpars()(0) / BParameterMap.at("BBd").getBBsoBBd());
    }
    if (computemt)
    {
        if(FlagMtPole){
            quarks[TOP].setMass(163.); //Cannot use MSbar mass for Alphas thresholds since it is not yet updated
            quarks[TOP].setMass(Mp2Mbar(mtpole, TOP, FULLNNLO));
            quarks[TOP].setMass_scale(quarks[TOP].getMass());
        }
        else
            mtpole = Mbar2Mp(quarks[TOP].getMass(), TOP, FULLNNLO);
   }
    return (QCDsuccess);
}

PreUpdate()

bool QCD::PreUpdate ( )

virtual

The pre-update method for QCD.

This method resets the internal flags requireYu, requireYd, computeBd, computeFBd and computemt before updating the model parameters with the method Update().

Returns

a boolean that is true if the execution is successful

Implements Model.

Reimplemented in FlavourWilsonCoefficient, LoopMediators, RealWeakEFTCC, RealWeakEFTLFV, GeneralSUSY, GeorgiMachacek, LeftRightSymmetricModel, MFV, NPSMEFTd6General, pMSSM, StandardModel, SUSY, SUSYMassInsertion, THDM, and THDMW.

Definition at line 130 of file QCD.cpp.

{
    computemt = false;
    return (true);
}

setComputemt()

void QCD::setComputemt ( bool  computemt )

inline

A set method to change the value of computemt.

Parameters

[in]

computemt

the new value for computemt

Definition at line 988 of file QCD.h.

    {
        this->computemt = computemt;
    }

setFlag()

bool QCD::setFlag ( const std::string  name, const bool  value  )

virtual

A method to set a flag of QCD.

Parameters

[in]	name	name of a model flag
[in]	value	the boolean to be assigned to the flag specified by name

Returns

a boolean that is true if the execution is successful

Implements Model.

Reimplemented in FlavourWilsonCoefficient, LoopMediators, RealWeakEFTCC, RealWeakEFTLFV, HiggsChiral, HiggsKigen, NPbase, NPd6SILH, NPEpsilons, NPSMEFTd6, NPSMEFTd6General, StandardModel, THDM, GeorgiMachacek, LeftRightSymmetricModel, NPSMEFT6dtopquark, and SUSY.

Definition at line 479 of file QCD.cpp.

{
    bool res = false;
    if (name.compare("FlagCsi") == 0)
    {
        FlagCsi = value;
        if (computeBs)
            BParameterMap.at("BBs").setFlagCsi(FlagCsi);
        if (computeBd)
            BParameterMap.at("BBd").setFlagCsi(FlagCsi);
        res = true;
    }
    else if (name.compare("FlagMtPole") == 0)
    {
        FlagMtPole = value;
        if (FlagMtPole) {
            ModelParamMap.at("mtop")=std::cref(mtpole);
            std::cout << "WARNING: use of pole top mass as input is now deprecated. This feature will be removed in future releases. " << std::endl;
            std::cout << "Using anyway the pole mass as requested." << std::endl;
        }
        else
            ModelParamMap.at("mtop")=std::cref(quarks[TOP].getMass());
        res = true;
    }
    else if (name.compare("FlagMpole2MbarNumeric") == 0)
    {
        FlagMpole2MbarNumeric = value;
        res = true;
    }
    return res;
}

setFlagStr()

bool QCD::setFlagStr ( const std::string  name, const std::string  value  )

virtual

A method to set a flag of QCD.

Parameters

[in]	name	name of a model flag
[in]	value	the string to be assigned to the flag specified by name

Returns

a boolean that is true if the execution is successful

Implements Model.

Reimplemented in LeftRightSymmetricModel, NPSMEFTd6General, StandardModel, THDM, and THDMW.

Definition at line 511 of file QCD.cpp.

{
    std::cout << "WARNING: wrong name or value for ModelFlag " << name << std::endl;
    return (false);
}

setMtpole()

void QCD::setMtpole ( double  mtpole_in )

inline

A method to set the pole mass of the top quark.

Returns

the pole mass of the top quark \(m_t^{pole}\)

Definition at line 609 of file QCD.h.

    {
        mtpole = mtpole_in;
    }

setNc()

void QCD::setNc ( double  Nc )

inline

A set method to change the number of colours \(N_c\).

Parameters

[in]

Nc

the number of colours

Definition at line 516 of file QCD.h.

    {
        this->Nc = Nc;
    }

setOptionalParameter()

void QCD::setOptionalParameter ( std::string  name, double  value  )

inline

A method to set the parameter value for the parameters that are specific to only one set of observables.

Parameters

[in]	name	the name of the parameter
[in]	value	the value of the parameter

Definition at line 460 of file QCD.h.

    {
        optionalParameters[name] = value;
    }

setParameter()

void QCD::setParameter ( const std::string  name, const double &  value  )

protectedvirtual

A method to set the value of a parameter of QCD.

Parameters

[in]	name	name of a model parameter
[in]	value	the value to be assigned to the parameter specified by name

Implements Model.

Reimplemented in NPDF2, HiggsChiral, HiggsKigen, NPd6SILH, NPEpsilons, NPEpsilons_pureNP, NPHiggs, NPSMEFT6dtopquark, NPSMEFTd6, NPSMEFTd6General, NPSMEFTd6U2, NPSMEFTd6U2qU1le, NPSMEFTd6U3, NPSTU, NPSTUVWXY, NPSTUZbbbarLR, NPZbbbar, NPZbbbarLinearized, SigmaBR, StandardModel, SUSY, THDM, CMFV, FlavourWilsonCoefficient, FlavourWilsonCoefficient_DF2, GeneralSUSY, GeorgiMachacek, LeftRightSymmetricModel, MFV, pMSSM, SUSYMassInsertion, and THDMW.

Definition at line 343 of file QCD.cpp.

{
    int notABparameter = 0;
    int notAMesonParameter = 0;
 
    if (name.compare("AlsM") == 0)
    {
        AlsM = value;
        computemt = true;
    }
    else if (name.compare("MAls") == 0)
    {
        MAls = value;
        computemt = true;
    }
    else if (name.compare("mup") == 0)
    {
        if (value < MEPS)
            UpdateError = true;
        quarks[UP].setMass(value);
    }
    else if (name.compare("mdown") == 0)
    {
        if (value < MEPS)
            UpdateError = true;
        quarks[DOWN].setMass(value);
    }
    else if (name.compare("mcharm") == 0)
    {
        quarks[CHARM].setMass(value);
        quarks[CHARM].setMass_scale(value);
    }
    else if (name.compare("mstrange") == 0)
    {
        if (value < MEPS)
            UpdateError = true;
        quarks[STRANGE].setMass(value);
    }
    else if (name.compare("mtop") == 0)
    {
        if (FlagMtPole)
            mtpole = value;
        else
        {
            quarks[TOP].setMass(value);
            quarks[TOP].setMass_scale(value);
        }
        computemt = true;
    }
    else if (name.compare("mbottom") == 0)
    {
        quarks[BOTTOM].setMass(value);
        quarks[BOTTOM].setMass_scale(value);
    }
    else if (name.compare("muc") == 0)
        muc = value;
    else if (name.compare("mub") == 0)
        mub = value;
    else if (name.compare("mut") == 0)
        mut = value;
    else if (optionalParameters.find(name) != optionalParameters.end())
        setOptionalParameter(name, value);
    else
    {
        if (!BParameterMap.empty())
            for (std::map<std::string, BParameter>::iterator it = BParameterMap.begin(); it != BParameterMap.end(); it++)
                if (it->second.setParameter(name, value))
                    notABparameter += 1;
        if (!mesonsMap.empty())
            for (std::map<const QCD::meson, Meson>::iterator it = mesonsMap.begin(); it != mesonsMap.end(); it++)
                if (it->second.setParameter(name, value))
                    notAMesonParameter += 1;
        if (unknownParameterWarning && !isSliced && notABparameter == 0 && notAMesonParameter == 0)
            if (std::find(unknownParameters.begin(), unknownParameters.end(), name) == unknownParameters.end())
                unknownParameters.push_back(name);
    }
}

setQuarkMass()

void QCD::setQuarkMass ( const quark  q, const double  mass  )

inline

A set method to change the mass of a quark.

Parameters

[in]	q	the quark for which the mass is being set
[in]	mass	the mass of the quark in GeV

Definition at line 546 of file QCD.h.

    {
        quarks[q].setMass(mass);
    }

threCorrForMass()

const double QCD::threCorrForMass ( const double  nf_f, const double  nf_i  ) const

private

The threshold correction for running of a mass when crossing a flavour threshold.

Parameters

[in]	nf_f	the number of flavours \(n_f\) after crossing the threshold
[in]	nf_i	the number of flavours \(n_i\) before crossing the threshold

Returns

the threshold correction factor

Definition at line 1286 of file QCD.cpp.

{
    if (fabs(nf_f - nf_i) != 1.)
    {
        QCDsuccess = false;
        std::cout << "Error in QCD::threCorrForMass()! QCDsuccess set to false" << std::endl;
        return 0.;
    }
 
    // hep-ph/9712201v2 eq. (48)
    double mu_threshold, mf, log_mu2_mf2, AlsoverPi;
    if (nf_f > nf_i)
    {
        if (nf_f == 6.)
        {
            mu_threshold = mut;
            mf = quarks[TOP].getMass(); // m_t(m_t)
        }
        else if (nf_f == 5.)
        {
            mu_threshold = mub;
            mf = quarks[BOTTOM].getMass(); // m_b(m_b)
        }
        else if (nf_f == 4.)
        {
            mu_threshold = muc;
            mf = quarks[CHARM].getMass(); // m_c(m_c)
        }
        else
        {
            QCDsuccess = false;
            std::cout << "Error in QCD::threCorrForMass()! QCDsuccess set to false" << std::endl;
            return 0.;
        }
        log_mu2_mf2 = 2. * log(mu_threshold / mf);
        AlsoverPi = Als(mu_threshold - MEPS, FULLNNLO) / M_PI;
        return (1. + AlsoverPi * AlsoverPi * (-log_mu2_mf2 * log_mu2_mf2 / 12. + 5. / 36. * log_mu2_mf2 - 89. / 432.));
    }
    else
    {
        if (nf_i == 6.)
        {
            mu_threshold = mut;
            mf = quarks[TOP].getMass(); // m_t(m_t)
        }
        else if (nf_i == 5.)
        {
            mu_threshold = mub;
            mf = quarks[BOTTOM].getMass(); // m_b(m_b)
        }
        else if (nf_i == 4.)
        {
            mu_threshold = muc;
            mf = quarks[CHARM].getMass(); // m_c(m_c)
        }
        else
        {
            QCDsuccess = false;
            std::cout << "Error in QCD::threCorrForMass()! QCDsuccess set to false" << std::endl;
            return 0.;
        }
        log_mu2_mf2 = 2. * log(mu_threshold / mf);
        AlsoverPi = Als(mu_threshold + MEPS, FULLNNLO) / M_PI;
        return (1. + AlsoverPi * AlsoverPi * (log_mu2_mf2 * log_mu2_mf2 / 12. - 5. / 36. * log_mu2_mf2 + 89. / 432.));
    }
}

Thresholds()

const double QCD::Thresholds

(

const int

i

)

const

For accessing the active flavour threshold scales.

Parameters

[in]

i

the index referring to active flavour thresholds.

Returns

the threshold scale: 1.0E10 (i = 0), \(\mu_t\) (i = 1), \(\mu_b\) (i = 2), \(\mu_c\) (i = 3) and 0. (default)

Definition at line 524 of file QCD.cpp.

{
    if (!(mut > mub && mub > muc))
    {
        QCDsuccess = false;
        std::cout << "inverted thresholds in QCD::Thresholds()! QCDsuccess set to false" << std::endl;
    }
 
    switch (i)
    {
    case 0:
        return (1.0E10);
    case 1:
        return (mut);
    case 2:
        return (mub);
    case 3:
        return (muc);
    default:
        return (0.);
    }
}

Update()

bool QCD::Update ( const std::map< std::string, double > &  DPars )

virtual

The update method for QCD.

This method updates all the model parameters with given DPars.

Parameters

[in]

DPars

a map of the parameters that are being updated in the Monte Carlo run (including parameters that are varied and those that are held constant)

Returns

a boolean that is true if the execution is successful

Implements Model.

Reimplemented in FlavourWilsonCoefficient, LoopMediators, RealWeakEFTCC, RealWeakEFTLFV, GeneralSUSY, GeorgiMachacek, LeftRightSymmetricModel, MFV, NPbase, pMSSM, StandardModel, SUSY, SUSYMassInsertion, THDM, and THDMW.

Definition at line 136 of file QCD.cpp.

{
    QCDsuccess = true;
    if (!PreUpdate())
        return (false);
 
    UpdateError = false;
 
    for (std::map<std::string, double>::const_iterator it = DPars.begin(); it != DPars.end(); it++)
    {
        setParameter(it->first, it->second);
    }
 
    if (UpdateError || !QCDsuccess)
        return (false);
 
    if (!PostUpdate() || !QCDsuccess)
        return (false);
 
    return (true);
}

ZeroNf3NLO()

const double QCD::ZeroNf3NLO ( double *  logLambda3, double *  logLambda4_in  ) const

private

A member for calculating the difference in \(\alpha_s^{\mathrm{FULLNLO}}\) across the three-four flavour threshold using AlsWithLambda().

Parameters

[in]	logLambda3	\(\log(\Lambda_{\rm QCD}^{(3)})\)
[in]	logLambda4_in	\(\log(\Lambda_{\rm QCD}^{(4)})\)

Returns

the difference \(\alpha_s^{\mathrm{FULLNLO}}(\mu_c-\epsilon)\) - \(\alpha_s^{\mathrm{FULLNLO}}(\mu_c+\epsilon)\) with \(\epsilon = 10^{-10}\)

Definition at line 1062 of file QCD.cpp.

{
    return (AlsWithLambda(muc - 1.e-10, *logLambda3, FULLNLO) - AlsWithLambda(muc + 1.e-10, *logLambda4_in, FULLNLO));
}

ZeroNf4NLO()

const double QCD::ZeroNf4NLO ( double *  logLambda4, double *  logLambda5_in  ) const

private

A member for calculating the difference in \(\alpha_s^{\mathrm{FULLNLO}}\) across the four-five flavour threshold using AlsWithLambda().

Parameters

[in]	logLambda4	\(\log(\Lambda_{\rm QCD}^{(4)})\)
[in]	logLambda5_in	\(\log(\Lambda_{\rm QCD}^{(5)})\)

Returns

the difference \(\alpha_s^{\mathrm{FULLNLO}}(\mu_b-\epsilon)\) - \(\alpha_s^{\mathrm{FULLNLO}}(\mu_b+\epsilon)\) with \(\epsilon = 10^{-10}\)

Definition at line 1057 of file QCD.cpp.

{
    return (AlsWithLambda(mub - 1.e-10, *logLambda4, FULLNLO) - AlsWithLambda(mub + 1.e-10, *logLambda5_in, FULLNLO));
}

ZeroNf5()

const double QCD::ZeroNf5 ( double *  logLambda5, double *  order  ) const

private

A member for calculating the difference in \(\alpha_s\) using AlsWithLambda() and the input value of \(\alpha_s(M_{\alpha_s})\) given as a model parameter.

Parameters

[in]	logLambda5	\(\log(\Lambda_{\rm QCD}^{(5)})\)
[in]	order	the QCD order of the calculation

Returns

AlsWithLambda( \(M_{\alpha_s}\), *logLambda5, *order) - \(\alpha_s(M_{\alpha_s})\)

Definition at line 1052 of file QCD.cpp.

{
    return (AlsWithLambda(MAls, *logLambda5, (orders)*order) - AlsM);
}

ZeroNf6NLO()

const double QCD::ZeroNf6NLO ( double *  logLambda6, double *  logLambda5_in  ) const

private

A member for calculating the difference in \(\alpha_s^{\mathrm{FULLNLO}}\) across the six-five flavour threshold using AlsWithLambda().

Parameters

[in]	logLambda6	\(\log(\Lambda_{\rm QCD}^{(6)})\)
[in]	logLambda5_in	\(\log(\Lambda_{\rm QCD}^{(5)})\)

Returns

the difference \(\alpha_s^{\mathrm{FULLNLO}}(\mu_t+\epsilon)\) - \(\alpha_s^{\mathrm{FULLNLO}}(\mu_t-\epsilon)\) with \(\epsilon = 10^{-10}\)

Definition at line 1047 of file QCD.cpp.

{
    return (AlsWithLambda(mut + 1.e-10, *logLambda6, FULLNLO) - AlsWithLambda(mut - 1.e-10, *logLambda5_in, FULLNLO));
}

Member Data Documentation

als_cache

double QCD::als_cache[9][CacheSize]

mutableprivate

Cache for \(\alpha_s\).

Definition at line 1039 of file QCD.h.

AlsM

double QCD::AlsM

protected

The strong coupling constant at the mass scale MAls, \(\alpha_s(M_{\alpha_s})\).

Definition at line 1018 of file QCD.h.

BParameterMap

std::map<std::string, BParameter> QCD::BParameterMap

mutableprivate

Definition at line 1030 of file QCD.h.

CA

double QCD::CA

protected

Definition at line 1026 of file QCD.h.

CacheSize

const int QCD::CacheSize = 5

staticprivate

Defines the depth of the cache.

Definition at line 1038 of file QCD.h.

CF

double QCD::CF

protected

Definition at line 1026 of file QCD.h.

computeBd

bool QCD::computeBd

mutableprivate

Switch for computing \(B_{B_d}\) from \(B_{B_s}\).

Definition at line 1036 of file QCD.h.

computeBs

bool QCD::computeBs

mutableprivate

Switch for computing \(B_{B_s}\) from \(F_{B_s}\sqrt{B_{B_s}}\).

Definition at line 1037 of file QCD.h.

computeFBd

bool QCD::computeFBd

mutableprivate

Switch for computing \(F_{B_d}\) from \(F_{B_s}\).

Definition at line 1034 of file QCD.h.

computeFBp

bool QCD::computeFBp

mutableprivate

Switch for computing \(F_{B^+}\) from \(F_{B_s}\).

Definition at line 1035 of file QCD.h.

computemt

bool QCD::computemt

protected

Switch for computing the \(\overline{\mathrm{MS}}\) mass of the top quark.

Definition at line 1011 of file QCD.h.

dAdA_NA

double QCD::dAdA_NA

protected

Definition at line 1026 of file QCD.h.

dFdA_NA

double QCD::dFdA_NA

protected

Definition at line 1026 of file QCD.h.

dFdF_NA

double QCD::dFdF_NA

protected

Definition at line 1026 of file QCD.h.

FlagCsi

bool QCD::FlagCsi

private

A flag to determine whether \(B_{B_s}\) and \(B_{B_s}/B_{B_d}\) or \(F_{B_s}\sqrt{B_{B_s}}\) (false) and \(\xi \equiv F_{B_s}\sqrt{B_{B_s}}/(F_{B_d}\sqrt{B_{B_d}})\) (default, true) are used as inputs.

Definition at line 1048 of file QCD.h.

FlagMpole2MbarNumeric

bool QCD::FlagMpole2MbarNumeric

protected

A flag to determine whether the pole mass to \(\over \mathrm{MS}\) mass conversion is done numerically.

Definition at line 1015 of file QCD.h.

FlagMtPole

bool QCD::FlagMtPole

protected

A flag to determine whether the pole mass of the top quark is used as input.

Definition at line 1014 of file QCD.h.

logLambda5_cache

double QCD::logLambda5_cache[4][CacheSize]

mutableprivate

Definition at line 1040 of file QCD.h.

logLambdaNLO_cache

double QCD::logLambdaNLO_cache[9][CacheSize]

mutableprivate

Definition at line 1041 of file QCD.h.

MAls

double QCD::MAls

protected

The mass scale in GeV at which the strong coupling measurement is provided.

Definition at line 1019 of file QCD.h.

mesonsMap

std::map<const QCD::meson, Meson> QCD::mesonsMap

mutableprivate

The map of defined mesons.

Definition at line 1047 of file QCD.h.

mp2mbar_cache

double QCD::mp2mbar_cache[6][CacheSize]

mutableprivate

Cache for pole mass to msbar mass conversion.

Definition at line 1043 of file QCD.h.

mrun_cache

double QCD::mrun_cache[11][CacheSize]

mutableprivate

Cache for running quark mass.

Definition at line 1042 of file QCD.h.

mtpole

double QCD::mtpole

protected

The pole mass of the top quark.

Definition at line 1020 of file QCD.h.

mub

double QCD::mub

protected

The threshold between five- and four-flavour theory in GeV.

Definition at line 1022 of file QCD.h.

muc

double QCD::muc

protected

The threshold between four- and three-flavour theory in GeV.

Definition at line 1023 of file QCD.h.

mut

double QCD::mut

protected

The threshold between six- and five-flavour theory in GeV.

Definition at line 1021 of file QCD.h.

NA

double QCD::NA

protected

Definition at line 1026 of file QCD.h.

Nc

double QCD::Nc

protected

The number of colours.

Definition at line 1025 of file QCD.h.

NQCDvars

const int QCD::NQCDvars = 11

static

The number of model parameters in QCD.

Definition at line 359 of file QCD.h.

optionalParameters

std::map<std::string, double> QCD::optionalParameters

private

A map for containing the list and values of the parameters that are used only by a specific set of observables.

Definition at line 1045 of file QCD.h.

QCDsuccess

bool QCD::QCDsuccess =true

mutableprotected

Definition at line 995 of file QCD.h.

QCDvars

std::string QCD::QCDvars

static

Initial value:

= {
    "AlsM", "MAls",
    "mup", "mdown", "mcharm", "mstrange", "mtop", "mbottom",
    "muc", "mub", "mut"}

An array containing the labels under which all QCD parameters are stored in a vector of ModelParameter via InputParser::ReadParameters().

Definition at line 365 of file QCD.h.

quarks

Particle QCD::quarks[6]

protected

The vector of all SM quarks.

Definition at line 1027 of file QCD.h.

realorder

orders QCD::realorder

mutableprivate

Definition at line 1049 of file QCD.h.

requireYd

bool QCD::requireYd

protected

Switch for generating the Yukawa couplings to the down-type quarks.

Definition at line 1013 of file QCD.h.

requireYu

bool QCD::requireYu

protected

Switch for generating the Yukawa couplings to the up-type quarks.

Definition at line 1012 of file QCD.h.

TF

double QCD::TF

protected

Definition at line 1026 of file QCD.h.

unknownParameters

std::vector<std::string> QCD::unknownParameters

private

A vector for containing the names of the parameters that are not being used but specified in the configuration file.

Definition at line 1046 of file QCD.h.

unknownParameterWarning

bool QCD::unknownParameterWarning

private

A flag to stop the unknown parameter warning after the first time.

Definition at line 1044 of file QCD.h.

zeta2

double QCD::zeta2

private

\(\zeta(2)\) computed with the GSL.

Definition at line 1032 of file QCD.h.

zeta3

double QCD::zeta3

private

\(\zeta(3)\) computed with the GSL.

Definition at line 1033 of file QCD.h.

---

The documentation for this class was generated from the following files:

• QCD.h
• QCD.cpp