ATLAS Offline Software
Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
ST::SUSYObjDef_xAOD Class Referenceabstract

#include <SUSYObjDef_xAOD.h>

Inheritance diagram for ST::SUSYObjDef_xAOD:
Collaboration diagram for ST::SUSYObjDef_xAOD:

Public Types

enum  DataSource { Undefined = -1, Data, FullSim, AtlfastII }
 

Public Member Functions

 SUSYObjDef_xAOD (const std::string &name)
 
 ~SUSYObjDef_xAOD ()
 
StatusCode initialize () override final
 Dummy implementation of the initialisation function. More...
 
bool isData () const override final
 
bool isAtlfast () const override final
 
StatusCode setBoolProperty (const std::string &name, const bool &property) override final
 
void setDataSource (int source)
 
StatusCode FillJet (xAOD::Jet &input, const bool doCalib=true, bool isFat=false, bool doLargeRdecorations=false) override final
 
StatusCode FillTrackJet (xAOD::Jet &input) override final
 
StatusCode FillTau (xAOD::TauJet &input) override final
 
StatusCode FillMuon (xAOD::Muon &input, const float ptcut, const float etacut) override final
 
StatusCode FillElectron (xAOD::Electron &input, const float etcut, const float etacut) override final
 
StatusCode FillPhoton (xAOD::Photon &input, const float ptcut, const float etacut) override final
 
const xAOD::VertexGetPrimVtx () const override final
 
StatusCode GetJets (xAOD::JetContainer *&copy, xAOD::ShallowAuxContainer *&copyaux, const bool recordSG=true, const std::string &jetkey="", const xAOD::JetContainer *containerToBeCopied=nullptr) override final
 
StatusCode GetTrackJets (xAOD::JetContainer *&copy, xAOD::ShallowAuxContainer *&copyaux, const bool recordSG=true, const std::string &jetkey="", const xAOD::JetContainer *containerToBeCopied=nullptr) override final
 
StatusCode GetJetsSyst (const xAOD::JetContainer &calibjets, xAOD::JetContainer *&copy, xAOD::ShallowAuxContainer *&copyaux, const bool recordSG=true, const std::string &jetkey="") override final
 
StatusCode GetFatJets (xAOD::JetContainer *&copy, xAOD::ShallowAuxContainer *&copyaux, const bool recordSG=false, const std::string &jetkey="", const bool doLargeRdecorations=false, const xAOD::JetContainer *containerToBeCopied=nullptr) override final
 
StatusCode GetTaus (xAOD::TauJetContainer *&copy, xAOD::ShallowAuxContainer *&copyaux, const bool recordSG=true, const std::string &taukey="TauJets", const xAOD::TauJetContainer *containerToBeCopied=nullptr) override final
 
StatusCode GetMuons (xAOD::MuonContainer *&copy, xAOD::ShallowAuxContainer *&copyaux, const bool recordSG=true, const std::string &muonkey="Muons", const std::string &lrtmuonkey="MuonsLRT", const xAOD::MuonContainer *containerToBeCopied=nullptr) override final
 
StatusCode GetElectrons (xAOD::ElectronContainer *&copy, xAOD::ShallowAuxContainer *&copyaux, const bool recordSG=true, const std::string &elekey="Electrons", const std::string &lrtelekey="LRTElectrons", const xAOD::ElectronContainer *containerToBeCopied=nullptr) override final
 
StatusCode GetPhotons (xAOD::PhotonContainer *&copy, xAOD::ShallowAuxContainer *&copyaux, const bool recordSG=true, const std::string &photonkey="Photons", const xAOD::PhotonContainer *containerToBeCopied=nullptr) override final
 
StatusCode GetMET (xAOD::MissingETContainer &met, const xAOD::JetContainer *jet, const xAOD::ElectronContainer *elec=nullptr, const xAOD::MuonContainer *muon=nullptr, const xAOD::PhotonContainer *gamma=nullptr, const xAOD::TauJetContainer *taujet=nullptr, bool doTST=true, bool doJVTCut=true, const xAOD::IParticleContainer *invis=nullptr) override final
 
StatusCode GetTrackMET (xAOD::MissingETContainer &met, const xAOD::JetContainer *jet, const xAOD::ElectronContainer *elec=nullptr, const xAOD::MuonContainer *muon=nullptr) override final
 
StatusCode GetMETSig (xAOD::MissingETContainer &met, double &metSignificance, bool doTST=true, bool doJVTCut=true) override final
 
StatusCode MergeMuons (const xAOD::MuonContainer &muons, const std::vector< bool > &writeMuon, xAOD::MuonContainer *outputCol) const override final
 
StatusCode prepareLRTMuons (const xAOD::MuonContainer *inMuons, xAOD::MuonContainer *copy) const override final
 
StatusCode MergeElectrons (const xAOD::ElectronContainer &electrons, xAOD::ElectronContainer *outputCol, const std::set< const xAOD::Electron * > &ElectronsToRemove) const override final
 
StatusCode prepareLRTElectrons (const xAOD::ElectronContainer *inMuons, xAOD::ElectronContainer *copy) const override final
 
StatusCode SetBtagWeightDecorations (const xAOD::Jet &input, const asg::AnaToolHandle< IBTaggingSelectionTool > &btagSelTool, const std::string &btagTagger) const override final
 
bool IsPFlowCrackVetoCleaning (const xAOD::ElectronContainer *elec=nullptr, const xAOD::PhotonContainer *gamma=nullptr) const override final
 
bool IsSignalJet (const xAOD::Jet &input, const float ptcut, const float etacut) const override final
 
bool IsBadJet (const xAOD::Jet &input) const override final
 
bool IsBJetLoose (const xAOD::Jet &input) const override final
 
bool JetPassJVT (xAOD::Jet &input) override final
 
bool IsSignalMuon (const xAOD::Muon &input, const float ptcut, const float d0sigcut, const float z0cut, const float etacut=DUMMYDEF) const override final
 
bool IsSignalElectron (const xAOD::Electron &input, const float etcut, const float d0sigcut, const float z0cut, const float etacut=DUMMYDEF) const override final
 
bool IsCosmicMuon (const xAOD::Muon &input, const float z0cut, const float d0cut) const override final
 
bool IsHighPtMuon (const xAOD::Muon &input) const override final
 
bool IsSignalTau (const xAOD::TauJet &input, const float ptcut, const float etacut) const override final
 
bool IsBadMuon (const xAOD::Muon &input, const float qopcut) const override final
 
bool IsSignalPhoton (const xAOD::Photon &input, const float ptcut, const float etacut=DUMMYDEF) const override final
 
bool IsBJet (const xAOD::Jet &input) const override final
 
bool IsTrackBJet (const xAOD::Jet &input) const override final
 
bool IsTruthBJet (const xAOD::Jet &input) const override final
 
int IsBJetContinuous (const xAOD::Jet &input) const override final
 
int IsTrackBJetContinuous (const xAOD::Jet &input) const override final
 
float BtagSF (const xAOD::JetContainer *jets) override final
 
float BtagSFsys (const xAOD::JetContainer *jets, const CP::SystematicSet &systConfig) override final
 
float BtagSF_trkJet (const xAOD::JetContainer *trkjets) override final
 
float BtagSFsys_trkJet (const xAOD::JetContainer *trkjets, const CP::SystematicSet &systConfig) override final
 
double JVT_SF (const xAOD::JetContainer *jets) override final
 
double JVT_SFsys (const xAOD::JetContainer *jets, const CP::SystematicSet &systConfig) override final
 
double FJVT_SF (const xAOD::JetContainer *jets) override final
 
double FJVT_SFsys (const xAOD::JetContainer *jets, const CP::SystematicSet &systConfig) override final
 
float GetSignalMuonSF (const xAOD::Muon &mu, const bool recoSF=true, const bool isoSF=true, const bool doBadMuonHP=true, const bool warnOVR=true) override final
 
double GetMuonTriggerEfficiency (const xAOD::Muon &mu, const std::string &trigExpr, const bool isdata=false) override final
 
double GetTotalMuonTriggerSF (const xAOD::MuonContainer &sfmuons, const std::string &trigExpr) override final
 
double GetTotalMuonSF (const xAOD::MuonContainer &muons, const bool recoSF=true, const bool isoSF=true, const std::string &trigExpr="HLT_mu20_iloose_L1MU15_OR_HLT_mu50", const bool bmhptSF=true) override final
 
double GetTotalMuonSFsys (const xAOD::MuonContainer &muons, const CP::SystematicSet &systConfig, const bool recoSF=true, const bool isoSF=true, const std::string &trigExpr="HLT_mu20_iloose_L1MU15_OR_HLT_mu50", const bool bmhptSF=true) override final
 
float GetSignalElecSF (const xAOD::Electron &el, const bool recoSF=true, const bool idSF=true, const bool triggerSF=true, const bool isoSF=true, const std::string &trigExpr="singleLepton", const bool ecidsSF=false, const bool cidSF=false) override final
 
double GetEleTriggerEfficiency (const xAOD::Electron &el, const std::string &trigExpr="SINGLE_E_2015_e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose_2016_2018_e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0") const override final
 
double GetTriggerGlobalEfficiency (const xAOD::ElectronContainer &electrons, const xAOD::MuonContainer &muons, const std::string &trigExpr="diLepton") override final
 
double GetTriggerGlobalEfficiency (const xAOD::PhotonContainer &photons, const std::string &trigExpr="diPhoton") override final
 
double GetEleTriggerEfficiencySF (const xAOD::Electron &el, const std::string &trigExpr="SINGLE_E_2015_e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose_2016_2018_e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0") const override final
 
double GetTriggerGlobalEfficiencySF (const xAOD::ElectronContainer &electrons, const xAOD::MuonContainer &muons, const std::string &trigExpr="diLepton") override final
 
double GetTriggerGlobalEfficiencySF (const xAOD::PhotonContainer &photons, const std::string &trigExpr="diPhoton") override final
 
double GetTriggerGlobalEfficiencySFsys (const xAOD::ElectronContainer &electrons, const xAOD::MuonContainer &muons, const CP::SystematicSet &systConfig, const std::string &trigExpr="diLepton") override final
 
double GetTriggerGlobalEfficiencySFsys (const xAOD::PhotonContainer &photons, const CP::SystematicSet &systConfig, const std::string &trigExpr="diPhoton") override final
 
float GetTotalElectronSF (const xAOD::ElectronContainer &electrons, const bool recoSF=true, const bool idSF=true, const bool triggerSF=true, const bool isoSF=true, const std::string &trigExpr="singleLepton", const bool ecidsSF=false, const bool cidSF=false) override final
 
float GetTotalElectronSFsys (const xAOD::ElectronContainer &electrons, const CP::SystematicSet &systConfig, const bool recoSF=true, const bool idSF=true, const bool triggerSF=true, const bool isoSF=true, const std::string &trigExpr="singleLepton", const bool ecidsSF=false, const bool cidSF=false) override final
 
double GetSignalTauSF (const xAOD::TauJet &tau, const bool idSF=true, const bool triggerSF=true, const std::string &trigExpr="tau25_medium1_tracktwo") override final
 
double GetSignalTauSFsys (const xAOD::TauJet &tau, const CP::SystematicSet &systConfig, const bool idSF=true, const bool triggerSF=true, const std::string &trigExpr="tau25_medium1_tracktwo") override final
 
double GetTauTriggerEfficiencySF (const xAOD::TauJet &tau, const std::string &trigExpr="tau25_medium1_tracktwo") override final
 
double GetTotalTauSF (const xAOD::TauJetContainer &taus, const bool idSF=true, const bool triggerSF=true, const std::string &trigExpr="tau25_medium1_tracktwo") override final
 
double GetTotalTauSFsys (const xAOD::TauJetContainer &taus, const CP::SystematicSet &systConfig, const bool idSF=true, const bool triggerSF=true, const std::string &trigExpr="tau25_medium1_tracktwo") override final
 
double GetSignalPhotonSF (const xAOD::Photon &ph, const bool effSF=true, const bool isoSF=true, const bool triggerSF=false) const override final
 
double GetSignalPhotonSFsys (const xAOD::Photon &ph, const CP::SystematicSet &systConfig, const bool effSF=true, const bool isoSF=true, const bool triggerSF=false) override final
 
double GetTotalPhotonSF (const xAOD::PhotonContainer &photons, const bool effSF=true, const bool isoSF=true, const bool triggerSF=false) const override final
 
double GetTotalPhotonSFsys (const xAOD::PhotonContainer &photons, const CP::SystematicSet &systConfig, const bool effSF=true, const bool isoSF=true, const bool triggerSF=false) override final
 
double GetTotalJetSF (const xAOD::JetContainer *jets, const bool btagSF=true, const bool jvtSF=true, const bool fjvtSF=false) override final
 
double GetTotalJetSFsys (const xAOD::JetContainer *jets, const CP::SystematicSet &systConfig, const bool btagSF=true, const bool jvtSF=true, const bool fjvtSF=false) override final
 
bool IsMETTrigPassed (unsigned int runnumber=0, bool j400_OR=false) const override final
 
bool IsMETTrigPassed (const std::string &triggerName, bool j400_OR=false) const override final
 
bool IsTrigPassed (const std::string &, unsigned int condition=TrigDefs::Physics) const override final
 
bool IsTrigMatched (const xAOD::IParticle *part, const std::string &tr_item) override final
 
bool IsTrigMatched (const xAOD::IParticle *part1, const xAOD::IParticle *part2, const std::string &tr_item) override final
 
bool IsTrigMatched (const std::vector< const xAOD::IParticle * > &v, const std::string &tr_item) override final
 
bool IsTrigMatched (const std::initializer_list< const xAOD::IParticle * > &v, const std::string &tr_item) override final
 
void TrigMatch (const xAOD::IParticle *p, std::initializer_list< std::string >::iterator, std::initializer_list< std::string >::iterator) override final
 
void TrigMatch (const xAOD::IParticle *p, const std::vector< std::string > &items) override final
 
void TrigMatch (const xAOD::IParticle *p, const std::initializer_list< std::string > &items) override final
 
void TrigMatch (const xAOD::IParticleContainer *v, const std::vector< std::string > &items) override final
 
void TrigMatch (const xAOD::IParticleContainer *v, const std::initializer_list< std::string > &items) override final
 
void TrigMatch (const std::initializer_list< const xAOD::IParticle * > &v, const std::vector< std::string > &items) override final
 
void TrigMatch (const std::initializer_list< const xAOD::IParticle * > &v, const std::initializer_list< std::string > &items) override final
 
void TrigMatch (const xAOD::IParticle *p, const std::string &item) override final
 
void TrigMatch (const xAOD::IParticleContainer *v, const std::string &item) override final
 
void TrigMatch (const std::initializer_list< const xAOD::IParticle * > &v, const std::string &item) override final
 
float GetTrigPrescale (const std::string &) const override final
 
const Trig::ChainGroupGetTrigChainGroup (const std::string &) const override final
 
std::vector< std::string > GetTriggerOR (const std::string &trigExpr) const
 
void GetTriggerTokens (std::string, std::vector< std::string > &, std::vector< std::string > &, std::vector< std::string > &, std::vector< std::string > &, std::vector< std::string > &) const
 
Trig::FeatureContainer GetTriggerFeatures (const std::string &chainName="EF_.*", unsigned int condition=TrigDefs::Physics) const
 
const xAOD::EventInfoGetEventInfo () const override final
 
float GetPileupWeight () override final
 
float GetPileupWeightPrescaledTrigger (const std::string &trigger_expr) override final
 
ULong64_t GetPileupWeightHash () override final
 
float GetDataWeight (const std::string &) override final
 
float GetCorrectedAverageInteractionsPerCrossing (bool includeDataSF=false) override final
 
float GetCorrectedActualInteractionsPerCrossing (bool includeDataSF=false) override final
 
double GetSumOfWeights (int channel) override final
 
unsigned int GetRandomRunNumber (bool muDependentRRN=true) override final
 
StatusCode ApplyPRWTool (bool muDependentRRN=true) override final
 
unsigned int GetRunNumber () const override final
 
const xAOD::TrackParticleContainerGetInDetLargeD0Tracks (const EventContext &ctx) const override final
 
const xAOD::TrackParticleContainerGetInDetLargeD0GSFTracks (const EventContext &ctx) const override final
 
StatusCode ApplyLRTUncertainty () override final
 
int treatAsYear (const int runNumber=-1) const override final
 
StatusCode OverlapRemoval (const xAOD::ElectronContainer *electrons, const xAOD::MuonContainer *muons, const xAOD::JetContainer *jets, const xAOD::PhotonContainer *gamma=nullptr, const xAOD::TauJetContainer *taujet=nullptr, const xAOD::JetContainer *fatjets=nullptr) override final
 
StatusCode NearbyLeptonCorrections (xAOD::ElectronContainer *electrons=nullptr, xAOD::MuonContainer *muons=nullptr) const override final
 
StatusCode resetSystematics () override final
 
const CP::SystematicSetcurrentSystematic () const
 
StatusCode applySystematicVariation (const CP::SystematicSet &systConfig) override final
 
bool isPrompt (const xAOD::IParticle *part) const override final
 
StatusCode FindSusyHP (int &pdgid1, int &pdgid2) const
 
StatusCode FindSusyHP (const xAOD::TruthParticleContainer *truthP, int &pdgid1, int &pdgid2, bool isTruth3=false) const override final
 
StatusCode FindSusyHP (const xAOD::TruthEvent *truthE, int &pdgid1, int &pdgid2) const override final
 
std::string TrigSingleLep () const override final
 
bool isNominal (const CP::SystematicSet &syst) const
 
bool isWeight (const CP::SystematicSet &systSet) const
 
bool isVariation (const CP::SystematicSet &syst) const
 
bool currentSystematicIsNominal () const
 
bool currentSystematicIsVariation () const
 
bool currentSystematicIsWeight () const
 
ST::SystInfo getSystInfo (const CP::SystematicVariation &sys) const override final
 
std::vector< ST::SystInfogetSystInfoList () const override final
 
float getSherpaVjetsNjetsWeight () const override final
 
float getSherpaVjetsNjetsWeight (const std::string &jetContainer) const override final
 
int getMCShowerType (const std::string &sample_name="", const std::string &tagger="") const override final
 
template<typename T >
const T * getProperty (const std::string &name)
 
virtual void print () const =0
 Print the state of the tool. More...
 
virtual StatusCode sysInitialize ()
 Function initialising the tool in the correct way in Athena. More...
 
virtual void print () const
 Print the state of the tool. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Static Public Member Functions

static bool FindSusyHardProc (const xAOD::TruthParticleContainer *truthP, int &pdgid1, int &pdgid2, bool isTruth3=false)
 
static bool FindSusyHardProc (const xAOD::TruthEvent *truthE, int &pdgid1, int &pdgid2)
 

Public Attributes

const xAOD::MuonContainerprompt_muons = nullptr
 
const xAOD::MuonContainerlrt_muons = nullptr
 
const xAOD::ElectronContainerprompt_electrons = nullptr
 
const xAOD::ElectronContainerlrt_electrons = nullptr
 

Protected Member Functions

StatusCode autoconfigurePileupRWTool (const std::string &PRWfilesDir="dev/PileupReweighting/share/", const std::string &PRWfileName="", bool usePathResolver=true, bool RPVLLmode=false, bool Combinedmode=false, const std::string &HFFilter="")
 
StatusCode readConfig () override final
 
StatusCode validConfig (bool strict=false) const
 
const std::vector< std::string > split (const std::string &s, const std::string &delim) const
 
void getTauConfig (const std::string &tauConfigPath, std::vector< float > &pT_window, std::vector< float > &eta_window, bool &eleOLR, bool &muVeto, bool &muOLR) const
 
void configFromFile (bool &property, const std::string &propname, TEnv &rEnv, bool defaultValue)
 
void configFromFile (double &property, const std::string &propname, TEnv &rEnv, double defaultValue)
 
void configFromFile (int &property, const std::string &propname, TEnv &rEnv, int defaultValue)
 
void configFromFile (std::string &property, const std::string &propname, TEnv &rEnv, const std::string &defaultValue, bool allowEmpty=false)
 
bool check_isOption (const std::string &wp, const std::vector< std::string > &list) const
 
bool check_isTighter (const std::string &wp1, const std::string &wp, const std::vector< std::string > &list) const
 
std::string EG_WP (const std::string &wp) const
 
std::vector< std::string > getElSFkeys (const std::string &mapFile) const
 
void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Protected Attributes

int m_dataSource
 
int m_jetInputType
 
std::string m_configFile
 
bool m_force_noElId
 
bool m_force_noMuId
 
bool m_doTTVAsf
 
bool m_doModifiedEleId
 
bool m_upstreamTriggerMatching
 
std::string m_trigMatchingPrefix
 Use composite trigger matching tool if matching was done upstream. More...
 
std::string m_jetUncertaintiesConfig
 Prefix for trigger matchiing container name. More...
 
std::string m_jetUncertaintiesAnalysisFile
 
std::string m_jetUncertaintiesCalibArea
 
std::string m_jetUncertaintiesMCType
 
bool m_jetUncertaintiesPDsmearing
 
bool m_useBtagging
 
bool m_useBtagging_trkJet
 
bool m_debug
 
bool m_strictConfigCheck
 
std::string m_badJetCut
 
std::string m_fatJetUncConfig
 
std::string m_fatJetUncVars
 
TEnv m_WconfigReader
 
TEnv m_ZconfigReader
 
TEnv m_TopconfigReader
 
std::string m_WDecorName
 
std::string m_ZDecorName
 
std::string m_TopDecorName
 
std::string m_WtagConfig
 
std::string m_ZtagConfig
 
std::string m_ToptagConfig
 
std::string m_WZTaggerCalibArea
 
std::string m_TopTaggerCalibArea
 
std::string m_WTagUncConfig
 
std::string m_ZTagUncConfig
 
std::string m_TopTagUncConfig
 
std::string m_JetTruthLabelName
 
bool m_tool_init
 
bool m_subtool_init
 
std::string m_eleTerm
 
std::string m_gammaTerm
 
std::string m_tauTerm
 
std::string m_jetTerm
 
std::string m_muonTerm
 
std::string m_inputMETSuffix
 
std::string m_inputMETMap
 
std::string m_inputMETCore
 
std::string m_inputMETRef
 
std::string m_outMETTerm
 
bool m_metRemoveOverlappingCaloTaggedMuons
 
bool m_metDoSetMuonJetEMScale
 
bool m_metDoRemoveMuonJets
 
bool m_metUseGhostMuons
 
bool m_metDoMuonEloss
 
bool m_metGreedyPhotons
 
bool m_metVeryGreedyPhotons
 
std::string m_metsysConfigPrefix
 
bool m_trkMETsyst
 
bool m_caloMETsyst
 
bool m_trkJetsyst
 
int m_softTermParam
 
bool m_treatPUJets
 
bool m_doPhiReso
 
bool m_autoconfigPRW
 
std::string m_autoconfigPRWPath
 
std::string m_autoconfigPRWFile
 
bool m_autoconfigPRWCombinedmode
 
bool m_autoconfigPRWRPVmode
 
std::string m_autoconfigPRWRtags
 
std::string m_mcCampaign
 
int m_mcChannel
 
bool m_useCommonPRWFiles
 
std::string m_commonPRWFileMC20a
 
std::string m_commonPRWFileMC20d
 
std::string m_commonPRWFileMC20e
 
std::string m_commonPRWFileMC21a
 
std::string m_commonPRWFileMC23a
 
std::string m_commonPRWFileMC23c
 
std::string m_commonPRWFileMC23d
 
std::string m_commonPRWFileMC23e
 
std::vector< std::string > m_prwConfFiles
 
std::vector< std::string > m_prwLcalcFiles
 
std::string m_prwActualMu2017File
 
std::string m_prwActualMu2018File
 
std::string m_prwActualMu2022File
 
std::string m_prwActualMu2023File
 
std::string m_prwActualMu2024File
 
double m_prwDataSF
 
double m_prwDataSF_UP
 
double m_prwDataSF_DW
 
bool m_runDepPrescaleWeightPRW
 
std::vector< std::string > m_el_id_support
 
std::vector< std::string > m_ph_id_support
 
int m_mu_id_support
 
std::vector< std::string > m_tau_id_support
 
std::vector< std::string > m_el_iso_support
 
std::vector< std::string > m_mu_iso_support
 
std::map< std::string, std::string > m_el_iso_fallback
 
std::map< std::string, std::string > m_mu_iso_fallback
 
std::string m_electronTriggerSFStringSingle
 
std::map< std::string, std::string > m_tau_trig_support
 
std::string m_eleId
 
std::string m_eleIdBaseline
 
std::string m_eleConfig
 
std::string m_eleConfigBaseline
 
std::string m_eleBaselineIso_WP
 
bool m_eleIdExpert
 
int m_muId
 
int m_muIdBaseline
 
std::string m_photonId
 
std::string m_photonIdBaseline
 
std::string m_tauId
 
std::string m_tauIdBaseline
 
std::string m_eleIso_WP
 
std::string m_eleIsoHighPt_WP
 
double m_eleIsoHighPtThresh
 
std::string m_eleChID_WP
 
bool m_eleLRT
 
int m_eleLRT_strat
 
bool m_eleChIso
 
bool m_eleChID_signal
 
bool m_runECIS
 
std::string m_photonBaselineIso_WP
 
std::string m_photonIso_WP
 
std::string m_photonTriggerName
 
std::string m_muBaselineIso_WP
 
std::string m_muIso_WP
 
std::string m_muIsoHighPt_WP
 
double m_muIsoHighPtThresh
 
bool m_muHighPtExtraSmear
 
bool m_muEffCorrForce1D
 
std::string m_BtagWP
 
std::string m_BtagTagger
 
double m_BtagMinPt
 
std::string m_BtagKeyOverride
 
std::string m_BtagSystStrategy
 
std::string m_EigenvectorReductionB
 
std::string m_EigenvectorReductionC
 
std::string m_EigenvectorReductionLight
 
std::string m_BtagWP_trkJet
 
std::string m_BtagTagger_trkJet
 
double m_BtagMinPt_trkJet
 
double m_eleBaselinePt
 
double m_eleBaselineEta
 
bool m_eleBaselineCrackVeto
 
double m_elePt
 
double m_eleEta
 
bool m_eleCrackVeto
 
double m_eled0sig
 
double m_elez0
 
double m_elebaselined0sig
 
double m_elebaselinez0
 
std::string m_eleEffMapFilePath
 
std::string m_eleEffMapFilePathRun2
 
bool m_eleAllowRun3TrigSFFallback
 
bool m_eleForceFullSimCalib
 
double m_muBaselinePt
 
double m_muBaselineEta
 
double m_muPt
 
double m_muEta
 
double m_mud0sig
 
double m_muz0
 
double m_mubaselined0sig
 
double m_mubaselinez0
 
bool m_murequirepassedHighPtCuts
 
double m_muCosmicz0
 
double m_muCosmicd0
 
double m_badmuQoverP
 
int m_muCalibrationMode
 
bool m_muLRT
 
double m_photonBaselinePt
 
double m_photonBaselineEta
 
double m_photonEta
 
double m_photonPt
 
bool m_photonBaselineCrackVeto
 
bool m_photonCrackVeto
 
bool m_photonAllowLate
 
double m_tauPrePtCut
 
double m_tauPt
 
double m_tauEta
 
std::string m_tauConfigPath
 
std::string m_tauConfigPathBaseline
 
bool m_tauDoTTM
 
std::string m_tauSmearingToolRecommendationTag
 
std::string m_tauSmearingToolGenerator
 
TEnv m_tauConfigReader
 
double m_jetPt
 
double m_jetEta
 
double m_jetJvt
 
std::string m_JvtWP
 
double m_JvtPtMax
 
std::string m_JvtConfigRun2
 
std::string m_JvtConfigRun3
 
double m_trkJetPt
 
double m_trkJetEta
 
bool m_doFwdJVT
 
std::string m_fJvtWP
 
double m_fJvtPtMax
 
double m_fJvtEtaMin
 
std::string m_fJvtConfigRun2
 
std::string m_fJvtConfigRun3
 
bool m_JMScalib
 
bool m_orDoTau
 Overlap removal options. More...
 
bool m_orDoPhoton
 
bool m_orDoEleJet
 
bool m_orDoElEl
 
bool m_orDoElMu
 
bool m_orDoMuonJet
 
bool m_orDoBjet
 
bool m_orDoElBjet
 
bool m_orDoMuBjet
 
bool m_orDoTauBjet
 
bool m_orDoBoostedElectron
 
double m_orBoostedElectronC1
 
double m_orBoostedElectronC2
 
double m_orBoostedElectronMaxConeSize
 
bool m_orDoBoostedMuon
 
double m_orBoostedMuonC1
 
double m_orBoostedMuonC2
 
double m_orBoostedMuonMaxConeSize
 
bool m_orApplyRelPt
 
double m_orMuJetPtRatio
 
double m_orMuJetTrkPtRatio
 
double m_orMuJetInnerDR
 
bool m_orDoMuonJetGhostAssociation
 
bool m_orRemoveCaloMuons
 
std::string m_orBtagWP
 
std::string m_orInputLabel
 
bool m_orPhotonFavoured
 
double m_orBJetPtUpperThres
 
bool m_orLinkOverlapObjects
 
bool m_orDoFatjets
 
double m_EleFatJetDR
 
double m_JetFatJetDR
 
bool m_doIsoSignal
 
bool m_doElIsoSignal
 
bool m_doPhIsoSignal
 
bool m_doMuIsoSignal
 
bool m_useSigLepForIsoCloseByOR
 
std::string m_IsoCloseByORpassLabel
 
bool m_useTRUTH3
 
std::map< std::string, bool > m_slices
 
bool m_isRun3
 
bool m_isPHYSLITE
 
std::string m_metJetSelection
 
int m_showerType
 
std::string m_defaultJets
 
std::string m_defaultTrackJets
 
std::string m_fatJets
 
std::string m_defaultTruthJets
 
CP::SystematicSet m_defaultSyst = CP::SystematicSet()
 
CP::SystematicSet m_currentSyst
 
std::string m_EG_corrModel
 
std::string m_EG_corrFNList
 
bool m_applyJVTCut
 
std::string m_bTaggingCalibrationFilePath
 
std::map< std::string, std::string > m_legsPerTool
 
std::map< std::string, std::string > m_legsPerTool_ph
 
asg::AnaToolHandle< IJetCalibrationToolm_jetCalibTool
 
asg::AnaToolHandle< IJetCalibrationToolm_jetFatCalibTool
 
asg::AnaToolHandle< ICPJetUncertaintiesToolm_jetUncertaintiesTool
 
asg::AnaToolHandle< ICPJetUncertaintiesToolm_jetUncertaintiesPDSmearTool
 
asg::AnaToolHandle< ICPJetUncertaintiesToolm_fatjetUncertaintiesTool
 
asg::AnaToolHandle< IJetSelectorm_jetCleaningTool
 
asg::AnaToolHandle< JetPileupLabelingToolm_jetPileupLabelingTool
 
asg::AnaToolHandle< JetVertexTaggerToolm_jetJvtMomentTool
 
asg::AnaToolHandle< JetPileupTag::JetVertexNNTaggerm_jetNNJvtMomentTool
 
asg::AnaToolHandle< IAsgSelectionToolm_jetNNJvtSelectionTool
 
asg::AnaToolHandle< CP::IJvtEfficiencyToolm_jetNNJvtEfficiencyTool
 
asg::AnaToolHandle< IAsgSelectionToolm_jetfJvtSelectionTool
 
asg::AnaToolHandle< CP::IJvtEfficiencyToolm_jetfJvtEfficiencyTool
 
asg::AnaToolHandle< SmoothedWZTaggerm_WTaggerTool
 
asg::AnaToolHandle< SmoothedWZTaggerm_ZTaggerTool
 
asg::AnaToolHandle< JSSWTopTaggerDNNm_TopTaggerTool
 
asg::AnaToolHandle< JetTruthLabelingToolm_jetTruthLabelingTool
 
asg::AnaToolHandle< ICPJetUncertaintiesToolm_WTagjetUncertaintiesTool
 
asg::AnaToolHandle< ICPJetUncertaintiesToolm_ZTagjetUncertaintiesTool
 
asg::AnaToolHandle< ICPJetUncertaintiesToolm_TopTagjetUncertaintiesTool
 
SG::ReadDecorHandleKey< xAOD::JetContainerm_label_truthKey
 
std::string m_jesConfig
 
std::string m_jesConfigJMS
 
std::string m_jesConfigJMSData
 
std::string m_jesConfigAFII
 
std::string m_jesConfigFat
 
std::string m_jesConfigFatData
 
std::string m_jesCalibSeq
 
std::string m_jesCalibSeqJMS
 
std::string m_jesCalibSeqFat
 
std::string m_jesCalibArea
 
asg::AnaToolHandle< CP::IMuonSelectionToolm_muonSelectionTool
 
asg::AnaToolHandle< CP::IMuonSelectionToolm_muonSelectionHighPtTool
 
asg::AnaToolHandle< CP::IMuonSelectionToolm_muonSelectionToolBaseline
 
asg::AnaToolHandle< CP::IMuonCalibrationAndSmearingToolm_muonCalibTool
 
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactorsm_muonEfficiencySFTool
 
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactorsm_muonEfficiencyBMHighPtSFTool
 
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactorsm_muonTTVAEfficiencySFTool
 
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactorsm_muonIsolationSFTool
 
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactorsm_muonHighPtIsolationSFTool
 
asg::AnaToolHandle< CP::IMuonTriggerScaleFactorsm_muonTriggerSFTool
 
ToolHandleArray< CP::IMuonTriggerScaleFactorsm_muonTrigSFTools
 
asg::AnaToolHandle< CP::IMuonLRTOverlapRemovalToolm_muonLRTORTool
 
SG::WriteHandleKey< xAOD::MuonContainerm_outMuonLocation {this, "OutputMuonLocation", "StdWithLRTMuons", "name of the muon container to write"}
 
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionToolm_elecEfficiencySFTool_reco
 Combined muon collection. More...
 
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionToolm_elecEfficiencySFTool_id
 
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionToolm_elecEfficiencySFTool_trig_singleLep
 
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionToolm_elecEfficiencySFTool_trigEff_singleLep
 
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionToolm_elecEfficiencySFTool_iso
 
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionToolm_elecEfficiencySFTool_isoHighPt
 
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionToolm_elecEfficiencySFTool_chf
 
std::vector< asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > > m_elecEfficiencySFTool_trig_mixLep
 
std::vector< asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > > m_elecEfficiencySFTool_trigEff_mixLep
 
ToolHandleArray< IAsgElectronEfficiencyCorrectionToolm_elecTrigSFTools
 
ToolHandleArray< IAsgElectronEfficiencyCorrectionToolm_elecTrigEffTools
 
asg::AnaToolHandle< CP::IElectronLRTOverlapRemovalToolm_elecLRTORTool
 
SG::WriteHandleKey< xAOD::ElectronContainerm_outElectronLocation {this, "OutputElectronLocation", "StdWithLRTElectrons", "name of the muon container to write"}
 
asg::AnaToolHandle< CP::IEgammaCalibrationAndSmearingToolm_egammaCalibTool
 Combined electron collection. More...
 
asg::AnaToolHandle< IAsgElectronLikelihoodToolm_elecSelLikelihood
 
asg::AnaToolHandle< IAsgElectronLikelihoodToolm_elecSelLikelihoodBaseline
 
asg::AnaToolHandle< IAsgPhotonIsEMSelectorm_photonSelIsEM
 
asg::AnaToolHandle< IAsgPhotonIsEMSelectorm_photonSelIsEMBaseline
 
asg::AnaToolHandle< IAsgDeadHVCellRemovalToolm_deadHVTool
 
asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionToolm_photonEfficiencySFTool
 
asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionToolm_photonIsolationSFTool
 
asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionToolm_photonTriggerSFTool
 
std::vector< asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > > m_photonEfficiencySFTool_trigSF_AsymDiphoton
 
std::vector< asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > > m_photonEfficiencySFTool_trigEff_AsymDiphoton
 
ToolHandleArray< IAsgPhotonEfficiencyCorrectionToolm_photonTrigSFTools
 
ToolHandleArray< IAsgPhotonEfficiencyCorrectionToolm_photonTrigEffTools
 
asg::AnaToolHandle< IEGammaAmbiguityToolm_egammaAmbiguityTool
 
asg::AnaToolHandle< IAsgElectronLikelihoodToolm_elecChargeIDSelectorTool
 
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionToolm_elecChargeEffCorrTool
 
asg::AnaToolHandle< TauAnalysisTools::ITauSelectionToolm_tauSelTool
 
asg::AnaToolHandle< TauAnalysisTools::ITauSelectionToolm_tauSelToolBaseline
 
asg::AnaToolHandle< TauAnalysisTools::ITauSmearingToolm_tauSmearingTool
 
asg::AnaToolHandle< TauAnalysisTools::ITauTruthMatchingToolm_tauTruthMatch
 
asg::AnaToolHandle< TauAnalysisTools::ITauEfficiencyCorrectionsToolm_tauEffTool
 
std::vector< asg::AnaToolHandle< TauAnalysisTools::ITauEfficiencyCorrectionsTool > > m_tauTrigEffTool
 
asg::AnaToolHandle< IBTaggingEfficiencyToolm_btagEffTool
 
asg::AnaToolHandle< IBTaggingSelectionToolm_btagSelTool
 
asg::AnaToolHandle< IBTaggingSelectionToolm_btagSelTool_OR
 
asg::AnaToolHandle< IBTaggingEfficiencyToolm_btagEffTool_trkJet
 
asg::AnaToolHandle< IBTaggingSelectionToolm_btagSelTool_trkJet
 
asg::AnaToolHandle< IMETMakerm_metMaker
 
asg::AnaToolHandle< IMETSystematicsToolm_metSystTool
 
asg::AnaToolHandle< IMETSignificancem_metSignif
 
std::string m_trig2015combination_singleLep
 
std::string m_trig2016combination_singleLep
 
std::string m_trig2017combination_singleLep
 
std::string m_trig2018combination_singleLep
 
std::string m_trig2022combination_singleLep
 
int m_trigNToys_diLep
 
std::string m_trig2015combination_diLep
 
std::string m_trig2016combination_diLep
 
std::string m_trig2017combination_diLep
 
std::string m_trig2018combination_diLep
 
std::string m_trig2022combination_diLep
 
asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionToolm_trigGlobalEffCorrTool_diLep
 
int m_trigNToys_multiLep
 
std::string m_trig2015combination_multiLep
 
std::string m_trig2016combination_multiLep
 
std::string m_trig2017combination_multiLep
 
std::string m_trig2018combination_multiLep
 
std::string m_trig2022combination_multiLep
 
asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionToolm_trigGlobalEffCorrTool_multiLep
 
int m_trigNToys_diPhoton
 
std::string m_trig2015combination_diPhoton
 
std::string m_trig2016combination_diPhoton
 
std::string m_trig2017combination_diPhoton
 
std::string m_trig2018combination_diPhoton
 
std::string m_trig2022combination_diPhoton
 
asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionToolm_trigGlobalEffCorrTool_diPhoton
 
asg::AnaToolHandle< TrigConf::ITrigConfigToolm_trigConfTool
 
asg::AnaToolHandle< Trig::TrigDecisionToolm_trigDecTool
 
asg::AnaToolHandle< Trig::IMatchingToolm_trigMatchingTool
 
asg::AnaToolHandle< Trig::IMatchScoringToolm_trigMatchScoringTool
 
asg::AnaToolHandle< Trig::IMatchScoringToolm_trigDRScoringTool
 
asg::AnaToolHandle< CP::IIsolationCorrectionToolm_isoCorrTool
 
asg::AnaToolHandle< CP::IIsolationSelectionToolm_isoTool
 
asg::AnaToolHandle< CP::IIsolationSelectionToolm_isoBaselineTool
 
asg::AnaToolHandle< CP::IIsolationSelectionToolm_isoHighPtTool
 
asg::AnaToolHandle< CP::IIsolationCloseByCorrectionToolm_isoCloseByTool
 
asg::AnaToolHandle< CP::IPileupReweightingToolm_prwTool
 
asg::AnaToolHandle< InDet::IInclusiveTrackFilterToolm_LRTuncTool
 
asg::AnaToolHandle< ORUtils::IOverlapToolm_tauJetORtool
 
ORUtils::ToolBox m_orToolbox
 
asg::AnaToolHandle< IWeightToolm_pmgSHnjetWeighter
 
asg::AnaToolHandle< IWeightToolm_pmgSHnjetWeighterWZ
 
std::string m_eleIdBaselineDFName
 
std::string m_eleIdDFName
 
std::string m_photonIdBaselineDFName
 
std::string m_photonIdDFName
 
std::string m_jetCleanDFName
 
SG::ConstAccessor< char > m_acc_eleIdBaseline
 
SG::ConstAccessor< char > m_acc_eleId
 
SG::ConstAccessor< char > m_acc_photonIdBaseline
 
SG::ConstAccessor< char > m_acc_photonId
 
SG::ConstAccessor< char > m_acc_jetClean
 

Private Types

typedef ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

StatusCode SUSYToolsInit ()
 
bool emulateHLT (const std::string &triggerName) const
 
bool isTrigInTDT (std::scoped_lock< std::mutex > &lock, const std::string &triggerName) const
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

std::map< std::string, std::string > m_conf_to_prop
 
std::set< std::string > m_bool_prop_set
 
std::map< std::string, std::function< bool()> > m_metTriggerFuncs ATLAS_THREAD_SAFE
 
std::map< std::string, bool > m_checkedTriggers ATLAS_THREAD_SAFE
 
std::mutex m_triggerCacheMutex
 
std::vector< std::string > m_v_trigs15_cache_singleEle
 
std::vector< std::string > m_v_trigs16_cache_singleEle
 
std::vector< std::string > m_v_trigs17_cache_singleEle
 
std::vector< std::string > m_v_trigs18_cache_singleEle
 
std::vector< std::string > m_v_trigs22_cache_singleEle
 
std::vector< std::string > m_v_trigs15_cache_singleLep
 
std::vector< std::string > m_v_trigs16_cache_singleLep
 
std::vector< std::string > m_v_trigs17_cache_singleLep
 
std::vector< std::string > m_v_trigs18_cache_singleLep
 
std::vector< std::string > m_v_trigs22_cache_singleLep
 
std::vector< std::string > m_v_trigs15_cache_diLep
 
std::vector< std::string > m_v_trigs16_cache_diLep
 
std::vector< std::string > m_v_trigs17_cache_diLep
 
std::vector< std::string > m_v_trigs18_cache_diLep
 
std::vector< std::string > m_v_trigs22_cache_diLep
 
std::vector< std::string > m_v_trigs15_cache_multiLep
 
std::vector< std::string > m_v_trigs16_cache_multiLep
 
std::vector< std::string > m_v_trigs17_cache_multiLep
 
std::vector< std::string > m_v_trigs18_cache_multiLep
 
std::vector< std::string > m_v_trigs22_cache_multiLep
 
SG::ReadHandleKey< xAOD::TrackParticleContainerm_LRTCollectionName {this, "LRTCollectionName", "InDetLargeD0TrackParticles", "LRT collection name"}
 
SG::ReadHandleKey< xAOD::TrackParticleContainerm_GSFLRTCollectionName {this, "GSFLRTCollectionName", "LRTGSFTrackParticles", "GSF LRT collection name"}
 
MetaStore_t m_inputMetaStore
 Object accessing the input metadata store. More...
 
MetaStore_t m_outputMetaStore
 Object accessing the output metadata store. More...
 
bool m_beginInputFileCalled
 Flag helping to discover when the tool misses the opening of the first input file. More...
 
bool m_useIncidents
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Callback functions helping in metadata reading/writing

void setUseIncidents (const bool flag)
 
virtual void handle (const Incident &inc)
 Function receiving incidents from IncidentSvc/TEvent. More...
 
virtual StatusCode beginInputFile ()
 Function called when a new input file is opened. More...
 
virtual StatusCode endInputFile ()
 Function called when the currently open input file got completely processed. More...
 
virtual StatusCode beginEvent ()
 Function called when a new events is loaded. More...
 
virtual StatusCode metaDataStop ()
 Function called when the tool should write out its metadata. More...
 

Detailed Description

Definition at line 140 of file SUSYObjDef_xAOD.h.

Member Typedef Documentation

◆ MetaStore_t

Type of the metadata store object in Athena.

Definition at line 66 of file AsgMetadataTool.h.

◆ MetaStorePtr_t

Type of the metadata store pointer in standalone mode.

Definition at line 68 of file AsgMetadataTool.h.

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ DataSource

Enumerator
Undefined 
Data 
FullSim 
AtlfastII 

Definition at line 475 of file ISUSYObjDef_xAODTool.h.

475  {
476  Undefined = -1,
477  Data,
478  FullSim,
479  AtlfastII
480  };

Constructor & Destructor Documentation

◆ SUSYObjDef_xAOD()

ST::SUSYObjDef_xAOD::SUSYObjDef_xAOD ( const std::string &  name)

Override for the b-tagging jet collection

Definition at line 101 of file SUSYObjDef_xAOD.cxx.

105  m_force_noElId(false),
106  m_force_noMuId(false),
107  m_doTTVAsf(true),
110  m_useBtagging(false),
111  m_useBtagging_trkJet(false),
112  m_debug(false),
113  m_strictConfigCheck(false),
114  m_badJetCut(""),
115  m_fatJetUncConfig(""),
116  m_fatJetUncVars(""),
117  m_WDecorName(""),
118  m_ZDecorName(""),
119  m_TopDecorName(""),
120  m_WtagConfig(""),
121  m_ZtagConfig(""),
122  m_ToptagConfig(""),
125  m_WTagUncConfig(""),
126  m_ZTagUncConfig(""),
127  m_TopTagUncConfig(""),
129  m_tool_init(false),
130  m_subtool_init(false),
131  // set dummies for configuration
132  m_eleTerm(""),
133  m_gammaTerm(""),
134  m_tauTerm(""),
135  m_jetTerm(""),
136  m_muonTerm(""),
137  m_inputMETSuffix(""),
138  m_outMETTerm(""),
141  m_metDoRemoveMuonJets(true),
142  m_metUseGhostMuons(false),
143  m_metDoMuonEloss(false),
144  m_metGreedyPhotons(false),
145  m_metVeryGreedyPhotons(false),
147  m_trkMETsyst(true),
148  m_caloMETsyst(false),
149  m_softTermParam(-99),
150  m_treatPUJets(true),
151  m_doPhiReso(true),
152  m_autoconfigPRW(false),
156  m_autoconfigPRWRPVmode(false),
158  m_mcCampaign(""),
159  m_mcChannel(-99),
160  m_useCommonPRWFiles(false),
169  m_prwDataSF(-99.),
170  m_prwDataSF_UP(-99.),
171  m_prwDataSF_DW(-99.),
174  m_eleId(""),
175  m_eleIdBaseline(""),
176  m_eleConfig(""),
179  m_eleIdExpert(false),
180  m_muId(static_cast<int>(xAOD::Muon::Quality(xAOD::Muon::VeryLoose))),
181  m_muIdBaseline(static_cast<int>(xAOD::Muon::Quality(xAOD::Muon::VeryLoose))),
182  m_photonId(""),
183  m_photonIdBaseline(""),
184  m_tauId(""),
185  m_tauIdBaseline(""),
186  m_eleIso_WP(""),
187  m_eleIsoHighPt_WP(""),
188  m_eleIsoHighPtThresh(-99.),
189  m_eleChID_WP(""),
190  m_eleLRT_strat(-99),
191  m_eleChIso(true),
192  m_eleChID_signal(false),
193  m_runECIS(false),
195  m_photonIso_WP(""),
197  m_muBaselineIso_WP(""),
198  m_muIso_WP(""),
199  m_muIsoHighPt_WP(""),
200  m_muIsoHighPtThresh(-99.),
201  m_muHighPtExtraSmear(false),
202  m_muEffCorrForce1D(false),
203  m_BtagWP(""),
204  m_BtagTagger(""),
205  m_BtagMinPt(-99.),
206  m_BtagKeyOverride(""),
207  m_BtagSystStrategy(""),
211  m_BtagWP_trkJet(""),
213  m_BtagMinPt_trkJet(-99.),
214  //configurable cuts here
215  m_eleBaselinePt(-99.),
216  m_eleBaselineEta(-99.),
217  m_eleBaselineCrackVeto(false),
218  m_elePt(-99.),
219  m_eleEta(-99.),
220  m_eleCrackVeto(false),
221  m_eled0sig(-99.),
222  m_elez0(-99.),
223  m_elebaselined0sig(-99.),
224  m_elebaselinez0(-99),
226  m_eleForceFullSimCalib(false),
227  //
228  m_muBaselinePt(-99.),
229  m_muBaselineEta(-99.),
230  m_muPt(-99.),
231  m_muEta(-99.),
232  m_mud0sig(-99.),
233  m_muz0(-99.),
234  m_mubaselined0sig(-99.),
235  m_mubaselinez0(-99.),
237  m_muCosmicz0(-99.),
238  m_muCosmicd0(-99.),
239  m_badmuQoverP(-99.),
240  m_muCalibrationMode(-99.),
241  //
242  m_photonBaselinePt(-99.),
243  m_photonBaselineEta(-99.),
244  m_photonEta(-99.),
245  m_photonPt(-99.),
247  m_photonCrackVeto(true),
248  m_photonAllowLate(false),
249  //
250  m_tauPrePtCut(-99.),
251  m_tauPt(-99.),
252  m_tauEta(-99.),
253  m_tauConfigPath(""),
255  m_tauDoTTM(false),
258  //
259  m_jetPt(-99.),
260  m_jetEta(-99.),
261  m_jetJvt(-99.),
262  m_JvtWP(""),
263  m_JvtPtMax(-99.),
264  m_JvtConfigRun2(""),
265  m_JvtConfigRun3(""),
266  m_trkJetPt(-99.),
267  m_trkJetEta(-99.),
268  m_doFwdJVT(false),
269  m_fJvtWP(""),
270  m_fJvtPtMax(-99.),
271  m_fJvtEtaMin(-99.),
272  m_fJvtConfigRun2(""),
273  m_fJvtConfigRun3(""),
274  m_JMScalib(false),
275  //
276  m_orDoTau(false),
277  m_orDoPhoton(false),
278  m_orDoEleJet(true),
279  m_orDoElEl(false),
280  m_orDoElMu(false),
281  m_orDoMuonJet(true),
282  m_orDoBjet(false),
283  m_orDoElBjet(true),
284  m_orDoMuBjet(true),
285  m_orDoTauBjet(true),
286  m_orDoBoostedElectron(false),
287  m_orBoostedElectronC1(-999.), // set to positive value to activate
288  m_orBoostedElectronC2(-999.), // set to positive value to activate
289  m_orBoostedElectronMaxConeSize(-999.), // set to positive value to activate
290  m_orDoBoostedMuon(true),
291  m_orBoostedMuonC1(-999.), // set to positive value to activate
292  m_orBoostedMuonC2(-999.), // set to positive value to activate
293  m_orBoostedMuonMaxConeSize(-999.), // set to positive value to activate
294  m_orApplyRelPt(false),
295  m_orMuJetPtRatio(-999.),
296  m_orMuJetTrkPtRatio(-999.),
297  m_orMuJetInnerDR(-999),
299  m_orRemoveCaloMuons(true),
300  m_orBtagWP(""),
301  m_orInputLabel(""),
302  m_orPhotonFavoured(false),
303  m_orBJetPtUpperThres(-999.),
304  m_orLinkOverlapObjects(false),
305  m_orDoFatjets(false),
306  m_EleFatJetDR(-999.),
307  m_JetFatJetDR(-999.),
308  m_doIsoSignal(true),
309  m_doElIsoSignal(true),
310  m_doPhIsoSignal(true),
311  m_doMuIsoSignal(true),
312 
315 
316  m_useTRUTH3(true),
317 
318  m_slices(std::map<std::string,bool>()),
319  m_isRun3(false),
320  m_isPHYSLITE(false),
321 
322  m_metJetSelection(""),
323  m_fatJets(""),
324  //
325  m_currentSyst(),
326  m_EG_corrModel(""),
327  m_EG_corrFNList(""),
328  m_applyJVTCut(true),
329  //
330  // set toolhandles empty by default
331  m_jetCalibTool(""),
332  m_jetFatCalibTool(""),
336  m_jetCleaningTool(""),
338  m_jetJvtMomentTool(""),
344  //
345  m_WTaggerTool(""),
346  m_ZTaggerTool(""),
347  m_TopTaggerTool(""),
352  //
356  m_muonCalibTool(""),
363  //
370  //
371  m_egammaCalibTool(""),
374  m_photonSelIsEM(""),
382  //
383  m_tauSelTool(""),
385  m_tauSmearingTool(""),
386  m_tauTruthMatch(""),
387  m_tauEffTool(""),
388  //
389  m_btagEffTool(""),
390  m_btagSelTool(""),
391  m_btagSelTool_OR(""),
394  //
395  m_metMaker(""),
396  m_metSystTool(""),
397  m_metSignif(""),
398  //
404  m_trigNToys_diLep(-99),
425  m_trigConfTool(""),
426  m_trigDecTool(""),
427  m_trigMatchingTool(""),
430  //
431  m_isoCorrTool(""),
432  m_isoTool(""),
433  //disable m_isoToolLowPtPLV(""),
434  m_isoBaselineTool(""),
435  m_isoHighPtTool(""),
436  //
437  m_prwTool(""),
438  //
439  m_LRTuncTool(""),
440  //
441  m_orToolbox("ORToolbox",this),
442  //
445  //
446  m_acc_eleIdBaseline("DFCommonElectronsLHLooseBL"),
447  m_acc_eleId("DFCommonElectronsLHTight"),
448  m_acc_photonIdBaseline("DFCommonPhotonsIsEMTight"),
449  m_acc_photonId("DFCommonPhotonsIsEMTight"),
450  //
451  m_acc_jetClean("DFCommonJets_jetClean_LooseBad")
452 {
453  //General settings
454  declareProperty( "DataSource", m_dataSource = Undefined );
455  declareProperty( "DebugMode", m_debug );
456  declareProperty( "ConfigFile", m_configFile = "SUSYTools/SUSYTools_Default.conf" );
457  //Overlap Removal
458  declareProperty( "DoTauOR", m_orDoTau );
459  declareProperty( "DoPhotonOR", m_orDoPhoton );
460  declareProperty( "DoEleJetOR", m_orDoEleJet );
461  declareProperty( "DoElElOR", m_orDoElEl );
462  declareProperty( "DoElMuOR", m_orDoElMu );
463  declareProperty( "DoMuonJetOR", m_orDoMuonJet );
464  declareProperty( "DoBjetOR", m_orDoBjet );
465  declareProperty( "DoElBjetOR", m_orDoElBjet );
466  declareProperty( "DoMuBjetOR", m_orDoMuBjet );
467  declareProperty( "DoTauBjetOR", m_orDoTauBjet );
468  declareProperty( "UseBtagging", m_useBtagging );
469  declareProperty( "UseBtaggingTrkJet", m_useBtagging_trkJet );
470  declareProperty( "DoBoostedElectronOR", m_orDoBoostedElectron );
471  declareProperty( "BoostedElectronORC1", m_orBoostedElectronC1 );
472  declareProperty( "BoostedElectronORC2", m_orBoostedElectronC2 );
473  declareProperty( "BoostedElectronORMaxConeSize", m_orBoostedElectronMaxConeSize );
474  declareProperty( "DoBoostedMuonOR", m_orDoBoostedMuon );
475  declareProperty( "BoostedMuonORC1", m_orBoostedMuonC1 );
476  declareProperty( "BoostedMuonORC2", m_orBoostedMuonC2 );
477  declareProperty( "BoostedMuonORMaxConeSize", m_orBoostedMuonMaxConeSize );
478  declareProperty( "ORDoMuonJetGhostAssociation", m_orDoMuonJetGhostAssociation );
479  declareProperty( "ORRemoveCaloMuons", m_orRemoveCaloMuons );
480  declareProperty( "ORMuJetApplyRelPt", m_orApplyRelPt);
481  declareProperty( "ORMuJetPtRatio", m_orMuJetPtRatio);
482  declareProperty( "ORMuJetInnerDR", m_orMuJetInnerDR );
483  declareProperty( "ORJetTrkPtRatio", m_orMuJetTrkPtRatio);
484  declareProperty( "ORInputLabel", m_orInputLabel);
485  declareProperty( "ORPhotonFavoured", m_orPhotonFavoured);
486  declareProperty( "ORBJetPtUpperThres", m_orBJetPtUpperThres);
487  declareProperty( "ORLinkOverlapObjects", m_orLinkOverlapObjects);
488 
489  declareProperty( "DoFatJetOR", m_orDoFatjets);
490  declareProperty( "OREleFatJetDR", m_EleFatJetDR);
491  declareProperty( "ORJetFatJetDR", m_JetFatJetDR);
492  declareProperty( "TriggerUpstreamMatching", m_upstreamTriggerMatching, "Use alternative trigger matching tool based on upstream (in-derivation) matching");
493  declareProperty( "TriggerMatchingPrefix", m_trigMatchingPrefix, "Prefix for trigger matching containers (Analysis for PHSYLITE derivations");
494 
495  //--- Object definitions
496  //MET
497  declareProperty( "METEleTerm", m_eleTerm );
498  declareProperty( "METGammaTerm", m_gammaTerm );
499  declareProperty( "METTauTerm", m_tauTerm );
500  declareProperty( "METJetTerm", m_jetTerm );
501  declareProperty( "METMuonTerm", m_muonTerm );
502  declareProperty( "METInputSuffix", m_inputMETSuffix );
503  declareProperty( "METOutputTerm", m_outMETTerm );
504  declareProperty( "METDoTrkSyst", m_trkMETsyst );
505  declareProperty( "METDoCaloSyst", m_caloMETsyst );
506  declareProperty( "METDoTrkJetSyst", m_trkJetsyst );
507  declareProperty( "METJetSelection", m_metJetSelection );
508  declareProperty( "METSysConfigPrefix", m_metsysConfigPrefix );
509 
510  declareProperty( "METRemoveORCaloTaggedMuons", m_metRemoveOverlappingCaloTaggedMuons);
511  declareProperty( "METDoSetMuonJetEMScale", m_metDoSetMuonJetEMScale);
512  declareProperty( "METDoRemoveMuonJets", m_metDoRemoveMuonJets );
513  declareProperty( "METUseGhostMuons", m_metUseGhostMuons );
514  declareProperty( "METDoMuonEloss", m_metDoMuonEloss );
515  declareProperty( "METDoGreedyPhotons", m_metGreedyPhotons );
516  declareProperty( "METDoVeryGreedyPhotons", m_metVeryGreedyPhotons );
517 
518 
519  declareProperty( "SoftTermParam", m_softTermParam);
520  declareProperty( "TreatPUJets", m_treatPUJets);
521  declareProperty( "DoPhiReso", m_doPhiReso);
522 
523  //JETS
524  declareProperty( "JetInputType", m_jetInputType );
525 
526  declareProperty( "FwdJetDoJVT", m_doFwdJVT );
527 
528  declareProperty( "JetJMSCalib", m_JMScalib );
529  declareProperty( "JetLargeRcollection", m_fatJets );
530 
531  //BTAGGING
532  declareProperty( "BtagTagger", m_BtagTagger);
533  declareProperty( "BtagWPOR", m_orBtagWP); //the one used in the Overlap Removal
534  declareProperty( "BtagWP", m_BtagWP); //the one used in FillJet() afterwards
535  declareProperty( "BtagMinPt", m_BtagMinPt); // minimum jetPt cut (MR31061) >=20 GeV EM jets & >=10 GeV TrackJets (not calibrated below)
536  declareProperty( "BtagKeyOverride", m_BtagKeyOverride);
538  declareProperty( "BtagTaggerTrkJet", m_BtagTagger_trkJet);
539  declareProperty( "BtagMinPtTrkJet", m_BtagMinPt_trkJet); // minimum jetPt cut (MR31061) >=20 GeV EM jets & >=10 GeV TrackJets (not calibrated below)
540  declareProperty( "BtagWPTrkJet", m_BtagWP_trkJet); //the one used in FillTrackJet() afterwards
541  //ELECTRONS
542  declareProperty( "EleBaselinePt", m_eleBaselinePt);
543  declareProperty( "ElePt", m_elePt);
544  declareProperty( "EleBaselineEta", m_eleBaselineEta);
545  declareProperty( "EleEta", m_eleEta);
546  declareProperty( "EleBaselineId", m_eleIdBaseline);
547  declareProperty( "EleBaselineConfig", m_eleConfigBaseline);
548  declareProperty( "EleBaselineCrackVeto", m_eleBaselineCrackVeto);
549  declareProperty( "EleId", m_eleId);
550  declareProperty( "EleConfig", m_eleConfig);
551  declareProperty( "EleIso", m_eleIso_WP);
552  declareProperty( "EleIsoHighPt", m_eleIsoHighPt_WP);
553  declareProperty( "EleIsoHighPtThresh", m_eleIsoHighPtThresh);
554  declareProperty( "EleCFT", m_eleChID_WP);
555  declareProperty( "EleCFTIso", m_eleChIso);
556  declareProperty( "EleCFTSignal", m_eleChID_signal);
557  declareProperty( "EleD0sig", m_eled0sig);
558  declareProperty( "EleZ0", m_elez0);
559  declareProperty( "EleBaselineD0sig", m_elebaselined0sig);
560  declareProperty( "EleBaselineZ0", m_elebaselinez0);
561  declareProperty( "EleCrackVeto", m_eleCrackVeto);
562  declareProperty( "EleForceNoId", m_force_noElId );
563  declareProperty( "EleEffMapFilePath", m_eleEffMapFilePath);
564  declareProperty( "EleAllowRun3TrigSFFallback", m_eleAllowRun3TrigSFFallback);
565  declareProperty( "EleForceFullSimCalib", m_eleForceFullSimCalib);
566 
567  //MUONS
568  declareProperty( "MuonBaselinePt", m_muBaselinePt);
569  declareProperty( "MuonPt", m_muPt);
570  declareProperty( "MuonBaselineEta", m_muBaselineEta);
571  declareProperty( "MuonEta", m_muEta);
572  declareProperty( "MuonBaselineId", m_muIdBaseline);
573  declareProperty( "MuonId", m_muId);
574  declareProperty( "MuonIso", m_muIso_WP);
575  declareProperty( "MuonIsoHighPt", m_muIsoHighPt_WP);
576  declareProperty( "MuonIsoHighPtThresh", m_muIsoHighPtThresh);
577  declareProperty( "MuonHighPtExtraSmear", m_muHighPtExtraSmear);
578  declareProperty( "MuonEffCorrForce1D", m_muEffCorrForce1D);
579  declareProperty( "MuonD0sig", m_mud0sig);
580  declareProperty( "MuonZ0", m_muz0);
581  declareProperty( "MuonBaselineD0sig", m_mubaselined0sig);
582  declareProperty( "MuonBaselineZ0", m_mubaselinez0);
583  declareProperty( "MuonRequireHighPtCuts", m_murequirepassedHighPtCuts);
584  declareProperty( "MuonForceNoId", m_force_noMuId );
585  declareProperty( "MuonTTVASF", m_doTTVAsf );
586  declareProperty( "MuonCalibrationMode", m_muCalibrationMode);
587 
588  //PHOTONS
589  declareProperty( "PhotonBaselinePt", m_photonBaselinePt);
590  declareProperty( "PhotonPt", m_photonPt);
591  declareProperty( "PhotonBaselineEta", m_photonBaselineEta);
592  declareProperty( "PhotonEta", m_photonEta);
593  declareProperty( "PhotonBaselineId", m_photonIdBaseline);
594  declareProperty( "PhotonId", m_photonId);
595  declareProperty( "PhotonIso", m_photonIso_WP);
596  declareProperty( "PhotonTriggerName", m_photonTriggerName);
597  declareProperty( "PhotonBaselineCrackVeto", m_photonBaselineCrackVeto);
598  declareProperty( "PhotonCrackVeto", m_photonCrackVeto);
599  declareProperty( "PhotonAllowLate", m_photonAllowLate);
600 
601  //TAUS
602  declareProperty( "TauBaselineId", m_tauIdBaseline);
603  declareProperty( "TauId", m_tauId);
604  declareProperty( "TauIdConfigPathBaseline", m_tauConfigPathBaseline);
605  declareProperty( "TauIdConfigPath", m_tauConfigPath);
606  declareProperty( "TauDoTruthMatching", m_tauDoTTM);
607  declareProperty( "TauSmearingToolRecommendationTag", m_tauSmearingToolRecommendationTag);
608  declareProperty( "TauSmearingToolGenerator", m_tauSmearingToolGenerator);
609 
610  //Leptons
611  declareProperty( "SigLepRequireIso", m_doIsoSignal ); //leave here for back-compatibility
612  declareProperty( "SigElRequireIso", m_doElIsoSignal );
613  declareProperty( "SigMuRequireIso", m_doMuIsoSignal );
614  declareProperty( "SigPhRequireIso", m_doPhIsoSignal );
615 
616  //Isolation correction for leptons and photons
617  declareProperty( "UseSigLepForIsoCloseByOR", m_useSigLepForIsoCloseByOR );
618  declareProperty( "IsoCloseByORpassLabel", m_IsoCloseByORpassLabel );
619 
620  //Truth
621  declareProperty( "UseTRUTH3", m_useTRUTH3 ); // true if using TRUTH3 type containers
622 
623  //--- Tools configuration
624  //PRW
625  declareProperty( "AutoconfigurePRWTool", m_autoconfigPRW );
626  declareProperty( "AutoconfigurePRWToolPath", m_autoconfigPRWPath ); // e.g. dev/PileupReweighting/share/
627  declareProperty( "AutoconfigurePRWToolFile", m_autoconfigPRWFile ); // e.g. DSID407xxx/pileup_mc16a_dsid407352_FS.root
628  declareProperty( "AutoconfigurePRWToolCombinedmode", m_autoconfigPRWCombinedmode );
629  declareProperty( "AutoconfigurePRWToolRPVmode", m_autoconfigPRWRPVmode );
630  declareProperty( "AutoconfigurePRWToolRtags", m_autoconfigPRWRtags );
631  declareProperty( "mcCampaign", m_mcCampaign );
632  declareProperty( "mcChannel", m_mcChannel );
633  declareProperty( "PRWConfigFiles", m_prwConfFiles );
634  declareProperty( "PRWLumiCalcFiles", m_prwLcalcFiles );
635  declareProperty( "PRWActualMu2017File", m_prwActualMu2017File );
636  declareProperty( "PRWActualMu2018File", m_prwActualMu2018File );
637  declareProperty( "PRWActualMu2022File", m_prwActualMu2022File );
638  declareProperty( "PRWActualMu2023File", m_prwActualMu2023File );
639  declareProperty( "PRWActualMu2024File", m_prwActualMu2024File );
640  declareProperty( "PRWDataScaleFactor", m_prwDataSF);
641  declareProperty( "PRWDataScaleFactorUP", m_prwDataSF_UP);
642  declareProperty( "PRWDataScaleFactorDOWN", m_prwDataSF_DW);
643  declareProperty( "PRWUseRunDependentPrescaleWeight", m_runDepPrescaleWeightPRW);
644  declareProperty( "PRWUseCommonMCFiles", m_useCommonPRWFiles);
645  declareProperty( "PRWCommonFileMC20a", m_commonPRWFileMC20a);
646  declareProperty( "PRWCommonFileMC20d", m_commonPRWFileMC20d);
647  declareProperty( "PRWCommonFileMC20e", m_commonPRWFileMC20e);
648  declareProperty( "PRWCommonFileMC21a", m_commonPRWFileMC21a);
649  declareProperty( "PRWCommonFileMC23a", m_commonPRWFileMC23a);
650  declareProperty( "PRWCommonFileMC23c", m_commonPRWFileMC23c);
651  declareProperty( "PRWCommonFileMC23d", m_commonPRWFileMC23d);
652  declareProperty( "PRWCommonFileMC23e", m_commonPRWFileMC23e);
653  //LargeR uncertainties config, as from https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/JetUncertainties2016PrerecLargeR#Understanding_which_configuratio
654  declareProperty( "JetLargeRuncConfig", m_fatJetUncConfig );
655  declareProperty( "JetLargeRuncVars", m_fatJetUncVars );
656  declareProperty( "JetWtaggerConfig", m_WtagConfig );
657  declareProperty( "JetZtaggerConfig", m_ZtagConfig );
658  declareProperty( "JetWZTaggerCalibArea", m_WZTaggerCalibArea );
659  declareProperty( "JetToptaggerConfig", m_ToptagConfig );
660  declareProperty( "JetTruthLabelName", m_JetTruthLabelName );
661  declareProperty( "JetTopTaggerCalibArea", m_TopTaggerCalibArea );
662  declareProperty( "JetWTaguncConfig", m_WTagUncConfig );
663  declareProperty( "JetZTaguncConfig", m_ZTagUncConfig );
664  declareProperty( "JetTopTaguncConfig", m_TopTagUncConfig );
665  //Btagging MCtoMC SFs
666  declareProperty( "ShowerType", m_showerType = 0 );
667  //Egamma NP correlation model
668  declareProperty( "EleEffNPcorrModel", m_EG_corrModel );
669  //Egamma correction file list override
670  declareProperty( "EleEffCorrFNList", m_EG_corrFNList );
671  declareProperty( "IsRun3", m_isRun3 );
672  declareProperty( "IsPHYSLITE", m_isPHYSLITE );
673 
674  //For electron trigger SF tools
675  declareProperty( "ElectronTriggerSFStringSingle", m_electronTriggerSFStringSingle);
676 
677  //--- Tool pointers /MT : we may want to improve the descriptions :)
678  m_jetCalibTool.declarePropertyFor( this, "JetCalibTool", "The JetCalibTool" );
679  m_jetFatCalibTool.declarePropertyFor( this, "FatJetCalibTool", "The JetCalibTool for large-R jets" );
680  m_jetUncertaintiesTool.declarePropertyFor( this, "JetUncertaintiesTool", "The JetUncertaintiesTool" );
681  m_jetUncertaintiesPDSmearTool.declarePropertyFor( this, "JetPDSmearUncertaintiesTool", "The JetPDSmearUncertaintiesTool" );
682  m_fatjetUncertaintiesTool.declarePropertyFor( this, "FatJetUncertaintiesTool", "The JetUncertaintiesTool for large-R jets" );
683  m_WTagjetUncertaintiesTool.declarePropertyFor( this, "WJetUncertaintiesTool", "The JetUncertaintiesTool for large-R W-tagged jets" );
684  m_ZTagjetUncertaintiesTool.declarePropertyFor( this, "ZJetUncertaintiesTool", "The JetUncertaintiesTool for large-R Z-tagged jets" );
685  m_TopTagjetUncertaintiesTool.declarePropertyFor( this, "TopJetUncertaintiesTool", "The JetUncertaintiesTool for large-R Top-tagged jets" );
686  m_jetCleaningTool.declarePropertyFor( this, "JetCleaningTool", "The JetCleaningTool" );
687  m_jetPileupLabelingTool.declarePropertyFor( this, "JetPileupLabelingTool", "The JetPileupLabelingTool" );
688  m_jetJvtMomentTool.declarePropertyFor( this, "JetJvtMomentTool", "The JetJvtMomentTool" );
689  m_jetNNJvtMomentTool.declarePropertyFor( this, "JetNNJvtMomentTool", "The JetNNJvtMomentTool" );
690  m_jetNNJvtSelectionTool.declarePropertyFor( this, "JetNNJvtSelectionTool", "The JetNNJvtSelectionTool" );
691  m_jetNNJvtEfficiencyTool.declarePropertyFor( this, "JetNNJvtEfficiencyTool", "The JetNNJvtEfficiencyTool" );
692  m_jetfJvtSelectionTool.declarePropertyFor( this, "JetfJvtSelectionTool", "The JetfJvtSelectionTool" );
693  m_jetfJvtEfficiencyTool.declarePropertyFor( this, "JetfJvtEfficiencyTool", "The JetfJvtEfficiencyTool" );
694  //
695  m_WTaggerTool.declarePropertyFor( this, "WTaggerTool", "The SmoothedWZTaggerTool" );
696  m_ZTaggerTool.declarePropertyFor( this, "ZTaggerTool", "The SmoothedWZTaggerTool" );
697  m_TopTaggerTool.declarePropertyFor( this, "TopTaggerTool", "The DNNTopTaggerTool" );
698  m_jetTruthLabelingTool.declarePropertyFor( this, "JetTruthLabelingTool", "The JetTruthLabelingTool" );
699  //
700  m_muonSelectionTool.declarePropertyFor( this, "MuonSelectionTool", "The MuonSelectionTool for signal muons" );
701  m_muonSelectionHighPtTool.declarePropertyFor( this, "MuonSelectionHighPtTool", "The MuonSelectionTool for signal muons (HighPt WP)" );
702  m_muonSelectionToolBaseline.declarePropertyFor( this, "MuonSelectionToolBaseline", "The MuonSelectionTool for baseline muons" );
703  m_muonCalibTool.declarePropertyFor( this, "MuonCalibTool", "The MuonCalibTool" );
704  m_muonEfficiencySFTool.declarePropertyFor( this, "MuonEfficiencyScaleFactorsTool", "The MuonEfficiencySFTool" );
705  m_muonEfficiencyBMHighPtSFTool.declarePropertyFor( this, "MuonBadMuonHighPtScaleFactorsTool", "The MuonBadMuonHighPtSFTool" );
706  m_muonTTVAEfficiencySFTool.declarePropertyFor( this, "MuonTTVAEfficiencyScaleFactorsTool", "The MuonTTVAEfficiencySFTool" );
707  m_muonIsolationSFTool.declarePropertyFor( this, "MuonIsolationScaleFactorsTool", "The MuonIsolationSFTool" );
708  m_muonHighPtIsolationSFTool.declarePropertyFor( this, "MuonHighPtIsolationScaleFactorsTool", "The MuonIsolationSFTool" );
709  m_muonTriggerSFTool.declarePropertyFor( this, "MuonTriggerScaleFactorsTool", "The MuonTriggerSFTool" );
710  m_muonLRTORTool.declarePropertyFor( this, "MuonLRTOverlapRemovalTool", "Prompt/LRT muon OR Tool" );
711  //
712  m_elecEfficiencySFTool_reco.declarePropertyFor( this, "ElectronEfficiencyCorrectionTool_reco", "The ElectronEfficiencyCorrectionTool for reconstruction SFs" );
713  m_elecEfficiencySFTool_trig_singleLep.declarePropertyFor( this, "ElectronEfficiencyCorrectionTool_trig_singleLep", "The ElectronEfficiencyCorrectionTool for single-e triggers" );
714  m_elecEfficiencySFTool_id.declarePropertyFor( this, "ElectronEfficiencyCorrectionTool_id", "The ElectronEfficiencyCorrectionTool for ID SFs" );
715  m_elecEfficiencySFTool_iso.declarePropertyFor( this, "ElectronEfficiencyCorrectionTool_iso" , "The ElectronEfficiencyCorrectionTool for iso SFs" );
716  m_elecEfficiencySFTool_isoHighPt.declarePropertyFor( this, "ElectronEfficiencyCorrectionTool_isoHigPt" , "The ElectronEfficiencyCorrectionTool for iso high-pt SFs" );
717  m_elecSelLikelihood.declarePropertyFor( this, "ElectronLikelihoodTool" , "The ElectronSelLikelihoodTool for signal electrons" );
718  m_elecSelLikelihoodBaseline.declarePropertyFor( this, "ElectronLikelihoodToolBaseline" , "The ElectronSelLikelihoodTool for baseline electrons" );
719  m_egammaAmbiguityTool.declarePropertyFor( this, "EgammaAmbiguityTool", "The EgammaAmbiguityTool" );
720  m_elecChargeIDSelectorTool.declarePropertyFor( this, "ElectronChargeIDSelectorTool", "The ElectronChargeIDSelectorTool" );
721  m_elecChargeEffCorrTool.declarePropertyFor( this, "ElectronChargeEffCorrectionTool", "The ElectronChargeEffCorrectionTool" );
722  m_elecLRTORTool.declarePropertyFor( this, "ElectronLRTOverlapRemovalTool", "Prompt/LRT electron OR Tool" );
723  //
724  m_photonSelIsEM.declarePropertyFor( this, "PhotonIsEMSelector" , "The PhotonIsEMSelectorTool for signal photons" );
725  m_photonSelIsEMBaseline.declarePropertyFor( this, "PhotonIsEMSelectorBaseline" , "The PhotonIsEMSelectorTool for baseline photons" );
726  m_photonEfficiencySFTool.declarePropertyFor( this, "PhotonEfficiencyCorrectionTool", "The PhotonEfficiencyCorrectionTool for reco SFs" );
727  m_photonIsolationSFTool.declarePropertyFor( this, "PhotonIsolationCorrectionTool", "The PhotonEfficiencyCorrectionTool for iso SFs" );
728  m_photonTriggerSFTool.declarePropertyFor( this, "PhotonTriggerEfficiencyCorrectionTool", "The PhotonEfficiencyCorrectionTool for trigger SFs" );
729  //
730  m_egammaCalibTool.declarePropertyFor( this, "EgammaCalibrationAndSmearingTool", "The EgammaCalibrationAndSmearingTool");
731  //
732  m_tauSelTool.declarePropertyFor( this, "TauSelectionTool", "The TauSelectionTool for signal taus" );
733  m_tauSelToolBaseline.declarePropertyFor( this, "TauSelectionToolBaseline", "The TauSelectionTool for baseline taus" );
734  m_tauSmearingTool.declarePropertyFor( this, "TauSmearingTool", "The TauSmearingTool" );
735  m_tauTruthMatch.declarePropertyFor( this, "TauTruthMatch", "The TTMT" );
736  m_tauEffTool.declarePropertyFor( this, "TauEfficiencyCorrectionsTool", "The TauEfficiencyCorrectionsTool" );
737  //
738  m_btagEffTool.declarePropertyFor( this, "BTaggingEfficiencyTool", "The BTaggingEfficiencyTool" );
739  m_btagSelTool.declarePropertyFor( this, "BTaggingSelectionTool", "The main BTaggingSelectionTool" );
740  m_btagSelTool_OR.declarePropertyFor( this, "BTaggingSelectionTool_OR", "The BTaggingSelectionTool used to select b-jets for overlap removal" );
741  m_btagEffTool_trkJet.declarePropertyFor( this, "BTaggingEfficiencyTool_trkJet", "The BTaggingEfficiencyTool for track jets" );
742  m_btagSelTool_trkJet.declarePropertyFor( this, "BTaggingSelectionTool_trkJet", "The main BTaggingSelectionTool for track jets" );
743  //
744  m_metMaker.declarePropertyFor( this, "METMaker", "The METMaker instance");
745  m_metSystTool.declarePropertyFor( this, "METSystTool", "The METSystematicsTool");
746  m_metSignif.declarePropertyFor( this, "METSignificance", "The METSignifiance instance");
747  //
748  m_trigGlobalEffCorrTool_diLep.declarePropertyFor( this, "TrigGlobalEfficiencyCorrection_diLep", "The TrigGlobalEfficiencyCorrection tool for dilepton" );
749  m_trigGlobalEffCorrTool_multiLep.declarePropertyFor( this, "TrigGlobalEfficiencyCorrection_multiLep", "The TrigGlobalEfficiencyCorrection tool for trilepton" );
750  m_trigGlobalEffCorrTool_diPhoton.declarePropertyFor( this, "TrigGlobalEfficiencyCorrection_diPhoton", "The TrigGlobalEfficiencyCorrection tool for asymmetric diphoton" );
751  m_trigConfTool.declarePropertyFor( this, "TrigConfigTool", "The TrigConfigTool" );
752  m_trigDecTool.declarePropertyFor( this, "TrigDecisionTool", "The TrigDecisionTool" );
753  m_trigMatchingTool.declarePropertyFor( this, "TrigMatchTool", "The TrigMatchingTool" );
754  m_trigMatchScoringTool.declarePropertyFor( this, "TrigMatchScoringTool", "The TrigMatchScoringTool" );
755  m_trigDRScoringTool.declarePropertyFor( this, "TrigDRScoringTool", "The TrigDRScoringTool" );
756  //
757  m_isoCorrTool.declarePropertyFor( this, "IsolationCorrectionTool", "The IsolationCorrectionTool" );
758  m_isoTool.declarePropertyFor( this, "IsolationSelectionTool", "The IsolationSelectionTool");
759  //disable m_isoToolLowPtPLV.declarePropertyFor( this, "IsolationLowPtPLVTool", "The IsolationLowPtPLVTool");
760  m_isoBaselineTool.declarePropertyFor( this, "IsolationSelectionTool_Baseline", "The IsolationSelectionTool for baseline objects");
761  m_isoHighPtTool.declarePropertyFor( this, "IsolationSelectionTool_HighPt", "The IsolationSelectionTool for High Pt");
762  m_isoCloseByTool.declarePropertyFor( this, "IsolationCloseByCorrectionTool", "The IsolationCloseByCorrectionTool");
763  //
764  m_prwTool.declarePropertyFor( this, "PileupReweightingTool", "The PRW tool" );
765  //
766  m_LRTuncTool.declarePropertyFor( this, "InclusiveTrackFilterTool", "The LRT uncertainty tool");
767  //
768  m_pmgSHnjetWeighter.declarePropertyFor( this, "PMGSHVjetReweightTool", "The PMGSHVjetReweightTool (AntiKt4TruthJets)" );
769  m_pmgSHnjetWeighterWZ.declarePropertyFor( this, "PMGSHVjetReweightWZTool", "The PMGSHVjetReweightTool (AntiKt4TruthWZJets)" );
770  //
771  m_tauJetORtool.declarePropertyFor( this, "TauJetOverlapTool", "The TauJetOverlapTool");
772  //disable m_orToolbox.declarePropertyFor( this, "OverlapRemovalTool", "The overlap removal tool");
773 
774  //load supported WPs (by tightness order)
775  m_el_id_support.push_back("VeryLooseNoPix"); // WPs for LRT Electron
776  m_el_id_support.push_back("VeryLooseLLH");
777  m_el_id_support.push_back("LooseNoPix"); // WPs for LRT Electron
778  m_el_id_support.push_back("LooseLLH");
779  m_el_id_support.push_back("LooseAndBLayerLLH");
780  m_el_id_support.push_back("LooseDNNnoCF");
781  m_el_id_support.push_back("LooseDNN");
782  m_el_id_support.push_back("MediumNoPix"); // WPs for LRT Electron
783  m_el_id_support.push_back("MediumLLH");
784  m_el_id_support.push_back("MediumDNNnoCF");
785  m_el_id_support.push_back("MediumDNN");
786  m_el_id_support.push_back("TightNoPix"); // WPs for LRT Electron
787  m_el_id_support.push_back("TightLLH");
788  m_el_id_support.push_back("TightDNNnoCF");
789  m_el_id_support.push_back("TightDNN");
790 
791  m_ph_id_support.push_back("Loose");
792  m_ph_id_support.push_back("Medium");
793  m_ph_id_support.push_back("Tight");
794  m_ph_id_support.push_back("TightPtIncl"); // Should not be mixed with Tight
795 
796  m_mu_id_support = 4; //maximum value supported
797 
798  // Tau ID WPs
799  m_tau_id_support.push_back("rnn001");
800  m_tau_id_support.push_back("VeryLoose");
801  m_tau_id_support.push_back("Loose");
802  m_tau_id_support.push_back("Medium");
803  m_tau_id_support.push_back("Tight");
804 
805  // Iso WPs
806  // -- see https://twiki.cern.ch/twiki/bin/view/AtlasProtected/RecommendedIsolationWPs#Current_official_working_points
807  // -- the el iso points are those which have (or will have) SFs available
808  m_el_iso_support = {
809  "FCLoose", "FCTight", // current WPs
810  "FCHighPtCaloOnly", // current HighPtCaloOnly WPs
811  "Gradient", //
812  "HighPtCaloOnly", //
813  "TightTrackOnly_VarRad","TightTrackOnly_FixedRad",//
814  "Tight_VarRad","Loose_VarRad", //
815  "PLVLoose", "PLVTight", // PLV recommended WPs, fallback support below b/o SFs and & egamma map file
816  "PLImprovedTight", "PLImprovedVeryTight" // New PLIV WPs, fallback support below b/o SFs & egamma map file
817  };
818  // -- the muon iso points are those which have SFs available
819  // -- more details https://indico.cern.ch/event/878781/contributions/3721998/attachments/1976194/3289315/20200127_IFFshort_2.pdf
820  m_mu_iso_support = {
821  "PflowLoose_FixedRad", "PflowLoose_VarRad", "PflowTight_FixedRad", "PflowTight_VarRad", // PFlow (new naming) recommended WPs
822  "TightTrackOnly_FixedRad", "TightTrackOnly_VarRad", "HighPtTrackOnly", // TrackOnly (new naming) recommended WPs
823  "PLVLoose", "PLVTight", // PLV recommended WPs
824  "Loose_VarRad", "Loose_FixedRad", "Tight_VarRad", "Tight_FixedRad", // Other WPs (new naming)
825  "PLImprovedTight", "PLImprovedVeryTight" // New PLIV WPs, fallback support below b/o SFs
826  };
827 
828  // Construct electron fallback WPs for SFs
829  for (const auto& x : m_el_iso_support) { m_el_iso_fallback[x] = x; } // all current WPs
830  m_el_iso_fallback["PLVTight"] = "FCTight"; // plus actual fallback
831  m_el_iso_fallback["PLVLoose"] = "FCLoose";
832  m_el_iso_fallback["PLImprovedTight"] = "FCTight";
833  m_el_iso_fallback["PLImprovedVeryTight"] = "FCTight";
834  m_el_iso_fallback["HighPtCaloOnly"] = "FCHighPtCaloOnly";
835  m_el_iso_fallback["TightTrackOnly_VarRad"] = "FCTight";
836  m_el_iso_fallback["TightTrackOnly_FixedRad"] = "FCTight";
837  m_el_iso_fallback["Tight_VarRad"] = "FCTight";
838  m_el_iso_fallback["Loose_VarRad"] = "FCLoose";
839 
840  // Construct muon fallback WPs for SFs
841  m_mu_iso_fallback = {};
842  m_mu_iso_fallback["PLImprovedTight"] = "PLVTight";
843  m_mu_iso_fallback["PLImprovedVeryTight"] = "PLVTight";
844 }

◆ ~SUSYObjDef_xAOD()

ST::SUSYObjDef_xAOD::~SUSYObjDef_xAOD ( )

Definition at line 3084 of file SUSYObjDef_xAOD.cxx.

3084  {
3085 
3086 #ifdef XAOD_STANDALONE
3087  // remove all tools from the asg::ToolStore (and delete them)
3088  // so that they don't get re-used if we set up another SUSYTools
3089  // instance, e.g. when processing two datasets in one EventLoop
3090  // job
3091  if (!m_trigDecTool.empty()){
3092  if (asg::ToolStore::contains<Trig::TrigDecisionTool>("ToolSvc.TrigDecisionTool") ){
3093  // Ignore both of these so that we are safe if others have cleaned up
3094  m_trigDecTool->finalize().ignore();
3095  asg::ToolStore::remove("ToolSvc.TrigDecisionTool").ignore();
3096  }
3097  }
3098 #endif
3099 }

Member Function Documentation

◆ ApplyLRTUncertainty()

StatusCode ST::SUSYObjDef_xAOD::ApplyLRTUncertainty ( )
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3054 of file SUSYObjDef_xAOD.cxx.

3054  {
3055 
3056  const EventContext& ctx = Gaudi::Hive::currentContext();
3057 
3058  // Loop over tracks and call LRT uncertainty tool
3059  ATH_MSG_DEBUG ( "Applying LRT filter tool decorations for uncertainty");
3061  for(const auto trk: inTracks) dec_lrtFilter(*trk) = m_LRTuncTool->accept(trk);
3062 
3063  // Loop over GSF LRT tracks and call uncertainty tool
3064  const xAOD::TrackParticleContainer inGSFTracks = GetInDetLargeD0GSFTracks(ctx);
3065  for(const auto trk: inGSFTracks) dec_lrtFilter(*trk) = m_LRTuncTool->accept(trk);
3066 
3067  return StatusCode::SUCCESS;
3068 }

◆ ApplyPRWTool()

StatusCode ST::SUSYObjDef_xAOD::ApplyPRWTool ( bool  muDependentRRN = true)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3009 of file SUSYObjDef_xAOD.cxx.

3009  {
3010 
3011  const xAOD::EventInfo* evtInfo = GetEventInfo();
3012  if(!randomrunnumber.isAvailable(*evtInfo))
3013  ATH_CHECK( m_prwTool->apply( *evtInfo, muDependentRRN ) );
3014  return StatusCode::SUCCESS;
3015 }

◆ applySystematicVariation()

StatusCode ST::SUSYObjDef_xAOD::applySystematicVariation ( const CP::SystematicSet systConfig)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2119 of file SUSYObjDef_xAOD.cxx.

2120 {
2121  if (!m_tool_init) {
2122  ATH_MSG_ERROR("SUSYTools was not initialized!!");
2123  return StatusCode::FAILURE;
2124  }
2125 
2126  ATH_MSG_DEBUG(" in SUSYObjDef_xAOD::applySystematicVariation \"" << systConfig.name() << "\" size " << systConfig.size());
2127 
2128  m_currentSyst = systConfig;
2129 
2130  // NB: SystematicSet typically has only one component (see SUSYToolsTester macro)
2131  // The PDSmear systematics have been initialised as the second component of the JET_JER systematic, here we'll catch the uncertainties which are to use the PDSmear initialised tool.
2132  if (!m_jetUncertaintiesTool.empty() && systConfig.name().find("__2") == std::string::npos) {
2134  if ( ret != StatusCode::SUCCESS) {
2135  ATH_MSG_VERBOSE("Cannot configure JetUncertaintiesTool for systematic var. " << systConfig.name() );
2136  } else {
2137  ATH_MSG_VERBOSE("Configured JetUncertaintiesTool for systematic var. " << systConfig.name() );
2138  }
2139  }
2140  if (!m_jetUncertaintiesPDSmearTool.empty() && systConfig.name().find("__2") != std::string::npos ) {
2142  if ( ret != StatusCode::SUCCESS) {
2143  ATH_MSG_VERBOSE("Cannot configure JetUncertaintiesPDSmearTool for systematic var. " << systConfig.name() );
2144  } else {
2145  ATH_MSG_VERBOSE("Configured JetUncertaintiesPDSmearTool for systematic var. " << systConfig.name() );
2146  }
2147  }
2148  if (!m_WTagjetUncertaintiesTool.empty() && !m_WTagUncConfig.empty()) {
2150  if ( ret != StatusCode::SUCCESS) {
2151  ATH_MSG_VERBOSE("Cannot configure (Fat)JetUncertaintiesTool (WTag) for systematic var. " << systConfig.name() );
2152  } else {
2153  ATH_MSG_VERBOSE("Configured (Fat)JetUncertaintiesTool (WTag) for systematic var. " << systConfig.name() );
2154  }
2155  }
2156  if (!m_ZTagjetUncertaintiesTool.empty() && !m_ZTagUncConfig.empty()) {
2158  if ( ret != StatusCode::SUCCESS) {
2159  ATH_MSG_VERBOSE("Cannot configure (Fat)JetUncertaintiesTool (ZTag) for systematic var. " << systConfig.name() );
2160  } else {
2161  ATH_MSG_VERBOSE("Configured (Fat)JetUncertaintiesTool (ZTag) for systematic var. " << systConfig.name() );
2162  }
2163  }
2164 
2167  if ( ret != StatusCode::SUCCESS) {
2168  ATH_MSG_VERBOSE("Cannot configure (Fat)JetUncertaintiesTool (TopTag) for systematic var. " << systConfig.name() );
2169  } else {
2170  ATH_MSG_VERBOSE("Configured (Fat)JetUncertaintiesTool (TopTag) for systematic var. " << systConfig.name() );
2171  }
2172  }
2175  if ( ret != StatusCode::SUCCESS) {
2176  ATH_MSG_VERBOSE("Cannot configure (Fat)JetUncertaintiesTool (main) for systematic var. " << systConfig.name() );
2177  } else {
2178  ATH_MSG_VERBOSE("Configured (Fat)JetUncertaintiesTool (main) for systematic var. " << systConfig.name() );
2179  }
2180  }
2183  if ( ret != StatusCode::SUCCESS) {
2184  ATH_MSG_VERBOSE("Cannot configure NNJvtEfficiency for systematic var. " << systConfig.name() );
2185  } else {
2186  ATH_MSG_VERBOSE("Configured NNJvtEfficiency for systematic var. " << systConfig.name() );
2187  }
2188  }
2189  if (!m_jetfJvtEfficiencyTool.empty()) {
2191  if ( ret != StatusCode::SUCCESS) {
2192  ATH_MSG_VERBOSE("Cannot configure fJvtEfficiency for systematic var. " << systConfig.name() );
2193  } else {
2194  ATH_MSG_VERBOSE("Configured fJvtEfficiency for systematic var. " << systConfig.name() );
2195  }
2196  }
2197  if (!m_muonCalibTool.empty()) {
2199  if (ret != StatusCode::SUCCESS) {
2200  ATH_MSG_ERROR("Cannot configure MuonCalibTool for systematic var. " << systConfig.name() );
2201  return ret;
2202  } else {
2203  ATH_MSG_VERBOSE("MuonCalibTool configured for systematic var. " << systConfig.name() );
2204  }
2205  }
2206  if (!m_muonEfficiencySFTool.empty()) {
2208  if ( ret != StatusCode::SUCCESS) {
2209  ATH_MSG_ERROR("Cannot configure MuonEfficiencyScaleFactors for systematic var. " << systConfig.name() );
2210  return ret;
2211  } else {
2212  ATH_MSG_VERBOSE("MuonEfficiencyScaleFactors configured for systematic var. " << systConfig.name() );
2213  }
2214  }
2217  if ( ret != StatusCode::SUCCESS) {
2218  ATH_MSG_ERROR("Cannot configure MuonBadMuonHighPtScaleFactors for systematic var. " << systConfig.name() );
2219  return ret;
2220  } else {
2221  ATH_MSG_VERBOSE("MuonBadMuonHighPtScaleFactors configured for systematic var. " << systConfig.name() );
2222  }
2223  }
2226  if ( ret != StatusCode::SUCCESS) {
2227  ATH_MSG_ERROR("Cannot configure MuonTTVAEfficiencyScaleFactors for systematic var. " << systConfig.name() );
2228  return ret;
2229  } else {
2230  ATH_MSG_VERBOSE("MuonTTVAEfficiencyScaleFactors configured for systematic var. " << systConfig.name() );
2231  }
2232  }
2233  if (!m_muonIsolationSFTool.empty()) {
2235  if ( ret != StatusCode::SUCCESS) {
2236  ATH_MSG_ERROR("Cannot configure MuonIsolationScaleFactors for systematic var. " << systConfig.name() );
2237  return ret;
2238  } else {
2239  ATH_MSG_VERBOSE("MuonIsolationScaleFactors configured for systematic var. " << systConfig.name() );
2240  }
2241  }
2242  if (!m_muonTriggerSFTool.empty()) {
2244  if ( ret != StatusCode::SUCCESS) {
2245  ATH_MSG_ERROR("Cannot configure MuonTriggerScaleFactors for systematic var. " << systConfig.name() );
2246  return ret;
2247  } else {
2248  ATH_MSG_VERBOSE("MuonTriggerScaleFactors configured for systematic var. " << systConfig.name() );
2249  }
2250  }
2253  if (ret != StatusCode::SUCCESS) {
2254  ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (reco) for systematic var. " << systConfig.name() );
2255  return ret;
2256  } else {
2257  ATH_MSG_VERBOSE("AsgElectronEfficiencyCorrectionTool (reco) configured for systematic var. " << systConfig.name() );
2258  }
2259  }
2262  if (ret != StatusCode::SUCCESS) {
2263  ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (id) for systematic var. " << systConfig.name() );
2264  return ret;
2265  } else {
2266  ATH_MSG_VERBOSE("AsgElectronEfficiencyCorrectionTool (id) configured for systematic var. " << systConfig.name() );
2267  }
2268  }
2271  if (ret != StatusCode::SUCCESS) {
2272  ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (trigger) for systematic var. " << systConfig.name() );
2273  return ret;
2274  } else {
2275  ATH_MSG_VERBOSE("AsgElectronEfficiencyCorrectionTool (trigger) configured for systematic var. " << systConfig.name() );
2276  }
2277  }
2280  if (ret != StatusCode::SUCCESS) {
2281  ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (trigger SFTool) for systematic var. " << systConfig.name() );
2282  return ret;
2283  } else {
2284  ATH_MSG_VERBOSE("AsgElectronEfficiencyCorrectionTool (trigger SFTool) configured for systematic var. " << systConfig.name() );
2285  }
2286  }
2289  for(auto &sfop : m_elecTrigEffTools){
2290  StatusCode ret1 = sfop->applySystematicVariation(systConfig);
2291  if (ret1 != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure m_elecTrigEffTools (dilepton trigger) for systematic var. " << systConfig.name() ); return ret1; }
2292  }
2293  for(auto &sfop : m_elecTrigSFTools){
2294  StatusCode ret1 = sfop->applySystematicVariation(systConfig);
2295  if (ret1 != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure m_elecTrigSFTools (dilepton trigger) for systematic var. " << systConfig.name() ); return ret1; }
2296  }
2297  for(auto &sfop : m_muonTrigSFTools){
2298  StatusCode ret1 = sfop->applySystematicVariation(systConfig);
2299  if (ret1 != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure m_muonTrigSFTools (dilepton trigger) for systematic var. " << systConfig.name() ); return ret1; }
2300  }
2301  if (ret != StatusCode::SUCCESS) {
2302  ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (dilepton trigger) for systematic var. " << systConfig.name() );
2303  return ret;
2304  } else {
2305  ATH_MSG_VERBOSE("TrigGlobalEfficiencyCorrectionTool (dilepton trigger) configured for systematic var. " << systConfig.name() );
2306  }
2307  }
2310  for(auto &sfop : m_elecTrigEffTools){
2311  StatusCode ret1 = sfop->applySystematicVariation(systConfig);
2312  if (ret1 != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure m_elecTrigEffTools (multilep trigger) for systematic var. " << systConfig.name() ); return ret1; }
2313  }
2314  for(auto &sfop : m_elecTrigSFTools){
2315  StatusCode ret1 = sfop->applySystematicVariation(systConfig);
2316  if (ret1 != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure m_elecTrigSFTools (multilep trigger) for systematic var. " << systConfig.name() ); return ret1; }
2317  }
2318  for(auto &sfop : m_muonTrigSFTools){
2319  StatusCode ret1 = sfop->applySystematicVariation(systConfig);
2320  if (ret1 != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure m_muonTrigSFTools (multilep trigger) for systematic var. " << systConfig.name() ); return ret1; }
2321  }
2322  if (ret != StatusCode::SUCCESS) {
2323  ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (multi-lepton trigger) for systematic var. " << systConfig.name() );
2324  return ret;
2325  } else {
2326  ATH_MSG_VERBOSE("TrigGlobalEfficiencyCorrectionTool (multi-lepton trigger) configured for systematic var. " << systConfig.name() );
2327  }
2328  }
2331  if (ret != StatusCode::SUCCESS) {
2332  ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (iso) for systematic var. " << systConfig.name() );
2333  return ret;
2334  } else {
2335  ATH_MSG_VERBOSE("AsgElectronEfficiencyCorrectionTool (iso) configured for systematic var. " << systConfig.name() );
2336  }
2337  }
2340  if (ret != StatusCode::SUCCESS) {
2341  ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (iso high-pt) for systematic var. " << systConfig.name() );
2342  return ret;
2343  } else {
2344  ATH_MSG_VERBOSE("AsgElectronEfficiencyCorrectionTool (iso high-pt) configured for systematic var. " << systConfig.name() );
2345  }
2346  }
2347  if (!m_elecChargeEffCorrTool.empty()) {
2349  if (ret != StatusCode::SUCCESS) {
2350  ATH_MSG_ERROR("Cannot configure ElectronChargeEffCorrectionTool for systematic var. " << systConfig.name() );
2351  return ret;
2352  } else {
2353  ATH_MSG_VERBOSE("ElectronChargeEffCorrectionTool configured for systematic var. " << systConfig.name() );
2354  }
2355  }
2356  if (!isData() && !m_photonEfficiencySFTool.empty()) {
2358  if (ret != StatusCode::SUCCESS) {
2359  ATH_MSG_ERROR("Cannot configure AsgPhotonEfficiencyCorrectionTool (reco) for systematic var. " << systConfig.name() );
2360  return ret;
2361  } else {
2362  ATH_MSG_VERBOSE("AsgPhotonEfficiencyCorrectionTool (reco) configured for systematic var. " << systConfig.name() );
2363  }
2364  }
2365  if (!isData() && !m_photonIsolationSFTool.empty()) {
2367  if (ret != StatusCode::SUCCESS) {
2368  ATH_MSG_ERROR("Cannot configure AsgPhotonEfficiencyCorrectionTool (iso) for systematic var. " << systConfig.name() );
2369  return ret;
2370  } else {
2371  ATH_MSG_VERBOSE("AsgPhotonEfficiencyCorrectionTool configured (iso) for systematic var. " << systConfig.name() );
2372  }
2373  }
2374  if (!isData() && !m_photonTriggerSFTool.empty()) {
2376  if (ret != StatusCode::SUCCESS) {
2377  ATH_MSG_ERROR("Cannot configure AsgPhotonEfficiencyCorrectionTool (trigger) for systematic var. " << systConfig.name() );
2378  return ret;
2379  } else {
2380  ATH_MSG_VERBOSE("AsgPhotonEfficiencyCorrectionTool configured (trigger) for systematic var. " << systConfig.name() );
2381  }
2382  }
2385  for(auto &sfop : m_photonTrigEffTools){
2386  StatusCode ret1 = sfop->applySystematicVariation(systConfig);
2387  if (ret1 != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure m_photonTrigEffTools (diphoton trigger) for systematic var. " << systConfig.name() ); return ret1; }
2388  }
2389  for(auto &sfop : m_photonTrigSFTools){
2390  StatusCode ret1 = sfop->applySystematicVariation(systConfig);
2391  if (ret1 != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure m_photonTrigSFTools (diphoton trigger) for systematic var. " << systConfig.name() ); return ret1; }
2392  }
2393  if (ret != StatusCode::SUCCESS) {
2394  ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (diphoton trigger) for systematic var. " << systConfig.name() );
2395  return ret;
2396  } else {
2397  ATH_MSG_VERBOSE("TrigGlobalEfficiencyCorrectionTool (diphoton trigger) configured for systematic var. " << systConfig.name() );
2398  }
2399  }
2400  if (!m_egammaCalibTool.empty()) {
2402  if (ret != StatusCode::SUCCESS) {
2403  ATH_MSG_ERROR("Cannot configure EgammaCalibrationAndSmearingTool for systematic var. " << systConfig.name() );
2404  return ret;
2405  } else {
2406  ATH_MSG_VERBOSE("EgammaCalibrationAndSmearingTool configured for systematic var. " << systConfig.name() );
2407  }
2408  }
2409  if (!m_isoCorrTool.empty()) {
2411  if (ret != StatusCode::SUCCESS) {
2412  ATH_MSG_ERROR("Cannot configure IsolationCorrectionTool for systematic var. " << systConfig.name() );
2413  return ret;
2414  } else {
2415  ATH_MSG_VERBOSE("IsolationCorrectionTool configured for systematic var. " << systConfig.name() );
2416  }
2417  }
2418  if (!m_btagEffTool.empty()) {
2419  //if ( systConfig.size() > 0 && m_btagEffTool->isAffectedBySystematic(*systConfig.begin()) ) {
2421  if ( ret != StatusCode::SUCCESS) {
2422  ATH_MSG_ERROR("Cannot configure xAODBTaggingEfficiency for systematic var. " << systConfig.name() );
2423  return ret;
2424  } else {
2425  ATH_MSG_VERBOSE("Configured xAODBTaggingEfficiency for systematic var. " << systConfig.name() );
2426  }
2427  //}
2428  }
2429  if (!m_btagEffTool_trkJet.empty()) {
2431  if ( ret != StatusCode::SUCCESS) {
2432  ATH_MSG_ERROR("Cannot configure xAODBTaggingEfficiency (track jets) for systematic var. " << systConfig.name() );
2433  return ret;
2434  } else {
2435  ATH_MSG_VERBOSE("Configured xAODBTaggingEfficiency (track jets) for systematic var. " << systConfig.name() );
2436  }
2437  }
2438  if (!m_tauSmearingTool.empty()) {
2440  if ( ret != StatusCode::SUCCESS) {
2441  ATH_MSG_ERROR("Cannot configure TauSmearingTool for systematic var. " << systConfig.name() );
2442  return ret;
2443  } else {
2444  ATH_MSG_VERBOSE("Configured TauSmearingTool for systematic var. " << systConfig.name() );
2445  }
2446  }
2447  if (!m_tauEffTool.empty()) {
2449  if ( ret != StatusCode::SUCCESS) {
2450  ATH_MSG_ERROR("Cannot configure TauEfficiencyCorrectionsTool for systematic var. " << systConfig.name() );
2451  return ret;
2452  } else {
2453  ATH_MSG_VERBOSE("Configured TauEfficiencyCorrectionsTool for systematic var. " << systConfig.name() );
2454  }
2455  }
2456  for(auto &tool : m_tauTrigEffTool) {
2457  StatusCode ret = tool->applySystematicVariation(systConfig);
2458  if (ret != StatusCode::SUCCESS) {
2459  ATH_MSG_ERROR("Cannot configure " << tool->name() << " for systematic var. " << systConfig.name() );
2460  return ret;
2461  } else {
2462  ATH_MSG_VERBOSE("Configured " << tool->name() << " for systematic var. " << systConfig.name() );
2463  }
2464  }
2465  if (!m_metSystTool.empty()) {
2467  if ( ret != StatusCode::SUCCESS) {
2468  ATH_MSG_ERROR("Cannot configure METSystematicsTool for systematic var. " << systConfig.name() );
2469  return ret;
2470  } else {
2471  ATH_MSG_VERBOSE("Configured METSystematicsTool for systematic var. " << systConfig.name() );
2472  }
2473  }
2474  if (!m_prwTool.empty()) {
2475  StatusCode ret = m_prwTool->applySystematicVariation(systConfig);
2476  if ( ret != StatusCode::SUCCESS) {
2477  ATH_MSG_ERROR("Cannot configure PileupReweightingTool for systematic var. " << systConfig.name() );
2478  return ret;
2479  } else {
2480  ATH_MSG_VERBOSE("Configured PileupReweightingTool for systematic var. " << systConfig.name() );
2481  }
2482  }
2483 
2484  if (!m_LRTuncTool.empty()) {
2486  if ( ret != StatusCode::SUCCESS) {
2487  ATH_MSG_ERROR("Cannot configure InDetTrackFilterTool for systematic var. " << systConfig.name() );
2488  return ret;
2489  } else {
2490  ATH_MSG_VERBOSE("Configured InDetTrackFilterTool for systematic var. " << systConfig.name() );
2491  }
2492  }
2493 
2494  return StatusCode::SUCCESS;
2495 }

◆ autoconfigurePileupRWTool()

StatusCode ST::SUSYObjDef_xAOD::autoconfigurePileupRWTool ( const std::string &  PRWfilesDir = "dev/PileupReweighting/share/",
const std::string &  PRWfileName = "",
bool  usePathResolver = true,
bool  RPVLLmode = false,
bool  Combinedmode = false,
const std::string &  HFFilter = "" 
)
protected

Definition at line 1001 of file SUSYObjDef_xAOD.cxx.

1001  {
1002 
1003  // this will contain the path of the PRW file on /cvmfs which needs to be reverse engineered from the DSID and MC campaign
1004  // the path(s) will be added to m_prwConfFiles which is later used in the configuration of the CP PRW tool
1005  std::string prwConfigFile("");
1006 
1007  if ( !isData() && m_autoconfigPRW ) {
1008 
1009  prwConfigFile = PRWfilesDir;
1010 
1011  float dsid = -999;
1012  std::string amiTag("");
1013  std::string mcCampaignMD("");
1014  std::string simFlavour("");
1015  std::string simType("");
1016  const xAOD::FileMetaData* fmd = nullptr;
1017 
1018  // configure PRW rtag options from m_autoconfigPRWRtags string
1019  // e.g. "mc20a:r13167_r14859,mc20d:r13144_r14860,mc20e:r13145_r14861,mc21a:r13752_r13829,mc23a:r14622_r14932_r15540,mc23c:r14799_r14908,mc23d:r15224_r15530,mc23e:r16083"
1020  std::map<std::string,std::vector<std::string>> PRWRtags = {};
1021  std::string allcampaigns = "mc20a.mc20d.mc20e.mc21a.mc23a.mc23c.mc23d.mc23e";
1022  bool standard_like = true;
1023  for ( const auto& campaign_rtags : split( m_autoconfigPRWRtags, "," ) ) { // split string by ","
1024  std::string icampaign = campaign_rtags.substr(0, campaign_rtags.find(":")); // first field = campaign, split by ":"
1025  std::vector<std::string> irtags = split( campaign_rtags.substr(campaign_rtags.find(":")+1), "_" ); // remaining fields = rtags, split by "_"
1026  PRWRtags[icampaign] = irtags;
1027  ATH_MSG_DEBUG( "PRW autoconfigure considering rtags " << campaign_rtags.substr(campaign_rtags.find("_")+1) << " for campaign " << icampaign );
1028  }
1029  for ( const auto& x : PRWRtags ) {
1030  if ( allcampaigns.find(x.first)==string::npos ) {
1031  ATH_MSG_ERROR("m_autoconfigPRWRtags contains invalid campaign: " << x.first << " (" << m_autoconfigPRWRtags << ")");
1032  ATH_MSG_ERROR("use any of " << allcampaigns);
1033  return StatusCode::FAILURE;
1034  }
1035  }
1036 
1037  // let's use MetaData to extract sample information
1038  if ( inputMetaStore()->contains<xAOD::FileMetaData>("FileMetaData") && inputMetaStore()->retrieve(fmd,"FileMetaData").isSuccess() ) {
1041  fmd->value(xAOD::FileMetaData::simFlavour, simFlavour);
1042 
1043  if(simFlavour.starts_with("ATLFASTII")) simType = "AFII";
1044  else if(simFlavour.starts_with("ATLFAST3")) simType = "AF3";
1045  else simType = "FS";
1046 
1047  bool found = false;
1048  while ( mcCampaignMD.empty() ) {
1049  for ( const auto& campaign_rtags : PRWRtags ) { // consider all campaigns
1050  for ( const auto& rtag: campaign_rtags.second ) { // consider all rtags
1051  if (found) continue;
1052  if (amiTag.find(rtag)!=string::npos) { // find matching tag
1053  mcCampaignMD = campaign_rtags.first.substr(0,5); // save campaign
1054  standard_like = (campaign_rtags.first.find("ns")?true:false); // track non-standard r-tags
1055  found = true; // break if found
1056  }
1057  }
1058  }
1059  // in case not found
1060  if (!found) {
1061  ATH_MSG_ERROR( "autoconfigurePileupRWTool(): unrecognized xAOD::FileMetaData::amiTag, \'" << amiTag << "'. Please check your input sample.");
1062  return StatusCode::FAILURE;
1063  }
1064  //
1065  ATH_MSG_INFO( "Setting up autoconfigurePileupRWTool for mc campaign " << mcCampaignMD << " (from amiTag " << amiTag << ") (standard-like = " << (standard_like?"true":"false") << ")." );
1066  if ( (!standard_like) && (!RPVLLmode) )
1067  ATH_MSG_WARNING("Non-standard r-tag found (" << amiTag.data() << "), but RPVLLmode not set. Perhaps you want to set \"PRW.autoconfigPRWRPVmode: 1\" in the config?");
1068  }
1069  } else {
1070 #ifndef XAOD_STANDALONE
1071  ATH_MSG_ERROR( "autoconfigurePileupRWTool(): access to FileMetaData failed, can't get mc channel number.");
1072  return StatusCode::FAILURE;
1073 #else
1074 
1075  if ( m_mcCampaign == "mc20a" || m_mcCampaign == "mc20d" || m_mcCampaign == "mc20e" || m_mcCampaign == "mc21a" || m_mcCampaign == "mc23a" || m_mcCampaign == "mc23c" || m_mcCampaign == "mc23d" || m_mcCampaign == "mc23e") {
1076  // First see if the user set the mcCampaign/run number by property (hopefully temporary workaround)
1077  if ( m_mcChannel > 0) {
1078  ATH_MSG_WARNING( "autoconfigurePileupRWTool(): access to FileMetaData failed -> getting the mc channel number (DSID) and campaign from configuration." );
1079  std::string NoMetadataButPropertyOK("");
1080  NoMetadataButPropertyOK += "autoconfigurePileupRWTool(): 'mcCampaign' is used and passed to SUSYTools as '";
1081  NoMetadataButPropertyOK += m_mcCampaign;
1082  NoMetadataButPropertyOK += "'. 'mcChannel' is used and passed to SUSYTools as '";
1083  NoMetadataButPropertyOK += std::to_string(m_mcChannel);
1084  NoMetadataButPropertyOK += "'. Autocongiguring PRW accordingly.";
1085  ATH_MSG_WARNING( NoMetadataButPropertyOK );
1086  mcCampaignMD = m_mcCampaign;
1087  dsid = m_mcChannel;
1088  } else {
1089  // OK, this is a fall-back option without using MetaData but one has to manually set 'mcCampaign' property
1090  ATH_MSG_WARNING( "autoconfigurePileupRWTool(): access to FileMetaData failed -> getting the mc channel number (DSID) from the event store." );
1091  const xAOD::EventInfo* evtInfo = GetEventInfo();
1092  dsid = evtInfo->mcChannelNumber();
1093 
1094  std::string NoMetadataButPropertyOK("");
1095  NoMetadataButPropertyOK += "autoconfigurePileupRWTool(): 'mcCampaign' is used and passed to SUSYTools as '";
1096  NoMetadataButPropertyOK += m_mcCampaign;
1097  NoMetadataButPropertyOK += "'. Autoconfiguring PRW accordingly.";
1098  ATH_MSG_WARNING( NoMetadataButPropertyOK );
1099  mcCampaignMD = m_mcCampaign;
1100  }
1101  } else {
1102  ATH_MSG_ERROR( "autoconfigurePileupRWTool(): `mcCampaign' is not set properly.");
1103  return StatusCode::FAILURE;
1104  }
1105 #endif
1106  }
1107 
1108  // If requested set the PRW file to common PRW file of the processed MC campaign
1109  if (m_useCommonPRWFiles) {
1110  ATH_MSG_INFO( "autoconfigurePileupRWTool(): retrieving the common PRW file for MC campaign: " << mcCampaignMD );
1111  if (mcCampaignMD == "mc20a") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC20a);}
1112  else if (mcCampaignMD == "mc20d") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC20d);}
1113  else if (mcCampaignMD == "mc20e") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC20e);}
1114  else if (mcCampaignMD == "mc21a") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC21a);}
1115  else if (mcCampaignMD == "mc23a") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC23a);}
1116  else if (mcCampaignMD == "mc23c") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC23c);}
1117  else if (mcCampaignMD == "mc23d") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC23d);}
1118  else if (mcCampaignMD == "mc23e") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC23e);}
1119  else {
1120  ATH_MSG_ERROR( "autoconfigurePileupRWTool(): no common PRW file known for MC campaign: " << mcCampaignMD);
1121  return StatusCode::FAILURE;
1122  }
1123  }
1124  // Otherwise try finding the dedicated PRW file on /cvmfs
1125  else {
1126  // Retrieve the input file
1127  int DSID_INT = static_cast<int>(dsid);
1128  prwConfigFile += "DSID" + std::to_string(DSID_INT/1000) + "xxx/pileup_" + mcCampaignMD + "_dsid" + std::to_string(DSID_INT) + "_" + simType + ".root";
1129 
1130  if (RPVLLmode) prwConfigFile = TString(prwConfigFile).ReplaceAll(".root","_rpvll.root").Data();
1131 
1132  // PRW file specified by user
1133  // e.g. DSID700xxx/pileup_mc20a_dsid700015_FS.root
1134  if (!PRWfileName.empty()) {
1135  prwConfigFile = PRWfilesDir + PRWfileName;
1136  ATH_MSG_INFO( "autoconfigurePileupRWTool(): PRW file was specifed by user: " << prwConfigFile.data() );
1137  }
1138  }
1139 
1140  m_prwConfFiles.clear();
1141 
1142  // Combined mode can be only used when running with full data with the same MC samples
1143  if (Combinedmode) {
1144  if (mcCampaignMD.find("mc20") == std::string::npos) {
1145  ATH_MSG_ERROR( "autoconfigurePileupRWTool(): combined mode currently onlys supported for mc20! Impossible to autoconfigure PRW. Aborting." );
1146  return StatusCode::FAILURE;
1147  }
1148  // When using the common PRW files we can directly add them
1149  if (m_useCommonPRWFiles) {
1150  m_prwConfFiles.push_back( m_commonPRWFileMC20a );
1151  m_prwConfFiles.push_back( m_commonPRWFileMC20d );
1152  m_prwConfFiles.push_back( m_commonPRWFileMC20e );
1153  }
1154  // Otherwise we have to replace the mc campaign in the name accordingly
1155  else {
1156  m_prwConfFiles.emplace_back( TString(prwConfigFile).ReplaceAll(mcCampaignMD, "mc20a").Data() );
1157  m_prwConfFiles.emplace_back( TString(prwConfigFile).ReplaceAll(mcCampaignMD, "mc20d").Data() );
1158  m_prwConfFiles.emplace_back( TString(prwConfigFile).ReplaceAll(mcCampaignMD, "mc20e").Data() );
1159  }
1162  } else {
1163  m_prwConfFiles.push_back( prwConfigFile );
1164  if ( mcCampaignMD == "mc20d") {
1166  } else if (mcCampaignMD == "mc20e") {
1168  } else if (mcCampaignMD == "mc21a" || mcCampaignMD == "mc23a") {
1170  } else if (mcCampaignMD == "mc23c" || mcCampaignMD == "mc23d") {
1172  } else if (mcCampaignMD == "mc23e") {
1174  }
1175 
1176  }
1177  prwConfigFile = usePathResolver ? PathResolverFindCalibFile(prwConfigFile) : prwConfigFile;
1178 
1179  // Test if file exists (i.e. was requested already to /cvmfs if the DSID-specific PRW files are used) and is usable
1180  TFile testF(prwConfigFile.data(),"read");
1181  if (testF.IsZombie()) {
1182  ATH_MSG_ERROR( "autoconfigurePileupRWTool(): file not found -> " << prwConfigFile.data() << " ! Impossible to autoconfigure PRW. Aborting." );
1183  if ( (!standard_like) && (!RPVLLmode) )
1184  ATH_MSG_WARNING("Running with non-standard r-tag (" << amiTag.data() << "), but RPVLLmode not set. Perhaps you want to set \"PRW.autoconfigPRWRPVmode: 1\" in the config?");
1185  return StatusCode::FAILURE;
1186  }
1187 
1188  ATH_MSG_INFO( "autoconfigurePileupRWTool(): configuring PRW tool using " << prwConfigFile.data() );
1189  }
1190  // Return gracefully
1191  return StatusCode::SUCCESS;
1192 }

◆ beginEvent()

StatusCode asg::AsgMetadataTool::beginEvent ( )
protectedvirtualinherited

Function called when a new events is loaded.

Dummy implementation that can be overridden by the derived tool.

Reimplemented in AsgElectronEfficiencyCorrectionTool, TrigConf::xAODConfigTool, TauAnalysisTools::TauSelectionTool, TauAnalysisTools::DiTauSelectionTool, TauAnalysisTools::CommonSmearingTool, TauAnalysisTools::DiTauEfficiencyCorrectionsTool, Trig::TrigDecisionTool, TauAnalysisTools::TauEfficiencyCorrectionsTool, Trig::TrigConfBunchCrossingTool, xAODMaker::TriggerMenuMetaDataTool, and Trig::xAODBunchCrossingTool.

Definition at line 196 of file AsgMetadataTool.cxx.

196  {
197 
198  // Return gracefully:
199  return StatusCode::SUCCESS;
200  }

◆ beginInputFile()

StatusCode asg::AsgMetadataTool::beginInputFile ( )
protectedvirtualinherited

Function called when a new input file is opened.

Dummy implementation that can be overridden by the derived tool.

Reimplemented in AsgElectronEfficiencyCorrectionTool, TrigConf::xAODConfigTool, PMGTools::PMGTruthWeightTool, BookkeeperTool, xAODMaker::FileMetaDataTool, BookkeeperDumperTool, Trig::TrigDecisionTool, xAODMaker::TriggerMenuMetaDataTool, xAODMaker::TruthMetaDataTool, Trig::xAODBunchCrossingTool, TauAnalysisTools::TauEfficiencyCorrectionsTool, and TauAnalysisTools::TauSmearingTool.

Definition at line 180 of file AsgMetadataTool.cxx.

180  {
181 
182  // Return gracefully:
183  return StatusCode::SUCCESS;
184  }

◆ BtagSF()

float ST::SUSYObjDef_xAOD::BtagSF ( const xAOD::JetContainer jets)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 791 of file Jets.cxx.

791  {
792 
793  float totalSF = 1.;
794  for ( const xAOD::Jet* jet : *jets ) {
795 
796  float sf = 1.;
797 
798  if ( std::abs(jet->eta()) > 2.5 ) {
799  ATH_MSG_VERBOSE( "Trying to retrieve b-tagging SF for jet with |eta|>2.5 (jet eta=" << jet->eta() << "), jet will be skipped");
800  } else if ( jet->pt() < 20e3 ){
801  ATH_MSG_VERBOSE( "Trying to retrieve b-tagging SF for jet with invalid pt (jet pt=" << jet->pt() << "), jet will be skipped");
802  } else {
803 
805  int truthlabel(-1);
806  if (!jet->getAttribute("HadronConeExclTruthLabelID", truthlabel)) {
807  ATH_MSG_ERROR("Failed to get jet truth label!");
808  }
809  ATH_MSG_VERBOSE("This jet is " << (acc_bjet(*jet) ? "" : "not ") << "b-tagged.");
810  ATH_MSG_VERBOSE("This jet's truth label is " << truthlabel);
811 
812  if ( acc_bjet(*jet) or m_BtagWP == "Continuous") {
814 
815  switch (result) {
817  ATH_MSG_ERROR( "Failed to retrieve SF for b-tagged jets in SUSYTools_xAOD::BtagSF" );
818  break;
820  ATH_MSG_VERBOSE( "No valid SF for b-tagged jets in SUSYTools_xAOD::BtagSF" );
821  break;
822  default:
823  ATH_MSG_VERBOSE( "Retrieve SF for b-tagged jets in SUSYTools_xAOD::BtagSF with value " << sf );
824  }
825  } else {
826 
828 
829  switch (result) {
831  ATH_MSG_ERROR( "Failed to retrieve SF for non-b-tagged jets in SUSYTools_xAOD::BtagSF" );
832  break;
834  ATH_MSG_VERBOSE( "No valid inefficiency SF for non-b-tagged jets in SUSYTools_xAOD::BtagSF" );
835  break;
836  default:
837  ATH_MSG_VERBOSE( "Retrieve SF for non-b-tagged jets in SUSYTools_xAOD::BtagSF with value " << sf );
838  }
839  }
840  }
841 
842  dec_effscalefact(*jet) = sf;
843 
844  if( acc_signal(*jet) && acc_passOR(*jet) ) totalSF *= sf; //consider goodjets only
845 
846  }
847 
848  return totalSF;
849  }

◆ BtagSF_trkJet()

float ST::SUSYObjDef_xAOD::BtagSF_trkJet ( const xAOD::JetContainer trkjets)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 872 of file Jets.cxx.

872  {
873 
874  float totalSF = 1.;
875  for ( const xAOD::Jet* trkjet : *trkjets ) {
876 
877  float sf = 1.;
878 
879  if ( std::abs(trkjet->eta()) > 2.5 ) {
880  ATH_MSG_VERBOSE( "Trying to retrieve b-tagging SF for trkjet with |eta|>2.5 (trkjet eta=" << trkjet->eta() << "), trkjet will be skipped");
881  } else if ( trkjet->pt() < 10e3 ){
882  ATH_MSG_VERBOSE( "Trying to retrieve b-tagging SF for trkjet with invalid pt (trkjet pt=" << trkjet->pt() << "), jet will be skipped");
883  } else {
884 
886  int truthlabel(-1);
887  if (!trkjet->getAttribute("HadronConeExclTruthLabelID", truthlabel)) {
888  ATH_MSG_ERROR("Failed to get jet truth label!");
889  }
890  ATH_MSG_VERBOSE("This jet is " << (acc_bjet(*trkjet) ? "" : "not ") << "b-tagged.");
891  ATH_MSG_VERBOSE("This jet's truth label is " << truthlabel);
892 
893  if ( acc_bjet(*trkjet) ) {
895 
896  switch (result) {
898  ATH_MSG_ERROR( "Failed to retrieve SF for b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet" );
899  break;
901  ATH_MSG_VERBOSE( "No valid SF for b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet" );
902  break;
903  default:
904  ATH_MSG_VERBOSE( "Retrieve SF for b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet with value " << sf );
905  }
906  } else {
907 
909 
910  switch (result) {
912  ATH_MSG_ERROR( "Failed to retrieve SF for non-b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet" );
913  break;
915  ATH_MSG_VERBOSE( "No valid inefficiency SF for non-b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet" );
916  break;
917  default:
918  ATH_MSG_VERBOSE( "Retrieve SF for non-b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet with value " << sf );
919  }
920  }
921  }
922 
923  dec_effscalefact(*trkjet) = sf;
924 
925  if( acc_signal(*trkjet) ) totalSF *= sf;
926 
927  }
928 
929  return totalSF;
930  }

◆ BtagSFsys()

float ST::SUSYObjDef_xAOD::BtagSFsys ( const xAOD::JetContainer jets,
const CP::SystematicSet systConfig 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 852 of file Jets.cxx.

853  {
854  float totalSF = 1.;
855 
856  //Set the new systematic variation
858  if ( ret != StatusCode::SUCCESS) {
859  ATH_MSG_ERROR("Cannot configure BTaggingEfficiencyTool for systematic var. " << systConfig.name() );
860  }
861 
862  totalSF = BtagSF( jets );
863 
865  if ( ret != StatusCode::SUCCESS) {
866  ATH_MSG_ERROR("Cannot configure BTaggingEfficiencyTool for systematic var. " << systConfig.name() );
867  }
868 
869  return totalSF;
870  }

◆ BtagSFsys_trkJet()

float ST::SUSYObjDef_xAOD::BtagSFsys_trkJet ( const xAOD::JetContainer trkjets,
const CP::SystematicSet systConfig 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 933 of file Jets.cxx.

934  {
935  float totalSF = 1.;
936 
937  //Set the new systematic variation
939  if ( ret != StatusCode::SUCCESS) {
940  ATH_MSG_ERROR("Cannot configure BTaggingEfficiencyTool (track jets) for systematic var. " << systConfig.name() );
941  }
942 
943  totalSF = BtagSF_trkJet( trkjets );
944 
946  if ( ret != StatusCode::SUCCESS) {
947  ATH_MSG_ERROR("Cannot configure BTaggingEfficiencyTool (track jets) for systematic var. " << systConfig.name() );
948  }
949 
950  return totalSF;
951  }

◆ check_isOption()

bool ST::SUSYObjDef_xAOD::check_isOption ( const std::string &  wp,
const std::vector< std::string > &  list 
) const
protected

Definition at line 1202 of file SUSYObjDef_xAOD.cxx.

1202  {
1203  //check if the selected WP is supported
1204  return (std::find(list.begin(), list.end(),wp) != list.end());
1205 }

◆ check_isTighter()

bool ST::SUSYObjDef_xAOD::check_isTighter ( const std::string &  wp1,
const std::string &  wp,
const std::vector< std::string > &  list 
) const
protected

Definition at line 1207 of file SUSYObjDef_xAOD.cxx.

1207  {
1208  //check if WP1 is tighter than WP2
1209  //it is assumed that both WPs are supported
1210  return (std::find(list.begin(),list.end(),wp1) > std::find(list.begin(), list.end(),wp2));
1211 }

◆ configFromFile() [1/4]

void ST::SUSYObjDef_xAOD::configFromFile ( bool &  property,
const std::string &  propname,
TEnv &  rEnv,
bool  defaultValue 
)
protected

Definition at line 1245 of file SUSYObjDef_xAOD.cxx.

1247 {
1248  if(m_bool_prop_set.find(m_conf_to_prop[propname])!=m_bool_prop_set.end()){
1249  ATH_MSG_INFO( "configFromFile(): property \"" << propname << "\" already set with value " << property << ". Ignoring change request." );
1250  rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(propname.c_str() ) );
1251  return;
1252  }
1253  property = rEnv.GetValue(propname.c_str(), static_cast<int>(defaultValue));
1254  ATH_MSG_INFO( "configFromFile(): Loaded property \"" << propname << "\" with value " << property );
1255  // Remove the item from the table
1256  rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(propname.c_str() ) );
1257 }

◆ configFromFile() [2/4]

void ST::SUSYObjDef_xAOD::configFromFile ( double &  property,
const std::string &  propname,
TEnv &  rEnv,
double  defaultValue 
)
protected

Definition at line 1260 of file SUSYObjDef_xAOD.cxx.

1262 {
1263  // ignore if already configured
1264  if (property > -90.) {
1265  ATH_MSG_INFO( "configFromFile(): property \"" << propname << "\" already set with value " << property << ". Ignoring change request." );
1266  rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(propname.c_str() ) );
1267  return;
1268  }
1269  property = rEnv.GetValue(propname.c_str(), defaultValue);
1270  ATH_MSG_INFO( "configFromFile(): Loaded property \"" << propname << "\" with value " << property );
1271  // Remove the item from the table
1272  rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(propname.c_str() ) );
1273 }

◆ configFromFile() [3/4]

void ST::SUSYObjDef_xAOD::configFromFile ( int &  property,
const std::string &  propname,
TEnv &  rEnv,
int  defaultValue 
)
protected

Definition at line 1276 of file SUSYObjDef_xAOD.cxx.

1278 {
1279  // ignore if already configured
1280  if (property > -90){
1281  ATH_MSG_INFO( "configFromFile(): property \"" << propname << "\" already set with value " << property << ". Ignoring change request." );
1282  rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(propname.c_str() ) );
1283  return;
1284  }
1285  property = rEnv.GetValue(propname.c_str(), defaultValue);
1286  ATH_MSG_INFO( "configFromFile(): Loaded property \"" << propname << "\" with value " << property );
1287  // Remove the item from the table
1288  rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(propname.c_str() ) );
1289 }

◆ configFromFile() [4/4]

void ST::SUSYObjDef_xAOD::configFromFile ( std::string &  property,
const std::string &  propname,
TEnv &  rEnv,
const std::string &  defaultValue,
bool  allowEmpty = false 
)
protected

Definition at line 1292 of file SUSYObjDef_xAOD.cxx.

1294 {
1295  // ignore if already configured
1296  if (!property.empty()){
1297  ATH_MSG_INFO( "configFromFile(): property \"" << propname << "\" already set with value " << property << ". Ignoring change request." );
1298  rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(propname.c_str() ) );
1299  return;
1300  }
1301  property = rEnv.GetValue(propname.c_str(), defaultValue.c_str());
1302  if (property.empty() && !allowEmpty) {
1303  ATH_MSG_FATAL("Read empty string property from text file (property name: " << propname << ")");
1304  }
1305 
1306  // post-processing to get rid of leading/trailing spaces and comments
1307  std::string tmp_prop = property.substr(0, property.find('#', 0));
1308  property = TString(tmp_prop).ReplaceAll(" ","").Data();
1309 
1310  // Interpret None as an empty string
1311  if (property=="None" || property=="NONE" || property=="none") {
1312  ATH_MSG_VERBOSE( "Property \"" << propname << "\" being set to empty string due to specification of \"" << property << "\"" );
1313  property = "";
1314  }
1315 
1316  ATH_MSG_INFO( "configFromFile(): Loaded property \"" << propname << "\" with value " << property );
1317  // Remove the item from the table
1318  rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(propname.c_str() ) );
1319 }

◆ currentSystematic()

const CP::SystematicSet & ST::SUSYObjDef_xAOD::currentSystematic ( ) const

Definition at line 2077 of file SUSYObjDef_xAOD.cxx.

2077  {
2078  return m_currentSyst;
2079 }

◆ currentSystematicIsNominal()

bool ST::SUSYObjDef_xAOD::currentSystematicIsNominal ( ) const

Definition at line 2105 of file SUSYObjDef_xAOD.cxx.

2105  {
2106  return isNominal(m_currentSyst);
2107 }

◆ currentSystematicIsVariation()

bool ST::SUSYObjDef_xAOD::currentSystematicIsVariation ( ) const

Definition at line 2109 of file SUSYObjDef_xAOD.cxx.

2109  {
2110  return isVariation(m_currentSyst);
2111 }

◆ currentSystematicIsWeight()

bool ST::SUSYObjDef_xAOD::currentSystematicIsWeight ( ) const

Definition at line 2113 of file SUSYObjDef_xAOD.cxx.

2113  {
2114  return isWeight(m_currentSyst);
2115 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyArrayType  
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyType  
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleType  
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType  
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleBase hndl,
const std::string &  doc,
const SG::VarHandleType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKey hndl,
const std::string &  doc,
const SG::VarHandleKeyType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType  
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ EG_WP()

std::string ST::SUSYObjDef_xAOD::EG_WP ( const std::string &  wp) const
protected

Definition at line 1214 of file SUSYObjDef_xAOD.cxx.

1214  {
1215  //translate our electron wps to EGamma internal jargon
1216  //@ElectronPhotonSelectorTools/EGSelectorConfigurationMapping.h
1217  TString copy = TString(wp).Copy().ReplaceAll("AndBLayer","BL").ReplaceAll("LLH","LHElectron");
1218  // the DNN WPs are labeled in the map as e.g. TightDNNnoCFElectron or TightDNNElectron
1219  if (wp.find("DNNnoCF") != std::string::npos)
1220  copy.ReplaceAll("DNNnoCF", "DNNnoCFElectron");
1221  else if (wp.find("DNN") != std::string::npos)
1222  copy.ReplaceAll("DNN", "DNNElectron");
1223  return copy.Data();
1224 }

◆ emulateHLT()

bool ST::SUSYObjDef_xAOD::emulateHLT ( const std::string &  triggerName) const
private

Definition at line 99 of file Trigger.cxx.

99  {
100  std::scoped_lock lock (m_triggerCacheMutex);
101  // First, check if we've already tried using this trigger
102  auto funcItr = m_metTriggerFuncs.find(triggerName);
103  if (funcItr != m_metTriggerFuncs.end() )
104  return funcItr->second();
105 
106  // Next, check that it really is a HLT MET trigger
107  if (triggerName.substr(0,6) != "HLT_xe") {
108  ATH_MSG_ERROR( "Requested trigger " << triggerName << " isn't a MET trigger! (HLT MET items should begin with 'HLT_xe'). Will return false." );
109  return false;
110  }
111 
112  // Next, parse the name to work out which containers are needed to emulate the decision
113  std::vector<std::pair<int, std::string> > hypos; // algorithms and thresholds needed
114  std::string temp(triggerName);
115  // Note, we need to split on '_AND_' used for the combined mht+cell trigger
116  do {
117  auto pos = temp.find("_AND_");
118  std::string itemName = temp.substr(0, pos);
119  ATH_MSG_DEBUG( "Split trigger item " << itemName );
120  if (pos == std::string::npos)
121  temp = "";
122  else
123  temp = temp.substr(pos + 5);
124 
125  std::regex expr("HLT_xe([[:digit:]]+)_?(mht|pufit|pueta|tc_lcw|)_?(?:L1XE([[:digit:]]+)|)");
126  std::smatch sm;
127  if (!std::regex_match(itemName, sm, expr) ) {
128  ATH_MSG_WARNING( "Regex reading for item " << itemName << " (" << triggerName << ") failed! Will be ignored!" );
129  continue;
130  }
131  if (sm.size() < 4) { // first object is the whole match, then there are three capture groups
132  ATH_MSG_WARNING( "Regex failed to capture the right groups for item " << itemName << " (" << triggerName << ") failed! Will be ignored!" );
133  for (unsigned int ii = 0; ii < sm.size(); ++ii) {
134  ATH_MSG_WARNING( sm[ii] );
135  }
136  continue;
137  }
138  int threshold = std::stoi(sm[1] );
139  std::string algKey = sm[2];
140  std::string metContBaseName = "HLT_xAOD__TrigMissingETContainer_TrigEFMissingET";
141  if (algKey.empty()) hypos.push_back(std::make_pair(threshold, metContBaseName) );
142  else if (algKey == "mht") hypos.push_back(std::make_pair(threshold, metContBaseName+"_mht") );
143  else if (algKey == "pufit") hypos.push_back(std::make_pair(threshold, metContBaseName+"_topocl_PUC") );
144  else if (algKey == "pueta") hypos.push_back(std::make_pair(threshold, metContBaseName+"_topocl_PS") );
145  else if (algKey == "tc_lcw") hypos.push_back(std::make_pair(threshold, metContBaseName+"topocl") );
146 
147  ATH_MSG_DEBUG( "Container: " << hypos.back().second << ", Threshold: " << hypos.back().first );
148 
149  if (sm[3] != "" && sm[3] != "50") {
150  ATH_MSG_WARNING( "The trigger requires a different L1 item to L1_XE50! This currently isn't allowed for in the code so the emulation will be slightly wrong" );
151  // Note, now the L1 part is done in the previous section. However I'm keeping this warning here.
152  }
153  }
154  while (!temp.empty());
155 
156  // Check if we have the containers and construct the lambda
157  // Already done the L1 decision - only care about HLT
158  std::function<bool()> lambda;
159  bool hasRequired = true;
160  if (hypos.empty()) lambda = [] () {return false;};
161  else {
162  for (const auto& pair : hypos) {
163  if (evtStore()->contains<xAOD::TrigMissingETContainer>(pair.second) ) {
164  auto lambda_hypo = [this, pair] () {
165  const xAOD::TrigMissingETContainer* cont(nullptr);
166  if (evtStore()->retrieve(cont, pair.second) ) {
167  if (cont->empty()) return false;
168  float ex = cont->front()->ex() * 0.001;
169  float ey = cont->front()->ey() * 0.001;
170  float met = std::sqrt(ex*ex + ey*ey);
171  return met > pair.first;
172  }
173  else {
174  return false;
175  }
176  };
177  // an empty std::function evaluates to false
178  if (lambda) {
179  lambda = [lambda, lambda_hypo] () {
180  return lambda() && lambda_hypo();
181  };
182  }
183  else {
184  lambda = lambda_hypo;
185  }
186  }
187  else {
188  hasRequired = false;
189  ATH_MSG_WARNING( "Container: " << pair.second << " missing!" );
190  }
191  }
192  }
193  if (hasRequired) {
194  m_metTriggerFuncs[triggerName] = lambda;
195  return m_metTriggerFuncs.at(triggerName)();
196  }
197  // We can't get the exact trigger decision :( . Look for an alternative
198  std::vector<std::string> replacementTriggers({"HLT_xe110_mht_L1XE50", "HLT_xe100_mht_L1XE50", "HLT_xe90_mht_L1XE50", "HLT_xe70_mht"});
199  for (const std::string& trigName : replacementTriggers) {
200  if (isTrigInTDT(lock, trigName) ) {
201  ATH_MSG_WARNING( "Trigger " << triggerName << " not available and direct emulation impossible! Will use " << trigName << " instead!");
202  m_metTriggerFuncs[triggerName] = [this, trigName] () {
203  return m_trigDecTool->isPassed(trigName);
204  };
205  return m_metTriggerFuncs.at(triggerName)();
206  }
207  }
208  ATH_MSG_ERROR( "Cannot find the trigger in the menu, direct emulation is impossible and no replacement triggers are available! Will return false" );
209  m_metTriggerFuncs.at(triggerName) = [] () {return false;};
210  return m_metTriggerFuncs.at(triggerName)();
211 }

◆ endInputFile()

StatusCode asg::AsgMetadataTool::endInputFile ( )
protectedvirtualinherited

Function called when the currently open input file got completely processed.

Dummy implementation that can be overridden by the derived tool.

Reimplemented in BookkeeperTool, xAODMaker::FileMetaDataTool, BookkeeperDumperTool, xAODMaker::TriggerMenuMetaDataTool, and xAODMaker::TruthMetaDataTool.

Definition at line 188 of file AsgMetadataTool.cxx.

188  {
189 
190  // Return gracefully:
191  return StatusCode::SUCCESS;
192  }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ FillElectron()

StatusCode ST::SUSYObjDef_xAOD::FillElectron ( xAOD::Electron input,
const float  etcut,
const float  etacut 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 221 of file Electrons.cxx.

221  {
222 
223  ATH_MSG_VERBOSE( "Starting FillElectron on el with pre-calibration pt=" << input.pt() );
224 
225  // According to https://twiki.cern.ch/twiki/bin/view/AtlasProtected/EGammaIdentificationRun2#Electron_identification:
226  // "Please apply the identification to uncalibrated electron object. ID scale factors are to be applied to calibrated objects."
227  dec_baseline(input) = false;
228  dec_selected(input) = 0;
229  dec_signal(input) = false;
230  dec_isol(input) = false;
231  dec_isolHighPt(input) = false;
232  dec_passSignalID(input) = false;
233  dec_passChID(input) = false;
234  dec_ecisBDT(input) = -999.;
235 
236  const xAOD::EventInfo* evtInfo = nullptr;
237  ATH_CHECK( evtStore()->retrieve( evtInfo, "EventInfo" ) );
238  const xAOD::Vertex* pv = this->GetPrimVtx();
239  const xAOD::TrackParticle* track = input.trackParticle();
240  if (!track) {
241  ATH_MSG_DEBUG("No primary track particle for this electron. Skipping.");
242  return StatusCode::SUCCESS;
243  }
244  double primvertex_z = pv ? pv->z() : 0;
245  double el_z0 = track->z0() + track->vz() - primvertex_z;
246  dec_z0sinTheta(input) = el_z0 * TMath::Sin(input.p4().Theta());
247  //protect against exception thrown for null or negative d0sig
248  try{
249  dec_d0sig(input) = xAOD::TrackingHelpers::d0significance( track , evtInfo->beamPosSigmaX(), evtInfo->beamPosSigmaY(), evtInfo->beamPosSigmaXY() );
250  }
251  catch(...){
252  float d0sigError = -99.;
253  ATH_MSG_WARNING("FillElectron : Exception catched from d0significance() calculation. Setting dummy decoration d0sig=" << d0sigError );
254  dec_d0sig(input) = d0sigError;
255  }
256 
257  // don't bother calibrating or computing WP
258  if ( input.pt() < 4e3 ) return StatusCode::SUCCESS;
259  if ( !input.caloCluster() ) { ATH_MSG_WARNING( "FillElectron: no caloCluster found: " << input.caloCluster() ); return StatusCode::SUCCESS; }
260 
261  //Check DeadHVCellRemoval
262  bool pass_deadHVTool = m_deadHVTool->accept(&input);
263 
264  if (m_debug) {
265  unsigned char el_nPixHits(0), el_nSCTHits(0);
266  input.trackParticle()->summaryValue(el_nPixHits, xAOD::numberOfPixelHits);
267  input.trackParticle()->summaryValue(el_nSCTHits, xAOD::numberOfSCTHits);
268 
269  ATH_MSG_INFO( "ELECTRON eta: " << input.eta());
270  ATH_MSG_INFO( "ELECTRON phi: " << input.phi());
271  ATH_MSG_INFO( "ELECTRON cl eta: " << input.caloCluster()->eta());
272  ATH_MSG_INFO( "ELECTRON cl phi: " << input.caloCluster()->phi());
273  ATH_MSG_INFO( "ELECTRON cl e: " << input.caloCluster()->e());
274  ATH_MSG_INFO( "ELECTRON trk eta: " << input.trackParticle()->eta());
275  ATH_MSG_INFO( "ELECTRON trk phi: " << input.trackParticle()->phi());
276  ATH_MSG_INFO( "ELECTRON author: " << input.author());
277  ATH_MSG_INFO( "ELECTRON OQ: " << acc_OQ(input));
278  ATH_MSG_INFO( "ELECTRON nPixHits: " << static_cast<int>(el_nPixHits));
279  ATH_MSG_INFO( "ELECTRON nSCTHits: " << static_cast<int>(el_nSCTHits));
280  ATH_MSG_INFO( "ELECTRON deadHVTools: " << static_cast<bool>(pass_deadHVTool));
281  }
282 
283  if (!pass_deadHVTool) return StatusCode::SUCCESS;
284  if (!input.isGoodOQ(xAOD::EgammaParameters::BADCLUSELECTRON)) return StatusCode::SUCCESS;
285 
287  ATH_MSG_ERROR("No baseline electron selector defined!");
288  return StatusCode::FAILURE;
289  }
290 
291  bool passBaseID = false;
292  if (m_eleIdExpert) {
293  passBaseID = bool(m_elecSelLikelihoodBaseline->accept(&input));
294  } else {
296  passBaseID = m_acc_eleIdBaseline(input);
297  } else {
298  ATH_MSG_VERBOSE ("DFCommonElectronsLHxxx variables are not found. Calculating the ID from LH tool..");
299  passBaseID = bool(m_elecSelLikelihoodBaseline->accept(&input));
300  }
301  }
302 
303  if ( !passBaseID && !m_force_noElId ) return StatusCode::SUCCESS;
304 
305  //baseline ID decoration for TauEl OR
306  //dec_passBaseID(input) = true;
307 
308  // calibrate the electron 4-vector here only if within eta window
309  if (std::abs(input.caloCluster()->etaBE(2)) >= etacut) return StatusCode::SUCCESS;
310 
312  if ( std::abs( input.caloCluster()->etaBE(2) ) >1.37 && std::abs( input.caloCluster()->etaBE(2) ) <1.52) {
313  return StatusCode::SUCCESS;
314  }
315  }
316 
317  // corrections described in https://twiki.cern.ch/twiki/bin/view/AtlasProtected/EGammaCalibrationRun2
319  ATH_MSG_ERROR( "FillElectron: EgammaCalibTool applyCorrection failed ");
320 
322  ATH_MSG_ERROR("FillElectron: IsolationCorrectionTool applyCorrection failed");
323 
324  ATH_MSG_VERBOSE( "FillElectron: post-calibration pt=" << input.pt() );
325 
326  if (input.pt() < etcut) return StatusCode::SUCCESS;
327 
328  if (m_elebaselinez0>0. && std::abs(acc_z0sinTheta(input))>m_elebaselinez0) return StatusCode::SUCCESS;
329  if (m_elebaselined0sig>0. && std::abs(acc_d0sig(input))>m_elebaselined0sig) return StatusCode::SUCCESS;
330 
331  //--- Do baseline isolation check
332  if ( !( m_eleBaselineIso_WP.empty() ) && !( m_isoBaselineTool->accept(input) ) ) return StatusCode::SUCCESS;
333 
334  dec_baseline(input) = true;
335  dec_selected(input) = 2;
336  //disable if (!m_eleIso_WP.empty() && m_eleIso_WP.find("PLV")!=std::string::npos) ATH_CHECK( ->augmentPLV(input) );
337  if (!m_eleIso_WP.empty()) dec_isol(input) = bool(m_isoTool->accept(input));
338  if (!m_eleIsoHighPt_WP.empty()) dec_isolHighPt(input) = bool(m_isoHighPtTool->accept(input));
339 
340  //ChargeIDSelector
341  if( m_runECIS ){
342  if (acc_passECIDS.isAvailable(input)) {
343  dec_passChID(input) = acc_passECIDS(input); // Loose 97% WP!
344  } else {
345  dec_passChID(input) = bool(m_elecChargeIDSelectorTool->accept(&input));
346  //disable double bdt = m_elecChargeIDSelectorTool->calculate(&input).getResult("bdt");
347  //disable dec_ecisBDT(input) = bdt;
348  }
349  }
350  else{
351  dec_passChID(input) = true;
352  }
353 
354  ATH_MSG_VERBOSE( "FillElectron: passed baseline selection" );
355 
356  return StatusCode::SUCCESS;
357 }

◆ FillJet()

StatusCode ST::SUSYObjDef_xAOD::FillJet ( xAOD::Jet input,
const bool  doCalib = true,
bool  isFat = false,
bool  doLargeRdecorations = false 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 384 of file Jets.cxx.

384  {
385 
386  ATH_MSG_VERBOSE( "Starting FillJet on jet with pt=" << input.pt() );
387  ATH_MSG_VERBOSE( "jet (pt,eta,phi) before calibration " << input.pt() << " " << input.eta() << " " << input.phi() );
388 
389  static const SG::ConstAccessor<bool> acc_wValidKinRange(m_WDecorName+"_ValidKinRange");
390  static const SG::ConstAccessor<bool> acc_zValidKinRange(m_ZDecorName+"_ValidKinRange");
391  static const SG::ConstAccessor<bool> acc_topValidKinRange(m_TopDecorName+"_ValidKinRange");
392  static const SG::ConstAccessor<bool> acc_wtagged(m_WDecorName+"_Tagged");
393  static const SG::ConstAccessor<bool> acc_ztagged(m_ZDecorName+"_Tagged");
394  static const SG::ConstAccessor<bool> acc_toptagged(m_TopDecorName+"_Tagged");
395 
396  if (doCalib) {
397  if(!isFat){
398  //disable - obsoleted ATH_CHECK( m_jetCalibTool->applyCalibration(input) );
399  }
400  else {
401  //disable - obsoleted ATH_CHECK( m_jetFatCalibTool->applyCalibration(input) );
402  dec_baseline(input) = ( input.pt() > m_jetPt ) || ( input.pt() > 20e3 ); // Allows for setting m_jetPt < 20e3
403  dec_bad(input) = false;
404  dec_signal(input) = false;
405  dec_bjet_loose(input) = false;
406  dec_effscalefact(input) = 1.;
407  dec_passOR(input) = true;
408  dec_bjet_jetunc(input) = false;
409  dec_btag_weight(input) = -999.;
410 
411  dec_wtagged(input) = -1;
412  dec_ztagged(input) = -1;
413  dec_toptagged(input) = -1;
414  if (doLargeRdecorations) {
418 
419  // Retrieve large-R tagging results for W/Z/top
420  if (!m_WtagConfig.empty()) {
421  // Only tag jets if they are inside the kinematic range
422  if ( !acc_wValidKinRange(input) ) {
423  ATH_MSG_VERBOSE("Large-R W candidate jet outside of recommended tagging range. Will set score to 0.");
424  dec_wtagged(input) = 0;
425  }
426  else dec_wtagged(input) = acc_wtagged(input);
427  }
428  if (!m_ZtagConfig.empty()) {
429  // Only tag jets if they are inside the kinematic range
430  if ( !acc_zValidKinRange(input) ) {
431  ATH_MSG_VERBOSE("Large-R Z candidate jet outside of recommended tagging range. Will set score to 0.");
432  dec_ztagged(input) = 0;
433  }
434  else dec_ztagged(input) = acc_ztagged(input);
435  }
436  if (!m_ToptagConfig.empty()) {
437  // Only tag jets if they are inside the kinematic range
438  if ( !acc_topValidKinRange(input) ) {
439  ATH_MSG_VERBOSE("Large-R Top candidate jet outside of recommended tagging range. Will set score to 0.");
440  dec_toptagged(input) = 0;
441  }
442  else dec_toptagged(input) = acc_toptagged(input);
443  }
444 
445  }
446 
447  // If a user hasn't specified an uncertainty config, then this tool will be empty
448  // for large R jets
449  if (!m_WTagjetUncertaintiesTool.empty() && !m_WTagUncConfig.empty() && !m_WtagConfig.empty() && doLargeRdecorations) {
451  switch (result) {
453  ATH_MSG_ERROR( "Failed to apply largeR W-tag jet scale uncertainties.");
454  return StatusCode::FAILURE;
455  //break;
457  ATH_MSG_VERBOSE( "No valid pt/eta/m range for largeR W-tag jet scale uncertainties. ");
458  break;
459  default:
460  break;
461  }
462  } else {
463  ATH_MSG_DEBUG( "No valid large-R W-tagged fat jet uncertainty, but FillJet called with a fat jet. Skipping uncertainties." );
464  }
465 
466  if (!m_ZTagjetUncertaintiesTool.empty() && !m_ZTagUncConfig.empty() && !m_ZtagConfig.empty() && doLargeRdecorations) {
468  switch (result) {
470  ATH_MSG_ERROR( "Failed to apply largeR Z-tag jet scale uncertainties.");
471  return StatusCode::FAILURE;
472  //break;
474  ATH_MSG_VERBOSE( "No valid pt/eta/m range for largeR Z-tag jet scale uncertainties. ");
475  break;
476  default:
477  break;
478  }
479  } else {
480  ATH_MSG_DEBUG( "No valid large-R Z-tagged fat jet uncertainty, but FillJet called with a fat jet. Skipping uncertainties." );
481  }
482 
483  if (!m_TopTagjetUncertaintiesTool.empty() && !m_TopTagUncConfig.empty() && !m_ToptagConfig.empty() && doLargeRdecorations) {
485  switch (result) {
487  ATH_MSG_ERROR( "Failed to apply largeR Top-tag jet scale uncertainties.");
488  return StatusCode::FAILURE;
489  //break;
491  ATH_MSG_VERBOSE( "No valid pt/eta/m range for largeR Top-tag jet scale uncertainties. ");
492  break;
493  default:
494  break;
495  }
496  } else {
497  ATH_MSG_DEBUG( "No valid large-R Top-tagged fat jet uncertainty, but FillJet called with a fat jet. Skipping uncertainties." );
498  }
499 
502  switch (result) {
504  ATH_MSG_ERROR( "Failed to apply largeR jet scale uncertainties.");
505  return StatusCode::FAILURE;
506  //break;
508  ATH_MSG_VERBOSE( "No valid pt/eta/m range for largeR jet scale uncertainties. ");
509  break;
510  default:
511  break;
512  }
513  } else {
514  ATH_MSG_DEBUG( "No valid fat jet uncertainty, but FillJet called with a fat jet. Skipping uncertainties." );
515  }
516  ATH_MSG_VERBOSE( "Large-R jet (pt,eta,phi) after calibration " << input.pt() << " " << input.eta() << " " << input.phi() );
517 
518  return StatusCode::SUCCESS;
519  }
520  ATH_MSG_VERBOSE( "jet (pt,eta,phi) after calibration " << input.pt() << " " << input.eta() << " " << input.phi() );
521 
522  }
523 
524  dec_passOR(input) = true;
525  dec_bjet_jetunc(input) = false;
526 
527  if (m_useBtagging) {
528  if (m_BtagWP != "Continuous") this->IsBJet(input);
529  else this->IsBJetContinuous(input);
530  }
531 
532  if ( (input.pt() > m_jetPt) || (input.pt() > 15e3) ) {
533  if(!isFat && m_currentSyst.name().find("__2") == std::string::npos) {
534  // Use the normal jet uncertainties tool for this systematic and do not use the PDSmeared initialised tool
536  switch (result) {
538  ATH_MSG_ERROR( "Failed to apply JES correction" );
539  break;
541  ATH_MSG_WARNING( "JES correction OutOfValidity range."); // Jet (pt,eta,phi) = (" << input.pt() << ", " << input.eta() << ", " << input.phi() << ")");
542  break;
543  default:
544  break;
545  }
546  }
547  }
548 
550  if ( (input.pt() > m_jetPt) || (input.pt() > 15e3) ) {
551  if(!isFat && m_currentSyst.name().find("__2") != std::string::npos){
552  // Use the PDSmeared uncertainties tool on the systematic with PDsmear in the name
554  switch (result) {
556  ATH_MSG_ERROR( "Failed to apply JES correction" );
557  break;
559  ATH_MSG_WARNING( "JES correction OutOfValidity range."); // Jet (pt,eta,phi) = (" << input.pt() << ", " << input.eta() << ", " << input.phi() << ")");
560  break;
561  default:
562  break;
563  }
564  }
565  }
566  }
567 
568 
569  ATH_MSG_VERBOSE( "jet (pt,eta,phi) after JES correction " << input.pt() << " " << input.eta() << " " << input.phi() );
570 
572  dec_passFJvt(input) = !m_doFwdJVT || m_jetfJvtSelectionTool->accept(&input);
573  dec_baseline(input) = ( input.pt() > m_jetPt ) || ( input.pt() > 20e3 ); // Allows for setting m_jetPt < 20e3
574  dec_bad(input) = false;
575  dec_signal_less_JVT(input) = false;
576  dec_signal(input) = false;
577  dec_bjet_loose(input) = false;
578  dec_effscalefact(input) = 1.;
579 
580  //new state for OR . 0=non-baseline objects, 1=for baseline jets not passing JVT, 2=for any other baseline object
581  if (acc_baseline(input) ){
582  if( acc_passJvt(input) ) dec_selected(input) = 2;
583  else dec_selected(input) = 1;
584  }
585  else{
586  dec_selected(input) = 0;
587  }
588 
589  if (m_useBtagging && !m_orBtagWP.empty()) {
590  dec_bjet_loose(input) = this->IsBJetLoose(input);
591  }
592 
593  if (m_debug) {
594  ATH_MSG_INFO( "JET pt: " << input.pt() );
595  ATH_MSG_INFO( "JET eta: " << input.eta() );
596  ATH_MSG_INFO( "JET phi: " << input.phi() );
597  ATH_MSG_INFO( "JET E: " << input.e() );
598  ATH_MSG_INFO( "JET Ceta: " << input.jetP4(xAOD::JetConstitScaleMomentum).eta() );
599  ATH_MSG_INFO( "JET Cphi: " << input.jetP4(xAOD::JetConstitScaleMomentum).phi() );
600  ATH_MSG_INFO( "JET CE: " << input.jetP4(xAOD::JetConstitScaleMomentum).e() );
601  ATH_MSG_INFO( "JET Cm: " << input.jetP4(xAOD::JetConstitScaleMomentum).M() ); // fix-me M
602 
603  }
604 
605  return StatusCode::SUCCESS;
606  }

◆ FillMuon()

StatusCode ST::SUSYObjDef_xAOD::FillMuon ( xAOD::Muon input,
const float  ptcut,
const float  etacut 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 205 of file Muons.cxx.

205  {
206 
207  ATH_MSG_VERBOSE( "Starting FillMuon on mu with pt=" << input.pt() );
208 
209  dec_baseline(input) = false;
210  dec_selected(input) = 0;
211  dec_signal(input) = false;
212  dec_isol(input) = false;
213  dec_isolHighPt(input) = false;
214  dec_passedHighPtCuts(input) = false;
215  dec_passSignalID(input) = false;
216 
217  if (m_muEffCorrForce1D) {
218  dec_DFCommonJetDr(input) = -2.0;
219  } else if (!acc_DFCommonJetDr.isAvailable(input)) {
220  dec_dRJet(input) = -2.0;
221  }
222 
223  // don't bother calibrating or computing WP
224  if ( input.pt() < 3e3 ) return StatusCode::SUCCESS;
225 
226  ATH_MSG_VERBOSE( "MUON pt before calibration " << input.pt() );
227 
228  ATH_MSG_VERBOSE( "MUON eta = " << input.eta() );
229  ATH_MSG_VERBOSE( "MUON type = " << input.muonType() );
230  ATH_MSG_VERBOSE( "MUON author = " << input.author() );
231 
233  ATH_MSG_VERBOSE("FillMuon: applyCorrection out of validity range");
234  }
235 
236  ATH_MSG_VERBOSE( "MUON pt after calibration " << input.pt() );
237 
238  const xAOD::EventInfo* evtInfo = nullptr;
239  ATH_CHECK( evtStore()->retrieve( evtInfo, "EventInfo" ) );
240  const xAOD::Vertex* pv = this->GetPrimVtx();
241  double primvertex_z = pv ? pv->z() : 0;
242  //const xAOD::TrackParticle* track = input.primaryTrackParticle();
243  const xAOD::TrackParticle* track;
244  if (input.muonType() == xAOD::Muon::SiliconAssociatedForwardMuon) {
245  track = input.trackParticle(xAOD::Muon::CombinedTrackParticle);
246  if (!track) return StatusCode::SUCCESS; // don't treat SAF muons without CB track further
247  }
248  else {
249  track = input.primaryTrackParticle();
250  }
251 
252  //impact parameters (after applyCorrection() so to have the primaryTrack links restored in old buggy samples)
253  if (track){
254  dec_z0sinTheta(input) = (track->z0() + track->vz() - primvertex_z) * TMath::Sin(input.p4().Theta());
255  } else {
256  ATH_MSG_WARNING("FillMuon: Muon of pT and eta " << input.pt() << " MeV " << input.eta() << " has no associated track");
257  }
258  //protect against exception thrown for null or negative d0sig
259  try {
260  if (track)
261  dec_d0sig(input) = xAOD::TrackingHelpers::d0significance( track , evtInfo->beamPosSigmaX(), evtInfo->beamPosSigmaY(), evtInfo->beamPosSigmaXY() );
262  else
263  dec_d0sig(input) = -99.;
264  }
265  catch (...) {
266  float d0sigError = -99.;
267  ATH_MSG_WARNING("FillMuon : Exception caught from d0significance() calculation. Setting dummy decoration d0sig=" << d0sigError );
268  dec_d0sig(input) = d0sigError;
269  }
270 
271  if (m_debug) {
272  // Summary variables in
273  // /cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.0.3/xAODTracking/Root/TrackSummaryAccessors_v1.cxx
274 
275  unsigned char nBLHits(0), nPixHits(0), nPixelDeadSensors(0), nPixHoles(0),
276  nSCTHits(0), nSCTDeadSensors(0), nSCTHoles(0), nTRTHits(0), nTRTOutliers(0);
277 
278  if (track){
279  track->summaryValue( nBLHits, xAOD::numberOfBLayerHits);
280  track->summaryValue( nPixHits, xAOD::numberOfPixelHits);
281  track->summaryValue( nPixelDeadSensors, xAOD::numberOfPixelDeadSensors);
282  track->summaryValue( nPixHoles, xAOD::numberOfPixelHoles);
283 
284  track->summaryValue( nSCTHits, xAOD::numberOfSCTHits);
285  track->summaryValue( nSCTDeadSensors, xAOD::numberOfSCTDeadSensors);
286  track->summaryValue( nSCTHoles, xAOD::numberOfSCTHoles);
287 
288  track->summaryValue( nTRTHits, xAOD::numberOfTRTHits);
289  track->summaryValue( nTRTOutliers, xAOD::numberOfTRTOutliers);
290  }
291 
292  ATH_MSG_INFO( "MUON pt: " << input.pt() );
293  ATH_MSG_INFO( "MUON eta: " << input.eta() );
294  ATH_MSG_INFO( "MUON phi: " << input.phi() );
295  ATH_MSG_INFO( "MUON comb: " << (input.muonType() == xAOD::Muon::Combined));
296  ATH_MSG_INFO( "MUON sTag: " << (input.muonType() == xAOD::Muon::SegmentTagged));
297  ATH_MSG_INFO( "MUON loose:" << (input.quality() == xAOD::Muon::Loose));
298  ATH_MSG_INFO( "MUON bHit: " << static_cast<int>( nBLHits ));
299  ATH_MSG_INFO( "MUON pHit: " << static_cast<int>( nPixHits ));
300  ATH_MSG_INFO( "MUON pDead:" << static_cast<int>( nPixelDeadSensors ));
301  ATH_MSG_INFO( "MUON pHole:" << static_cast<int>( nPixHoles ));
302  ATH_MSG_INFO( "MUON sHit: " << static_cast<int>( nSCTHits));
303  ATH_MSG_INFO( "MUON sDead:" << static_cast<int>( nSCTDeadSensors ));
304  ATH_MSG_INFO( "MUON sHole:" << static_cast<int>( nSCTHoles ));
305  ATH_MSG_INFO( "MUON tHit: " << static_cast<int>( nTRTHits ));
306  ATH_MSG_INFO( "MUON tOut: " << static_cast<int>( nTRTOutliers ));
307 
308  const xAOD::TrackParticle* idtrack =
309  input.trackParticle( xAOD::Muon::InnerDetectorTrackParticle );
310 
311  if ( !idtrack) {
312  ATH_MSG_VERBOSE( "No ID track!! " );
313  } else {
314  ATH_MSG_VERBOSE( "ID track pt: " << idtrack->pt());
315  }
316  }
317 
318  if ( !m_force_noMuId && !m_muonSelectionToolBaseline->accept(input)) return StatusCode::SUCCESS;
319 
320  if (input.pt() <= ptcut || std::abs(input.eta()) >= etacut) return StatusCode::SUCCESS;
321 
322  if (m_mubaselinez0>0. && std::abs(acc_z0sinTheta(input))>m_mubaselinez0) return StatusCode::SUCCESS;
323  if (m_mubaselined0sig>0. && std::abs(acc_d0sig(input))>m_mubaselined0sig) return StatusCode::SUCCESS;
324 
325  //--- Do baseline isolation check
326  if ( !( m_muBaselineIso_WP.empty() ) && !( m_isoBaselineTool->accept(input) ) ) return StatusCode::SUCCESS;
327 
328  dec_baseline(input) = true;
329  dec_selected(input) = 2;
330 
331  //disable if (!m_muIso_WP.empty() && m_muIso_WP.find("PLV")!=std::string::npos) ATH_CHECK( m_isoToolLowPtPLV->augmentPLV(input) );
332  if (!m_muIso_WP.empty()) dec_isol(input) = bool(m_isoTool->accept(input));
333  if (!m_muIsoHighPt_WP.empty()) dec_isolHighPt(input) = bool(m_isoHighPtTool->accept(input));
334  dec_passSignalID(input) = bool(m_muonSelectionTool->accept(input));
335 
336  ATH_MSG_VERBOSE("FillMuon: passed baseline selection");
337  return StatusCode::SUCCESS;
338 }

◆ FillPhoton()

StatusCode ST::SUSYObjDef_xAOD::FillPhoton ( xAOD::Photon input,
const float  ptcut,
const float  etacut 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 78 of file Photons.cxx.

78  {
79 
80  ATH_MSG_VERBOSE( "Starting FillPhoton on ph with pre-calibration pt=" << input.pt() );
81 
82  if ( !input.caloCluster() ) {
83  ATH_MSG_WARNING( "FillPhoton: no caloCluster found: " << input.caloCluster() );
84  return StatusCode::SUCCESS;
85  }
86 
87  //Check DeadHVCellRemoval
88  bool pass_deadHVTool = m_deadHVTool->accept(&input);
89 
90  if (m_debug) {
91  ATH_MSG_INFO( "PHOTON eta: " << input.eta() );
92  ATH_MSG_INFO( "PHOTON phi: " << input.phi() );
93  ATH_MSG_INFO( "PHOTON cl eta: " << input.caloCluster()->eta() );
94  ATH_MSG_INFO( "PHOTON cl phi: " << input.caloCluster()->phi() );
95  ATH_MSG_INFO( "PHOTON cl e: " << input.caloCluster()->e() );
96  ATH_MSG_INFO( "PHOTON OQ: " << input.OQ() );
97  ATH_MSG_INFO( "PHOTON author: " << input.author() );
98  ATH_MSG_INFO( "PHOTON deadHVTools: " << pass_deadHVTool );
99  }
100 
101  dec_baseline(input) = false;
102  dec_selected(input) = 0;
103  dec_isol(input) = false;
104  dec_isEM(input) = 0;
105 
106  if (!pass_deadHVTool) return StatusCode::SUCCESS;
107 
108  // Author cuts needed according to https://twiki.cern.ch/twiki/bin/view/AtlasProtected/EGammaIdentificationRun2#Photon_authors
110  return StatusCode::SUCCESS;
111 
113  ATH_MSG_ERROR("FillPhoton: EgammaCalibTool applyCorrection failed");
114 
116  ATH_MSG_ERROR("FillPhoton: IsolationCorrectionTool applyCorrection failed");
117 
118  ATH_MSG_VERBOSE( "FillPhoton: post-calibration pt=" << input.pt() );
119 
120  if (input.pt() < ptcut || std::abs(input.caloCluster()->etaBE(2)) >= etacut) return StatusCode::SUCCESS;
121 
123  if ( std::abs( input.caloCluster()->etaBE(2) ) >1.37 && std::abs( input.caloCluster()->etaBE(2) ) <1.52) {
124  return StatusCode::SUCCESS;
125  }
126  }
127 
128  //Object quality cut as described at https://twiki.cern.ch/twiki/bin/view/AtlasProtected/EGammaIdentificationRun2#Object_quality_cut
130  return StatusCode::SUCCESS;
131 
132  //Photon quality as in https://twiki.cern.ch/twiki/bin/view/AtlasProtected/EGammaIdentificationRun2#Photon_cleaning
133  bool passPhCleaning = false;
134  if (acc_passPhCleaning.isAvailable(input) && acc_passPhCleaningNoTime.isAvailable(input)) {
135  if ( (!m_photonAllowLate && acc_passPhCleaning(input)) || (m_photonAllowLate && acc_passPhCleaningNoTime(input)) ) passPhCleaning = true;
136  } else {
137  ATH_MSG_VERBOSE ("DFCommonPhotonsCleaning is not found in DAOD..");
139  ( m_photonAllowLate && PhotonHelpers::passOQqualityDelayed(input)) ) passPhCleaning = true;
140  }
141  if (!passPhCleaning) return StatusCode::SUCCESS;
142 
143 
144  bool passBaseID = false;
146  passBaseID = bool(m_acc_photonIdBaseline(input));
147  } else {
148  passBaseID = bool(m_photonSelIsEMBaseline->accept(&input));
149  }
150  if (!passBaseID) return StatusCode::SUCCESS;
151 
152  //--- Do baseline isolation check
153  if ( !( m_photonBaselineIso_WP.empty() ) && !( m_isoBaselineTool->accept(input) ) ) return StatusCode::SUCCESS;
154 
155  dec_baseline(input) = true;
156  dec_selected(input) = 2;
157  if (!m_photonIso_WP.empty()) dec_isol(input) = bool(m_isoTool->accept(input));
158 
159  ATH_MSG_VERBOSE("FillPhoton: passed baseline selection.");
160  return StatusCode::SUCCESS;
161 }

◆ FillTau()

StatusCode ST::SUSYObjDef_xAOD::FillTau ( xAOD::TauJet input)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 76 of file Taus.cxx.

76  {
77 
78  ATH_MSG_VERBOSE( "Starting FillTau on tau with pT = " << input.pt()/1000 << " GeV" );
79  ATH_MSG_VERBOSE( "TAU pT before smearing " << input.pt()/1000 << " GeV");
80 
81  // do truth matching first (required unless already done in AOD->DAOD and truth matching info kept in DAOD)
83  ATH_MSG_VERBOSE("Tau truth matching done");
84 
85  // apply the calibration to data as well (not needed in R22, unless MVA TES gets updated)
86  if (std::abs(input.eta()) <= 2.5 && input.nTracks() > 0) {
88  ATH_MSG_ERROR(" Tau smearing failed " );
89  } else { ATH_MSG_VERBOSE("Tau smearing done"); }
90  }
91 
92  ATH_MSG_VERBOSE( "TAU pt after smearing " << input.pt()/1000. );
93 
94  // if tauPrePtCut set, apply min pT cut here before calling tau selection tool
95  // (avoid exceptions when running on derivations with removed tracks for low-pT taus, e.g. HIGG4D2)
96  if (input.pt() > m_tauPrePtCut) {
97  dec_baseline(input) = bool(m_tauSelToolBaseline->accept( input ));
98  }
99  else {
100  dec_baseline(input) = false;
101  }
102  if (acc_baseline(input)) dec_selected(input) = 2;
103  else dec_selected(input) = 0;
104 
105  if (acc_baseline(input)) ATH_MSG_VERBOSE("FillTau: passed baseline selection");
106  else ATH_MSG_VERBOSE("FillTau: failed baseline selection");
107  return StatusCode::SUCCESS;
108 }

◆ FillTrackJet()

StatusCode ST::SUSYObjDef_xAOD::FillTrackJet ( xAOD::Jet input)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 608 of file Jets.cxx.

608  {
609 
610  ATH_MSG_VERBOSE( "Starting FillTrackJet on jet with pt=" << input.pt() );
611 
612  dec_btag_weight(input) = -999.;
613  dec_effscalefact(input) = 1.;
614 
615  if (m_defaultTrackJets == "AntiKtVR30Rmax4Rmin02TrackJets") {
616  // VR recommendation
617  // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/BTagCalib2017#Recommendations_for_variable_rad
618  dec_baseline(input) = input.pt() >= 5e3 && input.numConstituents() >= 2;
619  if (m_trkJetPt < 10e3)
620  ATH_MSG_WARNING ("The pt threshold of VR jets you set is: " << m_trkJetPt/1000. << " GeV. But VR jets with pt < 10GeV are uncalibrated.");
621  dec_signal(input) = acc_baseline(input) && input.pt() >= m_trkJetPt && std::abs(input.eta()) <= m_trkJetEta;
622  dec_VRradius(input) = std::max(0.02,std::min(0.4,30000./input.pt()));
623  dec_passDRcut(input) = acc_signal(input);
624  } else {
625  dec_baseline(input) = input.pt() >= m_trkJetPt && std::abs(input.eta()) <= m_trkJetEta;
626  dec_signal(input) = acc_baseline(input);
627  }
628 
629  if (m_useBtagging_trkJet) {
630  if (m_BtagWP_trkJet != "Continuous") this->IsTrackBJet(input);
631  else this->IsTrackBJetContinuous(input);
632  }
633 
634  if (m_debug) {
635  ATH_MSG_INFO( "TRK JET pt: " << input.pt() );
636  ATH_MSG_INFO( "TRK JET eta: " << input.eta() );
637  ATH_MSG_INFO( "TRK JET phi: " << input.phi() );
638  ATH_MSG_INFO( "TRK JET E: " << input.e() );
639  }
640 
641  return StatusCode::SUCCESS;
642  }

◆ FindSusyHardProc() [1/2]

bool ST::SUSYObjDef_xAOD::FindSusyHardProc ( const xAOD::TruthEvent truthE,
int &  pdgid1,
int &  pdgid2 
)
static

Definition at line 231 of file Truth.cxx.

231  {
232 
233  pdgid1 = 0;
234  pdgid2 = 0;
235 
236  //go for TRUTH1-like ...
237  const xAOD::TruthParticle* firstsp(nullptr);
238  const xAOD::TruthParticle* secondsp(nullptr);
239 
240  for (unsigned int p=0; p < truthE->nTruthParticles(); ++p){
241 
242  const xAOD::TruthParticle* tp = truthE->truthParticle(p);
243 
244  //check ifSUSY particle
245  if ((tp->absPdgId() > 1000000 && tp->absPdgId() < 1000007) || // squarkL
246  (tp->absPdgId() > 1000010 && tp->absPdgId() < 1000017) || // sleptonL
247  (tp->absPdgId() > 2000000 && tp->absPdgId() < 2000007) || // squarkR
248  (tp->absPdgId() > 2000010 && tp->absPdgId() < 2000017) || // sleptonR
249  (tp->absPdgId() > 1000020 && tp->absPdgId() < 1000040)) { // gauginos
250 
251  if (tp->nParents() != 0) {
252  if ( tp->parent(0)->absPdgId() < 1000000) {
253  if (!firstsp) {
254  firstsp = tp;
255  } else if (!secondsp) {
256  secondsp = tp;
257  } else {
258  if (firstsp->nChildren() != 0 && HepMC::is_same_particle(tp,firstsp->child(0))) {
259  firstsp = tp;
260  }
261  else if (secondsp->nChildren() != 0 && HepMC::is_same_particle(tp,secondsp->child(0))) {
262  secondsp = tp;
263  }
264  else if (firstsp->nChildren() != 0 && HepMC::is_same_particle(firstsp->child(0),secondsp)) {
265  firstsp = secondsp;
266  secondsp = tp;
267  }
268  else if (secondsp->nChildren() != 0 && HepMC::is_same_particle(secondsp->child(0),firstsp)) {
269  secondsp = firstsp;
270  firstsp = tp;
271  }
272  }
273  }
274  }
275  }
276  }
277 
278  // quit if no sparticles found
279  if (!firstsp && !secondsp) return true; // should find none or two
280 
281  if (firstsp->nChildren() == 1) {
282  for (unsigned int p=0; p < truthE->nTruthParticles(); ++p){
283  const xAOD::TruthParticle* tp = truthE->truthParticle(p);
284  if (HepMC::is_same_particle(tp,firstsp->child(0)) && tp->pdgId() != firstsp->pdgId()) {
285  firstsp = tp;
286  break;
287  }
288  }
289  }
290 
291  if (secondsp->nChildren() == 1) {
292  for (unsigned int p=0; p < truthE->nTruthParticles(); ++p){
293  const xAOD::TruthParticle* tp = truthE->truthParticle(p);
294  if (HepMC::is_same_particle(tp,secondsp->child(0)) && tp->pdgId() != secondsp->pdgId()) {
295  secondsp = tp;
296  break;
297  }
298  }
299  }
300 
301  if (firstsp->absPdgId() > 1000000) pdgid1 = firstsp->pdgId();
302  if (secondsp->absPdgId() > 1000000) pdgid2 = secondsp->pdgId();
303 
304  // Return gracefully:
305  return true;
306 }

◆ FindSusyHardProc() [2/2]

bool ST::SUSYObjDef_xAOD::FindSusyHardProc ( const xAOD::TruthParticleContainer truthP,
int &  pdgid1,
int &  pdgid2,
bool  isTruth3 = false 
)
static

Definition at line 125 of file Truth.cxx.

125  {
126 
127  pdgid1 = 0;
128  pdgid2 = 0;
129 
130  //check for TRUTH3 structure first
131  if(isTruth3){
132  if(!truthP || truthP->size()<2){
133  return false;
134  }
135 
136  //get ID of first two BSM particles
137  pdgid1 = (*truthP)[0]->pdgId();
138  pdgid2 = (*truthP)[1]->pdgId();
139  return true;
140  }
141 
142  //go for TRUTH1-like if not...
143  const xAOD::TruthParticle* firstsp(nullptr);
144  const xAOD::TruthParticle* secondsp(nullptr);
145 
146  if (!truthP || truthP->empty()) {
147  return false;
148  }
149  for (const xAOD::TruthParticle* tp : *truthP) {
150 
151  //check ifSUSY particle
152  if ((tp->absPdgId() > 1000000 && tp->absPdgId() < 1000007) || // squarkL
153  (tp->absPdgId() > 1000010 && tp->absPdgId() < 1000017) || // sleptonL
154  (tp->absPdgId() > 2000000 && tp->absPdgId() < 2000007) || // squarkR
155  (tp->absPdgId() > 2000010 && tp->absPdgId() < 2000017) || // sleptonR
156  (tp->absPdgId() > 1000020 && tp->absPdgId() < 1000040)) { // gauginos
157 
158  if (tp->nParents() != 0) {
159  if ( tp->parent(0)->absPdgId() < 1000000) {
160  if (!firstsp) {
161  firstsp = tp;
162  } else if (!secondsp) {
163  secondsp = tp;
164  } else {
165  if (firstsp->nChildren() != 0 && HepMC::is_same_particle(tp,firstsp->child(0))) {
166  firstsp = tp;
167  }
168  else if (secondsp->nChildren() != 0 && HepMC::is_same_particle(tp,secondsp->child(0))) {
169  secondsp = tp;
170  }
171  else if (firstsp->nChildren() != 0 && HepMC::is_same_particle(firstsp->child(0),secondsp)) {
172  firstsp = secondsp;
173  secondsp = tp;
174  }
175  else if (secondsp->nChildren() != 0 && HepMC::is_same_particle(secondsp->child(0),firstsp)) {
176  secondsp = firstsp;
177  firstsp = tp;
178  }
179  }
180  }
181  }
182  }
183  }
184 
185  // quit if no sparticles found
186  if (!firstsp && !secondsp) return true; // should find none or two
187 
188  if (firstsp->nChildren() == 1) {
189  for (const xAOD::TruthParticle* tp : *truthP) {
190  if (HepMC::is_same_particle(tp,firstsp->child(0)) && tp->pdgId() != firstsp->pdgId()) {
191  firstsp = tp;
192  break;
193  }
194  }
195  }
196 
197  if (secondsp->nChildren() == 1) {
198  for (const xAOD::TruthParticle* tp : *truthP) {
199  if (HepMC::is_same_particle(tp,secondsp->child(0)) && tp->pdgId() != secondsp->pdgId()) {
200  secondsp = tp;
201  break;
202  }
203  }
204  }
205 
206  if (firstsp->absPdgId() > 1000000) pdgid1 = firstsp->pdgId();
207  if (secondsp->absPdgId() > 1000000) pdgid2 = secondsp->pdgId();
208 
209  // Return gracefully:
210  return true;
211 }

◆ FindSusyHP() [1/3]

StatusCode ST::SUSYObjDef_xAOD::FindSusyHP ( const xAOD::TruthEvent truthE,
int &  pdgid1,
int &  pdgid2 
) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 214 of file Truth.cxx.

214  {
215 
216  if (!truthE) {
217  ATH_MSG_ERROR("Null TruthEvent pointer!!");
218  return StatusCode::FAILURE;
219  }
220  if ( !SUSYObjDef_xAOD::FindSusyHardProc(truthE, pdgid1, pdgid2) ) {
221  ATH_MSG_ERROR("Problem finding SUSY hard process");
222  return StatusCode::FAILURE;
223  }
224  if (pdgid1 == 0 || pdgid2 == 0) {
225  ATH_MSG_DEBUG("No sparticles found!");
226  }
227  return StatusCode::SUCCESS;
228 }

◆ FindSusyHP() [2/3]

StatusCode ST::SUSYObjDef_xAOD::FindSusyHP ( const xAOD::TruthParticleContainer truthP,
int &  pdgid1,
int &  pdgid2,
bool  isTruth3 = false 
) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 105 of file Truth.cxx.

105  {
106  if (!truthP) {
107  ATH_MSG_ERROR("Null TruthParticleContainer pointer!!");
108  return StatusCode::FAILURE;
109  }
110  if (truthP->empty()) {
111  ATH_MSG_ERROR("Empty TruthParticleContainer!!");
112  return StatusCode::FAILURE;
113  }
114  if ( !SUSYObjDef_xAOD::FindSusyHardProc(truthP, pdgid1, pdgid2, isTruth3) ) {
115  ATH_MSG_ERROR("Problem finding SUSY hard process");
116  return StatusCode::FAILURE;
117  }
118  if (pdgid1 == 0 || pdgid2 == 0) {
119  ATH_MSG_DEBUG("No sparticles found!");
120  }
121  return StatusCode::SUCCESS;
122 }

◆ FindSusyHP() [3/3]

StatusCode ST::SUSYObjDef_xAOD::FindSusyHP ( int &  pdgid1,
int &  pdgid2 
) const

Definition at line 75 of file Truth.cxx.

75  {
76 
77  const xAOD::TruthParticleContainer* truthP = nullptr;
78  bool isTruth3 = false;
79  std::string key_T1 = "TruthParticles";
80  std::string key_T3 = "TruthBSM";
81 
82  ATH_MSG_DEBUG("Contains " << key_T1 << ": " << ((evtStore()->contains<xAOD::TruthParticleContainer>( key_T1 ))?1:0));
83  ATH_MSG_DEBUG("Contains " << key_T3 << ": " << ((evtStore()->contains<xAOD::TruthParticleContainer>( key_T3 ))?1:0));
84 
85  if(evtStore()->contains<xAOD::TruthParticleContainer>( key_T1 )){
86  ATH_CHECK( evtStore()->retrieve(truthP, key_T1) );
87  ATH_MSG_DEBUG("Retrieved " << key_T1 << " : size = " << truthP->size());
88  if (truthP->empty()) { ATH_MSG_WARNING(key_T1 << " is empty. Skipping FindSusyHP."); return StatusCode::SUCCESS; }
89  }
90  else if(evtStore()->contains<xAOD::TruthParticleContainer>( key_T3 )){
91  isTruth3=true;
92  ATH_CHECK( evtStore()->retrieve(truthP, key_T3) );
93  ATH_MSG_DEBUG("Retrieved " << key_T3 << " : size = " << truthP->size());
94  if (truthP->empty()) { ATH_MSG_WARNING(key_T3 << " is empty. Skipping FindSusyHP."); return StatusCode::SUCCESS; }
95  }
96  else {
97  ATH_MSG_WARNING("Neither " << key_T1 << " nor " << key_T3 << " are avaible. Skipping FindSusyHP.");
98  return StatusCode::SUCCESS;
99  }
100 
101  return SUSYObjDef_xAOD::FindSusyHP(truthP, pdgid1, pdgid2, isTruth3);
102 }

◆ FJVT_SF()

double ST::SUSYObjDef_xAOD::FJVT_SF ( const xAOD::JetContainer jets)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 1025 of file Jets.cxx.

1025  {
1026 
1027  float totalSF = 1.;
1028  if (!m_doFwdJVT) return totalSF;
1029 
1031  for (const xAOD::Jet* jet : *jets) {
1032  // Only jets that were good for every cut except JVT
1033  if (acc_signal_less_JVT(*jet) && acc_passOR(*jet)) {
1034  fjvtjets.push_back(jet);
1035  }
1036  }
1037 
1038  for (const xAOD::Jet* jet : fjvtjets) {
1039  float current_sf = 0;
1040 
1041  // the SF are only applied for HS jets and implicitely requires the presense of the isHS decoration
1043  if (acc_passFJvt(*jet)) {
1045  }
1046  else {
1048  }
1049 
1050  switch (result) {
1052  // this is probably not right, should report an error here
1053  ATH_MSG_ERROR("Inexplicably failed fJVT calibration" );
1054  break;
1056  // no fJvt SF for jet, that is ok e.g. for jets with |eta| < 2.5
1057  ATH_MSG_VERBOSE( "Skip SF application in SUSYTools_xAOD::FJVT_SF as jet outside validate range" );
1058  break;
1059  default:
1060  ATH_MSG_VERBOSE( "Retrieve SF for jet in SUSYTools_xAOD::FJVT_SF with value " << current_sf );
1061  totalSF *= current_sf;
1062  }
1063 
1064  }
1065 
1066  ATH_MSG_VERBOSE( "Retrieve total SF for jet container in SUSYTools_xAOD::FJVT_SF with value " << totalSF );
1067 
1068  return totalSF;
1069  }

◆ FJVT_SFsys()

double ST::SUSYObjDef_xAOD::FJVT_SFsys ( const xAOD::JetContainer jets,
const CP::SystematicSet systConfig 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 1071 of file Jets.cxx.

1071  {
1072 
1073  float totalSF = 1.;
1074  if (!m_doFwdJVT) return totalSF;
1075 
1076  //Set the new systematic variation
1078  if ( ret != StatusCode::SUCCESS) {
1079  ATH_MSG_ERROR("Cannot configure fJvtEfficiencyTool for systematic var. " << systConfig.name() );
1080  }
1081 
1082  // Delegate
1083  totalSF = SUSYObjDef_xAOD::FJVT_SF( jets );
1084 
1085  if (m_doFwdJVT) {
1087  if ( ret != StatusCode::SUCCESS) {
1088  ATH_MSG_ERROR("Cannot configure fJvtEfficiencyTool for systematic var. " << systConfig.name() );
1089  }
1090  }
1091 
1092  return totalSF;
1093  }

◆ GetCorrectedActualInteractionsPerCrossing()

float ST::SUSYObjDef_xAOD::GetCorrectedActualInteractionsPerCrossing ( bool  includeDataSF = false)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2986 of file SUSYObjDef_xAOD.cxx.

2986  {
2987  const xAOD::EventInfo* evtInfo = GetEventInfo();
2988  return m_prwTool->getCorrectedActualInteractionsPerCrossing( *evtInfo, includeDataSF );
2989 }

◆ GetCorrectedAverageInteractionsPerCrossing()

float ST::SUSYObjDef_xAOD::GetCorrectedAverageInteractionsPerCrossing ( bool  includeDataSF = false)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2981 of file SUSYObjDef_xAOD.cxx.

2981  {
2982  const xAOD::EventInfo* evtInfo = GetEventInfo();
2983  return m_prwTool->getCorrectedAverageInteractionsPerCrossing( *evtInfo, includeDataSF );
2984 }

◆ GetDataWeight()

float ST::SUSYObjDef_xAOD::GetDataWeight ( const std::string &  trig)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2976 of file SUSYObjDef_xAOD.cxx.

2976  {
2977  const xAOD::EventInfo* evtInfo = GetEventInfo();
2978  return m_prwTool->getDataWeight( *evtInfo, trig );
2979 }

◆ GetElectrons()

StatusCode ST::SUSYObjDef_xAOD::GetElectrons ( xAOD::ElectronContainer *&  copy,
xAOD::ShallowAuxContainer *&  copyaux,
const bool  recordSG = true,
const std::string &  elekey = "Electrons",
const std::string &  lrtelekey = "LRTElectrons",
const xAOD::ElectronContainer containerToBeCopied = nullptr 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 118 of file Electrons.cxx.

119 {
120  if (!m_tool_init) {
121  ATH_MSG_ERROR("SUSYTools was not initialized!!");
122  return StatusCode::FAILURE;
123  }
124 
125  // Initializing prompt/LRT OR procedure
126  auto outputCol = std::make_unique<xAOD::ElectronContainer>();
127  std::unique_ptr<xAOD::ElectronAuxContainer> outputAuxCol;
128  outputAuxCol = std::make_unique<xAOD::ElectronAuxContainer>();
129  outputCol->setStore(outputAuxCol.get());
131 
132  if (bool(m_eleLRT) && !lrtelekey.empty() && evtStore()->contains<xAOD::ElectronContainer>(lrtelekey)){
133  ATH_MSG_DEBUG("Applying prompt/LRT electron OR procedure");
134 
135  // First identify if merged container has already been made (for instances where GetElectrons() is called more than once)
136  if (evtStore()->contains<xAOD::ElectronContainer>("StdWithLRTElectrons")) {
137  ATH_MSG_DEBUG("Merged prompt/LRT container already created in TStore");
138  } else {
139  ATH_MSG_DEBUG("Creating merged prompt/LRT container in TStore");
140 
141  // Retrieve prompt and LRT electrons from TStore
143  ATH_CHECK( evtStore()->retrieve(lrt_electrons, lrtelekey) );
144 
145  // Remove LRT electrons as flagged by filter for uncertainty
146  auto filtered_electrons = std::make_unique<xAOD::ElectronContainer>();
147  std::unique_ptr<xAOD::ElectronAuxContainer> filtered_electrons_aux = std::make_unique<xAOD::ElectronAuxContainer>();
148  filtered_electrons->setStore(filtered_electrons_aux.get());
149  ATH_CHECK(prepareLRTElectrons(lrt_electrons, filtered_electrons.get()));
150 
151  // Check overlap between prompt and LRT collections
152  std::set<const xAOD::Electron *> ElectronsToRemove;
153  m_elecLRTORTool->checkOverlap(*prompt_electrons, *filtered_electrons, ElectronsToRemove);
154 
155  // Decorate electrons with prompt/LRT
156  for (const xAOD::Electron* el : *prompt_electrons) dec_isLRT(*el) = 0;
157  for (const xAOD::Electron* el : *filtered_electrons) dec_isLRT(*el) = 1;
158 
159  // Create merged StdWithLRTElectrons container
160  outputCol->reserve(prompt_electrons->size() + filtered_electrons->size());
161  ATH_CHECK(MergeElectrons(*prompt_electrons, outputCol.get(), ElectronsToRemove ));
162  ATH_CHECK(MergeElectrons(*filtered_electrons, outputCol.get(), ElectronsToRemove ));
163 
164  // Save merged StdWithLRTElectrons container to TStore
165  ATH_CHECK(evtStore()->record(std::move(outputCol), m_outElectronLocation.key()));
166  ATH_CHECK(evtStore()->record(std::move(outputAuxCol), m_outElectronLocation.key() + "Aux.") );
167  }
168  } else if (!lrtelekey.empty()) {
169  if(evtStore()->contains<xAOD::ElectronContainer>(lrtelekey) == false && bool(m_eleLRT) == true) ATH_MSG_WARNING("prompt/LRT OR procedure attempted but " << lrtelekey << " not in ROOT file, check config!");
170  ATH_MSG_DEBUG("Not applying prompt/LRT electron OR procedure");
171  }
172 
173  if (m_isPHYSLITE && elekey.find("AnalysisElectrons")==std::string::npos){
174  ATH_MSG_ERROR("You are running on PHYSLITE derivation. Please change the Electrons container to 'AnalysisElectrons'");
175  return StatusCode::FAILURE;
176  }
177 
178  const xAOD::ElectronContainer* electrons = nullptr;
179  if (bool(m_eleLRT) && evtStore()->contains<xAOD::ElectronContainer>(lrtelekey)){
180  ATH_MSG_DEBUG("Using container: " << m_outElectronLocation.key());
182  }
183  else {
184  if (copy==nullptr) { // empty container provided
185  ATH_MSG_DEBUG("Empty container provided");
186  if (containerToBeCopied != nullptr) {
187  ATH_MSG_DEBUG("Containter to be copied not nullptr");
188  electrons = containerToBeCopied;
189  }
190  else {
191  ATH_MSG_DEBUG("Getting Electrons collection");
192  ATH_CHECK( evtStore()->retrieve(electrons, elekey) );
193  }
194  }
195  }
196 
197  std::pair<xAOD::ElectronContainer*, xAOD::ShallowAuxContainer*> shallowcopy = xAOD::shallowCopyContainer(*electrons);
198  copy = shallowcopy.first;
199  copyaux = shallowcopy.second;
200  bool setLinks = xAOD::setOriginalObjectLink(*electrons, *copy);
201  if (!setLinks) {
202  ATH_MSG_WARNING("Failed to set original object links on " << elekey);
203  } else { // use the user-supplied collection instead
204  ATH_MSG_DEBUG("Not retrieving electron collection, using existing one provided by user");
205  electrons=copy;
206  }
207 
208  for (const auto& electron : *copy) {
211  }
212 
213  if (recordSG) {
214  ATH_CHECK( evtStore()->record(copy, "STCalib" + elekey + m_currentSyst.name()) );
215  ATH_CHECK( evtStore()->record(copyaux, "STCalib" + elekey + m_currentSyst.name() + "Aux.") );
216  }
217  return StatusCode::SUCCESS;
218 }

◆ GetEleTriggerEfficiency()

double ST::SUSYObjDef_xAOD::GetEleTriggerEfficiency ( const xAOD::Electron el,
const std::string &  trigExpr = "SINGLE_E_2015_e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose_2016_2018_e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0" 
) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 588 of file Electrons.cxx.

588  {
589 
590  std::string single_str = "SINGLE_E";
591  std::string single_str_2022 = "2022_";
592  std::string dilep_str = "DI_E";
593  std::string multi_str = "MULTI_L";
594 
595  double trig_eff(1.);
596 
598  if ( trigExpr.find(single_str) != std::string::npos || trigExpr.find(single_str_2022) != std::string::npos)
600  else if ( trigExpr.find(dilep_str) != std::string::npos )
601  ATH_MSG_ERROR( "Use GetTriggerGlobalEfficiency for logical OR of lepton triggers");
602  else if ( trigExpr.find(multi_str) != std::string::npos )
603  ATH_MSG_ERROR( "Use GetTriggerGlobalEfficiency for logical OR of lepton triggers");
604  else
605  ATH_MSG_ERROR( "The trigger expression (" << trigExpr << ") is not supported by the electron trigger efficiency!");
606 
607  switch (result) {
609  ATH_MSG_ERROR( "Failed to retrieve signal electron trigger efficiency");
610  return 1.;
612  ATH_MSG_VERBOSE( "OutOfValidityRange found for signal electron trigger efficiency");
613  return 1.;
614  default:
615  break;
616  }
617 
618  return trig_eff;
619 }

◆ GetEleTriggerEfficiencySF()

double ST::SUSYObjDef_xAOD::GetEleTriggerEfficiencySF ( const xAOD::Electron el,
const std::string &  trigExpr = "SINGLE_E_2015_e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose_2016_2018_e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0" 
) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 554 of file Electrons.cxx.

554  {
555 
556  double trig_sf(1.);
557 
558  std::string single_str = "SINGLE_E";
559  std::string single_str_2022 = "2022_";
560  std::string dilep_str = "DI_E";
561  std::string multi_str = "MULTI_L";
562 
564  if ( trigExpr.find(single_str) != std::string::npos || trigExpr.find(single_str_2022) != std::string::npos)
566  else if ( trigExpr.find(dilep_str) != std::string::npos )
567  ATH_MSG_ERROR( "Use GetTriggerGlobalEfficiency for logical OR of lepton triggers");
568  else if ( trigExpr.find(multi_str) != std::string::npos )
569  ATH_MSG_ERROR( "Use GetTriggerGlobalEfficiency for logical OR of lepton triggers");
570  else
571  ATH_MSG_ERROR( "The trigger expression (" << trigExpr << ") is not supported by the electron trigger SF!");
572 
573  switch (result) {
575  ATH_MSG_ERROR( "Failed to retrieve signal electron trigger SF");
576  return 1.;
578  ATH_MSG_VERBOSE( "OutOfValidityRange found for signal electron trigger SF");
579  return 1.;
580  default:
581  break;
582  }
583 
584  return trig_sf;
585 }

◆ getElSFkeys()

std::vector< std::string > ST::SUSYObjDef_xAOD::getElSFkeys ( const std::string &  mapFile) const
protected

Definition at line 1226 of file SUSYObjDef_xAOD.cxx.

1226  {
1227 
1228  if( mapFile.empty() )
1229  return {};
1230 
1231  std::vector<std::string> theKeys;
1232 
1233  std::string filename = PathResolverFindCalibFile(mapFile);
1234  std::ifstream input( filename );
1235  for( std::string line; getline( input, line ); ){
1236  std::vector<std::string> tokens = split((const std::string)line,"=");
1237  if(tokens.size()){
1238  theKeys.push_back(tokens.at(0));
1239  }
1240  }
1241 
1242  return theKeys;
1243 }

◆ GetEventInfo()

const xAOD::EventInfo * ST::SUSYObjDef_xAOD::GetEventInfo ( ) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2938 of file SUSYObjDef_xAOD.cxx.

2938  {
2939  const xAOD::EventInfo* evtInfo = nullptr;
2940  if ( evtStore()->retrieve( evtInfo, "EventInfo" ).isFailure() ) {
2941  throw std::runtime_error("Unable to fetch EventInfo.");
2942  }
2943  return evtInfo;
2944 }

◆ GetFatJets()

StatusCode ST::SUSYObjDef_xAOD::GetFatJets ( xAOD::JetContainer *&  copy,
xAOD::ShallowAuxContainer *&  copyaux,
const bool  recordSG = false,
const std::string &  jetkey = "",
const bool  doLargeRdecorations = false,
const xAOD::JetContainer containerToBeCopied = nullptr 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 243 of file Jets.cxx.

244  {
245  if (!m_tool_init) {
246  ATH_MSG_ERROR("SUSYTools was not initialized!!");
247  return StatusCode::FAILURE;
248  }
249 
250  if (m_fatJets.empty()) {
251  ATH_MSG_ERROR("JetFatCalibTool was not initialized for largeR jet!!");
252  return StatusCode::FAILURE;
253  }
254 
255  std::string jetkey_tmp = jetkey;
256  if (jetkey.empty()) {
257  jetkey_tmp = m_fatJets;
258  }
259 
260  const xAOD::JetContainer* jets = nullptr;
261  if (copy==nullptr) { // empty container provided
262  if (containerToBeCopied != nullptr) {
263  jets = containerToBeCopied;
264  }
265  else {
266  ATH_MSG_DEBUG("Retrieve jet collection: " << jetkey_tmp);
267  ATH_CHECK( evtStore()->retrieve(jets, jetkey_tmp) );
268  }
269 
270  std::pair<xAOD::JetContainer*, xAOD::ShallowAuxContainer*> shallowcopy = xAOD::shallowCopyContainer(*jets);
271  copy = shallowcopy.first;
272  copyaux = shallowcopy.second;
273  bool setLinks = xAOD::setOriginalObjectLink(*jets, *copy);
274  if (!setLinks) {
275  ATH_MSG_WARNING("Failed to set original object links on " << jetkey_tmp);
276  }
277  } else { // use the user-supplied collection instead
278  ATH_MSG_DEBUG("Not retrieving jet collection, using existing one provided by user");
279  jets=copy;
280  }
281 
282  if(jets->size()==0) {
283  ATH_MSG_DEBUG("Large R jet collection is empty");
284  return StatusCode::SUCCESS;
285  }
286 
287  // Calibrate the jets - only insitu for data for now
289 
290 
291  if (!isData() && !m_JetTruthLabelName.empty()){
292  ATH_MSG_DEBUG("Checking if decorator for JetTruthLabelingTool is available:");
293  std::string fatjetcoll = m_fatJets;
294  m_label_truthKey = fatjetcoll+"."+m_JetTruthLabelName;
296  ATH_MSG_DEBUG("Reading JetTruthLabelingTool truthKey:" << m_label_truthKey << " isAvailable " << labelHandle_truthKey.isAvailable());
297  // Truth Labeling (MC only)
298  if (!labelHandle_truthKey.isAvailable() && !m_isPHYSLITE) ATH_CHECK(m_jetTruthLabelingTool->decorate(*copy));
299  }
300 
301 
302  for (const auto& jet : *copy) {
303 
304  ATH_CHECK( this->FillJet(*jet, true, true, doLargeRdecorations) );
305  //
306  // For OR, selected if it passed cuts
307  if ( acc_baseline(*jet) ){
308  dec_selected(*jet) = 1;
309  }
310  else{
311  dec_selected(*jet) = 0;
312  }
313  }
314  if (recordSG) {
315  ATH_CHECK( evtStore()->record(copy, "STCalib" + jetkey_tmp + m_currentSyst.name()) );
316  ATH_CHECK( evtStore()->record(copyaux, "STCalib" + jetkey_tmp + m_currentSyst.name() + "Aux.") );
317  }
318  return StatusCode::SUCCESS;
319  }

◆ GetInDetLargeD0GSFTracks()

const xAOD::TrackParticleContainer & ST::SUSYObjDef_xAOD::GetInDetLargeD0GSFTracks ( const EventContext &  ctx) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3045 of file SUSYObjDef_xAOD.cxx.

3045  {
3047 
3048  if ( !tracks.isValid() ) {
3049  throw std::runtime_error("Unable to fetch LargeD0 GSF tracks.");
3050  }
3051  return *tracks;
3052 }

◆ GetInDetLargeD0Tracks()

const xAOD::TrackParticleContainer & ST::SUSYObjDef_xAOD::GetInDetLargeD0Tracks ( const EventContext &  ctx) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3033 of file SUSYObjDef_xAOD.cxx.

3033  {
3035 
3036  if ( !tracks.isValid() ) {
3037  throw std::runtime_error("Unable to fetch LargeD0 tracks.");
3038  }
3039 
3040  //const xAOD::TrackParticleContainer out = *tracks;
3041 
3042  return *tracks;
3043 }

◆ GetJets()

StatusCode ST::SUSYObjDef_xAOD::GetJets ( xAOD::JetContainer *&  copy,
xAOD::ShallowAuxContainer *&  copyaux,
const bool  recordSG = true,
const std::string &  jetkey = "",
const xAOD::JetContainer containerToBeCopied = nullptr 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 74 of file Jets.cxx.

75  {
76  if (!m_tool_init) {
77  ATH_MSG_ERROR("SUSYTools was not initialized!!");
78  return StatusCode::FAILURE;
79  }
80 
81  if (m_isPHYSLITE && jetkey.find("AnalysisJets") == std::string::npos){
82  ATH_MSG_ERROR("You are running on PHYSLITE derivation. Please change the Jets container to 'AnalysisJets'");
83  return StatusCode::FAILURE;
84  }
85 
86  ATH_MSG_DEBUG("Default jetkey: " << m_defaultJets);
87  ATH_MSG_DEBUG("Function argument jetkey: " << jetkey);
88 
89  // load default regular & btag jet keys
90  std::string jetkey_tmp = m_defaultJets; // use default for regular jetkey_tmp
91 
92  // override default if user is passing a jetkey
93  if (!jetkey.empty()) {
94  jetkey_tmp = jetkey;
95  }
96 
97  // final settings
98  ATH_MSG_DEBUG("Key for retrieving jet collection: jetkey = " << jetkey_tmp);
99 
100  const xAOD::JetContainer* jets = nullptr;
101  if (copy==nullptr) { // empty container provided
102  if (containerToBeCopied != nullptr) {
103  jets = containerToBeCopied;
104  }
105  else {
106  ATH_MSG_DEBUG("Retrieve jet collection: " << jetkey_tmp);
107  ATH_CHECK( evtStore()->retrieve(jets, jetkey_tmp) );
108  }
109  std::pair<xAOD::JetContainer*, xAOD::ShallowAuxContainer*> shallowcopy = xAOD::shallowCopyContainer(*jets);
110  copy = shallowcopy.first;
111  copyaux = shallowcopy.second;
112  bool setLinks = xAOD::setOriginalObjectLink(*jets, *copy);
113  if (!setLinks) {
114  ATH_MSG_WARNING("Failed to set original object links on " << jetkey_tmp);
115  }
116  } else { // use the user-supplied collection instead
117  ATH_MSG_DEBUG("Not retrieving jet collecton, using existing one provided by user");
118  jets = copy;
119  }
120 
121  // Calibrate the jets
123 
124  // Add isHS labels to jets (required for JvtEfficiencyTools)
125  if (!isData()) {
127  }
128 
129  // Calculate Jvt scores (required by METSignificance)
130  for (const auto& jet : *copy) {
131  dec_jvt(*jet) = m_jetJvtMomentTool->updateJvt(*jet);
132  }
133 
134  // Re-calculate NNJvt scores
136 
137  // Update the jets
138  for (const auto& jet : *copy) {
139  ATH_CHECK( this->FillJet(*jet) );
140  }
141 
142  for (const auto& jet : *copy) {
143  // Update the JVT decorations if needed
144  if( m_doFwdJVT){
145  dec_passJvt(*jet) = acc_passFJvt(*jet) && acc_passJvt(*jet);
146  dec_fjvt(*jet) = acc_fjvt(*jet);
147 
148  //new state for OR . 0=non-baseline objects, 1=for baseline jets not passing JVT, 2=for any other baseline object
149  if ( acc_baseline(*jet) ){
150  if( acc_passJvt(*jet) ) dec_selected(*jet) = 2;
151  else dec_selected(*jet) = 1;
152  }
153  else{
154  dec_selected(*jet) = 0;
155  }
156  }
157  this->IsBadJet(*jet);
158  this->IsSignalJet(*jet, m_jetPt, m_jetEta);
159  if (!isData())this->IsTruthBJet(*jet);
160  }
161  if (recordSG) {
162  std::string auxname = copyaux->name();
163  if (auxname.compare("UNKNOWN")==0) copyaux->setName(std::string("STCalib" + jetkey_tmp + m_currentSyst.name() + "AuxCopy").c_str());
164  ATH_CHECK( evtStore()->record(copy, "STCalib" + jetkey_tmp + m_currentSyst.name()) );
165  ATH_CHECK( evtStore()->record(copyaux, "STCalib" + jetkey_tmp + m_currentSyst.name() + "Aux.") );
166  }
167  return StatusCode::SUCCESS;
168  }

◆ GetJetsSyst()

StatusCode ST::SUSYObjDef_xAOD::GetJetsSyst ( const xAOD::JetContainer calibjets,
xAOD::JetContainer *&  copy,
xAOD::ShallowAuxContainer *&  copyaux,
const bool  recordSG = true,
const std::string &  jetkey = "" 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 322 of file Jets.cxx.

323  {
324  if (!m_tool_init) {
325  ATH_MSG_ERROR("SUSYTools was not initialized!!");
326  return StatusCode::FAILURE;
327  }
328 
329  std::string jetkey_tmp = jetkey;
330  if (jetkey.empty()) {
331  jetkey_tmp = m_defaultJets;
332  }
333 
334  std::pair<xAOD::JetContainer*, xAOD::ShallowAuxContainer*> shallowcopy = xAOD::shallowCopyContainer(calibjets);
335  copy = shallowcopy.first;
336  copyaux = shallowcopy.second;
337 
338  bool setLinks = xAOD::setOriginalObjectLink(calibjets, *copy);
339  if (!setLinks) {
340  ATH_MSG_WARNING("Failed to set original object links on " << jetkey_tmp);
341  }
342 
343  // ghost associate the muons to the jets (needed by MET muon-jet OR later)
344  ATH_MSG_VERBOSE("Run muon-to-jet ghost association");
345  const xAOD::MuonContainer* muons = nullptr;
346  // Do a little guessing
347  if (jetkey!="AnalysisJets"){
348  ATH_CHECK( evtStore()->retrieve(muons, "Muons") );
349  } else {
350  ATH_CHECK( evtStore()->retrieve(muons, "AnalysisMuons") );
351  }
352  met::addGhostMuonsToJets(*muons, *copy);
353 
354  // Update the jets
355  for (const auto& jet : *copy) {
356  ATH_CHECK( this->FillJet(*jet, false) );
357  }
358 
359  for (const auto& jet : *copy) {
360  // Update the JVT decorations if needed
361  if( m_doFwdJVT){
362  dec_passJvt(*jet) = acc_passFJvt(*jet) && acc_passJvt(*jet);
363 
364  //new state for OR . 0=non-baseline objects, 1=for baseline jets not passing JVT, 2=for any other baseline object
365  if ( acc_baseline(*jet) ){
366  if( acc_passJvt(*jet) ) dec_selected(*jet) = 2;
367  else dec_selected(*jet) = 1;
368  }
369  else{
370  dec_selected(*jet) = 0;
371  }
372  }
373  this->IsBadJet(*jet);
374  this->IsSignalJet(*jet, m_jetPt, m_jetEta);
375  if (!isData())this->IsTruthBJet(*jet);
376  }
377  if (recordSG) {
378  ATH_CHECK( evtStore()->record(copy, "STCalib" + jetkey_tmp + m_currentSyst.name()) );
379  ATH_CHECK( evtStore()->record(copyaux, "STCalib" + jetkey_tmp + m_currentSyst.name() + "Aux.") );
380  }
381  return StatusCode::SUCCESS;
382  }

◆ getKey()

SG::sgkey_t asg::AsgTool::getKey ( const void *  ptr) const
inherited

Get the (hashed) key of an object that is in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the SG::sgkey_t key for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also
asg::AsgTool::getName
Parameters
ptrThe bare pointer to the object that the event store should know about
Returns
The hashed key of the object in the store. If not found, an invalid (zero) key.

Definition at line 119 of file AsgTool.cxx.

119  {
120 
121 #ifdef XAOD_STANDALONE
122  // In case we use @c xAOD::TEvent, we have a direct function call
123  // for this.
124  return evtStore()->event()->getKey( ptr );
125 #else
126  const SG::DataProxy* proxy = evtStore()->proxy( ptr );
127  return ( proxy == nullptr ? 0 : proxy->sgkey() );
128 #endif // XAOD_STANDALONE
129  }

◆ getMCShowerType()

int ST::SUSYObjDef_xAOD::getMCShowerType ( const std::string &  sample_name = "",
const std::string &  tagger = "" 
) const
inlinefinaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 428 of file SUSYObjDef_xAOD.h.

428 { return ST::getMCShowerType(sample_name, tagger); }

◆ GetMET()

StatusCode ST::SUSYObjDef_xAOD::GetMET ( xAOD::MissingETContainer met,
const xAOD::JetContainer jet,
const xAOD::ElectronContainer elec = nullptr,
const xAOD::MuonContainer muon = nullptr,
const xAOD::PhotonContainer gamma = nullptr,
const xAOD::TauJetContainer taujet = nullptr,
bool  doTST = true,
bool  doJVTCut = true,
const xAOD::IParticleContainer invis = nullptr 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 23 of file MET.cxx.

30  {
31  if (!m_tool_init) {
32  ATH_MSG_ERROR("SUSYTools was not initialized!!");
33  return StatusCode::FAILURE;
34  }
35 
36  const xAOD::MissingETContainer* metcore(nullptr);
37  if ( evtStore()->retrieve( metcore, m_inputMETCore ).isFailure() ) {
38  ATH_MSG_WARNING( "Unable to retrieve MET core container: " << m_inputMETCore );
39  return StatusCode::FAILURE;
40  }
41  const xAOD::MissingETAssociationMap* metMap(nullptr);
42  if ( evtStore()->retrieve(metMap, m_inputMETMap).isFailure() ) {
43  ATH_MSG_WARNING("Unable to retrieve MissingETAssociationMap: " << m_inputMETMap);
44  return StatusCode::FAILURE;
45  }
46  // Helper keeps track of object selection flags for this map
47  xAOD::MissingETAssociationHelper metHelper(&(*metMap));
48 
49  std::string softTerm = "SoftClus";
50  if (doTST) {
51  softTerm = "PVSoftTrk";
52  } else if (doJVTCut) {
53  ATH_MSG_WARNING( "Requested CST MET and a JVT cut. This is not a recommended configuration - please consider switching to TST." );
54  }
55 
56  metHelper.resetObjSelectionFlags();
57 
58  // allow creation of proxy MET by flagging objects for "neutrino/ification" as already selected
59  if (invis) {
60  ATH_CHECK( m_metMaker->markInvisible(invis, metHelper, &met) );
61  }
62 
63  if (elec) {
64  ATH_MSG_VERBOSE("Build electron MET");
66  for (const xAOD::Electron* el : *elec) {
67  // pass baseline selection
68  if (acc_baseline(*el)) {
69  bool veto(false);
70  if (invis) {
71  for (const xAOD::IParticle* ipart : *invis) {
72  if (ipart == el) {veto = true; break;}
73  }
74  }
75  if (!veto) metelectron.push_back(el);
76  }
77  }
78  ATH_CHECK( m_metMaker->rebuildMET(m_eleTerm, xAOD::Type::Electron, &met, metelectron.asDataVector(), metHelper) );
79  }
80 
81  if (gamma) {
82  ATH_MSG_VERBOSE("Build photon MET");
84  for (const xAOD::Photon* ph : *gamma) {
85  // pass baseline selection
86  if (acc_baseline(*ph)) {
87  bool veto(false);
88  if (invis) {
89  for (const xAOD::IParticle* ipart : *invis) {
90  if (ipart == ph) {veto = true; break;}
91  }
92  }
93  if (!veto) metgamma.push_back(ph);
94  }
95  }
96  ATH_CHECK( m_metMaker->rebuildMET(m_gammaTerm, xAOD::Type::Photon, &met, metgamma.asDataVector(), metHelper) );
97  }
98 
99  if (taujet) {
100  ATH_MSG_VERBOSE("Build tau MET");
102  for (const xAOD::TauJet* tau : *taujet) {
103  // pass baseline selection
104  if (acc_baseline(*tau)) {
105  bool veto(false);
106  if (invis) {
107  for (const xAOD::IParticle* ipart : *invis) {
108  if (ipart == tau) {veto = true; break;}
109  }
110  }
111  if (!veto) mettau.push_back(tau);
112  }
113  }
114  ATH_CHECK( m_metMaker->rebuildMET(m_tauTerm, xAOD::Type::Tau, &met, mettau.asDataVector(), metHelper) );
115  }
116 
117  if (muon) {
118  ATH_MSG_VERBOSE("Build muon MET");
120  for (const xAOD::Muon* mu : *muon) {
121  bool veto(false);
122  // pass baseline selection
123  if (acc_baseline(*mu)) {
124  if (invis) {
125  for (const xAOD::IParticle* ipart : *invis) {
126  if (ipart == mu) {veto = true; break;}
127  }
128  }
129  if (!veto) metmuon.push_back(mu);
130  }
131  }
132  ATH_CHECK( m_metMaker->rebuildMET(m_muonTerm, xAOD::Type::Muon, &met, metmuon.asDataVector(), metHelper) );
133  }
134 
135  if (!jet) {
136  ATH_MSG_WARNING("Invalid jet container specified for MET rebuilding!");
137  return StatusCode::SUCCESS;
138  }
139 
140  ATH_MSG_VERBOSE("Build jet/soft MET");
141  ATH_CHECK( m_metMaker->rebuildJetMET(m_jetTerm, softTerm, &met, jet, metcore, metHelper, doJVTCut) );
142 
143  if (!isData()) {
144  m_metSystTool->setRandomSeed(static_cast<int>(1e6*met[softTerm]->phi()));
145  ATH_MSG_VERBOSE("Original soft term " << met[softTerm]->name() << " (met: " << met[softTerm]->met() << ")" );
146  if ( m_metSystTool->applyCorrection(*met[softTerm], metHelper) != CP::CorrectionCode::Ok ) {
147  ATH_MSG_WARNING("GetMET: Failed to apply MET soft term systematics.");
148  }
149  ATH_MSG_VERBOSE("New soft term value: " << met[softTerm]->met() );
150  }
151 
152  ATH_MSG_VERBOSE("Build MET sum");
153  ATH_CHECK( met::buildMETSum(m_outMETTerm, &met, met[softTerm]->source()) );
154  ATH_MSG_VERBOSE( "Rebuilt MET: Missing Et (x,y): (" << met[m_outMETTerm]->mpx() << "," << met[m_outMETTerm]->mpy() << ")");
155  ATH_MSG_VERBOSE( "Done rebuilding MET." );
156 
157  return StatusCode::SUCCESS;
158 }

◆ GetMETSig()

StatusCode ST::SUSYObjDef_xAOD::GetMETSig ( xAOD::MissingETContainer met,
double &  metSignificance,
bool  doTST = true,
bool  doJVTCut = true 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 240 of file MET.cxx.

242  {
243 
244  std::string softTerm = "SoftClus";
245  if (doTST) {
246  softTerm = "PVSoftTrk";
247  } else if (doJVTCut) {
248  ATH_MSG_WARNING( "Requested CST MET and a JVT cut. This is not a recommended configuration - please consider switching to TST." );
249  }
250 
251  const xAOD::EventInfo* evtInfo = nullptr;
252  ATH_CHECK( evtStore()->retrieve( evtInfo, "EventInfo" ) );
254  metSignificance = m_metSignif->GetSignificance();
255  ATH_MSG_VERBOSE( "Obtained MET Significance: " << metSignificance );
256 
257  return StatusCode::SUCCESS;
258 }

◆ GetMuons()

StatusCode ST::SUSYObjDef_xAOD::GetMuons ( xAOD::MuonContainer *&  copy,
xAOD::ShallowAuxContainer *&  copyaux,
const bool  recordSG = true,
const std::string &  muonkey = "Muons",
const std::string &  lrtmuonkey = "MuonsLRT",
const xAOD::MuonContainer containerToBeCopied = nullptr 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 100 of file Muons.cxx.

101 {
102  if (!m_tool_init) {
103  ATH_MSG_ERROR("SUSYTools was not initialized!!");
104  return StatusCode::FAILURE;
105  }
106 
107  // Initializing prompt/LRT OR procedure
108  auto outputCol = std::make_unique<xAOD::MuonContainer>();
109  std::unique_ptr<xAOD::MuonAuxContainer> outputAuxCol;
110  outputAuxCol = std::make_unique<xAOD::MuonAuxContainer>();
111  outputCol->setStore(outputAuxCol.get());
112  ATH_CHECK( m_outMuonLocation.initialize() );
113 
114  if (bool(m_muLRT) && !lrtmuonkey.empty() && evtStore()->contains<xAOD::MuonContainer>(lrtmuonkey)){
115  ATH_MSG_DEBUG("Applying prompt/LRT muon OR procedure");
116 
117  // First identify if merged container has already been made (for instances where GetMuons() is called more than once)
118  if (evtStore()->contains<xAOD::MuonContainer>("StdWithLRTMuons")) {
119  ATH_MSG_DEBUG("Merged prompt/LRT container already created in TStore");
120  } else {
121  ATH_MSG_DEBUG("Creating merged prompt/LRT container in TStore");
122 
123  // Retrieve prompt and LRT muons from TStore
124  ATH_CHECK( evtStore()->retrieve(prompt_muons, muonkey) );
125  ATH_CHECK( evtStore()->retrieve(lrt_muons, lrtmuonkey) );
126 
127  // Remove LRT muons as flagged by filter for uncertainty
128  auto filtered_muons = std::make_unique<xAOD::MuonContainer>();
129  std::unique_ptr<xAOD::MuonAuxContainer> filtered_muons_aux = std::make_unique<xAOD::MuonAuxContainer>();
130  filtered_muons->setStore(filtered_muons_aux.get());
131  ATH_CHECK(prepareLRTMuons(lrt_muons, filtered_muons.get()));
132 
133  // Check overlap between prompt and LRT collections
134  std::vector<bool> writePromptMuon;
135  std::vector<bool> writeLRTMuon;
136  m_muonLRTORTool->checkOverlap(*prompt_muons, *filtered_muons, writePromptMuon, writeLRTMuon);
137 
138  // Decorate muons with prompt/LRT
139  for (const xAOD::Muon* mu : *prompt_muons) dec_isLRT(*mu) = 0;
140  for (const xAOD::Muon* mu : *filtered_muons) dec_isLRT(*mu) = 1;
141 
142  // Create merged StdWithLRTMuons container
143  outputCol->reserve(prompt_muons->size() + filtered_muons->size());
144  ATH_CHECK(MergeMuons(*prompt_muons, writePromptMuon, outputCol.get()) );
145  ATH_CHECK(MergeMuons(*filtered_muons, writeLRTMuon, outputCol.get()) );
146 
147  // Save merged StdWithLRTMuons container to TStore
148  ATH_CHECK(evtStore()->record(std::move(outputCol), m_outMuonLocation.key()));
149  ATH_CHECK(evtStore()->record(std::move(outputAuxCol), m_outMuonLocation.key() + "Aux.") );
150 
151  }
152  } else if (!lrtmuonkey.empty()) {
153  if (evtStore()->contains<xAOD::MuonContainer>(lrtmuonkey) == false && bool(m_muLRT) == true) ATH_MSG_WARNING("prompt/LRT OR procedure attempted but " << lrtmuonkey << " not in ROOT file, check config!");
154  ATH_MSG_DEBUG("Not applying prompt/LRT muon OR procedure");
155  }
156 
157  if (m_isPHYSLITE && muonkey.find("AnalysisMuons")==std::string::npos){
158  ATH_MSG_ERROR("You are running on PHYSLITE derivation. Please change the Muons container to 'AnalysisMuons'");
159  return StatusCode::FAILURE;
160  }
161 
162  const xAOD::MuonContainer* muons = nullptr;
163  if (bool(m_muLRT) && evtStore()->contains<xAOD::MuonContainer>(lrtmuonkey)){
164  ATH_MSG_DEBUG("Using container: " << m_outMuonLocation.key());
165  ATH_CHECK( evtStore()->retrieve(muons, m_outMuonLocation.key()));
166  }
167  else {
168  if (copy==nullptr) { // empty container provided
169  ATH_MSG_DEBUG("Empty container provided");
170  if (containerToBeCopied != nullptr) {
171  ATH_MSG_DEBUG("Containter to be copied not nullptr");
172  muons = containerToBeCopied;
173  }
174  else {
175  ATH_MSG_DEBUG("Getting Muons collection");
176  ATH_CHECK( evtStore()->retrieve(muons, muonkey) );
177  }
178  }
179  }
180 
181  std::pair<xAOD::MuonContainer*, xAOD::ShallowAuxContainer*> shallowcopy = xAOD::shallowCopyContainer(*muons);
182  copy = shallowcopy.first;
183  copyaux = shallowcopy.second;
184  bool setLinks = xAOD::setOriginalObjectLink(*muons, *copy);
185  if (!setLinks) {
186  ATH_MSG_WARNING("Failed to set original object links on " << muonkey);
187  } else { // use the user-supplied collection instead
188  ATH_MSG_DEBUG("Not retrieving muon collection, using existing one provided by user");
189  muons=copy;
190  }
191 
192  for (const auto& muon : *copy) {
196  this->IsBadMuon(*muon, m_badmuQoverP);
197  }
198  if (recordSG) {
199  ATH_CHECK( evtStore()->record(copy, "STCalib" + muonkey + m_currentSyst.name()) );
200  ATH_CHECK( evtStore()->record(copyaux, "STCalib" + muonkey + m_currentSyst.name() + "Aux.") );
201  }
202  return StatusCode::SUCCESS;
203 }

◆ GetMuonTriggerEfficiency()

double ST::SUSYObjDef_xAOD::GetMuonTriggerEfficiency ( const xAOD::Muon mu,
const std::string &  trigExpr,
const bool  isdata = false 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 530 of file Muons.cxx.

530  {
531 
532  double eff(1.);
533 
535  ATH_MSG_WARNING("Problem retrieving signal muon trigger efficiency for " << trigExpr );
536  }
537  else{
538  ATH_MSG_DEBUG("Got efficiency " << eff << " for " << trigExpr );
539  }
540  return eff;
541 }

◆ getName()

const std::string & asg::AsgTool::getName ( const void *  ptr) const
inherited

Get the name of an object that is / should be in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the std::string name for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also
asg::AsgTool::getKey
Parameters
ptrThe bare pointer to the object that the event store should know about
Returns
The string name of the object in the store. If not found, an empty string.

Definition at line 106 of file AsgTool.cxx.

106  {
107 
108 #ifdef XAOD_STANDALONE
109  // In case we use @c xAOD::TEvent, we have a direct function call
110  // for this.
111  return evtStore()->event()->getName( ptr );
112 #else
113  const SG::DataProxy* proxy = evtStore()->proxy( ptr );
114  static const std::string dummy = "";
115  return ( proxy == nullptr ? dummy : proxy->name() );
116 #endif // XAOD_STANDALONE
117  }

◆ GetPhotons()

StatusCode ST::SUSYObjDef_xAOD::GetPhotons ( xAOD::PhotonContainer *&  copy,
xAOD::ShallowAuxContainer *&  copyaux,
const bool  recordSG = true,
const std::string &  photonkey = "Photons",
const xAOD::PhotonContainer containerToBeCopied = nullptr 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 33 of file Photons.cxx.

34 {
35  if (!m_tool_init) {
36  ATH_MSG_ERROR("SUSYTools was not initialized!!");
37  return StatusCode::FAILURE;
38  }
39 
40  if (m_isPHYSLITE && photonkey.find("AnalysisPhotons")==std::string::npos){
41  ATH_MSG_ERROR("You are running on PHYSLITE derivation. Please change the Photons container to 'AnalysisPhotons'");
42  return StatusCode::FAILURE;
43  }
44 
45  const xAOD::PhotonContainer* photons = nullptr;
46  if (copy==nullptr) { // empty container provided
47  if (containerToBeCopied != nullptr) {
48  photons = containerToBeCopied;
49  }
50  else {
51  ATH_CHECK( evtStore()->retrieve(photons, photonkey) );
52  }
53  std::pair<xAOD::PhotonContainer*, xAOD::ShallowAuxContainer*> shallowcopy = xAOD::shallowCopyContainer(*photons);
54  copy = shallowcopy.first;
55  copyaux = shallowcopy.second;
56  bool setLinks = xAOD::setOriginalObjectLink(*photons, *copy);
57  if (!setLinks) {
58  ATH_MSG_WARNING("Failed to set original object links on " << photonkey);
59  }
60  } else { // use the user-supplied collection instead
61  ATH_MSG_DEBUG("Not retrieving photon collecton, using existing one provided by user");
62  photons=copy;
63  }
64 
65  for (const auto& photon : *copy) {
68  }
69 
70  if (recordSG) {
71  ATH_CHECK( evtStore()->record(copy, "STCalib" + photonkey + m_currentSyst.name()) );
72  ATH_CHECK( evtStore()->record(copyaux, "STCalib" + photonkey + m_currentSyst.name() + "Aux.") );
73  }
74  return StatusCode::SUCCESS;
75 }

◆ GetPileupWeight()

float ST::SUSYObjDef_xAOD::GetPileupWeight ( )
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2946 of file SUSYObjDef_xAOD.cxx.

2946  {
2947 
2948  const xAOD::EventInfo* evtInfo = GetEventInfo();
2949  float pu_weight = m_prwTool->getCombinedWeight(*evtInfo);
2950 
2951  if(!isfinite(pu_weight)) pu_weight = 1.;
2952 
2953  return pu_weight;
2954 }

◆ GetPileupWeightHash()

ULong64_t ST::SUSYObjDef_xAOD::GetPileupWeightHash ( )
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2971 of file SUSYObjDef_xAOD.cxx.

2971  {
2972  const xAOD::EventInfo* evtInfo = GetEventInfo();
2973  return m_prwTool->getPRWHash( *evtInfo );
2974 }

◆ GetPileupWeightPrescaledTrigger()

float ST::SUSYObjDef_xAOD::GetPileupWeightPrescaledTrigger ( const std::string &  trigger_expr)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2956 of file SUSYObjDef_xAOD.cxx.

2956  {
2957  /* This requires the setup of the PRW tool using your own prescaled lumicalc
2958  files with syntax "HLT_PrescaledTriggerA.lumicalc.root:HLT_PrescaledTriggerA".
2959  For further informations, please refer to:
2960  https://twiki.cern.ch/twiki/bin/view/AtlasProtected/ExtendedPileupReweighting#Prescaling%20MC
2961  */
2962 
2963  const xAOD::EventInfo* evtInfo = GetEventInfo();
2964  float pu_weight = m_prwTool->getCombinedWeight(*evtInfo,trigger_expr);
2965 
2966  if(!isfinite(pu_weight)) pu_weight = 1.;
2967 
2968  return pu_weight;
2969 }

◆ GetPrimVtx()

const xAOD::Vertex * ST::SUSYObjDef_xAOD::GetPrimVtx ( ) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2877 of file SUSYObjDef_xAOD.cxx.

2877  {
2878  const xAOD::VertexContainer* vertices = nullptr;
2879  if ( evtStore()->retrieve( vertices, "PrimaryVertices" ).isSuccess() ) {
2880  for ( const auto& vx : *vertices ) {
2881  if (vx->vertexType() == xAOD::VxType::PriVtx) {
2882  ATH_MSG_DEBUG("PrimaryVertex found with z=" << vx->z());
2883  return vx;
2884  }
2885  }
2886  } else {
2887  ATH_MSG_WARNING("Failed to retrieve VertexContainer \"PrimaryVertices\", returning nullptr");
2888  }
2889  return nullptr;
2890 }

◆ getProperty() [1/2]

template<typename T >
const T* ST::ISUSYObjDef_xAODTool::getProperty ( const std::string &  name)
inlineinherited

Definition at line 237 of file ISUSYObjDef_xAODTool.h.

237  {
238  return dynamic_cast<asg::AsgTool&>(*this).getProperty<T>(name);
239  }

◆ getProperty() [2/2]

template<class T >
const T* asg::AsgTool::getProperty ( const std::string &  name) const
inherited

Get one of the tool's properties.

◆ GetRandomRunNumber()

unsigned int ST::SUSYObjDef_xAOD::GetRandomRunNumber ( bool  muDependentRRN = true)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2995 of file SUSYObjDef_xAOD.cxx.

2995  {
2996 
2997  const xAOD::EventInfo* evtInfo = GetEventInfo();
2998  if (randomrunnumber.isAvailable(*(evtInfo)) && muDependentRRN) {
2999  return randomrunnumber(*(evtInfo));
3000  }
3001  else if (!muDependentRRN) {
3002  return m_prwTool->getRandomRunNumber( *evtInfo, muDependentRRN );
3003  }
3004  ATH_MSG_ERROR ( "Failed to find RandomRunNumber decoration! You need to call ApplyPRWTool() beforehand!" );
3005  return 0;
3006 }

◆ GetRunNumber()

unsigned int ST::SUSYObjDef_xAOD::GetRunNumber ( ) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3017 of file SUSYObjDef_xAOD.cxx.

3017  {
3018 
3019  const xAOD::EventInfo* evtInfo = GetEventInfo();
3020 
3021  // For data, we can just directly use the run number
3022  if (isData()) { return evtInfo->runNumber(); }
3023 
3024  // else it's MC as we need the RRN assigned by the PRW tool
3025  if (!randomrunnumber.isAvailable(*(evtInfo))) {
3026  ATH_MSG_ERROR ( "Failed to find RandomRunNumber decoration! You need to call ApplyPRWTool() beforehand!" );
3027  }
3028  return randomrunnumber(*(evtInfo));
3029 
3030 }

◆ getSherpaVjetsNjetsWeight() [1/2]

float ST::SUSYObjDef_xAOD::getSherpaVjetsNjetsWeight ( ) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2846 of file SUSYObjDef_xAOD.cxx.

2846  {
2847 
2848  //Retrieve the truth jets
2849  if( evtStore()->contains<xAOD::JetContainer>("AntiKt4TruthWZJets") ){
2850  return getSherpaVjetsNjetsWeight("AntiKt4TruthWZJets");
2851  }
2852  else if( evtStore()->contains<xAOD::JetContainer>("AntiKt4TruthJets")){
2853  return getSherpaVjetsNjetsWeight("AntiKt4TruthJets" );
2854  }
2855  else{
2856  ATH_MSG_WARNING("No TruthJetContainer found! Dummy null weight retrieved.");
2857  }
2858  return 0.;
2859 }

◆ getSherpaVjetsNjetsWeight() [2/2]

float ST::SUSYObjDef_xAOD::getSherpaVjetsNjetsWeight ( const std::string &  jetContainer) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2861 of file SUSYObjDef_xAOD.cxx.

2861  {
2862 
2863  if(jetContainer=="AntiKt4TruthWZJets"){
2864  return m_pmgSHnjetWeighterWZ->getWeight();
2865  }
2866  else if (jetContainer=="AntiKt4TruthJets"){
2867  return m_pmgSHnjetWeighter->getWeight();
2868  }
2869  else{
2870  ATH_MSG_WARNING(jetContainer << " is no supported by PMGSherpa22VJetsWeightTool! Please check...");
2871  }
2872  return 1.;
2873 
2874 }

◆ GetSignalElecSF()

float ST::SUSYObjDef_xAOD::GetSignalElecSF ( const xAOD::Electron el,
const bool  recoSF = true,
const bool  idSF = true,
const bool  triggerSF = true,
const bool  isoSF = true,
const std::string &  trigExpr = "singleLepton",
const bool  ecidsSF = false,
const bool  cidSF = false 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 418 of file Electrons.cxx.

425  {
426 
427  if ((m_eleId == "VeryLooseLLH" || m_eleId == "LooseLLH" || m_eleId == "Loose" || m_eleId == "Medium" || m_eleId == "Tight") && (idSF || triggerSF || isoSF)) {
428  ATH_MSG_ERROR("No signal electron ID or trigger scale factors provided for the selected working point!");
429  ATH_MSG_ERROR("I will now die messily.");
430  }
431 
432  //shortcut keys for trigger SF config
433  std::string singleLepStr = "singleLepton";
434  std::string diLepStr = "diLepton";
435  std::string multiLepStr = "multiLepton";
436 
437  float sf(1.);
438 
439  if (recoSF) {
440  double reco_sf(1.);
441 
443  switch (result) {
445  sf *= reco_sf;
446  break;
448  ATH_MSG_ERROR( "Failed to retrieve signal electron reco SF");
449  break;
451  ATH_MSG_VERBOSE( "OutOfValidityRange found for signal electron reco SF");
452  break;
453  default:
454  ATH_MSG_WARNING( "Don't know what to do for signal electron reco SF");
455  }
456  }
457 
458  if (idSF) {
459  double id_sf(1.);
460 
462  switch (result) {
464  sf *= id_sf;
465  break;
467  ATH_MSG_ERROR( "Failed to retrieve signal electron id SF");
468  break;
470  ATH_MSG_VERBOSE( "OutOfValidityRange found for signal electron id SF");
471  break;
472  default:
473  ATH_MSG_WARNING( "Don't know what to do for signal electron id SF");
474  }
475  }
476 
477  if (triggerSF) {
478 
479  std::vector<std::string> trigMChains={};
480  std::string theExpr ("");
481  if(trigExpr==singleLepStr) {
482  if (this->treatAsYear()==2015) trigMChains = m_v_trigs15_cache_singleEle;
483  else if (this->treatAsYear()==2016) trigMChains = m_v_trigs16_cache_singleEle;
484  else if (this->treatAsYear()==2017) trigMChains = m_v_trigs17_cache_singleEle;
485  else if (this->treatAsYear()==2018) trigMChains = m_v_trigs18_cache_singleEle;
486  else trigMChains = m_v_trigs22_cache_singleEle;
488  }
489  else{
490  ATH_MSG_WARNING( "Only single lepton trigger SFs are supported in GetSignalElecSF(). Use GetTriggerGlobalEfficiencySF() for dilepton or multilepton triggers!");
491  }
492 
493  //check matching
494  this->TrigMatch({&el}, trigMChains);
495 
496  if(!acc_trigmatched(el)){
497  ATH_MSG_DEBUG( "Electron was not matched to trigger " << theExpr << " - scale factor does not apply (year " << this->treatAsYear() << ") Returning 1." );
498  }
499  else{ //is trig-matched electron, go for it!
500  if (trigExpr==multiLepStr || trigExpr==diLepStr) {
501  ATH_MSG_WARNING( "The dilepton or multilepton trigger SFs are not supported in GetSignalElecSF(). Use GetTriggerGlobalEfficiencySF()!");
502  }
503  else {
504  double trig_sf = GetEleTriggerEfficiencySF( el , theExpr );
505  sf *= trig_sf;
506  }
507  }
508  }
509 
510  if (isoSF) {
511  double iso_sf(1.);
513  if (acc_isolHighPt(el) && el.pt()>m_eleIsoHighPtThresh)
515  else
517 
518  switch (result) {
520  sf *= iso_sf;
521  break;
523  ATH_MSG_ERROR( "Failed to retrieve signal electron iso SF");
524  break;
526  ATH_MSG_VERBOSE( "OutOfValidityRange found for signal electron iso SF");
527  break;
528  default:
529  ATH_MSG_WARNING( "Don't know what to do for signal electron iso SF");
530  }
531  }
532 
533  // Charge flip SF: combined ECIDs & charge ID
534  if ( ecidsSF || cidSF ) {
535  double chf_sf(1.);
536  // 1. ECIDs SF
537  if ( ecidsSF ) {
538  sf *= chf_sf;
539  ATH_MSG_WARNING( "ECID SF ARE NOT YET SUPPORTED IN R22" );
540  }
541  // 2. CID SF
542  if ( cidSF ) {
543  sf *= chf_sf;
544  dec_sfChIDEff(el) = chf_sf;
545  ATH_MSG_WARNING( "CID SF ARE NOT YET SUPPORTED IN R22" );
546  }
547  }
548 
549  dec_effscalefact(el) = sf;
550  return sf;
551 }

◆ GetSignalMuonSF()

float ST::SUSYObjDef_xAOD::GetSignalMuonSF ( const xAOD::Muon mu,
const bool  recoSF = true,
const bool  isoSF = true,
const bool  doBadMuonHP = true,
const bool  warnOVR = true 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 477 of file Muons.cxx.

478 {
479  float sf(1.);
480 
481  if (recoSF) {
482  float sf_reco(1.);
484  if(warnOVR) ATH_MSG_WARNING(" GetSignalMuonSF: Reco getEfficiencyScaleFactor out of validity range");
485  }
486  ATH_MSG_VERBOSE( "MuonReco ScaleFactor " << sf_reco );
487  sf *= sf_reco;
488 
489  float sf_ttva(1.);
490  if(m_doTTVAsf){
492  if(warnOVR) ATH_MSG_WARNING(" GetSignalMuonSF: TTVA getEfficiencyScaleFactor out of validity range");
493  }
494  ATH_MSG_VERBOSE( "MuonTTVA ScaleFactor " << sf_ttva );
495  sf *= sf_ttva;
496  }
497 
498  float sf_badHighPt(1.);
499  if(m_muId == 4 && doBadMuonHP){
501  if(warnOVR) ATH_MSG_WARNING(" GetSignalMuonSF: BadMuonHighPt getEfficiencyScaleFactor out of validity range");
502  }
503  ATH_MSG_VERBOSE( "MuonBadMuonHighPt ScaleFactor " << sf_badHighPt );
504  sf *= sf_badHighPt;
505  }
506  }
507 
508 
509  if (isoSF) {
510  float sf_iso(1.);
511  if (acc_isolHighPt(mu) && mu.pt()>m_muIsoHighPtThresh) {
513  if(warnOVR) ATH_MSG_WARNING(" GetSignalMuonSF: high-pt Iso getEfficiencyScaleFactor out of validity range");
514  }
515  } else if (acc_isol(mu) && mu.pt()<m_muIsoHighPtThresh) {
517  if(warnOVR) ATH_MSG_WARNING(" GetSignalMuonSF: Iso getEfficiencyScaleFactor out of validity range");
518  }
519  }
520  ATH_MSG_VERBOSE( "MuonIso ScaleFactor " << sf_iso );
521  sf *= sf_iso;
522  }
523 
524 
525  dec_effscalefact(mu) = sf;
526  return sf;
527 }

◆ GetSignalPhotonSF()

double ST::SUSYObjDef_xAOD::GetSignalPhotonSF ( const xAOD::Photon ph,
const bool  effSF = true,
const bool  isoSF = true,
const bool  triggerSF = false 
) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 203 of file Photons.cxx.

204 {
205  double sf(1.);
206 
207  if (effSF) {
208 
209  double sf_eff = 1.;
210 
212  if (res == CP::CorrectionCode::OutOfValidityRange) ATH_MSG_WARNING(" GetSignalPhotonSF: EfficiencyScaleFactor out of validity range");
213 
214  sf *= sf_eff;
215  }
216 
217  if (isoSF) {
218 
219  double sf_iso = 1.;
220 
222  if (res == CP::CorrectionCode::OutOfValidityRange) ATH_MSG_WARNING(" GetSignalPhotonSF: IsolationScaleFactor out of validity range");
223 
224  sf *= sf_iso;
225  }
226 
227  if (triggerSF) {
228 
229  double sf_trigger = 1.;
230 
232  if (res == CP::CorrectionCode::OutOfValidityRange) ATH_MSG_WARNING(" GetSignalPhotonSF: TriggerScaleFactor out of validity range");
233 
234  sf *= sf_trigger;
235  }
236 
237  ATH_MSG_VERBOSE( "ScaleFactor " << sf );
238 
239  dec_effscalefact(ph) = sf;
240  return sf;
241 }

◆ GetSignalPhotonSFsys()

double ST::SUSYObjDef_xAOD::GetSignalPhotonSFsys ( const xAOD::Photon ph,
const CP::SystematicSet systConfig,
const bool  effSF = true,
const bool  isoSF = true,
const bool  triggerSF = false 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 244 of file Photons.cxx.

245 {
246  double sf(1.);
247 
248  //Set the new systematic variation
250  if (ret != StatusCode::SUCCESS) {
251  ATH_MSG_ERROR("Cannot configure AsgPhotonEfficiencyCorrectionTool (reco) for systematic var. " << systConfig.name() );
252  }
253 
255  if (ret != StatusCode::SUCCESS) {
256  ATH_MSG_ERROR("Cannot configure AsgPhotonEfficiencyCorrectionTool (iso) for systematic var. " << systConfig.name() );
257  }
258 
260  if (ret != StatusCode::SUCCESS) {
261  ATH_MSG_ERROR("Cannot configure AsgPhotonEfficiencyCorrectionTool (trigger) for systematic var. " << systConfig.name() );
262  }
263 
264  if (effSF) {
265 
266  double sf_eff = 1.;
267 
269  if (res == CP::CorrectionCode::OutOfValidityRange) ATH_MSG_WARNING(" GetSignalPhotonSF: getEfficiencyScaleFactor out of validity range");
270 
271  sf *= sf_eff;
272  }
273 
274  if (isoSF) {
275 
276  double sf_iso = 1.;
277 
279  if (res == CP::CorrectionCode::OutOfValidityRange) ATH_MSG_WARNING(" GetSignalPhotonSF: getEfficiencyScaleFactor out of validity range");
280 
281  sf *= sf_iso;
282  }
283 
284  if (triggerSF) {
285 
286  double sf_trigger = 1.;
287 
289  if (res == CP::CorrectionCode::OutOfValidityRange) ATH_MSG_WARNING(" GetSignalPhotonSF: getEfficiencyScaleFactor out of validity range");
290 
291  sf *= sf_trigger;
292  }
293 
294  //Roll back to current sys
296  if (ret != StatusCode::SUCCESS) {
297  ATH_MSG_ERROR("Cannot configure AsgPhotonEfficiencyCorrectionTool back to default.");
298  }
299 
301  if (ret != StatusCode::SUCCESS) {
302  ATH_MSG_ERROR("Cannot configure AsgPhotonEfficiencyCorrectionTool (iso) for systematic var. " << systConfig.name() );
303  }
304 
306  if (ret != StatusCode::SUCCESS) {
307  ATH_MSG_ERROR("Cannot configure AsgPhotonEfficiencyCorrectionTool (trigger) for systematic var. " << systConfig.name() );
308  }
309 
310  ATH_MSG_VERBOSE( "ScaleFactor " << sf );
311 
312  dec_effscalefact(ph) = sf;
313  return sf;
314 }

◆ GetSignalTauSF()

double ST::SUSYObjDef_xAOD::GetSignalTauSF ( const xAOD::TauJet tau,
const bool  idSF = true,
const bool  triggerSF = true,
const std::string &  trigExpr = "tau25_medium1_tracktwo" 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 129 of file Taus.cxx.

133 {
134  double sf(1.);
135 
136  if (acc_signal(tau)) {
137  if (idSF) {
139  ATH_MSG_WARNING("Failed to retrieve tau efficiency scale factor.");
140  }
141  ATH_MSG_VERBOSE(" Retrieved tau SF " << sf);
142  }
143 
144  if (triggerSF) {
145  double trig_sf = GetTauTriggerEfficiencySF(tau, trigExpr);
146 
147  if (trig_sf > -90) {
148  sf *= trig_sf;
149  ATH_MSG_VERBOSE(" Retrieved tau trig SF " << trig_sf);
150  }
151  }
152  }
153 
154  dec_effscalefact(tau) = sf;
155  return sf;
156 }

◆ GetSignalTauSFsys()

double ST::SUSYObjDef_xAOD::GetSignalTauSFsys ( const xAOD::TauJet tau,
const CP::SystematicSet systConfig,
const bool  idSF = true,
const bool  triggerSF = true,
const std::string &  trigExpr = "tau25_medium1_tracktwo" 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 159 of file Taus.cxx.

164 {
165  double sf(1.);
166 
167  //Set the new systematic variation
169  if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure TauEfficiencyCorrectionsTool for systematic var. " << systConfig.name() ); }
170 
171  for (auto& tool : m_tauTrigEffTool) {
172  ret = tool->applySystematicVariation(systConfig);
173  if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure " << tool->name() << " for systematic var. " << systConfig.name()); }
174  }
175 
176  sf *= GetSignalTauSF(tau, idSF, triggerSF, trigExpr);
177 
178  //Roll back to default
180  if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure TauEfficiencyCorrectionsTool back to default"); }
181 
182  for (auto& tool : m_tauTrigEffTool) {
183  ret = tool->applySystematicVariation(m_currentSyst);
184  if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure " << tool->name() << " back to default"); }
185  }
186 
187  dec_effscalefact(tau) = sf;
188 
189  return sf;
190 }

◆ GetSumOfWeights()

double ST::SUSYObjDef_xAOD::GetSumOfWeights ( int  channel)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2991 of file SUSYObjDef_xAOD.cxx.

2991  {
2993 }

◆ getSystInfo()

ST::SystInfo ST::SUSYObjDef_xAOD::getSystInfo ( const CP::SystematicVariation sys) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2540 of file SUSYObjDef_xAOD.cxx.

2540  {
2541 
2542  SystInfo sysInfo;
2543  sysInfo.affectsKinematics = false;
2544  sysInfo.affectsWeights = false;
2545  sysInfo.affectedWeights.clear();
2546  sysInfo.systset.insert(sys);
2547 
2550  sysInfo.affectsWeights = true;
2551  sysInfo.affectsType = SystObjType::Jet;
2552  sysInfo.affectedWeights.insert(ST::Weights::Jet::JVT);
2553  }
2554  }
2555 
2556  if (!m_jetfJvtEfficiencyTool.empty()) {
2558  sysInfo.affectsWeights = true;
2559  sysInfo.affectsType = SystObjType::Jet;
2560  sysInfo.affectedWeights.insert(ST::Weights::Jet::FJVT);
2561  }
2562  }
2563 
2564  if (sys.name().find("__2") == std::string::npos) {
2565  if (!m_jetUncertaintiesTool.empty()) {
2567  sysInfo.affectsKinematics = true;
2568  sysInfo.affectsType = SystObjType::Jet;
2569  }
2570  }
2571  }
2572  if (sys.name().find("__2") != std::string::npos) {
2575  sysInfo.affectsKinematics = true;
2576  sysInfo.affectsType = SystObjType::Jet;
2577  }
2578  }
2579  }
2580 
2583  sysInfo.affectsKinematics = true;
2584  sysInfo.affectsType = SystObjType::Jet;
2585  }
2586  }
2589  sysInfo.affectsKinematics = true;
2590  sysInfo.affectsType = SystObjType::Jet;
2591  }
2592  }
2595  sysInfo.affectsKinematics = true;
2596  sysInfo.affectsType = SystObjType::Jet;
2597  }
2598  }
2601  sysInfo.affectsKinematics = true;
2602  sysInfo.affectsType = SystObjType::Jet;
2603  }
2604  }
2605 
2606  if (!m_muonCalibTool.empty()) {
2608  sysInfo.affectsKinematics = true;
2609  sysInfo.affectsType = SystObjType::Muon;
2610  }
2611  }
2614  sysInfo.affectsWeights = true;
2615  sysInfo.affectsType = SystObjType::Electron;
2616  sysInfo.affectedWeights.insert(ST::Weights::Electron::Trigger);
2617  }
2618  }
2621  sysInfo.affectsWeights = true;
2622  sysInfo.affectsType = SystObjType::Electron;
2623  sysInfo.affectedWeights.insert(ST::Weights::Electron::Trigger);
2624  }
2625  }
2626  if (!m_muonEfficiencySFTool.empty()) {
2628  sysInfo.affectsWeights = true;
2629  sysInfo.affectsType = SystObjType::Muon;
2630  sysInfo.affectedWeights.insert(ST::Weights::Muon::Reconstruction);
2631  }
2632  }
2635  sysInfo.affectsWeights = true;
2636  sysInfo.affectsType = SystObjType::Muon;
2637  sysInfo.affectedWeights.insert(ST::Weights::Muon::Reconstruction);
2638  }
2639  }
2642  sysInfo.affectsWeights = true;
2643  sysInfo.affectsType = SystObjType::Muon;
2644  sysInfo.affectedWeights.insert(ST::Weights::Muon::Reconstruction);
2645  }
2646  }
2647  if (!m_muonIsolationSFTool.empty()) {
2649  sysInfo.affectsWeights = true;
2650  sysInfo.affectsType = SystObjType::Muon;
2651  sysInfo.affectedWeights.insert(ST::Weights::Muon::Isolation);
2652  }
2653  }
2654  if (!m_muonTriggerSFTool.empty()) {
2656  sysInfo.affectsWeights = true;
2657  sysInfo.affectsType = SystObjType::Muon;
2658  sysInfo.affectedWeights.insert(ST::Weights::Muon::Trigger);
2659  }
2660  }
2663  sysInfo.affectsWeights = true;
2664  sysInfo.affectsType = SystObjType::Electron;
2665  sysInfo.affectedWeights.insert(ST::Weights::Electron::Reconstruction);
2666  }
2667  }
2670  sysInfo.affectsWeights = true;
2671  sysInfo.affectsType = SystObjType::Electron;
2672  sysInfo.affectedWeights.insert(ST::Weights::Electron::ID);
2673  }
2674  }
2677  sysInfo.affectsWeights = true;
2678  sysInfo.affectsType = SystObjType::Electron;
2679  sysInfo.affectedWeights.insert(ST::Weights::Electron::Trigger);
2680  }
2681  }
2684  sysInfo.affectsWeights = true;
2685  sysInfo.affectsType = SystObjType::Electron;
2686  sysInfo.affectedWeights.insert(ST::Weights::Electron::Trigger);
2687  }
2688  }
2691  sysInfo.affectsWeights = true;
2692  sysInfo.affectsType = SystObjType::Electron;
2693  sysInfo.affectedWeights.insert(ST::Weights::Electron::Isolation);
2694  }
2695  }
2698  sysInfo.affectsWeights = true;
2699  sysInfo.affectsType = SystObjType::Electron;
2700  sysInfo.affectedWeights.insert(ST::Weights::Electron::Isolation);
2701  }
2702  }
2703  if (!m_egammaCalibTool.empty()) {
2705  sysInfo.affectsKinematics = true;
2706  if (sys.basename().compare(0, 3, "EG_") == 0) {
2707  sysInfo.affectsType = SystObjType::Egamma;
2708  } else if (sys.basename().compare(0, 3, "PH_") == 0) {
2709  sysInfo.affectsType = SystObjType::Photon;
2710  } else if (sys.basename().compare(0, 3, "EL_") == 0) {
2711  sysInfo.affectsType = SystObjType::Electron;
2712  }
2713  }
2714  }
2715  if (!isData() && !m_isoCorrTool.empty()) {
2717  sysInfo.affectsWeights = false;
2718  sysInfo.affectsKinematics = true;
2719  sysInfo.affectsType = SystObjType::Photon;
2720  }
2721  }
2722  if (!isData() && !m_photonEfficiencySFTool.empty()) {
2724  sysInfo.affectsWeights = true;
2725  sysInfo.affectsType = SystObjType::Photon;
2726  sysInfo.affectedWeights.insert(ST::Weights::Photon::Reconstruction);
2727  }
2728  }
2729  if (!isData() && !m_photonIsolationSFTool.empty()) {
2731  sysInfo.affectsWeights = true;
2732  sysInfo.affectsType = SystObjType::Photon;
2733  sysInfo.affectedWeights.insert(ST::Weights::Photon::Isolation);
2734  }
2735  }
2736  if (!isData() && !m_photonTriggerSFTool.empty()) {
2738  sysInfo.affectsWeights = true;
2739  sysInfo.affectsType = SystObjType::Photon;
2740  sysInfo.affectedWeights.insert(ST::Weights::Photon::Trigger);
2741  }
2742  }
2745  sysInfo.affectsWeights = true;
2746  sysInfo.affectsType = SystObjType::Photon;
2747  sysInfo.affectedWeights.insert(ST::Weights::Photon::Trigger);
2748  }
2749  }
2750  if ( !m_btagEffTool.empty() ) {
2752  sysInfo.affectsWeights = true;
2753  sysInfo.affectsType = SystObjType::BTag;
2754  sysInfo.affectedWeights.insert(ST::Weights::Jet::Btag);
2755  }
2756  }
2757  if ( !m_btagEffTool_trkJet.empty() ) {
2759  sysInfo.affectsWeights = true;
2760  sysInfo.affectsType = SystObjType::BTag;
2761  sysInfo.affectedWeights.insert(ST::Weights::Jet::Btag_Track);
2762  }
2763  }
2764  if (!m_tauSmearingTool.empty()) {
2766  sysInfo.affectsKinematics = true;
2767  sysInfo.affectsType = SystObjType::Tau;
2768  }
2769  }
2770  if (!m_tauEffTool.empty()) {
2772  sysInfo.affectsWeights = true;
2773  sysInfo.affectsType = SystObjType::Tau;
2774  sysInfo.affectedWeights.insert(ST::Weights::Tau::Reconstruction);
2775  }
2776  }
2777  for(const auto &tool : m_tauTrigEffTool) {
2778  if(tool->isAffectedBySystematic(sys)) {
2779  sysInfo.affectsWeights = true;
2780  sysInfo.affectsType = SystObjType::Tau;
2781  sysInfo.affectedWeights.insert(ST::Weights::Tau::Trigger);
2782  break;
2783  }
2784  }
2785  if (!m_metSystTool.empty()) {
2787  sysInfo.affectsKinematics = true;
2788  switch (met::getSystType(sys)) {
2789  case met::SOFTCALO:
2790  sysInfo.affectsType = SystObjType::MET_CST;
2791  break;
2792  case met::SOFTTRK:
2793  sysInfo.affectsType = SystObjType::MET_TST;
2794  break;
2795  case met::JETTRK:
2796  sysInfo.affectsType = SystObjType::MET_Track;
2797  break;
2798  default:
2799  ATH_MSG_ERROR("Unsupported systematic!");
2800  }
2801  }
2802  }
2803  if (!m_prwTool.empty()) {
2805  sysInfo.affectsWeights = true;
2806  sysInfo.affectsType = SystObjType::EventWeight;
2807  }
2808  }
2809 
2810  if (!m_LRTuncTool.empty()){
2812  sysInfo.affectsKinematics = true;
2813  sysInfo.affectsType = SystObjType::LRT_Object;
2814  }
2815  }
2816 
2817  std::string affectedType;
2818  switch (sysInfo.affectsType) {
2819  case Unknown : affectedType = "UNKNOWN"; break;
2820  case Jet : affectedType = "JET"; break;
2821  case Egamma : affectedType = "EGAMMA"; break;
2822  case Electron : affectedType = "ELECTRON"; break;
2823  case Photon : affectedType = "PHOTON"; break;
2824  case Muon : affectedType = "MUON"; break;
2825  case Tau : affectedType = "TAU"; break;
2826  case BTag : affectedType = "BTAG"; break;
2827  case MET_TST : affectedType = "MET_TST"; break;
2828  case MET_CST : affectedType = "MET_CST"; break;
2829  case MET_Track : affectedType = "MET_Track"; break;
2830  case EventWeight : affectedType = "EVENT WEIGHT"; break;
2831  case LRT_Object : affectedType = "LRT_OBJECT"; break;
2832  }
2833 
2834  ATH_MSG_VERBOSE("Variation " << sys.name() << " affects "
2835  << ( sysInfo.affectsWeights ? "weights " : "" )
2836  << ( sysInfo.affectsKinematics ? "kinematics " : "" )
2837  << "for " << affectedType );
2838 
2839  return sysInfo;
2840 
2841 }

◆ getSystInfoList()

std::vector< ST::SystInfo > ST::SUSYObjDef_xAOD::getSystInfoList ( ) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2497 of file SUSYObjDef_xAOD.cxx.

2497  {
2498  if (!m_tool_init) {
2499  ATH_MSG_ERROR("SUSYTools was not initialized!!");
2500  return vector<ST::SystInfo>();
2501  }
2502 
2503  ATH_MSG_INFO("Extracting systematics info list");
2504 
2505  // Now we can look at systematics:
2507  const CP::SystematicSet& recommendedSystematics = registry.recommendedSystematics();
2508 
2509  vector<SystInfo> sysInfoList;
2510  sysInfoList.reserve(recommendedSystematics.size() * 2); // allow for continuous systematics
2511 
2512  // this is the nominal set
2513  SystInfo infodef;
2514  infodef.affectsKinematics = false;
2515  infodef.affectsWeights = false;
2516  infodef.affectsType = Unknown;
2517  infodef.affectedWeights.clear();
2518  sysInfoList.push_back(infodef);
2519 
2520 
2521  // add all recommended systematics
2522  for (const auto& systSet : CP::make_systematics_vector(recommendedSystematics)) {
2523  for (const auto& sys : systSet) {
2524  sysInfoList.push_back(getSystInfo(sys));
2525  if (sys.basename().find("JET_JER") != std::string::npos && m_jetUncertaintiesPDsmearing == true) {
2526  // Add the additional PDSmear JET_JER systematics to the systematics registry if we're using the PDSmear. Otherwise they don't need to be added.
2527  std::string JER_systematicName = sys.name();
2528  JER_systematicName = std::regex_replace(JER_systematicName, std::regex("__1"), "__2");
2529  CP::SystematicVariation sys_JER(JER_systematicName);
2530  sysInfoList.push_back(getSystInfo(sys_JER));
2531  }
2532  }
2533 
2534  }
2535 
2536  ATH_MSG_INFO("Returning list of " << sysInfoList.size() << " systematic variations");
2537  return sysInfoList;
2538 }

◆ getTauConfig()

void ST::SUSYObjDef_xAOD::getTauConfig ( const std::string &  tauConfigPath,
std::vector< float > &  pT_window,
std::vector< float > &  eta_window,
bool &  eleOLR,
bool &  muVeto,
bool &  muOLR 
) const
protected

Definition at line 1812 of file SUSYObjDef_xAOD.cxx.

1812  {
1813 
1814  if(tauConfigPath.empty()) return;
1815 
1816  TEnv rEnv;
1817  auto filename = PathResolverFindCalibFile(tauConfigPath);
1818  rEnv.ReadFile(filename.c_str(), kEnvAll);
1819 
1820  std::vector<std::string> cuts;
1821  if (rEnv.Defined("SelectionCuts")) {
1822  cuts = split(rEnv.GetValue("SelectionCuts", " "), " ");
1823  } else {
1824  auto *l = rEnv.GetTable();
1825  for( Int_t i = 0; i < l->GetEntries(); ++i ) {
1826  cuts.push_back( l->At(i)->GetName() );
1827  }
1828  }
1829 
1830  //default OR settings
1831  eleOLR=false;
1832  muOLR=false;
1833  muVeto=false;
1834 
1835  static const std::string trueBool = "TRUE";
1836 
1837  // Now find the pT and eta window
1838  std::vector<std::string> v_pT_window;
1839  std::vector<std::string> v_eta_window;
1840  pT_window.clear();
1841  eta_window.clear();
1842  float pT_min = -99.0;
1843  float pT_max = -99.0;
1844  float eta_min = -99.0;
1845  float eta_max = -99.0;
1846  for (const auto& cut : cuts) {
1847  if(cut == "PtRegion") {
1848  v_pT_window = split(rEnv.GetValue("PtRegion", ""), ";");
1849  std::transform(std::begin(v_pT_window),
1850  std::end(v_pT_window),
1851  std::back_inserter(pT_window),
1852  [](const std::string& s) { return std::stof(s); }
1853  );
1854  } else if (cut == "PtMin") {
1855  pT_min = rEnv.GetValue("PtMin", NAN);
1856  } else if (cut == "PtMax") {
1857  pT_max = rEnv.GetValue("PtMax", NAN);
1858  } else if (cut == "AbsEtaRegion") {
1859  v_eta_window = split(rEnv.GetValue("AbsEtaRegion", ""), ";");
1860  std::transform(std::begin(v_eta_window),
1861  std::end(v_eta_window),
1862  std::back_inserter(eta_window),
1863  [](const std::string& s) { return std::stof(s); }
1864  );
1865  } else if (cut == "AbsEtaMin") {
1866  eta_min = rEnv.GetValue("AbsEtaMin", NAN);
1867  } else if (cut == "AbsEtaMax") {
1868  eta_max = rEnv.GetValue("AbsEtaMax", NAN);
1869  }
1870 
1871  //OR settings
1872  else if (cut == "EleOLR"){
1873  eleOLR = (rEnv.GetValue("EleOLR", "FALSE") == trueBool);
1874  }
1875  else if (cut == "MuonVeto"){
1876  muVeto = (rEnv.GetValue("MuonVeto", "FALSE") == trueBool);
1877  }
1878  else if (cut == "MuonOLR"){
1879  muOLR = (rEnv.GetValue("MuonOLR", "FALSE") == trueBool);
1880  }
1881  }
1882 
1883  if(pT_window.empty()) {
1884  if(pT_min == pT_min) {
1885  // fails on NaN
1886  pT_window.push_back(pT_min);
1887  } else {
1888  pT_window.push_back(-std::numeric_limits<float>::infinity());
1889  }
1890 
1891  if(pT_max == pT_max) {
1892  // fails on NaN
1893  pT_window.push_back(pT_max);
1894  } else {
1895  pT_window.push_back(std::numeric_limits<float>::infinity());
1896  }
1897  }
1898 
1899  if(eta_window.empty()) {
1900  if(eta_min == eta_min) {
1901  // fails on NaN
1902  eta_window.push_back(eta_min);
1903  } else {
1904  eta_window.push_back(-std::numeric_limits<float>::infinity());
1905  }
1906 
1907  if(eta_max == eta_max) {
1908  // fails on NaN
1909  eta_window.push_back(eta_max);
1910  } else {
1911  eta_window.push_back(std::numeric_limits<float>::infinity());
1912  }
1913  }
1914 }

◆ GetTaus()

StatusCode ST::SUSYObjDef_xAOD::GetTaus ( xAOD::TauJetContainer *&  copy,
xAOD::ShallowAuxContainer *&  copyaux,
const bool  recordSG = true,
const std::string &  taukey = "TauJets",
const xAOD::TauJetContainer containerToBeCopied = nullptr 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 30 of file Taus.cxx.

32 {
33  if (!m_tool_init) {
34  ATH_MSG_ERROR("SUSYTools was not initialized!!");
35  return StatusCode::FAILURE;
36  }
37 
38  if (m_isPHYSLITE && taukey.find("AnalysisTauJets")==std::string::npos){
39  ATH_MSG_ERROR("You are running on PHYSLITE derivation. Please change the Taus container to 'AnalysisTauJets'");
40  return StatusCode::FAILURE;
41  }
42 
43  const xAOD::TauJetContainer* taus = nullptr;
44  if (copy==nullptr) { // empty container provided
45  if (containerToBeCopied != nullptr) {
46  taus = containerToBeCopied;
47  }
48  else {
49  ATH_CHECK( evtStore()->retrieve(taus, taukey) );
50  }
51  std::pair<xAOD::TauJetContainer*, xAOD::ShallowAuxContainer*> shallowcopy = xAOD::shallowCopyContainer(*taus);
52  copy = shallowcopy.first;
53  copyaux = shallowcopy.second;
54  bool setLinks = xAOD::setOriginalObjectLink(*taus, *copy);
55  if (!setLinks) {
56  ATH_MSG_WARNING("Failed to set original object links on " << taukey);
57  }
58  } else { // use the user-supplied collection instead
59  ATH_MSG_DEBUG("Not retrieving tau collecton, using existing one provided by user");
60  taus=copy;
61  }
62 
63  for (const auto& tau : *copy) {
64  ATH_CHECK( this->FillTau(*tau) );
65  this->IsSignalTau(*tau, m_tauPt, m_tauEta);
66  }
67  if (recordSG) {
68  ATH_CHECK( evtStore()->record(copy, "STCalib" + taukey + m_currentSyst.name()) );
69  ATH_CHECK( evtStore()->record(copyaux, "STCalib" + taukey + m_currentSyst.name() + "Aux.") );
70  }
71  return StatusCode::SUCCESS;
72 }

◆ GetTauTriggerEfficiencySF()

double ST::SUSYObjDef_xAOD::GetTauTriggerEfficiencySF ( const xAOD::TauJet tau,
const std::string &  trigExpr = "tau25_medium1_tracktwo" 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 193 of file Taus.cxx.

193  {
194 
195  double eff(1.);
196 
197  auto map_it = m_tau_trig_support.find(trigExpr);
198  if (map_it == m_tau_trig_support.end()) {
199  ATH_MSG_WARNING("The trigger item requested (" << trigExpr << ") is not supported! Please check. Setting SF to 1.");
200  return eff;
201  }
202 
203  // trigger matching (dR=0.2)
204  std::vector<std::string> chains;
205  boost::split(chains, map_it->second, [](char c){return c == ',';});
206  bool match = false;
207  for (const std::string& chain : chains)
208  if (m_trigMatchingTool->match({&tau}, chain, 0.2)) {
209  match = true;
210  break;
211  }
212  if (!match) {
213  ATH_MSG_VERBOSE("Tau did not match trigger " << trigExpr);
214  return eff;
215  }
216 
217  int trigIdx = std::distance(std::begin(m_tau_trig_support), map_it);
218  if (m_tauTrigEffTool.at(trigIdx)->getEfficiencyScaleFactor(tau, eff) != CP::CorrectionCode::Ok) {
219  ATH_MSG_ERROR("Some problem found to retrieve SF for trigger item requested (" << trigExpr << ")");
220  eff = -99;
221  }
222 
223  return eff;
224 }

◆ GetTotalElectronSF()

float ST::SUSYObjDef_xAOD::GetTotalElectronSF ( const xAOD::ElectronContainer electrons,
const bool  recoSF = true,
const bool  idSF = true,
const bool  triggerSF = true,
const bool  isoSF = true,
const std::string &  trigExpr = "singleLepton",
const bool  ecidsSF = false,
const bool  cidSF = false 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 623 of file Electrons.cxx.

623  {
624  float sf(1.);
625 
626  for (const xAOD::Electron* electron : electrons) {
627  if (!acc_passOR(*electron)) continue;
628  if (acc_signal(*electron)) { sf *= this->GetSignalElecSF(*electron, recoSF, idSF, triggerSF, isoSF, trigExpr, ecidsSF, cidSF); }
629  else { this->GetSignalElecSF(*electron, recoSF, idSF, triggerSF, isoSF, trigExpr, ecidsSF, cidSF); }
630  }
631 
632  return sf;
633 }

◆ GetTotalElectronSFsys()

float ST::SUSYObjDef_xAOD::GetTotalElectronSFsys ( const xAOD::ElectronContainer electrons,
const CP::SystematicSet systConfig,
const bool  recoSF = true,
const bool  idSF = true,
const bool  triggerSF = true,
const bool  isoSF = true,
const std::string &  trigExpr = "singleLepton",
const bool  ecidsSF = false,
const bool  cidSF = false 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 636 of file Electrons.cxx.

636  {
637  float sf(1.);
638 
639  //Set the new systematic variation
641  if (ret != StatusCode::SUCCESS) {
642  ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (reco) for systematic var. " << systConfig.name() );
643  }
644 
646  if (ret != StatusCode::SUCCESS) {
647  ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (id) for systematic var. " << systConfig.name() );
648  }
649 
651  if (ret != StatusCode::SUCCESS) {
652  ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (trigger) for systematic var. " << systConfig.name() );
653  }
654 
656  if (ret != StatusCode::SUCCESS) {
657  ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (iso) for systematic var. " << systConfig.name() );
658  }
659 
661  if (ret != StatusCode::SUCCESS) {
662  ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (iso high-pt) for systematic var. " << systConfig.name() );
663  }
664 
666  if (ret != StatusCode::SUCCESS) {
667  ATH_MSG_ERROR("Cannot configure ElectronChargeEfficiencyCorrectionTool for systematic var. " << systConfig.name() );
668  }
669 
670 
671  //Get the total SF for new config
672  sf = GetTotalElectronSF(electrons, recoSF, idSF, triggerSF, isoSF, trigExpr, ecidsSF, cidSF);
673 
674  //Roll back to default
676  if (ret != StatusCode::SUCCESS) {
677  ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (reco) back to default.");
678  }
679 
681  if (ret != StatusCode::SUCCESS) {
682  ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (id) back to default.");
683  }
684 
686  if (ret != StatusCode::SUCCESS) {
687  ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (trigger) back to default.");
688  }
689 
691  if (ret != StatusCode::SUCCESS) {
692  ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (iso) back to default.");
693  }
694 
696  if (ret != StatusCode::SUCCESS) {
697  ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (iso high-pt) back to default.");
698  }
699 
701  if (ret != StatusCode::SUCCESS) {
702  ATH_MSG_ERROR("Cannot configure ElectronChargeEfficiencyCorrectionTool back to default.");
703  }
704 
705  return sf;
706 }

◆ GetTotalJetSF()

double ST::SUSYObjDef_xAOD::GetTotalJetSF ( const xAOD::JetContainer jets,
const bool  btagSF = true,
const bool  jvtSF = true,
const bool  fjvtSF = false 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 1095 of file Jets.cxx.

1095  {
1096 
1097  double totalSF = 1.;
1098  if (btagSF) totalSF *= BtagSF(jets);
1099 
1100  if (jvtSF && m_applyJVTCut) totalSF *= JVT_SF(jets);
1101 
1102  if (fjvtSF) totalSF *= FJVT_SF(jets);
1103 
1104  return totalSF;
1105  }

◆ GetTotalJetSFsys()

double ST::SUSYObjDef_xAOD::GetTotalJetSFsys ( const xAOD::JetContainer jets,
const CP::SystematicSet systConfig,
const bool  btagSF = true,
const bool  jvtSF = true,
const bool  fjvtSF = false 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 1108 of file Jets.cxx.

1108  {
1109 
1110  double totalSF = 1.;
1111  if (btagSF) totalSF *= BtagSFsys(jets, systConfig);
1112 
1113  if (jvtSF && m_applyJVTCut) totalSF *= JVT_SFsys(jets, systConfig);
1114 
1115  if (fjvtSF) totalSF *= FJVT_SFsys(jets, systConfig);
1116 
1117  return totalSF;
1118  }

◆ GetTotalMuonSF()

double ST::SUSYObjDef_xAOD::GetTotalMuonSF ( const xAOD::MuonContainer muons,
const bool  recoSF = true,
const bool  isoSF = true,
const std::string &  trigExpr = "HLT_mu20_iloose_L1MU15_OR_HLT_mu50",
const bool  bmhptSF = true 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 599 of file Muons.cxx.

599  {
600  double sf(1.);
601 
603  for (const xAOD::Muon* muon : muons) {
604  if( !acc_passOR(*muon) ) continue;
605  if (acc_signal(*muon)) {
606  sfmuons.push_back(muon);
607  if (recoSF || isoSF) { sf *= this->GetSignalMuonSF(*muon, recoSF, isoSF, bmhptSF); }
608  } else { // decorate baseline muons as well
609  if (recoSF || isoSF) { this->GetSignalMuonSF(*muon, recoSF, isoSF, bmhptSF, false); } //avoid OVR warnings in this case
610  }
611  }
612 
613  sf *= GetTotalMuonTriggerSF(*sfmuons.asDataVector(), trigExpr);
614 
615  return sf;
616 }

◆ GetTotalMuonSFsys()

double ST::SUSYObjDef_xAOD::GetTotalMuonSFsys ( const xAOD::MuonContainer muons,
const CP::SystematicSet systConfig,
const bool  recoSF = true,
const bool  isoSF = true,
const std::string &  trigExpr = "HLT_mu20_iloose_L1MU15_OR_HLT_mu50",
const bool  bmhptSF = true 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 619 of file Muons.cxx.

619  {
620  double sf(1.);
621  //Set the new systematic variation
623  if ( ret != StatusCode::SUCCESS) {
624  ATH_MSG_ERROR("Cannot configure MuonEfficiencyScaleFactors for systematic var. " << systConfig.name() );
625  }
626 
628  if ( ret != StatusCode::SUCCESS) {
629  ATH_MSG_ERROR("Cannot configure MuonBadMuonHighPtScaleFactors for systematic var. " << systConfig.name() );
630  }
631 
633  if ( ret != StatusCode::SUCCESS) {
634  ATH_MSG_ERROR("Cannot configure MuonTTVAEfficiencyScaleFactors for systematic var. " << systConfig.name() );
635  }
636 
638  if ( ret != StatusCode::SUCCESS) {
639  ATH_MSG_ERROR("Cannot configure MuonIsolationScaleFactors for systematic var. " << systConfig.name() );
640  }
641 
643  if ( ret != StatusCode::SUCCESS) {
644  ATH_MSG_ERROR("Cannot configure MuonHighPtIsolationScaleFactors for systematic var. " << systConfig.name() );
645  }
646 
648  if ( ret != StatusCode::SUCCESS) {
649  ATH_MSG_ERROR("Cannot configure MuonTriggerScaleFactors for systematic var. " << systConfig.name() );
650  }
651 
653  if (ret != StatusCode::SUCCESS) {
654  ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (trigger) for systematic var. " << systConfig.name() );
655  }
656 
658  if (ret != StatusCode::SUCCESS) {
659  ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (trigger) for systematic var. " << systConfig.name() );
660  }
661 
662  sf = GetTotalMuonSF(muons, recoSF, isoSF, trigExpr, bmhptSF);
663 
664  //Roll back to default
666  if ( ret != StatusCode::SUCCESS) {
667  ATH_MSG_ERROR("Cannot configure MuonEfficiencyScaleFactors back to default.");
668  }
669 
671  if ( ret != StatusCode::SUCCESS) {
672  ATH_MSG_ERROR("Cannot configure MuonBadMuonHighPtScaleFactors back to default.");
673  }
674 
676  if ( ret != StatusCode::SUCCESS) {
677  ATH_MSG_ERROR("Cannot configure MuonTTVAEfficiencyScaleFactors back to default.");
678  }
679 
681  if ( ret != StatusCode::SUCCESS) {
682  ATH_MSG_ERROR("Cannot configure MuonIsolationScaleFactors back to default.");
683  }
684 
686  if ( ret != StatusCode::SUCCESS) {
687  ATH_MSG_ERROR("Cannot configure MuonIsolationScaleFactors back to default.");
688  }
689 
691  if ( ret != StatusCode::SUCCESS) {
692  ATH_MSG_ERROR("Cannot configure MuonTriggerScaleFactors back to default.");
693  }
694 
696  if (ret != StatusCode::SUCCESS) {
697  ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (trigger) back to default.");
698  }
699 
701  if (ret != StatusCode::SUCCESS) {
702  ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (trigger) back to default.");
703  }
704 
705  return sf;
706 }

◆ GetTotalMuonTriggerSF()

double ST::SUSYObjDef_xAOD::GetTotalMuonTriggerSF ( const xAOD::MuonContainer sfmuons,
const std::string &  trigExpr 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 544 of file Muons.cxx.

544  {
545 
546  if (trigExpr.empty() || sfmuons.empty()) return 1.;
547 
548 
549  double trig_sf = 1.;
550 
551  int mulegs = 0;
552  const char *tmp = trigExpr.c_str();
553  while( (tmp = strstr(tmp, "mu")) ){
554  mulegs++;
555  tmp++;
556  }
557 
558  bool isdimuon = (trigExpr.find("2mu") != std::string::npos);
559  bool isOR = (trigExpr.find("OR") != std::string::npos);
560 
561  if((!isdimuon && mulegs<2) || (isdimuon && sfmuons.size()==2) || (mulegs>=2 && isOR)){ //Case 1: the tool takes easy care of the single, standard-dimuon and OR-of-single chains
562  if (m_muonTriggerSFTool->getTriggerScaleFactor( sfmuons, trig_sf, trigExpr ) == CP::CorrectionCode::Ok) {
563  ATH_MSG_DEBUG( "MuonTrig ScaleFactor " << trig_sf );
564  }
565  else{
566  ATH_MSG_DEBUG( "MuonTrig FAILED SOMEHOW");
567  }
568  }
569  else if(mulegs!=2 && isOR){ //Case 2: not supported. Not efficiency defined for (at least) one leg. Sorry...
570  ATH_MSG_WARNING( "SF for " << trigExpr << " are only supported for two muon events!");
571  }
572  else{ //Case 3: let's go the hard way...
573  //Following https://twiki.cern.ch/twiki/bin/view/Atlas/TrigMuonEfficiency
574  std::string newtrigExpr = TString(trigExpr).Copy().ReplaceAll("HLT_2","").Data();
575 
576  //redefine dimuon triggers here (2mu14 --> mu14_mu14)
577  if (isdimuon) { newtrigExpr += "_"+newtrigExpr; }
578  boost::replace_all(newtrigExpr, "HLT_", "");
579  boost::char_separator<char> sep("_");
580 
581  for (const auto& mutrig : boost::tokenizer<boost::char_separator<char>>(newtrigExpr, sep)) {
582  double dataFactor = 1.;
583  double mcFactor = 1.;
584 
585  for (const xAOD::Muon* mu : sfmuons) {
586  // No need for additional trigger matching
587  dataFactor *= (1 - GetMuonTriggerEfficiency(*mu, "HLT_"+mutrig, true));
588  mcFactor *= (1 - GetMuonTriggerEfficiency(*mu, "HLT_"+mutrig, false));
589  }
590  if( (1-mcFactor) > 0. )
591  trig_sf *= (1-dataFactor)/(1-mcFactor);
592  }
593  }
594 
595  return trig_sf;
596 }

◆ GetTotalPhotonSF()

double ST::SUSYObjDef_xAOD::GetTotalPhotonSF ( const xAOD::PhotonContainer photons,
const bool  effSF = true,
const bool  isoSF = true,
const bool  triggerSF = false 
) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 317 of file Photons.cxx.

318 {
319  double sf(1.);
320 
321  for (const xAOD::Photon* photon : photons) {
322  if (acc_signal(*photon) && acc_passOR(*photon)) { sf *= this->GetSignalPhotonSF(*photon, effSF, isoSF, triggerSF); }
323  }
324 
325  return sf;
326 }

◆ GetTotalPhotonSFsys()

double ST::SUSYObjDef_xAOD::GetTotalPhotonSFsys ( const xAOD::PhotonContainer photons,
const CP::SystematicSet systConfig,
const bool  effSF = true,
const bool  isoSF = true,
const bool  triggerSF = false 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 329 of file Photons.cxx.

330 {
331  double sf(1.);
332 
333  for (const xAOD::Photon* photon : photons) {
334  if (acc_signal(*photon) && acc_passOR(*photon)) { sf *= this->GetSignalPhotonSFsys(*photon, systConfig, effSF, isoSF, triggerSF); }
335  }
336 
337  return sf;
338 }

◆ GetTotalTauSF()

double ST::SUSYObjDef_xAOD::GetTotalTauSF ( const xAOD::TauJetContainer taus,
const bool  idSF = true,
const bool  triggerSF = true,
const std::string &  trigExpr = "tau25_medium1_tracktwo" 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 227 of file Taus.cxx.

227  {
228 
229  double sf(1.);
230 
231  for (const xAOD::TauJet* tau : taus) {
232  // check existence of OR information
233  if (!acc_passOR.isAvailable(*tau)) {
234  ATH_MSG_WARNING("Tau does not have Overlap Removal decision set. You should only call GetTotalTauSF with taus that have been passed through OR. SF will NOT be applied!");
235  break;
236  }
237 
238  // Call this for all taus, which will add the decoration
239  double tmpSF = GetSignalTauSF(*tau, idSF, triggerSF, trigExpr);
240  if (acc_signal(*tau) && acc_passOR(*tau)) {
241  sf *= tmpSF;
242  }
243  }
244 
245  return sf;
246 }

◆ GetTotalTauSFsys()

double ST::SUSYObjDef_xAOD::GetTotalTauSFsys ( const xAOD::TauJetContainer taus,
const CP::SystematicSet systConfig,
const bool  idSF = true,
const bool  triggerSF = true,
const std::string &  trigExpr = "tau25_medium1_tracktwo" 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 249 of file Taus.cxx.

249  {
250  double sf(1.);
251 
252  //Set the new systematic variation
254  if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure TauEfficiencyCorrectionsTool for systematic var. " << systConfig.name() ); }
255 
256  for (auto& tool : m_tauTrigEffTool) {
257  ret = tool->applySystematicVariation(systConfig);
258  if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure " << tool->name() << " for systematic var. " << systConfig.name()); }
259  }
260 
261  sf = GetTotalTauSF(taus, idSF, triggerSF, trigExpr);
262 
263  //Roll back to default
265  if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure TauEfficiencyCorrectionsTool back to default"); }
266 
267  for (auto& tool : m_tauTrigEffTool) {
268  ret = tool->applySystematicVariation(m_currentSyst);
269  if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure " << tool->name() << " back to default"); }
270  }
271 
272  return sf;
273 }

◆ GetTrackJets()

StatusCode ST::SUSYObjDef_xAOD::GetTrackJets ( xAOD::JetContainer *&  copy,
xAOD::ShallowAuxContainer *&  copyaux,
const bool  recordSG = true,
const std::string &  jetkey = "",
const xAOD::JetContainer containerToBeCopied = nullptr 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 170 of file Jets.cxx.

171  {
172  if (!m_tool_init) {
173  ATH_MSG_ERROR("SUSYTools was not initialized!!");
174  return StatusCode::FAILURE;
175  }
176 
177  ATH_MSG_DEBUG("Default jetkey (trkjet): " << m_defaultTrackJets);
178  ATH_MSG_DEBUG("Function argument jetkey (trkjet): " << jetkey);
179 
180  // load default regular & btag jet keys
181  std::string jetkey_tmp = m_defaultTrackJets;
182 
183  // override default if user is passing a jetkey
184  if (!jetkey.empty()) {
185  jetkey_tmp = jetkey;
186  }
187 
188  // final settings
189  ATH_MSG_DEBUG("Key for retrieving trkjet collection (as well as bjet info): jetkey = " << jetkey_tmp);
190 
191  const xAOD::JetContainer* jets = nullptr;
192  if (copy==nullptr) { // empty container provided
193  if (containerToBeCopied != nullptr) {
194  jets = containerToBeCopied;
195  }
196  else {
197  ATH_MSG_DEBUG("Retrieve jet collection: " << jetkey_tmp);
198  ATH_CHECK( evtStore()->retrieve(jets, jetkey_tmp) );
199  }
200  std::pair<xAOD::JetContainer*, xAOD::ShallowAuxContainer*> shallowcopy = xAOD::shallowCopyContainer(*jets);
201  copy = shallowcopy.first;
202  copyaux = shallowcopy.second;
203  bool setLinks = xAOD::setOriginalObjectLink(*jets, *copy);
204  if (!setLinks) {
205  ATH_MSG_WARNING("Failed to set original object links on " << jetkey_tmp);
206  }
207  } else { // use the user-supplied collection instead
208  ATH_MSG_DEBUG("Not retrieving jet collection, using existing one provided by user");
209  jets = copy;
210  }
211 
212  //disable - notfortrackjets? // Calibrate the jets
213  //disable - notfortrackjets? ATH_CHECK(m_jetCalibTool->applyCalibration(*copy));
214 
215  // Update the jets
216  for (const auto& jet : *copy) {
217  ATH_CHECK( this->FillTrackJet(*jet) );
218  }
219 
220  if (copy->size() > 1 && m_defaultTrackJets == "AntiKtVR30Rmax4Rmin02TrackJets") {
221  // Use iterators to avoid pairing the jets twice
222  for (xAOD::JetContainer::const_iterator j1 = copy->begin()+1; j1!= copy->end();++j1) {
223  const xAOD::Jet* jet1 = (*j1);
224  if (!acc_signal(*jet1)) continue;
225  for (xAOD::JetContainer::const_iterator j2 = copy->begin(); j2 != j1; ++j2) {
226  const xAOD::Jet* jet2 = (*j2);
227  if (!acc_baseline(*jet2)) continue;
228  //Reference to the use method in P4Helper: deltaR2( const xAOD::IParticle& p4, const xAOD::IParticle& , bool useRapidity=true )
229  float dr_jets = xAOD::P4Helpers::deltaR(jet1,jet2, false);
230  const xAOD::Jet* to_check = acc_VRradius(*jet1) < acc_VRradius(*jet2) ? jet1 : jet2;
231  if( dr_jets < acc_VRradius(*to_check)) dec_passDRcut(*to_check) = false;
232  //break the loop at this point???
233  }
234  }
235  }
236  if (recordSG) {
237  ATH_CHECK( evtStore()->record(copy, "STCalib" + jetkey_tmp + m_currentSyst.name()) );
238  ATH_CHECK( evtStore()->record(copyaux, "STCalib" + jetkey_tmp + m_currentSyst.name() + "Aux.") );
239  }
240  return StatusCode::SUCCESS;
241  }

◆ GetTrackMET()

StatusCode ST::SUSYObjDef_xAOD::GetTrackMET ( xAOD::MissingETContainer met,
const xAOD::JetContainer jet,
const xAOD::ElectronContainer elec = nullptr,
const xAOD::MuonContainer muon = nullptr 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 161 of file MET.cxx.

164  {
165  if (!m_tool_init) {
166  ATH_MSG_ERROR("SUSYTools was not initialized!!");
167  return StatusCode::FAILURE;
168  }
169 
170  const xAOD::MissingETContainer* metcore(nullptr);
171  if ( evtStore()->retrieve( metcore, m_inputMETCore ).isFailure() ) {
172  ATH_MSG_WARNING( "Unable to retrieve MET core container: " << m_inputMETCore );
173  return StatusCode::FAILURE;
174  }
175  const xAOD::MissingETAssociationMap* metMap(nullptr);
176  if ( evtStore()->retrieve(metMap, m_inputMETMap).isFailure() ) {
177  ATH_MSG_WARNING("Unable to retrieve MissingETAssociationMap: " << m_inputMETMap);
178  return StatusCode::FAILURE;
179  }
180  // Helper keeps track of object selection flags for this map
181  xAOD::MissingETAssociationHelper metHelper(&(*metMap));
182 
183  metHelper.resetObjSelectionFlags();
184 
185  if (elec) {
186  ATH_MSG_VERBOSE("Build electron MET");
188  for (const xAOD::Electron* el : *elec) {
189  // pass baseline selection
190  if (acc_baseline(*el)) metelectron.push_back(el);
191  }
192  ATH_CHECK( m_metMaker->rebuildMET(m_eleTerm, xAOD::Type::Electron, &met, metelectron.asDataVector(), metHelper) );
193  }
194 
195  if (muon) {
196  ATH_MSG_VERBOSE("Build muon MET");
198  for (const xAOD::Muon* mu : *muon) {
199  // pass baseline selection
200  if (acc_baseline(*mu)) metmuon.push_back(mu);
201  }
202  ATH_CHECK( m_metMaker->rebuildMET(m_muonTerm, xAOD::Type::Muon, &met, metmuon.asDataVector(), metHelper) );
203  }
204 
205  if (!jet) {
206  ATH_MSG_WARNING("Invalid jet container specified for MET rebuilding!");
207  return StatusCode::SUCCESS;
208  }
209  ATH_MSG_VERBOSE("Build jet/soft MET_Track");
210 
211  std::string softTerm = "PVSoftTrk";
212  ATH_CHECK( m_metMaker->rebuildTrackMET(m_jetTerm, softTerm, &met, jet, metcore, metHelper, true) );
213 
214  if (!isData()) {
215  m_metSystTool->setRandomSeed(static_cast<int>(1e6*met[softTerm]->phi()));
216 
217  if (m_trkMETsyst) {
218  ATH_MSG_VERBOSE("Apply trkMET systematics");
219  if ( m_metSystTool->applyCorrection(*met[softTerm],metHelper) != CP::CorrectionCode::Ok )
220  ATH_MSG_WARNING("GetMET: Failed to apply MET track (PVSoftTrk) systematics.");
221  }
222 
223  if (m_trkJetsyst) {
224  ATH_MSG_VERBOSE("Apply Ref Jet trkMET systematics");
226  ATH_MSG_WARNING("GetMET: Failed to apply MET track (RefJet) systematics.");
227  }
228 
229  }
230 
231  ATH_MSG_VERBOSE("Build MET sum");
232  ATH_CHECK( met::buildMETSum("Track", &met, met[softTerm]->source()) );
233  ATH_MSG_VERBOSE( "Done rebuilding MET." );
234 
235  ATH_MSG_VERBOSE( "Track MET: Missing Et (x,y): (" << met["Track"]->mpx() << "," << met["Track"]->mpy() << ")");
236 
237  return StatusCode::SUCCESS;
238 }

◆ GetTrigChainGroup()

const Trig::ChainGroup * ST::SUSYObjDef_xAOD::GetTrigChainGroup ( const std::string &  tr_item) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 317 of file Trigger.cxx.

317  {
318  return m_trigDecTool->getChainGroup(tr_item);
319 }

◆ GetTriggerFeatures()

Trig::FeatureContainer ST::SUSYObjDef_xAOD::GetTriggerFeatures ( const std::string &  chainName = "EF_.*",
unsigned int  condition = TrigDefs::Physics 
) const

Definition at line 395 of file Trigger.cxx.

396  {
398  }

◆ GetTriggerGlobalEfficiency() [1/2]

double ST::SUSYObjDef_xAOD::GetTriggerGlobalEfficiency ( const xAOD::ElectronContainer electrons,
const xAOD::MuonContainer muons,
const std::string &  trigExpr = "diLepton" 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 555 of file Trigger.cxx.

555  {
556 
557  double trig_eff(1.);
558  double trig_eff_data(1.);
559 
560  if (trigExpr!="multiLepton" && trigExpr!="diLepton") {
561  ATH_MSG_ERROR( "Failed to retrieve multi-lepton trigger efficiency");
562  return trig_eff;
563  }
564 
565  std::vector<const xAOD::Electron*> elec_trig;
566  for (const xAOD::Electron* electron : electrons) {
567  if (!acc_passOR(*electron)) continue;
568  if (!acc_signal(*electron)) continue;
569  elec_trig.push_back(electron);
570  }
571 
572  std::vector<const xAOD::Muon*> muon_trig;
573  for (const xAOD::Muon* muon : muons) {
574  if (!acc_passOR(*muon)) continue;
575  if (!acc_signal(*muon)) continue;
576  muon_trig.push_back(muon);
577  }
578 
579  bool matched = false;
580  if ((elec_trig.size()+muon_trig.size())>1 && trigExpr=="diLepton") {
582  ATH_MSG_ERROR ("trigGlobEffCorrTool::Trigger matching could not be checked, interrupting execution.");
583  }
584  } else if ((elec_trig.size()+muon_trig.size())>2 && trigExpr=="multiLepton") {
586  ATH_MSG_ERROR ("trigGlobEffCorrTool::Trigger matching could not be checked, interrupting execution.");
587  }
588  }
589 
591  if ((elec_trig.size()+muon_trig.size())>1 && trigExpr=="diLepton" && matched) {
592  result = m_trigGlobalEffCorrTool_diLep->getEfficiency( elec_trig, muon_trig, trig_eff_data, trig_eff);
593  }
594  else if ((elec_trig.size()+muon_trig.size())>2 && trigExpr=="multiLepton" && matched) {
595  result = m_trigGlobalEffCorrTool_multiLep->getEfficiency( elec_trig, muon_trig, trig_eff_data, trig_eff);
596  }
597 
598  switch (result) {
600  ATH_MSG_ERROR( "Failed to retrieve multi-lepton trigger efficiency");
601  return 1.;
603  ATH_MSG_VERBOSE( "OutOfValidityRange found for multi-lepton trigger efficiency");
604  return 1.;
605  default:
606  break;
607  }
608 
609  if (isData()) return trig_eff_data;
610  else return trig_eff;
611 }

◆ GetTriggerGlobalEfficiency() [2/2]

double ST::SUSYObjDef_xAOD::GetTriggerGlobalEfficiency ( const xAOD::PhotonContainer photons,
const std::string &  trigExpr = "diPhoton" 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 616 of file Trigger.cxx.

616  {
617 
618  double trig_eff(1.);
619  double trig_eff_data(1.);
620 
621  if (trigExpr!="diPhoton") {
622  ATH_MSG_ERROR( "Failed to retrieve diphoton trigger efficiency");
623  return trig_eff;
624  }
625 
626  std::vector<const xAOD::Photon*> ph_trig;
627  for (const xAOD::Photon* photon : photons) {
628  if (!acc_passOR(*photon)) continue;
629  if (!acc_signal(*photon)) continue;
630  ph_trig.push_back(photon);
631  }
632 
634  if (ph_trig.size()>1) {
635  result = m_trigGlobalEffCorrTool_diPhoton->getEfficiency(ph_trig, trig_eff_data, trig_eff);
636  }
637 
638  switch (result) {
640  ATH_MSG_ERROR( "Failed to retrieve diphoton trigger efficiency");
641  return 1.;
643  ATH_MSG_VERBOSE( "OutOfValidityRange found for diphoton trigger efficiency");
644  return 1.;
645  default:
646  break;
647  }
648 
649  if (isData()) return trig_eff_data;
650  else return trig_eff;
651 }

◆ GetTriggerGlobalEfficiencySF() [1/2]

double ST::SUSYObjDef_xAOD::GetTriggerGlobalEfficiencySF ( const xAOD::ElectronContainer electrons,
const xAOD::MuonContainer muons,
const std::string &  trigExpr = "diLepton" 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 400 of file Trigger.cxx.

400  {
401 
402  double trig_sf(1.);
403 
404  if (trigExpr!="multiLepton" && trigExpr!="diLepton") {
405  ATH_MSG_ERROR( "Failed to retrieve multi-lepton trigger SF");
406  return trig_sf;
407  }
408 
409  std::vector<const xAOD::Electron*> elec_trig;
410  for (const xAOD::Electron* electron : electrons) {
411  if (!acc_passOR(*electron)) continue;
412  if (!acc_signal(*electron)) continue;
413  elec_trig.push_back(electron);
414  }
415 
416  std::vector<const xAOD::Muon*> muon_trig;
417  for (const xAOD::Muon* muon : muons) {
418  if (!acc_passOR(*muon)) continue;
419  if (!acc_signal(*muon)) continue;
420  muon_trig.push_back(muon);
421  }
422 
423  bool matched = false;
424  if ((elec_trig.size()+muon_trig.size())>1 && trigExpr=="diLepton") {
426  ATH_MSG_ERROR ("trigGlobEffCorrTool::Trigger matching could not be checked, interrupting execution.");
427  }
428  } else if ((elec_trig.size()+muon_trig.size())>2 && trigExpr=="multiLepton") {
430  ATH_MSG_ERROR ("trigGlobEffCorrTool::Trigger matching could not be checked, interrupting execution.");
431  }
432  }
433 
435  if ((elec_trig.size()+muon_trig.size())>1 && trigExpr=="diLepton" && matched) {
436  result = m_trigGlobalEffCorrTool_diLep->getEfficiencyScaleFactor( elec_trig, muon_trig, trig_sf);
437  }
438  else if ((elec_trig.size()+muon_trig.size())>2 && trigExpr=="multiLepton" && matched) {
439  result = m_trigGlobalEffCorrTool_multiLep->getEfficiencyScaleFactor( elec_trig, muon_trig, trig_sf);
440  }
441 
442  switch (result) {
444  ATH_MSG_ERROR( "Failed to retrieve multi-lepton trigger SF");
445  return 1.;
447  ATH_MSG_VERBOSE( "OutOfValidityRange found for multi-lepton trigger SF");
448  return 1.;
449  default:
450  break;
451  }
452 
453  return trig_sf;
454 }

◆ GetTriggerGlobalEfficiencySF() [2/2]

double ST::SUSYObjDef_xAOD::GetTriggerGlobalEfficiencySF ( const xAOD::PhotonContainer photons,
const std::string &  trigExpr = "diPhoton" 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 498 of file Trigger.cxx.

498  {
499 
500  double trig_sf(1.);
501 
502  if (trigExpr!="diPhoton") {
503  ATH_MSG_ERROR( "Failed to retrieve diphoton trigger SF");
504  return trig_sf;
505  }
506 
507  std::vector<const xAOD::Photon*> ph_trig;
508  for (const xAOD::Photon* photon : photons) {
509  if (!acc_passOR(*photon)) continue;
510  if (!acc_signal(*photon)) continue;
511  ph_trig.push_back(photon);
512  }
513 
515  if (ph_trig.size()>1) {
517  }
518 
519  switch (result) {
521  ATH_MSG_ERROR( "Failed to retrieve diphoton trigger SF");
522  return 1.;
524  ATH_MSG_VERBOSE( "OutOfValidityRange found for diphoton trigger SF");
525  return 1.;
526  default:
527  break;
528  }
529 
530  return trig_sf;
531 }

◆ GetTriggerGlobalEfficiencySFsys() [1/2]

double ST::SUSYObjDef_xAOD::GetTriggerGlobalEfficiencySFsys ( const xAOD::ElectronContainer electrons,
const xAOD::MuonContainer muons,
const CP::SystematicSet systConfig,
const std::string &  trigExpr = "diLepton" 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 456 of file Trigger.cxx.

456  {
457 
458  double sf(1.);
459 
460  //Set the new systematic variation
461  if (trigExpr == "diLepton") {
463  if (ret != StatusCode::SUCCESS) {
464  ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (dilepton trigger) for systematic var. " << systConfig.name() );
465  }
466  }
467 
468  if (trigExpr == "multiLepton") {
470  if (ret != StatusCode::SUCCESS) {
471  ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (multi-lepton trigger) for systematic var. " << systConfig.name() );
472  }
473  }
474 
475  //Get the SF for new config
476  sf = GetTriggerGlobalEfficiencySF (electrons, muons, trigExpr);
477 
478  //Roll back to default
479  if (trigExpr == "diLepton") {
481  if (ret != StatusCode::SUCCESS) {
482  ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (dilepton trigger) back to default.");
483  }
484  }
485  if (trigExpr == "multiLepton") {
487  if (ret != StatusCode::SUCCESS) {
488  ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (multi-lepton trigger) back to default.");
489  }
490  }
491 
492  return sf;
493 }

◆ GetTriggerGlobalEfficiencySFsys() [2/2]

double ST::SUSYObjDef_xAOD::GetTriggerGlobalEfficiencySFsys ( const xAOD::PhotonContainer photons,
const CP::SystematicSet systConfig,
const std::string &  trigExpr = "diPhoton" 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 533 of file Trigger.cxx.

533  {
534 
535  double sf(1.);
536 
537  //Set the new systematic variation
539  if (ret != StatusCode::SUCCESS) {
540  ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (diphoton trigger) for systematic var. " << systConfig.name() );
541  }
542 
543  //Get the SF for new config
544  sf = GetTriggerGlobalEfficiencySF (photons, trigExpr);
545 
546  //Roll back to default
548  if (ret != StatusCode::SUCCESS) {
549  ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (diphoton trigger) back to default.");
550  }
551 
552  return sf;
553 }

◆ GetTriggerOR()

std::vector< std::string > ST::SUSYObjDef_xAOD::GetTriggerOR ( const std::string &  trigExpr) const

Definition at line 322 of file Trigger.cxx.

322  {
323 
324  static const std::string delOR = "_OR_";
325  std::vector<std::string> trigchains = {};
326  std::string newtrigExpr = TString(trigExpr).Copy().ReplaceAll("||",delOR).Data();
327  newtrigExpr = TString(trigExpr).Copy().ReplaceAll(" ","").Data();
328 
329  size_t pos = 0;
330  while ((pos = newtrigExpr.find(delOR)) != std::string::npos) {
331  trigchains.push_back( "HLT_"+newtrigExpr.substr(0, pos) );
332  newtrigExpr.erase(0, pos + delOR.length());
333  }
334  if(pos==std::string::npos)
335  trigchains.push_back("HLT_"+newtrigExpr);
336 
337  return trigchains;
338  }

◆ GetTriggerTokens()

void ST::SUSYObjDef_xAOD::GetTriggerTokens ( std::string  trigExpr,
std::vector< std::string > &  v_trigs15_cache,
std::vector< std::string > &  v_trigs16_cache,
std::vector< std::string > &  v_trigs17_cache,
std::vector< std::string > &  v_trigs18_cache,
std::vector< std::string > &  v_trigs22_cache 
) const

Definition at line 340 of file Trigger.cxx.

340  {
341 
342  // e.g. SINGLE_E_2015_e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose_2016_2018_e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0
343 
344  static const std::string del15 = "_2015_";
345  static const std::string del16 = "_2016_";
346  static const std::string del17 = "_2017_";
347  static const std::string del18 = "_2018_";
348  static const std::string del22 = "_2022_";
349 
350  size_t pos = 0;
351  std::string token15, token16, token17, token18, token22;
352 
353  //get trigger tokens for 2015, 2016, 2017, 2018 and 2022
354  if ( (pos = trigExpr.find(del15)) != std::string::npos) {
355  trigExpr.erase(0, pos + del15.length());
356 
357  pos = 0;
358  while ((pos = trigExpr.find(del16)) != std::string::npos) {
359  token15 = trigExpr.substr(0, pos);
360  token16 = trigExpr.erase(0, pos + del16.length() + del17.length() - 1);
361  // 2016-2018 use exact the same trigger string
362  token17 = token16;
363  token18 = token16;
364  }
365  }
366 
367  if ( (pos = trigExpr.find(del22)) != std::string::npos) {
368  trigExpr.erase(0, pos + del22.length());
369  }
370 
371  //redefine in case of custom user input
372  if(!m_isRun3){
373  if(token15.empty()) token15 = trigExpr;
374  if(token16.empty()) token16 = trigExpr;
375  if(token17.empty()) token17 = trigExpr;
376  if(token18.empty()) token18 = trigExpr;
377  }
378  else{
379  if(token22.empty()) token22 = trigExpr;
380  }
381 
382  //get trigger chains for matching in 2015 and 2018
383  if(!m_isRun3){
384  v_trigs15_cache = GetTriggerOR(token15);
385  v_trigs16_cache = GetTriggerOR(token16);
386  v_trigs17_cache = GetTriggerOR(token17);
387  v_trigs18_cache = GetTriggerOR(token18);
388  }
389  //get trigger chains for matching in 2022
390  else{
391  v_trigs22_cache = GetTriggerOR(token22);
392  }
393  }

◆ GetTrigPrescale()

float ST::SUSYObjDef_xAOD::GetTrigPrescale ( const std::string &  tr_item) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 312 of file Trigger.cxx.

312  {
313  return m_trigDecTool->getPrescale(tr_item);
314 }

◆ handle()

void asg::AsgMetadataTool::handle ( const Incident &  inc)
protectedvirtualinherited

Function receiving incidents from IncidentSvc/TEvent.

Reimplemented in Trig::TrigDecisionTool.

Definition at line 130 of file AsgMetadataTool.cxx.

130  {
131 
132  // Tell the user what's happening:
133  ATH_MSG_VERBOSE( "Callback received with incident: " << inc.type() );
134 
135  // Call the appropriate member function:
136  if( inc.type() == IncidentType::BeginInputFile ) {
137  m_beginInputFileCalled = true;
138  if( beginInputFile().isFailure() ) {
139  ATH_MSG_FATAL( "Failed to call beginInputFile()" );
140  throw std::runtime_error( "Couldn't call beginInputFile()" );
141  }
142  } else if( inc.type() == IncidentType::EndInputFile ) {
143  if( endInputFile().isFailure() ) {
144  ATH_MSG_FATAL( "Failed to call endInputFile()" );
145  throw std::runtime_error( "Couldn't call endInputFile()" );
146  }
147  } else if( inc.type() == IncidentType::BeginEvent ) {
148  // If the tool didn't catch the begin input file incident for the
149  // first input file of the job, then call the appropriate function
150  // now.
151  if( ! m_beginInputFileCalled ) {
152  m_beginInputFileCalled = true;
153  if( beginInputFile().isFailure() ) {
154  ATH_MSG_FATAL( "Failed to call beginInputFile()" );
155  throw std::runtime_error( "Couldn't call beginInputFile()" );
156  }
157  }
158  if( beginEvent().isFailure() ) {
159  ATH_MSG_FATAL( "Failed to call beginEvent()" );
160  throw std::runtime_error( "Couldn't call beginEvent()" );
161  }
162 
163  #ifdef XAOD_STANDALONE
164  } else if( inc.type() == IncidentType::MetaDataStop ) {
165  if( metaDataStop().isFailure() ) {
166  ATH_MSG_FATAL( "Failed to call metaDataStop()" );
167  throw std::runtime_error( "Couldn't call metaDataStop()" );
168  }
169 
170  #endif // XAOD_STANDALONE
171  } else {
172  ATH_MSG_WARNING( "Unknown incident type received in AsgMetaDataTool: " << inc.type() );
173  }
174 
175  return;
176  }

◆ initialize()

StatusCode ST::SUSYObjDef_xAOD::initialize ( )
finaloverridevirtual

Dummy implementation of the initialisation function.

It's here to allow the dual-use tools to skip defining an initialisation function. Since many are doing so...

Reimplemented from asg::AsgTool.

Definition at line 872 of file SUSYObjDef_xAOD.cxx.

872  {
873 
874  if (m_tool_init) {
875  ATH_MSG_ERROR("Initialising for a second time -- something is wrong!");
876  return StatusCode::FAILURE;
877  }
878 
879  // Greet the user:
880  ATH_MSG_INFO( "Initialising... " );
881 
882  bool autoconf(false);
883 #ifndef XAOD_STANDALONE // For now metadata is Athena-only
884  if ( m_dataSource < 0 ) {
885  autoconf = true;
886  ATH_MSG_INFO("Autoconfiguring: dataSource, mcCampaign, isPHYSLITE");
887  std::string projectName = "";
888  ATH_CHECK( AthAnalysisHelper::retrieveMetadata("/TagInfo", "project_name", projectName, inputMetaStore() ) );
889  if ( projectName == "IS_SIMULATION" ) {
890  std::string simFlavour = "";
891  ATH_CHECK( AthAnalysisHelper::retrieveMetadata("/Simulation/Parameters", "SimulationFlavour", simFlavour, inputMetaStore() ) );
892  TString s(simFlavour); s.ToUpper();
893  m_dataSource = s.Contains("ATLFAST") ? AtlfastII : FullSim;
894  } else if (projectName.compare(0, 4, "data") == 0 ) {
895  m_dataSource = Data;
896  } else {
897  ATH_MSG_ERROR("Failed to autoconfigure -- project_name matches neither IS_SIMULATION nor data!");
898  return StatusCode::FAILURE;
899  }
900 
901  }
902 #endif
903 
905 
906  //Read configuration from file (stored as Property)
907  ATH_CHECK( readConfig() );
908 
909  if (m_dataSource < 0) {
910  ATH_MSG_FATAL( "Data source incorrectly configured!!" );
911  ATH_MSG_FATAL("You must set the DataSource property to Data, FullSim or AtlfastII !!");
912  if (autoconf) ATH_MSG_FATAL("Autoconfiguration seems to have failed!");
913  // if(m_useLeptonTrigger<0) ATH_MSG_ERROR( "UseLeptonTrigger not set");
914  ATH_MSG_FATAL( "Exiting... " );
915  return StatusCode::FAILURE;
916  }
917  ATH_MSG_DEBUG( "Configured: IsData: " << isData() );
918  ATH_MSG_DEBUG( "Configured: IsAtlfast: " << isAtlfast() );
919 
920  switch (m_jetInputType) {
924  break;
925  default:
927  return StatusCode::FAILURE;
928  }
929 
930  if (m_inputMETSuffix.empty()){
932  }
934  ATH_MSG_INFO( "Configured for jet collection: " << m_defaultJets );
935 
936  m_defaultTruthJets = "AntiKt4TruthJets";
937  const xAOD::FileMetaData* fmd = nullptr;
938  std::string dataType;
939  if ( inputMetaStore()->contains<xAOD::FileMetaData>("FileMetaData") && inputMetaStore()->retrieve(fmd,"FileMetaData").isSuccess() )
941  if ( dataType.compare("StreamDAOD_PHYS")==0 || dataType.compare("StreamDAOD_PHYSLITE")==0 ) m_defaultTruthJets = "AntiKt4TruthDressedWZJets";
942  if ( dataType.compare("StreamDAOD_PHYSLITE")==0) m_isPHYSLITE = true;
943 
944  ATH_MSG_INFO( "Configured for truth jet collection: " << m_defaultTruthJets );
945 
946  m_inputMETCore = m_isPHYSLITE? "MET_Core_AnalysisMET":"MET_Core_" + m_inputMETSuffix;
947  m_inputMETMap = m_isPHYSLITE? "METAssoc_AnalysisMET":"METAssoc_" + m_inputMETSuffix;
948 
949  ATH_MSG_DEBUG ( "Build MET Core: " << m_inputMETCore);
950  ATH_MSG_DEBUG ( "Build MET with map: " << m_inputMETMap);
951 
952  m_jetCleanDFName = TString::Format("DFCommonJets_jetClean_%s", m_badJetCut.c_str());
954 
955  // the decorations are named like DFCommonElectronsLHTight, DFCommonElectronsDNNTight or DFCommonElectronsDNNTightNoCF
956  m_eleIdBaselineDFName = m_eleIdBaseline.find("DNN") == std::string::npos ? "DFCommonElectronsLH" : "DFCommonElectronsDNN";
957  m_eleIdBaselineDFName += TString(m_eleIdBaseline).ReplaceAll("LooseAndBLayer","LooseBL").ReplaceAll("LLH","").ReplaceAll("DNNnoCF","").ReplaceAll("DNN","").Data();
958  if (m_eleIdBaseline.find("noCF") != std::string::npos)
959  m_eleIdBaselineDFName += "NoCF";
961 
962  m_eleIdDFName = m_eleId.find("DNN") == std::string::npos ? "DFCommonElectronsLH" : "DFCommonElectronsDNN";
963  m_eleIdDFName += TString(m_eleId).ReplaceAll("LooseAndBLayer","LooseBL").ReplaceAll("LLH","").ReplaceAll("DNNnoCF","").ReplaceAll("DNN","").Data();
964  if (m_eleId.find("noCF") != std::string::npos)
965  m_eleIdDFName += "NoCF";
967 
968  m_photonIdBaselineDFName = "DFCommonPhotonsIsEM";
969  m_photonIdBaselineDFName += TString(m_photonIdBaseline).Data();
971 
972  m_photonIdDFName = "DFCommonPhotonsIsEM";
973  m_photonIdDFName += TString(m_photonId).Data();
975 
976  // autoconfigure PRW tool if m_autoconfigPRW==true
977  if (m_autoconfigPRWPath == "dev/PileupReweighting/share/")
979  else
980  // need to set a full path if you don't use the one in CVMFS
982 
983  // Read Handles
986 
987  // Write Handles
989  ATH_CHECK( m_outMuonLocation.initialize() );
990 
991  ATH_CHECK( this->SUSYToolsInit() );
992 
993  ATH_MSG_VERBOSE("Done with tool retrieval");
994 
995  m_tool_init = true;
996 
997  // Return gracefully:
998  return StatusCode::SUCCESS;
999 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ inputMetaStore()

AsgMetadataTool::MetaStorePtr_t asg::AsgMetadataTool::inputMetaStore ( ) const
inherited

Accessor for the input metadata store.

Definition at line 88 of file AsgMetadataTool.cxx.

88  {
89 
90 #ifdef XAOD_STANDALONE
91  return &m_inputMetaStore;
92 #else // XAOD_STANDALONE
93  return m_inputMetaStore;
94 #endif // XAOD_STANDALONE
95  }

◆ isAtlfast()

bool ST::SUSYObjDef_xAOD::isAtlfast ( ) const
inlinefinaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 157 of file SUSYObjDef_xAOD.h.

157 {return m_dataSource == AtlfastII;}

◆ IsBadJet()

bool ST::SUSYObjDef_xAOD::IsBadJet ( const xAOD::Jet input) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 710 of file Jets.cxx.

710  {
711 
712  if ( !acc_passOR(input) ) return false;
713 
714  float ptcut = 20e3;
715  if ( m_jetPt < ptcut ) ptcut = m_jetPt;
716 
717  bool isPileup = !acc_passJvt(input);
718 
719  if ( input.pt() <= ptcut || isPileup ) return false;
720 
722  dec_bad(input) = !m_acc_jetClean(input);
723  } else {
724  ATH_MSG_VERBOSE("DFCommon jet cleaning variable not available ... setting 'bad' decorator to 0.");
725  dec_bad(input) = 0;
726  // the jet cleaning decisions are only calculable at AOD now
727  // dec_bad(input) = m_jetCleaningTool.empty() ? false : !m_jetCleaningTool->keep(input);
728  }
729 
730  ATH_MSG_VERBOSE( "JET isbad?: " << static_cast<int>(acc_bad(input)));
731 
732  return acc_bad(input);
733  }

◆ IsBadMuon()

bool ST::SUSYObjDef_xAOD::IsBadMuon ( const xAOD::Muon input,
const float  qopcut 
) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 402 of file Muons.cxx.

403 {
404  const static SG::Decorator<char> dec_bad("bad");
405  dec_bad(input) = false;
406 
407  const static SG::Decorator<char> dec_bad_highPt("bad_highPt");
408  dec_bad_highPt(input) = false;
409 
410  const xAOD::TrackParticle* track;
411  if (input.muonType() == xAOD::Muon::SiliconAssociatedForwardMuon) {
412  track = input.trackParticle(xAOD::Muon::CombinedTrackParticle);
413  if (!track) return false; // don't treat SAF muons without CB track further
414  }
415  else{
416  track = input.primaryTrackParticle();
417  if (!track){
418  ATH_MSG_WARNING("Non-SAF muon without a track; cannot test IsBadMuon criteria");
419  return false;
420  }
421  }
422 
423  float Rerr = Amg::error(track->definingParametersCovMatrix(), 4) / std::abs(track->qOverP());
424  ATH_MSG_VERBOSE( "Track momentum error (%): " << Rerr * 100 );
425  bool isbad = Rerr > qopcut;
426  bool isbadHighPt = Rerr > qopcut;
427 
428  //new recommendation from MCP
430 
431  //new recommendation from MCP (at HighPT)
432  isbadHighPt |= m_muonSelectionHighPtTool->isBadMuon(input);
433 
434  dec_bad(input) = isbad;
435  dec_bad_highPt(input) = isbadHighPt;
436 
437  ATH_MSG_VERBOSE( "MUON isbad?: " << isbad );
438  return isbad;
439 }

◆ IsBJet()

bool ST::SUSYObjDef_xAOD::IsBJet ( const xAOD::Jet input) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 736 of file Jets.cxx.

736  {
737 
738  bool isbjet = bool(m_btagSelTool->accept(input));
739  dec_bjet(input) = isbjet;
740 
742  ANA_MSG_ERROR("Couldn't set b-tag decorations for jet, is-b = " << (isbjet?"true":"false") << ", pT = " << input.pt()/1000.);
743 
744  return isbjet;
745  }

◆ IsBJetContinuous()

int ST::SUSYObjDef_xAOD::IsBJetContinuous ( const xAOD::Jet input) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 758 of file Jets.cxx.

758  {
760  // Cheatsheet:
761  // returns 6 if between 65% and 0%
762  // returns 5 if between 70% and 65%
763  // returns 4 if between 77% and 70%
764  // returns 3 if between 85% and 77%
765  // returns 2 if between 90% and 85%
766  // returns 1 if between 100% and 90%
767  // returns 0 if smaller than -1e4-> should never happen
768  // return -1 if bigger than 1e4 or not in b-tagging acceptance
770 
771  int isbjet = m_btagSelTool->getQuantile(input);
772  dec_bjet(input) = isbjet;
773 
775  ANA_MSG_ERROR("Couldn't set continuous b-tag decorations for jet, is-b = " << isbjet << ", pT = " << input.pt()/1000.);
776 
777  return isbjet;
778  }

◆ IsBJetLoose()

bool ST::SUSYObjDef_xAOD::IsBJetLoose ( const xAOD::Jet input) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 645 of file Jets.cxx.

645  {
646  bool isbjet_loose = false;
647  if (m_orBJetPtUpperThres < 0 || m_orBJetPtUpperThres > input.pt())
648  isbjet_loose = bool(m_btagSelTool_OR->accept(input)); //note : b-tag applies only to jet with eta < 2.5
649  return isbjet_loose;
650  }

◆ IsCosmicMuon()

bool ST::SUSYObjDef_xAOD::IsCosmicMuon ( const xAOD::Muon input,
const float  z0cut,
const float  d0cut 
) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 441 of file Muons.cxx.

442 {
443  dec_cosmic(input) = false;
444 
445  const xAOD::TrackParticle* track(nullptr);
446  if (input.muonType() == xAOD::Muon::SiliconAssociatedForwardMuon) {
447  track = input.trackParticle(xAOD::Muon::CombinedTrackParticle);
448  if (!track){
449  ATH_MSG_VERBOSE("WARNING: SAF muon without CB track found. Not possible to check cosmic muon criteria");
450  return false; // don't treat SAF muons without CB track further
451  }
452  }
453  else {
454  track = input.primaryTrackParticle();
455  if (!track){
456  ATH_MSG_WARNING("Non-SAF muon without primary track particle found. Not possible to check cosmic muon criteria");
457  return false;
458  }
459  }
460 
461  double mu_d0 = track->d0();
462  const xAOD::Vertex* pv = this->GetPrimVtx();
463  double primvertex_z = pv ? pv->z() : 0;
464  double mu_z0_exPV = track->z0() + track->vz() - primvertex_z;
465 
466  bool isCosmicMuon = (std::abs(mu_z0_exPV) >= z0cut || std::abs(mu_d0) >= d0cut);
467 
468  if (isCosmicMuon) {
469  ATH_MSG_VERBOSE("COSMIC PV Z = " << primvertex_z << ", track z0 = " << mu_z0_exPV << ", track d0 = " << mu_d0);
470  }
471 
472  dec_cosmic(input) = isCosmicMuon;
473  return isCosmicMuon;
474 }

◆ isData()

bool ST::SUSYObjDef_xAOD::isData ( ) const
inlinefinaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 156 of file SUSYObjDef_xAOD.h.

156 {return m_dataSource == Data;}

◆ IsHighPtMuon()

bool ST::SUSYObjDef_xAOD::IsHighPtMuon ( const xAOD::Muon input) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 383 of file Muons.cxx.

387 {
388  if (input.pt() < 3e3){
389  ATH_MSG_DEBUG("No HighPt check supported for muons below 3GeV! False.");
390  dec_passedHighPtCuts(input) = false;
391  return false;
392  }
393 
394  bool isHighPt=false;
396  dec_passedHighPtCuts(input) = isHighPt;
397 
398  return isHighPt;
399 }

◆ IsMETTrigPassed() [1/2]

bool ST::SUSYObjDef_xAOD::IsMETTrigPassed ( const std::string &  triggerName,
bool  j400_OR = false 
) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 63 of file Trigger.cxx.

63  {
64  // NB - this now applies to the entire function...
65  //std::string L1item = "L1_XE50"; For now, I'll assume all the triggers use L1_XE50 - might need changing in the future.
66 
67  // First check if we're affected by the L1_XE50 bug
68  bool L1_XE50 = m_trigDecTool->isPassed("L1_XE50");
69  bool L1_XE55 = m_trigDecTool->isPassed("L1_XE55");
70  bool HLT_noalg_L1J400 = m_trigDecTool->isPassed("HLT_noalg_L1J400");
71  if (!L1_XE50 && j400_OR && HLT_noalg_L1J400) {
72  return emulateHLT(triggerName);
73  }
74  else if (L1_XE50 || L1_XE55) {
75  // See if the TDT knows about this
76  {
77  std::scoped_lock lock (m_triggerCacheMutex);
78  if (isTrigInTDT(lock, triggerName) ) return m_trigDecTool->isPassed(triggerName);
79  }
80  return emulateHLT(triggerName);
81  }
82  return false;
83 }

◆ IsMETTrigPassed() [2/2]

bool ST::SUSYObjDef_xAOD::IsMETTrigPassed ( unsigned int  runnumber = 0,
bool  j400_OR = false 
) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 30 of file Trigger.cxx.

30  {
31 
32  // Returns MET trigger decision for recommended lowest unprescaled evolution described in
33  // https://twiki.cern.ch/twiki/bin/viewauth/Atlas/LowestUnprescaled
34  // For period vs run number, see https://atlas-tagservices.cern.ch/tagservices/RunBrowser/runBrowserReport/rBR_Period_Report.php
35 
36  // if no runNumber specified, just read it from the current event
37  unsigned int rn;
38  if(runnumber>0){
39  rn = runnumber;
40  }
41  else{
42  rn = GetRunNumber(); // it takes care of dealing with data and MC
43  }
44 
45  int year = treatAsYear(rn);
46 
47  if (year == 2015) return IsMETTrigPassed("HLT_xe70_mht",j400_OR); //2015
48  else if(year == 2016 && rn >= 296939 && rn <= 302872 ) return IsMETTrigPassed("HLT_xe90_mht_L1XE50",j400_OR); //2016 A-D3
49  else if(year == 2016 && rn >= 302919 && rn <= 303892 ) return IsMETTrigPassed("HLT_xe100_mht_L1XE50",j400_OR); //2016 D4-F1
50  else if(year == 2016 && rn >= 303943) return IsMETTrigPassed("HLT_xe110_mht_L1XE50",j400_OR); //2016 F2-(open)
51  else if(year == 2017 && rn >= 325713 && rn <= 331975 ) return IsMETTrigPassed("HLT_xe110_pufit_L1XE55", false); // 2017 B1-D5
52  else if(year == 2017 && rn >= 332303 ) return IsMETTrigPassed("HLT_xe110_pufit_L1XE50", false); // 2017 D6-(open)
53  else if(year == 2018 && rn >= 348885 && rn <= 350013 ) return IsMETTrigPassed("HLT_xe110_pufit_xe70_L1XE50", false); // 2018 B-C5
54  else if(year == 2018 && rn >= 350067 ) return IsMETTrigPassed("HLT_xe110_pufit_xe65_L1XE50", false); // 2018 C5-(open)
55  else if(year == 2022) return IsMETTrigPassed("HLT_xe65_cell_xe90_pfopufit_L1XE50",false); // 2022
56  else if(year == 2023) return IsMETTrigPassed("HLT_xe65_cell_xe90_pfopufit_L1XE50",false); // 2023
57  else if(year == 2024) return IsMETTrigPassed("HLT_xe65_cell_xe105_nn_L1jXE100",false); // 2024
58 
59  return false;
60 }

◆ isNominal()

bool ST::SUSYObjDef_xAOD::isNominal ( const CP::SystematicSet syst) const

Definition at line 2081 of file SUSYObjDef_xAOD.cxx.

2081  {
2082  return syst.name().empty();
2083 }

◆ IsPFlowCrackVetoCleaning()

bool ST::SUSYObjDef_xAOD::IsPFlowCrackVetoCleaning ( const xAOD::ElectronContainer elec = nullptr,
const xAOD::PhotonContainer gamma = nullptr 
) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 261 of file MET.cxx.

262  {
263 
265  return true;
266  }
267 
268  bool passPFlowCVCleaning = true;
269 
270  if (elec) {
271  for (const xAOD::Electron* el : *elec) {
272  if (acc_passCrackVetoCleaning.isAvailable(*el)) {
273  if (!acc_passCrackVetoCleaning(*el)) {
274  passPFlowCVCleaning = false;
275  break;
276  }
277  } else {
278  ATH_MSG_WARNING("DFCommonCrackVetoCleaning variable is not available! Use p3830 onwards for PFlow jets!");
279  }
280  }
281  }
282 
283  if (passPFlowCVCleaning && gamma) {
284  for (const xAOD::Photon* ph : *gamma) {
285  if (acc_passCrackVetoCleaning.isAvailable(*ph)) {
286  if (!acc_passCrackVetoCleaning(*ph)) {
287  passPFlowCVCleaning = false;
288  break;
289  }
290  } else {
291  ATH_MSG_WARNING("DFCommonCrackVetoCleaning variable is not available! Use p3830 onwards for PFlow jets!");
292  }
293  }
294  }
295 
296  return passPFlowCVCleaning;
297 }

◆ isPrompt()

bool ST::SUSYObjDef_xAOD::isPrompt ( const xAOD::IParticle part) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 23 of file Truth.cxx.

23  {
24 
25  const int type = acc_truthType(*part);
26  int origin = acc_truthOrigin(*part);
27  int originbkg = 0;
28  if(acc_bkgTruthOrigin.isAvailable(*part)){ //only in SUSY2,3,5 for the moment!
29  originbkg = acc_bkgTruthOrigin(*part);
30  }
31  else{
32  ATH_MSG_DEBUG("::isPrompt() : No bkgTruthOrigin decoration available. Returning false by default.");
33  return false;
34  }
35 
36  //Electrons
37  if( part->type() == xAOD::Type::Electron ){
38  switch(type){
40  if(origin != MCTruthPartClassifier::PhotonConv) return false;
41  if(originbkg == MCTruthPartClassifier::FSRPhot || originbkg == MCTruthPartClassifier::BremPhot) return true;
42  origin = originbkg;
43  /* FALLTHRU */
44  case MCTruthPartClassifier::IsoElectron:
45  return (origin == MCTruthPartClassifier::top
48  || origin == MCTruthPartClassifier::Higgs
53  || origin == MCTruthPartClassifier::NuRMu
55  || origin == MCTruthPartClassifier::LQ
56  || origin == MCTruthPartClassifier::SUSY);
57  default:
58  return false;
59  }
60  // NB: will classify a few muon/quark brems as prompt electrons, but a small effect
61  }
62  if( part->type() == xAOD::Type::Muon ){
64  }
65  else{
66  ATH_MSG_DEBUG("::isPrompt() : Only Electrons supported at the moment!");
67  }
68 
69  //Photons ... ?
70  //Taus ... ?
71  return false;
72 }

◆ IsSignalElectron()

bool ST::SUSYObjDef_xAOD::IsSignalElectron ( const xAOD::Electron input,
const float  etcut,
const float  d0sigcut,
const float  z0cut,
const float  etacut = DUMMYDEF 
) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 360 of file Electrons.cxx.

361 {
362  if (!acc_baseline(input)) return false;
363 
364  dec_passSignalID(input) = false;
365 
366  if (m_eleIdExpert) {
367  if ( !m_elecSelLikelihood.empty() && m_elecSelLikelihood->accept(&input) ) dec_passSignalID(input) = true;
368  }
369  else {
371  dec_passSignalID(input) = m_acc_eleId(input);
372  } else {
373  ATH_MSG_VERBOSE ("DFCommonElectronsLHxxx variables are not found. Calculating the ID from LH tool..");
374  if ( !m_elecSelLikelihood.empty() && m_elecSelLikelihood->accept(&input) ) dec_passSignalID(input) = true;
375  }
376  }
377 
378  //overwrite ID selection if forced by user
379  if(m_force_noElId) dec_passSignalID(input) = true;
380 
381  if (!acc_passSignalID(input)) return false;
382 
383  if (input.p4().Perp2() <= etcut * etcut || input.p4().Perp2() == 0) return false; // eT cut (might be necessary for leading electron to pass trigger)
384  if ( etacut==DUMMYDEF ){
385  if(std::abs(input.caloCluster()->etaBE(2)) > m_eleEta ) return false;
386  }
387  else if ( std::abs(input.caloCluster()->etaBE(2)) > etacut ) return false;
388 
389  if (m_eleCrackVeto){
390  if ( std::abs( input.caloCluster()->etaBE(2) ) >1.37 && std::abs( input.caloCluster()->etaBE(2) ) <1.52) {
391  return false;
392  }
393  }
394 
395  if (acc_d0sig(input) != 0) {
396  if (d0sigcut > 0.0 && std::abs(acc_d0sig(input)) > d0sigcut) return false; // transverse IP cut
397  }
398 
399  if (z0cut > 0.0 && std::abs(acc_z0sinTheta(input)) > z0cut) return false; // longitudinal IP cut
400 
401 
402  ATH_MSG_VERBOSE( "IsSignalElectron: " << m_eleId << " " << acc_passSignalID(input) << " d0sig " << acc_d0sig(input) << " z0 sin(theta) " << acc_z0sinTheta(input) );
403 
404  if (m_doElIsoSignal) {
405  if ( !( (acc_isol(input) && input.pt()<m_eleIsoHighPtThresh) || (acc_isolHighPt(input) && input.pt()>m_eleIsoHighPtThresh)) ) return false;
406  ATH_MSG_VERBOSE( "IsSignalElectron: passed isolation" );
407  }
408 
409  if(m_eleChID_signal && !acc_passChID(input)) return false; //add charge flip check to signal definition
410 
411  dec_signal(input) = true;
412 
413  ATH_MSG_VERBOSE( "IsSignalElectron: passed selection" );
414  return true;
415 }

◆ IsSignalJet()

bool ST::SUSYObjDef_xAOD::IsSignalJet ( const xAOD::Jet input,
const float  ptcut,
const float  etacut 
) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 658 of file Jets.cxx.

658  {
659  if ( !acc_baseline(input) || !acc_passOR(input) ) return false;
660 
661  if ( input.pt() <= ptcut || std::abs(input.eta()) >= etacut) return false;
662 
663  bool isgoodjet = !acc_bad(input) && acc_passJvt(input);
664 
665  dec_signal(input) = isgoodjet;
666 
667  // For JVT calculation
668  dec_signal_less_JVT(input) = !acc_bad(input);
669 
670 
671  if (m_debug) {
672  float emfrac, hecf, LArQuality, HECQuality, Timing, fracSamplingMax, NegativeE, AverageLArQF;
673  std::vector<float> sumpttrk_vec;
674 
675  input.getAttribute(xAOD::JetAttribute::EMFrac, emfrac);
676  input.getAttribute(xAOD::JetAttribute::HECFrac, hecf);
677  input.getAttribute(xAOD::JetAttribute::LArQuality, LArQuality);
678  input.getAttribute(xAOD::JetAttribute::HECQuality, HECQuality);
679  input.getAttribute(xAOD::JetAttribute::Timing, Timing);
680  input.getAttribute(xAOD::JetAttribute::SumPtTrkPt500, sumpttrk_vec);
681  input.getAttribute(xAOD::JetAttribute::FracSamplingMax, fracSamplingMax);
682  input.getAttribute(xAOD::JetAttribute::NegativeE, NegativeE);
683  input.getAttribute(xAOD::JetAttribute::AverageLArQF, AverageLArQF);
684 
685  float sumpttrk;
686  if (!sumpttrk_vec.empty() && this->GetPrimVtx()) {
687  sumpttrk = sumpttrk_vec[this->GetPrimVtx()->index()];
688  } else {
689  sumpttrk = 0.;
690  }
691 
692  ATH_MSG_INFO( "JET pt: " << input.pt() );
693  ATH_MSG_INFO( "JET eta: " << input.eta() );
694  ATH_MSG_INFO( "JET emfrac: " << emfrac );
695  ATH_MSG_INFO( "JET hecfrac: " << hecf );
696  ATH_MSG_INFO( "JET LArQuality: " << LArQuality );
697  ATH_MSG_INFO( "JET HECQuality: " << HECQuality );
698  ATH_MSG_INFO( "JET Timing: " << Timing );
699  ATH_MSG_INFO( "JET sumpttrk: " << sumpttrk );
700  ATH_MSG_INFO( "JET fracSamplingMax: " << fracSamplingMax );
701  ATH_MSG_INFO( "JET AverageLArQF: " << AverageLArQF );
702  }
703 
704  ATH_MSG_VERBOSE( "JET isbad?: " << static_cast<int>(acc_bad(input)));
705 
706  return isgoodjet;
707  }

◆ IsSignalMuon()

bool ST::SUSYObjDef_xAOD::IsSignalMuon ( const xAOD::Muon input,
const float  ptcut,
const float  d0sigcut,
const float  z0cut,
const float  etacut = DUMMYDEF 
) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 341 of file Muons.cxx.

342 {
343  if (!acc_baseline(input)) return false;
344  if (!acc_passSignalID(input)) return false;
345 
346  if (input.pt() <= ptcut || input.pt() == 0) return false; // pT cut (might be necessary for leading muon to pass trigger)
347  if ( etacut==DUMMYDEF ){
348  if(std::abs(input.eta()) > m_muEta ) return false;
349  }
350  else if ( std::abs(input.eta()) > etacut ) return false;
351 
352  if (z0cut > 0.0 && std::abs(acc_z0sinTheta(input)) > z0cut) return false; // longitudinal IP cut
353  if (acc_d0sig(input) != 0) {
354  if (d0sigcut > 0.0 && std::abs(acc_d0sig(input)) > d0sigcut) return false; // transverse IP cut
355  }
356 
357  if (m_doMuIsoSignal) {
358  if ( !( (acc_isol(input) && input.pt()<m_muIsoHighPtThresh) || (acc_isolHighPt(input) && input.pt()>m_muIsoHighPtThresh)) ) return false;
359  ATH_MSG_VERBOSE( "IsSignalMuon: passed isolation");
360  }
361 
362  //set HighPtMuon decoration
364 
365  dec_signal(input) = true;
366 
367  if (m_muId == 4) { //i.e. HighPt muons
368  ATH_MSG_VERBOSE( "IsSignalMuon: mu pt " << input.pt()
369  << " signal? " << static_cast<int>(acc_signal(input))
370  << " isolation? " << static_cast<int>(acc_isol(input))
371  << " passedHighPtCuts? " << static_cast<int>(acc_passedHighPtCuts(input)));
372  } else {
373  ATH_MSG_VERBOSE( "IsSignalMuon: mu pt " << input.pt()
374  << " signal? " << static_cast<int>( acc_signal(input))
375  << " isolation? " << static_cast<int>( acc_isol(input)));
376  // Don't show HighPtFlag ... we didn't set it!
377  }
378 
379  return acc_signal(input);
380 }

◆ IsSignalPhoton()

bool ST::SUSYObjDef_xAOD::IsSignalPhoton ( const xAOD::Photon input,
const float  ptcut,
const float  etacut = DUMMYDEF 
) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 164 of file Photons.cxx.

165 {
166  dec_signal(input) = false;
167 
168  if ( !acc_baseline(input) ) return false;
169 
170  if ( !m_egammaAmbiguityTool->accept(input) ) return false;
171 
172  if ( input.pt() < ptcut ) return false;
173  if ( etacut==DUMMYDEF ){
174  if(std::abs(input.caloCluster()->etaBE(2)) > m_photonEta ) return false;
175  }
176  else if ( std::abs(input.caloCluster()->etaBE(2)) > etacut ) return false;
177 
178  if (m_photonCrackVeto){
179  if ( std::abs( input.caloCluster()->etaBE(2) ) >1.37 && std::abs( input.caloCluster()->etaBE(2) ) <1.52) {
180  return false;
181  }
182  }
183 
184  if (acc_isol(input) || !m_doPhIsoSignal) {
185  ATH_MSG_VERBOSE( "IsSignalPhoton: passed isolation");
186  } else return false;
187 
188  bool passID = false;
190  passID = m_acc_photonId(input);
191  } else {
192  ATH_MSG_VERBOSE ("DFCommonPhotonsIsEMxxx variables are not found. Calculating the ID from Photon ID tool..");
193  passID = bool(m_photonSelIsEM->accept(&input));
194  }
195  if ( !passID ) return false;
196 
197  dec_signal(input) = true;
198 
199  return true;
200 }

◆ IsSignalTau()

bool ST::SUSYObjDef_xAOD::IsSignalTau ( const xAOD::TauJet input,
const float  ptcut,
const float  etacut 
) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 111 of file Taus.cxx.

111  {
112 
113  dec_signal(input) = false;
114 
115  if ( !acc_baseline(input) ) return false;
116 
117  if (input.pt() <= ptcut) return false;
118 
119  if (std::abs(input.eta()) >= etacut) return false;
120 
121  if (!m_tauSelTool->accept( input )) return false;
122 
123  dec_signal(input) = true;
124 
125  return true;
126 }

◆ IsTrackBJet()

bool ST::SUSYObjDef_xAOD::IsTrackBJet ( const xAOD::Jet input) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 747 of file Jets.cxx.

747  {
748 
749  bool isbjet = bool(m_btagSelTool_trkJet->accept(input));
750  dec_bjet(input) = isbjet;
751 
753  ANA_MSG_ERROR("Couldn't set b-tag decorations for trackjet, is-b = " << (isbjet?"true":"false") << ", pT = " << input.pt()/1000.);
754 
755  return isbjet;
756  }

◆ IsTrackBJetContinuous()

int ST::SUSYObjDef_xAOD::IsTrackBJetContinuous ( const xAOD::Jet input) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 780 of file Jets.cxx.

780  {
781 
782  int isbjet = m_btagSelTool_trkJet->getQuantile(input);
783  dec_bjet(input) = isbjet;
784 
786  ANA_MSG_ERROR("Couldn't set continuous b-tag decorations for trackjet, is-b = " << isbjet << ", pT = " << input.pt()/1000.);
787 
788  return isbjet;
789  }

◆ isTrigInTDT()

bool ST::SUSYObjDef_xAOD::isTrigInTDT ( std::scoped_lock< std::mutex > &  lock,
const std::string &  triggerName 
) const
private

Definition at line 85 of file Trigger.cxx.

87 {
88  auto mapItr = m_checkedTriggers.find(triggerName);
89  if ( mapItr == m_checkedTriggers.end() ) {
90  const auto *cg = m_trigDecTool->getChainGroup(triggerName);
91  return m_checkedTriggers[triggerName] = cg->getListOfTriggers().size() != 0;
92  }
93  else {
94  return mapItr->second;
95  }
96 }

◆ IsTrigMatched() [1/4]

bool ST::SUSYObjDef_xAOD::IsTrigMatched ( const std::initializer_list< const xAOD::IParticle * > &  v,
const std::string &  tr_item 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 235 of file Trigger.cxx.

235  {
236  return m_trigMatchingTool->match(v, tr_item);
237 }

◆ IsTrigMatched() [2/4]

bool ST::SUSYObjDef_xAOD::IsTrigMatched ( const std::vector< const xAOD::IParticle * > &  v,
const std::string &  tr_item 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 230 of file Trigger.cxx.

230  {
231  return m_trigMatchingTool->match(v, tr_item);
232 }

◆ IsTrigMatched() [3/4]

bool ST::SUSYObjDef_xAOD::IsTrigMatched ( const xAOD::IParticle part,
const std::string &  tr_item 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 220 of file Trigger.cxx.

220  {
221  return this->IsTrigMatched({part}, tr_item);
222 }

◆ IsTrigMatched() [4/4]

bool ST::SUSYObjDef_xAOD::IsTrigMatched ( const xAOD::IParticle part1,
const xAOD::IParticle part2,
const std::string &  tr_item 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 225 of file Trigger.cxx.

225  {
226  return this->IsTrigMatched({part1, part2}, tr_item);
227 }

◆ IsTrigPassed()

bool ST::SUSYObjDef_xAOD::IsTrigPassed ( const std::string &  tr_item,
unsigned int  condition = TrigDefs::Physics 
) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 215 of file Trigger.cxx.

215  {
216  return m_trigDecTool->isPassed(tr_item, condition);
217 }

◆ IsTruthBJet()

bool ST::SUSYObjDef_xAOD::IsTruthBJet ( const xAOD::Jet input) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 309 of file Truth.cxx.

309  {
310  //Method to set correctly the IsBjet decoration needed by the JetUncertainties tool
311  bool isBjet = false;
312  if (acc_signal(input)) {
313 
314  int truthlabel(-1);
315  if (!input.getAttribute("HadronConeExclTruthLabelID", truthlabel)) {
316  ATH_MSG_ERROR("Failed to get jet truth label!");
317  }
318 
319  isBjet = std::abs(truthlabel) == 5;
320  }
321 
322  const static SG::Decorator<char> dec_bjet_jetunc("bjet_jetunc"); //added for JetUncertainties usage
323  dec_bjet_jetunc(input) = isBjet;
324 
325  return isBjet;
326 }

◆ isVariation()

bool ST::SUSYObjDef_xAOD::isVariation ( const CP::SystematicSet syst) const

Definition at line 2096 of file SUSYObjDef_xAOD.cxx.

2096  {
2097  // returns true if _any_ of the systematics affect kinematics. ignores effect on weights.
2098  for (const auto& sys : systSet) {
2099  auto info = getSystInfo(sys);
2100  if(info.affectsKinematics) { return true; }
2101  }
2102  return false;
2103 }

◆ isWeight()

bool ST::SUSYObjDef_xAOD::isWeight ( const CP::SystematicSet systSet) const

Definition at line 2085 of file SUSYObjDef_xAOD.cxx.

2085  {
2086  // returns true if all systematics do _not_ affect kinematics and _any_ of them affects the weight
2087  bool affectsWeights = false;
2088  for (const auto& sys : systSet) {
2089  auto info = getSystInfo(sys);
2090  if(info.affectsKinematics) { return false; }
2091  affectsWeights = affectsWeights or info.affectsWeights;
2092  }
2093  return affectsWeights;
2094 }

◆ JetPassJVT()

bool ST::SUSYObjDef_xAOD::JetPassJVT ( xAOD::Jet input)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 652 of file Jets.cxx.

652  {
653  char pass_jvt = !m_applyJVTCut || m_jetNNJvtSelectionTool->accept(&input);
654  dec_passJvt(input) = pass_jvt;
655  return pass_jvt;
656  }

◆ JVT_SF()

double ST::SUSYObjDef_xAOD::JVT_SF ( const xAOD::JetContainer jets)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 953 of file Jets.cxx.

953  {
954 
955  float totalSF = 1.;
956  if (!m_applyJVTCut) return totalSF;
957 
959  for (const xAOD::Jet* jet : *jets) {
960  // Only jets that were good for every cut except JVT
961  if (acc_signal_less_JVT(*jet) && acc_passOR(*jet)) {
962  jvtjets.push_back(jet);
963  }
964  }
965 
966  for (const xAOD::Jet* jet : jvtjets) {
967  float current_sf = 0;
968 
969  // the SF are only applied for HS jets and implicitely requires the presence of the isHS decoration
971  if (acc_passJvt(*jet)) {
973  }
974  else {
976  }
977 
978  switch (result) {
980  // this is probably not right, should report an error here
981  ATH_MSG_ERROR("Inexplicably failed JVT calibration" );
982  break;
984  // no NNJvt SF for jet, that is ok e.g. for jets with |eta| > 2.5
985  ATH_MSG_VERBOSE( "Skip SF application in SUSYTools_xAOD::JVT_SF as jet outside validate range" );
986  break;
987  default:
988  ATH_MSG_VERBOSE( "Retrieve SF for jet in SUSYTools_xAOD::JVT_SF with value " << current_sf );
989  totalSF *= current_sf;
990  }
991 
992  }
993 
994  ATH_MSG_VERBOSE( "Retrieve total SF for jet container in SUSYTools_xAOD::JVT_SF with value " << totalSF );
995 
996  return totalSF;
997  }

◆ JVT_SFsys()

double ST::SUSYObjDef_xAOD::JVT_SFsys ( const xAOD::JetContainer jets,
const CP::SystematicSet systConfig 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 1000 of file Jets.cxx.

1000  {
1001 
1002  float totalSF = 1.;
1003  if (!m_applyJVTCut) return totalSF;
1004 
1005  //Set the new systematic variation
1007  if ( ret != StatusCode::SUCCESS) {
1008  ATH_MSG_ERROR("Cannot configure NNjvtEfficiencyTool for systematic var. " << systConfig.name() );
1009  }
1010 
1011  // Delegate
1012  totalSF = SUSYObjDef_xAOD::JVT_SF( jets );
1013 
1014  // }
1015  if (m_applyJVTCut) {
1017  if ( ret != StatusCode::SUCCESS) {
1018  ATH_MSG_ERROR("Cannot configure NNjvtEfficiencyTool for systematic var. " << systConfig.name() );
1019  }
1020  }
1021 
1022  return totalSF;
1023  }

◆ MergeElectrons()

StatusCode ST::SUSYObjDef_xAOD::MergeElectrons ( const xAOD::ElectronContainer electrons,
xAOD::ElectronContainer outputCol,
const std::set< const xAOD::Electron * > &  ElectronsToRemove 
) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 61 of file Electrons.cxx.

61  {
62 
63  if (electrons.empty()) return StatusCode::SUCCESS;
64  for (const xAOD::Electron* electron: electrons) {
65  if (ElectronsToRemove.find(electron) != ElectronsToRemove.end()){
66  ATH_MSG_DEBUG( "Removing electron from output collection (isLRT?) : ("<< static_cast<int>(acc_isLRT(*electron)) << ")" );
67  ATH_MSG_DEBUG( "ELECTRON cl eta: " << electron->caloCluster()->eta());
68  ATH_MSG_DEBUG( "ELECTRON cl phi: " << electron->caloCluster()->phi());
69  continue;
70  // add electron into output
71  } else {
72  ATH_MSG_DEBUG( "Adding electron to output collection (isLRT?) : (" << static_cast<int>(acc_isLRT(*electron)) << ")" );
73  ATH_MSG_DEBUG( "ELECTRON cl eta: " << electron->caloCluster()->eta());
74  ATH_MSG_DEBUG( "ELECTRON cl phi: " << electron->caloCluster()->phi());
75  auto newElectron = new xAOD::Electron(*electron);
76 
77  if ( getOriginalObject(*electron) != nullptr ) {
79  } else {
80  setOriginalObjectLink(*electron, *newElectron);
81  }
82 
83  outputCol->push_back(newElectron);
84  }
85  }
86  return StatusCode::SUCCESS;
87 }

◆ MergeMuons()

StatusCode ST::SUSYObjDef_xAOD::MergeMuons ( const xAOD::MuonContainer muons,
const std::vector< bool > &  writeMuon,
xAOD::MuonContainer outputCol 
) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 55 of file Muons.cxx.

55  {
56  if (muons.empty()) return StatusCode::SUCCESS;
57  for (const xAOD::Muon* muon: muons) {
58  // add muon into output
59  if (writeMuon.at(muon->index())){
60  auto newMuon = new xAOD::Muon(*muon);
61 
62  if ( getOriginalObject(*muon) != nullptr ) {
64  } else {
65  setOriginalObjectLink(*muon, *newMuon);
66  }
67  outputCol->push_back(newMuon);
68  }
69  }
70  return StatusCode::SUCCESS;
71 }

◆ metaDataStop()

StatusCode asg::AsgMetadataTool::metaDataStop ( )
protectedvirtualinherited

Function called when the tool should write out its metadata.

Dummy implementation that can be overridden by the derived tool.

Reimplemented in xAODMaker::FileMetaDataTool, BookkeeperTool, BookkeeperDumperTool, xAODMaker::TriggerMenuMetaDataTool, and xAODMaker::TruthMetaDataTool.

Definition at line 204 of file AsgMetadataTool.cxx.

204  {
205 
206  // Return gracefully:
207  return StatusCode::SUCCESS;
208  }

◆ msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msg_level_name()

const std::string & asg::AsgTool::msg_level_name ( ) const
inherited

A deprecated function for getting the message level's name.

Instead of using this, weirdly named function, user code should get the string name of the current minimum message level (in case they really need it...), with:

MSG::name( msg().level() )

This function's name doesn't follow the ATLAS coding rules, and as such will be removed in the not too distant future.

Returns
The string name of the current minimum message level that's printed

Definition at line 101 of file AsgTool.cxx.

101  {
102 
103  return MSG::name( msg().level() );
104  }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ NearbyLeptonCorrections()

StatusCode ST::SUSYObjDef_xAOD::NearbyLeptonCorrections ( xAOD::ElectronContainer electrons = nullptr,
xAOD::MuonContainer muons = nullptr 
) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2928 of file SUSYObjDef_xAOD.cxx.

2928  {
2929  // This getCloseByIsoCorrection is computationally less expensive and actually corrects the isoaltion
2930  // variables from the contribution of the close by leptons
2931  if (m_isoCloseByTool->getCloseByIsoCorrection(Gaudi::Hive::currentContext(), electrons,muons) != CP::CorrectionCode::Ok) {
2932  return StatusCode::FAILURE;
2933  }
2934  // All done, all good :-)
2935  return StatusCode::SUCCESS;
2936 }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ outputMetaStore()

AsgMetadataTool::MetaStorePtr_t asg::AsgMetadataTool::outputMetaStore ( ) const
inherited

Accessor for the output metadata store.

Definition at line 97 of file AsgMetadataTool.cxx.

97  {
98 
99 #ifdef XAOD_STANDALONE
100  return &m_outputMetaStore;
101 #else // XAOD_STANDALONE
102  return m_outputMetaStore;
103 #endif // XAOD_STANDALONE
104  }

◆ OverlapRemoval()

StatusCode ST::SUSYObjDef_xAOD::OverlapRemoval ( const xAOD::ElectronContainer electrons,
const xAOD::MuonContainer muons,
const xAOD::JetContainer jets,
const xAOD::PhotonContainer gamma = nullptr,
const xAOD::TauJetContainer taujet = nullptr,
const xAOD::JetContainer fatjets = nullptr 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2893 of file SUSYObjDef_xAOD.cxx.

2896 {
2897 
2898  if (this->GetPrimVtx() == nullptr) {
2899  ATH_MSG_WARNING( "Will now call the OR tool on an event without a primary vertex, and it will likely crash. Please require a PV earlier in your analysis code!");
2900  }
2901 
2902  ATH_CHECK( m_orToolbox.masterTool->removeOverlaps(electrons, muons, jets, taujet, gamma, fatjets) );
2903 
2904  /*
2905  // Count number of objects after overlap removal
2906  int Nel = 0;
2907  for (const auto& el : *electrons) {
2908  if (dec_passOR( *el )) Nel++;
2909  }
2910 
2911  int Nmu = 0;
2912  for (const auto& mu : *muons) {
2913  if (dec_passOR( *mu )) Nmu++;
2914  }
2915 
2916  int Njet = 0;
2917  for (const auto& jet : *jets) {
2918  if (dec_passOR( *jet )) Njet++;
2919  }
2920 
2921  ATH_MSG_VERBOSE( "After overlap removal: Nel=" << Nel << ", Nmu=" << Nmu << ", Njet=" << Njet );
2922  */
2923 
2924  return StatusCode::SUCCESS;
2925 }

◆ prepareLRTElectrons()

StatusCode ST::SUSYObjDef_xAOD::prepareLRTElectrons ( const xAOD::ElectronContainer inMuons,
xAOD::ElectronContainer copy 
) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 90 of file Electrons.cxx.

90  {
91  for (const xAOD::Electron *electron: *inElectrons){
92  const xAOD::TrackParticle* idtrack = electron->trackParticle();
93 
94  // Save electron if the id track passes the LRT filter
95  if ( acc_lrtFilter.isAvailable(*idtrack) )
96  {
97  if ( static_cast<int>(acc_lrtFilter(*idtrack) ) ){
98  std::unique_ptr<xAOD::Electron> copyElectron = std::make_unique<xAOD::Electron>(*electron);
99 
100  // transfer original electron link
101 
102  setOriginalObjectLink(*electron, *copyElectron);
103  copy->push_back( std::move(copyElectron) );
104  }
105  }
106  else // Keep electron if flag is not available
107  {
108  std::unique_ptr<xAOD::Electron> copyElectron = std::make_unique<xAOD::Electron>(*electron);
109 
110  setOriginalObjectLink(*electron, *copyElectron);
111  copy->push_back( std::move(copyElectron) );
112  }
113  }
114  return StatusCode::SUCCESS;
115 }

◆ prepareLRTMuons()

StatusCode ST::SUSYObjDef_xAOD::prepareLRTMuons ( const xAOD::MuonContainer inMuons,
xAOD::MuonContainer copy 
) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 73 of file Muons.cxx.

73  {
74  for (const xAOD::Muon *muon: *inMuons){
75  const xAOD::TrackParticle* idtrack = muon->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
76 
77  // Save muon if the id track passes the LRT filter
78  if ( acc_lrtFilter.isAvailable(*idtrack) )
79  {
80  if ( static_cast<int>(acc_lrtFilter(*idtrack) ) ){
81  std::unique_ptr<xAOD::Muon> copyMuon = std::make_unique<xAOD::Muon>(*muon);
82 
83  // transfer original muon link
84  setOriginalObjectLink(*muon, *copyMuon);
85  copy->push_back( std::move(copyMuon) );
86  }
87  }
88  else // Keep muon if flag is not available
89  {
90  std::unique_ptr<xAOD::Muon> copyMuon = std::make_unique<xAOD::Muon>(*muon);
91 
92  setOriginalObjectLink(*muon, *copyMuon);
93  copy->push_back( std::move(copyMuon) );
94  }
95 
96  }
97  return StatusCode::SUCCESS;
98 }

◆ print() [1/2]

void asg::AsgTool::print ( ) const
virtualinherited

◆ print() [2/2]

virtual void asg::IAsgTool::print ( ) const
pure virtualinherited

◆ readConfig()

StatusCode ST::SUSYObjDef_xAOD::readConfig ( )
finaloverrideprotectedvirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 1322 of file SUSYObjDef_xAOD.cxx.

1323 {
1324  ATH_MSG_INFO( "***** ***** ***** *****" );
1325  ATH_MSG_INFO( "Configuring from file " << m_configFile );
1326 
1327  TEnv rEnv;
1328  int success = -1;
1329  success = rEnv.ReadFile(m_configFile.c_str(), kEnvAll);
1330  if (success != 0) return StatusCode::FAILURE;
1331 
1332  ATH_MSG_INFO( "Config file opened" );
1333 
1335  m_jetInputType = xAOD::JetInput::Type(rEnv.GetValue("Jet.InputType", 9));
1336  ATH_MSG_INFO( "readConfig(): Loaded property Jet.InputType with value " << static_cast<int>(m_jetInputType));
1337  }
1338  // Remove the item from the table
1339  rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject("Jet.InputType") );
1340 
1341  if (m_muId == static_cast<int>(xAOD::Muon::Quality(xAOD::Muon::VeryLoose))) {
1342  int muIdTmp = rEnv.GetValue("Muon.Id", 1);
1343  m_muId = (muIdTmp<4 ? static_cast<int>(xAOD::Muon::Quality(muIdTmp)) : muIdTmp);
1344  ATH_MSG_INFO( "readConfig(): Loaded property Muon.Id with value " << m_muId);
1345  // Remove the item from the table
1346  rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject("Muon.Id") );
1347  }
1348  if (m_muIdBaseline == static_cast<int>(xAOD::Muon::Quality(xAOD::Muon::VeryLoose))) {
1349  int muIdTmp = rEnv.GetValue("MuonBaseline.Id", 1);
1350  m_muIdBaseline = (muIdTmp<4 ? static_cast<int>(xAOD::Muon::Quality(muIdTmp)) : muIdTmp);
1351  ATH_MSG_INFO( "readConfig(): Loaded property MuonBaseline.Id with value " << m_muIdBaseline);
1352  // Remove the item from the table
1353  rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject("MuonBaseline.Id") );
1354  }
1355 
1356  // Deprecation warning
1357  std::string prop = rEnv.GetValue("Jet.JVT_WP", "");
1358  if ( !prop.empty() ) {
1359  ATH_MSG_WARNING("readConfig(): Found deprecated property name Jet.JVT_WP. Please move to using Jet.JvtWP. Propagating for now.");
1360  rEnv.SetValue("Jet.JvtWP", prop.c_str());
1361  rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject("Jet.JVT_WP") );
1362  }
1363 
1364  //load config file to Properties map (only booleans for now)
1365  m_conf_to_prop["IsRun3"] = "IsRun3";
1366  m_conf_to_prop["StrictConfigCheck"] = "StrictConfigCheck";
1367  m_conf_to_prop["Btag.enable"] = "UseBtagging";
1368  m_conf_to_prop["BtagTrkJet.enable"] = "UseBtaggingTrkJet";
1369  m_conf_to_prop["Ele.CrackVeto"] = "EleCrackVeto";
1370  m_conf_to_prop["EleBaseline.CrackVeto"] = "EleBaselineCrackVeto";
1371  m_conf_to_prop["Ele.ForceNoId"] = "EleForceNoId";
1372  m_conf_to_prop["Ele.AllowRun3TrigSFFallback"] = "EleAllowRun3TrigSFFallback";
1373  m_conf_to_prop["Muon.ForceNoId"] = "MuonForceNoId";
1374  m_conf_to_prop["Muon.TTVASF"] = "MuonTTVASF";
1375  m_conf_to_prop["Muon.passedHighPt"] = "MuonRequireHighPtCuts";
1376  m_conf_to_prop["PhotonBaseline.CrackVeto"] = "PhotonBaselineCrackVeto";
1377  m_conf_to_prop["Photon.CrackVeto"] = "PhotonCrackVeto";
1378  m_conf_to_prop["Photon.AllowLate"] = "PhotonAllowLate";
1379 
1380  m_conf_to_prop["FwdJet.doJVT"] = "FwdJetDoJVT";
1381 
1382  m_conf_to_prop["OR.DoBoostedElectron"] = "DoBoostedElectronOR";
1383  m_conf_to_prop["OR.DoBoostedMuon"] = "DoBoostedMuonOR";
1384  m_conf_to_prop["OR.DoMuonJetGhostAssociation"] = "ORDoMuonJetGhostAssociation";
1385  m_conf_to_prop["OR.DoTau"] = "DoTauOR";
1386  m_conf_to_prop["OR.DoPhoton"] = "DoPhotonOR";
1387  m_conf_to_prop["OR.DoEleJet"] = "DoEleJetOR";
1388  m_conf_to_prop["OR.DoElEl"] = "DoElElOR";
1389  m_conf_to_prop["OR.DoElMu"] = "DoElMuOR";
1390  m_conf_to_prop["OR.DoMuonJet"] = "DoMuonJetOR";
1391  m_conf_to_prop["OR.Bjet"] = "DoBjetOR";
1392  m_conf_to_prop["OR.ElBjet"] = "DoElBjetOR";
1393  m_conf_to_prop["OR.MuBjet"] = "DoMuBjetOR";
1394  m_conf_to_prop["OR.TauBjet"] = "DoTauBjetOR";
1395  m_conf_to_prop["OR.DoFatJets"] = "DoFatJetOR";
1396  m_conf_to_prop["OR.RemoveCaloMuons"] = "ORRemoveCaloMuons";
1397  m_conf_to_prop["OR.MuJetApplyRelPt"] = "ORMuJetApplyRelPt";
1398  m_conf_to_prop["OR.InputLabel"] = "ORInputLabel";
1399  m_conf_to_prop["Trigger.UpstreamMatching"] = "TriggerUpstreamMatching";
1400 
1401  m_conf_to_prop["SigLep.RequireIso"] = "SigLepRequireIso";
1402  m_conf_to_prop["SigEl.RequireIso"] = "SigElRequireIso";
1403  m_conf_to_prop["SigMu.RequireIso"] = "SigMuRequireIso";
1404  m_conf_to_prop["SigPh.RequireIso"] = "SigPhRequireIso";
1405  m_conf_to_prop["SigLepPh.IsoCloseByOR"] = "SigLepPhIsoCloseByOR";
1406  m_conf_to_prop["MET.RemoveOverlappingCaloTaggedMuons"] = "METRemoveORCaloTaggedMuons";
1407  m_conf_to_prop["MET.DoSetMuonJetEMScale"] = "METDoSetMuonJetEMScale";
1408  m_conf_to_prop["MET.DoRemoveMuonJets"] = "METDoRemoveMuonJets";
1409  m_conf_to_prop["MET.DoUseGhostMuons"] = "METUseGhostMuons";
1410  m_conf_to_prop["MET.DoMuonEloss"] = "METDoMuonEloss";
1411 
1412  m_conf_to_prop["MET.DoTrkSyst"] = "METDoTrkSyst";
1413  m_conf_to_prop["MET.DoCaloSyst"] = "METDoCaloSyst";
1414 
1415  m_conf_to_prop["Tau.DoTruthMatching"] = "TauDoTruthMatching";
1416  //
1417 
1418  configFromFile(m_slices["ele"], "Slices.Ele", rEnv, true);
1419  configFromFile(m_slices["pho"], "Slices.Pho", rEnv, true);
1420  configFromFile(m_slices["mu"], "Slices.Mu", rEnv, true);
1421  configFromFile(m_slices["tau"], "Slices.Tau", rEnv, true);
1422  configFromFile(m_slices["jet"], "Slices.Jet", rEnv, true);
1423  configFromFile(m_slices["bjet"], "Slices.BJet", rEnv, true);
1424  configFromFile(m_slices["fjet"], "Slices.FJet", rEnv, true);
1425  configFromFile(m_slices["tjet"], "Slices.TJet", rEnv, true);
1426  configFromFile(m_slices["met"], "Slices.MET", rEnv, true);
1427  //
1428  configFromFile(m_isRun3, "IsRun3", rEnv, false);
1429  //
1430  configFromFile(m_eleBaselinePt, "EleBaseline.Pt", rEnv, 10000.);
1431  configFromFile(m_eleBaselineEta, "EleBaseline.Eta", rEnv, 2.47);
1432  configFromFile(m_eleIdBaseline, "EleBaseline.Id", rEnv, "LooseAndBLayerLLH");
1433  configFromFile(m_eleBaselineIso_WP, "EleBaseline.Iso", rEnv, "None");
1434  configFromFile(m_eleConfigBaseline, "EleBaseline.Config", rEnv, "None");
1435  configFromFile(m_eleBaselineCrackVeto, "EleBaseline.CrackVeto", rEnv, false);
1436  configFromFile(m_force_noElId, "Ele.ForceNoId", rEnv, false);
1437 
1438  //
1439  configFromFile(m_elePt, "Ele.Et", rEnv, 25000.);
1440  configFromFile(m_eleEta, "Ele.Eta", rEnv, 2.47);
1441  configFromFile(m_eleCrackVeto, "Ele.CrackVeto", rEnv, false);
1442  configFromFile(m_eleIso_WP, "Ele.Iso", rEnv, "Loose_VarRad");
1443  configFromFile(m_eleIsoHighPt_WP, "Ele.IsoHighPt", rEnv, "HighPtCaloOnly");
1444  configFromFile(m_eleIsoHighPtThresh, "Ele.IsoHighPtThresh", rEnv, 200e3);
1445  configFromFile(m_eleChID_WP, "Ele.CFT", rEnv, "None"); // Loose is the only one supported for the moment, and not many clients yet.
1446  configFromFile(m_eleChIso, "Ele.CFTIso", rEnv, true); // use charge ID SFs without iso applied
1447  configFromFile(m_eleChID_signal, "Ele.CFTSignal", rEnv, !m_eleChID_WP.empty()); // Require ECID as part of the signal lepton definition
1448  configFromFile(m_eleId, "Ele.Id", rEnv, "TightLLH");
1449  configFromFile(m_eleLRT, "Ele.LRTOR", rEnv, false);
1450  configFromFile(m_eleLRT_strat, "Ele.LRTORStrat", rEnv, 0);
1451  configFromFile(m_eleConfig, "Ele.Config", rEnv, "None");
1452  configFromFile(m_eled0sig, "Ele.d0sig", rEnv, 5.);
1453  configFromFile(m_elez0, "Ele.z0", rEnv, 0.5);
1454  configFromFile(m_elebaselined0sig, "EleBaseline.d0sig", rEnv, -99.);
1455  configFromFile(m_elebaselinez0, "EleBaseline.z0", rEnv, 0.5);
1456  configFromFile(m_eleIdExpert, "Ele.IdExpert", rEnv, false);
1457  configFromFile(m_EG_corrModel, "Ele.EffNPcorrModel", rEnv, "TOTAL");
1458  configFromFile(m_EG_corrFNList, "Ele.EffCorrFNList", rEnv, "None");
1459  configFromFile(m_electronTriggerSFStringSingle, "Ele.TriggerSFStringSingle", rEnv, "SINGLE_E_2015_e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose_2016_2018_e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0");
1460  configFromFile(m_eleEffMapFilePath, "Ele.EffMapFilePath", rEnv, "ElectronEfficiencyCorrection/2015_2025/rel22.2/2024_Consolidated_Prerecom_v1/map1.txt");
1461  configFromFile(m_eleAllowRun3TrigSFFallback, "Ele.AllowRun3TrigSFFallback", rEnv, false);
1462  configFromFile(m_eleForceFullSimCalib, "Ele.ForceFullSimCalib", rEnv, false);
1463 
1464  configFromFile(m_trig2015combination_singleLep, "Trig.Singlelep2015", rEnv, "e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose || mu20_iloose_L1MU15_OR_mu40");
1465  configFromFile(m_trig2016combination_singleLep, "Trig.Singlelep2016", rEnv, "e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0 || mu26_ivarmedium_OR_mu50");
1466  configFromFile(m_trig2017combination_singleLep, "Trig.Singlelep2017", rEnv, "e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0 || mu26_ivarmedium_OR_mu50");
1467  configFromFile(m_trig2018combination_singleLep, "Trig.Singlelep2018", rEnv, "e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0 || mu26_ivarmedium_OR_mu50");
1468  configFromFile(m_trig2022combination_singleLep, "Trig.Singlelep2022", rEnv, "e26_lhtight_ivarloose_L1EM22VHI_OR_e60_lhmedium_L1EM22VHI_OR_e140_lhloose_L1EM22VHI || HLT_mu24_ivarmedium_L1MU14FCH_OR_HLT_mu50_L1MU14FCH");
1469  configFromFile(m_trigNToys_diLep, "Trig.DilepNToys", rEnv, 250); // 0 means calculate from formula instead - needs to be supported for the trigger combination
1470  configFromFile(m_trig2015combination_diLep, "Trig.Dilep2015", rEnv, "e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose || mu20_iloose_L1MU15_OR_mu40 || 2e12_lhloose_L12EM10VH || e17_lhloose_mu14 || e7_lhmedium_mu24 || mu18_mu8noL1 || 2mu10");
1471  configFromFile(m_trig2016combination_diLep, "Trig.Dilep2016", rEnv, "e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0 || mu26_ivarmedium_OR_mu50 || 2e17_lhvloose_nod0 || e17_lhloose_nod0_mu14 || e7_lhmedium_nod0_mu24 || e26_lhmedium_nod0_L1EM22VHI_mu8noL1 || mu22_mu8noL1 || 2mu14");
1472  configFromFile(m_trig2017combination_diLep, "Trig.Dilep2017", rEnv, "e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0 || mu26_ivarmedium_OR_mu50 || 2e24_lhvloose_nod0 || e17_lhloose_nod0_mu14 || e7_lhmedium_nod0_mu24 || e26_lhmedium_nod0_mu8noL1 || mu22_mu8noL1 || 2mu14");
1473  configFromFile(m_trig2018combination_diLep, "Trig.Dilep2018", rEnv, "e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0 || mu26_ivarmedium_OR_mu50 || 2e24_lhvloose_nod0 || e17_lhloose_nod0_mu14 || e7_lhmedium_nod0_mu24 || e26_lhmedium_nod0_mu8noL1 || mu22_mu8noL1 || 2mu14");
1474  // configFromFile(m_trig2022combination_diLep, "Trig.Dilep2022", rEnv, "");
1475  configFromFile(m_trigNToys_multiLep, "Trig.MultiNToys", rEnv, 250); // 0 means calculate from formula instead - needs to be supported for the trigger combination
1476  configFromFile(m_trig2015combination_multiLep, "Trig.Multi2015", rEnv, "e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose || mu20_iloose_L1MU15_OR_mu40 || 2e12_lhloose_L12EM10VH || e17_lhloose_2e9_lhloose || 2e12_lhloose_mu10 || e12_lhloose_2mu10 || e17_lhloose_mu14 || e7_lhmedium_mu24 || mu18_mu8noL1 || 2mu10 || 3mu6");
1477  configFromFile(m_trig2016combination_multiLep, "Trig.Multi2016", rEnv, "e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0 || mu26_ivarmedium_OR_mu50 || 2e17_lhvloose_nod0 || e17_lhloose_nod0_mu14 || e7_lhmedium_nod0_mu24 || e26_lhmedium_nod0_L1EM22VHI_mu8noL1 || e17_lhloose_nod0_2e9_lhloose_nod0 || e12_lhloose_nod0_2mu10 || 2e12_lhloose_nod0_mu10 || mu22_mu8noL1 || 2mu14 || 3mu6");
1478  configFromFile(m_trig2017combination_multiLep, "Trig.Multi2017", rEnv, "e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0 || mu26_ivarmedium_OR_mu50 || 2e24_lhvloose_nod0 || e17_lhloose_nod0_mu14 || e7_lhmedium_nod0_mu24 || e26_lhmedium_nod0_mu8noL1 || e24_lhvloose_nod0_2e12_lhvloose_nod0_L1EM20VH_3EM10VH || e12_lhloose_nod0_2mu10 || 2e12_lhloose_nod0_mu10 || mu22_mu8noL1 || 2mu14 || 3mu6");
1479  configFromFile(m_trig2018combination_multiLep, "Trig.Multi2018", rEnv, "e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0 || mu26_ivarmedium_OR_mu50 || 2e24_lhvloose_nod0 || e17_lhloose_nod0_mu14 || e7_lhmedium_nod0_mu24 || e26_lhmedium_nod0_mu8noL1 || e24_lhvloose_nod0_2e12_lhvloose_nod0_L1EM20VH_3EM10VH || e12_lhloose_nod0_2mu10 || 2e12_lhloose_nod0_mu10 || mu22_mu8noL1 || 2mu14 || 3mu6");
1480  // configFromFile(m_trig2022combination_multiLep, "Trig.Multi2022", rEnv, "");
1481  configFromFile(m_trigNToys_diPhoton, "Trig.DiphotonNToys", rEnv, 250); // 0 means calculate from formula instead - needs to be supported for the trigger combination
1482  configFromFile(m_trig2015combination_diPhoton, "Trig.Diphoton2015", rEnv, "g35_loose_g25_loose");
1483  configFromFile(m_trig2016combination_diPhoton, "Trig.Diphotonp2016", rEnv, "g35_loose_g25_loose");
1484  configFromFile(m_trig2017combination_diPhoton, "Trig.Diphotonp2017", rEnv, "g35_medium_g25_medium_L12EM20VH");
1485  configFromFile(m_trig2018combination_diPhoton, "Trig.Diphotonp2018", rEnv, "g35_medium_g25_medium_L12EM20VH");
1486  // configFromFile(m_trig2018combination_diPhoton, "Trig.Diphotonp2022", rEnv, "");
1487  //
1488  configFromFile(m_muBaselinePt, "MuonBaseline.Pt", rEnv, 10000.);
1489  configFromFile(m_muBaselineEta, "MuonBaseline.Eta", rEnv, 2.7);
1490  configFromFile(m_force_noMuId, "Muon.ForceNoId", rEnv, false);
1491  configFromFile(m_muBaselineIso_WP, "MuonBaseline.Iso", rEnv, "None");
1492  configFromFile(m_doTTVAsf, "Muon.TTVASF", rEnv, true);
1493  //
1494  configFromFile(m_muPt, "Muon.Pt", rEnv, 25000.);
1495  configFromFile(m_muEta, "Muon.Eta", rEnv, 2.7);
1496  configFromFile(m_muIso_WP, "Muon.Iso", rEnv, "Loose_VarRad");
1497  configFromFile(m_muIsoHighPt_WP, "Muon.IsoHighPt", rEnv, "Loose_VarRad");
1498  configFromFile(m_muIsoHighPtThresh, "Muon.IsoHighPtThresh", rEnv, 200e3);
1499  configFromFile(m_mud0sig, "Muon.d0sig", rEnv, 3.);
1500  configFromFile(m_muz0, "Muon.z0", rEnv, 0.5);
1501  configFromFile(m_mubaselined0sig, "MuonBaseline.d0sig", rEnv, -99.);
1502  configFromFile(m_mubaselinez0, "MuonBaseline.z0", rEnv, 0.5);
1503  configFromFile(m_murequirepassedHighPtCuts, "Muon.passedHighPt", rEnv, false);
1504  configFromFile(m_muHighPtExtraSmear, "Muon.HighPtExtraSmear", rEnv, false);
1505  configFromFile(m_muEffCorrForce1D, "Muon.EffCorrForce1D", rEnv, false);
1506  //
1507  configFromFile(m_muCosmicz0, "MuonCosmic.z0", rEnv, 1.);
1508  configFromFile(m_muCosmicd0, "MuonCosmic.d0", rEnv, 0.2);
1509  //
1510  // LRT muons
1511  configFromFile(m_muLRT, "Muon.LRTOR", rEnv, false);
1512  //
1513  configFromFile(m_badmuQoverP, "BadMuon.qoverp", rEnv, 0.4);
1514  //
1515  configFromFile(m_muCalibrationMode, "Muon.CalibrationMode", rEnv, 0); // 0: correctData_CB
1516  //
1517  configFromFile(m_photonBaselinePt, "PhotonBaseline.Pt", rEnv, 25000.);
1518  configFromFile(m_photonBaselineEta, "PhotonBaseline.Eta", rEnv, 2.37);
1519  configFromFile(m_photonIdBaseline, "PhotonBaseline.Id", rEnv, "Tight");
1520  configFromFile(m_photonBaselineCrackVeto, "PhotonBaseline.CrackVeto", rEnv, true);
1521  configFromFile(m_photonBaselineIso_WP, "PhotonBaseline.Iso", rEnv, "None");
1522  //
1523  configFromFile(m_photonPt, "Photon.Pt", rEnv, 130000.);
1524  configFromFile(m_photonEta, "Photon.Eta", rEnv, 2.37);
1525  configFromFile(m_photonId, "Photon.Id", rEnv, "Tight");
1526  configFromFile(m_photonIso_WP, "Photon.Iso", rEnv, "FixedCutTight");
1527  configFromFile(m_photonTriggerName, "Photon.TriggerName", rEnv, "DI_PH_2015_2016_g20_tight_2016_g22_tight_2017_2018_g20_tight_icalovloose_L1EM15VHI"); // for symmetric diphoton triggers
1528  configFromFile(m_photonCrackVeto, "Photon.CrackVeto", rEnv, true);
1529  configFromFile(m_photonAllowLate, "Photon.AllowLate", rEnv, false);
1530  //
1531  configFromFile(m_tauPrePtCut, "Tau.PrePtCut", rEnv, 0.);
1532  configFromFile(m_tauPt, "Tau.Pt", rEnv, 20000.);
1533  configFromFile(m_tauEta, "Tau.Eta", rEnv, 2.5);
1534  configFromFile(m_tauId, "Tau.Id", rEnv, "Medium");
1535  configFromFile(m_tauConfigPath, "Tau.ConfigPath", rEnv, "default");
1536  configFromFile(m_tauIdBaseline, "TauBaseline.Id", rEnv, "Medium");
1537  configFromFile(m_tauConfigPathBaseline, "TauBaseline.ConfigPath", rEnv, "default");
1538  configFromFile(m_tauDoTTM, "Tau.DoTruthMatching", rEnv, false);
1539  //
1540  configFromFile(m_tauSmearingToolRecommendationTag,"Tau.SmearingToolRecommendationTag", rEnv, "2022-prerec");
1541  configFromFile(m_tauSmearingToolGenerator,"Tau.SmearingToolGenerator", rEnv, "PoPy");
1542  //
1543  configFromFile(m_jetPt, "Jet.Pt", rEnv, 20000.);
1544  configFromFile(m_jetEta, "Jet.Eta", rEnv, 2.8);
1545  configFromFile(m_JvtWP, "Jet.JvtWP", rEnv, "FixedEffPt"); // https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/PileupJetRecommendations
1546  configFromFile(m_JvtPtMax, "Jet.JvtPtMax", rEnv, 60.0e3);
1547  configFromFile(m_JvtConfigRun2, "Jet.JvtConfigRun2", rEnv, "JetJvtEfficiency/May2024/NNJvtSFFile_Run2_EMPFlow.root", true); // empty string means dummy SF
1548  configFromFile(m_JvtConfigRun3, "Jet.JvtConfigRun3", rEnv, "JetJvtEfficiency/May2024/NNJvtSFFile_Run3_EMPFlow.root", true); // empty string means dummy SF
1549  configFromFile(m_jetUncertaintiesConfig, "Jet.UncertConfig", rEnv, m_isRun3 ? "rel22/Summer2024_PreRec/R4_CategoryReduction_FullJER.config" : "rel22/Summer2023_PreRec/R4_CategoryReduction_FullJER.config"); // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/JetUncertaintiesRel22/
1550  configFromFile(m_jetUncertaintiesAnalysisFile, "Jet.AnalysisFile", rEnv, "default"); // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/JetUncertaintiesRel21Summer2018SmallR
1551  configFromFile(m_jetUncertaintiesCalibArea, "Jet.UncertCalibArea", rEnv, "default"); // Defaults to default area set by tool
1552  configFromFile(m_jetUncertaintiesMCType, "Jet.UncertMCType", rEnv, "", true); // empty string means the MCType is guessed
1553  configFromFile(m_jetUncertaintiesPDsmearing, "Jet.UncertPDsmearing", rEnv, false); // for non "SimpleJER" config, run the PDSmear systematics. This are labelled with an __2 if they are being used, but otherwise will have the same tree name as the JET_JER systematic trees.
1554  configFromFile(m_fatJets, "Jet.LargeRcollection", rEnv, "AntiKt10UFOCSSKSoftDropBeta100Zcut10Jets"); // set to "None" to turn off large jets
1555  configFromFile(m_fatJetUncConfig, "Jet.LargeRuncConfig", rEnv, ""); // waiting for rec
1556  configFromFile(m_fatJetUncVars, "Jet.LargeRuncVars", rEnv, "default"); // do all if not specified
1557  configFromFile(m_WtagConfig, "Jet.WtaggerConfig", rEnv, "SmoothedContainedWTagger_AntiKt10UFOCSSKSoftDrop_FixedSignalEfficiency80_20220221.dat");
1558  configFromFile(m_ZtagConfig, "Jet.ZtaggerConfig", rEnv, "SmoothedContainedZTagger_AntiKt10UFOCSSKSoftDrop_FixedSignalEfficiency80_20220221.dat");
1559  configFromFile(m_WZTaggerCalibArea, "Jet.WZTaggerCalibArea", rEnv, "Winter2024_R22_PreRecs/SmoothedWZTaggers/");
1560  configFromFile(m_ToptagConfig, "Jet.ToptaggerConfig", rEnv, "DNNTagger_AntiKt10UFOSD_TopInclusive80_Oct30.dat");
1561  configFromFile(m_JetTruthLabelName, "Jet.JetTruthLabelName", rEnv, "R10TruthLabel_R21Precision_2022v1");
1562  configFromFile(m_TopTaggerCalibArea, "Jet.TopTaggerCalibArea", rEnv, "Winter2024_R22_PreRecs/JSSWTopTaggerDNN/");
1563  configFromFile(m_jesConfig, "Jet.JESConfig", rEnv, m_isRun3 ? "AntiKt4EMPFlow_MC23a_PreRecR22_Phase2_CalibConfig_ResPU_EtaJES_GSC_240306_InSitu.config" : "PreRec_R22_PFlow_ResPU_EtaJES_GSC_February23_230215.config"); //https://twiki.cern.ch/twiki/bin/view/AtlasProtected/ApplyJetCalibrationR22
1564  configFromFile(m_jesConfigAFII, "Jet.JESConfigAFII", rEnv, m_isRun3 ? "AntiKt4EMPFlow_MC23a_PreRecR22_Phase2_CalibConfig_ResPU_EtaJES_GSC_240306_InSitu.config" : "PreRec_R22_PFlow_ResPU_EtaJES_GSC_February23_230215.config");
1565  configFromFile(m_jesConfigJMS, "Jet.JESConfigJMS", rEnv, "JES_JMS_MC16Recommendation_Consolidated_MC_only_EMTopo_July2019_Rel21.config");
1566  configFromFile(m_jesConfigJMSData, "Jet.JESConfigJMSData", rEnv, "JES_JMS_MC16Recommendation_Consolidated_data_only_EMTopo_Sep2019_Rel21.config");
1567  configFromFile(m_jesConfigFat, "Jet.JESConfigFat", rEnv, "JES_MC20PreRecommendation_R10_UFO_CSSK_SoftDrop_JMS_R21Insitu_10Mar2023.config");
1568  configFromFile(m_jesConfigFatData, "Jet.JESConfigFatData", rEnv, "JES_MC20PreRecommendation_R10_UFO_CSSK_SoftDrop_JMS_R21Insitu_10Mar2023.config");
1569  configFromFile(m_jesCalibSeq, "Jet.CalibSeq", rEnv, "JetArea_Residual_EtaJES_GSC_Insitu");
1570  configFromFile(m_jesCalibSeqJMS, "Jet.CalibSeqJMS", rEnv, "JetArea_Residual_EtaJES_GSC");
1571  configFromFile(m_jesCalibSeqFat, "Jet.CalibSeqFat", rEnv, "EtaJES_JMS");
1572  configFromFile(m_jesCalibArea, "Jet.CalibArea", rEnv, m_isRun3 ? "00-04-83" : "00-04-82");
1573  //
1574  configFromFile(m_defaultTrackJets, "TrackJet.Coll", rEnv, "AntiKtVR30Rmax4Rmin02TrackJets");
1575  configFromFile(m_trkJetPt, "TrackJet.Pt", rEnv, 20000.);
1576  configFromFile(m_trkJetEta, "TrackJet.Eta", rEnv, 2.8);
1577  //
1578  configFromFile(m_badJetCut, "BadJet.Cut", rEnv, "LooseBad");
1579  //
1580  configFromFile(m_doFwdJVT, "FwdJet.doJVT", rEnv, false); // https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/PileupJetRecommendations
1581  configFromFile(m_fJvtWP, "FwdJet.JvtWP", rEnv, "Loose");
1582  configFromFile(m_fJvtPtMax, "FwdJet.JvtPtMax", rEnv, 60e3);
1583  configFromFile(m_fJvtEtaMin, "FwdJet.JvtEtaMin", rEnv, 2.5);
1584  configFromFile(m_fJvtConfigRun2, "FwdJet.JvtConfigRun2", rEnv, "JetJvtEfficiency/May2024/fJvtSFFile_Run2_EMPFlow.root", true); // empty string means dummy SF
1585  configFromFile(m_fJvtConfigRun3, "FwdJet.JvtConfigRun3", rEnv, "JetJvtEfficiency/May2024/fJvtSFFile_Run2_EMPFlow.root", true); // empty string means dummy SF
1586  configFromFile(m_JMScalib, "Jet.JMSCalib", rEnv, false);
1587  //
1588  configFromFile(m_useBtagging, "Btag.enable", rEnv, true);
1589  configFromFile(m_BtagTagger, "Btag.Tagger", rEnv, "GN2v01");
1590  configFromFile(m_BtagWP, "Btag.WP", rEnv, "Continuous");
1591  configFromFile(m_BtagMinPt, "Btag.MinPt", rEnv, -1.); // Not calibrated below 20
1592 
1593  configFromFile(m_bTaggingCalibrationFilePath, "Btag.CalibPath", rEnv, m_isRun3 ? "xAODBTaggingEfficiency/13p6TeV/MC23_2024-10-17_GN2v01_v1.root": "xAODBTaggingEfficiency/13TeV/MC20_2024-10-17_GN2v01_v1.root");
1594  configFromFile(m_BtagSystStrategy, "Btag.SystStrategy", rEnv, "SFEigen");
1595  configFromFile(m_EigenvectorReductionB, "Btag.EigenvectorReductionB", rEnv, "Loose");
1596  configFromFile(m_EigenvectorReductionC, "Btag.EigenvectorReductionC", rEnv, "Loose");
1597  configFromFile(m_EigenvectorReductionLight, "Btag.EigenvectorReductionLight", rEnv, "Loose");
1598 
1599  configFromFile(m_useBtagging_trkJet, "BtagTrkJet.enable", rEnv, true);
1600  configFromFile(m_BtagTagger_trkJet, "BtagTrkJet.Tagger", rEnv, "DL1r");
1601  configFromFile(m_BtagWP_trkJet, "BtagTrkJet.WP", rEnv, "FixedCutBEff_77");
1602  configFromFile(m_BtagMinPt_trkJet, "BtagTrkJet.MinPt", rEnv, -1.); // Not calibrated below 10
1603  configFromFile(m_BtagKeyOverride, "Btag.KeyOverride", rEnv, "", true);
1604  //
1605  configFromFile(m_orDoBoostedElectron, "OR.DoBoostedElectron", rEnv, true);
1606  configFromFile(m_orBoostedElectronC1, "OR.BoostedElectronC1", rEnv, -999.); // set to positive number to override default
1607  configFromFile(m_orBoostedElectronC2, "OR.BoostedElectronC2", rEnv, -999.); // set to positive number to override default - specify in MeV (i.e. "10*GeV" will nor work in the config file)
1608  configFromFile(m_orBoostedElectronMaxConeSize, "OR.BoostedElectronMaxConeSize", rEnv, -999.); // set to positive number to override default
1609  configFromFile(m_orDoBoostedMuon, "OR.DoBoostedMuon", rEnv, true);
1610  configFromFile(m_orBoostedMuonC1, "OR.BoostedMuonC1", rEnv, -999.); // set to positive number to override default
1611  configFromFile(m_orBoostedMuonC2, "OR.BoostedMuonC2", rEnv, -999.); // set to positive number to override default - specify in MeV (i.e. "10*GeV" will nor work in the config file)
1612  configFromFile(m_orBoostedMuonMaxConeSize, "OR.BoostedMuonMaxConeSize", rEnv, -999.); // set to positive number to override default
1613  configFromFile(m_orDoMuonJetGhostAssociation, "OR.DoMuonJetGhostAssociation", rEnv, true);
1614  configFromFile(m_orDoTau, "OR.DoTau", rEnv, false);
1615  configFromFile(m_orDoPhoton, "OR.DoPhoton", rEnv, false);
1616  configFromFile(m_orDoEleJet, "OR.EleJet", rEnv, true);
1617  configFromFile(m_orDoElEl, "OR.ElEl", rEnv, false);
1618  configFromFile(m_orDoElMu, "OR.ElMu", rEnv, false);
1619  configFromFile(m_orDoMuonJet, "OR.MuonJet", rEnv, true);
1620  configFromFile(m_orDoBjet, "OR.Bjet", rEnv, false);
1621  configFromFile(m_orDoElBjet, "OR.ElBjet", rEnv, false);
1622  configFromFile(m_orDoMuBjet, "OR.MuBjet", rEnv, false);
1623  configFromFile(m_orDoTauBjet, "OR.TauBjet", rEnv, false);
1624  configFromFile(m_orApplyRelPt, "OR.MuJetApplyRelPt", rEnv, false);
1625  configFromFile(m_orMuJetPtRatio, "OR.MuJetPtRatio", rEnv, -999.);
1626  configFromFile(m_orMuJetTrkPtRatio, "OR.MuJetTrkPtRatio", rEnv, -999.);
1627  configFromFile(m_orRemoveCaloMuons, "OR.RemoveCaloMuons", rEnv, true);
1628  configFromFile(m_orMuJetInnerDR, "OR.MuJetInnerDR", rEnv, -999.);
1629  configFromFile(m_orBtagWP, "OR.BtagWP", rEnv, "FixedCutBEff_85");
1630  configFromFile(m_orInputLabel, "OR.InputLabel", rEnv, "selected"); //"baseline"
1631  configFromFile(m_orPhotonFavoured, "OR.PhotonFavoured", rEnv, false);
1632  configFromFile(m_orBJetPtUpperThres, "OR.BJetPtUpperThres", rEnv, -1.); // upper pt threshold of b-jet in OR in unit of MeV, -1 means no pt threshold
1633  configFromFile(m_orLinkOverlapObjects, "OR.LinkOverlapObjects", rEnv, false);
1634  //
1635  configFromFile(m_orDoFatjets, "OR.DoFatJets", rEnv, false);
1636  configFromFile(m_EleFatJetDR, "OR.EleFatJetDR", rEnv, -999.);
1637  configFromFile(m_JetFatJetDR, "OR.JetFatJetDR", rEnv, -999.);
1638  //
1639  configFromFile(m_useTRUTH3, "Truth.UseTRUTH3", rEnv, true);
1641  configFromFile(m_upstreamTriggerMatching, "Trigger.UpstreamMatching", rEnv, false);
1642  configFromFile(m_trigMatchingPrefix, "Trigger.MatchingPrefix", rEnv, "", true);
1643  //
1644  configFromFile(m_doIsoSignal, "SigLep.RequireIso", rEnv, true);
1645  configFromFile(m_doElIsoSignal, "SigEl.RequireIso", rEnv, m_doIsoSignal);
1646  configFromFile(m_doMuIsoSignal, "SigMu.RequireIso", rEnv, m_doIsoSignal);
1647  configFromFile(m_doPhIsoSignal, "SigPh.RequireIso", rEnv, m_doIsoSignal);
1648  configFromFile(m_useSigLepForIsoCloseByOR, "SigLepPh.UseSigLepForIsoCloseByOR", rEnv, false);
1649  configFromFile(m_IsoCloseByORpassLabel, "SigLepPh.IsoCloseByORpassLabel", rEnv, "None");
1650 
1651  //
1652  configFromFile(m_eleTerm, "MET.EleTerm", rEnv, "RefEle");
1653  configFromFile(m_gammaTerm, "MET.GammaTerm", rEnv, "RefGamma");
1654  configFromFile(m_tauTerm, "MET.TauTerm", rEnv, "RefTau");
1655  configFromFile(m_jetTerm, "MET.JetTerm", rEnv, "RefJet");
1656  configFromFile(m_muonTerm, "MET.MuonTerm", rEnv, "Muons");
1657  configFromFile(m_inputMETSuffix, "MET.InputSuffix", rEnv, "", true); // May be empty
1658  configFromFile(m_outMETTerm, "MET.OutputTerm", rEnv, "Final");
1659  configFromFile(m_metRemoveOverlappingCaloTaggedMuons, "MET.RemoveOverlappingCaloTaggedMuons", rEnv, true);
1660  configFromFile(m_metDoSetMuonJetEMScale, "Met.DoSetMuonJetEMScale", rEnv, true);
1661  configFromFile(m_metDoRemoveMuonJets, "MET.DoRemoveMuonJets", rEnv, true);
1662  configFromFile(m_metUseGhostMuons, "MET.UseGhostMuons", rEnv, false);
1663  configFromFile(m_metDoMuonEloss, "MET.DoMuonEloss", rEnv, false);
1664  configFromFile(m_metGreedyPhotons, "MET.DoGreedyPhotons", rEnv, false);
1665  configFromFile(m_metVeryGreedyPhotons, "MET.DoVeryGreedyPhotons", rEnv, false);
1666 
1667  configFromFile(m_trkMETsyst, "MET.DoTrkSyst", rEnv, true);
1668  configFromFile(m_caloMETsyst, "MET.DoCaloSyst", rEnv, false);
1669  configFromFile(m_trkJetsyst, "MET.DoTrkJetSyst", rEnv, false);
1670  configFromFile(m_metsysConfigPrefix, "METSys.ConfigPrefix", rEnv, "METUtilities/R22_PreRecs");
1671  configFromFile(m_metJetSelection, "MET.JetSelection", rEnv, "Tight"); // Loose, Tight (default), Tighter, Tenacious
1672  configFromFile(m_softTermParam, "METSig.SoftTermParam", rEnv, met::Random);
1673  configFromFile(m_treatPUJets, "METSig.TreatPUJets", rEnv, true);
1674  configFromFile(m_doPhiReso, "METSig.DoPhiReso", rEnv, false);
1675  //
1676  configFromFile(m_prwActualMu2017File, "PRW.ActualMu2017File", rEnv, "GoodRunsLists/data17_13TeV/20180619/physics_25ns_Triggerno17e33prim.actualMu.OflLumi-13TeV-010.root");
1677  configFromFile(m_prwActualMu2018File, "PRW.ActualMu2018File", rEnv, "GoodRunsLists/data18_13TeV/20190318/physics_25ns_Triggerno17e33prim.actualMu.OflLumi-13TeV-010.root");
1678  configFromFile(m_prwActualMu2022File, "PRW.ActualMu2022File", rEnv, "GoodRunsLists/data22_13p6TeV/20230207/purw.actualMu.2022.root");
1679  configFromFile(m_prwActualMu2023File, "PRW.ActualMu2023File", rEnv, "GoodRunsLists/data23_13p6TeV/20230828/purw.actualMu.2023.root");
1680  configFromFile(m_prwActualMu2024File, "PRW.ActualMu2024File", rEnv, "GoodRunsLists/data24_13p6TeV/20241118/purw.actualMu.root");
1681  configFromFile(m_prwDataSF, "PRW.DataSF", rEnv, 1./1.03); // default for mc16, see: https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/ExtendedPileupReweighting#Tool_Properties
1682  configFromFile(m_prwDataSF_UP, "PRW.DataSF_UP", rEnv, 1./0.99); // mc16 uncertainty? defaulting to the value in PRWtool
1683  configFromFile(m_prwDataSF_DW, "PRW.DataSF_DW", rEnv, 1./1.07); // mc16 uncertainty? defaulting to the value in PRWtool
1684  configFromFile(m_runDepPrescaleWeightPRW, "PRW.UseRunDependentPrescaleWeight", rEnv, false); // If set to true, the prescale weight is the luminosity-average prescale over the lumiblocks in the unprescaled lumicalc file in the PRW tool.
1685  configFromFile(m_autoconfigPRWPath, "PRW.autoconfigPRWPath", rEnv, "dev/PileupReweighting/share/");
1686  configFromFile(m_autoconfigPRWFile, "PRW.autoconfigPRWFile", rEnv, "None");
1687  configFromFile(m_autoconfigPRWCombinedmode, "PRW.autoconfigPRWCombinedmode", rEnv, false);
1688  configFromFile(m_autoconfigPRWRPVmode, "PRW.autoconfigPRWRPVmode", rEnv, false);
1689  configFromFile(m_autoconfigPRWRtags, "PRW.autoconfigPRWRtags", rEnv, "mc20a:r13167_r14859,mc20d:r13144_r14860,mc20e:r13145_r14861,mc21a:r13752_r13829,mc23a:r14622_r14932_r15540,mc23c:r14799_r14908,mc23d:r15224_r15530,mc23e:r16083"); // Tag details here: https://twiki.cern.ch/twiki/bin/view/AtlasProtected/AtlasProductionGroup
1690  configFromFile(m_commonPRWFileMC20a, "PRW.commonPRWFileMC20a", rEnv, "PileupReweighting/mc20_common/mc20a.284500.physlite.prw.v1.root");
1691  configFromFile(m_commonPRWFileMC20d, "PRW.commonPRWFileMC20d", rEnv, "PileupReweighting/mc20_common/mc20d.300000.physlite.prw.v1.root");
1692  configFromFile(m_commonPRWFileMC20e, "PRW.commonPRWFileMC20e", rEnv, "PileupReweighting/mc20_common/mc20e.310000.physlite.prw.v1.root");
1693  configFromFile(m_commonPRWFileMC21a, "PRW.commonPRWFileMC21a", rEnv, "PileupReweighting/mc21_common/mc21a.410000.physlite.prw.v1.root");
1694  configFromFile(m_commonPRWFileMC23a, "PRW.commonPRWFileMC23a", rEnv, "PileupReweighting/mc23_common/mc23a.410000.physlite.prw.v2.root");
1695  configFromFile(m_commonPRWFileMC23c, "PRW.commonPRWFileMC23c", rEnv, "PileupReweighting/mc23_common/mc23c.450000.physlite.prw.v1.root");
1696  configFromFile(m_commonPRWFileMC23d, "PRW.commonPRWFileMC23d", rEnv, "PileupReweighting/mc23_common/mc23d.450000.physlite.prw.v1.root");
1697  configFromFile(m_commonPRWFileMC23e, "PRW.commonPRWFileMC23e", rEnv, "PileupReweighting/mc23_common/mc23e.470000.physlite.prw.v1.root");
1698  //
1699  configFromFile(m_strictConfigCheck, "StrictConfigCheck", rEnv, false);
1700 
1701  // By now rEnv should be empty!
1702  if (rEnv.GetTable() && rEnv.GetTable()->GetSize()>0){
1703  ATH_MSG_ERROR("Found " << rEnv.GetTable()->GetSize() << " unparsed environment options:");
1704  rEnv.Print();
1705  ATH_MSG_ERROR("Please fix your configuration!");
1706  return StatusCode::FAILURE;
1707  }
1708 
1709  // Set up the correct configuration files for the large-R jet tagging corresponding to the input tagger config
1710  if (!m_WtagConfig.empty()) {
1711  if (m_WtagConfig.find("Efficiency50") != std::string::npos){
1712  m_WTagUncConfig = "R10_SF_LCTopo_WTag_SigEff50.config";
1713  }
1714  else if (m_WtagConfig.find("Efficiency80") != std::string::npos){
1715  m_WTagUncConfig = "R10_SF_LCTopo_WTag_SigEff80.config";
1716  }
1717  else {
1718  ATH_MSG_ERROR("You have specified a large-R W-tag config without a matching uncertainties file. Please fix this. Currently the 50% and 80% WPs are supported");
1719  }
1720  }
1721  if (!m_ZtagConfig.empty()) {
1722  if (m_ZtagConfig.find("Efficiency50") != std::string::npos){
1723  m_ZTagUncConfig = "R10_SF_LCTopo_ZTag_SigEff50.config";
1724  }
1725  else if (m_ZtagConfig.find("Efficiency80") != std::string::npos){
1726  m_ZTagUncConfig = "R10_SF_LCTopo_ZTag_SigEff80.config";
1727  }
1728  else {
1729  ATH_MSG_ERROR("You have specified a large-R Z-tag config without a matching uncertainties file. Please fix this. Currently the 50% and 80% WPs are supported");
1730  }
1731  }
1732  std::string TopTagEff = "";
1733  std::string TopTagType = "";
1734  if (!m_ToptagConfig.empty()) {
1735  if (m_ToptagConfig.find("50") != std::string::npos){
1736  TopTagEff = "50";
1737  }
1738  else if (m_ToptagConfig.find("80") != std::string::npos){
1739  TopTagEff = "80";
1740  }
1741  else {
1742  ATH_MSG_ERROR("You have specified a large-R Top-tag config without a matching uncertainties file. Please fix this. Currently the 50% and 80% WPs are supported");
1743  }
1744  //
1745  if (m_ToptagConfig.find("Inclusive") != std::string::npos){
1746  TopTagType = "Inclusive";
1747  }
1748  else if (m_ToptagConfig.find("Contained") != std::string::npos){
1749  TopTagType = "Contained";
1750  }
1751  else {
1752  ATH_MSG_ERROR("You have specified a large-R Top-tag config without a matching uncertainties file. Please fix this. Currently the contained and inclusive WPs are supported");
1753  }
1754  m_TopTagUncConfig = "R10_SF_LCTopo_TopTag"+TopTagType+"_SigEff"+TopTagEff+".config";
1755  }
1756 
1757  //** validate configuration
1759 
1760  //** cache trigger chains for electron matching
1762 
1763  //** cache trigger chains for matching (both electrons and muons)
1765 
1771 
1777 
1783 
1784  return StatusCode::SUCCESS;
1785 }

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ resetSystematics()

StatusCode ST::SUSYObjDef_xAOD::resetSystematics ( )
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2073 of file SUSYObjDef_xAOD.cxx.

2073  {
2075 }

◆ setBoolProperty()

StatusCode ST::SUSYObjDef_xAOD::setBoolProperty ( const std::string &  name,
const bool &  property 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 866 of file SUSYObjDef_xAOD.cxx.

866  {
867  m_bool_prop_set.insert(name);
868  return this->setProperty(name, property);
869 }

◆ SetBtagWeightDecorations()

StatusCode ST::SUSYObjDef_xAOD::SetBtagWeightDecorations ( const xAOD::Jet input,
const asg::AnaToolHandle< IBTaggingSelectionTool > &  btagSelTool,
const std::string &  btagTagger 
) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 1120 of file Jets.cxx.

1120  {
1121  double weight = 0.;
1122  if ( btagSelTool->getTaggerWeight(input, weight, false/*useVetoWP=false*/) != CP::CorrectionCode::Ok ) {
1123  ATH_MSG_ERROR( btagSelTool->name() << ": could not retrieve b-tag weight (" << btagTagger << ")." );
1124  return StatusCode::FAILURE;
1125  }
1126  dec_btag_weight(input) = weight;
1127  ATH_MSG_DEBUG( btagSelTool->name() << " b-tag weight: " << weight );
1128 
1129  double btag_pb(-10), btag_pc(-10), btag_pu(-10), btag_ptau(-10);
1130  // following name change is needed given different name is used for GN2v00 in derivation and in CDI
1131  std::string actualTagger = btagTagger;
1132  if (btagTagger == "GN2v00LegacyWP" || btagTagger == "GN2v00NewAliasWP"){
1133  actualTagger = "GN2v00";
1134  }
1135  xAOD::BTaggingUtilities::getBTagging(input)->pb(actualTagger, btag_pb);
1136  xAOD::BTaggingUtilities::getBTagging(input)->pc(actualTagger, btag_pc);
1137  xAOD::BTaggingUtilities::getBTagging(input)->pu(actualTagger, btag_pu);
1138  xAOD::BTaggingUtilities::getBTagging(input)->pu(actualTagger, btag_ptau);
1139  dec_btag_pb(input) = btag_pb;
1140  dec_btag_pc(input) = btag_pc;
1141  dec_btag_pu(input) = btag_pu;
1142  dec_btag_ptau(input) = btag_ptau;
1143  ATH_MSG_DEBUG( btagSelTool->name() << " b-tag " << btagTagger << "-type pb: " << btag_pb );
1144  ATH_MSG_DEBUG( btagSelTool->name() << " b-tag " << btagTagger << "-type pc: " << btag_pc );
1145  ATH_MSG_DEBUG( btagSelTool->name() << " b-tag " << btagTagger << "-type pu: " << btag_pu );
1146  ATH_MSG_DEBUG( btagSelTool->name() << " b-tag " << btagTagger << "-type ptau: " << btag_ptau );
1147  // backwards compatibility
1148  if ( btagSelTool->name().find("DL1")!=std::string::npos ) {
1149  dec_btag_dl1pb(input) = btag_pb;
1150  dec_btag_dl1pc(input) = btag_pc;
1151  dec_btag_dl1pu(input) = btag_pu;
1152  }
1153  else {
1154  dec_btag_dl1pb(input) = -10;
1155  dec_btag_dl1pc(input) = -10;
1156  dec_btag_dl1pu(input) = -10;
1157  }
1158  return StatusCode::SUCCESS;
1159  }

◆ setDataSource()

void ST::SUSYObjDef_xAOD::setDataSource ( int  source)

Definition at line 1194 of file SUSYObjDef_xAOD.cxx.

1194  {
1195  if (source == 0) m_dataSource = Data;
1196  else if (source == 1) m_dataSource = FullSim;
1197  else if (source == 2) m_dataSource = AtlfastII;
1198  else ATH_MSG_ERROR("Trying to set data source to unknown type (" << source << ")");
1199 }

◆ setUseIncidents()

void asg::AsgMetadataTool::setUseIncidents ( const bool  flag)
inlineprotectedinherited

Definition at line 132 of file AsgMetadataTool.h.

133  {
135  }

◆ split()

const std::vector< std::string > ST::SUSYObjDef_xAOD::split ( const std::string &  s,
const std::string &  delim 
) const
protected

Definition at line 1788 of file SUSYObjDef_xAOD.cxx.

1788  {
1789  assert(delim.length() == 1);
1790  std::vector<std::string> retval;
1791  retval.reserve(std::count(s.begin(), s.end(), delim[0]) + 1);
1792  // if only 1
1793  if (s.find(delim)==std::string::npos) {
1794  retval.emplace_back(s);
1795  return retval;
1796  }
1797  // if need to split
1798  size_t last = 0;
1799  size_t next = 0;
1800  bool gothere=false;
1801  while ((next = s.find(delim, last)) != std::string::npos) {
1802  retval.emplace_back(s.substr(last, next - last));
1803  last = next + delim.length();
1804  gothere=true;
1805  }
1806  if(gothere)
1807  retval.emplace_back(s.substr(last));
1808 
1809  return retval;
1810 }

◆ SUSYToolsInit()

StatusCode SUSYObjDef_xAOD::SUSYToolsInit ( )
private

Definition at line 109 of file SUSYToolsInit.cxx.

110 {
111  if (m_dataSource < 0) {
112  ATH_MSG_FATAL("Data source incorrectly configured!!");
113  ATH_MSG_FATAL("You must set the DataSource property to Data, FullSim or AtlfastII !!");
114  ATH_MSG_FATAL("Expect segfaults if you're not checking status codes, which you should be !!");
115  return StatusCode::FAILURE;
116  }
117 
118  if (m_subtool_init) {
119  ATH_MSG_INFO("SUSYTools subtools already created. Ignoring this call.");
120  ATH_MSG_INFO("Note: No longer necessary to explicitly call SUSYToolsInit. Will avoid creating tools again.");
121  return StatusCode::SUCCESS;
122  }
123 
124  // /////////////////////////////////////////////////////////////////////////////////////////
125  // Initialise PileupReweighting Tool
126 
127  if (!m_prwTool.isUserConfigured()) {
128  ATH_MSG_DEBUG("Will now init the PRW tool");
129  std::vector<std::string> file_conf;
130  for (UInt_t i = 0; i < m_prwConfFiles.size(); i++) {
131  ATH_MSG_INFO("Adding PRW file: " << m_prwConfFiles.at(i));
132  file_conf.push_back(m_prwConfFiles.at(i));
133  }
134 
135  std::vector<std::string> file_ilumi;
136  for (UInt_t i = 0; i < m_prwLcalcFiles.size(); i++) {
137  ATH_MSG_INFO("Adding ilumicalc file: " << m_prwLcalcFiles.at(i));
138  file_ilumi.push_back(m_prwLcalcFiles.at(i));
139  }
140 
141  m_prwTool.setTypeAndName("CP::PileupReweightingTool/PrwTool");
142  ATH_CHECK( m_prwTool.setProperty("ConfigFiles", file_conf) );
143  ATH_CHECK( m_prwTool.setProperty("LumiCalcFiles", file_ilumi) );
144  ATH_CHECK( m_prwTool.setProperty("DataScaleFactor", m_prwDataSF) ); // 1./1.03 -> default for mc16, see: https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/ExtendedPileupReweighting#Tool_Properties
145  ATH_CHECK( m_prwTool.setProperty("DataScaleFactorUP", m_prwDataSF_UP) ); // 1. -> old value (mc15), as the one for mc16 is still missing
146  ATH_CHECK( m_prwTool.setProperty("DataScaleFactorDOWN", m_prwDataSF_DW) ); // 1./1.18 -> old value (mc15), as the one for mc16 is still missing
147  ATH_CHECK( m_prwTool.setProperty("TrigDecisionTool", m_trigDecTool.getHandle()) );
148  ATH_CHECK( m_prwTool.setProperty("UseRunDependentPrescaleWeight", m_runDepPrescaleWeightPRW) );
149  ATH_CHECK( m_prwTool.setProperty("OutputLevel", MSG::WARNING) );
151  } else {
152  ATH_MSG_INFO("Using user-configured PRW tool");
154  }
155 
157  // Initialize LRT systematics tool
159  {
160  ATH_MSG_INFO("Initializing LRT uncertainty tool");
161  m_LRTuncTool.setTypeAndName("InDet::InclusiveTrackFilterTool/LRTUncTool");
162  ATH_CHECK( m_LRTuncTool.setProperty("Seed", 1) );
164  } else {
165  ATH_MSG_INFO("Using user-configured LRT uncertainty tool");
167  }
168 
169  std::string toolName; // to be used for tool init below, keeping explicit string constants a minimum /CO
170 
171  std::string jetname,jetcoll,fatjetcoll;
172  if (m_slices["jet"]) {
174  // Initialise jet calibration tool
175 
176  // pick the right config file for the JES tool : https://twiki.cern.ch/twiki/bin/view/AtlasProtected/ApplyJetCalibrationR22
178  jetcoll = jetname + "Jets";
179 
181  toolName = "JetCalibTool_" + jetname;
182  m_jetCalibTool.setTypeAndName("JetCalibrationTool/"+toolName);
183  std::string JES_config_file, calibseq;
184 
186  ATH_MSG_ERROR("Unknown (unsupported) jet collection is used, (m_jetInputType = " << m_jetInputType << ")");
187  return StatusCode::FAILURE;
188  }
189 
190  std::string JESconfig = isAtlfast() ? m_jesConfigAFII : m_jesConfig;
191  if(isAtlfast() && m_isRun3) {
192  ATH_MSG_WARNING("Jet JES/JER recommendations currently not available for fast sim in Run 3, falling back to full sim version");
193  JESconfig = m_jesConfig;
194  }
195 
196  calibseq = m_jesCalibSeq;
197  JES_config_file = JESconfig;
198 
199  // remove Insitu if it's in the string if not data
200  if (!isData()) {
201  std::string insitu("_Insitu");
202  auto found = calibseq.find(insitu);
203  if(found != std::string::npos){
204  calibseq.erase(found, insitu.length());
205  }
206  }
207 
208  // JMS calibration (if requested)
209  if (m_JMScalib){
210  ATH_MSG_ERROR("JMS calibration is not supported yet for R22. Please modify your settings.");
211  return StatusCode::FAILURE;
212  }
213 
214  // now instantiate the tool
215  ATH_CHECK( m_jetCalibTool.setProperty("JetCollection", jetname) );
216  ATH_CHECK( m_jetCalibTool.setProperty("ConfigFile", JES_config_file) );
217  ATH_CHECK( m_jetCalibTool.setProperty("CalibSequence", calibseq) );
219  ATH_CHECK( m_jetCalibTool.setProperty("IsData", isData()) );
220  ATH_CHECK( m_jetCalibTool.setProperty("OutputLevel", this->msg().level()) );
223  }
224 
225  if (m_slices["fjet"]) {
226  //same for fat groomed jets
227  fatjetcoll = m_fatJets;
228 
229  if(fatjetcoll == "AnalysisLargeRJets") {
230  ATH_MSG_DEBUG("Fall back to calibration for AntiKt10UFOCSSKSoftDropBeta100Zcut10Jets, original name for AnalysisLargeRJets");
231  fatjetcoll = "AntiKt10UFOCSSKSoftDropBeta100Zcut10Jets";
232  }
233  if (fatjetcoll.size()>3)fatjetcoll.erase(fatjetcoll.size()-4,4);
234  if (!m_jetFatCalibTool.isUserConfigured() && !m_fatJets.empty()) {
235  toolName = "JetFatCalibTool_" + m_fatJets;
236  m_jetFatCalibTool.setTypeAndName("JetCalibrationTool/"+toolName);
237 
238  std::string jesConfigFat = m_jesConfigFat;
239  std::string jesCalibSeqFat = m_jesCalibSeqFat;
240  // add Insitu if data
241  if(isData()) jesCalibSeqFat += "_Insitu";
242 
243  // now instantiate the tool
244  ATH_CHECK( m_jetFatCalibTool.setProperty("JetCollection", fatjetcoll) );
245  ATH_CHECK( m_jetFatCalibTool.setProperty("ConfigFile", jesConfigFat) );
246  ATH_CHECK( m_jetFatCalibTool.setProperty("CalibSequence", jesCalibSeqFat) );
247  // always set to false : https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/ApplyJetCalibrationR21
249  ATH_CHECK( m_jetFatCalibTool.setProperty("OutputLevel", this->msg().level()) );
252  }
253 
254  if (m_slices["fjet"]) {
256  // Initialise Boson taggers: https://twiki.cern.ch/twiki/bin/view/AtlasProtected/BoostedJetTaggingRecommendationFullRun2#Higgs_taggers
257  if (!m_WTaggerTool.isUserConfigured() && !m_WtagConfig.empty()) {
258  m_WTaggerTool.setTypeAndName("SmoothedWZTagger/WTagger");
259  ATH_CHECK( m_WTaggerTool.setProperty("ContainerName", m_fatJets) );
263  ATH_CHECK( m_WTaggerTool.setProperty("TruthBosonContainerName", "TruthBoson") ); // Set this if you are using a TRUTH3 style truth boson container;
264  ATH_CHECK( m_WTaggerTool.setProperty("TruthTopQuarkContainerName", "TruthTop") ); // Set this if you are using a TRUTH3 style truth boson container;
265 #ifndef XAOD_STANDALONE
266  ATH_CHECK( m_WTaggerTool.setProperty("SuppressOutputDependence", true) );
267 #endif
268  ATH_CHECK( m_WTaggerTool.setProperty("OutputLevel", this->msg().level()) );
270 
271  // Retrieving DecorationName (needed to access tagging results downstream):
272  std::string WConfigPath = PathResolverFindCalibFile("BoostedJetTaggers/"+m_WZTaggerCalibArea+"/"+m_WtagConfig);
273  if ( m_WconfigReader.ReadFile( WConfigPath.c_str(), EEnvLevel(0) ) ) {
274  ATH_MSG_ERROR( "Error while reading large-R config file : " << WConfigPath );
275  return StatusCode::FAILURE;
276  }
277  else ATH_MSG_DEBUG( "Successfully read large-R config file : " << WConfigPath );
278 
279  m_WDecorName = m_WconfigReader.GetValue("DecorationName" ,"");
280  ANA_MSG_DEBUG( "Found DecorationName in large-R config file : " << m_WDecorName );
281 
283 
284  if (!m_ZTaggerTool.isUserConfigured() && !m_ZtagConfig.empty()) {
285  m_ZTaggerTool.setTypeAndName("SmoothedWZTagger/ZTagger");
286  ATH_CHECK( m_ZTaggerTool.setProperty("ContainerName", m_fatJets) );
290  ATH_CHECK( m_ZTaggerTool.setProperty("TruthBosonContainerName", "TruthBoson") ); // Set this if you are using a TRUTH3 style truth boson container;
291  ATH_CHECK( m_ZTaggerTool.setProperty("TruthTopQuarkContainerName", "TruthTop") ); // Set this if you are using a TRUTH3 style truth boson container;
292 #ifndef XAOD_STANDALONE
293  ATH_CHECK( m_ZTaggerTool.setProperty("SuppressOutputDependence", true) );
294 #endif
295  ATH_CHECK( m_ZTaggerTool.setProperty("OutputLevel", this->msg().level()) );
297 
298  // Retrieving DecorationName (needed to access tagging results downstream):
299  std::string ZConfigPath = PathResolverFindCalibFile("BoostedJetTaggers/"+m_WZTaggerCalibArea+"/"+m_ZtagConfig);
300  if ( m_ZconfigReader.ReadFile( ZConfigPath.c_str(), EEnvLevel(0) ) ) {
301  ATH_MSG_ERROR( "Error while reading large-R config file : " << ZConfigPath );
302  return StatusCode::FAILURE;
303  }
304  else ATH_MSG_DEBUG( "Successfully read large-R config file : " << ZConfigPath );
305 
306  m_ZDecorName = m_ZconfigReader.GetValue("DecorationName" ,"");
307  ANA_MSG_DEBUG( "Found DecorationName in large-R config file : " << m_ZDecorName );
308 
310 
311  if (!m_TopTaggerTool.isUserConfigured() && !m_ToptagConfig.empty()) {
312  m_TopTaggerTool.setTypeAndName("JSSWTopTaggerDNN/TopTagger");
313  ATH_CHECK( m_TopTaggerTool.setProperty("ContainerName", m_fatJets) );
317  ATH_CHECK( m_TopTaggerTool.setProperty("TruthBosonContainerName", "TruthBoson") ); // Set this if you are using a TRUTH3 style truth boson container;
318  ATH_CHECK( m_TopTaggerTool.setProperty("TruthTopQuarkContainerName", "TruthTop") ); // Set this if you are using a TRUTH3 style truth boson container;
319 #ifndef XAOD_STANDALONE
320  ATH_CHECK( m_TopTaggerTool.setProperty("SuppressOutputDependence", true) );
321 #endif
322  ATH_CHECK( m_TopTaggerTool.setProperty("OutputLevel", this->msg().level()) );
324 
325  // Retrieving DecorationName (needed to access tagging results downstream):
326  std::string TopConfigPath = PathResolverFindCalibFile("BoostedJetTaggers/"+m_TopTaggerCalibArea+"/"+m_ToptagConfig);
327  if ( m_TopconfigReader.ReadFile( TopConfigPath.c_str(), EEnvLevel(0) ) ) {
328  ATH_MSG_ERROR( "Error while reading large-R config file : " << TopConfigPath );
329  return StatusCode::FAILURE;
330  }
331  else ATH_MSG_DEBUG( "Successfully read large-R config file : " << TopConfigPath );
332 
333  m_TopDecorName = m_TopconfigReader.GetValue("DecorationName" ,"");
334  ANA_MSG_DEBUG( "Found DecorationName in large-R config file : " << m_TopDecorName );
335 
337 
339  // Initialise JetTruthLabelingTool: https://twiki.cern.ch/twiki/bin/view/AtlasProtected/JetUncertaintiesRel21Summer2019LargeR#AnalysisBase_21_2_114_and_newer
340  if(!isData()) {
341  m_label_truthKey = fatjetcoll+"."+m_JetTruthLabelName;
342  ATH_CHECK(m_label_truthKey.initialize());
343 
345  m_jetTruthLabelingTool.setTypeAndName("JetTruthLabelingTool/ST_JetTruthLabelingTool");
346  ATH_CHECK( m_jetTruthLabelingTool.setProperty("RecoJetContainer", m_fatJets) );
348  ATH_CHECK( m_jetTruthLabelingTool.setProperty("UseTRUTH3", m_useTRUTH3) ); // Set this to false only if you have the FULL !TruthParticles container in your input file
349  ATH_CHECK( m_jetTruthLabelingTool.setProperty("TruthParticleContainerName", "TruthParticles") );
350  ATH_CHECK( m_jetTruthLabelingTool.setProperty("TruthBosonContainerName", "TruthBoson") ); // Set this if you are using a TRUTH3 style truth boson container
351  ATH_CHECK( m_jetTruthLabelingTool.setProperty("TruthTopQuarkContainerName", "TruthTop") ); // Set this if you are using a TRUTH3 style truth top quark container
352  ATH_CHECK( m_jetTruthLabelingTool.setProperty("OutputLevel", this->msg().level()) );
355  }
356  }
357 
358  if (m_slices["jet"] || m_slices["fjet"]) {
359 
360 
362  // Initialise jet uncertainty tool
363  // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/JetUncertaintiesRel22
364  ATH_MSG_INFO("Set up Jet Uncertainty tool...");
365 
366  // if not set, derive the MCType from the simulation type and MC campaign
367  if (m_jetUncertaintiesMCType.empty()) m_jetUncertaintiesMCType = m_isRun3 ? "MC23" : (isAtlfast() ? "AF3" : "MC20");
368 
370  std::string jetdef("AntiKt4" + xAOD::JetInput::typeName(xAOD::JetInput::Type(m_jetInputType)));
371 
372  if(jetdef !="AntiKt4EMPFlow"){
373  ATH_MSG_WARNING("Jet Uncertaintes recommendations only exist for PFlow jets, falling back to AntiKt4EMPFlow");
374  jetdef = "AntiKt4EMPFlow";
375  }
376  toolName = "JetUncertaintiesTool_" + jetdef;
377 
378  if (m_isRun3 && isAtlfast()) {
379  ATH_MSG_WARNING("Jet Uncertaintes pre-recommendations for Run3 only exist for full sim");
380  }
381 
382  m_jetUncertaintiesTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
383 
384  ATH_CHECK( m_jetUncertaintiesTool.setProperty("JetDefinition", jetdef) );
386  ATH_CHECK( m_jetUncertaintiesTool.setProperty("IsData", false) ); // Never use the PDSmearing for the nominal tool.
390  ATH_CHECK( m_jetUncertaintiesTool.setProperty("OutputLevel", this->msg().level()) );
393 
394  ATH_MSG_INFO("Set up Jet PD Smear Uncertainty tool...");
395 
397  std::string jetdef("AntiKt4" + xAOD::JetInput::typeName(xAOD::JetInput::Type(m_jetInputType)));
398 
399  if(jetdef !="AntiKt4EMPFlow"){
400  ATH_MSG_WARNING("Jet Uncertaintes recommendations only exist for PFlow jets, falling back to AntiKt4EMPFlow");
401  jetdef = "AntiKt4EMPFlow";
402  }
403  toolName = "JetUncertaintiesPDSmearTool_" + jetdef;
404 
405  m_jetUncertaintiesPDSmearTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
406 
407  // If, for some reason, you're trying to use the PDSmear, with the reduced set return an error (you shouldn't do this, you're just going to duplicate the SimpleJER results.
408  bool JERUncPDsmearing = isData() ? isData() : m_jetUncertaintiesPDsmearing;
409  if (m_jetUncertaintiesConfig.find("SimpleJER") != std::string::npos && JERUncPDsmearing){
410  ATH_MSG_ERROR("You are trying to use the SimpleJER set, with PDsmearing. There is no functionality for this. Please fix your config file. Either run with PDSmear set to false, or run with the AllJER or FullJER sets.");
411  return StatusCode::FAILURE;
412  }
413  ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("JetDefinition", jetdef) );
415  ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("IsData", true) ); // Set to True by default for PDSmear-named tool.
418  ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("OutputLevel", this->msg().level()) );
420  } else{
421  ATH_MSG_DEBUG("Do not retrieve the jet PD Smearing tool if it is not configured");
422  //ATH_CHECK( m_jetUncertaintiesPDSmearTool.retrieve() );
423  }
424  }
425 
426  if (m_slices["fjet"]) {
427  ATH_MSG_INFO("Won't initialise jet uncertainty tool for fat jets until we get rec for UFO");
428  // Won't initialise jet uncertainty tool for fat jets until we get rec for UFO
429  /*
430  if (!m_fatjetUncertaintiesTool.isUserConfigured() && !m_fatJets.empty() && !m_fatJetUncConfig.empty()) {
431 
432  toolName = "JetUncertaintiesTool_" + m_fatJets;
433  m_fatjetUncertaintiesTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
434 
435  ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("JetDefinition", fatjetcoll) );
436  ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("MCType", "MC16") );
437  ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("IsData", isData()) );
438  ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("ConfigFile", m_fatJetUncConfig) );
439  if (m_jetUncertaintiesCalibArea != "default") ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("CalibArea", m_jetUncertaintiesCalibArea) );
440 
441  //Restrict variables to be shifted if (required)
442  if( m_fatJetUncVars != "default" ){
443  std::vector<std::string> shift_vars = {};
444 
445  std::string temp(m_fatJetUncVars);
446  do {
447  auto pos = temp.find(',');
448  shift_vars.push_back(temp.substr(0, pos));
449  if (pos == std::string::npos)
450  temp = "";
451  else
452  temp = temp.substr(pos + 1);
453 
454  }
455  while (!temp.empty() );
456 
457  ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("VariablesToShift", shift_vars) );
458  }
459 
460  ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("OutputLevel", this->msg().level()) );
461  ATH_CHECK( m_fatjetUncertaintiesTool.retrieve() );
462  } else if (m_fatjetUncertaintiesTool.isUserConfigured()) ATH_CHECK(m_fatjetUncertaintiesTool.retrieve());
463  */
464  ATH_MSG_INFO(" Won't initialise Wtagger uncertainty tool for fat jets until we get rec for UFO");
465  // Won't initialise Wtagger uncertainty tool for fat jets until we get rec for UFO
466  /*
467  if (!m_WTagjetUncertaintiesTool.isUserConfigured() && !m_fatJets.empty() && !m_WtagConfig.empty() && !m_WTagUncConfig.empty()) {
468 
469  toolName = "WTagJetUncertaintiesTool_" + m_fatJets;
470  m_WTagjetUncertaintiesTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
471  ATH_CHECK( m_WTagjetUncertaintiesTool.setProperty("JetDefinition", fatjetcoll) );
472  ATH_CHECK( m_WTagjetUncertaintiesTool.setProperty("MCType", "MC16") );
473  ATH_CHECK( m_WTagjetUncertaintiesTool.setProperty("IsData", isData()) );
474  ATH_CHECK( m_WTagjetUncertaintiesTool.setProperty("ConfigFile", "rel21/Fall2020/"+m_WTagUncConfig) );
475  ATH_CHECK( m_WTagjetUncertaintiesTool.setProperty("OutputLevel", this->msg().level()) );
476  ATH_CHECK( m_WTagjetUncertaintiesTool.retrieve() );
477  } else if (m_WTagjetUncertaintiesTool.isUserConfigured()) ATH_CHECK(m_WTagjetUncertaintiesTool.retrieve());
478  */
479  ATH_MSG_INFO(" Won't initialise Ztagger uncertainty tool for fat jets until we get rec for UFO");
480  // Won't initialise Ztagger uncertainty tool for fat jets until we get rec for UFO
481  /*
482  if (!m_ZTagjetUncertaintiesTool.isUserConfigured() && !m_fatJets.empty() && !m_ZtagConfig.empty() && !m_ZTagUncConfig.empty()) {
483 
484  toolName = "ZTagJetUncertaintiesTool_" + m_fatJets;
485  m_ZTagjetUncertaintiesTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
486  ATH_CHECK( m_ZTagjetUncertaintiesTool.setProperty("JetDefinition", fatjetcoll) );
487  ATH_CHECK( m_ZTagjetUncertaintiesTool.setProperty("ConfigFile", "rel21/Fall2020/"+m_ZTagUncConfig) );
488  ATH_CHECK( m_ZTagjetUncertaintiesTool.setProperty("MCType", "MC16") );
489  ATH_CHECK( m_ZTagjetUncertaintiesTool.setProperty("IsData", isData()) );
490  ATH_CHECK( m_ZTagjetUncertaintiesTool.setProperty("OutputLevel", this->msg().level()) );
491  ATH_CHECK( m_ZTagjetUncertaintiesTool.retrieve() );
492  } else if (m_ZTagjetUncertaintiesTool.isUserConfigured()) ATH_CHECK(m_ZTagjetUncertaintiesTool.retrieve());
493  */
494  ATH_MSG_INFO(" Won't initialise top-tagger uncertainty tool for fat jets until we get rec for UFO");
495  // Won't initialise top-tagger uncertainty tool for fat jets until we get rec for UFO
496  /*
497  if (!m_TopTagjetUncertaintiesTool.isUserConfigured() && !m_fatJets.empty() && !m_ToptagConfig.empty() && !m_TopTagUncConfig.empty()) {
498 
499  toolName = "TopTagJetUncertaintiesTool_" + m_fatJets;
500  m_TopTagjetUncertaintiesTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
501  ATH_CHECK( m_TopTagjetUncertaintiesTool.setProperty("JetDefinition", fatjetcoll) );
502  ATH_CHECK( m_TopTagjetUncertaintiesTool.setProperty("MCType", "MC16") );
503  ATH_CHECK( m_TopTagjetUncertaintiesTool.setProperty("IsData", isData()) );
504  ATH_CHECK( m_TopTagjetUncertaintiesTool.setProperty("ConfigFile", "rel21/Fall2020/"+m_TopTagUncConfig) );
505  ATH_CHECK( m_TopTagjetUncertaintiesTool.setProperty("OutputLevel", this->msg().level()) );
506  ATH_CHECK( m_TopTagjetUncertaintiesTool.retrieve() );
507  } else if (m_TopTagjetUncertaintiesTool.isUserConfigured()) ATH_CHECK(m_TopTagjetUncertaintiesTool.retrieve());
508  */
509  }
510 
511 
512  // tagger SF and uncertainties
513  // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/BoostedJetTaggingRecommendationFullRun2
514  // To be implemented here
515 
516  if (m_slices["jet"]) {
518  // Initialise jet cleaning tools
519 
520  // see https://twiki.cern.ch/twiki/bin/view/AtlasProtected/HowToCleanJetsR22
522  toolName = "JetCleaningTool";
523  m_jetCleaningTool.setTypeAndName("JetCleaningTool/"+toolName);
525  ATH_CHECK( m_jetCleaningTool.setProperty("DoUgly", false) );
526  ATH_CHECK( m_jetCleaningTool.setProperty("OutputLevel", this->msg().level()) );
529 
531  // Initialise jet pileup labeling tool (required for labels used by JvtEfficiencyTools)
532 
534  toolName = "PileupLabelingTool";
535  m_jetPileupLabelingTool.setTypeAndName("JetPileupLabelingTool/"+toolName);
538  #ifndef XAOD_STANDALONE
539  ATH_CHECK( m_jetPileupLabelingTool.setProperty("SuppressInputDependence", true) );
540  ATH_CHECK( m_jetPileupLabelingTool.setProperty("SuppressOutputDependence", true) );
541  #endif
542  ATH_CHECK( m_jetPileupLabelingTool.setProperty("OutputLevel", this->msg().level()) );
545 
547  // Initialise jet Jvt moment tool
548 
550  toolName = "JvtMomentTool";
551  m_jetJvtMomentTool.setTypeAndName("JetVertexTaggerTool/"+toolName);
553  #ifndef XAOD_STANDALONE
554  ATH_CHECK( m_jetJvtMomentTool.setProperty("SuppressInputDependence", true) );
555  ATH_CHECK( m_jetJvtMomentTool.setProperty("SuppressOutputDependence", true) );
556  #endif
557  ATH_CHECK( m_jetJvtMomentTool.setProperty("OutputLevel", this->msg().level()) );
560 
562  // Initialise jet NNJvt moment tool
563 
564  m_applyJVTCut = !m_JvtWP.empty();
566  toolName = "NNJvtMomentTool";
567  m_jetNNJvtMomentTool.setTypeAndName("JetPileupTag::JetVertexNNTagger/"+toolName);
569  #ifndef XAOD_STANDALONE
570  ATH_CHECK( m_jetNNJvtMomentTool.setProperty("SuppressInputDependence", true) );
571  ATH_CHECK( m_jetNNJvtMomentTool.setProperty("SuppressOutputDependence", true) );
572  #endif
573  ATH_CHECK( m_jetNNJvtMomentTool.setProperty("OutputLevel", this->msg().level()) );
576 
578  // Initialise jet NNJvt selection tool
579 
581  toolName = "NNJvtSelectionTool";
582  m_jetNNJvtSelectionTool.setTypeAndName("CP::NNJvtSelectionTool/"+toolName);
586  ATH_CHECK( m_jetNNJvtSelectionTool.setProperty("JvtMomentName", "NNJvt") );
587  ATH_CHECK( m_jetNNJvtSelectionTool.setProperty("OutputLevel", this->msg().level()) );
590 
592  // Initialise jet NNJvt efficiency tool (scale factors)
593 
595  toolName = "NNJvtEfficiencyTool";
596  m_jetNNJvtEfficiencyTool.setTypeAndName("CP::NNJvtEfficiencyTool/"+toolName);
601  ATH_CHECK( m_jetNNJvtEfficiencyTool.setProperty("OutputLevel", this->msg().level()) );
604 
606  // Initialise jet fJvt selection tool
607 
609  toolName = "fJvtSelectionTool";
610  m_jetfJvtSelectionTool.setTypeAndName("CP::FJvtSelectionTool/"+toolName);
614  ATH_CHECK( m_jetfJvtSelectionTool.setProperty("JvtMomentName", "DFCommonJets_fJvt") );
615  ATH_CHECK( m_jetfJvtSelectionTool.setProperty("OutputLevel", this->msg().level()) );
618 
620  // Initialise jet fJvt efficiency tool for scale factors (scale factors)
621 
623  toolName = "fJvtEfficiencyTool";
624  m_jetfJvtEfficiencyTool.setTypeAndName("CP::FJvtEfficiencyTool/"+toolName);
629  ATH_CHECK( m_jetfJvtEfficiencyTool.setProperty("OutputLevel", this->msg().level()) );
632  }
633 
634 
635  if (m_slices["mu"]) {
637  // Check muon baseline ID
638 
639  std::string muQualBaseline = "";
640  switch (m_muIdBaseline) {
641  case xAOD::Muon::VeryLoose: muQualBaseline = "VeryLoose";
642  ATH_MSG_WARNING("No muon scale factors are available for VeryLoose working point.");
643  break;
644  case xAOD::Muon::Loose: muQualBaseline = "Loose"; break;
645  case xAOD::Muon::Medium: muQualBaseline = "Medium"; break;
646  case xAOD::Muon::Tight: muQualBaseline = "Tight"; break;
647  case 4: muQualBaseline = "HighPt"; break;
648  case 5: muQualBaseline = "LowPt"; break;
649  case 6: muQualBaseline = "LowPtMVA"; break;
650  case 7: muQualBaseline = "HighPt3Layers"; break;
651  default:
652  ATH_MSG_ERROR("Invalid muon working point provided: " << m_muIdBaseline << ". Cannot initialise!");
653  return StatusCode::FAILURE;
654  break;
655  }
656 
658  // Initialise muon calibration tool
659  // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/MuonMomentumCorrectionsSubgroup#CP_MuonCalibrationAndSmearingToo
660  // Please not that for AthAnalysis we need to configure the MuonCalibTool within METSignificance manually and just can't pass the handle
661  // Hence, any changes here should also be propagated to the METSignificance setup further below
662 
664  m_muonCalibTool.setTypeAndName("CP::MuonCalibTool/ST_MuonCalibrationTool");
665  if (m_isRun3) ATH_CHECK( m_muonCalibTool.setProperty("IsRun3Geo", true ));
667  ATH_CHECK( m_muonCalibTool.setProperty("OutputLevel", this->msg().level()) );
668  ATH_CHECK( m_muonCalibTool.setProperty("release", "Recs2024_05_06_Run2Run3" ));
669  int IdBaselineInt = m_muIdBaseline;
670  if (IdBaselineInt == 4) {
671  ATH_CHECK( m_muonCalibTool.setProperty("do2StationsHighPt", true) );
672  }
675  } else ATH_CHECK( m_muonCalibTool.retrieve() );
676 
678  // Initialise muon selection tool
679 
681  toolName = "MuonSelectionTool_Baseline_" + muQualBaseline;
682  m_muonSelectionToolBaseline.setTypeAndName("CP::MuonSelectionTool/"+toolName);
683  if (m_isRun3) ATH_CHECK( m_muonSelectionToolBaseline.setProperty("IsRun3Geo", true ));
684 
685  if (m_muBaselineEta<m_muEta){ // Test for inconsistent configuration
686  ATH_MSG_ERROR( "Requested a baseline eta cut for muons (" << m_muBaselineEta <<
687  ") that is tighter than the signal cut (" << m_muEta << "). Please check your config." );
688  return StatusCode::FAILURE;
689  }
690  int IdBaselineInt = m_muIdBaseline;
692  if (IdBaselineInt == 6){
694  ATH_CHECK( m_muonSelectionToolBaseline.setProperty( "UseMVALowPt", true));
695  } else if (IdBaselineInt == 7){
697  ATH_CHECK( m_muonSelectionToolBaseline.setProperty( "Use2stationMuonsHighPt", false));
699  ATH_CHECK( m_muonSelectionToolBaseline.setProperty("OutputLevel", this->msg().level()) );
702 
703 
704  std::string muQual = "";
705  switch (m_muId) {
706  case xAOD::Muon::VeryLoose: muQual = "VeryLoose";
707  ATH_MSG_WARNING("No muon scale factors are available for VeryLoose working point.");
708  break;
709  case xAOD::Muon::Loose: muQual = "Loose"; break;
710  case xAOD::Muon::Medium: muQual = "Medium"; break;
711  case xAOD::Muon::Tight: muQual = "Tight"; break;
712  case 4: muQual = "HighPt"; break;
713  case 5: muQual = "LowPt"; break;
714  case 6: muQual = "LowPtMVA"; break;
715  case 7: muQual = "HighPt3Layers"; break;
716  default:
717  ATH_MSG_ERROR("Invalid muon working point provided: " << m_muId << ". Cannot initialise!");
718  return StatusCode::FAILURE;
719  break;
720  }
721 
723  toolName = "MuonSelectionTool_" + muQual;
724  m_muonSelectionTool.setTypeAndName("CP::MuonSelectionTool/"+toolName);
725  if (m_isRun3) ATH_CHECK( m_muonSelectionTool.setProperty("IsRun3Geo", true ));
727  int IdInt = m_muId;
728  if (IdInt == 6){
729  ATH_CHECK( m_muonSelectionTool.setProperty( "MuQuality", 5 ) );
730  ATH_CHECK( m_muonSelectionTool.setProperty( "UseMVALowPt", true));
731  } else if (IdInt == 7){
732  ATH_CHECK( m_muonSelectionTool.setProperty( "MuQuality", 4 ) );
733  ATH_CHECK( m_muonSelectionTool.setProperty( "Use2stationMuonsHighPt", false));
734  } else ATH_CHECK(m_muonSelectionTool.setProperty( "MuQuality", m_muId ));
735  ATH_CHECK( m_muonSelectionTool.setProperty("OutputLevel", this->msg().level()) );
738 
739 
740  if (!m_muonSelectionHighPtTool.isUserConfigured()) { //Fixed to HighPt WP
741  toolName = "MuonSelectionHighPtTool_" + muQual;
742  m_muonSelectionHighPtTool.setTypeAndName("CP::MuonSelectionTool/"+toolName);
743  if (m_isRun3) ATH_CHECK( m_muonSelectionHighPtTool.setProperty("IsRun3Geo", true ));
745  ATH_CHECK( m_muonSelectionHighPtTool.setProperty( "MuQuality", 4 ) );
746  ATH_CHECK( m_muonSelectionHighPtTool.setProperty("OutputLevel", this->msg().level()) );
749 
750 
752  // Initialise prompt/LRT muon OR tool
754  toolName = "MuonLRTOverlapRemovalTool";
755  m_muonLRTORTool.setTypeAndName("CP::MuonLRTOverlapRemovalTool/"+toolName);
757  if (m_isRun3) ATH_CHECK( m_muonLRTORTool.setProperty("UseRun3WP", true ));
758  ATH_CHECK( m_muonLRTORTool.setProperty("OutputLevel", this->msg().level()) );
760  } else ATH_CHECK( m_muonLRTORTool.retrieve() );
761 
763  // Initialise muon efficiency tools
765  toolName = "MuonEfficiencyScaleFactors_" + muQual;
766  m_muonEfficiencySFTool.setTypeAndName("CP::MuonEfficiencyScaleFactors/"+toolName);
767  ATH_CHECK( m_muonEfficiencySFTool.setProperty("WorkingPoint", muQual) );
768  ATH_CHECK( m_muonEfficiencySFTool.setProperty("CalibrationRelease", m_isRun3? "240711_Preliminary_r24run3":"230213_Preliminary_r22run2") );
769  ATH_CHECK( m_muonEfficiencySFTool.setProperty("OutputLevel", this->msg().level()) );
772 
773 
775  toolName = "MuonEfficiencyScaleFactorsBMHighPt_" + muQual;
776  m_muonEfficiencyBMHighPtSFTool.setTypeAndName("CP::MuonEfficiencyScaleFactors/"+toolName);
777  ATH_CHECK( m_muonEfficiencyBMHighPtSFTool.setProperty("WorkingPoint", "BadMuonVeto_HighPt") );
778  ATH_CHECK( m_muonEfficiencyBMHighPtSFTool.setProperty("CalibrationRelease", m_isRun3? "220817_Preliminary_r22run3":"230213_Preliminary_r22run2") ); //BadMuonVeto_HighPt currently not available for 240711_Preliminary_r24run3
779  ATH_CHECK( m_muonEfficiencyBMHighPtSFTool.setProperty("OutputLevel", this->msg().level()) );
782 
783 
784  if (m_doTTVAsf && m_mud0sig<0 && m_muz0<0){
785  ATH_MSG_WARNING("Requested TTVA SFs without d0sig and z0 cuts. Disabling scale factors as they will not make sense.");
786  m_doTTVAsf=false;
787  }
788 
790  toolName = "MuonTTVAEfficiencyScaleFactors";
791  m_muonTTVAEfficiencySFTool.setTypeAndName("CP::MuonEfficiencyScaleFactors/"+toolName);
792  ATH_CHECK( m_muonTTVAEfficiencySFTool.setProperty("WorkingPoint", "TTVA") );
793  ATH_CHECK( m_muonTTVAEfficiencySFTool.setProperty("CalibrationRelease", m_isRun3? "240711_Preliminary_r24run3":"230213_Preliminary_r22run2") );
794  ATH_CHECK( m_muonTTVAEfficiencySFTool.setProperty("OutputLevel", this->msg().level()) );
797 
798 
799 
801  // Initialise muon isolation tool
802  if (!m_muonIsolationSFTool.isUserConfigured() && !m_muIso_WP.empty() && !isData()) {
803  toolName = "MuonIsolationScaleFactors_" + m_muIso_WP;
804 
805  std::string tmp_muIso_WP = m_muIso_WP;
806  if ( !check_isOption(m_muIso_WP, m_mu_iso_support) ) { //check if supported
807  ATH_MSG_WARNING("Your selected muon Iso WP ("
808  << m_muIso_WP
809  << ") does not have SFs defined. Will try to find an appropriate fall-back.");
810  if (m_mu_iso_fallback.count(m_muIso_WP) > 0){
811  tmp_muIso_WP = m_mu_iso_fallback[m_muIso_WP];
812  ATH_MSG_WARNING("Your selected muon Iso WP ("
813  << m_muIso_WP
814  << " is not supported, and does not have SFs available. Falling back to "
815  << tmp_muIso_WP
816  << " for SF determination.");
817  } else {
818  ATH_MSG_ERROR("*** The muon isolation WP you selected (" << m_muIso_WP << ") is not currentely supported, and no known fall-back option for SFs exists. Sorry! ***");
819  return StatusCode::FAILURE;
820  }
821  }
822 
823  m_muonIsolationSFTool.setTypeAndName("CP::MuonEfficiencyScaleFactors/"+toolName);
824  ATH_CHECK( m_muonIsolationSFTool.setProperty("WorkingPoint", tmp_muIso_WP + "Iso") );
825  ATH_CHECK( m_muonIsolationSFTool.setProperty("CalibrationRelease", m_isRun3? "240711_Preliminary_r24run3":"230213_Preliminary_r22run2") );
826  ATH_CHECK( m_muonIsolationSFTool.setProperty("OutputLevel", this->msg().level()) );
828 
830 
831 
833  toolName = "MuonHighPtIsolationScaleFactors_" + m_muIsoHighPt_WP;
834 
835  std::string tmp_muIsoHighPt_WP = m_muIsoHighPt_WP;
836  if ( !check_isOption(m_muIsoHighPt_WP, m_mu_iso_support) ) { //check if supported
837  ATH_MSG_WARNING("Your selected muon high-pt Iso WP ("
839  << ") does not have SFs defined. Will try to find an appropriate fall-back.");
840  if (m_mu_iso_fallback.count(m_muIsoHighPt_WP) > 0){
841  tmp_muIsoHighPt_WP = m_mu_iso_fallback[m_muIsoHighPt_WP];
842  ATH_MSG_WARNING("Your selected muon high-pt Iso WP ("
844  << " is not supported, and does not have SFs available. Falling back to "
845  << tmp_muIsoHighPt_WP
846  << " for SF determination.");
847  } else {
848  ATH_MSG_ERROR("*** The muon isolation WP you selected (" << m_muIsoHighPt_WP << ") is not currentely supported, and no known fall-back option for SFs exists. Sorry! ***");
849  return StatusCode::FAILURE;
850  }
851  }
852 
853  m_muonHighPtIsolationSFTool.setTypeAndName("CP::MuonEfficiencyScaleFactors/"+toolName);
854  // Use for the low-pt WP a dedicated set of isolation scale-factors having an extra uncertainty in place
855  ATH_CHECK( m_muonHighPtIsolationSFTool.setProperty("WorkingPoint", tmp_muIsoHighPt_WP + "Iso") );
856  ATH_CHECK( m_muonHighPtIsolationSFTool.setProperty("CalibrationRelease", m_isRun3? "240711_Preliminary_r24run3":"230213_Preliminary_r22run2") );
857  ATH_CHECK( m_muonHighPtIsolationSFTool.setProperty("OutputLevel", this->msg().level()) );
859 
861 
862 
864  // Initialise muon trigger scale factor tools
865 
867  toolName = "MuonTriggerScaleFactors_" + muQual;
868  m_muonTriggerSFTool.setTypeAndName("CP::MuonTriggerScaleFactors/"+toolName);
869  if ( muQual=="LowPt" ) {
870  ATH_MSG_WARNING("You're using the LowPt muon selection, which is not supported yet in terms of muon trigger scale facorts. TEMPORAIRLY configuring the muonTriggerSFTool for Medium muons. Beware!");
871  ATH_CHECK( m_muonTriggerSFTool.setProperty("MuonQuality", "Medium" ) );
872  }
873  else ATH_CHECK( m_muonTriggerSFTool.setProperty("MuonQuality", muQual) );
874  //ATH_CHECK( m_muonTriggerSFTool.setProperty("Isolation", m_muIso_WP)); This property has been depreacted long time ago
875  ATH_CHECK( m_muonTriggerSFTool.setProperty("AllowZeroSF", true) );
876  ATH_CHECK( m_muonTriggerSFTool.setProperty("OutputLevel", this->msg().level()) );
879  } else if (m_muonTriggerSFTool.isUserConfigured()) {
882  }
883  }
884 
885  if (m_slices["ele"]) {
886  // /////////////////////////////////////////////////////////////////////////////////////////
887  // Initialise electron selector tools
888 
889  // Signal Electrons
891  toolName = "EleSelLikelihood_" + m_eleId;
892 
893  if (m_eleId.find("DNN") != std::string::npos) {
894  m_elecSelLikelihood.setTypeAndName("AsgElectronSelectorTool/"+toolName);
895  }
896  else {
897  m_elecSelLikelihood.setTypeAndName("AsgElectronLikelihoodTool/"+toolName);
898  }
899 
900  if (! m_eleConfig.empty() ){
901  ATH_MSG_INFO("Overriding specified Ele.Id working point in favour of configuration file");
903  } else if ( !check_isOption(m_eleId, m_el_id_support) ) { //check if supported
904  ATH_MSG_ERROR("Invalid electron ID selected: " << m_eleId);
905  return StatusCode::FAILURE;
906  }
907  else if (m_eleId == "VeryLooseLLH" || m_eleId == "LooseLLH") {
908  ATH_MSG_WARNING(" ****************************************************************************");
909  ATH_MSG_WARNING(" CAUTION: Setting " << m_eleId << " as signal electron ID");
910  ATH_MSG_WARNING(" These may be used for loose electron CRs but no scale factors are provided.");
911  ATH_MSG_WARNING(" ****************************************************************************");
913  } else {
915  }
916 
917  ATH_CHECK( m_elecSelLikelihood.setProperty("OutputLevel", this->msg().level()) );
920 
921  // Baseline Electrons
923  toolName = "EleSelLikelihoodBaseline_" + m_eleIdBaseline;
924 
925  if (m_eleIdBaseline.find("DNN") != std::string::npos) {
926  m_elecSelLikelihoodBaseline.setTypeAndName("AsgElectronSelectorTool/"+toolName);
927  }
928  else {
929  m_elecSelLikelihoodBaseline.setTypeAndName("AsgElectronLikelihoodTool/"+toolName);
930  }
931 
932  if (! m_eleConfigBaseline.empty() ){
933  ATH_MSG_INFO("Overriding specified EleBaseline.Id working point in favour of configuration file");
935  } else if ( !check_isOption(m_eleIdBaseline, m_el_id_support) ) { //check if supported
936  ATH_MSG_ERROR("Invalid electron ID selected: " << m_eleIdBaseline);
937  return StatusCode::FAILURE;
938  } else {
940  }
941 
942  ATH_CHECK( m_elecSelLikelihoodBaseline.setProperty("OutputLevel", this->msg().level()) );
945  }
946 
948  // Initialise prompt/LRT electron OR tool
950  toolName = "ElectronLRTOverlapRemovalTool";
951  m_elecLRTORTool.setTypeAndName("CP::ElectronLRTOverlapRemovalTool/"+toolName);
952  ATH_MSG_DEBUG("Setting ElectronLRTOverlapRemovalTool strategy to "<<m_eleLRT_strat);
953  ATH_CHECK( m_elecLRTORTool.setProperty("overlapStrategy", m_eleLRT_strat) );
955  } else ATH_CHECK( m_elecLRTORTool.retrieve() );
956 
957  if (m_slices["pho"]) {
958  // /////////////////////////////////////////////////////////////////////////////////////////
959  // Initialise photon selector tools
960 
962  toolName = "PhotonSelIsEM_" + m_photonId;
963  m_photonSelIsEM.setTypeAndName("AsgPhotonIsEMSelector/"+toolName);
964 
965  if (!check_isOption(m_photonId, m_ph_id_support)){ //check if supported
966  ATH_MSG_ERROR("Invalid photon ID selected: " << m_photonId);
967  return StatusCode::FAILURE;
968  }
969 
970  ATH_CHECK( m_photonSelIsEM.setProperty("WorkingPoint", m_photonId+"Photon") );
971  ATH_CHECK( m_photonSelIsEM.setProperty("OutputLevel", this->msg().level()) );
973  } else ATH_CHECK( m_photonSelIsEM.retrieve() );
974 
976  toolName = "PhotonSelIsEMBaseline_" + m_photonIdBaseline;
977  m_photonSelIsEMBaseline.setTypeAndName("AsgPhotonIsEMSelector/"+toolName);
978 
979  if(!check_isOption(m_photonIdBaseline, m_ph_id_support)){ //check if supported
980  ATH_MSG_ERROR("Invalid photon ID selected: " << m_photonIdBaseline);
981  return StatusCode::FAILURE;
982  }
983 
985  ATH_CHECK( m_photonSelIsEMBaseline.setProperty("OutputLevel", this->msg().level()) );
988  }
989 
990  if (m_slices["ele"]||m_slices["pho"]) {
992  // Initialise DeadHVCellRemovalTool
993  // https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/EGammaIdentificationRun2#Removal_of_Electron_Photon_clust
994 
995  ATH_MSG_DEBUG("Setup AsgDeadHVCellRemovalTool/deadHVTool");
996  m_deadHVTool.setTypeAndName("AsgDeadHVCellRemovalTool/deadHVTool");
998  }
999 
1000  if (m_slices["ele"]) {
1002  // Initialise electron efficiency tool
1003 
1005  if (!isData()) {
1006  if (isAtlfast()) data_type = PATCore::ParticleDataType::Fast;
1007  else data_type = PATCore::ParticleDataType::Full;
1008  ATH_MSG_DEBUG( "Setting data type to " << data_type);
1009  }
1010 
1011  m_eleEffMapFilePathRun2 = "ElectronEfficiencyCorrection/2015_2018/rel21.2/Precision_Summer2020_v1/map4.txt";
1012 
1013  if(!m_isRun3) {
1014  ATH_MSG_INFO( "Running on Run2 samples; Using egamma SF tools from R21 map ");
1016  }
1017 
1018  toolName = "AsgElectronEfficiencyCorrectionTool_reco";
1020 
1021  //-- get KEYS supported by egamma SF tools
1022  std::vector<std::string> eSF_keys = getElSFkeys( m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2);
1023 
1024  if (m_eleId.find("NoPix") != std::string::npos || m_eleId == "VeryLooseLLH" || m_eleId == "LooseLLH" || m_eleId == "Medium") {
1025  ATH_MSG_WARNING("Not configuring electron ID and trigger scale factors for " << m_eleId);
1026  }
1027  else {
1028  // This needs to be formatted for the scale factors: no _Rel20, no LH label, etc.
1029  std::string eleId = TString(m_eleId).ReplaceAll("AndBLayer", "BLayer").ReplaceAll("LLH", "").Data();
1030 
1031  if (m_eleId.find("DNN") != std::string::npos) {
1032  eleId = TString(eleId).ReplaceAll("DNNnoCF", "").ReplaceAll("DNN", "").ReplaceAll("Loose", "LooseBLayer").Data();
1033  ATH_MSG_WARNING("Electron DNN ID working point " << m_eleId << " doesn't have SFs yet, fall back to " << eleId);
1034  }
1035 
1036  // electron id
1037  toolName = "AsgElectronEfficiencyCorrectionTool_id_" + m_eleId;
1039 
1040  // override map file use if correction file list is set for WP
1041  std::map<std::string,std::string> corrFNList;
1042  if ( !m_EG_corrFNList.empty() ) {
1043  for ( const auto& WP_fname : split( m_EG_corrFNList, "," ) ) {
1044  std::string WP = WP_fname.substr(0,WP_fname.find(":"));
1045  std::string fname = WP_fname.substr(WP_fname.find(":")+1);
1046  corrFNList[WP] = fname;
1047  ATH_MSG_WARNING( "Correction file list defined for WP " << WP << ": " << fname << "." );
1048  ATH_MSG_WARNING( "Will use correction file rather than central map file." );
1049  }
1050  }
1051 
1052  // electron iso
1053  std::string EleIso("");
1054  if (std::find(eSF_keys.begin(), eSF_keys.end(), eleId+"_"+m_eleIso_WP) != eSF_keys.end()){
1055  EleIso = m_eleIso_WP;
1056  } else if (std::find(eSF_keys.begin(), eSF_keys.end(), eleId+"_"+m_el_iso_fallback[m_eleIso_WP]) != eSF_keys.end()){
1057  //--- Check to see if the only issue is an unknown isolation working point
1058  EleIso = m_el_iso_fallback[m_eleIso_WP];
1059  ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool_iso_*) Your selected electron Iso WP ("
1060  << m_eleIso_WP
1061  << ") does not have iso SFs defined. Falling back to "
1063  << " for SF calculations");
1064  }
1065  else{
1066  ATH_MSG_ERROR("*** THE ELECTRON ISOLATION SF YOU SELECTED (" << m_eleIso_WP << ") GOT NO SUPPORT ***");
1067  return StatusCode::FAILURE;
1068  }
1069 
1070  toolName = "AsgElectronEfficiencyCorrectionTool_iso_" + m_eleId + EleIso;
1071 
1072  // if running with correction file list
1073  if ( (!m_EG_corrFNList.empty()) && corrFNList.find(EleIso)!=corrFNList.end() ) { // overriding central map file
1074  CONFIG_EG_EFF_TOOL( m_elecEfficiencySFTool_iso, toolName, corrFNList[EleIso] );
1075  }
1076  // can't do the iso tool via the macro, it needs two properties set
1077  else { // default: use map file
1079  if ( !check_isOption(EleIso, m_el_iso_support) ) { //check if supported
1080  ATH_MSG_WARNING( "(" << toolName << ") Your electron Iso WP: " << EleIso<< " is no longer supported. This will almost certainly cause a crash now.");
1081  }
1082 
1083  m_elecEfficiencySFTool_iso.setTypeAndName("AsgElectronEfficiencyCorrectionTool/"+toolName);
1084 
1085  if ( m_EG_corrFNList.empty() ) {
1087  } else {
1088  ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("CorrectionFileNameList", corrFNList) );
1089  }
1091  ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("IsoKey", EleIso) );
1092  if (!isData() && ((EleIso.find("TightTrackOnly_VarRad")!=std::string::npos)||
1093  (EleIso.find("TightTrackOnly_FixedRad")!=std::string::npos)||
1094  (EleIso.find("Tight_VarRad")!=std::string::npos)||
1095  (EleIso.find("Loose_VarRad")!=std::string::npos))) {
1096  if (isAtlfast()) ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool/"+toolName+"). Your selected electron Iso WP (" + EleIso + ") don't have AFII SF. Falling back to FullSim");
1098  }
1099  else if (!isData()){
1100  ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("ForceDataType", static_cast<int>(data_type)));
1101  }
1103  ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("OutputLevel", this->msg().level()) );
1106  }
1107 
1108  // electron iso high-pt
1109  std::string EleIsohighPt("");
1110  if (std::find(eSF_keys.begin(), eSF_keys.end(), eleId+"_"+m_eleIsoHighPt_WP) != eSF_keys.end()){
1111  EleIsohighPt = m_eleIsoHighPt_WP;
1112  } else if (std::find(eSF_keys.begin(), eSF_keys.end(), eleId+"_"+m_el_iso_fallback[m_eleIsoHighPt_WP]) != eSF_keys.end()){
1113  //--- Check to see if the only issue is an unknown isolation working point
1114  EleIsohighPt = m_el_iso_fallback[m_eleIsoHighPt_WP];
1115  ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool_iso_*) Your selected high-pT electron Iso WP ("
1117  << ") does not have iso SFs defined. Falling back to "
1119  << " for SF calculations");
1120  }
1121  else{
1122  ATH_MSG_ERROR("*** THE HIGH PT ELECTRON ISOLATION SF YOU SELECTED (" << m_eleIsoHighPt_WP << ") GOT NO SUPPORT");
1123  return StatusCode::FAILURE;
1124  }
1125 
1126  toolName = "AsgElectronEfficiencyCorrectionTool_isoHigPt_" + m_eleId + EleIsohighPt;
1127 
1128  // if running with correction file list
1129  if ( (!m_EG_corrFNList.empty()) && corrFNList.find(EleIsohighPt)!=corrFNList.end() ) { // overriding central map file
1130  CONFIG_EG_EFF_TOOL( m_elecEfficiencySFTool_isoHighPt, toolName, corrFNList[EleIsohighPt] );
1131  }
1132  // can't do the iso tool via the macro, it needs two properties set
1133  else { // default: use map file
1135 
1136  if ( !check_isOption(EleIsohighPt, m_el_iso_support) ) { //check if supported
1137  ATH_MSG_WARNING( "(" << toolName << ") Your electron high-pt Iso WP: " << EleIsohighPt << " is no longer supported. This will almost certainly cause a crash now.");
1138  }
1139 
1140  m_elecEfficiencySFTool_isoHighPt.setTypeAndName("AsgElectronEfficiencyCorrectionTool/"+toolName);
1141 
1144  ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.setProperty("IsoKey", EleIsohighPt) );
1145  if (!isData()) {
1146  ATH_CHECK (m_elecEfficiencySFTool_isoHighPt.setProperty("ForceDataType", (int) data_type) );
1147  }
1149  ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.setProperty("OutputLevel", this->msg().level()) );
1152  }
1153 
1154  // electron triggers - first SFs (but we need to massage the id string since all combinations are not supported)
1155 
1156  //single lepton
1157 
1158  if(m_isRun3 && eleId.find("LooseBLayer") != std::string::npos) ATH_MSG_WARNING("Replacing 'LooseBLayer' with 'Loose' for Electron ID while configuring single-ele trigger SF using: " << m_eleEffMapFilePath);
1159  std::string triggerEleID = m_isRun3? TString(eleId).ReplaceAll("LooseBLayer", "Loose").Data() : eleId;
1160  std::string triggerEleIso= m_eleIso_WP;
1161 
1162  // This is an hack to work with ElectronEfficiencyCorrection/2015_2025/rel22.2/2022_Summer_Prerecom_v1/map4.txt to allow
1163 
1165  bool pass_isRun3TrigSFFallback = true;
1166  if (triggerEleID.find("Medium") != std::string::npos && triggerEleIso.find("Loose") != std::string::npos) {triggerEleID = "Loose";}
1167  else if (triggerEleID.find("Medium") != std::string::npos && triggerEleIso.find("Tight") != std::string::npos) {triggerEleID = "Tight"; triggerEleIso = "Tight_VarRad";}
1168  else if (triggerEleID.find("Medium") != std::string::npos && triggerEleIso.find("HighPtCaloOnly") != std::string::npos) {triggerEleID = "Tight"; triggerEleIso = "Tight_VarRad";}
1169  else if (triggerEleID.find("Tight") != std::string::npos && triggerEleIso.find("Loose") != std::string::npos) {triggerEleID = "Loose";}
1170  else if (triggerEleID.find("Tight") != std::string::npos && triggerEleIso.find("Tight") != std::string::npos) {triggerEleIso= "Tight_VarRad";}
1171  else if (triggerEleID.find("Tight") != std::string::npos && triggerEleIso.find("HighPtCaloOnly") != std::string::npos) {triggerEleID = "Tight"; triggerEleIso = "Tight_VarRad";}
1172  else if (triggerEleID.find("Loose") != std::string::npos && triggerEleIso.find("Tight") != std::string::npos) {triggerEleID = "Loose"; triggerEleIso = "Loose_VarRad";}
1173  else if (triggerEleID.find("Loose") != std::string::npos && triggerEleIso.find("HighPtCaloOnly") != std::string::npos) {triggerEleID = "Loose"; triggerEleIso = "Loose_VarRad";}
1174  else {pass_isRun3TrigSFFallback=false;}
1175  if(pass_isRun3TrigSFFallback){
1176  ATH_MSG_INFO(" ************** This is only for testing/studying purpose! ************** ");
1177  ATH_MSG_INFO(" ************** For official recommendation, please get in contact with the SUSY Bkg Forum ************** ");
1178  ATH_MSG_INFO("In the current map ("<<m_eleEffMapFilePath<<"), the only supported Electron ID working-points supported for Electron Trigger Scale Factor are 'Loose_Loose_VarRad' and 'Tight_Tight_VarRad' ");
1179  ATH_MSG_INFO("Only for single-lepton trigger scale factor, fall back to Electron ID: -> "<< triggerEleID << " with Isolation: " << triggerEleIso);
1180  }
1181  }
1182 
1183 
1184  ATH_MSG_INFO("eSF_keys: " << m_electronTriggerSFStringSingle<< "_"<<triggerEleID<<"_"<<triggerEleIso);
1185 
1186  if (std::find(eSF_keys.begin(), eSF_keys.end(), m_electronTriggerSFStringSingle+"_"+triggerEleID+"_"+triggerEleIso) != eSF_keys.end()){
1187  triggerEleIso = m_eleIso_WP;
1188  } else if (std::find(eSF_keys.begin(), eSF_keys.end(), m_electronTriggerSFStringSingle+"_"+triggerEleID+"_"+m_el_iso_fallback[triggerEleIso]) != eSF_keys.end()){
1189  //--- Check to see if the only issue is an unknown isolation working point
1190  triggerEleIso = m_el_iso_fallback[triggerEleIso];
1191  ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool_trig_singleLep_*) Your selected electron Iso WP ("
1192  << m_eleIso_WP
1193  << ") does not have trigger SFs defined. Falling back to "
1194  << triggerEleIso
1195  << " for SF calculations");
1196  }
1197  else{
1198  ATH_MSG_ERROR("*** THE SINGLE ELECTRON TRIGGER SF YOU SELECTED (" << m_electronTriggerSFStringSingle << ") GOT NO SUPPORT FOR YOUR ID+ISO WPs (" << m_eleId << "+" << m_eleIso_WP << ") ***");
1199  return StatusCode::FAILURE;
1200  }
1201 
1202  toolName = "AsgElectronEfficiencyCorrectionTool_trig_singleLep_" + triggerEleID;
1204  m_elecEfficiencySFTool_trig_singleLep.setTypeAndName("AsgElectronEfficiencyCorrectionTool/"+toolName);
1208  ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("IsoKey", triggerEleIso) );
1210  if (!isData()) {
1212  }
1213  ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("OutputLevel", this->msg().level()) );
1216 
1217 
1218  toolName = "AsgElectronEfficiencyCorrectionTool_trigEff_singleLep_" + triggerEleID;
1220  m_elecEfficiencySFTool_trigEff_singleLep.setTypeAndName("AsgElectronEfficiencyCorrectionTool/"+toolName);
1226  if (!isData()) {
1228  }
1229  ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("OutputLevel", this->msg().level()) );
1232 
1233  if (!m_isRun3){
1234  //mixed-leptons
1235  std::map<std::string,std::string> electronTriggerSFMapMixedLepton {
1236  // legs, Trigger keys,
1237  {"e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose,e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0", m_electronTriggerSFStringSingle},
1238  {"e24_lhvloose_nod0_L1EM20VH,e17_lhvloose_nod0,e12_lhloose_L1EM10VH","DI_E_2015_e12_lhloose_L1EM10VH_2016_e17_lhvloose_nod0_2017_2018_e24_lhvloose_nod0_L1EM20VH"},
1239  {"e26_lhmedium_nod0_L1EM22VHI,e26_lhmedium_nod0","MULTI_L_2015_e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose_2016_e26_lhmedium_nod0_L1EM22VHI_2017_2018_e26_lhmedium_nod0"},
1240  {"e17_lhloose,e17_lhloose_nod0","MULTI_L_2015_e17_lhloose_2016_2018_e17_lhloose_nod0"},
1241  {"e12_lhloose,e12_lhloose_nod0","MULTI_L_2015_e12_lhloose_2016_2018_e12_lhloose_nod0"},
1242  {"e7_lhmedium,e7_lhmedium_nod0","MULTI_L_2015_e7_lhmedium_2016_2018_e7_lhmedium_nod0"},
1243  {"e9_lhloose,e9_lhloose_nod0,e12_lhvloose_nod0_L1EM10VH","TRI_E_2015_e9_lhloose_2016_e9_lhloose_nod0_2017_2018_e12_lhvloose_nod0_L1EM10VH"}
1244 
1245  };
1246 
1247  // 2e17 trigger is used in 2017 or 2018?
1249  if (triglist_2017to2018.find("2e17_lhvloose_nod0_L12EM15VHI") != std::string::npos) {
1250  electronTriggerSFMapMixedLepton["e17_lhvloose_nod0_L1EM15VHI"] = "DI_E_2015_e12_lhloose_L1EM10VH_2016_e17_lhvloose_nod0_2017_2018_e17_lhvloose_nod0_L1EM15VHI";
1251  }
1252 
1253  std::string triggerMixedEleIso("");
1254 
1255  for(auto const& item : electronTriggerSFMapMixedLepton){
1256 
1257  if (std::find(eSF_keys.begin(), eSF_keys.end(), item.second+"_"+eleId+"_"+m_eleIso_WP) != eSF_keys.end()){
1258  triggerMixedEleIso = m_eleIso_WP;
1259  } else if (std::find(eSF_keys.begin(), eSF_keys.end(), item.second+"_"+eleId+"_"+m_el_iso_fallback[m_eleIso_WP]) != eSF_keys.end()){
1260  //--- Check to see if the only issue is an unknown isolation working point
1261  triggerMixedEleIso = m_el_iso_fallback[m_eleIso_WP];
1262  ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool_trig_mixLep_*) Your selected electron Iso WP ("
1263  << m_eleIso_WP
1264  << ") does not have trigger SFs defined. Falling back to "
1265  << triggerMixedEleIso
1266  << " for SF calculations");
1267  } else {
1268  ATH_MSG_ERROR("*** THE MIXED ELECTRON TRIGGER SF YOU SELECTED (" << item.second << ") GOT NO SUPPORT FOR YOUR ID+ISO WPs (" << m_eleId << "+" << m_eleIso_WP << "). The fallback options failed as well sorry! ***");
1269  return StatusCode::FAILURE;
1270  }
1271 
1272  ATH_MSG_VERBOSE ("Selected WP: " << item.second << "_" << eleId << "_" << triggerMixedEleIso);
1273 
1274  toolName = "AsgElectronEfficiencyCorrectionTool_trig_mixLep_" + (item.first).substr(0,8) + m_eleId;
1275  auto t_sf = m_elecEfficiencySFTool_trig_mixLep.emplace(m_elecEfficiencySFTool_trig_mixLep.end(), "AsgElectronEfficiencyCorrectionTool/"+toolName);
1276  ATH_CHECK( t_sf->setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
1277  ATH_CHECK( t_sf->setProperty("TriggerKey", item.second) );
1278  ATH_CHECK( t_sf->setProperty("IdKey", eleId) );
1279  ATH_CHECK( t_sf->setProperty("IsoKey", triggerMixedEleIso) );
1280  ATH_CHECK( t_sf->setProperty("CorrelationModel", m_EG_corrModel) );
1281  if (!isData()) {
1282  ATH_CHECK( t_sf->setProperty("ForceDataType", (int) (data_type==PATCore::ParticleDataType::Fast)? PATCore::ParticleDataType::Full : data_type) );
1283  }
1284  ATH_CHECK( t_sf->setProperty("OutputLevel", this->msg().level()) );
1285  ATH_CHECK( t_sf->initialize() );
1286  m_elecTrigSFTools.push_back(t_sf->getHandle());
1287  #ifndef XAOD_STANDALONE
1288  m_legsPerTool[toolName] = item.first;
1289  #else
1290  m_legsPerTool["ToolSvc."+toolName] = item.first;
1291  #endif
1292 
1293  toolName = "AsgElectronEfficiencyCorrectionTool_trigEff_mixLep_" + (item.first).substr(0,8) + m_eleId;
1294  auto t_eff = m_elecEfficiencySFTool_trigEff_mixLep.emplace(m_elecEfficiencySFTool_trigEff_mixLep.end(), "AsgElectronEfficiencyCorrectionTool/"+toolName);
1295  ATH_CHECK( t_eff->setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
1296  ATH_CHECK( t_eff->setProperty("TriggerKey", "Eff_"+item.second) );
1297  ATH_CHECK( t_eff->setProperty("IdKey", eleId) );
1298  ATH_CHECK( t_eff->setProperty("IsoKey", triggerMixedEleIso) );
1299  ATH_CHECK( t_eff->setProperty("CorrelationModel", m_EG_corrModel) );
1300  if (!isData()) {
1301  ATH_CHECK( t_eff->setProperty("ForceDataType", (int) (data_type==PATCore::ParticleDataType::Fast)? PATCore::ParticleDataType::Full : data_type) );
1302  }
1303  ATH_CHECK( t_eff->setProperty("OutputLevel", this->msg().level()) );
1304  ATH_CHECK( t_eff->initialize() );
1305  m_elecTrigEffTools.push_back(t_eff->getHandle());
1306  #ifndef XAOD_STANDALONE
1307  m_legsPerTool[toolName] = item.first;
1308  #else
1309  m_legsPerTool["ToolSvc."+toolName] = item.first;
1310  #endif
1311 
1312  }
1313  }
1314  else ATH_MSG_WARNING("*** THE ELECTRON TRIGGER SF MIXED AND SF DILEP ARE CURRENTY NOT SUPPORTED IN RUN3 ***");
1315 
1316  ATH_MSG_WARNING("*** THE ELECTRON CHARGE FLIP SF ARE CURRENTY NOT SUPPORTED ***");
1317  // all the iinitialisation of the related tools have been cleaned up
1318 
1319  }
1320 
1321  if (m_slices["pho"]) {
1322  // /////////////////////////////////////////////////////////////////////////////////////////
1323  // Initialise photon efficiency tool
1324 
1326  m_photonEfficiencySFTool.setTypeAndName("AsgPhotonEfficiencyCorrectionTool/AsgPhotonEfficiencyCorrectionTool_" + m_photonId);
1327 
1328  if (m_photonId != "Tight" ) {
1329  ATH_MSG_WARNING( "No Photon efficiency available for " << m_photonId << ", using Tight instead..." );
1330  }
1331 
1332  ATH_CHECK( m_photonEfficiencySFTool.setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2025/rel22.2/2024_FinalRun2_Recommendation_v1/map0.txt") );
1333  ATH_CHECK( m_photonEfficiencySFTool.setProperty("ForceDataType", 1) ); // Set data type: 1 for FULLSIM, 3 for AF2
1334  ATH_CHECK( m_photonEfficiencySFTool.setProperty("OutputLevel", this->msg().level()) );
1337 
1339  m_photonIsolationSFTool.setTypeAndName("AsgPhotonEfficiencyCorrectionTool/AsgPhotonEfficiencyCorrectionTool_isol" + m_photonIso_WP);
1340 
1341  if (m_photonIso_WP != "FixedCutTight" && m_photonIso_WP != "FixedCutLoose" && m_photonIso_WP != "TightCaloOnly") {
1342  ATH_MSG_WARNING( "No Photon efficiency available for " << m_photonIso_WP);
1343  }
1344 
1345  ATH_CHECK( m_photonIsolationSFTool.setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2025/rel22.2/2022_Summer_Prerecom_v1/map0.txt") );
1346  ATH_CHECK( m_photonIsolationSFTool.setProperty("IsoKey", m_photonIso_WP != "TightCaloOnly" ? m_photonIso_WP.substr(8) : m_photonIso_WP )); // Set isolation WP: Loose,Tight,TightCaloOnly
1347  ATH_CHECK( m_photonIsolationSFTool.setProperty("ForceDataType", 1) ); // Set data type: 1 for FULLSIM, 3 for AF2
1348  ATH_CHECK( m_photonIsolationSFTool.setProperty("OutputLevel", this->msg().level()) );
1351 
1352  // trigger scale factors
1354  m_photonTriggerSFTool.setTypeAndName("AsgPhotonEfficiencyCorrectionTool/AsgPhotonEfficiencyCorrectionTool_trig" + m_photonTriggerName);
1355 
1356  // Fallback to TightCaloOnly if Tight is selected
1357  std::string photonIso_forTrigSF = m_photonIso_WP;
1358  if (m_photonIso_WP == "FixedCutTight") {
1359  ATH_MSG_WARNING( "No Photon trigger SF available for " << m_photonIso_WP << ", using TightCaloOnly instead... Use at your own risk" );
1360  photonIso_forTrigSF = "TightCaloOnly";
1361  } else { // isolation WP supported: Loose or TightCaloOnly, removing "FixedCut" suffix..
1362  photonIso_forTrigSF = TString(m_photonIso_WP).ReplaceAll("FixedCut","").Data();
1363  }
1364 
1365  // "symmetric" diphoton triggers (year dependent)
1366  ATH_CHECK( m_photonTriggerSFTool.setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2018/rel21.2/Summer2020_Rec_v1/map3.txt") );
1367  ATH_CHECK( m_photonTriggerSFTool.setProperty("IsoKey", photonIso_forTrigSF )); // Set isolation WP: Loose,TightCaloOnly
1369  ATH_CHECK( m_photonTriggerSFTool.setProperty("ForceDataType", 1) ); // Set data type: 1 for FULLSIM, 3 for AF2
1370  ATH_CHECK( m_photonTriggerSFTool.setProperty("OutputLevel", this->msg().level()) );
1372 
1373  // "asymmetric" diphoton triggers
1374  std::map<std::string,std::string> diphotonTriggerSFMapAsymmetric {
1375  // legs, Trigger keys,
1376  {"g25_loose,g25_medium_L1EM20VH", "DI_PH_2015_g25_loose_2016_g25_loose_2017_g25_medium_L1EM20VH_2018_g25_medium_L1EM20VH"},
1377  {"g35_loose,g35_medium_L1EM20VH", "DI_PH_2015_g35_loose_2016_g35_loose_2017_g35_medium_L1EM20VH_2018_g35_medium_L1EM20VH"},
1378  };
1379 
1380  for(auto const& item : diphotonTriggerSFMapAsymmetric){
1381 
1382  toolName = "AsgPhotonEfficiencyCorrectionTool_trigSF_asymm_diphoton_" + (item.first).substr(0,9) + photonIso_forTrigSF;
1383  auto ph_trigSF = m_photonEfficiencySFTool_trigSF_AsymDiphoton.emplace(m_photonEfficiencySFTool_trigSF_AsymDiphoton.end(), "AsgPhotonEfficiencyCorrectionTool/"+toolName);
1384  ATH_CHECK( ph_trigSF->setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2018/rel21.2/Summer2020_Rec_v1/map3.txt") );
1385  ATH_CHECK( ph_trigSF->setProperty("IsoKey", photonIso_forTrigSF) );
1386  ATH_CHECK( ph_trigSF->setProperty("TriggerKey", item.second) );
1387  ATH_CHECK( ph_trigSF->setProperty("ForceDataType", 1) ); // Set DataType: 1 for FullSim and 3 for AFII
1388  ATH_CHECK( ph_trigSF->setProperty("OutputLevel", this->msg().level()) );
1389  ATH_CHECK( ph_trigSF->initialize() );
1390  m_photonTrigSFTools.push_back(ph_trigSF->getHandle());
1391  #ifndef XAOD_STANDALONE
1392  m_legsPerTool_ph[toolName] = item.first;
1393  #else
1394  m_legsPerTool_ph["ToolSvc."+toolName] = item.first;
1395  #endif
1396 
1397  toolName = "AsgPhotonEfficiencyCorrectionTool_trigEff_asymm_diphoton_" + (item.first).substr(0,9) + photonIso_forTrigSF;
1398  auto ph_trigEff = m_photonEfficiencySFTool_trigEff_AsymDiphoton.emplace(m_photonEfficiencySFTool_trigEff_AsymDiphoton.end(), "AsgPhotonEfficiencyCorrectionTool/"+toolName);
1399  ATH_CHECK( ph_trigEff->setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2018/rel21.2/Summer2020_Rec_v1/map3.txt") );
1400  ATH_CHECK( ph_trigEff->setProperty("IsoKey", photonIso_forTrigSF) );
1401  ATH_CHECK( ph_trigEff->setProperty("TriggerKey", "Eff_"+item.second) );
1402  ATH_CHECK( ph_trigEff->setProperty("ForceDataType", 1) ); // Set DataType: 1 for FullSim and 3 for AFII
1403  ATH_CHECK( ph_trigEff->setProperty("OutputLevel", this->msg().level()) );
1404  ATH_CHECK( ph_trigEff->initialize() );
1405  m_photonTrigEffTools.push_back(ph_trigEff->getHandle());
1406  #ifndef XAOD_STANDALONE
1407  m_legsPerTool_ph[toolName] = item.first;
1408  #else
1409  m_legsPerTool_ph["ToolSvc."+toolName] = item.first;
1410  #endif
1411 
1412  }
1413  }
1414  }
1415 
1416  }
1417  if (m_slices["ele"] || m_slices["pho"]) {
1419  // Initialize the EgammaAmbiguityTool
1420 
1422  m_egammaAmbiguityTool.setTypeAndName("EGammaAmbiguityTool/EGammaAmbiguityTool");
1423  ATH_CHECK( m_egammaAmbiguityTool.setProperty("OutputLevel", this->msg().level()) );
1426  }
1427 
1428 
1429  if (m_slices["ele"]) {
1430  //disable ///////////////////////////////////////////////////////////////////////////////////////////
1431  //disable // Initialize the AsgElectronChargeIDSelector
1432 
1433  //disable if (!m_elecChargeIDSelectorTool.isUserConfigured()) {
1434 
1435  //disable // For the selector, can use the nice function
1436  //disable std::string eleId = EG_WP(m_eleId);
1437  //disable m_elecChargeIDSelectorTool.setTypeAndName("AsgElectronChargeIDSelectorTool/ElectronChargeIDSelectorTool_"+eleId);
1438  //disable //default cut value for https://twiki.cern.ch/twiki/bin/view/AtlasProtected/ElectronChargeFlipTaggerTool
1439  //disable float BDTcut = -0.337671; // Loose 97%
1440  //disable if (m_eleChID_WP != "Loose" && !m_eleChID_WP.empty()) {
1441  //disable ATH_MSG_ERROR("Only Loose WP is supported in R21. Invalid ChargeIDSelector WP selected : " << m_eleChID_WP);
1442  //disable return StatusCode::FAILURE;
1443  //disable }
1444 
1445  //disable ATH_CHECK( m_elecChargeIDSelectorTool.setProperty("TrainingFile", "ElectronPhotonSelectorTools/ChargeID/ECIDS_20180731rel21Summer2018.root"));
1446  //disable ATH_CHECK( m_elecChargeIDSelectorTool.setProperty("CutOnBDT", BDTcut));
1447  //disable ATH_CHECK( m_elecChargeIDSelectorTool.setProperty("OutputLevel", this->msg().level()) );
1448  //disable ATH_CHECK( m_elecChargeIDSelectorTool.retrieve() );
1449  //disable } else ATH_CHECK( m_elecChargeIDSelectorTool.retrieve() );
1450 
1451 
1453  // Initialise egamma calibration tool
1454 
1456  m_egammaCalibTool.setTypeAndName("CP::EgammaCalibrationAndSmearingTool/EgammaCalibrationAndSmearingTool");
1457  ATH_MSG_DEBUG( "Initialising EgcalibTool " );
1458  ATH_CHECK( m_egammaCalibTool.setProperty("ESModel", m_isRun3 ? "es2022_R22_PRE" : "es2023_R22_Run2_v0") );
1459  ATH_CHECK( m_egammaCalibTool.setProperty("decorrelationModel", "1NP_v1") );
1460  // allows to bypass (intended) abort from of egamma calibration tool when configured for fastSim
1461  if (m_eleForceFullSimCalib) {
1462  ATH_MSG_WARNING( "Forcing EgcalibTool to use calibrations for full simulation" );
1463  ATH_CHECK( m_egammaCalibTool.setProperty("useFastSim", false) );
1464  }
1465  else {
1466  ATH_MSG_INFO("is Fast Sim:" << isAtlfast());
1467  ATH_CHECK( m_egammaCalibTool.setProperty("useFastSim", isAtlfast() ? 1 : 0) );
1468  }
1469  ATH_CHECK( m_egammaCalibTool.setProperty("OutputLevel", this->msg().level()) );
1471  } else ATH_CHECK( m_egammaCalibTool.retrieve() );
1472  }
1473 
1474 
1475  if (m_slices["tau"]) {
1477 
1479  // Initialise path to tau config file and config reader
1480 
1481  std::string inputfile = "";
1482  if (!m_tauConfigPath.empty() && (m_tauConfigPath!="default")) inputfile = m_tauConfigPath;
1483  else if (m_tauId == "rnn001") inputfile = "SUSYTools/tau_selection_rnn001.conf";
1484  else if (m_tauId == "VeryLoose") inputfile = "SUSYTools/tau_selection_veryloose.conf";
1485  else if (m_tauId == "Loose") inputfile = "SUSYTools/tau_selection_loose.conf";
1486  else if (m_tauId == "Medium") inputfile = "SUSYTools/tau_selection_medium.conf";
1487  else if (m_tauId == "Tight") inputfile = "SUSYTools/tau_selection_tight.conf";
1488  else {
1489  ATH_MSG_ERROR("Invalid tau ID selected: " << m_tauId);
1490  return StatusCode::FAILURE;
1491  }
1492 
1493  // Read in the config file so we can retrieve the fields later when configuring the efficiency tools
1494  if ( m_tauConfigReader.ReadFile( PathResolverFindCalibFile(inputfile).c_str(), EEnvLevel(0) ) ) {
1495  ATH_MSG_ERROR( "Error while reading tau config file : " << inputfile );
1496  return StatusCode::FAILURE;
1497  }
1498  else ATH_MSG_DEBUG( "Successfully read tau config file : " << inputfile );
1499 
1500 
1502  // Initialise tau selection tools
1503 
1504  if (!m_tauSelTool.isUserConfigured()) {
1505  toolName = "TauSelectionTool_" + m_tauId;
1506  m_tauSelTool.setTypeAndName("TauAnalysisTools::TauSelectionTool/"+toolName);
1507  ATH_CHECK( m_tauSelTool.setProperty("ConfigPath", inputfile) );
1508  ATH_CHECK( m_tauSelTool.setProperty("OutputLevel", this->msg().level()) );
1510  } else ATH_CHECK( m_tauSelTool.retrieve() );
1511 
1512 
1514  std::string inputfile = "";
1516  else if (m_tauIdBaseline == "rnn001") inputfile = "SUSYTools/tau_selection_rnn001.conf";
1517  else if (m_tauIdBaseline == "VeryLoose") inputfile = "SUSYTools/tau_selection_veryloose.conf";
1518  else if (m_tauIdBaseline == "Loose") inputfile = "SUSYTools/tau_selection_loose.conf";
1519  else if (m_tauIdBaseline == "Medium") inputfile = "SUSYTools/tau_selection_medium.conf";
1520  else if (m_tauIdBaseline == "Tight") inputfile = "SUSYTools/tau_selection_tight.conf";
1521  else {
1522  ATH_MSG_ERROR("Invalid baseline tau ID selected: " << m_tauIdBaseline);
1523  return StatusCode::FAILURE;
1524  }
1525  toolName = "TauSelectionToolBaseline_" + m_tauIdBaseline;
1526  m_tauSelToolBaseline.setTypeAndName("TauAnalysisTools::TauSelectionTool/"+toolName);
1528 
1529  ATH_CHECK( m_tauSelToolBaseline.setProperty("OutputLevel", this->msg().level()) );
1532 
1533 
1535  // Initialise tau efficiency tool
1536 
1537  if (!m_tauEffTool.isUserConfigured() && !isData()) {
1538  toolName = "TauEffTool_" + m_tauId;
1539  m_tauEffTool.setTypeAndName("TauAnalysisTools::TauEfficiencyCorrectionsTool/"+toolName);
1540  ATH_CHECK( m_tauEffTool.setProperty("PileupReweightingTool",m_prwTool.getHandle()) );
1541 
1542  std::vector<int> correction_types;
1543  // Read out the tau ID from the config file and map into the enum from tau CP
1544  std::string jetIDWP = m_tauConfigReader.GetValue("JetIDWP" ,"");
1545  ANA_MSG_DEBUG( "Found JetIDWP in tau config file : " << jetIDWP );
1546  int jet_id_lvl;
1547  if (jetIDWP == "JETIDNONE") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDNONE;
1548  else if (jetIDWP == "JETIDRNNVERYLOOSE") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDRNNVERYLOOSE;
1549  else if (jetIDWP == "JETIDRNNLOOSE") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDRNNLOOSE;
1550  else if (jetIDWP == "JETIDRNNMEDIUM") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDRNNMEDIUM;
1551  else if (jetIDWP == "JETIDRNNTIGHT") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDRNNTIGHT;
1552  else {
1553  ATH_MSG_ERROR("Invalid Tau ID in tau config file " << jetIDWP);
1554  return StatusCode::FAILURE;
1555  }
1556  // Add retrieval of reco and ID SFs
1557  correction_types.insert(correction_types.end(), {TauAnalysisTools::EfficiencyCorrectionType::SFRecoHadTau,
1558  TauAnalysisTools::EfficiencyCorrectionType::SFJetIDHadTau});
1559 
1560  // Read out the (optional) Ele OR from the config file and map into the enum from tau CP
1561  std::string eleIDWP = m_tauConfigReader.GetValue("EleIDWP" ,"");
1562  ANA_MSG_DEBUG( "Found EleIDWP in tau config file : " << eleIDWP );
1563  int ele_id_lvl = -1;
1564  if (eleIDWP == "ELEIDRNNLOOSE") ele_id_lvl = (int)TauAnalysisTools::EleID::ELEIDRNNLOOSE;
1565  else if (eleIDWP == "ELEIDRNNMEDIUM") ele_id_lvl = (int)TauAnalysisTools::EleID::ELEIDRNNMEDIUM;
1566  else if (eleIDWP == "ELEIDRNNTIGHT") ele_id_lvl = (int)TauAnalysisTools::EleID::ELEIDRNNTIGHT;
1567  else {
1568  ATH_MSG_INFO("No or invalid Ele OR in tau config file " << eleIDWP << " will not apply SFs for electro veto" );
1569  }
1570  // Add retrieval of electron veto SFs if its applied
1571  if (ele_id_lvl != -1 )
1572  correction_types.insert(correction_types.end(), {TauAnalysisTools::EfficiencyCorrectionType::SFEleIDHadTau,
1573  TauAnalysisTools::EfficiencyCorrectionType::SFEleIDElectron});
1574 
1575  ATH_CHECK( m_tauEffTool.setProperty("JetIDLevel", jet_id_lvl) );
1576  ATH_CHECK( m_tauEffTool.setProperty("EleIDLevel", ele_id_lvl) );
1577  ATH_CHECK( m_tauEffTool.setProperty("EfficiencyCorrectionTypes", correction_types) );
1578  ATH_CHECK( m_tauEffTool.setProperty("OutputLevel", this->msg().level()) );
1579  ATH_CHECK( m_tauEffTool.setProperty("useFastSim", isAtlfast()) );
1582 
1583 
1585  // Initialise tau trigger efficiency tool(s)
1586 
1587  if (!isData()) {
1589  if (m_tauId == "rnn001") iTauID = (int) TauAnalysisTools::JETIDNONE;
1590  else if (m_tauId == "VeryLoose") iTauID = (int) TauAnalysisTools::JETIDRNNVERYLOOSE;
1591  else if (m_tauId == "Loose") iTauID = (int) TauAnalysisTools::JETIDRNNLOOSE;
1592  else if (m_tauId == "Medium") iTauID = (int) TauAnalysisTools::JETIDRNNMEDIUM;
1593  else if (m_tauId == "Tight") iTauID = (int) TauAnalysisTools::JETIDRNNTIGHT;
1594  else {
1595  ATH_MSG_ERROR("Invalid tau ID selected: " << m_tauId);
1596  return StatusCode::FAILURE;
1597  }
1598 
1599  // map format: SF file name, corresponding single-tau leg (comma-separated in case of OR)
1600  m_tau_trig_support = {
1601  {"HLT_tau25_medium1_tracktwo", "HLT_tau25_medium1_tracktwo"},
1602  {"HLT_tau35_medium1_tracktwo", "HLT_tau35_medium1_tracktwo"},
1603  {"HLT_tau50L1TAU12_medium1_tracktwo", "HLT_tau50_medium1_tracktwo_L1TAU12"},
1604  {"HLT_tau60_medium1_tracktwo", "HLT_tau60_medium1_tracktwo"},
1605  {"HLT_tau80L1TAU60_medium1_tracktwo", "HLT_tau80_medium1_tracktwo_L1TAU60"},
1606  {"HLT_tau125_medium1_tracktwo", "HLT_tau125_medium1_tracktwo"},
1607  {"HLT_tau160_medium1_tracktwo", "HLT_tau160_medium1_tracktwo"},
1608  {"HLT_tau160L1TAU100_medium1_tracktwo", "HLT_tau160_medium1_tracktwo_L1TAU100"},
1609  // whole 2018 data taking period
1610  {"HLT_tau25_medium1_tracktwoEF", "HLT_tau25_medium1_tracktwoEF"},
1611  {"HLT_tau35L1TAU12IM_medium1_tracktwoEF", "HLT_tau35_medium1_tracktwoEF_L1TAU12IM"},
1612  {"HLT_tau35_medium1_tracktwoEF", "HLT_tau35_medium1_tracktwoEF"},
1613  {"HLT_tau60_medium1_tracktwoEF", "HLT_tau60_medium1_tracktwoEF"},
1614  {"HLT_tau80L1TAU60_medium1_tracktwoEF", "HLT_tau80_medium1_tracktwoEF_L1TAU60"},
1615  {"HLT_tau160L1TAU100_medium1_tracktwoEF", "HLT_tau160_medium1_tracktwoEF_L1TAU100"},
1616  // 2018 data after TS1, run >= 355261
1617  {"HLT_tau25_medium1_tracktwoEF_OR_mediumRNN_tracktwoMVA", "HLT_tau25_medium1_tracktwoEF,HLT_tau25_mediumRNN_tracktwoMVA"},
1618  {"HLT_tau35L1TAU12IM_medium1_tracktwoEF_OR_mediumRNN_tracktwoMVA", "HLT_tau35_medium1_tracktwoEF_L1TAU12IM,HLT_tau35_mediumRNN_tracktwoMVA_L1TAU12IM"},
1619  {"HLT_tau35_medium1_tracktwoEF_OR_mediumRNN_tracktwoMVA", "HLT_tau35_medium1_tracktwoEF,HLT_tau35_mediumRNN_tracktwoMVA"},
1620  {"HLT_tau60_medium1_tracktwoEF_OR_mediumRNN_tracktwoMVA", "HLT_tau60_medium1_tracktwoEF,HLT_tau60_mediumRNN_tracktwoMVA"},
1621  {"HLT_tau80L1TAU60_medium1_tracktwoEF_OR_mediumRNN_tracktwoMVA", "HLT_tau80_medium1_tracktwoEF_L1TAU60,HLT_tau80_mediumRNN_tracktwoMVA_L1TAU60"},
1622  {"HLT_tau160L1TAU100_medium1_tracktwoEF_OR_mediumRNN_tracktwoMVA", "HLT_tau160_medium1_tracktwoEF_L1TAU100,HLT_tau160_mediumRNN_tracktwoMVA_L1TAU100"}
1623  };
1624 
1625  for(auto const& trigger : m_tau_trig_support) {
1626  toolName = "TauTrigEffTool_" + m_tauId + "_" + trigger.first;
1627  auto tau_trigSF = m_tauTrigEffTool.emplace(m_tauTrigEffTool.end(), "TauAnalysisTools::TauEfficiencyCorrectionsTool/"+toolName);
1628  ATH_CHECK( tau_trigSF->setProperty("EfficiencyCorrectionTypes", std::vector<int>({TauAnalysisTools::SFTriggerHadTau})) );
1629  ATH_CHECK( tau_trigSF->setProperty("TriggerName", trigger.first) );
1630  ATH_CHECK( tau_trigSF->setProperty("JetIDLevel", iTauID) );
1631  ATH_CHECK( tau_trigSF->setProperty("PileupReweightingTool", m_prwTool.getHandle()) );
1632  ATH_CHECK( tau_trigSF->setProperty("OutputLevel", this->msg().level()) );
1633  ATH_CHECK( tau_trigSF->setProperty("useFastSim", isAtlfast()) );
1634  ATH_CHECK( tau_trigSF->initialize() );
1635  }
1636  }
1637 
1638 
1640  // Initialise tau smearing tool
1641 
1643  m_tauSmearingTool.setTypeAndName("TauAnalysisTools::TauSmearingTool/TauSmearingTool");
1645  if (m_isRun3){ ATH_CHECK( m_tauSmearingTool.setProperty("Campaign", "mc21") );}
1646  else { ATH_CHECK( m_tauSmearingTool.setProperty("Campaign", "mc20") );}
1648  ATH_CHECK( m_tauSmearingTool.setProperty("useFastSim", isAtlfast()) );
1649  ATH_CHECK( m_tauSmearingTool.setProperty("OutputLevel", this->msg().level()) );
1651  } else ATH_CHECK( m_tauSmearingTool.retrieve() );
1652 
1653 
1655  // Initialise tau truth matching tool
1656 
1658  m_tauTruthMatch.setTypeAndName("TauAnalysisTools::TauTruthMatchingTool/TauTruthMatch");
1659  ATH_CHECK( m_tauTruthMatch.setProperty("TruthJetContainerName", m_defaultTruthJets ) );
1660  ATH_CHECK( m_tauTruthMatch.setProperty("OutputLevel", this->msg().level()) );
1663 
1664 
1665  }
1666 
1667 
1668  if (m_slices["bjet"]) {
1670  // Initialise B-tagging tools
1671 
1672  // btagSelectionTool
1673  std::string jetcollBTag = jetcoll;
1674  if (jetcoll == "AntiKt4LCTopoJets") {
1675  ATH_MSG_WARNING(" *** HACK *** Treating LCTopoJets jets as EMTopo -- use at your own risk!");
1676  jetcollBTag = "AntiKt4EMTopoJets";
1677  }
1678 
1679  // print a warning if there is indication that the user supplied a CDI file not matching to the sample being processed
1680  // see --> https://twiki.cern.ch/twiki/bin/view/AtlasProtected/BTagRel22HighLevelSummary
1681  if( (m_bTaggingCalibrationFilePath.find(!m_isRun3 ? "MC20" : "MC23") == std::string::npos) && (m_bTaggingCalibrationFilePath.find(!m_isRun3 ? "MC20" : "MC21") == std::string::npos) ) {
1682  ATH_MSG_WARNING( "You are using a "<<(!m_isRun3 ? "Run3":"Run2")<<" CDI file while running on "<<(!m_isRun3 ? "Run2":"Run3")<<" sample; Please updates your CDI file to the correct version for "<<(!m_isRun3 ? "Run2":"Run3"));
1683  }
1684 
1685  if (m_useBtagging && !m_btagSelTool.isUserConfigured() && !m_BtagWP.empty()) {
1686  if (jetcollBTag.find("AntiKt4EMTopoJets") == std::string::npos && jetcollBTag.find("AntiKt4EMPFlowJets")==std::string::npos) {
1687  ATH_MSG_WARNING("** Only AntiKt4EMTopoJets and AntiKt4EMPFlowJets are supported with FTAG scale factors!");
1688  return StatusCode::FAILURE;
1689  }
1690 
1691  toolName = "BTagSel_" + jetcollBTag + m_BtagTagger + m_BtagWP;
1692 
1693  m_btagSelTool.setTypeAndName("BTaggingSelectionTool/"+toolName);
1694  ATH_CHECK( m_btagSelTool.setProperty("TaggerName", m_BtagTagger ) );
1695  ATH_CHECK( m_btagSelTool.setProperty("OperatingPoint", m_BtagWP ) );
1696  ATH_CHECK( m_btagSelTool.setProperty("JetAuthor", jetcollBTag ) );
1698  ATH_CHECK( m_btagSelTool.setProperty("FlvTagCutDefinitionsFileName", m_bTaggingCalibrationFilePath) );
1699  ATH_CHECK( m_btagSelTool.setProperty("OutputLevel", this->msg().level()) );
1702 
1703 
1705  if (jetcoll != "AntiKt4EMTopoJets" && jetcoll != "AntiKt4EMPFlowJets") {
1706  ATH_MSG_WARNING("** Only AntiKt4EMTopoJets and AntiKt4EMPFlowJets are supported with FTAG scale factors!");
1707  return StatusCode::FAILURE;
1708  }
1709 
1710  toolName = "BTagSelOR_" + jetcollBTag + m_orBtagWP;
1711  m_btagSelTool_OR.setTypeAndName("BTaggingSelectionTool/"+toolName);
1713  ATH_CHECK( m_btagSelTool_OR.setProperty("OperatingPoint", m_orBtagWP ) );
1714  ATH_CHECK( m_btagSelTool_OR.setProperty("JetAuthor", jetcollBTag ) );
1716  ATH_CHECK( m_btagSelTool_OR.setProperty("FlvTagCutDefinitionsFileName", m_bTaggingCalibrationFilePath) );
1717  ATH_CHECK( m_btagSelTool_OR.setProperty("OutputLevel", this->msg().level()) );
1720 
1721 
1722  std::string trkjetcoll = m_defaultTrackJets;
1723  const std::string& BTagColl_TrkJet = trkjetcoll;
1724  if (m_slices["tjet"]) {
1725  if ( m_useBtagging_trkJet && m_defaultTrackJets.empty()) {
1726  m_useBtagging_trkJet = false;
1727  ATH_MSG_INFO("TrackJet collection set to None: disabling btagging for TrackJets.");
1728  }
1729 
1731  if (trkjetcoll.find("AntiKt2PV0TrackJets")==std::string::npos && trkjetcoll.find("AntiKtVR30Rmax4Rmin02TrackJets")==std::string::npos) {
1732  ATH_MSG_WARNING("** Only AntiKt2PV0TrackJets and AntiKtVR30Rmax4Rmin02TrackJets are supported with FTAG scale factors!");
1733  return StatusCode::FAILURE;
1734  }
1735 
1736  toolName = "BTagSel_" + trkjetcoll + m_BtagTagger_trkJet + m_BtagWP_trkJet;
1737 
1738  m_btagSelTool_trkJet.setTypeAndName("BTaggingSelectionTool/"+toolName);
1742  ATH_CHECK( m_btagSelTool_trkJet.setProperty("JetAuthor", BTagColl_TrkJet ) );
1744  ATH_CHECK( m_btagSelTool_trkJet.setProperty("FlvTagCutDefinitionsFileName", m_bTaggingCalibrationFilePath) );
1745  ATH_CHECK( m_btagSelTool_trkJet.setProperty("OutputLevel", this->msg().level()) );
1748  }
1749 
1750  // Set MCshowerType for FTAG MC/MC SFs
1751  // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/BTagCalibrationRecommendationsRelease21#MC_MC_Scale_Factors_for_Analysis
1752  std::string MCshowerID;
1753  if(m_showerType==-1){
1754  ATH_MSG_ERROR( "Error! m_showerType=-1, which is an error case for FTAG MC/MC SFs." );
1755  return StatusCode::FAILURE;
1756  }
1757  if(m_BtagTagger=="DL1dv01"){
1758  if(!m_isRun3){
1759  MCshowerID= "default"; // Powheg+Pythia8 (410470) - PhPy8EG_A14
1760  if (m_showerType == 1) MCshowerID = "411233"; // PowhegHerwig7
1761  else if (m_showerType == 2) MCshowerID = "600666"; // PhH7EG_H7UE - 601414
1762  else if (m_showerType == 3) MCshowerID = "410250"; // Sherpa_221
1763  else if (m_showerType == 4) MCshowerID = "700122"; // Sh_2210
1764  else if (m_showerType == 5) MCshowerID = "700122"; // Sh_2211
1765  else if (m_showerType == 6) MCshowerID = "700660"; // Sh_2212 - 700660
1766  else if (m_showerType == 7) MCshowerID = "410464"; // aMcAtNloPy8
1767  else if (m_showerType == 8) MCshowerID = "412116"; // aMcAtNloHerwig7
1768  else if (m_showerType != 0){
1769  ATH_MSG_WARNING("Unknown ShowerID detected! Using default FTAG MC-MC SFs (Powheg+Pythia8). Please check if these are applicable for this sample!");
1770  }
1771  }
1772  else{
1773  MCshowerID= "default"; // Powheg+Pythia8 (601229) - PhPy8EG_A14
1774  if (m_showerType == 2) MCshowerID = "601414"; // POWHEG+Herwig721 - PhH7EG_A14
1775  else if (m_showerType == 6) MCshowerID = "700660"; // Sherpa 2.2.12 - Sh_2212
1776  else if (m_showerType != 0){
1777  ATH_MSG_WARNING("Unknown ShowerID detected! Using default FTAG MC-MC SFs (Powheg+Pythia8). Please check if these are applicable for this sample!");
1778  }
1779  }
1780  } else if (m_BtagTagger=="GN2v01"){
1781  if(!m_isRun3){
1782  MCshowerID= "default"; // PowhegPythia8EvtGen (410470)
1783  if (m_showerType == 1) MCshowerID = "410480"; // PYTHIA8EVTGEN517 (410480)
1784  else if (m_showerType == 2) MCshowerID = "411233"; // POWHEGHERWIG7 - 411233
1785  else if (m_showerType == 3) MCshowerID = "600666"; // PhH7EG_H7UE - 600666
1786  else if (m_showerType == 4) MCshowerID = "700660"; // Sh_2210 FTAGAnalysisConfig uses this, but docs say only 11-16 can be used
1787  else if (m_showerType == 5) MCshowerID = "700660"; // Sh_2211
1788  else if (m_showerType == 6) MCshowerID = "700660"; // Sh_2212
1789  else if (m_showerType == 7) MCshowerID = "700660"; // Sh_2214
1790  else if (m_showerType == 8) {
1791  ATH_MSG_WARNING("Unknown Sherpa version detected! Using FTAG MC-MC SFs for Sherpa 2.2.11-2.2.16. Please check if these are applicable for this sample!");
1792  MCshowerID = "700660"; // Unknown Sherpa Version. This is to handle Sh_blank (e.g. DSID 701050). The examples I've found are all 2.2.16, but that's not guaranteed.
1793  }
1794  else if (m_showerType != 0){
1795  ATH_MSG_WARNING("Unknown ShowerID detected! Using default FTAG MC-MC SFs (Powheg+Pythia8). Please check if these are applicable for this sample!");
1796  }
1797  }
1798  else {
1799  MCshowerID= "default"; // PowhegPythia8EvtGen (601229)
1800  if (m_showerType == 1) MCshowerID = "601398"; // PYTHIA8EVTGEN517 (601398)
1801  else if (m_showerType == 3) MCshowerID = "601414"; // PhH7EG_H7UE - 601414
1802  else if (m_showerType == 5) MCshowerID = "700808"; // Sh_2211
1803  else if (m_showerType == 6) MCshowerID = "700808"; // Sh_2212
1804  else if (m_showerType == 7) MCshowerID = "700808"; // Sh_2214
1805  else if (m_showerType == 8) {
1806  ATH_MSG_WARNING("Unknown Sherpa version detected! Using FTAG MC-MC SFs for Sherpa 2.2.11-2.2.16. Please check if these are applicable for this sample!");
1807  MCshowerID = "700660"; // Unknown Sherpa Version
1808  }
1809  else if (m_showerType != 0){
1810  ATH_MSG_WARNING("Unknown ShowerID detected! Using default FTAG MC-MC SFs (Powheg+Pythia8). Please check if these are applicable for this sample!");
1811  }
1812  }
1813  } else {
1814  ATH_MSG_WARNING("Unknown b-tagger detected! Only DL1dv01 and GN2v01 are supported. Falling back to default FTAG MC-MC SFs (Powheg+Pythia8). Please check if these are applicable for this sample!");
1815  MCshowerID= "default";
1816  }
1817 
1818  // btagEfficiencyTool
1819  if (m_useBtagging && !m_btagEffTool.isUserConfigured() && !m_BtagWP.empty()) {
1820  if (jetcoll != "AntiKt4EMTopoJets" && jetcoll != "AntiKt4EMPFlowJets") {
1821  ATH_MSG_WARNING("** Only AntiKt4EMTopoJets and AntiKt4EMPFlowJets are supported with FTAG scale factors!");
1822  return StatusCode::FAILURE;
1823  }
1824 
1825  toolName = "BTagSF_" + jetcollBTag + m_BtagTagger + m_BtagWP;
1826  m_btagEffTool.setTypeAndName("BTaggingEfficiencyTool/"+toolName);
1827  ATH_CHECK( m_btagEffTool.setProperty("TaggerName", m_BtagTagger ) );
1829  ATH_CHECK( m_btagEffTool.setProperty("OperatingPoint", m_BtagWP ) );
1830  ATH_CHECK( m_btagEffTool.setProperty("JetAuthor", jetcollBTag ) );
1832  ATH_CHECK( m_btagEffTool.setProperty("SystematicsStrategy", m_BtagSystStrategy ) );
1833  ATH_CHECK( m_btagEffTool.setProperty("EfficiencyBCalibrations", MCshowerID ));
1834  ATH_CHECK( m_btagEffTool.setProperty("EfficiencyCCalibrations", MCshowerID ));
1835  ATH_CHECK( m_btagEffTool.setProperty("EfficiencyTCalibrations", MCshowerID ));
1836  ATH_CHECK( m_btagEffTool.setProperty("EfficiencyLightCalibrations", MCshowerID ));
1837  ATH_CHECK( m_btagEffTool.setProperty("EigenvectorReductionB", m_EigenvectorReductionB ));
1838  ATH_CHECK( m_btagEffTool.setProperty("EigenvectorReductionC", m_EigenvectorReductionC ));
1839  ATH_CHECK( m_btagEffTool.setProperty("EigenvectorReductionLight", m_EigenvectorReductionLight ));
1840  ATH_CHECK( m_btagEffTool.setProperty("OutputLevel", this->msg().level()) );
1842  } else ATH_CHECK( m_btagEffTool.retrieve() );
1843 
1844 
1845  if (m_slices["tjet"]) {
1847  if (trkjetcoll.find("AntiKt2PV0TrackJets")==std::string::npos && trkjetcoll.find("AntiKtVR30Rmax4Rmin02TrackJets")==std::string::npos) {
1848  ATH_MSG_WARNING("** Only AntiKt2PV0TrackJets and AntiKtVR30Rmax4Rmin02TrackJets are supported with FTAG scale factors!");
1849  return StatusCode::FAILURE;
1850  }
1851 
1852  toolName = "BTagSF_" + trkjetcoll;
1853  m_btagEffTool_trkJet.setTypeAndName("BTaggingEfficiencyTool/"+toolName);
1857  ATH_CHECK( m_btagEffTool_trkJet.setProperty("JetAuthor", BTagColl_TrkJet ) );
1859  ATH_CHECK( m_btagEffTool_trkJet.setProperty("SystematicsStrategy", m_BtagSystStrategy ) );
1860  ATH_CHECK( m_btagEffTool_trkJet.setProperty("EfficiencyBCalibrations", MCshowerID ));
1861  ATH_CHECK( m_btagEffTool_trkJet.setProperty("EfficiencyCCalibrations", MCshowerID ));
1862  ATH_CHECK( m_btagEffTool_trkJet.setProperty("EfficiencyTCalibrations", MCshowerID ));
1863  ATH_CHECK( m_btagEffTool_trkJet.setProperty("EfficiencyLightCalibrations", MCshowerID ));
1866  ATH_CHECK( m_btagEffTool_trkJet.setProperty("EigenvectorReductionLight", m_EigenvectorReductionLight ));
1867  ATH_CHECK( m_btagEffTool_trkJet.setProperty("OutputLevel", this->msg().level()) );
1870  }
1871  }
1872 
1873 
1874  if (m_slices["met"]) {
1876  // Initialise MET tools
1877 
1878  if (!m_metMaker.isUserConfigured()) {
1879  toolName = m_doFwdJVT ? m_metJetSelection+"_fJVT" : m_metJetSelection+"_NOfJVT";
1880  m_metMaker.setTypeAndName("met::METMaker/METMaker_ST_"+toolName);
1881 
1883  ATH_CHECK( m_metMaker.setProperty("DoSetMuonJetEMScale", m_metDoSetMuonJetEMScale) );
1884  ATH_CHECK( m_metMaker.setProperty("DoRemoveMuonJets", m_metDoRemoveMuonJets) );
1885  ATH_CHECK( m_metMaker.setProperty("UseGhostMuons", m_metUseGhostMuons) );
1886  ATH_CHECK( m_metMaker.setProperty("DoMuonEloss", m_metDoMuonEloss) );
1887  ATH_CHECK( m_metMaker.setProperty("GreedyPhotons", m_metGreedyPhotons) );
1888  ATH_CHECK( m_metMaker.setProperty("VeryGreedyPhotons", m_metVeryGreedyPhotons) );
1889 
1890  // set the jet selection if default empty string is overridden through config file
1891  if (m_metJetSelection.size()) {
1892  ATH_CHECK( m_metMaker.setProperty("JetSelection", m_metJetSelection) );
1893  }
1895  ATH_CHECK( m_metMaker.setProperty("DoPFlow", true) );
1896  }
1897 
1898  ATH_CHECK( m_metMaker.setProperty("OutputLevel", this->msg().level()) );
1900  } else ATH_CHECK( m_metMaker.retrieve() );
1901 
1902 
1904  m_metSystTool.setTypeAndName("met::METSystematicsTool/METSystTool");
1906 
1907  if (m_trkMETsyst && m_caloMETsyst){
1908  ATH_MSG_ERROR( "Can only have CST *or* TST configured for MET maker. Please unset either METDoCaloSyst or METDoTrkSyst in your config file" );
1909  return StatusCode::FAILURE;
1910  }
1911 
1912  if (m_trkMETsyst) {
1913  ATH_CHECK( m_metSystTool.setProperty("ConfigSoftCaloFile", "") );
1914  ATH_CHECK( m_metSystTool.setProperty("ConfigSoftTrkFile", "TrackSoftTerms-pflow.config") );
1915  }
1916 
1917  if (m_caloMETsyst) {
1918  ATH_MSG_WARNING( "CST is no longer recommended by Jet/MET group");
1919  ATH_CHECK( m_metSystTool.setProperty("ConfigSoftTrkFile", "") );
1920  }
1921 
1922  if (m_trkJetsyst) {
1923  ATH_CHECK( m_metSystTool.setProperty("ConfigJetTrkFile", "JetTrackSyst.config") );
1924  }
1925 
1926  ATH_CHECK( m_metSystTool.setProperty("OutputLevel", this->msg().level()) );
1928  } else ATH_CHECK( m_metSystTool.retrieve());
1929 
1930 
1931  if (!m_metSignif.isUserConfigured()) {
1932  // See https://twiki.cern.ch/twiki/bin/view/AtlasProtected/MetSignificance
1933  m_metSignif.setTypeAndName("met::METSignificance/metSignificance_"+jetname);
1934 #ifndef XAOD_STANDALONE // Athena and AthAnalysis; need to take into account that MuonCalibTool is private tool
1939  if(jetname == "AntiKt4EMTopo" || jetname =="AntiKt4EMPFlow"){
1940  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "JetCollection", jetname) );
1941  } else {
1942  ATH_MSG_WARNING("Object-based METSignificance recommendations only exist for EMTopo and PFlow, falling back to AntiKt4EMTopo");
1943  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "JetCollection", "AntiKt4EMTopo") );
1944  }
1945  // setup a dedicated new muon calib tool for passing down to METSignificance
1946  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "MuonCalibTool", "CP::MuonCalibTool/calibTool"));
1947  if (m_isRun3)
1948  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.IsRun3Geo", true));
1950  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.OutputLevel",this->msg().level()));
1951  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.release", "Recs2024_05_06_Run2Run3"));
1952  int IdBaselineInt = m_muIdBaseline;
1953  if (IdBaselineInt == 4)
1954  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.do2StationsHighPt", true));
1955  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.doExtraSmearing", m_muHighPtExtraSmear));
1956  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "OutputLevel", this->msg().level()));
1957 #else // AnalysisBase; can just pass the muon calib tool configured above
1958  ATH_CHECK( m_metSignif.setProperty("SoftTermParam", m_softTermParam) );
1959  ATH_CHECK( m_metSignif.setProperty("TreatPUJets", m_treatPUJets) );
1960  ATH_CHECK( m_metSignif.setProperty("DoPhiReso", m_doPhiReso) );
1961  ATH_CHECK( m_metSignif.setProperty("IsAFII", isAtlfast()) );
1962  if(jetname == "AntiKt4EMTopo" || jetname =="AntiKt4EMPFlow"){
1963  ATH_CHECK( m_metSignif.setProperty("JetCollection", jetname) );
1964  } else {
1965  ATH_MSG_WARNING("Object-based METSignificance recommendations only exist for EMTopo and PFlow, falling back to AntiKt4EMTopo");
1966  ATH_CHECK( m_metSignif.setProperty("JetCollection", "AntiKt4EMTopo") );
1967  }
1968  // just pass the muon calib tool
1970  ATH_CHECK( m_metSignif.setProperty("OutputLevel", this->msg().level()) );
1971 #endif
1973  } else ATH_CHECK( m_metSignif.retrieve() );
1974  }
1975 
1976 
1978 // Initialise trigger tools
1979 
1981 
1982  // The decision tool
1983  m_trigDecTool.setTypeAndName("Trig::TrigDecisionTool/TrigDecisionTool");
1984  ATH_CHECK( m_trigDecTool.setProperty("TrigDecisionKey", "xTrigDecision") );
1985  if (m_isRun3) {
1986  ATH_CHECK( m_trigDecTool.setProperty("NavigationFormat", "TrigComposite") );
1987  ATH_CHECK( m_trigDecTool.setProperty("HLTSummary", "HLTNav_Summary_DAODSlimmed") );
1988  }
1989  ATH_CHECK( m_trigDecTool.setProperty("OutputLevel", this->msg().level()) );
1990 
1991 #ifndef XAOD_STANDALONE // Athena and AthAnalysis
1992  // Clear the default tool handle to cause a fallback on the config service
1993  ATH_CHECK( m_trigDecTool.setProperty("ConfigTool", ""));
1994 #else // AnalysisBase
1995  m_trigConfTool.setTypeAndName("TrigConf::xAODConfigTool/xAODConfigTool");
1998 #endif
1999 
2001 
2002  } else ATH_CHECK( m_trigDecTool.retrieve() );
2003 
2004  if (m_isRun3) {
2006  m_trigDRScoringTool.setTypeAndName("Trig::DRScoringTool/TrigDRScoringTool");
2007  ATH_CHECK( m_trigDRScoringTool.setProperty("OutputLevel", this->msg().level()) );
2010  }
2011 
2014  m_trigMatchingTool.setTypeAndName("Trig::MatchFromCompositeTool/TrigMatchFromCompositeTool");
2016  ATH_CHECK( m_trigMatchingTool.setProperty("RemapBrokenLinks", true) );
2017  }
2018  else {
2019  if (m_isRun3){
2020  m_trigMatchingTool.setTypeAndName("Trig::R3MatchingTool/TrigR3MatchingTool");
2023  }
2024  else {
2025  m_trigMatchingTool.setTypeAndName("Trig::MatchingTool/TrigMatchingTool");
2027  }
2028  }
2029  ATH_CHECK( m_trigMatchingTool.setProperty("OutputLevel", this->msg().level()) );
2032 
2034 // Initialise trigGlobalEfficiencyCorrection tool
2035 
2037 
2038  std::string no2e17("");
2039  if (m_trig2017combination_diLep.find("||2e17_lhvloose_nod0_L12EM15VHI") != std::string::npos) {
2040  auto pos_2e17 = m_trig2017combination_diLep.find("||2e17_lhvloose_nod0_L12EM15VHI");
2041  no2e17 = m_trig2017combination_diLep.substr(0, pos_2e17) + m_trig2017combination_diLep.substr(pos_2e17+31, m_trig2017combination_diLep.size());
2042  } else if (m_trig2017combination_diLep.find("2e17_lhvloose_nod0_L12EM15VHI||") != std::string::npos) {
2043  auto pos_2e17 = m_trig2017combination_diLep.find("2e17_lhvloose_nod0_L12EM15VHI||");
2044  no2e17 = m_trig2017combination_diLep.substr(0, pos_2e17) + m_trig2017combination_diLep.substr(pos_2e17+31, m_trig2017combination_diLep.size());
2045  } else {
2046  no2e17 = m_trig2017combination_diLep;
2047  }
2048  ATH_MSG_DEBUG( "TrigGlobalEfficiencyCorrectionTool/TrigGlobal_diLep: no2e17 trigger string: " << no2e17 );
2049 
2050  std::map<std::string,std::string> triggers_diLep;
2051  triggers_diLep["2015"] = m_trig2015combination_diLep;
2052  triggers_diLep["2016"] = m_trig2016combination_diLep;
2053  triggers_diLep["324320-326695"] = m_trig2017combination_diLep; // 2017 before accidental prescale of L12EM15VHI
2054  triggers_diLep["326834-328393"] = no2e17; // 2017 during accidental prescale
2055  triggers_diLep["329385-340453"] = m_trig2017combination_diLep; // 2017 after accidental prescale
2056  triggers_diLep["2018"] = m_trig2018combination_diLep;
2057 
2058  m_trigGlobalEffCorrTool_diLep.setTypeAndName("TrigGlobalEfficiencyCorrectionTool/TrigGlobal_diLep");
2060  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("ElectronScaleFactorTools", m_elecTrigSFTools) );
2062  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("TriggerCombination", triggers_diLep) );
2066  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("OutputLevel", this->msg().level()) );
2069 
2070 
2072 
2073  std::string no2e17("");
2074  if (m_trig2017combination_multiLep.find("||2e17_lhvloose_nod0_L12EM15VHI") != std::string::npos) {
2075  auto pos_2e17 = m_trig2017combination_multiLep.find("||2e17_lhvloose_nod0_L12EM15VHI");
2076  no2e17 = m_trig2017combination_multiLep.substr(0, pos_2e17) + m_trig2017combination_multiLep.substr(pos_2e17+31, m_trig2017combination_multiLep.size());
2077  } else if (m_trig2017combination_multiLep.find("2e17_lhvloose_nod0_L12EM15VHI||") != std::string::npos) {
2078  auto pos_2e17 = m_trig2017combination_multiLep.find("2e17_lhvloose_nod0_L12EM15VHI||");
2079  no2e17 = m_trig2017combination_multiLep.substr(0, pos_2e17) + m_trig2017combination_multiLep.substr(pos_2e17+31, m_trig2017combination_multiLep.size());
2080  } else {
2082  }
2083  ATH_MSG_DEBUG( "TrigGlobalEfficiencyCorrectionTool/TrigGlobal_multiLep: no2e17 trigger string: " << no2e17 );
2084 
2085  std::map<std::string,std::string> triggers_multiLep;
2086  triggers_multiLep["2015"] = m_trig2015combination_multiLep;
2087  triggers_multiLep["2016"] = m_trig2016combination_multiLep;
2088  triggers_multiLep["324320-326695"] = m_trig2017combination_multiLep; // 2017 before accidental prescale of L12EM15VHI
2089  triggers_multiLep["326834-328393"] = no2e17; // 2017 during accidental prescale
2090  triggers_multiLep["329385-340453"] = m_trig2017combination_multiLep; // 2017 after accidental prescale
2091  triggers_multiLep["2018"] = m_trig2018combination_multiLep;
2092 
2093  m_trigGlobalEffCorrTool_multiLep.setTypeAndName("TrigGlobalEfficiencyCorrectionTool/TrigGlobal_multiLep");
2097  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("TriggerCombination", triggers_multiLep) );
2101  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("OutputLevel", this->msg().level()) );
2104 
2105 
2107  m_trigGlobalEffCorrTool_diPhoton.setTypeAndName("TrigGlobalEfficiencyCorrectionTool/TrigGlobal_diPhoton");
2116  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("OutputLevel", this->msg().level()) );
2119 
2120 
2121  if (m_slices["ele"] || m_slices["pho"] || m_slices["mu"]) {
2122  // /////////////////////////////////////////////////////////////////////////////////////////
2123  // Initialise Isolation Correction Tool
2124 
2125  if ( !m_isoCorrTool.isUserConfigured() ) {
2126  m_isoCorrTool.setTypeAndName("CP::IsolationCorrectionTool/IsoCorrTool");
2127  ATH_CHECK( m_isoCorrTool.setProperty( "ToolVer", "REL22") );
2128  ATH_CHECK( m_isoCorrTool.setProperty( "IsMC", !isData()) );
2129  ATH_CHECK( m_isoCorrTool.setProperty( "AFII_corr", isAtlfast()) );
2130  ATH_CHECK( m_isoCorrTool.setProperty( "Apply_SC_leakcorr", false) );
2131  ATH_CHECK( m_isoCorrTool.setProperty( "CorrFile", "IsolationCorrections/v6/isolation_ptcorrections_rel22_mc20.root") );
2132  ATH_CHECK( m_isoCorrTool.setProperty( "OutputLevel", this->msg().level()) );
2134  } else ATH_CHECK( m_isoCorrTool.retrieve() );
2135 
2136 
2137  // /////////////////////////////////////////////////////////////////////////////////////////
2138  // Initialise Isolation Tool
2139  if (!m_isoTool.isUserConfigured()) {
2140  m_isoTool.setTypeAndName("CP::IsolationSelectionTool/IsoTool");
2141  ATH_CHECK( m_isoTool.setProperty("ElectronWP", m_eleIso_WP.empty() ? "Loose_VarRad" : m_eleIso_WP) );
2142  ATH_CHECK( m_isoTool.setProperty("MuonWP", m_muIso_WP.empty() ? "Loose_VarRad" : m_muIso_WP) );
2143  ATH_CHECK( m_isoTool.setProperty("PhotonWP", m_photonIso_WP.empty() ? "FixedCutTight" : m_photonIso_WP ) );
2144  ATH_CHECK( m_isoTool.setProperty("OutputLevel", this->msg().level()) );
2146  } else ATH_CHECK( m_isoTool.retrieve() );
2147 
2148  //disable if (!m_isoToolLowPtPLV.isUserConfigured()) {
2149  //disable m_isoToolLowPtPLV.setTypeAndName("CP::IsolationLowPtPLVTool/IsoToolLowPtPLV");
2150  //disable ATH_CHECK( m_isoToolLowPtPLV.setProperty("OutputLevel", this->msg().level()) );
2151  //disable ATH_CHECK( m_isoToolLowPtPLV.retrieve() );
2152  //disable } else ATH_CHECK( m_isoToolLowPtPLV.retrieve() );
2153 
2154 
2156  m_isoBaselineTool.setTypeAndName("CP::IsolationSelectionTool/IsoBaselineTool");
2157  ATH_CHECK( m_isoBaselineTool.setProperty("ElectronWP", m_eleBaselineIso_WP.empty() ? "Loose_VarRad" : m_eleBaselineIso_WP ) );
2158  ATH_CHECK( m_isoBaselineTool.setProperty("MuonWP", m_muBaselineIso_WP.empty() ? "Loose_VarRad" : m_muBaselineIso_WP ) );
2159  ATH_CHECK( m_isoBaselineTool.setProperty("PhotonWP", m_photonBaselineIso_WP.empty() ? "FixedCutTight" : m_photonBaselineIso_WP ) );
2160  ATH_CHECK( m_isoBaselineTool.setProperty("OutputLevel", this->msg().level()) );
2162  } else ATH_CHECK( m_isoBaselineTool.retrieve() );
2163 
2164 
2166  m_isoHighPtTool.setTypeAndName("CP::IsolationSelectionTool/IsoHighPtTool");
2167  ATH_CHECK( m_isoHighPtTool.setProperty("ElectronWP", m_eleIsoHighPt_WP.empty() ? "Loose_VarRad" : m_eleIsoHighPt_WP) );
2168  ATH_CHECK( m_isoHighPtTool.setProperty("MuonWP", m_muIsoHighPt_WP.empty() ? "Loose_VarRad" : m_muIsoHighPt_WP ) );
2169  ATH_CHECK( m_isoHighPtTool.setProperty("PhotonWP", m_photonIso_WP.empty() ? "FixedCutTight" : m_photonIso_WP ) );
2170  ATH_CHECK( m_isoHighPtTool.setProperty("OutputLevel", this->msg().level()) );
2172  } else ATH_CHECK( m_isoHighPtTool.retrieve() );
2173 
2174 
2175  // /////////////////////////////////////////////////////////////////////////////////////////
2176  // Initialise IsolationCloseByCorrectionTool Tool
2178  m_isoCloseByTool.setTypeAndName("CP::IsolationCloseByCorrectionTool/IsoCloseByTool");
2179  // Actually we could debate about what is the proper tool to choose if the users have different baseline & signal islation WP's
2181  ATH_CHECK( m_isoCloseByTool.setProperty("PassoverlapDecorator", m_IsoCloseByORpassLabel) );
2182  ATH_CHECK( m_isoCloseByTool.setProperty("SelectionDecorator", m_useSigLepForIsoCloseByOR ? "signal" : "baseline") );
2183  // Make this propery configurable as well?
2184  ATH_CHECK( m_isoCloseByTool.setProperty("BackupPrefix", "ORIG") );
2185  // The isolation selection decorator is updated as well by the tool
2186  ATH_CHECK( m_isoCloseByTool.setProperty("IsolationSelectionDecorator", "isol") );
2187 
2188  ATH_CHECK( m_isoCloseByTool.setProperty("OutputLevel", this->msg().level()) );
2189 #ifndef XAOD_ANALYSIS
2190  ATH_CHECK( m_isoCloseByTool.setProperty("ParticleCaloExtensionTool", "") );
2191 #endif
2193  } else ATH_CHECK( m_isoCloseByTool.retrieve() );
2194  }
2195 
2196 
2197 // /////////////////////////////////////////////////////////////////////////////////////////
2198 // Initialise Overlap Removal Tool
2199  if ( m_orToolbox.masterTool.empty() ){
2200 
2201  // set up the master tool
2202  std::string suffix = "";
2203  if (m_orDoTau) suffix += "Tau";
2204  if (m_orDoPhoton) suffix += "Gamma";
2205  if (m_orDoBjet) suffix += "Bjet";
2206  std::string toolName = "ORTool" + suffix;
2207  ATH_MSG_INFO("SUSYTools: Autoconfiguring " << toolName);
2208 
2209  std::string bJetLabel = "";
2210  //overwrite lepton flags if the global is false (yes?)
2211  if (!m_orDoBjet || !m_useBtagging) {
2212  m_orDoElBjet = false;
2213  m_orDoMuBjet = false;
2214  m_orDoTauBjet = false;
2215  }
2217  bJetLabel = "bjet_loose";
2218  }
2219 
2220  // Set the generic flags
2221  ORUtils::ORFlags orFlags(toolName, m_orInputLabel, "passOR");
2222  orFlags.bJetLabel = bJetLabel;
2223  orFlags.boostedLeptons = (m_orDoBoostedElectron || m_orDoBoostedMuon);
2224  orFlags.outputPassValue = true;
2225  orFlags.linkOverlapObjects = m_orLinkOverlapObjects;
2226  if (m_orDoElEl) {
2227  orFlags.doEleEleOR = true;
2228  } else orFlags.doEleEleOR = false;
2229  orFlags.doElectrons = true;
2230  orFlags.doMuons = true;
2231  orFlags.doJets = true;
2232  orFlags.doTaus = m_orDoTau;
2233  orFlags.doPhotons = m_orDoPhoton;
2234  orFlags.doFatJets = m_orDoFatjets;
2235 
2236  //set up all recommended tools
2238 
2239  // We don't currently have a good way to determine here which object
2240  // definitions are disabled, so we currently just configure all overlap
2241  // tools and disable the pointer safety checks
2242  ATH_CHECK( m_orToolbox.setGlobalProperty("OutputLevel", this->msg().level()) );
2243  ATH_CHECK( m_orToolbox.masterTool.setProperty("RequireExpectedPointers", false) );
2244 
2245  // Override boosted OR sliding cone options
2248 
2249  //add custom tau-jet OR tool
2250  if(m_orDoTau){
2251  m_orToolbox.tauJetORT.setTypeAndName("ORUtils::TauJetOverlapTool/" + orFlags.masterName + ".TauJetORT");
2253  }
2254 
2255  // override sliding cone params if sliding dR is on and the user-provided parameter values are non-negative
2256  if (m_orDoBoostedElectron) {
2260  }
2261  if (m_orDoBoostedMuon) {
2265  }
2266 
2267  // and switch off lep-bjet check if not requested
2268  if (!m_orDoElBjet) {
2269  ATH_CHECK(m_orToolbox.eleJetORT.setProperty("BJetLabel", ""));
2270  }
2271  if (!m_orDoMuBjet) {
2272  ATH_CHECK(m_orToolbox.muJetORT.setProperty("BJetLabel", ""));
2273  }
2274 
2275  // propagate the mu-jet ghost-association option which might be set by the user (default is true)
2277 
2278  // propagate mu-jet OR settings if requested
2280  if(m_orApplyRelPt){
2283  }
2285 
2286  // propagate the calo muon setting for EleMuORT
2288 
2289  // Use electron-muon DR matching to remove electrons within DR < 0.01 of Muons.
2290  if (m_orDoElMu){
2291  ATH_CHECK(m_orToolbox.eleMuORT.setProperty("UseDRMatching", m_orDoElMu) );
2292  }
2293 
2294  // propagate the fatjets OR settings
2295  if(m_orDoFatjets){
2298  }
2299 
2300  // Make sure that we deal with prorities correctly
2301  ATH_CHECK(m_orToolbox.eleJetORT.setProperty("EnableUserPriority", true));
2302  ATH_CHECK(m_orToolbox.muJetORT.setProperty("EnableUserPriority", true));
2303  if (m_orDoTau) ATH_CHECK(m_orToolbox.tauJetORT.setProperty("EnableUserPriority", true));
2304  if (m_orDoPhoton) ATH_CHECK(m_orToolbox.phoJetORT.setProperty("EnableUserPriority", true));
2305 
2306  if ( m_orPhotonFavoured ) {
2307  ATH_CHECK(m_orToolbox.phoEleORT.setProperty("SwapContainerPrecedence", true));
2308  ATH_CHECK(m_orToolbox.phoMuORT.setProperty("SwapContainerPrecedence", true));
2309  }
2310 
2311  if (!m_orDoEleJet){
2312  // Disable the electron removal part of e-j overlap removal
2313  ATH_CHECK( m_orToolbox.eleJetORT.setProperty("OuterDR",-1.) );
2314  ATH_CHECK( m_orToolbox.eleJetORT.setProperty("SlidingDRMaxCone",-1.) );
2315  }
2316  if (!m_orDoMuonJet){
2317  // Disable the muon removal part of m-j overlap removal
2318  ATH_CHECK( m_orToolbox.muJetORT.setProperty("OuterDR",-1.) );
2319  ATH_CHECK( m_orToolbox.muJetORT.setProperty("SlidingDRMaxCone",-1.) );
2320  }
2321 
2323 
2324  }
2325  // Done with the OR toolbox setup!
2326 
2327 // /////////////////////////////////////////////////////////////////////////////////////////
2328 // Initialise PMG Tools
2330  m_pmgSHnjetWeighter.setTypeAndName("PMGTools::PMGSherpa22VJetsWeightTool/PMGSHVjetReweighter");
2331  ATH_CHECK( m_pmgSHnjetWeighter.setProperty( "TruthJetContainer", "AntiKt4TruthJets"));
2332  ATH_CHECK( m_pmgSHnjetWeighter.setProperty("OutputLevel", this->msg().level()) );
2335 
2336 
2338  m_pmgSHnjetWeighterWZ.setTypeAndName("PMGTools::PMGSherpa22VJetsWeightTool/PMGSHVjetReweighterWZ");
2339  ATH_CHECK( m_pmgSHnjetWeighterWZ.setProperty( "TruthJetContainer", "AntiKt4TruthWZJets"));
2340  ATH_CHECK( m_pmgSHnjetWeighterWZ.setProperty("OutputLevel", this->msg().level()) );
2343 
2344 
2345  // prevent these initialiation snippets from being run again
2346  m_subtool_init = true;
2347 
2348  ATH_MSG_INFO("Done initialising SUSYTools");
2349 
2350  return StatusCode::SUCCESS;
2351 }

◆ sysInitialize()

StatusCode asg::AsgMetadataTool::sysInitialize ( )
virtualinherited

Function initialising the tool in the correct way in Athena.

This function is used to set up the callbacks from IncidentSvc in Athena at the right time during initialisation, without the user having to do anything special in his/her code.

Reimplemented from AthCommonDataStore< AthCommonMsg< AlgTool > >.

Definition at line 110 of file AsgMetadataTool.cxx.

110  {
111 
112 #ifndef XAOD_STANDALONE
113  if (m_useIncidents) {
114  // Connect to the IncidentSvc:
115  ServiceHandle< IIncidentSvc > incSvc( "IncidentSvc", name() );
116  ATH_CHECK( incSvc.retrieve() );
117 
118  // Set up the right callbacks: don't rethrow exceptions, any failure and we should end
119  incSvc->addListener( this, IncidentType::BeginEvent, 0, false );
120  }
121  // Let the base class do its thing:
122  ATH_CHECK( AlgTool::sysInitialize() );
123 
124 #endif // not XAOD_STANDALONE
125 
126  // Return gracefully:
127  return StatusCode::SUCCESS;
128  }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ treatAsYear()

int ST::SUSYObjDef_xAOD::treatAsYear ( const int  runNumber = -1) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3071 of file SUSYObjDef_xAOD.cxx.

3071  {
3072  // Use the run number we are passed if we are passed one, otherwise
3073  // use the run number from the GetRunNumber function
3074  int theRunNumber = runNumber>0?runNumber:GetRunNumber();
3075  if (theRunNumber<290000) return 2015;
3076  else if (theRunNumber<320000) return 2016;
3077  else if (theRunNumber<342000) return 2017;
3078  else if (theRunNumber<400000) return 2018;
3079  else if (theRunNumber<445000) return 2022;
3080  else if (theRunNumber<465000) return 2023;
3081  return 2024;
3082 }

◆ TrigMatch() [1/10]

void ST::SUSYObjDef_xAOD::TrigMatch ( const std::initializer_list< const xAOD::IParticle * > &  v,
const std::initializer_list< std::string > &  items 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 269 of file Trigger.cxx.

269  {
270  for(const auto& p : v) {
271  this->TrigMatch(p, items);
272  }
273 }

◆ TrigMatch() [2/10]

void ST::SUSYObjDef_xAOD::TrigMatch ( const std::initializer_list< const xAOD::IParticle * > &  v,
const std::string &  item 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 307 of file Trigger.cxx.

307  {
308  return this->TrigMatch(v, {item});
309 }

◆ TrigMatch() [3/10]

void ST::SUSYObjDef_xAOD::TrigMatch ( const std::initializer_list< const xAOD::IParticle * > &  v,
const std::vector< std::string > &  items 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 276 of file Trigger.cxx.

276  {
277  for(const auto& p : v) {
278  this->TrigMatch(p, items);
279  }
280 }

◆ TrigMatch() [4/10]

void ST::SUSYObjDef_xAOD::TrigMatch ( const xAOD::IParticle p,
const std::initializer_list< std::string > &  items 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 252 of file Trigger.cxx.

252  {
253  this->TrigMatch(p, items.begin(), items.end());
254 }

◆ TrigMatch() [5/10]

void ST::SUSYObjDef_xAOD::TrigMatch ( const xAOD::IParticle p,
const std::string &  item 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 297 of file Trigger.cxx.

297  {
298  return this->TrigMatch(p, {item});
299 }

◆ TrigMatch() [6/10]

void ST::SUSYObjDef_xAOD::TrigMatch ( const xAOD::IParticle p,
const std::vector< std::string > &  items 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 257 of file Trigger.cxx.

257  {
258  dec_trigmatched(*p) = 0;
259 
260  for(const auto& item: items) {
261  auto result = static_cast<int>(this->IsTrigMatched(p, item));
262  dec_trigmatched(*p) += result;
263  const SG::Decorator<char> dec(item);
264  dec(*p) = result;
265  }
266 }

◆ TrigMatch() [7/10]

void ST::SUSYObjDef_xAOD::TrigMatch ( const xAOD::IParticle p,
std::initializer_list< std::string >::iterator  i1,
std::initializer_list< std::string >::iterator  i2 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 240 of file Trigger.cxx.

240  {
241  dec_trigmatched(*p) = 0;
242 
243  for(const auto *it = i1; it != i2; ++it) {
244  auto result = static_cast<int>(this->IsTrigMatched(p, *it));
245  dec_trigmatched(*p) += result;
246  const SG::Decorator<char> dec(*it);
247  dec(*p) = result;
248  }
249 }

◆ TrigMatch() [8/10]

void ST::SUSYObjDef_xAOD::TrigMatch ( const xAOD::IParticleContainer v,
const std::initializer_list< std::string > &  items 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 290 of file Trigger.cxx.

290  {
291  for(const auto& p : *v) {
292  this->TrigMatch(p, items);
293  }
294 }

◆ TrigMatch() [9/10]

void ST::SUSYObjDef_xAOD::TrigMatch ( const xAOD::IParticleContainer v,
const std::string &  item 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 302 of file Trigger.cxx.

302  {
303  return this->TrigMatch(v, {item});
304 }

◆ TrigMatch() [10/10]

void ST::SUSYObjDef_xAOD::TrigMatch ( const xAOD::IParticleContainer v,
const std::vector< std::string > &  items 
)
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 283 of file Trigger.cxx.

283  {
284  for(const auto& p : *v) {
285  this->TrigMatch(p, items);
286  }
287 }

◆ TrigSingleLep()

std::string ST::SUSYObjDef_xAOD::TrigSingleLep ( ) const
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2071 of file SUSYObjDef_xAOD.cxx.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

◆ validConfig()

StatusCode ST::SUSYObjDef_xAOD::validConfig ( bool  strict = false) const
protected

baseline vs signal pt check

WP check

check pt and eta range

Definition at line 1916 of file SUSYObjDef_xAOD.cxx.

1916  {
1917  // Validate configuration (i.e. that signal settings are tighter than baseline, etc)
1918  // :: Throw SC::FAILURE if strict mode is enabled, just a WARNING if not
1919 
1920  // Electrons
1921  if( m_elePt < m_eleBaselinePt ){
1922  ATH_MSG_WARNING("Your electron pt configuration is inconsistent! Signal : " << m_elePt << " < Baseline : " << m_eleBaselinePt);
1923  if(strict) return StatusCode::FAILURE;
1924  }
1925  if( m_eleEta > m_eleBaselineEta ){
1926  ATH_MSG_WARNING("Your electron eta configuration is inconsistent! Signal : " << m_eleEta << " < Baseline : " << m_eleBaselineEta);
1927  if(strict) return StatusCode::FAILURE;
1928  }
1929 
1931  ATH_MSG_WARNING("Your electron ID configuration is inconsistent! Signal : " << m_eleId << " looser than Baseline : " << m_eleIdBaseline);
1932  if(strict) return StatusCode::FAILURE;
1933  }
1935  ATH_MSG_WARNING("Your electron crack removal is inconsistent! Signal : " << m_eleCrackVeto << " while Baseline : " << m_eleBaselineCrackVeto);
1936  if(strict) return StatusCode::FAILURE;
1937  }
1938 
1939  // Muons
1940  if( m_muPt < m_muBaselinePt ){
1941  ATH_MSG_WARNING("Your muon pt configuration is inconsistent! Signal : " << m_muPt << " < Baseline : " << m_muBaselinePt);
1942  if(strict) return StatusCode::FAILURE;
1943  }
1944  if( m_muEta > m_muBaselineEta ){
1945  ATH_MSG_WARNING("Your muon eta configuration is inconsistent! Signal : " << m_muEta << " < Baseline : " << m_muBaselineEta);
1946  if(strict) return StatusCode::FAILURE;
1947  }
1948  if( m_muId > m_muIdBaseline ){
1949  ATH_MSG_WARNING("Your muon ID configuration is inconsistent! Signal : " << m_muId << " < Baseline : " << m_muIdBaseline);
1950  if(strict) return StatusCode::FAILURE;
1951  }
1952 
1953  // Photons
1955  ATH_MSG_WARNING("Your photon pt configuration is inconsistent! Signal : " << m_photonPt << " < Baseline : " << m_photonBaselinePt);
1956  if(strict) return StatusCode::FAILURE;
1957  }
1959  ATH_MSG_WARNING("Your photon eta configuration is inconsistent! Signal : " << m_photonEta << " < Baseline : " << m_photonBaselineEta);
1960  if(strict) return StatusCode::FAILURE;
1961  }
1962  if( m_photonId=="Loose" && m_photonIdBaseline=="Tight" ){
1963  ATH_MSG_WARNING("Your photon ID configuration is inconsistent! Signal : " << m_photonId << " < Baseline : " << m_photonIdBaseline);
1964  if(strict) return StatusCode::FAILURE;
1965  }
1967  ATH_MSG_WARNING("Your photon crack removal is inconsistent! Signal : " << m_photonCrackVeto << " while Baseline : " << m_photonBaselineCrackVeto);
1968  if(strict) return StatusCode::FAILURE;
1969  }
1970 
1971  // Jets
1972  if ( m_jetPt < 20e3 ){
1973  ATH_MSG_WARNING("Your minimum signal jet pt is less than 20 GeV! Jet.Pt : " << m_jetPt << ". This is NOT supported by the jet group!");
1974  }
1975 
1976  //Btagging //OR-wp looser than signal-wp?
1977  if( m_BtagWP.compare(0, m_BtagWP.size()-3, m_orBtagWP, 0, m_BtagWP.size()-3) == 0 ){ //same tagger WP (FixedCutBEff_XX or HybBEff_XX)
1978  if( atoi(m_BtagWP.substr(m_BtagWP.size()-2, m_BtagWP.size()).c_str()) > atoi(m_orBtagWP.substr(m_orBtagWP.size()-2, m_orBtagWP.size()).c_str()) ){
1979  ATH_MSG_WARNING("Your btagging configuration is inconsistent! Signal : " << m_BtagWP << " is looser than OR-Baseline : " << m_orBtagWP);
1980  }
1981  }
1982  if (m_BtagMinPt < 20e3 || m_BtagMinPt_trkJet < 10e3) {
1983  ATH_MSG_WARNING("You btagging MinPt settings are inconsistent! EM(Topo|PFlow)Jets: not calibrated below 20 GeV (Btag.MinPt: " << m_BtagMinPt/1000. << " GeV set), VRTrackJets: not calibrated below 10 GeV (BtagTrkJet.MinPt: " << m_BtagMinPt_trkJet/1000. << " GeV set).");
1984  }
1985 
1986  //Taus
1988  if(m_tauPrePtCut > 0 and m_tauPrePtCut > m_tauPt) {
1989  ATH_MSG_WARNING("Your tau pt configuration is inconsistent! Signal pt cut : " << m_tauPt << " < Baseline (pre) pt cut : " << m_tauPrePtCut);
1990  if(strict) return StatusCode::FAILURE;
1991  }
1994  ATH_MSG_WARNING("Your tau ID configuration is inconsistent! Signal : " << m_tauId << " looser than Baseline : " << m_tauIdBaseline);
1995  if(strict) return StatusCode::FAILURE;
1996  }
1997 
1999  std::vector<float> pT_window;
2000  std::vector<float> eta_window;
2001  bool elOLR=false;
2002  bool muVeto=false;
2003  bool muOLR=false;
2004 
2005  if(!m_tauConfigPathBaseline.empty()) { //baseline taus
2006 
2007  std::string theConfig = m_tauConfigPathBaseline;
2008  if( m_tauConfigPathBaseline=="default" ){
2009  if (m_tauId == "rnn001") theConfig = "SUSYTools/tau_selection_rnn001.conf";
2010  else if (m_tauId == "VeryLoose") theConfig = "SUSYTools/tau_selection_veryloose.conf";
2011  else if (m_tauId == "Loose") theConfig = "SUSYTools/tau_selection_loose.conf";
2012  else if (m_tauId == "Medium") theConfig = "SUSYTools/tau_selection_medium.conf";
2013  else if (m_tauId == "Tight") theConfig = "SUSYTools/tau_selection_tight.conf";
2014  }
2015 
2016  //read config
2017  getTauConfig(theConfig, pT_window, eta_window, elOLR, muVeto, muOLR);
2018 
2019  //pt-eta checks
2020  if( m_tauPrePtCut > 0 and (m_tauPrePtCut != 1000*pT_window[0] or (pT_window[1] > 0 and m_tauPrePtCut > 1000*pT_window[1]))) {
2021  ATH_MSG_WARNING("Your baseline tau pt configuration is inconsistent! pre pT cut : " << m_tauPrePtCut << " / TauSelectionTool window (in MeV) : [" << 1000*pT_window[0] << ", " << 1000*pT_window[1] << "]");
2022  if(strict) return StatusCode::FAILURE;
2023  }
2024 
2025  if( m_tauPt > 0 and (m_tauPt != 1000*pT_window[0] or (pT_window[1] > 0 and m_tauPt > 1000*pT_window[1]))) {
2026  ATH_MSG_WARNING("Your baseline tau pt configuration is inconsistent! pT cut : " << m_tauPt << " / TauSelectionTool window (in Mev) : [" << 1000*pT_window[0] << ", " << 1000*pT_window[1] << "]");
2027  if(strict) return StatusCode::FAILURE;
2028  }
2029 
2030  if( m_tauEta > 0 and m_tauEta != eta_window[eta_window.size()-1]) { // eta window can have 4 entries
2031  ATH_MSG_WARNING("Your baseline tau eta configuration is inconsistent! eta cut : " << m_tauEta << " != TauSelectionTool max eta : " << eta_window[eta_window.size()-1]);
2032  if(strict) return StatusCode::FAILURE;
2033  }
2034  }
2035 
2036  if(!m_tauConfigPath.empty()) { //signal taus
2037 
2038  std::string theConfig = m_tauConfigPath;
2039  if( m_tauConfigPath=="default" ){
2040  if (m_tauId == "rnn001") theConfig = "SUSYTools/tau_selection_rnn001.conf";
2041  else if (m_tauId == "VeryLoose") theConfig = "SUSYTools/tau_selection_veryloose.conf";
2042  else if (m_tauId == "Loose") theConfig = "SUSYTools/tau_selection_loose.conf";
2043  else if (m_tauId == "Medium") theConfig = "SUSYTools/tau_selection_medium.conf";
2044  else if (m_tauId == "Tight") theConfig = "SUSYTools/tau_selection_tight.conf";
2045  }
2046 
2047  getTauConfig(theConfig, pT_window, eta_window, elOLR, muVeto, muOLR);
2048 
2049  if( m_tauPrePtCut > 0 and (m_tauPrePtCut != 1000*pT_window[0] or (pT_window[1] > 0 and m_tauPrePtCut > 1000*pT_window[1]))) {
2050  ATH_MSG_WARNING("Your tau pt configuration is inconsistent! pre pT cut : " << m_tauPrePtCut << " / TauSelectionTool window (in MeV) : [" << 1000*pT_window[0] << ", " << 1000*pT_window[1] << "]");
2051  if(strict) return StatusCode::FAILURE;
2052  }
2053 
2054  if( m_tauPt > 0 and (m_tauPt != 1000*pT_window[0] or (pT_window[1] > 0 and m_tauPt > 1000*pT_window[1]))) {
2055  ATH_MSG_WARNING("Your tau pt configuration is inconsistent! pT cut : " << m_tauPt << " / TauSelectionTool window (in Mev) : [" << 1000*pT_window[0] << ", " << 1000*pT_window[1] << "]");
2056  if(strict) return StatusCode::FAILURE;
2057  }
2058 
2059  if( m_tauEta > 0 and m_tauEta != eta_window[eta_window.size()-1]) { // eta window can have 4 entries
2060  ATH_MSG_WARNING("Your tau eta configuration is inconsistent! eta cut : " << m_tauEta << " != TauSelectionTool max eta : " << eta_window[eta_window.size()-1]);
2061  if(strict) return StatusCode::FAILURE;
2062  }
2063  }
2064 
2065 
2066  return StatusCode::SUCCESS;
2067 }

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/2]

std::map<std::string, std::function<bool()> > m_metTriggerFuncs ST::SUSYObjDef_xAOD::ATLAS_THREAD_SAFE
mutableprivate

Definition at line 443 of file SUSYObjDef_xAOD.h.

◆ ATLAS_THREAD_SAFE [2/2]

std::map<std::string, bool> m_checkedTriggers ST::SUSYObjDef_xAOD::ATLAS_THREAD_SAFE
mutableprivate

Definition at line 445 of file SUSYObjDef_xAOD.h.

◆ lrt_electrons

const xAOD::ElectronContainer* ST::SUSYObjDef_xAOD::lrt_electrons = nullptr

Definition at line 211 of file SUSYObjDef_xAOD.h.

◆ lrt_muons

const xAOD::MuonContainer* ST::SUSYObjDef_xAOD::lrt_muons = nullptr

Definition at line 205 of file SUSYObjDef_xAOD.h.

◆ m_acc_eleId

SG::ConstAccessor<char> ST::SUSYObjDef_xAOD::m_acc_eleId
protected

Definition at line 982 of file SUSYObjDef_xAOD.h.

◆ m_acc_eleIdBaseline

SG::ConstAccessor<char> ST::SUSYObjDef_xAOD::m_acc_eleIdBaseline
protected

Definition at line 981 of file SUSYObjDef_xAOD.h.

◆ m_acc_jetClean

SG::ConstAccessor<char> ST::SUSYObjDef_xAOD::m_acc_jetClean
protected

Definition at line 985 of file SUSYObjDef_xAOD.h.

◆ m_acc_photonId

SG::ConstAccessor<char> ST::SUSYObjDef_xAOD::m_acc_photonId
protected

Definition at line 984 of file SUSYObjDef_xAOD.h.

◆ m_acc_photonIdBaseline

SG::ConstAccessor<char> ST::SUSYObjDef_xAOD::m_acc_photonIdBaseline
protected

Definition at line 983 of file SUSYObjDef_xAOD.h.

◆ m_applyJVTCut

bool ST::SUSYObjDef_xAOD::m_applyJVTCut
protected

Definition at line 812 of file SUSYObjDef_xAOD.h.

◆ m_autoconfigPRW

bool ST::SUSYObjDef_xAOD::m_autoconfigPRW
protected

Definition at line 588 of file SUSYObjDef_xAOD.h.

◆ m_autoconfigPRWCombinedmode

bool ST::SUSYObjDef_xAOD::m_autoconfigPRWCombinedmode
protected

Definition at line 591 of file SUSYObjDef_xAOD.h.

◆ m_autoconfigPRWFile

std::string ST::SUSYObjDef_xAOD::m_autoconfigPRWFile
protected

Definition at line 590 of file SUSYObjDef_xAOD.h.

◆ m_autoconfigPRWPath

std::string ST::SUSYObjDef_xAOD::m_autoconfigPRWPath
protected

Definition at line 589 of file SUSYObjDef_xAOD.h.

◆ m_autoconfigPRWRPVmode

bool ST::SUSYObjDef_xAOD::m_autoconfigPRWRPVmode
protected

Definition at line 592 of file SUSYObjDef_xAOD.h.

◆ m_autoconfigPRWRtags

std::string ST::SUSYObjDef_xAOD::m_autoconfigPRWRtags
protected

Definition at line 593 of file SUSYObjDef_xAOD.h.

◆ m_badJetCut

std::string ST::SUSYObjDef_xAOD::m_badJetCut
protected

Definition at line 537 of file SUSYObjDef_xAOD.h.

◆ m_badmuQoverP

double ST::SUSYObjDef_xAOD::m_badmuQoverP
protected

Definition at line 707 of file SUSYObjDef_xAOD.h.

◆ m_beginInputFileCalled

bool asg::AsgMetadataTool::m_beginInputFileCalled
privateinherited

Flag helping to discover when the tool misses the opening of the first input file.

Definition at line 126 of file AsgMetadataTool.h.

◆ m_bool_prop_set

std::set<std::string> ST::SUSYObjDef_xAOD::m_bool_prop_set
private

Definition at line 439 of file SUSYObjDef_xAOD.h.

◆ m_btagEffTool

asg::AnaToolHandle<IBTaggingEfficiencyTool> ST::SUSYObjDef_xAOD::m_btagEffTool
protected

Definition at line 912 of file SUSYObjDef_xAOD.h.

◆ m_btagEffTool_trkJet

asg::AnaToolHandle<IBTaggingEfficiencyTool> ST::SUSYObjDef_xAOD::m_btagEffTool_trkJet
protected

Definition at line 915 of file SUSYObjDef_xAOD.h.

◆ m_bTaggingCalibrationFilePath

std::string ST::SUSYObjDef_xAOD::m_bTaggingCalibrationFilePath
protected

Definition at line 814 of file SUSYObjDef_xAOD.h.

◆ m_BtagKeyOverride

std::string ST::SUSYObjDef_xAOD::m_BtagKeyOverride
protected

Definition at line 670 of file SUSYObjDef_xAOD.h.

◆ m_BtagMinPt

double ST::SUSYObjDef_xAOD::m_BtagMinPt
protected

Definition at line 669 of file SUSYObjDef_xAOD.h.

◆ m_BtagMinPt_trkJet

double ST::SUSYObjDef_xAOD::m_BtagMinPt_trkJet
protected

Definition at line 677 of file SUSYObjDef_xAOD.h.

◆ m_btagSelTool

asg::AnaToolHandle<IBTaggingSelectionTool> ST::SUSYObjDef_xAOD::m_btagSelTool
protected

Definition at line 913 of file SUSYObjDef_xAOD.h.

◆ m_btagSelTool_OR

asg::AnaToolHandle<IBTaggingSelectionTool> ST::SUSYObjDef_xAOD::m_btagSelTool_OR
protected

Definition at line 914 of file SUSYObjDef_xAOD.h.

◆ m_btagSelTool_trkJet

asg::AnaToolHandle<IBTaggingSelectionTool> ST::SUSYObjDef_xAOD::m_btagSelTool_trkJet
protected

Definition at line 916 of file SUSYObjDef_xAOD.h.

◆ m_BtagSystStrategy

std::string ST::SUSYObjDef_xAOD::m_BtagSystStrategy
protected

Definition at line 671 of file SUSYObjDef_xAOD.h.

◆ m_BtagTagger

std::string ST::SUSYObjDef_xAOD::m_BtagTagger
protected

Definition at line 668 of file SUSYObjDef_xAOD.h.

◆ m_BtagTagger_trkJet

std::string ST::SUSYObjDef_xAOD::m_BtagTagger_trkJet
protected

Definition at line 676 of file SUSYObjDef_xAOD.h.

◆ m_BtagWP

std::string ST::SUSYObjDef_xAOD::m_BtagWP
protected

Definition at line 667 of file SUSYObjDef_xAOD.h.

◆ m_BtagWP_trkJet

std::string ST::SUSYObjDef_xAOD::m_BtagWP_trkJet
protected

Definition at line 675 of file SUSYObjDef_xAOD.h.

◆ m_caloMETsyst

bool ST::SUSYObjDef_xAOD::m_caloMETsyst
protected

Definition at line 581 of file SUSYObjDef_xAOD.h.

◆ m_commonPRWFileMC20a

std::string ST::SUSYObjDef_xAOD::m_commonPRWFileMC20a
protected

Definition at line 598 of file SUSYObjDef_xAOD.h.

◆ m_commonPRWFileMC20d

std::string ST::SUSYObjDef_xAOD::m_commonPRWFileMC20d
protected

Definition at line 599 of file SUSYObjDef_xAOD.h.

◆ m_commonPRWFileMC20e

std::string ST::SUSYObjDef_xAOD::m_commonPRWFileMC20e
protected

Definition at line 600 of file SUSYObjDef_xAOD.h.

◆ m_commonPRWFileMC21a

std::string ST::SUSYObjDef_xAOD::m_commonPRWFileMC21a
protected

Definition at line 601 of file SUSYObjDef_xAOD.h.

◆ m_commonPRWFileMC23a

std::string ST::SUSYObjDef_xAOD::m_commonPRWFileMC23a
protected

Definition at line 602 of file SUSYObjDef_xAOD.h.

◆ m_commonPRWFileMC23c

std::string ST::SUSYObjDef_xAOD::m_commonPRWFileMC23c
protected

Definition at line 603 of file SUSYObjDef_xAOD.h.

◆ m_commonPRWFileMC23d

std::string ST::SUSYObjDef_xAOD::m_commonPRWFileMC23d
protected

Definition at line 604 of file SUSYObjDef_xAOD.h.

◆ m_commonPRWFileMC23e

std::string ST::SUSYObjDef_xAOD::m_commonPRWFileMC23e
protected

Definition at line 605 of file SUSYObjDef_xAOD.h.

◆ m_conf_to_prop

std::map<std::string, std::string> ST::SUSYObjDef_xAOD::m_conf_to_prop
private

Definition at line 436 of file SUSYObjDef_xAOD.h.

◆ m_configFile

std::string ST::SUSYObjDef_xAOD::m_configFile
protected

Definition at line 516 of file SUSYObjDef_xAOD.h.

◆ m_currentSyst

CP::SystematicSet ST::SUSYObjDef_xAOD::m_currentSyst
protected

Definition at line 808 of file SUSYObjDef_xAOD.h.

◆ m_dataSource

int ST::SUSYObjDef_xAOD::m_dataSource
protected

Definition at line 513 of file SUSYObjDef_xAOD.h.

◆ m_deadHVTool

asg::AnaToolHandle<IAsgDeadHVCellRemovalTool> ST::SUSYObjDef_xAOD::m_deadHVTool
protected

Definition at line 891 of file SUSYObjDef_xAOD.h.

◆ m_debug

bool ST::SUSYObjDef_xAOD::m_debug
protected

Definition at line 533 of file SUSYObjDef_xAOD.h.

◆ m_defaultJets

std::string ST::SUSYObjDef_xAOD::m_defaultJets
protected

Definition at line 802 of file SUSYObjDef_xAOD.h.

◆ m_defaultSyst

CP::SystematicSet ST::SUSYObjDef_xAOD::m_defaultSyst = CP::SystematicSet()
protected

Definition at line 807 of file SUSYObjDef_xAOD.h.

◆ m_defaultTrackJets

std::string ST::SUSYObjDef_xAOD::m_defaultTrackJets
protected

Definition at line 803 of file SUSYObjDef_xAOD.h.

◆ m_defaultTruthJets

std::string ST::SUSYObjDef_xAOD::m_defaultTruthJets
protected

Definition at line 805 of file SUSYObjDef_xAOD.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_doElIsoSignal

bool ST::SUSYObjDef_xAOD::m_doElIsoSignal
protected

Definition at line 785 of file SUSYObjDef_xAOD.h.

◆ m_doFwdJVT

bool ST::SUSYObjDef_xAOD::m_doFwdJVT
protected

Definition at line 740 of file SUSYObjDef_xAOD.h.

◆ m_doIsoSignal

bool ST::SUSYObjDef_xAOD::m_doIsoSignal
protected

Definition at line 784 of file SUSYObjDef_xAOD.h.

◆ m_doModifiedEleId

bool ST::SUSYObjDef_xAOD::m_doModifiedEleId
protected

Definition at line 521 of file SUSYObjDef_xAOD.h.

◆ m_doMuIsoSignal

bool ST::SUSYObjDef_xAOD::m_doMuIsoSignal
protected

Definition at line 787 of file SUSYObjDef_xAOD.h.

◆ m_doPhiReso

bool ST::SUSYObjDef_xAOD::m_doPhiReso
protected

Definition at line 586 of file SUSYObjDef_xAOD.h.

◆ m_doPhIsoSignal

bool ST::SUSYObjDef_xAOD::m_doPhIsoSignal
protected

Definition at line 786 of file SUSYObjDef_xAOD.h.

◆ m_doTTVAsf

bool ST::SUSYObjDef_xAOD::m_doTTVAsf
protected

Definition at line 520 of file SUSYObjDef_xAOD.h.

◆ m_EG_corrFNList

std::string ST::SUSYObjDef_xAOD::m_EG_corrFNList
protected

Definition at line 811 of file SUSYObjDef_xAOD.h.

◆ m_EG_corrModel

std::string ST::SUSYObjDef_xAOD::m_EG_corrModel
protected

Definition at line 810 of file SUSYObjDef_xAOD.h.

◆ m_egammaAmbiguityTool

asg::AnaToolHandle<IEGammaAmbiguityTool> ST::SUSYObjDef_xAOD::m_egammaAmbiguityTool
protected

Definition at line 901 of file SUSYObjDef_xAOD.h.

◆ m_egammaCalibTool

asg::AnaToolHandle<CP::IEgammaCalibrationAndSmearingTool> ST::SUSYObjDef_xAOD::m_egammaCalibTool
protected

Combined electron collection.


Definition at line 886 of file SUSYObjDef_xAOD.h.

◆ m_EigenvectorReductionB

std::string ST::SUSYObjDef_xAOD::m_EigenvectorReductionB
protected

Definition at line 672 of file SUSYObjDef_xAOD.h.

◆ m_EigenvectorReductionC

std::string ST::SUSYObjDef_xAOD::m_EigenvectorReductionC
protected

Definition at line 673 of file SUSYObjDef_xAOD.h.

◆ m_EigenvectorReductionLight

std::string ST::SUSYObjDef_xAOD::m_EigenvectorReductionLight
protected

Definition at line 674 of file SUSYObjDef_xAOD.h.

◆ m_el_id_support

std::vector<std::string> ST::SUSYObjDef_xAOD::m_el_id_support
protected

Definition at line 621 of file SUSYObjDef_xAOD.h.

◆ m_el_iso_fallback

std::map<std::string, std::string> ST::SUSYObjDef_xAOD::m_el_iso_fallback
protected

Definition at line 629 of file SUSYObjDef_xAOD.h.

◆ m_el_iso_support

std::vector<std::string> ST::SUSYObjDef_xAOD::m_el_iso_support
protected

Definition at line 625 of file SUSYObjDef_xAOD.h.

◆ m_eleAllowRun3TrigSFFallback

bool ST::SUSYObjDef_xAOD::m_eleAllowRun3TrigSFFallback
protected

Definition at line 692 of file SUSYObjDef_xAOD.h.

◆ m_eleBaselineCrackVeto

bool ST::SUSYObjDef_xAOD::m_eleBaselineCrackVeto
protected

Definition at line 682 of file SUSYObjDef_xAOD.h.

◆ m_elebaselined0sig

double ST::SUSYObjDef_xAOD::m_elebaselined0sig
protected

Definition at line 688 of file SUSYObjDef_xAOD.h.

◆ m_eleBaselineEta

double ST::SUSYObjDef_xAOD::m_eleBaselineEta
protected

Definition at line 681 of file SUSYObjDef_xAOD.h.

◆ m_eleBaselineIso_WP

std::string ST::SUSYObjDef_xAOD::m_eleBaselineIso_WP
protected

Definition at line 641 of file SUSYObjDef_xAOD.h.

◆ m_eleBaselinePt

double ST::SUSYObjDef_xAOD::m_eleBaselinePt
protected

Definition at line 680 of file SUSYObjDef_xAOD.h.

◆ m_elebaselinez0

double ST::SUSYObjDef_xAOD::m_elebaselinez0
protected

Definition at line 689 of file SUSYObjDef_xAOD.h.

◆ m_elecChargeEffCorrTool

asg::AnaToolHandle<IAsgElectronEfficiencyCorrectionTool> ST::SUSYObjDef_xAOD::m_elecChargeEffCorrTool
protected

Definition at line 903 of file SUSYObjDef_xAOD.h.

◆ m_elecChargeIDSelectorTool

asg::AnaToolHandle<IAsgElectronLikelihoodTool> ST::SUSYObjDef_xAOD::m_elecChargeIDSelectorTool
protected

Definition at line 902 of file SUSYObjDef_xAOD.h.

◆ m_elecEfficiencySFTool_chf

asg::AnaToolHandle<IAsgElectronEfficiencyCorrectionTool> ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_chf
protected

Definition at line 876 of file SUSYObjDef_xAOD.h.

◆ m_elecEfficiencySFTool_id

asg::AnaToolHandle<IAsgElectronEfficiencyCorrectionTool> ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_id
protected

Definition at line 871 of file SUSYObjDef_xAOD.h.

◆ m_elecEfficiencySFTool_iso

asg::AnaToolHandle<IAsgElectronEfficiencyCorrectionTool> ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_iso
protected

Definition at line 874 of file SUSYObjDef_xAOD.h.

◆ m_elecEfficiencySFTool_isoHighPt

asg::AnaToolHandle<IAsgElectronEfficiencyCorrectionTool> ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_isoHighPt
protected

Definition at line 875 of file SUSYObjDef_xAOD.h.

◆ m_elecEfficiencySFTool_reco

asg::AnaToolHandle<IAsgElectronEfficiencyCorrectionTool> ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_reco
protected

Combined muon collection.


Definition at line 870 of file SUSYObjDef_xAOD.h.

◆ m_elecEfficiencySFTool_trig_mixLep

std::vector<asg::AnaToolHandle<IAsgElectronEfficiencyCorrectionTool> > ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_trig_mixLep
protected

Definition at line 878 of file SUSYObjDef_xAOD.h.

◆ m_elecEfficiencySFTool_trig_singleLep

asg::AnaToolHandle<IAsgElectronEfficiencyCorrectionTool> ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_trig_singleLep
protected

Definition at line 872 of file SUSYObjDef_xAOD.h.

◆ m_elecEfficiencySFTool_trigEff_mixLep

std::vector<asg::AnaToolHandle<IAsgElectronEfficiencyCorrectionTool> > ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_trigEff_mixLep
protected

Definition at line 879 of file SUSYObjDef_xAOD.h.

◆ m_elecEfficiencySFTool_trigEff_singleLep

asg::AnaToolHandle<IAsgElectronEfficiencyCorrectionTool> ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_trigEff_singleLep
protected

Definition at line 873 of file SUSYObjDef_xAOD.h.

◆ m_eleChID_signal

bool ST::SUSYObjDef_xAOD::m_eleChID_signal
protected

Definition at line 656 of file SUSYObjDef_xAOD.h.

◆ m_eleChID_WP

std::string ST::SUSYObjDef_xAOD::m_eleChID_WP
protected

Definition at line 652 of file SUSYObjDef_xAOD.h.

◆ m_eleChIso

bool ST::SUSYObjDef_xAOD::m_eleChIso
protected

Definition at line 655 of file SUSYObjDef_xAOD.h.

◆ m_elecLRTORTool

asg::AnaToolHandle<CP::IElectronLRTOverlapRemovalTool> ST::SUSYObjDef_xAOD::m_elecLRTORTool
protected

Definition at line 882 of file SUSYObjDef_xAOD.h.

◆ m_eleConfig

std::string ST::SUSYObjDef_xAOD::m_eleConfig
protected

Definition at line 639 of file SUSYObjDef_xAOD.h.

◆ m_eleConfigBaseline

std::string ST::SUSYObjDef_xAOD::m_eleConfigBaseline
protected

Definition at line 640 of file SUSYObjDef_xAOD.h.

◆ m_eleCrackVeto

bool ST::SUSYObjDef_xAOD::m_eleCrackVeto
protected

Definition at line 685 of file SUSYObjDef_xAOD.h.

◆ m_elecSelLikelihood

asg::AnaToolHandle<IAsgElectronLikelihoodTool> ST::SUSYObjDef_xAOD::m_elecSelLikelihood
protected

Definition at line 887 of file SUSYObjDef_xAOD.h.

◆ m_elecSelLikelihoodBaseline

asg::AnaToolHandle<IAsgElectronLikelihoodTool> ST::SUSYObjDef_xAOD::m_elecSelLikelihoodBaseline
protected

Definition at line 888 of file SUSYObjDef_xAOD.h.

◆ m_elecTrigEffTools

ToolHandleArray<IAsgElectronEfficiencyCorrectionTool> ST::SUSYObjDef_xAOD::m_elecTrigEffTools
protected

Definition at line 881 of file SUSYObjDef_xAOD.h.

◆ m_elecTrigSFTools

ToolHandleArray<IAsgElectronEfficiencyCorrectionTool> ST::SUSYObjDef_xAOD::m_elecTrigSFTools
protected

Definition at line 880 of file SUSYObjDef_xAOD.h.

◆ m_electronTriggerSFStringSingle

std::string ST::SUSYObjDef_xAOD::m_electronTriggerSFStringSingle
protected

Definition at line 633 of file SUSYObjDef_xAOD.h.

◆ m_eled0sig

double ST::SUSYObjDef_xAOD::m_eled0sig
protected

Definition at line 686 of file SUSYObjDef_xAOD.h.

◆ m_eleEffMapFilePath

std::string ST::SUSYObjDef_xAOD::m_eleEffMapFilePath
protected

Definition at line 690 of file SUSYObjDef_xAOD.h.

◆ m_eleEffMapFilePathRun2

std::string ST::SUSYObjDef_xAOD::m_eleEffMapFilePathRun2
protected

Definition at line 691 of file SUSYObjDef_xAOD.h.

◆ m_eleEta

double ST::SUSYObjDef_xAOD::m_eleEta
protected

Definition at line 684 of file SUSYObjDef_xAOD.h.

◆ m_EleFatJetDR

double ST::SUSYObjDef_xAOD::m_EleFatJetDR
protected

Definition at line 781 of file SUSYObjDef_xAOD.h.

◆ m_eleForceFullSimCalib

bool ST::SUSYObjDef_xAOD::m_eleForceFullSimCalib
protected

Definition at line 693 of file SUSYObjDef_xAOD.h.

◆ m_eleId

std::string ST::SUSYObjDef_xAOD::m_eleId
protected

Definition at line 637 of file SUSYObjDef_xAOD.h.

◆ m_eleIdBaseline

std::string ST::SUSYObjDef_xAOD::m_eleIdBaseline
protected

Definition at line 638 of file SUSYObjDef_xAOD.h.

◆ m_eleIdBaselineDFName

std::string ST::SUSYObjDef_xAOD::m_eleIdBaselineDFName
protected

Definition at line 975 of file SUSYObjDef_xAOD.h.

◆ m_eleIdDFName

std::string ST::SUSYObjDef_xAOD::m_eleIdDFName
protected

Definition at line 976 of file SUSYObjDef_xAOD.h.

◆ m_eleIdExpert

bool ST::SUSYObjDef_xAOD::m_eleIdExpert
protected

Definition at line 642 of file SUSYObjDef_xAOD.h.

◆ m_eleIso_WP

std::string ST::SUSYObjDef_xAOD::m_eleIso_WP
protected

Definition at line 649 of file SUSYObjDef_xAOD.h.

◆ m_eleIsoHighPt_WP

std::string ST::SUSYObjDef_xAOD::m_eleIsoHighPt_WP
protected

Definition at line 650 of file SUSYObjDef_xAOD.h.

◆ m_eleIsoHighPtThresh

double ST::SUSYObjDef_xAOD::m_eleIsoHighPtThresh
protected

Definition at line 651 of file SUSYObjDef_xAOD.h.

◆ m_eleLRT

bool ST::SUSYObjDef_xAOD::m_eleLRT
protected

Definition at line 653 of file SUSYObjDef_xAOD.h.

◆ m_eleLRT_strat

int ST::SUSYObjDef_xAOD::m_eleLRT_strat
protected

Definition at line 654 of file SUSYObjDef_xAOD.h.

◆ m_elePt

double ST::SUSYObjDef_xAOD::m_elePt
protected

Definition at line 683 of file SUSYObjDef_xAOD.h.

◆ m_eleTerm

std::string ST::SUSYObjDef_xAOD::m_eleTerm
protected

Definition at line 561 of file SUSYObjDef_xAOD.h.

◆ m_elez0

double ST::SUSYObjDef_xAOD::m_elez0
protected

Definition at line 687 of file SUSYObjDef_xAOD.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_fatJets

std::string ST::SUSYObjDef_xAOD::m_fatJets
protected

Definition at line 804 of file SUSYObjDef_xAOD.h.

◆ m_fatJetUncConfig

std::string ST::SUSYObjDef_xAOD::m_fatJetUncConfig
protected

Definition at line 539 of file SUSYObjDef_xAOD.h.

◆ m_fatjetUncertaintiesTool

asg::AnaToolHandle<ICPJetUncertaintiesTool> ST::SUSYObjDef_xAOD::m_fatjetUncertaintiesTool
protected

Definition at line 823 of file SUSYObjDef_xAOD.h.

◆ m_fatJetUncVars

std::string ST::SUSYObjDef_xAOD::m_fatJetUncVars
protected

Definition at line 540 of file SUSYObjDef_xAOD.h.

◆ m_fJvtConfigRun2

std::string ST::SUSYObjDef_xAOD::m_fJvtConfigRun2
protected

Definition at line 744 of file SUSYObjDef_xAOD.h.

◆ m_fJvtConfigRun3

std::string ST::SUSYObjDef_xAOD::m_fJvtConfigRun3
protected

Definition at line 745 of file SUSYObjDef_xAOD.h.

◆ m_fJvtEtaMin

double ST::SUSYObjDef_xAOD::m_fJvtEtaMin
protected

Definition at line 743 of file SUSYObjDef_xAOD.h.

◆ m_fJvtPtMax

double ST::SUSYObjDef_xAOD::m_fJvtPtMax
protected

Definition at line 742 of file SUSYObjDef_xAOD.h.

◆ m_fJvtWP

std::string ST::SUSYObjDef_xAOD::m_fJvtWP
protected

Definition at line 741 of file SUSYObjDef_xAOD.h.

◆ m_force_noElId

bool ST::SUSYObjDef_xAOD::m_force_noElId
protected

Definition at line 518 of file SUSYObjDef_xAOD.h.

◆ m_force_noMuId

bool ST::SUSYObjDef_xAOD::m_force_noMuId
protected

Definition at line 519 of file SUSYObjDef_xAOD.h.

◆ m_gammaTerm

std::string ST::SUSYObjDef_xAOD::m_gammaTerm
protected

Definition at line 562 of file SUSYObjDef_xAOD.h.

◆ m_GSFLRTCollectionName

SG::ReadHandleKey<xAOD::TrackParticleContainer> ST::SUSYObjDef_xAOD::m_GSFLRTCollectionName {this, "GSFLRTCollectionName", "LRTGSFTrackParticles", "GSF LRT collection name"}
private

Definition at line 478 of file SUSYObjDef_xAOD.h.

◆ m_inputMetaStore

MetaStore_t asg::AsgMetadataTool::m_inputMetaStore
privateinherited

Object accessing the input metadata store.

Definition at line 119 of file AsgMetadataTool.h.

◆ m_inputMETCore

std::string ST::SUSYObjDef_xAOD::m_inputMETCore
protected

Definition at line 568 of file SUSYObjDef_xAOD.h.

◆ m_inputMETMap

std::string ST::SUSYObjDef_xAOD::m_inputMETMap
protected

Definition at line 567 of file SUSYObjDef_xAOD.h.

◆ m_inputMETRef

std::string ST::SUSYObjDef_xAOD::m_inputMETRef
protected

Definition at line 569 of file SUSYObjDef_xAOD.h.

◆ m_inputMETSuffix

std::string ST::SUSYObjDef_xAOD::m_inputMETSuffix
protected

Definition at line 566 of file SUSYObjDef_xAOD.h.

◆ m_isoBaselineTool

asg::AnaToolHandle<CP::IIsolationSelectionTool> ST::SUSYObjDef_xAOD::m_isoBaselineTool
protected

Definition at line 961 of file SUSYObjDef_xAOD.h.

◆ m_IsoCloseByORpassLabel

std::string ST::SUSYObjDef_xAOD::m_IsoCloseByORpassLabel
protected

Definition at line 790 of file SUSYObjDef_xAOD.h.

◆ m_isoCloseByTool

asg::AnaToolHandle<CP::IIsolationCloseByCorrectionTool> ST::SUSYObjDef_xAOD::m_isoCloseByTool
protected

Definition at line 963 of file SUSYObjDef_xAOD.h.

◆ m_isoCorrTool

asg::AnaToolHandle<CP::IIsolationCorrectionTool> ST::SUSYObjDef_xAOD::m_isoCorrTool
protected

Definition at line 958 of file SUSYObjDef_xAOD.h.

◆ m_isoHighPtTool

asg::AnaToolHandle<CP::IIsolationSelectionTool> ST::SUSYObjDef_xAOD::m_isoHighPtTool
protected

Definition at line 962 of file SUSYObjDef_xAOD.h.

◆ m_isoTool

asg::AnaToolHandle<CP::IIsolationSelectionTool> ST::SUSYObjDef_xAOD::m_isoTool
protected

Definition at line 959 of file SUSYObjDef_xAOD.h.

◆ m_isPHYSLITE

bool ST::SUSYObjDef_xAOD::m_isPHYSLITE
protected

Definition at line 796 of file SUSYObjDef_xAOD.h.

◆ m_isRun3

bool ST::SUSYObjDef_xAOD::m_isRun3
protected

Definition at line 795 of file SUSYObjDef_xAOD.h.

◆ m_jesCalibArea

std::string ST::SUSYObjDef_xAOD::m_jesCalibArea
protected

Definition at line 854 of file SUSYObjDef_xAOD.h.

◆ m_jesCalibSeq

std::string ST::SUSYObjDef_xAOD::m_jesCalibSeq
protected

Definition at line 851 of file SUSYObjDef_xAOD.h.

◆ m_jesCalibSeqFat

std::string ST::SUSYObjDef_xAOD::m_jesCalibSeqFat
protected

Definition at line 853 of file SUSYObjDef_xAOD.h.

◆ m_jesCalibSeqJMS

std::string ST::SUSYObjDef_xAOD::m_jesCalibSeqJMS
protected

Definition at line 852 of file SUSYObjDef_xAOD.h.

◆ m_jesConfig

std::string ST::SUSYObjDef_xAOD::m_jesConfig
protected

Definition at line 845 of file SUSYObjDef_xAOD.h.

◆ m_jesConfigAFII

std::string ST::SUSYObjDef_xAOD::m_jesConfigAFII
protected

Definition at line 848 of file SUSYObjDef_xAOD.h.

◆ m_jesConfigFat

std::string ST::SUSYObjDef_xAOD::m_jesConfigFat
protected

Definition at line 849 of file SUSYObjDef_xAOD.h.

◆ m_jesConfigFatData

std::string ST::SUSYObjDef_xAOD::m_jesConfigFatData
protected

Definition at line 850 of file SUSYObjDef_xAOD.h.

◆ m_jesConfigJMS

std::string ST::SUSYObjDef_xAOD::m_jesConfigJMS
protected

Definition at line 846 of file SUSYObjDef_xAOD.h.

◆ m_jesConfigJMSData

std::string ST::SUSYObjDef_xAOD::m_jesConfigJMSData
protected

Definition at line 847 of file SUSYObjDef_xAOD.h.

◆ m_jetCalibTool

asg::AnaToolHandle<IJetCalibrationTool> ST::SUSYObjDef_xAOD::m_jetCalibTool
protected

Definition at line 819 of file SUSYObjDef_xAOD.h.

◆ m_jetCleanDFName

std::string ST::SUSYObjDef_xAOD::m_jetCleanDFName
protected

Definition at line 979 of file SUSYObjDef_xAOD.h.

◆ m_jetCleaningTool

asg::AnaToolHandle<IJetSelector> ST::SUSYObjDef_xAOD::m_jetCleaningTool
protected

Definition at line 824 of file SUSYObjDef_xAOD.h.

◆ m_jetEta

double ST::SUSYObjDef_xAOD::m_jetEta
protected

Definition at line 730 of file SUSYObjDef_xAOD.h.

◆ m_jetFatCalibTool

asg::AnaToolHandle<IJetCalibrationTool> ST::SUSYObjDef_xAOD::m_jetFatCalibTool
protected

Definition at line 820 of file SUSYObjDef_xAOD.h.

◆ m_JetFatJetDR

double ST::SUSYObjDef_xAOD::m_JetFatJetDR
protected

Definition at line 782 of file SUSYObjDef_xAOD.h.

◆ m_jetfJvtEfficiencyTool

asg::AnaToolHandle<CP::IJvtEfficiencyTool> ST::SUSYObjDef_xAOD::m_jetfJvtEfficiencyTool
protected

Definition at line 832 of file SUSYObjDef_xAOD.h.

◆ m_jetfJvtSelectionTool

asg::AnaToolHandle<IAsgSelectionTool> ST::SUSYObjDef_xAOD::m_jetfJvtSelectionTool
protected

Definition at line 831 of file SUSYObjDef_xAOD.h.

◆ m_jetInputType

int ST::SUSYObjDef_xAOD::m_jetInputType
protected

Definition at line 514 of file SUSYObjDef_xAOD.h.

◆ m_jetJvt

double ST::SUSYObjDef_xAOD::m_jetJvt
protected

Definition at line 731 of file SUSYObjDef_xAOD.h.

◆ m_jetJvtMomentTool

asg::AnaToolHandle<JetVertexTaggerTool> ST::SUSYObjDef_xAOD::m_jetJvtMomentTool
protected

Definition at line 827 of file SUSYObjDef_xAOD.h.

◆ m_jetNNJvtEfficiencyTool

asg::AnaToolHandle<CP::IJvtEfficiencyTool> ST::SUSYObjDef_xAOD::m_jetNNJvtEfficiencyTool
protected

Definition at line 830 of file SUSYObjDef_xAOD.h.

◆ m_jetNNJvtMomentTool

asg::AnaToolHandle<JetPileupTag::JetVertexNNTagger> ST::SUSYObjDef_xAOD::m_jetNNJvtMomentTool
protected

Definition at line 828 of file SUSYObjDef_xAOD.h.

◆ m_jetNNJvtSelectionTool

asg::AnaToolHandle<IAsgSelectionTool> ST::SUSYObjDef_xAOD::m_jetNNJvtSelectionTool
protected

Definition at line 829 of file SUSYObjDef_xAOD.h.

◆ m_jetPileupLabelingTool

asg::AnaToolHandle<JetPileupLabelingTool> ST::SUSYObjDef_xAOD::m_jetPileupLabelingTool
protected

Definition at line 826 of file SUSYObjDef_xAOD.h.

◆ m_jetPt

double ST::SUSYObjDef_xAOD::m_jetPt
protected

Definition at line 729 of file SUSYObjDef_xAOD.h.

◆ m_jetTerm

std::string ST::SUSYObjDef_xAOD::m_jetTerm
protected

Definition at line 564 of file SUSYObjDef_xAOD.h.

◆ m_jetTruthLabelingTool

asg::AnaToolHandle<JetTruthLabelingTool> ST::SUSYObjDef_xAOD::m_jetTruthLabelingTool
protected

Definition at line 837 of file SUSYObjDef_xAOD.h.

◆ m_JetTruthLabelName

std::string ST::SUSYObjDef_xAOD::m_JetTruthLabelName
protected

Definition at line 556 of file SUSYObjDef_xAOD.h.

◆ m_jetUncertaintiesAnalysisFile

std::string ST::SUSYObjDef_xAOD::m_jetUncertaintiesAnalysisFile
protected

Definition at line 526 of file SUSYObjDef_xAOD.h.

◆ m_jetUncertaintiesCalibArea

std::string ST::SUSYObjDef_xAOD::m_jetUncertaintiesCalibArea
protected

Definition at line 527 of file SUSYObjDef_xAOD.h.

◆ m_jetUncertaintiesConfig

std::string ST::SUSYObjDef_xAOD::m_jetUncertaintiesConfig
protected

Prefix for trigger matchiing container name.

Definition at line 525 of file SUSYObjDef_xAOD.h.

◆ m_jetUncertaintiesMCType

std::string ST::SUSYObjDef_xAOD::m_jetUncertaintiesMCType
protected

Definition at line 528 of file SUSYObjDef_xAOD.h.

◆ m_jetUncertaintiesPDsmearing

bool ST::SUSYObjDef_xAOD::m_jetUncertaintiesPDsmearing
protected

Definition at line 529 of file SUSYObjDef_xAOD.h.

◆ m_jetUncertaintiesPDSmearTool

asg::AnaToolHandle<ICPJetUncertaintiesTool> ST::SUSYObjDef_xAOD::m_jetUncertaintiesPDSmearTool
protected

Definition at line 822 of file SUSYObjDef_xAOD.h.

◆ m_jetUncertaintiesTool

asg::AnaToolHandle<ICPJetUncertaintiesTool> ST::SUSYObjDef_xAOD::m_jetUncertaintiesTool
protected

Definition at line 821 of file SUSYObjDef_xAOD.h.

◆ m_JMScalib

bool ST::SUSYObjDef_xAOD::m_JMScalib
protected

Definition at line 747 of file SUSYObjDef_xAOD.h.

◆ m_JvtConfigRun2

std::string ST::SUSYObjDef_xAOD::m_JvtConfigRun2
protected

Definition at line 734 of file SUSYObjDef_xAOD.h.

◆ m_JvtConfigRun3

std::string ST::SUSYObjDef_xAOD::m_JvtConfigRun3
protected

Definition at line 735 of file SUSYObjDef_xAOD.h.

◆ m_JvtPtMax

double ST::SUSYObjDef_xAOD::m_JvtPtMax
protected

Definition at line 733 of file SUSYObjDef_xAOD.h.

◆ m_JvtWP

std::string ST::SUSYObjDef_xAOD::m_JvtWP
protected

Definition at line 732 of file SUSYObjDef_xAOD.h.

◆ m_label_truthKey

SG::ReadDecorHandleKey<xAOD::JetContainer> ST::SUSYObjDef_xAOD::m_label_truthKey
protected

Definition at line 842 of file SUSYObjDef_xAOD.h.

◆ m_legsPerTool

std::map<std::string,std::string> ST::SUSYObjDef_xAOD::m_legsPerTool
protected

Definition at line 816 of file SUSYObjDef_xAOD.h.

◆ m_legsPerTool_ph

std::map<std::string,std::string> ST::SUSYObjDef_xAOD::m_legsPerTool_ph
protected

Definition at line 817 of file SUSYObjDef_xAOD.h.

◆ m_LRTCollectionName

SG::ReadHandleKey<xAOD::TrackParticleContainer> ST::SUSYObjDef_xAOD::m_LRTCollectionName {this, "LRTCollectionName", "InDetLargeD0TrackParticles", "LRT collection name"}
private

Definition at line 477 of file SUSYObjDef_xAOD.h.

◆ m_LRTuncTool

asg::AnaToolHandle<InDet::IInclusiveTrackFilterTool> ST::SUSYObjDef_xAOD::m_LRTuncTool
protected

Definition at line 967 of file SUSYObjDef_xAOD.h.

◆ m_mcCampaign

std::string ST::SUSYObjDef_xAOD::m_mcCampaign
protected

Definition at line 594 of file SUSYObjDef_xAOD.h.

◆ m_mcChannel

int ST::SUSYObjDef_xAOD::m_mcChannel
protected

Definition at line 595 of file SUSYObjDef_xAOD.h.

◆ m_metDoMuonEloss

bool ST::SUSYObjDef_xAOD::m_metDoMuonEloss
protected

Definition at line 575 of file SUSYObjDef_xAOD.h.

◆ m_metDoRemoveMuonJets

bool ST::SUSYObjDef_xAOD::m_metDoRemoveMuonJets
protected

Definition at line 573 of file SUSYObjDef_xAOD.h.

◆ m_metDoSetMuonJetEMScale

bool ST::SUSYObjDef_xAOD::m_metDoSetMuonJetEMScale
protected

Definition at line 572 of file SUSYObjDef_xAOD.h.

◆ m_metGreedyPhotons

bool ST::SUSYObjDef_xAOD::m_metGreedyPhotons
protected

Definition at line 576 of file SUSYObjDef_xAOD.h.

◆ m_metJetSelection

std::string ST::SUSYObjDef_xAOD::m_metJetSelection
protected

Definition at line 798 of file SUSYObjDef_xAOD.h.

◆ m_metMaker

asg::AnaToolHandle<IMETMaker> ST::SUSYObjDef_xAOD::m_metMaker
protected

Definition at line 918 of file SUSYObjDef_xAOD.h.

◆ m_metRemoveOverlappingCaloTaggedMuons

bool ST::SUSYObjDef_xAOD::m_metRemoveOverlappingCaloTaggedMuons
protected

Definition at line 571 of file SUSYObjDef_xAOD.h.

◆ m_metSignif

asg::AnaToolHandle<IMETSignificance> ST::SUSYObjDef_xAOD::m_metSignif
protected

Definition at line 920 of file SUSYObjDef_xAOD.h.

◆ m_metsysConfigPrefix

std::string ST::SUSYObjDef_xAOD::m_metsysConfigPrefix
protected

Definition at line 578 of file SUSYObjDef_xAOD.h.

◆ m_metSystTool

asg::AnaToolHandle<IMETSystematicsTool> ST::SUSYObjDef_xAOD::m_metSystTool
protected

Definition at line 919 of file SUSYObjDef_xAOD.h.

◆ m_metUseGhostMuons

bool ST::SUSYObjDef_xAOD::m_metUseGhostMuons
protected

Definition at line 574 of file SUSYObjDef_xAOD.h.

◆ m_metVeryGreedyPhotons

bool ST::SUSYObjDef_xAOD::m_metVeryGreedyPhotons
protected

Definition at line 577 of file SUSYObjDef_xAOD.h.

◆ m_mu_id_support

int ST::SUSYObjDef_xAOD::m_mu_id_support
protected

Definition at line 623 of file SUSYObjDef_xAOD.h.

◆ m_mu_iso_fallback

std::map<std::string, std::string> ST::SUSYObjDef_xAOD::m_mu_iso_fallback
protected

Definition at line 630 of file SUSYObjDef_xAOD.h.

◆ m_mu_iso_support

std::vector<std::string> ST::SUSYObjDef_xAOD::m_mu_iso_support
protected

Definition at line 626 of file SUSYObjDef_xAOD.h.

◆ m_mubaselined0sig

double ST::SUSYObjDef_xAOD::m_mubaselined0sig
protected

Definition at line 702 of file SUSYObjDef_xAOD.h.

◆ m_muBaselineEta

double ST::SUSYObjDef_xAOD::m_muBaselineEta
protected

Definition at line 697 of file SUSYObjDef_xAOD.h.

◆ m_muBaselineIso_WP

std::string ST::SUSYObjDef_xAOD::m_muBaselineIso_WP
protected

Definition at line 661 of file SUSYObjDef_xAOD.h.

◆ m_muBaselinePt

double ST::SUSYObjDef_xAOD::m_muBaselinePt
protected

Definition at line 696 of file SUSYObjDef_xAOD.h.

◆ m_mubaselinez0

double ST::SUSYObjDef_xAOD::m_mubaselinez0
protected

Definition at line 703 of file SUSYObjDef_xAOD.h.

◆ m_muCalibrationMode

int ST::SUSYObjDef_xAOD::m_muCalibrationMode
protected

Definition at line 708 of file SUSYObjDef_xAOD.h.

◆ m_muCosmicd0

double ST::SUSYObjDef_xAOD::m_muCosmicd0
protected

Definition at line 706 of file SUSYObjDef_xAOD.h.

◆ m_muCosmicz0

double ST::SUSYObjDef_xAOD::m_muCosmicz0
protected

Definition at line 705 of file SUSYObjDef_xAOD.h.

◆ m_mud0sig

double ST::SUSYObjDef_xAOD::m_mud0sig
protected

Definition at line 700 of file SUSYObjDef_xAOD.h.

◆ m_muEffCorrForce1D

bool ST::SUSYObjDef_xAOD::m_muEffCorrForce1D
protected

Definition at line 666 of file SUSYObjDef_xAOD.h.

◆ m_muEta

double ST::SUSYObjDef_xAOD::m_muEta
protected

Definition at line 699 of file SUSYObjDef_xAOD.h.

◆ m_muHighPtExtraSmear

bool ST::SUSYObjDef_xAOD::m_muHighPtExtraSmear
protected

Definition at line 665 of file SUSYObjDef_xAOD.h.

◆ m_muId

int ST::SUSYObjDef_xAOD::m_muId
protected

Definition at line 643 of file SUSYObjDef_xAOD.h.

◆ m_muIdBaseline

int ST::SUSYObjDef_xAOD::m_muIdBaseline
protected

Definition at line 644 of file SUSYObjDef_xAOD.h.

◆ m_muIso_WP

std::string ST::SUSYObjDef_xAOD::m_muIso_WP
protected

Definition at line 662 of file SUSYObjDef_xAOD.h.

◆ m_muIsoHighPt_WP

std::string ST::SUSYObjDef_xAOD::m_muIsoHighPt_WP
protected

Definition at line 663 of file SUSYObjDef_xAOD.h.

◆ m_muIsoHighPtThresh

double ST::SUSYObjDef_xAOD::m_muIsoHighPtThresh
protected

Definition at line 664 of file SUSYObjDef_xAOD.h.

◆ m_muLRT

bool ST::SUSYObjDef_xAOD::m_muLRT
protected

Definition at line 709 of file SUSYObjDef_xAOD.h.

◆ m_muonCalibTool

asg::AnaToolHandle<CP::IMuonCalibrationAndSmearingTool> ST::SUSYObjDef_xAOD::m_muonCalibTool
protected

Definition at line 859 of file SUSYObjDef_xAOD.h.

◆ m_muonEfficiencyBMHighPtSFTool

asg::AnaToolHandle<CP::IMuonEfficiencyScaleFactors> ST::SUSYObjDef_xAOD::m_muonEfficiencyBMHighPtSFTool
protected

Definition at line 861 of file SUSYObjDef_xAOD.h.

◆ m_muonEfficiencySFTool

asg::AnaToolHandle<CP::IMuonEfficiencyScaleFactors> ST::SUSYObjDef_xAOD::m_muonEfficiencySFTool
protected

Definition at line 860 of file SUSYObjDef_xAOD.h.

◆ m_muonHighPtIsolationSFTool

asg::AnaToolHandle<CP::IMuonEfficiencyScaleFactors> ST::SUSYObjDef_xAOD::m_muonHighPtIsolationSFTool
protected

Definition at line 864 of file SUSYObjDef_xAOD.h.

◆ m_muonIsolationSFTool

asg::AnaToolHandle<CP::IMuonEfficiencyScaleFactors> ST::SUSYObjDef_xAOD::m_muonIsolationSFTool
protected

Definition at line 863 of file SUSYObjDef_xAOD.h.

◆ m_muonLRTORTool

asg::AnaToolHandle<CP::IMuonLRTOverlapRemovalTool> ST::SUSYObjDef_xAOD::m_muonLRTORTool
protected

Definition at line 867 of file SUSYObjDef_xAOD.h.

◆ m_muonSelectionHighPtTool

asg::AnaToolHandle<CP::IMuonSelectionTool> ST::SUSYObjDef_xAOD::m_muonSelectionHighPtTool
protected

Definition at line 857 of file SUSYObjDef_xAOD.h.

◆ m_muonSelectionTool

asg::AnaToolHandle<CP::IMuonSelectionTool> ST::SUSYObjDef_xAOD::m_muonSelectionTool
protected

Definition at line 856 of file SUSYObjDef_xAOD.h.

◆ m_muonSelectionToolBaseline

asg::AnaToolHandle<CP::IMuonSelectionTool> ST::SUSYObjDef_xAOD::m_muonSelectionToolBaseline
protected

Definition at line 858 of file SUSYObjDef_xAOD.h.

◆ m_muonTerm

std::string ST::SUSYObjDef_xAOD::m_muonTerm
protected

Definition at line 565 of file SUSYObjDef_xAOD.h.

◆ m_muonTriggerSFTool

asg::AnaToolHandle<CP::IMuonTriggerScaleFactors> ST::SUSYObjDef_xAOD::m_muonTriggerSFTool
protected

Definition at line 865 of file SUSYObjDef_xAOD.h.

◆ m_muonTrigSFTools

ToolHandleArray<CP::IMuonTriggerScaleFactors> ST::SUSYObjDef_xAOD::m_muonTrigSFTools
protected

Definition at line 866 of file SUSYObjDef_xAOD.h.

◆ m_muonTTVAEfficiencySFTool

asg::AnaToolHandle<CP::IMuonEfficiencyScaleFactors> ST::SUSYObjDef_xAOD::m_muonTTVAEfficiencySFTool
protected

Definition at line 862 of file SUSYObjDef_xAOD.h.

◆ m_muPt

double ST::SUSYObjDef_xAOD::m_muPt
protected

Definition at line 698 of file SUSYObjDef_xAOD.h.

◆ m_murequirepassedHighPtCuts

bool ST::SUSYObjDef_xAOD::m_murequirepassedHighPtCuts
protected

Definition at line 704 of file SUSYObjDef_xAOD.h.

◆ m_muz0

double ST::SUSYObjDef_xAOD::m_muz0
protected

Definition at line 701 of file SUSYObjDef_xAOD.h.

◆ m_orApplyRelPt

bool ST::SUSYObjDef_xAOD::m_orApplyRelPt
protected

Definition at line 768 of file SUSYObjDef_xAOD.h.

◆ m_orBJetPtUpperThres

double ST::SUSYObjDef_xAOD::m_orBJetPtUpperThres
protected

Definition at line 777 of file SUSYObjDef_xAOD.h.

◆ m_orBoostedElectronC1

double ST::SUSYObjDef_xAOD::m_orBoostedElectronC1
protected

Definition at line 761 of file SUSYObjDef_xAOD.h.

◆ m_orBoostedElectronC2

double ST::SUSYObjDef_xAOD::m_orBoostedElectronC2
protected

Definition at line 762 of file SUSYObjDef_xAOD.h.

◆ m_orBoostedElectronMaxConeSize

double ST::SUSYObjDef_xAOD::m_orBoostedElectronMaxConeSize
protected

Definition at line 763 of file SUSYObjDef_xAOD.h.

◆ m_orBoostedMuonC1

double ST::SUSYObjDef_xAOD::m_orBoostedMuonC1
protected

Definition at line 765 of file SUSYObjDef_xAOD.h.

◆ m_orBoostedMuonC2

double ST::SUSYObjDef_xAOD::m_orBoostedMuonC2
protected

Definition at line 766 of file SUSYObjDef_xAOD.h.

◆ m_orBoostedMuonMaxConeSize

double ST::SUSYObjDef_xAOD::m_orBoostedMuonMaxConeSize
protected

Definition at line 767 of file SUSYObjDef_xAOD.h.

◆ m_orBtagWP

std::string ST::SUSYObjDef_xAOD::m_orBtagWP
protected

Definition at line 774 of file SUSYObjDef_xAOD.h.

◆ m_orDoBjet

bool ST::SUSYObjDef_xAOD::m_orDoBjet
protected

Definition at line 756 of file SUSYObjDef_xAOD.h.

◆ m_orDoBoostedElectron

bool ST::SUSYObjDef_xAOD::m_orDoBoostedElectron
protected

Definition at line 760 of file SUSYObjDef_xAOD.h.

◆ m_orDoBoostedMuon

bool ST::SUSYObjDef_xAOD::m_orDoBoostedMuon
protected

Definition at line 764 of file SUSYObjDef_xAOD.h.

◆ m_orDoElBjet

bool ST::SUSYObjDef_xAOD::m_orDoElBjet
protected

Definition at line 757 of file SUSYObjDef_xAOD.h.

◆ m_orDoEleJet

bool ST::SUSYObjDef_xAOD::m_orDoEleJet
protected

Definition at line 752 of file SUSYObjDef_xAOD.h.

◆ m_orDoElEl

bool ST::SUSYObjDef_xAOD::m_orDoElEl
protected

Definition at line 753 of file SUSYObjDef_xAOD.h.

◆ m_orDoElMu

bool ST::SUSYObjDef_xAOD::m_orDoElMu
protected

Definition at line 754 of file SUSYObjDef_xAOD.h.

◆ m_orDoFatjets

bool ST::SUSYObjDef_xAOD::m_orDoFatjets
protected

Definition at line 780 of file SUSYObjDef_xAOD.h.

◆ m_orDoMuBjet

bool ST::SUSYObjDef_xAOD::m_orDoMuBjet
protected

Definition at line 758 of file SUSYObjDef_xAOD.h.

◆ m_orDoMuonJet

bool ST::SUSYObjDef_xAOD::m_orDoMuonJet
protected

Definition at line 755 of file SUSYObjDef_xAOD.h.

◆ m_orDoMuonJetGhostAssociation

bool ST::SUSYObjDef_xAOD::m_orDoMuonJetGhostAssociation
protected

Definition at line 772 of file SUSYObjDef_xAOD.h.

◆ m_orDoPhoton

bool ST::SUSYObjDef_xAOD::m_orDoPhoton
protected

Definition at line 751 of file SUSYObjDef_xAOD.h.

◆ m_orDoTau

bool ST::SUSYObjDef_xAOD::m_orDoTau
protected

Overlap removal options.

Definition at line 750 of file SUSYObjDef_xAOD.h.

◆ m_orDoTauBjet

bool ST::SUSYObjDef_xAOD::m_orDoTauBjet
protected

Definition at line 759 of file SUSYObjDef_xAOD.h.

◆ m_orInputLabel

std::string ST::SUSYObjDef_xAOD::m_orInputLabel
protected

Definition at line 775 of file SUSYObjDef_xAOD.h.

◆ m_orLinkOverlapObjects

bool ST::SUSYObjDef_xAOD::m_orLinkOverlapObjects
protected

Definition at line 778 of file SUSYObjDef_xAOD.h.

◆ m_orMuJetInnerDR

double ST::SUSYObjDef_xAOD::m_orMuJetInnerDR
protected

Definition at line 771 of file SUSYObjDef_xAOD.h.

◆ m_orMuJetPtRatio

double ST::SUSYObjDef_xAOD::m_orMuJetPtRatio
protected

Definition at line 769 of file SUSYObjDef_xAOD.h.

◆ m_orMuJetTrkPtRatio

double ST::SUSYObjDef_xAOD::m_orMuJetTrkPtRatio
protected

Definition at line 770 of file SUSYObjDef_xAOD.h.

◆ m_orPhotonFavoured

bool ST::SUSYObjDef_xAOD::m_orPhotonFavoured
protected

Definition at line 776 of file SUSYObjDef_xAOD.h.

◆ m_orRemoveCaloMuons

bool ST::SUSYObjDef_xAOD::m_orRemoveCaloMuons
protected

Definition at line 773 of file SUSYObjDef_xAOD.h.

◆ m_orToolbox

ORUtils::ToolBox ST::SUSYObjDef_xAOD::m_orToolbox
protected

Definition at line 970 of file SUSYObjDef_xAOD.h.

◆ m_outElectronLocation

SG::WriteHandleKey<xAOD::ElectronContainer> ST::SUSYObjDef_xAOD::m_outElectronLocation {this, "OutputElectronLocation", "StdWithLRTElectrons", "name of the muon container to write"}
protected

Definition at line 883 of file SUSYObjDef_xAOD.h.

◆ m_outMETTerm

std::string ST::SUSYObjDef_xAOD::m_outMETTerm
protected

Definition at line 570 of file SUSYObjDef_xAOD.h.

◆ m_outMuonLocation

SG::WriteHandleKey<xAOD::MuonContainer> ST::SUSYObjDef_xAOD::m_outMuonLocation {this, "OutputMuonLocation", "StdWithLRTMuons", "name of the muon container to write"}
protected

Definition at line 868 of file SUSYObjDef_xAOD.h.

◆ m_outputMetaStore

MetaStore_t asg::AsgMetadataTool::m_outputMetaStore
privateinherited

Object accessing the output metadata store.

Definition at line 121 of file AsgMetadataTool.h.

◆ m_ph_id_support

std::vector<std::string> ST::SUSYObjDef_xAOD::m_ph_id_support
protected

Definition at line 622 of file SUSYObjDef_xAOD.h.

◆ m_photonAllowLate

bool ST::SUSYObjDef_xAOD::m_photonAllowLate
protected

Definition at line 717 of file SUSYObjDef_xAOD.h.

◆ m_photonBaselineCrackVeto

bool ST::SUSYObjDef_xAOD::m_photonBaselineCrackVeto
protected

Definition at line 715 of file SUSYObjDef_xAOD.h.

◆ m_photonBaselineEta

double ST::SUSYObjDef_xAOD::m_photonBaselineEta
protected

Definition at line 712 of file SUSYObjDef_xAOD.h.

◆ m_photonBaselineIso_WP

std::string ST::SUSYObjDef_xAOD::m_photonBaselineIso_WP
protected

Definition at line 658 of file SUSYObjDef_xAOD.h.

◆ m_photonBaselinePt

double ST::SUSYObjDef_xAOD::m_photonBaselinePt
protected

Definition at line 711 of file SUSYObjDef_xAOD.h.

◆ m_photonCrackVeto

bool ST::SUSYObjDef_xAOD::m_photonCrackVeto
protected

Definition at line 716 of file SUSYObjDef_xAOD.h.

◆ m_photonEfficiencySFTool

asg::AnaToolHandle<IAsgPhotonEfficiencyCorrectionTool> ST::SUSYObjDef_xAOD::m_photonEfficiencySFTool
protected

Definition at line 892 of file SUSYObjDef_xAOD.h.

◆ m_photonEfficiencySFTool_trigEff_AsymDiphoton

std::vector<asg::AnaToolHandle<IAsgPhotonEfficiencyCorrectionTool> > ST::SUSYObjDef_xAOD::m_photonEfficiencySFTool_trigEff_AsymDiphoton
protected

Definition at line 897 of file SUSYObjDef_xAOD.h.

◆ m_photonEfficiencySFTool_trigSF_AsymDiphoton

std::vector<asg::AnaToolHandle<IAsgPhotonEfficiencyCorrectionTool> > ST::SUSYObjDef_xAOD::m_photonEfficiencySFTool_trigSF_AsymDiphoton
protected

Definition at line 896 of file SUSYObjDef_xAOD.h.

◆ m_photonEta

double ST::SUSYObjDef_xAOD::m_photonEta
protected

Definition at line 713 of file SUSYObjDef_xAOD.h.

◆ m_photonId

std::string ST::SUSYObjDef_xAOD::m_photonId
protected

Definition at line 645 of file SUSYObjDef_xAOD.h.

◆ m_photonIdBaseline

std::string ST::SUSYObjDef_xAOD::m_photonIdBaseline
protected

Definition at line 646 of file SUSYObjDef_xAOD.h.

◆ m_photonIdBaselineDFName

std::string ST::SUSYObjDef_xAOD::m_photonIdBaselineDFName
protected

Definition at line 977 of file SUSYObjDef_xAOD.h.

◆ m_photonIdDFName

std::string ST::SUSYObjDef_xAOD::m_photonIdDFName
protected

Definition at line 978 of file SUSYObjDef_xAOD.h.

◆ m_photonIso_WP

std::string ST::SUSYObjDef_xAOD::m_photonIso_WP
protected

Definition at line 659 of file SUSYObjDef_xAOD.h.

◆ m_photonIsolationSFTool

asg::AnaToolHandle<IAsgPhotonEfficiencyCorrectionTool> ST::SUSYObjDef_xAOD::m_photonIsolationSFTool
protected

Definition at line 893 of file SUSYObjDef_xAOD.h.

◆ m_photonPt

double ST::SUSYObjDef_xAOD::m_photonPt
protected

Definition at line 714 of file SUSYObjDef_xAOD.h.

◆ m_photonSelIsEM

asg::AnaToolHandle<IAsgPhotonIsEMSelector> ST::SUSYObjDef_xAOD::m_photonSelIsEM
protected

Definition at line 889 of file SUSYObjDef_xAOD.h.

◆ m_photonSelIsEMBaseline

asg::AnaToolHandle<IAsgPhotonIsEMSelector> ST::SUSYObjDef_xAOD::m_photonSelIsEMBaseline
protected

Definition at line 890 of file SUSYObjDef_xAOD.h.

◆ m_photonTrigEffTools

ToolHandleArray<IAsgPhotonEfficiencyCorrectionTool> ST::SUSYObjDef_xAOD::m_photonTrigEffTools
protected

Definition at line 899 of file SUSYObjDef_xAOD.h.

◆ m_photonTriggerName

std::string ST::SUSYObjDef_xAOD::m_photonTriggerName
protected

Definition at line 660 of file SUSYObjDef_xAOD.h.

◆ m_photonTriggerSFTool

asg::AnaToolHandle<IAsgPhotonEfficiencyCorrectionTool> ST::SUSYObjDef_xAOD::m_photonTriggerSFTool
protected

Definition at line 894 of file SUSYObjDef_xAOD.h.

◆ m_photonTrigSFTools

ToolHandleArray<IAsgPhotonEfficiencyCorrectionTool> ST::SUSYObjDef_xAOD::m_photonTrigSFTools
protected

Definition at line 898 of file SUSYObjDef_xAOD.h.

◆ m_pmgSHnjetWeighter

asg::AnaToolHandle<IWeightTool> ST::SUSYObjDef_xAOD::m_pmgSHnjetWeighter
protected

Definition at line 972 of file SUSYObjDef_xAOD.h.

◆ m_pmgSHnjetWeighterWZ

asg::AnaToolHandle<IWeightTool> ST::SUSYObjDef_xAOD::m_pmgSHnjetWeighterWZ
protected

Definition at line 973 of file SUSYObjDef_xAOD.h.

◆ m_prwActualMu2017File

std::string ST::SUSYObjDef_xAOD::m_prwActualMu2017File
protected

Definition at line 609 of file SUSYObjDef_xAOD.h.

◆ m_prwActualMu2018File

std::string ST::SUSYObjDef_xAOD::m_prwActualMu2018File
protected

Definition at line 610 of file SUSYObjDef_xAOD.h.

◆ m_prwActualMu2022File

std::string ST::SUSYObjDef_xAOD::m_prwActualMu2022File
protected

Definition at line 611 of file SUSYObjDef_xAOD.h.

◆ m_prwActualMu2023File

std::string ST::SUSYObjDef_xAOD::m_prwActualMu2023File
protected

Definition at line 612 of file SUSYObjDef_xAOD.h.

◆ m_prwActualMu2024File

std::string ST::SUSYObjDef_xAOD::m_prwActualMu2024File
protected

Definition at line 613 of file SUSYObjDef_xAOD.h.

◆ m_prwConfFiles

std::vector<std::string> ST::SUSYObjDef_xAOD::m_prwConfFiles
protected

Definition at line 607 of file SUSYObjDef_xAOD.h.

◆ m_prwDataSF

double ST::SUSYObjDef_xAOD::m_prwDataSF
protected

Definition at line 615 of file SUSYObjDef_xAOD.h.

◆ m_prwDataSF_DW

double ST::SUSYObjDef_xAOD::m_prwDataSF_DW
protected

Definition at line 617 of file SUSYObjDef_xAOD.h.

◆ m_prwDataSF_UP

double ST::SUSYObjDef_xAOD::m_prwDataSF_UP
protected

Definition at line 616 of file SUSYObjDef_xAOD.h.

◆ m_prwLcalcFiles

std::vector<std::string> ST::SUSYObjDef_xAOD::m_prwLcalcFiles
protected

Definition at line 608 of file SUSYObjDef_xAOD.h.

◆ m_prwTool

asg::AnaToolHandle<CP::IPileupReweightingTool> ST::SUSYObjDef_xAOD::m_prwTool
protected

Definition at line 965 of file SUSYObjDef_xAOD.h.

◆ m_runDepPrescaleWeightPRW

bool ST::SUSYObjDef_xAOD::m_runDepPrescaleWeightPRW
protected

Definition at line 618 of file SUSYObjDef_xAOD.h.

◆ m_runECIS

bool ST::SUSYObjDef_xAOD::m_runECIS
protected

Definition at line 657 of file SUSYObjDef_xAOD.h.

◆ m_showerType

int ST::SUSYObjDef_xAOD::m_showerType
protected

Definition at line 800 of file SUSYObjDef_xAOD.h.

◆ m_slices

std::map<std::string,bool> ST::SUSYObjDef_xAOD::m_slices
protected

Definition at line 794 of file SUSYObjDef_xAOD.h.

◆ m_softTermParam

int ST::SUSYObjDef_xAOD::m_softTermParam
protected

Definition at line 584 of file SUSYObjDef_xAOD.h.

◆ m_strictConfigCheck

bool ST::SUSYObjDef_xAOD::m_strictConfigCheck
protected

Definition at line 535 of file SUSYObjDef_xAOD.h.

◆ m_subtool_init

bool ST::SUSYObjDef_xAOD::m_subtool_init
protected

Definition at line 559 of file SUSYObjDef_xAOD.h.

◆ m_tau_id_support

std::vector<std::string> ST::SUSYObjDef_xAOD::m_tau_id_support
protected

Definition at line 624 of file SUSYObjDef_xAOD.h.

◆ m_tau_trig_support

std::map<std::string, std::string> ST::SUSYObjDef_xAOD::m_tau_trig_support
protected

Definition at line 635 of file SUSYObjDef_xAOD.h.

◆ m_tauConfigPath

std::string ST::SUSYObjDef_xAOD::m_tauConfigPath
protected

Definition at line 722 of file SUSYObjDef_xAOD.h.

◆ m_tauConfigPathBaseline

std::string ST::SUSYObjDef_xAOD::m_tauConfigPathBaseline
protected

Definition at line 723 of file SUSYObjDef_xAOD.h.

◆ m_tauConfigReader

TEnv ST::SUSYObjDef_xAOD::m_tauConfigReader
protected

Definition at line 727 of file SUSYObjDef_xAOD.h.

◆ m_tauDoTTM

bool ST::SUSYObjDef_xAOD::m_tauDoTTM
protected

Definition at line 724 of file SUSYObjDef_xAOD.h.

◆ m_tauEffTool

asg::AnaToolHandle<TauAnalysisTools::ITauEfficiencyCorrectionsTool> ST::SUSYObjDef_xAOD::m_tauEffTool
protected

Definition at line 909 of file SUSYObjDef_xAOD.h.

◆ m_tauEta

double ST::SUSYObjDef_xAOD::m_tauEta
protected

Definition at line 721 of file SUSYObjDef_xAOD.h.

◆ m_tauId

std::string ST::SUSYObjDef_xAOD::m_tauId
protected

Definition at line 647 of file SUSYObjDef_xAOD.h.

◆ m_tauIdBaseline

std::string ST::SUSYObjDef_xAOD::m_tauIdBaseline
protected

Definition at line 648 of file SUSYObjDef_xAOD.h.

◆ m_tauJetORtool

asg::AnaToolHandle<ORUtils::IOverlapTool> ST::SUSYObjDef_xAOD::m_tauJetORtool
protected

Definition at line 969 of file SUSYObjDef_xAOD.h.

◆ m_tauPrePtCut

double ST::SUSYObjDef_xAOD::m_tauPrePtCut
protected

Definition at line 719 of file SUSYObjDef_xAOD.h.

◆ m_tauPt

double ST::SUSYObjDef_xAOD::m_tauPt
protected

Definition at line 720 of file SUSYObjDef_xAOD.h.

◆ m_tauSelTool

asg::AnaToolHandle<TauAnalysisTools::ITauSelectionTool> ST::SUSYObjDef_xAOD::m_tauSelTool
protected

Definition at line 905 of file SUSYObjDef_xAOD.h.

◆ m_tauSelToolBaseline

asg::AnaToolHandle<TauAnalysisTools::ITauSelectionTool> ST::SUSYObjDef_xAOD::m_tauSelToolBaseline
protected

Definition at line 906 of file SUSYObjDef_xAOD.h.

◆ m_tauSmearingTool

asg::AnaToolHandle<TauAnalysisTools::ITauSmearingTool> ST::SUSYObjDef_xAOD::m_tauSmearingTool
protected

Definition at line 907 of file SUSYObjDef_xAOD.h.

◆ m_tauSmearingToolGenerator

std::string ST::SUSYObjDef_xAOD::m_tauSmearingToolGenerator
protected

Definition at line 726 of file SUSYObjDef_xAOD.h.

◆ m_tauSmearingToolRecommendationTag

std::string ST::SUSYObjDef_xAOD::m_tauSmearingToolRecommendationTag
protected

Definition at line 725 of file SUSYObjDef_xAOD.h.

◆ m_tauTerm

std::string ST::SUSYObjDef_xAOD::m_tauTerm
protected

Definition at line 563 of file SUSYObjDef_xAOD.h.

◆ m_tauTrigEffTool

std::vector<asg::AnaToolHandle<TauAnalysisTools::ITauEfficiencyCorrectionsTool> > ST::SUSYObjDef_xAOD::m_tauTrigEffTool
protected

Definition at line 910 of file SUSYObjDef_xAOD.h.

◆ m_tauTruthMatch

asg::AnaToolHandle<TauAnalysisTools::ITauTruthMatchingTool> ST::SUSYObjDef_xAOD::m_tauTruthMatch
protected

Definition at line 908 of file SUSYObjDef_xAOD.h.

◆ m_tool_init

bool ST::SUSYObjDef_xAOD::m_tool_init
protected

Definition at line 558 of file SUSYObjDef_xAOD.h.

◆ m_TopconfigReader

TEnv ST::SUSYObjDef_xAOD::m_TopconfigReader
protected

Definition at line 544 of file SUSYObjDef_xAOD.h.

◆ m_TopDecorName

std::string ST::SUSYObjDef_xAOD::m_TopDecorName
protected

Definition at line 547 of file SUSYObjDef_xAOD.h.

◆ m_ToptagConfig

std::string ST::SUSYObjDef_xAOD::m_ToptagConfig
protected

Definition at line 550 of file SUSYObjDef_xAOD.h.

◆ m_TopTaggerCalibArea

std::string ST::SUSYObjDef_xAOD::m_TopTaggerCalibArea
protected

Definition at line 552 of file SUSYObjDef_xAOD.h.

◆ m_TopTaggerTool

asg::AnaToolHandle<JSSWTopTaggerDNN> ST::SUSYObjDef_xAOD::m_TopTaggerTool
protected

Definition at line 836 of file SUSYObjDef_xAOD.h.

◆ m_TopTagjetUncertaintiesTool

asg::AnaToolHandle<ICPJetUncertaintiesTool> ST::SUSYObjDef_xAOD::m_TopTagjetUncertaintiesTool
protected

Definition at line 840 of file SUSYObjDef_xAOD.h.

◆ m_TopTagUncConfig

std::string ST::SUSYObjDef_xAOD::m_TopTagUncConfig
protected

Definition at line 555 of file SUSYObjDef_xAOD.h.

◆ m_treatPUJets

bool ST::SUSYObjDef_xAOD::m_treatPUJets
protected

Definition at line 585 of file SUSYObjDef_xAOD.h.

◆ m_trig2015combination_diLep

std::string ST::SUSYObjDef_xAOD::m_trig2015combination_diLep
protected

Definition at line 929 of file SUSYObjDef_xAOD.h.

◆ m_trig2015combination_diPhoton

std::string ST::SUSYObjDef_xAOD::m_trig2015combination_diPhoton
protected

Definition at line 945 of file SUSYObjDef_xAOD.h.

◆ m_trig2015combination_multiLep

std::string ST::SUSYObjDef_xAOD::m_trig2015combination_multiLep
protected

Definition at line 937 of file SUSYObjDef_xAOD.h.

◆ m_trig2015combination_singleLep

std::string ST::SUSYObjDef_xAOD::m_trig2015combination_singleLep
protected

Definition at line 922 of file SUSYObjDef_xAOD.h.

◆ m_trig2016combination_diLep

std::string ST::SUSYObjDef_xAOD::m_trig2016combination_diLep
protected

Definition at line 930 of file SUSYObjDef_xAOD.h.

◆ m_trig2016combination_diPhoton

std::string ST::SUSYObjDef_xAOD::m_trig2016combination_diPhoton
protected

Definition at line 946 of file SUSYObjDef_xAOD.h.

◆ m_trig2016combination_multiLep

std::string ST::SUSYObjDef_xAOD::m_trig2016combination_multiLep
protected

Definition at line 938 of file SUSYObjDef_xAOD.h.

◆ m_trig2016combination_singleLep

std::string ST::SUSYObjDef_xAOD::m_trig2016combination_singleLep
protected

Definition at line 923 of file SUSYObjDef_xAOD.h.

◆ m_trig2017combination_diLep

std::string ST::SUSYObjDef_xAOD::m_trig2017combination_diLep
protected

Definition at line 931 of file SUSYObjDef_xAOD.h.

◆ m_trig2017combination_diPhoton

std::string ST::SUSYObjDef_xAOD::m_trig2017combination_diPhoton
protected

Definition at line 947 of file SUSYObjDef_xAOD.h.

◆ m_trig2017combination_multiLep

std::string ST::SUSYObjDef_xAOD::m_trig2017combination_multiLep
protected

Definition at line 939 of file SUSYObjDef_xAOD.h.

◆ m_trig2017combination_singleLep

std::string ST::SUSYObjDef_xAOD::m_trig2017combination_singleLep
protected

Definition at line 924 of file SUSYObjDef_xAOD.h.

◆ m_trig2018combination_diLep

std::string ST::SUSYObjDef_xAOD::m_trig2018combination_diLep
protected

Definition at line 932 of file SUSYObjDef_xAOD.h.

◆ m_trig2018combination_diPhoton

std::string ST::SUSYObjDef_xAOD::m_trig2018combination_diPhoton
protected

Definition at line 948 of file SUSYObjDef_xAOD.h.

◆ m_trig2018combination_multiLep

std::string ST::SUSYObjDef_xAOD::m_trig2018combination_multiLep
protected

Definition at line 940 of file SUSYObjDef_xAOD.h.

◆ m_trig2018combination_singleLep

std::string ST::SUSYObjDef_xAOD::m_trig2018combination_singleLep
protected

Definition at line 925 of file SUSYObjDef_xAOD.h.

◆ m_trig2022combination_diLep

std::string ST::SUSYObjDef_xAOD::m_trig2022combination_diLep
protected

Definition at line 933 of file SUSYObjDef_xAOD.h.

◆ m_trig2022combination_diPhoton

std::string ST::SUSYObjDef_xAOD::m_trig2022combination_diPhoton
protected

Definition at line 949 of file SUSYObjDef_xAOD.h.

◆ m_trig2022combination_multiLep

std::string ST::SUSYObjDef_xAOD::m_trig2022combination_multiLep
protected

Definition at line 941 of file SUSYObjDef_xAOD.h.

◆ m_trig2022combination_singleLep

std::string ST::SUSYObjDef_xAOD::m_trig2022combination_singleLep
protected

Definition at line 926 of file SUSYObjDef_xAOD.h.

◆ m_trigConfTool

asg::AnaToolHandle<TrigConf::ITrigConfigTool> ST::SUSYObjDef_xAOD::m_trigConfTool
protected

Definition at line 952 of file SUSYObjDef_xAOD.h.

◆ m_trigDecTool

asg::AnaToolHandle<Trig::TrigDecisionTool> ST::SUSYObjDef_xAOD::m_trigDecTool
protected

Definition at line 953 of file SUSYObjDef_xAOD.h.

◆ m_trigDRScoringTool

asg::AnaToolHandle<Trig::IMatchScoringTool> ST::SUSYObjDef_xAOD::m_trigDRScoringTool
protected

Definition at line 956 of file SUSYObjDef_xAOD.h.

◆ m_triggerCacheMutex

std::mutex ST::SUSYObjDef_xAOD::m_triggerCacheMutex
mutableprivate

Definition at line 446 of file SUSYObjDef_xAOD.h.

◆ m_trigGlobalEffCorrTool_diLep

asg::AnaToolHandle<ITrigGlobalEfficiencyCorrectionTool> ST::SUSYObjDef_xAOD::m_trigGlobalEffCorrTool_diLep
protected

Definition at line 934 of file SUSYObjDef_xAOD.h.

◆ m_trigGlobalEffCorrTool_diPhoton

asg::AnaToolHandle<ITrigGlobalEfficiencyCorrectionTool> ST::SUSYObjDef_xAOD::m_trigGlobalEffCorrTool_diPhoton
protected

Definition at line 950 of file SUSYObjDef_xAOD.h.

◆ m_trigGlobalEffCorrTool_multiLep

asg::AnaToolHandle<ITrigGlobalEfficiencyCorrectionTool> ST::SUSYObjDef_xAOD::m_trigGlobalEffCorrTool_multiLep
protected

Definition at line 942 of file SUSYObjDef_xAOD.h.

◆ m_trigMatchingPrefix

std::string ST::SUSYObjDef_xAOD::m_trigMatchingPrefix
protected

Use composite trigger matching tool if matching was done upstream.

Definition at line 523 of file SUSYObjDef_xAOD.h.

◆ m_trigMatchingTool

asg::AnaToolHandle<Trig::IMatchingTool> ST::SUSYObjDef_xAOD::m_trigMatchingTool
protected

Definition at line 954 of file SUSYObjDef_xAOD.h.

◆ m_trigMatchScoringTool

asg::AnaToolHandle<Trig::IMatchScoringTool> ST::SUSYObjDef_xAOD::m_trigMatchScoringTool
protected

Definition at line 955 of file SUSYObjDef_xAOD.h.

◆ m_trigNToys_diLep

int ST::SUSYObjDef_xAOD::m_trigNToys_diLep
protected

Definition at line 928 of file SUSYObjDef_xAOD.h.

◆ m_trigNToys_diPhoton

int ST::SUSYObjDef_xAOD::m_trigNToys_diPhoton
protected

Definition at line 944 of file SUSYObjDef_xAOD.h.

◆ m_trigNToys_multiLep

int ST::SUSYObjDef_xAOD::m_trigNToys_multiLep
protected

Definition at line 936 of file SUSYObjDef_xAOD.h.

◆ m_trkJetEta

double ST::SUSYObjDef_xAOD::m_trkJetEta
protected

Definition at line 738 of file SUSYObjDef_xAOD.h.

◆ m_trkJetPt

double ST::SUSYObjDef_xAOD::m_trkJetPt
protected

Definition at line 737 of file SUSYObjDef_xAOD.h.

◆ m_trkJetsyst

bool ST::SUSYObjDef_xAOD::m_trkJetsyst
protected

Definition at line 582 of file SUSYObjDef_xAOD.h.

◆ m_trkMETsyst

bool ST::SUSYObjDef_xAOD::m_trkMETsyst
protected

Definition at line 580 of file SUSYObjDef_xAOD.h.

◆ m_upstreamTriggerMatching

bool ST::SUSYObjDef_xAOD::m_upstreamTriggerMatching
protected

Definition at line 522 of file SUSYObjDef_xAOD.h.

◆ m_useBtagging

bool ST::SUSYObjDef_xAOD::m_useBtagging
protected

Definition at line 531 of file SUSYObjDef_xAOD.h.

◆ m_useBtagging_trkJet

bool ST::SUSYObjDef_xAOD::m_useBtagging_trkJet
protected

Definition at line 532 of file SUSYObjDef_xAOD.h.

◆ m_useCommonPRWFiles

bool ST::SUSYObjDef_xAOD::m_useCommonPRWFiles
protected

Definition at line 597 of file SUSYObjDef_xAOD.h.

◆ m_useIncidents

bool asg::AsgMetadataTool::m_useIncidents
privateinherited

Definition at line 128 of file AsgMetadataTool.h.

◆ m_useSigLepForIsoCloseByOR

bool ST::SUSYObjDef_xAOD::m_useSigLepForIsoCloseByOR
protected

Definition at line 789 of file SUSYObjDef_xAOD.h.

◆ m_useTRUTH3

bool ST::SUSYObjDef_xAOD::m_useTRUTH3
protected

Definition at line 792 of file SUSYObjDef_xAOD.h.

◆ m_v_trigs15_cache_diLep

std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs15_cache_diLep
private

Definition at line 464 of file SUSYObjDef_xAOD.h.

◆ m_v_trigs15_cache_multiLep

std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs15_cache_multiLep
private

Definition at line 470 of file SUSYObjDef_xAOD.h.

◆ m_v_trigs15_cache_singleEle

std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs15_cache_singleEle
private

Definition at line 452 of file SUSYObjDef_xAOD.h.

◆ m_v_trigs15_cache_singleLep

std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs15_cache_singleLep
private

Definition at line 458 of file SUSYObjDef_xAOD.h.

◆ m_v_trigs16_cache_diLep

std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs16_cache_diLep
private

Definition at line 465 of file SUSYObjDef_xAOD.h.

◆ m_v_trigs16_cache_multiLep

std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs16_cache_multiLep
private

Definition at line 471 of file SUSYObjDef_xAOD.h.

◆ m_v_trigs16_cache_singleEle

std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs16_cache_singleEle
private

Definition at line 453 of file SUSYObjDef_xAOD.h.

◆ m_v_trigs16_cache_singleLep

std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs16_cache_singleLep
private

Definition at line 459 of file SUSYObjDef_xAOD.h.

◆ m_v_trigs17_cache_diLep

std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs17_cache_diLep
private

Definition at line 466 of file SUSYObjDef_xAOD.h.

◆ m_v_trigs17_cache_multiLep

std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs17_cache_multiLep
private

Definition at line 472 of file SUSYObjDef_xAOD.h.

◆ m_v_trigs17_cache_singleEle

std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs17_cache_singleEle
private

Definition at line 454 of file SUSYObjDef_xAOD.h.

◆ m_v_trigs17_cache_singleLep

std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs17_cache_singleLep
private

Definition at line 460 of file SUSYObjDef_xAOD.h.

◆ m_v_trigs18_cache_diLep

std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs18_cache_diLep
private

Definition at line 467 of file SUSYObjDef_xAOD.h.

◆ m_v_trigs18_cache_multiLep

std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs18_cache_multiLep
private

Definition at line 473 of file SUSYObjDef_xAOD.h.

◆ m_v_trigs18_cache_singleEle

std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs18_cache_singleEle
private

Definition at line 455 of file SUSYObjDef_xAOD.h.

◆ m_v_trigs18_cache_singleLep

std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs18_cache_singleLep
private

Definition at line 461 of file SUSYObjDef_xAOD.h.

◆ m_v_trigs22_cache_diLep

std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs22_cache_diLep
private

Definition at line 468 of file SUSYObjDef_xAOD.h.

◆ m_v_trigs22_cache_multiLep

std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs22_cache_multiLep
private

Definition at line 474 of file SUSYObjDef_xAOD.h.

◆ m_v_trigs22_cache_singleEle

std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs22_cache_singleEle
private

Definition at line 456 of file SUSYObjDef_xAOD.h.

◆ m_v_trigs22_cache_singleLep

std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs22_cache_singleLep
private

Definition at line 462 of file SUSYObjDef_xAOD.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_WconfigReader

TEnv ST::SUSYObjDef_xAOD::m_WconfigReader
protected

Definition at line 542 of file SUSYObjDef_xAOD.h.

◆ m_WDecorName

std::string ST::SUSYObjDef_xAOD::m_WDecorName
protected

Definition at line 545 of file SUSYObjDef_xAOD.h.

◆ m_WtagConfig

std::string ST::SUSYObjDef_xAOD::m_WtagConfig
protected

Definition at line 548 of file SUSYObjDef_xAOD.h.

◆ m_WTaggerTool

asg::AnaToolHandle<SmoothedWZTagger> ST::SUSYObjDef_xAOD::m_WTaggerTool
protected

Definition at line 834 of file SUSYObjDef_xAOD.h.

◆ m_WTagjetUncertaintiesTool

asg::AnaToolHandle<ICPJetUncertaintiesTool> ST::SUSYObjDef_xAOD::m_WTagjetUncertaintiesTool
protected

Definition at line 838 of file SUSYObjDef_xAOD.h.

◆ m_WTagUncConfig

std::string ST::SUSYObjDef_xAOD::m_WTagUncConfig
protected

Definition at line 553 of file SUSYObjDef_xAOD.h.

◆ m_WZTaggerCalibArea

std::string ST::SUSYObjDef_xAOD::m_WZTaggerCalibArea
protected

Definition at line 551 of file SUSYObjDef_xAOD.h.

◆ m_ZconfigReader

TEnv ST::SUSYObjDef_xAOD::m_ZconfigReader
protected

Definition at line 543 of file SUSYObjDef_xAOD.h.

◆ m_ZDecorName

std::string ST::SUSYObjDef_xAOD::m_ZDecorName
protected

Definition at line 546 of file SUSYObjDef_xAOD.h.

◆ m_ZtagConfig

std::string ST::SUSYObjDef_xAOD::m_ZtagConfig
protected

Definition at line 549 of file SUSYObjDef_xAOD.h.

◆ m_ZTaggerTool

asg::AnaToolHandle<SmoothedWZTagger> ST::SUSYObjDef_xAOD::m_ZTaggerTool
protected

Definition at line 835 of file SUSYObjDef_xAOD.h.

◆ m_ZTagjetUncertaintiesTool

asg::AnaToolHandle<ICPJetUncertaintiesTool> ST::SUSYObjDef_xAOD::m_ZTagjetUncertaintiesTool
protected

Definition at line 839 of file SUSYObjDef_xAOD.h.

◆ m_ZTagUncConfig

std::string ST::SUSYObjDef_xAOD::m_ZTagUncConfig
protected

Definition at line 554 of file SUSYObjDef_xAOD.h.

◆ prompt_electrons

const xAOD::ElectronContainer* ST::SUSYObjDef_xAOD::prompt_electrons = nullptr

Definition at line 210 of file SUSYObjDef_xAOD.h.

◆ prompt_muons

const xAOD::MuonContainer* ST::SUSYObjDef_xAOD::prompt_muons = nullptr

Definition at line 204 of file SUSYObjDef_xAOD.h.


The documentation for this class was generated from the following files:
grepfile.info
info
Definition: grepfile.py:38
ST::SUSYObjDef_xAOD::m_WDecorName
std::string m_WDecorName
Definition: SUSYObjDef_xAOD.h:545
ST::SUSYObjDef_xAOD::m_v_trigs15_cache_singleLep
std::vector< std::string > m_v_trigs15_cache_singleLep
Definition: SUSYObjDef_xAOD.h:458
LArG4FSStartPointFilter.part
part
Definition: LArG4FSStartPointFilter.py:21
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
ST::SUSYObjDef_xAOD::m_applyJVTCut
bool m_applyJVTCut
Definition: SUSYObjDef_xAOD.h:812
ST::SUSYObjDef_xAOD::m_orBoostedMuonC1
double m_orBoostedMuonC1
Definition: SUSYObjDef_xAOD.h:765
ST::SUSYObjDef_xAOD::m_autoconfigPRWCombinedmode
bool m_autoconfigPRWCombinedmode
Definition: SUSYObjDef_xAOD.h:591
ST::SUSYObjDef_xAOD::GetTauTriggerEfficiencySF
double GetTauTriggerEfficiencySF(const xAOD::TauJet &tau, const std::string &trigExpr="tau25_medium1_tracktwo") override final
Definition: Taus.cxx:193
python.Dso.registry
registry
Definition: Control/AthenaServices/python/Dso.py:159
ST::SUSYObjDef_xAOD::m_muonEfficiencySFTool
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonEfficiencySFTool
Definition: SUSYObjDef_xAOD.h:860
asg::AnaToolHandle::initialize
StatusCode initialize()
initialize the tool
ST::SUSYObjDef_xAOD::m_badJetCut
std::string m_badJetCut
Definition: SUSYObjDef_xAOD.h:537
ST::SUSYObjDef_xAOD::emulateHLT
bool emulateHLT(const std::string &triggerName) const
Definition: Trigger.cxx:99
bJetLabel
const std::string bJetLabel
Definition: OverlapRemovalTester.cxx:70
ST::SUSYObjDef_xAOD::m_isoHighPtTool
asg::AnaToolHandle< CP::IIsolationSelectionTool > m_isoHighPtTool
Definition: SUSYObjDef_xAOD.h:962
ST::SUSYObjDef_xAOD::m_photonIdBaselineDFName
std::string m_photonIdBaselineDFName
Definition: SUSYObjDef_xAOD.h:977
ST::SUSYObjDef_xAOD::m_autoconfigPRWRtags
std::string m_autoconfigPRWRtags
Definition: SUSYObjDef_xAOD.h:593
ST::SUSYObjDef_xAOD::m_outElectronLocation
SG::WriteHandleKey< xAOD::ElectronContainer > m_outElectronLocation
Definition: SUSYObjDef_xAOD.h:883
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:73
CP::IMuonLRTOverlapRemovalTool::defaultStrategy
@ defaultStrategy
Definition: IMuonLRTOverlapRemovalTool.h:38
ST::SUSYObjDef_xAOD::m_GSFLRTCollectionName
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_GSFLRTCollectionName
Definition: SUSYObjDef_xAOD.h:478
ST::SUSYObjDef_xAOD::m_orBoostedElectronC1
double m_orBoostedElectronC1
Definition: SUSYObjDef_xAOD.h:761
xAOD::numberOfPixelHoles
@ numberOfPixelHoles
number of pixel layers on track with absence of hits [unit8_t].
Definition: TrackingPrimitives.h:261
JetPileupLabelingTool::decorate
StatusCode decorate(const xAOD::JetContainer &jets) const override
Decorate hard-scatter and pileup labels to a jet collection.
Definition: JetPileupLabelingTool.cxx:43
ST::SUSYObjDef_xAOD::m_orBoostedMuonC2
double m_orBoostedMuonC2
Definition: SUSYObjDef_xAOD.h:766
LikeEnum::Loose
@ Loose
Definition: LikelihoodEnums.h:12
ST::SUSYObjDef_xAOD::m_acc_photonIdBaseline
SG::ConstAccessor< char > m_acc_photonIdBaseline
Definition: SUSYObjDef_xAOD.h:983
TrigJetMonitorAlgorithm.jetcoll
jetcoll
Definition: TrigJetMonitorAlgorithm.py:1306
ST::SUSYObjDef_xAOD::m_photonBaselinePt
double m_photonBaselinePt
Definition: SUSYObjDef_xAOD.h:711
ST::SUSYObjDef_xAOD::IsHighPtMuon
bool IsHighPtMuon(const xAOD::Muon &input) const override final
Definition: Muons.cxx:383
ST::SUSYObjDef_xAOD::MergeElectrons
StatusCode MergeElectrons(const xAOD::ElectronContainer &electrons, xAOD::ElectronContainer *outputCol, const std::set< const xAOD::Electron * > &ElectronsToRemove) const override final
Definition: Electrons.cxx:61
NuRMu
@ NuRMu
Definition: TruthClasses.h:73
ST::SUSYObjDef_xAOD::m_deadHVTool
asg::AnaToolHandle< IAsgDeadHVCellRemovalTool > m_deadHVTool
Definition: SUSYObjDef_xAOD.h:891
ST::SUSYObjDef_xAOD::m_eleIdExpert
bool m_eleIdExpert
Definition: SUSYObjDef_xAOD.h:642
ST::SUSYObjDef_xAOD::m_doPhiReso
bool m_doPhiReso
Definition: SUSYObjDef_xAOD.h:586
ST::SUSYObjDef_xAOD::m_jetfJvtEfficiencyTool
asg::AnaToolHandle< CP::IJvtEfficiencyTool > m_jetfJvtEfficiencyTool
Definition: SUSYObjDef_xAOD.h:832
ST::SUSYObjDef_xAOD::m_tauSelTool
asg::AnaToolHandle< TauAnalysisTools::ITauSelectionTool > m_tauSelTool
Definition: SUSYObjDef_xAOD.h:905
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:195
ST::SUSYObjDef_xAOD::m_ZconfigReader
TEnv m_ZconfigReader
Definition: SUSYObjDef_xAOD.h:543
ST::SUSYObjDef_xAOD::GetEleTriggerEfficiencySF
double GetEleTriggerEfficiencySF(const xAOD::Electron &el, const std::string &trigExpr="SINGLE_E_2015_e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose_2016_2018_e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0") const override final
Definition: Electrons.cxx:554
ST::SUSYObjDef_xAOD::m_trig2022combination_multiLep
std::string m_trig2022combination_multiLep
Definition: SUSYObjDef_xAOD.h:941
ST::SUSYObjDef_xAOD::m_doTTVAsf
bool m_doTTVAsf
Definition: SUSYObjDef_xAOD.h:520
ST::SUSYObjDef_xAOD::m_commonPRWFileMC23e
std::string m_commonPRWFileMC23e
Definition: SUSYObjDef_xAOD.h:605
CP::SystematicVariation::CONTINUOUS
@ CONTINUOUS
Definition: SystematicVariation.h:79
ST::SUSYObjDef_xAOD::m_fJvtWP
std::string m_fJvtWP
Definition: SUSYObjDef_xAOD.h:741
asg::AsgTool
Base class for the dual-use tool implementation classes.
Definition: AsgTool.h:47
ST::SUSYObjDef_xAOD::GetTotalTauSF
double GetTotalTauSF(const xAOD::TauJetContainer &taus, const bool idSF=true, const bool triggerSF=true, const std::string &trigExpr="tau25_medium1_tracktwo") override final
Definition: Taus.cxx:227
ST::SUSYObjDef_xAOD::m_metDoSetMuonJetEMScale
bool m_metDoSetMuonJetEMScale
Definition: SUSYObjDef_xAOD.h:572
ST::SUSYObjDef_xAOD::m_v_trigs18_cache_diLep
std::vector< std::string > m_v_trigs18_cache_diLep
Definition: SUSYObjDef_xAOD.h:467
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
ST::SUSYObjDef_xAOD::BtagSF
float BtagSF(const xAOD::JetContainer *jets) override final
Definition: Jets.cxx:791
ST::SUSYObjDef_xAOD::m_ZTagjetUncertaintiesTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_ZTagjetUncertaintiesTool
Definition: SUSYObjDef_xAOD.h:839
IAsgPhotonEfficiencyCorrectionTool::getEfficiencyScaleFactor
virtual CP::CorrectionCode getEfficiencyScaleFactor(const xAOD::Egamma &, double &) const =0
Get the "photon scale factor" as a return value.
checkFileSG.line
line
Definition: checkFileSG.py:75
ST::SUSYObjDef_xAOD::m_muBaselineEta
double m_muBaselineEta
Definition: SUSYObjDef_xAOD.h:697
ST::SUSYObjDef_xAOD::m_trigGlobalEffCorrTool_multiLep
asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionTool > m_trigGlobalEffCorrTool_multiLep
Definition: SUSYObjDef_xAOD.h:942
ST::SUSYObjDef_xAOD::IsTrackBJetContinuous
int IsTrackBJetContinuous(const xAOD::Jet &input) const override final
Definition: Jets.cxx:780
asg::AnaToolHandle::isUserConfigured
bool isUserConfigured() const noexcept
whether this tool handle has been configured by the user
ST::SUSYObjDef_xAOD::IsTruthBJet
bool IsTruthBJet(const xAOD::Jet &input) const override final
Definition: Truth.cxx:309
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
xAOD::Electron
Electron_v1 Electron
Definition of the current "egamma version".
Definition: Event/xAOD/xAODEgamma/xAODEgamma/Electron.h:17
xAOD::Egamma
Egamma_v1 Egamma
Definition of the current "egamma version".
Definition: Egamma.h:17
ST::SUSYObjDef_xAOD::m_jetTerm
std::string m_jetTerm
Definition: SUSYObjDef_xAOD.h:564
ST::SUSYObjDef_xAOD::m_trig2022combination_diPhoton
std::string m_trig2022combination_diPhoton
Definition: SUSYObjDef_xAOD.h:949
ST::SUSYObjDef_xAOD::m_trigNToys_diLep
int m_trigNToys_diLep
Definition: SUSYObjDef_xAOD.h:928
ST::SUSYObjDef_xAOD::m_triggerCacheMutex
std::mutex m_triggerCacheMutex
Definition: SUSYObjDef_xAOD.h:446
CP::IIsolationCorrectionTool::applySystematicVariation
virtual StatusCode applySystematicVariation(const CP::SystematicSet &systConfig)=0
effects: configure this tool for the given list of systematic variations.
ST::SUSYObjDef_xAOD::m_jetUncertaintiesCalibArea
std::string m_jetUncertaintiesCalibArea
Definition: SUSYObjDef_xAOD.h:527
asg::AsgMetadataTool::beginEvent
virtual StatusCode beginEvent()
Function called when a new events is loaded.
Definition: AsgMetadataTool.cxx:196
ST::SUSYObjDef_xAOD::m_prwActualMu2022File
std::string m_prwActualMu2022File
Definition: SUSYObjDef_xAOD.h:611
ST::SUSYObjDef_xAOD::m_jesConfigAFII
std::string m_jesConfigAFII
Definition: SUSYObjDef_xAOD.h:848
ST::SUSYObjDef_xAOD::m_BtagSystStrategy
std::string m_BtagSystStrategy
Definition: SUSYObjDef_xAOD.h:671
get_generator_info.result
result
Definition: get_generator_info.py:21
ST::SUSYObjDef_xAOD::m_tauIdBaseline
std::string m_tauIdBaseline
Definition: SUSYObjDef_xAOD.h:648
ST::SUSYObjDef_xAOD::IsSignalElectron
bool IsSignalElectron(const xAOD::Electron &input, const float etcut, const float d0sigcut, const float z0cut, const float etacut=DUMMYDEF) const override final
Definition: Electrons.cxx:360
hotSpotInTAG.suffix
string suffix
Definition: hotSpotInTAG.py:186
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:392
xAOD::JetAttribute::LArQuality
@ LArQuality
Definition: JetAttributes.h:83
LikeEnum::VeryLoose
@ VeryLoose
Definition: LikelihoodEnums.h:11
runLayerRecalibration.chain
chain
Definition: runLayerRecalibration.py:175
NuREle
@ NuREle
Definition: TruthClasses.h:72
ST::SUSYObjDef_xAOD::m_showerType
int m_showerType
Definition: SUSYObjDef_xAOD.h:800
ST::SUSYObjDef_xAOD::m_elecChargeEffCorrTool
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecChargeEffCorrTool
Definition: SUSYObjDef_xAOD.h:903
ST::SUSYObjDef_xAOD::prepareLRTMuons
StatusCode prepareLRTMuons(const xAOD::MuonContainer *inMuons, xAOD::MuonContainer *copy) const override final
Definition: Muons.cxx:73
ST::SUSYObjDef_xAOD::m_photonTrigEffTools
ToolHandleArray< IAsgPhotonEfficiencyCorrectionTool > m_photonTrigEffTools
Definition: SUSYObjDef_xAOD.h:899
ST::SUSYObjDef_xAOD::m_acc_eleId
SG::ConstAccessor< char > m_acc_eleId
Definition: SUSYObjDef_xAOD.h:982
ORUtils::ToolBox::eleMuORT
OverlapHandle_t eleMuORT
Definition: ToolBox.h:70
ST::SUSYObjDef_xAOD::JVT_SFsys
double JVT_SFsys(const xAOD::JetContainer *jets, const CP::SystematicSet &systConfig) override final
Definition: Jets.cxx:1000
ST::SUSYObjDef_xAOD::m_mu_id_support
int m_mu_id_support
Definition: SUSYObjDef_xAOD.h:623
ST::SUSYObjDef_xAOD::m_eleIsoHighPt_WP
std::string m_eleIsoHighPt_WP
Definition: SUSYObjDef_xAOD.h:650
ST::SUSYObjDef_xAOD::m_BtagWP
std::string m_BtagWP
Definition: SUSYObjDef_xAOD.h:667
ST::SUSYObjDef_xAOD::m_eleAllowRun3TrigSFFallback
bool m_eleAllowRun3TrigSFFallback
Definition: SUSYObjDef_xAOD.h:692
ST::SUSYObjDef_xAOD::m_egammaCalibTool
asg::AnaToolHandle< CP::IEgammaCalibrationAndSmearingTool > m_egammaCalibTool
Combined electron collection.
Definition: SUSYObjDef_xAOD.h:886
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:24
ST::SUSYObjDef_xAOD::GetTotalMuonTriggerSF
double GetTotalMuonTriggerSF(const xAOD::MuonContainer &sfmuons, const std::string &trigExpr) override final
Definition: Muons.cxx:544
ST::SUSYObjDef_xAOD::m_trig2016combination_diPhoton
std::string m_trig2016combination_diPhoton
Definition: SUSYObjDef_xAOD.h:946
xAOD::JetAttribute::FracSamplingMax
@ FracSamplingMax
Definition: JetAttributes.h:116
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
ST::SUSYObjDef_xAOD::m_acc_eleIdBaseline
SG::ConstAccessor< char > m_acc_eleIdBaseline
Definition: SUSYObjDef_xAOD.h:981
CP::IMuonTriggerScaleFactors::getTriggerEfficiency
virtual CorrectionCode getTriggerEfficiency(const xAOD::Muon &mu, Double_t &efficiency, const std::string &trigger, Bool_t dataType) const =0
ST::SUSYObjDef_xAOD::split
const std::vector< std::string > split(const std::string &s, const std::string &delim) const
Definition: SUSYObjDef_xAOD.cxx:1788
ST::SUSYObjDef_xAOD::prompt_electrons
const xAOD::ElectronContainer * prompt_electrons
Definition: SUSYObjDef_xAOD.h:210
ST::SUSYObjDef_xAOD::m_metDoRemoveMuonJets
bool m_metDoRemoveMuonJets
Definition: SUSYObjDef_xAOD.h:573
CP::make_systematics_vector
std::vector< CP::SystematicSet > make_systematics_vector(const SystematicSet &systematics)
utility functions for working with systematics
Definition: SystematicsUtil.cxx:25
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
ST::SUSYObjDef_xAOD::m_outMETTerm
std::string m_outMETTerm
Definition: SUSYObjDef_xAOD.h:570
WBosonLRSM
@ WBosonLRSM
Definition: TruthClasses.h:71
ST::SUSYObjDef_xAOD::m_label_truthKey
SG::ReadDecorHandleKey< xAOD::JetContainer > m_label_truthKey
Definition: SUSYObjDef_xAOD.h:842
CP::IJvtEfficiencyTool::getEfficiencyScaleFactor
virtual CorrectionCode getEfficiencyScaleFactor(const xAOD::Jet &jet, float &sf) const =0
Calculate the efficiency scale factor for the provided jet.
ST::SUSYObjDef_xAOD::m_conf_to_prop
std::map< std::string, std::string > m_conf_to_prop
Definition: SUSYObjDef_xAOD.h:436
ST::SUSYObjDef_xAOD::m_orMuJetInnerDR
double m_orMuJetInnerDR
Definition: SUSYObjDef_xAOD.h:771
ST::SUSYObjDef_xAOD::m_muonEfficiencyBMHighPtSFTool
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonEfficiencyBMHighPtSFTool
Definition: SUSYObjDef_xAOD.h:861
CP::IIsolationCorrectionTool::applyCorrection
virtual CP::CorrectionCode applyCorrection(xAOD::Egamma &)=0
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
ST::SUSYObjDef_xAOD::m_muBaselinePt
double m_muBaselinePt
Definition: SUSYObjDef_xAOD.h:696
ST::SUSYObjDef_xAOD::m_pmgSHnjetWeighterWZ
asg::AnaToolHandle< IWeightTool > m_pmgSHnjetWeighterWZ
Definition: SUSYObjDef_xAOD.h:973
IMETMaker::rebuildJetMET
virtual StatusCode rebuildJetMET(const std::string &metJetKey, const std::string &metSoftKey, xAOD::MissingETContainer *metCont, const xAOD::JetContainer *jets, const xAOD::MissingETContainer *metCoreCont, xAOD::MissingETAssociationHelper &helper, bool doJetJVT)=0
ST::SUSYObjDef_xAOD::IsBJet
bool IsBJet(const xAOD::Jet &input) const override final
Definition: Jets.cxx:736
ST::SUSYObjDef_xAOD::m_v_trigs15_cache_multiLep
std::vector< std::string > m_v_trigs15_cache_multiLep
Definition: SUSYObjDef_xAOD.h:470
ST::SUSYObjDef_xAOD::m_legsPerTool
std::map< std::string, std::string > m_legsPerTool
Definition: SUSYObjDef_xAOD.h:816
ST::SUSYObjDef_xAOD::m_ZTagUncConfig
std::string m_ZTagUncConfig
Definition: SUSYObjDef_xAOD.h:554
ST::SUSYObjDef_xAOD::m_orDoElBjet
bool m_orDoElBjet
Definition: SUSYObjDef_xAOD.h:757
IAsgDeadHVCellRemovalTool::accept
virtual bool accept(const xAOD::Egamma *part) const =0
ST::SUSYObjDef_xAOD::m_tauSmearingToolGenerator
std::string m_tauSmearingToolGenerator
Definition: SUSYObjDef_xAOD.h:726
TauAnalysisTools::JETIDRNNTIGHT
@ JETIDRNNTIGHT
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:22
ST::MET_TST
@ MET_TST
Definition: ISUSYObjDef_xAODTool.h:81
ST::SUSYObjDef_xAOD::m_trigGlobalEffCorrTool_diPhoton
asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionTool > m_trigGlobalEffCorrTool_diPhoton
Definition: SUSYObjDef_xAOD.h:950
asg::AnaToolHandle::retrieve
StatusCode retrieve()
initialize the tool
ST::SUSYObjDef_xAOD::m_photonBaselineCrackVeto
bool m_photonBaselineCrackVeto
Definition: SUSYObjDef_xAOD.h:715
IMETMaker::markInvisible
virtual StatusCode markInvisible(const xAOD::IParticleContainer *collection, xAOD::MissingETAssociationHelper &helper, xAOD::MissingETContainer *metCont)=0
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_reco
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_reco
Combined muon collection.
Definition: SUSYObjDef_xAOD.h:870
SG::VIEW_ELEMENTS
@ VIEW_ELEMENTS
this data object is a view, it does not own its elmts
Definition: OwnershipPolicy.h:18
ST::SUSYObjDef_xAOD::m_useCommonPRWFiles
bool m_useCommonPRWFiles
Definition: SUSYObjDef_xAOD.h:597
ST::SUSYObjDef_xAOD::getTauConfig
void getTauConfig(const std::string &tauConfigPath, std::vector< float > &pT_window, std::vector< float > &eta_window, bool &eleOLR, bool &muVeto, bool &muOLR) const
Definition: SUSYObjDef_xAOD.cxx:1812
AthAnalysisHelper::setProperty
static StatusCode setProperty(const std::string &name, const std::string &property, const W &value, bool override=true)
Definition: AthAnalysisHelper.h:79
ST::SUSYObjDef_xAOD::m_elecSelLikelihood
asg::AnaToolHandle< IAsgElectronLikelihoodTool > m_elecSelLikelihood
Definition: SUSYObjDef_xAOD.h:887
ST::SUSYObjDef_xAOD::GetTriggerOR
std::vector< std::string > GetTriggerOR(const std::string &trigExpr) const
Definition: Trigger.cxx:322
ST::SUSYObjDef_xAOD::FillMuon
StatusCode FillMuon(xAOD::Muon &input, const float ptcut, const float etacut) override final
Definition: Muons.cxx:205
ST::SUSYObjDef_xAOD::m_orMuJetPtRatio
double m_orMuJetPtRatio
Definition: SUSYObjDef_xAOD.h:769
CP::SystematicSet::size
size_t size() const
returns: size of the set
Definition: SystematicSet.h:71
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_trig_mixLep
std::vector< asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > > m_elecEfficiencySFTool_trig_mixLep
Definition: SUSYObjDef_xAOD.h:878
ST::SUSYObjDef_xAOD::GetTriggerTokens
void GetTriggerTokens(std::string, std::vector< std::string > &, std::vector< std::string > &, std::vector< std::string > &, std::vector< std::string > &, std::vector< std::string > &) const
Definition: Trigger.cxx:340
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
ST::SUSYObjDef_xAOD::GetTotalMuonSF
double GetTotalMuonSF(const xAOD::MuonContainer &muons, const bool recoSF=true, const bool isoSF=true, const std::string &trigExpr="HLT_mu20_iloose_L1MU15_OR_HLT_mu50", const bool bmhptSF=true) override final
Definition: Muons.cxx:599
ST::EventWeight
@ EventWeight
Definition: ISUSYObjDef_xAODTool.h:84
IMETSystematicsTool::applyCorrection
virtual CP::CorrectionCode applyCorrection(xAOD::MissingET &met, const xAOD::MissingETAssociationHelper &helper) const =0
TauAnalysisTools::JETIDRNNMEDIUM
@ JETIDRNNMEDIUM
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:21
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
IsoCloseByCorrectionTest.WP
WP
Definition: IsoCloseByCorrectionTest.py:56
IWeightTool::getWeight
virtual double getWeight() const =0
returns: the value that was calculated from the usual Athena storegate
ST::SUSYObjDef_xAOD::m_jetNNJvtMomentTool
asg::AnaToolHandle< JetPileupTag::JetVertexNNTagger > m_jetNNJvtMomentTool
Definition: SUSYObjDef_xAOD.h:828
ST::SUSYObjDef_xAOD::IsBadMuon
bool IsBadMuon(const xAOD::Muon &input, const float qopcut) const override final
Definition: Muons.cxx:402
ST::SUSYObjDef_xAOD::lrt_muons
const xAOD::MuonContainer * lrt_muons
Definition: SUSYObjDef_xAOD.h:205
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
ST::SUSYObjDef_xAOD::m_EigenvectorReductionC
std::string m_EigenvectorReductionC
Definition: SUSYObjDef_xAOD.h:673
StateLessPT_NewConfig.Format
Format
Definition: StateLessPT_NewConfig.py:146
CP::IJvtEfficiencyTool::getInefficiencyScaleFactor
virtual CorrectionCode getInefficiencyScaleFactor(const xAOD::Jet &jet, float &sf) const =0
Calculate the inefficiency scale factor for the provided jet.
ST::SUSYObjDef_xAOD::m_fJvtConfigRun2
std::string m_fJvtConfigRun2
Definition: SUSYObjDef_xAOD.h:744
ST::SUSYObjDef_xAOD::m_doElIsoSignal
bool m_doElIsoSignal
Definition: SUSYObjDef_xAOD.h:785
PATCore::ParticleDataType::Fast
@ Fast
Definition: PATCoreEnums.h:22
ST::SUSYObjDef_xAOD::m_photonTriggerSFTool
asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > m_photonTriggerSFTool
Definition: SUSYObjDef_xAOD.h:894
ST::SUSYObjDef_xAOD::m_isoBaselineTool
asg::AnaToolHandle< CP::IIsolationSelectionTool > m_isoBaselineTool
Definition: SUSYObjDef_xAOD.h:961
ST::SUSYObjDef_xAOD::m_elecTrigEffTools
ToolHandleArray< IAsgElectronEfficiencyCorrectionTool > m_elecTrigEffTools
Definition: SUSYObjDef_xAOD.h:881
ST::SUSYObjDef_xAOD::m_JvtConfigRun2
std::string m_JvtConfigRun2
Definition: SUSYObjDef_xAOD.h:734
ST::SUSYObjDef_xAOD::m_tauSmearingTool
asg::AnaToolHandle< TauAnalysisTools::ITauSmearingTool > m_tauSmearingTool
Definition: SUSYObjDef_xAOD.h:907
ST::SUSYObjDef_xAOD::m_muPt
double m_muPt
Definition: SUSYObjDef_xAOD.h:698
ST::SUSYObjDef_xAOD::m_v_trigs17_cache_singleEle
std::vector< std::string > m_v_trigs17_cache_singleEle
Definition: SUSYObjDef_xAOD.h:454
TauAnalysisTools::ITauSmearingTool::applyCorrection
virtual CP::CorrectionCode applyCorrection(xAOD::TauJet &xTau) const =0
Declare the interface that the class provides.
ST::SUSYObjDef_xAOD::m_jetInputType
int m_jetInputType
Definition: SUSYObjDef_xAOD.h:514
ST::SUSYObjDef_xAOD::IsCosmicMuon
bool IsCosmicMuon(const xAOD::Muon &input, const float z0cut, const float d0cut) const override final
Definition: Muons.cxx:441
xAOD::TrackingHelpers::d0significance
double d0significance(const xAOD::TrackParticle *tp, double d0_uncert_beam_spot_2)
Definition: TrackParticlexAODHelpers.cxx:42
ST::SUSYObjDef_xAOD::m_el_iso_support
std::vector< std::string > m_el_iso_support
Definition: SUSYObjDef_xAOD.h:625
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
xAOD::TruthEventBase_v1::truthParticle
const TruthParticle * truthParticle(size_t index) const
Get a pointer to one of the truth particles.
Definition: TruthEventBase_v1.cxx:50
asg::AnaToolHandle::setTypeAndName
void setTypeAndName(const std::string &val_typeAndName)
set the value of type and name
ORUtils::recommendedTools
StatusCode recommendedTools(const ORFlags &flags, ToolBox &toolBox)
Pre-configured standard recommended OR tools.
Definition: OverlapRemovalInit.cxx:50
ST::SUSYObjDef_xAOD::m_trig2015combination_singleLep
std::string m_trig2015combination_singleLep
Definition: SUSYObjDef_xAOD.h:922
ST::SUSYObjDef_xAOD::configFromFile
void configFromFile(bool &property, const std::string &propname, TEnv &rEnv, bool defaultValue)
Definition: SUSYObjDef_xAOD.cxx:1245
skel.it
it
Definition: skel.GENtoEVGEN.py:396
CP::IPileupReweightingTool::GetSumOfEventWeights
virtual Double_t GetSumOfEventWeights(Int_t channel)=0
possible alternative to using the EventBookkeepers info ... assuming you made your PRW Config file!...
ST::SUSYObjDef_xAOD::m_metRemoveOverlappingCaloTaggedMuons
bool m_metRemoveOverlappingCaloTaggedMuons
Definition: SUSYObjDef_xAOD.h:571
ST::SUSYObjDef_xAOD::m_metMaker
asg::AnaToolHandle< IMETMaker > m_metMaker
Definition: SUSYObjDef_xAOD.h:918
ST::SUSYObjDef_xAOD::FillElectron
StatusCode FillElectron(xAOD::Electron &input, const float etcut, const float etacut) override final
Definition: Electrons.cxx:221
ST::SUSYObjDef_xAOD::m_trig2018combination_diPhoton
std::string m_trig2018combination_diPhoton
Definition: SUSYObjDef_xAOD.h:948
ST::SUSYObjDef_xAOD::m_trigNToys_diPhoton
int m_trigNToys_diPhoton
Definition: SUSYObjDef_xAOD.h:944
CP::SystematicSet
Class to wrap a set of SystematicVariations.
Definition: SystematicSet.h:31
ST::SUSYObjDef_xAOD::m_trigMatchScoringTool
asg::AnaToolHandle< Trig::IMatchScoringTool > m_trigMatchScoringTool
Definition: SUSYObjDef_xAOD.h:955
ST::SUSYObjDef_xAOD::GetTotalElectronSF
float GetTotalElectronSF(const xAOD::ElectronContainer &electrons, const bool recoSF=true, const bool idSF=true, const bool triggerSF=true, const bool isoSF=true, const std::string &trigExpr="singleLepton", const bool ecidsSF=false, const bool cidSF=false) override final
Definition: Electrons.cxx:623
ST::SUSYObjDef_xAOD::m_TopTaggerTool
asg::AnaToolHandle< JSSWTopTaggerDNN > m_TopTaggerTool
Definition: SUSYObjDef_xAOD.h:836
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
ST::SUSYObjDef_xAOD::m_orBtagWP
std::string m_orBtagWP
Definition: SUSYObjDef_xAOD.h:774
ST::SUSYObjDef_xAOD::m_elePt
double m_elePt
Definition: SUSYObjDef_xAOD.h:683
CP::IPileupReweightingTool::apply
virtual StatusCode apply(const xAOD::EventInfo &eventInfo, bool mu_dependent=true)=0
Decorates with: MC: PileupWeight (CombinedWeight[*UnrepresentedDataWeight if action=2]),...
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
CP::IIsolationCloseByCorrectionTool::getCloseByIsoCorrection
virtual CorrectionCode getCloseByIsoCorrection(const EventContext &ctx, const xAOD::ElectronContainer *Electrons=nullptr, const xAOD::MuonContainer *Muons=nullptr, const xAOD::PhotonContainer *Photons=nullptr) const =0
downloadSingle.dataType
string dataType
Definition: downloadSingle.py:18
asg::AsgMetadataTool::inputMetaStore
MetaStorePtr_t inputMetaStore() const
Accessor for the input metadata store.
Definition: AsgMetadataTool.cxx:88
TauAnalysisTools::ITauSelectionTool::accept
virtual asg::AcceptData accept(const xAOD::IParticle *p) const =0
Get the decision using a generic IParticle pointer.
ParticleTest.tp
tp
Definition: ParticleTest.py:25
TauAnalysisTools::JETIDRNNLOOSE
@ JETIDRNNLOOSE
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:20
ST::SUSYObjDef_xAOD::m_muId
int m_muId
Definition: SUSYObjDef_xAOD.h:643
ST::SUSYObjDef_xAOD::m_photonIso_WP
std::string m_photonIso_WP
Definition: SUSYObjDef_xAOD.h:659
ST::SUSYObjDef_xAOD::prepareLRTElectrons
StatusCode prepareLRTElectrons(const xAOD::ElectronContainer *inMuons, xAOD::ElectronContainer *copy) const override final
Definition: Electrons.cxx:90
DataVector::get
const T * get(size_type n) const
Access an element, as an rvalue.
ST::SUSYObjDef_xAOD::m_fJvtEtaMin
double m_fJvtEtaMin
Definition: SUSYObjDef_xAOD.h:743
ST::SUSYObjDef_xAOD::m_v_trigs18_cache_singleLep
std::vector< std::string > m_v_trigs18_cache_singleLep
Definition: SUSYObjDef_xAOD.h:461
CP::SystematicSet::name
std::string name() const
returns: the systematics joined into a single string.
Definition: SystematicSet.cxx:278
ST::SUSYObjDef_xAOD::GetSignalElecSF
float GetSignalElecSF(const xAOD::Electron &el, const bool recoSF=true, const bool idSF=true, const bool triggerSF=true, const bool isoSF=true, const std::string &trigExpr="singleLepton", const bool ecidsSF=false, const bool cidSF=false) override final
Definition: Electrons.cxx:418
ST::SUSYObjDef_xAOD::m_doPhIsoSignal
bool m_doPhIsoSignal
Definition: SUSYObjDef_xAOD.h:786
xAOD::EventInfo_v1::beamPosSigmaX
float beamPosSigmaX() const
The width of the beam spot in the X direction.
ST::SUSYObjDef_xAOD::m_muonTTVAEfficiencySFTool
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonTTVAEfficiencySFTool
Definition: SUSYObjDef_xAOD.h:862
ST::SUSYObjDef_xAOD::m_el_iso_fallback
std::map< std::string, std::string > m_el_iso_fallback
Definition: SUSYObjDef_xAOD.h:629
ANA_MSG_ERROR
#define ANA_MSG_ERROR(xmsg)
Macro printing error messages.
Definition: Control/AthToolSupport/AsgMessaging/AsgMessaging/MessageCheck.h:294
ST::SUSYObjDef_xAOD::m_force_noElId
bool m_force_noElId
Definition: SUSYObjDef_xAOD.h:518
PhotonConv
@ PhotonConv
Definition: TruthClasses.h:59
CP::IMuonCalibrationAndSmearingTool::applyCorrection
virtual CorrectionCode applyCorrection(xAOD::Muon &mu) const =0
Declare the interface that the class provides.
xAOD::ShallowAuxContainer::name
const char * name() const
Get the name of the container instance.
Definition: ShallowAuxContainer.cxx:595
IBTaggingSelectionTool::getTaggerWeight
virtual CP::CorrectionCode getTaggerWeight(const xAOD::Jet &jet, double &tagweight) const =0
ST::SUSYObjDef_xAOD::m_mubaselined0sig
double m_mubaselined0sig
Definition: SUSYObjDef_xAOD.h:702
ST::SUSYObjDef_xAOD::m_BtagMinPt
double m_BtagMinPt
Definition: SUSYObjDef_xAOD.h:669
LArG4GenerateShowerLib.condition
condition
Definition: LArG4GenerateShowerLib.py:19
ST::SUSYObjDef_xAOD::m_commonPRWFileMC21a
std::string m_commonPRWFileMC21a
Definition: SUSYObjDef_xAOD.h:601
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:158
xAOD::numberOfPixelHits
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
Definition: TrackingPrimitives.h:259
ST::SUSYObjDef_xAOD::m_prwActualMu2024File
std::string m_prwActualMu2024File
Definition: SUSYObjDef_xAOD.h:613
CP::IIsolationSelectionTool::accept
virtual asg::AcceptData accept(const xAOD::Photon &x) const =0
Declare the interface that the class provides.
asg::AsgTool::getProperty
const T * getProperty(const std::string &name) const
Get one of the tool's properties.
ST::SUSYObjDef_xAOD::m_trkJetsyst
bool m_trkJetsyst
Definition: SUSYObjDef_xAOD.h:582
ST::SUSYObjDef_xAOD::IsSignalPhoton
bool IsSignalPhoton(const xAOD::Photon &input, const float ptcut, const float etacut=DUMMYDEF) const override final
Definition: Photons.cxx:164
IMETSignificance::GetSignificance
virtual double GetSignificance() const =0
ST::SUSYObjDef_xAOD::m_photonEta
double m_photonEta
Definition: SUSYObjDef_xAOD.h:713
xAOD::numberOfTRTHits
@ numberOfTRTHits
number of TRT hits [unit8_t].
Definition: TrackingPrimitives.h:275
ST::SUSYObjDef_xAOD::m_orDoTau
bool m_orDoTau
Overlap removal options.
Definition: SUSYObjDef_xAOD.h:750
hotSpotInTAG.amiTag
amiTag
Definition: hotSpotInTAG.py:102
ST::SUSYObjDef_xAOD::m_v_trigs18_cache_singleEle
std::vector< std::string > m_v_trigs18_cache_singleEle
Definition: SUSYObjDef_xAOD.h:455
xAOD::EgammaParameters::BADCLUSELECTRON
const uint32_t BADCLUSELECTRON
Definition: EgammaDefs.h:116
ST::SUSYObjDef_xAOD::m_prwTool
asg::AnaToolHandle< CP::IPileupReweightingTool > m_prwTool
Definition: SUSYObjDef_xAOD.h:965
ST::SUSYObjDef_xAOD::m_muBaselineIso_WP
std::string m_muBaselineIso_WP
Definition: SUSYObjDef_xAOD.h:661
ST::SUSYObjDef_xAOD::m_trig2016combination_multiLep
std::string m_trig2016combination_multiLep
Definition: SUSYObjDef_xAOD.h:938
ST::SUSYObjDef_xAOD::m_inputMETSuffix
std::string m_inputMETSuffix
Definition: SUSYObjDef_xAOD.h:566
ST::SUSYObjDef_xAOD::m_WTaggerTool
asg::AnaToolHandle< SmoothedWZTagger > m_WTaggerTool
Definition: SUSYObjDef_xAOD.h:834
asg::AsgMetadataTool::m_beginInputFileCalled
bool m_beginInputFileCalled
Flag helping to discover when the tool misses the opening of the first input file.
Definition: AsgMetadataTool.h:126
CP::IEgammaCalibrationAndSmearingTool::applyCorrection
virtual CP::CorrectionCode applyCorrection(xAOD::Egamma &) const =0
SG::ConstAccessor
Helper class to provide constant type-safe access to aux data.
Definition: ConstAccessor.h:55
ST::SUSYObjDef_xAOD::m_eleConfigBaseline
std::string m_eleConfigBaseline
Definition: SUSYObjDef_xAOD.h:640
ST::SUSYObjDef_xAOD::GetPrimVtx
const xAOD::Vertex * GetPrimVtx() const override final
Definition: SUSYObjDef_xAOD.cxx:2877
ST::ISUSYObjDef_xAODTool::Undefined
@ Undefined
Definition: ISUSYObjDef_xAODTool.h:476
met::JETTRK
@ JETTRK
Definition: IMETSystematicsTool.h:50
asg::AsgMetadataTool::endInputFile
virtual StatusCode endInputFile()
Function called when the currently open input file got completely processed.
Definition: AsgMetadataTool.cxx:188
ST::SUSYObjDef_xAOD::m_v_trigs22_cache_singleLep
std::vector< std::string > m_v_trigs22_cache_singleLep
Definition: SUSYObjDef_xAOD.h:462
ST::SUSYObjDef_xAOD::m_bTaggingCalibrationFilePath
std::string m_bTaggingCalibrationFilePath
Definition: SUSYObjDef_xAOD.h:814
NuRTau
@ NuRTau
Definition: TruthClasses.h:74
asg::AsgMetadataTool::m_outputMetaStore
MetaStore_t m_outputMetaStore
Object accessing the output metadata store.
Definition: AsgMetadataTool.h:121
ST::SUSYObjDef_xAOD::m_eled0sig
double m_eled0sig
Definition: SUSYObjDef_xAOD.h:686
ST::SUSYObjDef_xAOD::m_v_trigs22_cache_singleEle
std::vector< std::string > m_v_trigs22_cache_singleEle
Definition: SUSYObjDef_xAOD.h:456
ORUtils::ToolBox::eleFatJetORT
OverlapHandle_t eleFatJetORT
Definition: ToolBox.h:79
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ST::SUSYObjDef_xAOD::m_metDoMuonEloss
bool m_metDoMuonEloss
Definition: SUSYObjDef_xAOD.h:575
ST::SUSYObjDef_xAOD::m_photonTrigSFTools
ToolHandleArray< IAsgPhotonEfficiencyCorrectionTool > m_photonTrigSFTools
Definition: SUSYObjDef_xAOD.h:898
ST::SUSYObjDef_xAOD::m_orDoFatjets
bool m_orDoFatjets
Definition: SUSYObjDef_xAOD.h:780
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
ST::SUSYObjDef_xAOD::m_trigMatchingTool
asg::AnaToolHandle< Trig::IMatchingTool > m_trigMatchingTool
Definition: SUSYObjDef_xAOD.h:954
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
ST::SUSYObjDef_xAOD::m_jetUncertaintiesPDSmearTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_jetUncertaintiesPDSmearTool
Definition: SUSYObjDef_xAOD.h:822
ST::SUSYObjDef_xAOD::FillJet
StatusCode FillJet(xAOD::Jet &input, const bool doCalib=true, bool isFat=false, bool doLargeRdecorations=false) override final
Definition: Jets.cxx:384
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
beamspotman.tokens
tokens
Definition: beamspotman.py:1284
CP::SystematicVariation
Definition: SystematicVariation.h:47
ZBoson
@ ZBoson
Definition: TruthClasses.h:67
ST::BTag
@ BTag
Definition: ISUSYObjDef_xAODTool.h:80
ST::SUSYObjDef_xAOD::IsSignalMuon
bool IsSignalMuon(const xAOD::Muon &input, const float ptcut, const float d0sigcut, const float z0cut, const float etacut=DUMMYDEF) const override final
Definition: Muons.cxx:341
ST::SUSYObjDef_xAOD::m_elebaselined0sig
double m_elebaselined0sig
Definition: SUSYObjDef_xAOD.h:688
python.AtlRunQueryAMI.year
year
Definition: AtlRunQueryAMI.py:226
Trig::TrigDecisionToolCore::features
FeatureContainer features(const Trig::ChainGroup *group, unsigned int condition=TrigDefs::Physics) const
Runs 1, 2.
Definition: DecisionAccess.cxx:92
xAOD::IParticle
Class providing the definition of the 4-vector interface.
Definition: Event/xAOD/xAODBase/xAODBase/IParticle.h:41
ST::SUSYObjDef_xAOD::m_debug
bool m_debug
Definition: SUSYObjDef_xAOD.h:533
ST::SUSYObjDef_xAOD::m_elecLRTORTool
asg::AnaToolHandle< CP::IElectronLRTOverlapRemovalTool > m_elecLRTORTool
Definition: SUSYObjDef_xAOD.h:882
TauAnalysisTools::JETIDNONE
@ JETIDNONE
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:14
asg::AnaToolHandle::setProperty
StatusCode setProperty(const std::string &property, const T2 &value)
set the given property of the tool.
xAOD::JetInput::typeName
const std::string & typeName(Type id)
Definition: JetContainerInfo.cxx:199
ST::SUSYObjDef_xAOD::m_trig2017combination_diPhoton
std::string m_trig2017combination_diPhoton
Definition: SUSYObjDef_xAOD.h:947
x
#define x
ST::SUSYObjDef_xAOD::GetSignalPhotonSFsys
double GetSignalPhotonSFsys(const xAOD::Photon &ph, const CP::SystematicSet &systConfig, const bool effSF=true, const bool isoSF=true, const bool triggerSF=false) override final
Definition: Photons.cxx:244
ST::SUSYObjDef_xAOD::m_doMuIsoSignal
bool m_doMuIsoSignal
Definition: SUSYObjDef_xAOD.h:787
ST::SUSYObjDef_xAOD::m_muonTerm
std::string m_muonTerm
Definition: SUSYObjDef_xAOD.h:565
ST::SUSYObjDef_xAOD::m_mu_iso_support
std::vector< std::string > m_mu_iso_support
Definition: SUSYObjDef_xAOD.h:626
ST::SUSYObjDef_xAOD::m_tau_id_support
std::vector< std::string > m_tau_id_support
Definition: SUSYObjDef_xAOD.h:624
PATCore::ParticleDataType::Data
@ Data
Definition: PATCoreEnums.h:22
HepMC::is_same_particle
bool is_same_particle(const T1 &p1, const T2 &p2)
Method to establish if two particles in the GenEvent actually represent the same particle.
Definition: MagicNumbers.h:367
xAOD::JetInput::LCTopo
@ LCTopo
Definition: JetContainerInfo.h:55
ST::SUSYObjDef_xAOD::m_muCosmicd0
double m_muCosmicd0
Definition: SUSYObjDef_xAOD.h:706
xAOD::numberOfBLayerHits
@ numberOfBLayerHits
these are the hits in the first pixel layer, i.e.
Definition: TrackingPrimitives.h:231
mapkey::sys
@ sys
Definition: TElectronEfficiencyCorrectionTool.cxx:42
CP::IMuonLRTOverlapRemovalTool::checkOverlap
virtual void checkOverlap(const xAOD::MuonContainer &promptCollection, const xAOD::MuonContainer &lrtCollection, std::vector< bool > &promptMuonsSelectedToKeep, std::vector< bool > &lrtMuonsSelectedToKeep) const =0
check the overlap between the prompt and LRT muon collections.
Pythia8_A14_NNPDF23LO_forMGHT_EvtGen.ptcut
float ptcut
Definition: Pythia8_A14_NNPDF23LO_forMGHT_EvtGen.py:9
xAOD::Muon_v1
Class describing a Muon.
Definition: Muon_v1.h:38
ST::SUSYObjDef_xAOD::m_fatJetUncVars
std::string m_fatJetUncVars
Definition: SUSYObjDef_xAOD.h:540
ST::SUSYObjDef_xAOD::m_orDoBjet
bool m_orDoBjet
Definition: SUSYObjDef_xAOD.h:756
IMETMaker::rebuildMET
virtual StatusCode rebuildMET(const std::string &metKey, xAOD::Type::ObjectType metType, xAOD::MissingETContainer *metCont, const xAOD::IParticleContainer *collection, xAOD::MissingETAssociationHelper &helper, MissingETBase::UsageHandler::Policy objScale=MissingETBase::UsageHandler::PhysicsObject)=0
ST::SUSYObjDef_xAOD::m_eleEffMapFilePath
std::string m_eleEffMapFilePath
Definition: SUSYObjDef_xAOD.h:690
xAOD::EventInfo_v1::runNumber
uint32_t runNumber() const
The current event's run number.
ST::SUSYObjDef_xAOD::m_orDoPhoton
bool m_orDoPhoton
Definition: SUSYObjDef_xAOD.h:751
ST::SUSYObjDef_xAOD::m_tool_init
bool m_tool_init
Definition: SUSYObjDef_xAOD.h:558
asg::AnaToolHandle::declarePropertyFor
void declarePropertyFor(T2 *tool, const std::string &name, const std::string &description="")
declare as property on the given tool
XMLtoHeader.count
count
Definition: XMLtoHeader.py:85
ST::SUSYObjDef_xAOD::m_jetJvtMomentTool
asg::AnaToolHandle< JetVertexTaggerTool > m_jetJvtMomentTool
Definition: SUSYObjDef_xAOD.h:827
ST::SUSYObjDef_xAOD::m_eleIdBaseline
std::string m_eleIdBaseline
Definition: SUSYObjDef_xAOD.h:638
ST::SUSYObjDef_xAOD::m_eleTerm
std::string m_eleTerm
Definition: SUSYObjDef_xAOD.h:561
xAOD::MissingETAssociationMap_v1
Definition: MissingETAssociationMap_v1.h:29
ST::SUSYObjDef_xAOD::isVariation
bool isVariation(const CP::SystematicSet &syst) const
Definition: SUSYObjDef_xAOD.cxx:2096
ST::SUSYObjDef_xAOD::BtagSF_trkJet
float BtagSF_trkJet(const xAOD::JetContainer *trkjets) override final
Definition: Jets.cxx:872
PATCore::ParticleDataType::DataType
DataType
Definition: PATCoreEnums.h:22
ST::SUSYObjDef_xAOD::m_orToolbox
ORUtils::ToolBox m_orToolbox
Definition: SUSYObjDef_xAOD.h:970
ST::SUSYObjDef_xAOD::m_mcChannel
int m_mcChannel
Definition: SUSYObjDef_xAOD.h:595
ST::SUSYObjDef_xAOD::m_tauConfigPath
std::string m_tauConfigPath
Definition: SUSYObjDef_xAOD.h:722
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
WBoson
@ WBoson
Definition: TruthClasses.h:66
ST::SUSYObjDef_xAOD::m_LRTCollectionName
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_LRTCollectionName
Definition: SUSYObjDef_xAOD.h:477
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
ST::SUSYObjDef_xAOD::m_photonBaselineEta
double m_photonBaselineEta
Definition: SUSYObjDef_xAOD.h:712
TauAnalysisTools::ELEIDRNNLOOSE
@ ELEIDRNNLOOSE
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:33
xAOD::FileMetaData_v1::value
bool value(MetaDataType type, std::string &val) const
Get a pre-defined string value out of the object.
Definition: FileMetaData_v1.cxx:195
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
ST::SUSYObjDef_xAOD::m_v_trigs15_cache_singleEle
std::vector< std::string > m_v_trigs15_cache_singleEle
Definition: SUSYObjDef_xAOD.h:452
ST::SUSYObjDef_xAOD::m_muonLRTORTool
asg::AnaToolHandle< CP::IMuonLRTOverlapRemovalTool > m_muonLRTORTool
Definition: SUSYObjDef_xAOD.h:867
xAOD::FileMetaData_v1::simFlavour
@ simFlavour
Fast or Full sim [string].
Definition: FileMetaData_v1.h:76
ST::SUSYObjDef_xAOD::m_gammaTerm
std::string m_gammaTerm
Definition: SUSYObjDef_xAOD.h:562
FSRPhot
@ FSRPhot
Definition: TruthClasses.h:96
ST::SUSYObjDef_xAOD::m_commonPRWFileMC20d
std::string m_commonPRWFileMC20d
Definition: SUSYObjDef_xAOD.h:599
ST::SUSYObjDef_xAOD::GetInDetLargeD0GSFTracks
const xAOD::TrackParticleContainer & GetInDetLargeD0GSFTracks(const EventContext &ctx) const override final
Definition: SUSYObjDef_xAOD.cxx:3045
ORUtils::ToolBox::setGlobalProperty
StatusCode setGlobalProperty(const std::string &property, const T &value)
Apply a global property to all tools.
Definition: ToolBox.h:104
ST::SUSYObjDef_xAOD::m_acc_jetClean
SG::ConstAccessor< char > m_acc_jetClean
Definition: SUSYObjDef_xAOD.h:985
ST::SUSYObjDef_xAOD::m_JvtPtMax
double m_JvtPtMax
Definition: SUSYObjDef_xAOD.h:733
dqt_zlumi_pandas.weight
int weight
Definition: dqt_zlumi_pandas.py:189
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
PrepareReferenceFile.regex
regex
Definition: PrepareReferenceFile.py:43
ST::SUSYObjDef_xAOD::IsTrackBJet
bool IsTrackBJet(const xAOD::Jet &input) const override final
Definition: Jets.cxx:747
ST::SUSYObjDef_xAOD::m_btagEffTool_trkJet
asg::AnaToolHandle< IBTaggingEfficiencyTool > m_btagEffTool_trkJet
Definition: SUSYObjDef_xAOD.h:915
LArCellBinning_test.retval
def retval
Definition: LArCellBinning_test.py:112
xAOD::phi
setEt phi
Definition: TrigEMCluster_v1.cxx:29
ST::SUSYObjDef_xAOD::FillTrackJet
StatusCode FillTrackJet(xAOD::Jet &input) override final
Definition: Jets.cxx:608
ORUtils::ToolBox::muJetORT
OverlapHandle_t muJetORT
Definition: ToolBox.h:72
CP::IMuonSelectionTool::isBadMuon
virtual bool isBadMuon(const xAOD::Muon &) const =0
Returns true if a CB muon fails some loose quaility requirements designed to remove pathological trac...
ST::SUSYObjDef_xAOD::FJVT_SFsys
double FJVT_SFsys(const xAOD::JetContainer *jets, const CP::SystematicSet &systConfig) override final
Definition: Jets.cxx:1071
met::buildMETSum
StatusCode buildMETSum(const std::string &totalName, xAOD::MissingETContainer *metCont)
Definition: METHelpers.cxx:64
xAOD::EventInfo_v1::mcChannelNumber
uint32_t mcChannelNumber() const
The MC generator's channel number.
ST::SUSYObjDef_xAOD::m_v_trigs17_cache_diLep
std::vector< std::string > m_v_trigs17_cache_diLep
Definition: SUSYObjDef_xAOD.h:466
ST::SUSYObjDef_xAOD::m_trkJetPt
double m_trkJetPt
Definition: SUSYObjDef_xAOD.h:737
ST::SUSYObjDef_xAOD::m_slices
std::map< std::string, bool > m_slices
Definition: SUSYObjDef_xAOD.h:794
ST::SUSYObjDef_xAOD::m_orLinkOverlapObjects
bool m_orLinkOverlapObjects
Definition: SUSYObjDef_xAOD.h:778
PATCore::ParticleDataType::Full
@ Full
Definition: PATCoreEnums.h:22
ST::SUSYObjDef_xAOD::m_eleEffMapFilePathRun2
std::string m_eleEffMapFilePathRun2
Definition: SUSYObjDef_xAOD.h:691
xAOD::JetConstitScaleMomentum
@ JetConstitScaleMomentum
Definition: JetTypes.h:29
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_isoHighPt
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_isoHighPt
Definition: SUSYObjDef_xAOD.h:875
ST::SUSYObjDef_xAOD::m_trig2018combination_singleLep
std::string m_trig2018combination_singleLep
Definition: SUSYObjDef_xAOD.h:925
HiggsMSSM
@ HiggsMSSM
Definition: TruthClasses.h:69
ST::SUSYObjDef_xAOD::m_orBoostedMuonMaxConeSize
double m_orBoostedMuonMaxConeSize
Definition: SUSYObjDef_xAOD.h:767
ST::SUSYObjDef_xAOD::m_photonEfficiencySFTool
asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > m_photonEfficiencySFTool
Definition: SUSYObjDef_xAOD.h:892
ORUtils::ToolBox::eleJetORT
OverlapHandle_t eleJetORT
Definition: ToolBox.h:71
ST::Egamma
@ Egamma
Definition: ISUSYObjDef_xAODTool.h:75
CP::IMuonTriggerScaleFactors::getTriggerScaleFactor
virtual CorrectionCode getTriggerScaleFactor(const xAOD::MuonContainer &mucont, Double_t &triggersf, const std::string &trigger) const =0
ST::SUSYObjDef_xAOD::m_tau_trig_support
std::map< std::string, std::string > m_tau_trig_support
Definition: SUSYObjDef_xAOD.h:635
ST::SUSYObjDef_xAOD::m_trigGlobalEffCorrTool_diLep
asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionTool > m_trigGlobalEffCorrTool_diLep
Definition: SUSYObjDef_xAOD.h:934
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
ST::SUSYObjDef_xAOD::m_WZTaggerCalibArea
std::string m_WZTaggerCalibArea
Definition: SUSYObjDef_xAOD.h:551
ST::SUSYObjDef_xAOD::m_isPHYSLITE
bool m_isPHYSLITE
Definition: SUSYObjDef_xAOD.h:796
ST::SUSYObjDef_xAOD::m_prwLcalcFiles
std::vector< std::string > m_prwLcalcFiles
Definition: SUSYObjDef_xAOD.h:608
ST::SUSYObjDef_xAOD::m_prwDataSF_DW
double m_prwDataSF_DW
Definition: SUSYObjDef_xAOD.h:617
ST::SUSYObjDef_xAOD::m_orDoBoostedMuon
bool m_orDoBoostedMuon
Definition: SUSYObjDef_xAOD.h:764
PhotonHelpers::passOQquality
bool passOQquality(const xAOD::Photon &ph)
Helper to ease the implemmantation of the pass Quality requirements.
Definition: PhotonHelpers.cxx:12
CP::CorrectionCode::OutOfValidityRange
@ OutOfValidityRange
Input object is out of validity range.
Definition: CorrectionCode.h:37
ST::SUSYObjDef_xAOD::m_el_id_support
std::vector< std::string > m_el_id_support
Definition: SUSYObjDef_xAOD.h:621
CP::CorrectionCode::Error
@ Error
Some error happened during the object correction.
Definition: CorrectionCode.h:36
ST::SUSYObjDef_xAOD::m_defaultJets
std::string m_defaultJets
Definition: SUSYObjDef_xAOD.h:802
ST::SUSYObjDef_xAOD::m_useBtagging
bool m_useBtagging
Definition: SUSYObjDef_xAOD.h:531
xAOD::JetAttribute::HECQuality
@ HECQuality
Definition: JetAttributes.h:80
ST::SUSYObjDef_xAOD::m_ph_id_support
std::vector< std::string > m_ph_id_support
Definition: SUSYObjDef_xAOD.h:622
ST::Photon
@ Photon
Definition: ISUSYObjDef_xAODTool.h:77
met
Definition: IMETSignificance.h:24
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
ST::SUSYObjDef_xAOD::SUSYToolsInit
StatusCode SUSYToolsInit()
Definition: SUSYToolsInit.cxx:109
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_trigEff_mixLep
std::vector< asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > > m_elecEfficiencySFTool_trigEff_mixLep
Definition: SUSYObjDef_xAOD.h:879
met::addGhostMuonsToJets
void addGhostMuonsToJets(const xAOD::MuonContainer &muons, xAOD::JetContainer &jets)
Definition: METHelpers.cxx:34
ST::SUSYObjDef_xAOD::m_TopTaggerCalibArea
std::string m_TopTaggerCalibArea
Definition: SUSYObjDef_xAOD.h:552
ST::SUSYObjDef_xAOD::isWeight
bool isWeight(const CP::SystematicSet &systSet) const
Definition: SUSYObjDef_xAOD.cxx:2085
jet
Definition: JetCalibTools_PlotJESFactors.cxx:23
ST::SUSYObjDef_xAOD::m_jetEta
double m_jetEta
Definition: SUSYObjDef_xAOD.h:730
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ST::SUSYObjDef_xAOD::m_fatJetUncConfig
std::string m_fatJetUncConfig
Definition: SUSYObjDef_xAOD.h:539
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
ST::SUSYObjDef_xAOD::IsBJetContinuous
int IsBJetContinuous(const xAOD::Jet &input) const override final
Definition: Jets.cxx:758
ST::SUSYObjDef_xAOD::GetRunNumber
unsigned int GetRunNumber() const override final
Definition: SUSYObjDef_xAOD.cxx:3017
IAsgSelectionTool::accept
virtual asg::AcceptData accept(const xAOD::IParticle *) const =0
The main accept method: the actual cuts are applied here.
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_id
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_id
Definition: SUSYObjDef_xAOD.h:871
CheckAppliedSFs.e3
e3
Definition: CheckAppliedSFs.py:264
SG::ReadDecorHandle
Handle class for reading a decoration on an object.
Definition: StoreGate/StoreGate/ReadDecorHandle.h:94
ST::SUSYObjDef_xAOD::readConfig
StatusCode readConfig() override final
Definition: SUSYObjDef_xAOD.cxx:1322
xAOD::BTagging_v1::pc
bool pc(const std::string &taggername, double &value) const
Definition: BTagging_v1.cxx:367
IAsgEGammaIsEMSelector::accept
virtual asg::AcceptData accept(const xAOD::IParticle *part) const =0
accept with pointer to IParticle so as to not hide the IAsgSelectionTool one
doubleTestComp.j1
j1
Definition: doubleTestComp.py:21
ST::SUSYObjDef_xAOD::m_tauConfigReader
TEnv m_tauConfigReader
Definition: SUSYObjDef_xAOD.h:727
ST::SUSYObjDef_xAOD::m_elez0
double m_elez0
Definition: SUSYObjDef_xAOD.h:687
ST::SUSYObjDef_xAOD::m_IsoCloseByORpassLabel
std::string m_IsoCloseByORpassLabel
Definition: SUSYObjDef_xAOD.h:790
ST::SUSYObjDef_xAOD::lrt_electrons
const xAOD::ElectronContainer * lrt_electrons
Definition: SUSYObjDef_xAOD.h:211
ST::SUSYObjDef_xAOD::m_tauSmearingToolRecommendationTag
std::string m_tauSmearingToolRecommendationTag
Definition: SUSYObjDef_xAOD.h:725
SG::Decorator< char >
ST::SUSYObjDef_xAOD::m_jetUncertaintiesConfig
std::string m_jetUncertaintiesConfig
Prefix for trigger matchiing container name.
Definition: SUSYObjDef_xAOD.h:525
ST::SUSYObjDef_xAOD::m_jetCalibTool
asg::AnaToolHandle< IJetCalibrationTool > m_jetCalibTool
Definition: SUSYObjDef_xAOD.h:819
TrigVtx::gamma
@ gamma
Definition: TrigParticleTable.h:26
fillPileUpNoiseLumi.next
next
Definition: fillPileUpNoiseLumi.py:52
ST::SUSYObjDef_xAOD::m_mu_iso_fallback
std::map< std::string, std::string > m_mu_iso_fallback
Definition: SUSYObjDef_xAOD.h:630
ST::SUSYObjDef_xAOD::m_v_trigs22_cache_multiLep
std::vector< std::string > m_v_trigs22_cache_multiLep
Definition: SUSYObjDef_xAOD.h:474
ST::SUSYObjDef_xAOD::m_photonEfficiencySFTool_trigEff_AsymDiphoton
std::vector< asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > > m_photonEfficiencySFTool_trigEff_AsymDiphoton
Definition: SUSYObjDef_xAOD.h:897
ST::SUSYObjDef_xAOD::m_trigNToys_multiLep
int m_trigNToys_multiLep
Definition: SUSYObjDef_xAOD.h:936
TauAnalysisTools::ITauEfficiencyCorrectionsTool::getEfficiencyScaleFactor
virtual CP::CorrectionCode getEfficiencyScaleFactor(const xAOD::TauJet &xTau, double &eff, unsigned int iRunNumber=0, unsigned int iMu=0)=0
Declare the interface that the class provides.
ST::SUSYObjDef_xAOD::m_BtagTagger
std::string m_BtagTagger
Definition: SUSYObjDef_xAOD.h:668
lumiFormat.i
int i
Definition: lumiFormat.py:85
ST::SUSYObjDef_xAOD::m_photonEfficiencySFTool_trigSF_AsymDiphoton
std::vector< asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > > m_photonEfficiencySFTool_trigSF_AsymDiphoton
Definition: SUSYObjDef_xAOD.h:896
ST::SUSYObjDef_xAOD::isNominal
bool isNominal(const CP::SystematicSet &syst) const
Definition: SUSYObjDef_xAOD.cxx:2081
ST::SUSYObjDef_xAOD::GetMuonTriggerEfficiency
double GetMuonTriggerEfficiency(const xAOD::Muon &mu, const std::string &trigExpr, const bool isdata=false) override final
Definition: Muons.cxx:530
ST::SUSYObjDef_xAOD::m_orDoEleJet
bool m_orDoEleJet
Definition: SUSYObjDef_xAOD.h:752
ST::SUSYObjDef_xAOD::m_orPhotonFavoured
bool m_orPhotonFavoured
Definition: SUSYObjDef_xAOD.h:776
xAOD::P4Helpers::deltaR
double deltaR(double rapidity1, double phi1, double rapidity2, double phi2)
from bare bare rapidity,phi
Definition: xAODP4Helpers.h:150
ST::SUSYObjDef_xAOD::m_jesCalibArea
std::string m_jesCalibArea
Definition: SUSYObjDef_xAOD.h:854
ST::SUSYObjDef_xAOD::m_eleChIso
bool m_eleChIso
Definition: SUSYObjDef_xAOD.h:655
IDTPM::nSCTHits
float nSCTHits(const U &p)
Definition: TrackParametersHelper.h:393
ST::ISUSYObjDef_xAODTool::Data
@ Data
Definition: ISUSYObjDef_xAODTool.h:477
xAOD::EgammaParameters::AuthorAmbiguous
const uint16_t AuthorAmbiguous
Object Reconstructed by standard cluster-based algorithm.
Definition: EgammaDefs.h:32
ST::SUSYObjDef_xAOD::m_trig2017combination_singleLep
std::string m_trig2017combination_singleLep
Definition: SUSYObjDef_xAOD.h:924
IDTPM::nTRTHits
float nTRTHits(const U &p)
Definition: TrackParametersHelper.h:446
xAOD::JetAttribute::EMFrac
@ EMFrac
Definition: JetAttributes.h:112
ORUtils::ToolBox::jetFatJetORT
OverlapHandle_t jetFatJetORT
Definition: ToolBox.h:80
Generate_dsid_ranseed.dsid
dsid
Definition: Generate_dsid_ranseed.py:6
ST::SUSYObjDef_xAOD::m_muonIsolationSFTool
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonIsolationSFTool
Definition: SUSYObjDef_xAOD.h:863
ST::SUSYObjDef_xAOD::m_jetCleanDFName
std::string m_jetCleanDFName
Definition: SUSYObjDef_xAOD.h:979
ST::SUSYObjDef_xAOD::m_jesCalibSeq
std::string m_jesCalibSeq
Definition: SUSYObjDef_xAOD.h:851
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
met::getSystType
SystType getSystType(const CP::SystematicVariation &systematic)
Definition: IMETSystematicsTool.h:53
ST::SUSYObjDef_xAOD::m_jetUncertaintiesTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_jetUncertaintiesTool
Definition: SUSYObjDef_xAOD.h:821
ST::SUSYObjDef_xAOD::m_muEta
double m_muEta
Definition: SUSYObjDef_xAOD.h:699
ST::SUSYObjDef_xAOD::IsSignalJet
bool IsSignalJet(const xAOD::Jet &input, const float ptcut, const float etacut) const override final
Definition: Jets.cxx:658
xAOD::TruthParticle_v1
Class describing a truth particle in the MC record.
Definition: TruthParticle_v1.h:37
CONFIG_EG_EFF_TOOL_KEY
#define CONFIG_EG_EFF_TOOL_KEY(TOOLHANDLE, TOOLNAME, KEYNAME, KEY, MAP)
Definition: SUSYToolsInit.cxx:96
ST::SUSYObjDef_xAOD::m_autoconfigPRW
bool m_autoconfigPRW
Definition: SUSYObjDef_xAOD.h:588
ST::SUSYObjDef_xAOD::m_orApplyRelPt
bool m_orApplyRelPt
Definition: SUSYObjDef_xAOD.h:768
xAOD::TauJet_v3
Class describing a tau jet.
Definition: TauJet_v3.h:41
asg::AsgMetadataTool::beginInputFile
virtual StatusCode beginInputFile()
Function called when a new input file is opened.
Definition: AsgMetadataTool.cxx:180
ST::SUSYObjDef_xAOD::m_v_trigs17_cache_singleLep
std::vector< std::string > m_v_trigs17_cache_singleLep
Definition: SUSYObjDef_xAOD.h:460
master.flag
bool flag
Definition: master.py:29
PlotPulseshapeFromCool.input
input
Definition: PlotPulseshapeFromCool.py:106
ST::SUSYObjDef_xAOD::m_muonCalibTool
asg::AnaToolHandle< CP::IMuonCalibrationAndSmearingTool > m_muonCalibTool
Definition: SUSYObjDef_xAOD.h:859
ST::SUSYObjDef_xAOD::m_ZTaggerTool
asg::AnaToolHandle< SmoothedWZTagger > m_ZTaggerTool
Definition: SUSYObjDef_xAOD.h:835
ST::SUSYObjDef_xAOD::m_orDoMuBjet
bool m_orDoMuBjet
Definition: SUSYObjDef_xAOD.h:758
CP::IPileupReweightingTool::getCorrectedAverageInteractionsPerCrossing
virtual float getCorrectedAverageInteractionsPerCrossing(const xAOD::EventInfo &eventInfo, bool includedDataScaleFactor=false)=0
ST::SUSYObjDef_xAOD::m_trig2017combination_multiLep
std::string m_trig2017combination_multiLep
Definition: SUSYObjDef_xAOD.h:939
ST::SUSYObjDef_xAOD::m_orRemoveCaloMuons
bool m_orRemoveCaloMuons
Definition: SUSYObjDef_xAOD.h:773
res
std::pair< std::vector< unsigned int >, bool > res
Definition: JetGroupProductTest.cxx:14
ST::SUSYObjDef_xAOD::m_prwDataSF
double m_prwDataSF
Definition: SUSYObjDef_xAOD.h:615
ST::SUSYObjDef_xAOD::FJVT_SF
double FJVT_SF(const xAOD::JetContainer *jets) override final
Definition: Jets.cxx:1025
Amg::transform
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
Definition: GeoPrimitivesHelpers.h:156
met::Random
@ Random
Definition: IMETSignificance.h:27
xAOD::VxType::PriVtx
@ PriVtx
Primary vertex.
Definition: TrackingPrimitives.h:571
ST::SUSYObjDef_xAOD::m_jesConfigJMS
std::string m_jesConfigJMS
Definition: SUSYObjDef_xAOD.h:846
ST::SUSYObjDef_xAOD::m_tauTerm
std::string m_tauTerm
Definition: SUSYObjDef_xAOD.h:563
ST::SUSYObjDef_xAOD::m_jetJvt
double m_jetJvt
Definition: SUSYObjDef_xAOD.h:731
ST::SUSYObjDef_xAOD::m_eleIdDFName
std::string m_eleIdDFName
Definition: SUSYObjDef_xAOD.h:976
BindingsTest.cut
cut
This script demonstrates how to call a C++ class from Python Also how to use PyROOT is shown.
Definition: BindingsTest.py:13
plotBeamSpotVert.cuts
string cuts
Definition: plotBeamSpotVert.py:93
python.BunchSpacingUtils.rn
rn
Definition: BunchSpacingUtils.py:87
ftag::defaults::tagger
const std::string tagger
Definition: ToolDefaults.h:11
xAOD::JetAttribute::Timing
@ Timing
Definition: JetAttributes.h:90
ORUtils::ToolBox::initialize
StatusCode initialize()
Attach and initialize all tools.
Definition: ToolBox.cxx:35
ST::SUSYObjDef_xAOD::m_jetUncertaintiesMCType
std::string m_jetUncertaintiesMCType
Definition: SUSYObjDef_xAOD.h:528
ST::SUSYObjDef_xAOD::m_commonPRWFileMC20e
std::string m_commonPRWFileMC20e
Definition: SUSYObjDef_xAOD.h:600
asg::AsgMetadataTool::metaDataStop
virtual StatusCode metaDataStop()
Function called when the tool should write out its metadata.
Definition: AsgMetadataTool.cxx:204
plotIsoValidation.el
el
Definition: plotIsoValidation.py:197
ST::SUSYObjDef_xAOD::check_isTighter
bool check_isTighter(const std::string &wp1, const std::string &wp, const std::vector< std::string > &list) const
Definition: SUSYObjDef_xAOD.cxx:1207
ST::SUSYObjDef_xAOD::m_jetUncertaintiesAnalysisFile
std::string m_jetUncertaintiesAnalysisFile
Definition: SUSYObjDef_xAOD.h:526
LQ
@ LQ
Definition: TruthClasses.h:75
ST::SUSYObjDef_xAOD::m_legsPerTool_ph
std::map< std::string, std::string > m_legsPerTool_ph
Definition: SUSYObjDef_xAOD.h:817
ST::SUSYObjDef_xAOD::m_WconfigReader
TEnv m_WconfigReader
Definition: SUSYObjDef_xAOD.h:542
ST::SUSYObjDef_xAOD::m_jetfJvtSelectionTool
asg::AnaToolHandle< IAsgSelectionTool > m_jetfJvtSelectionTool
Definition: SUSYObjDef_xAOD.h:831
python.xAODType.dummy
dummy
Definition: xAODType.py:4
ST::SUSYObjDef_xAOD::m_photonSelIsEM
asg::AnaToolHandle< IAsgPhotonIsEMSelector > m_photonSelIsEM
Definition: SUSYObjDef_xAOD.h:889
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
ST::SUSYObjDef_xAOD::m_trig2016combination_diLep
std::string m_trig2016combination_diLep
Definition: SUSYObjDef_xAOD.h:930
ST::SUSYObjDef_xAOD::m_jetUncertaintiesPDsmearing
bool m_jetUncertaintiesPDsmearing
Definition: SUSYObjDef_xAOD.h:529
ST::SUSYObjDef_xAOD::m_metSystTool
asg::AnaToolHandle< IMETSystematicsTool > m_metSystTool
Definition: SUSYObjDef_xAOD.h:919
MSG::name
const std::string & name(Level lvl)
Convenience function for translating message levels to strings.
Definition: MsgLevel.cxx:19
ST::SUSYObjDef_xAOD::prompt_muons
const xAOD::MuonContainer * prompt_muons
Definition: SUSYObjDef_xAOD.h:204
ST::SUSYObjDef_xAOD::m_BtagMinPt_trkJet
double m_BtagMinPt_trkJet
Definition: SUSYObjDef_xAOD.h:677
ST::SUSYObjDef_xAOD::m_v_trigs15_cache_diLep
std::vector< std::string > m_v_trigs15_cache_diLep
Definition: SUSYObjDef_xAOD.h:464
ST::SUSYObjDef_xAOD::m_orDoElEl
bool m_orDoElEl
Definition: SUSYObjDef_xAOD.h:753
ST::SUSYObjDef_xAOD::m_muIsoHighPtThresh
double m_muIsoHighPtThresh
Definition: SUSYObjDef_xAOD.h:664
ST::SUSYObjDef_xAOD::m_jetPileupLabelingTool
asg::AnaToolHandle< JetPileupLabelingTool > m_jetPileupLabelingTool
Definition: SUSYObjDef_xAOD.h:826
ST::SUSYObjDef_xAOD::m_trigMatchingPrefix
std::string m_trigMatchingPrefix
Use composite trigger matching tool if matching was done upstream.
Definition: SUSYObjDef_xAOD.h:523
ST::SUSYObjDef_xAOD::m_eleChID_signal
bool m_eleChID_signal
Definition: SUSYObjDef_xAOD.h:656
ORUtils::ToolBox::tauJetORT
OverlapHandle_t tauJetORT
Definition: ToolBox.h:75
ST::SUSYObjDef_xAOD::m_metUseGhostMuons
bool m_metUseGhostMuons
Definition: SUSYObjDef_xAOD.h:574
ST::SUSYObjDef_xAOD::m_WTagjetUncertaintiesTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_WTagjetUncertaintiesTool
Definition: SUSYObjDef_xAOD.h:838
histSizes.list
def list(name, path='/')
Definition: histSizes.py:38
ST::SUSYObjDef_xAOD::m_tauSelToolBaseline
asg::AnaToolHandle< TauAnalysisTools::ITauSelectionTool > m_tauSelToolBaseline
Definition: SUSYObjDef_xAOD.h:906
ST::SUSYObjDef_xAOD::isData
bool isData() const override final
Definition: SUSYObjDef_xAOD.h:156
xAOD::FileMetaData_v1::mcProcID
@ mcProcID
Same as mc_channel_number [float].
Definition: FileMetaData_v1.h:74
ST::SUSYObjDef_xAOD::m_prwDataSF_UP
double m_prwDataSF_UP
Definition: SUSYObjDef_xAOD.h:616
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
ST::SUSYObjDef_xAOD::m_bool_prop_set
std::set< std::string > m_bool_prop_set
Definition: SUSYObjDef_xAOD.h:439
ST::SUSYObjDef_xAOD::m_trig2018combination_diLep
std::string m_trig2018combination_diLep
Definition: SUSYObjDef_xAOD.h:932
ST::SUSYObjDef_xAOD::m_jesConfigFat
std::string m_jesConfigFat
Definition: SUSYObjDef_xAOD.h:849
ST::SUSYObjDef_xAOD::m_runECIS
bool m_runECIS
Definition: SUSYObjDef_xAOD.h:657
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
ST::SUSYObjDef_xAOD::m_trig2022combination_diLep
std::string m_trig2022combination_diLep
Definition: SUSYObjDef_xAOD.h:933
IsoMuon
@ IsoMuon
Definition: TruthClasses.h:15
diffPoolFiles.strict
strict
Definition: diffPoolFiles.py:68
ST::SUSYObjDef_xAOD::IsBadJet
bool IsBadJet(const xAOD::Jet &input) const override final
Definition: Jets.cxx:710
ST::SUSYObjDef_xAOD::m_eleIdBaselineDFName
std::string m_eleIdBaselineDFName
Definition: SUSYObjDef_xAOD.h:975
CP::IMuonSelectionTool::accept
virtual asg::AcceptData accept(const xAOD::Muon &mu) const =0
Decide whether the muon in question is a "good muon" or not.
ST::SUSYObjDef_xAOD::IsTrigMatched
bool IsTrigMatched(const xAOD::IParticle *part, const std::string &tr_item) override final
Definition: Trigger.cxx:220
ST::SUSYObjDef_xAOD::m_muIso_WP
std::string m_muIso_WP
Definition: SUSYObjDef_xAOD.h:662
xAOD::numberOfSCTHoles
@ numberOfSCTHoles
number of SCT holes [unit8_t].
Definition: TrackingPrimitives.h:270
ST::ISUSYObjDef_xAODTool::FullSim
@ FullSim
Definition: ISUSYObjDef_xAODTool.h:478
ST::SUSYObjDef_xAOD::isAtlfast
bool isAtlfast() const override final
Definition: SUSYObjDef_xAOD.h:157
ST::SUSYObjDef_xAOD::m_trig2015combination_multiLep
std::string m_trig2015combination_multiLep
Definition: SUSYObjDef_xAOD.h:937
DeMoUpdate.tmp
string tmp
Definition: DeMoUpdate.py:1167
PlotSFuncertainty.wp
wp
Definition: PlotSFuncertainty.py:112
ST::SUSYObjDef_xAOD::m_btagSelTool_trkJet
asg::AnaToolHandle< IBTaggingSelectionTool > m_btagSelTool_trkJet
Definition: SUSYObjDef_xAOD.h:916
SG::AuxElement::index
size_t index() const
Return the index of this element within its container.
ST::SUSYObjDef_xAOD::m_fatjetUncertaintiesTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_fatjetUncertaintiesTool
Definition: SUSYObjDef_xAOD.h:823
ICPJetUncertaintiesTool::applyCorrection
virtual CP::CorrectionCode applyCorrection(xAOD::Jet &input) const =0
ST::SUSYObjDef_xAOD::m_jesCalibSeqJMS
std::string m_jesCalibSeqJMS
Definition: SUSYObjDef_xAOD.h:852
IBTaggingEfficiencyTool::getScaleFactor
virtual CP::CorrectionCode getScaleFactor(const xAOD::Jet &jet, float &sf)=0
Declare the interface that the class provides.
TauAnalysisTools::ELEIDRNNMEDIUM
@ ELEIDRNNMEDIUM
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:34
xAOD::JetInput::Type
Type
Definition: JetContainerInfo.h:54
IDTPM::nSCTHoles
float nSCTHoles(const U &p)
Definition: TrackParametersHelper.h:403
ST::SUSYObjDef_xAOD::m_WTagUncConfig
std::string m_WTagUncConfig
Definition: SUSYObjDef_xAOD.h:553
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
xAOD::JetInput::EMPFlow
@ EMPFlow
Definition: JetContainerInfo.h:64
ST::SUSYObjDef_xAOD::m_runDepPrescaleWeightPRW
bool m_runDepPrescaleWeightPRW
Definition: SUSYObjDef_xAOD.h:618
ST::SUSYObjDef_xAOD::SetBtagWeightDecorations
StatusCode SetBtagWeightDecorations(const xAOD::Jet &input, const asg::AnaToolHandle< IBTaggingSelectionTool > &btagSelTool, const std::string &btagTagger) const override final
Definition: Jets.cxx:1120
ST::SUSYObjDef_xAOD::m_prwActualMu2017File
std::string m_prwActualMu2017File
Definition: SUSYObjDef_xAOD.h:609
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_trigEff_singleLep
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_trigEff_singleLep
Definition: SUSYObjDef_xAOD.h:873
ST::SUSYObjDef_xAOD::GetEventInfo
const xAOD::EventInfo * GetEventInfo() const override final
Definition: SUSYObjDef_xAOD.cxx:2938
ST::SUSYObjDef_xAOD::m_orDoElMu
bool m_orDoElMu
Definition: SUSYObjDef_xAOD.h:754
ST::SUSYObjDef_xAOD::m_tauJetORtool
asg::AnaToolHandle< ORUtils::IOverlapTool > m_tauJetORtool
Definition: SUSYObjDef_xAOD.h:969
ST::SUSYObjDef_xAOD::m_jetPt
double m_jetPt
Definition: SUSYObjDef_xAOD.h:729
Trig::TrigDecisionTool::isPassed
virtual bool isPassed(const std::string &chain, unsigned int condition) const
true if given chain passed
Definition: TrigDecisionTool.cxx:270
ST::SUSYObjDef_xAOD::m_photonBaselineIso_WP
std::string m_photonBaselineIso_WP
Definition: SUSYObjDef_xAOD.h:658
xAOD::FileMetaData_v1
Class holding file-level metadata about an xAOD file.
Definition: FileMetaData_v1.h:34
TrigConf::name
Definition: HLTChainList.h:35
ST::SUSYObjDef_xAOD::m_eleId
std::string m_eleId
Definition: SUSYObjDef_xAOD.h:637
ST::SUSYObjDef_xAOD::m_muIdBaseline
int m_muIdBaseline
Definition: SUSYObjDef_xAOD.h:644
DeMoScan.runnumber
runnumber
Definition: DeMoScan.py:266
CP::IElectronLRTOverlapRemovalTool::checkOverlap
virtual void checkOverlap(const xAOD::ElectronContainer &promptCollection, const xAOD::ElectronContainer &lrtCollection, std::set< const xAOD::Electron * > &ElectronsToRemove) const =0
Check the overlap between the prompt and LRT electron collections.
Trk::Combined
@ Combined
Definition: TrackSummaryTool.h:32
part2
Definition: part2.py:1
ST::SUSYObjDef_xAOD::m_eleIso_WP
std::string m_eleIso_WP
Definition: SUSYObjDef_xAOD.h:649
met::SOFTTRK
@ SOFTTRK
Definition: IMETSystematicsTool.h:49
ST::SUSYObjDef_xAOD::m_photonAllowLate
bool m_photonAllowLate
Definition: SUSYObjDef_xAOD.h:717
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
IAsgElectronEfficiencyCorrectionTool::getEfficiencyScaleFactor
virtual CP::CorrectionCode getEfficiencyScaleFactor(const xAOD::Electron &inputObject, double &efficiencyScaleFactor) const =0
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_iso
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_iso
Definition: SUSYObjDef_xAOD.h:874
ST::SUSYObjDef_xAOD::m_prwConfFiles
std::vector< std::string > m_prwConfFiles
Definition: SUSYObjDef_xAOD.h:607
ST::SUSYObjDef_xAOD::m_metJetSelection
std::string m_metJetSelection
Definition: SUSYObjDef_xAOD.h:798
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
xAOD::EventInfo_v1::beamPosSigmaY
float beamPosSigmaY() const
The width of the beam spot in the Y direction.
ORUtils::ToolBox::phoMuORT
OverlapHandle_t phoMuORT
Definition: ToolBox.h:77
ST::SUSYObjDef_xAOD::m_tauTruthMatch
asg::AnaToolHandle< TauAnalysisTools::ITauTruthMatchingTool > m_tauTruthMatch
Definition: SUSYObjDef_xAOD.h:908
LikeEnum::Tight
@ Tight
Definition: LikelihoodEnums.h:15
ST::SUSYObjDef_xAOD::m_eleLRT
bool m_eleLRT
Definition: SUSYObjDef_xAOD.h:653
ST::SUSYObjDef_xAOD::m_trig2022combination_singleLep
std::string m_trig2022combination_singleLep
Definition: SUSYObjDef_xAOD.h:926
ST::SUSYObjDef_xAOD::m_fJvtPtMax
double m_fJvtPtMax
Definition: SUSYObjDef_xAOD.h:742
ST::SUSYObjDef_xAOD::EG_WP
std::string EG_WP(const std::string &wp) const
Definition: SUSYObjDef_xAOD.cxx:1214
xAOD::BTagging_v1::pu
bool pu(const std::string &taggername, double &value) const
Definition: BTagging_v1.cxx:353
ST::SUSYObjDef_xAOD::m_inputMETCore
std::string m_inputMETCore
Definition: SUSYObjDef_xAOD.h:568
ORUtils::ToolBox::phoEleORT
OverlapHandle_t phoEleORT
Definition: ToolBox.h:76
xAOD::EventInfo_v1::averageInteractionsPerCrossing
float averageInteractionsPerCrossing() const
Average interactions per crossing for all BCIDs - for out-of-time pile-up.
Definition: EventInfo_v1.cxx:397
grepfile.sep
sep
Definition: grepfile.py:38
ST::SUSYObjDef_xAOD::check_isOption
bool check_isOption(const std::string &wp, const std::vector< std::string > &list) const
Definition: SUSYObjDef_xAOD.cxx:1202
xAOD::MissingETContainer_v1
Container for xAOD::MissingET_v1 objects.
Definition: MissingETContainer_v1.h:21
ST::SUSYObjDef_xAOD::m_eleForceFullSimCalib
bool m_eleForceFullSimCalib
Definition: SUSYObjDef_xAOD.h:693
ST::SUSYObjDef_xAOD::m_elecSelLikelihoodBaseline
asg::AnaToolHandle< IAsgElectronLikelihoodTool > m_elecSelLikelihoodBaseline
Definition: SUSYObjDef_xAOD.h:888
ST::SUSYObjDef_xAOD::m_subtool_init
bool m_subtool_init
Definition: SUSYObjDef_xAOD.h:559
ST::SUSYObjDef_xAOD::m_trigConfTool
asg::AnaToolHandle< TrigConf::ITrigConfigTool > m_trigConfTool
Definition: SUSYObjDef_xAOD.h:952
ST::SUSYObjDef_xAOD::GetSignalPhotonSF
double GetSignalPhotonSF(const xAOD::Photon &ph, const bool effSF=true, const bool isoSF=true, const bool triggerSF=false) const override final
Definition: Photons.cxx:203
IEGammaAmbiguityTool::accept
virtual bool accept(const xAOD::Egamma &egamma) const =0
Accept or reject egamma object based on ambiguity resolution.
ST::SUSYObjDef_xAOD::m_EigenvectorReductionLight
std::string m_EigenvectorReductionLight
Definition: SUSYObjDef_xAOD.h:674
xAOD::Muon
Muon_v1 Muon
Reference the current persistent version:
Definition: Event/xAOD/xAODMuon/xAODMuon/Muon.h:13
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
ST::SUSYObjDef_xAOD::m_ToptagConfig
std::string m_ToptagConfig
Definition: SUSYObjDef_xAOD.h:550
ST::Muon
@ Muon
Definition: ISUSYObjDef_xAODTool.h:78
ST::SUSYObjDef_xAOD::m_tauEffTool
asg::AnaToolHandle< TauAnalysisTools::ITauEfficiencyCorrectionsTool > m_tauEffTool
Definition: SUSYObjDef_xAOD.h:909
asg::AsgMetadataTool::m_inputMetaStore
MetaStore_t m_inputMetaStore
Object accessing the input metadata store.
Definition: AsgMetadataTool.h:119
TauAnalysisTools::ELEIDRNNTIGHT
@ ELEIDRNNTIGHT
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:35
xAOD::JetAttribute::AverageLArQF
@ AverageLArQF
Definition: JetAttributes.h:85
ST::SUSYObjDef_xAOD::m_tauPt
double m_tauPt
Definition: SUSYObjDef_xAOD.h:720
ST::SUSYObjDef_xAOD::m_muonSelectionToolBaseline
asg::AnaToolHandle< CP::IMuonSelectionTool > m_muonSelectionToolBaseline
Definition: SUSYObjDef_xAOD.h:858
ST::SUSYObjDef_xAOD::m_trkMETsyst
bool m_trkMETsyst
Definition: SUSYObjDef_xAOD.h:580
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
CP::IPileupReweightingTool::getRandomRunNumber
virtual int getRandomRunNumber(const xAOD::EventInfo &eventInfo, bool mu_dependent=true)=0
Get a random run number for this MC event, mu_dependency is recommended ... jetetmiss seem to like it...
ST::SUSYObjDef_xAOD::m_caloMETsyst
bool m_caloMETsyst
Definition: SUSYObjDef_xAOD.h:581
ST::SUSYObjDef_xAOD::m_JMScalib
bool m_JMScalib
Definition: SUSYObjDef_xAOD.h:747
ST::SUSYObjDef_xAOD::IsMETTrigPassed
bool IsMETTrigPassed(unsigned int runnumber=0, bool j400_OR=false) const override final
Definition: Trigger.cxx:30
ST::SUSYObjDef_xAOD::m_muz0
double m_muz0
Definition: SUSYObjDef_xAOD.h:701
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
ST::SUSYObjDef_xAOD::m_JvtWP
std::string m_JvtWP
Definition: SUSYObjDef_xAOD.h:732
Amg::error
double error(const Amg::MatrixX &mat, int index)
return diagonal error of the matrix caller should ensure the matrix is symmetric and the index is in ...
Definition: EventPrimitivesHelpers.h:40
ST::SUSYObjDef_xAOD::getSherpaVjetsNjetsWeight
float getSherpaVjetsNjetsWeight() const override final
Definition: SUSYObjDef_xAOD.cxx:2846
ST::SUSYObjDef_xAOD::TrigMatch
void TrigMatch(const xAOD::IParticle *p, std::initializer_list< std::string >::iterator, std::initializer_list< std::string >::iterator) override final
Definition: Trigger.cxx:240
xAOD::JetAttribute::SumPtTrkPt500
@ SumPtTrkPt500
Definition: JetAttributes.h:108
ST::SUSYObjDef_xAOD::m_useBtagging_trkJet
bool m_useBtagging_trkJet
Definition: SUSYObjDef_xAOD.h:532
xAOD::FileMetaData_v1::amiTag
@ amiTag
AMI tag used to process the file the last time [string].
Definition: FileMetaData_v1.h:58
ST::SUSYObjDef_xAOD::m_force_noMuId
bool m_force_noMuId
Definition: SUSYObjDef_xAOD.h:519
SUSY
@ SUSY
Definition: TruthClasses.h:77
HeavyBoson
@ HeavyBoson
Definition: TruthClasses.h:70
threshold
Definition: chainparser.cxx:74
ST::SUSYObjDef_xAOD::m_doFwdJVT
bool m_doFwdJVT
Definition: SUSYObjDef_xAOD.h:740
AtlCoolConsole.tool
tool
Definition: AtlCoolConsole.py:453
ST::SUSYObjDef_xAOD::FillTau
StatusCode FillTau(xAOD::TauJet &input) override final
Definition: Taus.cxx:76
ST::SUSYObjDef_xAOD::m_isoCloseByTool
asg::AnaToolHandle< CP::IIsolationCloseByCorrectionTool > m_isoCloseByTool
Definition: SUSYObjDef_xAOD.h:963
ST::SUSYObjDef_xAOD::m_muEffCorrForce1D
bool m_muEffCorrForce1D
Definition: SUSYObjDef_xAOD.h:666
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_trig_singleLep
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_trig_singleLep
Definition: SUSYObjDef_xAOD.h:872
ST::SUSYObjDef_xAOD::m_trig2018combination_multiLep
std::string m_trig2018combination_multiLep
Definition: SUSYObjDef_xAOD.h:940
CP::IPileupReweightingTool::getDataWeight
virtual float getDataWeight(const xAOD::EventInfo &eventInfo, const TString &trigger, bool mu_dependent=true)=0
Get the dataWeight used to 'unprescale' data collected from a given trigger combination....
ST::SUSYObjDef_xAOD::m_btagSelTool_OR
asg::AnaToolHandle< IBTaggingSelectionTool > m_btagSelTool_OR
Definition: SUSYObjDef_xAOD.h:914
xAOD::TruthEventBase_v1::nTruthParticles
size_t nTruthParticles() const
Get the number of truth particles.
IMETSystematicsTool::setRandomSeed
virtual void setRandomSeed(int seed) const =0
SmoothedWZTagger::tag
virtual StatusCode tag(const xAOD::Jet &jet) const override
Decorate single jet with tagging info.
Definition: SmoothedWZTagger.cxx:177
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
python.ElectronD3PDObject.matched
matched
Definition: ElectronD3PDObject.py:138
ST::SUSYObjDef_xAOD::m_commonPRWFileMC20a
std::string m_commonPRWFileMC20a
Definition: SUSYObjDef_xAOD.h:598
ST::SUSYObjDef_xAOD::m_muonSelectionHighPtTool
asg::AnaToolHandle< CP::IMuonSelectionTool > m_muonSelectionHighPtTool
Definition: SUSYObjDef_xAOD.h:857
TrigJetMonitorAlgorithm.items
items
Definition: TrigJetMonitorAlgorithm.py:79
ST::SUSYObjDef_xAOD::m_photonId
std::string m_photonId
Definition: SUSYObjDef_xAOD.h:645
item
Definition: ItemListSvc.h:43
ST::SUSYObjDef_xAOD::m_fJvtConfigRun3
std::string m_fJvtConfigRun3
Definition: SUSYObjDef_xAOD.h:745
xAOD::MissingETAssociationHelper
Definition: MissingETAssociationHelper.h:26
IBTaggingSelectionTool::getQuantile
virtual int getQuantile(const xAOD::IParticle *) const =0
Decide in which quantile of the tagger weight distribution the jet belongs The return value represent...
ST::SUSYObjDef_xAOD::m_trkJetEta
double m_trkJetEta
Definition: SUSYObjDef_xAOD.h:738
ST::SUSYObjDef_xAOD::m_BtagWP_trkJet
std::string m_BtagWP_trkJet
Definition: SUSYObjDef_xAOD.h:675
CP::IPileupReweightingTool::getCorrectedActualInteractionsPerCrossing
virtual float getCorrectedActualInteractionsPerCrossing(const xAOD::EventInfo &eventInfo, bool includedDataScaleFactor=false)=0
Get the actual mu of a lumiblock ...
xAOD::Electron_v1
Definition: Electron_v1.h:34
xAOD::ShallowAuxContainer::setName
void setName(const char *name)
Set the name of the container instance.
Definition: ShallowAuxContainer.cxx:600
met::SOFTCALO
@ SOFTCALO
Definition: IMETSystematicsTool.h:48
ST::SUSYObjDef_xAOD::m_dataSource
int m_dataSource
Definition: SUSYObjDef_xAOD.h:513
ST::SUSYObjDef_xAOD::m_badmuQoverP
double m_badmuQoverP
Definition: SUSYObjDef_xAOD.h:707
xAOD::shallowCopyContainer
std::pair< std::unique_ptr< T >, std::unique_ptr< ShallowAuxContainer > > shallowCopyContainer(const T &cont, [[maybe_unused]] const EventContext &ctx)
Function making a shallow copy of a constant container.
Definition: ShallowCopy.h:110
ST::SUSYObjDef_xAOD::m_outMuonLocation
SG::WriteHandleKey< xAOD::MuonContainer > m_outMuonLocation
Definition: SUSYObjDef_xAOD.h:868
ST::Electron
@ Electron
Definition: ISUSYObjDef_xAODTool.h:76
ST::Jet
@ Jet
Definition: ISUSYObjDef_xAODTool.h:74
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
ST::SUSYObjDef_xAOD::m_EleFatJetDR
double m_EleFatJetDR
Definition: SUSYObjDef_xAOD.h:781
ST::SUSYObjDef_xAOD::m_elebaselinez0
double m_elebaselinez0
Definition: SUSYObjDef_xAOD.h:689
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
ST::SUSYObjDef_xAOD::m_muCosmicz0
double m_muCosmicz0
Definition: SUSYObjDef_xAOD.h:705
xAOD::Photon
Photon_v1 Photon
Definition of the current "egamma version".
Definition: Event/xAOD/xAODEgamma/xAODEgamma/Photon.h:17
TauAnalysisTools::ITauTruthMatchingTool::getTruth
virtual const xAOD::TruthParticle * getTruth(const xAOD::TauJet &xTau)=0
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:431
ST::SUSYObjDef_xAOD::getSystInfo
ST::SystInfo getSystInfo(const CP::SystematicVariation &sys) const override final
Definition: SUSYObjDef_xAOD.cxx:2540
Muon
struct TBPatternUnitContext Muon
InDet::TrkOrigin::isPileup
bool isPileup(int origin)
from pileup
Definition: InDetTrackTruthOriginDefs.h:49
xAOD::JetInput::EMTopo
@ EMTopo
Definition: JetContainerInfo.h:56
xAOD::BTaggingUtilities::getBTagging
const BTagging * getBTagging(const SG::AuxElement &part)
Access the default xAOD::BTagging object associated to an object.
Definition: BTaggingUtilities.cxx:37
python.copyTCTOutput.chains
chains
Definition: copyTCTOutput.py:81
ST::SUSYObjDef_xAOD::m_btagSelTool
asg::AnaToolHandle< IBTaggingSelectionTool > m_btagSelTool
Definition: SUSYObjDef_xAOD.h:913
ST::MET_CST
@ MET_CST
Definition: ISUSYObjDef_xAODTool.h:82
ST::SUSYObjDef_xAOD::m_orDoTauBjet
bool m_orDoTauBjet
Definition: SUSYObjDef_xAOD.h:759
ST::SUSYObjDef_xAOD::m_jetNNJvtSelectionTool
asg::AnaToolHandle< IAsgSelectionTool > m_jetNNJvtSelectionTool
Definition: SUSYObjDef_xAOD.h:829
xAOD::numberOfTRTOutliers
@ numberOfTRTOutliers
number of TRT outliers [unit8_t].
Definition: TrackingPrimitives.h:276
Trig::TrigDecisionToolCore::getPrescale
float getPrescale(const Trig::ChainGroup *chaingroup, unsigned int condition=TrigDefs::Physics) const
Definition: ConfigurationAccess.cxx:88
python.AthDsoLogger.fname
string fname
Definition: AthDsoLogger.py:67
asg::ToolStore::remove
static StatusCode remove(const IAsgTool *tool)
Remove the specified tool from the store.
Definition: ToolStore.cxx:77
ST::SUSYObjDef_xAOD::m_orMuJetTrkPtRatio
double m_orMuJetTrkPtRatio
Definition: SUSYObjDef_xAOD.h:770
ST::SUSYObjDef_xAOD::FillPhoton
StatusCode FillPhoton(xAOD::Photon &input, const float ptcut, const float etacut) override final
Definition: Photons.cxx:78
python.PyAthena.v
v
Definition: PyAthena.py:154
ST::SUSYObjDef_xAOD::m_v_trigs16_cache_diLep
std::vector< std::string > m_v_trigs16_cache_diLep
Definition: SUSYObjDef_xAOD.h:465
ST::SUSYObjDef_xAOD::m_muonTriggerSFTool
asg::AnaToolHandle< CP::IMuonTriggerScaleFactors > m_muonTriggerSFTool
Definition: SUSYObjDef_xAOD.h:865
ST::SUSYObjDef_xAOD::m_eleCrackVeto
bool m_eleCrackVeto
Definition: SUSYObjDef_xAOD.h:685
xAOD::Jet_v1
Class describing a jet.
Definition: Jet_v1.h:57
ST::SUSYObjDef_xAOD::m_mubaselinez0
double m_mubaselinez0
Definition: SUSYObjDef_xAOD.h:703
ORUtils::ToolBox::masterTool
MasterHandle_t masterTool
Master overlap removal tool handle.
Definition: ToolBox.h:64
xAOD::EgammaParameters::BADCLUSPHOTON
const uint32_t BADCLUSPHOTON
Definition: EgammaDefs.h:124
DeMoAtlasDataLoss.runNumber
string runNumber
Definition: DeMoAtlasDataLoss.py:64
ST::SUSYObjDef_xAOD::GetSignalTauSF
double GetSignalTauSF(const xAOD::TauJet &tau, const bool idSF=true, const bool triggerSF=true, const std::string &trigExpr="tau25_medium1_tracktwo") override final
Definition: Taus.cxx:129
ST::SUSYObjDef_xAOD::getElSFkeys
std::vector< std::string > getElSFkeys(const std::string &mapFile) const
Definition: SUSYObjDef_xAOD.cxx:1226
ST::SUSYObjDef_xAOD::m_jesConfigJMSData
std::string m_jesConfigJMSData
Definition: SUSYObjDef_xAOD.h:847
ST::SUSYObjDef_xAOD::m_trig2016combination_singleLep
std::string m_trig2016combination_singleLep
Definition: SUSYObjDef_xAOD.h:923
CP::CorrectionCode::Ok
@ Ok
The correction was done successfully.
Definition: CorrectionCode.h:38
ITrigGlobalEfficiencyCorrectionTool::getEfficiencyScaleFactor
virtual CP::CorrectionCode getEfficiencyScaleFactor(const std::vector< const xAOD::IParticle * > &particles, double &efficiencyScaleFactor)=0
ST::SUSYObjDef_xAOD::m_btagEffTool
asg::AnaToolHandle< IBTaggingEfficiencyTool > m_btagEffTool
Definition: SUSYObjDef_xAOD.h:912
Trig::TrigDecisionTool::finalize
StatusCode finalize()
Definition: TrigDecisionTool.cxx:234
ST::SUSYObjDef_xAOD::m_fatJets
std::string m_fatJets
Definition: SUSYObjDef_xAOD.h:804
ST::SUSYObjDef_xAOD::m_elecChargeIDSelectorTool
asg::AnaToolHandle< IAsgElectronLikelihoodTool > m_elecChargeIDSelectorTool
Definition: SUSYObjDef_xAOD.h:902
ST::SUSYObjDef_xAOD::m_muCalibrationMode
int m_muCalibrationMode
Definition: SUSYObjDef_xAOD.h:708
asg::AnaToolHandle::getHandle
const ToolHandle< T > & getHandle() const noexcept
the tool handle we wrap
ST::SUSYObjDef_xAOD::m_softTermParam
int m_softTermParam
Definition: SUSYObjDef_xAOD.h:584
xAOD::EventInfo_v1::beamPosSigmaXY
float beamPosSigmaXY() const
The beam spot shape's X-Y correlation.
xAOD::photon
@ photon
Definition: TrackingPrimitives.h:199
ST::SUSYObjDef_xAOD::m_strictConfigCheck
bool m_strictConfigCheck
Definition: SUSYObjDef_xAOD.h:535
ST::SUSYObjDef_xAOD::m_orBoostedElectronMaxConeSize
double m_orBoostedElectronMaxConeSize
Definition: SUSYObjDef_xAOD.h:763
a
TList * a
Definition: liststreamerinfos.cxx:10
ST::SUSYObjDef_xAOD::FindSusyHP
StatusCode FindSusyHP(int &pdgid1, int &pdgid2) const
Definition: Truth.cxx:75
ST::SUSYObjDef_xAOD::m_eleBaselineIso_WP
std::string m_eleBaselineIso_WP
Definition: SUSYObjDef_xAOD.h:641
ST::SUSYObjDef_xAOD::m_inputMETMap
std::string m_inputMETMap
Definition: SUSYObjDef_xAOD.h:567
ST::SUSYObjDef_xAOD::m_BtagTagger_trkJet
std::string m_BtagTagger_trkJet
Definition: SUSYObjDef_xAOD.h:676
ST::SUSYObjDef_xAOD::m_autoconfigPRWRPVmode
bool m_autoconfigPRWRPVmode
Definition: SUSYObjDef_xAOD.h:592
ITrigGlobalEfficiencyCorrectionTool::checkTriggerMatching
virtual CP::CorrectionCode checkTriggerMatching(bool &matched, const std::vector< const xAOD::IParticle * > &particles)=0
h
ST::SUSYObjDef_xAOD::m_tauId
std::string m_tauId
Definition: SUSYObjDef_xAOD.h:647
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
ST::SUSYObjDef_xAOD::FindSusyHardProc
static bool FindSusyHardProc(const xAOD::TruthParticleContainer *truthP, int &pdgid1, int &pdgid2, bool isTruth3=false)
Definition: Truth.cxx:125
CondAlgsOpts.found
int found
Definition: CondAlgsOpts.py:101
ST::SUSYObjDef_xAOD::validConfig
StatusCode validConfig(bool strict=false) const
Definition: SUSYObjDef_xAOD.cxx:1916
xAOD::Photon_v1
Definition: Photon_v1.h:37
asg::AsgMetadataTool
Base class for dual-use tools that provide file metadata access.
Definition: AsgMetadataTool.h:48
mapkey::sf
@ sf
Definition: TElectronEfficiencyCorrectionTool.cxx:38
ST::SUSYObjDef_xAOD::m_EG_corrModel
std::string m_EG_corrModel
Definition: SUSYObjDef_xAOD.h:810
JetTruthLabelingTool::decorate
StatusCode decorate(const xAOD::JetContainer &jets) const override
decorate truth label to a jet collection
Definition: JetTruthLabelingTool.cxx:317
LikeEnum::Medium
@ Medium
Definition: LikelihoodEnums.h:14
ST::SUSYObjDef_xAOD::m_v_trigs18_cache_multiLep
std::vector< std::string > m_v_trigs18_cache_multiLep
Definition: SUSYObjDef_xAOD.h:473
ST::SUSYObjDef_xAOD::m_JetFatJetDR
double m_JetFatJetDR
Definition: SUSYObjDef_xAOD.h:782
ST::SUSYObjDef_xAOD::m_configFile
std::string m_configFile
Definition: SUSYObjDef_xAOD.h:516
ST::SUSYObjDef_xAOD::m_JetTruthLabelName
std::string m_JetTruthLabelName
Definition: SUSYObjDef_xAOD.h:556
ST::SUSYObjDef_xAOD::JVT_SF
double JVT_SF(const xAOD::JetContainer *jets) override final
Definition: Jets.cxx:953
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
ST::SUSYObjDef_xAOD::m_orDoBoostedElectron
bool m_orDoBoostedElectron
Definition: SUSYObjDef_xAOD.h:760
xAOD::numberOfSCTDeadSensors
@ numberOfSCTDeadSensors
number of dead SCT sensors crossed [unit8_t].
Definition: TrackingPrimitives.h:273
ST::SUSYObjDef_xAOD::m_photonSelIsEMBaseline
asg::AnaToolHandle< IAsgPhotonIsEMSelector > m_photonSelIsEMBaseline
Definition: SUSYObjDef_xAOD.h:890
ITrigGlobalEfficiencyCorrectionTool::getEfficiency
virtual CP::CorrectionCode getEfficiency(const std::vector< const xAOD::IParticle * > &particles, double &efficiencyData, double &efficiencyMc)=0
ST::SUSYObjDef_xAOD::GetSignalMuonSF
float GetSignalMuonSF(const xAOD::Muon &mu, const bool recoSF=true, const bool isoSF=true, const bool doBadMuonHP=true, const bool warnOVR=true) override final
Definition: Muons.cxx:477
CP::SystematicRegistry
This module implements the central registry for handling systematic uncertainties with CP tools.
Definition: SystematicRegistry.h:25
ConstDataVector
DataVector adapter that acts like it holds const pointers.
Definition: ConstDataVector.h:76
ST::SUSYObjDef_xAOD::m_photonPt
double m_photonPt
Definition: SUSYObjDef_xAOD.h:714
ORUtils::ORFlags
A struct of global config options used to simplify the config helper interface.
Definition: OverlapRemovalInit.h:29
ST::SUSYObjDef_xAOD::m_metVeryGreedyPhotons
bool m_metVeryGreedyPhotons
Definition: SUSYObjDef_xAOD.h:577
ST::SUSYObjDef_xAOD::GetTriggerGlobalEfficiencySF
double GetTriggerGlobalEfficiencySF(const xAOD::ElectronContainer &electrons, const xAOD::MuonContainer &muons, const std::string &trigExpr="diLepton") override final
Definition: Trigger.cxx:400
xAOD::setOriginalObjectLink
bool setOriginalObjectLink(const IParticle &original, IParticle &copy)
This function should be used by CP tools when they make a deep copy of an object in their correctedCo...
Definition: IParticleHelpers.cxx:30
ST::SUSYObjDef_xAOD::m_trigDecTool
asg::AnaToolHandle< Trig::TrigDecisionTool > m_trigDecTool
Definition: SUSYObjDef_xAOD.h:953
ST::SUSYObjDef_xAOD::m_isRun3
bool m_isRun3
Definition: SUSYObjDef_xAOD.h:795
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
ST::SUSYObjDef_xAOD::m_metsysConfigPrefix
std::string m_metsysConfigPrefix
Definition: SUSYObjDef_xAOD.h:578
ST::SUSYObjDef_xAOD::m_defaultTrackJets
std::string m_defaultTrackJets
Definition: SUSYObjDef_xAOD.h:803
ST::SUSYObjDef_xAOD::m_eleEta
double m_eleEta
Definition: SUSYObjDef_xAOD.h:684
ST::SUSYObjDef_xAOD::m_prwActualMu2023File
std::string m_prwActualMu2023File
Definition: SUSYObjDef_xAOD.h:612
FullCPAlgorithmsTest_CA.inputfile
dictionary inputfile
Definition: FullCPAlgorithmsTest_CA.py:62
ST::LRT_Object
@ LRT_Object
Definition: ISUSYObjDef_xAODTool.h:85
ST::SUSYObjDef_xAOD::m_jesCalibSeqFat
std::string m_jesCalibSeqFat
Definition: SUSYObjDef_xAOD.h:853
python.TriggerAPI.TriggerAPISession.chainName
chainName
Definition: TriggerAPISession.py:426
ST::SUSYObjDef_xAOD::m_TopTagUncConfig
std::string m_TopTagUncConfig
Definition: SUSYObjDef_xAOD.h:555
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
IJetCalibrationTool::applyCalibration
virtual StatusCode applyCalibration(xAOD::JetContainer &jets) const =0
Apply calibration to a jet container.
ST::SUSYObjDef_xAOD::applySystematicVariation
StatusCode applySystematicVariation(const CP::SystematicSet &systConfig) override final
Definition: SUSYObjDef_xAOD.cxx:2119
Higgs
@ Higgs
Definition: TruthClasses.h:68
CP::CorrectionCode
Return value from object correction CP tools.
Definition: CorrectionCode.h:31
ST::SUSYObjDef_xAOD::m_currentSyst
CP::SystematicSet m_currentSyst
Definition: SUSYObjDef_xAOD.h:808
CP::IPileupReweightingTool::getCombinedWeight
virtual float getCombinedWeight(const xAOD::EventInfo &eventInfo, bool correctUnrepresented=false)=0
Return combined pileup weight.
ST::SUSYObjDef_xAOD::m_treatPUJets
bool m_treatPUJets
Definition: SUSYObjDef_xAOD.h:585
ST::SUSYObjDef_xAOD::m_jesConfig
std::string m_jesConfig
Definition: SUSYObjDef_xAOD.h:845
xAOD::EgammaParameters::electron
@ electron
Definition: EgammaEnums.h:18
python.changerun.pv
pv
Definition: changerun.py:81
ST::SUSYObjDef_xAOD::m_tauConfigPathBaseline
std::string m_tauConfigPathBaseline
Definition: SUSYObjDef_xAOD.h:723
xAOD::EgammaParameters::AuthorPhoton
const uint16_t AuthorPhoton
Object Reconstructed by standard cluster-based algorithm.
Definition: EgammaDefs.h:28
ST::ISUSYObjDef_xAODTool::AtlfastII
@ AtlfastII
Definition: ISUSYObjDef_xAODTool.h:479
CaloCellTimeCorrFiller.filename
filename
Definition: CaloCellTimeCorrFiller.py:24
ST::SUSYObjDef_xAOD::m_autoconfigPRWPath
std::string m_autoconfigPRWPath
Definition: SUSYObjDef_xAOD.h:589
ST::SUSYObjDef_xAOD::m_photonIdDFName
std::string m_photonIdDFName
Definition: SUSYObjDef_xAOD.h:978
ST::SUSYObjDef_xAOD::m_jetFatCalibTool
asg::AnaToolHandle< IJetCalibrationTool > m_jetFatCalibTool
Definition: SUSYObjDef_xAOD.h:820
ST::SUSYObjDef_xAOD::m_electronTriggerSFStringSingle
std::string m_electronTriggerSFStringSingle
Definition: SUSYObjDef_xAOD.h:633
ST::SUSYObjDef_xAOD::m_jetNNJvtEfficiencyTool
asg::AnaToolHandle< CP::IJvtEfficiencyTool > m_jetNNJvtEfficiencyTool
Definition: SUSYObjDef_xAOD.h:830
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
CP::IMuonEfficiencyScaleFactors::getEfficiencyScaleFactor
virtual CorrectionCode getEfficiencyScaleFactor(const xAOD::Muon &mu, float &sf, const xAOD::EventInfo *info=0) const =0
Retrieve the Scale factor.
ST::SUSYObjDef_xAOD::BtagSFsys
float BtagSFsys(const xAOD::JetContainer *jets, const CP::SystematicSet &systConfig) override final
Definition: Jets.cxx:852
ST::SUSYObjDef_xAOD::m_tauEta
double m_tauEta
Definition: SUSYObjDef_xAOD.h:721
ST::SUSYObjDef_xAOD::m_v_trigs17_cache_multiLep
std::vector< std::string > m_v_trigs17_cache_multiLep
Definition: SUSYObjDef_xAOD.h:472
ST::SUSYObjDef_xAOD::m_trig2017combination_diLep
std::string m_trig2017combination_diLep
Definition: SUSYObjDef_xAOD.h:931
ST::SUSYObjDef_xAOD::m_trigDRScoringTool
asg::AnaToolHandle< Trig::IMatchScoringTool > m_trigDRScoringTool
Definition: SUSYObjDef_xAOD.h:956
ST::SUSYObjDef_xAOD::m_trig2015combination_diLep
std::string m_trig2015combination_diLep
Definition: SUSYObjDef_xAOD.h:929
ST::SUSYObjDef_xAOD::m_jetTruthLabelingTool
asg::AnaToolHandle< JetTruthLabelingTool > m_jetTruthLabelingTool
Definition: SUSYObjDef_xAOD.h:837
ST::SUSYObjDef_xAOD::m_eleLRT_strat
int m_eleLRT_strat
Definition: SUSYObjDef_xAOD.h:654
ORUtils::ToolBox::phoJetORT
OverlapHandle_t phoJetORT
Definition: ToolBox.h:78
ST::SUSYObjDef_xAOD::m_ZDecorName
std::string m_ZDecorName
Definition: SUSYObjDef_xAOD.h:546
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:268
ST::SUSYObjDef_xAOD::m_metSignif
asg::AnaToolHandle< IMETSignificance > m_metSignif
Definition: SUSYObjDef_xAOD.h:920
xAODType::Tau
@ Tau
The object is a tau (jet)
Definition: ObjectType.h:49
ST::SUSYObjDef_xAOD::m_autoconfigPRWFile
std::string m_autoconfigPRWFile
Definition: SUSYObjDef_xAOD.h:590
ST::SUSYObjDef_xAOD::m_v_trigs16_cache_singleLep
std::vector< std::string > m_v_trigs16_cache_singleLep
Definition: SUSYObjDef_xAOD.h:459
ST::SUSYObjDef_xAOD::m_jesConfigFatData
std::string m_jesConfigFatData
Definition: SUSYObjDef_xAOD.h:850
IMETMaker::rebuildTrackMET
virtual StatusCode rebuildTrackMET(const std::string &metJetKey, const std::string &metSoftKey, xAOD::MissingETContainer *metCont, const xAOD::JetContainer *jets, const xAOD::MissingETContainer *metCoreCont, xAOD::MissingETAssociationHelper &helper, bool doJetJVT)=0
CxxUtils::atoi
int atoi(std::string_view str)
Helper functions to unpack numbers decoded in string into integers and doubles The strings are requir...
Definition: Control/CxxUtils/Root/StringUtils.cxx:85
ST::SUSYObjDef_xAOD::m_eleBaselinePt
double m_eleBaselinePt
Definition: SUSYObjDef_xAOD.h:680
SG::ConstAccessor::isAvailable
bool isAvailable(const ELT &e) const
Test to see if this variable exists in the store.
IBTaggingSelectionTool::accept
virtual asg::AcceptData accept(const xAOD::IParticle *p) const =0
Declare the interface that the class provides.
xAOD::JetAttribute::HECFrac
@ HECFrac
Definition: JetAttributes.h:113
defineDB.jets
list jets
Definition: JetTagCalibration/share/defineDB.py:24
ST::SUSYObjDef_xAOD::m_commonPRWFileMC23c
std::string m_commonPRWFileMC23c
Definition: SUSYObjDef_xAOD.h:603
dqt_zlumi_alleff_HIST.eff
int eff
Definition: dqt_zlumi_alleff_HIST.py:113
copySelective.source
string source
Definition: copySelective.py:32
ST::Unknown
@ Unknown
Definition: ISUSYObjDef_xAODTool.h:73
CP::IPileupReweightingTool::getPRWHash
virtual ULong64_t getPRWHash(const xAOD::EventInfo &eventInfo)=0
return the prw hash used for fast updates of weights at the post-processing level ....
ST::SUSYObjDef_xAOD::m_v_trigs16_cache_multiLep
std::vector< std::string > m_v_trigs16_cache_multiLep
Definition: SUSYObjDef_xAOD.h:471
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
PhotonHelpers::passOQqualityDelayed
bool passOQqualityDelayed(const xAOD::Photon &ph)
Helpers to ease the implementation of the pass Quality requirements.
Definition: PhotonHelpers.cxx:29
Trig::TrigDecisionToolCore::getChainGroup
const Trig::ChainGroup * getChainGroup(const std::vector< std::string > &patterns, TrigDefs::Group props=TrigDefs::Group::Default) const
Create/get chain group (.
Definition: ChainGroupFunctions.cxx:38
xAOD::numberOfPixelDeadSensors
@ numberOfPixelDeadSensors
number of dead pixel sensors crossed [unit8_t].
Definition: TrackingPrimitives.h:266
ST::SUSYObjDef_xAOD::m_eleConfig
std::string m_eleConfig
Definition: SUSYObjDef_xAOD.h:639
top
@ top
Definition: TruthClasses.h:64
TauAnalysisTools::JETIDRNNVERYLOOSE
@ JETIDRNNVERYLOOSE
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:19
ST::SUSYObjDef_xAOD::m_muHighPtExtraSmear
bool m_muHighPtExtraSmear
Definition: SUSYObjDef_xAOD.h:665
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
calibdata.copy
bool copy
Definition: calibdata.py:27
ST::SUSYObjDef_xAOD::m_photonTriggerName
std::string m_photonTriggerName
Definition: SUSYObjDef_xAOD.h:660
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
veto
std::vector< std::string > veto
these patterns are anded
Definition: listroot.cxx:191
ST::SUSYObjDef_xAOD::m_TopTagjetUncertaintiesTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_TopTagjetUncertaintiesTool
Definition: SUSYObjDef_xAOD.h:840
IBTaggingEfficiencyTool::getInefficiencyScaleFactor
virtual CP::CorrectionCode getInefficiencyScaleFactor(const xAOD::Jet &jet, float &sf)=0
ST::SUSYObjDef_xAOD::m_EigenvectorReductionB
std::string m_EigenvectorReductionB
Definition: SUSYObjDef_xAOD.h:672
ST::SUSYObjDef_xAOD::m_orBoostedElectronC2
double m_orBoostedElectronC2
Definition: SUSYObjDef_xAOD.h:762
xAOD::getOriginalObject
const IParticle * getOriginalObject(const IParticle &copy)
This function can be used to conveniently get a pointer back to the original object from which a copy...
Definition: IParticleHelpers.cxx:140
xAODType::BTag
@ BTag
The object is a b-tagging object.
Definition: ObjectType.h:60
ST::Tau
@ Tau
Definition: ISUSYObjDef_xAODTool.h:79
ST::SUSYObjDef_xAOD::m_muLRT
bool m_muLRT
Definition: SUSYObjDef_xAOD.h:709
InDet::IInclusiveTrackFilterTool::accept
virtual bool accept(const xAOD::TrackParticle *) const =0
JetVertexTaggerTool::updateJvt
float updateJvt(const xAOD::Jet &jet) const override
Calculate the updated JVT.
Definition: JetVertexTaggerTool.cxx:200
ST::SUSYObjDef_xAOD::m_tauPrePtCut
double m_tauPrePtCut
Definition: SUSYObjDef_xAOD.h:719
ST::SUSYObjDef_xAOD::MergeMuons
StatusCode MergeMuons(const xAOD::MuonContainer &muons, const std::vector< bool > &writeMuon, xAOD::MuonContainer *outputCol) const override final
Definition: Muons.cxx:55
TauAnalysisTools::JETIDNONEUNCONFIGURED
@ JETIDNONEUNCONFIGURED
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:13
Trig::ChainGroup::getListOfTriggers
std::vector< std::string > getListOfTriggers() const
Definition: ChainGroup.cxx:467
ST::SUSYObjDef_xAOD::m_v_trigs22_cache_diLep
std::vector< std::string > m_v_trigs22_cache_diLep
Definition: SUSYObjDef_xAOD.h:468
ST::SUSYObjDef_xAOD::m_orInputLabel
std::string m_orInputLabel
Definition: SUSYObjDef_xAOD.h:775
IAsgElectronLikelihoodTool::accept
virtual asg::AcceptData accept(const xAOD::IParticle *part) const =0
accept with pointer to IParticle so as to not hide the IAsgSelectionTool one
JetPileupTag::JetVertexNNTagger::decorate
virtual StatusCode decorate(const xAOD::JetContainer &jetCont) const override
Decorate a jet collection without otherwise modifying it.
Definition: JetVertexNNTagger.cxx:146
ST::SUSYObjDef_xAOD::m_ZtagConfig
std::string m_ZtagConfig
Definition: SUSYObjDef_xAOD.h:549
ST::SUSYObjDef_xAOD::m_eleBaselineCrackVeto
bool m_eleBaselineCrackVeto
Definition: SUSYObjDef_xAOD.h:682
CP::IIsolationCorrectionTool::isAffectedBySystematic
virtual bool isAffectedBySystematic(const CP::SystematicVariation &systematic) const =0
Declare the interface that this class provides.
ST::SUSYObjDef_xAOD::m_mud0sig
double m_mud0sig
Definition: SUSYObjDef_xAOD.h:700
Trig::IMatchingTool::match
virtual bool match(const xAOD::IParticle &recoObject, const std::string &chain, double matchThreshold=0.1, bool rerun=false) const =0
single object trigger matching. matchThreshold is typically the deltaR requirement to obtain positive...
ST::SUSYObjDef_xAOD::m_muIsoHighPt_WP
std::string m_muIsoHighPt_WP
Definition: SUSYObjDef_xAOD.h:663
ST::SUSYObjDef_xAOD::m_murequirepassedHighPtCuts
bool m_murequirepassedHighPtCuts
Definition: SUSYObjDef_xAOD.h:704
ST::SUSYObjDef_xAOD::m_muonHighPtIsolationSFTool
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonHighPtIsolationSFTool
Definition: SUSYObjDef_xAOD.h:864
ST::SUSYObjDef_xAOD::m_photonIdBaseline
std::string m_photonIdBaseline
Definition: SUSYObjDef_xAOD.h:646
ST::SUSYObjDef_xAOD::treatAsYear
int treatAsYear(const int runNumber=-1) const override final
Definition: SUSYObjDef_xAOD.cxx:3071
CONFIG_EG_EFF_TOOL
#define CONFIG_EG_EFF_TOOL(TOOLHANDLE, TOOLNAME, CORRFILE)
Definition: SUSYToolsInit.cxx:84
SG::DataProxy
Definition: DataProxy.h:45
CaloNoise_fillDB.mu
mu
Definition: CaloNoise_fillDB.py:53
ST::SUSYObjDef_xAOD::m_metGreedyPhotons
bool m_metGreedyPhotons
Definition: SUSYObjDef_xAOD.h:576
xAOD::bool
setBGCode setTAP setLVL2ErrorBits bool
Definition: TrigDecision_v1.cxx:60
CP::ISystematicsTool::applySystematicVariation
virtual StatusCode applySystematicVariation(const SystematicSet &systConfig)=0
effects: configure this tool for the given list of systematic variations.
ST::SUSYObjDef_xAOD::m_muonTrigSFTools
ToolHandleArray< CP::IMuonTriggerScaleFactors > m_muonTrigSFTools
Definition: SUSYObjDef_xAOD.h:866
ST::SUSYObjDef_xAOD::m_jetCleaningTool
asg::AnaToolHandle< IJetSelector > m_jetCleaningTool
Definition: SUSYObjDef_xAOD.h:824
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
ST::SUSYObjDef_xAOD::m_photonCrackVeto
bool m_photonCrackVeto
Definition: SUSYObjDef_xAOD.h:716
ST::SUSYObjDef_xAOD::autoconfigurePileupRWTool
StatusCode autoconfigurePileupRWTool(const std::string &PRWfilesDir="dev/PileupReweighting/share/", const std::string &PRWfileName="", bool usePathResolver=true, bool RPVLLmode=false, bool Combinedmode=false, const std::string &HFFilter="")
Definition: SUSYObjDef_xAOD.cxx:1001
ST::SUSYObjDef_xAOD::m_BtagKeyOverride
std::string m_BtagKeyOverride
Definition: SUSYObjDef_xAOD.h:670
asg::AnaToolHandle::empty
bool empty() const
whether this ToolHandle is completely empty, i.e.
python.compressB64.c
def c
Definition: compressB64.py:93
ST::SUSYObjDef_xAOD::m_commonPRWFileMC23a
std::string m_commonPRWFileMC23a
Definition: SUSYObjDef_xAOD.h:602
ST::SUSYObjDef_xAOD::m_orDoMuonJetGhostAssociation
bool m_orDoMuonJetGhostAssociation
Definition: SUSYObjDef_xAOD.h:772
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
ST::SUSYObjDef_xAOD::m_isoCorrTool
asg::AnaToolHandle< CP::IIsolationCorrectionTool > m_isoCorrTool
Definition: SUSYObjDef_xAOD.h:958
ST::SUSYObjDef_xAOD::m_defaultTruthJets
std::string m_defaultTruthJets
Definition: SUSYObjDef_xAOD.h:805
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
ST::SUSYObjDef_xAOD::m_tauDoTTM
bool m_tauDoTTM
Definition: SUSYObjDef_xAOD.h:724
ST::SUSYObjDef_xAOD::m_elecTrigSFTools
ToolHandleArray< IAsgElectronEfficiencyCorrectionTool > m_elecTrigSFTools
Definition: SUSYObjDef_xAOD.h:880
ST::SUSYObjDef_xAOD::m_tauTrigEffTool
std::vector< asg::AnaToolHandle< TauAnalysisTools::ITauEfficiencyCorrectionsTool > > m_tauTrigEffTool
Definition: SUSYObjDef_xAOD.h:910
ST::SUSYObjDef_xAOD::m_mcCampaign
std::string m_mcCampaign
Definition: SUSYObjDef_xAOD.h:594
xAOD::Jet
Jet_v1 Jet
Definition of the current "jet version".
Definition: Event/xAOD/xAODJet/xAODJet/Jet.h:17
ST::SUSYObjDef_xAOD::m_TopDecorName
std::string m_TopDecorName
Definition: SUSYObjDef_xAOD.h:547
ST::SUSYObjDef_xAOD::m_orDoMuonJet
bool m_orDoMuonJet
Definition: SUSYObjDef_xAOD.h:755
Trk::split
@ split
Definition: LayerMaterialProperties.h:38
ST::SUSYObjDef_xAOD::m_v_trigs16_cache_singleEle
std::vector< std::string > m_v_trigs16_cache_singleEle
Definition: SUSYObjDef_xAOD.h:453
BkgElectron
@ BkgElectron
Definition: TruthClasses.h:13
ST::SUSYObjDef_xAOD::m_commonPRWFileMC23d
std::string m_commonPRWFileMC23d
Definition: SUSYObjDef_xAOD.h:604
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
ST::SUSYObjDef_xAOD::GetInDetLargeD0Tracks
const xAOD::TrackParticleContainer & GetInDetLargeD0Tracks(const EventContext &ctx) const override final
Definition: SUSYObjDef_xAOD.cxx:3033
xAOD::FileMetaData_v1::dataType
@ dataType
Data type that's in the file [string].
Definition: FileMetaData_v1.h:64
doubleTestComp.j2
j2
Definition: doubleTestComp.py:22
xAOD::JetInput::Uncategorized
@ Uncategorized
Definition: JetContainerInfo.h:100
ST::SUSYObjDef_xAOD::m_upstreamTriggerMatching
bool m_upstreamTriggerMatching
Definition: SUSYObjDef_xAOD.h:522
InDetDD::electrons
@ electrons
Definition: InDetDD_Defs.h:17
ST::SUSYObjDef_xAOD::m_LRTuncTool
asg::AnaToolHandle< InDet::IInclusiveTrackFilterTool > m_LRTuncTool
Definition: SUSYObjDef_xAOD.h:967
ST::MET_Track
@ MET_Track
Definition: ISUSYObjDef_xAODTool.h:83
IMETSignificance::varianceMET
virtual StatusCode varianceMET(xAOD::MissingETContainer *metCont, float avgmu, const std::string &jetTermName, const std::string &softTermName, const std::string &totalMETName)=0
xAOD::JetAttribute::NegativeE
@ NegativeE
Definition: JetAttributes.h:84
ST::SUSYObjDef_xAOD::m_WtagConfig
std::string m_WtagConfig
Definition: SUSYObjDef_xAOD.h:548
ST::SUSYObjDef_xAOD::m_useTRUTH3
bool m_useTRUTH3
Definition: SUSYObjDef_xAOD.h:792
ST::SUSYObjDef_xAOD::m_EG_corrFNList
std::string m_EG_corrFNList
Definition: SUSYObjDef_xAOD.h:811
ST::SUSYObjDef_xAOD::m_acc_photonId
SG::ConstAccessor< char > m_acc_photonId
Definition: SUSYObjDef_xAOD.h:984
TSU::T
unsigned long long T
Definition: L1TopoDataTypes.h:35
match
bool match(std::string s1, std::string s2)
match the individual directories of two strings
Definition: hcg.cxx:356
ST::SUSYObjDef_xAOD::IsSignalTau
bool IsSignalTau(const xAOD::TauJet &input, const float ptcut, const float etacut) const override final
Definition: Taus.cxx:111
ST::SUSYObjDef_xAOD::m_photonIsolationSFTool
asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > m_photonIsolationSFTool
Definition: SUSYObjDef_xAOD.h:893
ST::SUSYObjDef_xAOD::isTrigInTDT
bool isTrigInTDT(std::scoped_lock< std::mutex > &lock, const std::string &triggerName) const
Definition: Trigger.cxx:85
fitman.k
k
Definition: fitman.py:528
ST::SUSYObjDef_xAOD::m_muonSelectionTool
asg::AnaToolHandle< CP::IMuonSelectionTool > m_muonSelectionTool
Definition: SUSYObjDef_xAOD.h:856
ST::SUSYObjDef_xAOD::m_useSigLepForIsoCloseByOR
bool m_useSigLepForIsoCloseByOR
Definition: SUSYObjDef_xAOD.h:789
JSSWTopTaggerDNN::tag
virtual StatusCode tag(const xAOD::Jet &jet) const override
Decorate single jet with tagging info.
Definition: JSSWTopTaggerDNN.cxx:381
ST::SUSYObjDef_xAOD::m_eleBaselineEta
double m_eleBaselineEta
Definition: SUSYObjDef_xAOD.h:681
BremPhot
@ BremPhot
Definition: TruthClasses.h:92
CP::SystematicRegistry::getInstance
static SystematicRegistry & getInstance()
Get the singleton instance of the registry for the curren thread.
Definition: SystematicRegistry.cxx:25
AthAnalysisHelper::retrieveMetadata
static std::string retrieveMetadata(const std::string &folder, const std::string &key, const ServiceHandle< StoreGateSvc > &inputMetaStore)
method that always returns as a string you can use from, e.g, pyROOT with evt = ROOT....
Definition: AthAnalysisHelper.h:254
ST::SUSYObjDef_xAOD::m_egammaAmbiguityTool
asg::AnaToolHandle< IEGammaAmbiguityTool > m_egammaAmbiguityTool
Definition: SUSYObjDef_xAOD.h:901
ST::SUSYObjDef_xAOD::m_TopconfigReader
TEnv m_TopconfigReader
Definition: SUSYObjDef_xAOD.h:544
ST::SUSYObjDef_xAOD::m_prwActualMu2018File
std::string m_prwActualMu2018File
Definition: SUSYObjDef_xAOD.h:610
ST::SUSYObjDef_xAOD::m_doIsoSignal
bool m_doIsoSignal
Definition: SUSYObjDef_xAOD.h:784
xAOD::BTagging_v1::pb
bool pb(const std::string &taggername, double &value) const
Definition: BTagging_v1.cxx:360
ServiceHandle< IIncidentSvc >
ST::SUSYObjDef_xAOD::m_eleIsoHighPtThresh
double m_eleIsoHighPtThresh
Definition: SUSYObjDef_xAOD.h:651
ST::SUSYObjDef_xAOD::m_orBJetPtUpperThres
double m_orBJetPtUpperThres
Definition: SUSYObjDef_xAOD.h:777
ST::SUSYObjDef_xAOD::m_eleChID_WP
std::string m_eleChID_WP
Definition: SUSYObjDef_xAOD.h:652
ANA_MSG_DEBUG
#define ANA_MSG_DEBUG(xmsg)
Macro printing debug messages.
Definition: Control/AthToolSupport/AsgMessaging/AsgMessaging/MessageCheck.h:288
ST::SUSYObjDef_xAOD::m_trig2015combination_diPhoton
std::string m_trig2015combination_diPhoton
Definition: SUSYObjDef_xAOD.h:945
CP::ISystematicsTool::isAffectedBySystematic
virtual bool isAffectedBySystematic(const SystematicVariation &systematic) const =0
Declare the interface that this class provides.
asg::AsgMetadataTool::m_useIncidents
bool m_useIncidents
Definition: AsgMetadataTool.h:128
ST::SUSYObjDef_xAOD::m_isoTool
asg::AnaToolHandle< CP::IIsolationSelectionTool > m_isoTool
Definition: SUSYObjDef_xAOD.h:959
ST::SUSYObjDef_xAOD::m_JvtConfigRun3
std::string m_JvtConfigRun3
Definition: SUSYObjDef_xAOD.h:735
ST::SUSYObjDef_xAOD::m_defaultSyst
CP::SystematicSet m_defaultSyst
Definition: SUSYObjDef_xAOD.h:807
ST::SUSYObjDef_xAOD::IsBJetLoose
bool IsBJetLoose(const xAOD::Jet &input) const override final
Definition: Jets.cxx:645
ST::SUSYObjDef_xAOD::m_pmgSHnjetWeighter
asg::AnaToolHandle< IWeightTool > m_pmgSHnjetWeighter
Definition: SUSYObjDef_xAOD.h:972