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

Typedefs

typedef std::pair< int, strp_int_string
 Typedefs for pairs that we will use in maps. More...
 
typedef std::pair< int, intpair_ints
 
typedef std::pair< str, pair_intspair_string_ints
 
typedef std::pair< str, strpair_strings
 

Functions

std::map< str, p_int_stringinit_gauge_label_to_index_type ()
 map from gauge eigenstate strings to string, index pairs More...
 
std::map< str, p_int_stringinit_mass_label_to_index_type ()
 map from mass eigenstate strings to string, index pairs More...
 
std::map< str, pair_string_intsinit_familystate_label ()
 map to extract info from family state More...
 
std::map< p_int_string, std::vector< str > > init_type_family_to_gauge_states ()
 map to obtain left_right gauge_pairs from state info helps us reuse other routiones with string arguments More...
 
std::map< str, std::vector< str > > init_family_state_to_gauge_state ()
 maps directly from family string to left_right gauge_pairs helps us reuse other routines that take string arguments More...
 
std::map< str, std::vector< str > > init_gauge_es_to_family_states ()
 maps directly from gauge_es string to familystates helps us reuse other routines that take string arguments More...
 
std::map< str, std::vector< str > > init_type_to_vec_of_mass_es ()
 map from string representing type (ie up-squarks, down-squarks or charged sleptons) to appropriate set of mass eigenstates More...
 
std::map< str, std::vector< str > > init_type_to_vec_of_gauge_es ()
 map from string representing type (ie up-squarks, down-squarks or charged sleptons) to appropriate set of gauge eigenstates More...
 
std::vector< doubleget_Pole_Mixing_col (str type, int gauge_index, const SubSpectrum &mssm)
 
std::vector< doubleget_Pole_Mixing_row (str type, int mass_index, const SubSpectrum &mssm)
 
void add_MODSEL_disclaimer (SLHAstruct &slha, const str &object)
 Add a disclaimer about the absence of a MODSEL block in a generated SLHAea object. More...
 
void attempt_to_add_SLHA1_mixing (const str &block, SLHAstruct &slha, const str &type, const SubSpectrum &spec, double tol, str &s1, str &s2, bool pterror)
 Simple helper function for for adding missing SLHA1 2x2 family mixing matrices to an SLHAea object. More...
 
std::vector< doubleget_mass_comp_for_gauge (str gauge_es, const SubSpectrum &mssm)
 returns vector representing composition of requested gauge state in terms of the slha2 mass eigenstates (~u_1 ...~u_6 etc) which is just a column in the mixing matrix More...
 
double get_mixing_element (str gauge_es, str mass_es, const SubSpectrum &mssm)
 routine to return mass state admixure for given gauge state in the end this is a trival routine but may help More...
 
std::vector< doubleget_gauge_comp_for_mass (str mass_es, const SubSpectrum &mssm)
 returns vector representing composition of requested mass eigenstate in terms of the slha2 gauge eigenstates (~u_L,~c_L,...~t_R etc) which is just a row in the mixing matrix just wraps get_Pole_Mixing_row after extracting info from string More...
 
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_composition More...
 
str mass_es_from_gauge_es (str gauge_es, double &max_mixing, const SubSpectrum &mssm)
 as above but doesn't fill a gauge_composition vector would have a slight efficiency saving if we didn't use wrapper and avoided skipped gauge_composition entirely but at the cost of a lot of code duplication More...
 
str mass_es_from_gauge_es (str gauge_es, std::vector< double > &gauge_composition, const SubSpectrum &mssm)
 as above but doesn't fill max_mixing would have a slight efficiency saving if we didn't use wrapper and avoided skipped max_mixing entirely but at the cost of a lot of code duplication More...
 
str mass_es_from_gauge_es (str gauge_es, const SubSpectrum &mssm)
 as above but doesn't fill max_mixing or gauge_composition would have a slight efficiency saving if we didn't use wrapper and avoided skipped max_mixing entirely but at the cost of a lot of code duplication More...
 
str mass_es_from_gauge_es (str gauge_es, const SubSpectrum &mssm, double tol, str context, bool pterror)
 as above but do test against tol internally More...
 
str gauge_es_from_mass_es (str mass_es, double &max_mixing, std::vector< double > &mass_composition, const SubSpectrum &mssm)
 identifies gauge_es with largest mass_es content also fills largest max_mixing and full mass_composition More...
 
str gauge_es_from_mass_es (str mass_es, double &max_mixing, const SubSpectrum &mssm)
 as above but doesn't fill a gauge_composition vector would have a slight efficiency saving if we didn't use wrapper and avoided skipped gauge_composition entirely but at the cost of a lot of code duplication More...
 
str gauge_es_from_mass_es (str mass_es, std::vector< double > &mass_composition, const SubSpectrum &mssm)
 as above but doesn't fill max_mixing would have a slight efficiency saving if we didn't use wrapper and avoided skipped max_mixing entirely but at the cost of a lot of code duplication More...
 
str gauge_es_from_mass_es (str mass_es, const SubSpectrum &mssm)
 as above but doesn't fill max_mixing or gauge_composition would have a slight efficiency saving if we didn't use wrapper and avoided skipped max_mixing entirely but at the cost of a lot of code duplication More...
 
str gauge_es_from_mass_es (str mass_es, const SubSpectrum &mssm, double tol, str context, bool pterror)
 as above but do test against tol internally More...
 
sspair identify_mass_ess_for_family (str type, int family, const SubSpectrum &mssm)
 identify the two mass eigenstate corresponding to the approximate family states, e.g. More...
 
str mass_es_closest_to_family (str familystate, const SubSpectrum &mssm)
 identify the mass eigenstate corresponding to family state takes string and returns only requested state I suspect this is the more useful one More...
 
std::vector< doubleget_gauge_comp_for_family_state (str familystate, str &mass_es, const SubSpectrum &mssm)
 returns vector with composition of closest the mass eigenstate to give family state in terms of gauge eigenstates and stores mass eigenstate in mass_es More...
 
str mass_es_closest_to_family (str familystate, std::vector< double > &gauge_composition, std::vector< double > &off_family_mixing, const SubSpectrum &mssm)
 identifies the mass_es that is closest match to specified family state and fills mixture of the two gauge states with same family into std::vector gauge_composition also fills remaining off-family mixings into a second vector More...
 
str mass_es_closest_to_family (str familystate, std::vector< double > &gauge_composition, const SubSpectrum &mssm)
 identifies the mass_es that is closest match to specified family state and fills mixture of the two gauge states with same family into std::vector gauge_composition More...
 
str mass_es_closest_to_family (str familystate, double &sqr_sum_mix, const SubSpectrum &mssm)
 identifies the mass_es that is closest match to specified family state and fills sqr_sum_mix with the square sum of each of the two mixings into gauge_es of that family More...
 
str mass_es_closest_to_family (str familystate, const SubSpectrum &mssm, double tol, str context, bool pterror)
 identifies the mass_es that is closest match to specified family does tol-test internally to check correctness of assumptions More...
 
std::vector< doublefamily_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. More...
 
std::vector< doublefamily_state_mix_matrix (str type, int family, str &mass_es1, str &mass_es2, const SubSpectrum &mssm)
 identifies the two mass_es which best matches specified family state storing them in strings and then returns the 2by2 mixing matrix for that family state in the form (Mix_{11}, Mix_{12}, Mix_{21}, Mix_{22}) It also stores the mixing elements for the gauge states that don't belong to the correct family for this state in a std::vector The latter should have entries which are zero in absense of family mixing More...
 
double get_gauge_admix_for_family_state (str familystate, str gauge_es, str &mass_es, const SubSpectrum &mssm)
 returns admix of gauge eigenstate in the mass eigenstate closest to the given family state and stores mass eigenstate in mass_es More...
 
str family_state_closest_to_mass_es (str mass_es, double &sum_sq_mix, std::vector< double > &mass_comp, const SubSpectrum &mssm)
 returns family state that best matches the given mass_es fills a double with the sum of the square mixings to gauge_es of the matching family and fills the mixing of the matching gauge_es into mass eigenstates More...
 
str family_state_closest_to_mass_es (str mass_es, double &sum_sq_mix, const SubSpectrum &mssm)
 wrapper for overloaded version returns family state that best matches the given mass_es fills a double with the sum of the square mixings to gauge_es of the matching family More...
 
str family_state_closest_to_mass_es (str mass_es, std::vector< double > &mass_comp, const SubSpectrum &mssm)
 wrapper for overloaded version returns family state that best matches the given mass_es and fills the mixing of the matching mass_es into gauge eigenstates More...
 
str family_state_closest_to_mass_es (str mass_es, const SubSpectrum &mssm, double tol, str context, bool pterror)
 wrapper for overloaded version returns family state that best matches the given mass_es and fills the mixing of the matching mass_es into gauge eigenstates More...
 
void add_MSSM_spectrum_to_SLHAea (const SubSpectrum &mssmspec, SLHAstruct &slha, int slha_version)
 Add an entire MSSM spectrum to an SLHAea object. More...
 

Variables

const std::map< str, p_int_stringgauge_label_to_index_type = init_gauge_label_to_index_type()
 Known maps filled at initialisation. More...
 
const std::map< str, p_int_stringmass_label_to_index_type = init_mass_label_to_index_type()
 
const std::map< str, pair_string_intsfamilystate_label = init_familystate_label()
 
const std::map< p_int_string, std::vector< str > > type_family_to_gauge_states = init_type_family_to_gauge_states()
 
const std::map< str, std::vector< str > > family_state_to_gauge_state = init_family_state_to_gauge_state()
 
const std::map< str, std::vector< str > > gauge_es_to_family_states = init_gauge_es_to_family_states()
 
const std::map< str, std::vector< str > > type_to_vec_of_mass_es = init_type_to_vec_of_mass_es()
 
const std::map< str, std::vector< str > > type_to_vec_of_gauge_es = init_type_to_vec_of_gauge_es()
 

Typedef Documentation

◆ p_int_string

Typedefs for pairs that we will use in maps.

Definition at line 116 of file ini_functions.hpp.

◆ pair_ints

typedef std::pair<int,int> Gambit::slhahelp::pair_ints

Definition at line 117 of file ini_functions.hpp.

◆ pair_string_ints

Definition at line 118 of file ini_functions.hpp.

◆ pair_strings

Definition at line 119 of file ini_functions.hpp.

Function Documentation

◆ add_MODSEL_disclaimer()

void Gambit::slhahelp::add_MODSEL_disclaimer ( SLHAstruct slha,
const str object 
)

Add a disclaimer about the absence of a MODSEL block in a generated SLHAea object.

Definition at line 75 of file mssm_slhahelp.cpp.

Referenced by Gambit::DecayTable::getSLHAea(), Gambit::SMInputs::getSLHAea(), and Gambit::SubSpectrum::getSLHAea().

76  {
77  slha.push_front("# depend on which calculator you intend this object or file to be used with.");
78  slha.push_front("# Note that block MODSEL is not automatically emitted, as its contents");
79  slha.push_front("# This SLHA(ea) object was created from a GAMBIT "+object+" object.");
80  }
Here is the caller graph for this function:

◆ add_MSSM_spectrum_to_SLHAea()

void Gambit::slhahelp::add_MSSM_spectrum_to_SLHAea ( const SubSpectrum mssmspec,
SLHAstruct slha,
int  slha_version 
)

Add an entire MSSM spectrum to an SLHAea object.

Definition at line 772 of file mssm_slhahelp.cpp.

References attempt_to_add_SLHA1_mixing(), Gambit::LogTags::debug, Gambit::Par::dimensionless, family_state_closest_to_mass_es(), family_state_mix_matrix(), cyclic_include_check::fs, gauge_es_from_mass_es(), Gambit::SubSpectrum::get(), Gambit::Models::partmap::get_antiparticle(), Gambit::SubSpectrum::GetScale(), Gambit::SubSpectrum::has(), Gambit::invalid_point(), LOCAL_INFO, M, Gambit::Par::mass1, Gambit::Par::mass2, mass_es_closest_to_family(), mass_es_from_gauge_es(), combine_hdf5::N, Gambit::Models::ParticleDB(), Gambit::Par::Pole_Mass, Gambit::Par::Pole_Mixing, Gambit::invalid_point_exception::raise(), Gambit::sgn(), Gambit::SLHAea_add(), Gambit::SLHAea_add_block(), Gambit::SLHAea_add_from_subspec(), Gambit::SLHAea_block_exists(), Gambit::SLHAea_check_block(), Gambit::SLHAea_delete_block(), and Gambit::utils_error().

Referenced by Gambit::SpecBit::MSSMSpec< MI >::add_to_SLHAea(), and Gambit::MSSMSimpleSpec::add_to_SLHAea().

773  {
774  std::ostringstream comment;
775 
776  // Make sure to overwrite all entries if they exist already (from say a "hurriedly" copied SM subspectrum + unknown extra MSSM junk)
777 
778  //SPINFO block should be added separately.
779  // MINPAR block; some programs need tanbeta(mZ), so we should output it here if possible
780  SLHAea_check_block(slha, "MINPAR");
781  if(mssmspec.has(Par::dimensionless,"tanbeta(mZ)"))
782  {
783  SLHAea_add_from_subspec(slha,LOCAL_INFO,mssmspec,Par::dimensionless,"tanbeta(mZ)","MINPAR",3,"# tanbeta(mZ)^DRbar");
784  }
785  int sgnmu = sgn(mssmspec.get(Par::mass1,"Mu")); // Mu isn't at the input scale anymore, but sign(mu) doesn't change with running.
786  SLHAea_add(slha,"MINPAR",4,sgnmu,"# sign(mu)", true);
787 
788  // HMIX block
789  SLHAea_delete_block(slha, "HMIX");
790  SLHAea_add_block (slha, "HMIX", mssmspec.GetScale());
791  SLHAea_add_from_subspec(slha, LOCAL_INFO,mssmspec,Par::mass1,"Mu","HMIX",1,"mu DRbar");
792  SLHAea_add_from_subspec(slha, LOCAL_INFO,mssmspec,Par::dimensionless,"tanbeta","HMIX",2,"tan(beta) = vu/vd DRbar");
793  if (not mssmspec.has(Par::mass1,"vu")) utils_error().raise(LOCAL_INFO, "MSSM subspectrum does not contain vu!");
794  if (not mssmspec.has(Par::mass1,"vd")) utils_error().raise(LOCAL_INFO, "MSSM subspectrum does not contain vd!");
795  double vu = mssmspec.get(Par::mass1,"vu");
796  double vd = mssmspec.get(Par::mass1,"vd");
797  SLHAea_add(slha,"HMIX",3,sqrt(vu*vu + vd*vd),"v = sqrt(vd^2 + vu^2) DRbar", true);
798  SLHAea_add_from_subspec(slha,LOCAL_INFO,mssmspec,Par::mass2,"mA2","HMIX",4,"m^2_A (tree)");
799  SLHAea_add_from_subspec(slha,LOCAL_INFO,mssmspec,Par::mass2,"BMu","HMIX",101,"Bmu DRbar");
800  SLHAea_add(slha,"HMIX",102,vd,"vd DRbar", true);
801  SLHAea_add(slha,"HMIX",103,vu,"vu DRbar", true);
802  // GAUGE block
803  SLHAea_delete_block(slha, "GAUGE");
804  SLHAea_add_block (slha, "GAUGE", mssmspec.GetScale());
805  // Scale gY is in SU(5)/GUT normalisation internally; convert it to SM normalisation for SLHA output by multiplying by sqrt(3/5).
806  SLHAea_add_from_subspec(slha, LOCAL_INFO,mssmspec,Par::dimensionless,"g1","GAUGE",1,"g' = g1 = gY DRbar", true, sqrt(3./5.));
807  SLHAea_add_from_subspec(slha, LOCAL_INFO,mssmspec,Par::dimensionless,"g2","GAUGE",2,"g = g2 DRbar");
808  SLHAea_add_from_subspec(slha, LOCAL_INFO,mssmspec,Par::dimensionless,"g3","GAUGE",3,"g_s = g3 DRbar");
809 
810  const int pdg_codes[33] = {24,25,35,37,36,1000021,1000024,1000037,1000022,1000023,1000025,1000035,1000006,2000006,1000005,2000005,1000015,2000015,1000012,1000014,1000016,1000001,1000003,
811  2000001,2000003,1000011,1000013,2000011,2000013,1000002,1000004,2000002,2000004,};
812 
813  // Here we add the SLHA1-specific stuff, for backwards compatibility with backwards backends.
814  if (slha_version == 1)
815  {
816  const str slha1_sfermions[21] = {"~t_1", "~t_2", "~b_1", "~b_2", "~tau_1", "~tau_2",
817  "~nu_e_L", "~nu_mu_L", "~nu_tau_L",
818  "~d_L", "~s_L", "~d_R", "~s_R", "~e_L", "~mu_L",
819  "~e_R", "~mu_R", "~u_L", "~c_L", "~u_R", "~c_R"};
820  str slha2_sfermions[21];
821 
822  // STOPMIX, SBOTMIX and STAUMIX blocks
823  slhahelp::attempt_to_add_SLHA1_mixing("STOPMIX", slha, "~u", mssmspec, 1.0, slha2_sfermions[0], slha2_sfermions[1], true);
824  slhahelp::attempt_to_add_SLHA1_mixing("SBOTMIX", slha, "~d", mssmspec, 1.0, slha2_sfermions[2], slha2_sfermions[3], true);
825  slhahelp::attempt_to_add_SLHA1_mixing("STAUMIX", slha, "~e-", mssmspec, 1.0, slha2_sfermions[4], slha2_sfermions[5], true);
826 
827  // MASS block. Do everything except sfermions the same way as SLHA2.
828  for(int i=0;i<12;i++)
829  {
830  str comment(Models::ParticleDB().long_name(pdg_codes[i], 0));
831  SLHAea_add_from_subspec(slha, LOCAL_INFO, mssmspec, Par::Pole_Mass, std::pair<int, int>(pdg_codes[i],0), "MASS", comment);
832  }
833  for(int i=0;i<21;i++)
834  {
835  if (i > 5)
836  {
837  double max_mixing; // Don't actually care about this; we're going to SLHA1 whether it is a good approximation or not.
838  slha2_sfermions[i] = slhahelp::mass_es_from_gauge_es(slha1_sfermions[i], max_mixing, mssmspec);
839  }
840  SLHAea_add(slha, "MASS", pdg_codes[i+12], mssmspec.get(Par::Pole_Mass, slha2_sfermions[i]), slha1_sfermions[i], true);
841  }
842  }
843  else if (slha_version == 2)
844  {
845  // MASS block
846  for(int i=0;i<33;i++)
847  {
848  str comment(Models::ParticleDB().long_name(pdg_codes[i], 0));
849  SLHAea_add_from_subspec(slha, LOCAL_INFO, mssmspec, Par::Pole_Mass, std::pair<int, int>(pdg_codes[i],0), "MASS", comment);
850  }
851 
852  // USQMIX, DSQMIX, SELMIX
853  sspair S[3] = {sspair("USQMIX","~u"), sspair("DSQMIX","~d"), sspair("SELMIX","~e-")};
854  for (int k=0;k<3;k++)
855  {
856  SLHAea_delete_block(slha, S[k].first);
857  SLHAea_add_block (slha, S[k].first, mssmspec.GetScale());
858  for(int i=1;i<7;i++) for(int j=1;j<7;j++)
859  {
860  comment.str(""); comment << S[k].second << "-type sfermion mixing (" << i << "," << j << ")";
861  SLHAea_add_from_subspec(slha, LOCAL_INFO,mssmspec, Par::Pole_Mixing, S[k].second, i, j, S[k].first, i, j, comment.str());
862  }
863  }
864 
865  // SNUMIX block
866  sspair V("SNUMIX","~nu");
867  SLHAea_delete_block(slha, V.first);
868  SLHAea_add_block (slha, V.first, mssmspec.GetScale());
869  for(int i=1;i<4;i++) for(int j=1;j<4;j++)
870  {
871  comment.str(""); comment << V.second << " mixing matrix (" << i << "," << j << ")";
872  SLHAea_add_from_subspec(slha, LOCAL_INFO,mssmspec, Par::Pole_Mixing, V.second, i, j, V.first, i, j, comment.str());
873  }
874 
875  }
876  else
877  {
878  utils_error().raise(LOCAL_INFO, "Unrecognised version of SLHA standard; only SLHA1 and SLHA2 are permitted.");
879  }
880 
881  // MSOFT block (SLHA1 and SLHA2) plus MSL2, MSE2, MSQ2, MSU2 and MSD2 blocks (SLHA2 only)
882  if(not SLHAea_block_exists(slha,"MSOFT"))
883  {
884  SLHAea_add_block(slha, "MSOFT", mssmspec.GetScale());
885  }
886  SLHAea_add_from_subspec(slha, LOCAL_INFO,mssmspec,Par::mass1,"M1","MSOFT",1,"bino mass parameter M1");
887  SLHAea_add_from_subspec(slha, LOCAL_INFO,mssmspec,Par::mass1,"M2","MSOFT",2,"wino mass parameter M2");
888  SLHAea_add_from_subspec(slha, LOCAL_INFO,mssmspec,Par::mass1,"M3","MSOFT",3,"gluino mass parameter M3");
889  SLHAea_add_from_subspec(slha, LOCAL_INFO,mssmspec,Par::mass2,"mHd2","MSOFT",21,"d-type Higgs mass parameter mHd2");
890  SLHAea_add_from_subspec(slha, LOCAL_INFO,mssmspec,Par::mass2,"mHu2","MSOFT",22,"u-type Higgs mass parameter mHu2");
891  sspair M[5] = {sspair("MSL2","ml2"), sspair("MSE2","me2"), sspair("MSQ2","mq2"), sspair("MSU2","mu2"), sspair("MSD2","md2")};
892  for (int k=0;k<5;k++)
893  {
894  SLHAea_delete_block(slha, M[k].first);
895  if (slha_version == 2) SLHAea_add_block(slha, M[k].first, mssmspec.GetScale());
896  for(int i=1;i<4;i++) for(int j=1;j<4;j++)
897  {
898  comment.str(""); comment << M[k].second << "(" << i << "," << j << ")";
899  if (slha_version == 2) SLHAea_add_from_subspec(slha, LOCAL_INFO,mssmspec, Par::mass2, M[k].second, i, j, M[k].first, i, j, comment.str());
900  if (i== j)
901  {
902  double entry = mssmspec.get(Par::mass2, M[k].second, i, j);
903  SLHAea_add(slha,"MSOFT",30+3*k+i+(k>1?4:0),sgn(entry)*sqrt(std::abs(entry)),"sqrt("+comment.str()+")", true);
904  }
905  }
906  }
907 
908  // Yukawa and trilinear blocks. YU, YD and YE, plus [YU, YD and YE; SLHA1 only], or [TU, TD and TE; SLHA2 only].
909  sspair A[3] = {sspair("AU","Au"), sspair("AD","Ad"), sspair("AE","Ae")};
910  sspair Y[3] = {sspair("YU","Yu"), sspair("YD","Yd"), sspair("YE","Ye")};
911  sspair T[3] = {sspair("TU","TYu"), sspair("TD","TYd"), sspair("TE","TYe")};
912  for (int k=0;k<3;k++)
913  {
914  // Erase these blocks if they already exist; we need them in the right format
915  SLHAea_delete_block(slha, Y[k].first);
916  SLHAea_delete_block(slha, A[k].first);
917  SLHAea_delete_block(slha, T[k].first);
918  // Now add them back
919  SLHAea_add_block(slha, Y[k].first, mssmspec.GetScale());
920  if (slha_version == 1) SLHAea_add_block(slha, A[k].first, mssmspec.GetScale());
921  if (slha_version == 2) SLHAea_add_block(slha, T[k].first, mssmspec.GetScale());
922  for(int i=1;i<4;i++)
923  {
924  // SLHA2 says to output only diagonal of Yukawa matrices, since we should be in a basis in which they are diagonal.
925  // SLHA1 says to give only the 3,3 element, but we'll give the whole diagonal anyway, codes will ignore them if not
926  // needed.
927  comment.str(""); comment << Y[k].second << "(" << i << "," << i << ")";
928  SLHAea_add_from_subspec(slha,LOCAL_INFO,mssmspec,Par::dimensionless,Y[k].second, i, i, Y[k].first, i, i, comment.str());
929 
930  if (slha_version == 1)
931  {
932  comment.str(""); comment << A[k].second << "(" << i << "," << i << ")";
933  double invTii = 1.0/mssmspec.get(Par::dimensionless,Y[k].second,i,i);
934  SLHAea_add_from_subspec(slha, LOCAL_INFO,mssmspec, Par::mass1, T[k].second, i, i, A[k].first, i, i, comment.str(), true, invTii); // last argument is a rescaling factor
935  }
936  else if (slha_version == 2)
937  {
938  for(int j=1;j<4;j++)
939  {
940  comment.str(""); comment << T[k].second << "(" << i << "," << j << ")";
941  SLHAea_add_from_subspec(slha, LOCAL_INFO,mssmspec, Par::mass1, T[k].second, i, j, T[k].first, i, j, comment.str());
942  }
943  }
944  else
945  {
946  std::ostringstream msg;
947  msg << "Tried to ouput SLHA data, but SLHA version requested was invalid (should be 1 or 2, but received "<<slha_version<<")";
948  utils_error().raise(LOCAL_INFO,msg.str());
949  }
950  }
951  }
952 
953  // ALPHA block
954  // if this exists already, delete it entirely
955  auto it = slha.find("ALPHA");
956  if(it!=slha.end()) slha.erase(it); // TODO: format of this call is confusing, perhaps write a wrapper for it.
957  // ...and now add it back
958  SLHAea_add_block(slha, "ALPHA", mssmspec.GetScale());
959  slha["ALPHA"][""] << asin(mssmspec.get(Par::Pole_Mixing, "h0", 2, 2)) << "# sin^-1(SCALARMIX(2,2))";
960 
961  // UMIX and VMIX blocks, plus some FlexibleSUSY-only extensions: PSEUDOSCALARMIX, SCALARMIX and CHARGEMIX.
962  sspair U[5] = {sspair("UMIX","~chi-"), sspair("VMIX","~chi+"), sspair("PSEUDOSCALARMIX","A0"), sspair("SCALARMIX","h0"), sspair("CHARGEMIX","H+")};
963  for (int k=0;k<5;k++)
964  {
965  SLHAea_delete_block(slha, U[k].first);
966  SLHAea_add_block(slha, U[k].first, mssmspec.GetScale());
967  for(int i=1;i<3;i++) for(int j=1;j<3;j++)
968  {
969  comment.str(""); comment << U[k].second << " mixing matrix (" << i << "," << j << ")";
970  SLHAea_add_from_subspec(slha, LOCAL_INFO,mssmspec, Par::Pole_Mixing, U[k].second, i, j, U[k].first, i, j, comment.str());
971  }
972  }
973 
974  // NMIX block
975  sspair N("NMIX","~chi0");
976  SLHAea_delete_block(slha, N.first);
977  SLHAea_add_block(slha, N.first, mssmspec.GetScale());
978  for(int i=1;i<5;i++) for(int j=1;j<5;j++)
979  {
980  comment.str(""); comment << N.second << " mixing matrix (" << i << "," << j << ")";
981  SLHAea_add_from_subspec(slha, LOCAL_INFO,mssmspec, Par::Pole_Mixing, N.second, i, j, N.first, i, j, comment.str());
982  }
983  }
EXPORT_SYMBOLS error & utils_error()
Utility errors.
void attempt_to_add_SLHA1_mixing(const str &block, SLHAstruct &slha, const str &type, const SubSpectrum &spec, double tol, str &s1, str &s2, bool pterror)
Simple helper function for for adding missing SLHA1 2x2 family mixing matrices to an SLHAea object...
str mass_es_from_gauge_es(str gauge_es, const SubSpectrum &mssm, double tol, str context, bool pterror)
as above but do test against tol internally
void SLHAea_add_block(SLHAstruct &, const str &name, const double scale=-1)
Add a new block to an SLHAea object, with our without a scale.
#define LOCAL_INFO
Definition: local_info.hpp:34
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) ...
std::pair< str, str > sspair
Shorthand for a pair of standard strings.
Definition: util_types.hpp:64
bool SLHAea_block_exists(SLHAstruct &slha, const str &block)
Check if a block exists in an SLHAea object.
partmap & ParticleDB()
Database accessor function.
Definition: partmap.cpp:32
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
START_MODEL M
void SLHAea_delete_block(SLHAstruct &slha, const std::string &block)
Delete an entire block from an SLHAea object, if it exists (actually just the first block matching th...
int sgn(T val)
void SLHAea_add_from_subspec(SLHAstruct &slha, const str local_info, const SubSpectrum &subspec, const Par::Tags partype, const std::pair< int, int > &pdg_pair, const str &block, const str &comment, const bool error_if_missing=true, const double rescale=1.0)
Add an entry from a subspectrum getter to an SLHAea object; SLHA index given by pdg code...
bool SLHAea_check_block(SLHAstruct &slha, const str &block)
Check if a block exists in an SLHAea object, add it if not.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ attempt_to_add_SLHA1_mixing()

void Gambit::slhahelp::attempt_to_add_SLHA1_mixing ( const str block,
SLHAstruct slha,
const str type,
const SubSpectrum spec,
double  tol,
str s1,
str s2,
bool  pterror 
)

Simple helper function for for adding missing SLHA1 2x2 family mixing matrices to an SLHAea object.

Definition at line 83 of file mssm_slhahelp.cpp.

References family_state_mix_matrix(), LOCAL_INFO, mass_es_closest_to_family(), and Gambit::SLHAea_add_matrix().

Referenced by add_MSSM_spectrum_to_SLHAea().

85  {
86  if (slha.find(block) == slha.end())
87  {
88  std::vector<double> matmix = slhahelp::family_state_mix_matrix(type, 3, s1, s2, spec, tol, LOCAL_INFO, pterror);
89  SLHAea_add_matrix(slha, block, matmix, 2, 2);
90  }
91  else
92  {
93  std::map<str,str> family_to_3gen; // TODO: make const or something
94  family_to_3gen["~u"] = "~t";
95  family_to_3gen["~d"] = "~b";
96  family_to_3gen["~e-"] = "~tau";
97  s1 = slhahelp::mass_es_closest_to_family(family_to_3gen.at(type)+"_1", spec, tol, LOCAL_INFO, pterror);
98  s2 = slhahelp::mass_es_closest_to_family(family_to_3gen.at(type)+"_2", spec, tol, LOCAL_INFO, pterror);
99  }
100  }
std::vector< double > family_state_mix_matrix(str type, int family, str &mass_es1, str &mass_es2, const SubSpectrum &mssm)
identifies the two mass_es which best matches specified family state storing them in strings and then...
str mass_es_closest_to_family(str familystate, const SubSpectrum &mssm, double tol, str context, bool pterror)
identifies the mass_es that is closest match to specified family does tol-test internally to check co...
#define LOCAL_INFO
Definition: local_info.hpp:34
void SLHAea_add_matrix(SLHAstruct &slha, const str &block, const std::vector< T > &matrix, const int rows, const int cols, const str &comment="", const bool overwrite=false)
Add a whole matrix to an SLHAea object if it doesn&#39;t already exist.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ family_state_closest_to_mass_es() [1/4]

str Gambit::slhahelp::family_state_closest_to_mass_es ( str  mass_es,
double sum_sq_mix,
std::vector< double > &  mass_comp,
const SubSpectrum mssm 
)

returns family state that best matches the given mass_es fills a double with the sum of the square mixings to gauge_es of the matching family and fills the mixing of the matching gauge_es into mass eigenstates

get gauge_es with largest mixing to this mass_es

get family states for the same generation as this gauge_es

extractindex of mass-es and mass_ess_other from strings

choose mass ordering for family state which matches mass ordering of mass_es

subrtact 1 fgrom indices to deal with different indexing

Definition at line 670 of file mssm_slhahelp.cpp.

References gauge_es_from_mass_es(), and mass_es_from_gauge_es().

Referenced by add_MSSM_spectrum_to_SLHAea(), and family_state_closest_to_mass_es().

673  {
675  str gauge_es = gauge_es_from_mass_es(mass_es, mass_comp, mssm);
677  std::vector<str> family_states = gauge_es_to_family_states.at(gauge_es);
678  str family_state1 = family_states[0];
679  str family_state2 = family_states[1];
680  std::vector<str> gauge_states = family_state_to_gauge_state.at(family_state1);
681  str gauge_es_L = gauge_states[0];
682  str gauge_es_R = gauge_states[1];
683  str mass_es_other;
684  if(gauge_es == gauge_es_L)
685  mass_es_other = mass_es_from_gauge_es(gauge_es_R, mssm);
686  else mass_es_other = mass_es_from_gauge_es(gauge_es_L, mssm);
688  int mass_index = (mass_label_to_index_type.at(mass_es)).first;
689  int mass_index_other = (mass_label_to_index_type.at(mass_es_other)).first;
690  str fam_state;
693  if(mass_index < mass_index_other) fam_state = family_state1;
694  else fam_state = family_state2;
695 
696  //get gauge_indices to sum correct mixing elements
697  int gauge_index_L = (gauge_label_to_index_type.at(gauge_es_L)).first;
698  int gauge_index_R = (gauge_label_to_index_type.at(gauge_es_R)).first;
700  sum_sq_mix = mass_comp.at(gauge_index_L-1) * mass_comp.at(gauge_index_L-1);
701  sum_sq_mix += mass_comp.at(gauge_index_R-1) * mass_comp.at(gauge_index_R-1);
702 
703  return fam_state;
704  }
str mass_es_from_gauge_es(str gauge_es, const SubSpectrum &mssm, double tol, str context, bool pterror)
as above but do test against tol internally
str gauge_es_from_mass_es(str mass_es, const SubSpectrum &mssm, double tol, str context, bool pterror)
as above but do test against tol internally
const std::map< str, p_int_string > gauge_label_to_index_type
Known maps filled at initialisation.
const std::map< str, p_int_string > mass_label_to_index_type
const std::map< str, std::vector< str > > gauge_es_to_family_states
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
const std::map< str, std::vector< str > > family_state_to_gauge_state
Here is the call graph for this function:
Here is the caller graph for this function:

◆ family_state_closest_to_mass_es() [2/4]

str Gambit::slhahelp::family_state_closest_to_mass_es ( str  mass_es,
double sum_sq_mix,
const SubSpectrum mssm 
)

wrapper for overloaded version returns family state that best matches the given mass_es fills a double with the sum of the square mixings to gauge_es of the matching family

Definition at line 710 of file mssm_slhahelp.cpp.

References family_state_closest_to_mass_es(), and cyclic_include_check::fs.

712  {
713  std::vector<double> mass_comp;
714  str fs = family_state_closest_to_mass_es(mass_es, sum_sq_mix,
715  mass_comp, mssm);
716  return fs;
717  }
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
str family_state_closest_to_mass_es(str mass_es, const SubSpectrum &mssm, double tol, str context, bool pterror)
wrapper for overloaded version returns family state that best matches the given mass_es and fills the...
Here is the call graph for this function:

◆ family_state_closest_to_mass_es() [3/4]

str Gambit::slhahelp::family_state_closest_to_mass_es ( str  mass_es,
std::vector< double > &  mass_comp,
const SubSpectrum mssm 
)

wrapper for overloaded version returns family state that best matches the given mass_es and fills the mixing of the matching mass_es into gauge eigenstates

Definition at line 722 of file mssm_slhahelp.cpp.

References family_state_closest_to_mass_es(), and cyclic_include_check::fs.

725  {
726  double sum_sq_mix;
727  str fs = family_state_closest_to_mass_es(mass_es, sum_sq_mix, mass_comp,
728  mssm);
729  return fs;
730  }
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
str family_state_closest_to_mass_es(str mass_es, const SubSpectrum &mssm, double tol, str context, bool pterror)
wrapper for overloaded version returns family state that best matches the given mass_es and fills the...
Here is the call graph for this function:

◆ family_state_closest_to_mass_es() [4/4]

str Gambit::slhahelp::family_state_closest_to_mass_es ( str  mass_es,
const SubSpectrum mssm,
double  tol,
str  context,
bool  pterror 
)

wrapper for overloaded version returns family state that best matches the given mass_es and fills the mixing of the matching mass_es into gauge eigenstates

Definition at line 735 of file mssm_slhahelp.cpp.

References family_state_closest_to_mass_es(), cyclic_include_check::fs, Gambit::invalid_point(), LOCAL_INFO, Gambit::invalid_point_exception::raise(), and Gambit::utils_error().

737  {
738  double sum_sq_mix;
739  std::vector<double> mass_comp;
740  str fs = family_state_closest_to_mass_es(mass_es, sum_sq_mix,
741  mass_comp, mssm);
742  if(sum_sq_mix <= 1-tol)
743  {
744  const str errmsg = "Family_state_closest_to_mass_es called when family "
745  "mixing away from closest mass_es is greater than tol.";
746  str full_context = LOCAL_INFO + " called from " + context;
747  if (pterror)
748  {
749  invalid_point().raise(errmsg+" Raised at: "+full_context);
750  }
751  else
752  {
753  utils_error().raise(full_context, errmsg);
754  }
755  }
756  return fs;
757  }
EXPORT_SYMBOLS error & utils_error()
Utility errors.
#define LOCAL_INFO
Definition: local_info.hpp:34
virtual void raise(const std::string &)
Raise the exception, i.e. throw it.
Definition: exceptions.cpp:422
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
str family_state_closest_to_mass_es(str mass_es, const SubSpectrum &mssm, double tol, str context, bool pterror)
wrapper for overloaded version returns family state that best matches the given mass_es and fills the...
invalid_point_exception & invalid_point()
Invalid point exceptions.
Here is the call graph for this function:

◆ family_state_mix_matrix() [1/2]

std::vector<double> Gambit::slhahelp::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.

Definition at line 555 of file mssm_slhahelp.cpp.

References Gambit::invalid_point(), LOCAL_INFO, Gambit::invalid_point_exception::raise(), and Gambit::utils_error().

Referenced by Gambit::SpecBit::add_extra_MSSM_parameter_combinations(), add_MSSM_spectrum_to_SLHAea(), attempt_to_add_SLHA1_mixing(), Gambit::ColliderBit::get_sigma_ee_ll(), Gambit::PrecisionBit::GM2C_SUSY(), and Gambit::DecayBit::stau_1_decays_smallsplit().

558  {
559  std::vector<double> m = family_state_mix_matrix(type, generation, mass_es1, mass_es2, mssm);
560  if (m[0]*m[0] + m[1]*m[1] < 1-tol || m[2]*m[2] + m[3]*m[3] < 1-tol)
561  {
562  const str errmsg = "Too much interfamily mixing to safely determine "
563  "intrafamily mixing matrix.";
564  str full_context = LOCAL_INFO + " called from " + context;
565  if (pterror)
566  {
567  invalid_point().raise(errmsg+" Raised at: "+full_context);
568  }
569  else
570  {
571  utils_error().raise(full_context, errmsg);
572  }
573  }
574  return m;
575  }
std::vector< double > family_state_mix_matrix(str type, int family, str &mass_es1, str &mass_es2, const SubSpectrum &mssm)
identifies the two mass_es which best matches specified family state storing them in strings and then...
EXPORT_SYMBOLS error & utils_error()
Utility errors.
#define LOCAL_INFO
Definition: local_info.hpp:34
virtual void raise(const std::string &)
Raise the exception, i.e. throw it.
Definition: exceptions.cpp:422
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
invalid_point_exception & invalid_point()
Invalid point exceptions.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ family_state_mix_matrix() [2/2]

std::vector<double> Gambit::slhahelp::family_state_mix_matrix ( str  type,
int  family,
str mass_es1,
str mass_es2,
const SubSpectrum mssm 
)

identifies the two mass_es which best matches specified family state storing them in strings and then returns the 2by2 mixing matrix for that family state in the form (Mix_{11}, Mix_{12}, Mix_{21}, Mix_{22}) It also stores the mixing elements for the gauge states that don't belong to the correct family for this state in a std::vector The latter should have entries which are zero in absense of family mixing

get mass_es using one of our routines

need to turn type and family into a string should simplify the number of translations we do!

get index of right family states (ie gauge states with same family as requested family state

Put row 1 and row 2 into the same vector to return

Definition at line 585 of file mssm_slhahelp.cpp.

References Gambit::SubSpectrum::get(), identify_mass_ess_for_family(), LOCAL_INFO, Gambit::Par::Pole_Mixing, and Gambit::utils_error().

590  {
592  sspair mass_ess = identify_mass_ess_for_family(type, family, mssm);
593  mass_es1 = mass_ess.first;
594  mass_es2 = mass_ess.second;
595 
598  p_int_string gen_type(family,type);
599  std::vector<str> gauge_states;
600  try { gauge_states = type_family_to_gauge_states.at(gen_type); }
601  catch (std::out_of_range&) { utils_error().raise(LOCAL_INFO, "Sfermion type or generation index not recognised; use type=~u,~d,~e-, gen=1,2,3."); }
602  str gauge_es_L=gauge_states[0];
603  str gauge_es_R=gauge_states[1];
606  p_int_string gauge_Lindex_type =
607  gauge_label_to_index_type.at(gauge_es_L);
608  unsigned int gauge_L_index = gauge_Lindex_type.first;
609  unsigned int gauge_R_index
610  = (gauge_label_to_index_type.at(gauge_es_R)).first;
611 
612  str type_L = gauge_Lindex_type.second;
613  int mass_index1 = (mass_label_to_index_type.at(mass_es1)).first;
614  int mass_index2 = (mass_label_to_index_type.at(mass_es2)).first;
615  std::vector<double> mix_row_1;
616  std::vector<double> mix_row_2;
617  std::vector<str> gauge_es_strs = type_to_vec_of_gauge_es.at(type);
618  double row_length = gauge_es_strs.size();
619  for(std::vector<int>::size_type i = 1; i <= row_length; i++)
620  {
621  double temp1 = mssm.get(Par::Pole_Mixing,type, mass_index1, i);
622  double temp2 = mssm.get(Par::Pole_Mixing,type, mass_index2, i);
623  if(i == gauge_L_index || i == gauge_R_index)
624  {
625  mix_row_1.push_back(temp1);
626  mix_row_2.push_back(temp2);
627  }
628  }
629 
631  mix_row_1.insert(mix_row_1.end(), mix_row_2.begin(), mix_row_2.end());
632 
633  return mix_row_1;
634  }
std::pair< int, str > p_int_string
Typedefs for pairs that we will use in maps.
EXPORT_SYMBOLS error & utils_error()
Utility errors.
#define LOCAL_INFO
Definition: local_info.hpp:34
std::pair< str, str > sspair
Shorthand for a pair of standard strings.
Definition: util_types.hpp:64
sspair identify_mass_ess_for_family(str type, int family, const SubSpectrum &mssm)
identify the two mass eigenstate corresponding to the approximate family states, e.g.
const std::map< p_int_string, std::vector< str > > type_family_to_gauge_states
const std::map< str, p_int_string > gauge_label_to_index_type
Known maps filled at initialisation.
const std::map< str, p_int_string > mass_label_to_index_type
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
const std::map< str, std::vector< str > > type_to_vec_of_gauge_es
Here is the call graph for this function:

◆ gauge_es_from_mass_es() [1/5]

str Gambit::slhahelp::gauge_es_from_mass_es ( str  mass_es,
double max_mixing,
std::vector< double > &  mass_composition,
const SubSpectrum mssm 
)

identifies gauge_es with largest mass_es content also fills largest max_mixing and full mass_composition

passed in massstate to be set

start with zero

retrive type from the gauge_es string

iterate over vector of strings for mass states

Definition at line 262 of file mssm_slhahelp.cpp.

References get_mixing_element().

Referenced by add_MSSM_spectrum_to_SLHAea(), family_state_closest_to_mass_es(), and gauge_es_from_mass_es().

265  {
267  double temp_admix = 0.0;
269  max_mixing = 0;
271  str type = (mass_label_to_index_type.at(mass_es)).second;
272  str gauge_es, temp_gauge_es;
274  std::vector<str> gauge_es_vec = type_to_vec_of_gauge_es.at(type);
275  typedef std::vector<str>::iterator iter;
276  for(iter it = gauge_es_vec.begin(); it != gauge_es_vec.end(); ++it)
277  {
278  temp_gauge_es = *it;
279  temp_admix = get_mixing_element(temp_gauge_es, mass_es, mssm);
280  mass_composition.push_back(temp_admix);
281  //select largest
282  if(fabs(temp_admix) > fabs(max_mixing))
283  {
284  max_mixing = temp_admix;
285  gauge_es = temp_gauge_es;
286  }
287  } //end iteration over temp_mass_es
288 
289  //return string for closest gauge_es
290  return gauge_es;
291  }
double get_mixing_element(str gauge_es, str mass_es, const SubSpectrum &mssm)
routine to return mass state admixure for given gauge state in the end this is a trival routine but m...
const std::map< str, p_int_string > mass_label_to_index_type
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
const std::map< str, std::vector< str > > type_to_vec_of_gauge_es
Here is the call graph for this function:
Here is the caller graph for this function:

◆ gauge_es_from_mass_es() [2/5]

str Gambit::slhahelp::gauge_es_from_mass_es ( str  mass_es,
double max_mixing,
const SubSpectrum mssm 
)

as above but doesn't fill a gauge_composition vector would have a slight efficiency saving if we didn't use wrapper and avoided skipped gauge_composition entirely but at the cost of a lot of code duplication

Definition at line 297 of file mssm_slhahelp.cpp.

References gauge_es_from_mass_es().

299  {
300  std::vector<double> mass_composition;
301  str gauge_es = gauge_es_from_mass_es(mass_es, max_mixing,
302  mass_composition, mssm);
303  return gauge_es;
304 
305  }
str gauge_es_from_mass_es(str mass_es, const SubSpectrum &mssm, double tol, str context, bool pterror)
as above but do test against tol internally
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
Here is the call graph for this function:

◆ gauge_es_from_mass_es() [3/5]

str Gambit::slhahelp::gauge_es_from_mass_es ( str  mass_es,
std::vector< double > &  mass_composition,
const SubSpectrum mssm 
)

as above but doesn't fill max_mixing would have a slight efficiency saving if we didn't use wrapper and avoided skipped max_mixing entirely but at the cost of a lot of code duplication

Definition at line 311 of file mssm_slhahelp.cpp.

References gauge_es_from_mass_es().

314  {
315  double max_mixing;
316  str gauge_es = gauge_es_from_mass_es(mass_es, max_mixing,
317  mass_composition, mssm);
318 
319  return gauge_es;
320  }
str gauge_es_from_mass_es(str mass_es, const SubSpectrum &mssm, double tol, str context, bool pterror)
as above but do test against tol internally
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
Here is the call graph for this function:

◆ gauge_es_from_mass_es() [4/5]

str Gambit::slhahelp::gauge_es_from_mass_es ( str  mass_es,
const SubSpectrum mssm 
)

as above but doesn't fill max_mixing or gauge_composition would have a slight efficiency saving if we didn't use wrapper and avoided skipped max_mixing entirely but at the cost of a lot of code duplication

Definition at line 326 of file mssm_slhahelp.cpp.

References gauge_es_from_mass_es().

328  {
329  double max_mixing;
330  std::vector<double> mass_composition;
331  str gauge_es = gauge_es_from_mass_es(mass_es, max_mixing,
332  mass_composition, mssm);
333 
334  return gauge_es;
335  }
str gauge_es_from_mass_es(str mass_es, const SubSpectrum &mssm, double tol, str context, bool pterror)
as above but do test against tol internally
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
Here is the call graph for this function:

◆ gauge_es_from_mass_es() [5/5]

str Gambit::slhahelp::gauge_es_from_mass_es ( str  mass_es,
const SubSpectrum mssm,
double  tol,
str  context,
bool  pterror 
)

as above but do test against tol internally

Definition at line 338 of file mssm_slhahelp.cpp.

References gauge_es_from_mass_es(), Gambit::invalid_point(), LOCAL_INFO, Gambit::invalid_point_exception::raise(), and Gambit::utils_error().

340  {
341  double max_mixing;
342  std::vector<double> mass_composition;
343  str gauge_es = gauge_es_from_mass_es(mass_es, max_mixing,
344  mass_composition, mssm);
345  if((max_mixing*max_mixing) <= 1-tol)
346  {
347  const str errmsg = "Gauge_es from mass_es requested when mxing away "
348  "from closest mass_es is greater than tol";
349  str full_context = LOCAL_INFO + " called from " + context;
350  if (pterror)
351  {
352  invalid_point().raise(errmsg+" Raised at: "+full_context);
353  }
354  else
355  {
356  utils_error().raise(full_context, errmsg);
357  }
358  }
359  return gauge_es;
360  }
EXPORT_SYMBOLS error & utils_error()
Utility errors.
#define LOCAL_INFO
Definition: local_info.hpp:34
str gauge_es_from_mass_es(str mass_es, const SubSpectrum &mssm, double tol, str context, bool pterror)
as above but do test against tol internally
virtual void raise(const std::string &)
Raise the exception, i.e. throw it.
Definition: exceptions.cpp:422
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
invalid_point_exception & invalid_point()
Invalid point exceptions.
Here is the call graph for this function:

◆ get_gauge_admix_for_family_state()

double Gambit::slhahelp::get_gauge_admix_for_family_state ( str  familystate,
str  gauge_es,
str mass_es,
const SubSpectrum mssm 
)

returns admix of gauge eigenstate in the mass eigenstate closest to the given family state and stores mass eigenstate in mass_es

types should match but getting both allows us to throw error

throw error in gambit

get mass_es using one of our routines

extract info from strings via maps

Definition at line 639 of file mssm_slhahelp.cpp.

References Gambit::SubSpectrum::get(), LOCAL_INFO, mass_es_closest_to_family(), Gambit::Par::Pole_Mixing, and Gambit::utils_error().

643  {
644  pair_string_ints type_family_massorder;
645  try { type_family_massorder = familystate_label.at(familystate); }
646  catch (std::out_of_range&) { utils_error().raise(LOCAL_INFO, "Unrecognised family state."); }
647  str family_type = type_family_massorder.first;
648  p_int_string gauge_es_index_type = gauge_label_to_index_type.at(gauge_es);
649  int gauge_index = gauge_es_index_type.first;
651  str type_gauge = gauge_es_index_type.second;
652  if(family_type!=type_gauge)
653  {
654  utils_error().raise(LOCAL_INFO, "function get_gauge_admix_for_family_state "
655  "called with types for the family state and mass eigenstate that don't match.");
656  }
658  mass_es = mass_es_closest_to_family(familystate, mssm);
660  int mass_index = (mass_label_to_index_type.at(mass_es)).first;
661  double admix = mssm.get(Par::Pole_Mixing,type_gauge, mass_index,
662  gauge_index);
663  return admix;
664  }
std::pair< int, str > p_int_string
Typedefs for pairs that we will use in maps.
EXPORT_SYMBOLS error & utils_error()
Utility errors.
str mass_es_closest_to_family(str familystate, const SubSpectrum &mssm, double tol, str context, bool pterror)
identifies the mass_es that is closest match to specified family does tol-test internally to check co...
const std::map< str, pair_string_ints > familystate_label
std::pair< str, pair_ints > pair_string_ints
#define LOCAL_INFO
Definition: local_info.hpp:34
const std::map< str, p_int_string > gauge_label_to_index_type
Known maps filled at initialisation.
const std::map< str, p_int_string > mass_label_to_index_type
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
Here is the call graph for this function:

◆ get_gauge_comp_for_family_state()

std::vector<double> Gambit::slhahelp::get_gauge_comp_for_family_state ( str  familystate,
str mass_es,
const SubSpectrum mssm 
)

returns vector with composition of closest the mass eigenstate to give family state in terms of gauge eigenstates and stores mass eigenstate in mass_es

extract info from strings via maps

Definition at line 437 of file mssm_slhahelp.cpp.

References get_Pole_Mixing_row(), and mass_es_closest_to_family().

440  {
441  //get mass_es using one of our routines
442  mass_es = mass_es_closest_to_family(familystate, mssm);
444  int mass_index = (mass_label_to_index_type.at(mass_es)).first;
445  pair_string_ints state_info = familystate_label.at(familystate);
446  str type = state_info.first;
447  std::vector<double> gauge_es_content =
448  get_Pole_Mixing_row(type, mass_index,mssm);
449 
450  return gauge_es_content;
451 
452  }
str mass_es_closest_to_family(str familystate, const SubSpectrum &mssm, double tol, str context, bool pterror)
identifies the mass_es that is closest match to specified family does tol-test internally to check co...
const std::map< str, pair_string_ints > familystate_label
std::pair< str, pair_ints > pair_string_ints
std::vector< double > get_Pole_Mixing_row(str type, int mass_index, const SubSpectrum &mssm)
const std::map< str, p_int_string > mass_label_to_index_type
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
Here is the call graph for this function:

◆ get_gauge_comp_for_mass()

std::vector<double> Gambit::slhahelp::get_gauge_comp_for_mass ( str  mass_es,
const SubSpectrum mssm 
)

returns vector representing composition of requested mass eigenstate in terms of the slha2 gauge eigenstates (~u_L,~c_L,...~t_R etc) which is just a row in the mixing matrix just wraps get_Pole_Mixing_row after extracting info from string

extract info using map

Definition at line 147 of file mssm_slhahelp.cpp.

References get_Pole_Mixing_row().

148  {
150  p_int_string index_type = mass_label_to_index_type.at(mass_es);
151  int mass_index = index_type.first;
152  str type = index_type.second;
153  //fill vector with mixings
154  std::vector<double> mass_state_content =
155  get_Pole_Mixing_row(type, mass_index, mssm);
156 
157  return mass_state_content;
158  }
std::pair< int, str > p_int_string
Typedefs for pairs that we will use in maps.
std::vector< double > get_Pole_Mixing_row(str type, int mass_index, const SubSpectrum &mssm)
const std::map< str, p_int_string > mass_label_to_index_type
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
Here is the call graph for this function:

◆ get_mass_comp_for_gauge()

std::vector<double> Gambit::slhahelp::get_mass_comp_for_gauge ( str  gauge_es,
const SubSpectrum mssm 
)

returns vector representing composition of requested gauge state in terms of the slha2 mass eigenstates (~u_1 ...~u_6 etc) which is just a column in the mixing matrix

extract info from string via map

Definition at line 105 of file mssm_slhahelp.cpp.

References get_Pole_Mixing_col().

107  {
109  p_int_string index_type = gauge_label_to_index_type.at(gauge_es);
110  str type = index_type.second;
111  int gauge_index = index_type.first;
112 
113  std::vector<double> mass_state_content =
114  get_Pole_Mixing_col(type, gauge_index, mssm);
115 
116  return mass_state_content;
117  }
std::pair< int, str > p_int_string
Typedefs for pairs that we will use in maps.
std::vector< double > get_Pole_Mixing_col(str type, int gauge_index, const SubSpectrum &mssm)
const std::map< str, p_int_string > gauge_label_to_index_type
Known maps filled at initialisation.
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
Here is the call graph for this function:

◆ get_mixing_element()

double Gambit::slhahelp::get_mixing_element ( str  gauge_es,
str  mass_es,
const SubSpectrum mssm 
)

routine to return mass state admixure for given gauge state in the end this is a trival routine but may help

extract info from maps

types should match but getting both allows us to throw error

throw exception in gambit

will need to add mssm object to cal method in gambit

Definition at line 121 of file mssm_slhahelp.cpp.

References Gambit::SubSpectrum::get(), LOCAL_INFO, Gambit::Par::Pole_Mixing, and Gambit::utils_error().

Referenced by gauge_es_from_mass_es(), and mass_es_from_gauge_es().

122  {
124  p_int_string mass_es_index_type = mass_label_to_index_type.at(mass_es);
125  p_int_string gauge_es_index_type = gauge_label_to_index_type.at(gauge_es);
126  int gauge_index = gauge_es_index_type.first;
127  int mass_index = mass_es_index_type.first;
129  str type = mass_es_index_type.second;
130  str type_gauge = gauge_es_index_type.second;
131  if(type!=type_gauge)
132  {
134  utils_error().raise(LOCAL_INFO, "function get_mixing_element "
135  "called with types for the gauge eigenstate and mass eigenstate that don't match.");
136  }
138  double admix = mssm.get(Par::Pole_Mixing,type, mass_index,
139  gauge_index);
140  return admix;
141  }
std::pair< int, str > p_int_string
Typedefs for pairs that we will use in maps.
EXPORT_SYMBOLS error & utils_error()
Utility errors.
#define LOCAL_INFO
Definition: local_info.hpp:34
const std::map< str, p_int_string > gauge_label_to_index_type
Known maps filled at initialisation.
const std::map< str, p_int_string > mass_label_to_index_type
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
Here is the call graph for this function:
Here is the caller graph for this function:

◆ get_Pole_Mixing_col()

std::vector<double> Gambit::slhahelp::get_Pole_Mixing_col ( str  type,
int  gauge_index,
const SubSpectrum mssm 
)

Definition at line 47 of file mssm_slhahelp.cpp.

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

Referenced by get_mass_comp_for_gauge().

48  {
49  //extract info about indices for type using map
50  std::vector<str> mass_es_strs = type_to_vec_of_mass_es.at(type);
51  double col_length = mass_es_strs.size();
52  std::vector<double> mass_state_content(col_length);
53  //iterate over column in some way, e..g
54  for(std::vector<int>::size_type i = 1; i <= col_length; i++)
55  {
56  //Mix_{row, col}. Iterate through row index with column index fixed
57  mass_state_content[i - 1] = mssm.get(Par::Pole_Mixing,type, i, gauge_index);
58  }
59  return mass_state_content;
60  }
const std::map< str, std::vector< str > > type_to_vec_of_mass_es
Here is the call graph for this function:
Here is the caller graph for this function:

◆ get_Pole_Mixing_row()

std::vector<double> Gambit::slhahelp::get_Pole_Mixing_row ( str  type,
int  mass_index,
const SubSpectrum mssm 
)

Mix_{row, col}. Iterate through column index with row index fixed

Definition at line 61 of file mssm_slhahelp.cpp.

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

Referenced by get_gauge_comp_for_family_state(), and get_gauge_comp_for_mass().

62  {
63  std::vector<str> gauge_es_strs = type_to_vec_of_gauge_es.at(type);
64  double row_length = gauge_es_strs.size();
65  std::vector<double> gauge_state_content(row_length);
66  for(std::vector<int>::size_type i = 1; i <= row_length; i++)
67  {
69  gauge_state_content.at(i - 1) = mssm.get(Par::Pole_Mixing,type, mass_index, i);
70  }
71  return gauge_state_content;
72  }
const std::map< str, std::vector< str > > type_to_vec_of_gauge_es
Here is the call graph for this function:
Here is the caller graph for this function:

◆ identify_mass_ess_for_family()

sspair Gambit::slhahelp::identify_mass_ess_for_family ( str  type,
int  family,
const SubSpectrum mssm 
)

identify the two mass eigenstate corresponding to the approximate family states, e.g.

stops ("~u",3), smuons ("~mu", 2) etc Note: when there is family mixing there's no good definition ~t_1, ~t_2 etc if defined as the states you get from diagonalising a 2by2 mass (sub)matrix then extensive manipulations would be required So here we identify the mass eigenstates closest to the family ones which is a better defined question when there is family mixing prsesent and more useful here anyway returns a pair of strings labling the lighter one first

need to turn type and family into a string need to simplify the number of translations we do.

finds the mass_es with the largets mixing to passed gauge_es

Definition at line 371 of file mssm_slhahelp.cpp.

References LOCAL_INFO, mass_es_from_gauge_es(), and Gambit::utils_error().

Referenced by family_state_mix_matrix().

374  {
377  p_int_string gen_type(family,type);
378  std::vector<str> gauge_states;
379  try { gauge_states = type_family_to_gauge_states.at(gen_type); }
380  catch (std::out_of_range&) { utils_error().raise(LOCAL_INFO, "Sfermion type or generation index not recognised; use type=~u,~d,~e-, gen=1,2,3."); }
381  str gauge_esL=gauge_states[0];
382  str gauge_esR=gauge_states[1];
383 
386  str mass_esL = mass_es_from_gauge_es(gauge_esL, mssm);
387  str mass_esR = mass_es_from_gauge_es(gauge_esR, mssm);
388 
389  sspair answer;
390  int mass_index_L = (mass_label_to_index_type.at(mass_esL)).first;
391  int mass_index_R = (mass_label_to_index_type.at(mass_esR)).first;
392  // order pair by mass
393  if(mass_index_L < mass_index_R)
394  answer = std::make_pair(mass_esL,mass_esR);
395  else answer = std::make_pair(mass_esR,mass_esL);
396 
397  return answer;
398  }
std::pair< int, str > p_int_string
Typedefs for pairs that we will use in maps.
EXPORT_SYMBOLS error & utils_error()
Utility errors.
str mass_es_from_gauge_es(str gauge_es, const SubSpectrum &mssm, double tol, str context, bool pterror)
as above but do test against tol internally
#define LOCAL_INFO
Definition: local_info.hpp:34
std::pair< str, str > sspair
Shorthand for a pair of standard strings.
Definition: util_types.hpp:64
const std::map< p_int_string, std::vector< str > > type_family_to_gauge_states
const std::map< str, p_int_string > mass_label_to_index_type
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
Here is the call graph for this function:
Here is the caller graph for this function:

◆ init_family_state_to_gauge_state()

std::map< str, std::vector< str > > Gambit::slhahelp::init_family_state_to_gauge_state ( )

maps directly from family string to left_right gauge_pairs helps us reuse other routines that take string arguments

Definition at line 440 of file ini_functions.cpp.

References family_state_to_gauge_state.

441  {
442  std::map<str, std::vector<str> > family_state_to_gauge_state;
443 
444  family_state_to_gauge_state["~t_1"] = initVector<str>("~t_L","~t_R");
445  family_state_to_gauge_state["~t_2"] = initVector<str>("~t_L","~t_R");
446  family_state_to_gauge_state["~b_1"] = initVector<str>("~b_L","~b_R");
447  family_state_to_gauge_state["~b_2"] = initVector<str>("~b_L","~b_R");
448  family_state_to_gauge_state["~tau_1"] = initVector<str>("~tau_L","~tau_R");
449  family_state_to_gauge_state["~tau_2"] = initVector<str>("~tau_L","~tau_R");
450 
451  family_state_to_gauge_state["~c_1"] = initVector<str>("~c_L","~c_R");
452  family_state_to_gauge_state["~c_2"] = initVector<str>("~c_L","~c_R");
453  family_state_to_gauge_state["~s_1"] = initVector<str>("~s_L","~s_R");
454  family_state_to_gauge_state["~s_2"] = initVector<str>("~s_L","~s_R");
455  family_state_to_gauge_state["~muon_1"] = initVector<str>("~mu_L","~mu_R");
456  family_state_to_gauge_state["~muon_2"] = initVector<str>("~mu_L","~mu_R");
457 
458  family_state_to_gauge_state["~u_1"] = initVector<str>("~u_L","~u_R");
459  family_state_to_gauge_state["~u_2"] = initVector<str>("~u_L","~u_R");
460  family_state_to_gauge_state["~d_1"] = initVector<str>("~d_L","~d_R");
461  family_state_to_gauge_state["~d_2"] = initVector<str>("~d_L","~d_R");
462  family_state_to_gauge_state["~e-_1"] = initVector<str>("~e_L","~e_R");
463  family_state_to_gauge_state["~e-_2"] = initVector<str>("~e_L","~e_R");
464 
466  }
const std::map< str, std::vector< str > > family_state_to_gauge_state

◆ init_familystate_label()

std::map< str, pair_string_ints > Gambit::slhahelp::init_familystate_label ( )

map to extract info from family state

Definition at line 350 of file ini_functions.cpp.

References familystate_label.

351  {
352  std::map<str, pair_string_ints> familystate_label;
353 
354  //pairs labeling family, mass
355  pair_ints const three_one(3,1);
356  pair_ints const three_two(3,2);
357  pair_ints const two_one(3,1);
358  pair_ints const two_two(3,2);
359  pair_ints const one_one(3,1);
360  pair_ints const one_two(3,2);
361 
362  //triplet labelling type, generation and mass order of family states
363  pair_string_ints const stop1("~u",three_one);
364  pair_string_ints const stop2("~u",three_two);
365  pair_string_ints const sbot1("~d",three_one);
366  pair_string_ints const sbot2("~d",three_two);
367  pair_string_ints const stau1("~e-",three_one);
368  pair_string_ints const stau2("~e-",three_two);
369  pair_string_ints const scharm1("~u",two_one);
370  pair_string_ints const scharm2("~u",two_two);
371  pair_string_ints const sstrange1("~d",two_one);
372  pair_string_ints const sstrange2("~d",two_two);
373  pair_string_ints const smuon1("~e-",two_one);
374  pair_string_ints const smuon2("~e-",two_two);
375  pair_string_ints const sup1("~u",one_one);
376  pair_string_ints const sup2("~u",one_two);
377  pair_string_ints const sdown1("~d",one_one);
378  pair_string_ints const sdown2("~d",one_two);
379  pair_string_ints const selectron1("~e-",one_one);
380  pair_string_ints const selectron2("~e-",one_two);
381 
382  // only have left handed sneutrinos in MSSM
383  pair_string_ints const snue1("~nu",three_one);
384  pair_string_ints const snumu1("~nu",two_one);
385  pair_string_ints const snutau1("~nu",one_one);
386 
387  familystate_label["~t_1"] = stop1;
388  familystate_label["~t_2"] = stop2;
389  familystate_label["~b_1"] = sbot1;
390  familystate_label["~b_2"] = sbot2;
391  familystate_label["~tau_1"] = stau1;
392  familystate_label["~tau_2"] = stau2;
393 
394  familystate_label["~c_1"] = scharm1;
395  familystate_label["~c_2"] = scharm2;
396  familystate_label["~s_1"] = sstrange1;
397  familystate_label["~s_2"] = sstrange2;
398  familystate_label["~muon_1"] = smuon1;
399  familystate_label["~muon_2"] = smuon2;
400 
401  // maybe we shouldn't do first gen it's confusing
402  familystate_label["~u_1"] = sup1;
403  familystate_label["~u_2"] = sup2;
404  familystate_label["~d_1"] = sdown1;
405  familystate_label["~d_2"] = sdown2;
406  familystate_label["~e-_1"] = selectron1;
407  familystate_label["~e-_2"] = selectron2;
408 
409  // these are even less needed since no l-r mixing without r state
410  familystate_label["~nu_1"] = snue1;
411  familystate_label["~nu_2"] = snumu1;
412  familystate_label["~nu_3"] = snutau1;
413 
414  return familystate_label;
415 
416  }
const std::map< str, pair_string_ints > familystate_label
std::pair< str, pair_ints > pair_string_ints
std::pair< int, int > pair_ints

◆ init_gauge_es_to_family_states()

std::map< str, std::vector< str > > Gambit::slhahelp::init_gauge_es_to_family_states ( )

maps directly from gauge_es string to familystates helps us reuse other routines that take string arguments

Definition at line 470 of file ini_functions.cpp.

References gauge_es_to_family_states.

471  {
472  std::map<str, std::vector<str> > gauge_es_to_family_states;
473 
474  gauge_es_to_family_states["~t_L"] = initVector<str>("~t_1","~t_2");
475  gauge_es_to_family_states["~t_R"] = initVector<str>("~t_1","~t_2");
476  gauge_es_to_family_states["~b_L"] = initVector<str>("~b_1","~b_2");
477  gauge_es_to_family_states["~b_R"] = initVector<str>("~b_1","~b_2");
478  gauge_es_to_family_states["~tau_L"] = initVector<str>("~tau_1","~tau_2");
479  gauge_es_to_family_states["~tau_R"] = initVector<str>("~tau_1","~tau_2");
480  gauge_es_to_family_states["~c_L"] = initVector<str>("~c_1","~c_2");
481  gauge_es_to_family_states["~c_R"] = initVector<str>("~c_1","~c_2");
482  gauge_es_to_family_states["~s_L"] = initVector<str>("~s_1","~s_2");
483  gauge_es_to_family_states["~s_R"] = initVector<str>("~s_1","~s_2");
484  gauge_es_to_family_states["~mu_L"] = initVector<str>("~mu_1","~mu_2");
485  gauge_es_to_family_states["~mu_R"] = initVector<str>("~mu_1","~mu_2");
486 
487  gauge_es_to_family_states["~u_L"] = initVector<str>("~u_1","~u_2");
488  gauge_es_to_family_states["~u_R"] = initVector<str>("~u_1","~u_2");
489  gauge_es_to_family_states["~d_L"] = initVector<str>("~d_1","~d_2");
490  gauge_es_to_family_states["~d_R"] = initVector<str>("~d_1","~d_2");
491  gauge_es_to_family_states["~e_L"] = initVector<str>("~e-_1","~e-_2");
492  gauge_es_to_family_states["~e_R"] = initVector<str>("~e-_1","~e-_2");
493 
495  }
const std::map< str, std::vector< str > > gauge_es_to_family_states

◆ init_gauge_label_to_index_type()

std::map< str, p_int_string > Gambit::slhahelp::init_gauge_label_to_index_type ( )

map from gauge eigenstate strings to string, index pairs

Definition at line 285 of file ini_functions.cpp.

References gauge_label_to_index_type.

286  {
287  std::map<str, p_int_string> gauge_label_to_index_type;
288 
289  gauge_label_to_index_type["~e_L"] = std::make_pair(1,"~e-");
290  gauge_label_to_index_type["~mu_L"] = std::make_pair(2,"~e-");
291  gauge_label_to_index_type["~tau_L"] = std::make_pair(3,"~e-");
292  gauge_label_to_index_type["~e_R"] = std::make_pair(4,"~e-");
293  gauge_label_to_index_type["~mu_R"] = std::make_pair(5,"~e-");
294  gauge_label_to_index_type["~tau_R"] = std::make_pair(6,"~e-");
295 
296  gauge_label_to_index_type["~d_L"] = std::make_pair(1,"~d");
297  gauge_label_to_index_type["~s_L"] = std::make_pair(2,"~d");
298  gauge_label_to_index_type["~b_L"] = std::make_pair(3,"~d");
299  gauge_label_to_index_type["~d_R"] = std::make_pair(4,"~d");
300  gauge_label_to_index_type["~s_R"] = std::make_pair(5,"~d");
301  gauge_label_to_index_type["~b_R"] = std::make_pair(6,"~d");
302 
303  gauge_label_to_index_type["~u_L"] = std::make_pair(1,"~u");
304  gauge_label_to_index_type["~c_L"] = std::make_pair(2,"~u");
305  gauge_label_to_index_type["~t_L"] = std::make_pair(3,"~u");
306  gauge_label_to_index_type["~u_R"] = std::make_pair(4,"~u");
307  gauge_label_to_index_type["~c_R"] = std::make_pair(5,"~u");
308  gauge_label_to_index_type["~t_R"] = std::make_pair(6,"~u");
309 
310  gauge_label_to_index_type["~nu_e_L"] = std::make_pair(1,"~nu");
311  gauge_label_to_index_type["~nu_mu_L"] = std::make_pair(2,"~nu");
312  gauge_label_to_index_type["~nu_tau_L"] = std::make_pair(3,"~nu");
313 
315  }
const std::map< str, p_int_string > gauge_label_to_index_type
Known maps filled at initialisation.

◆ init_mass_label_to_index_type()

std::map< str, p_int_string > Gambit::slhahelp::init_mass_label_to_index_type ( )

map from mass eigenstate strings to string, index pairs

Definition at line 318 of file ini_functions.cpp.

References mass_label_to_index_type.

319  {
320  std::map<str, p_int_string> mass_label_to_index_type;
321  mass_label_to_index_type["~e-_1"] = std::make_pair(1,"~e-");
322  mass_label_to_index_type["~e-_2"] = std::make_pair(2,"~e-");
323  mass_label_to_index_type["~e-_3"] = std::make_pair(3,"~e-");
324  mass_label_to_index_type["~e-_4"] = std::make_pair(4,"~e-");
325  mass_label_to_index_type["~e-_5"] = std::make_pair(5,"~e-");
326  mass_label_to_index_type["~e-_6"] = std::make_pair(6,"~e-");
327 
328  mass_label_to_index_type["~d_1"] = std::make_pair(1,"~d");
329  mass_label_to_index_type["~d_2"] = std::make_pair(2,"~d");
330  mass_label_to_index_type["~d_3"] = std::make_pair(3,"~d");
331  mass_label_to_index_type["~d_4"] = std::make_pair(4,"~d");
332  mass_label_to_index_type["~d_5"] = std::make_pair(5,"~d");
333  mass_label_to_index_type["~d_6"] = std::make_pair(6,"~d");
334 
335  mass_label_to_index_type["~u_1"] = std::make_pair(1,"~u");
336  mass_label_to_index_type["~u_2"] = std::make_pair(2,"~u");
337  mass_label_to_index_type["~u_3"] = std::make_pair(3,"~u");
338  mass_label_to_index_type["~u_4"] = std::make_pair(4,"~u");
339  mass_label_to_index_type["~u_5"] = std::make_pair(5,"~u");
340  mass_label_to_index_type["~u_6"] = std::make_pair(6,"~u");
341 
342  mass_label_to_index_type["~nu_1"] = std::make_pair(1,"~nu");
343  mass_label_to_index_type["~nu_2"] = std::make_pair(2,"~nu");
344  mass_label_to_index_type["~nu_3"] = std::make_pair(3,"~nu");
345 
347  }
const std::map< str, p_int_string > mass_label_to_index_type

◆ init_type_family_to_gauge_states()

std::map< p_int_string, std::vector< str > > Gambit::slhahelp::init_type_family_to_gauge_states ( )

map to obtain left_right gauge_pairs from state info helps us reuse other routiones with string arguments

Definition at line 420 of file ini_functions.cpp.

References type_family_to_gauge_states.

421  {
422  std::map<p_int_string, std::vector<str> > type_family_to_gauge_states;
423 
424  type_family_to_gauge_states[std::make_pair(3,"~u")] = initVector<str>("~t_L","~t_R");
425  type_family_to_gauge_states[std::make_pair(3,"~d")] = initVector<str>("~b_L","~b_R");
426  type_family_to_gauge_states[std::make_pair(3,"~e-")]= initVector<str>("~tau_L","~tau_R");
427  type_family_to_gauge_states[std::make_pair(2,"~u")] = initVector<str>("~c_L","~c_R");
428  type_family_to_gauge_states[std::make_pair(2,"~d")] = initVector<str>("~s_L","~s_R");
429  type_family_to_gauge_states[std::make_pair(2,"~e-")]= initVector<str>("~mu_L","~mu_R");
430  type_family_to_gauge_states[std::make_pair(1,"~u")] = initVector<str>("~u_L","~u_R");
431  type_family_to_gauge_states[std::make_pair(1,"~d")] = initVector<str>("~d_L","~d_R");
432  type_family_to_gauge_states[std::make_pair(1,"~e-")]= initVector<str>("~e_L","~e_R");
433  //no sneutrino gauges pairs as no right sneutrino
434 
436  }
const std::map< p_int_string, std::vector< str > > type_family_to_gauge_states

◆ init_type_to_vec_of_gauge_es()

std::map< str, std::vector< str > > Gambit::slhahelp::init_type_to_vec_of_gauge_es ( )

map from string representing type (ie up-squarks, down-squarks or charged sleptons) to appropriate set of gauge eigenstates

Definition at line 513 of file ini_functions.cpp.

References type_to_vec_of_gauge_es.

514  {
515  std::map<str,std::vector<str> > type_to_vec_of_gauge_es;
516 
517  type_to_vec_of_gauge_es["~u"] = initVector<str>("~u_L", "~c_L", "~t_L", "~u_R", "~c_R", "~t_R");
518  type_to_vec_of_gauge_es["~d"] = initVector<str>("~d_L", "~s_L", "~b_L", "~d_R", "~s_R", "~b_R");
519  type_to_vec_of_gauge_es["~e-"] = initVector<str>("~e_L", "~mu_L", "~tau_L", "~e_R", "~mu_R", "~tau_R");
520  type_to_vec_of_gauge_es["~nu"] = initVector<str>("~nu_e_L", "~nu_mu_L", "~nu_tau_L");
521 
523  }
const std::map< str, std::vector< str > > type_to_vec_of_gauge_es

◆ init_type_to_vec_of_mass_es()

std::map< str, std::vector< str > > Gambit::slhahelp::init_type_to_vec_of_mass_es ( )

map from string representing type (ie up-squarks, down-squarks or charged sleptons) to appropriate set of mass eigenstates

Definition at line 499 of file ini_functions.cpp.

References type_to_vec_of_mass_es.

500  {
501  std::map<str,std::vector<str> > type_to_vec_of_mass_es;
502 
503  type_to_vec_of_mass_es["~u"] = initVector<str>("~u_1", "~u_2", "~u_3", "~u_4", "~u_5", "~u_6");
504  type_to_vec_of_mass_es["~d"] = initVector<str>("~d_1", "~d_2", "~d_3", "~d_4", "~d_5", "~d_6");
505  type_to_vec_of_mass_es["~e-"] = initVector<str>("~e-_1", "~e-_2", "~e-_3", "~e-_4", "~e-_5", "~e-_6");
506  type_to_vec_of_mass_es["~nu"] = initVector<str>("~nu_1", "~nu_2", "~nu_3");
507 
508  return type_to_vec_of_mass_es;
509  }
const std::map< str, std::vector< str > > type_to_vec_of_mass_es

◆ mass_es_closest_to_family() [1/5]

str Gambit::slhahelp::mass_es_closest_to_family ( str  familystate,
const SubSpectrum mssm 
)

identify the mass eigenstate corresponding to family state takes string and returns only requested state I suspect this is the more useful one

Definition at line 403 of file mssm_slhahelp.cpp.

References LOCAL_INFO, mass_es_from_gauge_es(), and Gambit::utils_error().

Referenced by add_MSSM_spectrum_to_SLHAea(), Gambit::ColliderBit::ALEPH_Stau_Conservative_LLike(), attempt_to_add_SLHA1_mixing(), get_gauge_admix_for_family_state(), get_gauge_comp_for_family_state(), Gambit::ColliderBit::L3_Stau_Conservative_LLike(), and mass_es_closest_to_family().

405  {
406  std::vector<str> family_gauge_states;
407  try { family_gauge_states = family_state_to_gauge_state.at(familystate); }
408  catch (std::out_of_range&) { utils_error().raise(LOCAL_INFO, "Unrecognised family state. ('"+familystate+"' was requested)"); }
409  str gauge_esL = family_gauge_states[0];
410  str gauge_esR = family_gauge_states[1];
411 
412  // finds the mass_es with the largets mixing to
413  // passed gauge_es
414  str mass_esL = mass_es_from_gauge_es(gauge_esL, mssm);
415  str mass_esR = mass_es_from_gauge_es(gauge_esR, mssm);
416 
417  // extract mass order (1 or 2) from string via map
418  pair_string_ints type_family_massorder =
419  familystate_label.at(familystate);
420  pair_ints family_massorder = type_family_massorder.second;
421  int mass_order = family_massorder.second;
422  // if massorder is 1 choose select from masstateL and mass_esR the one
423  // with the lowest index else take highest
424  int massorderL = (mass_label_to_index_type.at(mass_esL)).first;
425  int massorderR = (mass_label_to_index_type.at(mass_esR)).first;
426  str answer;
427  if( (mass_order == 1 && massorderL < massorderR) ||
428  (mass_order == 2 && massorderL > massorderR) ) answer = mass_esL;
429  else answer = mass_esR;
430 
431  return answer;
432  }
EXPORT_SYMBOLS error & utils_error()
Utility errors.
const std::map< str, pair_string_ints > familystate_label
str mass_es_from_gauge_es(str gauge_es, const SubSpectrum &mssm, double tol, str context, bool pterror)
as above but do test against tol internally
std::pair< str, pair_ints > pair_string_ints
#define LOCAL_INFO
Definition: local_info.hpp:34
std::pair< int, int > pair_ints
const std::map< str, p_int_string > mass_label_to_index_type
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
const std::map< str, std::vector< str > > family_state_to_gauge_state
Here is the call graph for this function:
Here is the caller graph for this function:

◆ mass_es_closest_to_family() [2/5]

str Gambit::slhahelp::mass_es_closest_to_family ( str  familystate,
std::vector< double > &  gauge_composition,
std::vector< double > &  off_family_mixing,
const SubSpectrum mssm 
)

identifies the mass_es that is closest match to specified family state and fills mixture of the two gauge states with same family into std::vector gauge_composition also fills remaining off-family mixings into a second vector

extract info from strings via maps

Definition at line 458 of file mssm_slhahelp.cpp.

References Gambit::SubSpectrum::get(), LOCAL_INFO, mass_es_closest_to_family(), Gambit::Par::Pole_Mixing, and Gambit::utils_error().

462  {
463  //get mass_es using one of our routines
464  str mass_es = mass_es_closest_to_family(familystate, mssm);
466  std::vector<str> gauge_states;
467  try { gauge_states = family_state_to_gauge_state.at(familystate); }
468  catch (std::out_of_range&) { utils_error().raise(LOCAL_INFO, "Unrecognised family state. ('"+familystate+"' was requested)"); }
469  str gauge_state_L = gauge_states[0];
470  str gauge_state_R = gauge_states[1];
471 
472  p_int_string gauge_Lindex_type =
473  gauge_label_to_index_type.at(gauge_state_L);
474  unsigned int gauge_L_index = gauge_Lindex_type.first;
475  str type = gauge_Lindex_type.second;
476  unsigned int gauge_R_index
477  = (gauge_label_to_index_type.at(gauge_state_R)).first;
478  int mass_index = (mass_label_to_index_type.at(mass_es)).first;
479  std::vector<str> gauge_es_strs = type_to_vec_of_gauge_es.at(type);
480  double row_length = gauge_es_strs.size();
481  for(std::vector<int>::size_type i = 1; i <= row_length; i++)
482  {
483  double temp = mssm.get(Par::Pole_Mixing,type, mass_index, i);
484  if(i == gauge_L_index || i == gauge_R_index)
485  gauge_composition.push_back(temp);
486  else off_family_mixing.push_back(temp);
487  }
488 
489  return mass_es;
490 
491  }
std::pair< int, str > p_int_string
Typedefs for pairs that we will use in maps.
EXPORT_SYMBOLS error & utils_error()
Utility errors.
str mass_es_closest_to_family(str familystate, const SubSpectrum &mssm, double tol, str context, bool pterror)
identifies the mass_es that is closest match to specified family does tol-test internally to check co...
#define LOCAL_INFO
Definition: local_info.hpp:34
const std::map< str, p_int_string > gauge_label_to_index_type
Known maps filled at initialisation.
const std::map< str, p_int_string > mass_label_to_index_type
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
const std::map< str, std::vector< str > > type_to_vec_of_gauge_es
const std::map< str, std::vector< str > > family_state_to_gauge_state
Here is the call graph for this function:

◆ mass_es_closest_to_family() [3/5]

str Gambit::slhahelp::mass_es_closest_to_family ( str  familystate,
std::vector< double > &  gauge_composition,
const SubSpectrum mssm 
)

identifies the mass_es that is closest match to specified family state and fills mixture of the two gauge states with same family into std::vector gauge_composition

Definition at line 496 of file mssm_slhahelp.cpp.

References mass_es_closest_to_family().

499  {
500  std::vector<double> off_family_mixing;
501  str mass_es = mass_es_closest_to_family(familystate, gauge_composition,
502  off_family_mixing, mssm);
503  return mass_es;
504 
505  }
str mass_es_closest_to_family(str familystate, const SubSpectrum &mssm, double tol, str context, bool pterror)
identifies the mass_es that is closest match to specified family does tol-test internally to check co...
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
Here is the call graph for this function:

◆ mass_es_closest_to_family() [4/5]

str Gambit::slhahelp::mass_es_closest_to_family ( str  familystate,
double sqr_sum_mix,
const SubSpectrum mssm 
)

identifies the mass_es that is closest match to specified family state and fills sqr_sum_mix with the square sum of each of the two mixings into gauge_es of that family

Definition at line 510 of file mssm_slhahelp.cpp.

References mass_es_closest_to_family().

513  {
514  std::vector<double> off_family_mixing;
515  std::vector<double> gauge_composition;
516  str mass_es = mass_es_closest_to_family(familystate, gauge_composition,
517  off_family_mixing, mssm);
518  sqr_sum_mix = gauge_composition[0] * gauge_composition[0];
519  sqr_sum_mix += gauge_composition[1] * gauge_composition[1];
520  return mass_es;
521 
522  }
str mass_es_closest_to_family(str familystate, const SubSpectrum &mssm, double tol, str context, bool pterror)
identifies the mass_es that is closest match to specified family does tol-test internally to check co...
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
Here is the call graph for this function:

◆ mass_es_closest_to_family() [5/5]

str Gambit::slhahelp::mass_es_closest_to_family ( str  familystate,
const SubSpectrum mssm,
double  tol,
str  context,
bool  pterror 
)

identifies the mass_es that is closest match to specified family does tol-test internally to check correctness of assumptions

Definition at line 526 of file mssm_slhahelp.cpp.

References Gambit::invalid_point(), LOCAL_INFO, mass_es_closest_to_family(), Gambit::invalid_point_exception::raise(), and Gambit::utils_error().

528  {
529  std::vector<double> off_family_mixing;
530  std::vector<double> gauge_composition;
531  str mass_es = mass_es_closest_to_family(familystate, gauge_composition,
532  off_family_mixing, mssm);
533  double sqr_sum_mix = gauge_composition[0] * gauge_composition[0];
534  sqr_sum_mix += gauge_composition[1] * gauge_composition[1];
535  if(sqr_sum_mix <= 1-tol)
536  {
537  const str errmsg = "Mass_es_closest_to_family requested when family "
538  "mixing away from closest mass_es is greater than tol";
539  str full_context = LOCAL_INFO + " called from " + context;
540  if (pterror)
541  {
542  invalid_point().raise(errmsg+" Raised at: "+full_context);
543  }
544  else
545  {
546  utils_error().raise(full_context, errmsg);
547  }
548  }
549 
550  return mass_es;
551 
552  }
EXPORT_SYMBOLS error & utils_error()
Utility errors.
str mass_es_closest_to_family(str familystate, const SubSpectrum &mssm, double tol, str context, bool pterror)
identifies the mass_es that is closest match to specified family does tol-test internally to check co...
#define LOCAL_INFO
Definition: local_info.hpp:34
virtual void raise(const std::string &)
Raise the exception, i.e. throw it.
Definition: exceptions.cpp:422
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
invalid_point_exception & invalid_point()
Invalid point exceptions.
Here is the call graph for this function:

◆ mass_es_from_gauge_es() [1/5]

str Gambit::slhahelp::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_composition

passed in massstate to be set

make sure this is zero to start

retrive type from the gauge_es string

iterate over vector of strings for mass states

Definition at line 162 of file mssm_slhahelp.cpp.

References get_mixing_element().

Referenced by Gambit::SpecBit::add_extra_MSSM_parameter_combinations(), add_MSSM_spectrum_to_SLHAea(), Gambit::ColliderBit::ALEPH_Selectron_Conservative_LLike(), Gambit::ColliderBit::ALEPH_Smuon_Conservative_LLike(), Gambit::DecayBit::check_first_sec_gen_mixing(), family_state_closest_to_mass_es(), Gambit::ColliderBit::get_sigma_ee_chi00(), Gambit::ColliderBit::get_sigma_ee_chipm(), Gambit::ColliderBit::get_sigma_ee_ll(), identify_mass_ess_for_family(), Gambit::ColliderBit::L3_Selectron_Conservative_LLike(), Gambit::ColliderBit::L3_Smuon_Conservative_LLike(), mass_es_closest_to_family(), mass_es_from_gauge_es(), Gambit::ColliderBit::OPAL_Chargino_All_Channels_Conservative_LLike(), Gambit::ColliderBit::OPAL_Chargino_Leptonic_Conservative_LLike(), and Gambit::ColliderBit::OPAL_Chargino_SemiLeptonic_Conservative_LLike().

165  {
167  double temp_admix = 0.0;
169  max_mixing = 0;
171  str type = (gauge_label_to_index_type.at(gauge_es)).second;
172  str mass_es, temp_mass_es;
174  std::vector<str> mass_es_set = type_to_vec_of_mass_es.at(type);
175  typedef std::vector<str>::iterator iter;
176  for(iter it = mass_es_set.begin(); it != mass_es_set.end(); ++it){
177  temp_mass_es = *it;
178  temp_admix = get_mixing_element(gauge_es, temp_mass_es,
179  mssm);
180  gauge_composition.push_back(temp_admix);
181  //select largest
182  if(fabs(temp_admix) > fabs(max_mixing))
183  {
184  max_mixing = temp_admix;
185  mass_es = temp_mass_es;
186  }
187  } //end iteration over temp_mass_es
188 
189  return mass_es;
190  }
double get_mixing_element(str gauge_es, str mass_es, const SubSpectrum &mssm)
routine to return mass state admixure for given gauge state in the end this is a trival routine but m...
const std::map< str, p_int_string > gauge_label_to_index_type
Known maps filled at initialisation.
const std::map< str, std::vector< str > > type_to_vec_of_mass_es
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
Here is the call graph for this function:
Here is the caller graph for this function:

◆ mass_es_from_gauge_es() [2/5]

str Gambit::slhahelp::mass_es_from_gauge_es ( str  gauge_es,
double max_mixing,
const SubSpectrum mssm 
)

as above but doesn't fill a gauge_composition vector would have a slight efficiency saving if we didn't use wrapper and avoided skipped gauge_composition entirely but at the cost of a lot of code duplication

Definition at line 196 of file mssm_slhahelp.cpp.

References mass_es_from_gauge_es().

198  {
199  std::vector<double> gauge_composition;
200  str mass_es = mass_es_from_gauge_es(gauge_es, max_mixing,
201  gauge_composition, mssm);
202  return mass_es;
203 
204  }
str mass_es_from_gauge_es(str gauge_es, const SubSpectrum &mssm, double tol, str context, bool pterror)
as above but do test against tol internally
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
Here is the call graph for this function:

◆ mass_es_from_gauge_es() [3/5]

str Gambit::slhahelp::mass_es_from_gauge_es ( str  gauge_es,
std::vector< double > &  gauge_composition,
const SubSpectrum mssm 
)

as above but doesn't fill max_mixing would have a slight efficiency saving if we didn't use wrapper and avoided skipped max_mixing entirely but at the cost of a lot of code duplication

Definition at line 210 of file mssm_slhahelp.cpp.

References mass_es_from_gauge_es().

213  {
214  double max_mixing = 0;
215  str mass_es = mass_es_from_gauge_es(gauge_es, max_mixing,
216  gauge_composition, mssm);
217 
218  return mass_es;
219  }
str mass_es_from_gauge_es(str gauge_es, const SubSpectrum &mssm, double tol, str context, bool pterror)
as above but do test against tol internally
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
Here is the call graph for this function:

◆ mass_es_from_gauge_es() [4/5]

str Gambit::slhahelp::mass_es_from_gauge_es ( str  gauge_es,
const SubSpectrum mssm 
)

as above but doesn't fill max_mixing or gauge_composition would have a slight efficiency saving if we didn't use wrapper and avoided skipped max_mixing entirely but at the cost of a lot of code duplication

Definition at line 225 of file mssm_slhahelp.cpp.

References mass_es_from_gauge_es().

227  {
228  double max_mixing = 0;
229  std::vector<double> gauge_composition;
230  str mass_es = mass_es_from_gauge_es(gauge_es, max_mixing,
231  gauge_composition, mssm);
232  return mass_es;
233  }
str mass_es_from_gauge_es(str gauge_es, const SubSpectrum &mssm, double tol, str context, bool pterror)
as above but do test against tol internally
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
Here is the call graph for this function:

◆ mass_es_from_gauge_es() [5/5]

str Gambit::slhahelp::mass_es_from_gauge_es ( str  gauge_es,
const SubSpectrum mssm,
double  tol,
str  context,
bool  pterror 
)

as above but do test against tol internally

Definition at line 236 of file mssm_slhahelp.cpp.

References Gambit::invalid_point(), LOCAL_INFO, mass_es_from_gauge_es(), Gambit::invalid_point_exception::raise(), and Gambit::utils_error().

238  {
239  double max_mixing = 0;
240  std::vector<double> gauge_composition;
241  str mass_es = mass_es_from_gauge_es(gauge_es, max_mixing,
242  gauge_composition, mssm);
243  if((max_mixing*max_mixing) <= 1-tol)
244  {
245  const str errmsg = "Mass_es_from_gauge_es requested when mixing "
246  "away from closest gauge_es is greater than tol.";
247  str full_context = LOCAL_INFO + " called from " + context;
248  if (pterror)
249  {
250  invalid_point().raise(errmsg+" Raised at: "+full_context);
251  }
252  else
253  {
254  utils_error().raise(full_context, errmsg);
255  }
256  }
257  return mass_es;
258  }
EXPORT_SYMBOLS error & utils_error()
Utility errors.
str mass_es_from_gauge_es(str gauge_es, const SubSpectrum &mssm, double tol, str context, bool pterror)
as above but do test against tol internally
#define LOCAL_INFO
Definition: local_info.hpp:34
virtual void raise(const std::string &)
Raise the exception, i.e. throw it.
Definition: exceptions.cpp:422
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
invalid_point_exception & invalid_point()
Invalid point exceptions.
Here is the call graph for this function:

Variable Documentation

◆ family_state_to_gauge_state

const std::map<str,std::vector<str> > Gambit::slhahelp::family_state_to_gauge_state = init_family_state_to_gauge_state()

Definition at line 40 of file mssm_slhahelp.cpp.

Referenced by init_family_state_to_gauge_state().

◆ familystate_label

const std::map<str, pair_string_ints> Gambit::slhahelp::familystate_label = init_familystate_label()

Definition at line 38 of file mssm_slhahelp.cpp.

Referenced by init_familystate_label().

◆ gauge_es_to_family_states

const std::map<str,std::vector<str> > Gambit::slhahelp::gauge_es_to_family_states = init_gauge_es_to_family_states()

Definition at line 41 of file mssm_slhahelp.cpp.

Referenced by init_gauge_es_to_family_states().

◆ gauge_label_to_index_type

const std::map<str, p_int_string> Gambit::slhahelp::gauge_label_to_index_type = init_gauge_label_to_index_type()

Known maps filled at initialisation.

Definition at line 36 of file mssm_slhahelp.cpp.

Referenced by init_gauge_label_to_index_type().

◆ mass_label_to_index_type

const std::map<str, p_int_string> Gambit::slhahelp::mass_label_to_index_type = init_mass_label_to_index_type()

Definition at line 37 of file mssm_slhahelp.cpp.

Referenced by init_mass_label_to_index_type().

◆ type_family_to_gauge_states

const std::map<p_int_string, std::vector<str> > Gambit::slhahelp::type_family_to_gauge_states = init_type_family_to_gauge_states()

Definition at line 39 of file mssm_slhahelp.cpp.

Referenced by init_type_family_to_gauge_states().

◆ type_to_vec_of_gauge_es

const std::map<str,std::vector<str> > Gambit::slhahelp::type_to_vec_of_gauge_es = init_type_to_vec_of_gauge_es()

Definition at line 43 of file mssm_slhahelp.cpp.

Referenced by init_type_to_vec_of_gauge_es().

◆ type_to_vec_of_mass_es

const std::map<str,std::vector<str> > Gambit::slhahelp::type_to_vec_of_mass_es = init_type_to_vec_of_mass_es()

Definition at line 42 of file mssm_slhahelp.cpp.

Referenced by init_type_to_vec_of_mass_es().