gambit is hosted by Hepforge, IPPP Durham
GAMBIT  v1.5.0-252-gf9a3f78
a Global And Modular Bsm Inference Tool
MSSMSpec.hpp
Go to the documentation of this file.
1 // GAMBIT: Global and Modular BSM Inference Tool
2 // *********************************************
28 
29 #ifndef MSSMSPEC_H
30 #define MSSMSPEC_H
31 
32 #include <memory>
33 
36 #include "gambit/Utils/version.hpp"
38 #include "gambit/SpecBit/MSSMSpec_head.hpp" // "Header" declarations for MSSMSpec class
39 
40 // Flexible SUSY stuff (should not be needed by the rest of gambit)
41 #include "flexiblesusy/config/config.h"
42 
43 namespace Gambit
44 {
45 
46  namespace SpecBit
47  {
48 
49  //
50  // IMPLEMENTATION OF MSSMSpec MEMBER FUNCTIONS FOLLOWS
51  //
52  // MSSMSpec this is a template class, we need these definition in the header
53  // file. It is nice to keep them seperate from the class declaration though.
54  //
55 
56  // Set index offset from interface class
57  template <class MI>
58  const int MSSMSpec<MI>::_index_offset = MI::index_offset;
59 
60  // NOTE!! mi is COPIED into the object, so when we get the reference to the
61  // actual Model object to store in 'model', we need to use the copy inside
62  // the object. So also need to make sure 'model_interface' is initialised first
63  // (i.e. it should be declared first)
64  template <class MI>
65  MSSMSpec<MI>::MSSMSpec(MI mi, str be_name, str be_version)
66  : backend_name(be_name)
67  , backend_version(be_version)
68  , model_interface(mi)
69  {}
70 
71  // Default constructor
72  template <class MI>
74  {}
75 
76  template <class MI>
78  {}
79 
80  // Fill an SLHAea object with spectrum information
81  template <class MI>
82  void MSSMSpec<MI>::add_to_SLHAea(int slha_version, SLHAstruct& slha) const
83  {
84  std::ostringstream comment;
85 
86  // SPINFO block
87  // TODO: This needs to become more sophisticated to deal with data potentially
88  // produced by different LE and HE spectrum sources. For now whichever subspectrum
89  // adds this block first will "win".
90  if(not SLHAea_block_exists(slha, "SPINFO"))
91  {
92  SLHAea_add_block(slha, "SPINFO");
93  SLHAea_add(slha, "SPINFO", 1, "GAMBIT, using "+backend_name);
94  SLHAea_add(slha, "SPINFO", 2, gambit_version()+" (GAMBIT); "+backend_version+" ("+backend_name+")");
95  }
96 
97  // All other MSSM blocks
98  slhahelp::add_MSSM_spectrum_to_SLHAea(*this, slha, slha_version);
99  }
100 
101  //inspired by softsusy's lsp method.
102  //This MSSM version assumes all states mass ordered.
103  //returns lsp mass and gives 3 integers to specify the state
104  // for most general case of a particle type with mass matrix
105  // row and col set to -1 when not needed
106  //(row only is used for vector)
107  //particle_type = 0 (neutralino), 1(Sneutrino), 2(up squark),
108  //3(down squarks), 4(charged slepton), 5(Chargino), 6(gluino)
109  //
110  // TODO: Ben: I'm a little unclear why we access the flexiblesusy
111  // data directly like this. Can't we use the function pointer maps
112  // that we wrote? This will reduce how much the softsusy wrapper
113  // has to clone the flexiblesusy model object structure.
114  template <class MI>
115  double MSSMSpec<MI>::get_lsp_mass(int & particle_type, int & row, int & col) const
116  {
117  row = -1; col = -1; particle_type =-1;//set default
118  double mlsp = fabs(model_interface.model.get_physical().MChi(0)); //most common lsp
119  particle_type = 0;
120  row = 0;
121 
123  double temp = model_interface.model.get_physical().MSv(0);
124  if (temp < mlsp) {
125  mlsp = temp;
126  particle_type = 1;
127  row=0;
128  }
129 
131  temp = model_interface.model.get_physical().MSu(0);
132  if (temp < mlsp) {
133  mlsp = temp;
134  particle_type = 2;
135  row=0;
136  }
137 
139  temp = model_interface.model.get_physical().MSd(0);
140  if (temp < mlsp) {
141  mlsp = temp;
142  particle_type = 3;
143  row=0;
144  }
145 
147  temp = model_interface.model.get_physical().MSe(0);
148  if (temp < mlsp) {
149  mlsp = temp;
150  particle_type = 4;
151  row=0;
152  }
153 
155  temp = fabs(model_interface.model.get_physical().MCha(0));
156  if (temp < mlsp) {
157  mlsp = temp;
158  particle_type = 5;
159  row=0;
160  }
161 
163  temp = fabs(model_interface.model.get_physical().MGlu);
164  if (temp < mlsp) {
165  mlsp = temp;
166  particle_type = 6;
167  row=0;
168  }
169 
170  //We have no gravitino mass right now. this should be added.
171  // /// gravitino -1
172  // temp = displayGravitino();
173  // if (temp < mlsp) {
174  // mlsp = temp; posi = 0; posj = 0; particle_type = -1; }
175 
176  return mlsp;
177  }
178 
179  //The MSSM has just one LSP - often the lightest neutralino
180  template <class MI>
182  return 1;
183  }
184 
185  //these are just wrappers. Need to test this carefully though
186  //inheritance is complicated
187  //TODO: Ben: If it helps, we can now put the run_to function
188  //in the interface class. Might be similar to what you were
189  //already doing for the softsusy interface. Should merge our
190  //approaches. Could do all of this via the interface. Depends
191  //what will be simplest in general.
192  template <class MI>
194  {
195  model_interface.model.run_to(scale);
196  }
197  template <class MI>
198  double MSSMSpec<MI>::GetScale() const
199  {
200  return model_interface.model.get_scale();
201  }
202  template <class MI>
203  void MSSMSpec<MI>::SetScale(double scale)
204  {
205  model_interface.model.set_scale(scale);
206  }
207 
208  template <class MI>
209  std::string MSSMSpec<MI>::AccessError(std::string state) const
210  {
211  std::string errormsg;
212  errormsg = "Error accessing "+ state + " element is out of bounds";
213  return errormsg;
214  }
215 
216  // "extra" function to compute TanBeta
217  template <class Model>
218  double get_tanbeta(const Model& model)
219  {
220  return model.get_vu() / model.get_vd();
221  }
222 
223  // "extra" function to compute mA2
224  template <class Model>
225  double get_DRbar_mA2(const Model& model)
226  {
227  double tb = model.get_vu() / model.get_vd();
228  double cb = cos(atan(tb));
229  double sb = sin(atan(tb));
230  return model.get_BMu() / (sb * cb);
231  }
232 
233  template <class Model>
235  {
236  double sthW2 = Utils::sqr(model.get_g1()) * 0.6 /
237  (0.6 * Utils::sqr(model.get_g1()) +
238  Utils::sqr(model.get_g2()));
239  return sthW2;
240  }
241 
242  // Need wrapper functions for A0 and H+ getters, to retrieve only the
243  // non-Goldstone entries.
244  // Need to pass in the model object, since we won't have the 'this' pointer
245  template <class Model>
247  {
248  return model.get_MAh_pole_slha(1);
249  }
250 
251  template <class Model>\
253  {
254  return model.get_MHpm_pole_slha(1);
255  }
256 
257  // maybe we will need the goldstones at some point
258  // I think it doesn't hurt to add them in case we do
259  template <class Model>
261  {
262  return model.get_MAh_pole_slha(0);
263  }
264 
265  template <class Model>
267  {
268  return model.get_MHpm_pole_slha(0);
269  }
270 
271 
272  template <class Model>
273  void set_MSu_pole_slha(Model& model, double mass,int i)
274  {
275  model.get_physical_slha().MSu(i) = mass;
276  }
277 
278  template <class Model>
279  void set_MSd_pole_slha(Model& model, double mass,int i)
280  {
281  model.get_physical_slha().MSd(i) = mass;
282  }
283 
284  template <class Model>
285  void set_MSe_pole_slha(Model& model, double mass,int i)
286  {
287  model.get_physical_slha().MSe(i) = mass;
288  }
289 
290  template <class Model>
291  void set_MSv_pole_slha(Model& model, double mass,int i)
292  {
293  model.get_physical_slha().MSv(i) = mass;
294  }
295 
296  template <class Model>
297  void set_MCha_pole_slha(Model& model, double mass, int i)
298  {
299  model.get_physical_slha().MCha(i) = mass;
300  }
301 
302  template <class Model>
303  void set_MChi_pole_slha(Model& model, double mass, int i)
304  {
305  model.get_physical_slha().MChi(i) = mass;
306  }
307 
308  template <class Model>
309  void set_Mhh_pole_slha(Model& model, double mass, int i)
310  {
311  model.get_physical_slha().Mhh(i) = mass;
312  }
313 
314  template <class Model>
315  void set_ZD_pole_slha(Model& model, double mass, int i, int j)
316  {
317  model.get_physical_slha().ZD(i,j) = mass;
318  }
319 
320  template <class Model>
321  void set_ZU_pole_slha(Model& model, double mass, int i, int j)
322  {
323  model.get_physical_slha().ZU(i,j) = mass;
324  }
325 
326  template <class Model>
327  void set_ZE_pole_slha(Model& model, double mass, int i, int j)
328  {
329  model.get_physical_slha().ZE(i,j) = mass;
330  }
331 
332  template <class Model>
333  void set_ZV_pole_slha(Model& model, double mass, int i, int j)
334  {
335  model.get_physical_slha().ZV(i,j) = mass;
336  }
337 
338  template <class Model>
339  void set_ZH_pole_slha(Model& model, double mass, int i, int j)
340  {
341  model.get_physical_slha().ZH(i,j) = mass;
342  }
343 
344  template <class Model>
345  void set_ZA_pole_slha(Model& model, double mass, int i, int j)
346  {
347  model.get_physical_slha().ZA(i,j) = mass;
348  }
349 
350  template <class Model>
351  void set_ZP_pole_slha(Model& model, double mass, int i, int j)
352  {
353  model.get_physical_slha().ZP(i,j) = mass;
354  }
355 
356  template <class Model>
357  void set_ZN_pole_slha(Model& model, double mass, int i, int j)
358  {
359  model.get_physical_slha().ZN(i,j) = mass;
360  }
361 
362  template <class Model>
363  void set_UM_pole_slha(Model& model, double mass, int i, int j)
364  {
365  model.get_physical_slha().UM(i,j) = mass;
366  }
367 
368  template <class Model>
369  void set_UP_pole_slha(Model& model, double mass, int i, int j)
370  {
371  model.get_physical_slha().UP(i,j) = mass;
372  }
373 
374  template <class Model>
375  void set_MAh1_pole_slha(Model& model, double mass)
376  {
377  model.get_physical_slha().MAh(1) = mass;
378  }
379 
380  template <class Model>
381  void set_MHpm1_pole_slha(Model& model, double mass)
382  {
383  model.get_physical_slha().MHpm(1) = mass;
384  }
385 
386  // goldstone setters. maybe we need these for some consistent calculation
387  // unlikely but I'll add them for now.
388  template <class Model>
390  {
391  model.get_physical_slha().MAh(0) = mass;
392  }
393 
394  template <class Model>
396  {
397  model.get_physical_slha().MHpm(0) = mass;
398  }
399 
400 
401  // PA: I'm using nicer names than the FlexibleSUSY ones here
402  // but maybe I shouldn't as it breaks the symmetry with the
403  // getters and could generate some confusion
404  template <class Model>
405 
406  void set_MGluino_pole_slha(Model& model, double mass)
407  {
408  model.get_physical_slha().MGlu = mass;
409  }
410 
411  //PA: setting MZ and MW is necessary because we may have them as ouptuts
412  template <class Model>
413  void set_MZ_pole_slha(Model& model, double mass)
414  {
415  model.get_physical_slha().MVZ = mass;
416  }
417 
418  template <class Model>
419  void set_MW_pole_slha(Model& model, double mass)
420  {
421  model.get_physical_slha().MVWm = mass;
422  }
423 
424 
425 
427 
428  // Filler function for getter function pointer maps
429  template <class MI>
431  {
432  typename MSSMSpec<MI>::GetterMaps map_collection;
433  typedef typename MI::Model Model;
434 
435  typedef typename MTget::FInfo1 FInfo1;
436  typedef typename MTget::FInfo2 FInfo2;
437 
438  static const std::set<int> i01 = initSet(0,1);
439  static const std::set<int> i012 = initSet(0,1,2);
440  static const std::set<int> i0123 = initSet(0,1,2,3);
441  static const std::set<int> i012345 = initSet(0,1,2,3,4,5);
442 
444  //
445  // Functions utilising the "plain-vanilla" function signature
446  // (Zero index member functions of model object)
447  { // scope so we can reuse the name 'tmp_map' several times, so that our macro works.
448  // could make a better macro, or an actual function, but I'm in a hurry
449  typename MTget::fmap0 tmp_map;
450  tmp_map["BMu"] = &Model::get_BMu;
451  tmp_map["mHd2"] = &Model::get_mHd2;
452  tmp_map["mHu2"] = &Model::get_mHu2;
453 
454  map_collection[Par::mass2].map0 = tmp_map;
455  }
456 
457  // Functions utilising the "extraM" function signature
458  // (Zero index, model object as argument)
459  {
460  typename MTget::fmap0_extraM tmp_map;
461  tmp_map["mA2"] = &get_DRbar_mA2<Model>;
462  map_collection[Par::mass2].map0_extraM = tmp_map;
463  }
464 
465  // functions utilising the two-index "plain-vanilla" function signature
466  // (two-index member functions of model object)
467  {
468  typename MTget::fmap2 tmp_map;
469  tmp_map["mq2"] = FInfo2( &Model::get_mq2, i012, i012);
470  tmp_map["ml2"] = FInfo2( &Model::get_ml2, i012, i012);
471  tmp_map["md2"] = FInfo2( &Model::get_md2, i012, i012);
472  tmp_map["mu2"] = FInfo2( &Model::get_mu2, i012, i012);
473  tmp_map["me2"] = FInfo2( &Model::get_me2, i012, i012);
474 
475  map_collection[Par::mass2].map2 = tmp_map;
476  }
477 
480  //
481  // Functions utilising the "plain-vanilla" function signature
482  // (Zero index member functions of model object)
483  {
484  typename MTget::fmap0 tmp_map;
485  tmp_map["M1"]= &Model::get_MassB;
486  tmp_map["M2"]= &Model::get_MassWB;
487  tmp_map["M3"]= &Model::get_MassG;
488  tmp_map["Mu"]= &Model::get_Mu;
489  tmp_map["vu"]= &Model::get_vu;
490  tmp_map["vd"]= &Model::get_vd;
491 
492  map_collection[Par::mass1].map0 = tmp_map;
493  }
494 
495  // Functions utilising the two-index "plain-vanilla" function signature
496  // (Two-index member functions of model object)
497  {
498  typename MTget::fmap2 tmp_map;
499  tmp_map["TYd"]= FInfo2( &Model::get_TYd, i012, i012);
500  tmp_map["TYe"]= FInfo2( &Model::get_TYe, i012, i012);
501  tmp_map["TYu"]= FInfo2( &Model::get_TYu, i012, i012);
502  tmp_map["ad"] = FInfo2( &Model::get_TYd, i012, i012);
503  tmp_map["ae"] = FInfo2( &Model::get_TYe, i012, i012);
504  tmp_map["au"] = FInfo2( &Model::get_TYu, i012, i012);
505 
506  map_collection[Par::mass1].map2 = tmp_map;
507  }
508 
510 
511  // @{ dimensionless - mass dimension 0 parameters
512  //
513  // Functions utilising the "plain-vanilla" function signature
514  // (Zero index member functions of model object)
515  {
516  typename MTget::fmap0 tmp_map;
517  tmp_map["g1"]= &Model::get_g1;
518  tmp_map["g2"]= &Model::get_g2;
519  tmp_map["g3"]= &Model::get_g3;
520 
521  map_collection[Par::dimensionless].map0 = tmp_map;
522  }
523 
524  // Functions utilising the "extraM" function signature
525  // (Zero index, model object as argument)
526  {
527  typename MTget::fmap0_extraM tmp_map;
528  tmp_map["tanbeta"] = &get_tanbeta<Model>;
529  tmp_map["sinW2"] = &get_sinthW2_DRbar<Model>;
530  map_collection[Par::dimensionless].map0_extraM = tmp_map;
531  }
532 
533  // Functions utilising the two-index "plain-vanilla" function signature
534  // (Two-index member functions of model object)
535  {
536  typename MTget::fmap2 tmp_map;
537 
538  tmp_map["Yd"]= FInfo2( &Model::get_Yd, i012, i012);
539  tmp_map["Yu"]= FInfo2( &Model::get_Yu, i012, i012);
540  tmp_map["Ye"]= FInfo2( &Model::get_Ye, i012, i012);
541 
542  map_collection[Par::dimensionless].map2 = tmp_map;
543  }
545 
547  //
548  // Functions utilising the "plain-vanilla" function signature
549  // (Zero index member functions of model object)
550  {
551  typename MTget::fmap0 tmp_map;
552 
557  tmp_map["W+"] = &Model::get_MVWm_pole_slha;
558  tmp_map["~g"] = &Model::get_MGlu_pole_slha;
559 
560  map_collection[Par::Pole_Mass].map0 = tmp_map;
561  }
562 
563  // Functions utilising the "extraM" function signature
564  // (Zero index, model object as argument)
565  {
566  typename MTget::fmap0_extraM tmp_map;
567 
568  // Using wrapper functions defined above
569  tmp_map["A0"] = &get_MAh1_pole_slha<Model>;
570  tmp_map["H+"] = &get_MHpm1_pole_slha<Model>;
571 
572  // Goldstones
573  // Using wrapper functions defined above
574  tmp_map["Goldstone0"] = &get_neutral_goldstone_pole_slha<Model>;
575  tmp_map["Goldstone+"] = &get_charged_goldstone_pole_slha<Model>;
576  // Antiparticle label (no automatic conversion for this)
577  tmp_map["Goldstone-"] = &get_charged_goldstone_pole_slha<Model>;
578 
579  map_collection[Par::Pole_Mass].map0_extraM = tmp_map;
580  }
581 
582  // Functions utilising the one-index "plain-vanilla" function signature
583  // (One-index member functions of model object)
584  {
585  typename MTget::fmap1 tmp_map;
586 
587  tmp_map["~d"] = FInfo1( &Model::get_MSd_pole_slha, i012345 );
588  tmp_map["~u"] = FInfo1( &Model::get_MSu_pole_slha, i012345 );
589  tmp_map["~e-"] = FInfo1( &Model::get_MSe_pole_slha, i012345 );
590  tmp_map["~nu"]= FInfo1( &Model::get_MSv_pole_slha, i012 );
591  tmp_map["h0"] = FInfo1( &Model::get_Mhh_pole_slha, i01 );
592  tmp_map["~chi+"] = FInfo1( &Model::get_MCha_pole_slha, i01 );
593  tmp_map["~chi0"] = FInfo1( &Model::get_MChi_pole_slha, i0123 );
594 
595  map_collection[Par::Pole_Mass].map1 = tmp_map;
596  }
597 
599 
601  //
602  // Functions utilising the two-index "plain-vanilla" function signature
603  // (Two-index member functions of model object)
604  {
605  typename MTget::fmap2 tmp_map;
606 
607  tmp_map["~d"] = FInfo2( &Model::get_ZD_pole_slha, i012345, i012345);
608  tmp_map["~nu"] = FInfo2( &Model::get_ZV_pole_slha, i012, i012);
609  tmp_map["~u"] = FInfo2( &Model::get_ZU_pole_slha, i012345, i012345);
610  tmp_map["~e-"] = FInfo2( &Model::get_ZE_pole_slha, i012345, i012345);
611  tmp_map["h0"] = FInfo2( &Model::get_ZH_pole_slha, i01, i01);
612  tmp_map["A0"] = FInfo2( &Model::get_ZA_pole_slha, i01, i01);
613  tmp_map["H+"] = FInfo2( &Model::get_ZP_pole_slha, i01, i01);
614  tmp_map["~chi0"] = FInfo2( &Model::get_ZN_pole_slha, i0123, i0123);
615  tmp_map["~chi-"] = FInfo2( &Model::get_UM_pole_slha, i01, i01);
616  tmp_map["~chi+"] = FInfo2( &Model::get_UP_pole_slha, i01, i01);
617 
618  map_collection[Par::Pole_Mixing].map2 = tmp_map;
619  }
621 
622  return map_collection;
623  }
624 
625  // Filler function for setter function pointer maps
626  template <class MI>
628  {
629  typename MSSMSpec<MI>::SetterMaps map_collection;
630  typedef typename MI::Model Model;
631 
632  typedef typename MTset::FInfo2 FInfo2;
633 
634  typedef typename MTset::FInfo1M FInfo1M;
635  typedef typename MTset::FInfo2M FInfo2M;
636 
637  static const std::set<int> i01 = initSet(0,1);
638  static const std::set<int> i012 = initSet(0,1,2);
639  static const std::set<int> i0123 = initSet(0,1,2,3);
640  static const std::set<int> i012345 = initSet(0,1,2,3,4,5);
641 
643  //
644  // Functions utilising the "plain-vanilla" function signature
645  // (Zero index member functions of model object)
646  { // scope so we can reuse the name 'tmp_map' several times, so that our macro works.
647  // could make a better macro, or an actual function, but I'm in a hurry
648  typename MTset::fmap0 tmp_map;
649  tmp_map["BMu"] = &Model::set_BMu;
650  tmp_map["mHd2"] = &Model::set_mHd2;
651  tmp_map["mHu2"] = &Model::set_mHu2;
652 
653  map_collection[Par::mass2].map0 = tmp_map;
654  }
655 
656  // Functions utilising the two-index "plain-vanilla" function signature
657  // (Two-index member functions of model object)
658  {
659  typename MTset::fmap2 tmp_map;
660  tmp_map["mq2"] = FInfo2( &Model::set_mq2, i012, i012);
661  tmp_map["ml2"] = FInfo2( &Model::set_ml2, i012, i012);
662  tmp_map["md2"] = FInfo2( &Model::set_md2, i012, i012);
663  tmp_map["mu2"] = FInfo2( &Model::set_mu2, i012, i012);
664  tmp_map["me2"] = FInfo2( &Model::set_me2, i012, i012);
665 
666  map_collection[Par::mass2].map2 = tmp_map;
667  }
669 
671  //
672  // Functions utilising the "plain-vanilla" function signature
673  // (Zero index member functions of model object)
674  {
675  typename MTset::fmap0 tmp_map;
676  tmp_map["M1"]= &Model::set_MassB;
677  tmp_map["M2"]= &Model::set_MassWB;
678  tmp_map["M3"]= &Model::set_MassG;
679  tmp_map["Mu"]= &Model::set_Mu;
680  tmp_map["vu"]= &Model::set_vu;
681  tmp_map["vd"]= &Model::set_vd;
682 
683  map_collection[Par::mass1].map0 = tmp_map;
684  }
685 
686  // Functions utilising the two-index "plain-vanilla" function signature
687  // (Two-index member functions of model object)
688  {
689  typename MTset::fmap2 tmp_map;
690  tmp_map["TYd"]= FInfo2( &Model::set_TYd, i012, i012);
691  tmp_map["TYe"]= FInfo2( &Model::set_TYe, i012, i012);
692  tmp_map["TYu"]= FInfo2( &Model::set_TYu, i012, i012);
693  tmp_map["ad"] = FInfo2( &Model::set_TYd, i012, i012);
694  tmp_map["ae"] = FInfo2( &Model::set_TYe, i012, i012);
695  tmp_map["au"] = FInfo2( &Model::set_TYu, i012, i012);
696 
697  map_collection[Par::mass1].map2 = tmp_map;
698  }
699 
701 
702  // @{ dimensionless - mass dimension 0 parameters
703  //
704  // Functions utilising the "plain-vanilla" function signature
705  // (Zero index member functions of model object)
706  {
707  typename MTset::fmap0 tmp_map;
708  tmp_map["g1"]= &Model::set_g1;
709  tmp_map["g2"]= &Model::set_g2;
710  tmp_map["g3"]= &Model::set_g3;
711 
712  map_collection[Par::dimensionless].map0 = tmp_map;
713  }
714 
715  // Functions utilising the two-index "plain-vanilla" function signature
716  // (Two-index member functions of model object)
717  {
718  typename MTset::fmap2 tmp_map;
719 
720  tmp_map["Yd"]= FInfo2( &Model::set_Yd, i012, i012);
721  tmp_map["Yu"]= FInfo2( &Model::set_Yu, i012, i012);
722  tmp_map["Ye"]= FInfo2( &Model::set_Ye, i012, i012);
723 
724  map_collection[Par::dimensionless].map2 = tmp_map;
725  }
726 
727  {
728  typename MTset::fmap0_extraM tmp_map;
729  tmp_map["~g"] = &set_MGluino_pole_slha<Model>;
730  tmp_map["A0"] = &set_MAh1_pole_slha<Model>;
731  tmp_map["H+"] = &set_MHpm1_pole_slha<Model>;
734  tmp_map["Goldstone0"] = &set_neutral_goldstone_pole_slha<Model>;
735  tmp_map["Goldstone+"] = &set_charged_goldstone_pole_slha<Model>;
736  tmp_map["Goldstone-"] = &set_charged_goldstone_pole_slha<Model>;
737 
741  tmp_map["W+"] = &set_MW_pole_slha<Model>;
742 
743  map_collection[Par::Pole_Mass].map0_extraM = tmp_map;
744  }
745 
746  {
747  typename MTset::fmap1_extraM tmp_map;
748 
749  tmp_map["~u"] = FInfo1M( &set_MSu_pole_slha<Model>, i012345 );
750  tmp_map["~d"] = FInfo1M( &set_MSd_pole_slha<Model>, i012345 );
751  tmp_map["~e-"]= FInfo1M( &set_MSe_pole_slha<Model>, i012345 );
752 
753  tmp_map["~nu"]= FInfo1M( &set_MSv_pole_slha<Model>, i012 );
754  tmp_map["~chi+"] = FInfo1M( &set_MCha_pole_slha<Model>, i01 );
755  tmp_map["~chi0"] = FInfo1M( &set_MChi_pole_slha<Model>, i0123 );
756  tmp_map["h0"] = FInfo1M( &set_Mhh_pole_slha<Model>, i01 );
757 
758  map_collection[Par::Pole_Mass].map1_extraM = tmp_map;
759  }
760 
761 
763  //
764  // Functions utilising the two-index "plain-vanilla" function signature
765  // (Two-index member functions of model object)
766  {
767  typename MTset::fmap2_extraM tmp_map;
768 
769  tmp_map["~d"] = FInfo2M( &set_ZD_pole_slha, i012345, i012345);
770  tmp_map["~nu"] = FInfo2M( &set_ZV_pole_slha, i012, i012);
771  tmp_map["~u"] = FInfo2M( &set_ZU_pole_slha, i012345, i012345);
772  tmp_map["~e-"] = FInfo2M( &set_ZE_pole_slha, i012345, i012345);
773  tmp_map["h0"] = FInfo2M( &set_ZH_pole_slha, i01, i01);
774  tmp_map["A0"] = FInfo2M( &set_ZA_pole_slha, i01, i01);
775  tmp_map["H+"] = FInfo2M( &set_ZP_pole_slha, i01, i01);
776  tmp_map["~chi0"] = FInfo2M( &set_ZN_pole_slha, i0123, i0123);
777  tmp_map["~chi-"] = FInfo2M( &set_UM_pole_slha, i01, i01);
778  tmp_map["~chi+"] = FInfo2M( &set_UP_pole_slha, i01, i01);
779 
780  map_collection[Par::Pole_Mixing].map2_extraM = tmp_map;
781  }
782 
783 
784  return map_collection;
785  }
786 
788 
789 
790  } // end SpecBit namespace
791 } // end Gambit namespace
792 
793 #endif
void set_charged_goldstone_pole_slha(Model &model, double mass)
Definition: MSSMSpec.hpp:395
void set_ZU_pole_slha(Model &model, double mass, int i, int j)
Definition: MSSMSpec.hpp:321
void set_MSd_pole_slha(Model &model, double mass, int i)
Definition: MSSMSpec.hpp:279
void set_ZN_pole_slha(Model &model, double mass, int i, int j)
Definition: MSSMSpec.hpp:357
SpecTraits< Self >::Model Model
Model & model()
Get model object on which to call function pointers.
Definition: spec_head.hpp:234
void set_MW_pole_slha(Model &model, double mass)
Definition: MSSMSpec.hpp:419
void set_MCha_pole_slha(Model &model, double mass, int i)
Definition: MSSMSpec.hpp:297
void set_ZV_pole_slha(Model &model, double mass, int i, int j)
Definition: MSSMSpec.hpp:333
virtual double get_lsp_mass(int &particle_type, int &row, int &col) const
Definition: MSSMSpec.hpp:115
virtual double GetScale() const
Returns the renormalisation scale of parameters.
Definition: MSSMSpec.hpp:198
"Header" declarations for MSSMSpec class (definitions in another header file due to this being a temp...
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.
static SetterMaps fill_setter_maps()
Definition: MSSMSpec.hpp:627
void set_ZE_pole_slha(Model &model, double mass, int i, int j)
Definition: MSSMSpec.hpp:327
double get_tanbeta(const Model &model)
Definition: MSSMSpec.hpp:218
void set_MSu_pole_slha(Model &model, double mass, int i)
Definition: MSSMSpec.hpp:273
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) ...
static const int _index_offset
void set_MChi_pole_slha(Model &model, double mass, int i)
Definition: MSSMSpec.hpp:303
virtual int get_numbers_stable_particles() const
There may be more than one new stable particle this method will tell you how many.
Definition: MSSMSpec.hpp:181
void set_MZ_pole_slha(Model &model, double mass)
Definition: MSSMSpec.hpp:413
double get_MHpm1_pole_slha(const Model &model)
Definition: MSSMSpec.hpp:252
virtual void add_to_SLHAea(int slha_version, SLHAstruct &slha) const
Add spectrum information to an SLHAea object (if possible)
Definition: MSSMSpec.hpp:82
Routines to help translate between SLHA2 sfermions and SLHA1 (or similar) sfermions.
EXPORT_SYMBOLS double sqr(double a)
returns square of double - saves tedious repetition
General small utility functions.
void set_MGluino_pole_slha(Model &model, double mass)
Definition: MSSMSpec.hpp:406
virtual std::string AccessError(std::string state) const
Definition: MSSMSpec.hpp:209
void add_MSSM_spectrum_to_SLHAea(const SubSpectrum &mssmspec, SLHAstruct &slha, int slha_version)
Add an entire MSSM spectrum to an SLHAea object.
SLHAea::Coll SLHAstruct
Less confusing name for SLHAea container class.
void set_ZD_pole_slha(Model &model, double mass, int i, int j)
Definition: MSSMSpec.hpp:315
static GetterMaps fill_getter_maps()
Map filler overrides.
Definition: MSSMSpec.hpp:430
Nicer alias for SLHAea container class, and some convenient helper functions that add or retrieve the...
double get_charged_goldstone_pole_slha(const Model &model)
Definition: MSSMSpec.hpp:266
Self::GetterMaps GetterMaps
bool SLHAea_block_exists(SLHAstruct &slha, const str &block)
Check if a block exists in an SLHAea object.
void set_neutral_goldstone_pole_slha(Model &model, double mass)
Definition: MSSMSpec.hpp:389
double get_sinthW2_DRbar(const Model &model)
Definition: MSSMSpec.hpp:234
str & gambit_version()
Statically construct a string containing the full GAMBIT version information and return a reference t...
Definition: version.cpp:32
double get_neutral_goldstone_pole_slha(const Model &model)
Definition: MSSMSpec.hpp:260
void set_UP_pole_slha(Model &model, double mass, int i, int j)
Definition: MSSMSpec.hpp:369
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
void set_MAh1_pole_slha(Model &model, double mass)
Definition: MSSMSpec.hpp:375
virtual void SetScale(double scale)
Manually set the renormalisation scale of parameters somewhat dangerous to allow this but may be need...
Definition: MSSMSpec.hpp:203
std::set< T > initSet(std::set< T > set)
Same as above, but for sets.
void set_ZA_pole_slha(Model &model, double mass, int i, int j)
Definition: MSSMSpec.hpp:345
virtual void RunToScaleOverride(double scale)
Run spectrum to new scale.
Definition: MSSMSpec.hpp:193
Self::SetterMaps SetterMaps
void set_MSv_pole_slha(Model &model, double mass, int i)
Definition: MSSMSpec.hpp:291
void set_MHpm1_pole_slha(Model &model, double mass)
Definition: MSSMSpec.hpp:381
void set_ZH_pole_slha(Model &model, double mass, int i, int j)
Definition: MSSMSpec.hpp:339
double get_DRbar_mA2(const Model &model)
Definition: MSSMSpec.hpp:225
void set_ZP_pole_slha(Model &model, double mass, int i, int j)
Definition: MSSMSpec.hpp:351
Version numbering.
TODO: see if we can use this one:
Definition: Analysis.hpp:33
void set_Mhh_pole_slha(Model &model, double mass, int i)
Definition: MSSMSpec.hpp:309
void set_MSe_pole_slha(Model &model, double mass, int i)
Definition: MSSMSpec.hpp:285
double get_MAh1_pole_slha(const Model &model)
Definition: MSSMSpec.hpp:246
void set_UM_pole_slha(Model &model, double mass, int i, int j)
Definition: MSSMSpec.hpp:363