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

Classes

class  MDMSpec
 
struct  MSSM_strs
 This struct contains all the strings we will use for the MSSM in the maps. More...
 
class  MSSMSpec
 
class  ScalarSingletDM_Z2Spec
 
class  ScalarSingletDM_Z3Spec
 
struct  SMHiggsModel
 Simple container "model object" for the SM Higgs sector variables. More...
 
class  SMHiggsSimpleSpec
 SubSpectrum wrapper class for the SM Higgs sector. More...
 

Functions

void add_error (std::ostringstream &out, const std::exception &e, const std::string &msg)
 
void exampleRead (bool &result)
 
void make_test_spectrum (SubSpectrum *&result)
 Create a spectrum object for testing purposes. More...
 
void specbit_test_func1 (double &result)
 Function to test out SpecBit features. More...
 
void specbit_test_func2 (double &result)
 Function to test out SpecBit features. More...
 
void specbit_test_func3 (double &result)
 Function to test out SpecBit features. More...
 
void specbit_test_Spectrum (double &result)
 Test out consistency of Spectrum object (and pre-extracted SM SubSpectrum*) More...
 
void specbit_test_show_SMInputs (double &result)
 Display SMInputs values. More...
 
void test_Singlet_spectrum (bool &result)
 Check that the SingletDM spectrum object is working. More...
 
template<class Model >
double get_sinthW2_MSbar (const Model &model)
 
template<class Model >
double get_tanbeta (const Model &model)
 
template<class Model >
double get_DRbar_mA2 (const Model &model)
 
template<class Model >
double get_sinthW2_DRbar (const Model &model)
 
template<class Model >
double get_MAh1_pole_slha (const Model &model)
 
template<class Model >
double get_MHpm1_pole_slha (const Model &model)
 
template<class Model >
double get_neutral_goldstone_pole_slha (const Model &model)
 
template<class Model >
double get_charged_goldstone_pole_slha (const Model &model)
 
template<class Model >
void set_MSu_pole_slha (Model &model, double mass, int i)
 
template<class Model >
void set_MSd_pole_slha (Model &model, double mass, int i)
 
template<class Model >
void set_MSe_pole_slha (Model &model, double mass, int i)
 
template<class Model >
void set_MSv_pole_slha (Model &model, double mass, int i)
 
template<class Model >
void set_MCha_pole_slha (Model &model, double mass, int i)
 
template<class Model >
void set_MChi_pole_slha (Model &model, double mass, int i)
 
template<class Model >
void set_Mhh_pole_slha (Model &model, double mass, int i)
 
template<class Model >
void set_ZD_pole_slha (Model &model, double mass, int i, int j)
 
template<class Model >
void set_ZU_pole_slha (Model &model, double mass, int i, int j)
 
template<class Model >
void set_ZE_pole_slha (Model &model, double mass, int i, int j)
 
template<class Model >
void set_ZV_pole_slha (Model &model, double mass, int i, int j)
 
template<class Model >
void set_ZH_pole_slha (Model &model, double mass, int i, int j)
 
template<class Model >
void set_ZA_pole_slha (Model &model, double mass, int i, int j)
 
template<class Model >
void set_ZP_pole_slha (Model &model, double mass, int i, int j)
 
template<class Model >
void set_ZN_pole_slha (Model &model, double mass, int i, int j)
 
template<class Model >
void set_UM_pole_slha (Model &model, double mass, int i, int j)
 
template<class Model >
void set_UP_pole_slha (Model &model, double mass, int i, int j)
 
template<class Model >
void set_MAh1_pole_slha (Model &model, double mass)
 
template<class Model >
void set_MHpm1_pole_slha (Model &model, double mass)
 
template<class Model >
void set_neutral_goldstone_pole_slha (Model &model, double mass)
 
template<class Model >
void set_charged_goldstone_pole_slha (Model &model, double mass)
 
template<class Model >
void set_MGluino_pole_slha (Model &model, double mass)
 
template<class Model >
void set_MZ_pole_slha (Model &model, double mass)
 
template<class Model >
void set_MW_pole_slha (Model &model, double mass)
 
template<class Model >
double get_sinthW2_MSbar2 (const Model &model)
 
template<class Model >
void set_Mhh_pole_slha (Model &model, double mass)
 
template<class Model >
void set_Mss_pole_slha (Model &model, double mass)
 
bool print_error (bool pass, std::string get_type, std::string data, double sting_get_out, double data_member, int i=-1, int j=-1)
 
void print_error (std::string get_type, std::string name, double sting_get_out, double data_member, int i=-1, int j=-1)
 
bool test_getters (std::string get_type, std::string name, double getter_output, double data_member, int i=-1, int j=-1)
 
template<class M >
bool TestMssmParMass2_0 (SubSpectrum *spec, M FSmssm, bool immediate_exit=true)
 Module convenience functions. More...
 
template<class MI >
bool TestMssmParMass2_0 (MSSMSpec< MI > &mssm, typename MI::Model &FSmssm, bool immediate_exit=true)
 
template<class M >
bool TestMssmParMass2_2 (SubSpectrum *spec, M FSmssm, bool immediate_exit=true)
 
template<class MI >
bool TestMssmParMass2_2 (MSSMSpec< MI > &mssm, typename MI::Model &FSmssm, bool immediate_exit=true)
 
template<class M >
bool TestMssmParMass1_0 (SubSpectrum *spec, M FSmssm, bool immediate_exit=true)
 
template<class MI >
bool TestMssmParMass1_0 (MSSMSpec< MI > &mssm, typename MI::Model &FSmssm, bool immediate_exit=true)
 
template<class M >
bool TestMssmParMass1_2 (SubSpectrum *spec, M FSmssm, bool immediate_exit=true)
 
template<class MI >
bool TestMssmParMass1_2 (MSSMSpec< MI > &mssm, typename MI::Model &FSmssm, bool immediate_exit=true)
 
template<class M >
bool TestMssmParMass0_0 (SubSpectrum *spec, M FSmssm, bool immediate_exit=true)
 
template<class MI >
bool TestMssmParMass0_0 (MSSMSpec< MI > &mssm, typename MI::Model &FSmssm, bool immediate_exit=true)
 
template<class M >
bool TestMssmParMass0_2 (SubSpectrum *spec, M FSmssm, bool immediate_exit=true)
 
template<class MI >
bool TestMssmParMass0_2 (MSSMSpec< MI > &mssm, typename MI::Model &FSmssm, bool immediate_exit=true)
 
template<class M >
bool TestMssmPoleGets0 (SubSpectrum *spec, M FSmssm, bool immediate_exit=true)
 
template<class MI >
bool TestMssmPoleGets0 (MSSMSpec< MI > &mssm, typename MI::Model &FSmssm, bool immediate_exit=true)
 
template<class M >
bool TestMssmPoleGets1 (SubSpectrum *spec, M FSmssm, bool immediate_exit=true)
 
template<class MI >
bool TestMssmPoleGets1 (MSSMSpec< MI > &mssm, typename MI::Model &FSmssm, bool immediate_exit=true)
 
template<class M >
bool TestMssmPoleMixingGets2 (SubSpectrum *spec, M FSmssm, bool immediate_exit=true)
 
template<class MI >
bool TestMssmPoleMixingGets2 (MSSMSpec< MI > &mssm, typename MI::Model &FSmssm, bool immediate_exit=true)
 
template<class M >
bool TestMssmPoleGets (SubSpectrum *spec, M FSmssm)
 
template<class MI >
bool TestMssmPoleGets (MSSMSpec< MI > &mssm, typename MI::Model &FSmssm)
 
template<class M >
bool TestMssmParGets (SubSpectrum *spec, M FSmssm)
 
template<class MI >
bool TestMssmParGets (MSSMSpec< MI > &mssm, typename MI::Model &FSmssm)
 
template<class Model >
void setup (Model &mssm)
 
template<class MI >
bool test_exact (MSSMSpec< MI > &mssm, typename MI::Model &FS_model_slha)
 
template<class M >
double test_exact (SubSpectrum *spec, M FS_model_slha)
 
template<class MI >
bool running_test (MSSMSpec< MI > &mssm, typename MI::Model &FS_model_slha, double tol)
 
template<class Model >
bool running_test (SubSpectrum *spec, Model &FS_model_slha, double tol)
 
bool test_within_tol (double a, double b, double tol, std::string label)
 
void Spectrum_test (Spectrum matched_spectra, const SubSpectrum *smin, bool SLHAonly=0)
 
double get_mUp (const softsusy::QedQcd &model)
 Plain C-function wrappers for QedQcd running mass getters. More...
 
double get_mCharm (const softsusy::QedQcd &model)
 
double get_mTop (const softsusy::QedQcd &model)
 
double get_mDown (const softsusy::QedQcd &model)
 
double get_mStrange (const softsusy::QedQcd &model)
 
double get_mBottom (const softsusy::QedQcd &model)
 
double get_mElectron (const softsusy::QedQcd &model)
 
double get_mMuon (const softsusy::QedQcd &model)
 
double get_mTau (const softsusy::QedQcd &model)
 
double get_mPhoton (const softsusy::QedQcd &)
 
double get_mGluon (const softsusy::QedQcd &)
 
double get_alpha (const softsusy::QedQcd &model)
 Plain C-function wrappers for QedQcd running coupling getters. More...
 
double get_alphaS (const softsusy::QedQcd &model)
 
double get_a1 (const softsusy::QedQcd &)
 All 3 SM gauge couplings. More...
 
double get_Pole_mElectron (const SMInputs &inputs)
 Plain C-function wrappers for extra pole mass getters (manually specified masses) More...
 
double get_Pole_mMuon (const SMInputs &inputs)
 
double get_Pole_mNu1 (const SMInputs &inputs)
 
double get_Pole_mNu2 (const SMInputs &inputs)
 
double get_Pole_mNu3 (const SMInputs &inputs)
 
double get_Pole_mPhoton (const SMInputs &)
 
double get_Pole_mGluon (const SMInputs &)
 
double get_sinthW2_pole (const softsusy::QedQcd &qedqcd)
 
void set_Pole_mElectron (SMInputs &inputs, double set_value)
 Plain C-function wrappers for extra pole mass setters (manually specified masses) More...
 
void get_DiracSingletDM_Z2_spectrum (Spectrum &result)
 Get a (simple) Spectrum object wrapper for the DiracSingletDM_Z2 model. More...
 
void fill_map_from_DiracSingletDM_Z2spectrum (std::map< std::string, double > &, const Spectrum &)
 
void get_DiracSingletDM_Z2_spectrum_as_map (std::map< std::string, double > &specmap)
 
void get_MajoranaSingletDM_Z2_spectrum (Spectrum &result)
 Get a (simple) Spectrum object wrapper for the MajoranaSingletDM_Z2 model. More...
 
void fill_map_from_MajoranaSingletDM_Z2spectrum (std::map< std::string, double > &, const Spectrum &)
 
void get_MajoranaSingletDM_Z2_spectrum_as_map (std::map< std::string, double > &specmap)
 
template<class MI , class SI >
Spectrum run_FS_spectrum_generator (const typename MI::InputParameters &input, const SMInputs &sminputs, const Options &runOptions, const std::map< str, safe_ptr< const double > > &input_Param)
 
template<class T >
void fill_MDM_input (T &input, const std::map< str, safe_ptr< const double > > &Param, SMInputs sminputs)
 
bool check_perturb_MDM (const Spectrum &spec, double scale, int pts)
 
void find_non_perturb_scale_MDM (double &result)
 
void fill_map_from_MDMspectrum (std::map< std::string, double > &, const Spectrum &)
 Print MDM spectrum out. Stripped down copy from MSSM version with variable names changed. More...
 
void get_MDM_spectrum_as_map (std::map< std::string, double > &specmap)
 
void get_SM_SubSpectrum_from_MSSM_Spectrum (const SubSpectrum *&result)
 Retrieve SubSpectrum* to SM LE model from Spectrum object DEPENDENCY(MSSM_spectrum, Spectrum) More...
 
void get_MSSM_spectrum_as_SLHAea_SLHA1 (SLHAstruct &result)
 Extract an SLHAea version of the spectrum contained in a Spectrum object, in SLHA1 format. More...
 
void get_MSSM_spectrum_as_SLHAea_SLHA2 (SLHAstruct &result)
 Extract an SLHAea version of the spectrum contained in a Spectrum object, in SLHA2 format. More...
 
void get_MSSM_spectrum_from_SLHAfile (Spectrum &result)
 Get an MSSMSpectrum object from an SLHA file Wraps it up in MSSMSimpleSpec; i.e. More...
 
void get_MSSM_spectrum_from_SLHAstruct (Spectrum &result)
 Get an MSSMSpectrum object from an SLHAstruct Wraps it up in MSSMSimpleSpec; i.e. More...
 
void FH_MSSMMasses (fh_MSSMMassObs &result)
 FeynHiggs SUSY masses and mixings. More...
 
void FH_AllHiggsMasses (fh_HiggsMassObs &result)
 Higgs masses and mixings with theoretical uncertainties. More...
 
void FH_Couplings (fh_Couplings &result)
 Call FH_Couplings from FeynHiggs and collect the output. More...
 
std::vector< strget_invisibles (const SubSpectrum &spec)
 Helper function to work out if the LSP is invisible, and if so, which particle it is. More...
 
void MSSM_higgs_couplings_pwid (HiggsCouplingsTable &result)
 Put together the Higgs couplings for the MSSM, from partial widths only. More...
 
void MSSM_higgs_couplings_FH (HiggsCouplingsTable &result)
 Put together the Higgs couplings for the MSSM, using FeynHiggs. More...
 
void FH_HiggsMass (triplet< double > &result)
 
void FH_HeavyHiggsMasses (map_int_triplet_dbl &result)
 
void SHD_HiggsMass (triplet< double > &result)
 
void get_ScalarSingletDM_Z2_spectrum (Spectrum &result)
 Get a (simple) Spectrum object wrapper for the ScalarSingletDM_Z2 model. More...
 
void get_ScalarSingletDM_Z3_spectrum (Spectrum &result)
 Get a (simple) Spectrum object wrapper for the ScalarSingletDM_Z3 model. More...
 
template<class T >
void fill_ScalarSingletDM_input (T &input, const std::map< str, safe_ptr< const double > > &Param, SMInputs sminputs)
 
template<class T >
void fill_extra_input (T &input, const std::map< str, safe_ptr< const double > > &Param)
 
bool check_perturb (const Spectrum &spec, const std::vector< SpectrumParameter > &required_parameters, double scale, int pts)
 
void ScalarSingletDM_higgs_couplings_pwid (HiggsCouplingsTable &result)
 Put together the Higgs couplings for the ScalarSingletDM models, from partial widths only. More...
 
void fill_map_from_ScalarSingletDM_spectrum (std::map< std::string, double > &specmap, const Spectrum &singletdmspec, const std::vector< SpectrumParameter > &required_parameters)
 Print ScalarSingletDM spectra out. Stripped down copy of MSSM version with variable names changed. More...
 
void get_ScalarSingletDM_Z2_spectrum_as_map (std::map< std::string, double > &specmap)
 
void get_ScalarSingletDM_Z3_spectrum_as_map (std::map< std::string, double > &specmap)
 
void get_QedQcd_spectrum (const SubSpectrum *&result)
 Construct a SubSpectrum object from SMInputs using QedQcdWrapper. More...
 
void get_SM_spectrum (Spectrum &result)
 Get a Spectrum object wrapper for Standard-Model-only information. More...
 
void SM_higgs_couplings (HiggsCouplingsTable &result)
 Put together the SM Higgs couplings. More...
 
void Math_test (bool &result)
 
void SUSYHD_test (bool &result)
 
void SPheno_MSSM_test (bool &result)
 
void MSSMspectrum_test (bool &result)
 Verify consistency of the contents of a Spectrum object of capability MSSMspectrum. More...
 
void light_quark_test (bool &)
 
void get_VectorSingletDM_Z2_spectrum (Spectrum &result)
 Get a (simple) Spectrum object wrapper for the VectorSingletDM_Z2 model. More...
 
void fill_map_from_VectorSingletDM_Z2spectrum (std::map< std::string, double > &, const Spectrum &)
 
void get_VectorSingletDM_Z2_spectrum_as_map (std::map< std::string, double > &specmap)
 
void check_EW_stability_ScalarSingletDM_Z3 (double &result)
 
bool check_perturb_to_min_lambda (const Spectrum &spec, double scale, int pts, const std::vector< SpectrumParameter > required_parameters)
 
double run_lambda (double scale, void *params)
 
void find_min_lambda_Helper (dbl_dbl_bool &vs_tuple, const Spectrum &fullspectrum, double high_energy_limit, int check_perturb_pts, const std::vector< SpectrumParameter > required_parameters)
 
void find_min_lambda_ScalarSingletDM_Z2 (dbl_dbl_bool &vs_tuple)
 
void find_min_lambda_ScalarSingletDM_Z3 (dbl_dbl_bool &vs_tuple)
 
void find_min_lambda_MDM (dbl_dbl_bool &vs_tuple)
 
void get_expected_vacuum_lifetime (double &lifetime)
 
void lnL_highscale_vacuum_decay_single_field (double &result)
 
void get_lambdaB (double &result)
 
void check_perturb_min_lambda (double &result)
 
void setup_QedQcd (softsusy::QedQcd &oneset, const SMInputs &sminputs)
 Non-Gambit helper functions. More...
 
void get_SMINPUTS (SMInputs &result)
 Gambit module functions. More...
 
template<class MI >
Spectrum run_FS_spectrum_generator (const typename MI::InputParameters &input, const SMInputs &sminputs, const Options &runOptions, const std::map< str, safe_ptr< const double > > &input_Param)
 Non-Gambit convenience functions. More...
 
Eigen::Matrix< double, 3, 3 > fill_3x3_parameter_matrix (const std::string &rootname, const std::map< str, safe_ptr< const double > > &Param)
 Helper function for setting 3x3 matrix-valued parameters. More...
 
Eigen::Matrix< double, 3, 3 > fill_3x3_symmetric_parameter_matrix (const std::string &rootname, const std::map< str, safe_ptr< const double > > &Param)
 As above, but for symmetric input (i.e. 6 entries, assumed to be the upper triangle) More...
 
template<class T >
void fill_MSSM63_input (T &input, const std::map< str, safe_ptr< const double > > &Param)
 Helper function for filling MSSM63-compatible input parameter objects Leaves out mHu2, mHd2, SignMu, (mA, mu) because we use two different parameterisations of these. More...
 
template<class T >
void fill_MSSM63_input_altnames (T &input, const std::map< str, safe_ptr< const double > > &Param)
 
bool has_neutralino_LSP (const Spectrum &result)
 Check that the spectrum has a neutralino LSP. More...
 
bool has_neutralino_LSP (const Spectrum *result)
 Helper to work with pointer. More...
 
void convert_MSSM_to_SM (Spectrum &result)
 Gambit module functions. More...
 
void convert_NMSSM_to_SM (Spectrum &result)
 
void convert_E6MSSM_to_SM (Spectrum &result)
 
void get_MSSM_spectrum_SPheno (Spectrum &spectrum)
 
void get_GUTMSSMB_spectrum (Spectrum &)
 
template<class Contents >
void fill_map_from_subspectrum (std::map< std::string, double > &, const SubSpectrum &)
 Convert MSSM type Spectrum object into a map, so it can be printed. More...
 
void add_extra_MSSM_parameter_combinations (std::map< std::string, double > &specmap, const SubSpectrum &mssm)
 Adds additional information from interesting combinations of MSSM parameters. More...
 
void get_MSSM_spectrum_as_map (std::map< std::string, double > &specmap)
 
void get_unimproved_MSSM_spectrum_as_map (std::map< std::string, double > &specmap)
 

Function Documentation

◆ add_error()

void Gambit::SpecBit::add_error ( std::ostringstream &  out,
const std::exception &  e,
const std::string &  msg 
)

Definition at line 44 of file SpecBit_examples.cpp.

45  {
46  out << "------------------------------" << std::endl;
47  out << "TEST FAIL: " << msg << std::endl;
48  out << "Exception thrown was: "<<e.what()<<std::endl;
49  return;
50  }

◆ add_extra_MSSM_parameter_combinations()

void Gambit::SpecBit::add_extra_MSSM_parameter_combinations ( std::map< std::string, double > &  specmap,
const SubSpectrum mssm 
)

Adds additional information from interesting combinations of MSSM parameters.

Determine which states are the third gens then add them for printing

Since this is for printing we only want to invalidate the point if this is completely wrong. We can also plot the mixing if we are suspicious.

return mass eigenstate strings that best represent required gauge eigenstate

Definition at line 1653 of file SpecBit_MSSM.cpp.

References Gambit::Par::dimensionless, Gambit::slhahelp::family_state_mix_matrix(), Gambit::SubSpectrum::get(), LOCAL_INFO, Gambit::Par::mass1, Gambit::slhahelp::mass_es_from_gauge_es(), and Gambit::Par::Pole_Mass.

Referenced by get_MSSM_spectrum_as_map(), and get_unimproved_MSSM_spectrum_as_map().

1654  {
1655  double At = 0;
1656  double Ab = 0;
1657  const double Yt = mssm.get(Par::dimensionless, "Yu", 3, 3);
1658  const double Yb = mssm.get(Par::dimensionless, "Yd", 3, 3);
1659  if(std::abs(Yt) > 1e-12)
1660  {
1661  At = mssm.get(Par::mass1, "TYu", 3, 3) / Yt;
1662  }
1663  if(std::abs(Yb) > 1e-12)
1664  {
1665  Ab = mssm.get(Par::mass1, "TYd", 3, 3) / Yb;
1666  }
1667 
1668  const double MuSUSY = mssm.get(Par::mass1, "Mu");
1669  const double tb = mssm.get(Par::dimensionless, "tanbeta");
1670 
1671  specmap["Xt"] = At - MuSUSY / tb;
1672  specmap["Xb"] = Ab - MuSUSY * tb;
1674  str msf1, msf2;
1678  const static double tol = 0.5;
1679  const static bool pt_error = true;
1680  slhahelp::family_state_mix_matrix("~u", 3, msf1, msf2, mssm, tol,
1681  LOCAL_INFO, pt_error);
1682  specmap["mstop1"] = mssm.get(Par::Pole_Mass, msf1);
1683  specmap["mstop2"] = mssm.get(Par::Pole_Mass, msf2);
1684  slhahelp::family_state_mix_matrix("~d", 3, msf1, msf2, mssm, tol,
1685  LOCAL_INFO, pt_error);
1686  specmap["msbottom1"] = mssm.get(Par::Pole_Mass, msf1);
1687  specmap["msbottom2"] = mssm.get(Par::Pole_Mass, msf2);
1688  slhahelp::family_state_mix_matrix("~e-", 3, msf1, msf2, mssm, tol,
1689  LOCAL_INFO, pt_error);
1690  specmap["mstau1"] = mssm.get(Par::Pole_Mass, msf1);
1691  specmap["mstau2"] = mssm.get(Par::Pole_Mass, msf2);
1694  const str gs_suL = slhahelp::mass_es_from_gauge_es("~u_L", mssm, tol,
1695  LOCAL_INFO, pt_error);
1696  specmap["msupL"] = mssm.get(Par::Pole_Mass,gs_suL);
1697  const str gs_scL = slhahelp::mass_es_from_gauge_es("~c_L", mssm, tol,
1698  LOCAL_INFO, pt_error);
1699  specmap["mscharmL"] = mssm.get(Par::Pole_Mass,gs_scL);
1700  const str gs_sdL = slhahelp::mass_es_from_gauge_es("~d_L", mssm, tol,
1701  LOCAL_INFO, pt_error);
1702  specmap["msdownL"] = mssm.get(Par::Pole_Mass,gs_sdL);
1703  const str gs_ssL = slhahelp::mass_es_from_gauge_es("~s_L", mssm, tol,
1704  LOCAL_INFO, pt_error);
1705  specmap["msstrangeL"] = mssm.get(Par::Pole_Mass,gs_ssL);
1706  const str gs_suR = slhahelp::mass_es_from_gauge_es("~u_R", mssm, tol,
1707  LOCAL_INFO, pt_error);
1708  specmap["msupR"] = mssm.get(Par::Pole_Mass,gs_suR);
1709  const str gs_scR = slhahelp::mass_es_from_gauge_es("~c_R", mssm, tol,
1710  LOCAL_INFO, pt_error);
1711  specmap["mscharmR"] = mssm.get(Par::Pole_Mass,gs_scR);
1712  const str gs_sdR = slhahelp::mass_es_from_gauge_es("~d_R", mssm, tol,
1713  LOCAL_INFO, pt_error);
1714  specmap["msdownR"] = mssm.get(Par::Pole_Mass,gs_sdR);
1715  const str gs_ssR = slhahelp::mass_es_from_gauge_es("~s_R", mssm, tol,
1716  LOCAL_INFO, pt_error);
1717  specmap["msstrangeR"] = mssm.get(Par::Pole_Mass,gs_ssR);
1718  const str gs_seL = slhahelp::mass_es_from_gauge_es("~e_L", mssm, tol,
1719  LOCAL_INFO, pt_error);
1720  specmap["mselectronL"] = mssm.get(Par::Pole_Mass,gs_seL);
1721  const str gs_sMuL = slhahelp::mass_es_from_gauge_es("~mu_L", mssm, tol,
1722  LOCAL_INFO, pt_error);
1723  specmap["msmuonL"] = mssm.get(Par::Pole_Mass,gs_sMuL);
1724  const str gs_seR = slhahelp::mass_es_from_gauge_es("~e_R", mssm, tol,
1725  LOCAL_INFO, pt_error);
1726  specmap["mselectronR"] = mssm.get(Par::Pole_Mass,gs_seR);
1727  const str gs_sMuR = slhahelp::mass_es_from_gauge_es("~mu_R", mssm, tol,
1728  LOCAL_INFO, pt_error);
1729  specmap["msmuonR"] = mssm.get(Par::Pole_Mass,gs_sMuR);
1730  const str gs_snu1 = slhahelp::mass_es_from_gauge_es("~nu_e_L", mssm, tol,
1731  LOCAL_INFO, pt_error);
1732  specmap["msnue"] = mssm.get(Par::Pole_Mass,gs_snu1);
1733  const str gs_snu2 = slhahelp::mass_es_from_gauge_es("~nu_mu_L", mssm, tol,
1734  LOCAL_INFO, pt_error);
1735  specmap["msnumu"] = mssm.get(Par::Pole_Mass,gs_snu2);
1736  const str gs_snu3 = slhahelp::mass_es_from_gauge_es("~nu_tau_L", mssm, tol,
1737  LOCAL_INFO, pt_error);
1738  specmap["msnutau"] = mssm.get(Par::Pole_Mass,gs_snu3);
1739 
1740  }
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...
#define LOCAL_INFO
Definition: local_info.hpp:34
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
str mass_es_from_gauge_es(str gauge_es, double &max_mixing, std::vector< double > &gauge_composition, const SubSpectrum &mssm)
indentifies the state with largest gauge_es content also fills largest max_mixing and full gauge_comp...
Here is the call graph for this function:
Here is the caller graph for this function:

◆ check_EW_stability_ScalarSingletDM_Z3()

void Gambit::SpecBit::check_EW_stability_ScalarSingletDM_Z3 ( double result)

Definition at line 55 of file SpecBit_VS.cpp.

References Gambit::Par::dimensionless, Gambit::Spectrum::get(), Gambit::invalid_point(), Gambit::Par::mass1, Gambit::Par::Pole_Mass, Gambit::Scanner::pow(), Gambit::invalid_point_exception::raise(), and ScalarSingletDM_Z3_spectrum.

56  {
57  // check that the electroweak scale stability conditions are satisfied
59 
61 
62  double lambda_h = fullspectrum.get(Par::dimensionless,"lambda_h");
63  double lambda_s = fullspectrum.get(Par::dimensionless,"lambda_S");
64  double lambda_hs = fullspectrum.get(Par::dimensionless,"lambda_hS");
65  double mu3 = fullspectrum.get(Par::mass1,"mu3");
66  double ms = fullspectrum.get(Par::Pole_Mass,"S");
67 
68  double check = 0;
69 
70  if ( (lambda_h*lambda_s > 0 ) )
71  {
72  check = 2 * pow( lambda_h * lambda_s , 0.5) + lambda_hs;
73  }
74  double check_2 = 2.*pow(abs(lambda_s),0.5)*ms - mu3;
75 
76  result = 0;
77 
78  // if any condition not satisfied set bad likelihood and invalidate point
79  if ( lambda_hs < 0 || lambda_s < 0 || check < 0 || check_2 < 0)
80  {
81  invalid_point().raise("Electroweak vacuum is unstable at low scale.");
82  result = -1e100;
83  }
84  }
std::chrono::milliseconds ms
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum ScalarSingletDM_Z3_spectrum
virtual void raise(const std::string &)
Raise the exception, i.e. throw it.
Definition: exceptions.cpp:422
Spectrum Spectrum
double pow(const double &a)
Outputs a^i.
invalid_point_exception & invalid_point()
Invalid point exceptions.
void check_EW_stability_ScalarSingletDM_Z3(double &result)
Definition: SpecBit_VS.cpp:55
Here is the call graph for this function:

◆ check_perturb()

bool Gambit::SpecBit::check_perturb ( const Spectrum spec,
const std::vector< SpectrumParameter > &  required_parameters,
double  scale,
int  pts 
)

Definition at line 322 of file SpecBit_ScalarSingletDM.cpp.

References Gambit::Spectrum::clone_HE(), Gambit::pi, and Gambit::Scanner::pow().

323  {
324  std::unique_ptr<SubSpectrum> ScalarSingletDM = spec.clone_HE();
325  double step = log10(scale) / pts;
326  double runto;
327  double ul = 4.0 * pi;
328 
329  for (int i=0;i<pts;i++)
330  {
331  runto = pow(10,step*float(i+1.0)); // scale to run spectrum to
332  if (runto<100){runto=100.0;}// avoid running to low scales
333 
334  ScalarSingletDM -> RunToScale(runto);
335 
336  for(std::vector<SpectrumParameter>::const_iterator it = required_parameters.begin();
337  it != required_parameters.end(); ++it)
338  {
339  const Par::Tags tag = it->tag();
340  const std::string name = it->name();
341  const std::vector<int> shape = it->shape();
342  std::ostringstream label;
343  label << name <<" "<< Par::toString.at(tag);
344 
345  if (name == "lambda_S"){ul = pi;}
346  else if (name == "lambda_h"){ul = 2*pi;}
347  else if (name == "lambda_hS"){ul = 4*pi;}
348  else {ul = 100;}
349 
350  if(shape.size()==1 and shape[0]==1)
351  {
352  if (abs(ScalarSingletDM->get(tag,name))>ul)
353  {
354  return false;
355  }
356  }
357  else if(shape.size()==1 and shape[0]>1)
358  {
359  for(int k = 1; k<=shape[0]; ++k)
360  {
361  if (abs(ScalarSingletDM->get(tag,name,k))>ul) return false;
362  }
363  }
364  else if(shape.size()==2)
365  {
366  for(int k = 1; k<=shape[0]; ++k)
367  {
368  for(int j = 1; j<=shape[0]; ++j)
369  {
370  if (abs(ScalarSingletDM->get(tag,name,k,j))>ul) return false;
371  }
372  }
373  }
374 
375  // check stability condition
376 
377  double lamhs = ScalarSingletDM->get(Par::dimensionless,"lambda_hS");
378  double lams = ScalarSingletDM->get(Par::dimensionless,"lambda_S");
379  double lamh = ScalarSingletDM->get(Par::dimensionless,"lambda_h");
380 
381  double stability_condition = 2.0 * pow(0.5* 0.25 * lamh*lams,0.5) + 0.5*lamhs;
382 
383  if (!(stability_condition > 0) && (lams>0) && (lamh>0))
384  {
385  //cout << "EW stability condition violated at Q = " << scale <<" , lambda_hs = "<< lamhs << "lamh = " << lamh << " lams = " << lams << endl;
386  return false;
387  }
388 
389  }
390  }
391 
392  return true;
393 
394  }
const double pi
double pow(const double &a)
Outputs a^i.
Here is the call graph for this function:

◆ check_perturb_MDM()

bool Gambit::SpecBit::check_perturb_MDM ( const Spectrum spec,
double  scale,
int  pts 
)

Definition at line 164 of file SpecBit_MDM.cpp.

References Gambit::SubSpectrumContents::all_parameters_with_tag(), Gambit::Spectrum::clone_HE(), Gambit::Par::dimensionless, fill_MDM_input(), Gambit::SubSpectrum::get(), Gambit::Options::getValueOrDef(), Gambit::invalid_point(), LOCAL_INFO, Gambit::pi, Gambit::Scanner::pow(), Gambit::invalid_point_exception::raise(), and SMINPUTS.

Referenced by find_non_perturb_scale_MDM().

165  {
166  using namespace flexiblesusy;
167  using namespace Gambit;
168  using namespace SpecBit;
169  std::unique_ptr<SubSpectrum> MDM = spec.clone_HE();
170  double step = log10(scale) / pts;
171  double runto;
172 
173  //const double ul = std::sqrt(4.0 * pi); // Maximum value for perturbative couplings, same perturbativity bound that FlexibleSUSY uses
174  double ul = 4.0 * pi;
175  for (int i=0;i<pts;i++)
176  {
177  runto = pow(10,step*float(i+1.0)); // scale to run spectrum to
178  if (runto<100){runto=100.0;}// avoid running to low scales
179 
180  try
181  {
182  MDM -> RunToScale(runto);
183  }
184  catch (const Error& error)
185  {
186  return false;
187  };
188 
189 
190 
191 
192  static const SpectrumContents::MDM contents;
193  static const std::vector<SpectrumParameter> required_parameters = contents.all_parameters_with_tag(Par::dimensionless);
194 
195  for(std::vector<SpectrumParameter>::const_iterator it = required_parameters.begin();
196  it != required_parameters.end(); ++it)
197  {
198  const Par::Tags tag = it->tag();
199  const std::string name = it->name();
200  const std::vector<int> shape = it->shape();
201  std::ostringstream label;
202  label << name <<" "<< Par::toString.at(tag);
203 
204  if (name == "lambda_h"){ul = 2*pi;}
205  else {ul = 4.0 * pi;}
206 
207  if(shape.size()==1 and shape[0]==1)
208  {
209  if (abs(MDM->get(tag,name))>ul)
210  {
211  return false;
212  }
213  }
214  else if(shape.size()==1 and shape[0]>1)
215  {
216  for(int k = 1; k<=shape[0]; ++k)
217  {
218  if (abs(MDM->get(tag,name,k))>ul) return false;
219  }
220  }
221  else if(shape.size()==2)
222  {
223  for(int k = 1; k<=shape[0]; ++k)
224  {
225  for(int j = 1; j<=shape[0]; ++j)
226  {
227  if (abs(MDM->get(tag,name,k,j))>ul) return false;
228  }
229  }
230  }
231 
232  }
233  }
234 
235  return true;
236 
237  }
GAMBIT error class.
Definition: exceptions.hpp:136
virtual double get(const Par::Tags, const str &, const SpecOverrideOptions=use_overrides, const SafeBool check_antiparticle=SafeBool(true)) const =0
const double pi
std::vector< SpectrumParameter > all_parameters_with_tag(Par::Tags tag) const
Function to retreive all parameters matching a certain tag.
double pow(const double &a)
Outputs a^i.
TODO: see if we can use this one:
Definition: Analysis.hpp:33
Here is the call graph for this function:
Here is the caller graph for this function:

◆ check_perturb_min_lambda()

void Gambit::SpecBit::check_perturb_min_lambda ( double result)

Definition at line 400 of file SpecBit_VS.cpp.

References Gambit::dbl_dbl_bool::flag, Gambit::invalid_point(), and Gambit::invalid_point_exception::raise().

401  {
402  namespace myPipe = Pipes::check_perturb_min_lambda;
403  dbl_dbl_bool vs_tuple = *myPipe::Dep::high_scale_vacuum_info;
404 
405  if (vs_tuple.flag)
406  {
407  invalid_point().raise("Couplings are non-perturbative before scale of vacuum instability");
408  result = -1e100;
409  }
410  else
411  {
412  result = 0;
413  }
414  }
virtual void raise(const std::string &)
Raise the exception, i.e. throw it.
Definition: exceptions.cpp:422
void check_perturb_min_lambda(double &result)
Definition: SpecBit_VS.cpp:400
invalid_point_exception & invalid_point()
Invalid point exceptions.
Here is the call graph for this function:

◆ check_perturb_to_min_lambda()

bool Gambit::SpecBit::check_perturb_to_min_lambda ( const Spectrum spec,
double  scale,
int  pts,
const std::vector< SpectrumParameter required_parameters 
)

Definition at line 86 of file SpecBit_VS.cpp.

References Gambit::Spectrum::clone_HE(), and Gambit::Scanner::pow().

Referenced by find_min_lambda_Helper().

88  {
89 
90  std::unique_ptr<SubSpectrum> subspec = spec.clone_HE();
91  double step = log10(scale) / pts;
92  double runto;
93 
94  double ul=3.5449077018110318; // sqrt(4*Pi)
95  for (int i=0;i<pts;i++)
96  {
97  runto = pow(10,step*float(i+1.0)); // scale to run spectrum to
98  if (runto<100){runto=200.0;}// avoid running to low scales
99 
100  try
101  {
102  subspec -> RunToScale(runto);
103  }
104  catch (const Error& error)
105  {
106  return false;
107  }
108 
109  for(std::vector<SpectrumParameter>::const_iterator it = required_parameters.begin();
110  it != required_parameters.end(); ++it)
111  {
112  const Par::Tags tag = it->tag();
113  const std::string name = it->name();
114  const std::vector<int> shape = it->shape();
115  std::ostringstream label;
116  label << name <<" "<< Par::toString.at(tag);
117  if(shape.size()==1 and shape[0]==1)
118  {
119  if (abs(subspec->get(tag,name))>ul)
120  {
121  return false;
122  }
123  }
124 
125  else if(shape.size()==1 and shape[0]>1)
126  {
127  for(int k = 1; k<=shape[0]; ++k) {
128  if (abs(subspec->get(tag,name,k))>ul)
129  {
130  return false;
131  }
132 
133  }
134  }
135  else if(shape.size()==2)
136  {
137  for(int k = 1; k<=shape[0]; ++k) {
138  for(int j = 1; j<=shape[0]; ++j) {
139  if (abs(subspec->get(tag,name,k,j))>ul)
140  {
141  return false;
142  }
143  }
144  }
145  }
146  }
147  }
148 
149  return true;
150  }
double pow(const double &a)
Outputs a^i.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ convert_E6MSSM_to_SM()

void Gambit::SpecBit::convert_E6MSSM_to_SM ( Spectrum result)

Definition at line 676 of file SpecBit_MSSM.cpp.

676 {result = *Pipes::convert_E6MSSM_to_SM::Dep::E6MSSM_spectrum;}

◆ convert_MSSM_to_SM()

void Gambit::SpecBit::convert_MSSM_to_SM ( Spectrum result)

Gambit module functions.

Definition at line 674 of file SpecBit_MSSM.cpp.

References MSSM_spectrum.

◆ convert_NMSSM_to_SM()

void Gambit::SpecBit::convert_NMSSM_to_SM ( Spectrum result)

Definition at line 675 of file SpecBit_MSSM.cpp.

References NMSSM_spectrum.

START_CAPABILITY NMSSM_spectrum

◆ exampleRead()

void Gambit::SpecBit::exampleRead ( bool &  result)

NEW! Tests of override setters

Now add some entry that didn't exist before

Note: if we try to do it like this, it should fail:

Definition at line 54 of file SpecBit_examples.cpp.

References ECHO, Gambit::Spectrum::get_HE(), Gambit::Spectrum::get_LE(), GET_M1_MATRIX, GET_M2_MATRIX, GET_MATRIX, GET_MIX_MATRIX, Gambit::SubSpectrum::GetScale(), Gambit::Spectrum::getSLHAea(), LOCAL_INFO, MSSM_spectrum, PDB, and Gambit::SubSpectrum::writeSLHAfile().

55  {
56 
57  // Retreive pointer to Spectrum object, delivered by dependency resolver
58  // Module function asks for Spectrum* with capability MSSM_spectrum.
59  // i.e. has DEPENDENCY(MSSM_spectrum, Spectrum*)
60  namespace myPipe = Pipes::exampleRead;
61  /*TAG*/ Spectrum fullspectrum = *myPipe::Dep::MSSM_spectrum;
62  const SubSpectrum* spec = fullspectrum->get_HE(); // MSSMSpec SubSpectrum object
63  const SubSpectrum* SM = fullspectrum->get_LE(); // QedQcdWrapper SubSpectrum object
64 
65  std::ostringstream report; // Information about any problems encountered
66 
67  // Extract SLHAea object
68  // This copies the data out. Could possible change it to pass out a
69  // reference instead, or have another function to do that.
70  SLHAea::Coll slhaea = fullspectrum->getSLHAea(2);
71  // for testing, write this to file
72  std::ofstream out1;
73  out1.open("SpecBit/exampleRead_test.slha");
74  out1 << slhaea;
75  out1.close();
76 
77  // SLHAea::Coll slhaea = spec->getSLHAea(2); // The above is just a wrapper for this.
78 
79  // If this is a valid model point, return true and dump information, else false
80 
81  // SLHAea objects behave mostly like maps, but with special kinds of keys. For
82  // "at" and "operator[]", it does automatic conversion, but for "find" it does
83  // not, so we have to manually do it.
84  SLHAea::Block spinfo = slhaea.at("SPINFO");
85  //std::vector<std::string> k3(1, "3");
86  std::vector<std::string> k4(1, "4");
87 
88  // See if error code entries exist
89  //if(spinfo.find(k3) == spinfo.end() and spinfo.find(k4) == spinfo.end())
90  if(spinfo.find(k4) == spinfo.end())
91  {
92  std::cout << "Good spectrum found! Inspecting contents..." << std::endl;
93  std::cout << std::endl << slhaea << std::endl;
94 
95  // Write to file so we can check it
96  std::string filename(myPipe::runOptions->getValue<std::string>("output_slha_filename"));
97  spec->writeSLHAfile(2,filename);
98 
99  // ---------------------------------------------------------
100  // BEGIN DEMO OF SPECTRUM OBJECT AND PARTICLE DATABASE
101  // ---------------------------------------------------------
102 
103  //#define ECHO(COMMAND) cout << " " << STRINGIFY(COMMAND) << " = " << COMMAND << endl;
104  //Replacing with a version that deals with SLHAea access errors
105  #define ECHO(COMMAND) \
106  { \
107  try { \
108  cout << " " << STRINGIFY(COMMAND) << " = " << COMMAND << endl;\
109  } \
110  catch (const std::exception& e) \
111  { add_error(report,e,STRINGIFY(COMMAND)); } \
112  }
113 
114  /* ----------Test particle database access ---------------- */
115  #define PDB Models::ParticleDB()
116 
117  // First check out what is actually in the database
118  PDB.check_contents();
119 
120  // Demo a couple of particle name retrievals
121  cout<<endl;
122  cout<<"Demo retrieval of lightest neutralino info from particle database"<<endl;
123  cout<<"-----------------------------------------------------------------"<<endl;
124  ECHO( PDB.pdg_pair("~chi0_1") ) // Input long name, retrieve PDG code + context integer
125  ECHO( PDB.pdg_pair("~chi0",1) ) // Input short name + index, retrieve PDG code + context integer
126  ECHO( PDB.long_name("~chi0",1) ) // Input short name + index, retrieve long name
127  ECHO( PDB.long_name(std::make_pair(1000022,0)) ) // Input PDG code + context integer, retrieve long name
128  ECHO( PDB.long_name(1000022,0) ) // Input PDG code + context integer, retrieve long name
129  ECHO( PDB.short_name_pair("~chi0_1") ) // Input long name, retrieve short name + index
130  ECHO( PDB.short_name_pair(std::make_pair(1000022,0)) ) // Input PDG code plus context integer, retrieve short name + index
131  ECHO( PDB.short_name_pair(1000022,0) ) // Input PDG code plus context integer, retrieve short name + index
132 
133  cout<<endl;
134  cout<<"Demo retrieval of antiparticle names/codes using particle names/codes"<<endl;
135  cout<<"-----------------------------------------------------------------"<<endl;
136  // Check existence in various ways
137  ECHO( PDB.has_antiparticle("~chi0_1") )
138  ECHO( PDB.has_antiparticle("~chi0",1) )
139  ECHO( PDB.has_antiparticle(std::make_pair("~chi0",1)) )
140  ECHO( PDB.has_antiparticle(1000022,0) )
141  ECHO( PDB.has_antiparticle(std::make_pair(1000022,0)) )
142  ECHO( PDB.get_antiparticle("~chi0_1") ) // Input long name, retrieve antiparticle long name
143  ECHO( PDB.get_antiparticle("~chi0",1) ) // Input short name + index, retrieve antiparticle short name + index
144  ECHO( PDB.get_antiparticle(std::make_pair("~chi0",1)) ) // Input short name + index, retrieve antiparticle short name + index
145  ECHO( PDB.get_antiparticle(1000022,0) ) // Input PDG code + context integet, retrieve antiparticle PDG code + context integer
146  ECHO( PDB.get_antiparticle(std::make_pair(1000022,0)) ) // Input PDG code + context integet, retrieve antiparticle PDG code + context integer
147  ECHO( PDB.has_antiparticle("~chi+_1") )
148  ECHO( PDB.has_antiparticle("~chi+",1) )
149  ECHO( PDB.has_antiparticle(std::make_pair("~chi+",1)) )
150  ECHO( PDB.has_antiparticle(1000024,0) )
151  ECHO( PDB.has_antiparticle(std::make_pair(1000024,0)) )
152  ECHO( PDB.get_antiparticle("~chi+_1") ) // Input long name, retrieve antiparticle long name
153  ECHO( PDB.get_antiparticle("~chi+",1) ) // Input short name + index, retrieve antiparticle short name + index
154  ECHO( PDB.get_antiparticle(std::make_pair("~chi+",1)) ) // Input short name + index, retrieve antiparticle short name + index
155  ECHO( PDB.get_antiparticle(1000024,0) ) // Input PDG code + context integet, retrieve antiparticle PDG code + context integer
156  ECHO( PDB.get_antiparticle(std::make_pair(1000024,0)) ) // Input PDG code + context integet, retrieve antiparticle PDG code + context integer
157  ECHO( PDB.has_antiparticle("u_1") )
158  ECHO( PDB.has_antiparticle("u",1) )
159  ECHO( PDB.has_antiparticle(std::make_pair("u",1)) )
160  ECHO( PDB.has_antiparticle(2,0) )
161  ECHO( PDB.has_antiparticle(std::make_pair(2,0)) )
162  ECHO( PDB.get_antiparticle("u_1") ) // Input long name, retrieve antiparticle long name
163  ECHO( PDB.get_antiparticle("u",1) ) // Input short name + index, retrieve antiparticle short name + index
164  ECHO( PDB.get_antiparticle(std::make_pair("u",1)) ) // Input short name + index, retrieve antiparticle short name + index
165  ECHO( PDB.get_antiparticle(2,0) ) // Input PDG code + context integet, retrieve antiparticle PDG code + context integer
166  ECHO( PDB.get_antiparticle(std::make_pair(2,0)) ) // Input PDG code + context integet, retrieve antiparticle PDG code + context integer
167 
168 
169  cout<<endl;
170  cout<<"Demo retrieval when no short name exists"<<endl;
171  cout<<"-----------------------------------------------------------------"<<endl;
172  ECHO( PDB.pdg_pair("H+") )
173  //ECHO( PDB.pdg_pair("H+",1) ) // Error!
174  //ECHO( PDB.long_name("H+",1) ) // Error!
175  ECHO( PDB.long_name(std::make_pair(37,0)) )
176  ECHO( PDB.long_name(37,0) )
177  //ECHO( PDB.short_name_pair("H+") ) // Error!
178  //ECHO( PDB.short_name_pair(std::make_pair(37,0)) ) // Error!
179  //ECHO( PDB.short_name_pair(37,0) ) // Error!
180  //ECHO( PDB.short_name_pair(37) ) // Error!
181  cout<<endl;
182  /* ----------------- Pole masses --------------------------- */
183 
184  cout<<"Begin demo retrievals from Spectrum and SubSpectrum objects"<<endl;
185  cout<<"-----------------------------------------------------------------"<<endl;
186  cout<<endl;
187  cout<<"First, general methods for accessing different sorts of information."<<endl;
188  cout<<endl;
189  // At the moment it is only pole masses which have getters overloaded to use
190  // the particle database information. It is only the MASS block in the
191  // spectrum generator output SLHA files which use PDG numbers anyway, so I
192  // think this makes sense.
193  cout<<"Lightest neutral Higgs boson pole mass:"<<endl;
194  ECHO( fullspectrum->get_Pole_Mass( PDB.short_name_pair(25,0) ) )
195  ECHO( fullspectrum->get_Pole_Mass( PDB.long_name(25,0) ) )
196  ECHO( fullspectrum->get_Pole_Mass(25,0) )
197  ECHO( fullspectrum->get_Pole_Mass( PDB.pdg_pair("h0",1) ) )
198  ECHO( fullspectrum->get_Pole_Mass("h0",1) )
199  ECHO( fullspectrum->get_Pole_Mass("h0_1") )
200 
201  ECHO( spec->get_Pole_Mass( PDB.short_name_pair(25,0) ) )
202  ECHO( spec->get_Pole_Mass( PDB.long_name(25,0) ) )
203  ECHO( spec->get_Pole_Mass(25,0) )
204  ECHO( spec->get_Pole_Mass( PDB.pdg_pair("h0",1) ) )
205  ECHO( spec->get_Pole_Mass("h0",1) )
206  ECHO( spec->get_Pole_Mass("h0_1") )
207 
208  cout<<endl;
209  cout<<"Retrieval of Spectrum object contents, with"<<endl;
210  cout<<"correspondence to SLHAea object entries"<<endl;
211  cout<<"-----------------------------------------------------------------"<<endl;
212 
213  // MZ was a bad first example; it is empty unless you switch on the SM pole mass
214  // calculator for flexiblesusy. We do not yet pass any input value of MZ though
215  // Similar issues with other gauge boson masses. So don't use these yet or
216  // you'll get zero for all these masses.
217  cout<<endl;
218  cout<<"Gauge boson pole masses:"<<endl;
219  cout<<endl;
220  ECHO( fullspectrum->get_Pole_Mass("Z0") )
221  ECHO( SM->get_Pole_Mass("Z0") )
222  ECHO( slhaea.at("SMINPUTS").at(4).at(1) )
223  cout<<endl;
224  ECHO( fullspectrum->get_Pole_Mass("gamma") )
225  ECHO( SM->get_Pole_Mass("gamma") )
226  cout<<" ***Not in slha***"<<endl;
227  cout<<endl;
228  ECHO( fullspectrum->get_Pole_Mass("W+") )
229  ECHO( SM->get_Pole_Mass("W+") )
230  ECHO( slhaea.at("MASS").at(24).at(1) )
231  cout<<endl;
232  ECHO( fullspectrum->get_Pole_Mass("g") )
233  ECHO( SM->get_Pole_Mass("g") )
234  cout<<" ***Not in slha***"<<endl;
235  cout<<endl;
236  cout<<"Quark pole masses (actually the slha entries are MSbar except the top mass):"<<endl;
237  cout<<endl;
238  // I'm a little unclear on what the pole masses for the lighter quarks mean, since I thought
239  // that non-perturbative effects made definining them difficult... well anyway will have
240  // to ask Peter what is being computed here.
241 
242  //ECHO( spec->get_Pole_Mass("u",1) ) // i.e. up (mass eigenstate)
243  cout<<" ***u Pole mass not well defined***"<<endl;
244  ECHO( slhaea.at("SMINPUTS").at(22).at(1) ) // mu(2 GeV)^MS-bar, not pole mass
245  cout<<endl;
246  //ECHO( spec->get_Pole_Mass("u",2) ) // i.e. charm
247  cout<<" ***c Pole mass not well defined***"<<endl;
248  ECHO( slhaea.at("SMINPUTS").at(24).at(1) ) // mc(mc)^MS-bar, not pole mass
249  cout<<endl;
250  //ECHO( spec->get_Pole_Mass("u",3) ) // i.e. top
251  ECHO( fullspectrum->get_Pole_Mass("t") )
252  ECHO( SM->get_Pole_Mass("u",3) ) // i.e. top
253  ECHO( slhaea.at("SMINPUTS").at(6).at(1) )
254  cout<<endl;
255  //ECHO( spec->get_Pole_Mass("d",1) ) // i.e. down
256  cout<<" ***d Pole mass not well defined***"<<endl;
257  ECHO( slhaea.at("SMINPUTS").at(21).at(1) ) // md(2 GeV)^MS-bar, not pole mass
258  cout<<endl;
259  //ECHO( spec->get_Pole_Mass("d",2) ) // i.e. strange
260  cout<<" ***s Pole mass not well defined***"<<endl;
261  ECHO( slhaea.at("SMINPUTS").at(23).at(1) ) // ms(2 GeV)^MS-bar, not pole mass
262  cout<<endl;
263  //ECHO( spec->get_Pole_Mass("d",3) ) // i.e. bottom
264  ECHO( fullspectrum->get_Pole_Mass("b") )
265  ECHO( SM->get_Pole_Mass("d",3) ) // i.e. bottom
266  ECHO( slhaea.at("SMINPUTS").at(5).at(1) ) // mb(mb)^MS-bar, not pole mass.
267  cout<<endl;
268  cout<<"Charged fermions pole masses:"<<endl;
269  cout<<endl;
270  //ECHO( spec->get_Pole_Mass("e-",1) ) // i.e. electron
271  ECHO( fullspectrum->get_Pole_Mass("e-") )
272  ECHO( SM->get_Pole_Mass("e-",1) ) // i.e. electron
273  ECHO( slhaea.at("SMINPUTS").at(11).at(1) )
274  cout<<endl;
275  //ECHO( spec->get_Pole_Mass("e-",2) ) // i.e. muon
276  ECHO( fullspectrum->get_Pole_Mass("mu-") )
277  ECHO( SM->get_Pole_Mass("e-",2) ) // i.e. muon
278  ECHO( slhaea.at("SMINPUTS").at(13).at(1) )
279  cout<<endl;
280  //ECHO( spec->get_Pole_Mass("e-",3) ) // i.e. tau
281  ECHO( fullspectrum->get_Pole_Mass("tau-") )
282  ECHO( SM->get_Pole_Mass("e-",3) ) // i.e. tau
283  ECHO( slhaea.at("SMINPUTS").at(7).at(1) )
284  cout<<endl;
285  cout<<"Neutrinos pole masses:"<<endl;
286  cout<<endl;
287  // These will produce errors because currently no neutrino mass getters are hooked up
288  //ECHO( spec->get_Pole_Mass("nu",1) ) // Just mass ordered (if there is mixing)
289  ECHO( fullspectrum->get_Pole_Mass("nu",1) )
290  ECHO( SM->get_Pole_Mass("nu",1) ) // Just mass ordered (if there is mixing)
291  ECHO( slhaea.at("SMINPUTS").at(12).at(1) )
292  cout<<endl;
293  //ECHO( spec->get_Pole_Mass("nu",2) )
294  ECHO( fullspectrum->get_Pole_Mass("nu",2) )
295  ECHO( SM->get_Pole_Mass("nu",2) )
296  ECHO( slhaea.at("SMINPUTS").at(14).at(1) )
297  cout<<endl;
298  //ECHO( spec->get_Pole_Mass("nu",3) )
299  ECHO( fullspectrum->get_Pole_Mass("nu",3) )
300  ECHO( SM->get_Pole_Mass("nu",3) )
301  ECHO( slhaea.at("SMINPUTS").at(8).at(1) )
302  cout<<endl;
303  // Now for SUSY particles
304  cout<<endl;
305  cout<<"MSSM Higgs sector pole masses:"<<endl;
306  cout<<endl;
307  ECHO( fullspectrum->get_Pole_Mass("h0",1) )
308  ECHO( spec->get_Pole_Mass("h0",1) ) // Lightest neutral Higgs boson
309  ECHO( slhaea.at("MASS").at(25).at(1) )
310  cout<<endl;
311  ECHO( fullspectrum->get_Pole_Mass("h0",2) )
312  ECHO( spec->get_Pole_Mass("h0",2) ) // Heavy neutral Higgs boson
313  ECHO( slhaea.at("MASS").at(35).at(1) )
314  cout<<endl;
315  ECHO( fullspectrum->get_Pole_Mass("H+") )
316  ECHO( spec->get_Pole_Mass("H+") ) // Charged Higgs
317  ECHO( slhaea.at("MASS").at(37).at(1) )
318  cout<<endl;
319  ECHO( fullspectrum->get_Pole_Mass("A0") )
320  ECHO( spec->get_Pole_Mass("A0") ) // Pseudoscalar neutral Higgs
321  ECHO( slhaea.at("MASS").at(36).at(1) )
322  cout<<endl;
323 
324  // I'm going to use these nested functors to save lots of typing for the rest. It is just the
325  // same as the examples above, except that the PDG codes are retrieved from the particle database.
326  // The PDG code - string name correspondences are defined in 'Models/src/particle_database.cpp'
327 
328  struct get_polemass_functor
329  {
330  // Single mass
331  void operator()(const std::string& longname)
332  {
333  std::ostringstream echo1, echo2, echo3;
334  echo1 << " fullspectrum->get_Pole_Mass("<<longname<<") = ";
335  double value1 = fullspectrum->get_Pole_Mass(longname);
336  echo2 << " spec->get_Pole_Mass("<<longname<<") = ";
337  double value2 = spec->get_Pole_Mass(longname);
338  echo3 << " slhaea.at(\"MASS\").at("<<PDB.pdg_pair(longname).first<<").at(1) = ";
339  str value3 = slhaea.at("MASS").at( PDB.pdg_pair(longname).first ).at(1);
340  cout << echo1.str() << value1 << endl;
341  cout << echo2.str() << value2 << endl;
342  cout << echo3.str() << value3 << endl;
343  cout<<endl;
344  }
345  // Range of indexes masses
346  void operator()(const std::string& longname, int from, int to)
347  {
348  for(int i=from; i<=to; ++i)
349  {
350  std::ostringstream echo1;
351  std::ostringstream echo2;
352  echo1 << " spec->get_Pole_Mass("<<longname<<","<<i<<") = ";
353  double value1 = spec->get_Pole_Mass(longname,i);
354  echo2 << " slhaea.at(\"MASS\").at("<<PDB.pdg_pair(longname,i).first<<").at(1) = ";
355  str value2 = slhaea.at("MASS").at( PDB.pdg_pair(longname,i).first ).at(1);
356  cout << echo1.str() << value1 << endl;
357  cout << echo2.str() << value2 << endl;
358  cout<<endl;
359  }
360  }
361 
362  get_polemass_functor(std::ostringstream& report, /*TAG*/ Spectrum fullin, const SubSpectrum* specin, SLHAea::Coll& slhaeain)
363  : report(report)
364  , fullspectrum(fullin)
365  , spec(specin)
366  , slhaea(slhaeain)
367  {}
368 
369  private:
370  std::ostringstream& report;
371  /*TAG*/ Spectrum fullspectrum;
372  const SubSpectrum* spec;
373  SLHAea::Coll slhaea;
374  };
375 
376  get_polemass_functor get_polemass(report,fullspectrum,spec,slhaea);
377 
378  cout<<endl<<"Gaugino pole masses:"<<endl<<endl;
379  get_polemass("~g");
380  get_polemass("~chi+",1,2);
381  get_polemass("~chi0",1,4);
382  cout<<endl<<"Squark pole masses:"<<endl<<endl;
383  get_polemass("~d",1,6);
384  get_polemass("~u",1,6);
385  cout<<endl<<"Slepton pole masses:"<<endl<<endl;
386  get_polemass("~e-",1,6);
387  get_polemass("~nu",1,3);
388 
389  cout << endl << "Mixing matrices:" << endl << endl;
390 
391  // Note, currently we are not using a matrix object or any such thing, so you have to
392  // extract the elements of each matrix one at a time. It would probably be handy to
393  // add such a return type though.
394 
395  #define GET_MIX_MATRIX_EL(r, PRODUCT) \
396  { \
397  str label = BOOST_PP_SEQ_ELEM(0, PRODUCT); \
398  str block = BOOST_PP_SEQ_ELEM(1, PRODUCT); \
399  int i = BOOST_PP_SEQ_ELEM(2, PRODUCT); \
400  int j = BOOST_PP_SEQ_ELEM(3, PRODUCT); \
401  try{ \
402  std::ostringstream echo1; \
403  std::ostringstream echo2; \
404  echo1 << " spec->get_Pole_Mixing("<<label<<","<<i<<","<<j<<") = "; \
405  double value1 = spec->get_Pole_Mixing(label,i,j); \
406  echo2 << " SLHAea::to<double>( slhaea.at("<<block<<").at("<<i<<","<<j<<").at(2) ) = "; \
407  double value2 = SLHAea::to<double>( slhaea.at(block).at(i,j).at(2) ); \
408  cout << echo1.str() << value1 <<endl; \
409  cout << echo2.str() << value2 <<endl; \
410  cout << endl; \
411  } \
412  catch (const std::exception& e) \
413  { add_error(report,e,label+": "+block); } \
414  }
415 
416  #define GET_MIX_MATRIX(NAME,BLOCK,__IND1,__IND2) BOOST_PP_SEQ_FOR_EACH_PRODUCT(GET_MIX_MATRIX_EL, ((NAME))((BLOCK))(BOOST_PP_TUPLE_TO_SEQ(__IND1))(BOOST_PP_TUPLE_TO_SEQ(__IND2)))
417 
418  // The names here could perhaps be improved. They are not so immediately obvious to me.
419 
420  GET_MIX_MATRIX("~chi-","UMIX",(1,2),(1,2)) cout<<endl;
421  GET_MIX_MATRIX("~chi+","VMIX",(1,2),(1,2)) cout<<endl;
422  GET_MIX_MATRIX("A0","PSEUDOSCALARMIX",(1,2),(1,2)) cout<<endl;
423  GET_MIX_MATRIX("~d","DSQMIX",(1,2,3,4,5,6),(1,2,3,4,5,6)) cout<<endl;
424  GET_MIX_MATRIX("~e-","SELMIX",(1,2,3,4,5,6),(1,2,3,4,5,6)) cout<<endl;
425  GET_MIX_MATRIX("h0","SCALARMIX",(1,2),(1,2)) cout<<endl;
426  GET_MIX_MATRIX("~chi0","NMIX",(1,2,3,4),(1,2,3,4)) cout<<endl;
427  GET_MIX_MATRIX("H+","CHARGEMIX",(1,2),(1,2)) cout<<endl;
428  GET_MIX_MATRIX("~u","USQMIX",(1,2,3,4,5,6),(1,2,3,4,5,6)) cout<<endl;
429  GET_MIX_MATRIX("~nu","SNUMIX",(1,2,3),(1,2,3)) cout<<endl;
430 
431  cout<<endl;
432  cout << "Next up: running parameters" << endl;
433  cout << "These are all given in the DRbar scheme, at least when running FlexibleSUSY or SoftSUSY. ";
434  cout << "There may be some switching or converting once other spectrum generator are added." << endl;
435  cout<<endl;
436  cout << "Spectrum object running parameters are currently defined at scale Q="
437  << spec->GetScale() << " [GeV]" << endl << endl;
438  cout<<endl;
439  cout << "-- Dimensionless parameters --" <<endl;
440  cout << endl << "Gauge couplings:" << endl << endl;
441  ECHO( spec->get_dimensionless_parameter("g1") ) // U_Y(1) gauge coupling in SU(5) normalisation
442  ECHO( slhaea.at("GAUGE").at(1).at(1) ) // This is in the Standard Model normalisation as per SLHA conventions
443  cout << "Note: " << spec->get_dimensionless_parameter("g1") << " * sqrt(3/5) = "
444  << spec->get_dimensionless_parameter("g1")*sqrt(3./5.) << endl;
445  cout<<endl;
446  ECHO( spec->get_dimensionless_parameter("g2") ) // SU(2) gauge coupling
447  ECHO( slhaea.at("GAUGE").at(2).at(1) )
448  cout<<endl;
449  ECHO( spec->get_dimensionless_parameter("g3") ) // SU(3) gauge coupling
450  ECHO( slhaea.at("GAUGE").at(3).at(1) )
451  cout<<endl;
452 
453  cout << endl << "Yukawa matrices:" << endl << endl;
454 
455  // Note, currently we are not using a matrix object or any such thing, so you have to
456  // extract the elements of the matrix one at a time. It would probably be handy to
457  // add such a return type though.
458 
459  #define GET_MATRIX_EL(r, PRODUCT) \
460  { \
461  str label = BOOST_PP_SEQ_ELEM(0, PRODUCT); \
462  str block = BOOST_PP_SEQ_ELEM(1, PRODUCT); \
463  int i = BOOST_PP_SEQ_ELEM(2, PRODUCT); \
464  int j = BOOST_PP_SEQ_ELEM(3, PRODUCT); \
465  try{ \
466  std::ostringstream echo1; \
467  std::ostringstream echo2; \
468  echo1 << " spec->get_dimensionless_parameter("<<label<<","<<i<<","<<j<<") = "; \
469  double value1 = spec->get_dimensionless_parameter(label,i,j); \
470  echo2 << " SLHAea::to<double>( slhaea.at("<<block<<").at("<<i<<","<<j<<").at(2) ) = "; \
471  double value2 = SLHAea::to<double>( slhaea.at(block).at(i,j).at(2) ); \
472  cout << echo1.str() << value1 <<endl; \
473  cout << echo2.str() << value2 <<endl; \
474  cout << endl; \
475  } catch (const std::exception& e) \
476  { add_error(report,e,label+": "+block); } \
477  }
478 
479  #define GET_MATRIX(NAME,BLOCK,__IND1,__IND2) BOOST_PP_SEQ_FOR_EACH_PRODUCT(GET_MATRIX_EL, ((NAME))((BLOCK))(BOOST_PP_TUPLE_TO_SEQ(__IND1))(BOOST_PP_TUPLE_TO_SEQ(__IND2)))
480 
481  GET_MATRIX("Yu","YU",(1,2,3),(1,2,3)) cout << endl;
482  GET_MATRIX("Yd","YD",(1,2,3),(1,2,3)) cout << endl;
483  GET_MATRIX("Ye","YE",(1,2,3),(1,2,3)) cout << endl;
484 
485  // Mass dimension 1 parameters
486 
487  cout<<endl;
488  cout<<"MSSM mass dimension 1 running parameters"<<endl;
489  cout<<endl;
490  ECHO( spec->get_mass_parameter("M1") ) // Gaugino mass parameter "MassB"
491  ECHO( slhaea.at("MSOFT").at(1).at(1) )
492  cout<<endl;
493  ECHO( spec->get_mass_parameter("M2") ) // Gaugino mass parameter "MassWB"
494  ECHO( slhaea.at("MSOFT").at(2).at(1) )
495  cout<<endl;
496  ECHO( spec->get_mass_parameter("M3") ) // Gaugino mass parameter "MassG"
497  ECHO( slhaea.at("MSOFT").at(3).at(1) )
498  cout<<endl;
499  ECHO( spec->get_mass_parameter("Mu") ) // Superpotential mu parameter
500  ECHO( slhaea.at("HMIX").at(1).at(1) )
501  cout<<endl;
502  ECHO( spec->get_mass_parameter("vd") ) // Down-type Higgs vev
503  ECHO( slhaea.at("HMIX").at(102).at(1) )
504  cout<<endl;
505  ECHO( spec->get_mass_parameter("vu") ) // Up-type Higgs vev
506  ECHO( slhaea.at("HMIX").at(103).at(1) )
507  cout<<endl;
508 
509  // Matrices
510 
511  #define GET_M1_MATRIX_EL(r, PRODUCT) \
512  { \
513  str label = BOOST_PP_SEQ_ELEM(0, PRODUCT); \
514  str block = BOOST_PP_SEQ_ELEM(1, PRODUCT); \
515  int i = BOOST_PP_SEQ_ELEM(2, PRODUCT); \
516  int j = BOOST_PP_SEQ_ELEM(3, PRODUCT); \
517  try{ \
518  std::ostringstream echo1; \
519  std::ostringstream echo2; \
520  echo1 << " spec->get_mass_parameter("<<label<<","<<i<<","<<j<<") = "; \
521  double value1 = spec->get_mass_parameter(label,i,j); \
522  echo2 << " SLHAea::to<double>( slhaea.at("<<block<<").at("<<i<<","<<j<<").at(2) ) = "; \
523  double value2 = SLHAea::to<double>( slhaea.at(block).at(i,j).at(2) ); \
524  cout << echo1.str() << value1 <<endl; \
525  cout << echo2.str() << value2 <<endl; \
526  cout << endl; \
527  } catch (const std::exception& e) \
528  { add_error(report,e,label+": "+block); } \
529  }
530 
531  #define GET_M1_MATRIX(NAME,BLOCK,__IND1,__IND2) BOOST_PP_SEQ_FOR_EACH_PRODUCT(GET_M1_MATRIX_EL, ((NAME))((BLOCK))(BOOST_PP_TUPLE_TO_SEQ(__IND1))(BOOST_PP_TUPLE_TO_SEQ(__IND2)))
532 
533  cout << endl << "Triliner coupling matrices? SLHA says these blocks should be called AU,AD,AE, not TU,TD,TE though, so I'm not sure. Need to check with Peter." << endl << endl;
534 
535  // Seem to be the trilinears, and TYu and au etc. seem to be equal. Ask Peter...
536 
537  GET_M1_MATRIX("TYu","TU",(1,2,3),(1,2,3)) cout << endl;
538  GET_M1_MATRIX("TYd","TD",(1,2,3),(1,2,3)) cout << endl;
539  GET_M1_MATRIX("TYe","TE",(1,2,3),(1,2,3)) cout << endl;
540  cout << endl;
541  GET_M1_MATRIX("au","TU",(1,2,3),(1,2,3)) cout << endl;
542  GET_M1_MATRIX("ad","TD",(1,2,3),(1,2,3)) cout << endl;
543  GET_M1_MATRIX("ae","TE",(1,2,3),(1,2,3)) cout << endl;
544 
545  // Mass dimension 2 parameters
546 
547  cout<<endl;
548  cout<<"MSSM mass dimension 2 running parameters"<<endl;
549  cout<<endl;
550  ECHO( spec->get_mass2_parameter("mHd2") ) // Down-type Higgs soft mass
551  ECHO( slhaea.at("MSOFT").at(21).at(1) )
552  cout<<endl;
553  ECHO( spec->get_mass2_parameter("mHu2") ) // Up-type Higgs soft mass
554  ECHO( slhaea.at("MSOFT").at(22).at(1) )
555  cout<<endl;
556  ECHO( spec->get_mass2_parameter("BMu") ) // Higgs bilinear soft parameter
557  ECHO( slhaea.at("HMIX").at(101).at(1) )
558  cout<<endl;
559 
560  // Matrices
561 
562  #define GET_M2_MATRIX_EL(r, PRODUCT) \
563  { \
564  str label = BOOST_PP_SEQ_ELEM(0, PRODUCT); \
565  str block = BOOST_PP_SEQ_ELEM(1, PRODUCT); \
566  int i = BOOST_PP_SEQ_ELEM(2, PRODUCT); \
567  int j = BOOST_PP_SEQ_ELEM(3, PRODUCT); \
568  std::ostringstream echo1; \
569  try { \
570  std::ostringstream echo2; \
571  echo1 << " spec->get_mass2_parameter("<<label<<","<<i<<","<<j<<") = "; \
572  double value1 = spec->get_mass2_parameter(label,i,j); \
573  echo2 << " SLHAea::to<double>( slhaea.at("<<block<<").at("<<i<<","<<j<<").at(2) ) = "; \
574  double value2 = SLHAea::to<double>( slhaea.at(block).at(i,j).at(2) ); \
575  cout << echo1.str() << value1 <<endl; \
576  cout << echo2.str() << value2 <<endl; \
577  cout << endl; \
578  } catch (const std::exception& e) \
579  { add_error(report,e,label+": "+block); } \
580  }
581 
582  #define GET_M2_MATRIX(NAME,BLOCK,__IND1,__IND2) BOOST_PP_SEQ_FOR_EACH_PRODUCT(GET_M2_MATRIX_EL, ((NAME))((BLOCK))(BOOST_PP_TUPLE_TO_SEQ(__IND1))(BOOST_PP_TUPLE_TO_SEQ(__IND2)))
583 
584  cout << endl << "Mass matrices:" << endl << endl;
585 
586  GET_M2_MATRIX("mq2","MSQ2",(1,2,3),(1,2,3)) cout << endl;
587  GET_M2_MATRIX("mu2","MSU2",(1,2,3),(1,2,3)) cout << endl;
588  GET_M2_MATRIX("md2","MSD2",(1,2,3),(1,2,3)) cout << endl;
589  GET_M2_MATRIX("me2","MSE2",(1,2,3),(1,2,3)) cout << endl;
590  GET_M2_MATRIX("ml2","MSL2",(1,2,3),(1,2,3)) cout << endl;
591 
592  cout << endl;
593 
595 
596  cout << "Testing set_override functions" << endl;
597 
598  cout << "Original M1:" << spec->get_mass_parameter("M1") << endl;
599  spec->set_override_mass_parameter(-666,"M1");
600  cout << "Override M1:" << spec->get_mass_parameter("M1") << endl;
601 
602  cout << "Original ~e-(1):" << spec->get_Pole_Mass("~e-",1) << endl;
603  spec->set_override_Pole_Mass(-667,"~e-",1);
604  cout << "Override ~e-(1):" << spec->get_Pole_Mass("~e-",1) << endl;
605 
606  cout << "Original ml2(1,1):" << spec->get_mass2_parameter("ml2",1,1) << endl;
607  spec->set_override_mass2_parameter(-668,"ml2",1,1);
608  cout << "Override ml2(1,1):" << spec->get_mass2_parameter("ml2",1,1) << endl;
609 
611  cout << "has 'new_entry'? " << spec->has_mass_parameter("new_entry") << endl;
612  cout << "..." << endl;
614  //spec->set_override_mass2_parameter(-1234,"new_entry"); // incorrect: safety still on
615  spec->set_override_mass_parameter(-1234,"new_entry",false); // correct: safety check turned off
616  cout << "has 'new_entry'? " << spec->has_mass_parameter("new_entry") << endl;
617  cout << "new_entry = " << spec->get_mass_parameter("new_entry") << endl;
618  cout << endl;
619 
620 
621  // Things left to add to demo:
622  // - Tree-level masses
623  // - Standard Model mixings (need to be added to MSSMSpec as well)
624  // - some extra stuff to do regarding organising Standard Model input
625  // parameters (and computing/transferring the pole masses)
626 
627  cout << "Test report:" << std::endl << report.str();
628 
629  SpecBit_warning().raise(LOCAL_INFO,"\n *** Stopped on purpose to examine spectrum contents ***");
630  result = 0;
631  }
632  //else if(spinfo.find(k3) != spinfo.end())
633  //{
634  // std::cout << "Bad spectrum: " << spinfo.at(3) << std::endl;
635  // result = 1;
636  //}
637  else if(spinfo.find(k4) != spinfo.end())
638  {
639  std::cout << "Bad spectrum: " << spinfo.at(4) << std::endl;
640  result = 1;
641  }
642  else
643  {
644  SpecBit_error().raise(LOCAL_INFO,"Bug in exampleRead 'if' logic");
645  }
646  }
#define LOCAL_INFO
Definition: local_info.hpp:34
STL namespace.
#define PDB
START_MODEL b
Definition: demo.hpp:235
void exampleRead(bool &result)
const double mu
Definition: SM_Z.hpp:42
#define GET_MATRIX(NAME, BLOCK, __IND1, __IND2)
Spectrum Spectrum
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
#define GET_MIX_MATRIX(NAME, BLOCK, __IND1, __IND2)
#define GET_M2_MATRIX(NAME, BLOCK, __IND1, __IND2)
#define GET_M1_MATRIX(NAME, BLOCK, __IND1, __IND2)
#define ECHO(COMMAND)
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum SMINPUTS
Here is the call graph for this function:

◆ FH_AllHiggsMasses()

void Gambit::SpecBit::FH_AllHiggsMasses ( fh_HiggsMassObs &  result)

Higgs masses and mixings with theoretical uncertainties.

Definition at line 1298 of file SpecBit_MSSM.cpp.

References Gambit::LogTags::err, Gambit::invalid_point(), and Gambit::invalid_point_exception::raise().

Referenced by main().

1299  {
1300  using namespace Pipes::FH_AllHiggsMasses;
1301 
1302  #ifdef SPECBIT_DEBUG
1303  cout << "****** calling FH_HiggsMasses ******" << endl;
1304  #endif
1305 
1306  // Higgs mass with
1307  // 0 - m1 (Mh in rMSSM)
1308  // 1 - m2 (MH in rMSSM)
1309  // 2 - m3 (MA in rMSSM)
1310  // 3 - MHpm
1311  Farray<fh_real, 1,4> MHiggs;
1312  Farray<fh_real, 1,4> DeltaMHiggs;
1313 
1314  // sine of effective Higgs mixing angle, alpha_eff
1315  fh_complex SAeff;
1316  fh_complex DeltaSAeff;
1317 
1318  // matrix needed to rotate Higgs
1319  // mass matrix to diagonal form
1320  Farray<fh_complex, 1,3, 1,3> UHiggs;
1321  Farray<fh_complex, 1,3, 1,3> DeltaUHiggs;
1322 
1323  // matrix of Z-factors needed to combine
1324  // amplitudes involving on-shell Higgs
1325  Farray<fh_complex, 1,3, 1,3> ZHiggs;
1326  Farray<fh_complex, 1,3, 1,3> DeltaZHiggs;
1327 
1328  #ifdef SPECBIT_DEBUG
1329  cout << "****** calling FHHiggsCorr ******" << endl;
1330  #endif
1331 
1332  int error = 1;
1333  BEreq::FHHiggsCorr(error, MHiggs, SAeff, UHiggs, ZHiggs);
1334  if (error != 0)
1335  {
1336  std::ostringstream err;
1337  err << "BEreq::FHHiggsCorr raised error flag: " << error << ".";
1338  invalid_point().raise(err.str());
1339  }
1340 
1341  #ifdef SPECBIT_DEBUG
1342  cout << "****** calling FHUncertainties ******" << endl;
1343  #endif
1344 
1345  error = 1;
1346  BEreq::FHUncertainties(error, DeltaMHiggs, DeltaSAeff, DeltaUHiggs, DeltaZHiggs);
1347  if (error != 0)
1348  {
1349  std::ostringstream err;
1350  err << "BEreq::FHUncertainties raised error flag: " << error << ".";
1351  invalid_point().raise(err.str());
1352  }
1353 
1354  fh_HiggsMassObs HiggsMassObs;
1355  for(int i = 0; i < 4; i++)
1356  {
1357  HiggsMassObs.MH[i] = MHiggs(i+1);
1358  HiggsMassObs.deltaMH[i] = DeltaMHiggs(i+1);
1359  }
1360  HiggsMassObs.SinAlphaEff = SAeff;
1361  HiggsMassObs.deltaSinAlphaEff = DeltaSAeff;
1362  for(int i = 0; i < 3; i++)
1363  for(int j = 0; j < 3; j++)
1364  {
1365  HiggsMassObs.UH[i][j] = UHiggs(i+1,j+1);
1366  HiggsMassObs.deltaUH[i][j] = DeltaUHiggs(i+1,j+1);
1367  HiggsMassObs.ZH[i][j] = ZHiggs(i+1,j+1);
1368  HiggsMassObs.deltaZH[i][j] = DeltaZHiggs(i+1,j+1);
1369  }
1370 
1371  result = HiggsMassObs;
1372  }
void FH_AllHiggsMasses(fh_HiggsMassObs &result)
Higgs masses and mixings with theoretical uncertainties.
virtual void raise(const std::string &)
Raise the exception, i.e. throw it.
Definition: exceptions.cpp:422
invalid_point_exception & invalid_point()
Invalid point exceptions.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ FH_Couplings()

void Gambit::SpecBit::FH_Couplings ( fh_Couplings &  result)

Call FH_Couplings from FeynHiggs and collect the output.

Definition at line 1379 of file SpecBit_MSSM.cpp.

References Gambit::LogTags::err, Gambit::invalid_point(), and Gambit::invalid_point_exception::raise().

Referenced by main().

1380  {
1381  using namespace Pipes::FH_Couplings;
1382 
1383  #ifdef SPECBIT_DEBUG
1384  cout << "****** calling FH_Couplings ******" << endl;
1385  #endif
1386 
1387  // what to use for internal Higgs mixing
1388  // (ex. in couplings)
1389  // (default = 1)
1390  // 0 - no mixing
1391  // 1 - UHiggs
1392  // 2 - ZHiggs
1393  int uzint = 2;
1394  // what to use for external Higgs mixing
1395  // (ex. in decays)
1396  // (default = 2)
1397  // 0 - no mixing
1398  // 1 - UHiggs
1399  // 2 - ZHiggs
1400  int uzext = 2;
1401  // which effective bottom mass to use
1402  int mfeff = 1;
1403 
1404  #ifdef SPECBIT_DEBUG
1405  cout << "****** calling FHSelectUZ ******" << endl;
1406  #endif
1407 
1408  int error = 1;
1409  BEreq::FHSelectUZ(error, uzint, uzext, mfeff);
1410  if (error != 0)
1411  {
1412  std::ostringstream err;
1413  err << "BEreq::FHSelectUZ raised error flag: " << error << ".";
1414  invalid_point().raise(err.str());
1415  }
1416 
1417  Farray<fh_complex, 1,ncouplings> couplings; // MSSM Higgs couplings
1418  Farray<fh_complex, 1,ncouplingsms> couplings_sm; // SM Higgs couplings
1419  Farray<fh_real, 1,ngammas> gammas; // Higgs decay widths and BR's (MSSM)
1420  Farray<fh_real, 1,ngammasms> gammas_sm; // Higgs decay widths and BR's (SM)
1421  int fast = 1; // include off-diagonal fermion decays? (1 = no)
1422 
1423  #ifdef SPECBIT_DEBUG
1424  cout << "****** calling FHCouplings ******" << endl;
1425  #endif
1426 
1427  error = 1;
1428  BEreq::FHCouplings(error, couplings, couplings_sm,
1429  gammas, gammas_sm, fast);
1430  if (error != 0)
1431  {
1432  std::ostringstream err;
1433  err << "BEreq::FHCouplings raised error flag: " << error << ".";
1434  invalid_point().raise(err.str());
1435  }
1436 
1437  fh_Couplings Couplings;
1438  for(int i = 0; i < ncouplings; i++) Couplings.couplings[i] = couplings(i+1);
1439  for(int i = 0; i < ncouplingsms; i++) Couplings.couplings_sm[i] = couplings_sm(i+1);
1440  for(int i = 0; i < ngammas; i++) Couplings.gammas[i] = gammas(i+1);
1441  for(int i = 0; i < ngammasms; i++) Couplings.gammas_sm[i] = gammas_sm(i+1);
1442  Couplings.calculator = BEreq::FHCouplings.origin();
1443  Couplings.calculator_version = BEreq::FHCouplings.version();
1444 
1445  result = Couplings;
1446  }
virtual void raise(const std::string &)
Raise the exception, i.e. throw it.
Definition: exceptions.cpp:422
void FH_Couplings(fh_Couplings &result)
Call FH_Couplings from FeynHiggs and collect the output.
invalid_point_exception & invalid_point()
Invalid point exceptions.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ FH_HeavyHiggsMasses()

void Gambit::SpecBit::FH_HeavyHiggsMasses ( map_int_triplet_dbl result)

Definition at line 1854 of file SpecBit_MSSM.cpp.

References LOCAL_INFO, Gambit::SMlike_higgs_PDG_code(), and unimproved_MSSM_spectrum.

Referenced by main().

1855  {
1856  using namespace Pipes::FH_HeavyHiggsMasses;
1857  const int neutrals[2] = {25, 35};
1858  int i = -1;
1859  const SubSpectrum& spec = Dep::unimproved_MSSM_spectrum->get_HE();
1860  int higgs = SMlike_higgs_PDG_code(spec);
1861  if (higgs == neutrals[0]) i = 1;
1862  else if (higgs == neutrals[1]) i = 0;
1863  else SpecBit_error().raise(LOCAL_INFO, "Urecognised SM-like Higgs PDG code!");
1864  result.clear();
1865  result[neutrals[i]].central = Dep::FH_HiggsMasses->MH[i];
1866  result[neutrals[i]].upper = Dep::FH_HiggsMasses->deltaMH[i];
1867  result[neutrals[i]].lower = Dep::FH_HiggsMasses->deltaMH[i];
1868  result[36].central = Dep::FH_HiggsMasses->MH[2];
1869  result[36].upper = Dep::FH_HiggsMasses->deltaMH[2];
1870  result[36].lower = Dep::FH_HiggsMasses->deltaMH[2];
1871  result[37].central = Dep::FH_HiggsMasses->MH[3];
1872  result[37].upper = Dep::FH_HiggsMasses->deltaMH[3];
1873  result[37].lower = Dep::FH_HiggsMasses->deltaMH[3];
1874  }
void FH_HeavyHiggsMasses(map_int_triplet_dbl &result)
#define LOCAL_INFO
Definition: local_info.hpp:34
int SMlike_higgs_PDG_code(const SubSpectrum &)
Determine which MSSM higgs is most SM-like.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ FH_HiggsMass()

void Gambit::SpecBit::FH_HiggsMass ( triplet< double > &  result)

Definition at line 1839 of file SpecBit_MSSM.cpp.

References Gambit::triplet< TYPE >::central, LOCAL_INFO, Gambit::triplet< TYPE >::lower, Gambit::SMlike_higgs_PDG_code(), unimproved_MSSM_spectrum, and Gambit::triplet< TYPE >::upper.

Referenced by main().

1840  {
1841  using namespace Pipes::FH_HiggsMass;
1842  //FH indices: 0=h0_1, 1=h0_2
1843  int i = 0;
1844  const SubSpectrum& spec = Dep::unimproved_MSSM_spectrum->get_HE();
1845  int higgs = SMlike_higgs_PDG_code(spec);
1846  if (higgs == 25) i = 0;
1847  else if (higgs == 35) i = 1;
1848  else SpecBit_error().raise(LOCAL_INFO, "Urecognised SM-like Higgs PDG code!");
1849  result.central = Dep::FH_HiggsMasses->MH[i];
1850  result.upper = Dep::FH_HiggsMasses->deltaMH[i];
1851  result.lower = Dep::FH_HiggsMasses->deltaMH[i];
1852  }
#define LOCAL_INFO
Definition: local_info.hpp:34
int SMlike_higgs_PDG_code(const SubSpectrum &)
Determine which MSSM higgs is most SM-like.
void FH_HiggsMass(triplet< double > &result)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ FH_MSSMMasses()

void Gambit::SpecBit::FH_MSSMMasses ( fh_MSSMMassObs &  result)

FeynHiggs SUSY masses and mixings.

Definition at line 1185 of file SpecBit_MSSM.cpp.

References Gambit::LogTags::err, Gambit::invalid_point(), and Gambit::invalid_point_exception::raise().

1186  {
1187  using namespace Pipes::FH_MSSMMasses;
1188 
1189  #ifdef SPECBIT_DEBUG
1190  cout << "****** calling FH_MSSMMasses ******" << endl;
1191  #endif
1192 
1193  // zero if minimal, non-zero if non-minimal flavour violation
1194  int nmfv;
1195 
1196  // MSf(s,t,g) MFV squark masses with indices
1197  // s = 1..2 sfermion index
1198  // t = 1..5 sfermion type nu,e,u,d,?
1199  // g = 1..3 generation index
1200  Farray<fh_real, 1,2, 1,5, 1,3> MSf;
1201 
1202  // USf(s1,s2,t,g) MFV squark mixing matrices with indices
1203  // s1 = 1..2 sfermion index (mass eigenstates)
1204  // s2 = 1..2 sfermion index (gauge eigenstates, L/R)
1205  // t = 1..5 sfermion type nu,e,u,d,?
1206  // g = 1..3 generation index
1207  Farray<fh_complex, 1,2, 1,2, 1,5, 1,3> USf;
1208 
1209  // NMFV squark masses, with indices
1210  // a = 1..6 extended sfermion index
1211  // t = 1..5 sfermion type
1212  Farray<fh_real, 1,6, 1,5> MASf;
1213 
1214  // NMFV squark mixing matrices, with indices
1215  // a1 = 1..6 extended sfermion index (mass eigenstates)
1216  // a2 = 1..6 extended sfermion index (gauge eigenstates)
1217  // t = 1..5 sftermion type nu,e,u,d,?
1218  Farray<fh_complex, 1,36, 1,5> UASf;
1219 
1220  // chargino masses
1221  Farray<fh_real, 1,2> MCha;
1222 
1223  // chargino mixing matrices (mass,gauge) eigenstates (2 x 2)
1224  Farray<fh_complex, 1,4> UCha;
1225  Farray<fh_complex, 1,4> VCha;
1226 
1227  // neutralino masses
1228  Farray<fh_real, 1,4> MNeu;
1229 
1230  // neutralino mixing matrices (mass,gauge) eigenstates (4 x 4)
1231  Farray<fh_complex, 1,16> ZNeu;
1232 
1233  // correction to bottom Yukawa coupling
1234  fh_complex DeltaMB;
1235 
1236  // gluino mass
1237  fh_real MGl;
1238 
1239  // tree-level Higgs masses (Mh, MH, MA, MHpm)
1240  Farray<fh_real, 1,4> MHtree;
1241 
1242  // tree-level Higgs mixing parameters sin alpha
1243  fh_real SAtree;
1244 
1245  #ifdef SPECBIT_DEBUG
1246  cout << "****** calling FHGetPara ******" << endl;
1247  #endif
1248 
1249  int error = 1;
1250  BEreq::FHGetPara(error, nmfv, MSf, USf, MASf, UASf,
1251  MCha, UCha, VCha, MNeu, ZNeu,
1252  DeltaMB, MGl, MHtree, SAtree);
1253  if (error != 0)
1254  {
1255  std::ostringstream err;
1256  err << "BEreq::FHGetPara raised error flag: " << error << ".";
1257  invalid_point().raise(err.str());
1258  }
1259 
1260  fh_MSSMMassObs MassObs;
1261  for(int i = 0; i < 2; i++)
1262  for(int j = 0; j < 5; j++)
1263  for(int k = 0; k < 3; k++)
1264  MassObs.MSf[i][j][k] = MSf(i+1,j+1,k+1);
1265  for(int i = 0; i < 2; i++)
1266  for(int j = 0; j < 2; j++)
1267  for(int k = 0; k < 5; k++)
1268  for(int l = 0; l < 3; l++)
1269  MassObs.USf[i][j][k][l] = USf(i+1,j+1,k+1,l+1);
1270  for(int i = 0; i < 6; i++)
1271  for(int j = 0; j < 5; j++)
1272  MassObs.MASf[i][j] = MASf(i+1,j+1);
1273  for(int i = 0; i < 36; i++)
1274  for(int j = 0; j < 5; j++)
1275  MassObs.UASf[i][j] = UASf(i+1,j+1);
1276  for(int i = 0; i < 2; i++)
1277  MassObs.MCha[i] = MCha(i+1);
1278  for(int i = 0; i < 4; i++)
1279  {
1280  MassObs.UCha[i] = UCha(i+1);
1281  MassObs.VCha[i] = VCha(i+1);
1282  }
1283  for(int i = 0; i < 4; i++)
1284  MassObs.MNeu[i] = MNeu(i+1);
1285  for(int i = 0; i < 16; i++)
1286  MassObs.ZNeu[i] = ZNeu(i+1);
1287  MassObs.deltaMB = DeltaMB;
1288  MassObs.MGl = MGl;
1289  for(int i = 0; i < 4; i++)
1290  MassObs.MHtree[i] = MHtree(i+1);
1291  MassObs.SinAlphatree = SAtree;
1292 
1293  result = MassObs;
1294  }
void FH_MSSMMasses(fh_MSSMMassObs &result)
FeynHiggs SUSY masses and mixings.
virtual void raise(const std::string &)
Raise the exception, i.e. throw it.
Definition: exceptions.cpp:422
invalid_point_exception & invalid_point()
Invalid point exceptions.
Here is the call graph for this function:

◆ fill_3x3_parameter_matrix()

Eigen::Matrix<double,3,3> Gambit::SpecBit::fill_3x3_parameter_matrix ( const std::string &  rootname,
const std::map< str, safe_ptr< const double > > &  Param 
)

Helper function for setting 3x3 matrix-valued parameters.

Definition at line 511 of file SpecBit_MSSM.cpp.

Referenced by fill_MSSM63_input(), and fill_MSSM63_input_altnames().

512  {
513  Eigen::Matrix<double,3,3> output;
514  for(int i=0; i<3; ++i) for(int j=0; j<3; ++j)
515  {
516  output(i,j) = *Param.at(rootname + "_" + std::to_string(i+1) + std::to_string(j+1));
517  }
518  return output;
519  }
Here is the caller graph for this function:

◆ fill_3x3_symmetric_parameter_matrix()

Eigen::Matrix<double,3,3> Gambit::SpecBit::fill_3x3_symmetric_parameter_matrix ( const std::string &  rootname,
const std::map< str, safe_ptr< const double > > &  Param 
)

As above, but for symmetric input (i.e. 6 entries, assumed to be the upper triangle)

Definition at line 522 of file SpecBit_MSSM.cpp.

Referenced by fill_MSSM63_input(), and fill_MSSM63_input_altnames().

523  {
524  Eigen::Matrix<double,3,3> output;
525  for(int i=0; i<3; ++i) for(int j=0; j<3; ++j)
526  {
527  str parname = rootname + "_" + ( i < j ? std::to_string(i+1) + std::to_string(j+1) : std::to_string(j+1) + std::to_string(i+1));
528  output(i,j) = *Param.at(parname);
529  }
530  return output;
531  }
STL namespace.
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
Here is the caller graph for this function:

◆ fill_extra_input()

template<class T >
void Gambit::SpecBit::fill_extra_input ( T &  input,
const std::map< str, safe_ptr< const double > > &  Param 
)

Definition at line 317 of file SpecBit_ScalarSingletDM.cpp.

318  {
319  input.mu3Input=*Param.at("mu3");
320  }

◆ fill_map_from_DiracSingletDM_Z2spectrum()

void Gambit::SpecBit::fill_map_from_DiracSingletDM_Z2spectrum ( std::map< std::string, double > &  specmap,
const Spectrum diracdmspec 
)

Add everything... use spectrum contents routines to automate task

Verification routine should have taken care of invalid shapes etc, so won't check for that here.

Add everything... use spectrum contents routines to automate task

Verification routine should have taken care of invalid shapes etc, so won't check for that here.

Definition at line 165 of file SpecBit_DiracSingletDM.cpp.

References Gambit::SubSpectrumContents::all_parameters().

Referenced by get_DiracSingletDM_Z2_spectrum(), and get_DiracSingletDM_Z2_spectrum_as_map().

166  {
168  static const SpectrumContents::DiracSingletDM_Z2 contents;
169  static const std::vector<SpectrumParameter> required_parameters = contents.all_parameters();
170 
171  for(std::vector<SpectrumParameter>::const_iterator it = required_parameters.begin();
172  it != required_parameters.end(); ++it)
173  {
174  const Par::Tags tag = it->tag();
175  const std::string name = it->name();
176  const std::vector<int> shape = it->shape();
177 
179 
180  // Check scalar case
181  if(shape.size()==1 and shape[0]==1)
182  {
183  std::ostringstream label;
184  label << name <<" "<< Par::toString.at(tag);
185  specmap[label.str()] = diracdmspec.get_HE().get(tag,name);
186  }
187  // Check vector case
188  else if(shape.size()==1 and shape[0]>1)
189  {
190  for(int i = 1; i<=shape[0]; ++i) {
191  std::ostringstream label;
192  label << name <<"_"<<i<<" "<< Par::toString.at(tag);
193  specmap[label.str()] = diracdmspec.get_HE().get(tag,name,i);
194  }
195  }
196  // Check matrix case
197  else if(shape.size()==2)
198  {
199  for(int i = 1; i<=shape[0]; ++i) {
200  for(int j = 1; j<=shape[0]; ++j) {
201  std::ostringstream label;
202  label << name <<"_("<<i<<","<<j<<") "<<Par::toString.at(tag);
203  specmap[label.str()] = diracdmspec.get_HE().get(tag,name,i,j);
204  }
205  }
206  }
207  // Deal with all other cases
208  else
209  {
210  // ERROR
211  std::ostringstream errmsg;
212  errmsg << "Error, invalid parameter received while converting DiracSingletDM_Z2spectrum to map of strings! This should no be possible if the spectrum content verification routines were working correctly; they must be buggy, please report this.";
213  errmsg << "Problematic parameter was: "<< tag <<", " << name << ", shape="<< shape;
214  utils_error().forced_throw(LOCAL_INFO,errmsg.str());
215  }
216  }
217 
218  }
EXPORT_SYMBOLS error & utils_error()
Utility errors.
#define LOCAL_INFO
Definition: local_info.hpp:34
DS5_MSPCTM DS_INTDOF const str TH_ProcessCatalog DiracSingletDM_Z2
Here is the call graph for this function:
Here is the caller graph for this function:

◆ fill_map_from_MajoranaSingletDM_Z2spectrum()

void Gambit::SpecBit::fill_map_from_MajoranaSingletDM_Z2spectrum ( std::map< std::string, double > &  specmap,
const Spectrum majoranadmspec 
)

Add everything... use spectrum contents routines to automate task

Verification routine should have taken care of invalid shapes etc, so won't check for that here.

Add everything... use spectrum contents routines to automate task

Verification routine should have taken care of invalid shapes etc, so won't check for that here.

Definition at line 165 of file SpecBit_MajoranaSingletDM.cpp.

References Gambit::SubSpectrumContents::all_parameters().

Referenced by get_MajoranaSingletDM_Z2_spectrum(), and get_MajoranaSingletDM_Z2_spectrum_as_map().

166  {
168  static const SpectrumContents::MajoranaSingletDM_Z2 contents;
169  static const std::vector<SpectrumParameter> required_parameters = contents.all_parameters();
170 
171  for(std::vector<SpectrumParameter>::const_iterator it = required_parameters.begin();
172  it != required_parameters.end(); ++it)
173  {
174  const Par::Tags tag = it->tag();
175  const std::string name = it->name();
176  const std::vector<int> shape = it->shape();
177 
179 
180  // Check scalar case
181  if(shape.size()==1 and shape[0]==1)
182  {
183  std::ostringstream label;
184  label << name <<" "<< Par::toString.at(tag);
185  specmap[label.str()] = majoranadmspec.get_HE().get(tag,name);
186  }
187  // Check vector case
188  else if(shape.size()==1 and shape[0]>1)
189  {
190  for(int i = 1; i<=shape[0]; ++i) {
191  std::ostringstream label;
192  label << name <<"_"<<i<<" "<< Par::toString.at(tag);
193  specmap[label.str()] = majoranadmspec.get_HE().get(tag,name,i);
194  }
195  }
196  // Check matrix case
197  else if(shape.size()==2)
198  {
199  for(int i = 1; i<=shape[0]; ++i) {
200  for(int j = 1; j<=shape[0]; ++j) {
201  std::ostringstream label;
202  label << name <<"_("<<i<<","<<j<<") "<<Par::toString.at(tag);
203  specmap[label.str()] = majoranadmspec.get_HE().get(tag,name,i,j);
204  }
205  }
206  }
207  // Deal with all other cases
208  else
209  {
210  // ERROR
211  std::ostringstream errmsg;
212  errmsg << "Error, invalid parameter received while converting MajoranaSingletDM_Z2spectrum to map of strings! This should no be possible if the spectrum content verification routines were working correctly; they must be buggy, please report this.";
213  errmsg << "Problematic parameter was: "<< tag <<", " << name << ", shape="<< shape;
214  utils_error().forced_throw(LOCAL_INFO,errmsg.str());
215  }
216  }
217 
218  }
EXPORT_SYMBOLS error & utils_error()
Utility errors.
#define LOCAL_INFO
Definition: local_info.hpp:34
DS5_MSPCTM DS_INTDOF const str TH_ProcessCatalog MajoranaSingletDM_Z2
Here is the call graph for this function:
Here is the caller graph for this function:

◆ fill_map_from_MDMspectrum()

void Gambit::SpecBit::fill_map_from_MDMspectrum ( std::map< std::string, double > &  specmap,
const Spectrum mdmspec 
)

Print MDM spectrum out. Stripped down copy from MSSM version with variable names changed.

Add everything... use spectrum contents routines to automate task

Verification routine should have taken care of invalid shapes etc, so won't check for that here.

Add everything... use spectrum contents routines to automate task

Verification routine should have taken care of invalid shapes etc, so won't check for that here.

Definition at line 337 of file SpecBit_MDM.cpp.

References Gambit::SubSpectrumContents::all_parameters().

Referenced by find_non_perturb_scale_MDM(), and get_MDM_spectrum_as_map().

338  {
340  static const SpectrumContents::MDM contents;
341  static const std::vector<SpectrumParameter> required_parameters = contents.all_parameters();
342 
343  for(std::vector<SpectrumParameter>::const_iterator it = required_parameters.begin();
344  it != required_parameters.end(); ++it)
345  {
346  const Par::Tags tag = it->tag();
347  const std::string name = it->name();
348  const std::vector<int> shape = it->shape();
349 
351 
352  // Check scalar case
353  if(shape.size()==1 and shape[0]==1)
354  {
355  std::ostringstream label;
356  label << name <<" "<< Par::toString.at(tag);
357  specmap[label.str()] = mdmspec.get_HE().get(tag,name);
358  }
359  // Check vector case
360  else if(shape.size()==1 and shape[0]>1)
361  {
362  for(int i = 1; i<=shape[0]; ++i) {
363  std::ostringstream label;
364  label << name <<"_"<<i<<" "<< Par::toString.at(tag);
365  specmap[label.str()] = mdmspec.get_HE().get(tag,name,i);
366  }
367  }
368  // Check matrix case
369  else if(shape.size()==2)
370  {
371  for(int i = 1; i<=shape[0]; ++i) {
372  for(int j = 1; j<=shape[0]; ++j) {
373  std::ostringstream label;
374  label << name <<"_("<<i<<","<<j<<") "<<Par::toString.at(tag);
375  specmap[label.str()] = mdmspec.get_HE().get(tag,name,i,j);
376  }
377  }
378  }
379  // Deal with all other cases
380  else
381  {
382  // ERROR
383  std::ostringstream errmsg;
384  errmsg << "Error, invalid parameter received while converting MDMspectrum to map of strings! This should no be possible if the spectrum content verification routines were working correctly; they must be buggy, please report this.";
385  errmsg << "Problematic parameter was: "<< tag <<", " << name << ", shape="<< shape;
386  utils_error().forced_throw(LOCAL_INFO,errmsg.str());
387  }
388  }
389 
390  }
EXPORT_SYMBOLS error & utils_error()
Utility errors.
#define LOCAL_INFO
Definition: local_info.hpp:34
std::vector< SpectrumParameter > all_parameters() const
Function to retreive all parameters.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ fill_map_from_ScalarSingletDM_spectrum()

void Gambit::SpecBit::fill_map_from_ScalarSingletDM_spectrum ( std::map< std::string, double > &  specmap,
const Spectrum singletdmspec,
const std::vector< SpectrumParameter > &  required_parameters 
)

Print ScalarSingletDM spectra out. Stripped down copy of MSSM version with variable names changed.

Verification routine should have taken care of invalid shapes etc, so won't check for that here.

Definition at line 598 of file SpecBit_ScalarSingletDM.cpp.

Referenced by get_ScalarSingletDM_Z2_spectrum_as_map(), and get_ScalarSingletDM_Z3_spectrum_as_map().

600  {
601  for(std::vector<SpectrumParameter>::const_iterator it = required_parameters.begin();
602  it != required_parameters.end(); ++it)
603  {
604  const Par::Tags tag = it->tag();
605  const std::string name = it->name();
606  const std::vector<int> shape = it->shape();
607 
609 
610  // Check scalar case
611  if(shape.size()==1 and shape[0]==1)
612  {
613  std::ostringstream label;
614  label << name <<" "<< Par::toString.at(tag);
615  specmap[label.str()] = singletdmspec.get_HE().get(tag,name);
616  }
617  // Check vector case
618  else if(shape.size()==1 and shape[0]>1)
619  {
620  for(int i = 1; i<=shape[0]; ++i) {
621  std::ostringstream label;
622  label << name <<"_"<<i<<" "<< Par::toString.at(tag);
623  specmap[label.str()] = singletdmspec.get_HE().get(tag,name,i);
624  }
625  }
626  // Check matrix case
627  else if(shape.size()==2)
628  {
629  for(int i = 1; i<=shape[0]; ++i) {
630  for(int j = 1; j<=shape[0]; ++j) {
631  std::ostringstream label;
632  label << name <<"_("<<i<<","<<j<<") "<<Par::toString.at(tag);
633  specmap[label.str()] = singletdmspec.get_HE().get(tag,name,i,j);
634  }
635  }
636  }
637  // Deal with all other cases
638  else
639  {
640  // ERROR
641  std::ostringstream errmsg;
642  errmsg << "Error, invalid parameter received while converting SingletDMspectrum to map of strings! This should no be possible if the spectrum content verification routines were working correctly; they must be buggy, please report this.";
643  errmsg << "Problematic parameter was: "<< tag <<", " << name << ", shape="<< shape;
644  utils_error().forced_throw(LOCAL_INFO,errmsg.str());
645  }
646  }
647 
648  }
EXPORT_SYMBOLS error & utils_error()
Utility errors.
#define LOCAL_INFO
Definition: local_info.hpp:34
Here is the caller graph for this function:

◆ fill_map_from_subspectrum()

template<class Contents >
void Gambit::SpecBit::fill_map_from_subspectrum ( std::map< std::string, double > &  specmap,
const SubSpectrum subspec 
)

Convert MSSM type Spectrum object into a map, so it can be printed.

Extract all parameters from a subspectrum and put them into a map.

Add everything... use spectrum contents routines to automate task (make sure to use correct template parameter!)

Verification routine should have taken care of invalid shapes etc, so won't check for that here.

Add everything... use spectrum contents routines to automate task (make sure to use correct template parameter!)

Verification routine should have taken care of invalid shapes etc, so won't check for that here.

Definition at line 1762 of file SpecBit_MSSM.cpp.

Referenced by MSSM_higgs_couplings_FH().

1763  {
1765  static const Contents contents;
1766  static const std::vector<SpectrumParameter> required_parameters = contents.all_parameters();
1767 
1768  for(std::vector<SpectrumParameter>::const_iterator it = required_parameters.begin();
1769  it != required_parameters.end(); ++it)
1770  {
1771  const Par::Tags tag = it->tag();
1772  const std::string name = it->name();
1773  const std::vector<int> shape = it->shape();
1774 
1776 
1777  // Check scalar case
1778  if(shape.size()==1 and shape[0]==1)
1779  {
1780  std::ostringstream label;
1781  label << name <<" "<< Par::toString.at(tag);
1782  specmap[label.str()] = subspec.get(tag,name);
1783  // Check again ignoring overrides (if the value has an override defined)
1784  if(subspec.has(tag,name,overrides_only) and
1785  subspec.has(tag,name,ignore_overrides))
1786  {
1787  label << " (unimproved)";
1788  specmap[label.str()] = subspec.get(tag,name,ignore_overrides);
1789  }
1790  }
1791  // Check vector case
1792  else if(shape.size()==1 and shape[0]>1)
1793  {
1794  for(int i = 1; i<=shape[0]; ++i) {
1795  std::ostringstream label;
1796  label << name <<"_"<<i<<" "<< Par::toString.at(tag);
1797  specmap[label.str()] = subspec.get(tag,name,i);
1798  // Check again ignoring overrides
1799  if(subspec.has(tag,name,i,overrides_only) and
1800  subspec.has(tag,name,i,ignore_overrides))
1801  {
1802  label << " (unimproved)";
1803  specmap[label.str()] = subspec.get(tag,name,i,ignore_overrides);
1804  }
1805  }
1806  }
1807  // Check matrix case
1808  else if(shape.size()==2)
1809  {
1810  for(int i = 1; i<=shape[0]; ++i) {
1811  for(int j = 1; j<=shape[0]; ++j) {
1812  std::ostringstream label;
1813  label << name <<"_("<<i<<","<<j<<") "<<Par::toString.at(tag);
1814  specmap[label.str()] = subspec.get(tag,name,i,j);
1815  // Check again ignoring overrides
1816  if(subspec.has(tag,name,i,j,overrides_only) and
1817  subspec.has(tag,name,i,j,ignore_overrides))
1818  {
1819  label << " (unimproved)";
1820  specmap[label.str()] = subspec.get(tag,name,i,j,ignore_overrides);
1821  }
1822  }
1823  }
1824  }
1825  // Deal with all other cases
1826  else
1827  {
1828  // ERROR
1829  std::ostringstream errmsg;
1830  errmsg << "Error, invalid parameter received while converting SubSpectrum with contents \""<<contents.getName()<<"\" to map of strings! This should no be possible if the spectrum content verification routines were working correctly; they must be buggy, please report this.";
1831  errmsg << "Problematic parameter was: "<< tag <<", " << name << ", shape="<< shape;
1832  SpecBit_error().forced_throw(LOCAL_INFO,errmsg.str());
1833  }
1834  }
1835  // add the scale!
1836  specmap["scale(Q)"] = subspec.GetScale();
1837  }
#define LOCAL_INFO
Definition: local_info.hpp:34
Here is the caller graph for this function:

◆ fill_map_from_VectorSingletDM_Z2spectrum()

void Gambit::SpecBit::fill_map_from_VectorSingletDM_Z2spectrum ( std::map< std::string, double > &  specmap,
const Spectrum vectordmspec 
)

Add everything... use spectrum contents routines to automate task

Verification routine should have taken care of invalid shapes etc, so won't check for that here.

Add everything... use spectrum contents routines to automate task

Verification routine should have taken care of invalid shapes etc, so won't check for that here.

Definition at line 135 of file SpecBit_VectorSingletDM.cpp.

References Gambit::SubSpectrumContents::all_parameters().

Referenced by get_VectorSingletDM_Z2_spectrum(), and get_VectorSingletDM_Z2_spectrum_as_map().

136  {
138  static const SpectrumContents::VectorSingletDM_Z2 contents;
139  static const std::vector<SpectrumParameter> required_parameters = contents.all_parameters();
140 
141  for(std::vector<SpectrumParameter>::const_iterator it = required_parameters.begin();
142  it != required_parameters.end(); ++it)
143  {
144  const Par::Tags tag = it->tag();
145  const std::string name = it->name();
146  const std::vector<int> shape = it->shape();
147 
149 
150  // Check scalar case
151  if(shape.size()==1 and shape[0]==1)
152  {
153  std::ostringstream label;
154  label << name <<" "<< Par::toString.at(tag);
155  specmap[label.str()] = vectordmspec.get_HE().get(tag,name);
156  }
157  // Check vector case
158  else if(shape.size()==1 and shape[0]>1)
159  {
160  for(int i = 1; i<=shape[0]; ++i) {
161  std::ostringstream label;
162  label << name <<"_"<<i<<" "<< Par::toString.at(tag);
163  specmap[label.str()] = vectordmspec.get_HE().get(tag,name,i);
164  }
165  }
166  // Check matrix case
167  else if(shape.size()==2)
168  {
169  for(int i = 1; i<=shape[0]; ++i) {
170  for(int j = 1; j<=shape[0]; ++j) {
171  std::ostringstream label;
172  label << name <<"_("<<i<<","<<j<<") "<<Par::toString.at(tag);
173  specmap[label.str()] = vectordmspec.get_HE().get(tag,name,i,j);
174  }
175  }
176  }
177  // Deal with all other cases
178  else
179  {
180  // ERROR
181  std::ostringstream errmsg;
182  errmsg << "Error, invalid parameter received while converting VectorSingletDM_Z2spectrum to map of strings! This should no be possible if the spectrum content verification routines were working correctly; they must be buggy, please report this.";
183  errmsg << "Problematic parameter was: "<< tag <<", " << name << ", shape="<< shape;
184  utils_error().forced_throw(LOCAL_INFO,errmsg.str());
185  }
186  }
187 
188  }
EXPORT_SYMBOLS error & utils_error()
Utility errors.
#define LOCAL_INFO
Definition: local_info.hpp:34
Spectrum Spectrum Spectrum Spectrum VectorSingletDM_Z2
Here is the call graph for this function:
Here is the caller graph for this function:

◆ fill_MDM_input()

template<class T >
void Gambit::SpecBit::fill_MDM_input ( T &  input,
const std::map< str, safe_ptr< const double > > &  Param,
SMInputs  sminputs 
)

Definition at line 141 of file SpecBit_MDM.cpp.

References Gambit::SMInputs::mT, and Gambit::Scanner::pow().

Referenced by check_perturb_MDM().

142  {
143  double mH = *Param.at("mH");
144  double mChi = *Param.at("mChi");
145 
146  //double QEFT = mChi;
147  /*
148  if (QEFT < sminputs.mT)
149  {
150  QEFT = sminputs.mT;
151  }
152  */
153  double QEFT = sminputs.mT;
154 
155  input.HiggsIN = 0.5*pow(mH,2);
156 
157  input.YcIN = 0.5*mChi;
158 
159  input.QEWSB = QEFT; // scale where EWSB conditions are applied
160  input.Qin = QEFT; //scale; // highest scale at which model is run to
161 
162  }
double pow(const double &a)
Outputs a^i.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ fill_MSSM63_input()

template<class T >
void Gambit::SpecBit::fill_MSSM63_input ( T &  input,
const std::map< str, safe_ptr< const double > > &  Param 
)

Helper function for filling MSSM63-compatible input parameter objects Leaves out mHu2, mHd2, SignMu, (mA, mu) because we use two different parameterisations of these.

Definition at line 536 of file SpecBit_MSSM.cpp.

References fill_3x3_parameter_matrix(), fill_3x3_symmetric_parameter_matrix(), and LOCAL_INFO.

Referenced by get_MSSM_spectrum_SPheno().

537  {
538  //double valued parameters
539  input.TanBeta = *Param.at("TanBeta");
540  input.MassBInput = *Param.at("M1");
541  input.MassWBInput = *Param.at("M2");
542  input.MassGInput = *Param.at("M3");
543 
544  // Sanity checks
545  if(input.TanBeta<0)
546  {
547  std::ostringstream msg;
548  msg << "Tried to set TanBeta parameter to a negative value ("<<input.TanBeta<<")! This parameter must be positive. Please check your inifile and try again.";
549  SpecBit_error().raise(LOCAL_INFO,msg.str());
550  }
551 
552  //3x3 matrices; filled with the help of a convenience function
553  input.mq2Input = fill_3x3_symmetric_parameter_matrix("mq2", Param);
554  input.ml2Input = fill_3x3_symmetric_parameter_matrix("ml2", Param);
555  input.md2Input = fill_3x3_symmetric_parameter_matrix("md2", Param);
556  input.mu2Input = fill_3x3_symmetric_parameter_matrix("mu2", Param);
557  input.me2Input = fill_3x3_symmetric_parameter_matrix("me2", Param);
558  input.Aeij = fill_3x3_parameter_matrix("Ae", Param);
559  input.Adij = fill_3x3_parameter_matrix("Ad", Param);
560  input.Auij = fill_3x3_parameter_matrix("Au", Param);
561 
562  #ifdef SPECBIT_DEBUG
563  #define INPUT(p) input.p
564  #define ostr std::cout
565  #define oend std::endl
566  ostr << "TanBeta = " << INPUT(TanBeta) << ", " << oend ;
567  ostr << "mq2Input = " << oend << INPUT(mq2Input) << ", " << oend;
568  ostr << "ml2Input = " << oend << INPUT(ml2Input) << ", " << oend;
569  ostr << "md2Input = " << oend << INPUT(md2Input) << ", " << oend;
570  ostr << "mu2Input = " << oend << INPUT(mu2Input) << ", " << oend;
571  ostr << "me2Input = " << oend << INPUT(me2Input) << ", " << oend;
572  ostr << "MassBInput = " << INPUT(MassBInput) << ", " << oend;
573  ostr << "MassWBInput = " << INPUT(MassWBInput) << ", " << oend;
574  ostr << "MassGInput = " << INPUT(MassGInput) << ", " << oend;
575  ostr << "Aeij = " << oend << INPUT(Aeij) << ", " << oend;
576  ostr << "Adij = " << oend << INPUT(Adij) << ", " << oend;
577  ostr << "Auij = " << oend << INPUT(Auij) << ", " << oend;
578  #undef INPUT
579  #undef ostr
580  #undef oend
581  #endif
582  }
#define LOCAL_INFO
Definition: local_info.hpp:34
Eigen::Matrix< double, 3, 3 > fill_3x3_parameter_matrix(const std::string &rootname, const std::map< str, safe_ptr< const double > > &Param)
Helper function for setting 3x3 matrix-valued parameters.
Eigen::Matrix< double, 3, 3 > fill_3x3_symmetric_parameter_matrix(const std::string &rootname, const std::map< str, safe_ptr< const double > > &Param)
As above, but for symmetric input (i.e. 6 entries, assumed to be the upper triangle) ...
Here is the call graph for this function:
Here is the caller graph for this function:

◆ fill_MSSM63_input_altnames()

template<class T >
void Gambit::SpecBit::fill_MSSM63_input_altnames ( T &  input,
const std::map< str, safe_ptr< const double > > &  Param 
)

Definition at line 590 of file SpecBit_MSSM.cpp.

References fill_3x3_parameter_matrix(), fill_3x3_symmetric_parameter_matrix(), and LOCAL_INFO.

Referenced by get_MSSM_spectrum_SPheno().

591  {
592  //double valued parameters
593  input.TanBeta = *Param.at("TanBeta");
594  input.M1Input = *Param.at("M1");
595  input.M2Input = *Param.at("M2");
596  input.M3Input = *Param.at("M3");
597 
598  // Sanity checks
599  if(input.TanBeta<0)
600  {
601  std::ostringstream msg;
602  msg << "Tried to set TanBeta parameter to a negative value ("<<input.TanBeta<<")! This parameter must be positive. Please check your inifile and try again.";
603  SpecBit_error().raise(LOCAL_INFO,msg.str());
604  }
605 
606  //3x3 matrices; filled with the help of a convenience function
607  input.mq2Input = fill_3x3_symmetric_parameter_matrix("mq2", Param);
608  input.ml2Input = fill_3x3_symmetric_parameter_matrix("ml2", Param);
609  input.md2Input = fill_3x3_symmetric_parameter_matrix("md2", Param);
610  input.mu2Input = fill_3x3_symmetric_parameter_matrix("mu2", Param);
611  input.me2Input = fill_3x3_symmetric_parameter_matrix("me2", Param);
612  input.AeInput = fill_3x3_parameter_matrix("Ae", Param);
613  input.AdInput= fill_3x3_parameter_matrix("Ad", Param);
614  input.AuInput = fill_3x3_parameter_matrix("Au", Param);
615 
616  #ifdef SPECBIT_DEBUG
617  #define INPUT(p) input.p
618  #define ostr std::cout
619  #define oend std::endl
620  ostr << "TanBeta = " << INPUT(TanBeta) << ", " << oend ;
621  ostr << "mq2Input = " << oend << INPUT(mq2Input) << ", " << oend;
622  ostr << "ml2Input = " << oend << INPUT(ml2Input) << ", " << oend;
623  ostr << "md2Input = " << oend << INPUT(md2Input) << ", " << oend;
624  ostr << "mu2Input = " << oend << INPUT(mu2Input) << ", " << oend;
625  ostr << "me2Input = " << oend << INPUT(me2Input) << ", " << oend;
626  ostr << "M1Input = " << INPUT(M1Input) << ", " << oend;
627  ostr << "M2Input = " << INPUT(M2Input) << ", " << oend;
628  ostr << "M3Input = " << INPUT(M3Input) << ", " << oend;
629  ostr << "AeInput = " << oend << INPUT(AeInput) << ", " << oend;
630  ostr << "AdInput = " << oend << INPUT(AdInput) << ", " << oend;
631  ostr << "AuInput = " << oend << INPUT(AuInput) << ", " << oend;
632  #undef INPUT
633  #undef ostr
634  #undef oend
635  #endif
636 
637  }
#define LOCAL_INFO
Definition: local_info.hpp:34
Eigen::Matrix< double, 3, 3 > fill_3x3_parameter_matrix(const std::string &rootname, const std::map< str, safe_ptr< const double > > &Param)
Helper function for setting 3x3 matrix-valued parameters.
Eigen::Matrix< double, 3, 3 > fill_3x3_symmetric_parameter_matrix(const std::string &rootname, const std::map< str, safe_ptr< const double > > &Param)
As above, but for symmetric input (i.e. 6 entries, assumed to be the upper triangle) ...
Here is the call graph for this function:
Here is the caller graph for this function:

◆ fill_ScalarSingletDM_input()

template<class T >
void Gambit::SpecBit::fill_ScalarSingletDM_input ( T &  input,
const std::map< str, safe_ptr< const double > > &  Param,
SMInputs  sminputs 
)

Definition at line 290 of file SpecBit_ScalarSingletDM.cpp.

References Gambit::SMInputs::GF, Gambit::SMInputs::mT, and Gambit::Scanner::pow().

291  {
292  double mH = *Param.at("mH");
293  double mS = *Param.at("mS");
294  double lambda_hs = *Param.at("lambda_hS");
295  double lambda_s = *Param.at("lambda_S");
296 
297  double QEFT = mS;
298 
299  if (QEFT < sminputs.mT)
300  {
301  //QEFT = *Param.at("mZ");
302  QEFT = sminputs.mT;
303  }
304 
305  input.HiggsIN = -0.5*pow(mH,2);
306  double vev = 1. / sqrt(sqrt(2.)*sminputs.GF);
307 
308  input.muSInput = pow(mS,2)-0.5*lambda_hs*pow(vev,2);
309  input.LamSHInput = lambda_hs;
310  input.LamSInput = lambda_s;
311  input.QEWSB = QEFT; // scale where EWSB conditions are applied
312  input.Qin = QEFT; //scale; // highest scale at which model is run to
313 
314  }
double pow(const double &a)
Outputs a^i.
Here is the call graph for this function:

◆ find_min_lambda_Helper()

void Gambit::SpecBit::find_min_lambda_Helper ( dbl_dbl_bool vs_tuple,
const Spectrum fullspectrum,
double  high_energy_limit,
int  check_perturb_pts,
const std::vector< SpectrumParameter required_parameters 
)

Definition at line 184 of file SpecBit_VS.cpp.

References check_perturb_to_min_lambda(), Gambit::Spectrum::clone_HE(), Gambit::Spectrum::get(), LOCAL_INFO, Gambit::pi, Gambit::Par::Pole_Mass, Gambit::Scanner::pow(), and run_lambda().

Referenced by find_min_lambda_MDM(), find_min_lambda_ScalarSingletDM_Z2(), and find_min_lambda_ScalarSingletDM_Z3().

187  {
188  std::unique_ptr<SubSpectrum> speccloned = fullspectrum.clone_HE();
189 
190  // three scales at which we choose to run the quartic coupling up to, and then use a Lagrange interpolating polynomial
191  // to get an estimate for the location of the minimum, this is an efficient way to narrow down over a huge energy range
192  double u_1 = 1, u_2 = 5, u_3 = 12;
193  double lambda_1,lambda_2,lambda_3;
194  double lambda_min = 0;
195 
196 
197  bool min_exists = 1;// check if gradient is positive at electroweak scale
198  if ( run_lambda(101.0, &speccloned ) > run_lambda(100.0, &speccloned ) )
199  {
200  // gradient is positive, the minimum is less than electroweak scale so
201  // lambda_h must be monotonally increasing
202  min_exists = 0;
203  lambda_min = run_lambda(100.0,&speccloned);
204  }
205 
206  double mu_min = 0;
207  if (min_exists)
208  {
209 
210  // fit parabola (in log space) to the 3 trial points and use this to estimate the minimum
211 
212  for (int i=1;i<2;i++)
213  {
214 
215  lambda_1 = run_lambda(pow(10,u_1),&speccloned);
216  lambda_2 = run_lambda(pow(10,u_2),&speccloned);
217  lambda_3 = run_lambda(pow(10,u_3),&speccloned);
218 
219  double min_u= (lambda_1*(pow(u_2,2)-pow(u_3,2)) - lambda_2*(pow(u_1,2)-pow(u_3,2)) + lambda_3*(pow(u_1,2)-pow(u_2,2)));
220  double denominator = ( lambda_1*(u_2-u_3)+ lambda_2*(u_3-u_1) +lambda_3*(u_1-u_2));
221 
222  min_u=0.5*(min_u/denominator);
223  u_1=min_u-2/(pow(float(i),0.01));
224  u_2=min_u;
225  u_3=min_u+2/(pow(float(i),0.01));
226 
227  }
228 
229  // run downhill minimization routine to find exact minimum
230 
231  double mu_lower = pow(10,u_1);
232  double mu_upper = pow(10,u_3);
233  mu_min = pow(10,u_2);
234 
235  gsl_function F;
236  F.function = &run_lambda;
237  F.params = &speccloned;
238 
239  int status;
240  int iteration = 0, max_iteration = 1000;
241 
242  const gsl_min_fminimizer_type *T;
243  gsl_min_fminimizer *s;
244 
245  T = gsl_min_fminimizer_brent;
246  s = gsl_min_fminimizer_alloc (T);
247  gsl_min_fminimizer_set (s, &F, mu_min, mu_lower, mu_upper);
248 
249  do
250  {
251  iteration++;
252  status = gsl_min_fminimizer_iterate (s);
253 
254  mu_min = gsl_min_fminimizer_x_minimum (s);
255  mu_lower = gsl_min_fminimizer_x_lower (s);
256  mu_upper = gsl_min_fminimizer_x_upper (s);
257 
258  status = gsl_min_test_interval (mu_lower, mu_upper, 0.0001, 0.0001);
259  // cout << "mu_lower = " << mu_lower << " mu_upper = " << mu_upper << endl;
260  }
261  while (status == GSL_CONTINUE && iteration < max_iteration);
262 
263  if (iteration == max_iteration)
264  {
265  SpecBit_error().raise(LOCAL_INFO,"The minimum of the quartic coupling could not be found");
266  }
267 
268  gsl_min_fminimizer_free (s);
269 
270  lambda_min = run_lambda(mu_min,&speccloned);
271 
272  }
273 
274  #ifdef SPECBIT_DEBUG
275  std::cout<< "minimum value of quartic coupling is "<< lambda_min << " at " << mu_min <<" GeV"<<std::endl;
276  #endif
277 
278  double lifetime,LB;
279  if (lambda_min<0) // second minimum exists, now determine stability and lifetime
280  {
281  LB=mu_min;
282  #ifdef SPECBIT_DEBUG
283  double p=exp(4*140-26/(abs(0.5*lambda_min)))*pow(LB/(1.2e19),4); // compute tunnelling rate
284  if (p>1)
285  {
286  cout<< "vacuum is unstable" << endl;
287  }
288  else
289  {
290  cout<< "vacuum is metastable" << endl;
291  }
292  #endif
293  double pi2_8_over3 = 8.* pow ( pi , 2 ) / 3.;
294  double conversion = (6.5821195e-25)/(31536000);
295  // top factor is hbar in units of GeV.s and bottom factor is number of seconds in a year
296  lifetime=conversion/(exp(3*140-pi2_8_over3/(abs(0.5*lambda_min)))*pow(1/(1.2e19),3)*pow(LB,4));
297 
298  }
299  else // quartic coupling always positive, set output to default values
300  {
301  LB=high_energy_limit;
302  lifetime=1e300;
303  #ifdef SPECBIT_DEBUG
304  cout << "vacuum is absolutely stable" << endl;
305  #endif
306  // vacuum is stable
307  }
308  // now do a check on the perturbativity of the couplings up to this scale
309  bool perturbative=check_perturb_to_min_lambda(fullspectrum,LB,check_perturb_pts,required_parameters);
310  double perturb=float(!perturbative);
311  #ifdef SPECBIT_DEBUG
312  cout << "perturbativity checked up to " << LB << " result = " << perturbative << endl;
313  cout << "Higgs pole mass = " << fullspectrum.get(Par::Pole_Mass, "h0_1") << endl;
314  #endif
315  vs_tuple = dbl_dbl_bool(lifetime,LB,perturb);
316  }
bool check_perturb_to_min_lambda(const Spectrum &spec, double scale, int pts, const std::vector< SpectrumParameter > required_parameters)
Definition: SpecBit_VS.cpp:86
#define LOCAL_INFO
Definition: local_info.hpp:34
const double pi
double pow(const double &a)
Outputs a^i.
double run_lambda(double scale, void *params)
Definition: SpecBit_VS.cpp:152
Here is the call graph for this function:
Here is the caller graph for this function:

◆ find_min_lambda_MDM()

void Gambit::SpecBit::find_min_lambda_MDM ( dbl_dbl_bool vs_tuple)

Definition at line 339 of file SpecBit_VS.cpp.

References Gambit::SubSpectrumContents::all_parameters_with_tag(), Gambit::Par::dimensionless, and find_min_lambda_Helper().

340  {
341  namespace myPipe = Pipes::find_min_lambda_MDM;
342  double high_energy_limit = myPipe::runOptions->getValueOrDef<double>(1.22e19,"set_high_scale");
343  int check_perturb_pts = myPipe::runOptions->getValueOrDef<double>(10,"check_perturb_pts");
344  static const SpectrumContents::MDM contents;
345  static const std::vector<SpectrumParameter> required_parameters = contents.all_parameters_with_tag(Par::dimensionless);
346  find_min_lambda_Helper(vs_tuple, *myPipe::Dep::MDM_spectrum, high_energy_limit, check_perturb_pts, required_parameters);
347  }
void find_min_lambda_Helper(dbl_dbl_bool &vs_tuple, const Spectrum &fullspectrum, double high_energy_limit, int check_perturb_pts, const std::vector< SpectrumParameter > required_parameters)
Definition: SpecBit_VS.cpp:184
void find_min_lambda_MDM(dbl_dbl_bool &vs_tuple)
Definition: SpecBit_VS.cpp:339
Here is the call graph for this function:

◆ find_min_lambda_ScalarSingletDM_Z2()

void Gambit::SpecBit::find_min_lambda_ScalarSingletDM_Z2 ( dbl_dbl_bool vs_tuple)

Definition at line 319 of file SpecBit_VS.cpp.

References Gambit::SubSpectrumContents::all_parameters_with_tag(), Gambit::Par::dimensionless, find_min_lambda_Helper(), and ScalarSingletDM_Z2_spectrum.

320  {
322  double high_energy_limit = myPipe::runOptions->getValueOrDef<double>(1.22e19,"set_high_scale");
323  int check_perturb_pts = myPipe::runOptions->getValueOrDef<double>(10,"check_perturb_pts");
324  static const SpectrumContents::ScalarSingletDM_Z2 contents;
325  static const std::vector<SpectrumParameter> required_parameters = contents.all_parameters_with_tag(Par::dimensionless);
326  find_min_lambda_Helper(vs_tuple, *myPipe::Dep::ScalarSingletDM_Z2_spectrum, high_energy_limit, check_perturb_pts, required_parameters);
327  }
void find_min_lambda_Helper(dbl_dbl_bool &vs_tuple, const Spectrum &fullspectrum, double high_energy_limit, int check_perturb_pts, const std::vector< SpectrumParameter > required_parameters)
Definition: SpecBit_VS.cpp:184
Spectrum ScalarSingletDM_Z2
void find_min_lambda_ScalarSingletDM_Z2(dbl_dbl_bool &vs_tuple)
Definition: SpecBit_VS.cpp:319
Here is the call graph for this function:

◆ find_min_lambda_ScalarSingletDM_Z3()

void Gambit::SpecBit::find_min_lambda_ScalarSingletDM_Z3 ( dbl_dbl_bool vs_tuple)

Definition at line 329 of file SpecBit_VS.cpp.

References Gambit::SubSpectrumContents::all_parameters_with_tag(), Gambit::Par::dimensionless, find_min_lambda_Helper(), and ScalarSingletDM_Z3_spectrum.

330  {
332  double high_energy_limit = myPipe::runOptions->getValueOrDef<double>(1.22e19,"set_high_scale");
333  int check_perturb_pts = myPipe::runOptions->getValueOrDef<double>(10,"check_perturb_pts");
334  static const SpectrumContents::ScalarSingletDM_Z2 contents;
335  static const std::vector<SpectrumParameter> required_parameters = contents.all_parameters_with_tag(Par::dimensionless);
336  find_min_lambda_Helper(vs_tuple, *myPipe::Dep::ScalarSingletDM_Z3_spectrum, high_energy_limit, check_perturb_pts, required_parameters);
337  }
void find_min_lambda_ScalarSingletDM_Z3(dbl_dbl_bool &vs_tuple)
Definition: SpecBit_VS.cpp:329
void find_min_lambda_Helper(dbl_dbl_bool &vs_tuple, const Spectrum &fullspectrum, double high_energy_limit, int check_perturb_pts, const std::vector< SpectrumParameter > required_parameters)
Definition: SpecBit_VS.cpp:184
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum ScalarSingletDM_Z3_spectrum
Spectrum ScalarSingletDM_Z2
Here is the call graph for this function:

◆ find_non_perturb_scale_MDM()

void Gambit::SpecBit::find_non_perturb_scale_MDM ( double result)

Definition at line 279 of file SpecBit_MDM.cpp.

References b, check_perturb_MDM(), fill_map_from_MDMspectrum(), Gambit::invalid_point(), Gambit::Scanner::pow(), and Gambit::invalid_point_exception::raise().

280  {
281  using namespace flexiblesusy;
282  using namespace softsusy;
283  namespace myPipe = Pipes::find_non_perturb_scale_MDM;
284  using namespace Gambit;
285  using namespace SpecBit;
286 
287  const Spectrum& fullspectrum = *myPipe::Dep::MDM_spectrum;
288 
289  // bound x by (a,b)
290  // do all this is log space please
291 
292  double ms = *myPipe::Param.at("mS");
293 
294  double a = log10(ms);
295 
296  if (a > 20.0)
297  {
298  std::ostringstream msg;
299  msg << "Scalar mass larger than 10^20 GeV " << std::endl;
300  invalid_point().raise(msg.str());
301  }
302 
303  double b = 20.0;
304  double x = 0.5 * ( b + ms );
305 
306  while (abs(a-b)>1e-10)
307  {
308  //cout<< "\r" << "(a,b) = " << a << " " << b << endl;
309  //std::cout << std::flush;
310 
311  x=0.5*(b-a)+a;
312 
313 
314  if (!check_perturb_MDM(fullspectrum,pow(10,x),3))
315  {
316  b=x;
317  }
318  else
319  {
320  a=x;
321  }
322  }
323  result = pow(10,0.5*(a+b));
324  }
void find_non_perturb_scale_MDM(double &result)
bool check_perturb_MDM(const Spectrum &spec, double scale, int pts)
START_MODEL b
Definition: demo.hpp:235
std::chrono::milliseconds ms
virtual void raise(const std::string &)
Raise the exception, i.e. throw it.
Definition: exceptions.cpp:422
Spectrum Spectrum
double pow(const double &a)
Outputs a^i.
invalid_point_exception & invalid_point()
Invalid point exceptions.
TODO: see if we can use this one:
Definition: Analysis.hpp:33
Here is the call graph for this function:

◆ get_a1()

double Gambit::SpecBit::get_a1 ( const softsusy::QedQcd &  )

All 3 SM gauge couplings.

The QedQcd documenation has the following to say about this calculations: { This will calculate the three gauge couplings of the Standard Model at the scale m2. It's a simple one-loop calculation only and no thresholds are assumed. Range of validity is electroweak to top scale.

Definition at line 144 of file QedQcdWrapper.cpp.

145  {
146  // We need sin^2 thetaW(Q) for this; i.e. I think it is supposed to be
147  // supplied at whatever scale the rest of the parameters are currently
148  // defined at. Not sure how to handle this.
149  //QedQcd::getGaugeMu(const double m2, const double sinth)
150  return 0.;
151  }

◆ get_alpha()

double Gambit::SpecBit::get_alpha ( const softsusy::QedQcd &  model)

Plain C-function wrappers for QedQcd running coupling getters.

Definition at line 126 of file QedQcdWrapper.cpp.

Referenced by SpecBit::QedQcdWrapper::fill_getter_maps().

126 { return model.displayAlpha(softsusy::ALPHA); }
Here is the caller graph for this function:

◆ get_alphaS()

double Gambit::SpecBit::get_alphaS ( const softsusy::QedQcd &  model)

Definition at line 127 of file QedQcdWrapper.cpp.

Referenced by SpecBit::QedQcdWrapper::fill_getter_maps().

127 { return model.displayAlpha(softsusy::ALPHAS); }
Here is the caller graph for this function:

◆ get_charged_goldstone_pole_slha()

template<class Model >
double Gambit::SpecBit::get_charged_goldstone_pole_slha ( const Model &  model)

Definition at line 266 of file MSSMSpec.hpp.

267  {
268  return model.get_MHpm_pole_slha(0);
269  }

◆ get_DiracSingletDM_Z2_spectrum()

void Gambit::SpecBit::get_DiracSingletDM_Z2_spectrum ( Spectrum result)

Get a (simple) Spectrum object wrapper for the DiracSingletDM_Z2 model.

Definition at line 52 of file SpecBit_DiracSingletDM.cpp.

References Gambit::SMInputs::alphainv, Gambit::SMInputs::alphaS, Gambit::Models::DiracSingletDM_Z2Model::DiracLambda, Gambit::Models::DiracSingletDM_Z2Model::DiracPoleMass, Gambit::Models::DiracSingletDM_Z2Model::DiracXi, fill_map_from_DiracSingletDM_Z2spectrum(), Gambit::Models::DiracSingletDM_Z2Model::g1, Gambit::Models::DiracSingletDM_Z2Model::g2, Gambit::Models::DiracSingletDM_Z2Model::g3, Gambit::SMInputs::GF, Gambit::Models::DiracSingletDM_Z2Model::HiggsPoleMass, Gambit::Models::DiracSingletDM_Z2Model::HiggsVEV, Gambit::invalid_point(), Gambit::SMInputs::mBmB, Gambit::SMInputs::mCmC, Gambit::SMInputs::mD, Gambit::SMInputs::mE, mh, Gambit::SMInputs::mMu, Gambit::SMInputs::mS, Gambit::SMInputs::mT, Gambit::SMInputs::mTau, Gambit::SMInputs::mU, Gambit::SMInputs::mZ, Gambit::pi, Gambit::Scanner::pow(), Gambit::invalid_point_exception::raise(), Gambit::Models::DiracSingletDM_Z2Model::sinW2, SMINPUTS, Spectrum, Gambit::Models::DiracSingletDM_Z2Model::Yd, Gambit::Models::DiracSingletDM_Z2Model::Ye, and Gambit::Models::DiracSingletDM_Z2Model::Yu.

53  {
54  namespace myPipe = Pipes::get_DiracSingletDM_Z2_spectrum;
55  const SMInputs& sminputs = *myPipe::Dep::SMINPUTS;
56 
57  // Initialise an object to carry the Dirac plus Higgs sector information
58  Models::DiracSingletDM_Z2Model diracmodel;
59 
60  // quantities needed to fill container spectrum, intermediate calculations
61  double alpha_em = 1.0 / sminputs.alphainv;
62  double C = alpha_em * pi / (sminputs.GF * pow(2,0.5));
63  double sinW2 = 0.5 - pow( 0.25 - C/pow(sminputs.mZ,2) , 0.5);
64  double cosW2 = 0.5 + pow( 0.25 - C/pow(sminputs.mZ,2) , 0.5);
65  double e = pow( 4*pi*( alpha_em ),0.5) ;
66 
67  // Higgs sector
68  double mh = *myPipe::Param.at("mH");
69  diracmodel.HiggsPoleMass = mh;
70 
71  double vev = 1. / sqrt(sqrt(2.)*sminputs.GF);
72  diracmodel.HiggsVEV = vev;
73  // diracmodel.LambdaH = GF*pow(mh,2)/pow(2,0.5) ;
74 
75  // DiracSingletDM_Z2 sector
76  diracmodel.DiracPoleMass = *myPipe::Param.at("mF");
77  diracmodel.DiracLambda = *myPipe::Param.at("lF");
78  diracmodel.DiracXi = *myPipe::Param.at("xi");
79 
80  // Invalidate point if the EFT validity constraint is not satisfied
81  // See https://arxiv.org/abs/1512.06458v4 for more details
82  if (myPipe::runOptions->getValueOrDef<bool>(false,"impose_EFT_validity"))
83  {
84  // Different EFT validity constraints for different model parametrisations.
85  if (myPipe::ModelInUse("DiracSingletDM_Z2_sps"))
86  {
87  // Invadlidate point if the EFT validity constraint is not satisfied,
88  // for each coupling independently.
89  double gs = diracmodel.DiracLambda * std::cos(diracmodel.DiracXi);
90  double gp = diracmodel.DiracLambda * std::sin(diracmodel.DiracXi);
91 
92  if (myPipe::runOptions->getValueOrDef<bool>(false,"impose_EFT_validity"))
93  {
94  if (gs >= (4*pi)/(2*diracmodel.DiracPoleMass))
95  {
96  std::ostringstream msg;
97  msg << "Parameter point [mF, lF_s] = [" << diracmodel.DiracPoleMass << " GeV, "
98  << gs << "/GeV] does not satisfy the EFT validity constraint.";
99  invalid_point().raise(msg.str());
100  }
101  if (gp >= (4*pi)/(2*diracmodel.DiracPoleMass))
102  {
103  std::ostringstream msg;
104  msg << "Parameter point [mF, lF_ps] = [" << diracmodel.DiracPoleMass << " GeV, "
105  << gp << "/GeV] does not satisfy the EFT validity constraint.";
106  invalid_point().raise(msg.str());
107  }
108  }
109  }
110  else
111  {
112  // Parametrisation with lambda/Lambda, xi
113  if (diracmodel.DiracLambda >= (4*pi)/(2*diracmodel.DiracPoleMass))
114  {
115  std::ostringstream msg;
116  msg << "Parameter point [mF, lF] = [" << diracmodel.DiracPoleMass << " GeV, "
117  << diracmodel.DiracLambda << "/GeV] does not satisfy the EFT validity constraint.";
118  invalid_point().raise(msg.str());
119  }
120  }
121  }
122 
123  // Standard model
124  diracmodel.sinW2 = sinW2;
125 
126  // gauge couplings
127  diracmodel.g1 = sqrt(5/3) * e / sqrt(cosW2);
128  diracmodel.g2 = e / sqrt(sinW2);
129  diracmodel.g3 = pow( 4*pi*( sminputs.alphaS ),0.5) ;
130 
131  // Yukawas
132  double sqrt2v = pow(2.0,0.5)/vev;
133  diracmodel.Yu[0] = sqrt2v * sminputs.mU;
134  diracmodel.Yu[1] = sqrt2v * sminputs.mCmC;
135  diracmodel.Yu[2] = sqrt2v * sminputs.mT;
136  diracmodel.Ye[0] = sqrt2v * sminputs.mE;
137  diracmodel.Ye[1] = sqrt2v * sminputs.mMu;
138  diracmodel.Ye[2] = sqrt2v * sminputs.mTau;
139  diracmodel.Yd[0] = sqrt2v * sminputs.mD;
140  diracmodel.Yd[1] = sqrt2v * sminputs.mS;
141  diracmodel.Yd[2] = sqrt2v * sminputs.mBmB;
142 
143  // Create a SubSpectrum object to wrap the EW sector information
144  Models::DiracSingletDM_Z2SimpleSpec diracspec(diracmodel);
145 
146  // Retrieve any mass cuts
147  static const Spectrum::mc_info mass_cut = myPipe::runOptions->getValueOrDef<Spectrum::mc_info>(Spectrum::mc_info(), "mass_cut");
148  static const Spectrum::mr_info mass_ratio_cut = myPipe::runOptions->getValueOrDef<Spectrum::mr_info>(Spectrum::mr_info(), "mass_ratio_cut");
149 
150  // We don't supply a LE subspectrum here; an SMSimpleSpec will therefore be automatically created from 'sminputs'
151  result = Spectrum(diracspec,sminputs,&myPipe::Param,mass_cut,mass_ratio_cut);
152 
153  }
virtual void raise(const std::string &)
Raise the exception, i.e. throw it.
Definition: exceptions.cpp:422
const double pi
void get_DiracSingletDM_Z2_spectrum(Spectrum &result)
Get a (simple) Spectrum object wrapper for the DiracSingletDM_Z2 model.
Spectrum Spectrum
double pow(const double &a)
Outputs a^i.
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum mh
invalid_point_exception & invalid_point()
Invalid point exceptions.
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum SMINPUTS
Here is the call graph for this function:

◆ get_DiracSingletDM_Z2_spectrum_as_map()

void Gambit::SpecBit::get_DiracSingletDM_Z2_spectrum_as_map ( std::map< std::string, double > &  specmap)

Definition at line 158 of file SpecBit_DiracSingletDM.cpp.

References fill_map_from_DiracSingletDM_Z2spectrum().

159  {
161  const Spectrum& diracdmspec(*myPipe::Dep::DiracSingletDM_Z2_spectrum);
162  fill_map_from_DiracSingletDM_Z2spectrum(specmap, diracdmspec);
163  }
void fill_map_from_DiracSingletDM_Z2spectrum(std::map< std::string, double > &, const Spectrum &)
void get_DiracSingletDM_Z2_spectrum_as_map(std::map< std::string, double > &specmap)
Spectrum Spectrum
Here is the call graph for this function:

◆ get_DRbar_mA2()

template<class Model >
double Gambit::SpecBit::get_DRbar_mA2 ( const Model &  model)

Definition at line 225 of file MSSMSpec.hpp.

226  {
227  double tb = model.get_vu() / model.get_vd();
228  double cb = cos(atan(tb));
229  double sb = sin(atan(tb));
230  return model.get_BMu() / (sb * cb);
231  }

◆ get_expected_vacuum_lifetime()

void Gambit::SpecBit::get_expected_vacuum_lifetime ( double lifetime)

Definition at line 353 of file SpecBit_VS.cpp.

References Gambit::dbl_dbl_bool::first.

354  {
355  namespace myPipe = Pipes::get_expected_vacuum_lifetime;
356  dbl_dbl_bool vs_tuple = *myPipe::Dep::high_scale_vacuum_info;
357 
358  if (vs_tuple.first<1e300)
359  {
360  lifetime=vs_tuple.first;
361  }
362  else
363  {
364  lifetime=1e300;
365  }
366  }
void get_expected_vacuum_lifetime(double &lifetime)
Definition: SpecBit_VS.cpp:353

◆ get_GUTMSSMB_spectrum()

void Gambit::SpecBit::get_GUTMSSMB_spectrum ( Spectrum )

Definition at line 1039 of file SpecBit_MSSM.cpp.

1040  {
1041  // Placeholder
1042  }

◆ get_invisibles()

std::vector<str> Gambit::SpecBit::get_invisibles ( const SubSpectrum spec)

Helper function to work out if the LSP is invisible, and if so, which particle it is.

Definition at line 1450 of file SpecBit_MSSM.cpp.

References Gambit::SubSpectrum::get(), and Gambit::Par::Pole_Mass.

Referenced by MSSM_higgs_couplings_FH(), and MSSM_higgs_couplings_pwid().

1451  {
1452  // Get the lighter of the lightest neutralino and the lightest sneutrino
1453  std::pair<str,double> neutralino("~chi0_1", spec.get(Par::Pole_Mass,"~chi0",1));
1454  std::pair<str,double> sneutrino("~nu_1", spec.get(Par::Pole_Mass,"~nu",1));
1455  std::pair<str,double> lnp = (neutralino.second < sneutrino.second ? neutralino : sneutrino);
1456 
1457  // Work out if this is indeed the LSP, and if decays of at least one neutral higgs to it are kinematically possible.
1458  bool inv_lsp = spec.get(Par::Pole_Mass,"~chi+",1) > lnp.second and
1459  spec.get(Par::Pole_Mass,"~g") > lnp.second and
1460  spec.get(Par::Pole_Mass,"~d",1) > lnp.second and
1461  spec.get(Par::Pole_Mass,"~u",1) > lnp.second and
1462  spec.get(Par::Pole_Mass,"~e-",1) > lnp.second and
1463  (spec.get(Par::Pole_Mass,"h0",2) > 2.*lnp.second or
1464  spec.get(Par::Pole_Mass,"A0") > 2.*lnp.second);
1465 
1466  // Create a vector containing all invisible products of higgs decays.
1467  if (inv_lsp) return initVector<str>(lnp.first);
1468  return std::vector<str>();
1469  }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ get_lambdaB()

void Gambit::SpecBit::get_lambdaB ( double result)

Definition at line 391 of file SpecBit_VS.cpp.

References Gambit::dbl_dbl_bool::second.

392  {
393  namespace myPipe = Pipes::get_lambdaB;
394  dbl_dbl_bool vs_tuple = *myPipe::Dep::high_scale_vacuum_info;
395  result=vs_tuple.second;
396  }
void get_lambdaB(double &result)
Definition: SpecBit_VS.cpp:391

◆ get_MAh1_pole_slha()

template<class Model >
double Gambit::SpecBit::get_MAh1_pole_slha ( const Model &  model)

Definition at line 246 of file MSSMSpec.hpp.

247  {
248  return model.get_MAh_pole_slha(1);
249  }

◆ get_MajoranaSingletDM_Z2_spectrum()

void Gambit::SpecBit::get_MajoranaSingletDM_Z2_spectrum ( Spectrum result)

Get a (simple) Spectrum object wrapper for the MajoranaSingletDM_Z2 model.

Definition at line 52 of file SpecBit_MajoranaSingletDM.cpp.

References Gambit::SMInputs::alphainv, Gambit::SMInputs::alphaS, fill_map_from_MajoranaSingletDM_Z2spectrum(), Gambit::Models::MajoranaSingletDM_Z2Model::g1, Gambit::Models::MajoranaSingletDM_Z2Model::g2, Gambit::Models::MajoranaSingletDM_Z2Model::g3, Gambit::SMInputs::GF, Gambit::Models::MajoranaSingletDM_Z2Model::HiggsPoleMass, Gambit::Models::MajoranaSingletDM_Z2Model::HiggsVEV, Gambit::invalid_point(), Gambit::Models::MajoranaSingletDM_Z2Model::MajoranaLambda, Gambit::Models::MajoranaSingletDM_Z2Model::MajoranaPoleMass, Gambit::Models::MajoranaSingletDM_Z2Model::MajoranaXi, Gambit::SMInputs::mBmB, Gambit::SMInputs::mCmC, Gambit::SMInputs::mD, Gambit::SMInputs::mE, mh, Gambit::SMInputs::mMu, Gambit::SMInputs::mS, Gambit::SMInputs::mT, Gambit::SMInputs::mTau, Gambit::SMInputs::mU, Gambit::SMInputs::mZ, Gambit::pi, Gambit::Scanner::pow(), Gambit::invalid_point_exception::raise(), Gambit::Models::MajoranaSingletDM_Z2Model::sinW2, SMINPUTS, Spectrum, Gambit::Models::MajoranaSingletDM_Z2Model::Yd, Gambit::Models::MajoranaSingletDM_Z2Model::Ye, and Gambit::Models::MajoranaSingletDM_Z2Model::Yu.

53  {
55  const SMInputs& sminputs = *myPipe::Dep::SMINPUTS;
56 
57  // Initialise an object to carry the Majorana plus Higgs sector information
58  Models::MajoranaSingletDM_Z2Model majoranamodel;
59 
60  // quantities needed to fill container spectrum, intermediate calculations
61  double alpha_em = 1.0 / sminputs.alphainv;
62  double C = alpha_em * pi / (sminputs.GF * pow(2,0.5));
63  double sinW2 = 0.5 - pow( 0.25 - C/pow(sminputs.mZ,2) , 0.5);
64  double cosW2 = 0.5 + pow( 0.25 - C/pow(sminputs.mZ,2) , 0.5);
65  double e = pow( 4*pi*( alpha_em ),0.5) ;
66 
67  // Higgs sector
68  double mh = *myPipe::Param.at("mH");
69  majoranamodel.HiggsPoleMass = mh;
70 
71  double vev = 1. / sqrt(sqrt(2.)*sminputs.GF);
72  majoranamodel.HiggsVEV = vev;
73  // majoranamodel.LambdaH = GF*pow(mh,2)/pow(2,0.5) ;
74 
75  // MajoranaSingletDM_Z2 sector
76  majoranamodel.MajoranaPoleMass = *myPipe::Param.at("mX");
77  majoranamodel.MajoranaLambda = *myPipe::Param.at("lX");
78  majoranamodel.MajoranaXi = *myPipe::Param.at("xi");
79 
80  // Invalidate point if the EFT validity constraint is not satisfied
81  // See https://arxiv.org/abs/1512.06458v4 for more details
82  if (myPipe::runOptions->getValueOrDef<bool>(false,"impose_EFT_validity"))
83  {
84  // Different EFT validity constraints for different model parametrisations.
85  if (myPipe::ModelInUse("MajoranaSingletDM_Z2_sps"))
86  {
87  // Invadlidate point if the EFT validity constraint is not satisfied,
88  // for each coupling independently.
89  double gs = majoranamodel.MajoranaLambda * std::cos(majoranamodel.MajoranaXi);
90  double gp = majoranamodel.MajoranaLambda * std::sin(majoranamodel.MajoranaXi);
91 
92  if (myPipe::runOptions->getValueOrDef<bool>(false,"impose_EFT_validity"))
93  {
94  if (gs >= (4*pi)/(2*majoranamodel.MajoranaPoleMass))
95  {
96  std::ostringstream msg;
97  msg << "Parameter point [mX, lX_s] = [" << majoranamodel.MajoranaPoleMass << " GeV, "
98  << gs << "/GeV] does not satisfy the EFT validity constraint.";
99  invalid_point().raise(msg.str());
100  }
101  if (gp >= (4*pi)/(2*majoranamodel.MajoranaPoleMass))
102  {
103  std::ostringstream msg;
104  msg << "Parameter point [mX, lX_ps] = [" << majoranamodel.MajoranaPoleMass << " GeV, "
105  << gp << "/GeV] does not satisfy the EFT validity constraint.";
106  invalid_point().raise(msg.str());
107  }
108  }
109  }
110  else
111  {
112  // Parametrisation with lambda/Lambda, xi
113  if (majoranamodel.MajoranaLambda >= (4*pi)/(2*majoranamodel.MajoranaPoleMass))
114  {
115  std::ostringstream msg;
116  msg << "Parameter point [mX, lX] = [" << majoranamodel.MajoranaPoleMass << " GeV, "
117  << majoranamodel.MajoranaLambda << "/GeV] does not satisfy the EFT validity constraint.";
118  invalid_point().raise(msg.str());
119  }
120  }
121  }
122 
123  // Standard model
124  majoranamodel.sinW2 = sinW2;
125 
126  // gauge couplings
127  majoranamodel.g1 = sqrt(5/3) * e / sqrt(cosW2);
128  majoranamodel.g2 = e / sqrt(sinW2);
129  majoranamodel.g3 = pow( 4*pi*( sminputs.alphaS ),0.5) ;
130 
131  // Yukawas
132  double sqrt2v = pow(2.0,0.5)/vev;
133  majoranamodel.Yu[0] = sqrt2v * sminputs.mU;
134  majoranamodel.Yu[1] = sqrt2v * sminputs.mCmC;
135  majoranamodel.Yu[2] = sqrt2v * sminputs.mT;
136  majoranamodel.Ye[0] = sqrt2v * sminputs.mE;
137  majoranamodel.Ye[1] = sqrt2v * sminputs.mMu;
138  majoranamodel.Ye[2] = sqrt2v * sminputs.mTau;
139  majoranamodel.Yd[0] = sqrt2v * sminputs.mD;
140  majoranamodel.Yd[1] = sqrt2v * sminputs.mS;
141  majoranamodel.Yd[2] = sqrt2v * sminputs.mBmB;
142 
143  // Create a SubSpectrum object to wrap the EW sector information
144  Models::MajoranaSingletDM_Z2SimpleSpec majoranaspec(majoranamodel);
145 
146  // Retrieve any mass cuts
147  static const Spectrum::mc_info mass_cut = myPipe::runOptions->getValueOrDef<Spectrum::mc_info>(Spectrum::mc_info(), "mass_cut");
148  static const Spectrum::mr_info mass_ratio_cut = myPipe::runOptions->getValueOrDef<Spectrum::mr_info>(Spectrum::mr_info(), "mass_ratio_cut");
149 
150  // We don't supply a LE subspectrum here; an SMSimpleSpec will therefore be automatically created from 'sminputs'
151  result = Spectrum(majoranaspec,sminputs,&myPipe::Param,mass_cut,mass_ratio_cut);
152 
153  }
virtual void raise(const std::string &)
Raise the exception, i.e. throw it.
Definition: exceptions.cpp:422
const double pi
void get_MajoranaSingletDM_Z2_spectrum(Spectrum &result)
Get a (simple) Spectrum object wrapper for the MajoranaSingletDM_Z2 model.
Spectrum Spectrum
double pow(const double &a)
Outputs a^i.
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum mh
invalid_point_exception & invalid_point()
Invalid point exceptions.
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum SMINPUTS
Here is the call graph for this function:

◆ get_MajoranaSingletDM_Z2_spectrum_as_map()

void Gambit::SpecBit::get_MajoranaSingletDM_Z2_spectrum_as_map ( std::map< std::string, double > &  specmap)

Definition at line 158 of file SpecBit_MajoranaSingletDM.cpp.

References fill_map_from_MajoranaSingletDM_Z2spectrum(), and MajoranaSingletDM_Z2_spectrum.

159  {
162  fill_map_from_MajoranaSingletDM_Z2spectrum(specmap, majoranadmspec);
163  }
Spectrum Spectrum Spectrum Spectrum Spectrum MajoranaSingletDM_Z2_spectrum
Spectrum Spectrum
void get_MajoranaSingletDM_Z2_spectrum_as_map(std::map< std::string, double > &specmap)
void fill_map_from_MajoranaSingletDM_Z2spectrum(std::map< std::string, double > &, const Spectrum &)
Here is the call graph for this function:

◆ get_mBottom()

double Gambit::SpecBit::get_mBottom ( const softsusy::QedQcd &  model)

Definition at line 115 of file QedQcdWrapper.cpp.

Referenced by SpecBit::QedQcdWrapper::fill_getter_maps().

115 { return model.displayMass(softsusy::mBottom); }
Here is the caller graph for this function:

◆ get_mCharm()

double Gambit::SpecBit::get_mCharm ( const softsusy::QedQcd &  model)

Definition at line 111 of file QedQcdWrapper.cpp.

Referenced by SpecBit::QedQcdWrapper::fill_getter_maps().

111 { return model.displayMass(softsusy::mCharm); }
Here is the caller graph for this function:

◆ get_MDM_spectrum_as_map()

void Gambit::SpecBit::get_MDM_spectrum_as_map ( std::map< std::string, double > &  specmap)

Definition at line 330 of file SpecBit_MDM.cpp.

References fill_map_from_MDMspectrum().

331  {
332  namespace myPipe = Pipes::get_MDM_spectrum_as_map;
333  const Spectrum& mdmspec(*myPipe::Dep::MDM_spectrum);
334  fill_map_from_MDMspectrum(specmap, mdmspec);
335  }
Spectrum Spectrum
void fill_map_from_MDMspectrum(std::map< std::string, double > &, const Spectrum &)
Print MDM spectrum out. Stripped down copy from MSSM version with variable names changed.
void get_MDM_spectrum_as_map(std::map< std::string, double > &specmap)
Here is the call graph for this function:

◆ get_mDown()

double Gambit::SpecBit::get_mDown ( const softsusy::QedQcd &  model)

Definition at line 113 of file QedQcdWrapper.cpp.

Referenced by SpecBit::QedQcdWrapper::fill_getter_maps().

113 { return model.displayMass(softsusy::mDown); }
Here is the caller graph for this function:

◆ get_mElectron()

double Gambit::SpecBit::get_mElectron ( const softsusy::QedQcd &  model)

Definition at line 116 of file QedQcdWrapper.cpp.

Referenced by SpecBit::QedQcdWrapper::fill_getter_maps().

116 { return model.displayMass(softsusy::mElectron); }
Here is the caller graph for this function:

◆ get_mGluon()

double Gambit::SpecBit::get_mGluon ( const softsusy::QedQcd &  )

Definition at line 121 of file QedQcdWrapper.cpp.

Referenced by SpecBit::QedQcdWrapper::fill_getter_maps().

121 { return 0.; }
Here is the caller graph for this function:

◆ get_MHpm1_pole_slha()

template<class Model >
double Gambit::SpecBit::get_MHpm1_pole_slha ( const Model &  model)

Definition at line 252 of file MSSMSpec.hpp.

253  {
254  return model.get_MHpm_pole_slha(1);
255  }

◆ get_mMuon()

double Gambit::SpecBit::get_mMuon ( const softsusy::QedQcd &  model)

Definition at line 117 of file QedQcdWrapper.cpp.

Referenced by SpecBit::QedQcdWrapper::fill_getter_maps().

117 { return model.displayMass(softsusy::mMuon); }
Here is the caller graph for this function:

◆ get_mPhoton()

double Gambit::SpecBit::get_mPhoton ( const softsusy::QedQcd &  )

Definition at line 120 of file QedQcdWrapper.cpp.

Referenced by SpecBit::QedQcdWrapper::fill_getter_maps().

120 { return 0.; }
Here is the caller graph for this function:

◆ get_MSSM_spectrum_as_map()

void Gambit::SpecBit::get_MSSM_spectrum_as_map ( std::map< std::string, double > &  specmap)

Definition at line 1742 of file SpecBit_MSSM.cpp.

References add_extra_MSSM_parameter_combinations(), Gambit::Spectrum::get_HE(), Gambit::Spectrum::get_LE(), and MSSM_spectrum.

1743  {
1744  namespace myPipe = Pipes::get_MSSM_spectrum_as_map;
1745  const Spectrum& mssmspec(*myPipe::Dep::MSSM_spectrum);
1746  fill_map_from_subspectrum<SpectrumContents::SM> (specmap, mssmspec.get_LE());
1747  fill_map_from_subspectrum<SpectrumContents::MSSM>(specmap, mssmspec.get_HE());
1748  add_extra_MSSM_parameter_combinations(specmap, mssmspec.get_HE());
1749  }
void add_extra_MSSM_parameter_combinations(std::map< std::string, double > &specmap, const SubSpectrum &mssm)
Adds additional information from interesting combinations of MSSM parameters.
Spectrum Spectrum
void get_MSSM_spectrum_as_map(std::map< std::string, double > &specmap)
Here is the call graph for this function:

◆ get_MSSM_spectrum_as_SLHAea_SLHA1()

void Gambit::SpecBit::get_MSSM_spectrum_as_SLHAea_SLHA1 ( SLHAstruct result)

Extract an SLHAea version of the spectrum contained in a Spectrum object, in SLHA1 format.

Definition at line 1058 of file SpecBit_MSSM.cpp.

References unimproved_MSSM_spectrum.

1059  {
1061  }

◆ get_MSSM_spectrum_as_SLHAea_SLHA2()

void Gambit::SpecBit::get_MSSM_spectrum_as_SLHAea_SLHA2 ( SLHAstruct result)

Extract an SLHAea version of the spectrum contained in a Spectrum object, in SLHA2 format.

Definition at line 1064 of file SpecBit_MSSM.cpp.

References unimproved_MSSM_spectrum.

1065  {
1067  }

◆ get_MSSM_spectrum_from_SLHAfile()

void Gambit::SpecBit::get_MSSM_spectrum_from_SLHAfile ( Spectrum result)

Get an MSSMSpectrum object from an SLHA file Wraps it up in MSSMSimpleSpec; i.e.

no RGE running possible. This is mainly for testing against benchmark points, but may be a useful last resort for interacting with "difficult" spectrum generators.

Definition at line 1073 of file SpecBit_MSSM.cpp.

References Gambit::EOM, Gambit::Spectrum::get_HE(), has_neutralino_LSP(), Gambit::invalid_point(), LOCAL_INFO, Gambit::logger(), Gambit::Par::mass1, Gambit::invalid_point_exception::raise(), and Gambit::SubSpectrum::set_override().

1074  {
1075  // Static counter running in a loop over all filenames
1076  static unsigned int counter = 0;
1077  static long int ncycle = 1;
1078  SLHAstruct input_slha;
1079 
1080  namespace myPipe = Pipes::get_MSSM_spectrum_from_SLHAfile;
1081 
1082  // Read filename from yaml file
1083  std::vector<std::string> filenames =
1084  myPipe::runOptions->getValue<std::vector<std::string>>("filenames");
1085 
1086  // Check how many loop over the input files we are doing.
1087  long int cycles = myPipe::runOptions->getValueOrDef<int>(-1,"cycles");
1088 
1089  // Check if we have completed the requested number of cycles
1090  if(cycles>0 and ncycle>cycles)
1091  {
1092  std::ostringstream msg;
1093  msg << "Preset number of loops through input files reached! Stopping. (tried to start cycle "<<ncycle<<" of "<<cycles<<")";
1094  SpecBit_error().raise(LOCAL_INFO,msg.str());
1095  }
1096 
1097  std::string filename = filenames[counter];
1098 
1099  logger() << "Reading SLHA file: " << filename << EOM;
1100  std::ifstream ifs(filename.c_str());
1101  if(!ifs.good()){ SpecBit_error().raise(LOCAL_INFO,"ERROR: SLHA file not found."); }
1102  ifs >> input_slha;
1103  ifs.close();
1104  counter++;
1105  if( counter >= filenames.size() )
1106  {
1107  logger() << "Returning to start of input SLHA file list (finished "<<ncycle<<" cycles)" << EOM;
1108  counter = 0;
1109  ncycle++;
1110  }
1111 
1112  // Retrieve any mass cuts
1113  static const Spectrum::mc_info mass_cut = myPipe::runOptions->getValueOrDef<Spectrum::mc_info>(Spectrum::mc_info(), "mass_cut");
1114  static const Spectrum::mr_info mass_ratio_cut = myPipe::runOptions->getValueOrDef<Spectrum::mr_info>(Spectrum::mr_info(), "mass_ratio_cut");
1115 
1116  // Create Spectrum object from the slhaea object
1117  result = spectrum_from_SLHAea<MSSMSimpleSpec, SLHAstruct>(input_slha, input_slha, mass_cut, mass_ratio_cut);
1118 
1119  // Add getter for susy scale if option set for this
1120  bool add_susy_scale = myPipe::runOptions->getValueOrDef<bool>(false,"assume_Q_is_MSUSY");
1121  if(add_susy_scale)
1122  {
1123  result.get_HE().set_override(Par::mass1,result.get_HE().GetScale(),"susy_scale",true);
1124  }
1125 
1126  // No sneaking in charged LSPs via SLHA, jävlar.
1127  if (not has_neutralino_LSP(result)) invalid_point().raise("Neutralino is not LSP.");
1128  }
#define LOCAL_INFO
Definition: local_info.hpp:34
SLHAea::Coll SLHAstruct
Less confusing name for SLHAea container class.
virtual void raise(const std::string &)
Raise the exception, i.e. throw it.
Definition: exceptions.cpp:422
const Logging::endofmessage EOM
Explicit const instance of the end of message struct in Gambit namespace.
Definition: logger.hpp:99
Logging::LogMaster & logger()
Function to retrieve a reference to the Gambit global log object.
Definition: logger.cpp:95
void get_MSSM_spectrum_from_SLHAfile(Spectrum &result)
Get an MSSMSpectrum object from an SLHA file Wraps it up in MSSMSimpleSpec; i.e.
invalid_point_exception & invalid_point()
Invalid point exceptions.
bool has_neutralino_LSP(const Spectrum *result)
Helper to work with pointer.
Here is the call graph for this function:

◆ get_MSSM_spectrum_from_SLHAstruct()

void Gambit::SpecBit::get_MSSM_spectrum_from_SLHAstruct ( Spectrum result)

Get an MSSMSpectrum object from an SLHAstruct Wraps it up in MSSMSimpleSpec; i.e.

no RGE running possible. This can be used as a poor-man's interface to backend spectrum generators

Definition at line 1133 of file SpecBit_MSSM.cpp.

References has_neutralino_LSP(), Gambit::invalid_point(), LOCAL_INFO, Gambit::Par::mass1, Gambit::invalid_point_exception::raise(), and unimproved_MSSM_spectrum.

1134  {
1135  namespace myPipe = Pipes::get_MSSM_spectrum_from_SLHAstruct;
1136  const SLHAstruct& input_slha_tmp = *myPipe::Dep::unimproved_MSSM_spectrum; // Retrieve dependency on SLHAstruct
1137 
1139  SLHAstruct input_slha(input_slha_tmp); // Copy struct (for demo adding of GAMBIT block only)
1140  // For example; add this to your input SLHAstruct:
1141  input_slha["GAMBIT"][""] << "BLOCK" << "GAMBIT";
1142  input_slha["GAMBIT"][""] << 1 << 1e99 << "# Input scale";
1143 
1144  // Retrieve any mass cuts
1145  static const Spectrum::mc_info mass_cut = myPipe::runOptions->getValueOrDef<Spectrum::mc_info>(Spectrum::mc_info(), "mass_cut");
1146  static const Spectrum::mr_info mass_ratio_cut = myPipe::runOptions->getValueOrDef<Spectrum::mr_info>(Spectrum::mr_info(), "mass_ratio_cut");
1147 
1148  // Create Spectrum object from the slhaea object
1149  result = spectrum_from_SLHAea<MSSMSimpleSpec, SLHAstruct>(input_slha, input_slha, mass_cut, mass_ratio_cut);
1150 
1151  // No sneaking in charged LSPs via SLHA, jävlar.
1152  if (not has_neutralino_LSP(result)) invalid_point().raise("Neutralino is not LSP.");
1153 
1154  // In order to translate from e.g. MSSM63atMGUT to MSSM63atQ, we need
1155  // to know that input scale Q. This is generally not stored in SLHA format,
1156  // but we need it, so if you want to produce a Spectrum object this way you
1157  // will need to add this information to your SLHAstruct:
1158  // BLOCK GAMBIT
1159  // 1 <high_scale> # Input scale of (upper) boundary conditions, e.g. GUT scale
1160 
1161  // Need to check if this information exists:
1162  SLHAstruct::const_iterator block = input_slha.find("GAMBIT");
1163  std::vector<std::string> key(1, "1");
1164  if(block == input_slha.end() or block->find(key) == block->end())
1165  {
1166  // Big problem
1167  std::ostringstream errmsg;
1168  errmsg << "Error constructing Spectrum object from a pre-existing SLHAstruct! " << endl
1169  << "The supplied SLHAstruct did not have the special GAMBIT block added. " << endl
1170  << "This block carries extra information from the spectrum generator " << endl
1171  << "that is usually thrown away, but which is needed for properly creating" << endl
1172  << "a Spectrum object. In whatever module function created the SLHAstruct " << endl
1173  << "that you want to use, please add code that adds the following " << endl
1174  << "information to the SLHAstruct (SLHAea::Coll): " << endl
1175  << " BLOCK GAMBIT " << endl
1176  << " 1 <high_scale> # Input scale of (upper) boundary conditions, e.g. GUT scale\n";
1177  SpecBit_error().raise(LOCAL_INFO,errmsg.str());
1178  }
1179 
1180  // OK the GAMBIT block exists, add the data to the MSSM SubSpectrum object.
1181  result.get_HE().set_override(Par::mass1,SLHAea::to<double>(input_slha.at("GAMBIT").at(1).at(1)), "high_scale", false);
1182  }
#define LOCAL_INFO
Definition: local_info.hpp:34
void get_MSSM_spectrum_from_SLHAstruct(Spectrum &result)
Get an MSSMSpectrum object from an SLHAstruct Wraps it up in MSSMSimpleSpec; i.e. ...
SLHAea::Coll SLHAstruct
Less confusing name for SLHAea container class.
virtual void raise(const std::string &)
Raise the exception, i.e. throw it.
Definition: exceptions.cpp:422
invalid_point_exception & invalid_point()
Invalid point exceptions.
bool has_neutralino_LSP(const Spectrum *result)
Helper to work with pointer.
Here is the call graph for this function:

◆ get_MSSM_spectrum_SPheno()

void Gambit::SpecBit::get_MSSM_spectrum_SPheno ( Spectrum spectrum)

Definition at line 678 of file SpecBit_MSSM.cpp.

References Gambit::Spectrum::drop_SLHAs_if_requested(), fill_MSSM63_input(), fill_MSSM63_input_altnames(), has_neutralino_LSP(), Gambit::invalid_point(), LOCAL_INFO, Gambit::invalid_point_exception::raise(), and SMINPUTS.

Referenced by main().

679  {
680  namespace myPipe = Pipes::get_MSSM_spectrum_SPheno;
681  const SMInputs &sminputs = *myPipe::Dep::SMINPUTS;
682 
683  // Set up the input structure
684  Finputs inputs;
685  inputs.sminputs = sminputs;
686  inputs.param = myPipe::Param;
687  inputs.options = myPipe::runOptions;
688 
689  // Retrieve any mass cuts
690  static const Spectrum::mc_info mass_cut = myPipe::runOptions->getValueOrDef<Spectrum::mc_info>(Spectrum::mc_info(), "mass_cut");
691  static const Spectrum::mr_info mass_ratio_cut = myPipe::runOptions->getValueOrDef<Spectrum::mr_info>(Spectrum::mr_info(), "mass_ratio_cut");
692 
693  // Get the spectrum from the Backend
694  myPipe::BEreq::SPheno_MSSMspectrum(spectrum, inputs);
695 
696  // Only allow neutralino LSPs.
697  if (not has_neutralino_LSP(spectrum)) invalid_point().raise("Neutralino is not LSP.");
698 
699  // Drop SLHA files if requested
700  spectrum.drop_SLHAs_if_requested(myPipe::runOptions, "GAMBIT_unimproved_spectrum");
701 
702  }
virtual void raise(const std::string &)
Raise the exception, i.e. throw it.
Definition: exceptions.cpp:422
invalid_point_exception & invalid_point()
Invalid point exceptions.
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum SMINPUTS
bool has_neutralino_LSP(const Spectrum *result)
Helper to work with pointer.
void get_MSSM_spectrum_SPheno(Spectrum &spectrum)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ get_mStrange()

double Gambit::SpecBit::get_mStrange ( const softsusy::QedQcd &  model)

Definition at line 114 of file QedQcdWrapper.cpp.

Referenced by SpecBit::QedQcdWrapper::fill_getter_maps().

114 { return model.displayMass(softsusy::mStrange); }
Here is the caller graph for this function:

◆ get_mTau()

double Gambit::SpecBit::get_mTau ( const softsusy::QedQcd &  model)

Definition at line 118 of file QedQcdWrapper.cpp.

Referenced by SpecBit::QedQcdWrapper::fill_getter_maps().

118 { return model.displayMass(softsusy::mTau); }
Here is the caller graph for this function:

◆ get_mTop()

double Gambit::SpecBit::get_mTop ( const softsusy::QedQcd &  model)

Definition at line 112 of file QedQcdWrapper.cpp.

Referenced by SpecBit::QedQcdWrapper::fill_getter_maps().

112 { return model.displayMass(softsusy::mTop); }
Here is the caller graph for this function:

◆ get_mUp()

double Gambit::SpecBit::get_mUp ( const softsusy::QedQcd &  model)

Plain C-function wrappers for QedQcd running mass getters.

Definition at line 110 of file QedQcdWrapper.cpp.

Referenced by SpecBit::QedQcdWrapper::fill_getter_maps().

110 { return model.displayMass(softsusy::mUp); }
Here is the caller graph for this function:

◆ get_neutral_goldstone_pole_slha()

template<class Model >
double Gambit::SpecBit::get_neutral_goldstone_pole_slha ( const Model &  model)

Definition at line 260 of file MSSMSpec.hpp.

261  {
262  return model.get_MAh_pole_slha(0);
263  }

◆ get_Pole_mElectron()

double Gambit::SpecBit::get_Pole_mElectron ( const SMInputs inputs)

Plain C-function wrappers for extra pole mass getters (manually specified masses)

Definition at line 155 of file QedQcdWrapper.cpp.

References Gambit::SMInputs::mE.

Referenced by SpecBit::QedQcdWrapper::fill_getter_maps().

155 { return inputs.mE; }
Here is the caller graph for this function:

◆ get_Pole_mGluon()

double Gambit::SpecBit::get_Pole_mGluon ( const SMInputs )

Definition at line 162 of file QedQcdWrapper.cpp.

Referenced by SpecBit::QedQcdWrapper::fill_getter_maps().

162 { return 0.; }
Here is the caller graph for this function:

◆ get_Pole_mMuon()

double Gambit::SpecBit::get_Pole_mMuon ( const SMInputs inputs)

Definition at line 156 of file QedQcdWrapper.cpp.

References Gambit::SMInputs::mMu.

Referenced by SpecBit::QedQcdWrapper::fill_getter_maps().

156 { return inputs.mMu; }
Here is the caller graph for this function:

◆ get_Pole_mNu1()

double Gambit::SpecBit::get_Pole_mNu1 ( const SMInputs inputs)

Definition at line 157 of file QedQcdWrapper.cpp.

References Gambit::SMInputs::mNu1.

Referenced by SpecBit::QedQcdWrapper::fill_getter_maps().

157 { return inputs.mNu1; }
Here is the caller graph for this function:

◆ get_Pole_mNu2()

double Gambit::SpecBit::get_Pole_mNu2 ( const SMInputs inputs)

Definition at line 158 of file QedQcdWrapper.cpp.

References Gambit::SMInputs::mNu2.

Referenced by SpecBit::QedQcdWrapper::fill_getter_maps().

158 { return inputs.mNu2; }
Here is the caller graph for this function:

◆ get_Pole_mNu3()

double Gambit::SpecBit::get_Pole_mNu3 ( const SMInputs inputs)

Definition at line 159 of file QedQcdWrapper.cpp.

References Gambit::SMInputs::mNu3.

Referenced by SpecBit::QedQcdWrapper::fill_getter_maps().

159 { return inputs.mNu3; }
Here is the caller graph for this function:

◆ get_Pole_mPhoton()

double Gambit::SpecBit::get_Pole_mPhoton ( const SMInputs )

Definition at line 161 of file QedQcdWrapper.cpp.

Referenced by SpecBit::QedQcdWrapper::fill_getter_maps().

161 { return 0.; }
Here is the caller graph for this function:

◆ get_QedQcd_spectrum()

void Gambit::SpecBit::get_QedQcd_spectrum ( const SubSpectrum *&  result)

Construct a SubSpectrum object from SMInputs using QedQcdWrapper.

Definition at line 46 of file SpecBit_SM.cpp.

References setup_QedQcd(), and SMINPUTS.

47  {
48  // Access the pipes for this function to get model and parameter information, and dependencies
49  namespace myPipe = Pipes::get_QedQcd_spectrum;
50 
51  // Get SLHA2 SMINPUTS values
52  const SMInputs& sminputs = *myPipe::Dep::SMINPUTS;
53 
54  // SoftSUSY object used to set quark and lepton masses and gauge
55  // couplings in QEDxQCD effective theory
56  // Will be initialised by default using values in lowe.h, which we will
57  // override next.
58  softsusy::QedQcd oneset;
59 
60  // Fill QedQcd object with SMInputs values
61  setup_QedQcd(oneset,sminputs);
62 
63  // Run everything to Mz
64  oneset.toMz();
65 
66  // Create a Spectrum object to wrap the qedqcd object
67  static QedQcdWrapper qedqcdspec(oneset,sminputs);
68  // TODO: This probably doesn't work, and only gets us one copy of the object once.
69  // Unfortunately we cannot copy SubSpectrum objects, so this is a little tricky to
70  // solve...
71 
72  result = &qedqcdspec;
73  }
void setup_QedQcd(softsusy::QedQcd &oneset, const SMInputs &sminputs)
Non-Gambit helper functions.
Definition: SpecBit.cpp:47
void get_QedQcd_spectrum(const SubSpectrum *&result)
Construct a SubSpectrum object from SMInputs using QedQcdWrapper.
Definition: SpecBit_SM.cpp:46
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum SMINPUTS
Here is the call graph for this function:

◆ get_ScalarSingletDM_Z2_spectrum()

void Gambit::SpecBit::get_ScalarSingletDM_Z2_spectrum ( Spectrum result)

Get a (simple) Spectrum object wrapper for the ScalarSingletDM_Z2 model.

Definition at line 56 of file SpecBit_ScalarSingletDM.cpp.

References Gambit::SMInputs::alphainv, Gambit::SMInputs::alphaS, Gambit::Models::ScalarSingletDM_Z2Model::g1, Gambit::Models::ScalarSingletDM_Z2Model::g2, Gambit::Models::ScalarSingletDM_Z2Model::g3, Gambit::SMInputs::GF, Gambit::Models::ScalarSingletDM_Z2Model::HiggsPoleMass, Gambit::Models::ScalarSingletDM_Z2Model::HiggsVEV, Gambit::SMInputs::mBmB, Gambit::SMInputs::mCmC, Gambit::SMInputs::mD, Gambit::SMInputs::mE, mh, Gambit::SMInputs::mMu, Gambit::SMInputs::mS, Gambit::SMInputs::mT, Gambit::SMInputs::mTau, Gambit::SMInputs::mU, Gambit::SMInputs::mZ, Gambit::pi, Gambit::Scanner::pow(), Gambit::Models::ScalarSingletDM_Z2Model::SingletLambda, Gambit::Models::ScalarSingletDM_Z2Model::SingletLambdaS, Gambit::Models::ScalarSingletDM_Z2Model::SingletPoleMass, Gambit::Models::ScalarSingletDM_Z2Model::sinW2, SMINPUTS, Spectrum, Gambit::Models::ScalarSingletDM_Z2Model::Yd, Gambit::Models::ScalarSingletDM_Z2Model::Ye, and Gambit::Models::ScalarSingletDM_Z2Model::Yu.

57  {
58  namespace myPipe = Pipes::get_ScalarSingletDM_Z2_spectrum;
59  const SMInputs& sminputs = *myPipe::Dep::SMINPUTS;
60 
61  // Initialise an object to carry the Singlet plus Higgs sector information
63 
64  // quantities needed to fill container spectrum, intermediate calculations
65  double alpha_em = 1.0 / sminputs.alphainv;
66  double C = alpha_em * pi / (sminputs.GF * pow(2,0.5));
67  double sinW2 = 0.5 - pow( 0.25 - C/pow(sminputs.mZ,2) , 0.5);
68  double cosW2 = 0.5 + pow( 0.25 - C/pow(sminputs.mZ,2) , 0.5);
69  double e = pow( 4*pi*( alpha_em ),0.5) ;
70 
71  // Higgs sector
72  double mh = *myPipe::Param.at("mH");
73  singletmodel.HiggsPoleMass = mh;
74 
75  double vev = 1. / sqrt(sqrt(2.)*sminputs.GF);
76  singletmodel.HiggsVEV = vev;
77 
78  // Scalar singlet sector
79  singletmodel.SingletPoleMass = *myPipe::Param.at("mS");
80  singletmodel.SingletLambda = *myPipe::Param.at("lambda_hS");
81  singletmodel.SingletLambdaS = 0;
82 
83  // Standard model
84  singletmodel.sinW2 = sinW2;
85 
86  // gauge couplings
87  singletmodel.g1 = sqrt(5/3) * e / sqrt(cosW2);
88  singletmodel.g2 = e / sqrt(sinW2);
89  singletmodel.g3 = pow( 4*pi*( sminputs.alphaS ),0.5) ;
90 
91  // Yukawas
92  double sqrt2v = pow(2.0,0.5)/vev;
93  singletmodel.Yu[0] = sqrt2v * sminputs.mU;
94  singletmodel.Yu[1] = sqrt2v * sminputs.mCmC;
95  singletmodel.Yu[2] = sqrt2v * sminputs.mT;
96  singletmodel.Ye[0] = sqrt2v * sminputs.mE;
97  singletmodel.Ye[1] = sqrt2v * sminputs.mMu;
98  singletmodel.Ye[2] = sqrt2v * sminputs.mTau;
99  singletmodel.Yd[0] = sqrt2v * sminputs.mD;
100  singletmodel.Yd[1] = sqrt2v * sminputs.mS;
101  singletmodel.Yd[2] = sqrt2v * sminputs.mBmB;
102 
103  // Create a SubSpectrum object to wrap the EW sector information
104  Models::ScalarSingletDM_Z2SimpleSpec singletspec(singletmodel);
105 
106  // Retrieve any mass cuts
107  static const Spectrum::mc_info mass_cut = myPipe::runOptions->getValueOrDef<Spectrum::mc_info>(Spectrum::mc_info(), "mass_cut");
108  static const Spectrum::mr_info mass_ratio_cut = myPipe::runOptions->getValueOrDef<Spectrum::mr_info>(Spectrum::mr_info(), "mass_ratio_cut");
109 
110  // We don't supply a LE subspectrum here; an SMSimpleSpec will therefore be automatically created from 'sminputs'
111  result = Spectrum(singletspec,sminputs,&myPipe::Param,mass_cut,mass_ratio_cut);
112 
113  }
const double pi
Spectrum Spectrum
double pow(const double &a)
Outputs a^i.
std::vector< YAML::sdd > mc_info
Typedefs for making it easier to manipulate mass cut and mass ratio cut info.
Definition: spectrum.hpp:119
void get_ScalarSingletDM_Z2_spectrum(Spectrum &result)
Get a (simple) Spectrum object wrapper for the ScalarSingletDM_Z2 model.
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum mh
Simple extension of the SMHiggsSimpleSpec "model object" to include scalar singlet DM parameters We c...
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum SMINPUTS
std::vector< YAML::ssdd > mr_info
Definition: spectrum.hpp:120
Container class for Standard Model input information (defined as in SLHA2)
Definition: sminputs.hpp:29
Here is the call graph for this function:

◆ get_ScalarSingletDM_Z2_spectrum_as_map()

void Gambit::SpecBit::get_ScalarSingletDM_Z2_spectrum_as_map ( std::map< std::string, double > &  specmap)

Definition at line 650 of file SpecBit_ScalarSingletDM.cpp.

References Gambit::SubSpectrumContents::all_parameters(), fill_map_from_ScalarSingletDM_spectrum(), and ScalarSingletDM_Z2_spectrum.

651  {
654  static const SpectrumContents::ScalarSingletDM_Z2 contents;
655  static const std::vector<SpectrumParameter> required_parameters = contents.all_parameters();
656  fill_map_from_ScalarSingletDM_spectrum(specmap, spec, required_parameters);
657  }
void fill_map_from_ScalarSingletDM_spectrum(std::map< std::string, double > &specmap, const Spectrum &singletdmspec, const std::vector< SpectrumParameter > &required_parameters)
Print ScalarSingletDM spectra out. Stripped down copy of MSSM version with variable names changed...
void get_ScalarSingletDM_Z2_spectrum_as_map(std::map< std::string, double > &specmap)
Spectrum Spectrum
std::vector< SpectrumParameter > all_parameters() const
Function to retreive all parameters.
Here is the call graph for this function:

◆ get_ScalarSingletDM_Z3_spectrum()

void Gambit::SpecBit::get_ScalarSingletDM_Z3_spectrum ( Spectrum result)

Get a (simple) Spectrum object wrapper for the ScalarSingletDM_Z3 model.

Definition at line 116 of file SpecBit_ScalarSingletDM.cpp.

References Gambit::SMInputs::alphainv, Gambit::SMInputs::alphaS, Gambit::Models::ScalarSingletDM_Z3Model::g1, Gambit::Models::ScalarSingletDM_Z3Model::g2, Gambit::Models::ScalarSingletDM_Z3Model::g3, Gambit::Options::getValueOrDef(), Gambit::SMInputs::GF, Gambit::Models::ScalarSingletDM_Z3Model::HiggsPoleMass, Gambit::Models::ScalarSingletDM_Z3Model::HiggsVEV, Gambit::invalid_point(), LOCAL_INFO, Gambit::Par::mass1, Gambit::SMInputs::mBmB, Gambit::SMInputs::mCmC, Gambit::SMInputs::mD, Gambit::SMInputs::mE, mh, Gambit::SMInputs::mMu, Gambit::SMInputs::mS, Gambit::SMInputs::mT, Gambit::SMInputs::mTau, Gambit::SMInputs::mU, Gambit::Models::ScalarSingletDM_Z3Model::mu3, Gambit::SMInputs::mZ, Gambit::pi, Gambit::Par::Pole_Mass_1srd_high, Gambit::Par::Pole_Mass_1srd_low, Gambit::Scanner::pow(), Gambit::invalid_point_exception::raise(), run_FS_spectrum_generator(), setup_QedQcd(), Gambit::Models::ScalarSingletDM_Z3Model::SingletLambda, Gambit::Models::ScalarSingletDM_Z3Model::SingletLambdaS, Gambit::Models::ScalarSingletDM_Z3Model::SingletPoleMass, Gambit::Models::ScalarSingletDM_Z3Model::sinW2, SMINPUTS, Spectrum, Gambit::Models::ScalarSingletDM_Z3Model::Yd, Gambit::Models::ScalarSingletDM_Z3Model::Ye, and Gambit::Models::ScalarSingletDM_Z3Model::Yu.

117  {
118  namespace myPipe = Pipes::get_ScalarSingletDM_Z3_spectrum;
119  const SMInputs& sminputs = *myPipe::Dep::SMINPUTS;
120 
121  // Initialise an object to carry the Singlet plus Higgs sector information
122  Models::ScalarSingletDM_Z3Model singletmodel;
123 
124  // quantities needed to fill container spectrum, intermediate calculations
125  double alpha_em = 1.0 / sminputs.alphainv;
126  double C = alpha_em * pi / (sminputs.GF * pow(2,0.5));
127  double sinW2 = 0.5 - pow( 0.25 - C/pow(sminputs.mZ,2) , 0.5);
128  double cosW2 = 0.5 + pow( 0.25 - C/pow(sminputs.mZ,2) , 0.5);
129  double e = pow( 4*pi*( alpha_em ),0.5) ;
130 
131  // Higgs sector
132  double mh = *myPipe::Param.at("mH");
133  singletmodel.HiggsPoleMass = mh;
134 
135  double vev = 1. / sqrt(sqrt(2.)*sminputs.GF);
136  singletmodel.HiggsVEV = vev;
137 
138  // Scalar singlet sector
139  singletmodel.SingletPoleMass = *myPipe::Param.at("mS");
140  singletmodel.SingletLambda = *myPipe::Param.at("lambda_hS");
141  singletmodel.SingletLambdaS = *myPipe::Param.at("lambda_S");
142 
143  singletmodel.mu3 = *myPipe::Param.at("mu3");
144 
145  // Standard model
146  singletmodel.sinW2 = sinW2;
147 
148  // gauge couplings
149  singletmodel.g1 = sqrt(5/3) * e / sqrt(cosW2);
150  singletmodel.g2 = e / sqrt(sinW2);
151  singletmodel.g3 = pow( 4*pi*( sminputs.alphaS ),0.5) ;
152 
153  // Yukawas
154  double sqrt2v = pow(2.0,0.5)/vev;
155  singletmodel.Yu[0] = sqrt2v * sminputs.mU;
156  singletmodel.Yu[1] = sqrt2v * sminputs.mCmC;
157  singletmodel.Yu[2] = sqrt2v * sminputs.mT;
158  singletmodel.Ye[0] = sqrt2v * sminputs.mE;
159  singletmodel.Ye[1] = sqrt2v * sminputs.mMu;
160  singletmodel.Ye[2] = sqrt2v * sminputs.mTau;
161  singletmodel.Yd[0] = sqrt2v * sminputs.mD;
162  singletmodel.Yd[1] = sqrt2v * sminputs.mS;
163  singletmodel.Yd[2] = sqrt2v * sminputs.mBmB;
164 
165  // Create a SubSpectrum object to wrap the EW sector information
166  Models::ScalarSingletDM_Z3SimpleSpec singletspec(singletmodel);
167 
168  // Retrieve any mass cuts
169  static const Spectrum::mc_info mass_cut = myPipe::runOptions->getValueOrDef<Spectrum::mc_info>(Spectrum::mc_info(), "mass_cut");
170  static const Spectrum::mr_info mass_ratio_cut = myPipe::runOptions->getValueOrDef<Spectrum::mr_info>(Spectrum::mr_info(), "mass_ratio_cut");
171 
172  // We don't supply a LE subspectrum here; an SMSimpleSpec will therefore be automatically created from 'sminputs'
173  result = Spectrum(singletspec,sminputs,&myPipe::Param,mass_cut,mass_ratio_cut);
174 
175  }
void get_ScalarSingletDM_Z3_spectrum(Spectrum &result)
Get a (simple) Spectrum object wrapper for the ScalarSingletDM_Z3 model.
const double pi
Spectrum Spectrum
double pow(const double &a)
Outputs a^i.
std::vector< YAML::sdd > mc_info
Typedefs for making it easier to manipulate mass cut and mass ratio cut info.
Definition: spectrum.hpp:119
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum mh
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum SMINPUTS
std::vector< YAML::ssdd > mr_info
Definition: spectrum.hpp:120
Container class for Standard Model input information (defined as in SLHA2)
Definition: sminputs.hpp:29
Here is the call graph for this function:

◆ get_ScalarSingletDM_Z3_spectrum_as_map()

void Gambit::SpecBit::get_ScalarSingletDM_Z3_spectrum_as_map ( std::map< std::string, double > &  specmap)

Definition at line 659 of file SpecBit_ScalarSingletDM.cpp.

References Gambit::SubSpectrumContents::all_parameters(), fill_map_from_ScalarSingletDM_spectrum(), and ScalarSingletDM_Z3_spectrum.

660  {
663  static const SpectrumContents::ScalarSingletDM_Z3 contents;
664  static const std::vector<SpectrumParameter> required_parameters = contents.all_parameters();
665  fill_map_from_ScalarSingletDM_spectrum(specmap, spec, required_parameters);
666  }
void get_ScalarSingletDM_Z3_spectrum_as_map(std::map< std::string, double > &specmap)
void fill_map_from_ScalarSingletDM_spectrum(std::map< std::string, double > &specmap, const Spectrum &singletdmspec, const std::vector< SpectrumParameter > &required_parameters)
Print ScalarSingletDM spectra out. Stripped down copy of MSSM version with variable names changed...
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum ScalarSingletDM_Z3_spectrum
Spectrum Spectrum
std::vector< SpectrumParameter > all_parameters() const
Function to retreive all parameters.
Here is the call graph for this function:

◆ get_sinthW2_DRbar()

template<class Model >
double Gambit::SpecBit::get_sinthW2_DRbar ( const Model &  model)

Definition at line 234 of file MSSMSpec.hpp.

References Gambit::Utils::sqr().

Referenced by Gambit::MSSMSimpleSpec::fill_getter_maps().

235  {
236  double sthW2 = Utils::sqr(model.get_g1()) * 0.6 /
237  (0.6 * Utils::sqr(model.get_g1()) +
238  Utils::sqr(model.get_g2()));
239  return sthW2;
240  }
EXPORT_SYMBOLS double sqr(double a)
returns square of double - saves tedious repetition
Here is the call graph for this function:
Here is the caller graph for this function:

◆ get_sinthW2_MSbar()

template<class Model >
double Gambit::SpecBit::get_sinthW2_MSbar ( const Model &  model)

Definition at line 87 of file MDMSpec.hpp.

References Gambit::Utils::sqr().

Referenced by Gambit::SpecBit::ScalarSingletDM_Z2Spec< MI >::AccessError().

88  {
89  double sthW2 = Utils::sqr(model.get_g1()) * 0.6 /
90  (0.6 * Utils::sqr(model.get_g1()) +
91  Utils::sqr(model.get_g2()));
92  return sthW2;
93  }
EXPORT_SYMBOLS double sqr(double a)
returns square of double - saves tedious repetition
Here is the call graph for this function:
Here is the caller graph for this function:

◆ get_sinthW2_MSbar2()

template<class Model >
double Gambit::SpecBit::get_sinthW2_MSbar2 ( const Model &  model)

Definition at line 105 of file ScalarSingletDM_Z3Spec.hpp.

References Gambit::Utils::sqr().

106  {
107  double sthW2 = Utils::sqr(model.get_g1()) * 0.6 /
108  (0.6 * Utils::sqr(model.get_g1()) +
109  Utils::sqr(model.get_g2()));
110  return sthW2;
111  }
EXPORT_SYMBOLS double sqr(double a)
returns square of double - saves tedious repetition
Here is the call graph for this function:

◆ get_sinthW2_pole()

double Gambit::SpecBit::get_sinthW2_pole ( const softsusy::QedQcd &  qedqcd)

Definition at line 164 of file QedQcdWrapper.cpp.

References Gambit::Utils::sqr().

Referenced by SpecBit::QedQcdWrapper::fill_getter_maps().

165  {
166  return (1 - Utils::sqr(qedqcd.displayPoleMW()) / Utils::sqr(qedqcd.displayPoleMZ()));
167  }
EXPORT_SYMBOLS double sqr(double a)
returns square of double - saves tedious repetition
Here is the call graph for this function:
Here is the caller graph for this function:

◆ get_SM_spectrum()

void Gambit::SpecBit::get_SM_spectrum ( Spectrum result)

Get a Spectrum object wrapper for Standard-Model-only information.

Definition at line 76 of file SpecBit_SM.cpp.

References Gambit::SMInputs::GF, Gambit::SpecBit::SMHiggsModel::HiggsPoleMass, Gambit::SpecBit::SMHiggsModel::HiggsVEV, setup_QedQcd(), SMINPUTS, and Spectrum.

77  {
78  namespace myPipe = Pipes::get_SM_spectrum;
79  const SMInputs& sminputs = *myPipe::Dep::SMINPUTS;
80 
81  // SoftSUSY object used to set quark and lepton masses and gauge
82  // couplings in QEDxQCD effective theory
83  softsusy::QedQcd oneset;
84 
85  // Fill QedQcd object with SMInputs values
86  setup_QedQcd(oneset,sminputs);
87 
88  // Run everything to Mz
89  oneset.toMz();
90 
91  // Create a SubSpectrum object to wrap the qedqcd object
92  // Attach the sminputs object as well, so that SM pole masses can be passed on (these aren't easily
93  // extracted from the QedQcd object, so use the values that we put into it.)
94  QedQcdWrapper qedqcdspec(oneset,sminputs);
95 
96  // Initialise an object to carry Higgs sector information
97  SMHiggsModel higgsmodel;
98  higgsmodel.HiggsPoleMass = *myPipe::Param.at("mH");
99  higgsmodel.HiggsVEV = 1. / sqrt(sqrt(2.)*sminputs.GF);
100 
101  // Create a SubSpectrum object to wrap the EW sector information
102  SMHiggsSimpleSpec higgsspec(higgsmodel);
103 
104  // Retrieve any mass cuts
105  static const Spectrum::mc_info mass_cut = myPipe::runOptions->getValueOrDef<Spectrum::mc_info>(Spectrum::mc_info(), "mass_cut");
106  static const Spectrum::mr_info mass_ratio_cut = myPipe::runOptions->getValueOrDef<Spectrum::mr_info>(Spectrum::mr_info(), "mass_ratio_cut");
107 
108  // Create full Spectrum object from components above (SubSpectrum objects will be "cloned" into the Spectrum object)
109  result = Spectrum(qedqcdspec,higgsspec,sminputs,&myPipe::Param,mass_cut,mass_ratio_cut);
110  }
void setup_QedQcd(softsusy::QedQcd &oneset, const SMInputs &sminputs)
Non-Gambit helper functions.
Definition: SpecBit.cpp:47
Spectrum Spectrum
void get_SM_spectrum(Spectrum &result)
Get a Spectrum object wrapper for Standard-Model-only information.
Definition: SpecBit_SM.cpp:76
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum SMINPUTS
Here is the call graph for this function:

◆ get_SM_SubSpectrum_from_MSSM_Spectrum()

void Gambit::SpecBit::get_SM_SubSpectrum_from_MSSM_Spectrum ( const SubSpectrum *&  result)

Retrieve SubSpectrum* to SM LE model from Spectrum object DEPENDENCY(MSSM_spectrum, Spectrum)

Definition at line 1050 of file SpecBit_MSSM.cpp.

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

1051  {
1053  const Spectrum& matched_spectra(*myPipe::Dep::unimproved_MSSM_spectrum);
1054  result = &matched_spectra.get_LE();
1055  }
Spectrum Spectrum
void get_SM_SubSpectrum_from_MSSM_Spectrum(const SubSpectrum *&result)
Retrieve SubSpectrum* to SM LE model from Spectrum object DEPENDENCY(MSSM_spectrum, Spectrum)
Here is the call graph for this function:

◆ get_SMINPUTS()

void Gambit::SpecBit::get_SMINPUTS ( SMInputs result)

Gambit module functions.

Set SMINPUTS (SLHA2) struct to match StandardModel_SLHA2 parameters.

Definition at line 82 of file SpecBit.cpp.

References Gambit::SMInputs::CKMdef::A, Gambit::SMInputs::PMNSdef::alpha1, Gambit::SMInputs::PMNSdef::alpha2, Gambit::SMInputs::alphainv, Gambit::SMInputs::alphaS, Gambit::SMInputs::CKM, Gambit::SMInputs::PMNSdef::delta13, Gambit::SMInputs::CKMdef::etabar, Gambit::SMInputs::GF, Gambit::SMInputs::CKMdef::lambda, LOCAL_INFO, Gambit::SMInputs::mBmB, Gambit::SMInputs::mCmC, Gambit::SMInputs::mD, Gambit::SMInputs::mE, Gambit::SMInputs::mMu, Gambit::SMInputs::mNu1, Gambit::SMInputs::mNu2, Gambit::SMInputs::mNu3, Gambit::SMInputs::mS, Gambit::SMInputs::mT, Gambit::SMInputs::mTau, Gambit::SMInputs::mU, Gambit::SMInputs::mW, Gambit::SMInputs::mZ, Gambit::pi, Gambit::SMInputs::PMNS, Gambit::Scanner::pow(), Gambit::SMInputs::CKMdef::rhobar, Gambit::SMInputs::PMNSdef::theta12, Gambit::SMInputs::PMNSdef::theta13, and Gambit::SMInputs::PMNSdef::theta23.

Referenced by main().

83  {
84  namespace myPipe = Pipes::get_SMINPUTS;
85  SMInputs sminputs;
86 
87  // Get values from Params pipe
88  // (as defined in SLHA2)
89  if(myPipe::ModelInUse("StandardModel_SLHA2"))
90  {
91  sminputs.alphainv = *myPipe::Param["alphainv"];
92  sminputs.GF = *myPipe::Param["GF" ];
93  sminputs.alphaS = *myPipe::Param["alphaS" ];
94 
95  sminputs.mZ = *myPipe::Param["mZ" ];
96 
97  sminputs.mE = *myPipe::Param["mE" ];
98  sminputs.mMu = *myPipe::Param["mMu" ];
99  sminputs.mTau = *myPipe::Param["mTau" ];
100 
101  sminputs.mNu1 = *myPipe::Param["mNu1" ];
102  sminputs.mNu2 = *myPipe::Param["mNu2" ];
103  sminputs.mNu3 = *myPipe::Param["mNu3" ];
104 
105  sminputs.mD = *myPipe::Param["mD" ];
106  sminputs.mU = *myPipe::Param["mU" ];
107  sminputs.mS = *myPipe::Param["mS" ];
108  sminputs.mCmC = *myPipe::Param["mCmC" ];
109  sminputs.mBmB = *myPipe::Param["mBmB" ];
110  sminputs.mT = *myPipe::Param["mT" ];
111 
112  sminputs.mNu1 = *myPipe::Param["mNu1" ];
113  sminputs.mNu2 = *myPipe::Param["mNu2" ];
114  sminputs.mNu3 = *myPipe::Param["mNu3" ];
115 
116  // CKM
117  sminputs.CKM.lambda = *myPipe::Param["CKM_lambda" ];
118  sminputs.CKM.A = *myPipe::Param["CKM_A" ];
119  sminputs.CKM.rhobar = *myPipe::Param["CKM_rhobar" ];
120  sminputs.CKM.etabar = *myPipe::Param["CKM_etabar" ];
121 
122  // PMNS
123  sminputs.PMNS.theta12 = *myPipe::Param["theta12"];
124  sminputs.PMNS.theta23 = *myPipe::Param["theta23"];
125  sminputs.PMNS.theta13 = *myPipe::Param["theta13"];
126  sminputs.PMNS.delta13 = *myPipe::Param["delta13"];
127  sminputs.PMNS.alpha1 = *myPipe::Param["alpha1"];
128  sminputs.PMNS.alpha2 = *myPipe::Param["alpha2"];
129 
130  // W mass. Stick with the observed value (set in the default constructor) unless instructed otherwise.
131  if (myPipe::runOptions->getValueOrDef<bool>(false,"enforce_tree_level_MW"))
132  {
133  // Calculate MW from alpha, mZ and G_F, assuming the tree-level relation.
134  const double pionroot2 = pi * pow(2,-0.5);
135  double cosW2 = 0.5 + pow(0.25 - pionroot2 / (sminputs.alphainv * sminputs.GF * pow(sminputs.mZ,2.0)), 0.5);
136  sminputs.mW = sminputs.mZ * pow(cosW2,0.5);
137  }
138 
139  }
140  else
141  {
142  std::ostringstream errmsg;
143  errmsg << "Error mapping Standard Model parameters to SMINPUTS capabilities!";
144  errmsg << "Perhaps you have added a new model to the ALLOWED_MODELS of this ";
145  errmsg << "module function but have not added a corresponding case in the ";
146  errmsg << "function source (here)." << std::endl;
147  SpecBit_error().raise(LOCAL_INFO,errmsg.str());
148  }
149  // Return filled struct
150  result = sminputs;
151  }
#define LOCAL_INFO
Definition: local_info.hpp:34
void get_SMINPUTS(SMInputs &result)
Gambit module functions.
Definition: SpecBit.cpp:82
const double pi
double pow(const double &a)
Outputs a^i.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ get_tanbeta()

template<class Model >
double Gambit::SpecBit::get_tanbeta ( const Model &  model)

Definition at line 218 of file MSSMSpec.hpp.

Referenced by Gambit::MSSMSimpleSpec::fill_getter_maps().

219  {
220  return model.get_vu() / model.get_vd();
221  }
Here is the caller graph for this function:

◆ get_unimproved_MSSM_spectrum_as_map()

void Gambit::SpecBit::get_unimproved_MSSM_spectrum_as_map ( std::map< std::string, double > &  specmap)

Definition at line 1750 of file SpecBit_MSSM.cpp.

References add_extra_MSSM_parameter_combinations(), Gambit::Spectrum::get_HE(), Gambit::Spectrum::get_LE(), and unimproved_MSSM_spectrum.

1751  {
1752  namespace myPipe = Pipes::get_unimproved_MSSM_spectrum_as_map;
1754  fill_map_from_subspectrum<SpectrumContents::SM> (specmap, mssmspec.get_LE());
1755  fill_map_from_subspectrum<SpectrumContents::MSSM>(specmap, mssmspec.get_HE());
1756  add_extra_MSSM_parameter_combinations(specmap, mssmspec.get_HE());
1757  }
void get_unimproved_MSSM_spectrum_as_map(std::map< std::string, double > &specmap)
void add_extra_MSSM_parameter_combinations(std::map< std::string, double > &specmap, const SubSpectrum &mssm)
Adds additional information from interesting combinations of MSSM parameters.
Spectrum Spectrum
Here is the call graph for this function:

◆ get_VectorSingletDM_Z2_spectrum()

void Gambit::SpecBit::get_VectorSingletDM_Z2_spectrum ( Spectrum result)

Get a (simple) Spectrum object wrapper for the VectorSingletDM_Z2 model.

Definition at line 53 of file SpecBit_VectorSingletDM.cpp.

References Gambit::SMInputs::alphainv, Gambit::SMInputs::alphaS, fill_map_from_VectorSingletDM_Z2spectrum(), Gambit::Models::VectorSingletDM_Z2Model::g1, Gambit::Models::VectorSingletDM_Z2Model::g2, Gambit::Models::VectorSingletDM_Z2Model::g3, Gambit::SMInputs::GF, Gambit::Models::VectorSingletDM_Z2Model::HiggsPoleMass, Gambit::Models::VectorSingletDM_Z2Model::HiggsVEV, Gambit::invalid_point(), Gambit::SMInputs::mBmB, Gambit::SMInputs::mCmC, Gambit::SMInputs::mD, Gambit::SMInputs::mE, mh, Gambit::SMInputs::mMu, Gambit::SMInputs::mS, Gambit::SMInputs::mT, Gambit::SMInputs::mTau, Gambit::SMInputs::mU, Gambit::SMInputs::mZ, Gambit::pi, Gambit::Scanner::pow(), Gambit::invalid_point_exception::raise(), Gambit::Models::VectorSingletDM_Z2Model::sinW2, SMINPUTS, Spectrum, Gambit::Models::VectorSingletDM_Z2Model::VectorLambda, Gambit::Models::VectorSingletDM_Z2Model::VectorPoleMass, Gambit::Models::VectorSingletDM_Z2Model::Yd, Gambit::Models::VectorSingletDM_Z2Model::Ye, and Gambit::Models::VectorSingletDM_Z2Model::Yu.

54  {
55  namespace myPipe = Pipes::get_VectorSingletDM_Z2_spectrum;
56  const SMInputs& sminputs = *myPipe::Dep::SMINPUTS;
57 
58  // Initialise an object to carry the Singlet plus Higgs sector information
59  Models::VectorSingletDM_Z2Model vectormodel;
60 
61  // quantities needed to fill container spectrum, intermediate calculations
62  double alpha_em = 1.0 / sminputs.alphainv;
63  double C = alpha_em * pi / (sminputs.GF * pow(2,0.5));
64  double sinW2 = 0.5 - pow( 0.25 - C/pow(sminputs.mZ,2) , 0.5);
65  double cosW2 = 0.5 + pow( 0.25 - C/pow(sminputs.mZ,2) , 0.5);
66  double e = pow( 4*pi*( alpha_em ),0.5) ;
67 
68  // Higgs sector
69  double mh = *myPipe::Param.at("mH");
70  vectormodel.HiggsPoleMass = mh;
71 
72  double vev = 1. / sqrt(sqrt(2.)*sminputs.GF);
73  vectormodel.HiggsVEV = vev;
74  //vectormodel.LambdaH = GF*pow(mh,2)/pow(2,0.5) ;
75 
76  // VectorSingletDM_Z2 sector
77  vectormodel.VectorPoleMass = *myPipe::Param.at("mV");
78  vectormodel.VectorLambda = *myPipe::Param.at("lambda_hV");
79 
80  if (myPipe::runOptions->getValueOrDef<bool>(false,"impose_pert_unitarity"))
81  {
82  // Invalidate point if the perturbative unitarity constraint is not satisfied
83  if (vectormodel.VectorLambda > (2*pow(vectormodel.VectorPoleMass,2))/pow(vev,2))
84  {
85  std::ostringstream msg;
86  msg << "Parameter point [mV, lambda_hV] = [" << vectormodel.VectorPoleMass << " GeV, "
87  << vectormodel.VectorLambda << "] does not satisfy the perturbative unitarity constraint.";
88  invalid_point().raise(msg.str());
89  }
90  }
91  else {}
92 
93  // Standard model
94  vectormodel.sinW2 = sinW2;
95 
96  // gauge couplings
97  vectormodel.g1 = sqrt(5/3) * e / sqrt(cosW2);
98  vectormodel.g2 = e / sqrt(sinW2);
99  vectormodel.g3 = pow( 4*pi*( sminputs.alphaS ),0.5) ;
100 
101  // Yukawas
102  double sqrt2v = pow(2.0,0.5)/vev;
103  vectormodel.Yu[0] = sqrt2v * sminputs.mU;
104  vectormodel.Yu[1] = sqrt2v * sminputs.mCmC;
105  vectormodel.Yu[2] = sqrt2v * sminputs.mT;
106  vectormodel.Ye[0] = sqrt2v * sminputs.mE;
107  vectormodel.Ye[1] = sqrt2v * sminputs.mMu;
108  vectormodel.Ye[2] = sqrt2v * sminputs.mTau;
109  vectormodel.Yd[0] = sqrt2v * sminputs.mD;
110  vectormodel.Yd[1] = sqrt2v * sminputs.mS;
111  vectormodel.Yd[2] = sqrt2v * sminputs.mBmB;
112 
113  // Create a SubSpectrum object to wrap the EW sector information
114  Models::VectorSingletDM_Z2SimpleSpec vectorspec(vectormodel);
115 
116  // Retrieve any mass cuts
117  static const Spectrum::mc_info mass_cut = myPipe::runOptions->getValueOrDef<Spectrum::mc_info>(Spectrum::mc_info(), "mass_cut");
118  static const Spectrum::mr_info mass_ratio_cut = myPipe::runOptions->getValueOrDef<Spectrum::mr_info>(Spectrum::mr_info(), "mass_ratio_cut");
119 
120  // We don't supply a LE subspectrum here; an SMSimpleSpec will therefore be automatically created from 'sminputs'
121  result = Spectrum(vectorspec,sminputs,&myPipe::Param,mass_cut,mass_ratio_cut);
122 
123  }
void get_VectorSingletDM_Z2_spectrum(Spectrum &result)
Get a (simple) Spectrum object wrapper for the VectorSingletDM_Z2 model.
virtual void raise(const std::string &)
Raise the exception, i.e. throw it.
Definition: exceptions.cpp:422
const double pi
Spectrum Spectrum
double pow(const double &a)
Outputs a^i.
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum mh
invalid_point_exception & invalid_point()
Invalid point exceptions.
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum SMINPUTS
Here is the call graph for this function:

◆ get_VectorSingletDM_Z2_spectrum_as_map()

void Gambit::SpecBit::get_VectorSingletDM_Z2_spectrum_as_map ( std::map< std::string, double > &  specmap)

Definition at line 128 of file SpecBit_VectorSingletDM.cpp.

References fill_map_from_VectorSingletDM_Z2spectrum(), and VectorSingletDM_Z2_spectrum.

129  {
132  fill_map_from_VectorSingletDM_Z2spectrum(specmap, vectordmspec);
133  }
void get_VectorSingletDM_Z2_spectrum_as_map(std::map< std::string, double > &specmap)
Spectrum Spectrum
Spectrum Spectrum Spectrum Spectrum VectorSingletDM_Z2_spectrum
void fill_map_from_VectorSingletDM_Z2spectrum(std::map< std::string, double > &, const Spectrum &)
Here is the call graph for this function:

◆ has_neutralino_LSP() [1/2]

bool Gambit::SpecBit::has_neutralino_LSP ( const Spectrum result)

Check that the spectrum has a neutralino LSP.

Definition at line 641 of file SpecBit_MSSM.cpp.

References Gambit::Spectrum::get(), and Gambit::Par::Pole_Mass.

Referenced by get_MSSM_spectrum_from_SLHAfile(), get_MSSM_spectrum_from_SLHAstruct(), get_MSSM_spectrum_SPheno(), and has_neutralino_LSP().

642  {
643  double msqd = result.get(Par::Pole_Mass, 1000001, 0);
644  double msqu = result.get(Par::Pole_Mass, 1000002, 0);
645  double msl = result.get(Par::Pole_Mass, 1000011, 0);
646  double msneu = result.get(Par::Pole_Mass, 1000012, 0);
647  double mglui = result.get(Par::Pole_Mass, 1000021, 0);
648  double mchi0 = std::abs(result.get(Par::Pole_Mass, 1000022, 0));
649  double mchip = std::abs(result.get(Par::Pole_Mass, 1000024, 0));
650 
651  return mchi0 < mchip &&
652  mchi0 < mglui &&
653  mchi0 < msl &&
654  mchi0 < msneu &&
655  mchi0 < msqu &&
656  mchi0 < msqd;
657  }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ has_neutralino_LSP() [2/2]

bool Gambit::SpecBit::has_neutralino_LSP ( const Spectrum result)

Helper to work with pointer.

Definition at line 659 of file SpecBit_MSSM.cpp.

References has_neutralino_LSP().

660  {
661  return has_neutralino_LSP(*result);
662  }
bool has_neutralino_LSP(const Spectrum *result)
Helper to work with pointer.
Here is the call graph for this function:

◆ light_quark_test()

void Gambit::SpecBit::light_quark_test ( bool &  )

Generate data for a plot of quark mass

Definition at line 748 of file SpecBit_tests.cpp.

References Gambit::SubSpectrum::clone(), Gambit::Par::dimensionless, Gambit::Utils::endA(), Gambit::EOM, Gambit::logger(), Gambit::Par::mass1, and Gambit::DecayBit::SM_Z::mu.

749  {
750  namespace myPipe = Pipes::light_quark_test;
751  const SubSpectrum& qedqcd = **myPipe::Dep::qedqcd_subspectrum;
752 
753  // Check light quark mass ratios
754  logger() << "Checking light quark mass ratios:" << EOM;
755 
757  double Qs[] = {
758  1.00000000e-02, 1.25892541e-02, 1.58489319e-02,
759  1.99526231e-02, 2.51188643e-02, 3.16227766e-02,
760  3.98107171e-02, 5.01187234e-02, 6.30957344e-02,
761  7.94328235e-02, 1.00000000e-01, 1.25892541e-01,
762  1.58489319e-01, 1.99526231e-01, 2.51188643e-01,
763  3.16227766e-01, 3.98107171e-01, 5.01187234e-01,
764  6.30957344e-01, 7.94328235e-01, 1.00000000e+00,
765  1.25892541e+00, 1.58489319e+00, 1.99526231e+00,
766  2.51188643e+00, 3.16227766e+00, 3.98107171e+00,
767  5.01187234e+00, 6.30957344e+00, 7.94328235e+00,
768  1.00000000e+01, 1.25892541e+01, 1.58489319e+01,
769  1.99526231e+01, 2.51188643e+01, 3.16227766e+01,
770  3.98107171e+01, 5.01187234e+01, 6.30957344e+01,
771  7.94328235e+01, 1.00000000e+02, 1.25892541e+02,
772  1.58489319e+02, 1.99526231e+02, 2.51188643e+02,
773  3.16227766e+02, 3.98107171e+02, 5.01187234e+02,
774  6.30957344e+02, 7.94328235e+02, 1.00000000e+03,
775  1.25892541e+03, 1.58489319e+03, 1.99526231e+03,
776  2.51188643e+03, 3.16227766e+03, 3.98107171e+03,
777  5.01187234e+03, 6.30957344e+03, 7.94328235e+03,
778  1.00000000e+04, 1.25892541e+04, 1.58489319e+04,
779  1.99526231e+04, 2.51188643e+04, 3.16227766e+04,
780  3.98107171e+04, 5.01187234e+04, 6.30957344e+04,
781  7.94328235e+04
782  };
783 
784  std::vector<double> Qvec(Qs, Utils::endA(Qs));
785 
786  std::ofstream Qout;
787  Qout.open("SpecBit/light_quark_txt");
788 
789  Qout <<std::setw(12)<<"Qin"
790  <<std::setw(12)<<"Qreal"
791  <<std::setw(12)<<"alphaS"
792  <<std::setw(12)<<"md"
793  <<std::setw(12)<<"mu"
794  <<std::setw(12)<<"ms"
795  <<std::setw(12)<<"mu/md"
796  <<std::setw(12)<<"ms/md"
797  <<std::endl;
798  for(std::vector<double>::iterator it = Qvec.begin(); it != Qvec.end(); ++it)
799  {
800  // Clone to avoid buildup of errors
801  std::unique_ptr<SubSpectrum> SMloop = qedqcd.clone();
802 
803  SMloop->RunToScale(*it);
804  double Q = SMloop->GetScale();
805  double mu = SMloop->get(Par::mass1,"u");
806  double md = SMloop->get(Par::mass1,"d");
807  double ms = SMloop->get(Par::mass1,"s");
808  double alphas = SMloop->get(Par::dimensionless,"alphaS");
809  // Write to file
810  Qout <<std::setw(12)<<*it
811  <<std::setw(12)<<Q
812  <<std::setw(12)<<alphas
813  <<std::setw(12)<<md
814  <<std::setw(12)<<mu
815  <<std::setw(12)<<ms
816  <<std::setw(12)<<mu/md
817  <<std::setw(12)<<ms/md
818  <<std::endl;
819  }
820 
821  Qout.close();
822 
823  std::cout << " light quark test finished, bailing out!" << std::endl;
824  exit(0);
825  }
std::chrono::milliseconds ms
const double mu
Definition: SM_Z.hpp:42
const Logging::endofmessage EOM
Explicit const instance of the end of message struct in Gambit namespace.
Definition: logger.hpp:99
Logging::LogMaster & logger()
Function to retrieve a reference to the Gambit global log object.
Definition: logger.cpp:95
void light_quark_test(bool &)
T * endA(T(&arr)[N])
Here is the call graph for this function:

◆ lnL_highscale_vacuum_decay_single_field()

void Gambit::SpecBit::lnL_highscale_vacuum_decay_single_field ( double result)

Definition at line 369 of file SpecBit_VS.cpp.

References Gambit::dbl_dbl_bool::first, Gambit::Options::getValueOrDef(), and Gambit::dbl_dbl_bool::second.

370  {
372  dbl_dbl_bool vs_tuple = *myPipe::Dep::high_scale_vacuum_info;
373 
374  const Options& runOptions=*myPipe::runOptions;
375  bool demand_stable = runOptions.getValueOrDef<bool>(false,"demand_stable");
376  double stability_scale = runOptions.getValueOrDef<double>(1.22e19,"set_stability_scale");
377 
378  if (demand_stable && (vs_tuple.second < stability_scale))
379  {
380  result = -1e100;
381  }
382  else
383  {
384  double conversion = (6.5821195e-25)/(31536000);
385  result=((- ( 1 / ( vs_tuple.first/conversion ) ) * exp(140) * (1/ (1.2e19) ) ) );
386  }
387 
388  }
void lnL_highscale_vacuum_decay_single_field(double &result)
Definition: SpecBit_VS.cpp:369
Here is the call graph for this function:

◆ make_test_spectrum()

void Gambit::SpecBit::make_test_spectrum ( SubSpectrum *&  result)

Create a spectrum object for testing purposes.

Definition at line 44 of file SpecBit_tests.cpp.

References Gambit::logger(), Gambit::SpecBit::MSSMSpec< MI >::model_interface, mssm_manipulate(), setup(), TestMssmParGets(), and TestMssmPoleGets().

45  {
46  typedef CMSSM_interface<ALGORITHM1> MI;
47  static MI::Model FS_model; //start with empty flexiblesusy object
48  // Or could use flexiblesusy classes directly; these two are equivalent in this case:
49  //static CMSSM_slha<Two_scale> FS_model; //start with empty flexiblesusy object
50 
51  // Create model interface class (leaving input stuff with default values)
52  MI model_interface(FS_model);
53 
54  // Create SubSpectrum object to wrap flexiblesusy object
55  static MSSMSpec<MI> mssm(FS_model);
56 
57  // I think these objects should only get created once since they are static...
58  // ...and they should be destructed automatically when the program ends.
59 
60  setup(mssm.model_interface.model); //fill with some parameters
61  mssm.model_interface.model.calculate_DRbar_parameters(); //calculated DRbar masses
62  mssm.model_interface.model.calculate_pole_masses();//now calculate pole masses
63 
64  // Check contents
65  logger() << "This is specbit_tests. Checking SubSpectrum object contents..." << std::endl;
66  if(TestMssmParGets(mssm, mssm.model_interface.model)==false){
67  logger() << "TestMssmParGets fail." << std::endl;
68  return;
69  }
70  if(TestMssmPoleGets(mssm, mssm.model_interface.model)==false){
71  logger() << "TestMssmPoleGets fail." << std::endl;
72  return;
73  }
74  //So now we have a mssm1 model object filled, as it will be
75  //stored in Gambit after the spectrum generator has run
76  // mssm.mass2_par_mapping(); //call mapping - this needs to be changed.
77 
78  mssm_manipulate(mssm); //function can manipulate knowing the model
79 
80  // Store result for gambit to use
81  result = &mssm;
82  }
bool TestMssmParGets(SubSpectrum *spec, M FSmssm)
bool TestMssmPoleGets(SubSpectrum *spec, M FSmssm)
void mssm_manipulate(Gambit::SpecBit::MSSMSpec< M > &mssm)
void setup(Model &mssm)
Logging::LogMaster & logger()
Function to retrieve a reference to the Gambit global log object.
Definition: logger.cpp:95
Here is the call graph for this function:

◆ Math_test()

void Gambit::SpecBit::Math_test ( bool &  result)

Definition at line 60 of file SpecBit_tests.cpp.

61  {
62  namespace myPipe = Pipes::Math_test;
63 
64  int input1 = 3, input2 = 4;
65 
66  int output= myPipe::BEreq::MathTest(input1,input2);
67  cout << "Testing Mathematica" << endl;
68  cout << "Result : " << output << endl;
69 
70 
71  result = true;
72 
73  }
void Math_test(bool &result)

◆ MSSM_higgs_couplings_FH()

void Gambit::SpecBit::MSSM_higgs_couplings_FH ( HiggsCouplingsTable result)

Put together the Higgs couplings for the MSSM, using FeynHiggs.

Definition at line 1547 of file SpecBit_MSSM.cpp.

References Gambit::HiggsCouplingsTable::C_bb2, Gambit::HiggsCouplingsTable::C_cc2, Gambit::HiggsCouplingsTable::C_gaga2, Gambit::HiggsCouplingsTable::C_gg2, Gambit::HiggsCouplingsTable::C_hiZ2, Gambit::HiggsCouplingsTable::C_mumu2, Gambit::HiggsCouplingsTable::C_ss2, Gambit::HiggsCouplingsTable::C_tautau2, Gambit::HiggsCouplingsTable::C_tt2, Gambit::HiggsCouplingsTable::C_WW2, Gambit::HiggsCouplingsTable::C_Zga2, Gambit::HiggsCouplingsTable::C_ZZ2, Gambit::HiggsCouplingsTable::compute_effective_coupling(), Gambit::HiggsCouplingsTable::CP, fill_map_from_subspectrum(), get_invisibles(), Gambit::SMInputs::GF, Gambit::HiggsCouplingsTable::invisibles, MSSM_spectrum, Gambit::SMInputs::mZ, Gambit::Scanner::pow(), Gambit::HiggsCouplingsTable::set_charged_decays(), Gambit::HiggsCouplingsTable::set_neutral_decays(), Gambit::HiggsCouplingsTable::set_neutral_decays_SM(), Gambit::HiggsCouplingsTable::set_t_decays(), and Gambit::SMlike_higgs_PDG_code().

1548  {
1549  using namespace Pipes::MSSM_higgs_couplings_FH;
1550 
1551  // Retrieve spectrum contents
1552  const SubSpectrum& spec = Dep::MSSM_spectrum->get_HE();
1553  const SMInputs& sminputs = Dep::MSSM_spectrum->get_SMInputs();
1554 
1555  // Set up neutral Higgses
1556  static const std::vector<str> sHneut = initVector<str>("h0_1", "h0_2", "A0");
1557 
1558  // Work out which SM values correspond to which SUSY Higgs
1559  int higgs = (SMlike_higgs_PDG_code(spec) == 25 ? 0 : 1);
1560  int other_higgs = (higgs == 0 ? 1 : 0);
1561 
1562  // Set the decays
1563  result.set_neutral_decays_SM(higgs, sHneut[higgs], *Dep::Reference_SM_Higgs_decay_rates);
1564  result.set_neutral_decays_SM(other_higgs, sHneut[other_higgs], *Dep::Reference_SM_other_Higgs_decay_rates);
1565  result.set_neutral_decays_SM(2, sHneut[2], *Dep::Reference_SM_A0_decay_rates);
1566  result.set_neutral_decays(0, sHneut[0], *Dep::Higgs_decay_rates);
1567  result.set_neutral_decays(1, sHneut[1], *Dep::h0_2_decay_rates);
1568  result.set_neutral_decays(2, sHneut[2], *Dep::A0_decay_rates);
1569  result.set_charged_decays(0, "H+", *Dep::H_plus_decay_rates);
1570  result.set_t_decays(*Dep::t_decay_rates);
1571 
1572  // Use the branching fractions to compute gluon, gamma/Z and second generation fermionic effective couplings
1573  for (int i = 0; i < 3; i++)
1574  {
1575  result.C_gg2[i] = result.compute_effective_coupling(i, std::pair<int,int>(21, 0), std::pair<int,int>(21, 0));
1576  result.C_gaga2[i] = result.compute_effective_coupling(i, std::pair<int,int>(22, 0), std::pair<int,int>(22, 0));
1577  result.C_Zga2[i] = result.compute_effective_coupling(i, std::pair<int,int>(23, 0), std::pair<int,int>(22, 0));
1578  result.C_mumu2[i] = result.compute_effective_coupling(i, std::pair<int,int>(13, 1), std::pair<int,int>(-13, 1));
1579  result.C_ss2[i] = result.compute_effective_coupling(i, std::pair<int,int>(3, 1), std::pair<int,int>(-3, 1));
1580  result.C_cc2[i] = result.compute_effective_coupling(i, std::pair<int,int>(4, 1), std::pair<int,int>(-4, 1));
1581  }
1582 
1583  // Use couplings to get effective third-generation couplings
1584  for(int i = 0; i < 3; i++)
1585  {
1586  // Compute effective couplings
1587  double g2_s[3], g2_p[3];
1588  for (int j = 0; j < 3; j++) // j=0,1,2 => tau, t, b
1589  {
1590  fh_complex fh_L = Dep::FH_Couplings_output->couplings[H0FF(i+1,j+2,3,3)-1];
1591  fh_complex fh_R = Dep::FH_Couplings_output->couplings[H0FF(i+1,j+2,3,3)+Roffset-1];
1592  fh_complex fh_SM_L = Dep::FH_Couplings_output->couplings_sm[H0FF(i+1,j+2,3,3)-1];
1593  fh_complex fh_SM_R