namespace Gambit::SpecBit #

[No description available]

Classes #

Types #

Functions #

Types Documentation #

typedef vec_pair_int_dbl #

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

typedef SpectrumEntry #

typedef struct SpectrumEntry Gambit::SpecBit::SpectrumEntry;

typedef map_str_SpectrumEntry #

typedef std::map<std::string,SpectrumEntry> Gambit::SpecBit::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

Functions Documentation #

function setup_QedQcd #

void setup_QedQcd(
    softsusy::QedQcd & oneset,
    const SMInputs & sminputs
)

Non-Gambit helper functions.

Initialise QedQcd object from SMInputs data

set running quark masses

set QED and QCD structure constants

NOTE! These assume the input electron and muon pole masses are “close enough” to MSbar masses at MZ. The object does the same with its default values so I guess it is ok.

set running quark masses

set QED and QCD structure constants

NOTE! These assume the input electron and muon pole masses are “close enough” to MSbar masses at MZ. The object does the same with its default values so I guess it is ok.

function has_neutralino_LSP #

bool has_neutralino_LSP(
    const Spectrum & result
)

Check that the spectrum has a neutralino LSP.

function has_neutralino_LSP #

bool has_neutralino_LSP(
    const Spectrum * result
)

Helper to work with pointer.

function get_SMINPUTS #

void get_SMINPUTS(
    SMInputs & result
)

Gambit module functions.

Set SMINPUTS (SLHA2) struct to match StandardModel_SLHA2 parameters.

function check_LSP #

void check_LSP(
    const Spectrum & spec,
    const Options & runOptions,
    bool gravitino_is_canonical_LSP
)

Non-Gambit convenience functions.

Check that the spectrum has the canonical LSP for the model being scanned.

function check_LSP #

void check_LSP(
    const Spectrum * spec,
    const Options & runOptions,
    bool gravitino_model
)

Helper to work with pointer.

function get_light_gravitino_mass #

double get_light_gravitino_mass(
    const std::map< str, safe_ptr< const double > > & Param,
    const Options & runOptions
)

Check that the gravitino is actually light, and retrieve its mass.

function add_gravitino_mass #

void add_gravitino_mass(
    Spectrum & spec,
    const std::map< str, safe_ptr< const double > > & Param,
    const Options & runOptions
)

Add the gravitino mass if it is present (spectrum object version)

function add_gravitino_mass #

void add_gravitino_mass(
    SLHAstruct & slha,
    const std::map< str, safe_ptr< const double > > & Param,
    const Options & runOptions
)

Add the gravitino mass if it is present (SLHAea version)

function add_gravitino_mass_from_slhaea #

void add_gravitino_mass_from_slhaea(
    Spectrum & spec,
    const SLHAstruct & input_slha
)

Add the gravitino mass to a spectrum object if it is present in an SLHAea object.

function run_FS_spectrum_generator #

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,
    bool gravitino_model
)

Compute an MSSM spectrum using flexiblesusy.

TODO: Need to tell gambit that the spectrum is not viable somehow. For now just die.

Check what the problem was see: contrib/MassSpectra/flexiblesusy/src/problems.hpp

Fast way for now:

function fill_3x3_parameter_matrix #

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.

function fill_3x3_symmetric_parameter_matrix #

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)

function fill_MSSM63_input #

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

function fill_MSSM63_input_altnames #

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

function convert_MSSM_to_SM #

void convert_MSSM_to_SM(
    Spectrum & result
)

Gambit module functions.

function convert_NMSSM_to_SM #

void convert_NMSSM_to_SM(
    Spectrum & result
)

function convert_E6MSSM_to_SM #

void convert_E6MSSM_to_SM(
    Spectrum & result
)

function get_MSSM_spectrum_SPheno #

void get_MSSM_spectrum_SPheno(
    Spectrum & spectrum
)

function get_GUTMSSMB_spectrum #

void get_GUTMSSMB_spectrum(
    Spectrum & 
)

function fill_map_from_subspectrum #

template <class Contents >
void 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.

function add_extra_MSSM_parameter_combinations #

void 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

function get_MSSM_spectrum_as_map #

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

function get_unimproved_MSSM_spectrum_as_map #

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

function add_error #

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

function exampleRead #

void 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:

function make_test_spectrum #

void make_test_spectrum(
    SubSpectrum *& result
)

Create a spectrum object for testing purposes.

function specbit_test_func1 #

void specbit_test_func1(
    double & result
)

Function to test out SpecBit features.

function specbit_test_func2 #

void specbit_test_func2(
    double & result
)

Function to test out SpecBit features.

function specbit_test_func3 #

void specbit_test_func3(
    double & result
)

Function to test out SpecBit features.

function specbit_test_Spectrum #

void specbit_test_Spectrum(
    double & result
)

Test out consistency of Spectrum object (and pre-extracted SM SubSpectrum*)

function specbit_test_show_SMInputs #

void specbit_test_show_SMInputs(
    double & result
)

Display SMInputs values.

function test_Singlet_spectrum #

void test_Singlet_spectrum(
    bool & result
)

Check that the SingletDM spectrum object is working.

function get_sinthW2_MSbar #

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

function get_tanbeta #

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

function get_DRbar_mA2 #

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

function get_sinthW2_DRbar #

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

function get_MAh1_pole_slha #

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

function get_MHpm1_pole_slha #

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

function get_neutral_goldstone_pole_slha #

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

function get_charged_goldstone_pole_slha #

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

function set_MSu_pole_slha #

template <class Model >
void set_MSu_pole_slha(
    Model & model,
    double mass,
    int i
)

function set_MSd_pole_slha #

template <class Model >
void set_MSd_pole_slha(
    Model & model,
    double mass,
    int i
)

function set_MSe_pole_slha #

template <class Model >
void set_MSe_pole_slha(
    Model & model,
    double mass,
    int i
)

function set_MSv_pole_slha #

template <class Model >
void set_MSv_pole_slha(
    Model & model,
    double mass,
    int i
)

function set_MCha_pole_slha #

template <class Model >
void set_MCha_pole_slha(
    Model & model,
    double mass,
    int i
)

function set_MChi_pole_slha #

template <class Model >
void set_MChi_pole_slha(
    Model & model,
    double mass,
    int i
)

function set_Mhh_pole_slha #

template <class Model >
void set_Mhh_pole_slha(
    Model & model,
    double mass,
    int i
)

function set_ZD_pole_slha #

template <class Model >
void set_ZD_pole_slha(
    Model & model,
    double mass,
    int i,
    int j
)

function set_ZU_pole_slha #

template <class Model >
void set_ZU_pole_slha(
    Model & model,
    double mass,
    int i,
    int j
)

function set_ZE_pole_slha #

template <class Model >
void set_ZE_pole_slha(
    Model & model,
    double mass,
    int i,
    int j
)

function set_ZV_pole_slha #

template <class Model >
void set_ZV_pole_slha(
    Model & model,
    double mass,
    int i,
    int j
)

function set_ZH_pole_slha #

template <class Model >
void set_ZH_pole_slha(
    Model & model,
    double mass,
    int i,
    int j
)

function set_ZA_pole_slha #

template <class Model >
void set_ZA_pole_slha(
    Model & model,
    double mass,
    int i,
    int j
)

function set_ZP_pole_slha #

template <class Model >
void set_ZP_pole_slha(
    Model & model,
    double mass,
    int i,
    int j
)

function set_ZN_pole_slha #

template <class Model >
void set_ZN_pole_slha(
    Model & model,
    double mass,
    int i,
    int j
)

function set_UM_pole_slha #

template <class Model >
void set_UM_pole_slha(
    Model & model,
    double mass,
    int i,
    int j
)

function set_UP_pole_slha #

template <class Model >
void set_UP_pole_slha(
    Model & model,
    double mass,
    int i,
    int j
)

function set_MAh1_pole_slha #

template <class Model >
void set_MAh1_pole_slha(
    Model & model,
    double mass
)

function set_MHpm1_pole_slha #

template <class Model >
void set_MHpm1_pole_slha(
    Model & model,
    double mass
)

function set_neutral_goldstone_pole_slha #

template <class Model >
void set_neutral_goldstone_pole_slha(
    Model & model,
    double mass
)

function set_charged_goldstone_pole_slha #

template <class Model >
void set_charged_goldstone_pole_slha(
    Model & model,
    double mass
)

function set_MGluino_pole_slha #

template <class Model >
void set_MGluino_pole_slha(
    Model & model,
    double mass
)

function set_MZ_pole_slha #

template <class Model >
void set_MZ_pole_slha(
    Model & model,
    double mass
)

function set_MW_pole_slha #

template <class Model >
void set_MW_pole_slha(
    Model & model,
    double mass
)

function get_sinthW2_MSbar2 #

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

function set_Mhh_pole_slha #

template <class Model >
void set_Mhh_pole_slha(
    Model & model,
    double mass
)

function set_Mss_pole_slha #

template <class Model >
void set_Mss_pole_slha(
    Model & model,
    double mass
)

function print_error #

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
)

function print_error #

void print_error(
    std::string get_type,
    std::string name,
    double sting_get_out,
    double data_member,
    int i =-1,
    int j =-1
)

function test_getters #

bool test_getters(
    std::string get_type,
    std::string name,
    double getter_output,
    double data_member,
    int i =-1,
    int j =-1
)

function TestMssmParMass2_0 #

template <class M >
bool TestMssmParMass2_0(
    SubSpectrum * spec,
    M FSmssm,
    bool immediate_exit =true
)

Module convenience functions.

function TestMssmParMass2_0 #

template <class MI >
bool TestMssmParMass2_0(
    MSSMSpec< MI > & mssm,
    typename MI::Model & FSmssm,
    bool immediate_exit =true
)

function TestMssmParMass2_2 #

template <class M >
bool TestMssmParMass2_2(
    SubSpectrum * spec,
    M FSmssm,
    bool immediate_exit =true
)

function TestMssmParMass2_2 #

template <class MI >
bool TestMssmParMass2_2(
    MSSMSpec< MI > & mssm,
    typename MI::Model & FSmssm,
    bool immediate_exit =true
)

function TestMssmParMass1_0 #

template <class M >
bool TestMssmParMass1_0(
    SubSpectrum * spec,
    M FSmssm,
    bool immediate_exit =true
)

function TestMssmParMass1_0 #

template <class MI >
bool TestMssmParMass1_0(
    MSSMSpec< MI > & mssm,
    typename MI::Model & FSmssm,
    bool immediate_exit =true
)

function TestMssmParMass1_2 #

template <class M >
bool TestMssmParMass1_2(
    SubSpectrum * spec,
    M FSmssm,
    bool immediate_exit =true
)

function TestMssmParMass1_2 #

template <class MI >
bool TestMssmParMass1_2(
    MSSMSpec< MI > & mssm,
    typename MI::Model & FSmssm,
    bool immediate_exit =true
)

function TestMssmParMass0_0 #

template <class M >
bool TestMssmParMass0_0(
    SubSpectrum * spec,
    M FSmssm,
    bool immediate_exit =true
)

function TestMssmParMass0_0 #

template <class MI >
bool TestMssmParMass0_0(
    MSSMSpec< MI > & mssm,
    typename MI::Model & FSmssm,
    bool immediate_exit =true
)

function TestMssmParMass0_2 #

template <class M >
bool TestMssmParMass0_2(
    SubSpectrum * spec,
    M FSmssm,
    bool immediate_exit =true
)

function TestMssmParMass0_2 #

template <class MI >
bool TestMssmParMass0_2(
    MSSMSpec< MI > & mssm,
    typename MI::Model & FSmssm,
    bool immediate_exit =true
)

function TestMssmPoleGets0 #

template <class M >
bool TestMssmPoleGets0(
    SubSpectrum * spec,
    M FSmssm,
    bool immediate_exit =true
)

function TestMssmPoleGets0 #

template <class MI >
bool TestMssmPoleGets0(
    MSSMSpec< MI > & mssm,
    typename MI::Model & FSmssm,
    bool immediate_exit =true
)

function TestMssmPoleGets1 #

template <class M >
bool TestMssmPoleGets1(
    SubSpectrum * spec,
    M FSmssm,
    bool immediate_exit =true
)

function TestMssmPoleGets1 #

template <class MI >
bool TestMssmPoleGets1(
    MSSMSpec< MI > & mssm,
    typename MI::Model & FSmssm,
    bool immediate_exit =true
)

function TestMssmPoleMixingGets2 #

template <class M >
bool TestMssmPoleMixingGets2(
    SubSpectrum * spec,
    M FSmssm,
    bool immediate_exit =true
)

function TestMssmPoleMixingGets2 #

template <class MI >
bool TestMssmPoleMixingGets2(
    MSSMSpec< MI > & mssm,
    typename MI::Model & FSmssm,
    bool immediate_exit =true
)

function TestMssmPoleGets #

template <class M >
bool TestMssmPoleGets(
    SubSpectrum * spec,
    M FSmssm
)

function TestMssmPoleGets #

template <class MI >
bool TestMssmPoleGets(
    MSSMSpec< MI > & mssm,
    typename MI::Model & FSmssm
)

function TestMssmParGets #

template <class M >
bool TestMssmParGets(
    SubSpectrum * spec,
    M FSmssm
)

function TestMssmParGets #

template <class MI >
bool TestMssmParGets(
    MSSMSpec< MI > & mssm,
    typename MI::Model & FSmssm
)

function setup #

template <class Model >
void setup(
    Model & mssm
)

function test_exact #

template <class MI >
bool test_exact(
    MSSMSpec< MI > & mssm,
    typename MI::Model & FS_model_slha
)

function test_exact #

template <class M >
double test_exact(
    SubSpectrum * spec,
    M FS_model_slha
)

function running_test #

template <class MI >
bool running_test(
    MSSMSpec< MI > & mssm,
    typename MI::Model & FS_model_slha,
    double tol
)

function running_test #

template <class Model >
bool running_test(
    SubSpectrum * spec,
    Model & FS_model_slha,
    double tol
)

function test_within_tol #

bool test_within_tol(
    double a,
    double b,
    double tol,
    std::string label
)

function Spectrum_test #

void Spectrum_test(
    Spectrum matched_spectra,
    const SubSpectrum * smin,
    bool SLHAonly =0
)

Generate data for a plot of quark mass

Testing copyability of Spectrum;

function get_mUp #

double get_mUp(
    const softsusy::QedQcd & model
)

Plain C-function wrappers for QedQcd running mass getters.

function get_mCharm #

double get_mCharm(
    const softsusy::QedQcd & model
)

function get_mTop #

double get_mTop(
    const softsusy::QedQcd & model
)

function get_mDown #

double get_mDown(
    const softsusy::QedQcd & model
)

function get_mStrange #

double get_mStrange(
    const softsusy::QedQcd & model
)

function get_mBottom #

double get_mBottom(
    const softsusy::QedQcd & model
)

function get_mElectron #

double get_mElectron(
    const softsusy::QedQcd & model
)

function get_mMuon #

double get_mMuon(
    const softsusy::QedQcd & model
)

function get_mTau #

double get_mTau(
    const softsusy::QedQcd & model
)

function get_mPhoton #

double get_mPhoton(
    const softsusy::QedQcd & 
)

function get_mGluon #

double get_mGluon(
    const softsusy::QedQcd & 
)

function get_alpha #

double get_alpha(
    const softsusy::QedQcd & model
)

Plain C-function wrappers for QedQcd running coupling getters.

function get_alphaS #

double get_alphaS(
    const softsusy::QedQcd & model
)

function get_a1 #

double 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.

function get_Pole_mElectron #

double get_Pole_mElectron(
    const SMInputs & inputs
)

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

function get_Pole_mMuon #

double get_Pole_mMuon(
    const SMInputs & inputs
)

function get_Pole_mNu1 #

double get_Pole_mNu1(
    const SMInputs & inputs
)

function get_Pole_mNu2 #

double get_Pole_mNu2(
    const SMInputs & inputs
)

function get_Pole_mNu3 #

double get_Pole_mNu3(
    const SMInputs & inputs
)

function get_Pole_mPhoton #

double get_Pole_mPhoton(
    const SMInputs & 
)

function get_Pole_mGluon #

double get_Pole_mGluon(
    const SMInputs & 
)

function get_sinthW2_pole #

double get_sinthW2_pole(
    const softsusy::QedQcd & qedqcd
)

function set_Pole_mElectron #

void set_Pole_mElectron(
    SMInputs & inputs,
    double set_value
)

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

function get_DiracSingletDM_Z2_spectrum #

void get_DiracSingletDM_Z2_spectrum(
    Spectrum & result
)

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

function fill_map_from_DiracSingletDM_Z2spectrum #

void 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.

function get_DiracSingletDM_Z2_spectrum_as_map #

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

function get_DMEFT_spectrum #

void get_DMEFT_spectrum(
    Spectrum & result
)

Get a simple wrapper for Spectrum object.

function fill_map_from_DMEFT_spectrum #

void fill_map_from_DMEFT_spectrum(
    std::map< std::string, double > & specmap,
    const Spectrum & spec
)

Use SpectrumContents routines to automate

Use SpectrumContents routines to automate

function get_DMEFT_spectrum_as_map #

void get_DMEFT_spectrum_as_map(
    std::map< std::string, double > & specmap
)

function get_DMsimpVectorMedDiracDM_spectrum #

void get_DMsimpVectorMedDiracDM_spectrum(
    Spectrum & result
)

Get a (simple) Spectrum object wrapper for DMsimpVectorMedDiracDM_spectrum model.

function fill_map_from_DMsimpVectorMedDiracDM_spectrum #

void fill_map_from_DMsimpVectorMedDiracDM_spectrum(
    std::map< std::string, double > & specmap,
    const Spectrum & spec
)

Use SpectrumContents routines to automate

Use SpectrumContents routines to automate

function get_DMsimpVectorMedDiracDM_spectrum_as_map #

void get_DMsimpVectorMedDiracDM_spectrum_as_map(
    std::map< std::string, double > & specmap
)

function Unitarity_Bound_DMsimpVectorMedDiracDM #

void Unitarity_Bound_DMsimpVectorMedDiracDM(
    double & result
)

Calculate whether or not unitarity is violated.

function get_DMsimpVectorMedMajoranaDM_spectrum #

void get_DMsimpVectorMedMajoranaDM_spectrum(
    Spectrum & result
)

Get a (simple) Spectrum object wrapper for DMsimpVectorMedMajoranaDM_spectrum model.

function fill_map_from_DMsimpVectorMedMajoranaDM_spectrum #

void fill_map_from_DMsimpVectorMedMajoranaDM_spectrum(
    std::map< std::string, double > & specmap,
    const Spectrum & spec
)

Use SpectrumContents routines to automate

Use SpectrumContents routines to automate

function get_DMsimpVectorMedMajoranaDM_spectrum_as_map #

void get_DMsimpVectorMedMajoranaDM_spectrum_as_map(
    std::map< std::string, double > & specmap
)

function Unitarity_Bound_DMsimpVectorMedMajoranaDM #

void Unitarity_Bound_DMsimpVectorMedMajoranaDM(
    double & result
)

Calculate whether or not unitarity is violated.

function get_DMsimpVectorMedScalarDM_spectrum #

void get_DMsimpVectorMedScalarDM_spectrum(
    Spectrum & result
)

Get a (simple) Spectrum object wrapper for DMsimpVectorMedScalarDM_spectrum model.

function fill_map_from_DMsimpVectorMedScalarDM_spectrum #

void fill_map_from_DMsimpVectorMedScalarDM_spectrum(
    std::map< std::string, double > & specmap,
    const Spectrum & spec
)

Use SpectrumContents routines to automate

Use SpectrumContents routines to automate

function get_DMsimpVectorMedScalarDM_spectrum_as_map #

void get_DMsimpVectorMedScalarDM_spectrum_as_map(
    std::map< std::string, double > & specmap
)

function get_DMsimpVectorMedVectorDM_spectrum #

void get_DMsimpVectorMedVectorDM_spectrum(
    Spectrum & result
)

Get a (simple) Spectrum object wrapper for DMsimpVectorMedVectorDM_spectrum model.

function fill_map_from_DMsimpVectorMedVectorDM_spectrum #

void fill_map_from_DMsimpVectorMedVectorDM_spectrum(
    std::map< std::string, double > & specmap,
    const Spectrum & spec
)

Use SpectrumContents routines to automate

Use SpectrumContents routines to automate

function get_DMsimpVectorMedVectorDM_spectrum_as_map #

void get_DMsimpVectorMedVectorDM_spectrum_as_map(
    std::map< std::string, double > & specmap
)

function DecayWidthPerturbativity_DMsimpVectorMedVectorDM #

void DecayWidthPerturbativity_DMsimpVectorMedVectorDM(
    double & result
)

Calculate the mediator decay width-mass ratio and invalidate the point if greater than 1.

function get_MajoranaSingletDM_Z2_spectrum #

void get_MajoranaSingletDM_Z2_spectrum(
    Spectrum & result
)

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

function fill_map_from_MajoranaSingletDM_Z2spectrum #

void 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.

function get_MajoranaSingletDM_Z2_spectrum_as_map #

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

function run_FS_spectrum_generator #

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
)

function fill_MDM_input #

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

function check_perturb_MDM #

bool check_perturb_MDM(
    const Spectrum & spec,
    double scale,
    int pts
)

function find_non_perturb_scale_MDM #

void find_non_perturb_scale_MDM(
    double & result
)

function fill_map_from_MDMspectrum #

void 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.

function get_MDM_spectrum_as_map #

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

function get_SM_SubSpectrum_from_MSSM_Spectrum #

void get_SM_SubSpectrum_from_MSSM_Spectrum(
    const SubSpectrum *& result
)

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

function get_MSSM_spectrum_as_SLHAea_SLHA1 #

void get_MSSM_spectrum_as_SLHAea_SLHA1(
    SLHAstruct & result
)

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

function get_MSSM_spectrum_as_SLHAea_SLHA2 #

void get_MSSM_spectrum_as_SLHAea_SLHA2(
    SLHAstruct & result
)

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

function get_MSSM_spectrum_from_SLHAfile #

void 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.

function get_MSSM_spectrum_from_SLHAstruct #

void 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

function get_MSSM_spectrum_from_postprocessor #

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.

function FeynHiggs_MSSMMasses #

void FeynHiggs_MSSMMasses(
    fh_MSSMMassObs_container & result
)

FeynHiggs SUSY masses and mixings.

function FeynHiggs_AllHiggsMasses #

void FeynHiggs_AllHiggsMasses(
    fh_HiggsMassObs_container & result
)

Higgs masses and mixings with theoretical uncertainties.

function FeynHiggs_Couplings #

void FeynHiggs_Couplings(
    fh_Couplings_container & result
)

Call FHCouplings from FeynHiggs and collect the output.

function get_invisibles #

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.

function MSSM_higgs_couplings_pwid #

void MSSM_higgs_couplings_pwid(
    HiggsCouplingsTable & result
)

Put together the Higgs couplings for the MSSM, from partial widths only.

function MSSM_higgs_couplings_FeynHiggs #

void MSSM_higgs_couplings_FeynHiggs(
    HiggsCouplingsTable & result
)

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

function FeynHiggs_HiggsMass #

void FeynHiggs_HiggsMass(
    triplet< double > & result
)

function FeynHiggs_HeavyHiggsMasses #

void FeynHiggs_HeavyHiggsMasses(
    map_int_triplet_dbl & result
)

function SUSYHD_HiggsMass #

void SUSYHD_HiggsMass(
    triplet< double > & result
)

function get_ScalarSingletDM_Z2_spectrum #

void get_ScalarSingletDM_Z2_spectrum(
    Spectrum & result
)

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

function get_ScalarSingletDM_Z3_spectrum #

void get_ScalarSingletDM_Z3_spectrum(
    Spectrum & result
)

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

function fill_ScalarSingletDM_input #

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

function fill_extra_input #

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

function check_perturb #

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

function ScalarSingletDM_higgs_couplings_pwid #

void ScalarSingletDM_higgs_couplings_pwid(
    HiggsCouplingsTable & result
)

Put together the Higgs couplings for the ScalarSingletDM models, from partial widths only.

function fill_map_from_ScalarSingletDM_spectrum #

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.

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

function get_ScalarSingletDM_Z2_spectrum_as_map #

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

function get_ScalarSingletDM_Z3_spectrum_as_map #

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

function get_QedQcd_spectrum #

void get_QedQcd_spectrum(
    const SubSpectrum *& result
)

Construct a SubSpectrum object from SMInputs using QedQcdWrapper.

function get_SM_spectrum #

void get_SM_spectrum(
    Spectrum & result
)

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

function SM_higgs_couplings #

void SM_higgs_couplings(
    HiggsCouplingsTable & result
)

Put together the SM Higgs couplings.

function get_SubGeVDM_spectrum #

void get_SubGeVDM_spectrum(
    Spectrum & result
)

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

function fill_map_from_SubGeVDM_spectrum #

void fill_map_from_SubGeVDM_spectrum(
    std::map< std::string, double > & specmap,
    const Spectrum & SubGeVdmspec
)

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.

function get_SubGeVDM_spectrum_as_map #

void get_SubGeVDM_spectrum_as_map(
    std::map< std::string, double > & specmap
)

function Math_test #

void Math_test(
    bool & result
)

function SUSYHD_test #

void SUSYHD_test(
    bool & result
)

function SPheno_MSSM_test #

void SPheno_MSSM_test(
    bool & result
)

function MSSMspectrum_test #

void MSSMspectrum_test(
    bool & result
)

Verify consistency of the contents of a Spectrum object of capability MSSMspectrum. (derived from old ’exampleRead’ function)

NEW! Tests of override setters These cannot be run on a const spectrum object, so we need to clone it first

Now add some entry that didn’t exist before

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

TODO: Tests of ordinary ‘setter’ functions (these actually replace data in the wrapped object)

Tests of spectrum/particle database antiparticle getters/setters interaction

Turn SpecBit warnings to ‘fatal’ in order to trigger stop after this function runs.

function light_quark_test #

void light_quark_test(
    bool & 
)

Generate data for a plot of quark mass

function get_VectorSingletDM_Z2_spectrum #

void get_VectorSingletDM_Z2_spectrum(
    Spectrum & result
)

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

function fill_map_from_VectorSingletDM_Z2spectrum #

void 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.

function get_VectorSingletDM_Z2_spectrum_as_map #

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

function check_EW_stability_ScalarSingletDM_Z3 #

void check_EW_stability_ScalarSingletDM_Z3(
    double & result
)

function check_perturb_to_min_lambda #

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

function run_lambda #

double run_lambda(
    double scale,
    void * params
)

function find_min_lambda_Helper #

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
)

function find_min_lambda_ScalarSingletDM_Z2 #

void find_min_lambda_ScalarSingletDM_Z2(
    dbl_dbl_bool & vs_tuple
)

function find_min_lambda_ScalarSingletDM_Z3 #

void find_min_lambda_ScalarSingletDM_Z3(
    dbl_dbl_bool & vs_tuple
)

function find_min_lambda_MDM #

void find_min_lambda_MDM(
    dbl_dbl_bool & vs_tuple
)

function get_expected_vacuum_lifetime #

void get_expected_vacuum_lifetime(
    double & lifetime
)

function lnL_highscale_vacuum_decay_single_field #

void lnL_highscale_vacuum_decay_single_field(
    double & result
)

function get_lambdaB #

void get_lambdaB(
    double & result
)

function check_perturb_min_lambda #

void check_perturb_min_lambda(
    double & result
)

function get_likelihood_VS #

void get_likelihood_VS(
    double & result
)

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

function get_VS_results #

void get_VS_results(
    map_str_dbl & result
)

get all results from VS as str to dbl map to easily print them

function make_vpp_inputs #

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.

function set_panic_vacua #

void set_panic_vacua(
    std::set< std::string > & result
)

Create a string set containing a list with all likelihoods that vevacious should calculate. The options are tunneling to

• the global minimum -> “global”
• the nearest minimum -> “nearest” Default behaviour (if no sub-capabilities are set): calculate both

function set_tunnelling_strategy #

void set_tunnelling_strategy(
    std::set< std::string > & result
)

Create a string set containing a list of the tunnelling strategies that vevacious should use. This could be

• quantum (zero-T) tunnelling to new minimum -> “quantum”
• thermal (finiite-T) tunnelling to new minimum -> “thermal” Default behaviour is both

function helper_set_tunnelingStrategy #

str helper_set_tunnelingStrategy(
    std::set< std::string > tunnelling_strategy
)

Set tunnelling strategy for the different minima, either

• JustQuantum -> only quantum
• JustThermal -> only thermal or
• QuantumThenThermal -> both depending on the strategy provided from the sub-capabilities

function initialize_vevacious #

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.

function exec_pass_spectrum_to_vevacious #

vevacious_1_0::VevaciousPlusPlus::VevaciousPlusPlus 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?

function helper_run_vevacious #

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

function helper_catch_vevacious #

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

function compare_panic_vacua #

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. Return true if they coincide, false if not.

function check_vacuum_stability_vevacious #

void check_vacuum_stability_vevacious(
    VevaciousResultContainer & result
)

Check stability of global vacuum of the potential with vevacious.

function vevacious_file_location_MSSM #

void vevacious_file_location_MSSM(
    map_str_str & result
)

Tell GAMBIT which files to work with for the MSSM.

function prepare_pass_MSSM_spectrum_to_vevacious #

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. The actual passing happens in the helper function exec_pass_spectrum_to_vevacious which gets executed every time before a vevacious call. Model dependent.

Updated on 2024-07-18 at 13:53:32 +0000