namespace Gambit::ColliderBit

[No description available]

Namespaces

Name
Gambit::ColliderBit::ATLAS
ATLAS-specific efficiency and smearing functions for super fast detector simulation.
Gambit::ColliderBit::CMS
CMS-specific efficiency and smearing functions for super fast detector simulation.
Gambit::ColliderBit::EventConversion

Classes

Name
structGambit::ColliderBit::_gsl_target_func_params
A struct to contain parameters for the GSL optimiser target function.
classGambit::ColliderBit::ALEPHSelectronLimitAt208GeV
A class to contain the limit data from ALEPH_PLB526_2002_206, figure 3a.
classGambit::ColliderBit::ALEPHSmuonLimitAt208GeV
A class to contain the limit data from ALEPH_PLB526_2002_206, figure 3b.
classGambit::ColliderBit::ALEPHStauLimitAt208GeV
A class to contain the limit data from ALEPH_PLB526_2002_206, figure 3c.
classGambit::ColliderBit::Analysis
A class for collider analyses within ColliderBit.
classGambit::ColliderBit::Analysis_ATLAS_13TeV_0LEP_139invfb
ATLAS Run 2 0-lepton jet+MET SUSY analysis, with 139/fb of data.
classGambit::ColliderBit::Analysis_ATLAS_13TeV_0LEP_13invfb
ATLAS Run 2 0-lepton jet+MET SUSY analysis, with 13/fb of data.
classGambit::ColliderBit::Analysis_ATLAS_13TeV_0LEP_36invfb
ATLAS Run 2 0-lepton jet+MET SUSY analysis, with 36/fb of data.
classGambit::ColliderBit::Analysis_ATLAS_13TeV_0LEPStop_36invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_1Lep2b_139invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_1LEPStop_36invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_2bMET_36invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_2BoostedBosons_139invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_2LEPStop_139invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_2LEPStop_36invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_2LEPStop_exclusive_139invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_2LEPStop_inclusive_139invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_2OSLEP_chargino_139invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_2OSLEP_chargino_80invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_2OSLEP_chargino_binned_139invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_2OSLEP_chargino_binned_80invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_2OSLEP_chargino_inclusive_139invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_2OSLEP_chargino_inclusive_80invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_2OSLEP_Z_139invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_3b_24invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_3b_36invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_3b_discoverySR_24invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_3b_discoverySR_36invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_3LEP_139invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_4LEP_139invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_4LEP_36invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_MONOJET_139infb
ATLAS Monojet analysis, with 139/fb of data.
classGambit::ColliderBit::Analysis_ATLAS_13TeV_MultiLEP_2Lep0Jets_36invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_MultiLEP_2LepPlusJets_36invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_MultiLEP_36invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_MultiLEP_3Lep_36invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_MultiLEP_confnote_36invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_MultiLEP_strong_139invfb
ATLAS Run 2 search for same-sign leptons and jets, with 139/fb of data.
classGambit::ColliderBit::Analysis_ATLAS_13TeV_PhotonGGM_1Photon_139invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_PhotonGGM_1Photon_36invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_PhotonGGM_2Photon_36invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_PhotonGGM_36invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_RJ3L_2Lep2Jets_36invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_RJ3L_3Lep_36invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_RJ3L_lowmass_36invfb
classGambit::ColliderBit::Analysis_ATLAS_13TeV_ZGammaGrav_CONFNOTE_80invfb
ATLAS ZH(->photon+gravitino) (79.8 fb^-1)
classGambit::ColliderBit::Analysis_ATLAS_7TeV_1OR2LEPStop_4_7invfb
classGambit::ColliderBit::Analysis_ATLAS_7TeV_2LEPStop_4_7invfb
classGambit::ColliderBit::Analysis_ATLAS_8TeV_0LEP_20invfb
classGambit::ColliderBit::Analysis_ATLAS_8TeV_0LEPStop_20invfb
classGambit::ColliderBit::Analysis_ATLAS_8TeV_1LEPbb_20invfb
classGambit::ColliderBit::Analysis_ATLAS_8TeV_1LEPStop_20invfb
classGambit::ColliderBit::Analysis_ATLAS_8TeV_2bStop_20invfb
classGambit::ColliderBit::Analysis_ATLAS_8TeV_2LEPEW_20invfb
classGambit::ColliderBit::Analysis_ATLAS_8TeV_2LEPStop_20invfb
classGambit::ColliderBit::Analysis_ATLAS_8TeV_3LEPEW_20invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_0LEP_137invfb
CMS Run 2 0-lepton jet+MET SUSY analysis, with 137/fb of data.
classGambit::ColliderBit::Analysis_CMS_13TeV_0LEP_13invfb
CMS Run 2 0-lepton jet+MET SUSY analysis, with 13/fb of data.
classGambit::ColliderBit::Analysis_CMS_13TeV_0LEP_36invfb
CMS Run 2 0-lepton jet+MET SUSY analysis, with 36/fb of data.
classGambit::ColliderBit::Analysis_CMS_13TeV_1LEPbb_36invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_1LEPStop_36invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_1Photon1Lepton_36invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_1Photon1Lepton_emu_combined_36invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_2LEPsoft_36invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_2LEPsoft_36invfb_nocovar
classGambit::ColliderBit::Analysis_CMS_13TeV_2LEPsoft_stop_36invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_2LEPsoft_stop_36invfb_nocovar
classGambit::ColliderBit::Analysis_CMS_13TeV_2LEPStop_36invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_2OSLEP_137invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_2OSLEP_36invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_2OSLEP_36invfb_nocovar
classGambit::ColliderBit::Analysis_CMS_13TeV_2OSLEP_chargino_stop_36invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_2OSLEP_confnote_36invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_2OSLEP_for_chargino_36invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_2OSLEP_for_stop_36invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_2OSLEP_Slepton_137invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_2OSLEP_Strong_Production_137invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_2Photon_GMSB_36invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_2SSLEP_Stop_137invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_2SSLEP_Stop_36invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_2SSLEP_Stop_exclusive_36invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_2SSLEP_Stop_inclusive_36invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_MONOJET_36invfb
CMS Run 2 monojet analysis (no W/Z region) with 36/fb of data.
classGambit::ColliderBit::Analysis_CMS_13TeV_MultiLEP_137invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_MultiLEP_2LEP_137invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_MultiLEP_2SSLep_36invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_MultiLEP_36invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_MultiLEP_3LEP_137invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_MultiLEP_3Lep_36invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_MultiLEP_3LEPTau_137invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_MultiLEP_4LEP_137invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_MultiLEP_4LEPTau_137invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_MultiLEP_Full_2SSLep_36invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_MultiLEP_Full_36invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_MultiLEP_Full_3Lep_36invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_MultiLEP_Full_3Lep_rebinned_36invfb
classGambit::ColliderBit::Analysis_CMS_13TeV_Photon_GMSB_36invfb
classGambit::ColliderBit::Analysis_CMS_8TeV_1LEPDMTOP_20invfb
classGambit::ColliderBit::Analysis_CMS_8TeV_2LEPDMTOP_20invfb
classGambit::ColliderBit::Analysis_CMS_8TeV_MONOJET_20invfb
classGambit::ColliderBit::Analysis_CMS_8TeV_MultiLEP_20invfb
classGambit::ColliderBit::Analysis_CMS_8TeV_MultiLEP_3Lep_20invfb
classGambit::ColliderBit::Analysis_CMS_8TeV_MultiLEP_4Lep_20invfb
classGambit::ColliderBit::Analysis_Covariance
Dummy analysis code with a hard-coded return including a SR covariance matrix.
classGambit::ColliderBit::Analysis_Minimum
Basic analysis code for copying.
classGambit::ColliderBit::AnalysisContainer
A class for managing collections of Analysis instances.
structGambit::ColliderBit::AnalysisData
structGambit::ColliderBit::AnalysisLogLikes
Container for loglike information for an analysis.
classGambit::ColliderBit::AnalysisUtil
classGambit::ColliderBit::BaBar_single_photon_analysis_info
A class to hold analysis information for the BaBar single photon search (specific to dark photon models)
classGambit::ColliderBit::BaseCollider
An abstract base class for collider simulators within ColliderBit.
classGambit::ColliderBit::BaseDetector
An abstract base class for detector simulators within ColliderBit.
classGambit::ColliderBit::BaseLimitContainer
Base class for experimental limit curve interpolation.
classGambit::ColliderBit::BuckFast
A base class for BuckFast simple smearing simulations within ColliderBit.
structGambit::ColliderBit::convergence_settings
Type for holding Monte Carlo convergence settings.
structGambit::ColliderBit::Cutflow
A tracker of numbers & fractions of events passing sequential cuts.
structGambit::ColliderBit::Cutflows
A container for several Cutflow objects, with some convenient batch access.
classGambit::ColliderBit::Dijet_analysis_info
A class to hold analysis information for DiJets (specific to DMsimp models)
classGambit::ColliderBit::EventCounter
A simple class for counting events of type HEPUtils::Event.
classGambit::ColliderBit::ImageLimit
structGambit::ColliderBit::jet_collection_settings
Struct of different jet collection settings.
classGambit::ColliderBit::L3ChargedGauginoSmallDeltaMAnySneutrinoLimitAt188pt6GeV
A class to contain the limit data from L3PLB_482_2000_31, figure 5b.
classGambit::ColliderBit::L3ChargedGauginoSmallDeltaMWithHeavySneutrinoLimitAt188pt6GeV
A class to contain the limit data from L3PLB_482_2000_31, figure 5a.
classGambit::ColliderBit::L3ChargedHiggsinoSmallDeltaMLimitAt188pt6GeV
A class to contain the limit data from L3PLB_482_2000_31, figure 5c.
classGambit::ColliderBit::L3CharginoAllChannelsLimitAt188pt6GeV
A class to contain the limit data from L3PLB_472_2000_420, figure 2a.
classGambit::ColliderBit::L3CharginoLeptonicLimitAt188pt6GeV
A class to contain the limit data from L3PLB_472_2000_420, figure 2b.
classGambit::ColliderBit::L3NeutralinoAllChannelsLimitAt188pt6GeV
A class to contain the limit data from L3PLB_472_2000_420, figure 3a.
classGambit::ColliderBit::L3NeutralinoLeptonicLimitAt188pt6GeV
A class to contain the limit data from L3PLB_472_2000_420, figure 3b.
classGambit::ColliderBit::L3SelectronLimitAt205GeV
A class to contain the limit data from L3_PLB580_2004_37, figure 2a.
classGambit::ColliderBit::L3SmuonLimitAt205GeV
A class to contain the limit data from L3_PLB580_2004_37, figure 2b.
classGambit::ColliderBit::L3StauLimitAt205GeV
A class to contain the limit data from L3_PLB580_2004_37, figure 2c.
classGambit::ColliderBit::LineSegment
A simple container for a line segment on an xy plane.
structGambit::ColliderBit::LSP
classGambit::ColliderBit::MC_convergence_checker
Helper class for testing for convergence of analyses.
classGambit::ColliderBit::MC_xsec_container
A class for holding a total cross-section calculated via MC across multiple threads.
structGambit::ColliderBit::MCLoopInfo
Container for event loop status data and settings.
classGambit::ColliderBit::Model_analysis_info
classGambit::ColliderBit::MT2
A useful MT2 class for this module.
classGambit::ColliderBit::OPALCharginoAllChannelsLimitAt208GeV
A class to contain the limit data from OPAL_EPJC35_2004_1, figure 8b.
classGambit::ColliderBit::OPALCharginoHadronicLimitAt208GeV
A class to contain the limit data from OPAL_EPJC35_2004_1, figure 5b.
classGambit::ColliderBit::OPALCharginoLeptonicLimitAt208GeV
A class to contain the limit data from OPAL_EPJC35_2004_1, figure 7b.
classGambit::ColliderBit::OPALCharginoSemiLeptonicLimitAt208GeV
A class to contain the limit data from OPAL_EPJC35_2004_1, figure 6b.
classGambit::ColliderBit::OPALDegenerateCharginoLimitAt208GeV
A class to contain the limit data from OPAL, hep-ex/0210043, figure 5a (in colour)
classGambit::ColliderBit::OPALNeutralinoHadronicLimitAt208GeV
A class to contain the limit data from OPAL_EPJC35_2004_1, figure 9b.
classGambit::ColliderBit::OPALNeutralinoHadronicViaZLimitAt208GeV
A class to contain the limit data from OPAL_EPJC35_2004_1, figure 9b.
classGambit::ColliderBit::P2
A simple container for a point on an xy plane.
classGambit::ColliderBit::Perf_Plot
classGambit::ColliderBit::PID_pair_xsec_container
A class for holding the production cross-section for final state identified by the pair of PID codes.
classGambit::ColliderBit::process_xsec_container
A class for holding the cross-section of a single Pythia process (identified by the Pythia process code)
classGambit::ColliderBit::Py8Collider
A specializable, recyclable class interfacing ColliderBit and Pythia.
classGambit::ColliderBit::SetHooks
A templated class specific for the UserHooks.
structGambit::ColliderBit::SignalRegionData
A simple container for the result of one signal region from one analysis.
classGambit::ColliderBit::xsec_container
A base class for holding cross-section info within ColliderBit.

Types

Name
enumspecialIterations { BASE_INIT = -1, COLLIDER_INIT = -2, COLLIDER_INIT_OMP = -3, XSEC_CALCULATION = -4, START_SUBPROCESS = -5, COLLECT_CONVERGENCE_DATA = -6, CHECK_CONVERGENCE = -7, END_SUBPROCESS = -8, COLLIDER_FINALIZE = -9, BASE_FINALIZE = -10}
Special iteration labels for the loop controlled by operateLHCLoop.
typedef std::vector< AnalysisData * >AnalysisDataPointers
Container for data from multiple analyses and SRs.
typedef std::map< std::string, AnalysisLogLikes >map_str_AnalysisLogLikes
Typedef for a string-to-AnalysisLogLikes map.
typedef std::vector< AnalysisContainer >AnalysisContainers
Container for multiple analysis containers.
typedef std::chrono::millisecondsms
typedef std::chrono::steady_clocksteady_clock
typedef std::chrono::steady_clock::time_pointtp
typedef std::map< std::string, double >timer_map_type
typedef std::pair< std::string, SLHAstruct >pair_str_SLHAstruct
Typedef for a str-SLHAstruct pair, to pass around SLHA filenames + content.
typedef std::vector< std::pair< int, int > >vec_iipair
Typedefs related to cross-sections.
typedef std::vector< PID_pair >vec_PID_pair
typedef std::multimap< int, std::pair< int, int > >multimap_int_iipair
typedef std::multimap< int, PID_pair >multimap_int_PID_pair
typedef std::multimap< PID_pair, int >multimap_PID_pair_int
typedef std::map< int, xsec_container >map_int_xsec
typedef std::map< int, process_xsec_container >map_int_process_xsec
typedef std::map< std::pair< int, int >, PID_pair_xsec_container >map_iipair_PID_pair_xsec
typedef std::map< PID_pair, PID_pair_xsec_container >map_PID_pair_PID_pair_xsec
typedef HEPUtils::EventHEPUtils_Event
Typedef for a std::function that sets the weight for the input HEPUtils::Event.
typedef std::function< void(HEPUtils_Event &, const BaseCollider *)>EventWeighterFunctionType
typedef std::vector< std::vector< double > >MixMatrix
typedef std::vector< std::vector< double > >data_type
typedef std::vector< const HEPUtils::Particle * >ParticlePtrs
Typedef for a vector of Particle pointers.
typedef std::vector< const HEPUtils::Jet * >JetPtrs
Typedef for a vector of Jet pointers.

Functions

Name
template <typename Vec4T >
FJNS::PseudoJet
mk_pseudojet(const Vec4T & p)
template <typename Vec4T >
HEPUtils::P4
mk_p4(const Vec4T & p)
template <typename EventT >
bool
fromBottom(int n, const EventT & evt)
template <typename EventT >
bool
fromTau(int n, const EventT & evt)
template <typename EventT >
bool
fromHadron(int n, const EventT & evt)
template <typename EventT >
bool
isFinalB(int n, const EventT & evt)
template <typename EventT >
bool
isFinalTau(int n, const EventT & evt)
template <typename EventT >
bool
isParton(int n, const EventT & evt)
template <typename EventT >
bool
isFinalParton(int n, const EventT & evt)
template <typename EventT >
bool
isFinalPhoton(int n, const EventT & evt)
template <typename EventT >
bool
isFinalLepton(int n, const EventT & evt)
voidget_sigma_ee_ll(triplet< double > & result, const double sqrts, const int generation, const int l_chirality, const int lbar_chirality, const double gtol, const double ftol, const bool gpt_error, const bool fpt_error, const Spectrum & spec, const double gammaZ, const bool l_are_gauge_es)
voidget_sigma_ee_chi00(triplet< double > & result, const double sqrts, const int chi_first, const int chi_second, const double tol, const bool pt_error, const Spectrum & spec, const double gammaZ)
Retrieve the production cross-section at an e+e- collider for neutralino pairs.
voidget_sigma_ee_chipm(triplet< double > & result, const double sqrts, const int chi_plus, const int chi_minus, const double tol, const bool pt_error, const Spectrum & spec, const double gammaZ)
Retrieve the production cross-section at an e+e- collider for chargino pairs.
doublexsec_sleislej(int pid1, int pid2, double sqrts, double m1, double m2, MixMatrix F, MixMatrix N, const double mN[4], double alpha, double mZ, double gZ, double sin2thetaW, bool warn_on_CP_violating_masses =true)
doublexsec_neuineuj(int pid1, int pid2, double sqrts, double m1, double m2, MixMatrix N, const double mS[2], double tanb, double alpha, double mZ, double gZ, double sin2thetaW)
doublexsec_chaichaj(int pid1, int pid2, double sqrts, double m1, double m2, MixMatrix V, MixMatrix U, double msn, double alpha, double mZ, double gZ, double sin2thetaW)
voidSLHA2BFM_NN(MixMatrix & NN, double tanb, double sin2thetaW)
Functions to convert mass matrices between SLHA and BFM conventions ////////////////////////////////////////////////////////////////////.
voidSLHA2BFM_VV(MixMatrix & VV)
Converts the chargino mixing matrix V in SLHA conventions to BFM conventions.
voidBFM2SLHA_NN(MixMatrix & NN, double tanb, double sin2thetaW)
Converts a neutralino mixing matrix in BFM conventions to SLHA conventions, (\tan\beta) is as defined in SLHA.
voidBFM2SLHA_VV(MixMatrix & VV)
Converts the chargino mixing matrix V in BFM conventions to SLHA conventions.
MixMatrixmultiply(MixMatrix A, MixMatrix B)
Helper function to multiply matrices.
MixMatrixtranspose(MixMatrix A)
Helper function to find matrix transpose.
voidprint(MixMatrix A)
Helper function to print a matrix.
P2operator+(const P2 & a, const P2 & b)
P2operator-(const P2 & a, const P2 & b)
P2operator*(const P2 & a, double f)
P2operator*(double f, const P2 & a)
P2operator/(const P2 & a, double f)
std::stringto_str(const P2 & p2)
Make a string representation of the vector.
std::ostream &operator«(std::ostream & ostr, const P2 & p2)
Write a string representation of the vector to the provided stream.
std::stringto_str(const LineSegment & lineseg)
Make a string representation of the LineSegment.
std::ostream &operator«(std::ostream & ostr, const LineSegment & lineseg)
Write a string representation of the vector to the provided stream.
boolamIaJet(const HEPUtils::Jet * jet)
Identifier for jets true.
boolamIaBJet(const HEPUtils::Jet * jet)
Indentifier for b-jets true.
boolamIaJet(const HEPUtils::Particle * part)
Identifier for jets false.
boolamIaBJet(const HEPUtils::Particle * part)
Identifier for b-jets true.
boolamIanElectron(const HEPUtils::Particle * part)
Identifier for electrons.
boolamIaMuon(const HEPUtils::Particle * part)
Identifier for muons.
boolamIaTau(const HEPUtils::Particle * part)
Identifier for taus.
template <typename CONTAINER ,typename RMFN >
void
iremoveerase(CONTAINER & c, const RMFN & fn)
Convenience combination of remove_if and erase.
voidifilter_reject(ParticlePtrs & particles, std::function< bool(const Particle *)> rejfn, bool do_delete =true)
In-place filter a supplied particle vector by rejecting those which fail a supplied cut.
voidifilter_select(ParticlePtrs & particles, std::function< bool(const Particle *)> selfn, bool do_delete =true)
In-place filter a supplied particle vector by keeping those which pass a supplied cut.
ParticlePtrsfilter_reject(const ParticlePtrs & particles, std::function< bool(const Particle *)> rejfn, bool do_delete =true)
ParticlePtrsfilter_select(const ParticlePtrs & particles, std::function< bool(const Particle *)> selfn, bool do_delete =true)
Filter a supplied particle vector by keeping those which pass a supplied cut.
voidifilter_reject(JetPtrs & jets, std::function< bool(const Jet *)> rejfn, bool do_delete =true)
In-place filter a supplied jet vector by rejecting those which fail a supplied cut.
voidifilter_select(JetPtrs & jets, std::function< bool(const Jet *)> selfn, bool do_delete =true)
In-place filter a supplied jet vector by keeping those which pass a supplied cut.
JetPtrsfilter_reject(const JetPtrs & jets, std::function< bool(const Jet *)> rejfn, bool do_delete =true)
JetPtrsfilter_select(const JetPtrs & jets, std::function< bool(const Jet *)> selfn, bool do_delete =true)
Filter a supplied particle vector by keeping those which pass a supplied cut.
boolrandom_bool(double eff)
Return a random true/false at a success rate given by a number.
boolrandom_bool(const HEPUtils::BinnedFn1D< double > & effmap, double x)
Return a random true/false at a success rate given by a 1D efficiency map.
boolrandom_bool(const HEPUtils::BinnedFn2D< double > & effmap, double x, double y)
Return a random true/false at a success rate given by a 2D efficiency map.
voidfiltereff(std::vector< const HEPUtils::Particle * > & particles, double eff, bool do_delete =false)
Utility function for filtering a supplied particle vector by sampling wrt an efficiency scalar.
voidfiltereff(std::vector< const HEPUtils::Particle * > & particles, std::function< double(const HEPUtils::Particle *)> eff_fn, bool do_delete =false)
Utility function for filtering a supplied particle vector by sampling an efficiency returned by a provided function object.
voidfiltereff_pt(std::vector< const HEPUtils::Particle * > & particles, const HEPUtils::BinnedFn1D< double > & eff_pt, bool do_delete =false)
Utility function for filtering a supplied particle vector by sampling wrt a binned 1D efficiency map in pT.
voidfiltereff_etapt(std::vector< const HEPUtils::Particle * > & particles, const HEPUtils::BinnedFn2D< double > & eff_etapt, bool do_delete =false)
Utility function for filtering a supplied particle vector by sampling wrt a binned 2D efficiency map in
boolhas_tag(const HEPUtils::BinnedFn2D< double > & effmap, double eta, double pt)
std::map< const HEPUtils::Jet *, bool >generateBTagsMap(const std::vector< const HEPUtils::Jet * > & jets, double bTagEff, double cMissTagEff, double otherMissTagEff, double pTmin =0., double absEtaMax =DBL_MAX)
Return a map<Jet*,bool> containing a generated b-tag for every jet in the input vector.
template <typename NUM1 ,typename NUM2 >
size_t
binIndex(NUM1 val, const std::vector< NUM2 > & binedges, bool allow_overflow =false)
std::vector< double >mk_bin_values(const std::vector< double > & binEdgeValues)
Make a vector of central bin values from a vector of bin edge values using linear interpolation.
std::vector< double >makeBinValues(const std::vector< double > & binEdgeValues)
Alias.
template <typename MOM >
std::vector< std::shared_ptr< HEPUtils::Jet > >
get_jets(const std::vector< MOM * > & moms, double R, double ptmin =0 *GeV, FJNS::JetAlgorithm alg =FJNS::antikt_algorithm)
Run jet clustering from any P4-compatible momentum type.
boolobject_in_cone(const HEPUtils::Event & e, std::string jetcollection, const HEPUtils::P4 & p4, double ptmin, double rmax, double rmin =0.05)
Check if there’s a physics object above ptmin in an annulus rmin..rmax around the given four-momentum p4.
template <typename MOMPTRS1 ,typename MOMPTRS2 >
void
removeOverlap(MOMPTRS1 & momstofilter, const MOMPTRS2 & momstocmp, double deltaRMax, bool use_rapidity =false, double pTmax =DBL_MAX, double btageff =0)
template <typename MOMPTRS1 ,typename MOMPTRS2 >
void
removeOverlap(MOMPTRS1 & momstofilter, const MOMPTRS2 & momstocmp, double(*)(const double) deltaRMax, bool use_rapidity =false, double pTmax =DBL_MAX, double btageff =0)
template <typename MOMPTRS1 >
void
removeOverlapIfBjet(MOMPTRS1 & momstofilter, std::vector< const HEPUtils::Jet * > & jets, double deltaRMax, bool use_rapidity =false, double pTmax =DBL_MAX)
template <typename CONTAINER ,typename FN >
bool
all_of(const CONTAINER & c, const FN & f)
Non-iterator version of std::all_of.
template <typename CONTAINER ,typename FN >
bool
any_of(const CONTAINER & c, const FN & f)
Non-iterator version of std::any_of.
template <typename CONTAINER ,typename FN >
bool
none_of(const CONTAINER & c, const FN & f)
Non-iterator version of std::none_of.
std::vector< std::vector< const HEPUtils::Particle * > >getSFOSpairs(std::vector< const HEPUtils::Particle * > particles)
Utility function for returning a collection of same-flavour, oppsosite-sign particle pairs.
std::vector< std::vector< const HEPUtils::Particle * > >getOSpairs(std::vector< const HEPUtils::Particle * > particles)
Utility function for returning a collection of oppsosite-sign particle pairs.
std::vector< std::vector< const HEPUtils::Particle * > >getSSpairs(std::vector< const HEPUtils::Particle * > particles)
Utility function for returning a collection of same-sign particle pairs.
std::vector< std::vector< const HEPUtils::Jet * > >getBJetPairs(std::vector< const HEPUtils::Jet * > bjets)
Utility function for returning a collection of b-tagged jets.
voidsortBy(ParticlePtrs & particles, std::function< bool(const Particle *, const Particle *)> cmpfn)
Particle-sorting function.
boolcmpParticlesByPt(const HEPUtils::Particle * lep1, const HEPUtils::Particle * lep2)
Comparison function to give a particles sorting order decreasing by pT.
voidsortByPt(ParticlePtrs & particles)
voidsortBy(JetPtrs & jets, std::function< bool(const Jet *, const Jet *)> cmpfn)
Jet-sorting function.
boolcmpJetsByPt(const HEPUtils::Jet * jet1, const HEPUtils::Jet * jet2)
Comparison function to give a jets sorting order decreasing by pT.
voidsortByPt(JetPtrs & jets)
voidsortByParentMass(std::vector< std::vector< const Particle * > > & pairs, double mP)
voiduniquePairs(std::vector< std::vector< const Particle * > > & pairs)
Remove pairs with already used leptons, assumes some order.
intcountPt(const std::vector< const Particle * > & particles, double pTlim)
Count number of particles that have pT > pTlim.
intcountPt(const std::vector< const Jet * > & jets, double pTlim)
Count number of jets that have pT > pTlim.
doublescalarSumPt(const std::vector< const Particle * > & particles, double pTlim =0.)
Scalar sum pT of particles with pT > pTlim (default pTlim = 0)
doublescalarSumPt(const std::vector< const Jet * > & jets, double pTlim =0.)
Scalar sum pT of jets.
doubleget_mT2(const Particle * part1, const Particle * part2, P4 pTmiss, double mass)
Faster way to compute stransverse mass.
doubleget_mT2(P4 mom1, P4 mom2, P4 pTmiss, double mass)
Faster way to compute stransverse mass, from the momenta.
doubleget_mT(const Particle * part, P4 pTmiss)
doubleget_mT(P4 mom, P4 pTmiss)
doubleget_mT(const Particle * part1, const Particle * part2, P4 pTmiss)
doubleget_mT(const Particle * part1, const Particle * part2, const Particle * part3, P4 pTmiss)
boolsameSign(const Particle * P1, const Particle * P2)
Have two particles the same sign?
booloppositeSign(const Particle * P1, const Particle * P2)
Have two particles the opposite sign?
voidLEP208_SLHA1_convention_xsec_selselbar(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_selserbar(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_serserbar(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_serselbar(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_se1se1bar(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_se1se2bar(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_se2se2bar(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_se2se1bar(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_smulsmulbar(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_smulsmurbar(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_smursmurbar(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_smursmulbar(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_smu1smu1bar(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_smu1smu2bar(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_smu2smu2bar(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_smu2smu1bar(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_staulstaulbar(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_staulstaurbar(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_staurstaurbar(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_staurstaulbar(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_stau1stau1bar(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_stau1stau2bar(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_stau2stau2bar(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_stau2stau1bar(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_chi00_11(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_chi00_12(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_chi00_13(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_chi00_14(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_chi00_22(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_chi00_23(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_chi00_24(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_chi00_33(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_chi00_34(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_chi00_44(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_chipm_11(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_chipm_12(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_chipm_22(triplet< double > & result)
voidLEP208_SLHA1_convention_xsec_chipm_21(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_selselbar(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_selserbar(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_serserbar(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_serselbar(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_se1se1bar(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_se1se2bar(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_se2se2bar(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_se2se1bar(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_smulsmulbar(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_smulsmurbar(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_smursmurbar(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_smursmulbar(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_smu1smu1bar(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_smu1smu2bar(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_smu2smu2bar(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_smu2smu1bar(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_staulstaulbar(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_staulstaurbar(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_staurstaurbar(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_staurstaulbar(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_stau1stau1bar(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_stau1stau2bar(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_stau2stau2bar(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_stau2stau1bar(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_chi00_11(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_chi00_12(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_chi00_13(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_chi00_14(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_chi00_22(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_chi00_23(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_chi00_24(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_chi00_33(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_chi00_34(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_chi00_44(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_chipm_11(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_chipm_12(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_chipm_22(triplet< double > & result)
voidLEP205_SLHA1_convention_xsec_chipm_21(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_selselbar(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_selserbar(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_serserbar(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_serselbar(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_se1se1bar(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_se1se2bar(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_se2se2bar(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_se2se1bar(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_smulsmulbar(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_smulsmurbar(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_smursmurbar(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_smursmulbar(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_smu1smu1bar(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_smu1smu2bar(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_smu2smu2bar(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_smu2smu1bar(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_staulstaulbar(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_staulstaurbar(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_staurstaurbar(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_staurstaulbar(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_stau1stau1bar(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_stau1stau2bar(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_stau2stau2bar(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_stau2stau1bar(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_chi00_11(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_chi00_12(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_chi00_13(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_chi00_14(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_chi00_22(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_chi00_23(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_chi00_24(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_chi00_33(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_chi00_34(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_chi00_44(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_chipm_11(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_chipm_12(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_chipm_22(triplet< double > & result)
voidLEP188_SLHA1_convention_xsec_chipm_21(triplet< double > & result)
voidALEPH_Selectron_Conservative_LLike(double & result)
voidALEPH_Smuon_Conservative_LLike(double & result)
voidALEPH_Stau_Conservative_LLike(double & result)
voidL3_Selectron_Conservative_LLike(double & result)
voidL3_Smuon_Conservative_LLike(double & result)
voidL3_Stau_Conservative_LLike(double & result)
voidL3_Neutralino_All_Channels_Conservative_LLike(double & result)
voidL3_Neutralino_Leptonic_Conservative_LLike(double & result)
voidL3_Chargino_All_Channels_Conservative_LLike(double & result)
voidL3_Chargino_Leptonic_Conservative_LLike(double & result)
voidOPAL_Chargino_Hadronic_Conservative_LLike(double & result)
voidOPAL_Chargino_SemiLeptonic_Conservative_LLike(double & result)
voidOPAL_Chargino_Leptonic_Conservative_LLike(double & result)
voidOPAL_Degenerate_Chargino_Conservative_LLike(double & result)
voidOPAL_Chargino_All_Channels_Conservative_LLike(double & result)
voidOPAL_Neutralino_Hadronic_Conservative_LLike(double & result)
doubleI1(double s, double m1, double m2, double mk, double ml)
doubleI2(double s, double m1, double m2, double mk, double ml)
doubleI3(double s, double m1, double m2, double mk)
Analysis *mkAnalysis(const str & name)
Factory definition.
strgetDetector(const str & name)
Return the detector to be used for a given analysis name, checking that the analysis exists.
std::ostream &operator«(std::ostream & os, const Cutflow & cf)
Print a Cutflow to a stream.
std::ostream &operator«(std::ostream & os, const Cutflows & cfs)
Print a Cutflows to a stream.
template <typename EventT >
void
convertParticleEvent(const EventT & pevt, HEPUtils::Event & result, std::vector< jet_collection_settings > all_jet_collection_settings, str jetcollection_taus, double jet_pt_min)
template <typename EventT >
void
convertPartonEvent(const EventT & pevt, HEPUtils::Event & result, std::vector< jet_collection_settings > all_jet_collection_settings, str jetcollection_taus, double jet_pt_min)
Convert a partonic (no hadrons) EventT into an unsmeared HEPUtils::Event.
const multimap_PID_pair_int &all_PID_pairs_to_process_codes()
template <typename PythiaT ,typename hepmc_writerT >
void
dropHepMCEventPy8Collider(const PythiaT * Pythia, const safe_ptr< Options > & runOptions)
Drop a HepMC file for the event.
template <typename PythiaT ,typename EventT ,typename hepmc_writerT >
void
generateEventPy8Collider(EventT & pythia_event, const MCLoopInfo & RunMC, const Py8Collider< PythiaT, EventT, hepmc_writerT > & HardScatteringSim, const int iteration, void(*)() wrapup, const safe_ptr< Options > & runOptions)
Generate a hard scattering event with Pythia.
template <typename PythiaT ,typename EventT ,typename hepmc_writerT >
void
convertEventToHEPUtilsPy8Collider(HEPUtils::Event & event, const EventT & pythia_event, const Py8Collider< PythiaT, EventT, hepmc_writerT > & HardScatteringSim, const EventWeighterFunctionType & EventWeighterFunction, const int iteration, void(*)() wrapup, const safe_ptr< Options > & runOptions)
Generate a hard scattering event with Pythia and convert it to HEPUtils::Event.
template <typename PythiaT ,typename EventT ,typename hepmc_writerT >
void
convertEventToHepMCPy8Collider(HepMC3::GenEvent & event, const EventT & pythia_event, const Py8Collider< PythiaT, EventT, hepmc_writerT > & HardScatteringSim, const int iteration, void(*)() wrapup)
Generate a hard scattering event with Pythia and convert it to HepMC event.
template <typename PythiaT ,typename EventT ,typename hepmc_writerT >
void
getPy8Collider(Py8Collider< PythiaT, EventT, hepmc_writerT > & result, const MCLoopInfo & RunMC, const SLHAstruct & slha, const str model_suffix, const int iteration, void(*)() wrapup, const Options & runOptions)
Retrieve a Pythia hard-scattering Monte Carlo simulation.
voidget_HEPUtils_event(const LHEF::Reader & , HEPUtils::Event & , double , std::vector< Gambit::ColliderBit::jet_collection_settings > )
Extract an LHE event as a HEPUtils::Event.
LineSegmentmakeLine(const P2 & pt1, const P2 & pt2)
Factory function for lines.
doubleaddInQuad(const double & a, const double & b)
Add two numbers in quadrature.
FJNS::JetAlgorithmFJalgorithm_map(std::string algorithm)
Storage of different FastJet methods.
FJNS::StrategyFJstrategy_map(std::string strategy)
FJNS::RecombinationSchemeFJRecomScheme_map(std::string reco_scheme)
boolsortByPT13(const HEPUtils::Jet * jet1, const HEPUtils::Jet * jet2)
boolsortByPT13_sharedptr(std::shared_ptr< HEPUtils::Jet > jet1, std::shared_ptr< HEPUtils::Jet > jet2)
boolsortByMass(const HEPUtils::Jet * jet1, const HEPUtils::Jet * jet2)
boolsortByMass_sharedptr(std::shared_ptr< HEPUtils::Jet > jet1, std::shared_ptr< HEPUtils::Jet > jet2)
doublecalcMT(HEPUtils::P4 jetMom, HEPUtils::P4 metMom)
boolsortByPT_1l(const HEPUtils::Jet * jet1, const HEPUtils::Jet * jet2)
boolsortByPT_1l_sharedptr(std::shared_ptr< HEPUtils::Jet > jet1, std::shared_ptr< HEPUtils::Jet > jet2)
boolsortByMass_1l(const HEPUtils::Jet * jet1, const HEPUtils::Jet * jet2)
boolsortByMass_1l_sharedptr(std::shared_ptr< HEPUtils::Jet > jet1, std::shared_ptr< HEPUtils::Jet > jet2)
doublecalcMT_1l(HEPUtils::P4 jetMom, HEPUtils::P4 metMom)
boolsortByPT_j(const HEPUtils::Jet * jet1, const HEPUtils::Jet * jet2)
boolsortByPT_l(const HEPUtils::Particle * lep1, const HEPUtils::Particle * lep2)
boolsortByPT_jet(const HEPUtils::Jet * jet1, const HEPUtils::Jet * jet2)
boolsortByPT_lep(const HEPUtils::Particle * lep1, const HEPUtils::Particle * lep2)
boolsortByPT_RJ3L(const HEPUtils::Jet * jet1, const HEPUtils::Jet * jet2)
boolsortLepByPT_RJ3L(const HEPUtils::Particle * lep1, const HEPUtils::Particle * lep2)
boolSortLeptons(const pair< TLorentzVector, int > lv1, const pair< TLorentzVector, int > lv2)
boolSortJets(const TLorentzVector jv1, const TLorentzVector jv2)
boolsortByPT(const HEPUtils::Jet * jet1, const HEPUtils::Jet * jet2)
boolsortByPT_2lep(const HEPUtils::Particle * lep1, const HEPUtils::Particle * lep2)
doublePhi_mpi_pi(double x)
double_Phi_mpi_pi(double x)
void_setEventWeight_unity(HEPUtils::Event & event, const BaseCollider * )
A function that sets the event weight to unity, with zero uncertainty.
voidsetEventWeight_unity(EventWeighterFunctionType & result)
void_setEventWeight_fromCrossSection(HEPUtils::Event & event, const BaseCollider * HardScatteringSim_ptr, const map_int_process_xsec & ProcessCrossSectionsMap, const int use_trust_level)
A function that sets the event weight based on the process cross-sections.
voidsetEventWeight_fromCrossSection(EventWeighterFunctionType & result)
voidfill_BaBar_single_photon()
doubleBaBar_single_photon_LogLike(double kappa, double mAp, double BRinv)
Perform the actual likelihood evaluation.
voidBaBar_single_photon_LogLike_SubGeVDM(double & result)
voidgetDummyColliderObservable(double & result)
Dummy observable that creates a dependency on TestModel1D.
voidoperateLHCLoop(MCLoopInfo & result)
LHC Loop Manager.
voidgetLHCEventLoopInfo(map_str_dbl & result)
Store some information about the event generation.
voidCollectAnalyses(AnalysisDataPointers & result)
Loop over all analyses and collect them in one place.
voidset_CS(hb_ModelParameters & result, const HiggsCouplingsTable & couplings, int n_neutral_higgses)
Helper function to set HiggsBounds/Signals parameters cross-section ratios from a GAMBIT HiggsCouplingsTable.
voidset_SMLikeHiggs_ModelParameters(const SubSpectrum & spec, const HiggsCouplingsTable & couplings, hb_ModelParameters & result)
Helper function for populating a HiggsBounds/Signals ModelParameters object for SM-like Higgs.
voidSMLikeHiggs_ModelParameters(hb_ModelParameters & result)
SM-like (SM + possible invisibles) Higgs model parameters for HiggsBounds/Signals.
voidMSSMLikeHiggs_ModelParameters(hb_ModelParameters & result)
MSSM-like (MSSM + NMSSM + …) Higgs model parameters for HiggsBounds/Signals.
voidcalc_HB_LEP_LogLike(double & result)
Get a LEP chisq from HiggsBounds.
voidcalc_HS_LHC_LogLike(double & result)
Get an LHC chisq from HiggsSignals.
voidFeynHiggs_HiggsProd(fh_HiggsProd_container & result)
Higgs production cross-sections from FeynHiggs.
voidfill_analysis_loglikes(const AnalysisData & ana_data, AnalysisLogLikes & ana_loglikes, bool use_marg, bool has_and_use_covar, bool combine_nocovar_SRs, bool has_and_use_fulllikes, bool()(const str &) FullLikes_FileExists, int()(const str &, const str &) FullLikes_ReadIn, double(*)(std::map< str, double > &, const str &) FullLikes_Evaluate, const std::string alt_loglike_key)
Forward declaration of funtion in LHC_likelihoods.
voidDMEFT_fill_analysis_info_map()
Forward declarations of functions in this file.
voidDMsimp_fill_analysis_info_map(std::map< str, str > Analysis_data_path, std::map< str, std::vector< str > > Interpolation_columns, int Ndim)
A function for filling the analysis_info_map for the DMsimp models.
voidSubGeVDM_fill_analysis_info_map(std::map< str, str > Analysis_data_path, std::map< str, std::vector< str > > Interpolation_columns)
A function for filling the analysis_info_map for the SubGeVDM_fermion and SubGeVDM_scalar models.
voidDMEFT_results(AnalysisDataPointers & result)
Results from DMEFT analyses before any modification of the MET spectrum.
voidDMEFT_results_profiled(AnalysisDataPointers & result)
Results from DMEFT analyses after profiling over the ‘a’ parameter in the smooth cut-off of the MET spectrum.
voidDMEFT_results_cutoff(AnalysisDataPointers & result)
Results from DMEFT analyses after imposing a hard cut-off of the MET spectrum.
voidDMsimpVectorMedScalarDM_monojet_results(AnalysisDataPointers & )
voidDMsimpVectorMedMajoranaDM_monojet_results(AnalysisDataPointers & )
voidDMsimpVectorMedDiracDM_monojet_results(AnalysisDataPointers & )
voidSubGeVDM_results(AnalysisDataPointers & result)
Results for the SubGeVDM_fermion and SubGeVDM_scalar model.
voidget_DMEFT_signal_yields_dim6_operator(std::vector< double > & signal_yields, const str, const Model_analysis_info & analysis_info, double m, double O1, double O2, double lambda)
Fill the input vector with the DMEFT signal prediction for a given set of dim-6 operators.
voidget_DMEFT_signal_yields_dim7_operator(std::vector< double > & signal_yields, const str, const Model_analysis_info & analysis_info, double m, double O, double lambda)
Fill the input vector with the DMEFT signal prediction for a given dim-7 operator.
voidget_DMsimpVectorMedScalarDM_signal_yields(std::vector< double > & signal_yields, const Model_analysis_info & analysis_info, double mDM, double mMed, double gq, double gVchi)
Fill the input vector with the signal prediction for the DMsimpVectorMedScalarDM model.
voidget_DMsimpVectorMedMajoranaDM_signal_yields(std::vector< double > & signal_yields, const Model_analysis_info & analysis_info, double mDM, double mMed, double gq, double gAchi)
Fill the input vector with the signal prediction for the DMsimpVectorMedMajoranaDM model.
voidget_DMsimpVectorMedDiracDM_signal_yields(std::vector< double > & signal_yields, const Model_analysis_info & analysis_info, double mDM, double mMed, double gq, double gVchi, double gAchi)
Fill the input vector with the signal prediction for the DMsimpVectorMedDiracDM model.
voidget_SubGeVDM_scalar_signal_yields(std::vector< double > & signal_yields, const Model_analysis_info & analysis_info, double mDM, double mAp, double kappa, double gDM)
voidget_SubGeVDM_fermion_signal_yields(std::vector< double > & signal_yields, const Model_analysis_info & analysis_info, double mDM, double mAp, double kappa, double gDM)
voidget_DMsimpVectorMedVectorDM_signal_yields(std::vector< double > & signal_yields, const Model_analysis_info & analysis_info, double mDM, double mMed, double gq, double gVchi)
Fill the input vector with the signal prediction for the DMsimpVectorMedVectorDM model.
voidget_all_DMEFT_signal_yields(std::vector< double > & sr_nums, const Model_analysis_info & analysis_info, const Spectrum & spec)
Fill the input vector with the total DMEFT signal prediction for each SR in the given LHC analysis.
voidget_all_DMsimp_signal_yields(std::vector< double > & sr_nums, const Model_analysis_info & analysis_info, const Spectrum & spec, str & modelname)
Fill the input vector with the total DMsimp signal prediction for each SR in the given LHC analysis.
voidget_all_SubGeVDM_signal_yields(std::vector< double > & sr_nums, const Model_analysis_info & analysis_info, const Spectrum & spec, str & modelname)
Fill the input vector with the total SubGeV signal prediction for each SR in the given analysis.
voidsignal_modifier_function(AnalysisData & adata, double lambda, double a)
voidsignal_cutoff_function(AnalysisData & adata, double lambda)
void_gsl_target_func(const size_t, const double * a, void * fparams, double * fval)
A target function for the GSL optimiser.
voidcalc_DMEFT_profiled_LHC_nuisance_params(map_str_dbl & result)
voidInterpolatedMCInfo(MCLoopInfo & result)
voidfill_analysis_info_map(str current_analysis_name, Model_analysis_info * current_ainfo)
voidget_all_signal_yields(void(*)(std::vector< double > &, const Model_analysis_info &, const Spectrum &, str &modelname) get_all_model_signal_yields, const Spectrum & spec, std::map< str, AnalysisData > & analysis_data_map, AnalysisDataPointers & result, str & modelname)
Loop over analyses registered in the analysis_info_map.
voidDMsimp_results(AnalysisDataPointers & result)
Results from DMsimp model analyses.
voidfill_DMsimp_DiJets()
Fill the DMsimp object with the interpolation information.
doubleDiJet_search_LogLike(str searchname, double gq, double mMed, double BR_q)
Perform the actual likelihood evaluation for a given di-jet search.
doubleTotal_DiJet_search_LogLike(double mMed, double gq, double BR_q)
Loop over the di-jet analyses and calculate the most constraining likelihood.
voidDiJet_LogLike_DMsimp(double & result)
LSPget_LSP_for_LEP_limits(const Spectrum & spec)
doublelimit_LLike(double x, double x95, double sigma)
LEP limit likelihood function.
boolis_xsec_sane(const triplet< double > & xsecWithError)
LEP limit debugging function.
voidLEP207_SLHA1_convention_xsec_chi00_11(triplet< double > & result)
voidL3_Gravitino_LLike(double & result)
voidconvert_yaml_options_for_contur(std::vector< std::string > & yaml_options)
voidRivet_measurements(std::shared_ptr< std::ostringstream > & result)
voidgetActiveProcessCodes(std::vector< int > & result)
Get the list of active collider process codes.
voidgetAnalysisContainer(AnalysisContainer & result, const str & detname, const MCLoopInfo & RunMC, const xsec_container & TotalCrossSection, int iteration)
Retrieve an analysis container for a specific detector.
voidgetBuckFastATLAS(BaseDetector *& result)
Retrieve a BuckFast sim of ATLAS.
voidgetBuckFastCMS(BaseDetector *& result)
Retrieve a BuckFast sim of CMS.
voidgetBuckFastIdentity(BaseDetector *& result)
Retrieve an Identity BuckFast sim (no sim)
voidreadHepMCEvent(HepMC3::GenEvent & result, const str HepMC_filename, const MCLoopInfo & RunMC, const int iteration, void(*)() halt)
A nested function that reads in HepMC event files.
voidgetHepMCEvent(HepMC3::GenEvent & result)
A nested function that reads in HepMC event files.
voidread_jet_collections_settings(const Options & runOptions, std::vector< jet_collection_settings > & all_jet_collection_settings, str & jetcollection_taus)
voidgetHepMCEvent_HEPUtils(HEPUtils::Event & result)
A nested function that reads in HepMC event files and converts them to HEPUtils::Event format.
voidconvertHepMCEvent_HEPUtils(HEPUtils::Event & result)
voidgetLHEvent_HEPUtils(HEPUtils::Event & result)
A nested function that reads in Les Houches Event files and converts them to HEPUtils::Event format.
std::pair< double, double >convert_xsecs_to_fb(double input_xsec, double input_xsec_uncert, str input_unit, bool input_fractional_uncert)
voidgetPIDPairCrossSectionsMap_prospino(map_PID_pair_PID_pair_xsec & result)
PID_pair_xsec_containersilly_pid_xsec_constructor(PID_pair pid_pair, double xsec_val)
Test functions for provding PIDPairCrossSectionsMap (cross-sections in fb)
voidgetPIDPairCrossSectionsMap_testing(map_PID_pair_PID_pair_xsec & result)
voidgetProcessCrossSectionsMap(map_int_process_xsec & result)
Get a map between Pythia process codes and cross-sections.
voidgetEvGenCrossSection(MC_xsec_container & result)
Compute a cross-section from Monte Carlo.
voidgetEvGenCrossSection_as_base(xsec_container & result)
Return MC_xsec_container as the base xsec_container.
voidgetNLLFastCrossSection(xsec_container & result)
Get a cross-section from NLL-FAST.
boolcheckOptions_getYAMLCrossSection(const Options & runOptions, const str calling_function, std::pair< str, str > & xsec_pnames, str & input_unit, bool & input_fractional_uncert, str & errmsg)
A helper function to check the YAML options for getYAMLCrossSection and getYAMLCrossSection_SLHA.
voidgetYAMLCrossSection(xsec_container & result)
A function that reads the total cross-section from the input file, but builds up the number of events from the event loop.
voidgetYAMLCrossSection_SLHA(xsec_container & result)
A function that reads a list of (SLHA file, total cross-section) pairs from the input YAML file.
voidgetYAMLCrossSection_param(xsec_container & result)
voidgetTotalCrossSectionAsMap(map_str_dbl & result)
Get cross-section info as map_str_dbl (for simple printing)
voidgetPIDPairCrossSectionsInfo(map_str_dbl & result)
Output PID pair cross-sections as a str-dbl map, for easy printing.
voiddoCrossSectionConsistencyCheck(bool & result)
voidcalc_LHC_signals(map_str_dbl & result)
Loop over all analyses and fill a map of predicted counts.
void_gsl_calc_Analysis_MinusLogLike(const size_t n, const double * unit_nuisances_dbl, void * fixedparamspack, double * fval)
void_gsl_calc_Analysis_MinusLogLikeGrad(const size_t n, const double * unit_nuisances_dbl, void * fixedparamspack, double * fgrad)
Loglike gradient-function wrapper to provide the signature for GSL multimin.
void_gsl_calc_Analysis_MinusLogLikeAndGrad(const size_t n, const double * unit_nuisances_dbl, void * fixedparamspack, double * fval, double * fgrad)
std::vector< double >_gsl_mkpackedarray(const Eigen::ArrayXd & n_preds, const Eigen::ArrayXd & n_obss, const Eigen::ArrayXd & sqrtevals, const Eigen::MatrixXd & evecs)
doubleprofile_loglike_cov(const Eigen::ArrayXd & n_preds, const Eigen::ArrayXd & n_obss, const Eigen::ArrayXd & sqrtevals, const Eigen::MatrixXd & evecs)
doublemarg_loglike_nulike1sr(const Eigen::ArrayXd & n_preds, const Eigen::ArrayXd & n_obss, const Eigen::ArrayXd & sqrtevals)
doublemarg_loglike_cov(const Eigen::ArrayXd & n_preds, const Eigen::ArrayXd & n_obss, const Eigen::ArrayXd & sqrtevals, const Eigen::MatrixXd & evecs)
voidfill_analysis_loglikes_full(const AnalysisData & ana_data, AnalysisLogLikes & ana_loglikes, bool()(const str &) FullLikes_FileExists, int()(const str &, const str &) FullLikes_ReadIn, double(*)(std::map< str, double > &, const str &) FullLikes_Evaluate, const std::string alt_loglike_key ="")
voidcalc_LHC_LogLikes_common(map_str_AnalysisLogLikes & result, bool use_fulllikes, AnalysisDataPointers & ana, const Options & runOptions, bool skip_calc, bool()(const str &) FullLikes_FileExists, int()(const str &, const str &) FullLikes_ReadIn, double(*)(std::map< str, double > &, const str &) FullLikes_Evaluate)
Loop over all analyses and fill a map of AnalysisLogLikes objects.
voidcalc_LHC_LogLikes_full(map_str_AnalysisLogLikes & result)
Loop over all analyses and fill a map of AnalysisLogLikes objects.
voidcalc_LHC_LogLikes(map_str_AnalysisLogLikes & result)
Loop over all analyses and fill a map of AnalysisLogLikes objectss.
voidget_LHC_LogLike_per_analysis(map_str_dbl & result)
Extract the combined log likelihood for each analysis.
voidget_LHC_LogLike_per_SR(map_str_dbl & result)
Extract the log likelihood for each SR.
voidget_LHC_LogLike_SR_labels(map_str_str & result)
Extract the labels for the SRs used in the analysis loglikes.
voidget_LHC_LogLike_SR_indices(map_str_dbl & result)
voidcalc_combined_LHC_LogLike(double & result)
Compute the total likelihood combining all analyses.
voidcalc_LHC_LogLike_scan_guide(double & result)
voidget_HEPUtils_event(const LHEF::Reader & lhe, Event & evt, double jet_pt_min, std::vector< jet_collection_settings > all_jet_collection_settings)
Extract an LHE event as a HEPUtils::Event.
voidgetNextSLHAFileNameAndContent(pair_str_SLHAstruct & result)
voidgetAndReplaceSLHAContent(pair_str_SLHAstruct & result)
voidgetSLHAFileElements(map_str_dbl & result)
voidgetSLHA1Spectrum(SLHAstruct & result)
voidgetSLHA2Spectrum(SLHAstruct & result)
voidcalc_susy_spectrum_scan_guide(double & result)
voidget_susy_spectrum_validation_loglike(double & result)
voidgetActiveProcessCodeToPIDPairsMap(multimap_int_PID_pair & result)
voidgetActivePIDPairs(vec_PID_pair & result)
Get a list of all the PID pairs related to active process codes.
voidrunAnalyses(AnalysisDataPointers & result, const str & , const MCLoopInfo & RunMC, const AnalysisContainer & Container, const HEPUtils::Event & SmearedEvent, int iteration, void(*)() wrapup)
Run all the analyses in a given container.
voidsmearEvent(HEPUtils::Event & result, const HEPUtils::Event & HardScatteringEvent, const BaseDetector & detector, const MCLoopInfo & RunMC, const int iteration, const str & detname)
Smear an event.

Attributes

Name
const multimap_int_PID_pairall_process_codes_to_PID_pairs
constexpr doublesqrtsGeV
const doubleGeV
Unit conversions (multiply to construct in standard units, divide to decode to that unit)
const doubleMeV
const doubleTeV
std::map< str, BaBar_single_photon_analysis_info >SubGeVDM_BaBar_single_photon_analysis_info
A Map between search name and the analysis info needed.
std::map< str, Model_analysis_info >analysis_info_map
std::map< str, Dijet_analysis_info >DMsimp_dijet_analysis_info
A Map between search name and the analysis info needed.
std::vector< str >dijet_searches
The di_jet searches that are to be used.

Types Documentation

enum specialIterations

EnumeratorValueDescription
BASE_INIT-1
COLLIDER_INIT-2
COLLIDER_INIT_OMP-3
XSEC_CALCULATION-4
START_SUBPROCESS-5
COLLECT_CONVERGENCE_DATA-6
CHECK_CONVERGENCE-7
END_SUBPROCESS-8
COLLIDER_FINALIZE-9
BASE_FINALIZE-10

Special iteration labels for the loop controlled by operateLHCLoop.

typedef AnalysisDataPointers

typedef std::vector<AnalysisData*> Gambit::ColliderBit::AnalysisDataPointers;

Container for data from multiple analyses and SRs.

typedef map_str_AnalysisLogLikes

typedef std::map<std::string,AnalysisLogLikes> Gambit::ColliderBit::map_str_AnalysisLogLikes;

Typedef for a string-to-AnalysisLogLikes map.

typedef AnalysisContainers

typedef std::vector<AnalysisContainer> Gambit::ColliderBit::AnalysisContainers;

Container for multiple analysis containers.

typedef ms

typedef std::chrono::milliseconds Gambit::ColliderBit::ms;

typedef steady_clock

typedef std::chrono::steady_clock Gambit::ColliderBit::steady_clock;

typedef tp

typedef std::chrono::steady_clock::time_point Gambit::ColliderBit::tp;

typedef timer_map_type

typedef std::map<std::string,double> Gambit::ColliderBit::timer_map_type;

typedef pair_str_SLHAstruct

typedef std::pair<std::string,SLHAstruct> Gambit::ColliderBit::pair_str_SLHAstruct;

Typedef for a str-SLHAstruct pair, to pass around SLHA filenames + content.

typedef vec_iipair

typedef std::vector<std::pair<int,int> > Gambit::ColliderBit::vec_iipair;

Typedefs related to cross-sections.

typedef vec_PID_pair

typedef std::vector<PID_pair> Gambit::ColliderBit::vec_PID_pair;

typedef multimap_int_iipair

typedef std::multimap<int,std::pair<int,int> > Gambit::ColliderBit::multimap_int_iipair;

typedef multimap_int_PID_pair

typedef std::multimap<int,PID_pair> Gambit::ColliderBit::multimap_int_PID_pair;

typedef multimap_PID_pair_int

typedef std::multimap<PID_pair,int> Gambit::ColliderBit::multimap_PID_pair_int;

typedef map_int_xsec

typedef std::map<int,xsec_container> Gambit::ColliderBit::map_int_xsec;

typedef map_int_process_xsec

typedef std::map<int,process_xsec_container> Gambit::ColliderBit::map_int_process_xsec;

typedef map_iipair_PID_pair_xsec

typedef std::map<std::pair<int,int>,PID_pair_xsec_container> Gambit::ColliderBit::map_iipair_PID_pair_xsec;

typedef map_PID_pair_PID_pair_xsec

typedef std::map<PID_pair,PID_pair_xsec_container> Gambit::ColliderBit::map_PID_pair_PID_pair_xsec;

typedef HEPUtils_Event

typedef HEPUtils::Event Gambit::ColliderBit::HEPUtils_Event;

Typedef for a std::function that sets the weight for the input HEPUtils::Event.

typedef EventWeighterFunctionType

typedef std::function<void(HEPUtils_Event&, const BaseCollider*)> Gambit::ColliderBit::EventWeighterFunctionType;

typedef MixMatrix

typedef std::vector< std::vector<double> > Gambit::ColliderBit::MixMatrix;

typedef data_type

typedef std::vector<std::vector<double> > Gambit::ColliderBit::data_type;

typedef ParticlePtrs

typedef std::vector<const HEPUtils::Particle*> Gambit::ColliderBit::ParticlePtrs;

Typedef for a vector of Particle pointers.

typedef JetPtrs

typedef std::vector<const HEPUtils::Jet*> Gambit::ColliderBit::JetPtrs;

Typedef for a vector of Jet pointers.

Functions Documentation

function mk_pseudojet

template <typename Vec4T >
inline FJNS::PseudoJet mk_pseudojet(
    const Vec4T & p
)

function mk_p4

template <typename Vec4T >
inline HEPUtils::P4 mk_p4(
    const Vec4T & p
)

function fromBottom

template <typename EventT >
inline bool fromBottom(
    int n,
    const EventT & evt
)

Todo: Rewrite using the Pythia > 8.176 particle-based methods

TodoWhat about partonic decays?

function fromTau

template <typename EventT >
inline bool fromTau(
    int n,
    const EventT & evt
)

Todo: Rewrite using the Pythia > 8.176 particle-based methods

function fromHadron

template <typename EventT >
inline bool fromHadron(
    int n,
    const EventT & evt
)

Todo: Rewrite using the Pythia > 8.176 particle-based methods

function isFinalB

template <typename EventT >
inline bool isFinalB(
    int n,
    const EventT & evt
)

function isFinalTau

template <typename EventT >
inline bool isFinalTau(
    int n,
    const EventT & evt
)

function isParton

template <typename EventT >
inline bool isParton(
    int n,
    const EventT & evt
)

function isFinalParton

template <typename EventT >
inline bool isFinalParton(
    int n,
    const EventT & evt
)

function isFinalPhoton

template <typename EventT >
inline bool isFinalPhoton(
    int n,
    const EventT & evt
)

function isFinalLepton

template <typename EventT >
inline bool isFinalLepton(
    int n,
    const EventT & evt
)

function get_sigma_ee_ll

void get_sigma_ee_ll(
    triplet< double > & result,
    const double sqrts,
    const int generation,
    const int l_chirality,
    const int lbar_chirality,
    const double gtol,
    const double ftol,
    const bool gpt_error,
    const bool fpt_error,
    const Spectrum & spec,
    const double gammaZ,
    const bool l_are_gauge_es
)

High-level cross section routines.

Retrieve the production cross-section at an e+e- collider for slepton pairs. If l_are_gauge_es = T, then l(bar)_chirality = 1 => (anti-)left-type slepton = 2 => (anti-)right-type slepton If l_are_gauge_es = F, then l(bar)_chirality = 1 => (anti-)slepton is lightest family state = 2 => (anti-)slepton is heaviest family state

Retrieve the production cross-section at an e+e- collider for slepton pairs. If l_are_gauge_es = T, then l(bar)_chirality = 1 => (anti-)left-type slepton = 2 => (anti-)right-type slepton If l_are_gauge_es = F, then l(bar)_chirality = 1 => (anti-)slepton is lightest family state = 2 => (anti-)slepton is heaviest family state

function get_sigma_ee_chi00

void get_sigma_ee_chi00(
    triplet< double > & result,
    const double sqrts,
    const int chi_first,
    const int chi_second,
    const double tol,
    const bool pt_error,
    const Spectrum & spec,
    const double gammaZ
)

Retrieve the production cross-section at an e+e- collider for neutralino pairs.

function get_sigma_ee_chipm

void get_sigma_ee_chipm(
    triplet< double > & result,
    const double sqrts,
    const int chi_plus,
    const int chi_minus,
    const double tol,
    const bool pt_error,
    const Spectrum & spec,
    const double gammaZ
)

Retrieve the production cross-section at an e+e- collider for chargino pairs.

function xsec_sleislej

double xsec_sleislej(
    int pid1,
    int pid2,
    double sqrts,
    double m1,
    double m2,
    MixMatrix F,
    MixMatrix N,
    const double mN[4],
    double alpha,
    double mZ,
    double gZ,
    double sin2thetaW,
    bool warn_on_CP_violating_masses =true
)

Low-level cross section routines.

Cross section [pb] for ( e^+e^- -> \tilde l_i \tilde l_j^* ) To use, call SLHA2BFM first on SLHA mixing matrices constructed as a vector of vectors

Cross section [pb] for (e^+e^- -> \tilde l_i \tilde l_j^*) To use, call SLHA2BFM first on SLHA mixing matrices constructed as a vector of vectors

function xsec_neuineuj

double xsec_neuineuj(
    int pid1,
    int pid2,
    double sqrts,
    double m1,
    double m2,
    MixMatrix N,
    const double mS[2],
    double tanb,
    double alpha,
    double mZ,
    double gZ,
    double sin2thetaW
)

Cross section [pb] for ( e^+e^- -> \tilde\chi^0_i \tilde\chi^0_j ) Masses mi and mj for the neutralinos are signed. mS are the selectron masses (left = 0, right = 1). Warning! BFM uses inverted (\tan\beta)! Use tanb = 1 / tanb in converting from SLHA.

Cross section [pb] for (e^+e^- -> \tilde\chi^0_i \tilde\chi^0_j) Masses mi and mj for the neutralinos are signed. mS are the selectron masses (left = 0, right = 1). Warning! BFM uses inverted (\tan\beta)! Use tanb = 1 / tanb in converting from SLHA.

function xsec_chaichaj

double xsec_chaichaj(
    int pid1,
    int pid2,
    double sqrts,
    double m1,
    double m2,
    MixMatrix V,
    MixMatrix U,
    double msn,
    double alpha,
    double mZ,
    double gZ,
    double sin2thetaW
)

Cross section [pb] for ( e^+e^- -> \tilde\chi^+_i \tilde\chi^-_j ) Masses mi and mj for the charginos are signed. msn is electron sneutrino mass.

Cross section [pb] for (e^+e^- -> \tilde\chi^+_i \tilde\chi^-_j) Masses mi and mj for the charginos are signed. msn is electron sneutrino mass.

function SLHA2BFM_NN

void SLHA2BFM_NN(
    MixMatrix & NN,
    double tanb,
    double sin2thetaW
)

Functions to convert mass matrices between SLHA and BFM conventions ////////////////////////////////////////////////////////////////////.

Conversion between SLHA and BFM conventions. (\tan\beta) is as per SLHA.

Converts a neutralino mixing matrix in SLHA conventions to BFM conventions, (\tan\beta) is as defined in SLHA

function SLHA2BFM_VV

void SLHA2BFM_VV(
    MixMatrix & VV
)

Converts the chargino mixing matrix V in SLHA conventions to BFM conventions.

function BFM2SLHA_NN

void BFM2SLHA_NN(
    MixMatrix & NN,
    double tanb,
    double sin2thetaW
)

Converts a neutralino mixing matrix in BFM conventions to SLHA conventions, (\tan\beta) is as defined in SLHA.

function BFM2SLHA_VV

void BFM2SLHA_VV(
    MixMatrix & VV
)

Converts the chargino mixing matrix V in BFM conventions to SLHA conventions.

function multiply

MixMatrix multiply(
    MixMatrix A,
    MixMatrix B
)

Helper function to multiply matrices.

function transpose

MixMatrix transpose(
    MixMatrix A
)

Helper function to find matrix transpose.

function print

void print(
    MixMatrix A
)

Helper function to print a matrix.

function operator+

inline P2 operator+(
    const P2 & a,
    const P2 & b
)

function operator-

inline P2 operator-(
    const P2 & a,
    const P2 & b
)

function operator*

inline P2 operator*(
    const P2 & a,
    double f
)

function operator*

inline P2 operator*(
    double f,
    const P2 & a
)

function operator/

inline P2 operator/(
    const P2 & a,
    double f
)

function to_str

inline std::string to_str(
    const P2 & p2
)

Make a string representation of the vector.

function operator«

inline std::ostream & operator<<(
    std::ostream & ostr,
    const P2 & p2
)

Write a string representation of the vector to the provided stream.

function to_str

inline std::string to_str(
    const LineSegment & lineseg
)

Make a string representation of the LineSegment.

function operator«

inline std::ostream & operator<<(
    std::ostream & ostr,
    const LineSegment & lineseg
)

Write a string representation of the vector to the provided stream.

function amIaJet

inline bool amIaJet(
    const HEPUtils::Jet * jet
)

Identifier for jets true.

function amIaBJet

inline bool amIaBJet(
    const HEPUtils::Jet * jet
)

Indentifier for b-jets true.

function amIaJet

inline bool amIaJet(
    const HEPUtils::Particle * part
)

Identifier for jets false.

function amIaBJet

inline bool amIaBJet(
    const HEPUtils::Particle * part
)

Identifier for b-jets true.

function amIanElectron

inline bool amIanElectron(
    const HEPUtils::Particle * part
)

Identifier for electrons.

function amIaMuon

inline bool amIaMuon(
    const HEPUtils::Particle * part
)

Identifier for muons.

function amIaTau

inline bool amIaTau(
    const HEPUtils::Particle * part
)

Identifier for taus.

function iremoveerase

template <typename CONTAINER ,
typename RMFN >
inline void iremoveerase(
    CONTAINER & c,
    const RMFN & fn
)

Convenience combination of remove_if and erase.

function ifilter_reject

inline void ifilter_reject(
    ParticlePtrs & particles,
    std::function< bool(const Particle *)> rejfn,
    bool do_delete =true
)

In-place filter a supplied particle vector by rejecting those which fail a supplied cut.

function ifilter_select

inline void ifilter_select(
    ParticlePtrs & particles,
    std::function< bool(const Particle *)> selfn,
    bool do_delete =true
)

In-place filter a supplied particle vector by keeping those which pass a supplied cut.

function filter_reject

inline ParticlePtrs filter_reject(
    const ParticlePtrs & particles,
    std::function< bool(const Particle *)> rejfn,
    bool do_delete =true
)

Todo: Optimise by only copying those which are selected (filter_select is canonical)

Filter a supplied particle vector by rejecting those which fail a supplied cut

function filter_select

inline ParticlePtrs filter_select(
    const ParticlePtrs & particles,
    std::function< bool(const Particle *)> selfn,
    bool do_delete =true
)

Filter a supplied particle vector by keeping those which pass a supplied cut.

function ifilter_reject

inline void ifilter_reject(
    JetPtrs & jets,
    std::function< bool(const Jet *)> rejfn,
    bool do_delete =true
)

In-place filter a supplied jet vector by rejecting those which fail a supplied cut.

function ifilter_select

inline void ifilter_select(
    JetPtrs & jets,
    std::function< bool(const Jet *)> selfn,
    bool do_delete =true
)

In-place filter a supplied jet vector by keeping those which pass a supplied cut.

function filter_reject

inline JetPtrs filter_reject(
    const JetPtrs & jets,
    std::function< bool(const Jet *)> rejfn,
    bool do_delete =true
)

Todo: Optimise by only copying those which are selected (filter_select is canonical)

Filter a supplied particle vector by rejecting those which fail a supplied cut

function filter_select

inline JetPtrs filter_select(
    const JetPtrs & jets,
    std::function< bool(const Jet *)> selfn,
    bool do_delete =true
)

Filter a supplied particle vector by keeping those which pass a supplied cut.

function random_bool

bool random_bool(
    double eff
)

Return a random true/false at a success rate given by a number.

TodoHandle out-of-range eff values

TodoHandle out-of-range eff values

function random_bool

inline bool random_bool(
    const HEPUtils::BinnedFn1D< double > & effmap,
    double x
)

Return a random true/false at a success rate given by a 1D efficiency map.

function random_bool

inline bool random_bool(
    const HEPUtils::BinnedFn2D< double > & effmap,
    double x,
    double y
)

Return a random true/false at a success rate given by a 2D efficiency map.

function filtereff

void filtereff(
    std::vector< const HEPUtils::Particle * > & particles,
    double eff,
    bool do_delete =false
)

Utility function for filtering a supplied particle vector by sampling wrt an efficiency scalar.

function filtereff

void filtereff(
    std::vector< const HEPUtils::Particle * > & particles,
    std::function< double(const HEPUtils::Particle *)> eff_fn,
    bool do_delete =false
)

Utility function for filtering a supplied particle vector by sampling an efficiency returned by a provided function object.

Utility function for filtering a supplied particle vector by sampling wrt a binned 1D efficiency map in pT.

function filtereff_pt

void filtereff_pt(
    std::vector< const HEPUtils::Particle * > & particles,
    const HEPUtils::BinnedFn1D< double > & eff_pt,
    bool do_delete =false
)

Utility function for filtering a supplied particle vector by sampling wrt a binned 1D efficiency map in pT.

function filtereff_etapt

void filtereff_etapt(
    std::vector< const HEPUtils::Particle * > & particles,
    const HEPUtils::BinnedFn2D< double > & eff_etapt,
    bool do_delete =false
)

Utility function for filtering a supplied particle vector by sampling wrt a binned 2D efficiency map in |eta| and pT.

function has_tag

inline bool has_tag(
    const HEPUtils::BinnedFn2D< double > & effmap,
    double eta,
    double pt
)

Todo: Also need 1D? Sampling in what variable?

Randomly get a tag result (can be anything) from a 2D |eta|-pT efficiency map

function generateBTagsMap

inline std::map< const HEPUtils::Jet *, bool > generateBTagsMap(
    const std::vector< const HEPUtils::Jet * > & jets,
    double bTagEff,
    double cMissTagEff,
    double otherMissTagEff,
    double pTmin =0.,
    double absEtaMax =DBL_MAX
)

Return a map<Jet*,bool> containing a generated b-tag for every jet in the input vector.

function binIndex

template <typename NUM1 ,
typename NUM2 >
inline size_t binIndex(
    NUM1 val,
    const std::vector< NUM2 > & binedges,
    bool allow_overflow =false
)

< Below/out of histo range

< Above/out of histo range

function mk_bin_values

inline std::vector< double > mk_bin_values(
    const std::vector< double > & binEdgeValues
)

Make a vector of central bin values from a vector of bin edge values using linear interpolation.

function makeBinValues

inline std::vector< double > makeBinValues(
    const std::vector< double > & binEdgeValues
)

Alias.

function get_jets

template <typename MOM >
inline std::vector< std::shared_ptr< HEPUtils::Jet > > get_jets(
    const std::vector< MOM * > & moms,
    double R,
    double ptmin =0 *GeV,
    FJNS::JetAlgorithm alg =FJNS::antikt_algorithm
)

Run jet clustering from any P4-compatible momentum type.

function object_in_cone

inline bool object_in_cone(
    const HEPUtils::Event & e,
    std::string jetcollection,
    const HEPUtils::P4 & p4,
    double ptmin,
    double rmax,
    double rmin =0.05
)

Check if there’s a physics object above ptmin in an annulus rmin..rmax around the given four-momentum p4.

function removeOverlap

template <typename MOMPTRS1 ,
typename MOMPTRS2 >
void removeOverlap(
    MOMPTRS1 & momstofilter,
    const MOMPTRS2 & momstocmp,
    double deltaRMax,
    bool use_rapidity =false,
    double pTmax =DBL_MAX,
    double btageff =0
)

Overlap removal – discard from first list if within deltaRMax of any from the second list Optional arguments:

  • use_rapidity = use rapidity instead of psedurapidity to compute deltaR. Defaults to False
  • pTmax = only discard from first list with pT < pTmax. Defaults to DBL_MAX
  • btageff = do not discard jets that have a b-tagging efficiency lower than btageff. Defaults to 0

function removeOverlap

template <typename MOMPTRS1 ,
typename MOMPTRS2 >
void removeOverlap(
    MOMPTRS1 & momstofilter,
    const MOMPTRS2 & momstocmp,
    double(*)(const double) deltaRMax,
    bool use_rapidity =false,
    double pTmax =DBL_MAX,
    double btageff =0
)

Overlap removal – discard from first list if within deltaRmax of any from the second list. Overload of previous function where deltaRmax is a function of the pT of the first list Optional arguments:

  • use_rapidity = use rapidity instead of psedurapidity to compute deltaR. Defaults to False
  • pTmax = only discard from first list with pT < pTmax. Defaults to DBL_MAX
  • btageff = do not discard jets that have a b-tagging efficiency lower than btageff. Defaults to 0

function removeOverlapIfBjet

template <typename MOMPTRS1 >
void removeOverlapIfBjet(
    MOMPTRS1 & momstofilter,
    std::vector< const HEPUtils::Jet * > & jets,
    double deltaRMax,
    bool use_rapidity =false,
    double pTmax =DBL_MAX
)

Overlap removal for checking against b-jets – discard from first list if within deltaRMax of a b-jet in the second list Optional arguments:

  • use_rapidity = use rapidity instead of psedurapidity to compute deltaR. Defaults to False
  • pTmax = only discard from first list with pT < pTmax. Defaults to DBL_MAX

function all_of

template <typename CONTAINER ,
typename FN >
inline bool all_of(
    const CONTAINER & c,
    const FN & f
)

Non-iterator version of std::all_of.

function any_of

template <typename CONTAINER ,
typename FN >
inline bool any_of(
    const CONTAINER & c,
    const FN & f
)

Non-iterator version of std::any_of.

function none_of

template <typename CONTAINER ,
typename FN >
inline bool none_of(
    const CONTAINER & c,
    const FN & f
)

Non-iterator version of std::none_of.

function getSFOSpairs

std::vector< std::vector< const HEPUtils::Particle * > > getSFOSpairs(
    std::vector< const HEPUtils::Particle * > particles
)

Utility function for returning a collection of same-flavour, oppsosite-sign particle pairs.

function getOSpairs

std::vector< std::vector< const HEPUtils::Particle * > > getOSpairs(
    std::vector< const HEPUtils::Particle * > particles
)

Utility function for returning a collection of oppsosite-sign particle pairs.

function getSSpairs

std::vector< std::vector< const HEPUtils::Particle * > > getSSpairs(
    std::vector< const HEPUtils::Particle * > particles
)

Utility function for returning a collection of same-sign particle pairs.

function getBJetPairs

std::vector< std::vector< const HEPUtils::Jet * > > getBJetPairs(
    std::vector< const HEPUtils::Jet * > bjets
)

Utility function for returning a collection of b-tagged jets.

function sortBy

inline void sortBy(
    ParticlePtrs & particles,
    std::function< bool(const Particle *, const Particle *)> cmpfn
)

Particle-sorting function.

function cmpParticlesByPt

inline bool cmpParticlesByPt(
    const HEPUtils::Particle * lep1,
    const HEPUtils::Particle * lep2
)

Comparison function to give a particles sorting order decreasing by pT.

function sortByPt

inline void sortByPt(
    ParticlePtrs & particles
)

function sortBy

inline void sortBy(
    JetPtrs & jets,
    std::function< bool(const Jet *, const Jet *)> cmpfn
)

Jet-sorting function.

function cmpJetsByPt

inline bool cmpJetsByPt(
    const HEPUtils::Jet * jet1,
    const HEPUtils::Jet * jet2
)

Comparison function to give a jets sorting order decreasing by pT.

function sortByPt

inline void sortByPt(
    JetPtrs & jets
)

function sortByParentMass

inline void sortByParentMass(
    std::vector< std::vector< const Particle * > > & pairs,
    double mP
)

function uniquePairs

inline void uniquePairs(
    std::vector< std::vector< const Particle * > > & pairs
)

Remove pairs with already used leptons, assumes some order.

function countPt

inline int countPt(
    const std::vector< const Particle * > & particles,
    double pTlim
)

Count number of particles that have pT > pTlim.

function countPt

inline int countPt(
    const std::vector< const Jet * > & jets,
    double pTlim
)

Count number of jets that have pT > pTlim.

function scalarSumPt

inline double scalarSumPt(
    const std::vector< const Particle * > & particles,
    double pTlim =0.
)

Scalar sum pT of particles with pT > pTlim (default pTlim = 0)

function scalarSumPt

inline double scalarSumPt(
    const std::vector< const Jet * > & jets,
    double pTlim =0.
)

Scalar sum pT of jets.

function get_mT2

inline double get_mT2(
    const Particle * part1,
    const Particle * part2,
    P4 pTmiss,
    double mass
)

Faster way to compute stransverse mass.

function get_mT2

inline double get_mT2(
    P4 mom1,
    P4 mom2,
    P4 pTmiss,
    double mass
)

Faster way to compute stransverse mass, from the momenta.

function get_mT

inline double get_mT(
    const Particle * part,
    P4 pTmiss
)

function get_mT

inline double get_mT(
    P4 mom,
    P4 pTmiss
)

function get_mT

inline double get_mT(
    const Particle * part1,
    const Particle * part2,
    P4 pTmiss
)

function get_mT

inline double get_mT(
    const Particle * part1,
    const Particle * part2,
    const Particle * part3,
    P4 pTmiss
)

function sameSign

inline bool sameSign(
    const Particle * P1,
    const Particle * P2
)

Have two particles the same sign?

function oppositeSign

inline bool oppositeSign(
    const Particle * P1,
    const Particle * P2
)

Have two particles the opposite sign?

function LEP208_SLHA1_convention_xsec_selselbar

void LEP208_SLHA1_convention_xsec_selselbar(
    triplet< double > & result
)

ee –> selectron pair production cross-sections at 208 GeV

function LEP208_SLHA1_convention_xsec_selserbar

void LEP208_SLHA1_convention_xsec_selserbar(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_serserbar

void LEP208_SLHA1_convention_xsec_serserbar(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_serselbar

void LEP208_SLHA1_convention_xsec_serselbar(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_se1se1bar

void LEP208_SLHA1_convention_xsec_se1se1bar(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_se1se2bar

void LEP208_SLHA1_convention_xsec_se1se2bar(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_se2se2bar

void LEP208_SLHA1_convention_xsec_se2se2bar(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_se2se1bar

void LEP208_SLHA1_convention_xsec_se2se1bar(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_smulsmulbar

void LEP208_SLHA1_convention_xsec_smulsmulbar(
    triplet< double > & result
)

ee –> smuon pair production cross-sections at 208 GeV

function LEP208_SLHA1_convention_xsec_smulsmurbar

void LEP208_SLHA1_convention_xsec_smulsmurbar(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_smursmurbar

void LEP208_SLHA1_convention_xsec_smursmurbar(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_smursmulbar

void LEP208_SLHA1_convention_xsec_smursmulbar(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_smu1smu1bar

void LEP208_SLHA1_convention_xsec_smu1smu1bar(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_smu1smu2bar

void LEP208_SLHA1_convention_xsec_smu1smu2bar(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_smu2smu2bar

void LEP208_SLHA1_convention_xsec_smu2smu2bar(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_smu2smu1bar

void LEP208_SLHA1_convention_xsec_smu2smu1bar(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_staulstaulbar

void LEP208_SLHA1_convention_xsec_staulstaulbar(
    triplet< double > & result
)

ee –> stau pair production cross-sections at 208 GeV

function LEP208_SLHA1_convention_xsec_staulstaurbar

void LEP208_SLHA1_convention_xsec_staulstaurbar(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_staurstaurbar

void LEP208_SLHA1_convention_xsec_staurstaurbar(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_staurstaulbar

void LEP208_SLHA1_convention_xsec_staurstaulbar(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_stau1stau1bar

void LEP208_SLHA1_convention_xsec_stau1stau1bar(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_stau1stau2bar

void LEP208_SLHA1_convention_xsec_stau1stau2bar(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_stau2stau2bar

void LEP208_SLHA1_convention_xsec_stau2stau2bar(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_stau2stau1bar

void LEP208_SLHA1_convention_xsec_stau2stau1bar(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_chi00_11

void LEP208_SLHA1_convention_xsec_chi00_11(
    triplet< double > & result
)

ee –> neutralino pair production cross-sections at 208 GeV

function LEP208_SLHA1_convention_xsec_chi00_12

void LEP208_SLHA1_convention_xsec_chi00_12(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_chi00_13

void LEP208_SLHA1_convention_xsec_chi00_13(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_chi00_14

void LEP208_SLHA1_convention_xsec_chi00_14(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_chi00_22

void LEP208_SLHA1_convention_xsec_chi00_22(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_chi00_23

void LEP208_SLHA1_convention_xsec_chi00_23(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_chi00_24

void LEP208_SLHA1_convention_xsec_chi00_24(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_chi00_33

void LEP208_SLHA1_convention_xsec_chi00_33(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_chi00_34

void LEP208_SLHA1_convention_xsec_chi00_34(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_chi00_44

void LEP208_SLHA1_convention_xsec_chi00_44(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_chipm_11

void LEP208_SLHA1_convention_xsec_chipm_11(
    triplet< double > & result
)

ee –> chargino pair production cross-sections at 208 GeV

function LEP208_SLHA1_convention_xsec_chipm_12

void LEP208_SLHA1_convention_xsec_chipm_12(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_chipm_22

void LEP208_SLHA1_convention_xsec_chipm_22(
    triplet< double > & result
)

function LEP208_SLHA1_convention_xsec_chipm_21

void LEP208_SLHA1_convention_xsec_chipm_21(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_selselbar

void LEP205_SLHA1_convention_xsec_selselbar(
    triplet< double > & result
)

ee –> selectron pair production cross-sections at 205 GeV

function LEP205_SLHA1_convention_xsec_selserbar

void LEP205_SLHA1_convention_xsec_selserbar(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_serserbar

void LEP205_SLHA1_convention_xsec_serserbar(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_serselbar

void LEP205_SLHA1_convention_xsec_serselbar(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_se1se1bar

void LEP205_SLHA1_convention_xsec_se1se1bar(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_se1se2bar

void LEP205_SLHA1_convention_xsec_se1se2bar(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_se2se2bar

void LEP205_SLHA1_convention_xsec_se2se2bar(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_se2se1bar

void LEP205_SLHA1_convention_xsec_se2se1bar(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_smulsmulbar

void LEP205_SLHA1_convention_xsec_smulsmulbar(
    triplet< double > & result
)

ee –> smuon pair production cross-sections at 205 GeV

function LEP205_SLHA1_convention_xsec_smulsmurbar

void LEP205_SLHA1_convention_xsec_smulsmurbar(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_smursmurbar

void LEP205_SLHA1_convention_xsec_smursmurbar(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_smursmulbar

void LEP205_SLHA1_convention_xsec_smursmulbar(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_smu1smu1bar

void LEP205_SLHA1_convention_xsec_smu1smu1bar(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_smu1smu2bar

void LEP205_SLHA1_convention_xsec_smu1smu2bar(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_smu2smu2bar

void LEP205_SLHA1_convention_xsec_smu2smu2bar(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_smu2smu1bar

void LEP205_SLHA1_convention_xsec_smu2smu1bar(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_staulstaulbar

void LEP205_SLHA1_convention_xsec_staulstaulbar(
    triplet< double > & result
)

ee –> stau pair production cross-sections at 205 GeV

function LEP205_SLHA1_convention_xsec_staulstaurbar

void LEP205_SLHA1_convention_xsec_staulstaurbar(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_staurstaurbar

void LEP205_SLHA1_convention_xsec_staurstaurbar(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_staurstaulbar

void LEP205_SLHA1_convention_xsec_staurstaulbar(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_stau1stau1bar

void LEP205_SLHA1_convention_xsec_stau1stau1bar(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_stau1stau2bar

void LEP205_SLHA1_convention_xsec_stau1stau2bar(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_stau2stau2bar

void LEP205_SLHA1_convention_xsec_stau2stau2bar(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_stau2stau1bar

void LEP205_SLHA1_convention_xsec_stau2stau1bar(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_chi00_11

void LEP205_SLHA1_convention_xsec_chi00_11(
    triplet< double > & result
)

ee –> neutralino pair production cross-sections at 205 GeV

function LEP205_SLHA1_convention_xsec_chi00_12

void LEP205_SLHA1_convention_xsec_chi00_12(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_chi00_13

void LEP205_SLHA1_convention_xsec_chi00_13(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_chi00_14

void LEP205_SLHA1_convention_xsec_chi00_14(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_chi00_22

void LEP205_SLHA1_convention_xsec_chi00_22(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_chi00_23

void LEP205_SLHA1_convention_xsec_chi00_23(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_chi00_24

void LEP205_SLHA1_convention_xsec_chi00_24(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_chi00_33

void LEP205_SLHA1_convention_xsec_chi00_33(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_chi00_34

void LEP205_SLHA1_convention_xsec_chi00_34(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_chi00_44

void LEP205_SLHA1_convention_xsec_chi00_44(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_chipm_11

void LEP205_SLHA1_convention_xsec_chipm_11(
    triplet< double > & result
)

ee –> chargino pair production cross-sections at 205 GeV

function LEP205_SLHA1_convention_xsec_chipm_12

void LEP205_SLHA1_convention_xsec_chipm_12(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_chipm_22

void LEP205_SLHA1_convention_xsec_chipm_22(
    triplet< double > & result
)

function LEP205_SLHA1_convention_xsec_chipm_21

void LEP205_SLHA1_convention_xsec_chipm_21(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_selselbar

void LEP188_SLHA1_convention_xsec_selselbar(
    triplet< double > & result
)

ee –> selectron pair production cross-sections at 188.6 GeV

function LEP188_SLHA1_convention_xsec_selserbar

void LEP188_SLHA1_convention_xsec_selserbar(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_serserbar

void LEP188_SLHA1_convention_xsec_serserbar(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_serselbar

void LEP188_SLHA1_convention_xsec_serselbar(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_se1se1bar

void LEP188_SLHA1_convention_xsec_se1se1bar(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_se1se2bar

void LEP188_SLHA1_convention_xsec_se1se2bar(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_se2se2bar

void LEP188_SLHA1_convention_xsec_se2se2bar(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_se2se1bar

void LEP188_SLHA1_convention_xsec_se2se1bar(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_smulsmulbar

void LEP188_SLHA1_convention_xsec_smulsmulbar(
    triplet< double > & result
)

ee –> smuon pair production cross-sections at 188.6 GeV

function LEP188_SLHA1_convention_xsec_smulsmurbar

void LEP188_SLHA1_convention_xsec_smulsmurbar(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_smursmurbar

void LEP188_SLHA1_convention_xsec_smursmurbar(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_smursmulbar

void LEP188_SLHA1_convention_xsec_smursmulbar(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_smu1smu1bar

void LEP188_SLHA1_convention_xsec_smu1smu1bar(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_smu1smu2bar

void LEP188_SLHA1_convention_xsec_smu1smu2bar(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_smu2smu2bar

void LEP188_SLHA1_convention_xsec_smu2smu2bar(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_smu2smu1bar

void LEP188_SLHA1_convention_xsec_smu2smu1bar(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_staulstaulbar

void LEP188_SLHA1_convention_xsec_staulstaulbar(
    triplet< double > & result
)

ee –> stau pair production cross-sections at 188.6 GeV

function LEP188_SLHA1_convention_xsec_staulstaurbar

void LEP188_SLHA1_convention_xsec_staulstaurbar(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_staurstaurbar

void LEP188_SLHA1_convention_xsec_staurstaurbar(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_staurstaulbar

void LEP188_SLHA1_convention_xsec_staurstaulbar(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_stau1stau1bar

void LEP188_SLHA1_convention_xsec_stau1stau1bar(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_stau1stau2bar

void LEP188_SLHA1_convention_xsec_stau1stau2bar(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_stau2stau2bar

void LEP188_SLHA1_convention_xsec_stau2stau2bar(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_stau2stau1bar

void LEP188_SLHA1_convention_xsec_stau2stau1bar(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_chi00_11

void LEP188_SLHA1_convention_xsec_chi00_11(
    triplet< double > & result
)

ee –> neutralino pair production cross-sections at 188.6 GeV

function LEP188_SLHA1_convention_xsec_chi00_12

void LEP188_SLHA1_convention_xsec_chi00_12(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_chi00_13

void LEP188_SLHA1_convention_xsec_chi00_13(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_chi00_14

void LEP188_SLHA1_convention_xsec_chi00_14(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_chi00_22

void LEP188_SLHA1_convention_xsec_chi00_22(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_chi00_23

void LEP188_SLHA1_convention_xsec_chi00_23(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_chi00_24

void LEP188_SLHA1_convention_xsec_chi00_24(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_chi00_33

void LEP188_SLHA1_convention_xsec_chi00_33(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_chi00_34

void LEP188_SLHA1_convention_xsec_chi00_34(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_chi00_44

void LEP188_SLHA1_convention_xsec_chi00_44(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_chipm_11

void LEP188_SLHA1_convention_xsec_chipm_11(
    triplet< double > & result
)

ee –> chargino pair production cross-sections at 188.6 GeV

function LEP188_SLHA1_convention_xsec_chipm_12

void LEP188_SLHA1_convention_xsec_chipm_12(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_chipm_22

void LEP188_SLHA1_convention_xsec_chipm_22(
    triplet< double > & result
)

function LEP188_SLHA1_convention_xsec_chipm_21

void LEP188_SLHA1_convention_xsec_chipm_21(
    triplet< double > & result
)

function ALEPH_Selectron_Conservative_LLike

void ALEPH_Selectron_Conservative_LLike(
    double & result
)

LEP Slepton Log-Likelihoods

function ALEPH_Smuon_Conservative_LLike

void ALEPH_Smuon_Conservative_LLike(
    double & result
)

function ALEPH_Stau_Conservative_LLike

void ALEPH_Stau_Conservative_LLike(
    double & result
)

function L3_Selectron_Conservative_LLike

void L3_Selectron_Conservative_LLike(
    double & result
)

function L3_Smuon_Conservative_LLike

void L3_Smuon_Conservative_LLike(
    double & result
)

function L3_Stau_Conservative_LLike

void L3_Stau_Conservative_LLike(
    double & result
)

function L3_Neutralino_All_Channels_Conservative_LLike

void L3_Neutralino_All_Channels_Conservative_LLike(
    double & result
)

LEP Gaugino Log-Likelihoods

function L3_Neutralino_Leptonic_Conservative_LLike

void L3_Neutralino_Leptonic_Conservative_LLike(
    double & result
)

function L3_Chargino_All_Channels_Conservative_LLike

void L3_Chargino_All_Channels_Conservative_LLike(
    double & result
)

function L3_Chargino_Leptonic_Conservative_LLike

void L3_Chargino_Leptonic_Conservative_LLike(
    double & result
)

function OPAL_Chargino_Hadronic_Conservative_LLike

void OPAL_Chargino_Hadronic_Conservative_LLike(
    double & result
)

function OPAL_Chargino_SemiLeptonic_Conservative_LLike

void OPAL_Chargino_SemiLeptonic_Conservative_LLike(
    double & result
)

function OPAL_Chargino_Leptonic_Conservative_LLike

void OPAL_Chargino_Leptonic_Conservative_LLike(
    double & result
)

function OPAL_Degenerate_Chargino_Conservative_LLike

void OPAL_Degenerate_Chargino_Conservative_LLike(
    double & result
)

function OPAL_Chargino_All_Channels_Conservative_LLike

void OPAL_Chargino_All_Channels_Conservative_LLike(
    double & result
)

function OPAL_Neutralino_Hadronic_Conservative_LLike

void OPAL_Neutralino_Hadronic_Conservative_LLike(
    double & result
)

function I1

double I1(
    double s,
    double m1,
    double m2,
    double mk,
    double ml
)

Integrals for t-channel neutralino diagrams m1 and m2 are masses of final state sleptons mk and ml are neutralino masses

function I2

double I2(
    double s,
    double m1,
    double m2,
    double mk,
    double ml
)

function I3

double I3(
    double s,
    double m1,
    double m2,
    double mk
)

function mkAnalysis

Analysis * mkAnalysis(
    const str & name
)

Factory definition.

Note: The caller is responsible for deleting the returned analysis object.

Todo: Move to a separate file

Create a new analysis based on a name string

function getDetector

str getDetector(
    const str & name
)

Return the detector to be used for a given analysis name, checking that the analysis exists.

Return the detector to be used for a given analysis name (and check that the analysis exists).

function operator«

inline std::ostream & operator<<(
    std::ostream & os,
    const Cutflow & cf
)

Print a Cutflow to a stream.

function operator«

inline std::ostream & operator<<(
    std::ostream & os,
    const Cutflows & cfs
)

Print a Cutflows to a stream.

function convertParticleEvent

template <typename EventT >
void convertParticleEvent(
    const EventT & pevt,
    HEPUtils::Event & result,
    std::vector< jet_collection_settings > all_jet_collection_settings,
    str jetcollection_taus,
    double jet_pt_min
)

Todo: Overlap between jets and prompt containers: need some isolation in MET calculation

Convert a hadron-level EventT into an unsmeared HEPUtils::Event

TodoTemporarily using quark-based tagging instead – fix

TodoTemporarily using quark-based tagging instead – fix

TodoWhat’s wrong with having a W daughter? Doesn’t that just mark a final tau?

TodoMove out-of-acceptance MET contribution to BuckFast

Jet finding

Create and run a new cluster sequence for the given jet collection. The HEPUtils::Event instance (‘result’) takes ownership of the cluster sequence and a shared_ptr is returned here.

Get the resulting pseudojets

Do jet b-tagging, etc. and add to the Event TodoUse ghost tagging?

We need to remove this b-tag in the detector sim if outside the tracker acceptance!

TodoReplace with HEPUtils::any(bhadrons, [&](const auto& pb){ pj.delta_R(pb) < 0.4 })

< TodoHard-coded radius!!!

< TodoHard-coded radius!!!

< TodoHard-coded radius!!!

< TodoHard-coded radius from ATLAS-CONF-2021-022, make selectable?

< TodoHard-coded radius from ATLAS-CONF-2021-022, make selectable?

< TodoHard-coded radius from ATLAS-CONF-2021-022, make selectable?

Calculate missing momentum

function convertPartonEvent

template <typename EventT >
void convertPartonEvent(
    const EventT & pevt,
    HEPUtils::Event & result,
    std::vector< jet_collection_settings > all_jet_collection_settings,
    str jetcollection_taus,
    double jet_pt_min
)

Convert a partonic (no hadrons) EventT into an unsmeared HEPUtils::Event.

TodoWe should leave this for the detector sim / analysis to deal with

Todo_Some_ photons should be included in jets!!! Ignore for now since no FSR

TodoTodoLepton dressing

TodoOnly include hadronic tau fraction?

Jet finding

This b-tag is removed in the detector sim if outside the tracker acceptance!

Calculate missing momentum

function all_PID_pairs_to_process_codes

const multimap_PID_pair_int & all_PID_pairs_to_process_codes()

function dropHepMCEventPy8Collider

template <typename PythiaT ,
typename hepmc_writerT >
void dropHepMCEventPy8Collider(
    const PythiaT * Pythia,
    const safe_ptr< Options > & runOptions
)

Drop a HepMC file for the event.

function generateEventPy8Collider

template <typename PythiaT ,
typename EventT ,
typename hepmc_writerT >
void generateEventPy8Collider(
    EventT & pythia_event,
    const MCLoopInfo & RunMC,
    const Py8Collider< PythiaT, EventT, hepmc_writerT > & HardScatteringSim,
    const int iteration,
    void(*)() wrapup,
    const safe_ptr< Options > & runOptions
)

Generate a hard scattering event with Pythia.

function convertEventToHEPUtilsPy8Collider

template <typename PythiaT ,
typename EventT ,
typename hepmc_writerT >
void convertEventToHEPUtilsPy8Collider(
    HEPUtils::Event & event,
    const EventT & pythia_event,
    const Py8Collider< PythiaT, EventT, hepmc_writerT > & HardScatteringSim,
    const EventWeighterFunctionType & EventWeighterFunction,
    const int iteration,
    void(*)() wrapup,
    const safe_ptr< Options > & runOptions
)

Generate a hard scattering event with Pythia and convert it to HEPUtils::Event.

function convertEventToHepMCPy8Collider

template <typename PythiaT ,
typename EventT ,
typename hepmc_writerT >
void convertEventToHepMCPy8Collider(
    HepMC3::GenEvent & event,
    const EventT & pythia_event,
    const Py8Collider< PythiaT, EventT, hepmc_writerT > & HardScatteringSim,
    const int iteration,
    void(*)() wrapup
)

Generate a hard scattering event with Pythia and convert it to HepMC event.

function getPy8Collider

template <typename PythiaT ,
typename EventT ,
typename hepmc_writerT >
void getPy8Collider(
    Py8Collider< PythiaT, EventT, hepmc_writerT > & result,
    const MCLoopInfo & RunMC,
    const SLHAstruct & slha,
    const str model_suffix,
    const int iteration,
    void(*)() wrapup,
    const Options & runOptions
)

Retrieve a Pythia hard-scattering Monte Carlo simulation.

function get_HEPUtils_event

void get_HEPUtils_event(
    const LHEF::Reader & ,
    HEPUtils::Event & ,
    double ,
    std::vector< Gambit::ColliderBit::jet_collection_settings > 
)

Extract an LHE event as a HEPUtils::Event.

function makeLine

inline LineSegment makeLine(
    const P2 & pt1,
    const P2 & pt2
)

Factory function for lines.

function addInQuad

inline double addInQuad(
    const double & a,
    const double & b
)

Add two numbers in quadrature.

Todo: Use HEPUtils add_quad

function FJalgorithm_map

FJNS::JetAlgorithm FJalgorithm_map(
    std::string algorithm
)

Storage of different FastJet methods.

function FJstrategy_map

FJNS::Strategy FJstrategy_map(
    std::string strategy
)

function FJRecomScheme_map

FJNS::RecombinationScheme FJRecomScheme_map(
    std::string reco_scheme
)

function sortByPT13

bool sortByPT13(
    const HEPUtils::Jet * jet1,
    const HEPUtils::Jet * jet2
)

function sortByPT13_sharedptr

bool sortByPT13_sharedptr(
    std::shared_ptr< HEPUtils::Jet > jet1,
    std::shared_ptr< HEPUtils::Jet > jet2
)

function sortByMass

bool sortByMass(
    const HEPUtils::Jet * jet1,
    const HEPUtils::Jet * jet2
)

function sortByMass_sharedptr

bool sortByMass_sharedptr(
    std::shared_ptr< HEPUtils::Jet > jet1,
    std::shared_ptr< HEPUtils::Jet > jet2
)

function calcMT

double calcMT(
    HEPUtils::P4 jetMom,
    HEPUtils::P4 metMom
)

function sortByPT_1l

bool sortByPT_1l(
    const HEPUtils::Jet * jet1,
    const HEPUtils::Jet * jet2
)

function sortByPT_1l_sharedptr

bool sortByPT_1l_sharedptr(
    std::shared_ptr< HEPUtils::Jet > jet1,
    std::shared_ptr< HEPUtils::Jet > jet2
)

function sortByMass_1l

bool sortByMass_1l(
    const HEPUtils::Jet * jet1,
    const HEPUtils::Jet * jet2
)

function sortByMass_1l_sharedptr

bool sortByMass_1l_sharedptr(
    std::shared_ptr< HEPUtils::Jet > jet1,
    std::shared_ptr< HEPUtils::Jet > jet2
)

function calcMT_1l

double calcMT_1l(
    HEPUtils::P4 jetMom,
    HEPUtils::P4 metMom
)

function sortByPT_j

bool sortByPT_j(
    const HEPUtils::Jet * jet1,
    const HEPUtils::Jet * jet2
)

function sortByPT_l

bool sortByPT_l(
    const HEPUtils::Particle * lep1,
    const HEPUtils::Particle * lep2
)

function sortByPT_jet

bool sortByPT_jet(
    const HEPUtils::Jet * jet1,
    const HEPUtils::Jet * jet2
)

function sortByPT_lep

bool sortByPT_lep(
    const HEPUtils::Particle * lep1,
    const HEPUtils::Particle * lep2
)

function sortByPT_RJ3L

bool sortByPT_RJ3L(
    const HEPUtils::Jet * jet1,
    const HEPUtils::Jet * jet2
)

function sortLepByPT_RJ3L

bool sortLepByPT_RJ3L(
    const HEPUtils::Particle * lep1,
    const HEPUtils::Particle * lep2
)

function SortLeptons

bool SortLeptons(
    const pair< TLorentzVector, int > lv1,
    const pair< TLorentzVector, int > lv2
)

function SortJets

bool SortJets(
    const TLorentzVector jv1,
    const TLorentzVector jv2
)

function sortByPT

bool sortByPT(
    const HEPUtils::Jet * jet1,
    const HEPUtils::Jet * jet2
)

function sortByPT_2lep

bool sortByPT_2lep(
    const HEPUtils::Particle * lep1,
    const HEPUtils::Particle * lep2
)

function Phi_mpi_pi

double Phi_mpi_pi(
    double x
)

function _Phi_mpi_pi

double _Phi_mpi_pi(
    double x
)

function _setEventWeight_unity

void _setEventWeight_unity(
    HEPUtils::Event & event,
    const BaseCollider * 
)

A function that sets the event weight to unity, with zero uncertainty.

function setEventWeight_unity

void setEventWeight_unity(
    EventWeighterFunctionType & result
)

Module function providing an instance of EventWeighterFunctionType pointing to _setEventWeight_unity

function _setEventWeight_fromCrossSection

void _setEventWeight_fromCrossSection(
    HEPUtils::Event & event,
    const BaseCollider * HardScatteringSim_ptr,
    const map_int_process_xsec & ProcessCrossSectionsMap,
    const int use_trust_level
)

A function that sets the event weight based on the process cross-sections.

function setEventWeight_fromCrossSection

void setEventWeight_fromCrossSection(
    EventWeighterFunctionType & result
)

Module function providing an instance of EventWeighterFunctionType pointing to _setEventWeight_fromCrossSection

function fill_BaBar_single_photon

void fill_BaBar_single_photon()

function BaBar_single_photon_LogLike

double BaBar_single_photon_LogLike(
    double kappa,
    double mAp,
    double BRinv
)

Perform the actual likelihood evaluation.

function BaBar_single_photon_LogLike_SubGeVDM

void BaBar_single_photon_LogLike_SubGeVDM(
    double & result
)

function getDummyColliderObservable

void getDummyColliderObservable(
    double & result
)

Dummy observable that creates a dependency on TestModel1D.

This is used to satisfy the normal GAMBIT model requrements in a minimal way. This is useful in the case where we just want to run ColliderBit on a single point with a custom Pythia version, using Pythia’s SLHA interface.

function operateLHCLoop

void operateLHCLoop(
    MCLoopInfo & result
)

LHC Loop Manager.

function getLHCEventLoopInfo

void getLHCEventLoopInfo(
    map_str_dbl & result
)

Store some information about the event generation.

function CollectAnalyses

void CollectAnalyses(
    AnalysisDataPointers & result
)

Loop over all analyses and collect them in one place.

function set_CS

void set_CS(
    hb_ModelParameters & result,
    const HiggsCouplingsTable & couplings,
    int n_neutral_higgses
)

Helper function to set HiggsBounds/Signals parameters cross-section ratios from a GAMBIT HiggsCouplingsTable.

function set_SMLikeHiggs_ModelParameters

void set_SMLikeHiggs_ModelParameters(
    const SubSpectrum & spec,
    const HiggsCouplingsTable & couplings,
    hb_ModelParameters & result
)

Helper function for populating a HiggsBounds/Signals ModelParameters object for SM-like Higgs.

function SMLikeHiggs_ModelParameters

void SMLikeHiggs_ModelParameters(
    hb_ModelParameters & result
)

SM-like (SM + possible invisibles) Higgs model parameters for HiggsBounds/Signals.

function MSSMLikeHiggs_ModelParameters

void MSSMLikeHiggs_ModelParameters(
    hb_ModelParameters & result
)

MSSM-like (MSSM + NMSSM + …) Higgs model parameters for HiggsBounds/Signals.

function calc_HB_LEP_LogLike

void calc_HB_LEP_LogLike(
    double & result
)

Get a LEP chisq from HiggsBounds.

function calc_HS_LHC_LogLike

void calc_HS_LHC_LogLike(
    double & result
)

Get an LHC chisq from HiggsSignals.

function FeynHiggs_HiggsProd

void FeynHiggs_HiggsProd(
    fh_HiggsProd_container & result
)

Higgs production cross-sections from FeynHiggs.

function fill_analysis_loglikes

void fill_analysis_loglikes(
    const AnalysisData & ana_data,
    AnalysisLogLikes & ana_loglikes,
    bool use_marg,
    bool has_and_use_covar,
    bool combine_nocovar_SRs,
    bool has_and_use_fulllikes,
    bool(*)(const str &) FullLikes_FileExists,
    int(*)(const str &, const str &) FullLikes_ReadIn,
    double(*)(std::map< str, double > &, const str &) FullLikes_Evaluate,
    const std::string alt_loglike_key
)

Forward declaration of funtion in LHC_likelihoods.

Helper function called by calc_LHC_LogLikes to compute the loglike(s) for a given analysis.

TodoUnify this for both cov and no-cov, feeding in one-element Eigen blocks as Ref<>s for the latter?

TodoCompute the background-only covariance decomposition and likelihood only once

TodoOnly compute this once per run

TodoUse newer (?) one-step Eigen constructors for (const) single-element arrays

TodoOnly compute this once per run

TodoOnly compute this once per run

TodoUnify this for both cov and no-cov, feeding in one-element Eigen blocks as Ref<>s for the latter?

TodoCompute the background-only covariance decomposition and likelihood only once

TodoOnly compute this once per run

TodoUse newer (?) one-step Eigen constructors for (const) single-element arrays

TodoOnly compute this once per run

TodoOnly compute this once per run

function DMEFT_fill_analysis_info_map

void DMEFT_fill_analysis_info_map()

Forward declarations of functions in this file.

A function for filling the analysis_info_map for the DMEFT model.

function DMsimp_fill_analysis_info_map

void DMsimp_fill_analysis_info_map(
    std::map< str, str > Analysis_data_path,
    std::map< str, std::vector< str > > Interpolation_columns,
    int Ndim
)

A function for filling the analysis_info_map for the DMsimp models.

function SubGeVDM_fill_analysis_info_map

void SubGeVDM_fill_analysis_info_map(
    std::map< str, str > Analysis_data_path,
    std::map< str, std::vector< str > > Interpolation_columns
)

A function for filling the analysis_info_map for the SubGeVDM_fermion and SubGeVDM_scalar models.

function DMEFT_results

void DMEFT_results(
    AnalysisDataPointers & result
)

Results from DMEFT analyses before any modification of the MET spectrum.

function DMEFT_results_profiled

void DMEFT_results_profiled(
    AnalysisDataPointers & result
)

Results from DMEFT analyses after profiling over the ‘a’ parameter in the smooth cut-off of the MET spectrum.

function DMEFT_results_cutoff

void DMEFT_results_cutoff(
    AnalysisDataPointers & result
)

Results from DMEFT analyses after imposing a hard cut-off of the MET spectrum.

function DMsimpVectorMedScalarDM_monojet_results

void DMsimpVectorMedScalarDM_monojet_results(
    AnalysisDataPointers & 
)

function DMsimpVectorMedMajoranaDM_monojet_results

void DMsimpVectorMedMajoranaDM_monojet_results(
    AnalysisDataPointers & 
)

function DMsimpVectorMedDiracDM_monojet_results

void DMsimpVectorMedDiracDM_monojet_results(
    AnalysisDataPointers & 
)

function SubGeVDM_results

void SubGeVDM_results(
    AnalysisDataPointers & result
)

Results for the SubGeVDM_fermion and SubGeVDM_scalar model.

function get_DMEFT_signal_yields_dim6_operator

void get_DMEFT_signal_yields_dim6_operator(
    std::vector< double > & signal_yields,
    const str,
    const Model_analysis_info & analysis_info,
    double m,
    double O1,
    double O2,
    double lambda
)

Fill the input vector with the DMEFT signal prediction for a given set of dim-6 operators.

function get_DMEFT_signal_yields_dim7_operator

void get_DMEFT_signal_yields_dim7_operator(
    std::vector< double > & signal_yields,
    const str,
    const Model_analysis_info & analysis_info,
    double m,
    double O,
    double lambda
)

Fill the input vector with the DMEFT signal prediction for a given dim-7 operator.

function get_DMsimpVectorMedScalarDM_signal_yields

void get_DMsimpVectorMedScalarDM_signal_yields(
    std::vector< double > & signal_yields,
    const Model_analysis_info & analysis_info,
    double mDM,
    double mMed,
    double gq,
    double gVchi
)

Fill the input vector with the signal prediction for the DMsimpVectorMedScalarDM model.

function get_DMsimpVectorMedMajoranaDM_signal_yields

void get_DMsimpVectorMedMajoranaDM_signal_yields(
    std::vector< double > & signal_yields,
    const Model_analysis_info & analysis_info,
    double mDM,
    double mMed,
    double gq,
    double gAchi
)

Fill the input vector with the signal prediction for the DMsimpVectorMedMajoranaDM model.

function get_DMsimpVectorMedDiracDM_signal_yields

void get_DMsimpVectorMedDiracDM_signal_yields(
    std::vector< double > & signal_yields,
    const Model_analysis_info & analysis_info,
    double mDM,
    double mMed,
    double gq,
    double gVchi,
    double gAchi
)

Fill the input vector with the signal prediction for the DMsimpVectorMedDiracDM model.

function get_SubGeVDM_scalar_signal_yields

void get_SubGeVDM_scalar_signal_yields(
    std::vector< double > & signal_yields,
    const Model_analysis_info & analysis_info,
    double mDM,
    double mAp,
    double kappa,
    double gDM
)

Fill the input vector with the signal prediction for the SubGeVBeamDump_MB model TODO: If you apply some scaling based on couplings, then this is where you would want to do this

function get_SubGeVDM_fermion_signal_yields

void get_SubGeVDM_fermion_signal_yields(
    std::vector< double > & signal_yields,
    const Model_analysis_info & analysis_info,
    double mDM,
    double mAp,
    double kappa,
    double gDM
)

function get_DMsimpVectorMedVectorDM_signal_yields

void get_DMsimpVectorMedVectorDM_signal_yields(
    std::vector< double > & signal_yields,
    const Model_analysis_info & analysis_info,
    double mDM,
    double mMed,
    double gq,
    double gVchi
)

Fill the input vector with the signal prediction for the DMsimpVectorMedVectorDM model.

function get_all_DMEFT_signal_yields

void get_all_DMEFT_signal_yields(
    std::vector< double > & sr_nums,
    const Model_analysis_info & analysis_info,
    const Spectrum & spec
)

Fill the input vector with the total DMEFT signal prediction for each SR in the given LHC analysis.

function get_all_DMsimp_signal_yields

void get_all_DMsimp_signal_yields(
    std::vector< double > & sr_nums,
    const Model_analysis_info & analysis_info,
    const Spectrum & spec,
    str & modelname
)

Fill the input vector with the total DMsimp signal prediction for each SR in the given LHC analysis.

function get_all_SubGeVDM_signal_yields

void get_all_SubGeVDM_signal_yields(
    std::vector< double > & sr_nums,
    const Model_analysis_info & analysis_info,
    const Spectrum & spec,
    str & modelname
)

Fill the input vector with the total SubGeV signal prediction for each SR in the given analysis.

function signal_modifier_function

void signal_modifier_function(
    AnalysisData & adata,
    double lambda,
    double a
)

Function to modify the DMEFT LHC signal prediction for ETmiss bins where ETmiss > Lambda. Alt 1: Gradually turn off the ETmiss spectrum above Lambda by multiplying the spectrum with (ETmiss/Lambda)^-a

function signal_cutoff_function

void signal_cutoff_function(
    AnalysisData & adata,
    double lambda
)

Function to modify the DMEFT LHC signal prediction for ETmiss bins where ETmiss > Lambda. Alt 2: Simply put a hard cut-off in the ETmiss spectrum for ETmiss > Lambda

function _gsl_target_func

void _gsl_target_func(
    const size_t,
    const double * a,
    void * fparams,
    double * fval
)

A target function for the GSL optimiser.

function calc_DMEFT_profiled_LHC_nuisance_params

void calc_DMEFT_profiled_LHC_nuisance_params(
    map_str_dbl & result
)

function InterpolatedMCInfo

void InterpolatedMCInfo(
    MCLoopInfo & result
)

This makes an MCLoopInfo object for satisfying the ColliderBit dependency chain (This will not be needed once we have a general system for simulation-less analyses.)

function fill_analysis_info_map

void fill_analysis_info_map(
    str current_analysis_name,
    Model_analysis_info * current_ainfo
)

A function to fill the analysis_info_map given an analysis This is where all the analysis-specific numbers and file names go.

NEW BEAM DUMP content added by Taylor

function get_all_signal_yields

void get_all_signal_yields(
    void(*)(std::vector< double > &, const Model_analysis_info &, const Spectrum &, str &modelname) get_all_model_signal_yields,
    const Spectrum & spec,
    std::map< str, AnalysisData > & analysis_data_map,
    AnalysisDataPointers & result,
    str & modelname
)

Loop over analyses registered in the analysis_info_map.

function DMsimp_results

void DMsimp_results(
    AnalysisDataPointers & result
)

Results from DMsimp model analyses.

function fill_DMsimp_DiJets

void fill_DMsimp_DiJets()

Fill the DMsimp object with the interpolation information.

function DiJet_search_LogLike

double DiJet_search_LogLike(
    str searchname,
    double gq,
    double mMed,
    double BR_q
)

Perform the actual likelihood evaluation for a given di-jet search.

function Total_DiJet_search_LogLike

double Total_DiJet_search_LogLike(
    double mMed,
    double gq,
    double BR_q
)

Loop over the di-jet analyses and calculate the most constraining likelihood.

function DiJet_LogLike_DMsimp

void DiJet_LogLike_DMsimp(
    double & result
)

Interpolated Di-jet likelihoods from quark coupling upper limits This assumes the Narrow width approximation

function get_LSP_for_LEP_limits

LSP get_LSP_for_LEP_limits(
    const Spectrum & spec
)

function limit_LLike

double limit_LLike(
    double x,
    double x95,
    double sigma
)

LEP limit likelihood function.

Incorporate theoretical uncertainty in a 95% limit xPredicted cross section

x95Experimental 95% upper limit on cross section

sigmaTheoretical uncertainty on predicted cross section

Log-likelihood

function is_xsec_sane

bool is_xsec_sane(
    const triplet< double > & xsecWithError
)

LEP limit debugging function.

function LEP207_SLHA1_convention_xsec_chi00_11

void LEP207_SLHA1_convention_xsec_chi00_11(
    triplet< double > & result
)

function L3_Gravitino_LLike

void L3_Gravitino_LLike(
    double & result
)

L3 search for gravitinos at 207 GeV

We use a limit from Fig. 6c of https://doi.org/10.1016/j.physletb.2004.01.010.

We use the 95% upper limit on [ \sigma(ee \to \chi^0_1\chi^0_1) \textrm{BR}(\chi^0_1 \to \tilde{G}\gamma)^2 ]

function convert_yaml_options_for_contur

void convert_yaml_options_for_contur(
    std::vector< std::string > & yaml_options
)

function Rivet_measurements

void Rivet_measurements(
    std::shared_ptr< std::ostringstream > & result
)

function getActiveProcessCodes

void getActiveProcessCodes(
    std::vector< int > & result
)

Get the list of active collider process codes.

function getAnalysisContainer

void getAnalysisContainer(
    AnalysisContainer & result,
    const str & detname,
    const MCLoopInfo & RunMC,
    const xsec_container & TotalCrossSection,
    int iteration
)

Retrieve an analysis container for a specific detector.

function getBuckFastATLAS

void getBuckFastATLAS(
    BaseDetector *& result
)

Retrieve a BuckFast sim of ATLAS.

function getBuckFastCMS

void getBuckFastCMS(
    BaseDetector *& result
)

Retrieve a BuckFast sim of CMS.

function getBuckFastIdentity

void getBuckFastIdentity(
    BaseDetector *& result
)

Retrieve an Identity BuckFast sim (no sim)

function readHepMCEvent

void readHepMCEvent(
    HepMC3::GenEvent & result,
    const str HepMC_filename,
    const MCLoopInfo & RunMC,
    const int iteration,
    void(*)() halt
)

A nested function that reads in HepMC event files.

function getHepMCEvent

void getHepMCEvent(
    HepMC3::GenEvent & result
)

A nested function that reads in HepMC event files.

function read_jet_collections_settings

void read_jet_collections_settings(
    const Options & runOptions,
    std::vector< jet_collection_settings > & all_jet_collection_settings,
    str & jetcollection_taus
)

A helper function for collecting the jet_collections yaml settings. Used by functions getHepMCEvent_HEPUtils and convertHepMCEvent_HEPUtils.

function getHepMCEvent_HEPUtils

void getHepMCEvent_HEPUtils(
    HEPUtils::Event & result
)

A nested function that reads in HepMC event files and converts them to HEPUtils::Event format.

function convertHepMCEvent_HEPUtils

void convertHepMCEvent_HEPUtils(
    HEPUtils::Event & result
)

function getLHEvent_HEPUtils

void getLHEvent_HEPUtils(
    HEPUtils::Event & result
)

A nested function that reads in Les Houches Event files and converts them to HEPUtils::Event format.

function convert_xsecs_to_fb

std::pair< double, double > convert_xsecs_to_fb(
    double input_xsec,
    double input_xsec_uncert,
    str input_unit,
    bool input_fractional_uncert
)

Helper function that takes a cross-section value in fb or pb, along with an absolute or relative uncertainty, and returns the xsec and absolute uncertainty in fb.

function getPIDPairCrossSectionsMap_prospino

void getPIDPairCrossSectionsMap_prospino(
    map_PID_pair_PID_pair_xsec & result
)

Get a cross-section from Prospino WORK IN PROGRESS

function silly_pid_xsec_constructor

PID_pair_xsec_container silly_pid_xsec_constructor(
    PID_pair pid_pair,
    double xsec_val
)

Test functions for provding PIDPairCrossSectionsMap (cross-sections in fb)

function getPIDPairCrossSectionsMap_testing

void getPIDPairCrossSectionsMap_testing(
    map_PID_pair_PID_pair_xsec & result
)

function getProcessCrossSectionsMap

void getProcessCrossSectionsMap(
    map_int_process_xsec & result
)

Get a map between Pythia process codes and cross-sections.

function getEvGenCrossSection

void getEvGenCrossSection(
    MC_xsec_container & result
)

Compute a cross-section from Monte Carlo.

function getEvGenCrossSection_as_base

void getEvGenCrossSection_as_base(
    xsec_container & result
)

Return MC_xsec_container as the base xsec_container.

function getNLLFastCrossSection

void getNLLFastCrossSection(
    xsec_container & result
)

Get a cross-section from NLL-FAST.

function checkOptions_getYAMLCrossSection

bool checkOptions_getYAMLCrossSection(
    const Options & runOptions,
    const str calling_function,
    std::pair< str, str > & xsec_pnames,
    str & input_unit,
    bool & input_fractional_uncert,
    str & errmsg
)

A helper function to check the YAML options for getYAMLCrossSection and getYAMLCrossSection_SLHA.

function getYAMLCrossSection

void getYAMLCrossSection(
    xsec_container & result
)

A function that reads the total cross-section from the input file, but builds up the number of events from the event loop.

function getYAMLCrossSection_SLHA

void getYAMLCrossSection_SLHA(
    xsec_container & result
)

A function that reads a list of (SLHA file, total cross-section) pairs from the input YAML file.

function getYAMLCrossSection_param

void getYAMLCrossSection_param(
    xsec_container & result
)

A function that assigns a total cross-sections directly from the scan parameters (for model ColliderBit_SLHA_scan_model)

function getTotalCrossSectionAsMap

void getTotalCrossSectionAsMap(
    map_str_dbl & result
)

Get cross-section info as map_str_dbl (for simple printing)

function getPIDPairCrossSectionsInfo

void getPIDPairCrossSectionsInfo(
    map_str_dbl & result
)

Output PID pair cross-sections as a str-dbl map, for easy printing.

function doCrossSectionConsistencyCheck

void doCrossSectionConsistencyCheck(
    bool & result
)

A consistency check that ensures that if each event is weighted by a process-level cross-section from an external calculator, then the total cross-section is taken from the event generator

function calc_LHC_signals

void calc_LHC_signals(
    map_str_dbl & result
)

Loop over all analyses and fill a map of predicted counts.

function _gsl_calc_Analysis_MinusLogLike

void _gsl_calc_Analysis_MinusLogLike(
    const size_t n,
    const double * unit_nuisances_dbl,
    void * fixedparamspack,
    double * fval
)

Note: Doesn’t return a full log-like: the factorial term is missing since it’s expensive, fixed and cancels in DLLs

Loglike objective-function wrapper to provide the signature for GSL multimin

We’ve dropped the log(n_obs!) terms, since they’re expensive and cancel in computing DLL

function _gsl_calc_Analysis_MinusLogLikeGrad

void _gsl_calc_Analysis_MinusLogLikeGrad(
    const size_t n,
    const double * unit_nuisances_dbl,
    void * fixedparamspack,
    double * fgrad
)

Loglike gradient-function wrapper to provide the signature for GSL multimin.

function _gsl_calc_Analysis_MinusLogLikeAndGrad

void _gsl_calc_Analysis_MinusLogLikeAndGrad(
    const size_t n,
    const double * unit_nuisances_dbl,
    void * fixedparamspack,
    double * fval,
    double * fgrad
)

function _gsl_mkpackedarray

std::vector< double > _gsl_mkpackedarray(
    const Eigen::ArrayXd & n_preds,
    const Eigen::ArrayXd & n_obss,
    const Eigen::ArrayXd & sqrtevals,
    const Eigen::MatrixXd & evecs
)

function profile_loglike_cov

double profile_loglike_cov(
    const Eigen::ArrayXd & n_preds,
    const Eigen::ArrayXd & n_obss,
    const Eigen::ArrayXd & sqrtevals,
    const Eigen::MatrixXd & evecs
)

Note: Return value is missing the log(n_obs!) terms (n_SR of them) which cancel in LLR calculation

Todo: Pass in the cov, and compute the fixed evals, evecs, and corr matrix as fixed params in here? Via a helper function to reduce duplication

Return the best log likelihood

function marg_loglike_nulike1sr

double marg_loglike_nulike1sr(
    const Eigen::ArrayXd & n_preds,
    const Eigen::ArrayXd & n_obss,
    const Eigen::ArrayXd & sqrtevals
)

function marg_loglike_cov

double marg_loglike_cov(
    const Eigen::ArrayXd & n_preds,
    const Eigen::ArrayXd & n_obss,
    const Eigen::ArrayXd & sqrtevals,
    const Eigen::MatrixXd & evecs
)

TodoShould also implement a check of relative difference

How to correct negative rates? Discard (scales badly), set to epsilon (= discontinuous & unphysical pdf), transform to log-space (distorts the pdf quite badly), or something else (skew term)? We’re using the “set to epsilon” version for now. Ben: I would vote for ‘discard’. It can’t be that inefficient, surely? Andy: For a lot of signal regions, the probability of none having a negative sample is Prod_SR p(non-negative)_SR… which can get bad.

function fill_analysis_loglikes_full

void fill_analysis_loglikes_full(
    const AnalysisData & ana_data,
    AnalysisLogLikes & ana_loglikes,
    bool(*)(const str &) FullLikes_FileExists,
    int(*)(const str &, const str &) FullLikes_ReadIn,
    double(*)(std::map< str, double > &, const str &) FullLikes_Evaluate,
    const std::string alt_loglike_key =""
)

Helper function called by fill_analysis_loglikes below. It’s used to get the loglike(s) for ATLAS analyses for which we have the ATLAS Full Likelihood information.

function calc_LHC_LogLikes_common

void calc_LHC_LogLikes_common(
    map_str_AnalysisLogLikes & result,
    bool use_fulllikes,
    AnalysisDataPointers & ana,
    const Options & runOptions,
    bool skip_calc,
    bool(*)(const str &) FullLikes_FileExists,
    int(*)(const str &, const str &) FullLikes_ReadIn,
    double(*)(std::map< str, double > &, const str &) FullLikes_Evaluate
)

Loop over all analyses and fill a map of AnalysisLogLikes objects.

function calc_LHC_LogLikes_full

void calc_LHC_LogLikes_full(
    map_str_AnalysisLogLikes & result
)

Loop over all analyses and fill a map of AnalysisLogLikes objects.

TodoNeeds more sophistication once we add analyses that don’t use event generation.

function calc_LHC_LogLikes

void calc_LHC_LogLikes(
    map_str_AnalysisLogLikes & result
)

Loop over all analyses and fill a map of AnalysisLogLikes objectss.

TodoNeeds more sophistication once we add analyses that don’t use event generation.

function get_LHC_LogLike_per_analysis

void get_LHC_LogLike_per_analysis(
    map_str_dbl & result
)

Extract the combined log likelihood for each analysis.

function get_LHC_LogLike_per_SR

void get_LHC_LogLike_per_SR(
    map_str_dbl & result
)

Extract the log likelihood for each SR.

function get_LHC_LogLike_SR_labels

void get_LHC_LogLike_SR_labels(
    map_str_str & result
)

Extract the labels for the SRs used in the analysis loglikes.

function get_LHC_LogLike_SR_indices

void get_LHC_LogLike_SR_indices(
    map_str_dbl & result
)

Todo: Switch result type to map_str_int once we have implemented a printer for this type

Extract the indices for the SRs used in the analysis loglikes

function calc_combined_LHC_LogLike

void calc_combined_LHC_LogLike(
    double & result
)

Compute the total likelihood combining all analyses.

function calc_LHC_LogLike_scan_guide

void calc_LHC_LogLike_scan_guide(
    double & result
)

A dummy log-likelihood that helps the scanner track a given range of collider log-likelihood values

function get_HEPUtils_event

void get_HEPUtils_event(
    const LHEF::Reader & lhe,
    Event & evt,
    double jet_pt_min,
    std::vector< jet_collection_settings > all_jet_collection_settings
)

Extract an LHE event as a HEPUtils::Event.

TodoDress leptons?

TodoBug in HEPUtils::get_jets means that constituent info is lost for now…

function getNextSLHAFileNameAndContent

void getNextSLHAFileNameAndContent(
    pair_str_SLHAstruct & result
)

function getAndReplaceSLHAContent

void getAndReplaceSLHAContent(
    pair_str_SLHAstruct & result
)

TodoAdd option to save the new SLHA content to file

function getSLHAFileElements

void getSLHAFileElements(
    map_str_dbl & result
)

function getSLHA1Spectrum

void getSLHA1Spectrum(
    SLHAstruct & result
)

function getSLHA2Spectrum

void getSLHA2Spectrum(
    SLHAstruct & result
)

function calc_susy_spectrum_scan_guide

void calc_susy_spectrum_scan_guide(
    double & result
)

function get_susy_spectrum_validation_loglike

void get_susy_spectrum_validation_loglike(
    double & result
)

function getActiveProcessCodeToPIDPairsMap

void getActiveProcessCodeToPIDPairsMap(
    multimap_int_PID_pair & result
)

Get a multimap between the active Pythia process codes and the corresponding PID pair for the two final state particles

function getActivePIDPairs

void getActivePIDPairs(
    vec_PID_pair & result
)

Get a list of all the PID pairs related to active process codes.

function runAnalyses

void runAnalyses(
    AnalysisDataPointers & result,
    const str & ,
    const MCLoopInfo & RunMC,
    const AnalysisContainer & Container,
    const HEPUtils::Event & SmearedEvent,
    int iteration,
    void(*)() wrapup
)

Run all the analyses in a given container.

function smearEvent

void smearEvent(
    HEPUtils::Event & result,
    const HEPUtils::Event & HardScatteringEvent,
    const BaseDetector & detector,
    const MCLoopInfo & RunMC,
    const int iteration,
    const str & detname
)

Smear an event.

Attributes Documentation

variable all_process_codes_to_PID_pairs

static const multimap_int_PID_pair all_process_codes_to_PID_pairs;

variable sqrtsGeV

static constexpr double sqrtsGeV = 205;

variable GeV

static const double GeV = 1;

Unit conversions (multiply to construct in standard units, divide to decode to that unit)

variable MeV

static const double MeV = 1e-3;

variable TeV

static const double TeV = 1e3;

variable SubGeVDM_BaBar_single_photon_analysis_info

std::map< str, BaBar_single_photon_analysis_info > SubGeVDM_BaBar_single_photon_analysis_info;

A Map between search name and the analysis info needed.

variable analysis_info_map

std::map< str, Model_analysis_info > analysis_info_map;

A global map from analysis name to Model_analysis_info instance. This map is initialized by the function fill_analysis_info_map, which is called the first time DMEFT_results run.

variable DMsimp_dijet_analysis_info

std::map< str, Dijet_analysis_info > DMsimp_dijet_analysis_info;

A Map between search name and the analysis info needed.

variable dijet_searches

std::vector< str > dijet_searches = {{"ATLAS-CONF-2018-052"},
                                       {"CERN-EP-2017-280"},
                                       {"CERN-EP-2018-347"},
                                       {"CMS-EXO-18-012"},
                                       {"CMS-EXO-19-012"},
                                       {"DiJet_139"},
                                       {"DiJet_TLA"}};

The di_jet searches that are to be used.


Updated on 2024-07-18 at 13:53:30 +0000