gambit is hosted by Hepforge, IPPP Durham
GAMBIT  v1.5.0-2191-ga4742ac
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 
293  bool Spectrum::has(const Par::Tags partype, const std::string& mass, const int index1, const int index2) const
294  {
295  return (HE->has(partype,mass,index1,index2) or LE->has(partype,mass,index1,index2));
296  }
297 
298  double Spectrum::get(const Par::Tags partype, const std::string& mass, const int index1, const int index2) const
299  {
300  double result(-1);
301  if( HE->has(partype,mass,index1,index2) )
302  { result = HE->get(partype,mass,index1,index2); }
303  else if( LE->has(partype,mass,index1,index2) )
304  { result = LE->get(partype,mass,index1,index2); }
305  else
306  {
307  std::ostringstream errmsg;
308  errmsg << "Error retrieving particle spectrum data!" << std::endl;
309  errmsg << "No pole mixing with string reference '"<<mass<<"' and indices '"<<index1<<"','"<<index2<<"' could be found in either LE or HE SubSepctrum!" << std::endl;
310  utils_error().raise(LOCAL_INFO,errmsg.str());
311  }
312  // [[noreturn]]
313  return result;
314  }
315 
317 
318  /* Input PDG code plus context integer as separate arguments */
319  bool Spectrum::has(const Par::Tags partype,
320  const int pdg_code, const int context) const
321  {
322  return has( partype, std::make_pair(pdg_code,context) );
323  }
324 
325  /* Input PDG code plus context integer as separate arguments */
326  double Spectrum::get(const Par::Tags partype,
327  const int pdg_code, const int context) const
328  {
329  return get( partype, std::make_pair(pdg_code,context) );
330  }
331 
332  /* Input PDG code plus context integer as pair */
333  bool Spectrum::has(const Par::Tags partype,
334  const std::pair<int,int> pdgpr) const
335  {
336  /* If there is a short name, then retrieve that plus the index */
337  if( Models::ParticleDB().has_short_name(pdgpr) )
338  {
339  return has( partype, Models::ParticleDB().short_name_pair(pdgpr) );
340  }
341  else /* Use the long name with no index instead */
342  {
343  return has( partype, Models::ParticleDB().long_name(pdgpr) );
344  }
345  }
346 
347  /* Input PDG code plus context integer as pair */
348  double Spectrum::get(const Par::Tags partype,
349  const std::pair<int,int> pdgpr) const
350  {
351  /* If there is a short name, then retrieve that plus the index */
352  if( Models::ParticleDB().has_short_name(pdgpr) )
353  {
354  return get( partype, Models::ParticleDB().short_name_pair(pdgpr) );
355  }
356  else /* Use the long name with no index instead */
357  {
358  return get( partype, Models::ParticleDB().long_name(pdgpr) );
359  }
360  }
361 
362  /* Input short name plus index as pair */
363  bool Spectrum::has(const Par::Tags partype,
364  const std::pair<str,int> shortpr) const
365  {
366  return has( partype, shortpr.first, shortpr.second);
367  }
368 
369  /* Input short name plus index as pair */
370  double Spectrum::get(const Par::Tags partype,
371  const std::pair<str,int> shortpr) const
372  {
373  return get( partype, shortpr.first, shortpr.second);
374  }
375 
377 
379 
380  double Spectrum::safeget(const Par::Tags partype,
381  const std::string& mass) const
382  {
383  double result = get(partype, mass);
384  if (Utils::isnan(result))
385  utils_error().raise(LOCAL_INFO,"SubSpectrum parameter is nan!!");
386  return result;
387  }
388 
389  double Spectrum::safeget(const Par::Tags partype,
390  const std::string& mass, const int index) const
391  {
392  double result = get(partype, mass, index);
393  if (Utils::isnan(result))
394  utils_error().raise(LOCAL_INFO,"SubSpectrum parameter is nan!!");
395  return result;
396  }
397 
398  double Spectrum::safeget(const Par::Tags partype,
399  const int pdg_code, const int context) const
400  {
401  double result = get(partype, pdg_code, context);
402  if (Utils::isnan(result))
403  utils_error().raise(LOCAL_INFO,"SubSpectrum parameter is nan!!");
404  return result;
405  }
406 
407  double Spectrum::safeget(const Par::Tags partype,
408  const std::pair<int,int> pdgpr) const
409  {
410  double result = get(partype, pdgpr);
411  if (Utils::isnan(result))
412  utils_error().raise(LOCAL_INFO,"SubSpectrum parameter is nan!!");
413  return result;
414  }
415 
416  double Spectrum::safeget(const Par::Tags partype,
417  const std::pair<str,int> shortpr) const
418  {
419  double result = get(partype, shortpr);
420  if (Utils::isnan(result))
421  utils_error().raise(LOCAL_INFO,"SubSpectrum parameter is nan!!");
422  return result;
423  }
424 
426 
432  SLHAstruct Spectrum::getSLHAea(int slha_version) const
433  {
434  SLHAstruct slha(SMINPUTS.getSLHAea());
435  LE->add_to_SLHAea(slha_version, slha);
436  HE->add_to_SLHAea(slha_version, slha);
437  return slha;
438  }
439 
441  void Spectrum::writeSLHAfile(int slha_version, const str& filename) const
442  {
443  Utils::FileLock mylock(filename);
444  mylock.get_lock();
445  std::ofstream ofs(filename);
446  ofs << getSLHAea(slha_version);
447  ofs.close();
448  mylock.release_lock();
449  }
450 
452  void Spectrum::drop_SLHAs_if_requested(const safe_ptr<Options>& runOptions, const str& default_name)
453  {
454  if (runOptions->getValueOrDef<bool>(false, "drop_SLHA_file"))
455  {
456  // Spit out the full spectrum as SLHA1 and SLHA2 files.
457  str prefix = runOptions->getValueOrDef<str>("", "SLHA_output_prefix");
458  str filename = runOptions->getValueOrDef<str>(default_name, "SLHA_output_filename");
459  writeSLHAfile(1,prefix+filename+".slha1");
460  writeSLHAfile(2,prefix+filename+".slha2");
461  }
462  }
463 
465  const std::map<int, int>& Spectrum::PDG_translator() const
466  {
467  return HE->PDG_translator();
468  }
469 
470  // The expressions in all of the following CKM functions are from the CKMFitter paper hep-ph/0406184v3.
471 
473  std::complex<double> Spectrum::rhoplusieta(double lambda, double A, double rhobar, double etabar)
474  {
475  std::complex<double> x(rhobar, etabar);
476  double y = pow(A*lambda*lambda,2);
477  return sqrt((1.0-y)/(1.0-lambda*lambda))*x/(1.0-x*y);
478  }
479 
481  double Spectrum::Wolf2V_ud(double l, double A, double rhobar, double etabar)
482  {
483  double norm = std::norm(rhoplusieta(l,A,rhobar,etabar));
484  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)
485  - 0.0078125*pow(l,8)*(5.0-32.0*A*A*norm);
486  }
487 
489  double Spectrum::Wolf2V_us(double l, double A, double rhobar, double etabar)
490  {
491  double norm = std::norm(rhoplusieta(l,A,rhobar,etabar));
492  return l - 0.5*A*A*pow(l,7)*norm;
493  }
494 
496  std::complex<double> Spectrum::Wolf2V_ub(double l, double A, double rhobar, double etabar)
497  {
498  return A*pow(l,3)*std::conj(rhoplusieta(l,A,rhobar,etabar));
499  }
500 
502  std::complex<double> Spectrum::Wolf2V_cd(double l, double A, double rhobar, double etabar)
503  {
504  std::complex<double> x(rhoplusieta(l,A,rhobar,etabar));
505  return 0.5*pow(A*l,2)*(pow(l,3)*(1.0-2.0*x) + pow(l,5)*x) - l;
506  }
507 
509  std::complex<double> Spectrum::Wolf2V_cs(double l, double A, double rhobar, double etabar)
510  {
511  double l2 = l*l;
512  double fA2 = 4.0*A*A;
513  return 1.0 - 0.5*l2 - 0.125*l2*l2*(1.0+fA2)
514  - 0.0625*pow(l2,3)*(1.0-fA2+4.0*fA2*rhoplusieta(l,A,rhobar,etabar))
515  - 0.0078125*pow(l2,4)*(5.0-fA2*(2.0+4.0*fA2));
516  }
517 
519  double Spectrum::Wolf2V_cb(double l, double A, double rhobar, double etabar)
520  {
521  return A*l*l * (1.0 - 0.5*A*A*pow(l,6)*std::norm(rhoplusieta(l,A,rhobar,etabar)));
522  }
523 
525  std::complex<double> Spectrum::Wolf2V_td(double l, double A, double rhobar, double etabar)
526  {
527  std::complex<double> x(rhoplusieta(l,A,rhobar,etabar));
528  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);
529  }
530 
532  std::complex<double> Spectrum::Wolf2V_ts(double l, double A, double rhobar, double etabar)
533  {
534  std::complex<double> x(rhoplusieta(l,A,rhobar,etabar));
535  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);
536  }
537 
539  double Spectrum::Wolf2V_tb(double l, double A, double rhobar, double etabar)
540  {
541  double norm = std::norm(rhoplusieta(l,A,rhobar,etabar));
542  double l4 = pow(l,4);
543  return 1.0 - 0.5*A*A*l4 * (1.0 + l*l*norm + 0.25*A*A*l4);
544  }
545 
546 } // end namespace Gambit
547 
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:452
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:155
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:502
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:509
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:441
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:432
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:124
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:481
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. Exact override of base method.
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:525
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:380
partmap & ParticleDB()
Database accessor function.
Definition: partmap.cpp:36
static std::complex< double > Wolf2V_ts(double, double, double, double)
CKM Wolfenstein –> V_ts standard parameterisation convertor.
Definition: spectrum.cpp:532
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:496
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:465
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:519
static double Wolf2V_us(double, double, double, double)
CKM Wolfenstein –> V_us standard parameterisation convertor.
Definition: spectrum.cpp:489
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:473
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:539