gambit is hosted by Hepforge, IPPP Durham
GAMBIT  v1.5.0-252-gf9a3f78
a Global And Modular Bsm Inference Tool
MSSMSimpleSpec.cpp
Go to the documentation of this file.
1 // GAMBIT: Global and Modular BSM Inference Tool
2 // *********************************************
5 //
20 
25 #include "gambit/Logs/logger.hpp"
26 
27 #include <math.h>
28 #include <boost/lexical_cast.hpp>
29 
30 using namespace SLHAea;
31 
32 namespace Gambit
33 {
34 
36  bool orderer (std::pair<int, double> a, std::pair<int, double> b) { return a.second < b.second; }
37 
39 
41  MSSMea::MSSMea()
42  : SLHAeaModel()
43  {}
44 
46  MSSMea::MSSMea(const SLHAea::Coll& input)
47  : SLHAeaModel(input)
48  {
49  std::map<int, int>& slha1to2 = PDG_translation_map;
50  str blocks[4] = {"DSQMIX", "USQMIX", "SELMIX", "SNUMIX"};
51  str gen3mix[3] = {"SBOTMIX", "STOPMIX", "STAUMIX"};
53 
54  // Work out if this SLHAea object is SLHA1 or SLHA2
55  if (data.find(blocks[0]) == data.end() or
56  data.find(blocks[1]) == data.end() or
57  data.find(blocks[2]) == data.end() or
58  data.find(blocks[3]) == data.end() )
59  {
60  if (data.find(gen3mix[0]) == data.end() or
61  data.find(gen3mix[1]) == data.end() or
62  data.find(gen3mix[2]) == data.end() )
63  {
64  utils_error().raise(LOCAL_INFO, "Input SLHA data appears to be neither SLHA1 nor SLHA2.");
65  }
66  logger() << "Input SLHA for setting up simple spectrum is SLHA1. You old dog." << EOM;
67 
68  // Get scale, needed for specifying SLHA2 blocks
71  double scale = 0.0;
72  try
73  {
74  scale = SLHAea::to<double>(data.at("GAUGE").find_block_def()->at(3));
75  }
76  catch (const std::out_of_range& e)
77  {
78  std::ostringstream errmsg;
79  errmsg << "Could not find block \"GAUGE\" in SLHAea object (required to retrieve scale Q). Received out_of_range error with message: " << e.what();
80  utils_error().raise(LOCAL_INFO,errmsg.str());
81  }
82 
83  //Looks like it is SLHA1, so convert it to SLHA2.
84  int lengths[4] = {6, 6, 6, 3};
85  str names[4] = {"~d_", "~u_", "~l_", "~nu_"};
86  std::vector<int> pdg[4];
87  std::vector< std::pair<int, double> > masses[4];
88  pdg[0] = initVector<int>(1000001, 1000003, 1000005, 2000001, 2000003, 2000005); // d-type squarks
89  pdg[1] = initVector<int>(1000002, 1000004, 1000006, 2000002, 2000004, 2000006); // u-type squarks
90  pdg[2] = initVector<int>(1000011, 1000013, 1000015, 2000011, 2000013, 2000015); // sleptons
91  pdg[3] = initVector<int>(1000012, 1000014, 1000016); // sneutrinos
92  for (int j = 0; j < 4; j++)
93  {
94  // Get the masses
95  for (int i = 0; i < lengths[j]; i++) masses[j].push_back(std::pair<int, double>(pdg[j][i], getdata("MASS",pdg[j][i])));
96 
97  // Sort them
98  std::sort(masses[j].begin(), masses[j].end(), orderer);
99 
100  // Rewrite them in correct order, and populate the pdg-pdg maps
101  for (int i = 0; i < lengths[j]; i++)
102  {
103  //data["MASS"][pdg[j][i]][1] = boost::lexical_cast<str>(masses[j][i].second);
104  //data["MASS"][pdg[j][i]][2] = "# "+names[j]+boost::lexical_cast<str>(i+1);
105  str masspdg = boost::lexical_cast<str>(masses[j][i].second);
106  str comment = "# "+names[j]+boost::lexical_cast<str>(i+1);
107  SLHAea_add(data, "MASS", pdg[j][i], masspdg, comment, true);
108  slha1to2[masses[j][i].first] = pdg[j][i];
109  }
110 
111  // Write the mixing block. i is the SLHA2 index, k is the SLHA1 index.
112  //data[blocks[j]][""] << "BLOCK" << blocks[j];
113  SLHAea_check_block(data, blocks[j]);
114  for (int i = 0; i < lengths[j]; i++) for (int k = 0; k < lengths[j]; k++)
115  {
116  double datum;
117  if (lengths[j] == 3 or (k != 2 and k != 5)) // first or second generation (or neutrinos)
118  {
119  datum = (slha1to2.at(pdg[j][k]) == pdg[j][i]) ? 1.0 : 0.0;
120  }
121  else // third generation => need to use the 2x2 SLHA1 mixing matrices.
122  {
123  double family_index = 0;
124  if (k == 2)
125  {
126  if (slha1to2.at(pdg[j][k]) == pdg[j][i]) family_index = 1;
127  else if (slha1to2.at(pdg[j][5]) == pdg[j][i]) family_index = 2;
128  }
129  else if (k == 5)
130  {
131  if (slha1to2.at(pdg[j][k]) == pdg[j][i]) family_index = 2;
132  else if (slha1to2.at(pdg[j][2]) == pdg[j][i]) family_index = 1;
133  }
134  if (family_index > 0)
135  {
136  datum = getdata(gen3mix[j], family_index, (k+1)/3);
137  }
138  else datum = 0.0;
139  }
140  //data[blocks[j]][""] << i+1 << k+1 << datum << "# "+blocks[j]+boost::lexical_cast<str>(i*10+k+11);
141  SLHAea_add(data, blocks[j], i+1, k+1, datum, "# "+blocks[j]+boost::lexical_cast<str>(i*10+k+11), true);
142  }
143 
144  }
145  // Now deal with MSOFT --> SLHA2 soft mass matrix blocks
146  // (inverse of retrieval code in add_MSSM_spectrum_to_SLHAea)
147  sspair M[5] = {sspair("MSL2","ml2"), sspair("MSE2","me2"), sspair("MSQ2","mq2"), sspair("MSU2","mu2"), sspair("MSD2","md2")};
148  for (int k=0;k<5;k++)
149  {
150  std::string block(M[k].first);
151  if(not SLHAea_block_exists(data, block)) SLHAea_add_block(data, block, scale); //TODO: maybe just always delete and replace
152  for(int i=1;i<4;i++) for(int j=1;j<4;j++)
153  {
154  std::ostringstream comment;
155  comment << block << "(" << i << "," << j << ")";
156  double entry;
157  if(i==j)
158  {
159  entry = getdata("MSOFT",30+3*k+i+(k>1?4:0)); // black magic to get correct index in MSOFT matching diagonal elements
160  }
161  else
162  {
163  // Everything off-diagonal is zero in SLHA1
164  entry = 0;
165  }
166  //data[block][""] << i << j << entry*entry << "# "+comment.str();
167  SLHAea_add(data, block, i, j, entry*entry, "# "+comment.str(), true);
168  }
169  }
170 
171  // Yukawa and trilinear blocks. YU, YD and YE, plus [YU, YD and YE; SLHA1 only], or [TU, TD and TE; SLHA2 only].
172  sspair A[3] = {sspair("AU","Au"), sspair("AD","Ad"), sspair("AE","Ae")};
173  sspair Y[3] = {sspair("YU","Yu"), sspair("YD","Yd"), sspair("YE","Ye")};
174  sspair T[3] = {sspair("TU","TYu"), sspair("TD","TYd"), sspair("TE","TYe")};
175  for (int k=0;k<3;k++)
176  {
177  SLHAea_check_block(data, A[k].first);
178  SLHAea_check_block(data, Y[k].first);
179  SLHAea_check_block(data, T[k].first); // TODO: should delete superceded slha1 "A" blocks?
180  for(int i=1;i<4;i++)
181  {
182  for(int j=1;j<4;j++)
183  {
184  std::ostringstream comment;
185  comment << "(" << i << "," << j << ")";
186  // SLHA1 has only diagonal elements in Y and A. We should fill them out fully.
187  // Assume missing diagonal elements are also zero.
188  double Yentry;
189  double Aentry;
190  if(i==j)
191  {
192  if(SLHAea_check_block(data,Y[k].first,i,j))
193  {
194  Yentry = getdata(Y[k].first,i,j);
195  }
196  else
197  {
198  Yentry = 0;
199  }
200 
201  if(SLHAea_check_block(data,A[k].first,i,j))
202  {
203  Aentry = getdata(A[k].first,i,j);
204  }
205  else
206  {
207  Aentry = 0;
208  }
209  }
210  else
211  {
212  Yentry = 0;
213  Aentry = 0;
214  }
215 
216  double Tentry = Aentry * Yentry;
217  SLHAea_add(data, Y[k].first, i, j, Yentry, "# "+Y[k].first+"_"+comment.str(), true);
218  SLHAea_add(data, A[k].first, i, j, Aentry, "# "+A[k].first+"_"+comment.str(), true);
219  SLHAea_add(data, T[k].first, i, j, Tentry, "# "+T[k].first+"_"+comment.str(), true);
220  }
221  }
222  }
223 
224 
225  }
226 
227  else logger() << "Input SLHA data for setting up simple spectrum is SLHA2. *living in the future*" << EOM;
228  // In the end, we should always have converted to SLHA2 by now, so set this as the internally-tracked version.
230  }
231 
233  double MSSMea::get_Mu() const{ return getdata("HMIX",1); } // mu(Q) DRbar
234  double MSSMea::get_tanbeta() const{ return getdata("HMIX",2); } // tan beta(Q) DRbar ( = vu/vd)
235  double MSSMea::get_tanbeta_mZ() const{ return getdata("MINPAR",3); } // tan beta(mZ) DRbar
236  double MSSMea::get_v() const{ return getdata("HMIX",3); } // v = sqrt(vd^2 + vu^2) DRbar
237  double MSSMea::get_mA2() const{ return getdata("HMIX",4); } // m^2_A=[m3^2/cosBsinB](Q) DRbar, tree
240  // double MSSMea::get_BMu() const { return getdata("HMIX",101); }
241  // double MSSMea::get_vd() const { return getdata("HMIX",102); }
242  // double MSSMea::get_vu() const { return getdata("HMIX",103); }
244  double MSSMea::get_BMu() const
245  {
246  double tb = get_tanbeta();
247  double cb = cos(atan(tb));
248  double sb = sin(atan(tb));
249  return get_mA2() * (sb * cb);
250  }
251  double MSSMea::get_vd() const
252  {
253  double v = get_v();
254  double tb = get_tanbeta();
255  return sqrt(abs( v*v / ( tb*tb + 1 ) ));
256  }
257  double MSSMea::get_vu() const
258  {
259  double v = get_v();
260  double itb = 1./get_tanbeta();
261  return sqrt(abs( v*v / ( itb*itb + 1 ) ));
262  }
263 
264  double MSSMea::get_MassB () const { return getdata("MSOFT",1); }
265  double MSSMea::get_MassWB() const { return getdata("MSOFT",2); }
266  double MSSMea::get_MassG () const { return getdata("MSOFT",3); }
267  double MSSMea::get_mHd2() const { return getdata("MSOFT",21); }
268  double MSSMea::get_mHu2() const { return getdata("MSOFT",22); }
269 
270  double MSSMea::get_mq2(int i, int j) const { return getdata("MSQ2",i,j); }
271  double MSSMea::get_ml2(int i, int j) const { return getdata("MSL2",i,j); }
272  double MSSMea::get_md2(int i, int j) const { return getdata("MSD2",i,j); }
273  double MSSMea::get_mu2(int i, int j) const { return getdata("MSU2",i,j); }
274  double MSSMea::get_me2(int i, int j) const { return getdata("MSE2",i,j); }
275 
276  double MSSMea::get_TYd(int i, int j) const { return getdata("Td",i,j); }
277  double MSSMea::get_TYu(int i, int j) const { return getdata("Tu",i,j); }
278  double MSSMea::get_TYe(int i, int j) const { return getdata("Te",i,j); }
279 
280  double MSSMea::get_ad(int i, int j) const { return getdata("Ad",i,j); }
281  double MSSMea::get_au(int i, int j) const { return getdata("Au",i,j); }
282  double MSSMea::get_ae(int i, int j) const { return getdata("Ae",i,j); }
283 
284  double MSSMea::get_Yd(int i, int j) const { return getdata("Yd",i,j); }
285  double MSSMea::get_Yu(int i, int j) const { return getdata("Yu",i,j); }
286  double MSSMea::get_Ye(int i, int j) const { return getdata("Ye",i,j); }
287 
288  double MSSMea::get_g1() const { return getdata("GAUGE",1)/sqrt(3./5.); } // Convert from gy (in SLHAea object) to g1
289  double MSSMea::get_g2() const { return getdata("GAUGE",2); }
290  double MSSMea::get_g3() const { return getdata("GAUGE",3); }
292  {
293  double sg1 = 0.6 * Utils::sqr(get_g1());
294  return sg1 / (sg1 + Utils::sqr(get_g2()));
295  }
296 
297  double MSSMea::get_MGlu_pole() const { return getdata("MASS",1000021); }
298 
299  double MSSMea::get_Mhh_pole_slha(int i) const
300  {
301  if (i==1){ return getdata("MASS",25); } // Neutral Higgs(1)
302  else if (i==2){ return getdata("MASS",35); } // Neutral Higgs(2)
303  else { utils_error().raise(LOCAL_INFO,"Invalid index input to get_Mhh_pole_slha! Please check index range limits in wrapper SubSpectrum class!"); return -1; } // Should not return.
304  }
305  double MSSMea::get_MAh_pole () const { return getdata("MASS",36); }
306  double MSSMea::get_MHpm_pole() const { return getdata("MASS",37); }
307  double MSSMea::get_MW_pole() const { return getdata("MASS",24); } // REQUIRED output of MSSM-compatible subspectrum
308 
309  double MSSMea::get_MCha_pole_slha(int i) const
310  {
311  if (i==1){ return getdata("MASS",1000024); } // Chargino(1)
312  else if (i==2){ return getdata("MASS",1000037); } // Chargino(2)
313  else { utils_error().raise(LOCAL_INFO,"Invalid index input to get_MCha_pole_slha! Please check index range limits in wrapper SubSpectrum class!"); return -1; } // Should not return.
314  }
315  double MSSMea::get_MSd_pole_slha(int i) const
316  {
317  static std::map<int,int> match;
318 
319  if (i==1){ return getdata("MASS",1000001); } // d-type squark(1)
320  else if (i==2){ return getdata("MASS",1000003); } // d-type squark(2)
321  else if (i==3){ return getdata("MASS",1000005); } // d-type squark(3)
322  else if (i==4){ return getdata("MASS",2000001); } // d-type squark(4)
323  else if (i==5){ return getdata("MASS",2000003); } // d-type squark(5)
324  else if (i==6){ return getdata("MASS",2000005); } // d-type squark(6)
325  else { utils_error().raise(LOCAL_INFO,"Invalid index input to get_MSd_pole_slha! Please check index range limits in wrapper SubSpectrum class!"); return -1; } // Should not return.
326  }
327  double MSSMea::get_MSu_pole_slha(int i) const
328  {
329  if (i==1){ return getdata("MASS",1000002); } // u-type squark(1)
330  else if (i==2){ return getdata("MASS",1000004); } // u-type squark(2)
331  else if (i==3){ return getdata("MASS",1000006); } // u-type squark(3)
332  else if (i==4){ return getdata("MASS",2000002); } // u-type squark(4)
333  else if (i==5){ return getdata("MASS",2000004); } // u-type squark(5)
334  else if (i==6){ return getdata("MASS",2000006); } // u-type squark(6)
335  else { utils_error().raise(LOCAL_INFO,"Invalid index input to get_MSd_pole_slha! Please check index range limits in wrapper SubSpectrum class!"); return -1; } // Should not return.
336  }
337  double MSSMea::get_MSe_pole_slha(int i) const
338  {
339  if (i==1){ return getdata("MASS",1000011); } // charged slepton(1)
340  else if (i==2){ return getdata("MASS",1000013); } // charged slepton(2)
341  else if (i==3){ return getdata("MASS",1000015); } // charged slepton(3)
342  else if (i==4){ return getdata("MASS",2000011); } // charged slepton(4)
343  else if (i==5){ return getdata("MASS",2000013); } // charged slepton(5)
344  else if (i==6){ return getdata("MASS",2000015); } // charged slepton(6)
345  else { utils_error().raise(LOCAL_INFO,"Invalid index input to get_MSd_pole_slha! Please check index range limits in wrapper SubSpectrum class!"); return -1; } // Should not return.
346  }
347  double MSSMea::get_MSv_pole_slha(int i) const
348  {
349  if (i==1){ return getdata("MASS",1000012); } // Sneutrino(1)
350  else if (i==2){ return getdata("MASS",1000014); } // Sneutrino(2)
351  else if (i==3){ return getdata("MASS",1000016); } // Sneutrino(3)
352  else { utils_error().raise(LOCAL_INFO,"Invalid index input to get_MSd_pole_slha! Please check index range limits in wrapper SubSpectrum class!"); return -1; } // Should not return.
353  }
354  double MSSMea::get_MChi_pole_slha(int i) const
355  {
356  if (i==1){ return getdata("MASS",1000022); } // Neutralino(1)
357  else if (i==2){ return getdata("MASS",1000023); } // Neutralino(2)
358  else if (i==3){ return getdata("MASS",1000025); } // Neutralino(3)
359  else if (i==4){ return getdata("MASS",1000035); } // Neutralino(4)
360  else { utils_error().raise(LOCAL_INFO,"Invalid index input to get_MChi_pole_slha! Please check index range limits in wrapper SubSpectrum class!"); return -1; } // Should not return.
361  }
362 
363  // Pole Mixings
364  double MSSMea::get_ZD_pole_slha(int i, int j) const { return getdata("DSQMIX",i,j); }
365  double MSSMea::get_ZU_pole_slha(int i, int j) const { return getdata("USQMIX",i,j); }
366 
367  double MSSMea::get_ZV_pole_slha(int i, int j) const { return getdata("SNUMIX",i,j); }
368  double MSSMea::get_ZE_pole_slha(int i, int j) const { return getdata("SELMIX",i,j); }
369 
370  double MSSMea::get_ZH_pole_slha(int i, int j) const { return getdata("SCALARMIX",i,j); }
371  double MSSMea::get_ZA_pole_slha(int i, int j) const { return getdata("PSEUDOSCALARMIX",i,j); }
372 
373  double MSSMea::get_ZP_pole_slha(int i, int j) const { return getdata("CHARGEMIX",i,j); }
374  double MSSMea::get_ZN_pole_slha(int i, int j) const { return getdata("NMIX",i,j); }
375 
376  double MSSMea::get_UM_pole_slha(int i, int j) const { return getdata("UMIX",i,j); }
377  double MSSMea::get_UP_pole_slha(int i, int j) const { return getdata("VMIX",i,j); }
378 
380 
381 
383 
385 
388  {
389  set_pole_mass_uncertainties(uncert);
390  }
391 
393  MSSMSimpleSpec::MSSMSimpleSpec(const SLHAea::Coll& input, double uncert)
394  : SLHASimpleSpec(input)
395  {
397  }
398 
400  MSSMSimpleSpec::MSSMSimpleSpec(const MSSMSimpleSpec& other, double uncert)
401  : SLHASimpleSpec(other)
402  {
404  }
405 
407 
409  int MSSMSimpleSpec::get_index_offset() const {return 0.;} // we use indices starting from 1 in this file, matching user assumptions. (because Peter is god, he knows user assumptions before they do.)
410 
412  // NOTE! No need to write this function, SubSpectrum base class can handle it if add_to_SLHAea exists.
413  //SLHAea::Coll MSSMSimpleSpec::getSLHAea(int slha_version) const
414 
416  void MSSMSimpleSpec::add_to_SLHAea(int slha_version, SLHAea::Coll& slha) const
417  {
418  slha = slhawrap.get_slhaea();
419 
420  // Add SPINFO data if not already present
422 
423  // All MSSM blocks
424  slhahelp::add_MSSM_spectrum_to_SLHAea(*this, slha, slha_version);
425  }
426 
428  const std::map<int, int>& MSSMSimpleSpec::PDG_translator() const { return slhawrap.PDG_translator(); }
429 
432  {
433  const std::vector<int> i12 = initVector(1,2);
434  const std::vector<int> i123 = initVector(1,2,3);
435  const std::vector<int> i1234 = initVector(1,2,3,4);
436  const std::vector<int> i123456 = initVector(1,2,3,4,5,6);
437  const std::vector<str> sbosons1 = initVector<str>("~g","A0","H+","H-","W+","W-");
438  const std::vector<str> sbosons2 = initVector<str>("~chi+","~chi-","h0");
439  const std::vector<str> sfermions1 = initVector<str>("~u","~d","~e-","~ubar","~dbar","~e+");
440  const std::vector<str> sfermions2 = initVector<str>("~nu","~nubar");
441  set_override_vector(Par::Pole_Mass_1srd_high, uncert, sfermions1, i123456, true);
442  set_override_vector(Par::Pole_Mass_1srd_low, uncert, sfermions1, i123456, true);
443  set_override_vector(Par::Pole_Mass_1srd_high, uncert, sfermions2, i123, true);
444  set_override_vector(Par::Pole_Mass_1srd_low, uncert, sfermions2, i123, true);
445  set_override_vector(Par::Pole_Mass_1srd_high, uncert, sbosons1, true);
446  set_override_vector(Par::Pole_Mass_1srd_low, uncert, sbosons1, true);
447  set_override_vector(Par::Pole_Mass_1srd_high, uncert, sbosons2, i12, true);
448  set_override_vector(Par::Pole_Mass_1srd_low, uncert, sbosons2, i12, true);
449  set_override_vector(Par::Pole_Mass_1srd_high, uncert, "~chi0", i1234, true);
450  set_override_vector(Par::Pole_Mass_1srd_low, uncert, "~chi0", i1234, true);
451  }
452 
453  // Map fillers
454 
456  {
457  GetterMaps map_collection;
458 
459  typedef MTget::FInfo1 FInfo1;
460  typedef MTget::FInfo2 FInfo2;
461 
462  // Can't use c++11 initialiser lists, se have to initialise the index sets like this.
463  static const int i12v[] = {1,2};
464  static const std::set<int> i12(i12v, Utils::endA(i12v));
465 
466  static const int i123v[] = {1,2,3};
467  static const std::set<int> i123(i123v, Utils::endA(i123v));
468 
469  static const int i1234v[] = {1,2,3,4};
470  static const std::set<int> i1234(i1234v, Utils::endA(i1234v));
471 
472  static const int i123456v[] = {1,2,3,4,5,6};
473  static const std::set<int> i123456(i123456v, Utils::endA(i123456v));
474 
475  // Running parameters
476  {
477  MTget::fmap0 tmp_map;
478  tmp_map["BMu"] = &Model::get_BMu;
479  tmp_map["mA2"] = &Model::get_mA2;
480  tmp_map["mHd2"] = &Model::get_mHd2;
481  tmp_map["mHu2"] = &Model::get_mHu2;
482  map_collection[Par::mass2].map0 = tmp_map;
483  }
484  {
485  MTget::fmap2 tmp_map;
486  tmp_map["mq2"] = FInfo2( &Model::get_mq2, i123, i123);
487  tmp_map["ml2"] = FInfo2( &Model::get_ml2, i123, i123);
488  tmp_map["md2"] = FInfo2( &Model::get_md2, i123, i123);
489  tmp_map["mu2"] = FInfo2( &Model::get_mu2, i123, i123);
490  tmp_map["me2"] = FInfo2( &Model::get_me2, i123, i123);
491  map_collection[Par::mass2].map2 = tmp_map;
492  }
493  {
494  MTget::fmap0 tmp_map;
495  tmp_map["M1"]= &Model::get_MassB;
496  tmp_map["M2"]= &Model::get_MassWB;
497  tmp_map["M3"]= &Model::get_MassG;
498  tmp_map["Mu"]= &Model::get_Mu;
499  tmp_map["vu"]= &Model::get_vu;
500  tmp_map["vd"]= &Model::get_vd;
501  map_collection[Par::mass1].map0 = tmp_map;
502  }
503  {
504  MTget::fmap2 tmp_map;
505  tmp_map["TYd"]= FInfo2( &Model::get_TYd, i123, i123);
506  tmp_map["TYe"]= FInfo2( &Model::get_TYe, i123, i123);
507  tmp_map["TYu"]= FInfo2( &Model::get_TYu, i123, i123);
508  tmp_map["ad"] = FInfo2( &Model::get_ad, i123, i123);
509  tmp_map["ae"] = FInfo2( &Model::get_ae, i123, i123);
510  tmp_map["au"] = FInfo2( &Model::get_au, i123, i123);
511  map_collection[Par::mass1].map2 = tmp_map;
512  }
513  {
514  MTget::fmap0 tmp_map;
515  tmp_map["g1"]= &Model::get_g1;
516  tmp_map["g2"]= &Model::get_g2;
517  tmp_map["g3"]= &Model::get_g3;
518  tmp_map["tanbeta"]= &Model::get_tanbeta;
519  tmp_map["tanbeta(mZ)"]= &Model::get_tanbeta_mZ; // Special entry for reproducing MINPAR entry in SLHA
520  tmp_map["sinW2"]= &Model::get_sinthW2_DRbar;
521  map_collection[Par::dimensionless].map0 = tmp_map;
522  }
523  {
524  MTget::fmap2 tmp_map;
525  tmp_map["Yd"]= FInfo2( &Model::get_Yd, i123, i123);
526  tmp_map["Yu"]= FInfo2( &Model::get_Yu, i123, i123);
527  tmp_map["Ye"]= FInfo2( &Model::get_Ye, i123, i123);
528  map_collection[Par::dimensionless].map2 = tmp_map;
529  }
530 
531  // "Physical" parameters
532  {
533  MTget::fmap0 tmp_map;
534  tmp_map["~g"] = &Model::get_MGlu_pole;
535  tmp_map["A0"] = &Model::get_MAh_pole;
536  tmp_map["H+"] = &Model::get_MHpm_pole;
537  // Antiparticle label
538  tmp_map["H-"] = &Model::get_MHpm_pole;
539  tmp_map["W+"] = &Model::get_MW_pole;
540  map_collection[Par::Pole_Mass].map0 = tmp_map;
541  }
542  {
543  MTget::fmap1 tmp_map;
544  tmp_map["~d"] = FInfo1( &Model::get_MSd_pole_slha, i123456 );
545  tmp_map["~u"] = FInfo1( &Model::get_MSu_pole_slha, i123456 );
546  tmp_map["~e-"] = FInfo1( &Model::get_MSe_pole_slha, i123456 );
547  tmp_map["~nu"] = FInfo1( &Model::get_MSv_pole_slha, i123 );
548  tmp_map["h0"] = FInfo1( &Model::get_Mhh_pole_slha, i12 );
549  tmp_map["~chi+"] = FInfo1( &Model::get_MCha_pole_slha, i12 );
550  tmp_map["~chi0"] = FInfo1( &Model::get_MChi_pole_slha, i1234 );
551 
552  // Antiparticles (same getters, just different string name)
553  tmp_map["~dbar"] = FInfo1( &Model::get_MSd_pole_slha, i123456 );
554  tmp_map["~ubar"] = FInfo1( &Model::get_MSu_pole_slha, i123456 );
555  tmp_map["~e+"] = FInfo1( &Model::get_MSe_pole_slha, i123456 );
556  tmp_map["~nubar"]= FInfo1( &Model::get_MSv_pole_slha, i123 );
557  tmp_map["~chi-"] = FInfo1( &Model::get_MCha_pole_slha, i12 );
558  map_collection[Par::Pole_Mass].map1 = tmp_map;
559  }
560  {
561  MTget::fmap2 tmp_map;
562  tmp_map["~d"] = FInfo2( &Model::get_ZD_pole_slha, i123456, i123456);
563  tmp_map["~nu"] = FInfo2( &Model::get_ZV_pole_slha, i123, i123);
564  tmp_map["~u"] = FInfo2( &Model::get_ZU_pole_slha, i123456, i123456);
565  tmp_map["~e-"]= FInfo2( &Model::get_ZE_pole_slha, i123456, i123456);
566  tmp_map["h0"] = FInfo2( &Model::get_ZH_pole_slha, i12, i12);
567  tmp_map["A0"] = FInfo2( &Model::get_ZA_pole_slha, i12, i12);
568  tmp_map["H+"] = FInfo2( &Model::get_ZP_pole_slha, i12, i12);
569  tmp_map["~chi0"] = FInfo2( &Model::get_ZN_pole_slha, i1234, i1234);
570  tmp_map["~chi-"] = FInfo2( &Model::get_UM_pole_slha, i12, i12);
571  tmp_map["~chi+"] = FInfo2( &Model::get_UP_pole_slha, i12, i12);
572  map_collection[Par::Pole_Mixing].map2 = tmp_map;
573  }
574 
575  return map_collection;
576  }
577 
578 
579 } // end Gambit namespace
580 
581 
double get_UP_pole_slha(int i, int j) const
double get_vu() const
double get_Yd(int i, int j) const
SLHAea::Coll data
SLHAea object.
MSSMSimpleSpec(double uncert=0.03)
Constructors.
virtual const std::map< int, int > & PDG_translator() const
Retrieve the PDG translation map.
double get_Mu() const
Getters for MSSM information.
EXPORT_SYMBOLS error & utils_error()
Utility errors.
double get_md2(int i, int j) const
void set_pole_mass_uncertainties(double)
Set pole mass uncertainties.
virtual int get_index_offset() const
Ofset from user-input indices (user assumes 1,2,3 indexed, e.g. use offset=-1 for zero-indexing) ...
double get_Yu(int i, int j) const
double get_Mhh_pole_slha(int i) const
double get_ZA_pole_slha(int i, int j) const
double get_MChi_pole_slha(int i) const
double get_g3() const
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.
double get_MSu_pole_slha(int i) const
double get_vd() const
#define LOCAL_INFO
Definition: local_info.hpp:34
double get_ae(int i, int j) const
double get_mq2(int i, int j) const
double get_MSv_pole_slha(int i) const
double get_ZV_pole_slha(int i, int j) const
Logging access header for GAMBIT.
double get_tanbeta(const Model &model)
Definition: MSSMSpec.hpp:218
void SLHAea_add_GAMBIT_SPINFO(SLHAstruct &slha)
Write the SPINFO block with GAMBIT name and version number.
double get_MassB() const
START_MODEL b
Definition: demo.hpp:235
double get_g1() const
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) ...
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
double get_TYu(int i, int j) const
double get_Ye(int i, int j) const
std::pair< str, str > sspair
Shorthand for a pair of standard strings.
Definition: util_types.hpp:64
double get_MW_pole() const
General small utility functions.
double getdata(const std::string &block, int index) const
Helper functions to do error checking for SLHAea object contents.
void set_override_vector(const Par::Tags, const double, const std::vector< str > &, const bool allow_new=false, const bool decouple=false)
Vector override functions.
void add_MSSM_spectrum_to_SLHAea(const SubSpectrum &mssmspec, SLHAstruct &slha, int slha_version)
Add an entire MSSM spectrum to an SLHAea object.
double get_mA2() const
double get_MHpm_pole() const
double get_MassG() const
double get_tanbeta() const
bool SLHAea_block_exists(SLHAstruct &slha, const str &block)
Check if a block exists in an SLHAea object.
double get_mu2(int i, int j) const
double get_ZD_pole_slha(int i, int j) const
double get_au(int i, int j) const
double get_ZP_pole_slha(int i, int j) const
const Logging::endofmessage EOM
Explicit const instance of the end of message struct in Gambit namespace.
Definition: logger.hpp:99
double get_MAh_pole() const
double get_tanbeta_mZ() const
Logging::LogMaster & logger()
Function to retrieve a reference to the Gambit global log object.
Definition: logger.cpp:95
Variadic utilty functions.
double get_sinthW2_DRbar(const Model &model)
Definition: MSSMSpec.hpp:234
double get_mHu2() const
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
std::vector< T > initVector(std::vector< T > vector)
virtual void add_to_SLHAea(int, SLHAea::Coll &) const
Retrieve SLHAea object.
double get_ad(int i, int j) const
double get_ZH_pole_slha(int i, int j) const
double get_MGlu_pole() const
MSSMea()
Constructors.
START_MODEL M
double get_v() const
double get_MassWB() const
double get_MSd_pole_slha(int i) const
static GetterMaps fill_getter_maps()
Map fillers Used to initialise maps in Spec class, accessed via SubSpectrum interface class (speciali...
double get_me2(int i, int j) const
double get_ZE_pole_slha(int i, int j) const
double get_mHd2() const
double get_BMu() const
double get_g2() const
int wrapped_slha_version
SLHA version of SLHAea object.
double get_ZU_pole_slha(int i, int j) const
MSSM specialisation of SLHAea object wrapper version of SubSpectrum class.
double get_TYe(int i, int j) const
bool orderer(std::pair< int, double > a, std::pair< int, double > b)
Helper function for sorting int, double pairs according to the double.
double get_ZN_pole_slha(int i, int j) const
double get_ml2(int i, int j) const
T * endA(T(&arr)[N])
double get_sinthW2_DRbar() const
double get_UM_pole_slha(int i, int j) const
std::map< int, int > PDG_translation_map
PDG translation map (e.g. from SLHA1 to SLHA2 for MSSMskeleton)
TODO: see if we can use this one:
Definition: Analysis.hpp:33
double get_MCha_pole_slha(int i) const
Skeleton "model" class which interacts with an SLHAea object.
bool SLHAea_check_block(SLHAstruct &slha, const str &block)
Check if a block exists in an SLHAea object, add it if not.
double get_TYd(int i, int j) const
std::map< Par::Tags, MapCollection< MTget > > GetterMaps
Will need a map of map collections for both the getters and setters, containing the map collections f...
Definition: spec_head.hpp:248
double get_MSe_pole_slha(int i) const