Models status/update -------- == Model parameterisations Real MSSM with GUT boundary conditions implemented Note hierarchy changes: "friends" models now exist, dependency resolver can translate these i.e. INTERPRET_AS_X__FUNCTION, not just INTERPRET_AS_PARENT__FUNCTION ===================== /// FlexibleSUSY compatible general GUT scale MSSM parameterisation #define MODEL MSSMatMGUT START_MODEL DEFINEPARS(TanBeta,SignMu, mHu2,mHd2,M1,M2,M3) DEFINEPARS(mq2_11, mq2_12, mq2_13, mq2_21, mq2_22, mq2_23, mq2_31, mq2_32, mq2_33) DEFINEPARS(ml2_11, ml2_12, ml2_13, ml2_21, ml2_22, ml2_23, ml2_31, ml2_32, ml2_33) DEFINEPARS(md2_11, md2_12, md2_13, md2_21, md2_22, md2_23, md2_31, md2_32, md2_33) DEFINEPARS(mu2_11, mu2_12, mu2_13, mu2_21, mu2_22, mu2_23, mu2_31, mu2_32, mu2_33) DEFINEPARS(me2_11, me2_12, me2_13, me2_21, me2_22, me2_23, me2_31, me2_32, me2_33) DEFINEPARS(Ae_11, Ae_12, Ae_13, Ae_21, Ae_22, Ae_23, Ae_31, Ae_32, Ae_33) DEFINEPARS(Ad_11, Ad_12, Ad_13, Ad_21, Ad_22, Ad_23, Ad_31, Ad_32, Ad_33) DEFINEPARS(Au_11, Au_12, Au_13, Au_21, Au_22, Au_23, Au_31, Au_32, Au_33) #undef MODEL #define MODEL CMSSM START_MODEL DEFINEPARS(M0,M12,A0,tanb,signmu) // Now, CMSSM cannot actually be translated into MSSM, because MSSM is // "abstract" and has no parameters. Instead, we translate it into // GUTMSSMA and GUTMSSMB, which are children of MSSM. and which work // with specific spectrum generators. Most module functions just need // to say they work with MSSM, and then CMSSM should be permitted; // meanwhile SpecBit will translate CMSSM into GUTMSSMX in order to // generate a spectrum. // // ...__FUNCTION(Model name, translation function name) INTERPRET_AS_X__FUNCTION(MSSMatMGUT, CMSSM_to_MSSMatMGUT) INTERPRET_AS_X__FUNCTION(GUTMSSMB, CMSSM_to_GUTMSSMB) //USE_NULL_INTERPRET_AS_PARENT // Translation functions defined in MSSM.cpp #undef MODEL MSSM.cpp #define MODEL CMSSM void MODEL_NAMESPACE::CMSSM_to_MSSMatMGUT (const ModelParameters &myP, ModelParameters &targetP) { USE_MODEL_PIPE(MSSMatMGUT) //testing only logger()<<"Running interpret_as_X calculations for CMSSM --> MSSMatMGUT..."< M0vec(M0init,endA(M0init)); set_many_to_one(targetP, M0vec, myP["M0"]); // M12 targetP.setValue("M1", myP["M12"] ); targetP.setValue("M2", myP["M12"] ); targetP.setValue("M3", myP["M12"] ); // A0 static const char *A0init[] = { "Ae_11", "Ae_12", "Ae_13", "Ae_21", "Ae_22", "Ae_23", "Ae_31", "Ae_32", "Ae_33", /**/ "Ad_11", "Ad_12", "Ad_13", "Ad_21", "Ad_22", "Ad_23", "Ad_31", "Ad_32", "Ad_33", /**/ "Au_11", "Au_12", "Au_13", "Au_21", "Au_22", "Au_23", "Au_31", "Au_32", "Au_33" }; static const std::vector A0vec(A0init,endA(A0init)); set_many_to_one(targetP, A0vec, myP["A0"]); } void MODEL_NAMESPACE::CMSSM_to_GUTMSSMB (const ModelParameters &myP, ModelParameters &targetP) { logger()<<"Running interpret_as_X calculations for CMSSM --> GUTMSSMB..."< friend class RunparDer; template friend class PhysDer; public: virtual void dump2slha(const std::string&) const = 0; virtual SLHAea::Coll getSLHAea() const = 0; private: class RunningPars { public: /// run object to a particular scale virtual void RunToScale(double scale) = 0; /// returns the renormalisation scale of parameters virtual double GetScale() const = 0; /// Sets the renormalisation scale of parameters /// somewhat dangerous to allow this but may be needed virtual void SetScale(double scale) = 0; /// getters using map virtual double get_mass4_parameter(std::string) const = 0; virtual double get_mass4_parameter(std::string, int) const = 0; virtual double get_mass4_parameter(std::string, int, int) const = 0; virtual double get_mass3_parameter(std::string) const = 0; virtual double get_mass3_parameter(std::string, int) const = 0; virtual double get_mass3_parameter(std::string, int, int) const = 0; virtual double get_mass2_parameter(std::string) const = 0; virtual double get_mass2_parameter(std::string, int i) const = 0; virtual double get_mass2_parameter(std::string, int i, int j) const = 0; virtual double get_mass_parameter(std::string) const = 0; virtual double get_mass_parameter(std::string, int) const = 0; virtual double get_mass_parameter(std::string, int, int) const = 0; virtual double get_dimensionless_parameter(std::string) const = 0; virtual double get_dimensionless_parameter(std::string, int) const = 0; virtual double get_dimensionless_parameter(std::string, int, int) const = 0; }; class Phys { public: /// map based getters virtual double get_Pole_Mass(std::string) const = 0; virtual double get_Pole_Mass(std::string, int) const = 0; virtual double get_Pole_Mixing(std::string) const = 0; virtual double get_Pole_Mixing(std::string, int) const = 0; virtual double get_Pole_Mixing(std::string, int, int) const = 0; }; ---------------------- To hook up a new spectrum, need to - Inherit from this class - Overwrite "fill_mass_map" functions -> specific function pointers to functions which return particular masses/couplings/mixings, e.g. (MSSMSpec.hpp) - Overwrite virtual functions for writing slha files and SLHAea objects e.g. // Function to initialise mass2_map template typename MSSM_DRbarPars::fmap2 MSSM_DRbarPars::fill_mass2_map2() { fmap2 tmp_map; // Can't use c++11 initialise lists, se have to initialise the index sets like this. static const int i012v[] = {0,1,2}; static const std::set i012(i012v, Utils::endA(i012v)); tmp_map["mq2"] = FInfo2( &MI::Model::get_mq2, i012, i012); tmp_map["ml2"] = FInfo2( &MI::Model::get_ml2, i012, i012); tmp_map["md2"] = FInfo2( &MI::Model::get_md2, i012, i012); tmp_map["mu2"] = FInfo2( &MI::Model::get_mu2, i012, i012); tmp_map["me2"] = FInfo2( &MI::Model::get_me2, i012, i012); return tmp_map; } template typename MSSM_DRbarPars::fmap MSSM_DRbarPars::fill_mass0_map() { fmap tmp_map; tmp_map["g1"]= &MI::Model::get_g1; tmp_map["g2"]= &MI::Model::get_g2; tmp_map["g3"]= &MI::Model::get_g3; // can't do SM vev or tan beta this way // can create MSSM_DRbarPars getter which first calls // inherited one then adds vev and tan beta return tmp_map; } -- todo: - Currently the MSSMSpec class is a little broken and doesn't output SLHAfiles or SLHAea objects. I should be able to fix this today though. - The MSSMSpec class is templated on a model interface class, which needs to contain an object with all the function names listed above. This is for compatibility with all flexiblesusy MSSM models. It will work with softsusy with an extra interface layer. Non-mssm models will need a new wrapper class. === Creating spectra in SpecBit template // MI for Model_interface Spectrum* run_FS_spectrum_generator(const typename MI::InputParameters &input, const Options &runOptions) { // SoftSUSY object used to set quark and lepton masses and gauge // couplings in QEDxQCD effective theory // Will be initialised by default using values in lowe.h. Should add code here to // input any Standard Model values which we want to vary with the scan. Also need // to implement a strategy for carrying SM parameters around gambit consistently. QedQcd oneset; oneset.toMz(); // Create spectrum generator object typename MI::SpectrumGenerator spectrum_generator; // Spectrum generator settings // e.g. spectrum_generator.set_ewsb_loop_order( // Generate spectrum spectrum_generator.run(oneset, input); // Extract report on problems... const Problems& problems = spectrum_generator.get_problems(); // Create Model_interface to carry the input and results, and know // how to access the flexiblesusy routines. MI model_interface(spectrum_generator.get_model(),oneset,input); // Create Spectrum object to wrap flexiblesusy data static MSSMSpec mssmspec(model_interface); if( problems.have_problem() ) { ///TODO: Need to tell gambit that the spectrum is not viable somehow. For now // just die. std::ostringstream errmsg; errmsg << "A serious problem was encountered during spectrum generation! \ Message from flexibleSUSY below:" << std::endl; problems.print_problems(errmsg); problems.print_warnings(errmsg); SpecBit_error().raise(LOCAL_INFO,errmsg.str()); } // Return a pointer to the Spectrum object return &mssmspec; } -- And the actual module function: void get_MSSMatMGUT_spectrum (Spectrum* &result) { using namespace softsusy; namespace Pipe = Pipes::get_MSSMatMGUT_spectrum; MSSMatMGUT_input_parameters input; //double valued parameters input.TanBeta = *Pipe::Param["TanBeta"]; input.SignMu = *Pipe::Param["SignMu"]; input.mHu2IN = *Pipe::Param["mHu2"]; input.mHd2IN = *Pipe::Param["mHd2"]; input.MassBInput = *Pipe::Param["M1"]; input.MassWBInput = *Pipe::Param["M2"]; input.MassGInput = *Pipe::Param["M3"]; //3x3 matrices; filled with the help of a convenience function input.mq2Input = fill_3x3_parameter_matrix("mq2", Pipe::Param); input.ml2Input = fill_3x3_parameter_matrix("ml2", Pipe::Param); input.md2Input = fill_3x3_parameter_matrix("md2", Pipe::Param); input.mu2Input = fill_3x3_parameter_matrix("mu2", Pipe::Param); input.me2Input = fill_3x3_parameter_matrix("me2", Pipe::Param); input.Aeij = fill_3x3_parameter_matrix("Ae", Pipe::Param); input.Adij = fill_3x3_parameter_matrix("Ad", Pipe::Param); input.Auij = fill_3x3_parameter_matrix("Au", Pipe::Param); result = run_FS_spectrum_generator>(input,*Pipe::runOptions); } -- Extra translation module functions. But if you have the Spectrum object you can do these things yourself in your own module function, no need to use these. void dump_spectrum(double &result) { namespace Pipe = Pipes::dump_spectrum; Spectrum* spec(*Pipe::Dep::SM_spectrum); std::string filename(Pipe::runOptions->getValue("filename")); spec->dump2slha(filename); result = 1; } void get_MSSM_spectrum_as_SLHAea (SLHAea::Coll &result) { namespace Pipe = Pipes::get_MSSM_spectrum_as_SLHAea; Spectrum* spec(*Pipe::Dep::MSSM_spectrum); result = spec->getSLHAea(); } -- Functions to changes the capability associated with a Spectrum object to "SM_spectrum" void convert_MSSM_to_SM (Spectrum* &result) {result = *Pipes::convert_MSSM_to_SM::Dep::MSSM_spectrum;} //void convert_NMSSM_to_SM (Spectrum* &result) {result = *Pipes::convert_NMSSM_to_SM::Dep::NMSSM_spectrum;} //void convert_E6MSSM_to_SM (Spectrum* &result) {result = *Pipes::convert_E6MSSM_to_SM::Dep::E6MSSM_spectrum;} -- todo: - Need SpecBit functions like this to run the various spectrum generators and create Spectrum objects from them. FlexibleSUSY MSSM models will be easy, others take more work, especially stuff like say NMSSMTools. This requires "setter" routines for the spectrum object which don't exist yet. This feature is also needed for, say, generating spectra with one spectrum generator, but carrying it around in the Spectrum object in another format (basically flexiblesusy or softsusy format). ============= -- Some extra issues related to schemes of running parameters and conventions; Peter? -- And of course issues compiling flexiblesusy with all GAMBIT compilers: - Looks like flexiblesusy uses initialiser lists, so that rules out Intel compilers before about version 14 - Even if they take those out, it seems there is a weird compiler bug when multithreading is turned on before version 14. - Possible resolutions - Peter convinces Jae-hyeon to fix these problems (he doesn't seem keen) - We add preprocessor statements to disable flexiblesusy on these earlier compilers. In the end this will kill the use of all models except the MSSM and NMSSM, which can still be covered by softsusy (not right now though).