gambit is hosted by Hepforge, IPPP Durham
GAMBIT  v1.5.0-2191-ga4742ac
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...
 
class  SpectrumEntriesForVevacious
 class for setting & storing all spectrum entries of type SpectrumEntry that need to be passed to vevacious (scale, input filenames & paths as well as spectrum entries) passed to vevacious before calling it More...
 
struct  SpectrumEntry
 
class  VevaciousResultContainer
 

Typedefs

typedef std::vector< std::pair< int, double > > vec_pair_int_dbl
 
typedef struct SpectrumEntry SpectrumEntry
 
typedef std::map< std::string, SpectrumEntrymap_str_SpectrumEntry
 map mapping the name of a spectrum entry to the SpectrumEntry type. 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 get_MSSM_spectrum_from_postprocessor (Spectrum &result)
 Get pre-computed MSSM spectrum from previous output file This function ONLY works when the scan is driven by the postprocessor! This is because it relies on the global reader object created by the postprocessor to retrieve output. 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< std::pair< str, str > > get_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 get_likelihood_VS (double &result)
 Vacuum stability likelihood from a Vevacious run calculating the lifetime of & tunneling probability to the vacuua. More...
 
void get_VS_results (map_str_dbl &result)
 get all results from VS as str to dbl map to easily print them More...
 
void make_vpp_inputs (map_str_str &opts)
 Helper function that takes any YAML options and makes the vevacious input, in the form of .xml files. More...
 
void set_panic_vacua (std::set< std::string > &result)
 Create a string set containing a list with all likelihoods that vevacious should calculate. More...
 
void set_tunnelling_strategy (std::set< std::string > &result)
 Create a string set containing a list of the tunnelling strategies that vevacious should use. More...
 
str helper_set_tunnelingStrategy (std::set< std::string > tunnelling_strategy)
 Set tunnelling strategy for the different minima, either. More...
 
void initialize_vevacious (std::string &inputspath)
 Parses the YAML file for any settings, then passes to make_vpp_inputs to create .xml files for vevacious to run with. More...
 
vevacious_1_0::VevaciousPlusPlus::VevaciousPlusPlus exec_pass_spectrum_to_vevacious (SpectrumEntriesForVevacious &pass_spectrum)
 Execute the passing of the spectrum object (as SLHAea) to vevacious. More...
 
void helper_run_vevacious (vevacious_1_0::VevaciousPlusPlus::VevaciousPlusPlus &vevaciousPlusPlus, VevaciousResultContainer &result, std::string panic_vacuum, std::string inputPath)
 Call vevacious, the result is either "Stable", "Metastable" or "Inconclusive" in case a vevacious run failed for some reason. More...
 
void helper_catch_vevacious (VevaciousResultContainer &result, std::string panic_vacuum)
 Decide how to deal with a failed vevacious run –> set lifetime and thermalProbability conservatively to a value easy to identify in analysis. More...
 
void compare_panic_vacua (map_str_str &result)
 If tunnelling to global and nearest vacuum are requested, this capability compares if the two vacua are the same. More...
 
void check_vacuum_stability_vevacious (VevaciousResultContainer &result)
 Check stability of global vacuum of the potential with vevacious. More...
 
void vevacious_file_location_MSSM (map_str_str &result)
 Tell GAMBIT which files to work with for the MSSM. More...
 
void prepare_pass_MSSM_spectrum_to_vevacious (SpectrumEntriesForVevacious &result)
 This function adds all entries of the spectrum object (as SLHAea) that need to be passed to vevacious to an instance of type SpectrumEntriesForVevacious. More...
 
void setup_QedQcd (softsusy::QedQcd &oneset, const SMInputs &sminputs)
 Non-Gambit helper functions. More...
 
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 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)
 
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)
 

Typedef Documentation

◆ map_str_SpectrumEntry

map mapping the name of a spectrum entry to the SpectrumEntry type.

In principle one could just use a vector instead of a map. However, this requires a lot of caution to avoid filling up the vector with more & more entries with the same name but different parameters after one point is run so I thought this was the safer option

Definition at line 61 of file SpecBit_types.hpp.

◆ SpectrumEntry

Definition at line 54 of file SpecBit_types.hpp.

◆ vec_pair_int_dbl

typedef std::vector<std::pair<int,double> > Gambit::SpecBit::vec_pair_int_dbl

Definition at line 42 of file SpecBit_types.hpp.

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 1692 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().

1693  {
1694  double At = 0;
1695  double Ab = 0;
1696  const double Yt = mssm.get(Par::dimensionless, "Yu", 3, 3);
1697  const double Yb = mssm.get(Par::dimensionless, "Yd", 3, 3);
1698  if(std::abs(Yt) > 1e-12)
1699  {
1700  At = mssm.get(Par::mass1, "TYu", 3, 3) / Yt;
1701  }
1702  if(std::abs(Yb) > 1e-12)
1703  {
1704  Ab = mssm.get(Par::mass1, "TYd", 3, 3) / Yb;
1705  }
1706 
1707  const double MuSUSY = mssm.get(Par::mass1, "Mu");
1708  const double tb = mssm.get(Par::dimensionless, "tanbeta");
1709 
1710  specmap["Xt"] = At - MuSUSY / tb;
1711  specmap["Xb"] = Ab - MuSUSY * tb;
1713  str msf1, msf2;
1717  const static double tol = 0.5;
1718  const static bool pt_error = true;
1719  slhahelp::family_state_mix_matrix("~u", 3, msf1, msf2, mssm, tol,
1720  LOCAL_INFO, pt_error);
1721  specmap["mstop1"] = mssm.get(Par::Pole_Mass, msf1);
1722  specmap["mstop2"] = mssm.get(Par::Pole_Mass, msf2);
1723  slhahelp::family_state_mix_matrix("~d", 3, msf1, msf2, mssm, tol,
1724  LOCAL_INFO, pt_error);
1725  specmap["msbottom1"] = mssm.get(Par::Pole_Mass, msf1);
1726  specmap["msbottom2"] = mssm.get(Par::Pole_Mass, msf2);
1727  slhahelp::family_state_mix_matrix("~e-", 3, msf1, msf2, mssm, tol,
1728  LOCAL_INFO, pt_error);
1729  specmap["mstau1"] = mssm.get(Par::Pole_Mass, msf1);
1730  specmap["mstau2"] = mssm.get(Par::Pole_Mass, msf2);
1733  const str gs_suL = slhahelp::mass_es_from_gauge_es("~u_L", mssm, tol,
1734  LOCAL_INFO, pt_error);
1735  specmap["msupL"] = mssm.get(Par::Pole_Mass,gs_suL);
1736  const str gs_scL = slhahelp::mass_es_from_gauge_es("~c_L", mssm, tol,
1737  LOCAL_INFO, pt_error);
1738  specmap["mscharmL"] = mssm.get(Par::Pole_Mass,gs_scL);
1739  const str gs_sdL = slhahelp::mass_es_from_gauge_es("~d_L", mssm, tol,
1740  LOCAL_INFO, pt_error);
1741  specmap["msdownL"] = mssm.get(Par::Pole_Mass,gs_sdL);
1742  const str gs_ssL = slhahelp::mass_es_from_gauge_es("~s_L", mssm, tol,
1743  LOCAL_INFO, pt_error);
1744  specmap["msstrangeL"] = mssm.get(Par::Pole_Mass,gs_ssL);
1745  const str gs_suR = slhahelp::mass_es_from_gauge_es("~u_R", mssm, tol,
1746  LOCAL_INFO, pt_error);
1747  specmap["msupR"] = mssm.get(Par::Pole_Mass,gs_suR);
1748  const str gs_scR = slhahelp::mass_es_from_gauge_es("~c_R", mssm, tol,
1749  LOCAL_INFO, pt_error);
1750  specmap["mscharmR"] = mssm.get(Par::Pole_Mass,gs_scR);
1751  const str gs_sdR = slhahelp::mass_es_from_gauge_es("~d_R", mssm, tol,
1752  LOCAL_INFO, pt_error);
1753  specmap["msdownR"] = mssm.get(Par::Pole_Mass,gs_sdR);
1754  const str gs_ssR = slhahelp::mass_es_from_gauge_es("~s_R", mssm, tol,
1755  LOCAL_INFO, pt_error);
1756  specmap["msstrangeR"] = mssm.get(Par::Pole_Mass,gs_ssR);
1757  const str gs_seL = slhahelp::mass_es_from_gauge_es("~e_L", mssm, tol,
1758  LOCAL_INFO, pt_error);
1759  specmap["mselectronL"] = mssm.get(Par::Pole_Mass,gs_seL);
1760  const str gs_sMuL = slhahelp::mass_es_from_gauge_es("~mu_L", mssm, tol,
1761  LOCAL_INFO, pt_error);
1762  specmap["msmuonL"] = mssm.get(Par::Pole_Mass,gs_sMuL);
1763  const str gs_seR = slhahelp::mass_es_from_gauge_es("~e_R", mssm, tol,
1764  LOCAL_INFO, pt_error);
1765  specmap["mselectronR"] = mssm.get(Par::Pole_Mass,gs_seR);
1766  const str gs_sMuR = slhahelp::mass_es_from_gauge_es("~mu_R", mssm, tol,
1767  LOCAL_INFO, pt_error);
1768  specmap["msmuonR"] = mssm.get(Par::Pole_Mass,gs_sMuR);
1769  const str gs_snu1 = slhahelp::mass_es_from_gauge_es("~nu_e_L", mssm, tol,
1770  LOCAL_INFO, pt_error);
1771  specmap["msnue"] = mssm.get(Par::Pole_Mass,gs_snu1);
1772  const str gs_snu2 = slhahelp::mass_es_from_gauge_es("~nu_mu_L", mssm, tol,
1773  LOCAL_INFO, pt_error);
1774  specmap["msnumu"] = mssm.get(Par::Pole_Mass,gs_snu2);
1775  const str gs_snu3 = slhahelp::mass_es_from_gauge_es("~nu_tau_L", mssm, tol,
1776  LOCAL_INFO, pt_error);
1777  specmap["msnutau"] = mssm.get(Par::Pole_Mass,gs_snu3);
1778 
1779  }
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 69 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.

70  {
71  // check that the electroweak scale stability conditions are satisfied
73 
75 
76  double lambda_h = fullspectrum.get(Par::dimensionless,"lambda_h");
77  double lambda_s = fullspectrum.get(Par::dimensionless,"lambda_S");
78  double lambda_hs = fullspectrum.get(Par::dimensionless,"lambda_hS");
79  double mu3 = fullspectrum.get(Par::mass1,"mu3");
80  double ms = fullspectrum.get(Par::Pole_Mass,"S");
81 
82  double check = 0;
83 
84  if ( (lambda_h*lambda_s > 0 ) )
85  {
86  check = 2 * pow( lambda_h * lambda_s , 0.5) + lambda_hs;
87  }
88  double check_2 = 2.*pow(abs(lambda_s),0.5)*ms - mu3;
89 
90  result = 0;
91 
92  // if any condition not satisfied set bad likelihood and invalidate point
93  if ( lambda_hs < 0 || lambda_s < 0 || check < 0 || check_2 < 0)
94  {
95  invalid_point().raise("Electroweak vacuum is unstable at low scale.");
96  result = -1e100;
97  }
98  }
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. Exact override of base method.
Definition: exceptions.cpp:422
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:69
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 414 of file SpecBit_VS.cpp.

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

415  {
416  namespace myPipe = Pipes::check_perturb_min_lambda;
417  dbl_dbl_bool vs_tuple = *myPipe::Dep::high_scale_vacuum_info;
418 
419  if (vs_tuple.flag)
420  {
421  invalid_point().raise("Couplings are non-perturbative before scale of vacuum instability");
422  result = -1e100;
423  }
424  else
425  {
426  result = 0;
427  }
428  }
virtual void raise(const std::string &)
Raise the exception, i.e. throw it. Exact override of base method.
Definition: exceptions.cpp:422
void check_perturb_min_lambda(double &result)
Definition: SpecBit_VS.cpp:414
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 100 of file SpecBit_VS.cpp.

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

Referenced by find_min_lambda_Helper().

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

◆ check_vacuum_stability_vevacious()

void Gambit::SpecBit::check_vacuum_stability_vevacious ( VevaciousResultContainer result)

Check stability of global vacuum of the potential with vevacious.

Definition at line 1293 of file SpecBit_VS.cpp.

References Gambit::SpecBit::VevaciousResultContainer::clear_results(), compare_panic_vacua(), Gambit::LogTags::debug, Gambit::EOM, exec_pass_spectrum_to_vevacious(), Gambit::SpecBit::SpectrumEntriesForVevacious::get_inputPath(), helper_catch_vevacious(), helper_run_vevacious(), and Gambit::logger().

1294  {
1296 
1297  // get a str-str map with valculations vevacious has to execute for this parameter point
1298  // note: this has to be executed for each point as it can happen that the nearest and the
1299  // global panic vaccum are the same.
1300  map_str_str panic_vacua = *Dep::compare_panic_vacua;
1301 
1302  // This is the number of different pathFinders implemented in vevacious. It should be
1303  // returned by a BE convenience function, I tried to do it but didn't manage to
1304  // with the BOSS stuff -- that should probably be fixed # todo
1305  static int pathFinder_number = 2;
1306 
1307  // get the object that holds all inputs that needs to be passed to vevacious
1308  SpectrumEntriesForVevacious pass_spectrum = (*Dep::pass_spectrum_to_vevacious);
1309 
1310  // run vevacious for different panic vacua, respecting the choices for thermal
1311  // or only quantum tunnelling calculations
1312  for(auto x : panic_vacua)
1313  {
1314  // set panic vacuum and tunnelling strategy for vevacious run
1315  std::string panic_vacuum = x.first;
1316  std::string tunnellingStrategy = x.second;
1317 
1318  // reset all entries of the of VevaciousResultContainer map holding the results
1319  // to avoid that any value could be carried over from a previous calculated point
1320  result.clear_results(panic_vacuum, pathFinder_number);
1321  try
1322  {
1323  // create vevaciousPlusPlus object new for every try since spectrum
1324  // vevacious deletes spectrum after each run => to be able to do this
1325  // we need the non-rollcalled helper function that gets executed every time
1326  // we get to this line (unlike a dependency)
1327  vevacious_1_0::VevaciousPlusPlus::VevaciousPlusPlus vevaciousPlusPlus = exec_pass_spectrum_to_vevacious(pass_spectrum);
1328 
1329  // helper function to set lifetime & thermal probability accordingly
1330  // (this is a separate function s.t. we don't have to reproduce code
1331  // for different panic vacua)
1332  helper_run_vevacious(vevaciousPlusPlus, result, panic_vacuum, pass_spectrum.get_inputPath());
1333  }
1334  catch(const std::exception& e)
1335  {
1336  // call function that sets the lifetime & thermal probability if vevacious
1337  // has crashed for some reason
1338  helper_catch_vevacious(result, panic_vacuum);
1339  logger() << LogTags::debug << "Error occurred: " << e.what() << EOM;
1340  }
1341  }
1342  }
void helper_run_vevacious(vevacious_1_0::VevaciousPlusPlus::VevaciousPlusPlus &vevaciousPlusPlus, VevaciousResultContainer &result, std::string panic_vacuum, std::string inputPath)
Call vevacious, the result is either "Stable", "Metastable" or "Inconclusive" in case a vevacious run...
void helper_catch_vevacious(VevaciousResultContainer &result, std::string panic_vacuum)
Decide how to deal with a failed vevacious run –> set lifetime and thermalProbability conservatively...
const Logging::endofmessage EOM
Explicit const instance of the end of message struct in Gambit namespace.
Definition: logger.hpp:100
EXPORT_SYMBOLS Logging::LogMaster & logger()
Function to retrieve a reference to the Gambit global log object.
Definition: logger.cpp:95
vevacious_1_0::VevaciousPlusPlus::VevaciousPlusPlus exec_pass_spectrum_to_vevacious(SpectrumEntriesForVevacious &pass_spectrum)
Execute the passing of the spectrum object (as SLHAea) to vevacious.
std::map< std::string, std::string > map_str_str
Shorthand for a string-to-string map.
Definition: util_types.hpp:78
void check_vacuum_stability_vevacious(VevaciousResultContainer &result)
Check stability of global vacuum of the potential with vevacious.
void compare_panic_vacua(map_str_str &result)
If tunnelling to global and nearest vacuum are requested, this capability compares if the two vacua a...
Here is the call graph for this function:

◆ compare_panic_vacua()

void Gambit::SpecBit::compare_panic_vacua ( map_str_str result)

If tunnelling to global and nearest vacuum are requested, this capability compares if the two vacua are the same.

Return true if they coincide, false if not.

Definition at line 1235 of file SpecBit_VS.cpp.

References Gambit::LogTags::debug, Gambit::EOM, exec_pass_spectrum_to_vevacious(), helper_set_tunnelingStrategy(), and Gambit::logger().

Referenced by check_vacuum_stability_vevacious(), get_likelihood_VS(), and get_VS_results().

1236  {
1237  using namespace Pipes::compare_panic_vacua;
1238 
1239  // get the object that holds all inputs that needs to be passed to vevacious
1240  SpectrumEntriesForVevacious pass_spectrum = (*Dep::pass_spectrum_to_vevacious);
1241  // create vev object to check if global and near panic vacuum are the same
1242  vevacious_1_0::VevaciousPlusPlus::VevaciousPlusPlus vevaciousPlusPlus = exec_pass_spectrum_to_vevacious(pass_spectrum);
1243 
1244  // get set with contributions to likelihood that should be calculated
1245  std::set<std::string> panic_vacua = *Dep::panic_vacua;
1246 
1247  // Check if global and nearest are requested, if so test if the happen to be
1248  // the same minimum for this point in parameters space.
1249  // If that is the case, remove the global points from the
1250  if( panic_vacua.find("global") != panic_vacua.end() and panic_vacua.find("nearest") != panic_vacua.end() )
1251  {
1252  // get vector pair with VEVs of global and nearest vacua
1253  std::pair<std::vector<double>,std::vector<double>> vevs = vevaciousPlusPlus.RunVacua("internal");
1254  std::vector<double> global = vevs.first;
1255  std::vector<double> nearest = vevs.second;
1256 
1257  // check if vectors are equal
1258  bool compare = std::equal(global.begin(), global.end(), nearest.begin());
1259 
1260  // if the minima are the same, remove global entries if the corresponding nearest
1261  // entry is contained
1262  if(compare)
1263  {
1264  if (panic_vacua.find("global") != panic_vacua.end() and panic_vacua.find("nearest") != panic_vacua.end())
1265  {
1266  panic_vacua.erase("global");
1267  }
1268  // add info to logger
1269  std::ostringstream ss;
1270  ss << "Global and nearest minimum are the same. Will only calculate tunnelling" << endl;
1271  ss << "probability once." << endl;
1272  logger() << LogTags::debug << ss.str() << EOM;
1273  }
1274  else
1275  {
1276  // add info to debug logger
1277  std::ostringstream ss;
1278  ss << "Global and nearest minimum are not the same. Will calculate tunnelling" << endl;
1279  ss << "probability to both." << endl;
1280  logger() << LogTags::debug << ss.str() << EOM;
1281  }
1282 
1283  }
1284 
1285  // Fill result map and set tunnelling strategy for the minima
1286  for (auto &panic_vacuum: panic_vacua)
1287  result[panic_vacuum] = helper_set_tunnelingStrategy(*Dep::tunnelling_strategy);
1288 
1289  }
const Logging::endofmessage EOM
Explicit const instance of the end of message struct in Gambit namespace.
Definition: logger.hpp:100
EXPORT_SYMBOLS Logging::LogMaster & logger()
Function to retrieve a reference to the Gambit global log object.
Definition: logger.cpp:95
vevacious_1_0::VevaciousPlusPlus::VevaciousPlusPlus exec_pass_spectrum_to_vevacious(SpectrumEntriesForVevacious &pass_spectrum)
Execute the passing of the spectrum object (as SLHAea) to vevacious.
str helper_set_tunnelingStrategy(std::set< std::string > tunnelling_strategy)
Set tunnelling strategy for the different minima, either.
void compare_panic_vacua(map_str_str &result)
If tunnelling to global and nearest vacuum are requested, this capability compares if the two vacua a...
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 654 of file SpecBit_MSSM.cpp.

654 {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 652 of file SpecBit_MSSM.cpp.

References MSSM_spectrum.

◆ convert_NMSSM_to_SM()

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

Definition at line 653 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:270
void exampleRead(bool &result)
const double mu
Definition: SM_Z.hpp:42
#define GET_MATRIX(NAME, BLOCK, __IND1, __IND2)
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:

◆ exec_pass_spectrum_to_vevacious()

vevacious_1_0::VevaciousPlusPlus::VevaciousPlusPlus Gambit::SpecBit::exec_pass_spectrum_to_vevacious ( SpectrumEntriesForVevacious pass_spectrum)

Execute the passing of the spectrum object (as SLHAea) to vevacious.

It is a helper function and not a capability since this has to be executed before every single vevacious run. vevacious can run multiple times for a single point in parameter space depending on settings: -> global and/or nearest minimum for tunneling requested? -> multiple attempts for one vevacious run allowed?

Definition at line 1094 of file SpecBit_VS.cpp.

References Gambit::LogTags::debug, Gambit::SpecBit::SpectrumEntry::dimension, Gambit::EOM, Gambit::SpecBit::SpectrumEntriesForVevacious::get_inputFilename(), Gambit::SpecBit::SpectrumEntriesForVevacious::get_scale(), Gambit::SpecBit::SpectrumEntriesForVevacious::get_spec_entry_map(), Gambit::logger(), Gambit::SpecBit::SpectrumEntry::name, and Gambit::SpecBit::SpectrumEntry::parameters.

Referenced by check_vacuum_stability_vevacious(), and compare_panic_vacua().

1095  {
1096 
1097  // get inputFilename and initialise vevaciousPlusPlus object with it
1098  static std::string inputFilename = pass_spectrum.get_inputFilename();
1099  vevacious_1_0::VevaciousPlusPlus::VevaciousPlusPlus vevaciousPlusPlus(inputFilename);
1100 
1101  // get scale and the map containing all spectrum entries that need to be passed to vevacious
1102  double scale = pass_spectrum.get_scale();
1103  map_str_SpectrumEntry spec_entry_map = pass_spectrum.get_spec_entry_map();
1104 
1105  // iterate through map and call vevacious' 'ReadLhaBlock' to read spectrum entries
1106  for (auto it=spec_entry_map.begin(); it!=spec_entry_map.end(); ++it)
1107  {
1108  SpectrumEntry entry = it->second;
1109  logger() << LogTags::debug << "Passing ReadLhaBlock option "<< entry.name << " scale " << scale << " parameters" << entry.parameters <<" and dimension " << entry.dimension << " to vevacious" << EOM;
1110  vevaciousPlusPlus.ReadLhaBlock(entry.name, scale , entry.parameters, entry.dimension );
1111  }
1112 
1113  return vevaciousPlusPlus;
1114  }
std::map< std::string, SpectrumEntry > map_str_SpectrumEntry
map mapping the name of a spectrum entry to the SpectrumEntry type.
const Logging::endofmessage EOM
Explicit const instance of the end of message struct in Gambit namespace.
Definition: logger.hpp:100
EXPORT_SYMBOLS Logging::LogMaster & logger()
Function to retrieve a reference to the Gambit global log object.
Definition: logger.cpp:95
struct SpectrumEntry SpectrumEntry
Here is the call graph for this function:
Here is the caller graph for this function:

◆ FH_AllHiggsMasses()

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

Higgs masses and mixings with theoretical uncertainties.

Definition at line 1333 of file SpecBit_MSSM.cpp.

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

Referenced by main().

1334  {
1335  using namespace Pipes::FH_AllHiggsMasses;
1336 
1337  #ifdef SPECBIT_DEBUG
1338  cout << "****** calling FH_HiggsMasses ******" << endl;
1339  #endif
1340 
1341  // Higgs mass with
1342  // 0 - m1 (Mh in rMSSM)
1343  // 1 - m2 (MH in rMSSM)
1344  // 2 - m3 (MA in rMSSM)
1345  // 3 - MHpm
1346  Farray<fh_real, 1,4> MHiggs;
1347  Farray<fh_real, 1,4> DeltaMHiggs;
1348 
1349  // sine of effective Higgs mixing angle, alpha_eff
1350  fh_complex SAeff;
1351  fh_complex DeltaSAeff;
1352 
1353  // matrix needed to rotate Higgs
1354  // mass matrix to diagonal form
1355  Farray<fh_complex, 1,3, 1,3> UHiggs;
1356  Farray<fh_complex, 1,3, 1,3> DeltaUHiggs;
1357 
1358  // matrix of Z-factors needed to combine
1359  // amplitudes involving on-shell Higgs
1360  Farray<fh_complex, 1,3, 1,3> ZHiggs;
1361  Farray<fh_complex, 1,3, 1,3> DeltaZHiggs;
1362 
1363  #ifdef SPECBIT_DEBUG
1364  cout << "****** calling FHHiggsCorr ******" << endl;
1365  #endif
1366 
1367  int error = 1;
1368  BEreq::FHHiggsCorr(error, MHiggs, SAeff, UHiggs, ZHiggs);
1369  if (error != 0)
1370  {
1371  std::ostringstream err;
1372  err << "BEreq::FHHiggsCorr raised error flag: " << error << ".";
1373  invalid_point().raise(err.str());
1374  }
1375 
1376  #ifdef SPECBIT_DEBUG
1377  cout << "****** calling FHUncertainties ******" << endl;
1378  #endif
1379 
1380  error = 1;
1381  BEreq::FHUncertainties(error, DeltaMHiggs, DeltaSAeff, DeltaUHiggs, DeltaZHiggs);
1382  if (error != 0)
1383  {
1384  std::ostringstream err;
1385  err << "BEreq::FHUncertainties raised error flag: " << error << ".";
1386  invalid_point().raise(err.str());
1387  }
1388 
1389  fh_HiggsMassObs HiggsMassObs;
1390  for(int i = 0; i < 4; i++)
1391  {
1392  HiggsMassObs.MH[i] = MHiggs(i+1);
1393  HiggsMassObs.deltaMH[i] = DeltaMHiggs(i+1);
1394  }
1395  HiggsMassObs.SinAlphaEff = SAeff;
1396  HiggsMassObs.deltaSinAlphaEff = DeltaSAeff;
1397  for(int i = 0; i < 3; i++)
1398  for(int j = 0; j < 3; j++)
1399  {
1400  HiggsMassObs.UH[i][j] = UHiggs(i+1,j+1);
1401  HiggsMassObs.deltaUH[i][j] = DeltaUHiggs(i+1,j+1);
1402  HiggsMassObs.ZH[i][j] = ZHiggs(i+1,j+1);
1403  HiggsMassObs.deltaZH[i][j] = DeltaZHiggs(i+1,j+1);
1404  }
1405 
1406  result = HiggsMassObs;
1407  }
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. Exact override of base method.
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 1414 of file SpecBit_MSSM.cpp.

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

Referenced by main().

1415  {
1416  using namespace Pipes::FH_Couplings;
1417 
1418  #ifdef SPECBIT_DEBUG
1419  cout << "****** calling FH_Couplings ******" << endl;
1420  #endif
1421 
1422  // what to use for internal Higgs mixing
1423  // (ex. in couplings)
1424  // (default = 1)
1425  // 0 - no mixing
1426  // 1 - UHiggs
1427  // 2 - ZHiggs
1428  int uzint = 2;
1429  // what to use for external Higgs mixing
1430  // (ex. in decays)
1431  // (default = 2)
1432  // 0 - no mixing
1433  // 1 - UHiggs
1434  // 2 - ZHiggs
1435  int uzext = 2;
1436  // which effective bottom mass to use
1437  int mfeff = 1;
1438 
1439  #ifdef SPECBIT_DEBUG
1440  cout << "****** calling FHSelectUZ ******" << endl;
1441  #endif
1442 
1443  int error = 1;
1444  BEreq::FHSelectUZ(error, uzint, uzext, mfeff);
1445  if (error != 0)
1446  {
1447  std::ostringstream err;
1448  err << "BEreq::FHSelectUZ raised error flag: " << error << ".";
1449  invalid_point().raise(err.str());
1450  }
1451 
1452  Farray<fh_complex, 1,ncouplings> couplings; // MSSM Higgs couplings
1453  Farray<fh_complex, 1,ncouplingsms> couplings_sm; // SM Higgs couplings
1454  Farray<fh_real, 1,ngammas> gammas; // Higgs decay widths and BR's (MSSM)
1455  Farray<fh_real, 1,ngammasms> gammas_sm; // Higgs decay widths and BR's (SM)
1456  int fast = 1; // include off-diagonal fermion decays? (1 = no)
1457 
1458  #ifdef SPECBIT_DEBUG
1459  cout << "****** calling FHCouplings ******" << endl;
1460  #endif
1461 
1462  error = 1;
1463  BEreq::FHCouplings(error, couplings, couplings_sm,
1464  gammas, gammas_sm, fast);
1465  if (error != 0)
1466  {
1467  std::ostringstream err;
1468  err << "BEreq::FHCouplings raised error flag: " << error << ".";
1469  invalid_point().raise(err.str());
1470  }
1471 
1472  fh_Couplings Couplings;
1473  for(int i = 0; i < ncouplings; i++) Couplings.couplings[i] = couplings(i+1);
1474  for(int i = 0; i < ncouplingsms; i++) Couplings.couplings_sm[i] = couplings_sm(i+1);
1475  for(int i = 0; i < ngammas; i++) Couplings.gammas[i] = gammas(i+1);
1476  for(int i = 0; i < ngammasms; i++) Couplings.gammas_sm[i] = gammas_sm(i+1);
1477  Couplings.calculator = BEreq::FHCouplings.origin();
1478  Couplings.calculator_version = BEreq::FHCouplings.version();
1479 
1480  result = Couplings;
1481  }
virtual void raise(const std::string &)
Raise the exception, i.e. throw it. Exact override of base method.
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 1915 of file SpecBit_MSSM.cpp.

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

Referenced by main().

1916  {
1917  using namespace Pipes::FH_HeavyHiggsMasses;
1918  const int neutrals[2] = {25, 35};
1919  int i = -1;
1920  const SubSpectrum& spec = Dep::unimproved_MSSM_spectrum->get_HE();
1921  int higgs = SMlike_higgs_PDG_code(spec);
1922  if (higgs == neutrals[0]) i = 1;
1923  else if (higgs == neutrals[1]) i = 0;
1924  else SpecBit_error().raise(LOCAL_INFO, "Urecognised SM-like Higgs PDG code!");
1925  result.clear();
1926  result[neutrals[i]].central = Dep::FH_HiggsMasses->MH[i];
1927  result[neutrals[i]].upper = Dep::FH_HiggsMasses->deltaMH[i];
1928  result[neutrals[i]].lower = Dep::FH_HiggsMasses->deltaMH[i];
1929  result[36].central = Dep::FH_HiggsMasses->MH[2];
1930  result[36].upper = Dep::FH_HiggsMasses->deltaMH[2];
1931  result[36].lower = Dep::FH_HiggsMasses->deltaMH[2];
1932  result[37].central = Dep::FH_HiggsMasses->MH[3];
1933  result[37].upper = Dep::FH_HiggsMasses->deltaMH[3];
1934  result[37].lower = Dep::FH_HiggsMasses->deltaMH[3];
1935  }
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 1900 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().

1901  {
1902  using namespace Pipes::FH_HiggsMass;
1903  //FH indices: 0=h0_1, 1=h0_2
1904  int i = 0;
1905  const SubSpectrum& spec = Dep::unimproved_MSSM_spectrum->get_HE();
1906  int higgs = SMlike_higgs_PDG_code(spec);
1907  if (higgs == 25) i = 0;
1908  else if (higgs == 35) i = 1;
1909  else SpecBit_error().raise(LOCAL_INFO, "Urecognised SM-like Higgs PDG code!");
1910  result.central = Dep::FH_HiggsMasses->MH[i];
1911  result.upper = Dep::FH_HiggsMasses->deltaMH[i];
1912  result.lower = Dep::FH_HiggsMasses->deltaMH[i];
1913  }
#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 1220 of file SpecBit_MSSM.cpp.

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

1221  {
1222  using namespace Pipes::FH_MSSMMasses;
1223 
1224  #ifdef SPECBIT_DEBUG
1225  cout << "****** calling FH_MSSMMasses ******" << endl;
1226  #endif
1227 
1228  // zero if minimal, non-zero if non-minimal flavour violation
1229  int nmfv;
1230 
1231  // MSf(s,t,g) MFV squark masses with indices
1232  // s = 1..2 sfermion index
1233  // t = 1..5 sfermion type nu,e,u,d,?
1234  // g = 1..3 generation index
1235  Farray<fh_real, 1,2, 1,5, 1,3> MSf;
1236 
1237  // USf(s1,s2,t,g) MFV squark mixing matrices with indices
1238  // s1 = 1..2 sfermion index (mass eigenstates)
1239  // s2 = 1..2 sfermion index (gauge eigenstates, L/R)
1240  // t = 1..5 sfermion type nu,e,u,d,?
1241  // g = 1..3 generation index
1242  Farray<fh_complex, 1,2, 1,2, 1,5, 1,3> USf;
1243 
1244  // NMFV squark masses, with indices
1245  // a = 1..6 extended sfermion index
1246  // t = 1..5 sfermion type
1247  Farray<fh_real, 1,6, 1,5> MASf;
1248 
1249  // NMFV squark mixing matrices, with indices
1250  // a1 = 1..6 extended sfermion index (mass eigenstates)
1251  // a2 = 1..6 extended sfermion index (gauge eigenstates)
1252  // t = 1..5 sftermion type nu,e,u,d,?
1253  Farray<fh_complex, 1,36, 1,5> UASf;
1254 
1255  // chargino masses
1256  Farray<fh_real, 1,2> MCha;
1257 
1258  // chargino mixing matrices (mass,gauge) eigenstates (2 x 2)
1259  Farray<fh_complex, 1,4> UCha;
1260  Farray<fh_complex, 1,4> VCha;
1261 
1262  // neutralino masses
1263  Farray<fh_real, 1,4> MNeu;
1264 
1265  // neutralino mixing matrices (mass,gauge) eigenstates (4 x 4)
1266  Farray<fh_complex, 1,16> ZNeu;
1267 
1268  // correction to bottom Yukawa coupling
1269  fh_complex DeltaMB;
1270 
1271  // gluino mass
1272  fh_real MGl;
1273 
1274  // tree-level Higgs masses (Mh, MH, MA, MHpm)
1275  Farray<fh_real, 1,4> MHtree;
1276 
1277  // tree-level Higgs mixing parameters sin alpha
1278  fh_real SAtree;
1279 
1280  #ifdef SPECBIT_DEBUG
1281  cout << "****** calling FHGetPara ******" << endl;
1282  #endif
1283 
1284  int error = 1;
1285  BEreq::FHGetPara(error, nmfv, MSf, USf, MASf, UASf,
1286  MCha, UCha, VCha, MNeu, ZNeu,
1287  DeltaMB, MGl, MHtree, SAtree);
1288  if (error != 0)
1289  {
1290  std::ostringstream err;
1291  err << "BEreq::FHGetPara raised error flag: " << error << ".";
1292  invalid_point().raise(err.str());
1293  }
1294 
1295  fh_MSSMMassObs MassObs;
1296  for(int i = 0; i < 2; i++)
1297  for(int j = 0; j < 5; j++)
1298  for(int k = 0; k < 3; k++)
1299  MassObs.MSf[i][j][k] = MSf(i+1,j+1,k+1);
1300  for(int i = 0; i < 2; i++)
1301  for(int j = 0; j < 2; j++)
1302  for(int k = 0; k < 5; k++)
1303  for(int l = 0; l < 3; l++)
1304  MassObs.USf[i][j][k][l] = USf(i+1,j+1,k+1,l+1);
1305  for(int i = 0; i < 6; i++)
1306  for(int j = 0; j < 5; j++)
1307  MassObs.MASf[i][j] = MASf(i+1,j+1);
1308  for(int i = 0; i < 36; i++)
1309  for(int j = 0; j < 5; j++)
1310  MassObs.UASf[i][j] = UASf(i+1,j+1);
1311  for(int i = 0; i < 2; i++)
1312  MassObs.MCha[i] = MCha(i+1);
1313  for(int i = 0; i < 4; i++)
1314  {
1315  MassObs.UCha[i] = UCha(i+1);
1316  MassObs.VCha[i] = VCha(i+1);
1317  }
1318  for(int i = 0; i < 4; i++)
1319  MassObs.MNeu[i] = MNeu(i+1);
1320  for(int i = 0; i < 16; i++)
1321  MassObs.ZNeu[i] = ZNeu(i+1);
1322  MassObs.deltaMB = DeltaMB;
1323  MassObs.MGl = MGl;
1324  for(int i = 0; i < 4; i++)
1325  MassObs.MHtree[i] = MHtree(i+1);
1326  MassObs.SinAlphatree = SAtree;
1327 
1328  result = MassObs;
1329  }
void FH_MSSMMasses(fh_MSSMMassObs &result)
FeynHiggs SUSY masses and mixings.
virtual void raise(const std::string &)
Raise the exception, i.e. throw it. Exact override of base method.
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 514 of file SpecBit_MSSM.cpp.

References generate_raster_scan_settings::output.

Referenced by fill_MSSM63_input(), and fill_MSSM63_input_altnames().

515  {
516  Eigen::Matrix<double,3,3> output;
517  for(int i=0; i<3; ++i) for(int j=0; j<3; ++j)
518  {
519  output(i,j) = *Param.at(rootname + "_" + std::to_string(i+1) + std::to_string(j+1));
520  }
521  return output;
522  }
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 525 of file SpecBit_MSSM.cpp.

References generate_raster_scan_settings::output.

Referenced by fill_MSSM63_input(), and fill_MSSM63_input_altnames().

526  {
527  Eigen::Matrix<double,3,3> output;
528  for(int i=0; i<3; ++i) for(int j=0; j<3; ++j)
529  {
530  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));
531  output(i,j) = *Param.at(parname);
532  }
533  return output;
534  }
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
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
Spectrum Spectrum Spectrum Spectrum Spectrum 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 601 of file SpecBit_ScalarSingletDM.cpp.

Referenced by get_ScalarSingletDM_Z2_spectrum_as_map(), and get_ScalarSingletDM_Z3_spectrum_as_map().

603  {
604  for(std::vector<SpectrumParameter>::const_iterator it = required_parameters.begin();
605  it != required_parameters.end(); ++it)
606  {
607  const Par::Tags tag = it->tag();
608  const std::string name = it->name();
609  const std::vector<int> shape = it->shape();
610 
612 
613  // Check scalar case
614  if(shape.size()==1 and shape[0]==1)
615  {
616  std::ostringstream label;
617  label << name <<" "<< Par::toString.at(tag);
618  specmap[label.str()] = singletdmspec.get_HE().get(tag,name);
619  }
620  // Check vector case
621  else if(shape.size()==1 and shape[0]>1)
622  {
623  for(int i = 1; i<=shape[0]; ++i) {
624  std::ostringstream label;
625  label << name <<"_"<<i<<" "<< Par::toString.at(tag);
626  specmap[label.str()] = singletdmspec.get_HE().get(tag,name,i);
627  }
628  }
629  // Check matrix case
630  else if(shape.size()==2)
631  {
632  for(int i = 1; i<=shape[0]; ++i) {
633  for(int j = 1; j<=shape[0]; ++j) {
634  std::ostringstream label;
635  label << name <<"_("<<i<<","<<j<<") "<<Par::toString.at(tag);
636  specmap[label.str()] = singletdmspec.get_HE().get(tag,name,i,j);
637  }
638  }
639  }
640  // Deal with all other cases
641  else
642  {
643  // ERROR
644  std::ostringstream errmsg;
645  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.";
646  errmsg << "Problematic parameter was: "<< tag <<", " << name << ", shape="<< shape;
647  utils_error().forced_throw(LOCAL_INFO,errmsg.str());
648  }
649  }
650 
651  }
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 1823 of file SpecBit_MSSM.cpp.

Referenced by MSSM_higgs_couplings_FH().

1824  {
1826  static const Contents contents;
1827  static const std::vector<SpectrumParameter> required_parameters = contents.all_parameters();
1828 
1829  for(std::vector<SpectrumParameter>::const_iterator it = required_parameters.begin();
1830  it != required_parameters.end(); ++it)
1831  {
1832  const Par::Tags tag = it->tag();
1833  const std::string name = it->name();
1834  const std::vector<int> shape = it->shape();
1835 
1837 
1838  // Check scalar case
1839  if(shape.size()==1 and shape[0]==1)
1840  {
1841  std::ostringstream label;
1842  label << name <<" "<< Par::toString.at(tag);
1843  specmap[label.str()] = subspec.get(tag,name);
1844  // Check again ignoring overrides (if the value has an override defined)
1845  if(subspec.has(tag,name,overrides_only) and
1846  subspec.has(tag,name,ignore_overrides))
1847  {
1848  label << " (unimproved)";
1849  specmap[label.str()] = subspec.get(tag,name,ignore_overrides);
1850  }
1851  }
1852  // Check vector case
1853  else if(shape.size()==1 and shape[0]>1)
1854  {
1855  for(int i = 1; i<=shape[0]; ++i) {
1856  std::ostringstream label;
1857  label << name <<"_"<<i<<" "<< Par::toString.at(tag);
1858  specmap[label.str()] = subspec.get(tag,name,i);
1859  // Check again ignoring overrides
1860  if(subspec.has(tag,name,i,overrides_only) and
1861  subspec.has(tag,name,i,ignore_overrides))
1862  {
1863  label << " (unimproved)";
1864  specmap[label.str()] = subspec.get(tag,name,i,ignore_overrides);
1865  }
1866  }
1867  }
1868  // Check matrix case
1869  else if(shape.size()==2)
1870  {
1871  for(int i = 1; i<=shape[0]; ++i) {
1872  for(int j = 1; j<=shape[0]; ++j) {
1873  std::ostringstream label;
1874  label << name <<"_("<<i<<","<<j<<") "<<Par::toString.at(tag);
1875  specmap[label.str()] = subspec.get(tag,name,i,j);
1876  // Check again ignoring overrides
1877  if(subspec.has(tag,name,i,j,overrides_only) and
1878  subspec.has(tag,name,i,j,ignore_overrides))
1879  {
1880  label << " (unimproved)";
1881  specmap[label.str()] = subspec.get(tag,name,i,j,ignore_overrides);
1882  }
1883  }
1884  }
1885  }
1886  // Deal with all other cases
1887  else
1888  {
1889  // ERROR
1890  std::ostringstream errmsg;
1891  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.";
1892  errmsg << "Problematic parameter was: "<< tag <<", " << name << ", shape="<< shape;
1893  SpecBit_error().forced_throw(LOCAL_INFO,errmsg.str());
1894  }
1895  }
1896  // add the scale!
1897  specmap["scale(Q)"] = subspec.GetScale();
1898  }
#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 539 of file SpecBit_MSSM.cpp.

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

Referenced by get_MSSM_spectrum_SPheno().

540  {
541  //double valued parameters
542  input.TanBeta = *Param.at("TanBeta");
543  input.MassBInput = *Param.at("M1");
544  input.MassWBInput = *Param.at("M2");
545  input.MassGInput = *Param.at("M3");
546 
547  // Sanity checks
548  if(input.TanBeta<0)
549  {
550  std::ostringstream msg;
551  msg << "Tried to set TanBeta parameter to a negative value ("<<input.TanBeta<<")! This parameter must be positive. Please check your inifile and try again.";
552  SpecBit_error().raise(LOCAL_INFO,msg.str());
553  }
554 
555  //3x3 matrices; filled with the help of a convenience function
556  input.mq2Input = fill_3x3_symmetric_parameter_matrix("mq2", Param);
557  input.ml2Input = fill_3x3_symmetric_parameter_matrix("ml2", Param);
558  input.md2Input = fill_3x3_symmetric_parameter_matrix("md2", Param);
559  input.mu2Input = fill_3x3_symmetric_parameter_matrix("mu2", Param);
560  input.me2Input = fill_3x3_symmetric_parameter_matrix("me2", Param);
561  input.Aeij = fill_3x3_parameter_matrix("Ae", Param);
562  input.Adij = fill_3x3_parameter_matrix("Ad", Param);
563  input.Auij = fill_3x3_parameter_matrix("Au", Param);
564 
565  #ifdef SPECBIT_DEBUG
566  #define INPUT(p) input.p
567  #define ostr std::cout
568  #define oend std::endl
569  ostr << "TanBeta = " << INPUT(TanBeta) << ", " << oend ;
570  ostr << "mq2Input = " << oend << INPUT(mq2Input) << ", " << oend;
571  ostr << "ml2Input = " << oend << INPUT(ml2Input) << ", " << oend;
572  ostr << "md2Input = " << oend << INPUT(md2Input) << ", " << oend;
573  ostr << "mu2Input = " << oend << INPUT(mu2Input) << ", " << oend;
574  ostr << "me2Input = " << oend << INPUT(me2Input) << ", " << oend;
575  ostr << "MassBInput = " << INPUT(MassBInput) << ", " << oend;
576  ostr << "MassWBInput = " << INPUT(MassWBInput) << ", " << oend;
577  ostr << "MassGInput = " << INPUT(MassGInput) << ", " << oend;
578  ostr << "Aeij = " << oend << INPUT(Aeij) << ", " << oend;
579  ostr << "Adij = " << oend << INPUT(Adij) << ", " << oend;
580  ostr << "Auij = " << oend << INPUT(Auij) << ", " << oend;
581  #undef INPUT
582  #undef ostr
583  #undef oend
584  #endif
585  }
#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 593 of file SpecBit_MSSM.cpp.

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

Referenced by get_MSSM_spectrum_SPheno().

594  {
595  //double valued parameters
596  input.TanBeta = *Param.at("TanBeta");
597  input.M1Input = *Param.at("M1");
598  input.M2Input = *Param.at("M2");
599  input.M3Input = *Param.at("M3");
600 
601  // Sanity checks
602  if(input.TanBeta<0)
603  {
604  std::ostringstream msg;
605  msg << "Tried to set TanBeta parameter to a negative value ("<<input.TanBeta<<")! This parameter must be positive. Please check your inifile and try again.";
606  SpecBit_error().raise(LOCAL_INFO,msg.str());
607  }
608 
609  //3x3 matrices; filled with the help of a convenience function
610  input.mq2Input = fill_3x3_symmetric_parameter_matrix("mq2", Param);
611  input.ml2Input = fill_3x3_symmetric_parameter_matrix("ml2", Param);
612  input.md2Input = fill_3x3_symmetric_parameter_matrix("md2", Param);
613  input.mu2Input = fill_3x3_symmetric_parameter_matrix("mu2", Param);
614  input.me2Input = fill_3x3_symmetric_parameter_matrix("me2", Param);
615  input.AeInput = fill_3x3_parameter_matrix("Ae", Param);
616  input.AdInput= fill_3x3_parameter_matrix("Ad", Param);
617  input.AuInput = fill_3x3_parameter_matrix("Au", Param);
618 
619  #ifdef SPECBIT_DEBUG
620  #define INPUT(p) input.p
621  #define ostr std::cout
622  #define oend std::endl
623  ostr << "TanBeta = " << INPUT(TanBeta) << ", " << oend ;
624  ostr << "mq2Input = " << oend << INPUT(mq2Input) << ", " << oend;
625  ostr << "ml2Input = " << oend << INPUT(ml2Input) << ", " << oend;
626  ostr << "md2Input = " << oend << INPUT(md2Input) << ", " << oend;
627  ostr << "mu2Input = " << oend << INPUT(mu2Input) << ", " << oend;
628  ostr << "me2Input = " << oend << INPUT(me2Input) << ", " << oend;
629  ostr << "M1Input = " << INPUT(M1Input) << ", " << oend;
630  ostr << "M2Input = " << INPUT(M2Input) << ", " << oend;
631  ostr << "M3Input = " << INPUT(M3Input) << ", " << oend;
632  ostr << "AeInput = " << oend << INPUT(AeInput) << ", " << oend;
633  ostr << "AdInput = " << oend << INPUT(AdInput) << ", " << oend;
634  ostr << "AuInput = " << oend << INPUT(AuInput) << ", " << oend;
635  #undef INPUT
636  #undef ostr
637  #undef oend
638  #endif
639 
640  }
#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 198 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().

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

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

354  {
355  namespace myPipe = Pipes::find_min_lambda_MDM;
356  double high_energy_limit = myPipe::runOptions->getValueOrDef<double>(1.22e19,"set_high_scale");
357  int check_perturb_pts = myPipe::runOptions->getValueOrDef<double>(10,"check_perturb_pts");
358  static const SpectrumContents::MDM contents;
359  static const std::vector<SpectrumParameter> required_parameters = contents.all_parameters_with_tag(Par::dimensionless);
360  find_min_lambda_Helper(vs_tuple, *myPipe::Dep::MDM_spectrum, high_energy_limit, check_perturb_pts, required_parameters);
361  }
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:198
void find_min_lambda_MDM(dbl_dbl_bool &vs_tuple)
Definition: SpecBit_VS.cpp:353
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 333 of file SpecBit_VS.cpp.

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

334  {
336  double high_energy_limit = myPipe::runOptions->getValueOrDef<double>(1.22e19,"set_high_scale");
337  int check_perturb_pts = myPipe::runOptions->getValueOrDef<double>(10,"check_perturb_pts");
338  static const SpectrumContents::ScalarSingletDM_Z2 contents;
339  static const std::vector<SpectrumParameter> required_parameters = contents.all_parameters_with_tag(Par::dimensionless);
340  find_min_lambda_Helper(vs_tuple, *myPipe::Dep::ScalarSingletDM_Z2_spectrum, high_energy_limit, check_perturb_pts, required_parameters);
341  }
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:198
Spectrum Spectrum Spectrum ScalarSingletDM_Z2
void find_min_lambda_ScalarSingletDM_Z2(dbl_dbl_bool &vs_tuple)
Definition: SpecBit_VS.cpp:333
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 343 of file SpecBit_VS.cpp.

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

344  {
346  double high_energy_limit = myPipe::runOptions->getValueOrDef<double>(1.22e19,"set_high_scale");
347  int check_perturb_pts = myPipe::runOptions->getValueOrDef<double>(10,"check_perturb_pts");
348  static const SpectrumContents::ScalarSingletDM_Z2 contents;
349  static const std::vector<SpectrumParameter> required_parameters = contents.all_parameters_with_tag(Par::dimensionless);
350  find_min_lambda_Helper(vs_tuple, *myPipe::Dep::ScalarSingletDM_Z3_spectrum, high_energy_limit, check_perturb_pts, required_parameters);
351  }
void find_min_lambda_ScalarSingletDM_Z3(dbl_dbl_bool &vs_tuple)
Definition: SpecBit_VS.cpp:343
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:198
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum ScalarSingletDM_Z3_spectrum
Spectrum 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:270
std::chrono::milliseconds ms
virtual void raise(const std::string &)
Raise the exception, i.e. throw it. Exact override of base method.
Definition: exceptions.cpp:422
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. Exact override of base method.
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.
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)
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 367 of file SpecBit_VS.cpp.

References Gambit::dbl_dbl_bool::first.

368  {
369  namespace myPipe = Pipes::get_expected_vacuum_lifetime;
370  dbl_dbl_bool vs_tuple = *myPipe::Dep::high_scale_vacuum_info;
371 
372  if (vs_tuple.first<1e300)
373  {
374  lifetime=vs_tuple.first;
375  }
376  else
377  {
378  lifetime=1e300;
379  }
380  }
void get_expected_vacuum_lifetime(double &lifetime)
Definition: SpecBit_VS.cpp:367

◆ get_GUTMSSMB_spectrum()

void Gambit::SpecBit::get_GUTMSSMB_spectrum ( Spectrum )

Definition at line 1018 of file SpecBit_MSSM.cpp.

1019  {
1020  // Placeholder
1021  }

◆ get_invisibles()

std::vector<std::pair<str,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 1485 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().

1486  {
1487  // Get the lighter of the lightest neutralino and the lightest sneutrino
1488  std::pair<str,double> neutralino("~chi0_1", spec.get(Par::Pole_Mass,"~chi0",1));
1489  std::pair<str,double> sneutrino("~nu_1", spec.get(Par::Pole_Mass,"~nu",1));
1490  std::pair<str,double> lnp = (neutralino.second < sneutrino.second ? neutralino : sneutrino);
1491 
1492  // Work out if this is indeed the LSP, and if decays of at least one neutral higgs to it are kinematically possible.
1493  bool inv_lsp = spec.get(Par::Pole_Mass,"~chi+",1) > lnp.second and
1494  spec.get(Par::Pole_Mass,"~g") > lnp.second and
1495  spec.get(Par::Pole_Mass,"~d",1) > lnp.second and
1496  spec.get(Par::Pole_Mass,"~u",1) > lnp.second and
1497  spec.get(Par::Pole_Mass,"~e-",1) > lnp.second and
1498  (spec.get(Par::Pole_Mass,"h0",2) > 2.*lnp.second or
1499  spec.get(Par::Pole_Mass,"A0") > 2.*lnp.second);
1500 
1501  // Create a vector containing all invisible products of higgs decays.
1502  if (inv_lsp) return initVector<std::pair<str,str>>(std::make_pair(lnp.first,lnp.first));
1503  return std::vector<std::pair<str,str>>();
1504  }
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 405 of file SpecBit_VS.cpp.

References Gambit::dbl_dbl_bool::second.

406  {
407  namespace myPipe = Pipes::get_lambdaB;
408  dbl_dbl_bool vs_tuple = *myPipe::Dep::high_scale_vacuum_info;
409  result=vs_tuple.second;
410  }
void get_lambdaB(double &result)
Definition: SpecBit_VS.cpp:405

◆ get_likelihood_VS()

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

Vacuum stability likelihood from a Vevacious run calculating the lifetime of & tunneling probability to the vacuua.

Definition at line 437 of file SpecBit_VS.cpp.

References compare_panic_vacua(), Gambit::LogTags::debug, Gambit::EOM, Gambit::SpecBit::VevaciousResultContainer::get_thermalWidth(), Gambit::SpecBit::VevaciousResultContainer::get_width(), Gambit::hbar, and Gambit::logger().

438  {
439  using namespace Pipes::get_likelihood_VS;
440 
441  // Compute all vacuum stability results
442  VevaciousResultContainer vevacious_results = *Dep::check_vacuum_stability;
443 
444  // Add the decay width for global and nearest vacua
445  double width = 0.0;
446  for(auto vacua : *Dep::compare_panic_vacua)
447  {
448  if (vacua.second != "JustThermal")
449  {
450  logger() << LogTags::debug << "Adding " << vevacious_results.get_width(vacua.first) << " to decay withd for " << vacua.second << " contribution" << EOM;
451  width += vevacious_results.get_width(vacua.first);
452  }
453  if (vacua.second != "JustQuantum")
454  {
455  logger() << LogTags::debug << "Adding " << vevacious_results.get_thermalWidth(vacua.first) << " to decay withd for " << vacua.second << " contribution" << EOM;
456  width += vevacious_results.get_thermalWidth(vacua.first);
457  }
458  }
459 
460  double lifetime = hbar/width;
461 
462  // This is based on the estimation of the past lightcone from 1806.11281
463  double conversion = (6.5821195e-25)/(31536000);
464  result= - 1 / ( lifetime/conversion ) * exp(140) * (1/1.2e19) ;
465  }
const double hbar
void get_likelihood_VS(double &result)
Vacuum stability likelihood from a Vevacious run calculating the lifetime of & tunneling probability ...
Definition: SpecBit_VS.cpp:437
const Logging::endofmessage EOM
Explicit const instance of the end of message struct in Gambit namespace.
Definition: logger.hpp:100
EXPORT_SYMBOLS Logging::LogMaster & logger()
Function to retrieve a reference to the Gambit global log object.
Definition: logger.cpp:95
void compare_panic_vacua(map_str_str &result)
If tunnelling to global and nearest vacuum are requested, this capability compares if the two vacua a...
Here is the call graph for this function:

◆ 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. Exact override of base method.
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.
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
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  }
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 1781 of file SpecBit_MSSM.cpp.

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

1782  {
1783  namespace myPipe = Pipes::get_MSSM_spectrum_as_map;
1784  const Spectrum& mssmspec(*myPipe::Dep::MSSM_spectrum);
1785  try
1786  {
1787  fill_map_from_subspectrum<SpectrumContents::SM> (specmap, mssmspec.get_LE());
1788  }
1789  catch(const Gambit::exception&)
1790  {
1791  // The above will fail for the SimpleSpectrum versions of the MSSM spectrum
1792  // because it uses SM_slha rather than SM for the LE subspectrum
1793  // TODO: Would be better to do this in a more elegant way than with exception
1794  // handling
1795  fill_map_from_subspectrum<SpectrumContents::SM_slha> (specmap, mssmspec.get_LE());
1796  }
1797  fill_map_from_subspectrum<SpectrumContents::MSSM>(specmap, mssmspec.get_HE());
1798  add_extra_MSSM_parameter_combinations(specmap, mssmspec.get_HE());
1799  }
void add_extra_MSSM_parameter_combinations(std::map< std::string, double > &specmap, const SubSpectrum &mssm)
Adds additional information from interesting combinations of MSSM parameters.
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 1037 of file SpecBit_MSSM.cpp.

References unimproved_MSSM_spectrum.

1038  {
1040  }

◆ 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 1043 of file SpecBit_MSSM.cpp.

References unimproved_MSSM_spectrum.

1044  {
1046  }

◆ get_MSSM_spectrum_from_postprocessor()

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

Get pre-computed MSSM spectrum from previous output file This function ONLY works when the scan is driven by the postprocessor! This is because it relies on the global reader object created by the postprocessor to retrieve output.

Definition at line 1167 of file SpecBit_MSSM.cpp.

References Gambit::get_pp_reader(), Gambit::invalid_point(), Gambit::invalid_point_exception::raise(), Gambit::Printers::BaseReader::retrieve(), Gambit::SLHAea_add(), SMINPUTS, and Spectrum.

1168  {
1170  const SMInputs& sminputs = *myPipe::Dep::SMINPUTS; // Retrieve dependency on SLHAstruct
1171 
1172  // Retrieve the spectrum from whatever the point the global reader object is pointed at.
1173  // This should be the same point that the postprocessor has retrieved the
1174  // current set of ModelParameters from.
1175  // Will throw an error if no reader object exists, i.e. if the postprocessor is not
1176  // driving this scan.
1177 
1178  // Retrieve MSSM spectrum info into an SLHAea object
1179  MSSM_SLHAstruct mssm_in; // Special type to trigger specialised MSSM retrieve routine
1180  bool mssm_is_valid = get_pp_reader().retrieve(mssm_in,"MSSM_spectrum");
1181 
1182  // Retrieve SM spectrum info into an SLHAea object
1183  // (should really match SMINPUTS, but better to use what is actually in the reported output spectrum)
1184  SMslha_SLHAstruct sm_in;
1185  bool sm_is_valid = get_pp_reader().retrieve(sm_in,"MSSM_spectrum");
1186 
1187  // Check if a valid spectrum was retrived
1188  // (if the required datasets don't exist an error will be thrown,
1189  // so this is just checking that the spectrum was computed for
1190  // the current input point)
1191  if(not (mssm_is_valid and sm_is_valid)) invalid_point().raise("Postprocessor: precomputed spectrum was set 'invalid' for this point");
1192 
1193  // Dump spectrum to output for testing
1194  SLHAstruct mssm = mssm_in; // Only this type has stream overloads etc. defined
1195  SLHAstruct sm = sm_in;
1196 
1197  // Turns out we don't generically save tan_beta(mZ)_DRbar, so need to extract
1198  // this from model parameters (it is always an input, so we should have it in those)
1199  double tbmZ = *myPipe::Param.at("TanBeta");
1200  SLHAea_add(mssm, "MINPAR", 3, tbmZ, "tan beta (mZ)_DRbar");
1201  SLHAea_add(sm, "MINPAR", 3, tbmZ, "tan beta (mZ)_DRbar");
1202 
1203  // Retrieve any mass cuts (could just cut with postprocessor, but I
1204  // guess can leave this feature in for compatibility with usage
1205  // of other Spectrum objects.
1206  static const Spectrum::mc_info mass_cut = myPipe::runOptions->getValueOrDef<Spectrum::mc_info>(Spectrum::mc_info(), "mass_cut");
1207  static const Spectrum::mr_info mass_ratio_cut = myPipe::runOptions->getValueOrDef<Spectrum::mr_info>(Spectrum::mr_info(), "mass_ratio_cut");
1208 
1209  // Create HE simple SubSpectrum object from the SLHAea object
1210  MSSMSimpleSpec he(mssm);
1211 
1212  // Create SMSimpleSpec SubSpectrum object from SMInputs
1213  SMSimpleSpec le(sm);
1214 
1215  // Create full Spectrum object
1216  result = Spectrum(le,he,sminputs,NULL,mass_cut,mass_ratio_cut);
1217  }
void get_MSSM_spectrum_from_postprocessor(Spectrum &result)
Get pre-computed MSSM spectrum from previous output file This function ONLY works when the scan is dr...
void SLHAea_add(SLHAstruct &slha, const str &block, const int index, const double value, const str &comment="", const bool overwrite=false)
Add an entry to an SLHAea object (if overwrite=false, only if it doesn&#39;t already exist) ...
Printers::BaseReader & get_pp_reader()
SLHAea::Coll SLHAstruct
Less confusing name for SLHAea container class.
virtual void raise(const std::string &)
Raise the exception, i.e. throw it. Exact override of base method.
Definition: exceptions.cpp:422
bool retrieve(T &out, const std::string &label)
Reimplement overload for &#39;retrieve&#39; that uses the current point as the input for rank/pointID.
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_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 1052 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().

1053  {
1054  // Static counter running in a loop over all filenames
1055  static unsigned int counter = 0;
1056  static long int ncycle = 1;
1057  SLHAstruct input_slha;
1058 
1059  namespace myPipe = Pipes::get_MSSM_spectrum_from_SLHAfile;
1060 
1061  // Read filename from yaml file
1062  std::vector<std::string> filenames =
1063  myPipe::runOptions->getValue<std::vector<std::string>>("filenames");
1064 
1065  // Check how many loop over the input files we are doing.
1066  long int cycles = myPipe::runOptions->getValueOrDef<int>(-1,"cycles");
1067 
1068  // Check if we have completed the requested number of cycles
1069  if(cycles>0 and ncycle>cycles)
1070  {
1071  std::ostringstream msg;
1072  msg << "Preset number of loops through input files reached! Stopping. (tried to start cycle "<<ncycle<<" of "<<cycles<<")";
1073  SpecBit_error().raise(LOCAL_INFO,msg.str());
1074  }
1075 
1076  std::string filename = filenames[counter];
1077 
1078  logger() << "Reading SLHA file: " << filename << EOM;
1079  std::ifstream ifs(filename.c_str());
1080  if(!ifs.good()){ SpecBit_error().raise(LOCAL_INFO,"ERROR: SLHA file not found."); }
1081  ifs >> input_slha;
1082  ifs.close();
1083  counter++;
1084  if( counter >= filenames.size() )
1085  {
1086  logger() << "Returning to start of input SLHA file list (finished "<<ncycle<<" cycles)" << EOM;
1087  counter = 0;
1088  ncycle++;
1089  }
1090 
1091  // Retrieve any mass cuts
1092  static const Spectrum::mc_info mass_cut = myPipe::runOptions->getValueOrDef<Spectrum::mc_info>(Spectrum::mc_info(), "mass_cut");
1093  static const Spectrum::mr_info mass_ratio_cut = myPipe::runOptions->getValueOrDef<Spectrum::mr_info>(Spectrum::mr_info(), "mass_ratio_cut");
1094 
1095  // Create Spectrum object from the slhaea object
1096  result = spectrum_from_SLHAea<MSSMSimpleSpec, SLHAstruct>(input_slha, input_slha, mass_cut, mass_ratio_cut);
1097 
1098  // Add getter for susy scale if option set for this
1099  bool add_susy_scale = myPipe::runOptions->getValueOrDef<bool>(false,"assume_Q_is_MSUSY");
1100  if(add_susy_scale)
1101  {
1102  result.get_HE().set_override(Par::mass1,result.get_HE().GetScale(),"susy_scale",true);
1103  }
1104 
1105  // No sneaking in charged LSPs via SLHA, jävlar.
1106  if (not has_neutralino_LSP(result)) invalid_point().raise("Neutralino is not LSP.");
1107  }
#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. Exact override of base method.
Definition: exceptions.cpp:422
bool has_neutralino_LSP(const Spectrum &result)
Check that the spectrum has a neutralino LSP.
Definition: SpecBit.cpp:75
const Logging::endofmessage EOM
Explicit const instance of the end of message struct in Gambit namespace.
Definition: logger.hpp:100
EXPORT_SYMBOLS Logging::LogMaster & logger()
Function to retrieve a reference to the Gambit global log object.
Definition: logger.cpp:95
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.
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 1112 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.

1113  {
1114  namespace myPipe = Pipes::get_MSSM_spectrum_from_SLHAstruct;
1115  const SLHAstruct& input_slha_tmp = *myPipe::Dep::unimproved_MSSM_spectrum; // Retrieve dependency on SLHAstruct
1116 
1118  SLHAstruct input_slha(input_slha_tmp); // Copy struct (for demo adding of GAMBIT block only)
1119  // For example; add this to your input SLHAstruct:
1120  input_slha["GAMBIT"][""] << "BLOCK" << "GAMBIT";
1121  input_slha["GAMBIT"][""] << 1 << 1e99 << "# Input scale";
1122 
1123  // Retrieve any mass cuts
1124  static const Spectrum::mc_info mass_cut = myPipe::runOptions->getValueOrDef<Spectrum::mc_info>(Spectrum::mc_info(), "mass_cut");
1125  static const Spectrum::mr_info mass_ratio_cut = myPipe::runOptions->getValueOrDef<Spectrum::mr_info>(Spectrum::mr_info(), "mass_ratio_cut");
1126 
1127  // Create Spectrum object from the slhaea object
1128  result = spectrum_from_SLHAea<MSSMSimpleSpec, SLHAstruct>(input_slha, input_slha, mass_cut, mass_ratio_cut);
1129 
1130  // No sneaking in charged LSPs via SLHA, jävlar.
1131  if (not has_neutralino_LSP(result)) invalid_point().raise("Neutralino is not LSP.");
1132 
1133  // In order to translate from e.g. MSSM63atMGUT to MSSM63atQ, we need
1134  // to know that input scale Q. This is generally not stored in SLHA format,
1135  // but we need it, so if you want to produce a Spectrum object this way you
1136  // will need to add this information to your SLHAstruct:
1137  // BLOCK GAMBIT
1138  // 1 <high_scale> # Input scale of (upper) boundary conditions, e.g. GUT scale
1139 
1140  // Need to check if this information exists:
1141  SLHAstruct::const_iterator block = input_slha.find("GAMBIT");
1142  std::vector<std::string> key(1, "1");
1143  if(block == input_slha.end() or block->find(key) == block->end())
1144  {
1145  // Big problem
1146  std::ostringstream errmsg;
1147  errmsg << "Error constructing Spectrum object from a pre-existing SLHAstruct! " << endl
1148  << "The supplied SLHAstruct did not have the special GAMBIT block added. " << endl
1149  << "This block carries extra information from the spectrum generator " << endl
1150  << "that is usually thrown away, but which is needed for properly creating" << endl
1151  << "a Spectrum object. In whatever module function created the SLHAstruct " << endl
1152  << "that you want to use, please add code that adds the following " << endl
1153  << "information to the SLHAstruct (SLHAea::Coll): " << endl
1154  << " BLOCK GAMBIT " << endl
1155  << " 1 <high_scale> # Input scale of (upper) boundary conditions, e.g. GUT scale\n";
1156  SpecBit_error().raise(LOCAL_INFO,errmsg.str());
1157  }
1158 
1159  // OK the GAMBIT block exists, add the data to the MSSM SubSpectrum object.
1160  result.get_HE().set_override(Par::mass1,SLHAea::to<double>(input_slha.at("GAMBIT").at(1).at(1)), "high_scale", false);
1161  }
#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. Exact override of base method.
Definition: exceptions.cpp:422
bool has_neutralino_LSP(const Spectrum &result)
Check that the spectrum has a neutralino LSP.
Definition: SpecBit.cpp:75
invalid_point_exception & invalid_point()
Invalid point exceptions.
Here is the call graph for this function:

◆ get_MSSM_spectrum_SPheno()

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

Definition at line 656 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().

657  {
658  namespace myPipe = Pipes::get_MSSM_spectrum_SPheno;
659  const SMInputs &sminputs = *myPipe::Dep::SMINPUTS;
660 
661  // Set up the input structure
662  Finputs inputs;
663  inputs.sminputs = sminputs;
664  inputs.param = myPipe::Param;
665  inputs.options = myPipe::runOptions;
666 
667  // Retrieve any mass cuts
668  static const Spectrum::mc_info mass_cut = myPipe::runOptions->getValueOrDef<Spectrum::mc_info>(Spectrum::mc_info(), "mass_cut");
669  static const Spectrum::mr_info mass_ratio_cut = myPipe::runOptions->getValueOrDef<Spectrum::mr_info>(Spectrum::mr_info(), "mass_ratio_cut");
670 
671  // Get the spectrum from the Backend
672  myPipe::BEreq::SPheno_MSSMspectrum(spectrum, inputs);
673 
674  // Only allow neutralino LSPs.
675  if (not has_neutralino_LSP(spectrum)) invalid_point().raise("Neutralino is not LSP.");
676 
677  // Drop SLHA files if requested
678  spectrum.drop_SLHAs_if_requested(myPipe::runOptions, "GAMBIT_unimproved_spectrum");
679 
680  }
virtual void raise(const std::string &)
Raise the exception, i.e. throw it. Exact override of base method.
Definition: exceptions.cpp:422
bool has_neutralino_LSP(const Spectrum &result)
Check that the spectrum has a neutralino LSP.
Definition: SpecBit.cpp:75
invalid_point_exception & invalid_point()
Invalid point exceptions.
Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum Spectrum SMINPUTS
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:51
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
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 653 of file SpecBit_ScalarSingletDM.cpp.

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

654  {
657  static const SpectrumContents::ScalarSingletDM_Z2 contents;
658  static const std::vector<SpectrumParameter> required_parameters = contents.all_parameters();
659  fill_map_from_ScalarSingletDM_spectrum(specmap, spec, required_parameters);
660  }
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)
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
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 662 of file SpecBit_ScalarSingletDM.cpp.

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

663  {
666  static const SpectrumContents::ScalarSingletDM_Z3 contents;
667  static const std::vector<SpectrumParameter> required_parameters = contents.all_parameters();
668  fill_map_from_ScalarSingletDM_spectrum(specmap, spec, required_parameters);
669  }
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
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:51
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 1029 of file SpecBit_MSSM.cpp.

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

1030  {
1032  const Spectrum& matched_spectra(*myPipe::Dep::unimproved_MSSM_spectrum);
1033  result = &matched_spectra.get_LE();
1034  }
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 110 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().

111  {
112  namespace myPipe = Pipes::get_SMINPUTS;
113  SMInputs sminputs;
114 
115  // Get values from Params pipe
116  // (as defined in SLHA2)
117  if(myPipe::ModelInUse("StandardModel_SLHA2"))
118  {
119  sminputs.alphainv = *myPipe::Param["alphainv"];
120  sminputs.GF = *myPipe::Param["GF" ];
121  sminputs.alphaS = *myPipe::Param["alphaS" ];
122 
123  sminputs.mZ = *myPipe::Param["mZ" ];
124 
125  sminputs.mE = *myPipe::Param["mE" ];
126  sminputs.mMu = *myPipe::Param["mMu" ];
127  sminputs.mTau = *myPipe::Param["mTau" ];
128 
129  sminputs.mNu1 = *myPipe::Param["mNu1" ];
130  sminputs.mNu2 = *myPipe::Param["mNu2" ];
131  sminputs.mNu3 = *myPipe::Param["mNu3" ];
132 
133  sminputs.mD = *myPipe::Param["mD" ];
134  sminputs.mU = *myPipe::Param["mU" ];
135  sminputs.mS = *myPipe::Param["mS" ];
136  sminputs.mCmC = *myPipe::Param["mCmC" ];
137  sminputs.mBmB = *myPipe::Param["mBmB" ];
138  sminputs.mT = *myPipe::Param["mT" ];
139 
140  sminputs.mNu1 = *myPipe::Param["mNu1" ];
141  sminputs.mNu2 = *myPipe::Param["mNu2" ];
142  sminputs.mNu3 = *myPipe::Param["mNu3" ];
143 
144  // CKM
145  sminputs.CKM.lambda = *myPipe::Param["CKM_lambda" ];
146  sminputs.CKM.A = *myPipe::Param["CKM_A" ];
147  sminputs.CKM.rhobar = *myPipe::Param["CKM_rhobar" ];
148  sminputs.CKM.etabar = *myPipe::Param["CKM_etabar" ];
149 
150  // PMNS
151  sminputs.PMNS.theta12 = *myPipe::Param["theta12"];
152  sminputs.PMNS.theta23 = *myPipe::Param["theta23"];
153  sminputs.PMNS.theta13 = *myPipe::Param["theta13"];
154  sminputs.PMNS.delta13 = *myPipe::Param["delta13"];
155  sminputs.PMNS.alpha1 = *myPipe::Param["alpha1"];
156  sminputs.PMNS.alpha2 = *myPipe::Param["alpha2"];
157 
158  // W mass. Stick with the observed value (set in the default constructor) unless instructed otherwise.
159  if (myPipe::runOptions->getValueOrDef<bool>(false,"enforce_tree_level_MW"))
160  {
161  // Calculate MW from alpha, mZ and G_F, assuming the tree-level relation.
162  const double pionroot2 = pi * pow(2,-0.5);
163  double cosW2 = 0.5 + pow(0.25 - pionroot2 / (sminputs.alphainv * sminputs.GF * pow(sminputs.mZ,2.0)), 0.5);
164  sminputs.mW = sminputs.mZ * pow(cosW2,0.5);
165  }
166 
167  }
168  else
169  {
170  std::ostringstream errmsg;
171  errmsg << "Error mapping Standard Model parameters to SMINPUTS capabilities!";
172  errmsg << "Perhaps you have added a new model to the ALLOWED_MODELS of this ";
173  errmsg << "module function but have not added a corresponding case in the ";
174  errmsg << "function source (here)." << std::endl;
175  SpecBit_error().raise(LOCAL_INFO,errmsg.str());
176  }
177  // Return filled struct
178  result = sminputs;
179  }