namespace Gambit #

TODO: see if we can use this one: More…

Namespaces #

Classes #

Types #

Functions #

Attributes #

Detailed Description #

TODO: see if we can use this one:

Author:

• Anders Kvellestad
• Anders Kvellestad
• Martin White
• Tomas Gonzalo (gonzalo@physik.rwth-aachen.de)
• Gregory Martinez (gregory.david.martinez@gmail.com)
• Gregory Martinez (gregory.david.martinez@gmail.com)
• Pat Scott (p.scott@imperial.ac.uk)
• Gregory Martinez (gregory.david.martinez@gmail.com)
• Gregory Martinez (gregory.david.martinez@gmail.com)
• Pat Scott (patscott@physics.mcgill.ca)
• Gregory Martinez (gregory.david.martinez@gmail.com)
• Pat Scott (p.scott@imperial.ac.uk)
• Gregory Martinez (gregory.david.martinez@gmail.com)
• Pat Scott (p.scott@imperial.ac.uk)
• Ben Farmer (benjamin.farmer@fysik.su.se)

Date:

• 2020 June

• 2021 July

• Feb 2014
• 2013 August
• 2014 Feb
• 2014 Dec
• 2013 August 2013 Feb 2014
• 2013 July 2013/Feb 2014
• 2013 Aug
• 2013 August
• 2014 Feb
• 2014 Dec
• 2013 August
• 2014 Feb
• 2014 Dec
• 2017 Jun
• 2016 Aug

Standard libraries.

Just declare the classes here; should be defined in source files.

TODO: wrap using BOSS at some point, i.e. get this from FlexibleSUSY or SoftSUSY.

Map in which to keep factory functions for the priors.

Map in which to keep factory functions for the priors (prior_creators)

Simulation of “Search for photonic signatures of gauge-mediated supersymmetry in 13 TeV pp collisions with the ATLAS detector”.

Simulation of “Search for new phenomena in final states with photons, jets and missing transverse momentum in pp collisions at sqrt(s)=13 TeV with the ATLAS detector”.

Based on:

• https://atlas.web.cern.ch/Atlas/GROUPS/PHYSICS/CONFNOTES/ATLAS-CONF-2021-028/
• code in Analysis_ATLAS_13TeV_PhotonGGM_36invfb.cpp by Martin White

Based on:

• https://atlas.web.cern.ch/Atlas/GROUPS/PHYSICS/PAPERS/SUSY-2016-27/

Known issues:

1. Photon isolation requirement is missing 2) They use a bizarre HT definition where they don’t apply overlap removal between photons and jets. This might not work for us, since jets won’t be made by photons in our events.

Registry of priors Here we specify mappings from strings to prior objects. We need this so that strings in the inifile can be used to choose which prior objects and which combinations of them we want.

=================================================

Function definitions #

=================================================

Function definitions #

=================================================

Function definitions #

Ben Farmer (ben.farmer@gmail.com)

October 2013 - Aug 2016

=================================================

Function definitions #

=================================================

Function definitions #

=================================================

Function definitions #

Ben Farmer (ben.farmer@gmail.com)

October 2013 - Aug 2016

Will Handley (wh260@cam.ac.uk)

May 2018

Patrick Stoecker (stoecker@physik.rwth-aachen.de)

May 2020

Anders Kvellestad (anders.kvellestad@fys.uio.no)

June 2022

=================================================

Function definitions #

Ben Farmer (ben.farmer@gmail.com)

October 2013 - Aug 2016

Will Handley (wh260@cam.ac.uk)

May 2018

Patrick Stoecker (stoecker@physik.rwth-aachen.de)

May 2020

Jan 2021

Anders Kvellestad (anders.kvellestad@fys.uio.no)

June 2022

=================================================

Function definitions #

Ben Farmer (ben.farmer@gmail.com)

October 2013 - Aug 2016

Will Handley (wh260@cam.ac.uk)

May 2018, June 2021, Mar 2022

Patrick Stoecker (stoecker@physik.rwth-aachen.de)

May 2020

Anders Kvellestad (anders.kvellestad@fys.uio.no)

June 2022

=================================================

Function definitions #

GAMBIT: Global and Modular BSM Inference Tool

Declare a helper function for translating ‘mA’ MSSM parameterisations into the primary parameterisations, and another for translating from scales MGUT and MSUSY to arbitrary scale Q.

Authors #

(add name and date if you modify)

Pat Scott (p.scott@imperial.ac.uk)

2017 Aug

MSSM models with boundary conditions at MGUT scale

Models included: MSSM63atMGUT MSSM30atMGUT MSSM25atMGUT MSSM20atMGUT

Translation functions defined in MSSMatMGUT.cpp

Authors #

(add name and date if you modify)

Ben Farmer (ben.farmer@gmail.com)

2013 May

2014 Mar

2015 Jan, Aug

Pat Scott (p.scott@imperial.ac.uk)

2013 Sep

2015 Sep

Tomas Gonzalo (tomas.gonzalo@kit.edu)

2022 Sept

MSSM models with boundary conditions at MGUT scale with A pole mass and mu as explicit input parameters instead of mHu2 and mHd2

Models included: MSSM63atMGUT_mA MSSM30atMGUT_mA MSSM25atMGUT_mA MSSM20atMGUT_mA

Translation functions defined in MSSMatMGUT_mA.cpp

Authors #

(add name and date if you modify)

Ben Farmer (benjamin.farmer@fysik.su.se)

2017 Sep, Oct

2015 Jan

Pat Scott (p.scott@imperial.ac.uk)

2017 Aug

Tomas Gonzalo (tomas.gonzalo@kit.edu)

2022 Sept

MSSM models with boundary conditions at MGUT scale with A pole mass and mu as explicit input parameters instead of mHu2 and mHd2 and with a light gravitino

Models included: MSSM63atMGUT_mA_mG MSSM30atMGUT_mA_mG MSSM25atMGUT_mA_mG MSSM20atMGUT_mA_mG

Translation functions defined in MSSMatMGUT_mA_mG.cpp

Authors #

(add name and date if you modify)

Pat Scott (p.scott@imperial.ac.uk)

2018 Sept

Tomas Gonzalo (tomas.gonzalo@kit.edu)

2022 Sept

MSSM models with boundary conditions at MGUT scale with a light gravitino

Models included: MSSM63atMGUT_mG MSSM30atMGUT_mG MSSM25atMGUT_mG MSSM20atMGUT_mG

Translation functions defined in MSSMatMGUT_mG.cpp

Authors #

(add name and date if you modify)

Pat Scott (p.scott@imperial.ac.uk)

2018 Sep

Tomas Gonzalo (tomas.gonzalo@kit.edu)

2022 Sept

MSSM models with boundary conditions at MSUSY scale

Models included: MSSM63atMSUSY MSSM30atMSUSY MSSM25atMSUSY MSSM20atMSUSY

Translation functions defined in MSSMatMSUSY.cpp

Authors #

(add name and date if you modify)

Ben Farmer (benjamin.farmer@fysik.su.se)

2015 Jan

2017 Sep, Oct

Pat Scott (p.scott@imperial.ac.uk)

2015 Sep

Tomas Gonzalo (tomas.gonzalo@kit.edu)

2022 Sept

MSSM models with boundary conditions at MSUSY scale with A polea mass and mu as explicit input parameters instead of mHu2 and mHd2

Models included: MSSM63atMSUSY_mA MSSM30atMSUSY_mA MSSM25atMSUSY_mA MSSM20atMSUSY_mA

Translation functions defined in MSSMatMSUSY_mA.cpp

Authors #

(add name and date if you modify)

Ben Farmer (benjamin.farmer@fysik.su.se)

2015 Jan

2017 Sep, Oct

Pat Scott (p.scott@imperial.ac.uk)

2015 Sep

Tomas Gonzalo (tomas.gonzalo@kit.edu)

2022 Sept

MSSM models with boundary conditions at MSUSY scale with A polea mass and mu as explicit input parameters instead of mHu2 and mHd2 and with a light gravitino

Models included: MSSM63atMSUSY_mA_mG MSSM30atMSUSY_mA_mG MSSM25atMSUSY_mA_mG MSSM20atMSUSY_mA_mG

Translation functions defined in MSSMatMSUSY_mA_mG.cpp

Authors #

(add name and date if you modify)

Pat Scott (p.scott@imperial.ac.uk)

2018 Sep

Tomas Gonzalo (tomas.gonzalo@kit.edu)

2022 Sept

MSSM models with boundary conditions at MSUSY scale with a light gravitino

Models included: MSSM63atMSUSY_mG MSSM30atMSUSY_mG MSSM25atMSUSY_mG MSSM20atMSUSY_mG

Translation functions defined in MSSMatMSUSY_mG.cpp

Authors #

(add name and date if you modify)

Pat Scott (p.scott@imperial.ac.uk)

2018 Sep

Tomas Gonzalo (tomas.gonzalo@kit.edu)

2022 Sept

MSSM models with boundary conditions at generic scale Q with A pole mass and mu as explicit input parameters instead of mHu2 and mHd2.

Models included: MSSM63atQ_mA MSSM30atQ_mA MSSM24atQ_mA MSSM25atQ_mA MSSM20atQ_mA MSSM19atQ_mA MSSM16atQ_mA MSSM15atQ_mA MSSM11atQ_mA MSSM10atQ_mA MSSM10batQ_mA MSSM10catQ_mA MSSM9atQ_mA MSSM9batQ_mA MSSM7atQ_mA

Translation functions defined in MSSMatQ_mA.cpp

Authors #

(add name and date if you modify)

Pat Scott (p.scott@imperial.ac.uk)

2017 Aug

Tomas Gonzalo (tomas.gonzalo@kit.edu)

2022 Sept

MSSM models with boundary conditions at generic scale Q with A pole mass and mu as explicit input parameters instead of mHu2 and mHd2 and with a light gravitino.

Models included: MSSM63atQ_mA_mG MSSM30atQ_mA_mG MSSM24atQ_mA_mG MSSM25atQ_mA_mG MSSM20atQ_mA_mG MSSM19atQ_mA_mG MSSM16atQ_mA_mG MSSM15atQ_mA_mG MSSM11atQ_mA_mG MSSM10atQ_mA_mG MSSM10batQ_mA_mG MSSM10catQ_mA_mG MSSM9atQ_mA_mG MSSM9batQ_mA_mG MSSM7atQ_mA_mG

Translation functions defined in MSSMatQ_mA_mG.cpp

Authors #

(add name and date if you modify)

Pat Scott (p.scott@imperial.ac.uk)

2018 Sept

Tomas Gonzalo (tomas.gonzalo@kit.edu)

2022 Sept

GAMBIT: Global and Modular BSM Inference Tool

Nuclear parameters model definitions

Authors #

(add name and date if you modify)

Jonathan Cornell

2015 March

Sebastian Wild

2018 Oct

Janina Renk

2020 May

Tomas Gonzalo (tomas.gonzalo@monash.edu)

2020 Sep

Felix Kahlhoefer

2020 Dec

Ankit Beniwal

2020 Dec

Authors:

Ben Farmer (benjamin.farmer@fysik.su.se)

2015 Apr

Pat Scott (p.scott@imperial.ac.uk)

2016 Oct

Ben Farmer (benjamin.farmer@fysik.su.se)

2015 Apr

GAMBIT: Global and Modular BSM Inference Tool

Function implementations for MSSM translation helpers.

Authors #

(add name and date if you modify)

Ben Farmer (benjamin.farmer@fysik.su.se)

2015 Aug, 2017 Oct

Pat Scott (p.scott@imperial.ac.uk)

2018 Oct

Authors (add name and date if you modify):

Ben Farmer (b.farmer@imperial.ac.uk)

2019 Jan

Tomas Gonzalo (tomas.gonzalo@monash.edu)

2020 June

Janina Renk janina.renk@fysik.su.se

Oct 2018

Christoph Weniger c.weniger@uva.nl

Dec 2014

Christoph Weniger c.weniger@uva.nl

Dec 2014

Ben Farmer benjamin.farmer@fysik.su.se

Jan 2016

POSIX filesystem libraries Gambit Boost

Types Documentation #

typedef str #

typedef std::string Gambit::str;

Shorthand for a standard string.

typedef REAL #

typedef double Gambit::REAL;

typedef fh_real #

typedef Fdouble Gambit::fh_real;

typedef fh_complex #

typedef Fdouble_complex Gambit::fh_complex;

typedef fh_creal #

typedef const fh_real Gambit::fh_creal;

typedef fh_ccomplex #

typedef const fh_complex Gambit::fh_ccomplex;

typedef dblarr #

typedef double Gambit::dblarr[10];

typedef nuyield_function_pointer #

typedef double(* Gambit::nuyield_function_pointer) (const double &, const int &, void *&);

typedef clik_error #

typedef struct Gambit::_err Gambit::clik_error;

typedef Farray_Finteger_1_3 #

typedef Farray<Finteger,1,3> Gambit::Farray_Finteger_1_3;

typedef Farray_Freal8_1_2 #

typedef Farray<Freal8,1,2> Gambit::Farray_Freal8_1_2;

typedef Farray_Freal8_1_3 #

typedef Farray<Freal8,1,3> Gambit::Farray_Freal8_1_3;

typedef Farray_Freal8_1_4 #

typedef Farray<Freal8,1,4> Gambit::Farray_Freal8_1_4;

typedef Farray_Freal8_1_5 #

typedef Farray<Freal8,1,5> Gambit::Farray_Freal8_1_5;

typedef Farray_Freal8_1_6 #

typedef Farray<Freal8,1,6> Gambit::Farray_Freal8_1_6;

typedef Farray_Freal8_1_2_1_2 #

typedef Farray<Freal8,1,2,1,2> Gambit::Farray_Freal8_1_2_1_2;

typedef Farray_Freal8_1_3_1_3 #

typedef Farray<Freal8,1,3,1,3> Gambit::Farray_Freal8_1_3_1_3;

typedef Farray_Freal8_1_4_1_4 #

typedef Farray<Freal8,1,4,1,4> Gambit::Farray_Freal8_1_4_1_4;

typedef Farray_Freal8_1_6_1_6 #

typedef Farray<Freal8,1,6,1,6> Gambit::Farray_Freal8_1_6_1_6;

typedef Farray_Freal8_1_2_1_3 #

typedef Farray<Freal8,1,2,1,3> Gambit::Farray_Freal8_1_2_1_3;

typedef Farray_Fcomplex16_1_2 #

typedef Farray<Fcomplex16,1,2> Gambit::Farray_Fcomplex16_1_2;

typedef Farray_Fcomplex16_1_3 #

typedef Farray<Fcomplex16,1,3> Gambit::Farray_Fcomplex16_1_3;

typedef Farray_Fcomplex16_1_2_1_2 #

typedef Farray<Fcomplex16,1,2,1,2> Gambit::Farray_Fcomplex16_1_2_1_2;

typedef Farray_Fcomplex16_1_3_1_3 #

typedef Farray<Fcomplex16,1,3,1,3> Gambit::Farray_Fcomplex16_1_3_1_3;

typedef Farray_Fcomplex16_1_4_1_4 #

typedef Farray<Fcomplex16,1,4,1,4> Gambit::Farray_Fcomplex16_1_4_1_4;

typedef Farray_Fcomplex16_1_5_1_5 #

typedef Farray<Fcomplex16,1,5,1,5> Gambit::Farray_Fcomplex16_1_5_1_5;

typedef Farray_Fcomplex16_1_6_1_6 #

typedef Farray<Fcomplex16,1,6,1,6> Gambit::Farray_Fcomplex16_1_6_1_6;

typedef Farray_Flogical_1_100 #

typedef Farray<Flogical,1,100> Gambit::Farray_Flogical_1_100;

typedef Farray_Freal8_1_100 #

typedef Farray<Freal8,1,100> Gambit::Farray_Freal8_1_100;

typedef Farray_Freal8_1_100_1_2 #

typedef Farray<Freal8,1,100,1,2> Gambit::Farray_Freal8_1_100_1_2;

typedef Farray_Freal8_1_100_1_5 #

typedef Farray<Freal8,1,100,1,5> Gambit::Farray_Freal8_1_100_1_5;

typedef Farray_Freal8_1_100_1_2_1_2 #

typedef Farray<Freal8,1,100,1,2,1,2> Gambit::Farray_Freal8_1_100_1_2_1_2;

typedef Farray_Freal8_1_100_1_3_1_3 #

typedef Farray<Freal8,1,100,1,3,1,3> Gambit::Farray_Freal8_1_100_1_3_1_3;

typedef Farray_Freal8_1_100_1_4_1_4 #

typedef Farray<Freal8,1,100,1,4,1,4> Gambit::Farray_Freal8_1_100_1_4_1_4;

typedef Farray_Freal8_1_100_1_5_1_4 #

typedef Farray<Freal8,1,100,1,5,1,4> Gambit::Farray_Freal8_1_100_1_5_1_4;

typedef Farray_Freal8_1_100_1_5_1_5 #

typedef Farray<Freal8,1,100,1,5,1,5> Gambit::Farray_Freal8_1_100_1_5_1_5;

typedef Farray_Freal8_1_100_1_6_1_6 #

typedef Farray<Freal8,1,100,1,6,1,6> Gambit::Farray_Freal8_1_100_1_6_1_6;

typedef Farray_Freal8_1_100_1_7_1_7 #

typedef Farray<Freal8,1,100,1,7,1,7> Gambit::Farray_Freal8_1_100_1_7_1_7;

typedef Farray_Fstring60_1_31 #

typedef Farray<Fstring<60>,1,31> Gambit::Farray_Fstring60_1_31;

typedef Farray_Fstring60_1_10 #

typedef Farray<Fstring<60>,1,10> Gambit::Farray_Fstring60_1_10;

typedef Farray_Fstring60_1_2 #

typedef Farray<Fstring<60>,1,2> Gambit::Farray_Fstring60_1_2;

typedef Farray_Fstring60_1_33 #

typedef Farray<Fstring<60>,1,33> Gambit::Farray_Fstring60_1_33;

typedef Farray_Fstring60_1_15 #

typedef Farray<Fstring<60>,1,15> Gambit::Farray_Fstring60_1_15;

typedef Farray_Fstring60_1_22 #

typedef Farray<Fstring<60>,1,22> Gambit::Farray_Fstring60_1_22;

typedef Farray_Fstring60_1_25 #

typedef Farray<Fstring<60>,1,25> Gambit::Farray_Fstring60_1_25;

typedef Farray_Fstring60_1_9 #

typedef Farray<Fstring<60>,1,9> Gambit::Farray_Fstring60_1_9;

typedef Fstring20 #

typedef Fstring<20> Gambit::Fstring20;

typedef Farray_particle2_1_2 #

typedef Farray<particle2,1,2> Gambit::Farray_particle2_1_2;

typedef Farray_particle2_1_6 #

typedef Farray<particle2,1,6> Gambit::Farray_particle2_1_6;

typedef Farray_particle23_1_2 #

typedef Farray<particle23,1,2> Gambit::Farray_particle23_1_2;

typedef Farray_particle23_1_3 #

typedef Farray<particle23,1,3> Gambit::Farray_particle23_1_3;

typedef Farray_particle23_1_4 #

typedef Farray<particle23,1,4> Gambit::Farray_particle23_1_4;

typedef Farray_particle23_1_6 #

typedef Farray<particle23,1,6> Gambit::Farray_particle23_1_6;

typedef flav_observable_map #

typedef std::map<const std::string, double> Gambit::flav_observable_map;

Maps for holding observables and covariance matrix.

typedef flav_covariance_map #

typedef std::map<const std::string, std::map<const std::string, double> > Gambit::flav_covariance_map;

typedef fptr #

typedef double(* Gambit::fptr) (int &);

Pointer to a function that takes an integer by reference and returns a double. Just used for example purposes in ExampleBit_A and ExampleBit_B.

typedef fptr_dd #

typedef double(* Gambit::fptr_dd) (double &);

A double in, double out function pointer.

typedef LogTag #

typedef LogTags::LogTag_declaration Gambit::LogTag;

typedef map_str_dbl #

typedef std::map< std::string, double > Gambit::map_str_dbl;

Shorthand for a string-to-double map.

typedef map_str_str #

typedef std::map< std::string, std::string > Gambit::map_str_str;

Shorthand for a string-to-string map.

typedef parameterMap #

typedef std::map<std::string, double> Gambit::parameterMap;

typedef SLHAstruct #

typedef SLHAea::Coll Gambit::SLHAstruct;

Less confusing name for SLHAea container class.

typedef sspair #

typedef std::pair<str, str> Gambit::sspair;

Shorthand for a pair of standard strings.

typedef ddpair #

typedef std::pair<double, double> Gambit::ddpair;

Shorthand for a pair of doubles.

typedef iipair #

typedef std::pair<int, int> Gambit::iipair;

Shorthand for a pair of integers.

typedef sdpair #

typedef std::pair<str, double> Gambit::sdpair;

Shorthand for a pair of string and double.

typedef vec_dbl #

typedef std::vector<double> Gambit::vec_dbl;

Shorthand for a vector of doubles.

typedef mat_dbl #

typedef std::vector<std::vector<double> > Gambit::mat_dbl;

Shorthand for a matrix of doubles.

typedef map_str_int #

typedef std::map<std::string,int> Gambit::map_str_int;

Shorthand for a string-to-int map.

typedef map_str_map_str_dbl #

typedef std::map<std::string,std::map<std::string,double> > Gambit::map_str_map_str_dbl;

Shorthand for a string-to-string-to-double map.

typedef map_const_str_dbl #

typedef std::map<const std::string,double> Gambit::map_const_str_dbl;

Shorthand for a const-string-to-double map.

typedef map_const_str_map_const_str_dbl #

typedef std::map<const std::string,std::map<const std::string,double> > Gambit::map_const_str_map_const_str_dbl;

Shorthand for a const-string-to-const-string-to-double map.

typedef map_str_bool #

typedef std::map<std::string,bool> Gambit::map_str_bool;

Shorthand for a string-to-bool map.

typedef map_int_dbl #

typedef std::map<int,double> Gambit::map_int_dbl;

Shorthand for an int to double map.

typedef map_str_map_str_str #

typedef std::map<std::string,std::map<std::string,std::string> > Gambit::map_str_map_str_str;

Shorthand for a string-to-string-to-string map.

typedef map_intpair_dbl #

typedef std::map< std::pair < int, int >, double> Gambit::map_intpair_dbl;

Shorthand for an int-int pair to double map.

using vector_shared_ptr #

template <typename T >
using Gambit::vector_shared_ptr = typedef std::vector<std::shared_ptr<T> >;

typedef fptr_void #

typedef void(* Gambit::fptr_void) ();

Shorthand for a pointer to a void function with no arguments.

typedef map_int_triplet_dbl #

typedef std::map<int,triplet<double> > Gambit::map_int_triplet_dbl;

Shorthand for an int-to-double triplet map.

typedef param_map_type #

typedef std::map<std::string, safe_ptr<const double> > Gambit::param_map_type;

Shorthand for the type of the ‘Param’ map (string-to-double-safe_ptr map)

typedef Fcomplex #

typedef FcomplexT<float> Gambit::Fcomplex;

Fortran type typedefs TODO: Implement compiler dependent macros ensuring that these are always correct

typedef Fcomplex8 #

typedef FcomplexT<float> Gambit::Fcomplex8;

typedef Fcomplex16 #

typedef FcomplexT<double> Gambit::Fcomplex16;

typedef Fdouble_complex #

typedef FcomplexT<double> Gambit::Fdouble_complex;

typedef Flongdouble_complex #

typedef FcomplexT<long double> Gambit::Flongdouble_complex;

typedef Fcharacter #

typedef char Gambit::Fcharacter;

typedef Fdouble #

typedef double Gambit::Fdouble;

typedef Fdouble_precision #

typedef double Gambit::Fdouble_precision;

typedef Fdoubleprecision #

typedef double Gambit::Fdoubleprecision;

typedef Finteger #

typedef int Gambit::Finteger;

typedef Finteger2 #

typedef short Gambit::Finteger2;

typedef Finteger4 #

typedef long int Gambit::Finteger4;

typedef Finteger8 #

typedef long long Gambit::Finteger8;

typedef Flogical #

typedef int32_t Gambit::Flogical;

typedef Flogical1 #

typedef bool Gambit::Flogical1;

typedef Freal #

typedef float Gambit::Freal;

typedef Freal4 #

typedef float Gambit::Freal4;

typedef Freal8 #

typedef double Gambit::Freal8;

typedef Freal16 #

typedef long double Gambit::Freal16;

typedef MVoid #

typedef void Gambit::MVoid;

Types used for Mathematica backends.

typedef MInteger #

typedef int Gambit::MInteger;

typedef MReal #

typedef double Gambit::MReal;

typedef MBool #

typedef bool Gambit::MBool;

typedef MChar #

typedef char Gambit::MChar;

typedef MString #

typedef std::string Gambit::MString;

using MList #

template <typename T >
using Gambit::MList = typedef std::vector<T>;

Functions Documentation #

function swap #

void swap(
    Spectrum & first,
    Spectrum & second
)

Swap resources of two Spectrum objects Note: Not a member function! This is an external function which is a friend of the Spectrum class.

function sighandler_soft #

void sighandler_soft(
    int sig
)

Signal handler functions.

Helpers

======================================================================== #

We used to have more of these, but now we only use the “soft shutdown” signal handler. Sets a “shutdown_begun” flag, which is checked each likelihood loop, after which MPI synchronisation followed by clean shutdown is attempted.

function block_signals #

void block_signals()

Signal blocking/unblocking.

function unblock_signals #

void unblock_signals()

function SLHAea_add #

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’t already exist)

function SLHAea_add #

void SLHAea_add(
    SLHAstruct & slha,
    const str & block,
    const int index,
    const str & value,
    const str & comment ="",
    const bool overwrite =false
)

function SLHAea_add #

void SLHAea_add(
    SLHAstruct & slha,
    const str & block,
    const int index,
    const int value,
    const str & comment ="",
    const bool overwrite =false
)

function SLHAea_add #

void SLHAea_add(
    SLHAstruct & slha,
    const str & block,
    const int index1,
    const int index2,
    const double & value,
    const str & comment,
    const bool overwrite =false
)

function operator« #

inline std::ostream & operator<<(
    std::ostream & os,
    const BBN_container & bbn
)

function fixns #

str fixns(
    str s
)

Get back the “::” from things that use NS_SEP instead.

function vectorstr_push_back #

int vectorstr_push_back(
    std::vector< str > & vec,
    str s
)

Call push back on a vector of strings.

function set_allowed_models #

int set_allowed_models(
    functor & be_functor,
    std::vector< str > & allowed_at_be_level,
    str models_string
)

Notify a backend functor of which models it can be used with.

function register_backend_with_log #

int register_backend_with_log(
    str s
)

Register a backend with the logging system.

function register_type #

int register_type(
    str bever,
    str classname
)

Register a BOSSed type with the rollcall system.

Register a bossed type with the rollcall system.

function set_backend_functor_status #

int set_backend_functor_status(
    functor & be_functor,
    const std::vector< str > & symbol_names
)

Disable a backend functor if its library is missing or the symbol cannot be found.

function set_BackendIniBit_functor_status #

int set_BackendIniBit_functor_status(
    functor & ini_functor,
    str be,
    str v
)

Disable a backend initialisation function if the backend is missing.

function get_ctor_status #

int get_ctor_status(
    str be,
    str ver,
    str name,
    str barename,
    str args,
    const std::vector< str > & symbol_names
)

Get the status of a factory pointer to a BOSSed type’s wrapper constructor.

function set_backend_rule_for_model #

int set_backend_rule_for_model(
    module_functor_common & f,
    str models,
    str tags
)

Set a backend rule for one or more models.

function set_classload_requirements #

int set_classload_requirements(
    module_functor_common & f,
    str be,
    str verstr,
    str default_ver
)

Set the classloading requirements of a given functor.

function set_backend_functor_status_C_CXX_Fortran #

void set_backend_functor_status_C_CXX_Fortran(
    functor & be_functor,
    const std::vector< str > & symbol_names
)

Disable a C, C++ or Fortran backend functor if its library is missing or the symbol cannot be found.

function Core #

gambit_core & Core()

Core accessor function.

function core_error #

error & core_error()

Core errors.

function core_warning #

warning & core_warning()

Core warnings.

function register_module #

int register_module(
    str module,
    str ref
)

Register a module with the Core.

function register_module_functor_core #

int register_module_functor_core(
    module_functor_common & f
)

Register a module functor with the Core.

function register_model_functor_core #

int register_model_functor_core(
    primary_model_functor & primary_parameters
)

Register a model functor with the Core.

function register_backend #

int register_backend(
    str be,
    str ver,
    str ref
)

Register a backend with the Core.

function register_backend_functor #

int register_backend_functor(
    functor & f
)

Register a backend functor with the Core.

function register_management_req #

int register_management_req(
    module_functor_common & f
)

Register a loop management requirement with the Core.

function operator« #

YAML::Emitter & operator<<(
    YAML::Emitter & out,
    const capability_info & info
)

Emitter for the capability_info struct.

function operator« #

YAML::Emitter & operator<<(
    YAML::Emitter & out,
    const model_info & info
)

Emitter for the model_info struct.

function ini_catch #

void ini_catch(
    std::exception & e
)

Catch initialisation exceptions.

function add_equivrelation #

int add_equivrelation(
    str s1,
    str s2
)

Helper function for adding a type equivalency at initialisation.

function pass_default_to_backendinfo #

int pass_default_to_backendinfo(
    str be,
    str def
)

Helper function for passing default backend information at initialisation.

function add_model #

int add_model(
    str model,
    str parent
)

Runtime addition of model to GAMBIT model database.

function add_parameter #

int add_parameter(
    model_functor & primary_parameters,
    str param
)

Add a new parameter to a primary model functor.

function set_model_name #

int set_model_name(
    model_functor & primary_parameters,
    str model_name
)

Set the model name in a primary model functor.

Set model name string in a primary model functor.

function copy_parameters #

int copy_parameters(
    model_functor & donor,
    model_functor & donee,
    bool add_friend,
    str model ="",
    str model_x =""
)

Tell a model functor to take its parameter definition from another model functor.

function register_model_functor #

int register_model_functor(
    std::map< str, bool(*)()> ,
    std::map< str, str > ,
    bool(*)() ,
    const str & ,
    const str & 
)

Register a model functor.

function register_module_with_log #

int register_module_with_log(
    str module
)

Create a log tag for a new module.

function register_function #

int register_function(
    module_functor_common & f,
    bool can_manage,
    safe_ptr< bool > * done,
    safe_ptr< Options > & opts,
    safe_ptr< std::set< sspair > > & dependees,
    safe_ptr< Options > & subcaps
)

Register a function with a module.

function register_function_nesting #

int register_function_nesting(
    module_functor_common & f,
    omp_safe_ptr< long long > & iteration,
    const str & loopmanager_capability,
    const str & loopmanager_type
)

Register the fact that a module function needs to run nested.

function register_model_singly #

int register_model_singly(
    module_functor_common & f,
    const str & model
)

Register that a module function is compatible with a single model.

function register_model_group #

int register_model_group(
    module_functor_common & f,
    const str & group_name,
    const str & group
)

Register a model group with a functor.

function register_backend_requirement #

int register_backend_requirement(
    module_functor_common & f,
    const str & group,
    const str & req,
    const str & tags,
    bool is_variable,
    const str & req_type1,
    const str & req_type2,
    void(*)(functor *) resolver
)

Register a backend requirement for a module function.

function register_model_combination #

int register_model_combination(
    module_functor_common & f,
    const str & combo
)

Register a combination of models as allowed with a functor.

function register_dependency #

int register_dependency(
    module_functor_common & f,
    const str & dep,
    const str & dep_type,
    void(*)(functor *, module_functor_common *) resolver
)

Register a dependency of a module function.

function register_conditional_dependency #

int register_conditional_dependency(
    module_functor_common & f,
    const str & dep,
    const str & dep_type
)

Register a conditional dependency of a module function.

function register_model_parameter_dependency #

int register_model_parameter_dependency(
    module_functor_common & f,
    const str & model,
    const str & dep,
    void(*)(functor *, module_functor_common *) resolver
)

Register a model parameters dependency of a module function.

function register_model_conditional_dependency #

int register_model_conditional_dependency(
    module_functor_common & f,
    const str & model,
    const str & dep,
    void(*)(functor *, module_functor_common *) resolver
)

Register a model-conditional dependency of a module function.

function register_backend_conditional_dependency #

int register_backend_conditional_dependency(
    module_functor_common & f,
    const str & req,
    const str & be,
    const str & versions,
    const str & dep,
    void(*)(functor *, module_functor_common *) resolver
)

Register a backend-conditional dependency of a module function.

function apply_backend_matching_rule #

int apply_backend_matching_rule(
    module_functor_common & f,
    const str & rule
)

Apply a backend-matching rule.

function apply_backend_option_rule #

int apply_backend_option_rule(
    module_functor_common & f,
    const str & be_and_ver,
    const str & tags
)

Apply a backend option rule.

function SLHAea_add_from_subspec #

void SLHAea_add_from_subspec(
    SLHAstruct & slha,
    const str local_info,
    const SubSpectrum & subspec,
    const Par::Tags partype,
    const std::pair< int, int > & pdg_pair,
    const str & block,
    const str & comment,
    const bool error_if_missing =true,
    const double rescale =1.0
)

Add an entry from a subspectrum getter to an SLHAea object; SLHA index given by pdg code.

function SLHAea_add_from_subspec #

void SLHAea_add_from_subspec(
    SLHAstruct & slha,
    const str local_info,
    const SubSpectrum & subspec,
    const Par::Tags partype,
    const str & name,
    const str & block,
    const int slha_index,
    const str & comment,
    const bool error_if_missing =true,
    const double rescale =1.0
)

Add an entry from a subspectrum getter to an SLHAea object; 1 SLHA index.

function SLHAea_add_from_subspec #

void SLHAea_add_from_subspec(
    SLHAstruct & slha,
    const str local_info,
    const SubSpectrum & subspec,
    const Par::Tags partype,
    const str & name,
    const int index1,
    const int index2,
    const str & block,
    const int slha_index1,
    const int slha_index2,
    const str & comment,
    const bool error_if_missing =true,
    const double rescale =1.0
)

Add an entry from a subspectrum getter to an SLHAea object; two SubSpectrum getter indices, two SLHA indices.

function add_SimpleSpec_to_SLHAea #

void add_SimpleSpec_to_SLHAea(
    const SubSpectrum & subspec,
    SLHAstruct & slha,
    const SubSpectrumContents & contents
)

Write a SimpleSpectrum to an SLHAea object.

function SMlike_higgs_PDG_code #

int SMlike_higgs_PDG_code(
    const SubSpectrum & spec
)

Determine which MSSM higgs is most SM-like. Needs expansion to work with non-MSSM (e.g. *HDM) models

Determine which higgs is most SM-like. Works only for 2 and 3 higgses (e.g. MSSM and NMSSM)

function spectrum_from_SLHAea #

template <typename HE ,
typename HEmod >
Spectrum spectrum_from_SLHAea(
    HEmod hemod,
    SLHAstruct slhaea,
    const Spectrum::mc_info & mci,
    const Spectrum::mr_info & mri
)

Create a simple spectrum object from an SLHAea object.

function spectrum_from_SLHA #

template <typename HE >
Spectrum spectrum_from_SLHA(
    str slha,
    const Spectrum::mc_info & mci,
    const Spectrum::mr_info & mri
)

Create a simple spectrum object from an SLHA file.

function within_bounds #

inline bool within_bounds(
    const int i,
    const std::set< int > allowed
)

Helper function for checking if indices are valid.

function operator== #

static inline bool operator==(
    const SpecOverrideOptions & lhs,
    const SpecOverrideOptions & rhs
)

function terminator #

void terminator()

Author: Christoph Weniger

Date: 2016 Feb

function virtual_SMHiggs_widths #

double virtual_SMHiggs_widths(
    str channel,
    double mh
)

Higgs branching ratios and total width Gamma [GeV], as function of mass [GeV] (90 - 300 GeV)

function get_calculator_info #

void get_calculator_info(
    const SLHAstruct & slha,
    str & calculator,
    str & calculator_version
)

function SLHAea_add_QNumbers_from_subspec #

void SLHAea_add_QNumbers_from_subspec(
    SLHAstruct & slha,
    const SubSpectrum & subspec,
    const std::pair< int, int > pdg_pair
)

Adds QNUMBERS entry for a particle, SLHA index given by the PDG code.

function is_abs #

bool is_abs(
    str & s
)

Helper function for checking if a particle or ratio has been requested as an absolute value.

function logger #

EXPORT_SYMBOLS Logging::LogMaster & logger()

Function to retrieve a reference to the Gambit global log object.

function MSSM_mA_to_MSSM_mhud #

void MSSM_mA_to_MSSM_mhud(
    const ModelParameters & myP,
    ModelParameters & targetP,
    const SubSpectrum & HE
)

Translation function for mA,mu parameterisation to mHu2,mHd2 parameterisation.

function MSSMatX_to_MSSMatQ #

void MSSMatX_to_MSSMatQ(
    const ModelParameters & myP,
    ModelParameters & targetP,
    const SubSpectrum & HE
)

Translation function for MSSM defined at RGE-determined scale (e.g. GUT, SUSY) to arbitrary scale Q.

function MSSM20atX_to_MSSM25atX #

void MSSM20atX_to_MSSM25atX(
    const ModelParameters & myP,
    ModelParameters & targetP
)

Translation functions for 20-parameter models to 25-parameter.

function MSSM25atX_to_MSSM30atX #

void MSSM25atX_to_MSSM30atX(
    const ModelParameters & myP,
    ModelParameters & targetP
)

Translation functions for 25-parameter models to 30-parameter.

function MSSM30atX_to_MSSM63atX #

void MSSM30atX_to_MSSM63atX(
    const ModelParameters & myP,
    ModelParameters & targetP
)

Translation functions for 30-parameter models to 63-parameter.

function MSSM_mA_mG_to_MSSM_mhud #

void MSSM_mA_mG_to_MSSM_mhud(
    const ModelParameters & myP,
    ModelParameters & targetP,
    const SubSpectrum & HE
)

function orderer #

bool orderer(
    std::pair< int, double > a,
    std::pair< int, double > b
)

Helper function for sorting int, double pairs according to the double.

function get_pp_reader #

Printers::BaseReader & get_pp_reader()

function set_global_printer_manager #

void set_global_printer_manager(
    Printers::PrinterManager * pm
)

function get_global_printer_manager #

Printers::PrinterManager * get_global_printer_manager()

function format_for_screen #

std::string format_for_screen(
    const std::string & input_string
)

function print_to_screen #

void print_to_screen(
    const std::string & file_in,
    const std::string & name
)

function get_screen_cols #

inline int get_screen_cols()

function separate_line #

inline std::string separate_line(
    std::string & line,
    std::string::size_type indent,
    std::string::size_type cols_pos
)

function signal_name #

std::string signal_name(
    int sig
)

Translate signal codes to strings.

function signaldata #

EXPORT_SYMBOLS SignalData & signaldata()

Retrieve global instance of signal handler options struct.

function set_signal_handler #

void set_signal_handler(
    const YAML::Node & keyvalnode,
    const int sig,
    const std::string & def_mode
)

Choose signal handler for a given signal via yaml file option.

TODO: Mostly obsolete Choose signal handler for a given signal via yaml file option

function signal_mask #

sigset_t * signal_mask()

Getter for global signal set.

function read_SLHA #

SLHAstruct read_SLHA(
    str slha
)

Read an SLHA file in to an SLHAea object with some error-checking.

Create a strong typedef (different classes underneath, but can be assigned to each other etc.) that lets us create e.g. different print/retrieve functions for different sorts of spectrum information

function SLHAea_get #

double SLHAea_get(
    const SLHAstruct & slha,
    const str & block,
    const int index
)

Get an entry from an SLHAea object as a double, with some error checking.

function SLHAea_get #

double SLHAea_get(
    const SLHAstruct & slha,
    const str & block,
    const int index,
    const double defvalue
)

Get an entry from an SLHAea object as a double; raise a warning and use a default value if the entry is missing.

function SLHAea_add_block #

void SLHAea_add_block(
    SLHAstruct & slha,
    const str & name,
    const double scale =-1
)

Add a new block to an SLHAea object, with or without a scale.

function SLHAea_delete_block #

void SLHAea_delete_block(
    SLHAstruct & slha,
    const std::string & block
)

Delete an entire block from an SLHAea object, if it exists (actually just the first block matching the given name)

Delete a block entirely if it exists (TODO: actually only deletes first instance of the block found!)

function SLHAea_block_exists #

bool SLHAea_block_exists(
    SLHAstruct & slha,
    const str & block
)

Check if a block exists in an SLHAea object.

function SLHAea_check_block #

bool SLHAea_check_block(
    SLHAstruct & slha,
    const str & block
)

Check if a block exists in an SLHAea object, add it if not.

function SLHAea_check_block #

bool SLHAea_check_block(
    SLHAstruct & slha,
    const str & block,
    const int index
)

Check if a block exists in an SLHAea object, add it if not, and check if it has an entry at a given index.

function SLHAea_check_block #

bool SLHAea_check_block(
    SLHAstruct & slha,
    const str & block,
    const int index1,
    const int index2
)

function SLHAea_add_GAMBIT_SPINFO #

void SLHAea_add_GAMBIT_SPINFO(
    SLHAstruct & slha
)

Write the SPINFO block with GAMBIT name and version number.

function SLHAea_add_matrix #

template <typename T >
void SLHAea_add_matrix(
    SLHAstruct & slha,
    const str & block,
    const std::vector< T > & matrix,
    const int rows,
    const int cols,
    const str & comment ="",
    const bool overwrite =false
)

Add a whole matrix to an SLHAea object if it doesn’t already exist.

function SLHAea_overwrite_block #

template <class T >
void SLHAea_overwrite_block(
    SLHAstruct & slha,
    const str & block,
    int index,
    T value,
    const str & comment
)

Check if a line exists in an SLHAea block, then overwrite it if it does. Otherwise add the line.

function SLHAea_overwrite_block #

template <class T >
void SLHAea_overwrite_block(
    SLHAstruct & slha,
    const str & block,
    int index1,
    int index2,
    T value,
    const str & comment
)

Check if a line exists in an SLHAea block, then overwrite it if it does. Otherwise add the line.

function utils_error #

EXPORT_SYMBOLS error & utils_error()

Utility errors.

function utils_warning #

EXPORT_SYMBOLS warning & utils_warning()

Utility warnings.

function backend_error #

error & backend_error()

Backend errors.

function backend_warning #

warning & backend_warning()

Backend warnings.

function logging_error #

error & logging_error()

Logging errors.

function logging_warning #

warning & logging_warning()

Logging warnings.

function model_error #

error & model_error()

Model errors.

function model_warning #

warning & model_warning()

Model warnings.

function invalid_point #

invalid_point_exception & invalid_point()

Invalid point exceptions.

function initialise_standalone_logs #

void initialise_standalone_logs(
    str prefix
)

Logger setup standalone utility function.

function spacing #

std::string spacing(
    int len,
    int maxlen
)

Spacing utility for stream overloads.

function operator« #

template <class Type1 ,
class Type2 >
inline std::ostream & operator<<(
    std::ostream & os,
    const std::pair< Type1, Type2 > & p
)

Stream overload for pairs of any type that already has « defined.

function operator« #

template <class Type >
inline std::ostream & operator<<(
    std::ostream & os,
    const std::set< Type > & set
)

Stream overload for sets of any type that already has « defined.

function operator« #

template <class Type >
inline std::ostream & operator<<(
    std::ostream & os,
    const std::vector< Type > & v
)

Stream overload for vectors of any type that already has « defined.

function operator« #

template <class Type >
std::ostream & operator<<(
    std::ostream & os,
    const std::map< std::string, Type > & map
)

Stream overload for map from string to any type that already has « defined.

function byVal #

template <typename T >
T byVal(
    T t
)

Redirection function to turn an lvalue into an rvalue, so that it is correctly passed by value when doing perfect forwarding with functor typecasting.

function sgn #

template <typename T >
int sgn(
    T val
)

function memaddress_to_uint #

template <typename T >
uintptr_t memaddress_to_uint(
    T * ptr
)

Convert the memory address a pointer points to to an unsigned integer (The size of uintptr_t depends on system & ensures it is big enough to store memory addresses of the underlying setup)

function initVector #

template <typename T >
std::vector< T > initVector(
    std::vector< T > vector
)

function initVector #

template <typename T ,
typename... Args>
std::vector< T > initVector(
    std::vector< T > vector,
    T value,
    Args... args
)

function initVector #

template <typename T ,
typename U ,
typename... Args>
std::vector< T > initVector(
    std::vector< T > vector,
    U value,
    Args... args
)

function initVector #

template <typename T ,
typename... Args>
std::vector< T > initVector(
    T value,
    Args... args
)

function initSet #

template <typename T >
std::set< T > initSet(
    std::set< T > set
)

Same as above, but for sets.

function initSet #

template <typename T ,
typename... Args>
std::set< T > initSet(
    std::set< T > set,
    T value,
    Args... args
)

function initSet #

template <typename T ,
typename U ,
typename... Args>
std::set< T > initSet(
    std::set< T > set,
    U value,
    Args... args
)

function initSet #

template <typename T ,
typename... Args>
std::set< T > initSet(
    T value,
    Args... args
)

function stringifyVariadic #

inline const std::string stringifyVariadic()

function stringifyVariadic #

inline const std::string stringifyVariadic(
    const std::string & str
)

function stringifyVariadic #

template <typename... args>
inline const std::string stringifyVariadic(
    const std::string & str,
    const args &... strs
)

function gambit_version #

str & gambit_version()

Statically construct a string containing the full GAMBIT version information and return a reference to it.

function getVariadicNode #

inline const YAML::Node getVariadicNode(
    const YAML::Node & node
)

function getVariadicNode #

inline const YAML::Node getVariadicNode(
    const YAML::Node & node,
    std::string key
)

function getVariadicNode #

template <typename... args>
inline const YAML::Node getVariadicNode(
    const YAML::Node & node,
    const std::string & key,
    const args &... keys
)

function piped_errors #

Piped_exceptions piped_errors(
    1000 
)

Global instance of Piped_exceptions class for errors.

function piped_warnings #

Piped_exceptions piped_warnings(
    1000 
)

Global instance of Piped_exceptions class for warnings.

function add_screen_spaces #

inline void add_screen_spaces(
    std::string & str,
    std::string::size_type size,
    std::string::size_type indent
)

function wrap_lines #

inline void wrap_lines(
    std::vector< std::vector< std::string > > & data_in,
    const std::vector< int > & widths,
    const std::vector< int > & minWidths,
    double pad,
    std::vector< unsigned char > * row_flags =0
)

function get_gambit_version #

str get_gambit_version()

Construct a string containing the full GAMBIT version information.

Attributes Documentation #

variable mw_central_observed #

const double mw_central_observed = 80.385;

M_W (Breit-Wigner mass parameter ~ pole) = 80.385 +/- 0.015 GeV (1 sigma), Gaussian. Reference http://pdg.lbl.gov/2014/listings/rpp2014-list-w-boson.pdf = K.A. Olive et al. (Particle Data Group), Chin. Phys. C38, 090001 (2014)

variable mw_err_observed #

const double mw_err_observed = 0.015;

variable mz_central_observed #

const double mz_central_observed = 91.1876;

M_Z (Breit-Wigner mass parameter ~ pole) = 91.1876 +/- 0.0021 GeV (1 sigma), Gaussian. Reference https://pdg.lbl.gov/2022/listings/rpp2022-list-z-boson.pdf = R.L. Workmanet al. (Particle Data Group), Prog. Theor. Exp. Phys. 2022, 083C01 (2022)

variable mz_err_observed #

const double mz_err_observed = 0.0021;

variable gambit_registry #

gambit_registry {
    typedef void* factory_type(const std::map<str, primary_model_functor *> &,
     DRes::DependencyResolver &b, IniParser::IniFile &c, const str &purpose, Printers::BaseBasePrinter& p);

variable scanner_factories #

reg_elem< factory_type > __scanner_factories__;

variable use_overrides #

static const SpecOverrideOptions(0) use_overrides;

variable overrides_only #

static const SpecOverrideOptions(1) overrides_only;

variable ignore_overrides #

static const SpecOverrideOptions(2) ignore_overrides;

variable EOM #

const Logging::endofmessage EOM = Logging::endofmessage();

Explicit const instance of the end of message struct in Gambit namespace.

variable global_printer_manager #

Printers::PrinterManager * global_printer_manager = NULL;

variable gambit_citation_keys #

const std::vector< str > gambit_citation_keys = 
  {
    "GAMBIT:2017yxo", 
    "Kvellestad:2019vxm", 
      
    "Bloor:2021gtp", 
    "Alloul:2013bka", 
    "Christensen:2008py", 
    "Christensen:2010wz", 
    "Christensen:2009jx", 
    "Degrande:2011ua", 
    "Pukhov:2004ca", 
    "Belyaev:2012qa", 
    "Belanger:2014vza", 
    "Belanger:2013oya", 
    "Belanger:2010gh", 
    "Belanger:2008sj", 
    "Belanger:2006is", 
    "Belanger:2004yn", 
    "Belanger:2001fz", 
  };

variable piped_invalid_point #

Piped_invalid_point piped_invalid_point;

Global instance of piped invalid point class.

variable piped_errors #

Piped_exceptions piped_errors;

Global instance of Piped_exceptions class for errors.

variable piped_warnings #

Piped_exceptions piped_warnings;

Global instance of Piped_exceptions class for warnings.

variable pi #

const double pi = 3.141592653589793238462643383279502884197;

variable root2 #

const double root2 = sqrt(2.0);

variable zeta3 #

const double zeta3 = 1.2020569031595942855;

variable hbar #

const double hbar = 6.582119514e-25;

variable K2eV #

const double K2eV = 8.6173303e-5;

variable eV2g #

const double eV2g = 1.782661907e-33;

variable gev2cm #

const double gev2cm = 197.327053e-16;

variable gev2cm2 #

const double gev2cm2 = pow(197.327053e-16, 2.0);

variable gev2pb #

const double gev2pb = gev2cm2*1e36;

variable gev2tocm3s1 #

const double gev2tocm3s1 = 1.16733e-17;

variable s2cm #

const double s2cm = 2.99792458e10;

variable m_planck #

const double m_planck = 1.220910e19;

variable m_planck_red #

const double m_planck_red = m_planck/sqrt(8.0*pi);

variable atomic_mass_unit #

const double atomic_mass_unit = 0.931494028;

variable m_proton_amu #

const double m_proton_amu = 1.00727646688;

variable m_neutron_amu #

const double m_neutron_amu = 1.0086649156;

variable m_proton #

const double m_proton = m_proton_amu * atomic_mass_unit;

variable m_neutron #

const double m_neutron = m_neutron_amu * atomic_mass_unit;

variable m_deuteron #

const double m_deuteron = 1.87561294257;

variable m_electron #

const double m_electron = 0.5109989461e-3;

variable alpha_EM #

const double alpha_EM = 7.2973525664e-3;

variable c_SI #

const double c_SI = s2cm/100;

Values from Particle Data Group 2018 (http://pdg.lbl.gov/2018/reviews/rpp2018-rev-phys-constants.pdf)

variable eV_to_J #

const double eV_to_J = 1.6021766208e-19;

variable Mpc_SI #

const double Mpc_SI = 969394202136*pow(10,11)/pi;

variable GN_cgs #

const double GN_cgs = 6.67408e-8;

variable GN_SI #

const double GN_SI = GN_cgs/1e3;

variable kB_SI #

const double kB_SI = 1.38064852e-23;

variable kB_eV_over_K #

const double kB_eV_over_K = kB_SI/eV_to_J;

variable hP_SI #

const double hP_SI = 6.626070040e-34;

variable hP_eVs #

const double hP_eVs = hP_SI/eV_to_J;

variable hc_eVcm #

const double hc_eVcm =hP_eVs*s2cm;

variable sigmaB_SI #

const double sigmaB_SI = 2*pow(pi,5)*pow(kB_SI,4)/(15*pow(hP_SI,3)*c_SI*c_SI);

variable Neff_SM #

const double Neff_SM = 3.045;

variable alpha_e_OS_thomson_limit #

constexpr double alpha_e_OS_thomson_limit = 0.0072973525664;

Thomson limit of (\alpha_e) in OS scheme from PDG 2017

variable alpha_e_OS_MZ #

constexpr double alpha_e_OS_MZ = 1. / 128.944;

(\alpha_e(M_Z)) in OS scheme from 1105.3149

variable delta_alpha_OS #

constexpr double delta_alpha_OS = 1. - alpha_e_OS_thomson_limit / alpha_e_OS_MZ;

(\Delta\alpha) in OS scheme.

Defined by [ \alpha(M_Z) = \frac{\alpha(0)}{1 - \Delta\alpha} ]

variable meson_masses #

static const struct Gambit::Mesons_masses meson_masses;

variable meson_decay_constants #

static const struct Gambit::Mesons_decay_constants meson_decay_constants;

variable gambit_version_major #

const int gambit_version_major =     0;

variable gambit_version_minor #

const int gambit_version_minor =     0;

variable gambit_version_revision #

const int gambit_version_revision =  0;

variable gambit_version_patch #

const str gambit_version_patch =  "";

variable gambit_version_int #

const int gambit_version_int =  10000*gambit_version_major + 100*gambit_version_minor + gambit_version_revision;

Updated on 2023-06-26 at 21:36:50 +0000