gambit is hosted by Hepforge, IPPP Durham
GAMBIT  v1.5.0-2191-ga4742ac
a Global And Modular Bsm Inference Tool
Gambit::PrecisionBit Namespace Reference

Functions

void FH_PrecisionObs (fh_PrecisionObs &result)
 
void update_W_masses (SubSpectrum &HE, SubSpectrum &LE, const triplet< double > &prec_mw, bool allow_fallback)
 Helper function to set W masses. More...
 
void update_H_masses (SubSpectrum &HE, int n_higgs, const str *higgses, int central, int error, std::vector< triplet< double > > &MH, bool allow_fallback)
 Helper function to set arbitrary number of H masses. More...
 
void make_MSSM_precision_spectrum_none (Spectrum &improved_spec)
 Precision MSSM spectrum manufacturer that does nothing but relabel the unimproved spectrum. More...
 
void make_MSSM_precision_spectrum_W (Spectrum &improved_spec)
 Precision MSSM spectrum manufacturer with precision W mass only. More...
 
void make_MSSM_precision_spectrum_H (Spectrum &improved_spec)
 Precision MSSM spectrum manufacturer with precision SM-like Higgs mass. More...
 
void make_MSSM_precision_spectrum_H_W (Spectrum &improved_spec)
 Precision MSSM spectrum manufacturer with precision W and SM-like Higgs masses. More...
 
void make_MSSM_precision_spectrum_4H_W (Spectrum &improved_spec)
 Precision MSSM spectrum manufacturer with precision W and 2HDM (4x) Higgs masses. More...
 
void lnL_Z_mass (double &result)
 Z boson mass likelihood M_Z (Breit-Wigner mass parameter ~ pole) = 91.1876 +/- 0.0021 GeV (1 sigma), Gaussian. More...
 
void lnL_t_mass (double &result)
 t quark mass likelihood m_t (pole) = 173.34 +/- 0.76 GeV (1 sigma), Gaussian. More...
 
void lnL_mbmb (double &result)
 b quark mass likelihood m_b (mb)^MSbar = 4.18 +/- 0.03 GeV (1 sigma), Gaussian. More...
 
void lnL_mcmc (double &result)
 c quark mass likelihood m_c (mc)^MSbar = 1.28 +/- 0.03 GeV (1 sigma), Gaussian. More...
 
void lnL_light_quark_masses (double &result)
 Likelihoods for light quark mass ratios. More...
 
void lnL_alpha_em (double &result)
 alpha^{-1}(mZ)^MSbar likelihood alpha^{-1}(mZ)^MSbar = 127.950 +/- 0.017 (1 sigma), Gaussian. More...
 
void lnL_alpha_s (double &result)
 alpha_s(mZ)^MSbar likelihood alpha_s(mZ)^MSbar = 0.1181 +/- 0.0011 (1 sigma), Gaussian. More...
 
void lnL_GF (double &result)
 G_Fermi likelihood G_Fermi = (1.1663787 +/- 0.0000006) * 10^-5 GeV^-2 (1 sigma), Gaussian. More...
 
void lnL_W_mass (double &result)
 W boson mass likelihood. More...
 
void lnL_h_mass (double &result)
 Simple, naive h boson mass likelihood Reference: D. More...
 
void lnL_sinW2_eff (double &result)
 Effective leptonic sin^2(theta_W) likelihood sin^2theta_W^leptonic_effective~ sin^2theta_W(mZ)^MSbar + 0.00029 = 0.23155 +/- 0.00005 (1 sigma), Gaussian. More...
 
void lnL_deltarho (double &result)
 Delta rho likelihood Delta rho = 0.00037 +/- 0.00023 (1 sigma), Gaussian. More...
 
void gm2_SM_ee (triplet< double > &result)
 g-2 in SM from e+e- data More...
 
void gm2_SM_tautau (triplet< double > &result)
 g-2 in SM from tau+tau- data More...
 
void lnL_gm2 (double &result)
 g-2 likelihood More...
 
void GM2C_SUSY (triplet< double > &result)
 Calculate a_mu_SUSY using the gm2calc backend. More...
 
void SI_muon_gm2 (triplet< double > &result)
 Calculation of g-2 with SuperIso. More...
 
void SP_PrecisionObs (double &result)
 Precision observables from SUSY-POPE This function is unfinished because SUSY-POPE is buggy. More...
 
void RHN_sinW2_eff (triplet< double > &result)
 
void RHN_mw (triplet< double > &result)
 
void lnL_neutron_lifetime_beam_Yue (double &result)
 Beam method: Phys. Rev. Lett. 111, 222501 (2013) https://arxiv.org/abs/1309.2623. More...
 
void lnL_neutron_lifetime_bottle_PDG19 (double &result)
 Bottle method: average recommended by PDG 2019 http://pdg.lbl.gov/2019/listings/rpp2019-list-n.pdf. More...
 
void FH_precision_edm_e (double &result)
 FeynHiggs precision extractors. More...
 
void FH_precision_edm_n (double &result)
 
void FH_precision_edm_hg (double &result)
 
void FH_precision_gm2 (triplet< double > &result)
 
void FH_precision_deltarho (triplet< double > &result)
 
void FH_precision_mw (triplet< double > &result)
 
void FH_precision_sinW2 (triplet< double > &result)
 
void mw_from_SM_spectrum (triplet< double > &result)
 Basic mass extractors for different types of spectra, for use with precision likelihoods and other things not needing a whole spectrum object. More...
 
void mw_from_ScalarSingletDM_Z2_spectrum (triplet< double > &result)
 
void mw_from_ScalarSingletDM_Z3_spectrum (triplet< double > &result)
 
void mw_from_VectorSingletDM_Z2_spectrum (triplet< double > &result)
 
void mw_from_MajoranaSingletDM_Z2_spectrum (triplet< double > &result)
 
void mw_from_DiracSingletDM_Z2_spectrum (triplet< double > &result)
 
void mw_from_MSSM_spectrum (triplet< double > &result)
 
void mh_from_SM_spectrum (triplet< double > &result)
 
void mh_from_ScalarSingletDM_Z2_spectrum (triplet< double > &result)
 
void mh_from_ScalarSingletDM_Z3_spectrum (triplet< double > &result)
 
void mh_from_MSSM_spectrum (triplet< double > &result)
 

Function Documentation

◆ FH_precision_deltarho()

void Gambit::PrecisionBit::FH_precision_deltarho ( triplet< double > &  result)

Definition at line 161 of file PrecisionBit.cpp.

References abserr_mw, abserr_sinW2eff, Gambit::triplet< TYPE >::central, FH_Precision, Gambit::triplet< TYPE >::lower, mw, and Gambit::triplet< TYPE >::upper.

Referenced by main().

162  {
164  double sintw2eff = Pipes::FH_precision_sinW2::Dep::FH_Precision->sinW2_MSSM;
165  result.central = Pipes::FH_precision_deltarho::Dep::FH_Precision->deltaRho;
166  //Follows approximately from tree level relations, where delta{M_W, sintthetaW^2} go as deltarho
167  result.upper = std::max(abserr_mw/mw, abserr_sinW2eff/sintw2eff);
168  result.lower = result.upper;
169  }
Spectrum Spectrum Spectrum mw
fh_Couplings libfeynhiggs FH_Precision
const double abserr_mw
EWPO theoretical uncertainties on FeynHiggs calculations; based on hep-ph/0412214 Eq 3...
const double abserr_sinW2eff
Here is the caller graph for this function:

◆ FH_precision_edm_e()

void Gambit::PrecisionBit::FH_precision_edm_e ( double result)

FeynHiggs precision extractors.

Definition at line 152 of file PrecisionBit.cpp.

References FH_Precision.

fh_Couplings libfeynhiggs FH_Precision

◆ FH_precision_edm_hg()

void Gambit::PrecisionBit::FH_precision_edm_hg ( double result)

Definition at line 154 of file PrecisionBit.cpp.

References FH_Precision.

fh_Couplings libfeynhiggs FH_Precision

◆ FH_precision_edm_n()

void Gambit::PrecisionBit::FH_precision_edm_n ( double result)

Definition at line 153 of file PrecisionBit.cpp.

References FH_Precision.

fh_Couplings libfeynhiggs FH_Precision

◆ FH_precision_gm2()

void Gambit::PrecisionBit::FH_precision_gm2 ( triplet< double > &  result)

Definition at line 155 of file PrecisionBit.cpp.

References Gambit::triplet< TYPE >::central, FH_Precision, Gambit::triplet< TYPE >::lower, and Gambit::triplet< TYPE >::upper.

156  {
157  result.central = Pipes::FH_precision_gm2::Dep::FH_Precision->gmu2;
158  result.upper = std::max(std::abs(result.central)*0.3, 6e-10); //Based on hep-ph/0609168v1 eqs 84 & 85
159  result.lower = result.upper;
160  }
fh_Couplings libfeynhiggs FH_Precision

◆ FH_precision_mw()

void Gambit::PrecisionBit::FH_precision_mw ( triplet< double > &  result)

Definition at line 170 of file PrecisionBit.cpp.

References abserr_mw, Gambit::triplet< TYPE >::central, FH_Precision, Gambit::triplet< TYPE >::lower, and Gambit::triplet< TYPE >::upper.

171  {
172  result.central = Pipes::FH_precision_mw::Dep::FH_Precision->MW_MSSM;
173  result.upper = abserr_mw;
174  result.lower = result.upper;
175  }
fh_Couplings libfeynhiggs FH_Precision
const double abserr_mw
EWPO theoretical uncertainties on FeynHiggs calculations; based on hep-ph/0412214 Eq 3...

◆ FH_precision_sinW2()

void Gambit::PrecisionBit::FH_precision_sinW2 ( triplet< double > &  result)

Definition at line 176 of file PrecisionBit.cpp.

References abserr_sinW2eff, Gambit::triplet< TYPE >::central, FH_Precision, Gambit::triplet< TYPE >::lower, and Gambit::triplet< TYPE >::upper.

Referenced by main().

177  {
178  result.central = Pipes::FH_precision_sinW2::Dep::FH_Precision->sinW2_MSSM;
179  result.upper = abserr_sinW2eff;
180  result.lower = result.upper;
181  }
fh_Couplings libfeynhiggs FH_Precision
const double abserr_sinW2eff
Here is the caller graph for this function:

◆ FH_PrecisionObs()

void Gambit::PrecisionBit::FH_PrecisionObs ( fh_PrecisionObs &  result)

Definition at line 65 of file PrecisionBit.cpp.

References abserr_mw, Gambit::LogTags::err, Gambit::invalid_point(), LOCAL_INFO, Gambit::mw_central_observed, Gambit::mw_err_observed, and Gambit::invalid_point_exception::raise().

Referenced by main().

66  {
67  using namespace Pipes::FH_PrecisionObs;
68 
69  fh_real gm2; // g_{mu}-2
70  fh_real Deltarho; // deltaRho
71  fh_real MWMSSM; // W pole mass in MSSM
72  fh_real MWSM; // W pole mass in SM
73  fh_real SW2MSSM; // sin^2theta_W^leptonic_effective in MSSM
74  fh_real SW2SM; // sin^2theta_W^leptonic_effective in SM
75  fh_real edmeTh; // electron EDM (experimental)
76  fh_real edmn; // neutron EDM (experimental)
77  fh_real edmHg; // mercury EDM (experimental)
78  int ccb; // model corresponds to charge or colour-breaking minimum (experimental)
79 
80  int error = 1;
81  BEreq::FHConstraints(error, gm2, Deltarho,
82  MWMSSM, MWSM, SW2MSSM, SW2SM,
83  edmeTh, edmn, edmHg, ccb);
84  if (error != 0)
85  {
86  std::ostringstream err;
87  err << "BEreq::FHConstraints raised error flag: " << error << ".";
88  invalid_point().raise(err.str());
89  }
90 
91  // Just scrub this point now if it's more than 7 sigma off in mW,
92  // as extreme values of mW can cause instability in other routines.
93  const double obserrsq = mw_err_observed*mw_err_observed;
94  const double theoryerrsq = abserr_mw*abserr_mw;
95  if (std::abs(mw_central_observed - MWMSSM) > 7.0*sqrt(obserrsq + theoryerrsq))
96  {
97  std::ostringstream err;
98  err << "W mass too extreme. More than 7 sigma off observed value. " << endl
99  << "Deviation from observed value: " << std::abs(mw_central_observed - MWMSSM) << "." << endl
100  << "1 sigma uncertainty on observed value: " << sqrt(obserrsq + theoryerrsq) << "." << endl
101  << "Invalidating immediately to prevent downstream instability.";
102  invalid_point().raise(err.str());
103  //PrecisionBit_error().raise(LOCAL_INFO, err.str());
104  }
105 
106  // Just scrub this point now if sinW2 is negative in the MSSM,
107  // as negative sinW2 can cause instability in other routines
108  // (and this point should be excluded because this is waaay off
109  // the observed value).
110  if (SW2MSSM <= 0.0)
111  {
112  std::ostringstream err;
113  err << "Sin^2 thetaW_effective is less than zero." << endl
114  << "Value computed by FeynHiggs: " << SW2MSSM << endl
115  << "Invalidating immediately to prevent downstream instability.";
116  invalid_point().raise(err.str());
117  //PrecisionBit_error().raise(LOCAL_INFO, err.str());
118  }
119 
120  #ifdef PRECISIONBIT_DEBUG
121  // Just die if any of the other observables look really suspicious.
122  str nans;
123  if (Utils::isnan(gm2)) nans += "g-2 | ";
124  if (Utils::isnan(Deltarho)) nans += "Delta rho | ";
125  if (Utils::isnan(MWMSSM)) nans += "MW in MSSM | ";
126  if (Utils::isnan(MWSM)) nans += "MW in SM | ";
127  if (Utils::isnan(SW2MSSM)) nans += "sin^2 thetaW_effective in MSSM | ";
128  if (Utils::isnan(SW2SM)) nans += "sin^2 thetaW_effective in SM | ";
129  if (Utils::isnan(edmeTh)) nans += "e EDM | ";
130  if (Utils::isnan(edmn)) nans += "n EDM | ";
131  if (Utils::isnan(edmHg)) nans += "Hg EDM | ";
132  if (not nans.empty()) PrecisionBit_error().raise(LOCAL_INFO, nans+"returned as NaN from FeynHiggs!");
133  #endif
134 
135  fh_PrecisionObs PrecisionObs;
136  PrecisionObs.gmu2 = gm2;
137  PrecisionObs.deltaRho = Deltarho;
138  PrecisionObs.MW_MSSM = MWMSSM;
139  PrecisionObs.MW_SM = MWSM;
140  PrecisionObs.sinW2_MSSM = SW2MSSM;
141  PrecisionObs.sinW2_SM = SW2SM;
142  PrecisionObs.edm_ele = edmeTh;
143  PrecisionObs.edm_neu = edmn;
144  PrecisionObs.edm_Hg = edmHg;
145  PrecisionObs.ccb = ccb;
146 
147  result = PrecisionObs;
148  }
const double mw_err_observed
#define LOCAL_INFO
Definition: local_info.hpp:34
virtual void raise(const std::string &)
Raise the exception, i.e. throw it. Exact override of base method.
Definition: exceptions.cpp:422
const double abserr_mw
EWPO theoretical uncertainties on FeynHiggs calculations; based on hep-ph/0412214 Eq 3...
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
invalid_point_exception & invalid_point()
Invalid point exceptions.
void FH_PrecisionObs(fh_PrecisionObs &result)
const double mw_central_observed
M_W (Breit-Wigner mass parameter ~ pole) = 80.385 +/- 0.015 GeV (1 sigma), Gaussian.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ gm2_SM_ee()

void Gambit::PrecisionBit::gm2_SM_ee ( triplet< double > &  result)

g-2 in SM from e+e- data

Values taken from prediction in arXiv:1010.4180 (Eq 22)

Definition at line 888 of file PrecisionBit.cpp.

References Gambit::triplet< TYPE >::central, Gambit::triplet< TYPE >::lower, and Gambit::triplet< TYPE >::upper.

889  {
891  result.central = 2.0 * 11659180.2e-10;
892  result.upper = 2.0 * 4.9e-10;
893  result.lower = result.upper;
894  }

◆ gm2_SM_tautau()

void Gambit::PrecisionBit::gm2_SM_tautau ( triplet< double > &  result)

g-2 in SM from tau+tau- data

Values taken from prediction in arXiv:1010.4180, based on tau data

Definition at line 897 of file PrecisionBit.cpp.

References Gambit::triplet< TYPE >::central, Gambit::triplet< TYPE >::lower, and Gambit::triplet< TYPE >::upper.

898  {
900  result.central = 2.0 * 11659189.4e-10;
901  result.upper = 2.0 * 5.4e-10;
902  result.lower = result.upper;
903  }

◆ GM2C_SUSY()

void Gambit::PrecisionBit::GM2C_SUSY ( triplet< double > &  result)

Calculate a_mu_SUSY using the gm2calc backend.

fill pole masses. note: that the indices start from 0 in gm2calc, gambit indices start from 1, hence the offsets here

alpha_MZ := alpha(0) (1 - ^{OS}(M_Z) ) where ^{OS}(M_Z) = quark and lepton contributions to

convert DR-bar parameters to on-shell

need to hook up errors properly check for problems

check for warnings

Definition at line 924 of file PrecisionBit.cpp.

References Gambit::alpha_e_OS_MZ, Gambit::alpha_e_OS_thomson_limit, Gambit::SMInputs::alphaS, Gambit::triplet< TYPE >::central, Gambit::Par::dimensionless, Gambit::LogTags::err, Gambit::slhahelp::family_state_mix_matrix(), Gambit::SubSpectrum::get(), Gambit::SubSpectrum::GetScale(), Gambit::invalid_point(), LOCAL_INFO, Gambit::triplet< TYPE >::lower, Gambit::Par::mass1, Gambit::Par::mass2, Gambit::SMInputs::mBmB, Gambit::SMInputs::mCmC, Gambit::SMInputs::mD, Gambit::SMInputs::mE, Gambit::SMInputs::mMu, Gambit::SMInputs::mS, MSSM_spectrum, Gambit::SMInputs::mT, Gambit::SMInputs::mTau, Gambit::SMInputs::mU, Gambit::SMInputs::mZ, Gambit::Par::Pole_Mass, Gambit::invalid_point_exception::raise(), and Gambit::triplet< TYPE >::upper.

Referenced by main().

925  {
926  using namespace Pipes::GM2C_SUSY;
927  const SubSpectrum& mssm = Dep::MSSM_spectrum->get_HE();
928 
929  gm2calc_default::gm2calc::MSSMNoFV_onshell model;
930 
931  try
932  {
936  model.get_physical().MSvmL = mssm.get(Par::Pole_Mass, "~nu", 2); // 1L
937  str msm1, msm2;
938  // PA: todo: I think we shouldn't be too sensitive to mixing in this case.
939  // If we get a successful convergence to the pole mass scheme in the end it's OK
940  const static double tol = runOptions->getValueOrDef<double>(1e-1, "family_mixing_tolerance");
941  const static bool pt_error = runOptions->getValueOrDef<bool>(true, "family_mixing_tolerance_invalidates_point_only");
942  slhahelp::family_state_mix_matrix("~e-", 2, msm1, msm2, mssm, tol, LOCAL_INFO, pt_error);
943  model.get_physical().MSm(0) = mssm.get(Par::Pole_Mass, msm1); // 1L
944  model.get_physical().MSm(1) = mssm.get(Par::Pole_Mass, msm2); // 1L
945 
946  model.get_physical().MChi(0) = mssm.get(Par::Pole_Mass, "~chi0", 1); // 1L
947  model.get_physical().MChi(1) = mssm.get(Par::Pole_Mass, "~chi0", 2); // 1L
948  model.get_physical().MChi(2) = mssm.get(Par::Pole_Mass, "~chi0", 3); // 1L
949  model.get_physical().MChi(3) = mssm.get(Par::Pole_Mass, "~chi0", 4); // 1L
950 
951  model.get_physical().MCha(0) = mssm.get(Par::Pole_Mass, "~chi+", 1); // 1L
952  model.get_physical().MCha(1) = mssm.get(Par::Pole_Mass, "~chi+", 2); // 1L
953  model.get_physical().MAh(1) = mssm.get(Par::Pole_Mass, "A0"); // 2L
954 
955  model.set_TB(mssm.get(Par::dimensionless,"tanbeta"));
956  model.set_Mu(mssm.get(Par::mass1, "Mu"));
957  model.set_MassB(mssm.get(Par::mass1, "M1"));
958  model.set_MassWB(mssm.get(Par::mass1, "M2"));
959  model.set_MassG(mssm.get(Par::mass1, "M3"));
960  for(int i = 1; i<=3; i++)
961  {
962  for(int j = 1; j<=3; j++)
963  {
964  model.set_mq2(i-1,j-1, mssm.get(Par::mass2, "mq2", i, j));
965  model.set_ml2(i-1,j-1, mssm.get(Par::mass2, "ml2", i, j));
966  model.set_md2(i-1,j-1, mssm.get(Par::mass2, "md2", i, j));
967  model.set_mu2(i-1,j-1, mssm.get(Par::mass2, "mu2", i, j));
968  model.set_me2(i-1,j-1, mssm.get(Par::mass2, "me2", i, j));
969  double Au = 0.0, Ad = 0.0, Ae = 0.0;
970  if(mssm.get(Par::dimensionless, "Yu", i, j) > 1e-14){
971  Au = mssm.get(Par::mass1, "TYu", i, j)
972  / mssm.get(Par::dimensionless, "Yu", i, j);
973  }
974  if(mssm.get(Par::dimensionless, "Ye", i, j) > 1e-14){
975  Ae = mssm.get(Par::mass1, "TYe", i, j)
976  / mssm.get(Par::dimensionless, "Ye", i, j);
977  }
978  if(mssm.get(Par::dimensionless, "Yd", i, j) > 1e-14){
979  Ad = mssm.get(Par::mass1, "TYd", i, j)
980  / mssm.get(Par::dimensionless, "Yd", i, j);
981  }
982 
983  model.set_Au(i-1, j-1, Au);
984  model.set_Ad(i-1, j-1, Ad);
985  model.set_Ae(i-1, j-1, Ae);
986  }
987  }
988 
989  const SMInputs& smin = Dep::MSSM_spectrum->get_SMInputs();
990 
991  model.get_physical().MVZ =smin.mZ;
992  model.get_physical().MFb =smin.mBmB;
993  model.get_physical().MFt =smin.mT;
994  model.get_physical().MFtau =smin.mTau;
995  model.get_physical().MVWm =mssm.get(Par::Pole_Mass, "W+"); //GAMBIT can get the pole mas but it may have been improved by FeynHiggs calcualtion
996  model.get_physical().MFm =smin.mMu;
997  //use SM alphaS(MZ) instead of MSSM g3(MSUSY) -- appears at two-loop so difference should be three-loop
998  // (it is used for correctuions to yb and DRbar --> MS bar conversion)
999  model.set_g3(std::sqrt(4*M_PI*smin.alphaS));
1000  // these are not currently used but may be in future updates so set them anyway
1001  model.get_physical().MFe =smin.mE;
1002  model.get_physical().MFd =smin.mD; //MSbar
1003  model.get_physical().MFs =smin.mS; //MSbar
1004  model.get_physical().MFu =smin.mU; //MSbar
1005  model.get_physical().MFc =smin.mCmC; // MSbar
1006 
1009  // on-shell renormalized photon vacuum polarization
1010  // default value recommended by GM2calc from arxiv:1105.3149
1011  const double alpha_MZ = runOptions->getValueOrDef
1012  <double>(alpha_e_OS_MZ, "GM2Calc_extra_alpha_e_MZ");
1013  const double alpha_thomson = runOptions->getValueOrDef
1014  <double>(alpha_e_OS_thomson_limit, "GM2Calc_extra_alpha_e_thomson_limit");
1015 
1016  if (alpha_MZ > std::numeric_limits<double>::epsilon())
1017  model.set_alpha_MZ(alpha_MZ);
1018 
1019  if (alpha_thomson > std::numeric_limits<double>::epsilon())
1020  model.set_alpha_thompson(alpha_thomson);
1021 
1022  model.set_scale(mssm.GetScale()); // 2L
1023 
1025  model.convert_to_onshell();
1026 
1029  if( model.get_problems().have_problem() == true) {
1030  std::ostringstream err;
1031  err << "gm2calc routine convert_to_onshell raised error: "
1032  << model.get_problems().get_problems() << ".";
1033  invalid_point().raise(err.str());
1034  }
1036  if( model.get_problems().have_warning() == true) {
1037  std::ostringstream err;
1038  err << "gm2calc routine convert_to_onshell raised warning: "
1039  << model.get_problems().get_warnings() << ".";
1040  // Maybe you would argue that we want to invalidate such points, but the DRbar-->OS
1041  // conversion seems to fail to converge extremely often for general weak-scale SUSY models.
1042  PrecisionBit_warning().raise(LOCAL_INFO, err.str());
1043  }
1044 
1045  }
1046  catch (const gm2calc_default::gm2calc::Error& e)
1047  {
1048  std::ostringstream err;
1049  err << "gm2calc routine convert_to_onshell raised error: "
1050  << e.what() << ".";
1051  invalid_point().raise(err.str());
1052  }
1053  catch (...)
1054  {
1055  std::ostringstream err;
1056  err << "gm2calc routine convert_to_onshell raised unspecified error.";
1057  invalid_point().raise(err.str());
1058  }
1059 
1060  const double error = BEreq::calculate_uncertainty_amu_2loop(model);
1061 
1062  const double amumssm = BEreq::calculate_amu_1loop(model)
1063  + BEreq::calculate_amu_2loop(model);
1064 
1065  // Convert from a_mu to g-2
1066  result.central = 2.0*amumssm;
1067  result.upper = 2.0*error;
1068  result.lower = 2.0*error;
1069 
1070  return;
1071  }
std::vector< double > family_state_mix_matrix(str type, int generation, str &mass_es1, str &mass_es2, const SubSpectrum &mssm, double tol, str context, bool pterror)
Get the family mixing matrix and corresponding mass eigenstates, then check for interfamily mixing...
void GM2C_SUSY(triplet< double > &result)
Calculate a_mu_SUSY using the gm2calc backend.
#define LOCAL_INFO
Definition: local_info.hpp:34
virtual void raise(const std::string &)
Raise the exception, i.e. throw it. Exact override of base method.
Definition: exceptions.cpp:422
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
constexpr double alpha_e_OS_MZ
in OS scheme from 1105.3149
invalid_point_exception & invalid_point()
Invalid point exceptions.
constexpr double alpha_e_OS_thomson_limit
Thomson limit of in OS scheme from PDG 2017
Here is the call graph for this function:
Here is the caller graph for this function:

◆ lnL_alpha_em()

void Gambit::PrecisionBit::lnL_alpha_em ( double result)

alpha^{-1}(mZ)^MSbar likelihood alpha^{-1}(mZ)^MSbar = 127.950 +/- 0.017 (1 sigma), Gaussian.

(PDG global SM fit) Reference: http://pdg.lbl.gov/2016/reviews/rpp2016-rev-standard-model.pdf = C. Patrignani et al. (Particle Data Group), Chin. Phys. C, 40, 100001 (2016).

Option profile_systematics<bool>: Use likelihood version that has been profiled over systematic errors (default false)

Definition at line 810 of file PrecisionBit.cpp.

References Gambit::Stats::gaussian_loglikelihood(), lnL_alpha_em, profile_theory::profile(), and SMINPUTS.

811  {
812  using namespace Pipes::lnL_alpha_em;
814  bool profile = runOptions->getValueOrDef<bool>(false, "profile_systematics");
815  result = Stats::gaussian_loglikelihood(Dep::SMINPUTS->alphainv, 127.950, 0.0, 0.017, profile);
816  }
double gaussian_loglikelihood(double theory, double obs, double theoryerr, double obserr, bool profile_systematics)
Use a detection to compute a simple chi-square-like log likelihood, for the case when obs is Gaussian...
Definition: statistics.cpp:133
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum SMInputs SMInputs lnL_alpha_em
def profile(file_name, frac_error=0.1, min_=0., max_=1., log_normal=True)
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum SMINPUTS
Here is the call graph for this function:

◆ lnL_alpha_s()

void Gambit::PrecisionBit::lnL_alpha_s ( double result)

alpha_s(mZ)^MSbar likelihood alpha_s(mZ)^MSbar = 0.1181 +/- 0.0011 (1 sigma), Gaussian.

Reference: http://pdg.lbl.gov/2016/reviews/rpp2016-rev-qcd.pdf = C. Patrignani et al. (Particle Data Group), Chin. Phys. C, 40, 100001 (2016).

Option profile_systematics<bool>: Use likelihood version that has been profiled over systematic errors (default false)

Definition at line 821 of file PrecisionBit.cpp.

References Gambit::Stats::gaussian_loglikelihood(), profile_theory::profile(), and SMINPUTS.

822  {
823  using namespace Pipes::lnL_alpha_s;
825  bool profile = runOptions->getValueOrDef<bool>(false, "profile_systematics");
826  result = Stats::gaussian_loglikelihood(Dep::SMINPUTS->alphaS, 0.1181, 0.0, 0.0011, profile);
827  }
double gaussian_loglikelihood(double theory, double obs, double theoryerr, double obserr, bool profile_systematics)
Use a detection to compute a simple chi-square-like log likelihood, for the case when obs is Gaussian...
Definition: statistics.cpp:133
void lnL_alpha_s(double &result)
alpha_s(mZ)^MSbar likelihood alpha_s(mZ)^MSbar = 0.1181 +/- 0.0011 (1 sigma), Gaussian.
def profile(file_name, frac_error=0.1, min_=0., max_=1., log_normal=True)
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum SMINPUTS
Here is the call graph for this function:

◆ lnL_deltarho()

void Gambit::PrecisionBit::lnL_deltarho ( double result)

Delta rho likelihood Delta rho = 0.00037 +/- 0.00023 (1 sigma), Gaussian.

(PDG global SM fit) Reference: http://pdg.lbl.gov/2016/reviews/rpp2016-rev-qcd.pdf = C. Patrignani et al. (Particle Data Group), Chin. Phys. C, 40, 100001 (2016).

Option profile_systematics<bool>: Use likelihood version that has been profiled over systematic errors (default false)

Definition at line 877 of file PrecisionBit.cpp.

References Gambit::Stats::gaussian_loglikelihood(), and profile_theory::profile().

878  {
879  using namespace Pipes::lnL_deltarho;
880  double theory_uncert = std::max(Dep::deltarho->upper, Dep::deltarho->lower);
882  bool profile = runOptions->getValueOrDef<bool>(false, "profile_systematics");
883  result = Stats::gaussian_loglikelihood(Dep::deltarho->central, 0.00037, theory_uncert, 0.00023, profile);
884  }
double gaussian_loglikelihood(double theory, double obs, double theoryerr, double obserr, bool profile_systematics)
Use a detection to compute a simple chi-square-like log likelihood, for the case when obs is Gaussian...
Definition: statistics.cpp:133
def profile(file_name, frac_error=0.1, min_=0., max_=1., log_normal=True)
void lnL_deltarho(double &result)
Delta rho likelihood Delta rho = 0.00037 +/- 0.00023 (1 sigma), Gaussian.
Here is the call graph for this function:

◆ lnL_GF()

void Gambit::PrecisionBit::lnL_GF ( double result)

G_Fermi likelihood G_Fermi = (1.1663787 +/- 0.0000006) * 10^-5 GeV^-2 (1 sigma), Gaussian.

Reference: http://pdg.lbl.gov/2016/reviews/rpp2016-rev-qcd.pdf = C. Patrignani et al. (Particle Data Group), Chin. Phys. C, 40, 100001 (2016).

Option profile_systematics<bool>: Use likelihood version that has been profiled over systematic errors (default false)

Definition at line 832 of file PrecisionBit.cpp.

References Gambit::FlavBit::LoopFunctions::E(), Gambit::Stats::gaussian_loglikelihood(), lnL_GF, profile_theory::profile(), and SMINPUTS.

833  {
834  using namespace Pipes::lnL_GF;
836  bool profile = runOptions->getValueOrDef<bool>(false, "profile_systematics");
837  result = Stats::gaussian_loglikelihood(Dep::SMINPUTS->GF, 1.1663787E-05, 0.0, 0.0000006E-05, profile);
838  }
double gaussian_loglikelihood(double theory, double obs, double theoryerr, double obserr, bool profile_systematics)
Use a detection to compute a simple chi-square-like log likelihood, for the case when obs is Gaussian...
Definition: statistics.cpp:133
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum SMInputs SMInputs SMInputs lnL_GF
def profile(file_name, frac_error=0.1, min_=0., max_=1., log_normal=True)
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum SMINPUTS
double E(const double x, const double y)
Here is the call graph for this function:

◆ lnL_gm2()

void Gambit::PrecisionBit::lnL_gm2 ( double result)

g-2 likelihood

Option profile_systematics<bool>: Use likelihood version that has been profiled over systematic errors (default false)

Definition at line 906 of file PrecisionBit.cpp.

References Gambit::Stats::gaussian_loglikelihood(), muon_gm2, profile_theory::profile(), and Gambit::Utils::sqr().

907  {
908  using namespace Pipes::lnL_gm2;
909  double amu_sm = 0.5*Dep::muon_gm2_SM->central;
910  double amu_sm_error = 0.5*std::max(Dep::muon_gm2_SM->upper, Dep::muon_gm2_SM->lower);
911  double amu_bsm = 0.5*Dep::muon_gm2->central;
912  double amu_bsm_error = 0.5*std::max(Dep::muon_gm2->upper, Dep::muon_gm2->lower);
913  double amu_theory = amu_sm + amu_bsm;
914  double amu_theory_err = sqrt(Gambit::Utils::sqr(amu_sm_error) + Gambit::Utils::sqr(amu_bsm_error));
915  // From hep-ex/0602035, as updated in PDG 2016 (C. Patrignani et al, Chin. Phys. C, 40, 100001 (2016). ). Error combines statistical (5.4) and systematic (3.3) uncertainties in quadrature.
916  double amu_exp = 11659209.1e-10;
917  double amu_exp_error = 6.3e-10;
919  bool profile = runOptions->getValueOrDef<bool>(false, "profile_systematics");
920  result = Stats::gaussian_loglikelihood(amu_theory, amu_exp, amu_theory_err, amu_exp_error, profile);
921  }
double gaussian_loglikelihood(double theory, double obs, double theoryerr, double obserr, bool profile_systematics)
Use a detection to compute a simple chi-square-like log likelihood, for the case when obs is Gaussian...
Definition: statistics.cpp:133
EXPORT_SYMBOLS double sqr(double a)
returns square of double - saves tedious repetition
fh_Couplings libfeynhiggs muon_gm2
void lnL_gm2(double &result)
g-2 likelihood
def profile(file_name, frac_error=0.1, min_=0., max_=1., log_normal=True)
Here is the call graph for this function:

◆ lnL_h_mass()

void Gambit::PrecisionBit::lnL_h_mass ( double result)

Simple, naive h boson mass likelihood Reference: D.

Aad et al arxiv:1503.07589, Phys.Rev.Lett. 114 (2015) 191803 (ATLAS + CMS combination) Also used dierctly in http://pdg.lbl.gov/2016/tables/rpp2016-sum-gauge-higgs-bosons.pdf = C. Patrignani et al. (Particle Data Group), Chin. Phys. C, 40, 100001 (2016).

Option profile_systematics<bool>: Use likelihood version that has been profiled over systematic errors (default false)

Definition at line 853 of file PrecisionBit.cpp.

References Gambit::Stats::gaussian_loglikelihood(), mh, and profile_theory::profile().

854  {
855  using namespace Pipes::lnL_h_mass;
856  double theory_uncert = std::max(Dep::mh->upper, Dep::mh->lower);
858  bool profile = runOptions->getValueOrDef<bool>(false, "profile_systematics");
859  result = Stats::gaussian_loglikelihood(Dep::mh->central, 125.09, theory_uncert, 0.24, profile);
860  }
double gaussian_loglikelihood(double theory, double obs, double theoryerr, double obserr, bool profile_systematics)
Use a detection to compute a simple chi-square-like log likelihood, for the case when obs is Gaussian...
Definition: statistics.cpp:133
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum mh
def profile(file_name, frac_error=0.1, min_=0., max_=1., log_normal=True)
void lnL_h_mass(double &result)
Simple, naive h boson mass likelihood Reference: D.
Here is the call graph for this function:

◆ lnL_light_quark_masses()

void Gambit::PrecisionBit::lnL_light_quark_masses ( double result)

Likelihoods for light quark mass ratios.

At the moment, all are just gaussians. Default data from PDG http://PDG.LBL.GOV 26/06/2017. Likelihoods apply to MSbar masses at the scale mu = 2 GeV. m_u/m_d = 0.38-0.58 m_s / ((m_u + m_d)/2) = 27.3 +/- 0.7 m_s = (96 +/- 4) MeV

Option profile_systematics<bool>: Use likelihood version that has been profiled over systematic errors (default false)

Definition at line 786 of file PrecisionBit.cpp.

References Gambit::LogTags::debug, Gambit::EOM, Gambit::Stats::gaussian_loglikelihood(), Gambit::logger(), Gambit::SMInputs::mD, Gambit::SMInputs::mS, Gambit::SMInputs::mU, profile_theory::profile(), and SMINPUTS.

787  {
788  using namespace Pipes::lnL_light_quark_masses;
789  const SMInputs& SM = *Dep::SMINPUTS;
790 
791  double mud_obs = runOptions->getValueOrDef<double>(0.48, "mud_obs");
792  double mud_obserror = runOptions->getValueOrDef<double>(0.10, "mud_obserr");
793  double msud_obs = runOptions->getValueOrDef<double>(27.3, "msud_obs");
794  double msud_obserror = runOptions->getValueOrDef<double>(0.7, "msud_obserr");
795  double ms_obs = runOptions->getValueOrDef<double>(96.E-03, "ms_obs");
796  double ms_obserror = runOptions->getValueOrDef<double>(4.E-03, "ms_obserr");
797 
799  bool profile = runOptions->getValueOrDef<bool>(false, "profile_systematics");
800 
801  result = Stats::gaussian_loglikelihood(SM.mU/SM.mD, mud_obs, 0., mud_obserror, profile)
802  + Stats::gaussian_loglikelihood((2*SM.mS)/(SM.mU + SM.mD), msud_obs, 0., msud_obserror, profile)
803  + Stats::gaussian_loglikelihood(SM.mS, ms_obs, 0., ms_obserror, profile);
804  logger() << LogTags::debug << "Combined lnL for light quark mass ratios and s-quark mass is " << result << EOM;
805  }
double gaussian_loglikelihood(double theory, double obs, double theoryerr, double obserr, bool profile_systematics)
Use a detection to compute a simple chi-square-like log likelihood, for the case when obs is Gaussian...
Definition: statistics.cpp:133
void lnL_light_quark_masses(double &result)
Likelihoods for light quark mass ratios.
const Logging::endofmessage EOM
Explicit const instance of the end of message struct in Gambit namespace.
Definition: logger.hpp:100
EXPORT_SYMBOLS Logging::LogMaster & logger()
Function to retrieve a reference to the Gambit global log object.
Definition: logger.cpp:95
def profile(file_name, frac_error=0.1, min_=0., max_=1., log_normal=True)
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum SMINPUTS
Here is the call graph for this function:

◆ lnL_mbmb()

void Gambit::PrecisionBit::lnL_mbmb ( double result)

b quark mass likelihood m_b (mb)^MSbar = 4.18 +/- 0.03 GeV (1 sigma), Gaussian.

Reference: http://pdg.lbl.gov/2016/reviews/rpp2016-rev-qcd.pdf = C. Patrignani et al. (Particle Data Group), Chin. Phys. C, 40, 100001 (2016).

Option profile_systematics<bool>: Use likelihood version that has been profiled over systematic errors (default false)

Definition at line 761 of file PrecisionBit.cpp.

References Gambit::Stats::gaussian_loglikelihood(), lnL_mbmb, profile_theory::profile(), and SMINPUTS.

762  {
763  using namespace Pipes::lnL_mbmb;
765  bool profile = runOptions->getValueOrDef<bool>(false, "profile_systematics");
766  result = Stats::gaussian_loglikelihood(Dep::SMINPUTS->mBmB, 4.18, 0.0, 0.03, profile);
767  }
double gaussian_loglikelihood(double theory, double obs, double theoryerr, double obserr, bool profile_systematics)
Use a detection to compute a simple chi-square-like log likelihood, for the case when obs is Gaussian...
Definition: statistics.cpp:133
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum SMInputs lnL_mbmb
def profile(file_name, frac_error=0.1, min_=0., max_=1., log_normal=True)
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum SMINPUTS
Here is the call graph for this function:

◆ lnL_mcmc()

void Gambit::PrecisionBit::lnL_mcmc ( double result)

c quark mass likelihood m_c (mc)^MSbar = 1.28 +/- 0.03 GeV (1 sigma), Gaussian.

Reference: http://pdg.lbl.gov/2016/reviews/rpp2016-rev-qcd.pdf = C. Patrignani et al. (Particle Data Group), Chin. Phys. C, 40, 100001 (2016).

Option profile_systematics<bool>: Use likelihood version that has been profiled over systematic errors (default false)

Definition at line 772 of file PrecisionBit.cpp.

References Gambit::Stats::gaussian_loglikelihood(), profile_theory::profile(), and SMINPUTS.

773  {
774  using namespace Pipes::lnL_mcmc;
776  bool profile = runOptions->getValueOrDef<bool>(false, "profile_systematics");
777  result = Stats::gaussian_loglikelihood(Dep::SMINPUTS->mCmC, 1.28, 0.0, 0.03, profile);
778  }
double gaussian_loglikelihood(double theory, double obs, double theoryerr, double obserr, bool profile_systematics)
Use a detection to compute a simple chi-square-like log likelihood, for the case when obs is Gaussian...
Definition: statistics.cpp:133
void lnL_mcmc(double &result)
c quark mass likelihood m_c (mc)^MSbar = 1.28 +/- 0.03 GeV (1 sigma), Gaussian.
def profile(file_name, frac_error=0.1, min_=0., max_=1., log_normal=True)
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum SMINPUTS
Here is the call graph for this function:

◆ lnL_neutron_lifetime_beam_Yue()

void Gambit::PrecisionBit::lnL_neutron_lifetime_beam_Yue ( double result)

Beam method: Phys. Rev. Lett. 111, 222501 (2013) https://arxiv.org/abs/1309.2623.

Option profile_systematics<bool>: Use likelihood version that has been profiled over systematic errors (default false)

Definition at line 1169 of file PrecisionBit.cpp.

References Gambit::Stats::gaussian_loglikelihood(), and profile_theory::profile().

1170  {
1171  using namespace Pipes::lnL_neutron_lifetime_beam_Yue;
1173  bool profile = runOptions->getValueOrDef<bool>(false, "profile_systematics");
1174  result = Stats::gaussian_loglikelihood(*Param["neutron_lifetime"], 887.7, 1.9, 1.2, profile);
1175  }
double gaussian_loglikelihood(double theory, double obs, double theoryerr, double obserr, bool profile_systematics)
Use a detection to compute a simple chi-square-like log likelihood, for the case when obs is Gaussian...
Definition: statistics.cpp:133
void lnL_neutron_lifetime_beam_Yue(double &result)
Beam method: Phys. Rev. Lett. 111, 222501 (2013) https://arxiv.org/abs/1309.2623. ...
def profile(file_name, frac_error=0.1, min_=0., max_=1., log_normal=True)
Here is the call graph for this function:

◆ lnL_neutron_lifetime_bottle_PDG19()

void Gambit::PrecisionBit::lnL_neutron_lifetime_bottle_PDG19 ( double result)

Bottle method: average recommended by PDG 2019 http://pdg.lbl.gov/2019/listings/rpp2019-list-n.pdf.

Option profile_systematics<bool>: Use likelihood version that has been profiled over systematic errors (default false)

Definition at line 1178 of file PrecisionBit.cpp.

References Gambit::Stats::gaussian_loglikelihood(), and profile_theory::profile().

1179  {
1182  bool profile = runOptions->getValueOrDef<bool>(false, "profile_systematics");
1183  result = Stats::gaussian_loglikelihood(*Param["neutron_lifetime"], 879.4, 0, 0.6, profile);
1184  }
double gaussian_loglikelihood(double theory, double obs, double theoryerr, double obserr, bool profile_systematics)
Use a detection to compute a simple chi-square-like log likelihood, for the case when obs is Gaussian...
Definition: statistics.cpp:133
void lnL_neutron_lifetime_bottle_PDG19(double &result)
Bottle method: average recommended by PDG 2019 http://pdg.lbl.gov/2019/listings/rpp2019-list-n.pdf.
def profile(file_name, frac_error=0.1, min_=0., max_=1., log_normal=True)
Here is the call graph for this function:

◆ lnL_sinW2_eff()

void Gambit::PrecisionBit::lnL_sinW2_eff ( double result)

Effective leptonic sin^2(theta_W) likelihood sin^2theta_W^leptonic_effective~ sin^2theta_W(mZ)^MSbar + 0.00029 = 0.23155 +/- 0.00005 (1 sigma), Gaussian.

(PDG global SM fit) Reference: http://pdg.lbl.gov/2016/reviews/rpp2016-rev-qcd.pdf = C. Patrignani et al. (Particle Data Group), Chin. Phys. C, 40, 100001 (2016).

Option profile_systematics<bool>: Use likelihood version that has been profiled over systematic errors (default false)

Definition at line 865 of file PrecisionBit.cpp.

References Gambit::Stats::gaussian_loglikelihood(), and profile_theory::profile().

866  {
867  using namespace Pipes::lnL_sinW2_eff;
868  double theory_uncert = std::max(Dep::prec_sinW2_eff->upper, Dep::prec_sinW2_eff->lower);
870  bool profile = runOptions->getValueOrDef<bool>(false, "profile_systematics");
871  result = Stats::gaussian_loglikelihood(Dep::prec_sinW2_eff->central, 0.23155, theory_uncert, 0.00005, profile);
872  }
double gaussian_loglikelihood(double theory, double obs, double theoryerr, double obserr, bool profile_systematics)
Use a detection to compute a simple chi-square-like log likelihood, for the case when obs is Gaussian...
Definition: statistics.cpp:133
void lnL_sinW2_eff(double &result)
Effective leptonic sin^2(theta_W) likelihood sin^2theta_W^leptonic_effective~ sin^2theta_W(mZ)^MSbar ...
def profile(file_name, frac_error=0.1, min_=0., max_=1., log_normal=True)
Here is the call graph for this function:

◆ lnL_t_mass()

void Gambit::PrecisionBit::lnL_t_mass ( double result)

t quark mass likelihood m_t (pole) = 173.34 +/- 0.76 GeV (1 sigma), Gaussian.

Reference: http://arxiv.org/abs/1403.4427

Option profile_systematics<bool>: Use likelihood version that has been profiled over systematic errors (default false)

Definition at line 750 of file PrecisionBit.cpp.

References Gambit::Stats::gaussian_loglikelihood(), profile_theory::profile(), and SMINPUTS.

751  {
752  using namespace Pipes::lnL_t_mass;
754  bool profile = runOptions->getValueOrDef<bool>(false, "profile_systematics");
755  result = Stats::gaussian_loglikelihood(Dep::SMINPUTS->mT, 173.34, 0.0, 0.76, profile);
756  }
double gaussian_loglikelihood(double theory, double obs, double theoryerr, double obserr, bool profile_systematics)
Use a detection to compute a simple chi-square-like log likelihood, for the case when obs is Gaussian...
Definition: statistics.cpp:133
void lnL_t_mass(double &result)
t quark mass likelihood m_t (pole) = 173.34 +/- 0.76 GeV (1 sigma), Gaussian.
def profile(file_name, frac_error=0.1, min_=0., max_=1., log_normal=True)
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum SMINPUTS
Here is the call graph for this function:

◆ lnL_W_mass()

void Gambit::PrecisionBit::lnL_W_mass ( double result)

W boson mass likelihood.

Option profile_systematics<bool>: Use likelihood version that has been profiled over systematic errors (default false)

Definition at line 841 of file PrecisionBit.cpp.

References Gambit::Stats::gaussian_loglikelihood(), mw, Gambit::mw_central_observed, Gambit::mw_err_observed, and profile_theory::profile().

842  {
843  using namespace Pipes::lnL_W_mass;
844  double theory_uncert = std::max(Dep::mw->upper, Dep::mw->lower);
846  bool profile = runOptions->getValueOrDef<bool>(false, "profile_systematics");
847  result = Stats::gaussian_loglikelihood(Dep::mw->central, mw_central_observed, theory_uncert, mw_err_observed, profile);
848  }
Spectrum Spectrum Spectrum mw
const double mw_err_observed
double gaussian_loglikelihood(double theory, double obs, double theoryerr, double obserr, bool profile_systematics)
Use a detection to compute a simple chi-square-like log likelihood, for the case when obs is Gaussian...
Definition: statistics.cpp:133
void lnL_W_mass(double &result)
W boson mass likelihood.
def profile(file_name, frac_error=0.1, min_=0., max_=1., log_normal=True)
const double mw_central_observed
M_W (Breit-Wigner mass parameter ~ pole) = 80.385 +/- 0.015 GeV (1 sigma), Gaussian.
Here is the call graph for this function:

◆ lnL_Z_mass()

void Gambit::PrecisionBit::lnL_Z_mass ( double result)

Z boson mass likelihood M_Z (Breit-Wigner mass parameter ~ pole) = 91.1876 +/- 0.0021 GeV (1 sigma), Gaussian.

Reference: http://pdg.lbl.gov/2016/reviews/rpp2016-rev-qcd.pdf = C. Patrignani et al. (Particle Data Group), Chin. Phys. C, 40, 100001 (2016).

Option profile_systematics<bool>: Use likelihood version that has been profiled over systematic errors (default false)

Definition at line 739 of file PrecisionBit.cpp.

References Gambit::Stats::gaussian_loglikelihood(), lnL_Z_mass, profile_theory::profile(), and SMINPUTS.

740  {
741  using namespace Pipes::lnL_Z_mass;
743  bool profile = runOptions->getValueOrDef<bool>(false, "profile_systematics");
744  result = Stats::gaussian_loglikelihood(Dep::SMINPUTS->mZ, 91.1876, 0.0, 0.0021, profile);
745  }
double gaussian_loglikelihood(double theory, double obs, double theoryerr, double obserr, bool profile_systematics)
Use a detection to compute a simple chi-square-like log likelihood, for the case when obs is Gaussian...
Definition: statistics.cpp:133
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum lnL_Z_mass
def profile(file_name, frac_error=0.1, min_=0., max_=1., log_normal=True)
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum SMINPUTS
Here is the call graph for this function:

◆ make_MSSM_precision_spectrum_4H_W()

void Gambit::PrecisionBit::make_MSSM_precision_spectrum_4H_W ( Spectrum improved_spec)

Precision MSSM spectrum manufacturer with precision W and 2HDM (4x) Higgs masses.

Definition at line 588 of file PrecisionBit.cpp.

References Gambit::Par::dimensionless, Gambit::Spectrum::drop_SLHAs_if_requested(), Gambit::Spectrum::get_HE(), Gambit::Spectrum::get_LE(), LOCAL_INFO, prec_mw, Gambit::SubSpectrum::set_override(), Gambit::SMlike_higgs_PDG_code(), unimproved_MSSM_spectrum, update_H_masses(), and update_W_masses().

Referenced by main().

589  {
591  improved_spec = *Dep::unimproved_MSSM_spectrum; // Does copy
592  SubSpectrum& HE = improved_spec.get_HE();
593  SubSpectrum& LE = improved_spec.get_LE();
594  static bool allow_fallback = runOptions->getValueOrDef<bool>(false, "allow_fallback_to_unimproved_masses");
595 
596  // W mass
597  update_W_masses(HE, LE, *Dep::prec_mw, allow_fallback);
598 
599  // Higgs masses
600  // FIXME switch to this once the setters take pdg pairs
601  //const std::pair<int,int> higgses[4] = {std::pair<int,int>(25,0),
602  // std::pair<int,int>(35,0),
603  // std::pair<int,int>(36,0),
604  // std::pair<int,int>(37,0)};
605  const str higgses[4] = {"h0_1", "h0_2", "A0", "H+"};
606  std::vector< triplet<double> > MH;
607  int smlike_pdg = SMlike_higgs_PDG_code(HE);
608  if (smlike_pdg == 25)
609  { //h0_1
610  MH.push_back(*Dep::prec_mh);
611  MH.push_back(Dep::prec_HeavyHiggsMasses->at(35));
612  }
613  else if (smlike_pdg == 35)
614  { //h0_2
615  MH.push_back(Dep::prec_HeavyHiggsMasses->at(25));
616  MH.push_back(*Dep::prec_mh);
617  }
618  else PrecisionBit_error().raise(LOCAL_INFO, "Urecognised SM-like Higgs PDG code!");
619  MH.push_back(Dep::prec_HeavyHiggsMasses->at(36)); //A_0
620  MH.push_back(Dep::prec_HeavyHiggsMasses->at(37)); //H+
621 
622  static int central = runOptions->getValueOrDef<int>(1, "Higgs_predictions_source");
623  static int error = runOptions->getValueOrDef<int>(2, "Higgs_predictions_error_method");
624  update_H_masses(HE, 4, higgses, central, error, MH, allow_fallback);
625 
626  // Save the identity/identities of the calculator(s) used for the central value.
627  const str& p1_calc = Dep::prec_mh.name();
628  const str& p1_orig = Dep::prec_mh.origin();
629  const str& p2_calc = Dep::prec_HeavyHiggsMasses.name();
630  const str& p2_orig = Dep::prec_HeavyHiggsMasses.origin();
631  const str& s_calc = Dep::unimproved_MSSM_spectrum.name();
632  const str& s_orig = Dep::unimproved_MSSM_spectrum.origin();
633  if (central == 1) HE.set_override(Par::dimensionless, 1.0, "h mass from: "+p1_orig+"::"+p1_calc+", "+p2_orig+"::"+p2_calc, true);
634  if (central == 2) HE.set_override(Par::dimensionless, 1.0, "h mass from: "+s_orig+"::"+s_calc, true);
635  if (central == 3) HE.set_override(Par::dimensionless, 1.0, "h mass from: "+p1_orig+"::"+p1_calc+", "+p2_orig+"::"+p2_calc+", "+s_orig+"::"+s_calc, true);
636 
637  // Check if an SLHA file needs to be excreted.
638  improved_spec.drop_SLHAs_if_requested(runOptions, "GAMBIT_spectrum");
639 
640  }
void update_W_masses(SubSpectrum &HE, SubSpectrum &LE, const triplet< double > &prec_mw, bool allow_fallback)
Helper function to set W masses.
#define LOCAL_INFO
Definition: local_info.hpp:34
void update_H_masses(SubSpectrum &HE, int n_higgs, const str *higgses, int central, int error, std::vector< triplet< double > > &MH, bool allow_fallback)
Helper function to set arbitrary number of H masses.
int SMlike_higgs_PDG_code(const SubSpectrum &)
Determine which MSSM higgs is most SM-like.
fh_Couplings libfeynhiggs fh_PrecisionObs prec_mw
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
void make_MSSM_precision_spectrum_4H_W(Spectrum &improved_spec)
Precision MSSM spectrum manufacturer with precision W and 2HDM (4x) Higgs masses. ...
Here is the call graph for this function:
Here is the caller graph for this function:

◆ make_MSSM_precision_spectrum_H()

void Gambit::PrecisionBit::make_MSSM_precision_spectrum_H ( Spectrum improved_spec)

Precision MSSM spectrum manufacturer with precision SM-like Higgs mass.

Definition at line 508 of file PrecisionBit.cpp.

References Gambit::Par::dimensionless, Gambit::Spectrum::drop_SLHAs_if_requested(), Gambit::Spectrum::get_HE(), LOCAL_INFO, Gambit::SubSpectrum::set_override(), Gambit::SMlike_higgs_PDG_code(), unimproved_MSSM_spectrum, and update_H_masses().

509  {
511  improved_spec = *Dep::unimproved_MSSM_spectrum; // Does copy
512  SubSpectrum& HE = improved_spec.get_HE();
513  static bool allow_fallback = runOptions->getValueOrDef<bool>(false, "allow_fallback_to_unimproved_masses");
514 
515  // Higgs masses
516  // FIXME switch to this once the setters take pdg pairs
517  //const std::pair<int,int> higgses[4] = {std::pair<int,int>(25,0),
518  // std::pair<int,int>(35,0),
519  // std::pair<int,int>(36,0),
520  // std::pair<int,int>(37,0)};
521  str higgses[1];
522  std::vector< triplet<double> > MH = {*Dep::prec_mh};
523  int smlike_pdg = SMlike_higgs_PDG_code(HE);
524  if (smlike_pdg == 25) higgses[0] = "h0_1";
525  else if (smlike_pdg == 35) higgses[0] = "h0_2";
526  else PrecisionBit_error().raise(LOCAL_INFO, "Urecognised SM-like Higgs PDG code!");
527  static int central = runOptions->getValueOrDef<int>(1, "Higgs_predictions_source");
528  static int error = runOptions->getValueOrDef<int>(2, "Higgs_predictions_error_method");
529  update_H_masses(HE, 1, higgses, central, error, MH, allow_fallback);
530 
531  // Save the identity/identities of the calculator(s) used for the central value.
532  const str& p_calc = Dep::prec_mh.name();
533  const str& p_orig = Dep::prec_mh.origin();
534  const str& s_calc = Dep::unimproved_MSSM_spectrum.name();
535  const str& s_orig = Dep::unimproved_MSSM_spectrum.origin();
536  if (central == 1) HE.set_override(Par::dimensionless, 1.0, "h mass from: "+p_orig+"::"+p_calc, true);
537  if (central == 2) HE.set_override(Par::dimensionless, 1.0, "h mass from: "+s_orig+"::"+s_calc, true);
538  if (central == 3) HE.set_override(Par::dimensionless, 1.0, "h mass from: "+p_orig+"::"+p_calc+", "+s_orig+"::"+s_calc, true);
539 
540  // Check if an SLHA file needs to be excreted.
541  improved_spec.drop_SLHAs_if_requested(runOptions, "GAMBIT_spectrum");
542 
543  }
#define LOCAL_INFO
Definition: local_info.hpp:34
void update_H_masses(SubSpectrum &HE, int n_higgs, const str *higgses, int central, int error, std::vector< triplet< double > > &MH, bool allow_fallback)
Helper function to set arbitrary number of H masses.
int SMlike_higgs_PDG_code(const SubSpectrum &)
Determine which MSSM higgs is most SM-like.
void make_MSSM_precision_spectrum_H(Spectrum &improved_spec)
Precision MSSM spectrum manufacturer with precision SM-like Higgs mass.
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
Here is the call graph for this function:

◆ make_MSSM_precision_spectrum_H_W()

void Gambit::PrecisionBit::make_MSSM_precision_spectrum_H_W ( Spectrum improved_spec)

Precision MSSM spectrum manufacturer with precision W and SM-like Higgs masses.

Definition at line 546 of file PrecisionBit.cpp.

References Gambit::Par::dimensionless, Gambit::Spectrum::drop_SLHAs_if_requested(), Gambit::Spectrum::get_HE(), Gambit::Spectrum::get_LE(), LOCAL_INFO, prec_mw, Gambit::SubSpectrum::set_override(), Gambit::SMlike_higgs_PDG_code(), unimproved_MSSM_spectrum, update_H_masses(), and update_W_masses().

547  {
549  improved_spec = *Dep::unimproved_MSSM_spectrum; // Does copy
550  SubSpectrum& HE = improved_spec.get_HE();
551  SubSpectrum& LE = improved_spec.get_LE();
552  static bool allow_fallback = runOptions->getValueOrDef<bool>(false, "allow_fallback_to_unimproved_masses");
553 
554  // W mass
555  update_W_masses(HE, LE, *Dep::prec_mw, allow_fallback);
556 
557  // Higgs masses
558  // FIXME switch to this once the setters take pdg pairs
559  //const std::pair<int,int> higgses[4] = {std::pair<int,int>(25,0),
560  // std::pair<int,int>(35,0),
561  // std::pair<int,int>(36,0),
562  // std::pair<int,int>(37,0)};
563  str higgses[1];
564  std::vector< triplet<double> > MH = {*Dep::prec_mh};
565  int smlike_pdg = SMlike_higgs_PDG_code(HE);
566  if (smlike_pdg == 25) higgses[0] = "h0_1";
567  else if (smlike_pdg == 35) higgses[0] = "h0_2";
568  else PrecisionBit_error().raise(LOCAL_INFO, "Urecognised SM-like Higgs PDG code!");
569  static int central = runOptions->getValueOrDef<int>(1, "Higgs_predictions_source");
570  static int error = runOptions->getValueOrDef<int>(2, "Higgs_predictions_error_method");
571  update_H_masses(HE, 1, higgses, central, error, MH, allow_fallback);
572 
573  // Save the identity/identities of the calculator(s) used for the central value.
574  const str& p_calc = Dep::prec_mh.name();
575  const str& p_orig = Dep::prec_mh.origin();
576  const str& s_calc = Dep::unimproved_MSSM_spectrum.name();
577  const str& s_orig = Dep::unimproved_MSSM_spectrum.origin();
578  if (central == 1) HE.set_override(Par::dimensionless, 1.0, "h mass from: "+p_orig+"::"+p_calc, true);
579  if (central == 2) HE.set_override(Par::dimensionless, 1.0, "h mass from: "+s_orig+"::"+s_calc, true);
580  if (central == 3) HE.set_override(Par::dimensionless, 1.0, "h mass from: "+p_orig+"::"+p_calc+", "+s_orig+"::"+s_calc, true);
581 
582  // Check if an SLHA file needs to be excreted.
583  improved_spec.drop_SLHAs_if_requested(runOptions, "GAMBIT_spectrum");
584 
585  }
void update_W_masses(SubSpectrum &HE, SubSpectrum &LE, const triplet< double > &prec_mw, bool allow_fallback)
Helper function to set W masses.
void make_MSSM_precision_spectrum_H_W(Spectrum &improved_spec)
Precision MSSM spectrum manufacturer with precision W and SM-like Higgs masses.
#define LOCAL_INFO
Definition: local_info.hpp:34
void update_H_masses(SubSpectrum &HE, int n_higgs, const str *higgses, int central, int error, std::vector< triplet< double > > &MH, bool allow_fallback)
Helper function to set arbitrary number of H masses.
int SMlike_higgs_PDG_code(const SubSpectrum &)
Determine which MSSM higgs is most SM-like.
fh_Couplings libfeynhiggs fh_PrecisionObs prec_mw
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
Here is the call graph for this function:

◆ make_MSSM_precision_spectrum_none()

void Gambit::PrecisionBit::make_MSSM_precision_spectrum_none ( Spectrum improved_spec)

Precision MSSM spectrum manufacturer that does nothing but relabel the unimproved spectrum.

Definition at line 490 of file PrecisionBit.cpp.

References Gambit::Spectrum::drop_SLHAs_if_requested(), and unimproved_MSSM_spectrum.

491  {
493  improved_spec = *Dep::unimproved_MSSM_spectrum; // Does copy
494  improved_spec.drop_SLHAs_if_requested(runOptions, "GAMBIT_spectrum");
495  }
void make_MSSM_precision_spectrum_none(Spectrum &improved_spec)
Precision MSSM spectrum manufacturer that does nothing but relabel the unimproved spectrum...
Here is the call graph for this function:

◆ make_MSSM_precision_spectrum_W()

void Gambit::PrecisionBit::make_MSSM_precision_spectrum_W ( Spectrum improved_spec)

Precision MSSM spectrum manufacturer with precision W mass only.

Definition at line 498 of file PrecisionBit.cpp.

References Gambit::Spectrum::drop_SLHAs_if_requested(), Gambit::Spectrum::get_HE(), Gambit::Spectrum::get_LE(), prec_mw, unimproved_MSSM_spectrum, and update_W_masses().

499  {
501  improved_spec = *Dep::unimproved_MSSM_spectrum; // Does copy
502  static bool allow_fallback = runOptions->getValueOrDef<bool>(false, "allow_fallback_to_unimproved_masses");
503  update_W_masses(improved_spec.get_HE(), improved_spec.get_LE(), *Dep::prec_mw, allow_fallback);
504  improved_spec.drop_SLHAs_if_requested(runOptions, "GAMBIT_spectrum");
505  }
void update_W_masses(SubSpectrum &HE, SubSpectrum &LE, const triplet< double > &prec_mw, bool allow_fallback)
Helper function to set W masses.
void make_MSSM_precision_spectrum_W(Spectrum &improved_spec)
Precision MSSM spectrum manufacturer with precision W mass only.
fh_Couplings libfeynhiggs fh_PrecisionObs prec_mw
Here is the call graph for this function:

◆ mh_from_MSSM_spectrum()

void Gambit::PrecisionBit::mh_from_MSSM_spectrum ( triplet< double > &  result)

Definition at line 725 of file PrecisionBit.cpp.

References Gambit::triplet< TYPE >::central, Gambit::SubSpectrum::get(), Gambit::triplet< TYPE >::lower, MSSM_spectrum, Gambit::Par::Pole_Mass, Gambit::Par::Pole_Mass_1srd_high, Gambit::Par::Pole_Mass_1srd_low, Gambit::SMlike_higgs_PDG_code(), and Gambit::triplet< TYPE >::upper.

726  {
727  using namespace Pipes::mh_from_MSSM_spectrum;
728  const SubSpectrum& HE = Dep::MSSM_spectrum->get_HE();
729  int smlike_pdg = SMlike_higgs_PDG_code(HE);
730  result.central = HE.get(Par::Pole_Mass, smlike_pdg, 0);
731  result.upper = result.central * HE.get(Par::Pole_Mass_1srd_high, smlike_pdg, 0);
732  result.lower = result.central * HE.get(Par::Pole_Mass_1srd_low, smlike_pdg, 0);
733  }
void mh_from_MSSM_spectrum(triplet< double > &result)
int SMlike_higgs_PDG_code(const SubSpectrum &)
Determine which MSSM higgs is most SM-like.
Here is the call graph for this function:

◆ mh_from_ScalarSingletDM_Z2_spectrum()

void Gambit::PrecisionBit::mh_from_ScalarSingletDM_Z2_spectrum ( triplet< double > &  result)

Definition at line 709 of file PrecisionBit.cpp.

References Gambit::triplet< TYPE >::central, Gambit::SubSpectrum::get(), Gambit::triplet< TYPE >::lower, Gambit::Par::Pole_Mass, Gambit::Par::Pole_Mass_1srd_high, Gambit::Par::Pole_Mass_1srd_low, ScalarSingletDM_Z2_spectrum, and Gambit::triplet< TYPE >::upper.

710  {
712  const SubSpectrum& HE = Dep::ScalarSingletDM_Z2_spectrum->get_HE();
713  result.central = HE.get(Par::Pole_Mass, 25, 0);
714  result.upper = result.central * HE.get(Par::Pole_Mass_1srd_high, 25, 0);
715  result.lower = result.central * HE.get(Par::Pole_Mass_1srd_low, 25, 0);
716  }
void mh_from_ScalarSingletDM_Z2_spectrum(triplet< double > &result)
Here is the call graph for this function:

◆ mh_from_ScalarSingletDM_Z3_spectrum()

void Gambit::PrecisionBit::mh_from_ScalarSingletDM_Z3_spectrum ( triplet< double > &  result)

Definition at line 717 of file PrecisionBit.cpp.

References Gambit::triplet< TYPE >::central, Gambit::SubSpectrum::get(), Gambit::triplet< TYPE >::lower, mh_from_ScalarSingletDM_Z3_spectrum, Gambit::Par::Pole_Mass, Gambit::Par::Pole_Mass_1srd_high, Gambit::Par::Pole_Mass_1srd_low, ScalarSingletDM_Z3_spectrum, and Gambit::triplet< TYPE >::upper.

718  {
720  const SubSpectrum& HE = Dep::ScalarSingletDM_Z3_spectrum->get_HE();
721  result.central = HE.get(Par::Pole_Mass, 25, 0);
722  result.upper = result.central * HE.get(Par::Pole_Mass_1srd_high, 25, 0);
723  result.lower = result.central * HE.get(Par::Pole_Mass_1srd_low, 25, 0);
724  }
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum mh_from_ScalarSingletDM_Z3_spectrum
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum ScalarSingletDM_Z3_spectrum
Here is the call graph for this function:

◆ mh_from_SM_spectrum()

void Gambit::PrecisionBit::mh_from_SM_spectrum ( triplet< double > &  result)

Definition at line 701 of file PrecisionBit.cpp.

References Gambit::triplet< TYPE >::central, Gambit::SubSpectrum::get(), Gambit::triplet< TYPE >::lower, mh_from_SM_spectrum, Gambit::Par::Pole_Mass, Gambit::Par::Pole_Mass_1srd_high, Gambit::Par::Pole_Mass_1srd_low, SM_spectrum, and Gambit::triplet< TYPE >::upper.

702  {
703  using namespace Pipes::mh_from_SM_spectrum;
704  const SubSpectrum& HE = Dep::SM_spectrum->get_HE();
705  result.central = HE.get(Par::Pole_Mass, 25, 0);
706  result.upper = result.central * HE.get(Par::Pole_Mass_1srd_high, 25, 0);
707  result.lower = result.central * HE.get(Par::Pole_Mass_1srd_low, 25, 0);
708  }
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum mh_from_SM_spectrum
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum SM_spectrum
Here is the call graph for this function:

◆ mw_from_DiracSingletDM_Z2_spectrum()

void Gambit::PrecisionBit::mw_from_DiracSingletDM_Z2_spectrum ( triplet< double > &  result)

Definition at line 685 of file PrecisionBit.cpp.

References Gambit::triplet< TYPE >::central, Gambit::SubSpectrum::get(), Gambit::triplet< TYPE >::lower, Gambit::Par::Pole_Mass, Gambit::Par::Pole_Mass_1srd_high, Gambit::Par::Pole_Mass_1srd_low, and Gambit::triplet< TYPE >::upper.

686  {
688  const SubSpectrum& LE = Dep::DiracSingletDM_Z2_spectrum->get_LE();
689  result.central = LE.get(Par::Pole_Mass, "W+");
690  result.upper = result.central * LE.get(Par::Pole_Mass_1srd_high, "W+");
691  result.lower = result.central * LE.get(Par::Pole_Mass_1srd_low, "W+");
692  }
void mw_from_DiracSingletDM_Z2_spectrum(triplet< double > &result)
Here is the call graph for this function:

◆ mw_from_MajoranaSingletDM_Z2_spectrum()

void Gambit::PrecisionBit::mw_from_MajoranaSingletDM_Z2_spectrum ( triplet< double > &  result)

Definition at line 677 of file PrecisionBit.cpp.

References Gambit::triplet< TYPE >::central, Gambit::SubSpectrum::get(), Gambit::triplet< TYPE >::lower, MajoranaSingletDM_Z2_spectrum, mw_from_MajoranaSingletDM_Z2_spectrum, Gambit::Par::Pole_Mass, Gambit::Par::Pole_Mass_1srd_high, Gambit::Par::Pole_Mass_1srd_low, and Gambit::triplet< TYPE >::upper.

678  {
680  const SubSpectrum& LE = Dep::MajoranaSingletDM_Z2_spectrum->get_LE();
681  result.central = LE.get(Par::Pole_Mass, "W+");
682  result.upper = result.central * LE.get(Par::Pole_Mass_1srd_high, "W+");
683  result.lower = result.central * LE.get(Par::Pole_Mass_1srd_low, "W+");
684  }
Spectrum Spectrum Spectrum Spectrum Spectrum MajoranaSingletDM_Z2_spectrum
Spectrum Spectrum Spectrum Spectrum Spectrum mw_from_MajoranaSingletDM_Z2_spectrum
Here is the call graph for this function:

◆ mw_from_MSSM_spectrum()

void Gambit::PrecisionBit::mw_from_MSSM_spectrum ( triplet< double > &  result)

Definition at line 693 of file PrecisionBit.cpp.

References Gambit::triplet< TYPE >::central, Gambit::SubSpectrum::get(), Gambit::triplet< TYPE >::lower, MSSM_spectrum, Gambit::Par::Pole_Mass, Gambit::Par::Pole_Mass_1srd_high, Gambit::Par::Pole_Mass_1srd_low, and Gambit::triplet< TYPE >::upper.

694  {
695  using namespace Pipes::mw_from_MSSM_spectrum;
696  const SubSpectrum& HE = Dep::MSSM_spectrum->get_HE();
697  result.central = HE.get(Par::Pole_Mass, "W+");
698  result.upper = result.central * HE.get(Par::Pole_Mass_1srd_high, "W+");
699  result.lower = result.central * HE.get(Par::Pole_Mass_1srd_low, "W+");
700  }
void mw_from_MSSM_spectrum(triplet< double > &result)
Here is the call graph for this function:

◆ mw_from_ScalarSingletDM_Z2_spectrum()

void Gambit::PrecisionBit::mw_from_ScalarSingletDM_Z2_spectrum ( triplet< double > &  result)

Definition at line 653 of file PrecisionBit.cpp.

References Gambit::triplet< TYPE >::central, Gambit::SubSpectrum::get(), Gambit::triplet< TYPE >::lower, mw_from_ScalarSingletDM_Z2_spectrum, Gambit::Par::Pole_Mass, Gambit::Par::Pole_Mass_1srd_high, Gambit::Par::Pole_Mass_1srd_low, ScalarSingletDM_Z2_spectrum, and Gambit::triplet< TYPE >::upper.

654  {
656  const SubSpectrum& LE = Dep::ScalarSingletDM_Z2_spectrum->get_LE();
657  result.central = LE.get(Par::Pole_Mass, "W+");;
658  result.upper = result.central * LE.get(Par::Pole_Mass_1srd_high, "W+");
659  result.lower = result.central * LE.get(Par::Pole_Mass_1srd_low, "W+");
660  }
Spectrum Spectrum Spectrum mw_from_ScalarSingletDM_Z2_spectrum
Here is the call graph for this function:

◆ mw_from_ScalarSingletDM_Z3_spectrum()

void Gambit::PrecisionBit::mw_from_ScalarSingletDM_Z3_spectrum ( triplet< double > &  result)

Definition at line 661 of file PrecisionBit.cpp.

References Gambit::triplet< TYPE >::central, Gambit::SubSpectrum::get(), Gambit::triplet< TYPE >::lower, Gambit::Par::Pole_Mass, Gambit::Par::Pole_Mass_1srd_high, Gambit::Par::Pole_Mass_1srd_low, ScalarSingletDM_Z3_spectrum, and Gambit::triplet< TYPE >::upper.

662  {
664  const SubSpectrum& LE = Dep::ScalarSingletDM_Z3_spectrum->get_LE();
665  result.central = LE.get(Par::Pole_Mass, "W+");;
666  result.upper = result.central * LE.get(Par::Pole_Mass_1srd_high, "W+");
667  result.lower = result.central * LE.get(Par::Pole_Mass_1srd_low, "W+");
668  }
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum ScalarSingletDM_Z3_spectrum
void mw_from_ScalarSingletDM_Z3_spectrum(triplet< double > &result)
Here is the call graph for this function:

◆ mw_from_SM_spectrum()

void Gambit::PrecisionBit::mw_from_SM_spectrum ( triplet< double > &  result)

Basic mass extractors for different types of spectra, for use with precision likelihoods and other things not needing a whole spectrum object.

Definition at line 645 of file PrecisionBit.cpp.

References Gambit::triplet< TYPE >::central, Gambit::SubSpectrum::get(), Gambit::triplet< TYPE >::lower, Gambit::Par::Pole_Mass, Gambit::Par::Pole_Mass_1srd_high, Gambit::Par::Pole_Mass_1srd_low, SM_spectrum, and Gambit::triplet< TYPE >::upper.

646  {
647  using namespace Pipes::mw_from_SM_spectrum;
648  const SubSpectrum& LE = Dep::SM_spectrum->get_LE();
649  result.central = LE.get(Par::Pole_Mass, "W+");;
650  result.upper = result.central * LE.get(Par::Pole_Mass_1srd_high, "W+");
651  result.lower = result.central * LE.get(Par::Pole_Mass_1srd_low, "W+");
652  }
void mw_from_SM_spectrum(triplet< double > &result)
Basic mass extractors for different types of spectra, for use with precision likelihoods and other th...
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum SM_spectrum
Here is the call graph for this function:

◆ mw_from_VectorSingletDM_Z2_spectrum()

void Gambit::PrecisionBit::mw_from_VectorSingletDM_Z2_spectrum ( triplet< double > &  result)

Definition at line 669 of file PrecisionBit.cpp.

References Gambit::triplet< TYPE >::central, Gambit::SubSpectrum::get(), Gambit::triplet< TYPE >::lower, mw_from_VectorSingletDM_Z2_spectrum, Gambit::Par::Pole_Mass, Gambit::Par::Pole_Mass_1srd_high, Gambit::Par::Pole_Mass_1srd_low, Gambit::triplet< TYPE >::upper, and VectorSingletDM_Z2_spectrum.

670  {
672  const SubSpectrum& LE = Dep::VectorSingletDM_Z2_spectrum->get_LE();
673  result.central = LE.get(Par::Pole_Mass, "W+");
674  result.upper = result.central * LE.get(Par::Pole_Mass_1srd_high, "W+");
675  result.lower = result.central * LE.get(Par::Pole_Mass_1srd_low, "W+");
676  }
Spectrum Spectrum Spectrum Spectrum mw_from_VectorSingletDM_Z2_spectrum
Spectrum Spectrum Spectrum Spectrum VectorSingletDM_Z2_spectrum
Here is the call graph for this function:

◆ RHN_mw()

void Gambit::PrecisionBit::RHN_mw ( triplet< double > &  result)

Definition at line 1147 of file PrecisionBit.cpp.

References Gambit::triplet< TYPE >::central, Gambit::triplet< TYPE >::lower, Gambit::Scanner::pow(), and Gambit::triplet< TYPE >::upper.

1148  {
1149  using namespace Pipes::RHN_mw;
1150  Eigen::Matrix3cd Theta = *Dep::SeesawI_Theta;
1151  triplet<double> sinW2 = *Dep::prec_sinW2_eff;
1152  Eigen::Matrix3d ThetaNorm = (Theta * Theta.adjoint()).real();
1153 
1154  // SM precision calculation, from 1211.1864
1155  double sinW2_SM = 0.23152;
1156  double sinW2_SM_err = 0.00010;
1157  double mW_SM = 80.361;
1158  double mW_SM_err = 0.010;
1159 
1160  // Radiative corrections, form Marco's paper
1161  result.central = sqrt( pow(mW_SM,2) * sinW2_SM / sinW2.central * sqrt(1.0 - ThetaNorm(0,0) - ThetaNorm(1,1)) );
1162  result.upper = 0.5*result.central*sqrt( pow(2*mW_SM_err/mW_SM,2) + pow(sinW2_SM_err/sinW2_SM,2) + pow(sinW2.upper/sinW2.central,2) );
1163  result.lower = result.upper;
1164  }
void RHN_mw(triplet< double > &result)
double pow(const double &a)
Outputs a^i.
Here is the call graph for this function:

◆ RHN_sinW2_eff()

void Gambit::PrecisionBit::RHN_sinW2_eff ( triplet< double > &  result)

Definition at line 1132 of file PrecisionBit.cpp.

References Gambit::triplet< TYPE >::central, Gambit::triplet< TYPE >::lower, and Gambit::triplet< TYPE >::upper.

1133  {
1134  using namespace Pipes::RHN_sinW2_eff;
1135  Eigen::Matrix3cd Theta = *Dep::SeesawI_Theta;
1136  Eigen::Matrix3d ThetaNorm = (Theta * Theta.adjoint()).real();
1137 
1138  double sinW2_SM = 0.23152; // taken from 1211.1864
1139  double sinW2_SM_err = 0.00010;
1140 
1141  result.central = 0.5 - 0.5*sqrt(1.0 - 4*sinW2_SM*(1.0 - sinW2_SM)*sqrt(1.0 - ThetaNorm(0,0) - ThetaNorm(1,1)) );
1142  result.upper = (1.0 - 2*sinW2_SM) / (1.0 - 2*result.central) * sqrt(1.0 - ThetaNorm(0,0) - ThetaNorm(1,1)) * sinW2_SM_err;
1143  result.lower = result.upper;
1144  }
void RHN_sinW2_eff(triplet< double > &result)

◆ SI_muon_gm2()

void Gambit::PrecisionBit::SI_muon_gm2 ( triplet< double > &  result)

Calculation of g-2 with SuperIso.

Definition at line 1075 of file PrecisionBit.cpp.

References Gambit::triplet< TYPE >::central, Gambit::triplet< TYPE >::lower, muon_gm2, and Gambit::triplet< TYPE >::upper.

1076  {
1077  using namespace Pipes::SI_muon_gm2;
1078 
1079  #ifdef PRECISIONBIT_DEBUG
1080  cout<<"Starting SI_muon_gm2"<<endl;
1081  #endif
1082 
1083  struct parameters param = *Dep::SuperIso_modelinfo;
1084 
1085  if (param.model < 0)
1086  {
1087  result.central = 0.0;
1088  result.upper = 0.0;
1089  result.upper = 0.0;
1090  }
1091  else
1092  {
1093  result.central = BEreq::muon_gm2(&param);
1094  result.upper = std::max(std::abs(result.central)*0.3, 6e-10); //Based on hep-ph/0609168v1 eqs 84 & 85
1095  result.lower = result.upper;
1096  }
1097 
1098  #ifdef PRECISIONBIT_DEBUG
1099  printf("(g-2)_mu=%.3e\n",result.central);
1100  cout<<"Finished SI_muon_gm2"<<endl;
1101  #endif
1102  }
void SI_muon_gm2(triplet< double > &result)
Calculation of g-2 with SuperIso.
fh_Couplings libfeynhiggs muon_gm2

◆ SP_PrecisionObs()

void Gambit::PrecisionBit::SP_PrecisionObs ( double result)

Precision observables from SUSY-POPE This function is unfinished because SUSY-POPE is buggy.

Definition at line 1107 of file PrecisionBit.cpp.

1108  {
1109  using namespace Pipes::SP_PrecisionObs;
1110  int error = 0;
1111  Farray<Fdouble,1,35> SM_Obs;
1112  Farray<Fdouble,1,35> MSSM_Obs;
1113 
1114  BEreq::CalcObs_SUSYPOPE(error, SM_Obs, MSSM_Obs);
1115  if(error != 0)
1116  {
1117  std::cout << "something went wrong" << std::endl;
1118  }
1119  else
1120  {
1121  std::cout << " MW in SM = " << SM_Obs(1) << std::endl;
1122  std::cout << " MW in MSSM = " << MSSM_Obs(1) << std::endl;
1123  }
1124  result = 0.1;
1125  return;
1126 
1127  }
void SP_PrecisionObs(double &result)
Precision observables from SUSY-POPE This function is unfinished because SUSY-POPE is buggy...

◆ update_H_masses()

void Gambit::PrecisionBit::update_H_masses ( SubSpectrum HE,
int  n_higgs,
const str higgses,
int  central,
int  error,
std::vector< triplet< double > > &  MH,
bool  allow_fallback 
)

Helper function to set arbitrary number of H masses.

Definition at line 202 of file PrecisionBit.cpp.

References Gambit::SubSpectrum::get(), Gambit::invalid_point(), LOCAL_INFO, mh, Gambit::Par::Pole_Mass, Gambit::Par::Pole_Mass_1srd_high, Gambit::Par::Pole_Mass_1srd_low, Gambit::invalid_point_exception::raise(), and Gambit::SubSpectrum::set_override().

Referenced by make_MSSM_precision_spectrum_4H_W(), make_MSSM_precision_spectrum_H(), and make_MSSM_precision_spectrum_H_W().

203  {
204 
205  for (int i = 0; i < n_higgs; ++i)
206  {
207  if (MH[i].central <= 0.0 or Utils::isnan(MH[i].central))
208  {
209  if (allow_fallback) return;
210  invalid_point().raise("Precison "+higgses[i]+" mass NaN or <= 0. To allow fallback to the unimproved value, "
211  "set option allow_fallback_to_unimproved_masses=true in your YAML file.");
212  }
213  }
214 
215  // Central value:
216  // 1 = from precision calculator
217  // 2 = from spectrum calculator
218  // 3 = mean of precision mass and mass from spectrum calculator
219  std::vector<double> mh_s;
220  for (int i = 0; i < n_higgs; ++i) mh_s.push_back(HE.get(Par::Pole_Mass, higgses[i]));
221  double mh[n_higgs];
222 
223  #ifdef PRECISIONBIT_DEBUG
224  for (int i = 0; i < n_higgs; i++) cout << "h masses, spectrum generator: "<< mh_s[i] << endl;
225  for (int i = 0; i < n_higgs; i++) cout << "h masses, spectrum generator error low: "<< HE.get(Par::Pole_Mass_1srd_low, higgses[i])*mh_s[i] << endl;
226  for (int i = 0; i < n_higgs; i++) cout << "h masses, spectrum generator error high: "<< HE.get(Par::Pole_Mass_1srd_high, higgses[i])*mh_s[i] << endl;
227  for (int i = 0; i < n_higgs; i++) cout << "h masses, precision calculation: "<< MH[i].central << endl;
228  for (int i = 0; i < n_higgs; i++) cout << "h masses, precision calculation error low: "<< MH[i].lower << endl;
229  for (int i = 0; i < n_higgs; i++) cout << "h masses, precision calculation error high: "<< MH[i].upper << endl;
230  #endif
231 
232  if (central == 1)
233  {
234  for (int i = 0; i < n_higgs; i++) mh[i] = MH[i].central;
235  }
236  else if (central == 2)
237  {
238  for (int i = 0; i < n_higgs; i++) mh[i] = mh_s[i];
239  }
240  else if (central == 3)
241  {
242  for (int i = 0; i < n_higgs; i++) mh[i] = 0.5*(MH[i].central + mh_s[i]);
243  }
244  else
245  {
246  std::stringstream msg;
247  msg << "Unrecognised Higgs_predictions_source option specified for making MSSM precision spectrum: " << central;
248  PrecisionBit_error().raise(LOCAL_INFO,msg.str());
249  }
250  if (central != 2)
251  {
252  for (int i = 0; i < n_higgs; i++) HE.set_override(Par::Pole_Mass, mh[i], higgses[i]);
253  }
254 
255  // Uncertainties:
256  // Definitions: D_s = error on mass from spectrum calculator
257  // D_p = error on mass from precision calculator
258  // D_g = difference between central values from spectrum generator and precision calculator
259  // 1 = sum in quadrature of D_s, D_p and D_g
260  // 2 = range around chosen central (RACC), with D_s and D_p taken at their respective edges.
261  // 3 = RACC, with 1/2 * D_g taken at both edges.
262  // 4 = RACC, with 1/2 * D_g taken at the spectrum-generator edge, D_p taken at the other edge.
263  // 5 = RACC, with 1/2 * D_g taken at the precision-calculator edge, D_s taken at the other edge.
264  std::vector<double> D_g;
265  for (int i = 0; i < n_higgs; ++i) D_g.push_back(MH[i].central - mh_s[i]);
266  double mh_low[n_higgs], mh_high[n_higgs];
267 
268  // 1 = sum in quadrature of D_s, D_p and D_g
269  if (error == 1)
270  {
271  for (int i = 0; i < n_higgs; i++)
272  {
273  double D_s_low = HE.get(Par::Pole_Mass_1srd_low, higgses[i])*mh_s[i];
274  double D_s_high = HE.get(Par::Pole_Mass_1srd_high, higgses[i])*mh_s[i];
275  double D_p_low = MH[i].lower;
276  double D_p_high = MH[i].upper;
277  mh_low[i] = sqrt(D_s_low*D_s_low + D_p_low*D_p_low + D_g[i]*D_g[i]);
278  mh_high[i] = sqrt(D_s_high*D_s_high + D_p_high*D_p_high + D_g[i]*D_g[i]);
279  }
280  }
281 
282  // 2 = range around chosen central (RACC), with D_s and D_p taken at their respective edges.
283  else if (error == 2)
284  {
285  for (int i = 0; i < n_higgs; i++)
286  {
287  double D_s_low = mh_s[i]*HE.get(Par::Pole_Mass_1srd_low, higgses[i]);
288  double D_s_high = mh_s[i]*HE.get(Par::Pole_Mass_1srd_high, higgses[i]);
289  double D_p_low = MH[i].lower;
290  double D_p_high = MH[i].upper;
291  if (central == 1) // Using precision calculator mass as central value
292  {
293  if (D_g[i] >= 0) // Precision calculator mass is higher than spectrum generator mass
294  {
295  mh_low[i] = D_g[i] + D_s_low;
296  mh_high[i] = D_p_high;
297  }
298  else // Precision calculator mass is lower than spectrum generator mass
299  {
300  mh_low[i] = D_p_low;
301  mh_high[i] = D_s_high-D_g[i];
302  }
303  }
304  else if (central == 2) // Using spectrum generator mass as central value
305  {
306  if (D_g[i] >= 0) // Precision calculator mass is higher than spectrum generator mass
307  {
308  mh_low[i] = D_s_low;
309  mh_high[i] = D_g[i] + D_p_high;
310  }
311  else // Precision calculator mass is lower than spectrum generator mass
312  {
313  mh_low[i] = D_p_low-D_g[i];
314  mh_high[i] = D_s_high;
315  }
316  }
317  else // Using mean of spectrum gen and precision calc as central value
318  {
319  if (D_g[i] >= 0) // Precision calculator mass is higher than spectrum generator mass
320  {
321  mh_low[i] = 0.5*D_g[i] + D_s_low;
322  mh_high[i] = 0.5*D_g[i] + D_p_high;
323  }
324  else // Precision calculator mass is lower than spectrum generator mass
325  {
326  mh_low[i] = D_p_low - 0.5*D_g[i];
327  mh_high[i] = D_s_high - 0.5*D_g[i];
328  }
329  }
330  }
331  }
332 
333  // 3 = RACC, with 1/2 * D_g taken at both edges.
334  else if (error == 3)
335  {
336  for (int i = 0; i < n_higgs; i++)
337  {
338  if (central == 1) // Using precision calculator mass as central value
339  {
340  if (D_g[i] >= 0) // Precision calculator mass is higher than spectrum generator mass
341  {
342  mh_low[i] = 1.5*D_g[i];
343  mh_high[i] = 0.5*D_g[i];
344  }
345  else // Precision calculator mass is lower than spectrum generator mass
346  {
347  mh_low[i] = -0.5*D_g[i];
348  mh_high[i] = -1.5*D_g[i];
349  }
350  }
351  else if (central == 2) // Using spectrum generator mass as central value
352  {
353  if (D_g[i] >= 0) // Precision calculator mass is higher than spectrum generator mass
354  {
355  mh_low[i] = 0.5*D_g[i];
356  mh_high[i] = 1.5*D_g[i];
357  }
358  else // Precision calculator mass is lower than spectrum generator mass
359  {
360  mh_low[i] = -1.5*D_g[i];
361  mh_high[i] = -0.5*D_g[i];
362  }
363  }
364  else // Using mean of spectrum gen and precision calc as central value
365  {
366  mh_low[i] = fabs(D_g[i]);
367  mh_high[i] = mh_low[i];
368  }
369  }
370  }
371 
372  // 4 = RACC, with 1/2 * D_g taken at the spectrum-generator edge, D_p taken at the other edge.
373  else if (error == 4)
374  {
375  for (int i = 0; i < n_higgs; i++)
376  {
377  double D_p_low = MH[i].lower;
378  double D_p_high = MH[i].upper;
379  if (central == 1) // Using precision calculator mass as central value
380  {
381  if (D_g[i] >= 0) // Precision calculator mass is higher than spectrum generator mass
382  {
383  mh_low[i] = 1.5*D_g[i];
384  mh_high[i] = D_p_high;
385  }
386  else // Precision calculator mass is lower than spectrum generator mass
387  {
388  mh_low[i] = D_p_low;
389  mh_high[i] = -1.5*D_g[i];
390  }
391  }
392  else if (central == 2) // Using spectrum generator mass as central value
393  {
394  if (D_g[i] >= 0) // Precision calculator mass is higher than spectrum generator mass
395  {
396  mh_low[i] = 0.5*D_g[i];
397  mh_high[i] = D_g[i] + D_p_high;
398  }
399  else // Precision calculator mass is lower than spectrum generator mass
400  {
401  mh_low[i] = D_p_low-D_g[i];
402  mh_high[i] = -0.5*D_g[i];
403  }
404  }
405  else // Using mean of spectrum gen and precision calc as central value
406  {
407  if (D_g[i] >= 0) // Precision calculator mass is higher than spectrum generator mass
408  {
409  mh_low[i] = D_g[i];
410  mh_high[i] = 0.5*D_g[i] + D_p_high;
411  }
412  else // Precision calculator mass is lower than spectrum generator mass
413  {
414  mh_low[i] = D_p_low - 0.5*D_g[i];
415  mh_high[i] = -D_g[i];
416  }
417  }
418  }
419  }
420 
421  // 5 = RACC, with 1/2 * D_g taken at the precision-calculator edge, D_s taken at the other edge.
422  else if (error == 5)
423  {
424  for (int i = 0; i < n_higgs; i++)
425  {
426  double D_s_low = mh_s[i]*HE.get(Par::Pole_Mass_1srd_low, higgses[i]);
427  double D_s_high = mh_s[i]*HE.get(Par::Pole_Mass_1srd_high, higgses[i]);
428  if (central == 1) // Using precision calculator mass as central value
429  {
430  if (D_g[i] >= 0) // Precision calculator mass is higher than spectrum generator mass
431  {
432  mh_low[i] = D_g[i] + D_s_low;
433  mh_high[i] = 0.5*D_g[i];
434  }
435  else // Precision calculator mass is lower than spectrum generator mass
436  {
437  mh_low[i] = -0.5*D_g[i];
438  mh_high[i] = D_s_high-D_g[i];
439  }
440  }
441  else if (central == 2) // Using spectrum generator mass as central value
442  {
443  if (D_g[i] >= 0) // Precision calculator mass is higher than spectrum generator mass
444  {
445  mh_low[i] = D_s_low;
446  mh_high[i] = 1.5*D_g[i];
447  }
448  else // Precision calculator mass is lower than spectrum generator mass
449  {
450  mh_low[i] = -1.5*D_g[i];
451  mh_high[i] = D_s_high;
452  }
453  }
454  else // Using mean of spectrum gen and precision calc as central value
455  {
456  if (D_g[i] >= 0) // Precision calculator mass is higher than spectrum generator mass
457  {
458  mh_low[i] = 0.5*D_g[i] + D_s_low;
459  mh_high[i] = D_g[i];
460  }
461  else // Precision calculator mass is lower than spectrum generator mass
462  {
463  mh_low[i] = -D_g[i];
464  mh_high[i] = D_s_high - 0.5*D_g[i];
465  }
466  }
467  }
468  }
469 
470  // >5 = failure
471  else
472  {
473  std::stringstream msg;
474  msg << "Unrecognised Higgs_predictions_error_method specified for make_MSSM_precision_spectrum: " << central;
475  PrecisionBit_error().raise(LOCAL_INFO,msg.str());
476  }
477 
478  // Finally, set the errors.
479  for (int i = 0; i < n_higgs; i++) HE.set_override(Par::Pole_Mass_1srd_low, mh_low[i]/mh[i], higgses[i], true);
480  for (int i = 0; i < n_higgs; i++) HE.set_override(Par::Pole_Mass_1srd_high, mh_high[i]/mh[i], higgses[i], true);
481 
482  #ifdef PRECISIONBIT_DEBUG
483  for (int i = 0; i < n_higgs; i++) cout << "h masses, central: "<< HE.get(Par::Pole_Mass, higgses[i])<< endl;
484  for (int i = 0; i < n_higgs; i++) cout << "h masses, fractional low: "<< HE.get(Par::Pole_Mass_1srd_low, higgses[i])<< endl;
485  for (int i = 0; i < n_higgs; i++) cout << "h masses, fractional high: " << HE.get(Par::Pole_Mass_1srd_high, higgses[i])<<endl;
486  #endif
487  }
#define LOCAL_INFO
Definition: local_info.hpp:34
virtual void raise(const std::string &)
Raise the exception, i.e. throw it. Exact override of base method.
Definition: exceptions.cpp:422
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum mh
invalid_point_exception & invalid_point()
Invalid point exceptions.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ update_W_masses()

void Gambit::PrecisionBit::update_W_masses ( SubSpectrum HE,
SubSpectrum LE,
const triplet< double > &  prec_mw,
bool  allow_fallback 
)

Helper function to set W masses.

Definition at line 185 of file PrecisionBit.cpp.

References Gambit::triplet< TYPE >::central, Gambit::invalid_point(), Gambit::triplet< TYPE >::lower, Gambit::Par::Pole_Mass, Gambit::Par::Pole_Mass_1srd_high, Gambit::Par::Pole_Mass_1srd_low, Gambit::invalid_point_exception::raise(), Gambit::SubSpectrum::set_override(), and Gambit::triplet< TYPE >::upper.

Referenced by make_MSSM_precision_spectrum_4H_W(), make_MSSM_precision_spectrum_H_W(), and make_MSSM_precision_spectrum_W().

186  {
187  if (prec_mw.central <= 0.0 or Utils::isnan(prec_mw.central))
188  {
189  if (allow_fallback) return;
190  invalid_point().raise("Precison W mass NaN or <= 0. To allow fallback to the unimproved value, "
191  "set option allow_fallback_to_unimproved_masses=true in your YAML file.");
192  }
193  HE.set_override(Par::Pole_Mass, prec_mw.central, "W+", true); // "true" flag causes overrides to be written even if no native quantity exists to override.
194  HE.set_override(Par::Pole_Mass_1srd_high, prec_mw.upper/prec_mw.central, "W+", true);
195  HE.set_override(Par::Pole_Mass_1srd_low, prec_mw.lower/prec_mw.central, "W+", true);
196  LE.set_override(Par::Pole_Mass, prec_mw.central, "W+"); // No flag; W mass should definitely already exist in the LE spectrum.
197  LE.set_override(Par::Pole_Mass_1srd_high, prec_mw.upper/prec_mw.central, "W+", true);
198  LE.set_override(Par::Pole_Mass_1srd_low, prec_mw.lower/prec_mw.central, "W+", true);
199  }
virtual void raise(const std::string &)
Raise the exception, i.e. throw it. Exact override of base method.
Definition: exceptions.cpp:422
fh_Couplings libfeynhiggs fh_PrecisionObs prec_mw
invalid_point_exception & invalid_point()
Invalid point exceptions.
Here is the call graph for this function:
Here is the caller graph for this function: