gambit is hosted by Hepforge, IPPP Durham
GAMBIT  v1.5.0-252-gf9a3f78
a Global And Modular Bsm Inference Tool
spectrum.cpp
Go to the documentation of this file.
1 // GAMBIT: Global and Modular BSM Inference Tool
2 // *********************************************
36 
38 #include "gambit/Models/SimpleSpectra/SMSimpleSpec.hpp" // For auto-creation of simple SM low-energy SubSpectrum
41 
42 //#define SPECTRUM_DEBUG
43 
44 namespace Gambit
45 {
46 
48 
50  void Spectrum::check_init() const
51  {
52  if(not initialised) utils_error().raise(LOCAL_INFO,"Access or deepcopy of empty Spectrum object attempted!");
53  }
54 
57  void swap(Spectrum& first, Spectrum& second)
58  {
59  using std::swap; // enable ADL
60  swap(first.LE, second.LE);
61  swap(first.HE, second.HE);
62  swap(first.LE_new, second.LE_new);
63  swap(first.HE_new, second.HE_new);
64  swap(first.SMINPUTS, second.SMINPUTS);
65  swap(first.input_Param, second.input_Param);
66  swap(first.mass_cuts, second.mass_cuts);
67  swap(first.mass_ratio_cuts, second.mass_ratio_cuts);
68  swap(first.initialised, second.initialised);
69  }
70 
72 
75 
77  Spectrum::Spectrum(const SubSpectrum& le, const SubSpectrum& he, const SMInputs& smi, const std::map<str, safe_ptr<const double> >* params,
78  const mc_info& mci, const mr_info& mri)
79  : LE_new(le.clone())
80  , HE_new(he.clone())
81  , LE(LE_new.get())
82  , HE(HE_new.get())
83  , SMINPUTS(smi)
84  , input_Param(params)
85  , mass_cuts(&mci)
86  , mass_ratio_cuts(&mri)
87  , initialised(true)
88  { check_mass_cuts(); }
89 
91  Spectrum::Spectrum(const SubSpectrum& he, const SMInputs& smi, const std::map<str, safe_ptr<const double> >* params, const mc_info& mci, const mr_info& mri)
92  : LE_new(SMSimpleSpec(smi).clone())
93  , HE_new(he.clone())
94  , LE(LE_new.get())
95  , HE(HE_new.get())
96  , SMINPUTS(smi)
97  , input_Param(params)
98  , mass_cuts(&mci)
99  , mass_ratio_cuts(&mri)
100  , initialised(true)
101  { check_mass_cuts(); }
102 
105  Spectrum::Spectrum(SubSpectrum* const le, SubSpectrum* const he, const SMInputs& smi, const std::map<str, safe_ptr<const double> >* params,
106  const mc_info& mci, const mr_info& mri)
107  : LE(le)
108  , HE(he)
109  , SMINPUTS(smi)
110  , input_Param(params)
111  , mass_cuts(&mci)
112  , mass_ratio_cuts(&mri)
113  , initialised(true)
114  { check_mass_cuts(); }
115 
119  : LE_new(other.clone_LE())
120  , HE_new(other.clone_HE())
121  , LE(LE_new.get())
122  , HE(HE_new.get())
123  , SMINPUTS(other.SMINPUTS)
124  , input_Param(other.input_Param)
125  , mass_cuts(other.mass_cuts)
127  , initialised(other.initialised)
128  {}
129 
133  {
134  Spectrum temp(other);
135  swap(*this, temp);
136  return *this;
137  }
138 
141  {
142  swap(*this, other);
143  }
144 
146 
149  //DEFINE_PDG_GETTERS(Spectrum,Pole_Mass) //TODO: redo
150 
153  void Spectrum::RunBothToScale(double scale)
154  {
155  LE->RunToScale(scale);
156  HE->RunToScale(scale);
157  }
158 
160  bool is_abs(str& s)
161  {
162  if (s.at(0) != '|' or *s.rbegin() != '|') return false;
163  s = s.substr(1, s.size()-2);
164  return true;
165  }
166 
169  {
170  if (mass_cuts != NULL and not mass_cuts->empty())
171  {
172  for (auto it = mass_cuts->begin(); it != mass_cuts->end(); ++it)
173  {
174  str p = it->first;
175  bool absolute_value = is_abs(p);
176  const double& low = it->second.first;
177  const double& high = it->second.second;
178  #ifdef SPECTRUM_DEBUG
179  cout << "Applying mass cut " << low << " GeV < " << (absolute_value ? "|mass("+p+")|" : "mass("+p+")") << " < " << high << " GeV" << endl;
180  #endif
181  if (not has(Par::Pole_Mass, p)) utils_error().raise(LOCAL_INFO, "Cannot cut on mass of unrecognised particle: " + p);
182  double m = get(Par::Pole_Mass, p);
183  if (absolute_value) m = std::abs(m);
184  #ifdef SPECTRUM_DEBUG
185  cout << "Actual value: " << m << endl;
186  #endif
187  if (m < low or m > high) invalid_point().raise(p + " failed requested mass cut.");
188  }
189  }
190  if (mass_ratio_cuts != NULL and not mass_ratio_cuts->empty())
191  {
192  for (auto it = mass_ratio_cuts->begin(); it != mass_ratio_cuts->end(); ++it)
193  {
194  str p1 = it->first.first;
195  str p2 = it->first.second;
196  bool absolute_value1 = is_abs(p1);
197  bool absolute_value2 = is_abs(p2);
198  const double& low = it->second.first;
199  const double& high = it->second.second;
200  #ifdef SPECTRUM_DEBUG
201  cout << "Applying mass ratio cut " << low << " < "
202  << (absolute_value1 ? "|mass("+p1+")|" : "mass("+p1+")") << " / "
203  << (absolute_value2 ? "|mass("+p2+")|" : "mass("+p2+")")
204  << " < " << high << endl;
205  #endif
206  if (not has(Par::Pole_Mass, p1)) utils_error().raise(LOCAL_INFO, "Cannot cut on ratio with mass of unrecognised particle: " + p1);
207  if (not has(Par::Pole_Mass, p2)) utils_error().raise(LOCAL_INFO, "Cannot cut on ratio with mass of unrecognised particle: " + p2);
208  double m1 = get(Par::Pole_Mass, p1);
209  double m2 = get(Par::Pole_Mass, p2);
210  if (absolute_value1) m1 = std::abs(m1);
211  if (absolute_value2) m2 = std::abs(m2);
212  double mratio = m1/m2;
213  #ifdef SPECTRUM_DEBUG
214  cout << "Actual value: " << mratio << endl;
215  #endif
216  if (mratio < low or mratio > high) invalid_point().raise(p1 + "/" + p2 +" failed requested mass ratio cut.");
217  }
218  }
219  }
220 
227  // const versions
228  const SubSpectrum& Spectrum::get_LE() const {check_init(); return *LE;}
229  const SubSpectrum& Spectrum::get_HE() const {check_init(); return *HE;}
231 
234  std::unique_ptr<SubSpectrum> Spectrum::clone_LE() const {check_init(); return LE->clone();}
235  std::unique_ptr<SubSpectrum> Spectrum::clone_HE() const {check_init(); return HE->clone();}
236 
244  bool Spectrum::has(const Par::Tags partype, const std::string& mass) const
245  {
246  return (HE->has(partype,mass) or LE->has(partype,mass));
247  }
248 
249  double Spectrum::get(const Par::Tags partype, const std::string& mass) const
250  {
251  double result(-1);
252  if( HE->has(partype,mass) )
253  { result = HE->get(partype,mass); }
254  else if( LE->has(partype,mass) )
255  { result = LE->get(partype,mass); }
256  else
257  {
258  std::ostringstream errmsg;
259  errmsg << "Error retrieving particle spectrum data!" << std::endl;
260  errmsg << "No pole mass with string reference '"<<mass<<"' could be found in either LE or HE SubSpectrum!" <<std::endl;
261  utils_error().raise(LOCAL_INFO,errmsg.str());
262  }
263  // In c++11 we could add the [[noreturn]] attribute utils_error.raise()
264  // to suppress the compiler warning about not returning anything (and enable
265  // extra optimisations), however it isn't implemented in gcc until version
266  // 4.8 (and we decided to support earlier versions).
267  return result;
268  }
269 
270  bool Spectrum::has(const Par::Tags partype, const std::string& mass, const int index) const
271  {
272  return (HE->has(partype,mass,index) or LE->has(partype,mass,index));
273  }
274 
275  double Spectrum::get(const Par::Tags partype, const std::string& mass, const int index) const
276  {
277  double result(-1);
278  if( HE->has(partype,mass,index) )
279  { result = HE->get(partype,mass,index); }
280  else if( LE->has(partype,mass,index) )
281  { result = LE->get(partype,mass,index); }
282  else
283  {
284  std::ostringstream errmsg;
285  errmsg << "Error retrieving particle spectrum data!" << std::endl;
286  errmsg << "No pole mass with string reference '"<<mass<<"' and index '"<<index<<"' could be found in either LE or HE SubSpectrum!" <<std::endl;
287  utils_error().raise(LOCAL_INFO,errmsg.str());
288  }
289  // [[noreturn]]
290  return result;
291  }
292 
294 
295  /* Input PDG code plus context integer as separate arguments */
296  bool Spectrum::has(const Par::Tags partype,
297  const int pdg_code, const int context) const
298  {
299  return has( partype, std::make_pair(pdg_code,context) );
300  }
301 
302  /* Input PDG code plus context integer as separate arguments */
303  double Spectrum::get(const Par::Tags partype,
304  const int pdg_code, const int context) const
305  {
306  return get( partype, std::make_pair(pdg_code,context) );
307  }
308 
309  /* Input PDG code plus context integer as pair */
310  bool Spectrum::has(const Par::Tags partype,
311  const std::pair<int,int> pdgpr) const
312  {
313  /* If there is a short name, then retrieve that plus the index */
314  if( Models::ParticleDB().has_short_name(pdgpr) )
315  {
316  return has( partype, Models::ParticleDB().short_name_pair(pdgpr) );
317  }
318  else /* Use the long name with no index instead */
319  {
320  return has( partype, Models::ParticleDB().long_name(pdgpr) );
321  }
322  }
323 
324  /* Input PDG code plus context integer as pair */
325  double Spectrum::get(const Par::Tags partype,
326  const std::pair<int,int> pdgpr) const
327  {
328  /* If there is a short name, then retrieve that plus the index */
329  if( Models::ParticleDB().has_short_name(pdgpr) )
330  {
331  return get( partype, Models::ParticleDB().short_name_pair(pdgpr) );
332  }
333  else /* Use the long name with no index instead */
334  {
335  return get( partype, Models::ParticleDB().long_name(pdgpr) );
336  }
337  }
338 
339  /* Input short name plus index as pair */
340  bool Spectrum::has(const Par::Tags partype,
341  const std::pair<str,int> shortpr) const
342  {
343  return has( partype, shortpr.first, shortpr.second);
344  }
345 
346  /* Input short name plus index as pair */
347  double Spectrum::get(const Par::Tags partype,
348  const std::pair<str,int> shortpr) const
349  {
350  return get( partype, shortpr.first, shortpr.second);
351  }
352 
354 
356 
357  double Spectrum::safeget(const Par::Tags partype,
358  const std::string& mass) const
359  {
360  double result = get(partype, mass);
361  if (Utils::isnan(result))
362  utils_error().raise(LOCAL_INFO,"SubSpectrum parameter is nan!!");
363  return result;
364  }
365 
366  double Spectrum::safeget(const Par::Tags partype,
367  const std::string& mass, const int index) const
368  {
369  double result = get(partype, mass, index);
370  if (Utils::isnan(result))
371  utils_error().raise(LOCAL_INFO,"SubSpectrum parameter is nan!!");
372  return result;
373  }
374 
375  double Spectrum::safeget(const Par::Tags partype,
376  const int pdg_code, const int context) const
377  {
378  double result = get(partype, pdg_code, context);
379  if (Utils::isnan(result))
380  utils_error().raise(LOCAL_INFO,"SubSpectrum parameter is nan!!");
381  return result;
382  }
383 
384  double Spectrum::safeget(const Par::Tags partype,
385  const std::pair<int,int> pdgpr) const
386  {
387  double result = get(partype, pdgpr);
388  if (Utils::isnan(result))
389  utils_error().raise(LOCAL_INFO,"SubSpectrum parameter is nan!!");
390  return result;
391  }
392 
393  double Spectrum::safeget(const Par::Tags partype,
394  const std::pair<str,int> shortpr) const
395  {
396  double result = get(partype, shortpr);
397  if (Utils::isnan(result))
398  utils_error().raise(LOCAL_INFO,"SubSpectrum parameter is nan!!");
399  return result;
400  }
401 
403 
409  SLHAstruct Spectrum::getSLHAea(int slha_version) const
410  {
411  SLHAstruct slha(SMINPUTS.getSLHAea());
412  LE->add_to_SLHAea(slha_version, slha);
413  HE->add_to_SLHAea(slha_version, slha);
414  return slha;
415  }
416 
418  void Spectrum::writeSLHAfile(int slha_version, const str& filename) const
419  {
420  Utils::FileLock mylock(filename);
421  mylock.get_lock();
422  std::ofstream ofs(filename);
423  ofs << getSLHAea(slha_version);
424  ofs.close();
425  mylock.release_lock();
426  }
427 
429  void Spectrum::drop_SLHAs_if_requested(const safe_ptr<Options>& runOptions, const str& default_name)
430  {
431  if (runOptions->getValueOrDef<bool>(false, "drop_SLHA_file"))
432  {
433  // Spit out the full spectrum as SLHA1 and SLHA2 files.
434  str prefix = runOptions->getValueOrDef<str>("", "SLHA_output_prefix");
435  str filename = runOptions->getValueOrDef<str>(default_name, "SLHA_output_filename");
436  writeSLHAfile(1,prefix+filename+".slha1");
437  writeSLHAfile(2,prefix+filename+".slha2");
438  }
439  }
440 
442  const std::map<int, int>& Spectrum::PDG_translator() const
443  {
444  return HE->PDG_translator();
445  }
446 
447  // The expressions in all of the following CKM functions are from the CKMFitter paper hep-ph/0406184v3.
448 
450  std::complex<double> Spectrum::rhoplusieta(double lambda, double A, double rhobar, double etabar)
451  {
452  std::complex<double> x(rhobar, etabar);
453  double y = pow(A*lambda*lambda,2);
454  return sqrt((1.0-y)/(1.0-lambda*lambda))*x/(1.0-x*y);
455  }
456 
458  double Spectrum::Wolf2V_ud(double l, double A, double rhobar, double etabar)
459  {
460  double norm = std::norm(rhoplusieta(l,A,rhobar,etabar));
461  return 1.0 - 0.5*pow(l,2) - 0.125*pow(l,4) - 0.0625*pow(l,6)*(1.0+8.0*A*A*norm)
462  - 0.0078125*pow(l,8)*(5.0-32.0*A*A*norm);
463  }
464 
466  double Spectrum::Wolf2V_us(double l, double A, double rhobar, double etabar)
467  {
468  double norm = std::norm(rhoplusieta(l,A,rhobar,etabar));
469  return l - 0.5*A*A*pow(l,7)*norm;
470  }
471 
473  std::complex<double> Spectrum::Wolf2V_ub(double l, double A, double rhobar, double etabar)
474  {
475  return A*pow(l,3)*std::conj(rhoplusieta(l,A,rhobar,etabar));
476  }
477 
479  std::complex<double> Spectrum::Wolf2V_cd(double l, double A, double rhobar, double etabar)
480  {
481  std::complex<double> x(rhoplusieta(l,A,rhobar,etabar));
482  return 0.5*pow(A*l,2)*(pow(l,3)*(1.0-2.0*x) + pow(l,5)*x) - l;
483  }
484 
486  std::complex<double> Spectrum::Wolf2V_cs(double l, double A, double rhobar, double etabar)
487  {
488  double l2 = l*l;
489  double fA2 = 4.0*A*A;
490  return 1.0 - 0.5*l2 - 0.125*l2*l2*(1.0+fA2)
491  - 0.0625*pow(l2,3)*(1.0-fA2+4.0*fA2*rhoplusieta(l,A,rhobar,etabar))
492  - 0.0078125*pow(l2,4)*(5.0-fA2*(2.0+4.0*fA2));
493  }
494 
496  double Spectrum::Wolf2V_cb(double l, double A, double rhobar, double etabar)
497  {
498  return A*l*l * (1.0 - 0.5*A*A*pow(l,6)*std::norm(rhoplusieta(l,A,rhobar,etabar)));
499  }
500 
502  std::complex<double> Spectrum::Wolf2V_td(double l, double A, double rhobar, double etabar)
503  {
504  std::complex<double> x(rhoplusieta(l,A,rhobar,etabar));
505  return A*l*l * (l*(1.0-x) + 0.5*pow(l,3)*x + 0.125*pow(l,5)*(1.0+4.0*A*A)*x);
506  }
507 
509  std::complex<double> Spectrum::Wolf2V_ts(double l, double A, double rhobar, double etabar)
510  {
511  std::complex<double> x(rhoplusieta(l,A,rhobar,etabar));
512  return A*l*l * (0.5*pow(l,2)*(1.0-2.0*x) + 0.125*pow(l,4) + 0.0625*pow(l,6)*(1.0+8.0*A*A*x) - 1.0);
513  }
514 
516  double Spectrum::Wolf2V_tb(double l, double A, double rhobar, double etabar)
517  {
518  double norm = std::norm(rhoplusieta(l,A,rhobar,etabar));
519  double l4 = pow(l,4);
520  return 1.0 - 0.5*A*A*l4 * (1.0 + l*l*norm + 0.25*A*A*l4);
521  }
522 
523 } // end namespace Gambit
524 
friend void swap(Spectrum &first, Spectrum &second)
Friend function: swap resources of two Spectrum objects.
Definition: spectrum.cpp:57
void drop_SLHAs_if_requested(const safe_ptr< Options > &, const str &)
Helper function to drop SLHA files.
Definition: spectrum.cpp:429
void RunToScale(double scale, const int behave=0)
Run spectrum to a new scale This function is a wrapper for RunToScaleOverride which automatically che...
double get(const Par::Tags partype, const std::string &mass) const
Definition: spectrum.cpp:249
This class is used to deliver both information defined in the Standard Model (or potentially just QED...
std::pair< str, int > short_name_pair(str) const
Retrieve the short name and index, from the long name.
Definition: partmap.cpp:147
virtual std::unique_ptr< SubSpectrum > clone() const =0
Clone the SubSpectrum object.
static std::complex< double > Wolf2V_cd(double, double, double, double)
CKM Wolfenstein –> V_cd standard parameterisation convertor.
Definition: spectrum.cpp:479
virtual void add_to_SLHAea(int, SLHAstruct &) const
Add spectrum information to an SLHAea object (if possible)
SubSpectrum * LE
Definition: spectrum.hpp:129
EXPORT_SYMBOLS error & utils_error()
Utility errors.
static std::complex< double > Wolf2V_cs(double, double, double, double)
CKM Wolfenstein –> V_cs standard parameterisation convertor.
Definition: spectrum.cpp:486
const std::map< str, safe_ptr< const double > > * input_Param
Definition: spectrum.hpp:132
void writeSLHAfile(int, const str &) const
Output spectrum contents as an SLHA file, using getSLHAea.
Definition: spectrum.cpp:418
void check_init() const
Check if object has been fully initialised.
Definition: spectrum.cpp:50
std::unique_ptr< SubSpectrum > clone_LE() const
Clone getters Note: If you want to clone the whole Spectrum object, just use copy constructor...
Definition: spectrum.cpp:234
bool is_abs(str &s)
Helper function for checking if a particle or ratio has been requested as an absolute value...
Definition: spectrum.cpp:160
#define LOCAL_INFO
Definition: local_info.hpp:34
SLHAstruct getSLHAea(int) const
SLHAea object getter First constructs an SLHAea object from the SMINPUTS object, then adds the info f...
Definition: spectrum.cpp:409
GAMBIT file locking functions Use these to block access to sensitive parts of the code by other proce...
const mc_info * mass_cuts
Definition: spectrum.hpp:133
str long_name(str, int) const
Retrieve the long name, from the short name and index.
Definition: partmap.cpp:116
void swap(Spectrum &first, Spectrum &second)
Swap resources of two Spectrum objects Note: Not a member function! This is an external function whic...
Definition: spectrum.cpp:57
virtual const std::map< int, int > & PDG_translator() const
TODO: extra PDB overloads to handle all the one and two index cases (well all the ones that are feasi...
std::unique_ptr< SubSpectrum > HE_new
Definition: spectrum.hpp:128
static double Wolf2V_ud(double, double, double, double)
CKM Wolfenstein (lambda, A, rhobar, etabar) –> V_qq standard parameterisation convertors.
Definition: spectrum.cpp:458
SLHAea::Coll SLHAstruct
Less confusing name for SLHAea container class.
void check_mass_cuts()
Check the that the spectrum satisifies any mass cuts requested from the yaml file.
Definition: spectrum.cpp:168
virtual void raise(const std::string &)
Raise the exception, i.e. throw it.
Definition: exceptions.cpp:422
virtual double get(const Par::Tags, const str &, const SpecOverrideOptions=use_overrides, const SafeBool check_antiparticle=SafeBool(true)) const =0
static std::complex< double > Wolf2V_td(double, double, double, double)
CKM Wolfenstein –> V_td standard parameterisation convertor.
Definition: spectrum.cpp:502
SM specialisation of SLHAea object wrapper version of SubSpectrum class.
double safeget(const Par::Tags partype, const std::string &mass) const
Getters which first check the sanity of the thing they are returning.
Definition: spectrum.cpp:357
partmap & ParticleDB()
Database accessor function.
Definition: partmap.cpp:32
static std::complex< double > Wolf2V_ts(double, double, double, double)
CKM Wolfenstein –> V_ts standard parameterisation convertor.
Definition: spectrum.cpp:509
bool has(const Par::Tags partype, const std::string &mass) const
Pole mass getters/checkers "Shortcut" getters/checkers to access pole masses in hosted SubSpectrum ob...
Definition: spectrum.cpp:244
static std::complex< double > Wolf2V_ub(double, double, double, double)
CKM Wolfenstein –> V_ub standard parameterisation convertor.
Definition: spectrum.cpp:473
std::string str
Shorthand for a standard string.
Definition: Analysis.hpp:35
std::unique_ptr< SubSpectrum > clone_HE() const
Definition: spectrum.cpp:235
SubSpectrum & get_LE()
Standard getters Return references to internal data members.
Definition: spectrum.cpp:224
double lambda(double x, double y, double z)
Definition: MSSM_H.hpp:38
Virtual base class for interacting with spectrum generator output.
Definition: subspectrum.hpp:87
SLHAstruct getSLHAea() const
Definition: sminputs.cpp:87
const std::map< int, int > & PDG_translator() const
PDG code translation map, for special cases where an SLHA file has been read in and the PDG codes cha...
Definition: spectrum.cpp:442
SMInputs SMINPUTS
Definition: spectrum.hpp:131
Spectrum & operator=(const Spectrum &other)
Copy-assignment Using "copy-and-swap" idiom.
Definition: spectrum.cpp:132
double pow(const double &a)
Outputs a^i.
Exception objects required for standalone compilation.
std::vector< YAML::sdd > mc_info
Typedefs for making it easier to manipulate mass cut and mass ratio cut info.
Definition: spectrum.hpp:119
invalid_point_exception & invalid_point()
Invalid point exceptions.
SubSpectrum * HE
Definition: spectrum.hpp:130
Spectrum()
Default constructor.
Definition: spectrum.cpp:74
static double Wolf2V_cb(double, double, double, double)
CKM Wolfenstein –> V_cb standard parameterisation convertor.
Definition: spectrum.cpp:496
static double Wolf2V_us(double, double, double, double)
CKM Wolfenstein –> V_us standard parameterisation convertor.
Definition: spectrum.cpp:466
std::vector< YAML::ssdd > mr_info
Definition: spectrum.hpp:120
TODO: see if we can use this one:
Definition: Analysis.hpp:33
const mr_info * mass_ratio_cuts
Definition: spectrum.hpp:134
virtual bool has(const Par::Tags, const str &, const SpecOverrideOptions=use_overrides, const SafeBool check_antiparticle=SafeBool(true)) const =0
Getters/Setters etc.
SubSpectrum & get_HE()
Definition: spectrum.cpp:225
"Standard Model" (low-energy) plus high-energy model container class
Definition: spectrum.hpp:110
static std::complex< double > rhoplusieta(double, double, double, double)
Calculate Wolfenstein rho+i*eta from rhobar and etabar.
Definition: spectrum.cpp:450
std::unique_ptr< SubSpectrum > LE_new
Variables.
Definition: spectrum.hpp:127
SMInputs & get_SMInputs()
Definition: spectrum.cpp:226
void RunBothToScale(double scale)
Linked running Only possible with non-const object.
Definition: spectrum.cpp:153
Container class for Standard Model input information (defined as in SLHA2)
Definition: sminputs.hpp:29
static double Wolf2V_tb(double, double, double, double)
CKM Wolfenstein –> V_tb standard parameterisation convertor.
Definition: spectrum.cpp:516