ATLAS Offline Software
Loading...
Searching...
No Matches
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 Reference

#include <SUSYObjDef_xAOD.h>

Inheritance diagram for ST::SUSYObjDef_xAOD:

Public Types

enum  DataSource { Undefined = -1 , Data , FullSim , AtlfastII }
Definition of the StoreGate-like object's definition
typedef ServiceHandle< StoreGateSvc > MetaStore_t
 Type of the metadata store object in Athena.
typedef const ServiceHandle< StoreGateSvc > & MetaStorePtr_t
 Type of the metadata store pointer in standalone mode.

Public Member Functions

 SUSYObjDef_xAOD (const std::string &name)
 ~SUSYObjDef_xAOD ()
StatusCode initialize () override final
 Dummy implementation of the initialisation function.
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::Vertex * GetPrimVtx () 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 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 std::string &L1_name="L1_XE50") 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::ChainGroup * GetTrigChainGroup (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 > &, 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::EventInfo * GetEventInfo () 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::TrackParticleContainer & GetInDetLargeD0Tracks (const EventContext &ctx) const override final
const xAOD::TrackParticleContainer & GetInDetLargeD0GSFTracks (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::SystematicSet & currentSystematic () 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::SystInfo > getSystInfoList () 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 StatusCode sysInitialize ()
 Function initialising the tool in the correct way in Athena.
virtual void print () const
 Print the state of the tool.
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode sysStart () override
 Handle START transition.
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles.
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
void updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream & msg () const
bool msgLvl (const MSG::Level lvl) const
Functions providing access to the input/output metadata
MetaStorePtr_t inputMetaStore () const
 Accessor for the input metadata store.
MetaStorePtr_t outputMetaStore () const
 Accessor for the output metadata store.
Additional helper functions, not directly mimicking Athena
template<class T>
const T * getProperty (const std::string &name) const
 Get one of the tool's properties.
const std::string & msg_level_name () const __attribute__((deprecated))
 A deprecated function for getting the message level's name.
const std::string & getName (const void *ptr) const
 Get the name of an object that is / should be in the event store.
SG::sgkey_t getKey (const void *ptr) const
 Get the (hashed) key of an object that is in the event store.

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::MuonContainer * prompt_muons = nullptr
const xAOD::MuonContainer * lrt_muons = nullptr
const xAOD::ElectronContainer * prompt_electrons = nullptr
const xAOD::ElectronContainer * lrt_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
std::string getDefaultJetUncConfig ()
StatusCode 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
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.
Callback functions helping in metadata reading/writing
void setUseIncidents (const bool flag)
virtual void handle (const Incident &inc)
 Function receiving incidents from IncidentSvc/Event.
virtual StatusCode beginInputFile ()
 Function called when a new input file is opened.
virtual StatusCode endInputFile ()
 Function called when the currently open input file got completely processed.
virtual StatusCode beginEvent ()
 Function called when a new events is loaded.
virtual StatusCode metaDataStop ()
 Function called when the tool should write out its metadata.

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.
std::string m_jetUncertaintiesConfig
 Prefix for trigger matchiing container name.
std::string m_jetUncertaintiesAnalysisFile
std::string m_jetUncertaintiesCalibArea
std::string m_jetUncertaintiesMCType
std::string m_fatJetUncertaintiesMCType
bool m_jetUncertaintiesPDsmearing
bool m_useBtagging
bool m_useBtagging_trkJet
bool m_debug
bool m_strictConfigCheck
std::string m_badJetCut
std::string m_fatJetUncConfig
bool m_fatJetUncertaintiesPDsmearing
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
std::string m_fatUngroomedTruthJets
std::string m_fatTruthJets
bool m_getTruthGroomedJetValues
bool m_matchUngroomedParent
double m_dRTruthJet
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_commonPRWFileMC23a
std::string m_commonPRWFileMC23d
std::string m_commonPRWFileMC23e
std::string m_commonPRWFileMC23g
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
std::string m_prwActualMu2025File
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::map< int, int > m_tau_id_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_tauTagger
std::string m_tauId
std::string m_tauIdBaseline
bool m_tauEleId
bool m_tauEleIdBaseline
bool m_tauMuOLR
bool m_tauMuOLRBaseline
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_muTriggerSFCalibRelease
std::string m_muTriggerSFCalibFilename
std::string m_BtagWP
std::string m_BtagTagger
double m_BtagMinPt
std::string m_BtagSystStrategy
std::string m_EigenvectorReductionB
std::string m_EigenvectorReductionC
std::string m_EigenvectorReductionLight
bool m_BtagReadFromObject
std::string m_BtagWP_trkJet
std::string m_BtagTagger_trkJet
double m_BtagMinPt_trkJet
bool m_BtagReadFromObject_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_eleEffMapFilePathTriggerRun2
std::string m_eleEffMapFilePathTriggerRun3
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
std::string m_tauInputFile
std::string m_tauInputFileBaseline
bool m_tauDoTTM
std::string m_tauSmearingToolRecommendationTag
std::string m_tauEffToolRecommendationTag
bool m_ApplyMVATESQualityCheck
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.
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
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::vector< CP::SystematicSet > m_fatjetFFSmearingSyst
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< IJetCalibrationTool > m_jetCalibTool
asg::AnaToolHandle< IJetCalibrationTool > m_jetFatCalibTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_jetUncertaintiesTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_jetUncertaintiesPDSmearTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_fatjetUncertaintiesTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_fatjetUncertaintiesPDSmearTool
asg::AnaToolHandle< ICPJetCorrectionTool > m_fatjetFFSmearingTool
asg::AnaToolHandle< IJetSelector > m_jetCleaningTool
asg::AnaToolHandle< JetPileupLabelingTool > m_jetPileupLabelingTool
asg::AnaToolHandle< JetVertexTaggerTool > m_jetJvtMomentTool
asg::AnaToolHandle< JetPileupTag::JetVertexNNTagger > m_jetNNJvtMomentTool
asg::AnaToolHandle< IAsgSelectionTool > m_jetNNJvtSelectionTool
asg::AnaToolHandle< CP::IJvtEfficiencyTool > m_jetNNJvtEfficiencyTool
asg::AnaToolHandle< IAsgSelectionTool > m_jetfJvtSelectionTool
asg::AnaToolHandle< CP::IJvtEfficiencyTool > m_jetfJvtEfficiencyTool
asg::AnaToolHandle< SmoothedWZTagger > m_WTaggerTool
asg::AnaToolHandle< SmoothedWZTagger > m_ZTaggerTool
asg::AnaToolHandle< JSSWTopTaggerDNN > m_TopTaggerTool
asg::AnaToolHandle< JetTruthLabelingTool > m_jetTruthLabelingTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_WTagjetUncertaintiesTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_ZTagjetUncertaintiesTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_TopTagjetUncertaintiesTool
SG::ReadDecorHandleKey< xAOD::JetContainer > m_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::IMuonSelectionTool > m_muonSelectionTool
asg::AnaToolHandle< CP::IMuonSelectionTool > m_muonSelectionHighPtTool
asg::AnaToolHandle< CP::IMuonSelectionTool > m_muonSelectionToolBaseline
asg::AnaToolHandle< CP::IMuonCalibrationAndSmearingTool > m_muonCalibTool
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonEfficiencySFTool
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonEfficiencyBMHighPtSFTool
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonTTVAEfficiencySFTool
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonIsolationSFTool
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonHighPtIsolationSFTool
asg::AnaToolHandle< CP::IMuonTriggerScaleFactors > m_muonTriggerSFTool
ToolHandleArray< CP::IMuonTriggerScaleFactors > m_muonTrigSFTools
asg::AnaToolHandle< CP::IMuonLRTOverlapRemovalTool > m_muonLRTORTool
SG::WriteHandleKey< xAOD::MuonContainer > m_outMuonLocation {this, "OutputMuonLocation", "StdWithLRTMuons", "name of the muon container to write"}
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_reco
 Combined muon collection.
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_id
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_trig_singleLep
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_trigEff_singleLep
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_iso
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_isoHighPt
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_chf
std::vector< asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > > m_elecEfficiencySFTool_trig_mixLep
std::vector< asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > > m_elecEfficiencySFTool_trigEff_mixLep
ToolHandleArray< IAsgElectronEfficiencyCorrectionTool > m_elecTrigSFTools
ToolHandleArray< IAsgElectronEfficiencyCorrectionTool > m_elecTrigEffTools
asg::AnaToolHandle< CP::IElectronLRTOverlapRemovalTool > m_elecLRTORTool
SG::WriteHandleKey< xAOD::ElectronContainer > m_outElectronLocation {this, "OutputElectronLocation", "StdWithLRTElectrons", "name of the muon container to write"}
asg::AnaToolHandle< CP::IEgammaCalibrationAndSmearingTool > m_egammaCalibTool
 Combined electron collection.
asg::AnaToolHandle< IAsgElectronLikelihoodTool > m_elecSelLikelihood
asg::AnaToolHandle< IAsgElectronLikelihoodTool > m_elecSelLikelihoodBaseline
asg::AnaToolHandle< IAsgPhotonIsEMSelector > m_photonSelIsEM
asg::AnaToolHandle< IAsgPhotonIsEMSelector > m_photonSelIsEMBaseline
asg::AnaToolHandle< IAsgDeadHVCellRemovalTool > m_deadHVTool
asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > m_photonEfficiencySFTool
asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > m_photonIsolationSFTool
asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > m_photonTriggerSFTool
std::vector< asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > > m_photonEfficiencySFTool_trigSF_AsymDiphoton
std::vector< asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > > m_photonEfficiencySFTool_trigEff_AsymDiphoton
ToolHandleArray< IAsgPhotonEfficiencyCorrectionTool > m_photonTrigSFTools
ToolHandleArray< IAsgPhotonEfficiencyCorrectionTool > m_photonTrigEffTools
asg::AnaToolHandle< IEGammaAmbiguityTool > m_egammaAmbiguityTool
asg::AnaToolHandle< IAsgElectronLikelihoodTool > m_elecChargeIDSelectorTool
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecChargeEffCorrTool
asg::AnaToolHandle< TauAnalysisTools::ITauSelectionTool > m_tauSelTool
asg::AnaToolHandle< TauAnalysisTools::ITauSelectionTool > m_tauSelToolBaseline
asg::AnaToolHandle< TauAnalysisTools::ITauSmearingTool > m_tauSmearingTool
asg::AnaToolHandle< TauAnalysisTools::ITauTruthMatchingTool > m_tauTruthMatch
asg::AnaToolHandle< TauAnalysisTools::ITauEfficiencyCorrectionsTool > m_tauEffTool
std::vector< asg::AnaToolHandle< TauAnalysisTools::ITauEfficiencyCorrectionsTool > > m_tauTrigEffTool
asg::AnaToolHandle< IBTaggingEfficiencyTool > m_btagEffTool
asg::AnaToolHandle< IBTaggingSelectionTool > m_btagSelTool
asg::AnaToolHandle< IBTaggingSelectionTool > m_btagSelTool_OR
asg::AnaToolHandle< IBTaggingEfficiencyTool > m_btagEffTool_trkJet
asg::AnaToolHandle< IBTaggingSelectionTool > m_btagSelTool_trkJet
asg::AnaToolHandle< IMETMaker > m_metMaker
asg::AnaToolHandle< IMETSystematicsTool > m_metSystTool
asg::AnaToolHandle< IMETSignificance > m_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
std::string m_trig2023combination_singleLep
std::string m_trig2024combination_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< ITrigGlobalEfficiencyCorrectionTool > m_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< ITrigGlobalEfficiencyCorrectionTool > m_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< ITrigGlobalEfficiencyCorrectionTool > m_trigGlobalEffCorrTool_diPhoton
asg::AnaToolHandle< TrigConf::ITrigConfigTool > m_trigConfTool
asg::AnaToolHandle< Trig::TrigDecisionTool > m_trigDecTool
asg::AnaToolHandle< Trig::IMatchingTool > m_trigMatchingTool
asg::AnaToolHandle< Trig::IMatchScoringTool > m_trigMatchScoringTool
asg::AnaToolHandle< Trig::IMatchScoringTool > m_trigDRScoringTool
asg::AnaToolHandle< CP::IIsolationCorrectionTool > m_isoCorrTool
asg::AnaToolHandle< CP::IIsolationSelectionTool > m_isoTool
asg::AnaToolHandle< CP::IIsolationSelectionTool > m_isoBaselineTool
asg::AnaToolHandle< CP::IIsolationSelectionTool > m_isoHighPtTool
asg::AnaToolHandle< CP::IIsolationCloseByCorrectionTool > m_isoCloseByTool
asg::AnaToolHandle< CP::IPileupReweightingTool > m_prwTool
asg::AnaToolHandle< InDet::IInclusiveTrackFilterTool > m_LRTuncTool
asg::AnaToolHandle< ORUtils::IOverlapTool > m_tauJetORtool
ORUtils::ToolBox m_orToolbox
asg::AnaToolHandle< IWeightTool > m_pmgSHnjetWeighter
asg::AnaToolHandle< IWeightTool > m_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< StoreGateSvc > StoreGateSvc_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, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey>

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_trigs23_cache_singleEle
std::vector< std::string > m_v_trigs24_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_trigs23_cache_singleLep
std::vector< std::string > m_v_trigs24_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::TrackParticleContainer > m_LRTCollectionName {this, "LRTCollectionName", "InDetLargeD0TrackParticles", "LRT collection name"}
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_GSFLRTCollectionName {this, "GSFLRTCollectionName", "LRTGSFTrackParticles", "GSF LRT collection name"}
MetaStore_t m_inputMetaStore
 Object accessing the input metadata store.
MetaStore_t m_outputMetaStore
 Object accessing the output metadata store.
bool m_beginInputFileCalled
 Flag helping to discover when the tool misses the opening of the first input file.
bool m_useIncidents
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default).
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * > m_vhka
bool m_varHandleArraysDeclared

Detailed Description

Definition at line 141 of file SUSYObjDef_xAOD.h.

Member Typedef Documentation

◆ MetaStore_t

typedef ServiceHandle< StoreGateSvc > asg::AsgMetadataTool::MetaStore_t
inherited

Type of the metadata store object in Athena.

Definition at line 66 of file AsgMetadataTool.h.

◆ MetaStorePtr_t

typedef const ServiceHandle< StoreGateSvc >& asg::AsgMetadataTool::MetaStorePtr_t
inherited

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 376 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ DataSource

enum ST::ISUSYObjDef_xAODTool::DataSource
inherited
Enumerator
Undefined 
Data 
FullSim 
AtlfastII 

Definition at line 477 of file ISUSYObjDef_xAODTool.h.

477 {
478 Undefined = -1,
479 Data,
480 FullSim,
481 AtlfastII
482 };
ST::ISUSYObjDef_xAODTool::Undefined
@ Undefined
Definition ISUSYObjDef_xAODTool.h:478
ST::ISUSYObjDef_xAODTool::FullSim
@ FullSim
Definition ISUSYObjDef_xAODTool.h:480
ST::ISUSYObjDef_xAODTool::AtlfastII
@ AtlfastII
Definition ISUSYObjDef_xAODTool.h:481
ST::ISUSYObjDef_xAODTool::Data
@ Data
Definition ISUSYObjDef_xAODTool.h:479

Constructor & Destructor Documentation

◆ SUSYObjDef_xAOD()

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

Definition at line 100 of file SUSYObjDef_xAOD.cxx.

101 : asg::AsgMetadataTool( name ),
102 m_dataSource(Undefined),
103 m_jetInputType(xAOD::JetInput::Uncategorized),
104 m_force_noElId(false),
105 m_force_noMuId(false),
106 m_doTTVAsf(true),
107 m_upstreamTriggerMatching(false),
108 m_trigMatchingPrefix(""),
109 m_useBtagging(false),
110 m_useBtagging_trkJet(false),
111 m_debug(false),
112 m_strictConfigCheck(false),
113 m_badJetCut(""),
114 m_fatJetUncConfig(""),
115 m_fatJetUncVars(""),
116 m_WDecorName(""),
117 m_ZDecorName(""),
118 m_TopDecorName(""),
119 m_WtagConfig(""),
120 m_ZtagConfig(""),
121 m_ToptagConfig(""),
122 m_WZTaggerCalibArea(""),
123 m_TopTaggerCalibArea(""),
124 m_WTagUncConfig(""),
125 m_ZTagUncConfig(""),
126 m_TopTagUncConfig(""),
127 m_JetTruthLabelName(""),
128 m_fatUngroomedTruthJets(""),
129 m_fatTruthJets(""),
130 m_getTruthGroomedJetValues(false),
131 m_matchUngroomedParent(false),
132 m_dRTruthJet(-99),
133 m_tool_init(false),
134 m_subtool_init(false),
135 // set dummies for configuration
136 m_eleTerm(""),
137 m_gammaTerm(""),
138 m_tauTerm(""),
139 m_jetTerm(""),
140 m_muonTerm(""),
141 m_inputMETSuffix(""),
142 m_outMETTerm(""),
143 m_metRemoveOverlappingCaloTaggedMuons(true),
144 m_metDoSetMuonJetEMScale(true),
145 m_metDoRemoveMuonJets(true),
146 m_metUseGhostMuons(false),
147 m_metDoMuonEloss(false),
148 m_metGreedyPhotons(false),
149 m_metVeryGreedyPhotons(false),
150 m_metsysConfigPrefix(""),
151 m_trkMETsyst(true),
152 m_caloMETsyst(false),
153 m_softTermParam(-99),
154 m_treatPUJets(true),
155 m_doPhiReso(true),
156 m_autoconfigPRW(false),
157 m_autoconfigPRWPath(""),
158 m_autoconfigPRWFile(""),
159 m_autoconfigPRWCombinedmode(false),
160 m_autoconfigPRWRPVmode(false),
161 m_autoconfigPRWRtags(""),
162 m_mcCampaign(""),
163 m_mcChannel(-99),
164 m_useCommonPRWFiles(false),
165 m_commonPRWFileMC20a(""),
166 m_commonPRWFileMC20d(""),
167 m_commonPRWFileMC20e(""),
168 m_commonPRWFileMC23a(""),
169 m_commonPRWFileMC23d(""),
170 m_commonPRWFileMC23e(""),
171 m_commonPRWFileMC23g(""),
172 m_prwDataSF(-99.),
173 m_prwDataSF_UP(-99.),
174 m_prwDataSF_DW(-99.),
175 m_runDepPrescaleWeightPRW(false),
176 m_electronTriggerSFStringSingle(""),
177 m_eleId(""),
178 m_eleIdBaseline(""),
179 m_eleConfig(""),
180 m_eleConfigBaseline(""),
181 m_eleBaselineIso_WP(""),
182 m_eleIdExpert(false),
183 m_muId(static_cast<int>(xAOD::Muon::Quality::VeryLoose)),
184 m_muIdBaseline(static_cast<int>(xAOD::Muon::Quality::VeryLoose)),
185 m_photonId(""),
186 m_photonIdBaseline(""),
187 m_tauTagger(""),
188 m_tauId(""),
189 m_tauIdBaseline(""),
190 m_tauEleId(true),
191 m_tauEleIdBaseline(true),
192 m_tauMuOLR(false),
193 m_tauMuOLRBaseline(false),
194 m_eleIso_WP(""),
195 m_eleIsoHighPt_WP(""),
196 m_eleIsoHighPtThresh(-99.),
197 m_eleChID_WP(""),
198 m_eleLRT_strat(-99),
199 m_eleChIso(true),
200 m_eleChID_signal(false),
201 m_runECIS(false),
202 m_photonBaselineIso_WP(""),
203 m_photonIso_WP(""),
204 m_photonTriggerName(""),
205 m_muBaselineIso_WP(""),
206 m_muIso_WP(""),
207 m_muIsoHighPt_WP(""),
208 m_muIsoHighPtThresh(-99.),
209 m_muHighPtExtraSmear(false),
210 m_muEffCorrForce1D(false),
211 m_BtagWP(""),
212 m_BtagTagger(""),
213 m_BtagMinPt(-99.),
214 m_BtagSystStrategy(""),
215 m_EigenvectorReductionB(""),
216 m_EigenvectorReductionC(""),
217 m_EigenvectorReductionLight(""),
218 m_BtagReadFromObject(false),
219 m_BtagWP_trkJet(""),
220 m_BtagTagger_trkJet(""),
221 m_BtagMinPt_trkJet(-99.),
222 m_BtagReadFromObject_trkJet(false),
223 //configurable cuts here
224 m_eleBaselinePt(-99.),
225 m_eleBaselineEta(-99.),
226 m_eleBaselineCrackVeto(false),
227 m_elePt(-99.),
228 m_eleEta(-99.),
229 m_eleCrackVeto(false),
230 m_eled0sig(-99.),
231 m_elez0(-99.),
232 m_elebaselined0sig(-99.),
233 m_elebaselinez0(-99),
234 m_eleAllowRun3TrigSFFallback(false),
235 m_eleForceFullSimCalib(false),
236 //
237 m_muBaselinePt(-99.),
238 m_muBaselineEta(-99.),
239 m_muPt(-99.),
240 m_muEta(-99.),
241 m_mud0sig(-99.),
242 m_muz0(-99.),
243 m_mubaselined0sig(-99.),
244 m_mubaselinez0(-99.),
245 m_murequirepassedHighPtCuts(false),
246 m_muCosmicz0(-99.),
247 m_muCosmicd0(-99.),
248 m_badmuQoverP(-99.),
249 m_muCalibrationMode(-99.),
250 //
251 m_photonBaselinePt(-99.),
252 m_photonBaselineEta(-99.),
253 m_photonEta(-99.),
254 m_photonPt(-99.),
255 m_photonBaselineCrackVeto(true),
256 m_photonCrackVeto(true),
257 m_photonAllowLate(false),
258 //
259 m_tauPrePtCut(-99.),
260 m_tauPt(-99.),
261 m_tauEta(-99.),
262 m_tauConfigPath(""),
263 m_tauConfigPathBaseline(""),
264 m_tauInputFile(""),
265 m_tauInputFileBaseline(""),
266 m_tauDoTTM(false),
267 m_tauSmearingToolRecommendationTag(""),
268 m_tauEffToolRecommendationTag(""),
269 m_ApplyMVATESQualityCheck(true),
270 //
271 m_jetPt(-99.),
272 m_jetEta(-99.),
273 m_jetJvt(-99.),
274 m_JvtWP(""),
275 m_JvtPtMax(-99.),
276 m_JvtConfigRun2(""),
277 m_JvtConfigRun3(""),
278 m_trkJetPt(-99.),
279 m_trkJetEta(-99.),
280 m_doFwdJVT(false),
281 m_fJvtWP(""),
282 m_fJvtPtMax(-99.),
283 m_fJvtEtaMin(-99.),
284 m_fJvtConfigRun2(""),
285 m_fJvtConfigRun3(""),
286 m_JMScalib(false),
287 //
288 m_orDoTau(false),
289 m_orDoPhoton(false),
290 m_orDoEleJet(true),
291 m_orDoElEl(false),
292 m_orDoElMu(false),
293 m_orDoMuonJet(true),
294 m_orDoBjet(false),
295 m_orDoElBjet(true),
296 m_orDoMuBjet(true),
297 m_orDoTauBjet(true),
298 m_orDoBoostedElectron(false),
299 m_orBoostedElectronC1(-999.), // set to positive value to activate
300 m_orBoostedElectronC2(-999.), // set to positive value to activate
301 m_orBoostedElectronMaxConeSize(-999.), // set to positive value to activate
302 m_orDoBoostedMuon(true),
303 m_orBoostedMuonC1(-999.), // set to positive value to activate
304 m_orBoostedMuonC2(-999.), // set to positive value to activate
305 m_orBoostedMuonMaxConeSize(-999.), // set to positive value to activate
306 m_orApplyRelPt(false),
307 m_orMuJetPtRatio(-999.),
308 m_orMuJetTrkPtRatio(-999.),
309 m_orMuJetInnerDR(-999),
310 m_orDoMuonJetGhostAssociation(true),
311 m_orRemoveCaloMuons(true),
312 m_orBtagWP(""),
313 m_orInputLabel(""),
314 m_orPhotonFavoured(false),
315 m_orBJetPtUpperThres(-999.),
316 m_orLinkOverlapObjects(false),
317 m_orDoFatjets(false),
318 m_EleFatJetDR(-999.),
319 m_JetFatJetDR(-999.),
320 m_doIsoSignal(true),
321 m_doElIsoSignal(true),
322 m_doPhIsoSignal(true),
323 m_doMuIsoSignal(true),
324
325 m_useSigLepForIsoCloseByOR(false),
326 m_IsoCloseByORpassLabel(""),
327
328 m_slices(std::map<std::string,bool>()),
329 m_isRun3(false),
330 m_isPHYSLITE(false),
331
332 m_metJetSelection(""),
333 m_fatJets(""),
334 //
335 m_currentSyst(),
336 m_fatjetFFSmearingSyst(),
337 m_EG_corrModel(""),
338 m_EG_corrFNList(""),
339 m_applyJVTCut(true),
340 //
341 // set toolhandles empty by default
342 m_jetCalibTool(""),
343 m_jetFatCalibTool(""),
344 m_jetUncertaintiesTool(""),
345 m_jetUncertaintiesPDSmearTool(""),
346 m_fatjetUncertaintiesTool(""),
347 m_fatjetUncertaintiesPDSmearTool(""),
348 m_fatjetFFSmearingTool(""),
349 m_jetCleaningTool(""),
350 m_jetPileupLabelingTool(""),
351 m_jetJvtMomentTool(""),
352 m_jetNNJvtMomentTool(""),
353 m_jetNNJvtSelectionTool(""),
354 m_jetNNJvtEfficiencyTool(""),
355 m_jetfJvtSelectionTool(""),
356 m_jetfJvtEfficiencyTool(""),
357 //
358 m_WTaggerTool(""),
359 m_ZTaggerTool(""),
360 m_TopTaggerTool(""),
361 m_jetTruthLabelingTool(""),
362 m_WTagjetUncertaintiesTool(""),
363 m_ZTagjetUncertaintiesTool(""),
364 m_TopTagjetUncertaintiesTool(""),
365 //
366 m_muonSelectionTool(""),
367 m_muonSelectionHighPtTool(""),
368 m_muonSelectionToolBaseline(""),
369 m_muonCalibTool(""),
370 m_muonEfficiencySFTool(""),
371 m_muonEfficiencyBMHighPtSFTool(""),
372 m_muonTTVAEfficiencySFTool(""),
373 m_muonIsolationSFTool(""),
374 m_muonHighPtIsolationSFTool(""),
375 m_muonTriggerSFTool(""),
376 //
377 m_elecEfficiencySFTool_reco(""),
378 m_elecEfficiencySFTool_id(""),
379 m_elecEfficiencySFTool_trig_singleLep(""),
380 m_elecEfficiencySFTool_trigEff_singleLep(""),
381 m_elecEfficiencySFTool_iso(""),
382 m_elecEfficiencySFTool_isoHighPt(""),
383 //
384 m_egammaCalibTool(""),
385 m_elecSelLikelihood(""),
386 m_elecSelLikelihoodBaseline(""),
387 m_photonSelIsEM(""),
388 m_photonSelIsEMBaseline(""),
389 m_photonEfficiencySFTool(""),
390 m_photonIsolationSFTool(""),
391 m_photonTriggerSFTool(""),
392 m_egammaAmbiguityTool(""),
393 m_elecChargeIDSelectorTool(""),
394 m_elecChargeEffCorrTool(""),
395 //
396 m_tauSelTool(""),
397 m_tauSelToolBaseline(""),
398 m_tauSmearingTool(""),
399 m_tauTruthMatch(""),
400 m_tauEffTool(""),
401 //
402 m_btagEffTool(""),
403 m_btagSelTool(""),
404 m_btagSelTool_OR(""),
405 m_btagEffTool_trkJet(""),
406 m_btagSelTool_trkJet(""),
407 //
408 m_metMaker(""),
409 m_metSystTool(""),
410 m_metSignif(""),
411 //
412 m_trig2015combination_singleLep(""),
413 m_trig2016combination_singleLep(""),
414 m_trig2017combination_singleLep(""),
415 m_trig2018combination_singleLep(""),
416 m_trig2022combination_singleLep(""),
417 m_trig2023combination_singleLep(""),
418 m_trig2024combination_singleLep(""),
419 m_trigNToys_diLep(-99),
420 m_trig2015combination_diLep(""),
421 m_trig2016combination_diLep(""),
422 m_trig2017combination_diLep(""),
423 m_trig2018combination_diLep(""),
424 m_trig2022combination_diLep(""),
425 m_trigGlobalEffCorrTool_diLep(""),
426 m_trigNToys_multiLep(-99),
427 m_trig2015combination_multiLep(""),
428 m_trig2016combination_multiLep(""),
429 m_trig2017combination_multiLep(""),
430 m_trig2018combination_multiLep(""),
431 m_trig2022combination_multiLep(""),
432 m_trigGlobalEffCorrTool_multiLep(""),
433 m_trigNToys_diPhoton(-99),
434 m_trig2015combination_diPhoton(""),
435 m_trig2016combination_diPhoton(""),
436 m_trig2017combination_diPhoton(""),
437 m_trig2018combination_diPhoton(""),
438 m_trig2022combination_diPhoton(""),
439 m_trigGlobalEffCorrTool_diPhoton(""),
440 m_trigConfTool(""),
441 m_trigDecTool(""),
442 m_trigMatchingTool(""),
443 m_trigMatchScoringTool(""),
444 m_trigDRScoringTool(""),
445 //
446 m_isoCorrTool(""),
447 m_isoTool(""),
448 //disable m_isoToolLowPtPLV(""),
449 m_isoBaselineTool(""),
450 m_isoHighPtTool(""),
451 //
452 m_prwTool(""),
453 //
454 m_LRTuncTool(""),
455 //
456 m_orToolbox("ORToolbox",this),
457 //
458 m_pmgSHnjetWeighter(""),
459 m_pmgSHnjetWeighterWZ(""),
460 //
461 m_acc_eleIdBaseline("DFCommonElectronsLHLooseBL"),
462 m_acc_eleId("DFCommonElectronsLHTight"),
463 m_acc_photonIdBaseline("DFCommonPhotonsIsEMTight"),
464 m_acc_photonId("DFCommonPhotonsIsEMTight"),
465 //
466 m_acc_jetClean("DFCommonJets_jetClean_LooseBad")
467{
468 //General settings
469 declareProperty( "DataSource", m_dataSource = Undefined );
470 declareProperty( "DebugMode", m_debug );
471 declareProperty( "ConfigFile", m_configFile = "SUSYTools/SUSYTools_Default.conf" );
472 //Overlap Removal
473 declareProperty( "DoTauOR", m_orDoTau );
474 declareProperty( "DoPhotonOR", m_orDoPhoton );
475 declareProperty( "DoEleJetOR", m_orDoEleJet );
476 declareProperty( "DoElElOR", m_orDoElEl );
477 declareProperty( "DoElMuOR", m_orDoElMu );
478 declareProperty( "DoMuonJetOR", m_orDoMuonJet );
479 declareProperty( "DoBjetOR", m_orDoBjet );
480 declareProperty( "DoElBjetOR", m_orDoElBjet );
481 declareProperty( "DoMuBjetOR", m_orDoMuBjet );
482 declareProperty( "DoTauBjetOR", m_orDoTauBjet );
483 declareProperty( "UseBtagging", m_useBtagging );
484 declareProperty( "UseBtaggingTrkJet", m_useBtagging_trkJet );
485 declareProperty( "DoBoostedElectronOR", m_orDoBoostedElectron );
486 declareProperty( "BoostedElectronORC1", m_orBoostedElectronC1 );
487 declareProperty( "BoostedElectronORC2", m_orBoostedElectronC2 );
488 declareProperty( "BoostedElectronORMaxConeSize", m_orBoostedElectronMaxConeSize );
489 declareProperty( "DoBoostedMuonOR", m_orDoBoostedMuon );
490 declareProperty( "BoostedMuonORC1", m_orBoostedMuonC1 );
491 declareProperty( "BoostedMuonORC2", m_orBoostedMuonC2 );
492 declareProperty( "BoostedMuonORMaxConeSize", m_orBoostedMuonMaxConeSize );
493 declareProperty( "ORDoMuonJetGhostAssociation", m_orDoMuonJetGhostAssociation );
494 declareProperty( "ORRemoveCaloMuons", m_orRemoveCaloMuons );
495 declareProperty( "ORMuJetApplyRelPt", m_orApplyRelPt);
496 declareProperty( "ORMuJetPtRatio", m_orMuJetPtRatio);
497 declareProperty( "ORMuJetInnerDR", m_orMuJetInnerDR );
498 declareProperty( "ORJetTrkPtRatio", m_orMuJetTrkPtRatio);
499 declareProperty( "ORInputLabel", m_orInputLabel);
500 declareProperty( "ORPhotonFavoured", m_orPhotonFavoured);
501 declareProperty( "ORBJetPtUpperThres", m_orBJetPtUpperThres);
502 declareProperty( "ORLinkOverlapObjects", m_orLinkOverlapObjects);
503
504 declareProperty( "DoFatJetOR", m_orDoFatjets);
505 declareProperty( "OREleFatJetDR", m_EleFatJetDR);
506 declareProperty( "ORJetFatJetDR", m_JetFatJetDR);
507 declareProperty( "TriggerUpstreamMatching", m_upstreamTriggerMatching, "Use alternative trigger matching tool based on upstream (in-derivation) matching");
508 declareProperty( "TriggerMatchingPrefix", m_trigMatchingPrefix, "Prefix for trigger matching containers (Analysis for PHSYLITE derivations");
509
510 //--- Object definitions
511 //MET
512 declareProperty( "METEleTerm", m_eleTerm );
513 declareProperty( "METGammaTerm", m_gammaTerm );
514 declareProperty( "METTauTerm", m_tauTerm );
515 declareProperty( "METJetTerm", m_jetTerm );
516 declareProperty( "METMuonTerm", m_muonTerm );
517 declareProperty( "METInputSuffix", m_inputMETSuffix );
518 declareProperty( "METOutputTerm", m_outMETTerm );
519 declareProperty( "METDoTrkSyst", m_trkMETsyst );
520 declareProperty( "METDoCaloSyst", m_caloMETsyst );
521 declareProperty( "METDoTrkJetSyst", m_trkJetsyst );
522 declareProperty( "METJetSelection", m_metJetSelection );
523 declareProperty( "METSysConfigPrefix", m_metsysConfigPrefix );
524
525 declareProperty( "METRemoveORCaloTaggedMuons", m_metRemoveOverlappingCaloTaggedMuons);
526 declareProperty( "METDoSetMuonJetEMScale", m_metDoSetMuonJetEMScale);
527 declareProperty( "METDoRemoveMuonJets", m_metDoRemoveMuonJets );
528 declareProperty( "METUseGhostMuons", m_metUseGhostMuons );
529 declareProperty( "METDoMuonEloss", m_metDoMuonEloss );
530 declareProperty( "METDoGreedyPhotons", m_metGreedyPhotons );
531 declareProperty( "METDoVeryGreedyPhotons", m_metVeryGreedyPhotons );
532
533
534 declareProperty( "SoftTermParam", m_softTermParam);
535 declareProperty( "TreatPUJets", m_treatPUJets);
536 declareProperty( "DoPhiReso", m_doPhiReso);
537
538 //JETS
539 declareProperty( "JetInputType", m_jetInputType );
540
541 declareProperty( "FwdJetDoJVT", m_doFwdJVT );
542
543 declareProperty( "JetJMSCalib", m_JMScalib );
544 declareProperty( "JetLargeRcollection", m_fatJets );
545
546 //BTAGGING
547 declareProperty( "BtagTagger", m_BtagTagger);
548 declareProperty( "BtagWPOR", m_orBtagWP); //the one used in the Overlap Removal
549 declareProperty( "BtagWP", m_BtagWP); //the one used in FillJet() afterwards
550 declareProperty( "BtagMinPt", m_BtagMinPt); // minimum jetPt cut (MR31061) >=20 GeV EM jets & >=10 GeV TrackJets (not calibrated below)
551 declareProperty( "BtagCalibPath", m_bTaggingCalibrationFilePath);
552 declareProperty( "BtagReadFromObject", m_BtagReadFromObject);
553 declareProperty( "BtagTaggerTrkJet", m_BtagTagger_trkJet);
554 declareProperty( "BtagMinPtTrkJet", m_BtagMinPt_trkJet); // minimum jetPt cut (MR31061) >=20 GeV EM jets & >=10 GeV TrackJets (not calibrated below)
555 declareProperty( "BtagWPTrkJet", m_BtagWP_trkJet); //the one used in FillTrackJet() afterwards
556 declareProperty( "BtagReadFromObjectTrkJet", m_BtagReadFromObject_trkJet);
557 //ELECTRONS
558 declareProperty( "EleBaselinePt", m_eleBaselinePt);
559 declareProperty( "ElePt", m_elePt);
560 declareProperty( "EleBaselineEta", m_eleBaselineEta);
561 declareProperty( "EleEta", m_eleEta);
562 declareProperty( "EleBaselineId", m_eleIdBaseline);
563 declareProperty( "EleBaselineConfig", m_eleConfigBaseline);
564 declareProperty( "EleBaselineCrackVeto", m_eleBaselineCrackVeto);
565 declareProperty( "EleId", m_eleId);
566 declareProperty( "EleConfig", m_eleConfig);
567 declareProperty( "EleIso", m_eleIso_WP);
568 declareProperty( "EleIsoHighPt", m_eleIsoHighPt_WP);
569 declareProperty( "EleIsoHighPtThresh", m_eleIsoHighPtThresh);
570 declareProperty( "EleCFT", m_eleChID_WP);
571 declareProperty( "EleCFTIso", m_eleChIso);
572 declareProperty( "EleCFTSignal", m_eleChID_signal);
573 declareProperty( "EleD0sig", m_eled0sig);
574 declareProperty( "EleZ0", m_elez0);
575 declareProperty( "EleBaselineD0sig", m_elebaselined0sig);
576 declareProperty( "EleBaselineZ0", m_elebaselinez0);
577 declareProperty( "EleCrackVeto", m_eleCrackVeto);
578 declareProperty( "EleForceNoId", m_force_noElId );
579 declareProperty( "EleEffMapFilePath", m_eleEffMapFilePath);
580 declareProperty( "EleAllowRun3TrigSFFallback", m_eleAllowRun3TrigSFFallback);
581 declareProperty( "EleForceFullSimCalib", m_eleForceFullSimCalib);
582
583 //MUONS
584 declareProperty( "MuonBaselinePt", m_muBaselinePt);
585 declareProperty( "MuonPt", m_muPt);
586 declareProperty( "MuonBaselineEta", m_muBaselineEta);
587 declareProperty( "MuonEta", m_muEta);
588 declareProperty( "MuonBaselineId", m_muIdBaseline);
589 declareProperty( "MuonId", m_muId);
590 declareProperty( "MuonIso", m_muIso_WP);
591 declareProperty( "MuonIsoHighPt", m_muIsoHighPt_WP);
592 declareProperty( "MuonIsoHighPtThresh", m_muIsoHighPtThresh);
593 declareProperty( "MuonHighPtExtraSmear", m_muHighPtExtraSmear);
594 declareProperty( "MuonEffCorrForce1D", m_muEffCorrForce1D);
595 declareProperty( "MuonD0sig", m_mud0sig);
596 declareProperty( "MuonZ0", m_muz0);
597 declareProperty( "MuonBaselineD0sig", m_mubaselined0sig);
598 declareProperty( "MuonBaselineZ0", m_mubaselinez0);
599 declareProperty( "MuonRequireHighPtCuts", m_murequirepassedHighPtCuts);
600 declareProperty( "MuonForceNoId", m_force_noMuId );
601 declareProperty( "MuonTTVASF", m_doTTVAsf );
602 declareProperty( "MuonCalibrationMode", m_muCalibrationMode);
603 //MUONS TRIGGER SCALE FACTOR
604 declareProperty( "MuonTriggerSFCalibRelease", m_muTriggerSFCalibRelease );
605 declareProperty( "MuonTriggerSFCalibFilename", m_muTriggerSFCalibFilename );
606 //PHOTONS
607 declareProperty( "PhotonBaselinePt", m_photonBaselinePt);
608 declareProperty( "PhotonPt", m_photonPt);
609 declareProperty( "PhotonBaselineEta", m_photonBaselineEta);
610 declareProperty( "PhotonEta", m_photonEta);
611 declareProperty( "PhotonBaselineId", m_photonIdBaseline);
612 declareProperty( "PhotonId", m_photonId);
613 declareProperty( "PhotonIso", m_photonIso_WP);
614 declareProperty( "PhotonTriggerName", m_photonTriggerName);
615 declareProperty( "PhotonBaselineCrackVeto", m_photonBaselineCrackVeto);
616 declareProperty( "PhotonCrackVeto", m_photonCrackVeto);
617 declareProperty( "PhotonAllowLate", m_photonAllowLate);
618
619 //TAUS
620 declareProperty( "TauTagger", m_tauTagger);
621 declareProperty( "TauBaselineId", m_tauIdBaseline);
622 declareProperty( "TauId", m_tauId);
623 declareProperty( "TauBaselineEleId", m_tauEleIdBaseline);
624 declareProperty( "TauEleId", m_tauEleId);
625 declareProperty( "TauBaselineMuOLR", m_tauMuOLRBaseline);
626 declareProperty( "TauMuOLR", m_tauMuOLR);
627 declareProperty( "TauIdConfigPathBaseline", m_tauConfigPathBaseline);
628 declareProperty( "TauIdConfigPath", m_tauConfigPath);
629 declareProperty( "TauIdInputFileBaseline", m_tauInputFileBaseline);
630 declareProperty( "TauIdInputFile", m_tauInputFile);
631 declareProperty( "TauDoTruthMatching", m_tauDoTTM);
632 declareProperty( "TauSmearingToolRecommendationTag", m_tauSmearingToolRecommendationTag);
633 declareProperty( "TauEffToolRecommendationTag", m_tauEffToolRecommendationTag);
634 declareProperty( "TauMVATESQualityCheck", m_ApplyMVATESQualityCheck);
635
636 //Leptons
637 declareProperty( "SigLepRequireIso", m_doIsoSignal ); //leave here for back-compatibility
638 declareProperty( "SigElRequireIso", m_doElIsoSignal );
639 declareProperty( "SigMuRequireIso", m_doMuIsoSignal );
640 declareProperty( "SigPhRequireIso", m_doPhIsoSignal );
641
642 //Isolation correction for leptons and photons
643 declareProperty( "UseSigLepForIsoCloseByOR", m_useSigLepForIsoCloseByOR );
644 declareProperty( "IsoCloseByORpassLabel", m_IsoCloseByORpassLabel );
645
646 //--- Tools configuration
647 //PRW
648 declareProperty( "AutoconfigurePRWTool", m_autoconfigPRW );
649 declareProperty( "AutoconfigurePRWToolPath", m_autoconfigPRWPath ); // e.g. dev/PileupReweighting/share/
650 declareProperty( "AutoconfigurePRWToolFile", m_autoconfigPRWFile ); // e.g. DSID407xxx/pileup_mc16a_dsid407352_FS.root
651 declareProperty( "AutoconfigurePRWToolCombinedmode", m_autoconfigPRWCombinedmode );
652 declareProperty( "AutoconfigurePRWToolRPVmode", m_autoconfigPRWRPVmode );
653 declareProperty( "AutoconfigurePRWToolRtags", m_autoconfigPRWRtags );
654 declareProperty( "mcCampaign", m_mcCampaign );
655 declareProperty( "mcChannel", m_mcChannel );
656 declareProperty( "PRWConfigFiles", m_prwConfFiles );
657 declareProperty( "PRWLumiCalcFiles", m_prwLcalcFiles );
658 declareProperty( "PRWActualMu2017File", m_prwActualMu2017File );
659 declareProperty( "PRWActualMu2018File", m_prwActualMu2018File );
660 declareProperty( "PRWActualMu2022File", m_prwActualMu2022File );
661 declareProperty( "PRWActualMu2023File", m_prwActualMu2023File );
662 declareProperty( "PRWActualMu2024File", m_prwActualMu2024File );
663 declareProperty( "PRWActualMu2025File", m_prwActualMu2025File );
664 declareProperty( "PRWDataScaleFactor", m_prwDataSF);
665 declareProperty( "PRWDataScaleFactorUP", m_prwDataSF_UP);
666 declareProperty( "PRWDataScaleFactorDOWN", m_prwDataSF_DW);
667 declareProperty( "PRWUseRunDependentPrescaleWeight", m_runDepPrescaleWeightPRW);
668 declareProperty( "PRWUseCommonMCFiles", m_useCommonPRWFiles);
669 declareProperty( "PRWCommonFileMC20a", m_commonPRWFileMC20a);
670 declareProperty( "PRWCommonFileMC20d", m_commonPRWFileMC20d);
671 declareProperty( "PRWCommonFileMC20e", m_commonPRWFileMC20e);
672 declareProperty( "PRWCommonFileMC23a", m_commonPRWFileMC23a);
673 declareProperty( "PRWCommonFileMC23d", m_commonPRWFileMC23d);
674 declareProperty( "PRWCommonFileMC23e", m_commonPRWFileMC23e);
675 declareProperty( "PRWCommonFileMC23g", m_commonPRWFileMC23g);
676 //LargeR uncertainties config, as from https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/JetUncertainties2016PrerecLargeR#Understanding_which_configuratio
677 declareProperty( "JetLargeRuncConfig", m_fatJetUncConfig );
678 declareProperty( "JetLargeRuncVars", m_fatJetUncVars );
679 declareProperty( "JetWtaggerConfig", m_WtagConfig );
680 declareProperty( "JetZtaggerConfig", m_ZtagConfig );
681 declareProperty( "JetWZTaggerCalibArea", m_WZTaggerCalibArea );
682 declareProperty( "JetToptaggerConfig", m_ToptagConfig );
683 declareProperty( "JetTruthLabelName", m_JetTruthLabelName );
684 // Properties of the truth labelling tool
685 declareProperty( "JetUngrLargeRTruthCollection", m_fatUngroomedTruthJets );
686 declareProperty( "JetLargeRTruthCollection", m_fatTruthJets );
687 declareProperty( "GetTruthGroomedJetValues", m_getTruthGroomedJetValues);
688 declareProperty( "MatchUngroomedParent", m_matchUngroomedParent);
689 declareProperty( "dRTruthJet", m_dRTruthJet);
690
691 declareProperty( "JetTopTaggerCalibArea", m_TopTaggerCalibArea );
692 declareProperty( "JetWTaguncConfig", m_WTagUncConfig );
693 declareProperty( "JetZTaguncConfig", m_ZTagUncConfig );
694 declareProperty( "JetTopTaguncConfig", m_TopTagUncConfig );
695 //Btagging MCtoMC SFs
696 declareProperty( "ShowerType", m_showerType = 0 );
697 //Egamma NP correlation model
698 declareProperty( "EleEffNPcorrModel", m_EG_corrModel );
699 //Egamma correction file list override
700 declareProperty( "EleEffCorrFNList", m_EG_corrFNList );
701 declareProperty( "IsRun3", m_isRun3 );
702 declareProperty( "IsPHYSLITE", m_isPHYSLITE );
703
704 //For electron trigger SF tools
705 declareProperty( "ElectronTriggerSFStringSingle", m_electronTriggerSFStringSingle);
706
707 //--- Tool pointers /MT : we may want to improve the descriptions :)
708 m_jetCalibTool.declarePropertyFor( this, "JetCalibTool", "The JetCalibTool" );
709 m_jetFatCalibTool.declarePropertyFor( this, "FatJetCalibTool", "The JetCalibTool for large-R jets" );
710 m_jetUncertaintiesTool.declarePropertyFor( this, "JetUncertaintiesTool", "The JetUncertaintiesTool" );
711 m_jetUncertaintiesPDSmearTool.declarePropertyFor( this, "JetPDSmearUncertaintiesTool", "The JetPDSmearUncertaintiesTool" );
712 m_fatjetUncertaintiesTool.declarePropertyFor( this, "FatJetUncertaintiesTool", "The JetUncertaintiesTool for large-R jets" );
713 m_fatjetUncertaintiesPDSmearTool.declarePropertyFor( this, "FatJetPDSmearUncertaintiesTool", "The FatJetPDSmearUncertaintiesTool" );
714 m_fatjetFFSmearingTool.declarePropertyFor( this, "FatJetFFSmearingTool", "The FFSmearingTool for large-R jets" );
715 m_WTagjetUncertaintiesTool.declarePropertyFor( this, "WJetUncertaintiesTool", "The JetUncertaintiesTool for large-R W-tagged jets" );
716 m_ZTagjetUncertaintiesTool.declarePropertyFor( this, "ZJetUncertaintiesTool", "The JetUncertaintiesTool for large-R Z-tagged jets" );
717 m_TopTagjetUncertaintiesTool.declarePropertyFor( this, "TopJetUncertaintiesTool", "The JetUncertaintiesTool for large-R Top-tagged jets" );
718 m_jetCleaningTool.declarePropertyFor( this, "JetCleaningTool", "The JetCleaningTool" );
719 m_jetPileupLabelingTool.declarePropertyFor( this, "JetPileupLabelingTool", "The JetPileupLabelingTool" );
720 m_jetJvtMomentTool.declarePropertyFor( this, "JetJvtMomentTool", "The JetJvtMomentTool" );
721 m_jetNNJvtMomentTool.declarePropertyFor( this, "JetNNJvtMomentTool", "The JetNNJvtMomentTool" );
722 m_jetNNJvtSelectionTool.declarePropertyFor( this, "JetNNJvtSelectionTool", "The JetNNJvtSelectionTool" );
723 m_jetNNJvtEfficiencyTool.declarePropertyFor( this, "JetNNJvtEfficiencyTool", "The JetNNJvtEfficiencyTool" );
724 m_jetfJvtSelectionTool.declarePropertyFor( this, "JetfJvtSelectionTool", "The JetfJvtSelectionTool" );
725 m_jetfJvtEfficiencyTool.declarePropertyFor( this, "JetfJvtEfficiencyTool", "The JetfJvtEfficiencyTool" );
726 //
727 m_WTaggerTool.declarePropertyFor( this, "WTaggerTool", "The SmoothedWZTaggerTool" );
728 m_ZTaggerTool.declarePropertyFor( this, "ZTaggerTool", "The SmoothedWZTaggerTool" );
729 m_TopTaggerTool.declarePropertyFor( this, "TopTaggerTool", "The DNNTopTaggerTool" );
730 m_jetTruthLabelingTool.declarePropertyFor( this, "JetTruthLabelingTool", "The JetTruthLabelingTool" );
731 //
732 m_muonSelectionTool.declarePropertyFor( this, "MuonSelectionTool", "The MuonSelectionTool for signal muons" );
733 m_muonSelectionHighPtTool.declarePropertyFor( this, "MuonSelectionHighPtTool", "The MuonSelectionTool for signal muons (HighPt WP)" );
734 m_muonSelectionToolBaseline.declarePropertyFor( this, "MuonSelectionToolBaseline", "The MuonSelectionTool for baseline muons" );
735 m_muonCalibTool.declarePropertyFor( this, "MuonCalibTool", "The MuonCalibTool" );
736 m_muonEfficiencySFTool.declarePropertyFor( this, "MuonEfficiencyScaleFactorsTool", "The MuonEfficiencySFTool" );
737 m_muonEfficiencyBMHighPtSFTool.declarePropertyFor( this, "MuonBadMuonHighPtScaleFactorsTool", "The MuonBadMuonHighPtSFTool" );
738 m_muonTTVAEfficiencySFTool.declarePropertyFor( this, "MuonTTVAEfficiencyScaleFactorsTool", "The MuonTTVAEfficiencySFTool" );
739 m_muonIsolationSFTool.declarePropertyFor( this, "MuonIsolationScaleFactorsTool", "The MuonIsolationSFTool" );
740 m_muonHighPtIsolationSFTool.declarePropertyFor( this, "MuonHighPtIsolationScaleFactorsTool", "The MuonIsolationSFTool" );
741 m_muonTriggerSFTool.declarePropertyFor( this, "MuonTriggerScaleFactorsTool", "The MuonTriggerSFTool" );
742 m_muonLRTORTool.declarePropertyFor( this, "MuonLRTOverlapRemovalTool", "Prompt/LRT muon OR Tool" );
743 //
744 m_elecEfficiencySFTool_reco.declarePropertyFor( this, "ElectronEfficiencyCorrectionTool_reco", "The ElectronEfficiencyCorrectionTool for reconstruction SFs" );
745 m_elecEfficiencySFTool_trig_singleLep.declarePropertyFor( this, "ElectronEfficiencyCorrectionTool_trig_singleLep", "The ElectronEfficiencyCorrectionTool for single-e triggers" );
746 m_elecEfficiencySFTool_id.declarePropertyFor( this, "ElectronEfficiencyCorrectionTool_id", "The ElectronEfficiencyCorrectionTool for ID SFs" );
747 m_elecEfficiencySFTool_iso.declarePropertyFor( this, "ElectronEfficiencyCorrectionTool_iso" , "The ElectronEfficiencyCorrectionTool for iso SFs" );
748 m_elecEfficiencySFTool_isoHighPt.declarePropertyFor( this, "ElectronEfficiencyCorrectionTool_isoHigPt" , "The ElectronEfficiencyCorrectionTool for iso high-pt SFs" );
749 m_elecSelLikelihood.declarePropertyFor( this, "ElectronLikelihoodTool" , "The ElectronSelLikelihoodTool for signal electrons" );
750 m_elecSelLikelihoodBaseline.declarePropertyFor( this, "ElectronLikelihoodToolBaseline" , "The ElectronSelLikelihoodTool for baseline electrons" );
751 m_egammaAmbiguityTool.declarePropertyFor( this, "EgammaAmbiguityTool", "The EgammaAmbiguityTool" );
752 m_elecChargeIDSelectorTool.declarePropertyFor( this, "ElectronChargeIDSelectorTool", "The ElectronChargeIDSelectorTool" );
753 m_elecChargeEffCorrTool.declarePropertyFor( this, "ElectronChargeEffCorrectionTool", "The ElectronChargeEffCorrectionTool" );
754 m_elecLRTORTool.declarePropertyFor( this, "ElectronLRTOverlapRemovalTool", "Prompt/LRT electron OR Tool" );
755 //
756 m_photonSelIsEM.declarePropertyFor( this, "PhotonIsEMSelector" , "The PhotonIsEMSelectorTool for signal photons" );
757 m_photonSelIsEMBaseline.declarePropertyFor( this, "PhotonIsEMSelectorBaseline" , "The PhotonIsEMSelectorTool for baseline photons" );
758 m_photonEfficiencySFTool.declarePropertyFor( this, "PhotonEfficiencyCorrectionTool", "The PhotonEfficiencyCorrectionTool for reco SFs" );
759 m_photonIsolationSFTool.declarePropertyFor( this, "PhotonIsolationCorrectionTool", "The PhotonEfficiencyCorrectionTool for iso SFs" );
760 m_photonTriggerSFTool.declarePropertyFor( this, "PhotonTriggerEfficiencyCorrectionTool", "The PhotonEfficiencyCorrectionTool for trigger SFs" );
761 //
762 m_egammaCalibTool.declarePropertyFor( this, "EgammaCalibrationAndSmearingTool", "The EgammaCalibrationAndSmearingTool");
763 //
764 m_tauSelTool.declarePropertyFor( this, "TauSelectionTool", "The TauSelectionTool for signal taus" );
765 m_tauSelToolBaseline.declarePropertyFor( this, "TauSelectionToolBaseline", "The TauSelectionTool for baseline taus" );
766 m_tauSmearingTool.declarePropertyFor( this, "TauSmearingTool", "The TauSmearingTool" );
767 m_tauTruthMatch.declarePropertyFor( this, "TauTruthMatch", "The TTMT" );
768 m_tauEffTool.declarePropertyFor( this, "TauEfficiencyCorrectionsTool", "The TauEfficiencyCorrectionsTool" );
769 //
770 m_btagEffTool.declarePropertyFor( this, "BTaggingEfficiencyTool", "The BTaggingEfficiencyTool" );
771 m_btagSelTool.declarePropertyFor( this, "BTaggingSelectionTool", "The main BTaggingSelectionTool" );
772 m_btagSelTool_OR.declarePropertyFor( this, "BTaggingSelectionTool_OR", "The BTaggingSelectionTool used to select b-jets for overlap removal" );
773 m_btagEffTool_trkJet.declarePropertyFor( this, "BTaggingEfficiencyTool_trkJet", "The BTaggingEfficiencyTool for track jets" );
774 m_btagSelTool_trkJet.declarePropertyFor( this, "BTaggingSelectionTool_trkJet", "The main BTaggingSelectionTool for track jets" );
775 //
776 m_metMaker.declarePropertyFor( this, "METMaker", "The METMaker instance");
777 m_metSystTool.declarePropertyFor( this, "METSystTool", "The METSystematicsTool");
778 m_metSignif.declarePropertyFor( this, "METSignificance", "The METSignifiance instance");
779 //
780 m_trigGlobalEffCorrTool_diLep.declarePropertyFor( this, "TrigGlobalEfficiencyCorrection_diLep", "The TrigGlobalEfficiencyCorrection tool for dilepton" );
781 m_trigGlobalEffCorrTool_multiLep.declarePropertyFor( this, "TrigGlobalEfficiencyCorrection_multiLep", "The TrigGlobalEfficiencyCorrection tool for trilepton" );
782 m_trigGlobalEffCorrTool_diPhoton.declarePropertyFor( this, "TrigGlobalEfficiencyCorrection_diPhoton", "The TrigGlobalEfficiencyCorrection tool for asymmetric diphoton" );
783 m_trigConfTool.declarePropertyFor( this, "TrigConfigTool", "The TrigConfigTool" );
784 m_trigDecTool.declarePropertyFor( this, "TrigDecisionTool", "The TrigDecisionTool" );
785 m_trigMatchingTool.declarePropertyFor( this, "TrigMatchTool", "The TrigMatchingTool" );
786 m_trigMatchScoringTool.declarePropertyFor( this, "TrigMatchScoringTool", "The TrigMatchScoringTool" );
787 m_trigDRScoringTool.declarePropertyFor( this, "TrigDRScoringTool", "The TrigDRScoringTool" );
788 //
789 m_isoCorrTool.declarePropertyFor( this, "IsolationCorrectionTool", "The IsolationCorrectionTool" );
790 m_isoTool.declarePropertyFor( this, "IsolationSelectionTool", "The IsolationSelectionTool");
791 //disable m_isoToolLowPtPLV.declarePropertyFor( this, "IsolationLowPtPLVTool", "The IsolationLowPtPLVTool");
792 m_isoBaselineTool.declarePropertyFor( this, "IsolationSelectionTool_Baseline", "The IsolationSelectionTool for baseline objects");
793 m_isoHighPtTool.declarePropertyFor( this, "IsolationSelectionTool_HighPt", "The IsolationSelectionTool for High Pt");
794 m_isoCloseByTool.declarePropertyFor( this, "IsolationCloseByCorrectionTool", "The IsolationCloseByCorrectionTool");
795 //
796 m_prwTool.declarePropertyFor( this, "PileupReweightingTool", "The PRW tool" );
797 //
798 m_LRTuncTool.declarePropertyFor( this, "InclusiveTrackFilterTool", "The LRT uncertainty tool");
799 //
800 m_pmgSHnjetWeighter.declarePropertyFor( this, "PMGSHVjetReweightTool", "The PMGSHVjetReweightTool (AntiKt4TruthJets)" );
801 m_pmgSHnjetWeighterWZ.declarePropertyFor( this, "PMGSHVjetReweightWZTool", "The PMGSHVjetReweightTool (AntiKt4TruthWZJets)" );
802 //
803 m_tauJetORtool.declarePropertyFor( this, "TauJetOverlapTool", "The TauJetOverlapTool");
804 //disable m_orToolbox.declarePropertyFor( this, "OverlapRemovalTool", "The overlap removal tool");
805
806 //load supported WPs (by tightness order)
807 m_el_id_support.push_back("VeryLooseNoPix"); // WPs for LRT Electron
808 m_el_id_support.push_back("VeryLooseLLH");
809 m_el_id_support.push_back("LooseNoPix"); // WPs for LRT Electron
810 m_el_id_support.push_back("LooseLLH");
811 m_el_id_support.push_back("LooseAndBLayerLLH");
812 m_el_id_support.push_back("LooseDNNnoCF");
813 m_el_id_support.push_back("LooseDNN");
814 m_el_id_support.push_back("MediumNoPix"); // WPs for LRT Electron
815 m_el_id_support.push_back("MediumLLH");
816 m_el_id_support.push_back("MediumDNNnoCF");
817 m_el_id_support.push_back("MediumDNN");
818 m_el_id_support.push_back("TightNoPix"); // WPs for LRT Electron
819 m_el_id_support.push_back("TightLLH");
820 m_el_id_support.push_back("TightDNNnoCF");
821 m_el_id_support.push_back("TightDNN");
822
823 m_ph_id_support.push_back("Loose");
824 m_ph_id_support.push_back("Medium");
825 m_ph_id_support.push_back("Tight");
826 m_ph_id_support.push_back("TightPtIncl"); // Should not be mixed with Tight
827
828 m_mu_id_support = 4; //maximum value supported
829
830 // Tau ID WPs
831 m_tau_id_support.push_back("001");
832 m_tau_id_support.push_back("VeryLoose");
833 m_tau_id_support.push_back("Loose");
834 m_tau_id_support.push_back("Medium");
835 m_tau_id_support.push_back("Tight");
836
837 // Iso WPs
838 // -- see https://twiki.cern.ch/twiki/bin/view/AtlasProtected/RecommendedIsolationWPs#Current_official_working_points
839 // -- the el iso points are those which have (or will have) SFs available
840 m_el_iso_support = {
841 "FCLoose", "FCTight", // current WPs
842 "FCHighPtCaloOnly", // current HighPtCaloOnly WPs
843 "Gradient", //
844 "HighPtCaloOnly", //
845 "TightTrackOnly_VarRad","TightTrackOnly_FixedRad",//
846 "Tight_VarRad","Loose_VarRad", //
847 "PLVLoose", "PLVTight", // PLV recommended WPs, fallback support below b/o SFs and & egamma map file
848 "PLImprovedTight", "PLImprovedVeryTight" // New PLIV WPs, fallback support below b/o SFs & egamma map file
849 };
850 // -- the muon iso points are those which have SFs available
851 // -- more details https://indico.cern.ch/event/878781/contributions/3721998/attachments/1976194/3289315/20200127_IFFshort_2.pdf
852 m_mu_iso_support = {
853 "PflowLoose_FixedRad", "PflowLoose_VarRad", "PflowTight_FixedRad", "PflowTight_VarRad", // PFlow (new naming) recommended WPs
854 "TightTrackOnly_FixedRad", "TightTrackOnly_VarRad", "HighPtTrackOnly", // TrackOnly (new naming) recommended WPs
855 "PLVLoose", "PLVTight", // PLV recommended WPs
856 "Loose_VarRad", "Loose_FixedRad", "Tight_VarRad", "Tight_FixedRad", // Other WPs (new naming)
857 "PLImprovedTight", "PLImprovedVeryTight" // New PLIV WPs, fallback support below b/o SFs
858 };
859
860 // Construct electron fallback WPs for SFs
861 for (const auto& x : m_el_iso_support) { m_el_iso_fallback[x] = x; } // all current WPs
862 m_el_iso_fallback["PLVTight"] = "FCTight"; // plus actual fallback
863 m_el_iso_fallback["PLVLoose"] = "FCLoose";
864 m_el_iso_fallback["PLImprovedTight"] = "FCTight";
865 m_el_iso_fallback["PLImprovedVeryTight"] = "FCTight";
866 m_el_iso_fallback["HighPtCaloOnly"] = "FCHighPtCaloOnly";
867 m_el_iso_fallback["TightTrackOnly_VarRad"] = "FCTight";
868 m_el_iso_fallback["TightTrackOnly_FixedRad"] = "FCTight";
869 m_el_iso_fallback["Tight_VarRad"] = "FCTight";
870 m_el_iso_fallback["Loose_VarRad"] = "FCLoose";
871
872 // Construct muon fallback WPs for SFs
873 m_mu_iso_fallback = {};
874 m_mu_iso_fallback["PLImprovedTight"] = "PLVTight";
875 m_mu_iso_fallback["PLImprovedVeryTight"] = "PLVTight";
876
877 // Construct tau fallback WPs for GNTau --> RNN ID SFs
878 m_tau_id_fallback = {};
879 m_tau_id_fallback[10] = 6; // VeryLoose
880 m_tau_id_fallback[11] = 7; // Loose
881 m_tau_id_fallback[12] = 8; // Medium
882 m_tau_id_fallback[13] = 9; // Tight
883}
x
#define x
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition AthCommonDataStore.h:145
ST::SUSYObjDef_xAOD::m_photonBaselinePt
double m_photonBaselinePt
Definition SUSYObjDef_xAOD.h:735
ST::SUSYObjDef_xAOD::m_tauSelToolBaseline
asg::AnaToolHandle< TauAnalysisTools::ITauSelectionTool > m_tauSelToolBaseline
Definition SUSYObjDef_xAOD.h:934
ST::SUSYObjDef_xAOD::m_elebaselined0sig
double m_elebaselined0sig
Definition SUSYObjDef_xAOD.h:711
ST::SUSYObjDef_xAOD::m_ph_id_support
std::vector< std::string > m_ph_id_support
Definition SUSYObjDef_xAOD.h:636
ST::SUSYObjDef_xAOD::m_orMuJetInnerDR
double m_orMuJetInnerDR
Definition SUSYObjDef_xAOD.h:798
ST::SUSYObjDef_xAOD::m_metRemoveOverlappingCaloTaggedMuons
bool m_metRemoveOverlappingCaloTaggedMuons
Definition SUSYObjDef_xAOD.h:585
ST::SUSYObjDef_xAOD::m_BtagWP_trkJet
std::string m_BtagWP_trkJet
Definition SUSYObjDef_xAOD.h:697
ST::SUSYObjDef_xAOD::m_tauConfigPath
std::string m_tauConfigPath
Definition SUSYObjDef_xAOD.h:746
ST::SUSYObjDef_xAOD::m_pmgSHnjetWeighter
asg::AnaToolHandle< IWeightTool > m_pmgSHnjetWeighter
Definition SUSYObjDef_xAOD.h:1002
ST::SUSYObjDef_xAOD::m_JetTruthLabelName
std::string m_JetTruthLabelName
Definition SUSYObjDef_xAOD.h:564
ST::SUSYObjDef_xAOD::m_WTagjetUncertaintiesTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_WTagjetUncertaintiesTool
Definition SUSYObjDef_xAOD.h:866
ST::SUSYObjDef_xAOD::m_elecLRTORTool
asg::AnaToolHandle< CP::IElectronLRTOverlapRemovalTool > m_elecLRTORTool
Definition SUSYObjDef_xAOD.h:910
ST::SUSYObjDef_xAOD::m_mu_iso_support
std::vector< std::string > m_mu_iso_support
Definition SUSYObjDef_xAOD.h:640
ST::SUSYObjDef_xAOD::m_JetFatJetDR
double m_JetFatJetDR
Definition SUSYObjDef_xAOD.h:809
ST::SUSYObjDef_xAOD::m_el_id_support
std::vector< std::string > m_el_id_support
Definition SUSYObjDef_xAOD.h:635
ST::SUSYObjDef_xAOD::m_trigDecTool
asg::AnaToolHandle< Trig::TrigDecisionTool > m_trigDecTool
Definition SUSYObjDef_xAOD.h:983
ST::SUSYObjDef_xAOD::m_EG_corrModel
std::string m_EG_corrModel
Definition SUSYObjDef_xAOD.h:836
ST::SUSYObjDef_xAOD::m_muonSelectionTool
asg::AnaToolHandle< CP::IMuonSelectionTool > m_muonSelectionTool
Definition SUSYObjDef_xAOD.h:884
ST::SUSYObjDef_xAOD::m_tauMuOLRBaseline
bool m_tauMuOLRBaseline
Definition SUSYObjDef_xAOD.h:668
ST::SUSYObjDef_xAOD::m_subtool_init
bool m_subtool_init
Definition SUSYObjDef_xAOD.h:573
ST::SUSYObjDef_xAOD::m_trig2017combination_singleLep
std::string m_trig2017combination_singleLep
Definition SUSYObjDef_xAOD.h:952
ST::SUSYObjDef_xAOD::m_pmgSHnjetWeighterWZ
asg::AnaToolHandle< IWeightTool > m_pmgSHnjetWeighterWZ
Definition SUSYObjDef_xAOD.h:1003
ST::SUSYObjDef_xAOD::m_prwActualMu2018File
std::string m_prwActualMu2018File
Definition SUSYObjDef_xAOD.h:623
ST::SUSYObjDef_xAOD::m_ZTagjetUncertaintiesTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_ZTagjetUncertaintiesTool
Definition SUSYObjDef_xAOD.h:867
ST::SUSYObjDef_xAOD::m_autoconfigPRWPath
std::string m_autoconfigPRWPath
Definition SUSYObjDef_xAOD.h:603
ST::SUSYObjDef_xAOD::m_trig2017combination_diPhoton
std::string m_trig2017combination_diPhoton
Definition SUSYObjDef_xAOD.h:977
ST::SUSYObjDef_xAOD::m_trig2018combination_singleLep
std::string m_trig2018combination_singleLep
Definition SUSYObjDef_xAOD.h:953
ST::SUSYObjDef_xAOD::m_photonAllowLate
bool m_photonAllowLate
Definition SUSYObjDef_xAOD.h:741
ST::SUSYObjDef_xAOD::m_trig2016combination_multiLep
std::string m_trig2016combination_multiLep
Definition SUSYObjDef_xAOD.h:968
ST::SUSYObjDef_xAOD::m_photonIdBaseline
std::string m_photonIdBaseline
Definition SUSYObjDef_xAOD.h:661
ST::SUSYObjDef_xAOD::m_prwActualMu2025File
std::string m_prwActualMu2025File
Definition SUSYObjDef_xAOD.h:627
ST::SUSYObjDef_xAOD::m_jetFatCalibTool
asg::AnaToolHandle< IJetCalibrationTool > m_jetFatCalibTool
Definition SUSYObjDef_xAOD.h:846
ST::SUSYObjDef_xAOD::m_trig2016combination_diPhoton
std::string m_trig2016combination_diPhoton
Definition SUSYObjDef_xAOD.h:976
ST::SUSYObjDef_xAOD::m_trigGlobalEffCorrTool_multiLep
asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionTool > m_trigGlobalEffCorrTool_multiLep
Definition SUSYObjDef_xAOD.h:972
ST::SUSYObjDef_xAOD::m_isoBaselineTool
asg::AnaToolHandle< CP::IIsolationSelectionTool > m_isoBaselineTool
Definition SUSYObjDef_xAOD.h:991
ST::SUSYObjDef_xAOD::m_orMuJetTrkPtRatio
double m_orMuJetTrkPtRatio
Definition SUSYObjDef_xAOD.h:797
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_isoHighPt
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_isoHighPt
Definition SUSYObjDef_xAOD.h:903
ST::SUSYObjDef_xAOD::m_muz0
double m_muz0
Definition SUSYObjDef_xAOD.h:725
ST::SUSYObjDef_xAOD::m_muonEfficiencySFTool
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonEfficiencySFTool
Definition SUSYObjDef_xAOD.h:888
ST::SUSYObjDef_xAOD::m_prwActualMu2022File
std::string m_prwActualMu2022File
Definition SUSYObjDef_xAOD.h:624
ST::SUSYObjDef_xAOD::m_prwTool
asg::AnaToolHandle< CP::IPileupReweightingTool > m_prwTool
Definition SUSYObjDef_xAOD.h:995
ST::SUSYObjDef_xAOD::m_fatUngroomedTruthJets
std::string m_fatUngroomedTruthJets
Definition SUSYObjDef_xAOD.h:566
ST::SUSYObjDef_xAOD::m_EG_corrFNList
std::string m_EG_corrFNList
Definition SUSYObjDef_xAOD.h:837
ST::SUSYObjDef_xAOD::m_tauSelTool
asg::AnaToolHandle< TauAnalysisTools::ITauSelectionTool > m_tauSelTool
Definition SUSYObjDef_xAOD.h:933
ST::SUSYObjDef_xAOD::m_jetUncertaintiesPDSmearTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_jetUncertaintiesPDSmearTool
Definition SUSYObjDef_xAOD.h:848
ST::SUSYObjDef_xAOD::m_autoconfigPRWRtags
std::string m_autoconfigPRWRtags
Definition SUSYObjDef_xAOD.h:607
ST::SUSYObjDef_xAOD::m_trig2024combination_singleLep
std::string m_trig2024combination_singleLep
Definition SUSYObjDef_xAOD.h:956
ST::SUSYObjDef_xAOD::m_elecSelLikelihood
asg::AnaToolHandle< IAsgElectronLikelihoodTool > m_elecSelLikelihood
Definition SUSYObjDef_xAOD.h:915
ST::SUSYObjDef_xAOD::m_orDoElBjet
bool m_orDoElBjet
Definition SUSYObjDef_xAOD.h:784
ST::SUSYObjDef_xAOD::m_orBoostedElectronMaxConeSize
double m_orBoostedElectronMaxConeSize
Definition SUSYObjDef_xAOD.h:790
ST::SUSYObjDef_xAOD::m_doTTVAsf
bool m_doTTVAsf
Definition SUSYObjDef_xAOD.h:526
ST::SUSYObjDef_xAOD::m_tauId
std::string m_tauId
Definition SUSYObjDef_xAOD.h:663
ST::SUSYObjDef_xAOD::m_applyJVTCut
bool m_applyJVTCut
Definition SUSYObjDef_xAOD.h:838
ST::SUSYObjDef_xAOD::m_prwLcalcFiles
std::vector< std::string > m_prwLcalcFiles
Definition SUSYObjDef_xAOD.h:621
ST::SUSYObjDef_xAOD::m_metsysConfigPrefix
std::string m_metsysConfigPrefix
Definition SUSYObjDef_xAOD.h:592
ST::SUSYObjDef_xAOD::m_eleIdExpert
bool m_eleIdExpert
Definition SUSYObjDef_xAOD.h:657
ST::SUSYObjDef_xAOD::m_tauEffTool
asg::AnaToolHandle< TauAnalysisTools::ITauEfficiencyCorrectionsTool > m_tauEffTool
Definition SUSYObjDef_xAOD.h:937
ST::SUSYObjDef_xAOD::m_JMScalib
bool m_JMScalib
Definition SUSYObjDef_xAOD.h:774
ST::SUSYObjDef_xAOD::m_orDoBoostedMuon
bool m_orDoBoostedMuon
Definition SUSYObjDef_xAOD.h:791
ST::SUSYObjDef_xAOD::m_eleChID_signal
bool m_eleChID_signal
Definition SUSYObjDef_xAOD.h:676
ST::SUSYObjDef_xAOD::m_trig2016combination_singleLep
std::string m_trig2016combination_singleLep
Definition SUSYObjDef_xAOD.h:951
ST::SUSYObjDef_xAOD::m_trigMatchingPrefix
std::string m_trigMatchingPrefix
Use composite trigger matching tool if matching was done upstream.
Definition SUSYObjDef_xAOD.h:529
ST::SUSYObjDef_xAOD::m_fatJets
std::string m_fatJets
Definition SUSYObjDef_xAOD.h:829
ST::SUSYObjDef_xAOD::m_isoHighPtTool
asg::AnaToolHandle< CP::IIsolationSelectionTool > m_isoHighPtTool
Definition SUSYObjDef_xAOD.h:992
ST::SUSYObjDef_xAOD::m_commonPRWFileMC20d
std::string m_commonPRWFileMC20d
Definition SUSYObjDef_xAOD.h:613
ST::SUSYObjDef_xAOD::m_trkJetPt
double m_trkJetPt
Definition SUSYObjDef_xAOD.h:764
ST::SUSYObjDef_xAOD::m_slices
std::map< std::string, bool > m_slices
Definition SUSYObjDef_xAOD.h:819
ST::SUSYObjDef_xAOD::m_commonPRWFileMC23g
std::string m_commonPRWFileMC23g
Definition SUSYObjDef_xAOD.h:618
ST::SUSYObjDef_xAOD::m_orBoostedMuonC2
double m_orBoostedMuonC2
Definition SUSYObjDef_xAOD.h:793
ST::SUSYObjDef_xAOD::m_trigGlobalEffCorrTool_diPhoton
asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionTool > m_trigGlobalEffCorrTool_diPhoton
Definition SUSYObjDef_xAOD.h:980
ST::SUSYObjDef_xAOD::m_elecSelLikelihoodBaseline
asg::AnaToolHandle< IAsgElectronLikelihoodTool > m_elecSelLikelihoodBaseline
Definition SUSYObjDef_xAOD.h:916
ST::SUSYObjDef_xAOD::m_outMETTerm
std::string m_outMETTerm
Definition SUSYObjDef_xAOD.h:584
ST::SUSYObjDef_xAOD::m_trigNToys_multiLep
int m_trigNToys_multiLep
Definition SUSYObjDef_xAOD.h:966
ST::SUSYObjDef_xAOD::m_photonSelIsEM
asg::AnaToolHandle< IAsgPhotonIsEMSelector > m_photonSelIsEM
Definition SUSYObjDef_xAOD.h:917
ST::SUSYObjDef_xAOD::m_photonEta
double m_photonEta
Definition SUSYObjDef_xAOD.h:737
ST::SUSYObjDef_xAOD::m_orMuJetPtRatio
double m_orMuJetPtRatio
Definition SUSYObjDef_xAOD.h:796
ST::SUSYObjDef_xAOD::m_acc_photonId
SG::ConstAccessor< char > m_acc_photonId
Definition SUSYObjDef_xAOD.h:1014
ST::SUSYObjDef_xAOD::m_orBoostedElectronC2
double m_orBoostedElectronC2
Definition SUSYObjDef_xAOD.h:789
ST::SUSYObjDef_xAOD::m_gammaTerm
std::string m_gammaTerm
Definition SUSYObjDef_xAOD.h:576
ST::SUSYObjDef_xAOD::m_eleIsoHighPtThresh
double m_eleIsoHighPtThresh
Definition SUSYObjDef_xAOD.h:671
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_id
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_id
Definition SUSYObjDef_xAOD.h:899
ST::SUSYObjDef_xAOD::m_tauPrePtCut
double m_tauPrePtCut
Definition SUSYObjDef_xAOD.h:743
ST::SUSYObjDef_xAOD::m_badmuQoverP
double m_badmuQoverP
Definition SUSYObjDef_xAOD.h:731
ST::SUSYObjDef_xAOD::m_muonTTVAEfficiencySFTool
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonTTVAEfficiencySFTool
Definition SUSYObjDef_xAOD.h:890
ST::SUSYObjDef_xAOD::m_ZTagUncConfig
std::string m_ZTagUncConfig
Definition SUSYObjDef_xAOD.h:562
ST::SUSYObjDef_xAOD::m_tauEta
double m_tauEta
Definition SUSYObjDef_xAOD.h:745
ST::SUSYObjDef_xAOD::m_fatjetFFSmearingTool
asg::AnaToolHandle< ICPJetCorrectionTool > m_fatjetFFSmearingTool
Definition SUSYObjDef_xAOD.h:851
ST::SUSYObjDef_xAOD::m_eleBaselineEta
double m_eleBaselineEta
Definition SUSYObjDef_xAOD.h:704
ST::SUSYObjDef_xAOD::m_BtagReadFromObject_trkJet
bool m_BtagReadFromObject_trkJet
Definition SUSYObjDef_xAOD.h:700
ST::SUSYObjDef_xAOD::m_eleEffMapFilePath
std::string m_eleEffMapFilePath
Definition SUSYObjDef_xAOD.h:713
ST::SUSYObjDef_xAOD::m_WZTaggerCalibArea
std::string m_WZTaggerCalibArea
Definition SUSYObjDef_xAOD.h:559
ST::SUSYObjDef_xAOD::m_trig2015combination_singleLep
std::string m_trig2015combination_singleLep
Definition SUSYObjDef_xAOD.h:950
ST::SUSYObjDef_xAOD::m_EigenvectorReductionB
std::string m_EigenvectorReductionB
Definition SUSYObjDef_xAOD.h:693
ST::SUSYObjDef_xAOD::m_tauPt
double m_tauPt
Definition SUSYObjDef_xAOD.h:744
ST::SUSYObjDef_xAOD::m_metSignif
asg::AnaToolHandle< IMETSignificance > m_metSignif
Definition SUSYObjDef_xAOD.h:948
ST::SUSYObjDef_xAOD::m_autoconfigPRWRPVmode
bool m_autoconfigPRWRPVmode
Definition SUSYObjDef_xAOD.h:606
ST::SUSYObjDef_xAOD::m_isoTool
asg::AnaToolHandle< CP::IIsolationSelectionTool > m_isoTool
Definition SUSYObjDef_xAOD.h:989
ST::SUSYObjDef_xAOD::m_jetfJvtEfficiencyTool
asg::AnaToolHandle< CP::IJvtEfficiencyTool > m_jetfJvtEfficiencyTool
Definition SUSYObjDef_xAOD.h:860
ST::SUSYObjDef_xAOD::m_acc_eleId
SG::ConstAccessor< char > m_acc_eleId
Definition SUSYObjDef_xAOD.h:1012
ST::SUSYObjDef_xAOD::m_muCalibrationMode
int m_muCalibrationMode
Definition SUSYObjDef_xAOD.h:732
ST::SUSYObjDef_xAOD::m_prwActualMu2024File
std::string m_prwActualMu2024File
Definition SUSYObjDef_xAOD.h:626
ST::SUSYObjDef_xAOD::m_trkMETsyst
bool m_trkMETsyst
Definition SUSYObjDef_xAOD.h:594
ST::SUSYObjDef_xAOD::m_eleIso_WP
std::string m_eleIso_WP
Definition SUSYObjDef_xAOD.h:669
ST::SUSYObjDef_xAOD::m_metJetSelection
std::string m_metJetSelection
Definition SUSYObjDef_xAOD.h:823
ST::SUSYObjDef_xAOD::m_photonBaselineCrackVeto
bool m_photonBaselineCrackVeto
Definition SUSYObjDef_xAOD.h:739
ST::SUSYObjDef_xAOD::m_el_iso_support
std::vector< std::string > m_el_iso_support
Definition SUSYObjDef_xAOD.h:639
ST::SUSYObjDef_xAOD::m_muBaselineEta
double m_muBaselineEta
Definition SUSYObjDef_xAOD.h:721
ST::SUSYObjDef_xAOD::m_trig2017combination_multiLep
std::string m_trig2017combination_multiLep
Definition SUSYObjDef_xAOD.h:969
ST::SUSYObjDef_xAOD::m_doMuIsoSignal
bool m_doMuIsoSignal
Definition SUSYObjDef_xAOD.h:814
ST::SUSYObjDef_xAOD::m_softTermParam
int m_softTermParam
Definition SUSYObjDef_xAOD.h:598
ST::SUSYObjDef_xAOD::m_trigMatchingTool
asg::AnaToolHandle< Trig::IMatchingTool > m_trigMatchingTool
Definition SUSYObjDef_xAOD.h:984
ST::SUSYObjDef_xAOD::m_photonBaselineIso_WP
std::string m_photonBaselineIso_WP
Definition SUSYObjDef_xAOD.h:678
ST::SUSYObjDef_xAOD::m_elecChargeIDSelectorTool
asg::AnaToolHandle< IAsgElectronLikelihoodTool > m_elecChargeIDSelectorTool
Definition SUSYObjDef_xAOD.h:930
ST::SUSYObjDef_xAOD::m_BtagSystStrategy
std::string m_BtagSystStrategy
Definition SUSYObjDef_xAOD.h:692
ST::SUSYObjDef_xAOD::m_tauEleId
bool m_tauEleId
Definition SUSYObjDef_xAOD.h:665
ST::SUSYObjDef_xAOD::m_orDoElEl
bool m_orDoElEl
Definition SUSYObjDef_xAOD.h:780
ST::SUSYObjDef_xAOD::m_force_noElId
bool m_force_noElId
Definition SUSYObjDef_xAOD.h:524
ST::SUSYObjDef_xAOD::m_photonId
std::string m_photonId
Definition SUSYObjDef_xAOD.h:660
ST::SUSYObjDef_xAOD::m_prwDataSF_DW
double m_prwDataSF_DW
Definition SUSYObjDef_xAOD.h:631
ST::SUSYObjDef_xAOD::m_orDoBoostedElectron
bool m_orDoBoostedElectron
Definition SUSYObjDef_xAOD.h:787
ST::SUSYObjDef_xAOD::m_mu_id_support
int m_mu_id_support
Definition SUSYObjDef_xAOD.h:637
ST::SUSYObjDef_xAOD::m_badJetCut
std::string m_badJetCut
Definition SUSYObjDef_xAOD.h:544
ST::SUSYObjDef_xAOD::m_elez0
double m_elez0
Definition SUSYObjDef_xAOD.h:710
ST::SUSYObjDef_xAOD::m_muEffCorrForce1D
bool m_muEffCorrForce1D
Definition SUSYObjDef_xAOD.h:686
ST::SUSYObjDef_xAOD::m_eleBaselineCrackVeto
bool m_eleBaselineCrackVeto
Definition SUSYObjDef_xAOD.h:705
ST::SUSYObjDef_xAOD::m_mubaselinez0
double m_mubaselinez0
Definition SUSYObjDef_xAOD.h:727
ST::SUSYObjDef_xAOD::m_commonPRWFileMC20e
std::string m_commonPRWFileMC20e
Definition SUSYObjDef_xAOD.h:614
ST::SUSYObjDef_xAOD::m_jetPileupLabelingTool
asg::AnaToolHandle< JetPileupLabelingTool > m_jetPileupLabelingTool
Definition SUSYObjDef_xAOD.h:854
ST::SUSYObjDef_xAOD::m_trig2023combination_singleLep
std::string m_trig2023combination_singleLep
Definition SUSYObjDef_xAOD.h:955
ST::SUSYObjDef_xAOD::m_muonLRTORTool
asg::AnaToolHandle< CP::IMuonLRTOverlapRemovalTool > m_muonLRTORTool
Definition SUSYObjDef_xAOD.h:895
ST::SUSYObjDef_xAOD::m_photonBaselineEta
double m_photonBaselineEta
Definition SUSYObjDef_xAOD.h:736
ST::SUSYObjDef_xAOD::m_isRun3
bool m_isRun3
Definition SUSYObjDef_xAOD.h:820
ST::SUSYObjDef_xAOD::m_doIsoSignal
bool m_doIsoSignal
Definition SUSYObjDef_xAOD.h:811
ST::SUSYObjDef_xAOD::m_eleChIso
bool m_eleChIso
Definition SUSYObjDef_xAOD.h:675
ST::SUSYObjDef_xAOD::m_upstreamTriggerMatching
bool m_upstreamTriggerMatching
Definition SUSYObjDef_xAOD.h:528
ST::SUSYObjDef_xAOD::m_jetInputType
int m_jetInputType
Definition SUSYObjDef_xAOD.h:520
ST::SUSYObjDef_xAOD::m_orDoBjet
bool m_orDoBjet
Definition SUSYObjDef_xAOD.h:783
ST::SUSYObjDef_xAOD::m_orDoTauBjet
bool m_orDoTauBjet
Definition SUSYObjDef_xAOD.h:786
ST::SUSYObjDef_xAOD::m_acc_photonIdBaseline
SG::ConstAccessor< char > m_acc_photonIdBaseline
Definition SUSYObjDef_xAOD.h:1013
ST::SUSYObjDef_xAOD::m_muCosmicz0
double m_muCosmicz0
Definition SUSYObjDef_xAOD.h:729
ST::SUSYObjDef_xAOD::m_TopTaggerTool
asg::AnaToolHandle< JSSWTopTaggerDNN > m_TopTaggerTool
Definition SUSYObjDef_xAOD.h:864
ST::SUSYObjDef_xAOD::m_debug
bool m_debug
Definition SUSYObjDef_xAOD.h:540
ST::SUSYObjDef_xAOD::m_tauTerm
std::string m_tauTerm
Definition SUSYObjDef_xAOD.h:577
ST::SUSYObjDef_xAOD::m_muonTriggerSFTool
asg::AnaToolHandle< CP::IMuonTriggerScaleFactors > m_muonTriggerSFTool
Definition SUSYObjDef_xAOD.h:893
ST::SUSYObjDef_xAOD::m_tau_id_support
std::vector< std::string > m_tau_id_support
Definition SUSYObjDef_xAOD.h:638
ST::SUSYObjDef_xAOD::m_orLinkOverlapObjects
bool m_orLinkOverlapObjects
Definition SUSYObjDef_xAOD.h:805
ST::SUSYObjDef_xAOD::m_doElIsoSignal
bool m_doElIsoSignal
Definition SUSYObjDef_xAOD.h:812
ST::SUSYObjDef_xAOD::m_tauEffToolRecommendationTag
std::string m_tauEffToolRecommendationTag
Definition SUSYObjDef_xAOD.h:752
ST::SUSYObjDef_xAOD::m_muBaselineIso_WP
std::string m_muBaselineIso_WP
Definition SUSYObjDef_xAOD.h:681
ST::SUSYObjDef_xAOD::m_orBoostedMuonMaxConeSize
double m_orBoostedMuonMaxConeSize
Definition SUSYObjDef_xAOD.h:794
ST::SUSYObjDef_xAOD::m_jetEta
double m_jetEta
Definition SUSYObjDef_xAOD.h:757
ST::SUSYObjDef_xAOD::m_trigNToys_diPhoton
int m_trigNToys_diPhoton
Definition SUSYObjDef_xAOD.h:974
ST::SUSYObjDef_xAOD::m_fJvtWP
std::string m_fJvtWP
Definition SUSYObjDef_xAOD.h:768
ST::SUSYObjDef_xAOD::m_orBtagWP
std::string m_orBtagWP
Definition SUSYObjDef_xAOD.h:801
ST::SUSYObjDef_xAOD::m_eleLRT_strat
int m_eleLRT_strat
Definition SUSYObjDef_xAOD.h:674
ST::SUSYObjDef_xAOD::m_muId
int m_muId
Definition SUSYObjDef_xAOD.h:658
ST::SUSYObjDef_xAOD::m_BtagTagger
std::string m_BtagTagger
Definition SUSYObjDef_xAOD.h:690
ST::SUSYObjDef_xAOD::m_TopTaggerCalibArea
std::string m_TopTaggerCalibArea
Definition SUSYObjDef_xAOD.h:560
ST::SUSYObjDef_xAOD::m_eleChID_WP
std::string m_eleChID_WP
Definition SUSYObjDef_xAOD.h:672
ST::SUSYObjDef_xAOD::m_trig2015combination_diLep
std::string m_trig2015combination_diLep
Definition SUSYObjDef_xAOD.h:959
ST::SUSYObjDef_xAOD::m_muCosmicd0
double m_muCosmicd0
Definition SUSYObjDef_xAOD.h:730
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_trigEff_singleLep
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_trigEff_singleLep
Definition SUSYObjDef_xAOD.h:901
ST::SUSYObjDef_xAOD::m_force_noMuId
bool m_force_noMuId
Definition SUSYObjDef_xAOD.h:525
ST::SUSYObjDef_xAOD::m_photonTriggerName
std::string m_photonTriggerName
Definition SUSYObjDef_xAOD.h:680
ST::SUSYObjDef_xAOD::m_jetNNJvtSelectionTool
asg::AnaToolHandle< IAsgSelectionTool > m_jetNNJvtSelectionTool
Definition SUSYObjDef_xAOD.h:857
ST::SUSYObjDef_xAOD::m_ZTaggerTool
asg::AnaToolHandle< SmoothedWZTagger > m_ZTaggerTool
Definition SUSYObjDef_xAOD.h:863
ST::SUSYObjDef_xAOD::m_metDoSetMuonJetEMScale
bool m_metDoSetMuonJetEMScale
Definition SUSYObjDef_xAOD.h:586
ST::SUSYObjDef_xAOD::m_jetNNJvtMomentTool
asg::AnaToolHandle< JetPileupTag::JetVertexNNTagger > m_jetNNJvtMomentTool
Definition SUSYObjDef_xAOD.h:856
ST::SUSYObjDef_xAOD::m_fJvtConfigRun3
std::string m_fJvtConfigRun3
Definition SUSYObjDef_xAOD.h:772
ST::SUSYObjDef_xAOD::m_orInputLabel
std::string m_orInputLabel
Definition SUSYObjDef_xAOD.h:802
ST::SUSYObjDef_xAOD::m_configFile
std::string m_configFile
Definition SUSYObjDef_xAOD.h:522
ST::SUSYObjDef_xAOD::m_eleIdBaseline
std::string m_eleIdBaseline
Definition SUSYObjDef_xAOD.h:653
ST::SUSYObjDef_xAOD::m_el_iso_fallback
std::map< std::string, std::string > m_el_iso_fallback
Definition SUSYObjDef_xAOD.h:643
ST::SUSYObjDef_xAOD::m_currentSyst
CP::SystematicSet m_currentSyst
Definition SUSYObjDef_xAOD.h:833
ST::SUSYObjDef_xAOD::m_photonIso_WP
std::string m_photonIso_WP
Definition SUSYObjDef_xAOD.h:679
ST::SUSYObjDef_xAOD::m_muonEfficiencyBMHighPtSFTool
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonEfficiencyBMHighPtSFTool
Definition SUSYObjDef_xAOD.h:889
ST::SUSYObjDef_xAOD::m_tauJetORtool
asg::AnaToolHandle< ORUtils::IOverlapTool > m_tauJetORtool
Definition SUSYObjDef_xAOD.h:999
ST::SUSYObjDef_xAOD::m_orBoostedMuonC1
double m_orBoostedMuonC1
Definition SUSYObjDef_xAOD.h:792
ST::SUSYObjDef_xAOD::m_treatPUJets
bool m_treatPUJets
Definition SUSYObjDef_xAOD.h:599
ST::SUSYObjDef_xAOD::m_commonPRWFileMC23d
std::string m_commonPRWFileMC23d
Definition SUSYObjDef_xAOD.h:616
ST::SUSYObjDef_xAOD::m_muIsoHighPt_WP
std::string m_muIsoHighPt_WP
Definition SUSYObjDef_xAOD.h:683
ST::SUSYObjDef_xAOD::m_EleFatJetDR
double m_EleFatJetDR
Definition SUSYObjDef_xAOD.h:808
ST::SUSYObjDef_xAOD::m_matchUngroomedParent
bool m_matchUngroomedParent
Definition SUSYObjDef_xAOD.h:569
ST::SUSYObjDef_xAOD::m_ToptagConfig
std::string m_ToptagConfig
Definition SUSYObjDef_xAOD.h:558
ST::SUSYObjDef_xAOD::m_orBJetPtUpperThres
double m_orBJetPtUpperThres
Definition SUSYObjDef_xAOD.h:804
ST::SUSYObjDef_xAOD::m_muIsoHighPtThresh
double m_muIsoHighPtThresh
Definition SUSYObjDef_xAOD.h:684
ST::SUSYObjDef_xAOD::m_orApplyRelPt
bool m_orApplyRelPt
Definition SUSYObjDef_xAOD.h:795
ST::SUSYObjDef_xAOD::m_orDoPhoton
bool m_orDoPhoton
Definition SUSYObjDef_xAOD.h:778
ST::SUSYObjDef_xAOD::m_commonPRWFileMC23e
std::string m_commonPRWFileMC23e
Definition SUSYObjDef_xAOD.h:617
ST::SUSYObjDef_xAOD::m_muonCalibTool
asg::AnaToolHandle< CP::IMuonCalibrationAndSmearingTool > m_muonCalibTool
Definition SUSYObjDef_xAOD.h:887
ST::SUSYObjDef_xAOD::m_fJvtConfigRun2
std::string m_fJvtConfigRun2
Definition SUSYObjDef_xAOD.h:771
ST::SUSYObjDef_xAOD::m_jetJvtMomentTool
asg::AnaToolHandle< JetVertexTaggerTool > m_jetJvtMomentTool
Definition SUSYObjDef_xAOD.h:855
ST::SUSYObjDef_xAOD::m_getTruthGroomedJetValues
bool m_getTruthGroomedJetValues
Definition SUSYObjDef_xAOD.h:568
ST::SUSYObjDef_xAOD::m_jetUncertaintiesTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_jetUncertaintiesTool
Definition SUSYObjDef_xAOD.h:847
ST::SUSYObjDef_xAOD::m_metDoRemoveMuonJets
bool m_metDoRemoveMuonJets
Definition SUSYObjDef_xAOD.h:587
ST::SUSYObjDef_xAOD::m_tauSmearingToolRecommendationTag
std::string m_tauSmearingToolRecommendationTag
Definition SUSYObjDef_xAOD.h:751
ST::SUSYObjDef_xAOD::m_egammaAmbiguityTool
asg::AnaToolHandle< IEGammaAmbiguityTool > m_egammaAmbiguityTool
Definition SUSYObjDef_xAOD.h:929
ST::SUSYObjDef_xAOD::m_mcCampaign
std::string m_mcCampaign
Definition SUSYObjDef_xAOD.h:608
ST::SUSYObjDef_xAOD::m_orDoEleJet
bool m_orDoEleJet
Definition SUSYObjDef_xAOD.h:779
ST::SUSYObjDef_xAOD::m_elecChargeEffCorrTool
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecChargeEffCorrTool
Definition SUSYObjDef_xAOD.h:931
ST::SUSYObjDef_xAOD::m_orPhotonFavoured
bool m_orPhotonFavoured
Definition SUSYObjDef_xAOD.h:803
ST::SUSYObjDef_xAOD::m_trigConfTool
asg::AnaToolHandle< TrigConf::ITrigConfigTool > m_trigConfTool
Definition SUSYObjDef_xAOD.h:982
ST::SUSYObjDef_xAOD::m_WTagUncConfig
std::string m_WTagUncConfig
Definition SUSYObjDef_xAOD.h:561
ST::SUSYObjDef_xAOD::m_isoCloseByTool
asg::AnaToolHandle< CP::IIsolationCloseByCorrectionTool > m_isoCloseByTool
Definition SUSYObjDef_xAOD.h:993
ST::SUSYObjDef_xAOD::m_orDoMuonJetGhostAssociation
bool m_orDoMuonJetGhostAssociation
Definition SUSYObjDef_xAOD.h:799
ST::SUSYObjDef_xAOD::m_orDoElMu
bool m_orDoElMu
Definition SUSYObjDef_xAOD.h:781
ST::SUSYObjDef_xAOD::m_tau_id_fallback
std::map< int, int > m_tau_id_fallback
Definition SUSYObjDef_xAOD.h:645
ST::SUSYObjDef_xAOD::m_elebaselinez0
double m_elebaselinez0
Definition SUSYObjDef_xAOD.h:712
ST::SUSYObjDef_xAOD::m_tauIdBaseline
std::string m_tauIdBaseline
Definition SUSYObjDef_xAOD.h:664
ST::SUSYObjDef_xAOD::m_eleIsoHighPt_WP
std::string m_eleIsoHighPt_WP
Definition SUSYObjDef_xAOD.h:670
ST::SUSYObjDef_xAOD::m_metMaker
asg::AnaToolHandle< IMETMaker > m_metMaker
Definition SUSYObjDef_xAOD.h:946
ST::SUSYObjDef_xAOD::m_doPhIsoSignal
bool m_doPhIsoSignal
Definition SUSYObjDef_xAOD.h:813
ST::SUSYObjDef_xAOD::m_muHighPtExtraSmear
bool m_muHighPtExtraSmear
Definition SUSYObjDef_xAOD.h:685
ST::SUSYObjDef_xAOD::m_trigDRScoringTool
asg::AnaToolHandle< Trig::IMatchScoringTool > m_trigDRScoringTool
Definition SUSYObjDef_xAOD.h:986
ST::SUSYObjDef_xAOD::m_caloMETsyst
bool m_caloMETsyst
Definition SUSYObjDef_xAOD.h:595
ST::SUSYObjDef_xAOD::m_photonIsolationSFTool
asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > m_photonIsolationSFTool
Definition SUSYObjDef_xAOD.h:921
ST::SUSYObjDef_xAOD::m_photonCrackVeto
bool m_photonCrackVeto
Definition SUSYObjDef_xAOD.h:740
ST::SUSYObjDef_xAOD::m_orDoTau
bool m_orDoTau
Overlap removal options.
Definition SUSYObjDef_xAOD.h:777
ST::SUSYObjDef_xAOD::m_trig2016combination_diLep
std::string m_trig2016combination_diLep
Definition SUSYObjDef_xAOD.h:960
ST::SUSYObjDef_xAOD::m_BtagReadFromObject
bool m_BtagReadFromObject
Definition SUSYObjDef_xAOD.h:696
ST::SUSYObjDef_xAOD::m_JvtConfigRun2
std::string m_JvtConfigRun2
Definition SUSYObjDef_xAOD.h:761
ST::SUSYObjDef_xAOD::m_fatjetUncertaintiesTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_fatjetUncertaintiesTool
Definition SUSYObjDef_xAOD.h:849
ST::SUSYObjDef_xAOD::m_isoCorrTool
asg::AnaToolHandle< CP::IIsolationCorrectionTool > m_isoCorrTool
Definition SUSYObjDef_xAOD.h:988
ST::SUSYObjDef_xAOD::m_metGreedyPhotons
bool m_metGreedyPhotons
Definition SUSYObjDef_xAOD.h:590
ST::SUSYObjDef_xAOD::m_orDoMuBjet
bool m_orDoMuBjet
Definition SUSYObjDef_xAOD.h:785
ST::SUSYObjDef_xAOD::m_runECIS
bool m_runECIS
Definition SUSYObjDef_xAOD.h:677
ST::SUSYObjDef_xAOD::m_BtagMinPt_trkJet
double m_BtagMinPt_trkJet
Definition SUSYObjDef_xAOD.h:699
ST::SUSYObjDef_xAOD::m_dRTruthJet
double m_dRTruthJet
Definition SUSYObjDef_xAOD.h:570
ST::SUSYObjDef_xAOD::m_tauInputFile
std::string m_tauInputFile
Definition SUSYObjDef_xAOD.h:748
ST::SUSYObjDef_xAOD::m_JvtWP
std::string m_JvtWP
Definition SUSYObjDef_xAOD.h:759
ST::SUSYObjDef_xAOD::m_eleConfigBaseline
std::string m_eleConfigBaseline
Definition SUSYObjDef_xAOD.h:655
ST::SUSYObjDef_xAOD::m_eleEta
double m_eleEta
Definition SUSYObjDef_xAOD.h:707
ST::SUSYObjDef_xAOD::m_metDoMuonEloss
bool m_metDoMuonEloss
Definition SUSYObjDef_xAOD.h:589
ST::SUSYObjDef_xAOD::m_trig2022combination_singleLep
std::string m_trig2022combination_singleLep
Definition SUSYObjDef_xAOD.h:954
ST::SUSYObjDef_xAOD::m_metSystTool
asg::AnaToolHandle< IMETSystematicsTool > m_metSystTool
Definition SUSYObjDef_xAOD.h:947
ST::SUSYObjDef_xAOD::m_tauEleIdBaseline
bool m_tauEleIdBaseline
Definition SUSYObjDef_xAOD.h:666
ST::SUSYObjDef_xAOD::m_useBtagging
bool m_useBtagging
Definition SUSYObjDef_xAOD.h:538
ST::SUSYObjDef_xAOD::m_eleTerm
std::string m_eleTerm
Definition SUSYObjDef_xAOD.h:575
ST::SUSYObjDef_xAOD::m_ZtagConfig
std::string m_ZtagConfig
Definition SUSYObjDef_xAOD.h:557
ST::SUSYObjDef_xAOD::m_useBtagging_trkJet
bool m_useBtagging_trkJet
Definition SUSYObjDef_xAOD.h:539
ST::SUSYObjDef_xAOD::m_strictConfigCheck
bool m_strictConfigCheck
Definition SUSYObjDef_xAOD.h:542
ST::SUSYObjDef_xAOD::m_muonSelectionHighPtTool
asg::AnaToolHandle< CP::IMuonSelectionTool > m_muonSelectionHighPtTool
Definition SUSYObjDef_xAOD.h:885
ST::SUSYObjDef_xAOD::m_EigenvectorReductionLight
std::string m_EigenvectorReductionLight
Definition SUSYObjDef_xAOD.h:695
ST::SUSYObjDef_xAOD::m_jetfJvtSelectionTool
asg::AnaToolHandle< IAsgSelectionTool > m_jetfJvtSelectionTool
Definition SUSYObjDef_xAOD.h:859
ST::SUSYObjDef_xAOD::m_BtagMinPt
double m_BtagMinPt
Definition SUSYObjDef_xAOD.h:691
ST::SUSYObjDef_xAOD::m_doFwdJVT
bool m_doFwdJVT
Definition SUSYObjDef_xAOD.h:767
ST::SUSYObjDef_xAOD::m_BtagWP
std::string m_BtagWP
Definition SUSYObjDef_xAOD.h:689
ST::SUSYObjDef_xAOD::m_trig2018combination_diPhoton
std::string m_trig2018combination_diPhoton
Definition SUSYObjDef_xAOD.h:978
ST::SUSYObjDef_xAOD::m_eleCrackVeto
bool m_eleCrackVeto
Definition SUSYObjDef_xAOD.h:708
ST::SUSYObjDef_xAOD::m_jetCleaningTool
asg::AnaToolHandle< IJetSelector > m_jetCleaningTool
Definition SUSYObjDef_xAOD.h:852
ST::SUSYObjDef_xAOD::m_btagSelTool_trkJet
asg::AnaToolHandle< IBTaggingSelectionTool > m_btagSelTool_trkJet
Definition SUSYObjDef_xAOD.h:944
ST::SUSYObjDef_xAOD::m_LRTuncTool
asg::AnaToolHandle< InDet::IInclusiveTrackFilterTool > m_LRTuncTool
Definition SUSYObjDef_xAOD.h:997
ST::SUSYObjDef_xAOD::m_mcChannel
int m_mcChannel
Definition SUSYObjDef_xAOD.h:609
ST::SUSYObjDef_xAOD::m_jetNNJvtEfficiencyTool
asg::AnaToolHandle< CP::IJvtEfficiencyTool > m_jetNNJvtEfficiencyTool
Definition SUSYObjDef_xAOD.h:858
ST::SUSYObjDef_xAOD::m_WtagConfig
std::string m_WtagConfig
Definition SUSYObjDef_xAOD.h:556
ST::SUSYObjDef_xAOD::m_commonPRWFileMC20a
std::string m_commonPRWFileMC20a
Definition SUSYObjDef_xAOD.h:612
ST::SUSYObjDef_xAOD::m_trig2022combination_diLep
std::string m_trig2022combination_diLep
Definition SUSYObjDef_xAOD.h:963
ST::SUSYObjDef_xAOD::m_muonHighPtIsolationSFTool
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonHighPtIsolationSFTool
Definition SUSYObjDef_xAOD.h:892
ST::SUSYObjDef_xAOD::m_showerType
int m_showerType
Definition SUSYObjDef_xAOD.h:825
ST::SUSYObjDef_xAOD::m_tauSmearingTool
asg::AnaToolHandle< TauAnalysisTools::ITauSmearingTool > m_tauSmearingTool
Definition SUSYObjDef_xAOD.h:935
ST::SUSYObjDef_xAOD::m_JvtPtMax
double m_JvtPtMax
Definition SUSYObjDef_xAOD.h:760
ST::SUSYObjDef_xAOD::m_acc_eleIdBaseline
SG::ConstAccessor< char > m_acc_eleIdBaseline
Definition SUSYObjDef_xAOD.h:1011
ST::SUSYObjDef_xAOD::m_jetPt
double m_jetPt
Definition SUSYObjDef_xAOD.h:756
ST::SUSYObjDef_xAOD::m_trig2018combination_diLep
std::string m_trig2018combination_diLep
Definition SUSYObjDef_xAOD.h:962
ST::SUSYObjDef_xAOD::m_tauMuOLR
bool m_tauMuOLR
Definition SUSYObjDef_xAOD.h:667
ST::SUSYObjDef_xAOD::m_trkJetEta
double m_trkJetEta
Definition SUSYObjDef_xAOD.h:765
ST::SUSYObjDef_xAOD::m_trig2017combination_diLep
std::string m_trig2017combination_diLep
Definition SUSYObjDef_xAOD.h:961
ST::SUSYObjDef_xAOD::m_trigGlobalEffCorrTool_diLep
asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionTool > m_trigGlobalEffCorrTool_diLep
Definition SUSYObjDef_xAOD.h:964
ST::SUSYObjDef_xAOD::m_btagEffTool_trkJet
asg::AnaToolHandle< IBTaggingEfficiencyTool > m_btagEffTool_trkJet
Definition SUSYObjDef_xAOD.h:943
ST::SUSYObjDef_xAOD::m_prwActualMu2017File
std::string m_prwActualMu2017File
Definition SUSYObjDef_xAOD.h:622
ST::SUSYObjDef_xAOD::m_trigNToys_diLep
int m_trigNToys_diLep
Definition SUSYObjDef_xAOD.h:958
ST::SUSYObjDef_xAOD::m_prwConfFiles
std::vector< std::string > m_prwConfFiles
Definition SUSYObjDef_xAOD.h:620
ST::SUSYObjDef_xAOD::m_eleId
std::string m_eleId
Definition SUSYObjDef_xAOD.h:652
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_reco
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_reco
Combined muon collection.
Definition SUSYObjDef_xAOD.h:898
ST::SUSYObjDef_xAOD::m_prwDataSF_UP
double m_prwDataSF_UP
Definition SUSYObjDef_xAOD.h:630
ST::SUSYObjDef_xAOD::m_TopTagjetUncertaintiesTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_TopTagjetUncertaintiesTool
Definition SUSYObjDef_xAOD.h:868
ST::SUSYObjDef_xAOD::m_autoconfigPRWCombinedmode
bool m_autoconfigPRWCombinedmode
Definition SUSYObjDef_xAOD.h:605
ST::SUSYObjDef_xAOD::m_fatjetFFSmearingSyst
std::vector< CP::SystematicSet > m_fatjetFFSmearingSyst
Definition SUSYObjDef_xAOD.h:834
ST::SUSYObjDef_xAOD::m_tauDoTTM
bool m_tauDoTTM
Definition SUSYObjDef_xAOD.h:750
ST::SUSYObjDef_xAOD::m_WDecorName
std::string m_WDecorName
Definition SUSYObjDef_xAOD.h:553
ST::SUSYObjDef_xAOD::m_btagEffTool
asg::AnaToolHandle< IBTaggingEfficiencyTool > m_btagEffTool
Definition SUSYObjDef_xAOD.h:940
ST::SUSYObjDef_xAOD::m_tauTruthMatch
asg::AnaToolHandle< TauAnalysisTools::ITauTruthMatchingTool > m_tauTruthMatch
Definition SUSYObjDef_xAOD.h:936
ST::SUSYObjDef_xAOD::m_muIdBaseline
int m_muIdBaseline
Definition SUSYObjDef_xAOD.h:659
ST::SUSYObjDef_xAOD::m_btagSelTool_OR
asg::AnaToolHandle< IBTaggingSelectionTool > m_btagSelTool_OR
Definition SUSYObjDef_xAOD.h:942
ST::SUSYObjDef_xAOD::m_fatTruthJets
std::string m_fatTruthJets
Definition SUSYObjDef_xAOD.h:567
ST::SUSYObjDef_xAOD::m_orDoMuonJet
bool m_orDoMuonJet
Definition SUSYObjDef_xAOD.h:782
ST::SUSYObjDef_xAOD::m_useSigLepForIsoCloseByOR
bool m_useSigLepForIsoCloseByOR
Definition SUSYObjDef_xAOD.h:816
ST::SUSYObjDef_xAOD::m_metUseGhostMuons
bool m_metUseGhostMuons
Definition SUSYObjDef_xAOD.h:588
ST::SUSYObjDef_xAOD::m_muTriggerSFCalibRelease
std::string m_muTriggerSFCalibRelease
Definition SUSYObjDef_xAOD.h:687
ST::SUSYObjDef_xAOD::m_fJvtEtaMin
double m_fJvtEtaMin
Definition SUSYObjDef_xAOD.h:770
ST::SUSYObjDef_xAOD::m_photonPt
double m_photonPt
Definition SUSYObjDef_xAOD.h:738
ST::SUSYObjDef_xAOD::m_tauConfigPathBaseline
std::string m_tauConfigPathBaseline
Definition SUSYObjDef_xAOD.h:747
ST::SUSYObjDef_xAOD::m_useCommonPRWFiles
bool m_useCommonPRWFiles
Definition SUSYObjDef_xAOD.h:611
ST::SUSYObjDef_xAOD::m_jetJvt
double m_jetJvt
Definition SUSYObjDef_xAOD.h:758
ST::SUSYObjDef_xAOD::m_mu_iso_fallback
std::map< std::string, std::string > m_mu_iso_fallback
Definition SUSYObjDef_xAOD.h:644
ST::SUSYObjDef_xAOD::m_tauTagger
std::string m_tauTagger
Definition SUSYObjDef_xAOD.h:662
ST::SUSYObjDef_xAOD::m_fJvtPtMax
double m_fJvtPtMax
Definition SUSYObjDef_xAOD.h:769
ST::SUSYObjDef_xAOD::m_photonSelIsEMBaseline
asg::AnaToolHandle< IAsgPhotonIsEMSelector > m_photonSelIsEMBaseline
Definition SUSYObjDef_xAOD.h:918
ST::SUSYObjDef_xAOD::m_muBaselinePt
double m_muBaselinePt
Definition SUSYObjDef_xAOD.h:720
ST::SUSYObjDef_xAOD::m_murequirepassedHighPtCuts
bool m_murequirepassedHighPtCuts
Definition SUSYObjDef_xAOD.h:728
ST::SUSYObjDef_xAOD::m_mubaselined0sig
double m_mubaselined0sig
Definition SUSYObjDef_xAOD.h:726
ST::SUSYObjDef_xAOD::m_inputMETSuffix
std::string m_inputMETSuffix
Definition SUSYObjDef_xAOD.h:580
ST::SUSYObjDef_xAOD::m_muonTerm
std::string m_muonTerm
Definition SUSYObjDef_xAOD.h:579
ST::SUSYObjDef_xAOD::m_btagSelTool
asg::AnaToolHandle< IBTaggingSelectionTool > m_btagSelTool
Definition SUSYObjDef_xAOD.h:941
ST::SUSYObjDef_xAOD::m_ApplyMVATESQualityCheck
bool m_ApplyMVATESQualityCheck
Definition SUSYObjDef_xAOD.h:753
ST::SUSYObjDef_xAOD::m_acc_jetClean
SG::ConstAccessor< char > m_acc_jetClean
Definition SUSYObjDef_xAOD.h:1015
ST::SUSYObjDef_xAOD::m_eled0sig
double m_eled0sig
Definition SUSYObjDef_xAOD.h:709
ST::SUSYObjDef_xAOD::m_photonTriggerSFTool
asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > m_photonTriggerSFTool
Definition SUSYObjDef_xAOD.h:922
ST::SUSYObjDef_xAOD::m_EigenvectorReductionC
std::string m_EigenvectorReductionC
Definition SUSYObjDef_xAOD.h:694
ST::SUSYObjDef_xAOD::m_fatJetUncConfig
std::string m_fatJetUncConfig
Definition SUSYObjDef_xAOD.h:546
ST::SUSYObjDef_xAOD::m_prwDataSF
double m_prwDataSF
Definition SUSYObjDef_xAOD.h:629
ST::SUSYObjDef_xAOD::m_eleConfig
std::string m_eleConfig
Definition SUSYObjDef_xAOD.h:654
ST::SUSYObjDef_xAOD::m_orToolbox
ORUtils::ToolBox m_orToolbox
Definition SUSYObjDef_xAOD.h:1000
ST::SUSYObjDef_xAOD::m_orDoFatjets
bool m_orDoFatjets
Definition SUSYObjDef_xAOD.h:807
ST::SUSYObjDef_xAOD::m_jetTerm
std::string m_jetTerm
Definition SUSYObjDef_xAOD.h:578
ST::SUSYObjDef_xAOD::m_TopTagUncConfig
std::string m_TopTagUncConfig
Definition SUSYObjDef_xAOD.h:563
ST::SUSYObjDef_xAOD::m_tauInputFileBaseline
std::string m_tauInputFileBaseline
Definition SUSYObjDef_xAOD.h:749
ST::SUSYObjDef_xAOD::m_trigMatchScoringTool
asg::AnaToolHandle< Trig::IMatchScoringTool > m_trigMatchScoringTool
Definition SUSYObjDef_xAOD.h:985
ST::SUSYObjDef_xAOD::m_muonSelectionToolBaseline
asg::AnaToolHandle< CP::IMuonSelectionTool > m_muonSelectionToolBaseline
Definition SUSYObjDef_xAOD.h:886
ST::SUSYObjDef_xAOD::m_trig2022combination_multiLep
std::string m_trig2022combination_multiLep
Definition SUSYObjDef_xAOD.h:971
ST::SUSYObjDef_xAOD::m_eleAllowRun3TrigSFFallback
bool m_eleAllowRun3TrigSFFallback
Definition SUSYObjDef_xAOD.h:716
ST::SUSYObjDef_xAOD::m_muTriggerSFCalibFilename
std::string m_muTriggerSFCalibFilename
Definition SUSYObjDef_xAOD.h:688
ST::SUSYObjDef_xAOD::m_mud0sig
double m_mud0sig
Definition SUSYObjDef_xAOD.h:724
ST::SUSYObjDef_xAOD::m_egammaCalibTool
asg::AnaToolHandle< CP::IEgammaCalibrationAndSmearingTool > m_egammaCalibTool
Combined electron collection.
Definition SUSYObjDef_xAOD.h:914
ST::SUSYObjDef_xAOD::m_IsoCloseByORpassLabel
std::string m_IsoCloseByORpassLabel
Definition SUSYObjDef_xAOD.h:817
ST::SUSYObjDef_xAOD::m_trig2015combination_multiLep
std::string m_trig2015combination_multiLep
Definition SUSYObjDef_xAOD.h:967
ST::SUSYObjDef_xAOD::m_trig2022combination_diPhoton
std::string m_trig2022combination_diPhoton
Definition SUSYObjDef_xAOD.h:979
ST::SUSYObjDef_xAOD::m_prwActualMu2023File
std::string m_prwActualMu2023File
Definition SUSYObjDef_xAOD.h:625
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_trig_singleLep
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_trig_singleLep
Definition SUSYObjDef_xAOD.h:900
ST::SUSYObjDef_xAOD::m_jetTruthLabelingTool
asg::AnaToolHandle< JetTruthLabelingTool > m_jetTruthLabelingTool
Definition SUSYObjDef_xAOD.h:865
ST::SUSYObjDef_xAOD::m_TopDecorName
std::string m_TopDecorName
Definition SUSYObjDef_xAOD.h:555
ST::SUSYObjDef_xAOD::m_autoconfigPRW
bool m_autoconfigPRW
Definition SUSYObjDef_xAOD.h:602
ST::SUSYObjDef_xAOD::m_fatjetUncertaintiesPDSmearTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_fatjetUncertaintiesPDSmearTool
Definition SUSYObjDef_xAOD.h:850
ST::SUSYObjDef_xAOD::m_autoconfigPRWFile
std::string m_autoconfigPRWFile
Definition SUSYObjDef_xAOD.h:604
ST::SUSYObjDef_xAOD::m_isPHYSLITE
bool m_isPHYSLITE
Definition SUSYObjDef_xAOD.h:821
ST::SUSYObjDef_xAOD::m_dataSource
int m_dataSource
Definition SUSYObjDef_xAOD.h:519
ST::SUSYObjDef_xAOD::m_eleForceFullSimCalib
bool m_eleForceFullSimCalib
Definition SUSYObjDef_xAOD.h:717
ST::SUSYObjDef_xAOD::m_muEta
double m_muEta
Definition SUSYObjDef_xAOD.h:723
ST::SUSYObjDef_xAOD::m_ZDecorName
std::string m_ZDecorName
Definition SUSYObjDef_xAOD.h:554
ST::SUSYObjDef_xAOD::m_bTaggingCalibrationFilePath
std::string m_bTaggingCalibrationFilePath
Definition SUSYObjDef_xAOD.h:840
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_iso
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_iso
Definition SUSYObjDef_xAOD.h:902
ST::SUSYObjDef_xAOD::m_muPt
double m_muPt
Definition SUSYObjDef_xAOD.h:722
ST::SUSYObjDef_xAOD::m_WTaggerTool
asg::AnaToolHandle< SmoothedWZTagger > m_WTaggerTool
Definition SUSYObjDef_xAOD.h:862
ST::SUSYObjDef_xAOD::m_commonPRWFileMC23a
std::string m_commonPRWFileMC23a
Definition SUSYObjDef_xAOD.h:615
ST::SUSYObjDef_xAOD::m_jetCalibTool
asg::AnaToolHandle< IJetCalibrationTool > m_jetCalibTool
Definition SUSYObjDef_xAOD.h:845
ST::SUSYObjDef_xAOD::m_metVeryGreedyPhotons
bool m_metVeryGreedyPhotons
Definition SUSYObjDef_xAOD.h:591
ST::SUSYObjDef_xAOD::m_doPhiReso
bool m_doPhiReso
Definition SUSYObjDef_xAOD.h:600
ST::SUSYObjDef_xAOD::m_eleBaselineIso_WP
std::string m_eleBaselineIso_WP
Definition SUSYObjDef_xAOD.h:656
ST::SUSYObjDef_xAOD::m_fatJetUncVars
std::string m_fatJetUncVars
Definition SUSYObjDef_xAOD.h:548
ST::SUSYObjDef_xAOD::m_electronTriggerSFStringSingle
std::string m_electronTriggerSFStringSingle
Definition SUSYObjDef_xAOD.h:648
ST::SUSYObjDef_xAOD::m_runDepPrescaleWeightPRW
bool m_runDepPrescaleWeightPRW
Definition SUSYObjDef_xAOD.h:632
ST::SUSYObjDef_xAOD::m_trig2015combination_diPhoton
std::string m_trig2015combination_diPhoton
Definition SUSYObjDef_xAOD.h:975
ST::SUSYObjDef_xAOD::m_muonIsolationSFTool
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonIsolationSFTool
Definition SUSYObjDef_xAOD.h:891
ST::SUSYObjDef_xAOD::m_tool_init
bool m_tool_init
Definition SUSYObjDef_xAOD.h:572
ST::SUSYObjDef_xAOD::m_elePt
double m_elePt
Definition SUSYObjDef_xAOD.h:706
ST::SUSYObjDef_xAOD::m_eleBaselinePt
double m_eleBaselinePt
Definition SUSYObjDef_xAOD.h:703
ST::SUSYObjDef_xAOD::m_orRemoveCaloMuons
bool m_orRemoveCaloMuons
Definition SUSYObjDef_xAOD.h:800
ST::SUSYObjDef_xAOD::m_orBoostedElectronC1
double m_orBoostedElectronC1
Definition SUSYObjDef_xAOD.h:788
ST::SUSYObjDef_xAOD::m_trkJetsyst
bool m_trkJetsyst
Definition SUSYObjDef_xAOD.h:596
ST::SUSYObjDef_xAOD::m_BtagTagger_trkJet
std::string m_BtagTagger_trkJet
Definition SUSYObjDef_xAOD.h:698
ST::SUSYObjDef_xAOD::m_trig2018combination_multiLep
std::string m_trig2018combination_multiLep
Definition SUSYObjDef_xAOD.h:970
ST::SUSYObjDef_xAOD::m_photonEfficiencySFTool
asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > m_photonEfficiencySFTool
Definition SUSYObjDef_xAOD.h:920
ST::SUSYObjDef_xAOD::m_JvtConfigRun3
std::string m_JvtConfigRun3
Definition SUSYObjDef_xAOD.h:762
ST::SUSYObjDef_xAOD::m_muIso_WP
std::string m_muIso_WP
Definition SUSYObjDef_xAOD.h:682

◆ ~SUSYObjDef_xAOD()

ST::SUSYObjDef_xAOD::~SUSYObjDef_xAOD ( )

Definition at line 3208 of file SUSYObjDef_xAOD.cxx.

3208 {
3209
3210#ifdef XAOD_STANDALONE
3211 // remove all tools from the asg::ToolStore (and delete them)
3212 // so that they don't get re-used if we set up another SUSYTools
3213 // instance, e.g. when processing two datasets in one EventLoop
3214 // job
3215 if (!m_trigDecTool.empty()){
3216 if (asg::ToolStore::contains<Trig::TrigDecisionTool>("ToolSvc.TrigDecisionTool") ){
3217 // Ignore both of these so that we are safe if others have cleaned up
3218 m_trigDecTool->finalize().ignore();
3219 asg::ToolStore::remove("ToolSvc.TrigDecisionTool").ignore();
3220 }
3221 }
3222#endif
3223}
asg::ToolStore::contains
static bool contains(const std::string &name)
Check whether a tool with a given type and name is known in the store.
Definition ToolStore.h:51
asg::ToolStore::remove
static StatusCode remove(const IAsgTool *tool)
Remove the specified tool from the store.
Definition ToolStore.cxx:77

Member Function Documentation

◆ ApplyLRTUncertainty()

StatusCode ST::SUSYObjDef_xAOD::ApplyLRTUncertainty ( )
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3173 of file SUSYObjDef_xAOD.cxx.

3173 {
3174
3175 // Don't apply variations for data
3176 if (isData()) return StatusCode::SUCCESS;
3177
3178 const EventContext& ctx = Gaudi::Hive::currentContext();
3179
3180 // Loop over tracks and call LRT uncertainty tool
3181 ATH_MSG_DEBUG ( "Applying LRT filter tool decorations for uncertainty");
3182 const xAOD::TrackParticleContainer inTracks = GetInDetLargeD0Tracks(ctx);
3183 for(const auto* trk: inTracks) dec_lrtFilter(*trk) = m_LRTuncTool->accept(trk);
3184
3185 // Loop over GSF LRT tracks and call uncertainty tool
3186 const xAOD::TrackParticleContainer inGSFTracks = GetInDetLargeD0GSFTracks(ctx);
3187 for(const auto* trk: inGSFTracks) dec_lrtFilter(*trk) = m_LRTuncTool->accept(trk);
3188
3189 return StatusCode::SUCCESS;
3190}
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x,...)
Definition AthMsgStreamMacros.h:43
ST::SUSYObjDef_xAOD::isData
bool isData() const override final
Definition SUSYObjDef_xAOD.h:157
ST::SUSYObjDef_xAOD::GetInDetLargeD0GSFTracks
const xAOD::TrackParticleContainer & GetInDetLargeD0GSFTracks(const EventContext &ctx) const override final
Definition SUSYObjDef_xAOD.cxx:3164
ST::SUSYObjDef_xAOD::GetInDetLargeD0Tracks
const xAOD::TrackParticleContainer & GetInDetLargeD0Tracks(const EventContext &ctx) const override final
Definition SUSYObjDef_xAOD.cxx:3152
ST::dec_lrtFilter
static const SG::Decorator< char > dec_lrtFilter("passLRTFilter")
xAOD::TrackParticleContainer
TrackParticleContainer_v1 TrackParticleContainer
Definition of the current "TrackParticle container version".
Definition Event/xAOD/xAODTracking/xAODTracking/TrackParticleContainer.h:14

◆ ApplyPRWTool()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3128 of file SUSYObjDef_xAOD.cxx.

3128 {
3129
3130 const xAOD::EventInfo* evtInfo = GetEventInfo();
3131 if(!randomrunnumber.isAvailable(*evtInfo))
3132 ATH_CHECK( m_prwTool->apply( *evtInfo, muDependentRRN ) );
3133 return StatusCode::SUCCESS;
3134}
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
SG::ConstAccessor::isAvailable
bool isAvailable(const ELT &e) const
Test to see if this variable exists in the store.
ST::SUSYObjDef_xAOD::GetEventInfo
const xAOD::EventInfo * GetEventInfo() const override final
Definition SUSYObjDef_xAOD.cxx:3057
ST::randomrunnumber
static const SG::ConstAccessor< unsigned int > randomrunnumber("RandomRunNumber")
xAOD::EventInfo
EventInfo_v1 EventInfo
Definition of the latest event info version.
Definition IEventInfoCnvTool.h:16

◆ applySystematicVariation()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2219 of file SUSYObjDef_xAOD.cxx.

2220{
2221 if (!m_tool_init) {
2222 ATH_MSG_ERROR("SUSYTools was not initialized!!");
2223 return StatusCode::FAILURE;
2224 }
2225
2226 ATH_MSG_DEBUG(" in SUSYObjDef_xAOD::applySystematicVariation \"" << systConfig.name() << "\" size " << systConfig.size());
2227
2228 m_currentSyst = systConfig;
2229
2230 // NB: SystematicSet typically has only one component (see SUSYToolsTester macro)
2231 if (!m_jetUncertaintiesTool.empty() && systConfig.name().find("PseudoData") == std::string::npos) {
2232 StatusCode ret = m_jetUncertaintiesTool->applySystematicVariation(systConfig);
2233 if ( ret != StatusCode::SUCCESS) {
2234 ATH_MSG_VERBOSE("Cannot configure JetUncertaintiesTool for systematic var. " << systConfig.name() );
2235 } else {
2236 ATH_MSG_VERBOSE("Configured JetUncertaintiesTool for systematic var. " << systConfig.name() );
2237 }
2238 }
2239 if (!m_jetUncertaintiesPDSmearTool.empty() && systConfig.name().find("PseudoData") != std::string::npos) {
2240 StatusCode ret = m_jetUncertaintiesPDSmearTool->applySystematicVariation(systConfig);
2241 if ( ret != StatusCode::SUCCESS) {
2242 ATH_MSG_VERBOSE("Cannot configure JetUncertaintiesPDSmearTool for systematic var. " << systConfig.name() );
2243 } else {
2244 ATH_MSG_VERBOSE("Configured JetUncertaintiesPDSmearTool for systematic var. " << systConfig.name() );
2245 }
2246 }
2247 if (!m_WTagjetUncertaintiesTool.empty() && !m_WTagUncConfig.empty()) {
2248 StatusCode ret = m_WTagjetUncertaintiesTool->applySystematicVariation(systConfig);
2249 if ( ret != StatusCode::SUCCESS) {
2250 ATH_MSG_VERBOSE("Cannot configure (Fat)JetUncertaintiesTool (WTag) for systematic var. " << systConfig.name() );
2251 } else {
2252 ATH_MSG_VERBOSE("Configured (Fat)JetUncertaintiesTool (WTag) for systematic var. " << systConfig.name() );
2253 }
2254 }
2255 if (!m_ZTagjetUncertaintiesTool.empty() && !m_ZTagUncConfig.empty()) {
2256 StatusCode ret = m_ZTagjetUncertaintiesTool->applySystematicVariation(systConfig);
2257 if ( ret != StatusCode::SUCCESS) {
2258 ATH_MSG_VERBOSE("Cannot configure (Fat)JetUncertaintiesTool (ZTag) for systematic var. " << systConfig.name() );
2259 } else {
2260 ATH_MSG_VERBOSE("Configured (Fat)JetUncertaintiesTool (ZTag) for systematic var. " << systConfig.name() );
2261 }
2262 }
2263
2264 if (!m_TopTagjetUncertaintiesTool.empty() && !m_TopTagUncConfig.empty()) {
2265 StatusCode ret = m_TopTagjetUncertaintiesTool->applySystematicVariation(systConfig);
2266 if ( ret != StatusCode::SUCCESS) {
2267 ATH_MSG_VERBOSE("Cannot configure (Fat)JetUncertaintiesTool (TopTag) for systematic var. " << systConfig.name() );
2268 } else {
2269 ATH_MSG_VERBOSE("Configured (Fat)JetUncertaintiesTool (TopTag) for systematic var. " << systConfig.name() );
2270 }
2271 }
2272 if (!m_fatjetUncertaintiesTool.empty() && systConfig.name().find("PseudoData") == std::string::npos) {
2273 StatusCode ret = m_fatjetUncertaintiesTool->applySystematicVariation(systConfig);
2274 if ( ret != StatusCode::SUCCESS) {
2275 ATH_MSG_VERBOSE("Cannot configure (Fat)JetUncertaintiesTool (main) for systematic var. " << systConfig.name() );
2276 } else {
2277 ATH_MSG_VERBOSE("Configured (Fat)JetUncertaintiesTool (main) for systematic var. " << systConfig.name() );
2278 }
2279 }
2280 if (!m_fatjetUncertaintiesPDSmearTool.empty() && systConfig.name().find("PseudoData") != std::string::npos) {
2281 StatusCode ret = m_fatjetUncertaintiesPDSmearTool->applySystematicVariation(systConfig);
2282 if ( ret != StatusCode::SUCCESS) {
2283 ATH_MSG_VERBOSE("Cannot configure FatJetUncertaintiesPDSmearTool for systematic var. " << systConfig.name() );
2284 } else {
2285 ATH_MSG_VERBOSE("Configured FatJetUncertaintiesPDSmearTool for systematic var. " << systConfig.name() );
2286 }
2287 }
2288 if (!m_fatjetFFSmearingTool.empty() && std::find(m_fatjetFFSmearingSyst.begin(), m_fatjetFFSmearingSyst.end(), systConfig) != m_fatjetFFSmearingSyst.end()) {
2289 StatusCode ret = m_fatjetFFSmearingTool->applySystematicVariation(systConfig);
2290 if ( ret != StatusCode::SUCCESS) {
2291 ATH_MSG_VERBOSE("Cannot configure (Fat)JetFFSmearingTool (main) for systematic var. " << systConfig.name() );
2292 } else {
2293 ATH_MSG_VERBOSE("Configured (Fat)JetFFSmearingTool (main) for systematic var. " << systConfig.name() );
2294 }
2295 }
2296 if (!m_jetNNJvtEfficiencyTool.empty()) {
2297 StatusCode ret = m_jetNNJvtEfficiencyTool->applySystematicVariation(systConfig);
2298 if ( ret != StatusCode::SUCCESS) {
2299 ATH_MSG_VERBOSE("Cannot configure NNJvtEfficiency for systematic var. " << systConfig.name() );
2300 } else {
2301 ATH_MSG_VERBOSE("Configured NNJvtEfficiency for systematic var. " << systConfig.name() );
2302 }
2303 }
2304 if (!m_jetfJvtEfficiencyTool.empty()) {
2305 StatusCode ret = m_jetfJvtEfficiencyTool->applySystematicVariation(systConfig);
2306 if ( ret != StatusCode::SUCCESS) {
2307 ATH_MSG_VERBOSE("Cannot configure fJvtEfficiency for systematic var. " << systConfig.name() );
2308 } else {
2309 ATH_MSG_VERBOSE("Configured fJvtEfficiency for systematic var. " << systConfig.name() );
2310 }
2311 }
2312 if (!m_muonCalibTool.empty()) {
2313 StatusCode ret = m_muonCalibTool->applySystematicVariation(systConfig);
2314 if (ret != StatusCode::SUCCESS) {
2315 ATH_MSG_ERROR("Cannot configure MuonCalibTool for systematic var. " << systConfig.name() );
2316 return ret;
2317 } else {
2318 ATH_MSG_VERBOSE("MuonCalibTool configured for systematic var. " << systConfig.name() );
2319 }
2320 }
2321 if (!m_muonEfficiencySFTool.empty()) {
2322 StatusCode ret = m_muonEfficiencySFTool->applySystematicVariation(systConfig);
2323 if ( ret != StatusCode::SUCCESS) {
2324 ATH_MSG_ERROR("Cannot configure MuonEfficiencyScaleFactors for systematic var. " << systConfig.name() );
2325 return ret;
2326 } else {
2327 ATH_MSG_VERBOSE("MuonEfficiencyScaleFactors configured for systematic var. " << systConfig.name() );
2328 }
2329 }
2330 if (!m_muonEfficiencyBMHighPtSFTool.empty()) {
2331 StatusCode ret = m_muonEfficiencyBMHighPtSFTool->applySystematicVariation(systConfig);
2332 if ( ret != StatusCode::SUCCESS) {
2333 ATH_MSG_ERROR("Cannot configure MuonBadMuonHighPtScaleFactors for systematic var. " << systConfig.name() );
2334 return ret;
2335 } else {
2336 ATH_MSG_VERBOSE("MuonBadMuonHighPtScaleFactors configured for systematic var. " << systConfig.name() );
2337 }
2338 }
2339 if (!m_muonTTVAEfficiencySFTool.empty()) {
2340 StatusCode ret = m_muonTTVAEfficiencySFTool->applySystematicVariation(systConfig);
2341 if ( ret != StatusCode::SUCCESS) {
2342 ATH_MSG_ERROR("Cannot configure MuonTTVAEfficiencyScaleFactors for systematic var. " << systConfig.name() );
2343 return ret;
2344 } else {
2345 ATH_MSG_VERBOSE("MuonTTVAEfficiencyScaleFactors configured for systematic var. " << systConfig.name() );
2346 }
2347 }
2348 if (!m_muonIsolationSFTool.empty()) {
2349 StatusCode ret = m_muonIsolationSFTool->applySystematicVariation(systConfig);
2350 if ( ret != StatusCode::SUCCESS) {
2351 ATH_MSG_ERROR("Cannot configure MuonIsolationScaleFactors for systematic var. " << systConfig.name() );
2352 return ret;
2353 } else {
2354 ATH_MSG_VERBOSE("MuonIsolationScaleFactors configured for systematic var. " << systConfig.name() );
2355 }
2356 }
2357 if (!m_muonTriggerSFTool.empty()) {
2358 StatusCode ret = m_muonTriggerSFTool->applySystematicVariation(systConfig);
2359 if ( ret != StatusCode::SUCCESS) {
2360 ATH_MSG_ERROR("Cannot configure MuonTriggerScaleFactors for systematic var. " << systConfig.name() );
2361 return ret;
2362 } else {
2363 ATH_MSG_VERBOSE("MuonTriggerScaleFactors configured for systematic var. " << systConfig.name() );
2364 }
2365 }
2366 if (!m_elecEfficiencySFTool_reco.empty()) {
2367 StatusCode ret = m_elecEfficiencySFTool_reco->applySystematicVariation(systConfig);
2368 if (ret != StatusCode::SUCCESS) {
2369 ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (reco) for systematic var. " << systConfig.name() );
2370 return ret;
2371 } else {
2372 ATH_MSG_VERBOSE("AsgElectronEfficiencyCorrectionTool (reco) configured for systematic var. " << systConfig.name() );
2373 }
2374 }
2375 if (!m_elecEfficiencySFTool_id.empty()) {
2376 StatusCode ret = m_elecEfficiencySFTool_id->applySystematicVariation(systConfig);
2377 if (ret != StatusCode::SUCCESS) {
2378 ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (id) for systematic var. " << systConfig.name() );
2379 return ret;
2380 } else {
2381 ATH_MSG_VERBOSE("AsgElectronEfficiencyCorrectionTool (id) configured for systematic var. " << systConfig.name() );
2382 }
2383 }
2384 if (!m_elecEfficiencySFTool_trig_singleLep.empty()) {
2385 StatusCode ret = m_elecEfficiencySFTool_trig_singleLep->applySystematicVariation(systConfig);
2386 if (ret != StatusCode::SUCCESS) {
2387 ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (trigger) for systematic var. " << systConfig.name() );
2388 return ret;
2389 } else {
2390 ATH_MSG_VERBOSE("AsgElectronEfficiencyCorrectionTool (trigger) configured for systematic var. " << systConfig.name() );
2391 }
2392 }
2393 if (!m_elecEfficiencySFTool_trigEff_singleLep.empty()) {
2394 StatusCode ret = m_elecEfficiencySFTool_trigEff_singleLep->applySystematicVariation(systConfig);
2395 if (ret != StatusCode::SUCCESS) {
2396 ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (trigger SFTool) for systematic var. " << systConfig.name() );
2397 return ret;
2398 } else {
2399 ATH_MSG_VERBOSE("AsgElectronEfficiencyCorrectionTool (trigger SFTool) configured for systematic var. " << systConfig.name() );
2400 }
2401 }
2402 if (!m_trigGlobalEffCorrTool_diLep.empty()) {
2403 StatusCode ret = m_trigGlobalEffCorrTool_diLep->applySystematicVariation(systConfig);
2404 for(auto &sfop : m_elecTrigEffTools){
2405 StatusCode ret1 = sfop->applySystematicVariation(systConfig);
2406 if (ret1 != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure m_elecTrigEffTools (dilepton trigger) for systematic var. " << systConfig.name() ); return ret1; }
2407 }
2408 for(auto &sfop : m_elecTrigSFTools){
2409 StatusCode ret1 = sfop->applySystematicVariation(systConfig);
2410 if (ret1 != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure m_elecTrigSFTools (dilepton trigger) for systematic var. " << systConfig.name() ); return ret1; }
2411 }
2412 for(auto &sfop : m_muonTrigSFTools){
2413 StatusCode ret1 = sfop->applySystematicVariation(systConfig);
2414 if (ret1 != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure m_muonTrigSFTools (dilepton trigger) for systematic var. " << systConfig.name() ); return ret1; }
2415 }
2416 if (ret != StatusCode::SUCCESS) {
2417 ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (dilepton trigger) for systematic var. " << systConfig.name() );
2418 return ret;
2419 } else {
2420 ATH_MSG_VERBOSE("TrigGlobalEfficiencyCorrectionTool (dilepton trigger) configured for systematic var. " << systConfig.name() );
2421 }
2422 }
2423 if (!m_trigGlobalEffCorrTool_multiLep.empty()) {
2424 StatusCode ret = m_trigGlobalEffCorrTool_multiLep->applySystematicVariation(systConfig);
2425 for(auto &sfop : m_elecTrigEffTools){
2426 StatusCode ret1 = sfop->applySystematicVariation(systConfig);
2427 if (ret1 != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure m_elecTrigEffTools (multilep trigger) for systematic var. " << systConfig.name() ); return ret1; }
2428 }
2429 for(auto &sfop : m_elecTrigSFTools){
2430 StatusCode ret1 = sfop->applySystematicVariation(systConfig);
2431 if (ret1 != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure m_elecTrigSFTools (multilep trigger) for systematic var. " << systConfig.name() ); return ret1; }
2432 }
2433 for(auto &sfop : m_muonTrigSFTools){
2434 StatusCode ret1 = sfop->applySystematicVariation(systConfig);
2435 if (ret1 != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure m_muonTrigSFTools (multilep trigger) for systematic var. " << systConfig.name() ); return ret1; }
2436 }
2437 if (ret != StatusCode::SUCCESS) {
2438 ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (multi-lepton trigger) for systematic var. " << systConfig.name() );
2439 return ret;
2440 } else {
2441 ATH_MSG_VERBOSE("TrigGlobalEfficiencyCorrectionTool (multi-lepton trigger) configured for systematic var. " << systConfig.name() );
2442 }
2443 }
2444 if (!m_elecEfficiencySFTool_iso.empty()) {
2445 StatusCode ret = m_elecEfficiencySFTool_iso->applySystematicVariation(systConfig);
2446 if (ret != StatusCode::SUCCESS) {
2447 ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (iso) for systematic var. " << systConfig.name() );
2448 return ret;
2449 } else {
2450 ATH_MSG_VERBOSE("AsgElectronEfficiencyCorrectionTool (iso) configured for systematic var. " << systConfig.name() );
2451 }
2452 }
2453 if (!m_elecEfficiencySFTool_isoHighPt.empty()) {
2454 StatusCode ret = m_elecEfficiencySFTool_isoHighPt->applySystematicVariation(systConfig);
2455 if (ret != StatusCode::SUCCESS) {
2456 ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (iso high-pt) for systematic var. " << systConfig.name() );
2457 return ret;
2458 } else {
2459 ATH_MSG_VERBOSE("AsgElectronEfficiencyCorrectionTool (iso high-pt) configured for systematic var. " << systConfig.name() );
2460 }
2461 }
2462 if (!m_elecChargeEffCorrTool.empty()) {
2463 StatusCode ret = m_elecChargeEffCorrTool->applySystematicVariation(systConfig);
2464 if (ret != StatusCode::SUCCESS) {
2465 ATH_MSG_ERROR("Cannot configure ElectronChargeEffCorrectionTool for systematic var. " << systConfig.name() );
2466 return ret;
2467 } else {
2468 ATH_MSG_VERBOSE("ElectronChargeEffCorrectionTool configured for systematic var. " << systConfig.name() );
2469 }
2470 }
2471 if (!isData() && !m_photonEfficiencySFTool.empty()) {
2472 StatusCode ret = m_photonEfficiencySFTool->applySystematicVariation(systConfig);
2473 if (ret != StatusCode::SUCCESS) {
2474 ATH_MSG_ERROR("Cannot configure AsgPhotonEfficiencyCorrectionTool (reco) for systematic var. " << systConfig.name() );
2475 return ret;
2476 } else {
2477 ATH_MSG_VERBOSE("AsgPhotonEfficiencyCorrectionTool (reco) configured for systematic var. " << systConfig.name() );
2478 }
2479 }
2480 if (!isData() && !m_photonIsolationSFTool.empty()) {
2481 StatusCode ret = m_photonIsolationSFTool->applySystematicVariation(systConfig);
2482 if (ret != StatusCode::SUCCESS) {
2483 ATH_MSG_ERROR("Cannot configure AsgPhotonEfficiencyCorrectionTool (iso) for systematic var. " << systConfig.name() );
2484 return ret;
2485 } else {
2486 ATH_MSG_VERBOSE("AsgPhotonEfficiencyCorrectionTool configured (iso) for systematic var. " << systConfig.name() );
2487 }
2488 }
2489 if (!isData() && !m_photonTriggerSFTool.empty()) {
2490 StatusCode ret = m_photonTriggerSFTool->applySystematicVariation(systConfig);
2491 if (ret != StatusCode::SUCCESS) {
2492 ATH_MSG_ERROR("Cannot configure AsgPhotonEfficiencyCorrectionTool (trigger) for systematic var. " << systConfig.name() );
2493 return ret;
2494 } else {
2495 ATH_MSG_VERBOSE("AsgPhotonEfficiencyCorrectionTool configured (trigger) for systematic var. " << systConfig.name() );
2496 }
2497 }
2498 if (!m_trigGlobalEffCorrTool_diPhoton.empty()) {
2499 StatusCode ret = m_trigGlobalEffCorrTool_diPhoton->applySystematicVariation(systConfig);
2500 for(auto &sfop : m_photonTrigEffTools){
2501 StatusCode ret1 = sfop->applySystematicVariation(systConfig);
2502 if (ret1 != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure m_photonTrigEffTools (diphoton trigger) for systematic var. " << systConfig.name() ); return ret1; }
2503 }
2504 for(auto &sfop : m_photonTrigSFTools){
2505 StatusCode ret1 = sfop->applySystematicVariation(systConfig);
2506 if (ret1 != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure m_photonTrigSFTools (diphoton trigger) for systematic var. " << systConfig.name() ); return ret1; }
2507 }
2508 if (ret != StatusCode::SUCCESS) {
2509 ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (diphoton trigger) for systematic var. " << systConfig.name() );
2510 return ret;
2511 } else {
2512 ATH_MSG_VERBOSE("TrigGlobalEfficiencyCorrectionTool (diphoton trigger) configured for systematic var. " << systConfig.name() );
2513 }
2514 }
2515 if (!m_egammaCalibTool.empty()) {
2516 StatusCode ret = m_egammaCalibTool->applySystematicVariation(systConfig);
2517 if (ret != StatusCode::SUCCESS) {
2518 ATH_MSG_ERROR("Cannot configure EgammaCalibrationAndSmearingTool for systematic var. " << systConfig.name() );
2519 return ret;
2520 } else {
2521 ATH_MSG_VERBOSE("EgammaCalibrationAndSmearingTool configured for systematic var. " << systConfig.name() );
2522 }
2523 }
2524 if (!m_isoCorrTool.empty()) {
2525 StatusCode ret = m_isoCorrTool->applySystematicVariation(systConfig);
2526 if (ret != StatusCode::SUCCESS) {
2527 ATH_MSG_ERROR("Cannot configure IsolationCorrectionTool for systematic var. " << systConfig.name() );
2528 return ret;
2529 } else {
2530 ATH_MSG_VERBOSE("IsolationCorrectionTool configured for systematic var. " << systConfig.name() );
2531 }
2532 }
2533 if (!m_btagEffTool.empty()) {
2534 //if ( systConfig.size() > 0 && m_btagEffTool->isAffectedBySystematic(*systConfig.begin()) ) {
2535 StatusCode ret = m_btagEffTool->applySystematicVariation(systConfig);
2536 if ( ret != StatusCode::SUCCESS) {
2537 ATH_MSG_ERROR("Cannot configure xAODBTaggingEfficiency for systematic var. " << systConfig.name() );
2538 return ret;
2539 } else {
2540 ATH_MSG_VERBOSE("Configured xAODBTaggingEfficiency for systematic var. " << systConfig.name() );
2541 }
2542 //}
2543 }
2544 if (!m_btagEffTool_trkJet.empty()) {
2545 StatusCode ret = m_btagEffTool_trkJet->applySystematicVariation(systConfig);
2546 if ( ret != StatusCode::SUCCESS) {
2547 ATH_MSG_ERROR("Cannot configure xAODBTaggingEfficiency (track jets) for systematic var. " << systConfig.name() );
2548 return ret;
2549 } else {
2550 ATH_MSG_VERBOSE("Configured xAODBTaggingEfficiency (track jets) for systematic var. " << systConfig.name() );
2551 }
2552 }
2553 if (!m_tauSmearingTool.empty()) {
2554 StatusCode ret = m_tauSmearingTool->applySystematicVariation(systConfig);
2555 if ( ret != StatusCode::SUCCESS) {
2556 ATH_MSG_ERROR("Cannot configure TauSmearingTool for systematic var. " << systConfig.name() );
2557 return ret;
2558 } else {
2559 ATH_MSG_VERBOSE("Configured TauSmearingTool for systematic var. " << systConfig.name() );
2560 }
2561 }
2562 if (!m_tauEffTool.empty()) {
2563 StatusCode ret = m_tauEffTool->applySystematicVariation(systConfig);
2564 if ( ret != StatusCode::SUCCESS) {
2565 ATH_MSG_ERROR("Cannot configure TauEfficiencyCorrectionsTool for systematic var. " << systConfig.name() );
2566 return ret;
2567 } else {
2568 ATH_MSG_VERBOSE("Configured TauEfficiencyCorrectionsTool for systematic var. " << systConfig.name() );
2569 }
2570 }
2571 for(auto &tool : m_tauTrigEffTool) {
2572 StatusCode ret = tool->applySystematicVariation(systConfig);
2573 if (ret != StatusCode::SUCCESS) {
2574 ATH_MSG_ERROR("Cannot configure " << tool->name() << " for systematic var. " << systConfig.name() );
2575 return ret;
2576 } else {
2577 ATH_MSG_VERBOSE("Configured " << tool->name() << " for systematic var. " << systConfig.name() );
2578 }
2579 }
2580 if (!m_metSystTool.empty()) {
2581 StatusCode ret = m_metSystTool->applySystematicVariation(systConfig);
2582 if ( ret != StatusCode::SUCCESS) {
2583 ATH_MSG_ERROR("Cannot configure METSystematicsTool for systematic var. " << systConfig.name() );
2584 return ret;
2585 } else {
2586 ATH_MSG_VERBOSE("Configured METSystematicsTool for systematic var. " << systConfig.name() );
2587 }
2588 }
2589 if (!m_prwTool.empty()) {
2590 StatusCode ret = m_prwTool->applySystematicVariation(systConfig);
2591 if ( ret != StatusCode::SUCCESS) {
2592 ATH_MSG_ERROR("Cannot configure PileupReweightingTool for systematic var. " << systConfig.name() );
2593 return ret;
2594 } else {
2595 ATH_MSG_VERBOSE("Configured PileupReweightingTool for systematic var. " << systConfig.name() );
2596 }
2597 }
2598
2599 if (!m_LRTuncTool.empty()) {
2600 StatusCode ret = m_LRTuncTool->applySystematicVariation(systConfig);
2601 if ( ret != StatusCode::SUCCESS) {
2602 ATH_MSG_ERROR("Cannot configure InDetTrackFilterTool for systematic var. " << systConfig.name() );
2603 return ret;
2604 } else {
2605 ATH_MSG_VERBOSE("Configured InDetTrackFilterTool for systematic var. " << systConfig.name() );
2606 }
2607 }
2608
2609 return StatusCode::SUCCESS;
2610}
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x,...)
Definition AthMsgStreamMacros.h:47
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x,...)
Definition AthMsgStreamMacros.h:42
CP::SystematicSet::size
size_t size() const
returns: size of the set
Definition SystematicSet.h:71
CP::SystematicSet::name
const std::string & name() const
returns: the systematics joined into a single string.
Definition SystematicSet.cxx:277
ST::SUSYObjDef_xAOD::m_muonTrigSFTools
ToolHandleArray< CP::IMuonTriggerScaleFactors > m_muonTrigSFTools
Definition SUSYObjDef_xAOD.h:894
ST::SUSYObjDef_xAOD::m_elecTrigEffTools
ToolHandleArray< IAsgElectronEfficiencyCorrectionTool > m_elecTrigEffTools
Definition SUSYObjDef_xAOD.h:909
ST::SUSYObjDef_xAOD::m_elecTrigSFTools
ToolHandleArray< IAsgElectronEfficiencyCorrectionTool > m_elecTrigSFTools
Definition SUSYObjDef_xAOD.h:908
ST::SUSYObjDef_xAOD::m_photonTrigSFTools
ToolHandleArray< IAsgPhotonEfficiencyCorrectionTool > m_photonTrigSFTools
Definition SUSYObjDef_xAOD.h:926
ST::SUSYObjDef_xAOD::m_tauTrigEffTool
std::vector< asg::AnaToolHandle< TauAnalysisTools::ITauEfficiencyCorrectionsTool > > m_tauTrigEffTool
Definition SUSYObjDef_xAOD.h:938
ST::SUSYObjDef_xAOD::m_photonTrigEffTools
ToolHandleArray< IAsgPhotonEfficiencyCorrectionTool > m_photonTrigEffTools
Definition SUSYObjDef_xAOD.h:927
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22

◆ 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 1040 of file SUSYObjDef_xAOD.cxx.

1040 {
1041
1042 // this will contain the path of the PRW file on /cvmfs which needs to be reverse engineered from the DSID and MC campaign
1043 // the path(s) will be added to m_prwConfFiles which is later used in the configuration of the CP PRW tool
1044 std::string prwConfigFile("");
1045
1046 if ( !isData() && m_autoconfigPRW ) {
1047
1048 prwConfigFile = PRWfilesDir;
1049
1050 float dsid = -999;
1051 std::string amiTag("");
1052 std::string mcCampaignMD("");
1053 std::string simFlavour("");
1054 std::string simType("");
1055 const xAOD::FileMetaData* fmd = nullptr;
1056
1057 // configure PRW rtag options from m_autoconfigPRWRtags string
1058 // e.g. "mc20a:r13167_r14859,mc20d:r13144_r14860,mc20e:r13145_r14861,mc23a:r14622_r14932_r15540,mc23d:r15224_r15530,mc23e:r16083,mc23g:r17610"
1059 std::map<std::string,std::vector<std::string>> PRWRtags = {};
1060 std::string allcampaigns = "mc20a.mc20d.mc20e.mc23a.mc23d.mc23e.mc23g";
1061 bool standard_like = true;
1062 for ( const auto& campaign_rtags : split( m_autoconfigPRWRtags, "," ) ) { // split string by ","
1063 std::string icampaign = campaign_rtags.substr(0, campaign_rtags.find(":")); // first field = campaign, split by ":"
1064 std::vector<std::string> irtags = split( campaign_rtags.substr(campaign_rtags.find(":")+1), "_" ); // remaining fields = rtags, split by "_"
1065 PRWRtags[icampaign] = irtags;
1066 ATH_MSG_DEBUG( "PRW autoconfigure considering rtags " << campaign_rtags.substr(campaign_rtags.find("_")+1) << " for campaign " << icampaign );
1067 }
1068 for ( const auto& x : PRWRtags ) {
1069 if ( allcampaigns.find(x.first)==string::npos ) {
1070 ATH_MSG_ERROR("m_autoconfigPRWRtags contains invalid campaign: " << x.first << " (" << m_autoconfigPRWRtags << ")");
1071 ATH_MSG_ERROR("use any of " << allcampaigns);
1072 return StatusCode::FAILURE;
1073 }
1074 }
1075
1076 // let's use MetaData to extract sample information
1077 if ( inputMetaStore()->contains<xAOD::FileMetaData>("FileMetaData") && inputMetaStore()->retrieve(fmd,"FileMetaData").isSuccess() ) {
1078 fmd->value(xAOD::FileMetaData::mcProcID, dsid);
1079 fmd->value(xAOD::FileMetaData::amiTag, amiTag);
1080 fmd->value(xAOD::FileMetaData::simFlavour, simFlavour);
1081
1082 if(simFlavour.starts_with("ATLFASTII")) simType = "AFII";
1083 else if(simFlavour.starts_with("ATLFAST3")) simType = "AF3";
1084 else simType = "FS";
1085
1086 bool found = false;
1087 while ( mcCampaignMD.empty() ) {
1088 for ( const auto& campaign_rtags : PRWRtags ) { // consider all campaigns
1089 for ( const auto& rtag: campaign_rtags.second ) { // consider all rtags
1090 if (found) continue;
1091 if (amiTag.find(rtag)!=string::npos) { // find matching tag
1092 mcCampaignMD = campaign_rtags.first.substr(0,5); // save campaign
1093 standard_like = (campaign_rtags.first.find("ns")?true:false); // track non-standard r-tags
1094 found = true; // break if found
1095 }
1096 }
1097 }
1098 // in case not found
1099 if (!found) {
1100 ATH_MSG_ERROR( "autoconfigurePileupRWTool(): unrecognized xAOD::FileMetaData::amiTag, \'" << amiTag << "'. Please check your input sample.");
1101 return StatusCode::FAILURE;
1102 }
1103 //
1104 ATH_MSG_INFO( "Setting up autoconfigurePileupRWTool for mc campaign " << mcCampaignMD << " (from amiTag " << amiTag << ") (standard-like = " << (standard_like?"true":"false") << ")." );
1105 if ( (!standard_like) && (!RPVLLmode) )
1106 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?");
1107 }
1108 } else {
1109#ifndef XAOD_STANDALONE
1110 ATH_MSG_ERROR( "autoconfigurePileupRWTool(): access to FileMetaData failed, can't get mc channel number.");
1111 return StatusCode::FAILURE;
1112#else
1113
1114 if ( m_mcCampaign == "mc20a" || m_mcCampaign == "mc20d" || m_mcCampaign == "mc20e" || m_mcCampaign == "mc23a" || m_mcCampaign == "mc23d" || m_mcCampaign == "mc23e" || m_mcCampaign == "mc23g") {
1115 // First see if the user set the mcCampaign/run number by property (hopefully temporary workaround)
1116 if ( m_mcChannel > 0) {
1117 ATH_MSG_WARNING( "autoconfigurePileupRWTool(): access to FileMetaData failed -> getting the mc channel number (DSID) and campaign from configuration." );
1118 std::string NoMetadataButPropertyOK("");
1119 NoMetadataButPropertyOK += "autoconfigurePileupRWTool(): 'mcCampaign' is used and passed to SUSYTools as '";
1120 NoMetadataButPropertyOK += m_mcCampaign;
1121 NoMetadataButPropertyOK += "'. 'mcChannel' is used and passed to SUSYTools as '";
1122 NoMetadataButPropertyOK += std::to_string(m_mcChannel);
1123 NoMetadataButPropertyOK += "'. Autocongiguring PRW accordingly.";
1124 ATH_MSG_WARNING( NoMetadataButPropertyOK );
1125 mcCampaignMD = m_mcCampaign;
1126 dsid = m_mcChannel;
1127 } else {
1128 // OK, this is a fall-back option without using MetaData but one has to manually set 'mcCampaign' property
1129 ATH_MSG_WARNING( "autoconfigurePileupRWTool(): access to FileMetaData failed -> getting the mc channel number (DSID) from the event store." );
1130 const xAOD::EventInfo* evtInfo = GetEventInfo();
1131 dsid = evtInfo->mcChannelNumber();
1132
1133 std::string NoMetadataButPropertyOK("");
1134 NoMetadataButPropertyOK += "autoconfigurePileupRWTool(): 'mcCampaign' is used and passed to SUSYTools as '";
1135 NoMetadataButPropertyOK += m_mcCampaign;
1136 NoMetadataButPropertyOK += "'. Autoconfiguring PRW accordingly.";
1137 ATH_MSG_WARNING( NoMetadataButPropertyOK );
1138 mcCampaignMD = m_mcCampaign;
1139 }
1140 } else {
1141 ATH_MSG_ERROR( "autoconfigurePileupRWTool(): `mcCampaign' is not set properly.");
1142 return StatusCode::FAILURE;
1143 }
1144#endif
1145 }
1146
1147 // If requested set the PRW file to common PRW file of the processed MC campaign
1148 if (m_useCommonPRWFiles) {
1149 ATH_MSG_INFO( "autoconfigurePileupRWTool(): retrieving the common PRW file for MC campaign: " << mcCampaignMD );
1150 if (mcCampaignMD == "mc20a") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC20a);}
1151 else if (mcCampaignMD == "mc20d") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC20d);}
1152 else if (mcCampaignMD == "mc20e") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC20e);}
1153 else if (mcCampaignMD == "mc23a") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC23a);}
1154 else if (mcCampaignMD == "mc23d") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC23d);}
1155 else if (mcCampaignMD == "mc23e") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC23e);}
1156 else if (mcCampaignMD == "mc23g") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC23g);}
1157 else {
1158 ATH_MSG_ERROR( "autoconfigurePileupRWTool(): no common PRW file known for MC campaign: " << mcCampaignMD);
1159 return StatusCode::FAILURE;
1160 }
1161 }
1162 // Otherwise try finding the dedicated PRW file on /cvmfs
1163 else {
1164 // Retrieve the input file
1165 int DSID_INT = static_cast<int>(dsid);
1166 prwConfigFile += "DSID" + std::to_string(DSID_INT/1000) + "xxx/pileup_" + mcCampaignMD + "_dsid" + std::to_string(DSID_INT) + "_" + simType + ".root";
1167
1168 if (RPVLLmode) prwConfigFile = TString(prwConfigFile).ReplaceAll(".root","_rpvll.root").Data();
1169
1170 // PRW file specified by user
1171 // e.g. DSID700xxx/pileup_mc20a_dsid700015_FS.root
1172 if (!PRWfileName.empty()) {
1173 prwConfigFile = PRWfilesDir + PRWfileName;
1174 ATH_MSG_INFO( "autoconfigurePileupRWTool(): PRW file was specifed by user: " << prwConfigFile.data() );
1175 }
1176 }
1177
1178 m_prwConfFiles.clear();
1179
1180 // Combined mode can be only used when running with full data with the same MC samples
1181 if (Combinedmode) {
1182 if (mcCampaignMD.find("mc20") == std::string::npos) {
1183 ATH_MSG_ERROR( "autoconfigurePileupRWTool(): combined mode currently onlys supported for mc20! Impossible to autoconfigure PRW. Aborting." );
1184 return StatusCode::FAILURE;
1185 }
1186 // When using the common PRW files we can directly add them
1187 if (m_useCommonPRWFiles) {
1188 m_prwConfFiles.push_back( m_commonPRWFileMC20a );
1189 m_prwConfFiles.push_back( m_commonPRWFileMC20d );
1190 m_prwConfFiles.push_back( m_commonPRWFileMC20e );
1191 }
1192 // Otherwise we have to replace the mc campaign in the name accordingly
1193 else {
1194 m_prwConfFiles.emplace_back( TString(prwConfigFile).ReplaceAll(mcCampaignMD, "mc20a").Data() );
1195 m_prwConfFiles.emplace_back( TString(prwConfigFile).ReplaceAll(mcCampaignMD, "mc20d").Data() );
1196 m_prwConfFiles.emplace_back( TString(prwConfigFile).ReplaceAll(mcCampaignMD, "mc20e").Data() );
1197 }
1198 m_prwConfFiles.push_back( PathResolverFindCalibFile(m_prwActualMu2017File) );
1199 m_prwConfFiles.push_back( PathResolverFindCalibFile(m_prwActualMu2018File) );
1200 } else {
1201 m_prwConfFiles.push_back( prwConfigFile );
1202 if ( mcCampaignMD == "mc20d") {
1203 m_prwConfFiles.push_back( PathResolverFindCalibFile(m_prwActualMu2017File) );
1204 } else if (mcCampaignMD == "mc20e") {
1205 m_prwConfFiles.push_back( PathResolverFindCalibFile(m_prwActualMu2018File) );
1206 } else if (mcCampaignMD == "mc23a") {
1207 m_prwConfFiles.push_back( PathResolverFindCalibFile(m_prwActualMu2022File) );
1208 } else if (mcCampaignMD == "mc23d") {
1209 m_prwConfFiles.push_back( PathResolverFindCalibFile(m_prwActualMu2023File) );
1210 } else if (mcCampaignMD == "mc23e") {
1211 m_prwConfFiles.push_back( PathResolverFindCalibFile(m_prwActualMu2024File) );
1212 } else if (mcCampaignMD == "mc23g") {
1213 m_prwConfFiles.push_back( PathResolverFindCalibFile(m_prwActualMu2025File) );
1214 }
1215 }
1216 prwConfigFile = usePathResolver ? PathResolverFindCalibFile(prwConfigFile) : prwConfigFile;
1217
1218 // Test if file exists (i.e. was requested already to /cvmfs if the DSID-specific PRW files are used) and is usable
1219 TFile testF(prwConfigFile.data(),"read");
1220 if (testF.IsZombie()) {
1221 ATH_MSG_ERROR( "autoconfigurePileupRWTool(): file not found -> " << prwConfigFile.data() << " ! Impossible to autoconfigure PRW. Aborting." );
1222 if ( (!standard_like) && (!RPVLLmode) )
1223 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?");
1224 return StatusCode::FAILURE;
1225 }
1226
1227 ATH_MSG_INFO( "autoconfigurePileupRWTool(): configuring PRW tool using " << prwConfigFile.data() );
1228 }
1229 // Return gracefully
1230 return StatusCode::SUCCESS;
1231}
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x,...)
Definition AthMsgStreamMacros.h:46
ATH_MSG_INFO
#define ATH_MSG_INFO(x,...)
Definition AthMsgStreamMacros.h:45
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition PathResolver.cxx:325
ST::SUSYObjDef_xAOD::split
const std::vector< std::string > split(const std::string &s, const std::string &delim) const
Definition SUSYObjDef_xAOD.cxx:1891
asg::AsgMetadataTool::inputMetaStore
MetaStorePtr_t inputMetaStore() const
Accessor for the input metadata store.
Definition AsgMetadataTool.cxx:93
xAOD::EventInfo_v1::mcChannelNumber
uint32_t mcChannelNumber() const
The MC generator's channel number.
xAOD::FileMetaData_v1::mcProcID
@ mcProcID
Same as mc_channel_number [float].
Definition FileMetaData_v1.h:74
xAOD::FileMetaData_v1::amiTag
@ amiTag
AMI tag used to process the file the last time [string].
Definition FileMetaData_v1.h:58
xAOD::FileMetaData_v1::simFlavour
@ simFlavour
Fast or Full sim [string].
Definition FileMetaData_v1.h:76
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
contains
bool contains(const std::string &s, const std::string &regx)
does a string contain the substring
Definition hcg.cxx:116
Generate_dsid_ranseed.dsid
dsid
Definition Generate_dsid_ranseed.py:6
LCE_postprocessing.found
bool found
Definition LCE_postprocessing.py:46
xAOD::FileMetaData
FileMetaData_v1 FileMetaData
Declare the latest version of the class.
Definition Event/xAOD/xAODMetaData/xAODMetaData/FileMetaData.h:16

◆ 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 Trig::TrigConfBunchCrossingTool, Trig::TrigDecisionTool, Trig::xAODBunchCrossingTool, TrigConf::xAODConfigTool, and xAODMaker::TriggerMenuMetaDataTool.

Definition at line 201 of file AsgMetadataTool.cxx.

201 {
202
203 // Return gracefully:
204 return StatusCode::SUCCESS;
205 }

◆ 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 BookkeeperDumperTool, BookkeeperTool, PMGTools::PMGTruthWeightTool, Trig::TrigDecisionTool, Trig::xAODBunchCrossingTool, TrigConf::xAODConfigTool, xAODMaker::TriggerMenuMetaDataTool, and xAODMaker::TruthMetaDataTool.

Definition at line 185 of file AsgMetadataTool.cxx.

185 {
186
187 // Return gracefully:
188 return StatusCode::SUCCESS;
189 }

◆ BtagSF()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 844 of file Jets.cxx.

844 {
845
846 float totalSF = 1.;
847 for ( const xAOD::Jet* jet : *jets ) {
848
849 float sf = 1.;
850
851 if ( std::abs(jet->eta()) > 2.5 ) {
852 ATH_MSG_VERBOSE( "Trying to retrieve b-tagging SF for jet with |eta|>2.5 (jet eta=" << jet->eta() << "), jet will be skipped");
853 } else if ( jet->pt() < 20e3 ){
854 ATH_MSG_VERBOSE( "Trying to retrieve b-tagging SF for jet with invalid pt (jet pt=" << jet->pt() << "), jet will be skipped");
855 } else {
856
857 CP::CorrectionCode result;
858 int truthlabel(-1);
859 if (!jet->getAttribute("HadronConeExclTruthLabelID", truthlabel)) {
860 ATH_MSG_ERROR("Failed to get jet truth label!");
861 }
862 ATH_MSG_VERBOSE("This jet is " << (acc_bjet(*jet) ? "" : "not ") << "b-tagged.");
863 ATH_MSG_VERBOSE("This jet's truth label is " << truthlabel);
864
865 if ( acc_bjet(*jet) or m_BtagWP == "Continuous") {
866 result = m_btagEffTool->getScaleFactor(*jet, sf);
867
868 switch (result) {
869 case CP::CorrectionCode::Error:
870 ATH_MSG_ERROR( "Failed to retrieve SF for b-tagged jets in SUSYTools_xAOD::BtagSF" );
871 break;
872 case CP::CorrectionCode::OutOfValidityRange:
873 ATH_MSG_VERBOSE( "No valid SF for b-tagged jets in SUSYTools_xAOD::BtagSF" );
874 break;
875 default:
876 ATH_MSG_VERBOSE( "Retrieve SF for b-tagged jets in SUSYTools_xAOD::BtagSF with value " << sf );
877 }
878 } else {
879
880 result = m_btagEffTool->getInefficiencyScaleFactor(*jet, sf);
881
882 switch (result) {
883 case CP::CorrectionCode::Error:
884 ATH_MSG_ERROR( "Failed to retrieve SF for non-b-tagged jets in SUSYTools_xAOD::BtagSF" );
885 break;
886 case CP::CorrectionCode::OutOfValidityRange:
887 ATH_MSG_VERBOSE( "No valid inefficiency SF for non-b-tagged jets in SUSYTools_xAOD::BtagSF" );
888 break;
889 default:
890 ATH_MSG_VERBOSE( "Retrieve SF for non-b-tagged jets in SUSYTools_xAOD::BtagSF with value " << sf );
891 }
892 }
893 }
894
895 dec_effscalefact(*jet) = sf;
896
897 if( acc_signal(*jet) && acc_passOR(*jet) ) totalSF *= sf; //consider goodjets only
898
899 }
900
901 return totalSF;
902 }
CP::CorrectionCode::Error
@ Error
Some error happened during the object correction.
Definition CorrectionCode.h:36
CP::CorrectionCode::OutOfValidityRange
@ OutOfValidityRange
Input object is out of validity range.
Definition CorrectionCode.h:37
ST::dec_effscalefact
static const SG::Decorator< double > dec_effscalefact("effscalefact")
ST::acc_signal
static const SG::ConstAccessor< char > acc_signal("signal")
ST::acc_bjet
static const SG::ConstAccessor< char > acc_bjet("bjet")
ST::acc_passOR
static const SG::ConstAccessor< char > acc_passOR("passOR")
get_generator_info.result
result
Definition get_generator_info.py:21
xAOD::Jet
Jet_v1 Jet
Definition of the current "jet version".
Definition Event/xAOD/xAODJet/xAODJet/Jet.h:17

◆ BtagSF_trkJet()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 925 of file Jets.cxx.

925 {
926
927 float totalSF = 1.;
928 for ( const xAOD::Jet* trkjet : *trkjets ) {
929
930 float sf = 1.;
931
932 if ( std::abs(trkjet->eta()) > 2.5 ) {
933 ATH_MSG_VERBOSE( "Trying to retrieve b-tagging SF for trkjet with |eta|>2.5 (trkjet eta=" << trkjet->eta() << "), trkjet will be skipped");
934 } else if ( trkjet->pt() < 10e3 ){
935 ATH_MSG_VERBOSE( "Trying to retrieve b-tagging SF for trkjet with invalid pt (trkjet pt=" << trkjet->pt() << "), jet will be skipped");
936 } else {
937
938 CP::CorrectionCode result;
939 int truthlabel(-1);
940 if (!trkjet->getAttribute("HadronConeExclTruthLabelID", truthlabel)) {
941 ATH_MSG_ERROR("Failed to get jet truth label!");
942 }
943 ATH_MSG_VERBOSE("This jet is " << (acc_bjet(*trkjet) ? "" : "not ") << "b-tagged.");
944 ATH_MSG_VERBOSE("This jet's truth label is " << truthlabel);
945
946 if ( acc_bjet(*trkjet) ) {
947 result = m_btagEffTool_trkJet->getScaleFactor(*trkjet, sf);
948
949 switch (result) {
950 case CP::CorrectionCode::Error:
951 ATH_MSG_ERROR( "Failed to retrieve SF for b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet" );
952 break;
953 case CP::CorrectionCode::OutOfValidityRange:
954 ATH_MSG_VERBOSE( "No valid SF for b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet" );
955 break;
956 default:
957 ATH_MSG_VERBOSE( "Retrieve SF for b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet with value " << sf );
958 }
959 } else {
960
961 result = m_btagEffTool_trkJet->getInefficiencyScaleFactor(*trkjet, sf);
962
963 switch (result) {
964 case CP::CorrectionCode::Error:
965 ATH_MSG_ERROR( "Failed to retrieve SF for non-b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet" );
966 break;
967 case CP::CorrectionCode::OutOfValidityRange:
968 ATH_MSG_VERBOSE( "No valid inefficiency SF for non-b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet" );
969 break;
970 default:
971 ATH_MSG_VERBOSE( "Retrieve SF for non-b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet with value " << sf );
972 }
973 }
974 }
975
976 dec_effscalefact(*trkjet) = sf;
977
978 if( acc_signal(*trkjet) ) totalSF *= sf;
979
980 }
981
982 return totalSF;
983 }

◆ BtagSFsys()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 905 of file Jets.cxx.

906 {
907 float totalSF = 1.;
908
909 //Set the new systematic variation
910 StatusCode ret = m_btagEffTool->applySystematicVariation(systConfig);
911 if ( ret != StatusCode::SUCCESS) {
912 ATH_MSG_ERROR("Cannot configure BTaggingEfficiencyTool for systematic var. " << systConfig.name() );
913 }
914
915 totalSF = BtagSF( jets );
916
917 ret = m_btagEffTool->applySystematicVariation(m_currentSyst);
918 if ( ret != StatusCode::SUCCESS) {
919 ATH_MSG_ERROR("Cannot configure BTaggingEfficiencyTool for systematic var. " << systConfig.name() );
920 }
921
922 return totalSF;
923 }
ST::SUSYObjDef_xAOD::BtagSF
float BtagSF(const xAOD::JetContainer *jets) override final
Definition Jets.cxx:844

◆ BtagSFsys_trkJet()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 986 of file Jets.cxx.

987 {
988 float totalSF = 1.;
989
990 //Set the new systematic variation
991 StatusCode ret = m_btagEffTool_trkJet->applySystematicVariation(systConfig);
992 if ( ret != StatusCode::SUCCESS) {
993 ATH_MSG_ERROR("Cannot configure BTaggingEfficiencyTool (track jets) for systematic var. " << systConfig.name() );
994 }
995
996 totalSF = BtagSF_trkJet( trkjets );
997
998 ret = m_btagEffTool_trkJet->applySystematicVariation(m_currentSyst);
999 if ( ret != StatusCode::SUCCESS) {
1000 ATH_MSG_ERROR("Cannot configure BTaggingEfficiencyTool (track jets) for systematic var. " << systConfig.name() );
1001 }
1002
1003 return totalSF;
1004 }
ST::SUSYObjDef_xAOD::BtagSF_trkJet
float BtagSF_trkJet(const xAOD::JetContainer *trkjets) override final
Definition Jets.cxx:925

◆ check_isOption()

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

Definition at line 1241 of file SUSYObjDef_xAOD.cxx.

1241 {
1242 //check if the selected WP is supported
1243 return (std::find(list.begin(), list.end(),wp) != list.end());
1244}
histSizes.list
list(name, path='/')
Definition histSizes.py:38

◆ 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 1246 of file SUSYObjDef_xAOD.cxx.

1246 {
1247 //check if WP1 is tighter than WP2
1248 //it is assumed that both WPs are supported
1249 return (std::find(list.begin(),list.end(),wp1) > std::find(list.begin(), list.end(),wp2));
1250}

◆ configFromFile() [1/4]

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

Definition at line 1284 of file SUSYObjDef_xAOD.cxx.

1286{
1287 if(m_bool_prop_set.find(m_conf_to_prop[propname])!=m_bool_prop_set.end()){
1288 ATH_MSG_INFO( "configFromFile(): property \"" << propname << "\" already set with value " << property << ". Ignoring change request." );
1289 rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(propname.c_str() ) );
1290 return;
1291 }
1292 property = rEnv.GetValue(propname.c_str(), static_cast<int>(defaultValue));
1293 ATH_MSG_INFO( "configFromFile(): Loaded property \"" << propname << "\" with value " << property );
1294 // Remove the item from the table
1295 rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(propname.c_str() ) );
1296}
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_bool_prop_set
std::set< std::string > m_bool_prop_set
Definition SUSYObjDef_xAOD.h:439

◆ configFromFile() [2/4]

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

Definition at line 1299 of file SUSYObjDef_xAOD.cxx.

1301{
1302 // ignore if already configured
1303 if (property > -90.) {
1304 ATH_MSG_INFO( "configFromFile(): property \"" << propname << "\" already set with value " << property << ". Ignoring change request." );
1305 rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(propname.c_str() ) );
1306 return;
1307 }
1308 property = rEnv.GetValue(propname.c_str(), defaultValue);
1309 ATH_MSG_INFO( "configFromFile(): Loaded property \"" << propname << "\" with value " << property );
1310 // Remove the item from the table
1311 rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(propname.c_str() ) );
1312}

◆ configFromFile() [3/4]

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

Definition at line 1315 of file SUSYObjDef_xAOD.cxx.

1317{
1318 // ignore if already configured
1319 if (property > -90){
1320 ATH_MSG_INFO( "configFromFile(): property \"" << propname << "\" already set with value " << property << ". Ignoring change request." );
1321 rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(propname.c_str() ) );
1322 return;
1323 }
1324 property = rEnv.GetValue(propname.c_str(), defaultValue);
1325 ATH_MSG_INFO( "configFromFile(): Loaded property \"" << propname << "\" with value " << property );
1326 // Remove the item from the table
1327 rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(propname.c_str() ) );
1328}

◆ 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 1331 of file SUSYObjDef_xAOD.cxx.

1333{
1334 // ignore if already configured
1335 if (!property.empty()){
1336 ATH_MSG_INFO( "configFromFile(): property \"" << propname << "\" already set with value " << property << ". Ignoring change request." );
1337 rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(propname.c_str() ) );
1338 return;
1339 }
1340 property = rEnv.GetValue(propname.c_str(), defaultValue.c_str());
1341 if (property.empty() && !allowEmpty) {
1342 ATH_MSG_FATAL("Read empty string property from text file (property name: " << propname << ")");
1343 }
1344
1345 // post-processing to get rid of leading/trailing spaces and comments
1346 std::string tmp_prop = property.substr(0, property.find('#', 0));
1347 property = TString(tmp_prop).ReplaceAll(" ","").Data();
1348
1349 // Interpret None as an empty string
1350 if (property=="None" || property=="NONE" || property=="none") {
1351 ATH_MSG_VERBOSE( "Property \"" << propname << "\" being set to empty string due to specification of \"" << property << "\"" );
1352 property = "";
1353 }
1354
1355 ATH_MSG_INFO( "configFromFile(): Loaded property \"" << propname << "\" with value " << property );
1356 // Remove the item from the table
1357 rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(propname.c_str() ) );
1358}
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x,...)
Definition AthMsgStreamMacros.h:48

◆ currentSystematic()

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

Definition at line 2177 of file SUSYObjDef_xAOD.cxx.

2177 {
2178 return m_currentSyst;
2179}

◆ currentSystematicIsNominal()

bool ST::SUSYObjDef_xAOD::currentSystematicIsNominal ( ) const

Definition at line 2205 of file SUSYObjDef_xAOD.cxx.

2205 {
2206 return isNominal(m_currentSyst);
2207}
ST::SUSYObjDef_xAOD::isNominal
bool isNominal(const CP::SystematicSet &syst) const
Definition SUSYObjDef_xAOD.cxx:2181

◆ currentSystematicIsVariation()

bool ST::SUSYObjDef_xAOD::currentSystematicIsVariation ( ) const

Definition at line 2209 of file SUSYObjDef_xAOD.cxx.

2209 {
2210 return isVariation(m_currentSyst);
2211}
ST::SUSYObjDef_xAOD::isVariation
bool isVariation(const CP::SystematicSet &syst) const
Definition SUSYObjDef_xAOD.cxx:2196

◆ currentSystematicIsWeight()

bool ST::SUSYObjDef_xAOD::currentSystematicIsWeight ( ) const

Definition at line 2213 of file SUSYObjDef_xAOD.cxx.

2213 {
2214 return isWeight(m_currentSyst);
2215}
ST::SUSYObjDef_xAOD::isWeight
bool isWeight(const CP::SystematicSet &systSet) const
Definition SUSYObjDef_xAOD.cxx:2185

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & 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 }

◆ declareProperty()

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

Definition at line 145 of file AthCommonDataStore.h.

145 {
146 typedef typename SG::HandleClassifier<T>::type htype;
147 return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148 }
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition AthCommonDataStore.h:156

◆ 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 1253 of file SUSYObjDef_xAOD.cxx.

1253 {
1254 //translate our electron wps to EGamma internal jargon
1255 //@ElectronPhotonSelectorTools/EGSelectorConfigurationMapping.h
1256 TString copy = TString(wp).Copy().ReplaceAll("AndBLayer","BL").ReplaceAll("LLH","LHElectron");
1257 // the DNN WPs are labeled in the map as e.g. TightDNNnoCFElectron or TightDNNElectron
1258 if (wp.find("DNNnoCF") != std::string::npos)
1259 copy.ReplaceAll("DNNnoCF", "DNNnoCFElectron");
1260 else if (wp.find("DNN") != std::string::npos)
1261 copy.ReplaceAll("DNN", "DNNElectron");
1262 return copy.Data();
1263}
calibdata.copy
bool copy
Definition calibdata.py:26

◆ emulateHLT()

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

Definition at line 91 of file Trigger.cxx.

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

◆ 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 BookkeeperDumperTool, BookkeeperTool, TrigConf::xAODConfigTool, xAODMaker::TriggerMenuMetaDataTool, and xAODMaker::TruthMetaDataTool.

Definition at line 193 of file AsgMetadataTool.cxx.

193 {
194
195 // Return gracefully:
196 return StatusCode::SUCCESS;
197 }

◆ evtStore()

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; }

◆ 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 226 of file Electrons.cxx.

226 {
227
228 ATH_MSG_VERBOSE( "Starting FillElectron on el with pre-calibration pt=" << input.pt() );
229
230 // According to https://twiki.cern.ch/twiki/bin/view/AtlasProtected/EGammaIdentificationRun2#Electron_identification:
231 // "Please apply the identification to uncalibrated electron object. ID scale factors are to be applied to calibrated objects."
232 dec_baseline(input) = false;
233 dec_selected(input) = 0;
234 dec_signal(input) = false;
235 dec_isol(input) = false;
236 dec_isolHighPt(input) = false;
237 dec_passSignalID(input) = false;
238 dec_passChID(input) = false;
239 dec_ecisBDT(input) = -999.;
240
241 const xAOD::EventInfo* evtInfo = nullptr;
242 ATH_CHECK( evtStore()->retrieve( evtInfo, "EventInfo" ) );
243 const xAOD::Vertex* pv = this->GetPrimVtx();
244 const xAOD::TrackParticle* track = input.trackParticle();
245 if (!track) {
246 ATH_MSG_DEBUG("No primary track particle for this electron. Skipping.");
247 return StatusCode::SUCCESS;
248 }
249 double primvertex_z = pv ? pv->z() : 0;
250 double el_z0 = track->z0() + track->vz() - primvertex_z;
251 dec_z0sinTheta(input) = el_z0 * TMath::Sin(input.p4().Theta());
252 //protect against exception thrown for null or negative d0sig
253 try{
254 dec_d0sig(input) = xAOD::TrackingHelpers::d0significance( track , evtInfo->beamPosSigmaX(), evtInfo->beamPosSigmaY(), evtInfo->beamPosSigmaXY() );
255 }
256 catch(...){
257 float d0sigError = -99.;
258 ATH_MSG_WARNING("FillElectron : Exception catched from d0significance() calculation. Setting dummy decoration d0sig=" << d0sigError );
259 dec_d0sig(input) = d0sigError;
260 }
261
262 // don't bother calibrating or computing WP
263 if ( input.pt() < 4e3 ) return StatusCode::SUCCESS;
264 if ( !input.caloCluster() ) { ATH_MSG_WARNING( "FillElectron: no caloCluster found: " << input.caloCluster() ); return StatusCode::SUCCESS; }
265
266 //Check DeadHVCellRemoval
267 bool pass_deadHVTool = m_deadHVTool->accept(&input);
268
269 if (m_debug) {
270 unsigned char el_nPixHits(0), el_nSCTHits(0);
271 input.trackParticle()->summaryValue(el_nPixHits, xAOD::numberOfPixelHits);
272 input.trackParticle()->summaryValue(el_nSCTHits, xAOD::numberOfSCTHits);
273
274 ATH_MSG_INFO( "ELECTRON eta: " << input.eta());
275 ATH_MSG_INFO( "ELECTRON phi: " << input.phi());
276 ATH_MSG_INFO( "ELECTRON cl eta: " << input.caloCluster()->eta());
277 ATH_MSG_INFO( "ELECTRON cl phi: " << input.caloCluster()->phi());
278 ATH_MSG_INFO( "ELECTRON cl e: " << input.caloCluster()->e());
279 ATH_MSG_INFO( "ELECTRON trk eta: " << input.trackParticle()->eta());
280 ATH_MSG_INFO( "ELECTRON trk phi: " << input.trackParticle()->phi());
281 ATH_MSG_INFO( "ELECTRON author: " << input.author());
282 ATH_MSG_INFO( "ELECTRON OQ: " << acc_OQ(input));
283 ATH_MSG_INFO( "ELECTRON nPixHits: " << static_cast<int>(el_nPixHits));
284 ATH_MSG_INFO( "ELECTRON nSCTHits: " << static_cast<int>(el_nSCTHits));
285 ATH_MSG_INFO( "ELECTRON deadHVTools: " << static_cast<bool>(pass_deadHVTool));
286 }
287
288 if (!pass_deadHVTool) return StatusCode::SUCCESS;
289 if (!input.isGoodOQ(xAOD::EgammaParameters::BADCLUSELECTRON)) return StatusCode::SUCCESS;
290
291 if ( m_elecSelLikelihoodBaseline.empty()) {
292 ATH_MSG_ERROR("No baseline electron selector defined!");
293 return StatusCode::FAILURE;
294 }
295
296 bool passBaseID = false;
297 if (m_eleIdExpert) {
298 passBaseID = bool(m_elecSelLikelihoodBaseline->accept(&input));
299 } else {
300 if (m_acc_eleIdBaseline.isAvailable(input)) {
301 passBaseID = m_acc_eleIdBaseline(input);
302 } else {
303 ATH_MSG_VERBOSE ("DFCommonElectronsLHxxx variables are not found. Calculating the ID from LH tool..");
304 passBaseID = bool(m_elecSelLikelihoodBaseline->accept(&input));
305 }
306 }
307
308 if ( !passBaseID && !m_force_noElId ) return StatusCode::SUCCESS;
309
310 //baseline ID decoration for TauEl OR
311 //dec_passBaseID(input) = true;
312
313 // calibrate the electron 4-vector here only if within eta window
314 if (std::abs(input.caloCluster()->etaBE(2)) >= etacut) return StatusCode::SUCCESS;
315
316 if (m_eleBaselineCrackVeto){
317 if ( std::abs( input.caloCluster()->etaBE(2) ) >1.37 && std::abs( input.caloCluster()->etaBE(2) ) <1.52) {
318 return StatusCode::SUCCESS;
319 }
320 }
321
322 // corrections described in https://twiki.cern.ch/twiki/bin/view/AtlasProtected/EGammaCalibrationRun2
323 if ( m_egammaCalibTool->applyCorrection(input) != CP::CorrectionCode::Ok)
324 ATH_MSG_ERROR( "FillElectron: EgammaCalibTool applyCorrection failed ");
325
326 if (m_isoCorrTool->applyCorrection(input) != CP::CorrectionCode::Ok)
327 ATH_MSG_ERROR("FillElectron: IsolationCorrectionTool applyCorrection failed");
328
329 ATH_MSG_VERBOSE( "FillElectron: post-calibration pt=" << input.pt() );
330
331 if (input.pt() < etcut) return StatusCode::SUCCESS;
332
333 if (m_elebaselinez0>0. && std::abs(acc_z0sinTheta(input))>m_elebaselinez0) return StatusCode::SUCCESS;
334 if (m_elebaselined0sig>0. && std::abs(acc_d0sig(input))>m_elebaselined0sig) return StatusCode::SUCCESS;
335
336 //--- Do baseline isolation check
337 if ( !( m_eleBaselineIso_WP.empty() ) && !( m_isoBaselineTool->accept(input) ) ) return StatusCode::SUCCESS;
338
339 dec_baseline(input) = true;
340 dec_selected(input) = 2;
341 //disable if (!m_eleIso_WP.empty() && m_eleIso_WP.find("PLV")!=std::string::npos) ATH_CHECK( ->augmentPLV(input) );
342 if (!m_eleIso_WP.empty()) dec_isol(input) = bool(m_isoTool->accept(input));
343 if (!m_eleIsoHighPt_WP.empty()) dec_isolHighPt(input) = bool(m_isoHighPtTool->accept(input));
344
345 //ChargeIDSelector
346 if( m_runECIS ){
347 if (acc_passECIDS.isAvailable(input)) {
348 dec_passChID(input) = acc_passECIDS(input); // Loose 97% WP!
349 } else {
350 dec_passChID(input) = bool(m_elecChargeIDSelectorTool->accept(&input));
351 //disable double bdt = m_elecChargeIDSelectorTool->calculate(&input).getResult("bdt");
352 //disable dec_ecisBDT(input) = bdt;
353 }
354 }
355 else{
356 dec_passChID(input) = true;
357 }
358
359 ATH_MSG_VERBOSE( "FillElectron: passed baseline selection" );
360
361 return StatusCode::SUCCESS;
362}
CP::CorrectionCode::Ok
@ Ok
The correction was done successfully.
Definition CorrectionCode.h:38
ST::SUSYObjDef_xAOD::m_deadHVTool
asg::AnaToolHandle< IAsgDeadHVCellRemovalTool > m_deadHVTool
Definition SUSYObjDef_xAOD.h:919
ST::SUSYObjDef_xAOD::GetPrimVtx
const xAOD::Vertex * GetPrimVtx() const override final
Definition SUSYObjDef_xAOD.cxx:2996
xAOD::EventInfo_v1::beamPosSigmaY
float beamPosSigmaY() const
The width of the beam spot in the Y direction.
xAOD::EventInfo_v1::beamPosSigmaXY
float beamPosSigmaXY() const
The beam spot shape's X-Y correlation.
xAOD::EventInfo_v1::beamPosSigmaX
float beamPosSigmaX() const
The width of the beam spot in the X direction.
ST::acc_d0sig
static const SG::ConstAccessor< float > acc_d0sig("d0sig")
ST::dec_passSignalID
static const SG::Decorator< char > dec_passSignalID("passSignalID")
ST::dec_baseline
static const SG::Decorator< char > dec_baseline("baseline")
ST::dec_isolHighPt
static const SG::Decorator< char > dec_isolHighPt("isolHighPt")
ST::acc_z0sinTheta
static const SG::ConstAccessor< float > acc_z0sinTheta("z0sinTheta")
ST::acc_passECIDS
static const SG::ConstAccessor< char > acc_passECIDS("DFCommonElectronsECIDS")
ST::acc_OQ
static const SG::ConstAccessor< unsigned int > acc_OQ("OQ")
ST::dec_passChID
static const SG::Decorator< char > dec_passChID("passChID")
ST::dec_z0sinTheta
static const SG::Decorator< float > dec_z0sinTheta("z0sinTheta")
ST::dec_ecisBDT
static const SG::Decorator< double > dec_ecisBDT("ecisBDT")
ST::dec_isol
static const SG::Decorator< char > dec_isol("isol")
ST::dec_signal
static const SG::Decorator< char > dec_signal("signal")
ST::dec_d0sig
static const SG::Decorator< float > dec_d0sig("d0sig")
ST::dec_selected
static const SG::Decorator< char > dec_selected("selected")
xAOD::EgammaParameters::BADCLUSELECTRON
const uint32_t BADCLUSELECTRON
Definition EgammaDefs.h:116
xAOD::TrackingHelpers::d0significance
double d0significance(const xAOD::TrackParticle *tp, double d0_uncert_beam_spot_2)
Definition TrackParticlexAODHelpers.cxx:42
xAOD::TrackParticle
TrackParticle_v1 TrackParticle
Reference the current persistent version:
Definition Event/xAOD/xAODTracking/xAODTracking/TrackParticle.h:13
xAOD::Vertex
Vertex_v1 Vertex
Define the latest version of the vertex class.
Definition Event/xAOD/xAODTracking/xAODTracking/Vertex.h:16
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition TrackingPrimitives.h:264
xAOD::numberOfPixelHits
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
Definition TrackingPrimitives.h:255

◆ 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 403 of file Jets.cxx.

403 {
404
405 ATH_MSG_VERBOSE( "Starting FillJet on jet with pt=" << input.pt() );
406 ATH_MSG_VERBOSE( "jet (pt,eta,phi) before calibration " << input.pt() << " " << input.eta() << " " << input.phi() );
407
408 static const SG::ConstAccessor<char> acc_wValidKinRange(m_WDecorName+"_ValidKinRange");
409 static const SG::ConstAccessor<char> acc_zValidKinRange(m_ZDecorName+"_ValidKinRange");
410 static const SG::ConstAccessor<char> acc_topValidKinRange(m_TopDecorName+"_ValidKinRange");
411 static const SG::ConstAccessor<char> acc_wtagged(m_WDecorName+"_Tagged");
412 static const SG::ConstAccessor<char> acc_ztagged(m_ZDecorName+"_Tagged");
413 static const SG::ConstAccessor<char> acc_toptagged(m_TopDecorName+"_Tagged");
414
415 if (doCalib) {
416 if(!isFat){
417 //disable - obsoleted ATH_CHECK( m_jetCalibTool->applyCalibration(input) );
418 }
419 else {
420 //disable - obsoleted ATH_CHECK( m_jetFatCalibTool->applyCalibration(input) );
421 dec_baseline(input) = ( input.pt() > m_jetPt ) || ( input.pt() > 20e3 ); // Allows for setting m_jetPt < 20e3
422 dec_bad(input) = false;
423 dec_signal(input) = false;
424 dec_bjet_loose(input) = false;
425 dec_effscalefact(input) = 1.;
426 dec_passOR(input) = true;
427 dec_bjet_jetunc(input) = false;
428 dec_btag_weight(input) = -999.;
429
430 dec_wtagged(input) = -1;
431 dec_ztagged(input) = -1;
432 dec_toptagged(input) = -1;
433 if (doLargeRdecorations) {
434
435 // Retrieve large-R tagging results for W/Z/top
436 if (!m_WtagConfig.empty()) {
437 // Only tag jets if they are inside the kinematic range
438 if ( !acc_wValidKinRange(input) ) {
439 ATH_MSG_VERBOSE("Large-R W candidate jet outside of recommended tagging range. Will set score to 0.");
440 dec_wtagged(input) = 0;
441 }
442 else dec_wtagged(input) = acc_wtagged(input);
443 }
444 if (!m_ZtagConfig.empty()) {
445 // Only tag jets if they are inside the kinematic range
446 if ( !acc_zValidKinRange(input) ) {
447 ATH_MSG_VERBOSE("Large-R Z candidate jet outside of recommended tagging range. Will set score to 0.");
448 dec_ztagged(input) = 0;
449 }
450 else dec_ztagged(input) = acc_ztagged(input);
451 }
452 if (!m_ToptagConfig.empty()) {
453 ATH_CHECK(m_TopTaggerTool->tag(input));
454 // Only tag jets if they are inside the kinematic range
455 if ( !acc_topValidKinRange(input) ) {
456 ATH_MSG_VERBOSE("Large-R Top candidate jet outside of recommended tagging range. Will set score to 0.");
457 dec_toptagged(input) = 0;
458 }
459 else dec_toptagged(input) = acc_toptagged(input);
460 }
461
462 }
463
464 // If a user hasn't specified an uncertainty config, then this tool will be empty
465 // for large R jets
466 if (!m_WTagjetUncertaintiesTool.empty() && !m_WTagUncConfig.empty() && !m_WtagConfig.empty() && doLargeRdecorations) {
467 CP::CorrectionCode result = m_WTagjetUncertaintiesTool->applyCorrection(input);
468 switch (result) {
469 case CP::CorrectionCode::Error:
470 ATH_MSG_ERROR( "Failed to apply largeR W-tag jet scale uncertainties.");
471 return StatusCode::FAILURE;
472 //break;
473 case CP::CorrectionCode::OutOfValidityRange:
474 ATH_MSG_VERBOSE( "No valid pt/eta/m range for largeR W-tag jet scale uncertainties. ");
475 break;
476 default:
477 break;
478 }
479 } else {
480 ATH_MSG_DEBUG( "No valid large-R W-tagged fat jet uncertainty, but FillJet called with a fat jet. Skipping uncertainties." );
481 }
482
483 if (!m_ZTagjetUncertaintiesTool.empty() && !m_ZTagUncConfig.empty() && !m_ZtagConfig.empty() && doLargeRdecorations) {
484 CP::CorrectionCode result = m_ZTagjetUncertaintiesTool->applyCorrection(input);
485 switch (result) {
486 case CP::CorrectionCode::Error:
487 ATH_MSG_ERROR( "Failed to apply largeR Z-tag jet scale uncertainties.");
488 return StatusCode::FAILURE;
489 //break;
490 case CP::CorrectionCode::OutOfValidityRange:
491 ATH_MSG_VERBOSE( "No valid pt/eta/m range for largeR Z-tag jet scale uncertainties. ");
492 break;
493 default:
494 break;
495 }
496 } else {
497 ATH_MSG_DEBUG( "No valid large-R Z-tagged fat jet uncertainty, but FillJet called with a fat jet. Skipping uncertainties." );
498 }
499
500 if (!m_TopTagjetUncertaintiesTool.empty() && !m_TopTagUncConfig.empty() && !m_ToptagConfig.empty() && doLargeRdecorations) {
501 CP::CorrectionCode result = m_TopTagjetUncertaintiesTool->applyCorrection(input);
502 switch (result) {
503 case CP::CorrectionCode::Error:
504 ATH_MSG_ERROR( "Failed to apply largeR Top-tag jet scale uncertainties.");
505 return StatusCode::FAILURE;
506 //break;
507 case CP::CorrectionCode::OutOfValidityRange:
508 ATH_MSG_VERBOSE( "No valid pt/eta/m range for largeR Top-tag jet scale uncertainties. ");
509 break;
510 default:
511 break;
512 }
513 } else {
514 ATH_MSG_DEBUG( "No valid large-R Top-tagged fat jet uncertainty, but FillJet called with a fat jet. Skipping uncertainties." );
515 }
516
517 if (!m_fatjetUncertaintiesTool.empty() && m_currentSyst.name().find("PseudoData") == std::string::npos) {
518 CP::CorrectionCode result = m_fatjetUncertaintiesTool->applyCorrection(input);
519 switch (result) {
520 case CP::CorrectionCode::Error:
521 ATH_MSG_ERROR( "Failed to apply largeR jet scale uncertainties.");
522 return StatusCode::FAILURE;
523 //break;
524 case CP::CorrectionCode::OutOfValidityRange:
525 ATH_MSG_VERBOSE( "No valid pt/eta/m range for largeR jet scale uncertainties. ");
526 break;
527 default:
528 break;
529 }
530 } else {
531 ATH_MSG_DEBUG( "No valid fat jet uncertainty, but FillJet called with a fat jet. Skipping uncertainties." );
532 }
533
534 // Use the PDSmeared uncertainties tool on the systematic with PseudoData in the name
535 if (!m_fatjetUncertaintiesPDSmearTool.empty() && m_fatJetUncertaintiesPDsmearing && m_currentSyst.name().find("PseudoData")) {
536 CP::CorrectionCode result = m_fatjetUncertaintiesPDSmearTool->applyCorrection(input);
537 switch (result) {
538 case CP::CorrectionCode::Error:
539 ATH_MSG_ERROR( "Failed to apply largeR jet scale PD uncertainties.");
540 return StatusCode::FAILURE;
541 //break;
542 case CP::CorrectionCode::OutOfValidityRange:
543 ATH_MSG_VERBOSE( "No valid pt/eta/m range for largeR jet scale uncertainties. ");
544 break;
545 default:
546 break;
547 }
548 } else {
549 ATH_MSG_DEBUG( "No valid fat jet uncertainty, but FillJet called with a fat jet. Skipping uncertainties." );
550 }
551
552 if (!m_fatjetFFSmearingTool.empty() && std::find(m_fatjetFFSmearingSyst.begin(), m_fatjetFFSmearingSyst.end(), m_currentSyst) != m_fatjetFFSmearingSyst.end()) {
553 CP::CorrectionCode result = m_fatjetFFSmearingTool->applyCorrection(input);
554 switch (result) {
555 case CP::CorrectionCode::Error:
556 ATH_MSG_ERROR( "Failed to apply largeR jet scale uncertainties.");
557 return StatusCode::FAILURE;
558 //break;
559 case CP::CorrectionCode::OutOfValidityRange:
560 ATH_MSG_VERBOSE( "No valid pt/eta/m range for largeR jet scale uncertainties. ");
561 break;
562 default:
563 break;
564 }
565 } else {
566 ATH_MSG_DEBUG( "No valid fat jet uncertainty, but FillJet called with a fat jet. Skipping uncertainties." );
567 }
568
569 ATH_MSG_VERBOSE( "Large-R jet (pt,eta,phi) after calibration " << input.pt() << " " << input.eta() << " " << input.phi() );
570
571 return StatusCode::SUCCESS;
572 }
573 ATH_MSG_VERBOSE( "jet (pt,eta,phi) after calibration " << input.pt() << " " << input.eta() << " " << input.phi() );
574
575 }
576
577 dec_passOR(input) = true;
578 dec_bjet_jetunc(input) = false;
579
580 if (m_useBtagging) {
581 if (m_BtagWP != "Continuous") this->IsBJet(input);
582 else this->IsBJetContinuous(input);
583 }
584
585 if ( (input.pt() > m_jetPt) || (input.pt() > 15e3) ) {
586 if(!isFat && m_currentSyst.name().find("PseudoData") == std::string::npos) {
587 // Use the normal jet uncertainties tool for this systematic and do not use the PDSmeared initialised tool
588 CP::CorrectionCode result = m_jetUncertaintiesTool->applyCorrection(input);
589 switch (result) {
590 case CP::CorrectionCode::Error:
591 ATH_MSG_ERROR( "Failed to apply JES correction" );
592 break;
593 case CP::CorrectionCode::OutOfValidityRange:
594 ATH_MSG_WARNING( "JES correction OutOfValidity range."); // Jet (pt,eta,phi) = (" << input.pt() << ", " << input.eta() << ", " << input.phi() << ")");
595 break;
596 default:
597 break;
598 }
599 }
600 }
601
602 if (m_jetUncertaintiesPDsmearing) {
603 if ( (input.pt() > m_jetPt) || (input.pt() > 15e3) ) {
604 if(!isFat && m_currentSyst.name().find("PseudoData")){
605 // Use the PDSmeared uncertainties tool on the systematic with PseudoData in the name
606 CP::CorrectionCode result = m_jetUncertaintiesPDSmearTool->applyCorrection(input);
607 switch (result) {
608 case CP::CorrectionCode::Error:
609 ATH_MSG_ERROR( "Failed to apply JES correction" );
610 break;
611 case CP::CorrectionCode::OutOfValidityRange:
612 ATH_MSG_WARNING( "JES correction OutOfValidity range."); // Jet (pt,eta,phi) = (" << input.pt() << ", " << input.eta() << ", " << input.phi() << ")");
613 break;
614 default:
615 break;
616 }
617 }
618 }
619 }
620
621
622 ATH_MSG_VERBOSE( "jet (pt,eta,phi) after JES correction " << input.pt() << " " << input.eta() << " " << input.phi() );
623
624 dec_passJvt(input) = !m_applyJVTCut || m_jetNNJvtSelectionTool->accept(&input);
625 dec_passFJvt(input) = !m_doFwdJVT || m_jetfJvtSelectionTool->accept(&input);
626 dec_baseline(input) = ( input.pt() > m_jetPt ) || ( input.pt() > 20e3 ); // Allows for setting m_jetPt < 20e3
627 dec_bad(input) = false;
628 dec_signal_less_JVT(input) = false;
629 dec_signal(input) = false;
630 dec_bjet_loose(input) = false;
631 dec_effscalefact(input) = 1.;
632
633 //new state for OR . 0=non-baseline objects, 1=for baseline jets not passing JVT, 2=for any other baseline object
634 if (acc_baseline(input) ){
635 if( acc_passJvt(input) ) dec_selected(input) = 2;
636 else dec_selected(input) = 1;
637 }
638 else{
639 dec_selected(input) = 0;
640 }
641
642 if (m_useBtagging && !m_orBtagWP.empty()) {
643 dec_bjet_loose(input) = this->IsBJetLoose(input);
644 }
645
646 if (m_debug) {
647 ATH_MSG_INFO( "JET pt: " << input.pt() );
648 ATH_MSG_INFO( "JET eta: " << input.eta() );
649 ATH_MSG_INFO( "JET phi: " << input.phi() );
650 ATH_MSG_INFO( "JET E: " << input.e() );
651 ATH_MSG_INFO( "JET Ceta: " << input.jetP4(xAOD::JetConstitScaleMomentum).eta() );
652 ATH_MSG_INFO( "JET Cphi: " << input.jetP4(xAOD::JetConstitScaleMomentum).phi() );
653 ATH_MSG_INFO( "JET CE: " << input.jetP4(xAOD::JetConstitScaleMomentum).e() );
654 ATH_MSG_INFO( "JET Cm: " << input.jetP4(xAOD::JetConstitScaleMomentum).M() ); // fix-me M
655
656 }
657
658 return StatusCode::SUCCESS;
659 }
ST::SUSYObjDef_xAOD::IsBJetLoose
bool IsBJetLoose(const xAOD::Jet &input) const override final
Definition Jets.cxx:698
ST::SUSYObjDef_xAOD::m_fatJetUncertaintiesPDsmearing
bool m_fatJetUncertaintiesPDsmearing
Definition SUSYObjDef_xAOD.h:547
ST::SUSYObjDef_xAOD::m_jetUncertaintiesPDsmearing
bool m_jetUncertaintiesPDsmearing
Definition SUSYObjDef_xAOD.h:536
ST::SUSYObjDef_xAOD::IsBJetContinuous
int IsBJetContinuous(const xAOD::Jet &input) const override final
Definition Jets.cxx:811
ST::SUSYObjDef_xAOD::IsBJet
bool IsBJet(const xAOD::Jet &input) const override final
Definition Jets.cxx:789
ST::dec_passOR
static const SG::Decorator< char > dec_passOR("passOR")
ST::dec_passFJvt
static const SG::Decorator< char > dec_passFJvt("passFJvt")
ST::acc_ztagged
static const SG::ConstAccessor< int > acc_ztagged("ztagged")
ST::dec_toptagged
static const SG::Decorator< int > dec_toptagged("toptagged")
ST::dec_signal_less_JVT
static const SG::Decorator< char > dec_signal_less_JVT("signal_less_JVT")
Decorator for signal jets without a JVT requirement.
ST::acc_passJvt
static const SG::ConstAccessor< char > acc_passJvt("passJvt")
ST::dec_passJvt
static const SG::Decorator< char > dec_passJvt("passJvt")
ST::dec_btag_weight
static const SG::Decorator< double > dec_btag_weight("btag_weight")
ST::acc_baseline
static const SG::ConstAccessor< char > acc_baseline("baseline")
ST::dec_bjet_jetunc
static const SG::Decorator< char > dec_bjet_jetunc("bjet_jetunc")
ST::dec_ztagged
static const SG::Decorator< int > dec_ztagged("ztagged")
ST::dec_wtagged
static const SG::Decorator< int > dec_wtagged("wtagged")
ST::dec_bad
static const SG::Decorator< char > dec_bad("bad")
ST::acc_wtagged
static const SG::ConstAccessor< int > acc_wtagged("wtagged")
ST::acc_toptagged
static const SG::ConstAccessor< int > acc_toptagged("toptagged")
ST::dec_bjet_loose
static const SG::Decorator< char > dec_bjet_loose("bjet_loose")
xAOD::JetConstitScaleMomentum
@ JetConstitScaleMomentum
Definition JetTypes.h:29

◆ FillMuon()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 212 of file Muons.cxx.

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

◆ FillPhoton()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 81 of file Photons.cxx.

81 {
82
83 ATH_MSG_VERBOSE( "Starting FillPhoton on ph with pre-calibration pt=" << input.pt() );
84
85 if ( !input.caloCluster() ) {
86 ATH_MSG_WARNING( "FillPhoton: no caloCluster found: " << input.caloCluster() );
87 return StatusCode::SUCCESS;
88 }
89
90 //Check DeadHVCellRemoval
91 bool pass_deadHVTool = m_deadHVTool->accept(&input);
92
93 if (m_debug) {
94 ATH_MSG_INFO( "PHOTON eta: " << input.eta() );
95 ATH_MSG_INFO( "PHOTON phi: " << input.phi() );
96 ATH_MSG_INFO( "PHOTON cl eta: " << input.caloCluster()->eta() );
97 ATH_MSG_INFO( "PHOTON cl phi: " << input.caloCluster()->phi() );
98 ATH_MSG_INFO( "PHOTON cl e: " << input.caloCluster()->e() );
99 ATH_MSG_INFO( "PHOTON OQ: " << input.OQ() );
100 ATH_MSG_INFO( "PHOTON author: " << input.author() );
101 ATH_MSG_INFO( "PHOTON deadHVTools: " << pass_deadHVTool );
102 }
103
104 dec_baseline(input) = false;
105 dec_selected(input) = 0;
106 dec_isol(input) = false;
107 dec_isEM(input) = 0;
108
109 if (!pass_deadHVTool) return StatusCode::SUCCESS;
110
111 // Author cuts needed according to https://twiki.cern.ch/twiki/bin/view/AtlasProtected/EGammaIdentificationRun2#Photon_authors
112 if ( !(input.author() & (xAOD::EgammaParameters::AuthorPhoton + xAOD::EgammaParameters::AuthorAmbiguous)) )
113 return StatusCode::SUCCESS;
114
115 // calibrate the photon 4-vector here only if within eta window
116 if (std::abs(input.caloCluster()->etaBE(2)) >= etacut) return StatusCode::SUCCESS;
117
118 if (m_photonBaselineCrackVeto){
119 if ( std::abs( input.caloCluster()->etaBE(2) ) >1.37 && std::abs( input.caloCluster()->etaBE(2) ) <1.52) {
120 return StatusCode::SUCCESS;
121 }
122 }
123
124 if (m_egammaCalibTool->applyCorrection(input) != CP::CorrectionCode::Ok)
125 ATH_MSG_ERROR("FillPhoton: EgammaCalibTool applyCorrection failed");
126
127 if (m_isoCorrTool->applyCorrection(input) != CP::CorrectionCode::Ok)
128 ATH_MSG_ERROR("FillPhoton: IsolationCorrectionTool applyCorrection failed");
129
130 ATH_MSG_VERBOSE( "FillPhoton: post-calibration pt=" << input.pt() );
131
132 if (input.pt() < ptcut) return StatusCode::SUCCESS;
133
134 //Object quality cut as described at https://twiki.cern.ch/twiki/bin/view/AtlasProtected/EGammaIdentificationRun2#Object_quality_cut
135 if (!input.isGoodOQ(xAOD::EgammaParameters::BADCLUSPHOTON))
136 return StatusCode::SUCCESS;
137
138 //Photon quality as in https://twiki.cern.ch/twiki/bin/view/AtlasProtected/EGammaIdentificationRun2#Photon_cleaning
139 bool passPhCleaning = false;
140 if (acc_passPhCleaning.isAvailable(input) && acc_passPhCleaningNoTime.isAvailable(input)) {
141 if ( (!m_photonAllowLate && acc_passPhCleaning(input)) || (m_photonAllowLate && acc_passPhCleaningNoTime(input)) ) passPhCleaning = true;
142 } else {
143 ATH_MSG_VERBOSE ("DFCommonPhotonsCleaning is not found in DAOD..");
144 if ( (!m_photonAllowLate && PhotonHelpers::passOQquality(input)) ||
145 ( m_photonAllowLate && PhotonHelpers::passOQqualityDelayed(input)) ) passPhCleaning = true;
146 }
147 if (!passPhCleaning) return StatusCode::SUCCESS;
148
149
150 bool passBaseID = false;
151 if (m_acc_photonIdBaseline.isAvailable(input)) {
152 passBaseID = bool(m_acc_photonIdBaseline(input));
153 } else {
154 passBaseID = bool(m_photonSelIsEMBaseline->accept(&input));
155 }
156 if (!passBaseID) return StatusCode::SUCCESS;
157
158 //--- Do baseline isolation check
159 if ( !( m_photonBaselineIso_WP.empty() ) && !( m_isoBaselineTool->accept(input) ) ) return StatusCode::SUCCESS;
160
161 dec_baseline(input) = true;
162 dec_selected(input) = 2;
163 if (!m_photonIso_WP.empty()) dec_isol(input) = bool(m_isoTool->accept(input));
164
165 ATH_MSG_VERBOSE("FillPhoton: passed baseline selection.");
166 return StatusCode::SUCCESS;
167}
PhotonHelpers::passOQqualityDelayed
bool passOQqualityDelayed(const xAOD::Photon &ph)
Helpers to ease the implementation of the pass Quality requirements.
Definition PhotonHelpers.cxx:29
PhotonHelpers::passOQquality
bool passOQquality(const xAOD::Photon &ph)
Helper to ease the implemmantation of the pass Quality requirements.
Definition PhotonHelpers.cxx:12
ST::acc_passPhCleaning
static const SG::ConstAccessor< char > acc_passPhCleaning("DFCommonPhotonsCleaning")
ST::dec_isEM
static const SG::Decorator< unsigned > dec_isEM("isEM")
ST::acc_passPhCleaningNoTime
static const SG::ConstAccessor< char > acc_passPhCleaningNoTime("DFCommonPhotonsCleaningNoTime")
xAOD::EgammaParameters::AuthorPhoton
const uint16_t AuthorPhoton
Object Reconstructed by standard cluster-based algorithm.
Definition EgammaDefs.h:28
xAOD::EgammaParameters::BADCLUSPHOTON
const uint32_t BADCLUSPHOTON
Definition EgammaDefs.h:124
xAOD::EgammaParameters::AuthorAmbiguous
const uint16_t AuthorAmbiguous
Object Reconstructed by standard cluster-based algorithm.
Definition EgammaDefs.h:32

◆ FillTau()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 80 of file Taus.cxx.

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

◆ FillTrackJet()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 661 of file Jets.cxx.

661 {
662
663 ATH_MSG_VERBOSE( "Starting FillTrackJet on jet with pt=" << input.pt() );
664
665 dec_btag_weight(input) = -999.;
666 dec_effscalefact(input) = 1.;
667
668 if (m_defaultTrackJets == "AntiKtVR30Rmax4Rmin02TrackJets") {
669 // VR recommendation
670 // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/BTagCalib2017#Recommendations_for_variable_rad
671 dec_baseline(input) = input.pt() >= 5e3 && input.numConstituents() >= 2;
672 if (m_trkJetPt < 10e3)
673 ATH_MSG_WARNING ("The pt threshold of VR jets you set is: " << m_trkJetPt/1000. << " GeV. But VR jets with pt < 10GeV are uncalibrated.");
674 dec_signal(input) = acc_baseline(input) && input.pt() >= m_trkJetPt && std::abs(input.eta()) <= m_trkJetEta;
675 dec_VRradius(input) = std::max(0.02,std::min(0.4,30000./input.pt()));
676 dec_passDRcut(input) = acc_signal(input);
677 } else {
678 dec_baseline(input) = input.pt() >= m_trkJetPt && std::abs(input.eta()) <= m_trkJetEta;
679 dec_signal(input) = acc_baseline(input);
680 }
681
682 if (m_useBtagging_trkJet) {
683 if (m_BtagWP_trkJet != "Continuous") this->IsTrackBJet(input);
684 else this->IsTrackBJetContinuous(input);
685 }
686
687 if (m_debug) {
688 ATH_MSG_INFO( "TRK JET pt: " << input.pt() );
689 ATH_MSG_INFO( "TRK JET eta: " << input.eta() );
690 ATH_MSG_INFO( "TRK JET phi: " << input.phi() );
691 ATH_MSG_INFO( "TRK JET E: " << input.e() );
692 }
693
694 return StatusCode::SUCCESS;
695 }
ST::SUSYObjDef_xAOD::m_defaultTrackJets
std::string m_defaultTrackJets
Definition SUSYObjDef_xAOD.h:828
ST::SUSYObjDef_xAOD::IsTrackBJet
bool IsTrackBJet(const xAOD::Jet &input) const override final
Definition Jets.cxx:800
ST::SUSYObjDef_xAOD::IsTrackBJetContinuous
int IsTrackBJetContinuous(const xAOD::Jet &input) const override final
Definition Jets.cxx:833
ST::dec_VRradius
static const SG::Decorator< float > dec_VRradius("VRradius")
ST::dec_passDRcut
static const SG::Decorator< char > dec_passDRcut("passDRcut")

◆ FindSusyHardProc() [1/2]

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

Definition at line 227 of file Truth.cxx.

227 {
228
229 pdgid1 = 0;
230 pdgid2 = 0;
231
232 //go for TRUTH1-like ...
233 const xAOD::TruthParticle* firstsp(nullptr);
234 const xAOD::TruthParticle* secondsp(nullptr);
235
236 for (unsigned int p=0; p < truthE->nTruthParticles(); ++p){
237
238 const xAOD::TruthParticle* tp = truthE->truthParticle(p);
239
240 //check ifSUSY particle
241 if (MC::isSquark(tp) || MC::isSlepton(tp) || MC::isGaugino(tp)) {
242
243 if (tp->nParents() != 0) {
244 if ( !MC::isSUSY(tp->parent(0))) {
245 if (!firstsp) {
246 firstsp = tp;
247 } else if (!secondsp) {
248 secondsp = tp;
249 } else {
250 if (firstsp->nChildren() != 0 && HepMC::is_same_particle(tp,firstsp->child(0))) {
251 firstsp = tp;
252 }
253 else if (secondsp->nChildren() != 0 && HepMC::is_same_particle(tp,secondsp->child(0))) {
254 secondsp = tp;
255 }
256 else if (firstsp->nChildren() != 0 && HepMC::is_same_particle(firstsp->child(0),secondsp)) {
257 firstsp = secondsp;
258 secondsp = tp;
259 }
260 else if (secondsp->nChildren() != 0 && HepMC::is_same_particle(secondsp->child(0),firstsp)) {
261 secondsp = firstsp;
262 firstsp = tp;
263 }
264 }
265 }
266 }
267 }
268 }
269
270 // quit if no sparticles found
271 if (!firstsp && !secondsp) return true; // should find none or two
272
273 if (firstsp->nChildren() == 1) {
274 for (unsigned int p=0; p < truthE->nTruthParticles(); ++p){
275 const xAOD::TruthParticle* tp = truthE->truthParticle(p);
276 if (HepMC::is_same_particle(tp,firstsp->child(0)) && tp->pdgId() != firstsp->pdgId()) {
277 firstsp = tp;
278 break;
279 }
280 }
281 }
282
283 if (secondsp->nChildren() == 1) {
284 for (unsigned int p=0; p < truthE->nTruthParticles(); ++p){
285 const xAOD::TruthParticle* tp = truthE->truthParticle(p);
286 if (HepMC::is_same_particle(tp,secondsp->child(0)) && tp->pdgId() != secondsp->pdgId()) {
287 secondsp = tp;
288 break;
289 }
290 }
291 }
292
293 if (MC::isSUSY(firstsp)) pdgid1 = firstsp->pdgId();
294 if (MC::isSUSY(secondsp)) pdgid2 = secondsp->pdgId();
295
296 // Return gracefully:
297 return true;
298}
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
xAOD::TruthEventBase_v1::nTruthParticles
size_t nTruthParticles() const
Get the number of truth particles.
xAOD::TruthParticle_v1::pdgId
int pdgId() const
PDG ID code.
xAOD::TruthParticle_v1::parent
const TruthParticle_v1 * parent(size_t i) const
Retrieve the i-th mother (TruthParticle) of this TruthParticle.
Definition TruthParticle_v1.cxx:126
xAOD::TruthParticle_v1::nParents
size_t nParents() const
Number of parents of this particle.
Definition TruthParticle_v1.cxx:117
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:334
MC::isSlepton
bool isSlepton(const T &p)
Definition HepMCHelpers.h:489
MC::isSquark
bool isSquark(const T &p)
PDG rule 11d Fundamental supersymmetric particles are identified by adding a nonzero n to the particl...
Definition HepMCHelpers.h:465
MC::isSUSY
bool isSUSY(const T &p)
Definition HepMCHelpers.h:630
MC::isGaugino
bool isGaugino(const T &p)
Definition HepMCHelpers.h:511
xAOD::TruthParticle
TruthParticle_v1 TruthParticle
Typedef to implementation.
Definition Event/xAOD/xAODTruth/xAODTruth/TruthParticle.h:15

◆ FindSusyHardProc() [2/2]

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

Definition at line 126 of file Truth.cxx.

126 {
127
128 pdgid1 = 0;
129 pdgid2 = 0;
130
131 //check for TRUTH3 structure first
132 if(isTruth3){
133 if(!truthP || truthP->size()<2){
134 return false;
135 }
136
137 //get ID of first two BSM particles
138 pdgid1 = (*truthP)[0]->pdgId();
139 pdgid2 = (*truthP)[1]->pdgId();
140 return true;
141 }
142
143 //go for TRUTH1-like if not...
144 const xAOD::TruthParticle* firstsp(nullptr);
145 const xAOD::TruthParticle* secondsp(nullptr);
146
147 if (!truthP || truthP->empty()) {
148 return false;
149 }
150 for (const xAOD::TruthParticle* tp : *truthP) {
151 if (MC::isSquark(tp) || MC::isSlepton(tp) || MC::isGaugino(tp)) {
152
153 if (tp->nParents() != 0) {
154
155 if ( !MC::isSUSY(tp->parent(0))) {
156 if (!firstsp) {
157 firstsp = tp;
158 } else if (!secondsp) {
159 secondsp = tp;
160 } else {
161 if (firstsp->nChildren() != 0 && HepMC::is_same_particle(tp,firstsp->child(0))) {
162 firstsp = tp;
163 }
164 else if (secondsp->nChildren() != 0 && HepMC::is_same_particle(tp,secondsp->child(0))) {
165 secondsp = tp;
166 }
167 else if (firstsp->nChildren() != 0 && HepMC::is_same_particle(firstsp->child(0),secondsp)) {
168 firstsp = secondsp;
169 secondsp = tp;
170 }
171 else if (secondsp->nChildren() != 0 && HepMC::is_same_particle(secondsp->child(0),firstsp)) {
172 secondsp = firstsp;
173 firstsp = tp;
174 }
175 }
176 }
177 }
178 }
179 }
180
181 // quit if no sparticles found
182 if (!firstsp && !secondsp) return true; // should find none or two
183
184 if (firstsp->nChildren() == 1) {
185 for (const xAOD::TruthParticle* tp : *truthP) {
186 if (HepMC::is_same_particle(tp,firstsp->child(0)) && tp->pdgId() != firstsp->pdgId()) {
187 firstsp = tp;
188 break;
189 }
190 }
191 }
192
193 if (secondsp->nChildren() == 1) {
194 for (const xAOD::TruthParticle* tp : *truthP) {
195 if (HepMC::is_same_particle(tp,secondsp->child(0)) && tp->pdgId() != secondsp->pdgId()) {
196 secondsp = tp;
197 break;
198 }
199 }
200 }
201
202 if (MC::isSUSY(firstsp)) pdgid1 = firstsp->pdgId();
203 if (MC::isSUSY(secondsp)) pdgid2 = secondsp->pdgId();
204
205 // Return gracefully:
206 return true;
207}
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.

◆ 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 210 of file Truth.cxx.

210 {
211
212 if (!truthE) {
213 ATH_MSG_ERROR("Null TruthEvent pointer!!");
214 return StatusCode::FAILURE;
215 }
216 if ( !SUSYObjDef_xAOD::FindSusyHardProc(truthE, pdgid1, pdgid2) ) {
217 ATH_MSG_ERROR("Problem finding SUSY hard process");
218 return StatusCode::FAILURE;
219 }
220 if (pdgid1 == 0 || pdgid2 == 0) {
221 ATH_MSG_DEBUG("No sparticles found!");
222 }
223 return StatusCode::SUCCESS;
224}
ST::SUSYObjDef_xAOD::FindSusyHardProc
static bool FindSusyHardProc(const xAOD::TruthParticleContainer *truthP, int &pdgid1, int &pdgid2, bool isTruth3=false)
Definition Truth.cxx:126

◆ 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 106 of file Truth.cxx.

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

◆ FindSusyHP() [3/3]

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

Definition at line 76 of file Truth.cxx.

76 {
77
78 const xAOD::TruthParticleContainer* truthP = nullptr;
79 bool isTruth3 = false;
80 std::string key_T1 = "TruthParticles";
81 std::string key_T3 = "TruthBSM";
82
83 ATH_MSG_DEBUG("Contains " << key_T1 << ": " << ((evtStore()->contains<xAOD::TruthParticleContainer>( key_T1 ))?1:0));
84 ATH_MSG_DEBUG("Contains " << key_T3 << ": " << ((evtStore()->contains<xAOD::TruthParticleContainer>( key_T3 ))?1:0));
85
86 if(evtStore()->contains<xAOD::TruthParticleContainer>( key_T1 )){
87 ATH_CHECK( evtStore()->retrieve(truthP, key_T1) );
88 ATH_MSG_DEBUG("Retrieved " << key_T1 << " : size = " << truthP->size());
89 if (truthP->empty()) { ATH_MSG_WARNING(key_T1 << " is empty. Skipping FindSusyHP."); return StatusCode::SUCCESS; }
90 }
91 else if(evtStore()->contains<xAOD::TruthParticleContainer>( key_T3 )){
92 isTruth3=true;
93 ATH_CHECK( evtStore()->retrieve(truthP, key_T3) );
94 ATH_MSG_DEBUG("Retrieved " << key_T3 << " : size = " << truthP->size());
95 if (truthP->empty()) { ATH_MSG_WARNING(key_T3 << " is empty. Skipping FindSusyHP."); return StatusCode::SUCCESS; }
96 }
97 else {
98 ATH_MSG_WARNING("Neither " << key_T1 << " nor " << key_T3 << " are avaible. Skipping FindSusyHP.");
99 return StatusCode::SUCCESS;
100 }
101
102 return SUSYObjDef_xAOD::FindSusyHP(truthP, pdgid1, pdgid2, isTruth3);
103}
ST::SUSYObjDef_xAOD::FindSusyHP
StatusCode FindSusyHP(int &pdgid1, int &pdgid2) const
Definition Truth.cxx:76
xAOD::TruthParticleContainer
TruthParticleContainer_v1 TruthParticleContainer
Declare the latest version of the truth particle container.
Definition Event/xAOD/xAODTruth/xAODTruth/TruthParticleContainer.h:17

◆ FJVT_SF()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 1078 of file Jets.cxx.

1078 {
1079
1080 float totalSF = 1.;
1081 if (!m_doFwdJVT) return totalSF;
1082
1083 ConstDataVector<xAOD::JetContainer> fjvtjets(SG::VIEW_ELEMENTS);
1084 for (const xAOD::Jet* jet : *jets) {
1085 // Only jets that were good for every cut except JVT
1086 if (acc_signal_less_JVT(*jet) && acc_passOR(*jet)) {
1087 fjvtjets.push_back(jet);
1088 }
1089 }
1090
1091 for (const xAOD::Jet* jet : fjvtjets) {
1092 float current_sf = 0;
1093
1094 // the SF are only applied for HS jets and implicitely requires the presense of the isHS decoration
1095 CP::CorrectionCode result;
1096 if (acc_passFJvt(*jet)) {
1097 result = m_jetfJvtEfficiencyTool->getEfficiencyScaleFactor(*jet,current_sf);
1098 }
1099 else {
1100 result = m_jetfJvtEfficiencyTool->getInefficiencyScaleFactor(*jet,current_sf);
1101 }
1102
1103 switch (result) {
1104 case CP::CorrectionCode::Error:
1105 // this is probably not right, should report an error here
1106 ATH_MSG_ERROR("Inexplicably failed fJVT calibration" );
1107 break;
1108 case CP::CorrectionCode::OutOfValidityRange:
1109 // no fJvt SF for jet, that is ok e.g. for jets with |eta| < 2.5
1110 ATH_MSG_VERBOSE( "Skip SF application in SUSYTools_xAOD::FJVT_SF as jet outside validate range" );
1111 break;
1112 default:
1113 ATH_MSG_VERBOSE( "Retrieve SF for jet in SUSYTools_xAOD::FJVT_SF with value " << current_sf );
1114 totalSF *= current_sf;
1115 }
1116
1117 }
1118
1119 ATH_MSG_VERBOSE( "Retrieve total SF for jet container in SUSYTools_xAOD::FJVT_SF with value " << totalSF );
1120
1121 return totalSF;
1122 }
SG::VIEW_ELEMENTS
@ VIEW_ELEMENTS
this data object is a view, it does not own its elmts
Definition OwnershipPolicy.h:18
ST::acc_passFJvt
static const SG::ConstAccessor< char > acc_passFJvt("passFJvt")
ST::acc_signal_less_JVT
static const SG::ConstAccessor< char > acc_signal_less_JVT("signal_less_JVT")
Accessor for signal jets without a JVT requirement.

◆ FJVT_SFsys()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 1124 of file Jets.cxx.

1124 {
1125
1126 float totalSF = 1.;
1127 if (!m_doFwdJVT) return totalSF;
1128
1129 //Set the new systematic variation
1130 StatusCode ret = m_jetfJvtEfficiencyTool->applySystematicVariation(systConfig);
1131 if ( ret != StatusCode::SUCCESS) {
1132 ATH_MSG_ERROR("Cannot configure fJvtEfficiencyTool for systematic var. " << systConfig.name() );
1133 }
1134
1135 // Delegate
1136 totalSF = SUSYObjDef_xAOD::FJVT_SF( jets );
1137
1138 if (m_doFwdJVT) {
1139 ret = m_jetfJvtEfficiencyTool->applySystematicVariation(m_currentSyst);
1140 if ( ret != StatusCode::SUCCESS) {
1141 ATH_MSG_ERROR("Cannot configure fJvtEfficiencyTool for systematic var. " << systConfig.name() );
1142 }
1143 }
1144
1145 return totalSF;
1146 }
ST::SUSYObjDef_xAOD::FJVT_SF
double FJVT_SF(const xAOD::JetContainer *jets) override final
Definition Jets.cxx:1078

◆ GetCorrectedActualInteractionsPerCrossing()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3105 of file SUSYObjDef_xAOD.cxx.

3105 {
3106 const xAOD::EventInfo* evtInfo = GetEventInfo();
3107 return m_prwTool->getCorrectedActualInteractionsPerCrossing( *evtInfo, includeDataSF );
3108}

◆ GetCorrectedAverageInteractionsPerCrossing()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3100 of file SUSYObjDef_xAOD.cxx.

3100 {
3101 const xAOD::EventInfo* evtInfo = GetEventInfo();
3102 return m_prwTool->getCorrectedAverageInteractionsPerCrossing( *evtInfo, includeDataSF );
3103}

◆ GetDataWeight()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3095 of file SUSYObjDef_xAOD.cxx.

3095 {
3096 const xAOD::EventInfo* evtInfo = GetEventInfo();
3097 return m_prwTool->getDataWeight( *evtInfo, trig );
3098}

◆ getDefaultJetUncConfig()

std::string ST::SUSYObjDef_xAOD::getDefaultJetUncConfig ( )
protected

Definition at line 1915 of file SUSYObjDef_xAOD.cxx.

1915 {
1916 if (m_isRun3)
1917 return isAtlfast() ? "rel22/Spring2025_PreRec/R4_CategoryReduction_FullJER_MC23.config" : "rel22/Spring2025_PreRec/R4_CategoryReduction_FullJER_MC23.config";
1918 else
1919 return isAtlfast() ? "rel22/Spring2025_PreRec/R4_CategoryReduction_FullJER_MC20_MC21.config" : "rel22/Spring2025_PreRec/R4_CategoryReduction_FullJER_MC20_MC21.config";
1920}
ST::SUSYObjDef_xAOD::isAtlfast
bool isAtlfast() const override final
Definition SUSYObjDef_xAOD.h:158

◆ 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());
130 ATH_CHECK( m_outElectronLocation.initialize() );
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
142 ATH_CHECK( evtStore()->retrieve(prompt_electrons, elekey) );
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());
181 ATH_CHECK( evtStore()->retrieve(electrons, 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 if (copy==nullptr) { // empty container provided
198 xAOD::ShallowCopyResult_t<xAOD::ElectronContainer> shallowcopy = xAOD::shallowCopy(*electrons);
199 copy = shallowcopy.first.get();
200 copyaux = shallowcopy.second.get();
201 bool setLinks = xAOD::setOriginalObjectLink(*electrons, *copy);
202 if (!setLinks) {
203 ATH_MSG_WARNING("Failed to set original object links on " << elekey);
204 }
205 if (recordSG) {
206 ATH_CHECK( evtStore()->record(std::move(shallowcopy.first), "STCalib" + elekey + m_currentSyst.name()) );
207 ATH_CHECK( evtStore()->record(std::move(shallowcopy.second), "STCalib" + elekey + m_currentSyst.name() + "Aux.") );
208 } else {
209 ATH_MSG_ERROR("Shallow copy not recorded in StoreGate!");
210 return StatusCode::FAILURE;
211 }
212 } else { // use the user-supplied collection instead
213 ATH_MSG_DEBUG("Not retrieving electron collection, using existing one provided by user");
214 electrons=copy; // this does nothing
215 }
216
217 for (const auto electron : *copy) {
218 ATH_CHECK( this->FillElectron(*electron, m_eleBaselinePt, m_eleBaselineEta) );
219 this->IsSignalElectron(*electron, m_elePt, m_eled0sig, m_elez0, m_eleEta);
220 }
221
222 return StatusCode::SUCCESS;
223}
ST::SUSYObjDef_xAOD::FillElectron
StatusCode FillElectron(xAOD::Electron &input, const float etcut, const float etacut) override final
Definition Electrons.cxx:226
ST::SUSYObjDef_xAOD::m_eleLRT
bool m_eleLRT
Definition SUSYObjDef_xAOD.h:673
ST::SUSYObjDef_xAOD::prepareLRTElectrons
StatusCode prepareLRTElectrons(const xAOD::ElectronContainer *inMuons, xAOD::ElectronContainer *copy) const override final
Definition Electrons.cxx:90
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
ST::SUSYObjDef_xAOD::lrt_electrons
const xAOD::ElectronContainer * lrt_electrons
Definition SUSYObjDef_xAOD.h:212
ST::SUSYObjDef_xAOD::m_outElectronLocation
SG::WriteHandleKey< xAOD::ElectronContainer > m_outElectronLocation
Definition SUSYObjDef_xAOD.h:911
ST::SUSYObjDef_xAOD::prompt_electrons
const xAOD::ElectronContainer * prompt_electrons
Definition SUSYObjDef_xAOD.h:211
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:365
ST::dec_isLRT
static const SG::Decorator< char > dec_isLRT("isLRT")
xAOD::ShallowCopyResult_t
typename ShallowCopyResult< T >::type ShallowCopyResult_t
Return type of xAOD::shallowCopy.
Definition ShallowCopy.h:68
xAOD::ElectronContainer
ElectronContainer_v1 ElectronContainer
Definition of the current "electron container version".
Definition ElectronContainer.h:17
xAOD::shallowCopy
ShallowCopyResult_t< T > shallowCopy(const T &cont, const EventContext &ctx)
Create a shallow copy of an existing container.
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
xAOD::Electron
Electron_v1 Electron
Definition of the current "egamma version".
Definition Electron.h:17

◆ 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 595 of file Electrons.cxx.

595 {
596
597 std::string single_str = "SINGLE_E";
598 std::string single_Run3 = "202";
599 std::string dilep_str = "DI_E";
600 std::string multi_str = "MULTI_L";
601
602 double trig_eff(1.);
603
604 CP::CorrectionCode result;
605 if ( trigExpr.find(single_str) != std::string::npos || trigExpr.find(single_Run3) != std::string::npos)
606 result = m_elecEfficiencySFTool_trigEff_singleLep->getEfficiencyScaleFactor(el, trig_eff);
607 else if ( trigExpr.find(dilep_str) != std::string::npos )
608 ATH_MSG_ERROR( "Use GetTriggerGlobalEfficiency for logical OR of lepton triggers");
609 else if ( trigExpr.find(multi_str) != std::string::npos )
610 ATH_MSG_ERROR( "Use GetTriggerGlobalEfficiency for logical OR of lepton triggers");
611 else
612 ATH_MSG_ERROR( "The trigger expression (" << trigExpr << ") is not supported by the electron trigger efficiency!");
613
614 switch (result) {
615 case CP::CorrectionCode::Error:
616 ATH_MSG_ERROR( "Failed to retrieve signal electron trigger efficiency");
617 return 1.;
618 case CP::CorrectionCode::OutOfValidityRange:
619 ATH_MSG_VERBOSE( "OutOfValidityRange found for signal electron trigger efficiency");
620 return 1.;
621 default:
622 break;
623 }
624
625 return trig_eff;
626}

◆ 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 561 of file Electrons.cxx.

561 {
562
563 double trig_sf(1.);
564
565 std::string single_str = "SINGLE_E";
566 std::string single_Run3 = "202";
567 std::string dilep_str = "DI_E";
568 std::string multi_str = "MULTI_L";
569
570 CP::CorrectionCode result;
571 if ( trigExpr.find(single_str) != std::string::npos || trigExpr.find(single_Run3) != std::string::npos)
572 result = m_elecEfficiencySFTool_trig_singleLep->getEfficiencyScaleFactor(el, trig_sf);
573 else if ( trigExpr.find(dilep_str) != std::string::npos )
574 ATH_MSG_ERROR( "Use GetTriggerGlobalEfficiency for logical OR of lepton triggers");
575 else if ( trigExpr.find(multi_str) != std::string::npos )
576 ATH_MSG_ERROR( "Use GetTriggerGlobalEfficiency for logical OR of lepton triggers");
577 else
578 ATH_MSG_ERROR( "The trigger expression (" << trigExpr << ") is not supported by the electron trigger SF!");
579
580 switch (result) {
581 case CP::CorrectionCode::Error:
582 ATH_MSG_ERROR( "Failed to retrieve signal electron trigger SF");
583 return 1.;
584 case CP::CorrectionCode::OutOfValidityRange:
585 ATH_MSG_VERBOSE( "OutOfValidityRange found for signal electron trigger SF");
586 return 1.;
587 default:
588 break;
589 }
590
591 return trig_sf;
592}

◆ getElSFkeys()

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

Definition at line 1265 of file SUSYObjDef_xAOD.cxx.

1265 {
1266
1267 if( mapFile.empty() )
1268 return {};
1269
1270 std::vector<std::string> theKeys;
1271
1272 std::string filename = PathResolverFindCalibFile(mapFile);
1273 std::ifstream input( filename );
1274 for( std::string line; getline( input, line ); ){
1275 std::vector<std::string> tokens = split((const std::string)line,"=");
1276 if(tokens.size()){
1277 theKeys.push_back(tokens.at(0));
1278 }
1279 }
1280
1281 return theKeys;
1282}

◆ GetEventInfo()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3057 of file SUSYObjDef_xAOD.cxx.

3057 {
3058 const xAOD::EventInfo* evtInfo = nullptr;
3059 if ( evtStore()->retrieve( evtInfo, "EventInfo" ).isFailure() ) {
3060 throw std::runtime_error("Unable to fetch EventInfo.");
3061 }
3062 return evtInfo;
3063}

◆ 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 250 of file Jets.cxx.

251 {
252 if (!m_tool_init) {
253 ATH_MSG_ERROR("SUSYTools was not initialized!!");
254 return StatusCode::FAILURE;
255 }
256
257 if (m_fatJets.empty()) {
258 ATH_MSG_ERROR("JetFatCalibTool was not initialized for largeR jet!!");
259 return StatusCode::FAILURE;
260 }
261
262 std::string jetkey_tmp = jetkey;
263 if (jetkey.empty()) {
264 jetkey_tmp = m_fatJets;
265 }
266
267 const xAOD::JetContainer* jets = nullptr;
268 if (copy==nullptr) { // empty container provided
269 if (containerToBeCopied != nullptr) {
270 jets = containerToBeCopied;
271 }
272 else {
273 ATH_MSG_DEBUG("Retrieve jet collection: " << jetkey_tmp);
274 ATH_CHECK( evtStore()->retrieve(jets, jetkey_tmp) );
275 }
276
277 xAOD::ShallowCopyResult_t<xAOD::JetContainer> shallowcopy = xAOD::shallowCopy(*jets);
278 copy = shallowcopy.first.get();
279 copyaux = shallowcopy.second.get();
280 bool setLinks = xAOD::setOriginalObjectLink(*jets, *copy);
281 if (!setLinks) {
282 ATH_MSG_WARNING("Failed to set original object links on " << jetkey_tmp);
283 }
284 if (recordSG) {
285 ATH_CHECK( evtStore()->record(std::move(shallowcopy.first), "STCalib" + jetkey_tmp + m_currentSyst.name()) );
286 ATH_CHECK( evtStore()->record(std::move(shallowcopy.second), "STCalib" + jetkey_tmp + m_currentSyst.name() + "Aux.") );
287 } else {
288 ATH_MSG_ERROR("Shallow copy not recorded in StoreGate!");
289 return StatusCode::FAILURE;
290 }
291 } else { // use the user-supplied collection instead
292 ATH_MSG_DEBUG("Not retrieving jet collection, using existing one provided by user");
293 jets=copy;
294 }
295
296 if(jets->size()==0) {
297 ATH_MSG_DEBUG("Large R jet collection is empty");
298 return StatusCode::SUCCESS;
299 }
300
301 // Calibrate the jets - only insitu for data for now
302 if (isData()) ATH_CHECK(m_jetFatCalibTool->applyCalibration(*copy));
303
304
305 if (!isData() && !m_JetTruthLabelName.empty()){
306 ATH_MSG_DEBUG("Checking if decorator for JetTruthLabelingTool is available:");
307 std::string fatjetcoll = m_fatJets;
308 m_label_truthKey = fatjetcoll+"."+m_JetTruthLabelName;
309 SG::ReadDecorHandle<xAOD::JetContainer, int> labelHandle_truthKey(m_label_truthKey);
310 ATH_MSG_DEBUG("Reading JetTruthLabelingTool truthKey:" << m_label_truthKey << " isAvailable " << labelHandle_truthKey.isAvailable());
311 // Truth Labeling (MC only)
312 if (!labelHandle_truthKey.isAvailable() && !m_isPHYSLITE) ATH_CHECK(m_jetTruthLabelingTool->decorate(*copy));
313 }
314
315
316 // apply boosted jet taggers
317 if (!m_WtagConfig.empty())
318 ATH_CHECK(m_WTaggerTool->decorate(*copy));
319 if (!m_ZtagConfig.empty())
320 ATH_CHECK(m_ZTaggerTool->decorate(*copy));
321
322 for (const auto jet : *copy) {
323 ATH_CHECK( this->FillJet(*jet, true, true, doLargeRdecorations) );
324 //
325 // For OR, selected if it passed cuts
326 if ( acc_baseline(*jet) ){
327 dec_selected(*jet) = 1;
328 }
329 else{
330 dec_selected(*jet) = 0;
331 }
332 }
333
334 return StatusCode::SUCCESS;
335 }
ST::SUSYObjDef_xAOD::m_label_truthKey
SG::ReadDecorHandleKey< xAOD::JetContainer > m_label_truthKey
Definition SUSYObjDef_xAOD.h:870
ST::SUSYObjDef_xAOD::FillJet
StatusCode FillJet(xAOD::Jet &input, const bool doCalib=true, bool isFat=false, bool doLargeRdecorations=false) override final
Definition Jets.cxx:403
xAOD::JetContainer
JetContainer_v1 JetContainer
Definition of the current "jet container version".
Definition JetContainer.h:17

◆ GetInDetLargeD0GSFTracks()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3164 of file SUSYObjDef_xAOD.cxx.

3164 {
3165 SG::ReadHandle<xAOD::TrackParticleContainer> tracks(m_GSFLRTCollectionName, ctx);
3166
3167 if ( !tracks.isValid() ) {
3168 throw std::runtime_error("Unable to fetch LargeD0 GSF tracks.");
3169 }
3170 return *tracks;
3171}
ST::SUSYObjDef_xAOD::m_GSFLRTCollectionName
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_GSFLRTCollectionName
Definition SUSYObjDef_xAOD.h:482

◆ GetInDetLargeD0Tracks()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3152 of file SUSYObjDef_xAOD.cxx.

3152 {
3153 SG::ReadHandle<xAOD::TrackParticleContainer> tracks(m_LRTCollectionName, ctx);
3154
3155 if ( !tracks.isValid() ) {
3156 throw std::runtime_error("Unable to fetch LargeD0 tracks.");
3157 }
3158
3159 //const xAOD::TrackParticleContainer out = *tracks;
3160
3161 return *tracks;
3162}
ST::SUSYObjDef_xAOD::m_LRTCollectionName
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_LRTCollectionName
Definition SUSYObjDef_xAOD.h:481

◆ 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 73 of file Jets.cxx.

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

◆ 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 338 of file Jets.cxx.

339 {
340 if (!m_tool_init) {
341 ATH_MSG_ERROR("SUSYTools was not initialized!!");
342 return StatusCode::FAILURE;
343 }
344
345 std::string jetkey_tmp = jetkey;
346 if (jetkey.empty()) {
347 jetkey_tmp = m_defaultJets;
348 }
349
350 xAOD::ShallowCopyResult_t<xAOD::JetContainer> shallowcopy = xAOD::shallowCopy(calibjets);
351 copy = shallowcopy.first.get();
352 copyaux = shallowcopy.second.get();
353
354 bool setLinks = xAOD::setOriginalObjectLink(calibjets, *copy);
355 if (!setLinks) {
356 ATH_MSG_WARNING("Failed to set original object links on " << jetkey_tmp);
357 }
358
359 // ghost associate the muons to the jets (needed by MET muon-jet OR later)
360 ATH_MSG_VERBOSE("Run muon-to-jet ghost association");
361 const xAOD::MuonContainer* muons = nullptr;
362 // Do a little guessing
363 if (jetkey!="AnalysisJets"){
364 ATH_CHECK( evtStore()->retrieve(muons, "Muons") );
365 } else {
366 ATH_CHECK( evtStore()->retrieve(muons, "AnalysisMuons") );
367 }
368 met::addGhostMuonsToJets(*muons, *copy);
369
370 // Update the jets
371 for (const auto jet : *copy) {
372 ATH_CHECK( this->FillJet(*jet, false) );
373 }
374
375 for (const auto jet : *copy) {
376 // Update the JVT decorations if needed
377 if( m_doFwdJVT){
378 dec_passJvt(*jet) = acc_passFJvt(*jet) && acc_passJvt(*jet);
379
380 //new state for OR . 0=non-baseline objects, 1=for baseline jets not passing JVT, 2=for any other baseline object
381 if ( acc_baseline(*jet) ){
382 if( acc_passJvt(*jet) ) dec_selected(*jet) = 2;
383 else dec_selected(*jet) = 1;
384 }
385 else{
386 dec_selected(*jet) = 0;
387 }
388 }
389 this->IsBadJet(*jet);
390 this->IsSignalJet(*jet, m_jetPt, m_jetEta);
391 if (!isData())this->IsTruthBJet(*jet);
392 }
393 if (recordSG) {
394 ATH_CHECK( evtStore()->record(std::move(shallowcopy.first), "STCalib" + jetkey_tmp + m_currentSyst.name()) );
395 ATH_CHECK( evtStore()->record(std::move(shallowcopy.second), "STCalib" + jetkey_tmp + m_currentSyst.name() + "Aux.") );
396 } else {
397 ATH_MSG_ERROR("Shallow copy not recorded in StoreGate!");
398 return StatusCode::FAILURE;
399 }
400 return StatusCode::SUCCESS;
401 }
met::addGhostMuonsToJets
void addGhostMuonsToJets(const xAOD::MuonContainer &muons, xAOD::JetContainer &jets)
Definition METHelpers.cxx:34
xAOD::MuonContainer
MuonContainer_v1 MuonContainer
Definition of the current "Muon container version".
Definition MuonContainer.h:14

◆ 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::Event 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::Event, 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 }
StateLessPT_NewConfig.proxy
proxy
Definition StateLessPT_NewConfig.py:415

◆ 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); }
ST::getMCShowerType
static int getMCShowerType(const std::string &sample_name, const std::string &tagger="")
Definition ISUSYObjDef_xAODTool.h:169

◆ 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");
65 ConstDataVector<xAOD::ElectronContainer> metelectron(SG::VIEW_ELEMENTS);
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");
83 ConstDataVector<xAOD::PhotonContainer> metgamma(SG::VIEW_ELEMENTS);
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");
101 ConstDataVector<xAOD::TauJetContainer> mettau(SG::VIEW_ELEMENTS);
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");
119 ConstDataVector<xAOD::MuonContainer> metmuon(SG::VIEW_ELEMENTS);
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}
ST::SUSYObjDef_xAOD::m_inputMETCore
std::string m_inputMETCore
Definition SUSYObjDef_xAOD.h:582
ST::SUSYObjDef_xAOD::m_inputMETMap
std::string m_inputMETMap
Definition SUSYObjDef_xAOD.h:581
veto
std::vector< std::string > veto
these patterns are anded
Definition listroot.cxx:191
met::buildMETSum
StatusCode buildMETSum(const std::string &totalName, xAOD::MissingETContainer *metCont)
Definition METHelpers.cxx:65
xAODType::Photon
@ Photon
The object is a photon.
Definition ObjectType.h:47
xAODType::Muon
@ Muon
The object is a muon.
Definition ObjectType.h:48
xAODType::Electron
@ Electron
The object is an electron.
Definition ObjectType.h:46
xAODType::Tau
@ Tau
The object is a tau (jet).
Definition ObjectType.h:49
xAOD::TauJet
TauJet_v3 TauJet
Definition of the current "tau version".
Definition TauJet.h:17
xAOD::MissingETContainer
MissingETContainer_v1 MissingETContainer
Definition MissingETContainer.h:16
xAOD::Muon
Muon_v1 Muon
Reference the current persistent version:
Definition Muon.h:13
xAOD::Photon
Photon_v1 Photon
Definition of the current "egamma version".
Definition Photon.h:17
xAOD::MissingETAssociationMap
MissingETAssociationMap_v1 MissingETAssociationMap
Version control by type defintion.
Definition MissingETAssociationMap.h:16

◆ 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" ) );
253 ATH_CHECK( m_metSignif->varianceMET( &met, evtInfo->averageInteractionsPerCrossing(), m_jetTerm, softTerm, m_outMETTerm) );
254 metSignificance = m_metSignif->GetSignificance();
255 ATH_MSG_VERBOSE( "Obtained MET Significance: " << metSignificance );
256
257 return StatusCode::SUCCESS;
258}
xAOD::EventInfo_v1::averageInteractionsPerCrossing
float averageInteractionsPerCrossing() const
Average interactions per crossing for all BCIDs - for out-of-time pile-up.
Definition EventInfo_v1.cxx:365

◆ 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 101 of file Muons.cxx.

102{
103 if (!m_tool_init) {
104 ATH_MSG_ERROR("SUSYTools was not initialized!!");
105 return StatusCode::FAILURE;
106 }
107
108 // Initializing prompt/LRT OR procedure
109 auto outputCol = std::make_unique<xAOD::MuonContainer>();
110 std::unique_ptr<xAOD::MuonAuxContainer> outputAuxCol;
111 outputAuxCol = std::make_unique<xAOD::MuonAuxContainer>();
112 outputCol->setStore(outputAuxCol.get());
113 ATH_CHECK( m_outMuonLocation.initialize() );
114
115 if (bool(m_muLRT) && !lrtmuonkey.empty() && evtStore()->contains<xAOD::MuonContainer>(lrtmuonkey)){
116 ATH_MSG_DEBUG("Applying prompt/LRT muon OR procedure");
117
118 // First identify if merged container has already been made (for instances where GetMuons() is called more than once)
119 if (evtStore()->contains<xAOD::MuonContainer>("StdWithLRTMuons")) {
120 ATH_MSG_DEBUG("Merged prompt/LRT container already created in TStore");
121 } else {
122 ATH_MSG_DEBUG("Creating merged prompt/LRT container in TStore");
123
124 // Retrieve prompt and LRT muons from TStore
125 ATH_CHECK( evtStore()->retrieve(prompt_muons, muonkey) );
126 ATH_CHECK( evtStore()->retrieve(lrt_muons, lrtmuonkey) );
127
128 // Remove LRT muons as flagged by filter for uncertainty
129 auto filtered_muons = std::make_unique<xAOD::MuonContainer>();
130 std::unique_ptr<xAOD::MuonAuxContainer> filtered_muons_aux = std::make_unique<xAOD::MuonAuxContainer>();
131 filtered_muons->setStore(filtered_muons_aux.get());
132 ATH_CHECK(prepareLRTMuons(lrt_muons, filtered_muons.get()));
133
134 // Check overlap between prompt and LRT collections
135 std::vector<bool> writePromptMuon;
136 std::vector<bool> writeLRTMuon;
137 m_muonLRTORTool->checkOverlap(*prompt_muons, *filtered_muons, writePromptMuon, writeLRTMuon);
138
139 // Decorate muons with prompt/LRT
140 for (const xAOD::Muon* mu : *prompt_muons) dec_isLRT(*mu) = 0;
141 for (const xAOD::Muon* mu : *filtered_muons) dec_isLRT(*mu) = 1;
142
143 // Create merged StdWithLRTMuons container
144 outputCol->reserve(prompt_muons->size() + filtered_muons->size());
145 ATH_CHECK(MergeMuons(*prompt_muons, writePromptMuon, outputCol.get()) );
146 ATH_CHECK(MergeMuons(*filtered_muons, writeLRTMuon, outputCol.get()) );
147
148 // Save merged StdWithLRTMuons container to TStore
149 ATH_CHECK(evtStore()->record(std::move(outputCol), m_outMuonLocation.key()));
150 ATH_CHECK(evtStore()->record(std::move(outputAuxCol), m_outMuonLocation.key() + "Aux.") );
151
152 }
153 } else if (!lrtmuonkey.empty()) {
154 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!");
155 ATH_MSG_DEBUG("Not applying prompt/LRT muon OR procedure");
156 }
157
158 if (m_isPHYSLITE && muonkey.find("AnalysisMuons")==std::string::npos){
159 ATH_MSG_ERROR("You are running on PHYSLITE derivation. Please change the Muons container to 'AnalysisMuons'");
160 return StatusCode::FAILURE;
161 }
162
163 const xAOD::MuonContainer* muons = nullptr;
164 if (bool(m_muLRT) && evtStore()->contains<xAOD::MuonContainer>(lrtmuonkey)){
165 ATH_MSG_DEBUG("Using container: " << m_outMuonLocation.key());
166 ATH_CHECK( evtStore()->retrieve(muons, m_outMuonLocation.key()));
167 }
168 else {
169 if (copy==nullptr) { // empty container provided
170 ATH_MSG_DEBUG("Empty container provided");
171 if (containerToBeCopied != nullptr) {
172 ATH_MSG_DEBUG("Containter to be copied not nullptr");
173 muons = containerToBeCopied;
174 }
175 else {
176 ATH_MSG_DEBUG("Getting Muons collection");
177 ATH_CHECK( evtStore()->retrieve(muons, muonkey) );
178 }
179 }
180 }
181
182 if (copy==nullptr) { // empty container provided
183 xAOD::ShallowCopyResult_t<xAOD::MuonContainer> shallowcopy = xAOD::shallowCopy(*muons);
184 copy = shallowcopy.first.get();
185 copyaux = shallowcopy.second.get();
186 bool setLinks = xAOD::setOriginalObjectLink(*muons, *copy);
187 if (!setLinks) {
188 ATH_MSG_WARNING("Failed to set original object links on " << muonkey);
189 }
190 if (recordSG) {
191 ATH_CHECK( evtStore()->record(std::move(shallowcopy.first), "STCalib" + muonkey + m_currentSyst.name()) );
192 ATH_CHECK( evtStore()->record(std::move(shallowcopy.second), "STCalib" + muonkey + m_currentSyst.name() + "Aux.") );
193 } else {
194 ATH_MSG_ERROR("Shallow copy not recorded in StoreGate!");
195 return StatusCode::FAILURE;
196 }
197 } else { // use the user-supplied collection instead
198 ATH_MSG_DEBUG("Not retrieving muon collection, using existing one provided by user");
199 muons=copy; // this does nothing
200 }
201
202 for (const auto muon : *copy) {
203 ATH_CHECK( this->FillMuon(*muon, m_muBaselinePt, m_muBaselineEta) );
204 this->IsSignalMuon(*muon, m_muPt, m_mud0sig, m_muz0, m_muEta);
205 this->IsCosmicMuon(*muon, m_muCosmicz0, m_muCosmicd0);
206 this->IsBadMuon(*muon, m_badmuQoverP);
207 }
208
209 return StatusCode::SUCCESS;
210}
ST::SUSYObjDef_xAOD::IsBadMuon
bool IsBadMuon(const xAOD::Muon &input, const float qopcut) const override final
Definition Muons.cxx:408
ST::SUSYObjDef_xAOD::m_outMuonLocation
SG::WriteHandleKey< xAOD::MuonContainer > m_outMuonLocation
Definition SUSYObjDef_xAOD.h:896
ST::SUSYObjDef_xAOD::MergeMuons
StatusCode MergeMuons(const xAOD::MuonContainer &muons, const std::vector< bool > &writeMuon, xAOD::MuonContainer *outputCol) const override final
Definition Muons.cxx:56
ST::SUSYObjDef_xAOD::prepareLRTMuons
StatusCode prepareLRTMuons(const xAOD::MuonContainer *inMuons, xAOD::MuonContainer *copy) const override final
Definition Muons.cxx:74
ST::SUSYObjDef_xAOD::lrt_muons
const xAOD::MuonContainer * lrt_muons
Definition SUSYObjDef_xAOD.h:206
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:347
ST::SUSYObjDef_xAOD::IsCosmicMuon
bool IsCosmicMuon(const xAOD::Muon &input, const float z0cut, const float d0cut) const override final
Definition Muons.cxx:447
ST::SUSYObjDef_xAOD::m_muLRT
bool m_muLRT
Definition SUSYObjDef_xAOD.h:733
ST::SUSYObjDef_xAOD::FillMuon
StatusCode FillMuon(xAOD::Muon &input, const float ptcut, const float etacut) override final
Definition Muons.cxx:212
ST::SUSYObjDef_xAOD::prompt_muons
const xAOD::MuonContainer * prompt_muons
Definition SUSYObjDef_xAOD.h:205

◆ 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 536 of file Muons.cxx.

536 {
537
538 double eff(1.);
539
540 if (m_muonTriggerSFTool->getTriggerEfficiency(mu, eff, trigExpr, isdata) != CP::CorrectionCode::Ok) {
541 ATH_MSG_WARNING("Problem retrieving signal muon trigger efficiency for " << trigExpr );
542 }
543 else{
544 ATH_MSG_DEBUG("Got efficiency " << eff << " for " << trigExpr );
545 }
546 return eff;
547}
dqt_zlumi_alleff_HIST.eff
int eff
Definition dqt_zlumi_alleff_HIST.py:113

◆ 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::Event 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::Event, 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 xAOD::ShallowCopyResult_t<xAOD::PhotonContainer> shallowcopy = xAOD::shallowCopy(*photons);
54 copy = shallowcopy.first.get();
55 copyaux = shallowcopy.second.get();
56 bool setLinks = xAOD::setOriginalObjectLink(*photons, *copy);
57 if (!setLinks) {
58 ATH_MSG_WARNING("Failed to set original object links on " << photonkey);
59 }
60 if (recordSG) {
61 ATH_CHECK( evtStore()->record(std::move(shallowcopy.first), "STCalib" + photonkey + m_currentSyst.name()) );
62 ATH_CHECK( evtStore()->record(std::move(shallowcopy.second), "STCalib" + photonkey + m_currentSyst.name() + "Aux.") );
63 } else {
64 ATH_MSG_ERROR("Shallow copy not recorded in StoreGate!");
65 return StatusCode::FAILURE;
66 }
67 } else { // use the user-supplied collection instead
68 ATH_MSG_DEBUG("Not retrieving photon collecton, using existing one provided by user");
69 photons=copy;
70 }
71
72 for (const auto photon : *copy) {
73 ATH_CHECK( this->FillPhoton(*photon, m_photonBaselinePt, m_photonBaselineEta) );
74 this->IsSignalPhoton(*photon, m_photonPt, m_photonEta);
75 }
76
77 return StatusCode::SUCCESS;
78}
ST::SUSYObjDef_xAOD::FillPhoton
StatusCode FillPhoton(xAOD::Photon &input, const float ptcut, const float etacut) override final
Definition Photons.cxx:81
ST::SUSYObjDef_xAOD::IsSignalPhoton
bool IsSignalPhoton(const xAOD::Photon &input, const float ptcut, const float etacut=DUMMYDEF) const override final
Definition Photons.cxx:170
xAOD::PhotonContainer
PhotonContainer_v1 PhotonContainer
Definition of the current "photon container version".
Definition PhotonContainer.h:17

◆ GetPileupWeight()

float ST::SUSYObjDef_xAOD::GetPileupWeight ( )
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3065 of file SUSYObjDef_xAOD.cxx.

3065 {
3066
3067 const xAOD::EventInfo* evtInfo = GetEventInfo();
3068 float pu_weight = m_prwTool->getCombinedWeight(*evtInfo);
3069
3070 if(!isfinite(pu_weight)) pu_weight = 1.;
3071
3072 return pu_weight;
3073}

◆ GetPileupWeightHash()

ULong64_t ST::SUSYObjDef_xAOD::GetPileupWeightHash ( )
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3090 of file SUSYObjDef_xAOD.cxx.

3090 {
3091 const xAOD::EventInfo* evtInfo = GetEventInfo();
3092 return m_prwTool->getPRWHash( *evtInfo );
3093}

◆ GetPileupWeightPrescaledTrigger()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3075 of file SUSYObjDef_xAOD.cxx.

3075 {
3076 /* This requires the setup of the PRW tool using your own prescaled lumicalc
3077 files with syntax "HLT_PrescaledTriggerA.lumicalc.root:HLT_PrescaledTriggerA".
3078 For further informations, please refer to:
3079 https://twiki.cern.ch/twiki/bin/view/AtlasProtected/ExtendedPileupReweighting#Prescaling%20MC
3080 */
3081
3082 const xAOD::EventInfo* evtInfo = GetEventInfo();
3083 float pu_weight = m_prwTool->getCombinedWeight(*evtInfo,trigger_expr);
3084
3085 if(!isfinite(pu_weight)) pu_weight = 1.;
3086
3087 return pu_weight;
3088}

◆ GetPrimVtx()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2996 of file SUSYObjDef_xAOD.cxx.

2996 {
2997 const xAOD::VertexContainer* vertices = nullptr;
2998 if ( evtStore()->retrieve( vertices, "PrimaryVertices" ).isSuccess() ) {
2999 for ( const auto vx : *vertices ) {
3000 if (vx->vertexType() == xAOD::VxType::PriVtx) {
3001 ATH_MSG_DEBUG("PrimaryVertex found with z=" << vx->z());
3002 return vx;
3003 }
3004 }
3005 } else {
3006 ATH_MSG_WARNING("Failed to retrieve VertexContainer \"PrimaryVertices\", returning nullptr");
3007 }
3008 return nullptr;
3009}
xAOD::VxType::PriVtx
@ PriVtx
Primary vertex.
Definition TrackingPrimitives.h:597
xAOD::VertexContainer
VertexContainer_v1 VertexContainer
Definition of the current "Vertex container version".
Definition VertexContainer.h:14

◆ getProperty() [1/2]

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

Get one of the tool's properties.

◆ getProperty() [2/2]

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

Definition at line 240 of file ISUSYObjDef_xAODTool.h.

240 {
241 return dynamic_cast<asg::AsgTool&>(*this).getProperty<T>(name);
242 }
TSU::T
unsigned long long T
Definition L1TopoDataTypes.h:36

◆ GetRandomRunNumber()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3114 of file SUSYObjDef_xAOD.cxx.

3114 {
3115
3116 const xAOD::EventInfo* evtInfo = GetEventInfo();
3117 if (randomrunnumber.isAvailable(*(evtInfo)) && muDependentRRN) {
3118 return randomrunnumber(*(evtInfo));
3119 }
3120 else if (!muDependentRRN) {
3121 return m_prwTool->getRandomRunNumber( *evtInfo, muDependentRRN );
3122 }
3123 ATH_MSG_ERROR ( "Failed to find RandomRunNumber decoration! You need to call ApplyPRWTool() beforehand!" );
3124 return 0;
3125}

◆ GetRunNumber()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3136 of file SUSYObjDef_xAOD.cxx.

3136 {
3137
3138 const xAOD::EventInfo* evtInfo = GetEventInfo();
3139
3140 // For data, we can just directly use the run number
3141 if (isData()) { return evtInfo->runNumber(); }
3142
3143 // else it's MC as we need the RRN assigned by the PRW tool
3144 if (!randomrunnumber.isAvailable(*(evtInfo))) {
3145 ATH_MSG_ERROR ( "Failed to find RandomRunNumber decoration! You need to call ApplyPRWTool() beforehand!" );
3146 }
3147 return randomrunnumber(*(evtInfo));
3148
3149}
xAOD::EventInfo_v1::runNumber
uint32_t runNumber() const
The current event's run number.

◆ getSherpaVjetsNjetsWeight() [1/2]

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2965 of file SUSYObjDef_xAOD.cxx.

2965 {
2966
2967 //Retrieve the truth jets
2968 if( evtStore()->contains<xAOD::JetContainer>("AntiKt4TruthWZJets") ){
2969 return getSherpaVjetsNjetsWeight("AntiKt4TruthWZJets");
2970 }
2971 else if( evtStore()->contains<xAOD::JetContainer>("AntiKt4TruthJets")){
2972 return getSherpaVjetsNjetsWeight("AntiKt4TruthJets" );
2973 }
2974 else{
2975 ATH_MSG_WARNING("No TruthJetContainer found! Dummy null weight retrieved.");
2976 }
2977 return 0.;
2978}
ST::SUSYObjDef_xAOD::getSherpaVjetsNjetsWeight
float getSherpaVjetsNjetsWeight() const override final
Definition SUSYObjDef_xAOD.cxx:2965

◆ getSherpaVjetsNjetsWeight() [2/2]

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2980 of file SUSYObjDef_xAOD.cxx.

2980 {
2981
2982 if(jetContainer=="AntiKt4TruthWZJets"){
2983 return m_pmgSHnjetWeighterWZ->getWeight();
2984 }
2985 else if (jetContainer=="AntiKt4TruthJets"){
2986 return m_pmgSHnjetWeighter->getWeight();
2987 }
2988 else{
2989 ATH_MSG_WARNING(jetContainer << " is no supported by PMGSherpa22VJetsWeightTool! Please check...");
2990 }
2991 return 1.;
2992
2993}

◆ 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 423 of file Electrons.cxx.

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

◆ 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 483 of file Muons.cxx.

484{
485 float sf(1.);
486
487 if (recoSF) {
488 float sf_reco(1.);
489 if (m_muonEfficiencySFTool->getEfficiencyScaleFactor( mu, sf_reco ) == CP::CorrectionCode::OutOfValidityRange) {
490 if(warnOVR) ATH_MSG_WARNING(" GetSignalMuonSF: Reco getEfficiencyScaleFactor out of validity range");
491 }
492 ATH_MSG_VERBOSE( "MuonReco ScaleFactor " << sf_reco );
493 sf *= sf_reco;
494
495 float sf_ttva(1.);
496 if(m_doTTVAsf){
497 if (m_muonTTVAEfficiencySFTool->getEfficiencyScaleFactor( mu, sf_ttva ) == CP::CorrectionCode::OutOfValidityRange) {
498 if(warnOVR) ATH_MSG_WARNING(" GetSignalMuonSF: TTVA getEfficiencyScaleFactor out of validity range");
499 }
500 ATH_MSG_VERBOSE( "MuonTTVA ScaleFactor " << sf_ttva );
501 sf *= sf_ttva;
502 }
503
504 float sf_badHighPt(1.);
505 if(m_muId == 4 && doBadMuonHP){
506 if (m_muonEfficiencyBMHighPtSFTool->getEfficiencyScaleFactor( mu, sf_badHighPt ) == CP::CorrectionCode::OutOfValidityRange) {
507 if(warnOVR) ATH_MSG_WARNING(" GetSignalMuonSF: BadMuonHighPt getEfficiencyScaleFactor out of validity range");
508 }
509 ATH_MSG_VERBOSE( "MuonBadMuonHighPt ScaleFactor " << sf_badHighPt );
510 sf *= sf_badHighPt;
511 }
512 }
513
514
515 if (isoSF) {
516 float sf_iso(1.);
517 if (acc_isolHighPt(mu) && mu.pt()>m_muIsoHighPtThresh) {
518 if (m_muonHighPtIsolationSFTool->getEfficiencyScaleFactor( mu, sf_iso ) == CP::CorrectionCode::OutOfValidityRange) {
519 if(warnOVR) ATH_MSG_WARNING(" GetSignalMuonSF: high-pt Iso getEfficiencyScaleFactor out of validity range");
520 }
521 } else if (acc_isol(mu) && mu.pt()<m_muIsoHighPtThresh) {
522 if (m_muonIsolationSFTool->getEfficiencyScaleFactor( mu, sf_iso ) == CP::CorrectionCode::OutOfValidityRange) {
523 if(warnOVR) ATH_MSG_WARNING(" GetSignalMuonSF: Iso getEfficiencyScaleFactor out of validity range");
524 }
525 }
526 ATH_MSG_VERBOSE( "MuonIso ScaleFactor " << sf_iso );
527 sf *= sf_iso;
528 }
529
530
531 dec_effscalefact(mu) = sf;
532 return sf;
533}
CaloNoise_fillDB.mu
int mu
Definition CaloNoise_fillDB.py:173
ST::acc_isol
static const SG::ConstAccessor< char > acc_isol("isol")

◆ 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 209 of file Photons.cxx.

210{
211 double sf(1.);
212
213 if (effSF) {
214
215 double sf_eff = 1.;
216
217 CP::CorrectionCode res = m_photonEfficiencySFTool->getEfficiencyScaleFactor( ph, sf_eff );
218 if (res == CP::CorrectionCode::OutOfValidityRange) ATH_MSG_WARNING(" GetSignalPhotonSF: EfficiencyScaleFactor out of validity range");
219
220 sf *= sf_eff;
221 }
222
223 if (isoSF) {
224
225 double sf_iso = 1.;
226
227 CP::CorrectionCode res = m_photonIsolationSFTool->getEfficiencyScaleFactor( ph, sf_iso );
228 if (res == CP::CorrectionCode::OutOfValidityRange) ATH_MSG_WARNING(" GetSignalPhotonSF: IsolationScaleFactor out of validity range");
229
230 sf *= sf_iso;
231 }
232
233 if (triggerSF) {
234
235 double sf_trigger = 1.;
236
237 CP::CorrectionCode res = m_photonTriggerSFTool->getEfficiencyScaleFactor( ph, sf_trigger );
238 if (res == CP::CorrectionCode::OutOfValidityRange) ATH_MSG_WARNING(" GetSignalPhotonSF: TriggerScaleFactor out of validity range");
239
240 sf *= sf_trigger;
241 }
242
243 ATH_MSG_VERBOSE( "ScaleFactor " << sf );
244
245 dec_effscalefact(ph) = sf;
246 return sf;
247}
res
std::pair< std::vector< unsigned int >, bool > res
Definition JetGroupProductTest.cxx:11

◆ 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 250 of file Photons.cxx.

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

◆ 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 133 of file Taus.cxx.

137{
138 double sf(1.);
139
140 // TEMPORARY: no recommendations yet for 2024+
141 if (acc_signal(tau) && this->treatAsYear()<2024) {
142 if (idSF) {
143 if (m_tauEffTool->getEfficiencyScaleFactor(tau, sf) != CP::CorrectionCode::Ok) {
144 ATH_MSG_WARNING("Failed to retrieve tau efficiency scale factor.");
145 }
146 ATH_MSG_VERBOSE(" Retrieved tau SF " << sf);
147 }
148
149 if (triggerSF) {
150 double trig_sf = GetTauTriggerEfficiencySF(tau, trigExpr);
151
152 if (trig_sf > -90) {
153 sf *= trig_sf;
154 ATH_MSG_VERBOSE(" Retrieved tau trig SF " << trig_sf);
155 }
156 }
157 }
158
159 dec_effscalefact(tau) = sf;
160 return sf;
161}
ST::SUSYObjDef_xAOD::GetTauTriggerEfficiencySF
double GetTauTriggerEfficiencySF(const xAOD::TauJet &tau, const std::string &trigExpr="tau25_medium1_tracktwo") override final
Definition Taus.cxx:201

◆ 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 164 of file Taus.cxx.

169{
170 double sf(1.);
171
172 // TEMPORARY: no recommendations yet for 2024+
173 if (this->treatAsYear()<2024) {
174 //Set the new systematic variation
175 StatusCode ret = m_tauEffTool->applySystematicVariation(systConfig);
176 if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure TauEfficiencyCorrectionsTool for systematic var. " << systConfig.name() ); }
177
178 for (auto& tool : m_tauTrigEffTool) {
179 ret = tool->applySystematicVariation(systConfig);
180 if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure " << tool->name() << " for systematic var. " << systConfig.name()); }
181 }
182
183 sf *= GetSignalTauSF(tau, idSF, triggerSF, trigExpr);
184
185 //Roll back to default
186 ret = m_tauEffTool->applySystematicVariation(m_currentSyst);
187 if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure TauEfficiencyCorrectionsTool back to default"); }
188
189 for (auto& tool : m_tauTrigEffTool) {
190 ret = tool->applySystematicVariation(m_currentSyst);
191 if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure " << tool->name() << " back to default"); }
192 }
193 }
194
195 dec_effscalefact(tau) = sf;
196
197 return sf;
198}
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:133

◆ GetSumOfWeights()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3110 of file SUSYObjDef_xAOD.cxx.

3110 {
3111 return m_prwTool->GetSumOfEventWeights(channel);
3112}

◆ getSystInfo()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2647 of file SUSYObjDef_xAOD.cxx.

2647 {
2648
2649 SystInfo sysInfo;
2650 sysInfo.affectsKinematics = false;
2651 sysInfo.affectsWeights = false;
2652 sysInfo.affectedWeights.clear();
2653 sysInfo.systset.insert(sys);
2654
2655 if (!m_jetNNJvtEfficiencyTool.empty()) {
2656 if ( m_jetNNJvtEfficiencyTool->isAffectedBySystematic( sys ) ) {
2657 sysInfo.affectsWeights = true;
2658 sysInfo.affectsType = SystObjType::Jet;
2659 sysInfo.affectedWeights.insert(ST::Weights::Jet::JVT);
2660 }
2661 }
2662
2663 if (!m_jetfJvtEfficiencyTool.empty()) {
2664 if ( m_jetfJvtEfficiencyTool->isAffectedBySystematic( sys ) ) {
2665 sysInfo.affectsWeights = true;
2666 sysInfo.affectsType = SystObjType::Jet;
2667 sysInfo.affectedWeights.insert(ST::Weights::Jet::FJVT);
2668 }
2669 }
2670
2671 if (!m_jetUncertaintiesTool.empty()) {
2672 if ( m_jetUncertaintiesTool->isAffectedBySystematic( sys ) ) {
2673 sysInfo.affectsKinematics = true;
2674 sysInfo.affectsType = SystObjType::Jet;
2675 }
2676 }
2677 if (!m_jetUncertaintiesPDSmearTool.empty()) {
2678 if ( m_jetUncertaintiesPDSmearTool->isAffectedBySystematic( sys ) ) {
2679 sysInfo.affectsKinematics = true;
2680 sysInfo.affectsType = SystObjType::Jet;
2681 }
2682 }
2683
2684 if (!m_fatjetUncertaintiesTool.empty()) {
2685 if ( m_fatjetUncertaintiesTool->isAffectedBySystematic( sys ) ) {
2686 sysInfo.affectsKinematics = true;
2687 sysInfo.affectsType = SystObjType::Jet;
2688 }
2689 }
2690 if (!m_fatjetUncertaintiesPDSmearTool.empty()) {
2691 if ( m_fatjetUncertaintiesPDSmearTool->isAffectedBySystematic( sys ) ) {
2692 sysInfo.affectsKinematics = true;
2693 sysInfo.affectsType = SystObjType::Jet;
2694 }
2695 }
2696
2697 if (!m_fatjetFFSmearingTool.empty()) {
2698 CP::SystematicSet dummy;
2699 dummy.insert(sys);
2700 if ( std::find(m_fatjetFFSmearingSyst.begin(), m_fatjetFFSmearingSyst.end(), dummy) != m_fatjetFFSmearingSyst.end() ) {
2701 sysInfo.affectsKinematics = true;
2702 sysInfo.affectsType = SystObjType::Jet;
2703 }
2704 }
2705
2706 if (!m_WTagjetUncertaintiesTool.empty()) {
2707 if ( m_WTagjetUncertaintiesTool->isAffectedBySystematic( CP::SystematicVariation(sys.basename(), CP::SystematicVariation::CONTINUOUS) ) ) {
2708 sysInfo.affectsKinematics = true;
2709 sysInfo.affectsType = SystObjType::Jet;
2710 }
2711 }
2712 if (!m_ZTagjetUncertaintiesTool.empty()) {
2713 if ( m_ZTagjetUncertaintiesTool->isAffectedBySystematic( CP::SystematicVariation(sys.basename(), CP::SystematicVariation::CONTINUOUS) ) ) {
2714 sysInfo.affectsKinematics = true;
2715 sysInfo.affectsType = SystObjType::Jet;
2716 }
2717 }
2718 if (!m_TopTagjetUncertaintiesTool.empty()) {
2719 if ( m_TopTagjetUncertaintiesTool->isAffectedBySystematic( CP::SystematicVariation(sys.basename(), CP::SystematicVariation::CONTINUOUS) ) ) {
2720 sysInfo.affectsKinematics = true;
2721 sysInfo.affectsType = SystObjType::Jet;
2722 }
2723 }
2724
2725 if (!m_muonCalibTool.empty()) {
2726 if ( m_muonCalibTool->isAffectedBySystematic(sys) ) {
2727 sysInfo.affectsKinematics = true;
2728 sysInfo.affectsType = SystObjType::Muon;
2729 }
2730 }
2731 if (!m_elecEfficiencySFTool_trig_singleLep.empty()) {
2732 if ( m_elecEfficiencySFTool_trig_singleLep->isAffectedBySystematic(sys) ) {
2733 sysInfo.affectsWeights = true;
2734 sysInfo.affectsType = SystObjType::Electron;
2735 sysInfo.affectedWeights.insert(ST::Weights::Electron::Trigger);
2736 }
2737 }
2738 if (!m_elecEfficiencySFTool_trigEff_singleLep.empty()) {
2739 if ( m_elecEfficiencySFTool_trigEff_singleLep->isAffectedBySystematic(sys) ) {
2740 sysInfo.affectsWeights = true;
2741 sysInfo.affectsType = SystObjType::Electron;
2742 sysInfo.affectedWeights.insert(ST::Weights::Electron::Trigger);
2743 }
2744 }
2745 if (!m_muonEfficiencySFTool.empty()) {
2746 if ( m_muonEfficiencySFTool->isAffectedBySystematic(sys) ) {
2747 sysInfo.affectsWeights = true;
2748 sysInfo.affectsType = SystObjType::Muon;
2749 sysInfo.affectedWeights.insert(ST::Weights::Muon::Reconstruction);
2750 }
2751 }
2752 if (!m_muonEfficiencyBMHighPtSFTool.empty()) {
2753 if ( m_muonEfficiencyBMHighPtSFTool->isAffectedBySystematic(sys) ) {
2754 sysInfo.affectsWeights = true;
2755 sysInfo.affectsType = SystObjType::Muon;
2756 sysInfo.affectedWeights.insert(ST::Weights::Muon::Reconstruction);
2757 }
2758 }
2759 if (!m_muonTTVAEfficiencySFTool.empty()) {
2760 if ( m_muonTTVAEfficiencySFTool->isAffectedBySystematic(sys) ) {
2761 sysInfo.affectsWeights = true;
2762 sysInfo.affectsType = SystObjType::Muon;
2763 sysInfo.affectedWeights.insert(ST::Weights::Muon::Reconstruction);
2764 }
2765 }
2766 if (!m_muonIsolationSFTool.empty()) {
2767 if ( m_muonIsolationSFTool->isAffectedBySystematic(sys) ) {
2768 sysInfo.affectsWeights = true;
2769 sysInfo.affectsType = SystObjType::Muon;
2770 sysInfo.affectedWeights.insert(ST::Weights::Muon::Isolation);
2771 }
2772 }
2773 if (!m_muonTriggerSFTool.empty()) {
2774 if ( m_muonTriggerSFTool->isAffectedBySystematic(sys) ) {
2775 sysInfo.affectsWeights = true;
2776 sysInfo.affectsType = SystObjType::Muon;
2777 sysInfo.affectedWeights.insert(ST::Weights::Muon::Trigger);
2778 }
2779 }
2780 if (!m_elecEfficiencySFTool_reco.empty()) {
2781 if ( m_elecEfficiencySFTool_reco->isAffectedBySystematic(sys) ) {
2782 sysInfo.affectsWeights = true;
2783 sysInfo.affectsType = SystObjType::Electron;
2784 sysInfo.affectedWeights.insert(ST::Weights::Electron::Reconstruction);
2785 }
2786 }
2787 if (!m_elecEfficiencySFTool_id.empty()) {
2788 if ( m_elecEfficiencySFTool_id->isAffectedBySystematic(sys) ) {
2789 sysInfo.affectsWeights = true;
2790 sysInfo.affectsType = SystObjType::Electron;
2791 sysInfo.affectedWeights.insert(ST::Weights::Electron::ID);
2792 }
2793 }
2794 if (!m_trigGlobalEffCorrTool_diLep.empty()) {
2795 if ( m_trigGlobalEffCorrTool_diLep->isAffectedBySystematic(sys) ) {
2796 sysInfo.affectsWeights = true;
2797 sysInfo.affectsType = SystObjType::Electron;
2798 sysInfo.affectedWeights.insert(ST::Weights::Electron::Trigger);
2799 }
2800 }
2801 if (!m_trigGlobalEffCorrTool_multiLep.empty()) {
2802 if ( m_trigGlobalEffCorrTool_multiLep->isAffectedBySystematic(sys) ) {
2803 sysInfo.affectsWeights = true;
2804 sysInfo.affectsType = SystObjType::Electron;
2805 sysInfo.affectedWeights.insert(ST::Weights::Electron::Trigger);
2806 }
2807 }
2808 if (!m_elecEfficiencySFTool_iso.empty() ) {
2809 if ( m_elecEfficiencySFTool_iso->isAffectedBySystematic(sys) ) {
2810 sysInfo.affectsWeights = true;
2811 sysInfo.affectsType = SystObjType::Electron;
2812 sysInfo.affectedWeights.insert(ST::Weights::Electron::Isolation);
2813 }
2814 }
2815 if (!m_elecEfficiencySFTool_isoHighPt.empty() ) {
2816 if ( m_elecEfficiencySFTool_isoHighPt->isAffectedBySystematic(sys) ) {
2817 sysInfo.affectsWeights = true;
2818 sysInfo.affectsType = SystObjType::Electron;
2819 sysInfo.affectedWeights.insert(ST::Weights::Electron::Isolation);
2820 }
2821 }
2822 if (!m_egammaCalibTool.empty()) {
2823 if ( m_egammaCalibTool->isAffectedBySystematic(sys) ) {
2824 sysInfo.affectsKinematics = true;
2825 if (sys.basename().compare(0, 3, "EG_") == 0) {
2826 sysInfo.affectsType = SystObjType::Egamma;
2827 } else if (sys.basename().compare(0, 3, "PH_") == 0) {
2828 sysInfo.affectsType = SystObjType::Photon;
2829 } else if (sys.basename().compare(0, 3, "EL_") == 0) {
2830 sysInfo.affectsType = SystObjType::Electron;
2831 }
2832 }
2833 }
2834 if (!isData() && !m_isoCorrTool.empty()) {
2835 if (m_isoCorrTool->isAffectedBySystematic(sys)){
2836 sysInfo.affectsWeights = false;
2837 sysInfo.affectsKinematics = true;
2838 sysInfo.affectsType = SystObjType::Photon;
2839 }
2840 }
2841 if (!isData() && !m_photonEfficiencySFTool.empty()) {
2842 if (m_photonEfficiencySFTool->isAffectedBySystematic(CP::SystematicVariation(sys.basename(), CP::SystematicVariation::CONTINUOUS)) ) {
2843 sysInfo.affectsWeights = true;
2844 sysInfo.affectsType = SystObjType::Photon;
2845 sysInfo.affectedWeights.insert(ST::Weights::Photon::Reconstruction);
2846 }
2847 }
2848 if (!isData() && !m_photonIsolationSFTool.empty()) {
2849 if (m_photonIsolationSFTool->isAffectedBySystematic(sys)) {
2850 sysInfo.affectsWeights = true;
2851 sysInfo.affectsType = SystObjType::Photon;
2852 sysInfo.affectedWeights.insert(ST::Weights::Photon::Isolation);
2853 }
2854 }
2855 if (!isData() && !m_photonTriggerSFTool.empty()) {
2856 if (m_photonTriggerSFTool->isAffectedBySystematic(sys)) {
2857 sysInfo.affectsWeights = true;
2858 sysInfo.affectsType = SystObjType::Photon;
2859 sysInfo.affectedWeights.insert(ST::Weights::Photon::Trigger);
2860 }
2861 }
2862 if (!m_trigGlobalEffCorrTool_diPhoton.empty()) {
2863 if ( m_trigGlobalEffCorrTool_diPhoton->isAffectedBySystematic(sys) ) {
2864 sysInfo.affectsWeights = true;
2865 sysInfo.affectsType = SystObjType::Photon;
2866 sysInfo.affectedWeights.insert(ST::Weights::Photon::Trigger);
2867 }
2868 }
2869 if ( !m_btagEffTool.empty() ) {
2870 if ( m_btagEffTool->isAffectedBySystematic(sys) ) {
2871 sysInfo.affectsWeights = true;
2872 sysInfo.affectsType = SystObjType::BTag;
2873 sysInfo.affectedWeights.insert(ST::Weights::Jet::Btag);
2874 }
2875 }
2876 if ( !m_btagEffTool_trkJet.empty() ) {
2877 if ( m_btagEffTool_trkJet->isAffectedBySystematic(sys) ) {
2878 sysInfo.affectsWeights = true;
2879 sysInfo.affectsType = SystObjType::BTag;
2880 sysInfo.affectedWeights.insert(ST::Weights::Jet::Btag_Track);
2881 }
2882 }
2883 if (!m_tauSmearingTool.empty()) {
2884 if ( m_tauSmearingTool->isAffectedBySystematic(sys) ) {
2885 sysInfo.affectsKinematics = true;
2886 sysInfo.affectsType = SystObjType::Tau;
2887 }
2888 }
2889 if (!m_tauEffTool.empty()) {
2890 if ( m_tauEffTool->isAffectedBySystematic(sys) ) {
2891 sysInfo.affectsWeights = true;
2892 sysInfo.affectsType = SystObjType::Tau;
2893 sysInfo.affectedWeights.insert(ST::Weights::Tau::Reconstruction);
2894 }
2895 }
2896 for(const auto &tool : m_tauTrigEffTool) {
2897 if(tool->isAffectedBySystematic(sys)) {
2898 sysInfo.affectsWeights = true;
2899 sysInfo.affectsType = SystObjType::Tau;
2900 sysInfo.affectedWeights.insert(ST::Weights::Tau::Trigger);
2901 break;
2902 }
2903 }
2904 if (!m_metSystTool.empty()) {
2905 if ( m_metSystTool->isAffectedBySystematic(sys) ) {
2906 sysInfo.affectsKinematics = true;
2907 switch (met::getSystType(sys)) {
2908 case met::SOFTCALO:
2909 sysInfo.affectsType = SystObjType::MET_CST;
2910 break;
2911 case met::SOFTTRK:
2912 sysInfo.affectsType = SystObjType::MET_TST;
2913 break;
2914 case met::JETTRK:
2915 sysInfo.affectsType = SystObjType::MET_Track;
2916 break;
2917 default:
2918 ATH_MSG_ERROR("Unsupported systematic!");
2919 }
2920 }
2921 }
2922 if (!m_prwTool.empty()) {
2923 if ( m_prwTool->isAffectedBySystematic(sys) ) {
2924 sysInfo.affectsWeights = true;
2925 sysInfo.affectsType = SystObjType::EventWeight;
2926 }
2927 }
2928
2929 if (!m_LRTuncTool.empty()){
2930 if ( m_LRTuncTool->isAffectedBySystematic(sys) ) {
2931 sysInfo.affectsKinematics = true;
2932 sysInfo.affectsType = SystObjType::LRT_Object;
2933 }
2934 }
2935
2936 std::string affectedType;
2937 switch (sysInfo.affectsType) {
2938 case Unknown : affectedType = "UNKNOWN"; break;
2939 case Jet : affectedType = "JET"; break;
2940 case Egamma : affectedType = "EGAMMA"; break;
2941 case Electron : affectedType = "ELECTRON"; break;
2942 case Photon : affectedType = "PHOTON"; break;
2943 case Muon : affectedType = "MUON"; break;
2944 case Tau : affectedType = "TAU"; break;
2945 case BTag : affectedType = "BTAG"; break;
2946 case MET_TST : affectedType = "MET_TST"; break;
2947 case MET_CST : affectedType = "MET_CST"; break;
2948 case MET_Track : affectedType = "MET_Track"; break;
2949 case EventWeight : affectedType = "EVENT WEIGHT"; break;
2950 case LRT_Object : affectedType = "LRT_OBJECT"; break;
2951 }
2952
2953 ATH_MSG_VERBOSE("Variation " << sys.name() << " affects "
2954 << ( sysInfo.affectsWeights ? "weights " : "" )
2955 << ( sysInfo.affectsKinematics ? "kinematics " : "" )
2956 << "for " << affectedType );
2957
2958 return sysInfo;
2959
2960}
ST::Weights::Tau::Reconstruction
static const unsigned int Reconstruction
Definition ISUSYObjDef_xAODTool.h:119
ST::Weights::Tau::Trigger
static const unsigned int Trigger
Definition ISUSYObjDef_xAODTool.h:120
met::getSystType
SystType getSystType(const CP::SystematicVariation &systematic)
Definition IMETSystematicsTool.h:55
xAOD::Unknown
@ Unknown
Track fitter not defined.
Definition TrackingPrimitives.h:37
xAOD::Egamma
Egamma_v1 Egamma
Definition of the current "egamma version".
Definition Egamma.h:17

◆ getSystInfoList()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2612 of file SUSYObjDef_xAOD.cxx.

2612 {
2613 if (!m_tool_init) {
2614 ATH_MSG_ERROR("SUSYTools was not initialized!!");
2615 return vector<ST::SystInfo>();
2616 }
2617
2618 ATH_MSG_INFO("Extracting systematics info list");
2619
2620 // Now we can look at systematics:
2621 const CP::SystematicRegistry& registry = CP::SystematicRegistry::getInstance();
2622 const CP::SystematicSet& recommendedSystematics = registry.recommendedSystematics();
2623
2624 vector<SystInfo> sysInfoList;
2625 sysInfoList.reserve(recommendedSystematics.size() * 2); // allow for continuous systematics
2626
2627 // this is the nominal set
2628 SystInfo infodef;
2629 infodef.affectsKinematics = false;
2630 infodef.affectsWeights = false;
2631 infodef.affectsType = Unknown;
2632 infodef.affectedWeights.clear();
2633 sysInfoList.push_back(infodef);
2634
2635
2636 // add all recommended systematics
2637 for (const auto& systSet : CP::make_systematics_vector(recommendedSystematics)) {
2638 for (const auto& sys : systSet) {
2639 sysInfoList.push_back(getSystInfo(sys));
2640 }
2641 }
2642
2643 ATH_MSG_INFO("Returning list of " << sysInfoList.size() << " systematic variations");
2644 return sysInfoList;
2645}
CP::SystematicRegistry::getInstance
static SystematicRegistry & getInstance()
Get the singleton instance of the registry for the curren thread.
Definition SystematicRegistry.cxx:25
ST::SUSYObjDef_xAOD::getSystInfo
ST::SystInfo getSystInfo(const CP::SystematicVariation &sys) const override final
Definition SUSYObjDef_xAOD.cxx:2647
CP::make_systematics_vector
std::vector< CP::SystematicSet > make_systematics_vector(const SystematicSet &systematics)
utility functions for working with systematics
Definition SystematicsUtil.cxx:25

◆ getTauConfig()

StatusCode 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 1922 of file SUSYObjDef_xAOD.cxx.

1922 {
1923
1924 if(tauConfigPath.empty()) return StatusCode::FAILURE;
1925
1926 TEnv rEnv;
1927 auto filename = PathResolverFindCalibFile(tauConfigPath);
1928 if ( rEnv.ReadFile(filename.c_str(), kEnvAll) ) {
1929 ATH_MSG_ERROR( "Error while reading tau config file : " << filename );
1930 ATH_MSG_ERROR( "Find examples at: https://gitlab.cern.ch/atlas/athena/-/tree/main/PhysicsAnalysis/Algorithms/TauAnalysisAlgorithms/data");
1931 return StatusCode::FAILURE;
1932 } else {
1933 ATH_MSG_DEBUG( "Successfully read tau config file : " << filename );
1934 }
1935
1936 std::vector<std::string> cuts;
1937 if (rEnv.Defined("SelectionCuts")) {
1938 cuts = split(rEnv.GetValue("SelectionCuts", " "), " ");
1939 } else {
1940 auto *l = rEnv.GetTable();
1941 for( Int_t i = 0; i < l->GetEntries(); ++i ) {
1942 cuts.push_back( l->At(i)->GetName() );
1943 }
1944 }
1945
1946 //default OR settings
1947 eleOLR=false;
1948 muOLR=false;
1949 muVeto=false;
1950
1951 static const std::string trueBool = "TRUE";
1952
1953 // Now find the pT and eta window
1954 std::vector<std::string> v_pT_window;
1955 std::vector<std::string> v_eta_window;
1956 pT_window.clear();
1957 eta_window.clear();
1958 float pT_min = -99.0;
1959 float pT_max = -99.0;
1960 float eta_min = -99.0;
1961 float eta_max = -99.0;
1962 for (const auto& cut : cuts) {
1963 if(cut == "PtRegion") {
1964 v_pT_window = split(rEnv.GetValue("PtRegion", ""), ";");
1965 std::transform(std::begin(v_pT_window),
1966 std::end(v_pT_window),
1967 std::back_inserter(pT_window),
1968 [](const std::string& s) { return std::stof(s); }
1969 );
1970 } else if (cut == "PtMin") {
1971 pT_min = rEnv.GetValue("PtMin", NAN);
1972 } else if (cut == "PtMax") {
1973 pT_max = rEnv.GetValue("PtMax", NAN);
1974 } else if (cut == "AbsEtaRegion") {
1975 v_eta_window = split(rEnv.GetValue("AbsEtaRegion", ""), ";");
1976 std::transform(std::begin(v_eta_window),
1977 std::end(v_eta_window),
1978 std::back_inserter(eta_window),
1979 [](const std::string& s) { return std::stof(s); }
1980 );
1981 } else if (cut == "AbsEtaMin") {
1982 eta_min = rEnv.GetValue("AbsEtaMin", NAN);
1983 } else if (cut == "AbsEtaMax") {
1984 eta_max = rEnv.GetValue("AbsEtaMax", NAN);
1985 }
1986
1987 //OR settings
1988 else if (cut == "EleOLR"){
1989 eleOLR = (rEnv.GetValue("EleOLR", "FALSE") == trueBool);
1990 }
1991 else if (cut == "MuonVeto"){
1992 muVeto = (rEnv.GetValue("MuonVeto", "FALSE") == trueBool);
1993 }
1994 else if (cut == "MuonOLR"){
1995 muOLR = (rEnv.GetValue("MuonOLR", "FALSE") == trueBool);
1996 }
1997 }
1998
1999 if(pT_window.empty()) {
2000 if(pT_min == pT_min) {
2001 // fails on NaN
2002 pT_window.push_back(pT_min);
2003 } else {
2004 pT_window.push_back(-std::numeric_limits<float>::infinity());
2005 }
2006
2007 if(pT_max == pT_max) {
2008 // fails on NaN
2009 pT_window.push_back(pT_max);
2010 } else {
2011 pT_window.push_back(std::numeric_limits<float>::infinity());
2012 }
2013 }
2014
2015 if(eta_window.empty()) {
2016 if(eta_min == eta_min) {
2017 // fails on NaN
2018 eta_window.push_back(eta_min);
2019 } else {
2020 eta_window.push_back(-std::numeric_limits<float>::infinity());
2021 }
2022
2023 if(eta_max == eta_max) {
2024 // fails on NaN
2025 eta_window.push_back(eta_max);
2026 } else {
2027 eta_window.push_back(std::numeric_limits<float>::infinity());
2028 }
2029 }
2030
2031 return StatusCode::SUCCESS;
2032}
PrintTrkAnaSummary.l
l
Printing final latex table to .tex output file.
Definition PrintTrkAnaSummary.py:370

◆ 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 xAOD::ShallowCopyResult_t<xAOD::TauJetContainer> shallowcopy = xAOD::shallowCopy(*taus);
52 copy = shallowcopy.first.get();
53 copyaux = shallowcopy.second.get();
54 bool setLinks = xAOD::setOriginalObjectLink(*taus, *copy);
55 if (!setLinks) {
56 ATH_MSG_WARNING("Failed to set original object links on " << taukey);
57 }
58 if (recordSG) {
59 ATH_CHECK( evtStore()->record(std::move(shallowcopy.first), "STCalib" + taukey + m_currentSyst.name()) );
60 ATH_CHECK( evtStore()->record(std::move(shallowcopy.second), "STCalib" + taukey + m_currentSyst.name() + "Aux.") );
61 } else {
62 ATH_MSG_ERROR("Shallow copy not recorded in StoreGate!");
63 return StatusCode::FAILURE;
64 }
65 } else { // use the user-supplied collection instead
66 ATH_MSG_DEBUG("Not retrieving tau collecton, using existing one provided by user");
67 taus=copy;
68 }
69
70 for (const auto tau : *copy) {
71 ATH_CHECK( this->FillTau(*tau) );
72 this->IsSignalTau(*tau, m_tauPt, m_tauEta);
73 }
74
75 return StatusCode::SUCCESS;
76}
taus
static Double_t taus
Definition LArPhysWaveHECTool.cxx:37
ST::SUSYObjDef_xAOD::FillTau
StatusCode FillTau(xAOD::TauJet &input) override final
Definition Taus.cxx:80
ST::SUSYObjDef_xAOD::IsSignalTau
bool IsSignalTau(const xAOD::TauJet &input, const float ptcut, const float etacut) const override final
Definition Taus.cxx:115
xAOD::TauJetContainer
TauJetContainer_v3 TauJetContainer
Definition of the current "taujet container version".
Definition TauJetContainer.h:17

◆ 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 201 of file Taus.cxx.

201 {
202
203 double eff(1.);
204
205 auto map_it = m_tau_trig_support.find(trigExpr);
206 if (map_it == m_tau_trig_support.end()) {
207 ATH_MSG_WARNING("The trigger item requested (" << trigExpr << ") is not supported! Please check. Setting SF to 1.");
208 return eff;
209 }
210
211 // trigger matching (dR=0.2)
212 std::vector<std::string> chains;
213 for (auto part : std::views::split(map_it->second, ',')) chains.emplace_back(&*part.begin(), std::ranges::distance(part));
214 bool match = false;
215 for (const std::string& chain : chains)
216 if (m_trigMatchingTool->match({&tau}, chain, 0.2)) {
217 match = true;
218 break;
219 }
220 if (!match) {
221 ATH_MSG_VERBOSE("Tau did not match trigger " << trigExpr);
222 return eff;
223 }
224
225 int trigIdx = std::distance(std::begin(m_tau_trig_support), map_it);
226 if (m_tauTrigEffTool.at(trigIdx)->getEfficiencyScaleFactor(tau, eff) != CP::CorrectionCode::Ok) {
227 ATH_MSG_ERROR("Some problem found to retrieve SF for trigger item requested (" << trigExpr << ")");
228 eff = -99;
229 }
230
231 return eff;
232}
ST::SUSYObjDef_xAOD::m_tau_trig_support
std::map< std::string, std::string > m_tau_trig_support
Definition SUSYObjDef_xAOD.h:650
match
bool match(std::string s1, std::string s2)
match the individual directories of two strings
Definition hcg.cxx:359

◆ 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 630 of file Electrons.cxx.

630 {
631 float sf(1.);
632
633 for (const xAOD::Electron* electron : electrons) {
634 if (!acc_passOR(*electron)) continue;
635 if (acc_signal(*electron)) { sf *= this->GetSignalElecSF(*electron, recoSF, idSF, triggerSF, isoSF, trigExpr, ecidsSF, cidSF); }
636 else { this->GetSignalElecSF(*electron, recoSF, idSF, triggerSF, isoSF, trigExpr, ecidsSF, cidSF); }
637 }
638
639 return sf;
640}
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:423

◆ 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 643 of file Electrons.cxx.

643 {
644 float sf(1.);
645
646 //Set the new systematic variation
647 StatusCode ret(StatusCode::SUCCESS);
648 if(!m_elecEfficiencySFTool_reco.empty()){
649 ret = m_elecEfficiencySFTool_reco->applySystematicVariation(systConfig);
650 if (ret != StatusCode::SUCCESS) {
651 ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (reco) for systematic var. " << systConfig.name() );
652 }
653 }
654
655 if(!m_elecEfficiencySFTool_id.empty()){
656 ret = m_elecEfficiencySFTool_id->applySystematicVariation(systConfig);
657 if (ret != StatusCode::SUCCESS) {
658 ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (id) for systematic var. " << systConfig.name() );
659 }
660 }
661
662 if(!m_elecEfficiencySFTool_trig_singleLep.empty()){
663 ret = m_elecEfficiencySFTool_trig_singleLep->applySystematicVariation(systConfig);
664 if (ret != StatusCode::SUCCESS) {
665 ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (trigger) for systematic var. " << systConfig.name() );
666 }
667 }
668
669 if(!m_elecEfficiencySFTool_iso.empty()){
670 ret = m_elecEfficiencySFTool_iso->applySystematicVariation(systConfig);
671 if (ret != StatusCode::SUCCESS) {
672 ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (iso) for systematic var. " << systConfig.name() );
673 }
674 }
675
676 if(!m_elecEfficiencySFTool_isoHighPt.empty()){
677 ret = m_elecEfficiencySFTool_isoHighPt->applySystematicVariation(systConfig);
678 if (ret != StatusCode::SUCCESS) {
679 ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (iso high-pt) for systematic var. " << systConfig.name() );
680 }
681 }
682
683 if(!m_elecChargeEffCorrTool.empty()){
684 ret = m_elecChargeEffCorrTool->applySystematicVariation(systConfig);
685 if (ret != StatusCode::SUCCESS) {
686 ATH_MSG_ERROR("Cannot configure ElectronChargeEfficiencyCorrectionTool for systematic var. " << systConfig.name() );
687 }
688 }
689
690
691 //Get the total SF for new config
692 sf = GetTotalElectronSF(electrons, recoSF, idSF, triggerSF, isoSF, trigExpr, ecidsSF, cidSF);
693
694 //Roll back to default
695 if(!m_elecEfficiencySFTool_reco.empty()){
696 ret = m_elecEfficiencySFTool_reco->applySystematicVariation(m_currentSyst);
697 if (ret != StatusCode::SUCCESS) {
698 ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (reco) back to default.");
699 }
700 }
701
702 if(!m_elecEfficiencySFTool_id.empty()){
703 ret = m_elecEfficiencySFTool_id->applySystematicVariation(m_currentSyst);
704 if (ret != StatusCode::SUCCESS) {
705 ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (id) back to default.");
706 }
707 }
708
709 if(!m_elecEfficiencySFTool_trig_singleLep.empty()){
710 ret = m_elecEfficiencySFTool_trig_singleLep->applySystematicVariation(m_currentSyst);
711 if (ret != StatusCode::SUCCESS) {
712 ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (trigger) back to default.");
713 }
714 }
715
716 if(!m_elecEfficiencySFTool_iso.empty()){
717 ret = m_elecEfficiencySFTool_iso->applySystematicVariation(m_currentSyst);
718 if (ret != StatusCode::SUCCESS) {
719 ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (iso) back to default.");
720 }
721 }
722
723 if(!m_elecEfficiencySFTool_isoHighPt.empty()){
724 ret = m_elecEfficiencySFTool_isoHighPt->applySystematicVariation(m_currentSyst);
725 if (ret != StatusCode::SUCCESS) {
726 ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (iso high-pt) back to default.");
727 }
728 }
729
730 if(!m_elecChargeEffCorrTool.empty()){
731 ret = m_elecChargeEffCorrTool->applySystematicVariation(m_currentSyst);
732 if (ret != StatusCode::SUCCESS) {
733 ATH_MSG_ERROR("Cannot configure ElectronChargeEfficiencyCorrectionTool back to default.");
734 }
735 }
736
737 return sf;
738}
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:630

◆ 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 1148 of file Jets.cxx.

1148 {
1149
1150 double totalSF = 1.;
1151 if (btagSF) totalSF *= BtagSF(jets);
1152
1153 if (jvtSF && m_applyJVTCut) totalSF *= JVT_SF(jets);
1154
1155 if (fjvtSF) totalSF *= FJVT_SF(jets);
1156
1157 return totalSF;
1158 }
ST::SUSYObjDef_xAOD::JVT_SF
double JVT_SF(const xAOD::JetContainer *jets) override final
Definition Jets.cxx:1006

◆ 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 1161 of file Jets.cxx.

1161 {
1162
1163 double totalSF = 1.;
1164 if (btagSF) totalSF *= BtagSFsys(jets, systConfig);
1165
1166 if (jvtSF && m_applyJVTCut) totalSF *= JVT_SFsys(jets, systConfig);
1167
1168 if (fjvtSF) totalSF *= FJVT_SFsys(jets, systConfig);
1169
1170 return totalSF;
1171 }
ST::SUSYObjDef_xAOD::JVT_SFsys
double JVT_SFsys(const xAOD::JetContainer *jets, const CP::SystematicSet &systConfig) override final
Definition Jets.cxx:1053
ST::SUSYObjDef_xAOD::FJVT_SFsys
double FJVT_SFsys(const xAOD::JetContainer *jets, const CP::SystematicSet &systConfig) override final
Definition Jets.cxx:1124
ST::SUSYObjDef_xAOD::BtagSFsys
float BtagSFsys(const xAOD::JetContainer *jets, const CP::SystematicSet &systConfig) override final
Definition Jets.cxx:905

◆ 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 605 of file Muons.cxx.

605 {
606 double sf(1.);
607
608 ConstDataVector<xAOD::MuonContainer> sfmuons(SG::VIEW_ELEMENTS);
609 for (const xAOD::Muon* muon : muons) {
610 if( !acc_passOR(*muon) ) continue;
611 if (acc_signal(*muon)) {
612 sfmuons.push_back(muon);
613 if (recoSF || isoSF) { sf *= this->GetSignalMuonSF(*muon, recoSF, isoSF, bmhptSF); }
614 } else { // decorate baseline muons as well
615 if (recoSF || isoSF) { this->GetSignalMuonSF(*muon, recoSF, isoSF, bmhptSF, false); } //avoid OVR warnings in this case
616 }
617 }
618
619 sf *= GetTotalMuonTriggerSF(*sfmuons.asDataVector(), trigExpr);
620
621 return sf;
622}
ST::SUSYObjDef_xAOD::GetTotalMuonTriggerSF
double GetTotalMuonTriggerSF(const xAOD::MuonContainer &sfmuons, const std::string &trigExpr) override final
Definition Muons.cxx:550
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:483

◆ 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 625 of file Muons.cxx.

625 {
626 double sf(1.);
627 //Set the new systematic variation
628 StatusCode ret = m_muonEfficiencySFTool->applySystematicVariation(systConfig);
629 if ( ret != StatusCode::SUCCESS) {
630 ATH_MSG_ERROR("Cannot configure MuonEfficiencyScaleFactors for systematic var. " << systConfig.name() );
631 }
632
633 ret = m_muonEfficiencyBMHighPtSFTool->applySystematicVariation(systConfig);
634 if ( ret != StatusCode::SUCCESS) {
635 ATH_MSG_ERROR("Cannot configure MuonBadMuonHighPtScaleFactors for systematic var. " << systConfig.name() );
636 }
637
638 ret = m_muonTTVAEfficiencySFTool->applySystematicVariation(systConfig);
639 if ( ret != StatusCode::SUCCESS) {
640 ATH_MSG_ERROR("Cannot configure MuonTTVAEfficiencyScaleFactors for systematic var. " << systConfig.name() );
641 }
642
643 ret = m_muonIsolationSFTool->applySystematicVariation(systConfig);
644 if ( ret != StatusCode::SUCCESS) {
645 ATH_MSG_ERROR("Cannot configure MuonIsolationScaleFactors for systematic var. " << systConfig.name() );
646 }
647
648 ret = m_muonHighPtIsolationSFTool->applySystematicVariation(systConfig);
649 if ( ret != StatusCode::SUCCESS) {
650 ATH_MSG_ERROR("Cannot configure MuonHighPtIsolationScaleFactors for systematic var. " << systConfig.name() );
651 }
652
653 ret = m_muonTriggerSFTool->applySystematicVariation(systConfig);
654 if ( ret != StatusCode::SUCCESS) {
655 ATH_MSG_ERROR("Cannot configure MuonTriggerScaleFactors for systematic var. " << systConfig.name() );
656 }
657
658 ret = m_trigGlobalEffCorrTool_diLep->applySystematicVariation(systConfig);
659 if (ret != StatusCode::SUCCESS) {
660 ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (trigger) for systematic var. " << systConfig.name() );
661 }
662
663 ret = m_trigGlobalEffCorrTool_multiLep->applySystematicVariation(systConfig);
664 if (ret != StatusCode::SUCCESS) {
665 ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (trigger) for systematic var. " << systConfig.name() );
666 }
667
668 sf = GetTotalMuonSF(muons, recoSF, isoSF, trigExpr, bmhptSF);
669
670 //Roll back to default
671 ret = m_muonEfficiencySFTool->applySystematicVariation(m_currentSyst);
672 if ( ret != StatusCode::SUCCESS) {
673 ATH_MSG_ERROR("Cannot configure MuonEfficiencyScaleFactors back to default.");
674 }
675
676 ret = m_muonEfficiencyBMHighPtSFTool->applySystematicVariation(m_currentSyst);
677 if ( ret != StatusCode::SUCCESS) {
678 ATH_MSG_ERROR("Cannot configure MuonBadMuonHighPtScaleFactors back to default.");
679 }
680
681 ret = m_muonTTVAEfficiencySFTool->applySystematicVariation(m_currentSyst);
682 if ( ret != StatusCode::SUCCESS) {
683 ATH_MSG_ERROR("Cannot configure MuonTTVAEfficiencyScaleFactors back to default.");
684 }
685
686 ret = m_muonIsolationSFTool->applySystematicVariation(m_currentSyst);
687 if ( ret != StatusCode::SUCCESS) {
688 ATH_MSG_ERROR("Cannot configure MuonIsolationScaleFactors back to default.");
689 }
690
691 ret = m_muonHighPtIsolationSFTool->applySystematicVariation(m_currentSyst);
692 if ( ret != StatusCode::SUCCESS) {
693 ATH_MSG_ERROR("Cannot configure MuonIsolationScaleFactors back to default.");
694 }
695
696 ret = m_muonTriggerSFTool->applySystematicVariation(m_currentSyst);
697 if ( ret != StatusCode::SUCCESS) {
698 ATH_MSG_ERROR("Cannot configure MuonTriggerScaleFactors back to default.");
699 }
700
701 ret = m_trigGlobalEffCorrTool_diLep->applySystematicVariation(m_currentSyst);
702 if (ret != StatusCode::SUCCESS) {
703 ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (trigger) back to default.");
704 }
705
706 ret = m_trigGlobalEffCorrTool_multiLep->applySystematicVariation(m_currentSyst);
707 if (ret != StatusCode::SUCCESS) {
708 ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (trigger) back to default.");
709 }
710
711 return sf;
712}
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:605

◆ GetTotalMuonTriggerSF()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 550 of file Muons.cxx.

550 {
551
552 if (trigExpr.empty() || sfmuons.empty()) return 1.;
553
554
555 double trig_sf = 1.;
556
557 int mulegs = 0;
558 const char *tmp = trigExpr.c_str();
559 while( (tmp = strstr(tmp, "mu")) ){
560 mulegs++;
561 tmp++;
562 }
563
564 bool isdimuon = (trigExpr.find("2mu") != std::string::npos);
565 bool isOR = (trigExpr.find("OR") != std::string::npos);
566
567 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
568 if (m_muonTriggerSFTool->getTriggerScaleFactor( sfmuons, trig_sf, trigExpr ) == CP::CorrectionCode::Ok) {
569 ATH_MSG_DEBUG( "MuonTrig ScaleFactor " << trig_sf );
570 }
571 else{
572 ATH_MSG_DEBUG( "MuonTrig FAILED SOMEHOW");
573 }
574 }
575 else if(mulegs!=2 && isOR){ //Case 2: not supported. Not efficiency defined for (at least) one leg. Sorry...
576 ATH_MSG_WARNING( "SF for " << trigExpr << " are only supported for two muon events!");
577 }
578 else{ //Case 3: let's go the hard way...
579 //Following https://twiki.cern.ch/twiki/bin/view/Atlas/TrigMuonEfficiency
580 std::string newtrigExpr = TString(trigExpr).Copy().ReplaceAll("HLT_2","").Data();
581
582 //redefine dimuon triggers here (2mu14 --> mu14_mu14)
583 if (isdimuon) { newtrigExpr += "_"+newtrigExpr; }
584 newtrigExpr = std::regex_replace(newtrigExpr, std::regex("HLT_"), "");
585
586 for (auto part : std::views::split(newtrigExpr, '_')) {
587 std::string mutrig(&*part.begin(), std::ranges::distance(part));
588 double dataFactor = 1.;
589 double mcFactor = 1.;
590
591 for (const xAOD::Muon* mu : sfmuons) {
592 // No need for additional trigger matching
593 dataFactor *= (1 - GetMuonTriggerEfficiency(*mu, "HLT_"+mutrig, true));
594 mcFactor *= (1 - GetMuonTriggerEfficiency(*mu, "HLT_"+mutrig, false));
595 }
596 if( (1-mcFactor) > 0. )
597 trig_sf *= (1-dataFactor)/(1-mcFactor);
598 }
599 }
600
601 return trig_sf;
602}
ST::SUSYObjDef_xAOD::GetMuonTriggerEfficiency
double GetMuonTriggerEfficiency(const xAOD::Muon &mu, const std::string &trigExpr, const bool isdata=false) override final
Definition Muons.cxx:536

◆ 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 323 of file Photons.cxx.

324{
325 double sf(1.);
326
327 for (const xAOD::Photon* photon : photons) {
328 if (acc_signal(*photon) && acc_passOR(*photon)) { sf *= this->GetSignalPhotonSF(*photon, effSF, isoSF, triggerSF); }
329 }
330
331 return sf;
332}
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:209

◆ 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 335 of file Photons.cxx.

336{
337 double sf(1.);
338
339 for (const xAOD::Photon* photon : photons) {
340 if (acc_signal(*photon) && acc_passOR(*photon)) { sf *= this->GetSignalPhotonSFsys(*photon, systConfig, effSF, isoSF, triggerSF); }
341 }
342
343 return sf;
344}
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:250

◆ 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 235 of file Taus.cxx.

235 {
236
237 double sf(1.);
238
239 for (const xAOD::TauJet* tau : taus) {
240 // check existence of OR information
241 if (!acc_passOR.isAvailable(*tau)) {
242 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!");
243 break;
244 }
245
246 // Call this for all taus, which will add the decoration
247 double tmpSF = GetSignalTauSF(*tau, idSF, triggerSF, trigExpr);
248 if (acc_signal(*tau) && acc_passOR(*tau)) {
249 sf *= tmpSF;
250 }
251 }
252
253 return sf;
254}

◆ 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 257 of file Taus.cxx.

257 {
258 double sf(1.);
259
260 //Set the new systematic variation
261 StatusCode ret = m_tauEffTool->applySystematicVariation(systConfig);
262 if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure TauEfficiencyCorrectionsTool for systematic var. " << systConfig.name() ); }
263
264 for (auto& tool : m_tauTrigEffTool) {
265 ret = tool->applySystematicVariation(systConfig);
266 if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure " << tool->name() << " for systematic var. " << systConfig.name()); }
267 }
268
269 sf = GetTotalTauSF(taus, idSF, triggerSF, trigExpr);
270
271 //Roll back to default
272 ret = m_tauEffTool->applySystematicVariation(m_currentSyst);
273 if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure TauEfficiencyCorrectionsTool back to default"); }
274
275 for (auto& tool : m_tauTrigEffTool) {
276 ret = tool->applySystematicVariation(m_currentSyst);
277 if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure " << tool->name() << " back to default"); }
278 }
279
280 return sf;
281}
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:235

◆ 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 173 of file Jets.cxx.

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

◆ 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");
187 ConstDataVector<xAOD::ElectronContainer> metelectron(SG::VIEW_ELEMENTS);
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");
197 ConstDataVector<xAOD::MuonContainer> metmuon(SG::VIEW_ELEMENTS);
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");
225 if ( m_metSystTool->applyCorrection(*met[m_jetTerm],metHelper) != CP::CorrectionCode::Ok )
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 309 of file Trigger.cxx.

309 {
310 return m_trigDecTool->getChainGroup(tr_item);
311}

◆ GetTriggerFeatures()

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

Definition at line 420 of file Trigger.cxx.

421 {
422 return m_trigDecTool->features(chainName,condition);
423 }

◆ 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 580 of file Trigger.cxx.

580 {
581
582 double trig_eff(1.);
583 double trig_eff_data(1.);
584
585 if (trigExpr!="multiLepton" && trigExpr!="diLepton") {
586 ATH_MSG_ERROR( "Failed to retrieve multi-lepton trigger efficiency");
587 return trig_eff;
588 }
589
590 std::vector<const xAOD::Electron*> elec_trig;
591 for (const xAOD::Electron* electron : electrons) {
592 if (!acc_passOR(*electron)) continue;
593 if (!acc_signal(*electron)) continue;
594 elec_trig.push_back(electron);
595 }
596
597 std::vector<const xAOD::Muon*> muon_trig;
598 for (const xAOD::Muon* muon : muons) {
599 if (!acc_passOR(*muon)) continue;
600 if (!acc_signal(*muon)) continue;
601 muon_trig.push_back(muon);
602 }
603
604 bool matched = false;
605 if ((elec_trig.size()+muon_trig.size())>1 && trigExpr=="diLepton") {
606 if ( m_trigGlobalEffCorrTool_diLep->checkTriggerMatching( matched, elec_trig, muon_trig) != CP::CorrectionCode::Ok ) {
607 ATH_MSG_ERROR ("trigGlobEffCorrTool::Trigger matching could not be checked, interrupting execution.");
608 }
609 } else if ((elec_trig.size()+muon_trig.size())>2 && trigExpr=="multiLepton") {
610 if ( m_trigGlobalEffCorrTool_multiLep->checkTriggerMatching( matched, elec_trig, muon_trig) != CP::CorrectionCode::Ok ) {
611 ATH_MSG_ERROR ("trigGlobEffCorrTool::Trigger matching could not be checked, interrupting execution.");
612 }
613 }
614
615 CP::CorrectionCode result;
616 if ((elec_trig.size()+muon_trig.size())>1 && trigExpr=="diLepton" && matched) {
617 result = m_trigGlobalEffCorrTool_diLep->getEfficiency( elec_trig, muon_trig, trig_eff_data, trig_eff);
618 }
619 else if ((elec_trig.size()+muon_trig.size())>2 && trigExpr=="multiLepton" && matched) {
620 result = m_trigGlobalEffCorrTool_multiLep->getEfficiency( elec_trig, muon_trig, trig_eff_data, trig_eff);
621 }
622
623 switch (result) {
624 case CP::CorrectionCode::Error:
625 ATH_MSG_ERROR( "Failed to retrieve multi-lepton trigger efficiency");
626 return 1.;
627 case CP::CorrectionCode::OutOfValidityRange:
628 ATH_MSG_VERBOSE( "OutOfValidityRange found for multi-lepton trigger efficiency");
629 return 1.;
630 default:
631 break;
632 }
633
634 if (isData()) return trig_eff_data;
635 else return trig_eff;
636}

◆ 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 641 of file Trigger.cxx.

641 {
642
643 double trig_eff(1.);
644 double trig_eff_data(1.);
645
646 if (trigExpr!="diPhoton") {
647 ATH_MSG_ERROR( "Failed to retrieve diphoton trigger efficiency");
648 return trig_eff;
649 }
650
651 std::vector<const xAOD::Photon*> ph_trig;
652 for (const xAOD::Photon* photon : photons) {
653 if (!acc_passOR(*photon)) continue;
654 if (!acc_signal(*photon)) continue;
655 ph_trig.push_back(photon);
656 }
657
658 CP::CorrectionCode result;
659 if (ph_trig.size()>1) {
660 result = m_trigGlobalEffCorrTool_diPhoton->getEfficiency(ph_trig, trig_eff_data, trig_eff);
661 }
662
663 switch (result) {
664 case CP::CorrectionCode::Error:
665 ATH_MSG_ERROR( "Failed to retrieve diphoton trigger efficiency");
666 return 1.;
667 case CP::CorrectionCode::OutOfValidityRange:
668 ATH_MSG_VERBOSE( "OutOfValidityRange found for diphoton trigger efficiency");
669 return 1.;
670 default:
671 break;
672 }
673
674 if (isData()) return trig_eff_data;
675 else return trig_eff;
676}

◆ 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 425 of file Trigger.cxx.

425 {
426
427 double trig_sf(1.);
428
429 if (trigExpr!="multiLepton" && trigExpr!="diLepton") {
430 ATH_MSG_ERROR( "Failed to retrieve multi-lepton trigger SF");
431 return trig_sf;
432 }
433
434 std::vector<const xAOD::Electron*> elec_trig;
435 for (const xAOD::Electron* electron : electrons) {
436 if (!acc_passOR(*electron)) continue;
437 if (!acc_signal(*electron)) continue;
438 elec_trig.push_back(electron);
439 }
440
441 std::vector<const xAOD::Muon*> muon_trig;
442 for (const xAOD::Muon* muon : muons) {
443 if (!acc_passOR(*muon)) continue;
444 if (!acc_signal(*muon)) continue;
445 muon_trig.push_back(muon);
446 }
447
448 bool matched = false;
449 if ((elec_trig.size()+muon_trig.size())>1 && trigExpr=="diLepton") {
450 if ( m_trigGlobalEffCorrTool_diLep->checkTriggerMatching( matched, elec_trig, muon_trig) != CP::CorrectionCode::Ok ) {
451 ATH_MSG_ERROR ("trigGlobEffCorrTool::Trigger matching could not be checked, interrupting execution.");
452 }
453 } else if ((elec_trig.size()+muon_trig.size())>2 && trigExpr=="multiLepton") {
454 if ( m_trigGlobalEffCorrTool_multiLep->checkTriggerMatching( matched, elec_trig, muon_trig) != CP::CorrectionCode::Ok ) {
455 ATH_MSG_ERROR ("trigGlobEffCorrTool::Trigger matching could not be checked, interrupting execution.");
456 }
457 }
458
459 CP::CorrectionCode result;
460 if ((elec_trig.size()+muon_trig.size())>1 && trigExpr=="diLepton" && matched) {
461 result = m_trigGlobalEffCorrTool_diLep->getEfficiencyScaleFactor( elec_trig, muon_trig, trig_sf);
462 }
463 else if ((elec_trig.size()+muon_trig.size())>2 && trigExpr=="multiLepton" && matched) {
464 result = m_trigGlobalEffCorrTool_multiLep->getEfficiencyScaleFactor( elec_trig, muon_trig, trig_sf);
465 }
466
467 switch (result) {
468 case CP::CorrectionCode::Error:
469 ATH_MSG_ERROR( "Failed to retrieve multi-lepton trigger SF");
470 return 1.;
471 case CP::CorrectionCode::OutOfValidityRange:
472 ATH_MSG_VERBOSE( "OutOfValidityRange found for multi-lepton trigger SF");
473 return 1.;
474 default:
475 break;
476 }
477
478 return trig_sf;
479}

◆ 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 523 of file Trigger.cxx.

523 {
524
525 double trig_sf(1.);
526
527 if (trigExpr!="diPhoton") {
528 ATH_MSG_ERROR( "Failed to retrieve diphoton trigger SF");
529 return trig_sf;
530 }
531
532 std::vector<const xAOD::Photon*> ph_trig;
533 for (const xAOD::Photon* photon : photons) {
534 if (!acc_passOR(*photon)) continue;
535 if (!acc_signal(*photon)) continue;
536 ph_trig.push_back(photon);
537 }
538
539 CP::CorrectionCode result;
540 if (ph_trig.size()>1) {
541 result = m_trigGlobalEffCorrTool_diPhoton->getEfficiencyScaleFactor(ph_trig, trig_sf);
542 }
543
544 switch (result) {
545 case CP::CorrectionCode::Error:
546 ATH_MSG_ERROR( "Failed to retrieve diphoton trigger SF");
547 return 1.;
548 case CP::CorrectionCode::OutOfValidityRange:
549 ATH_MSG_VERBOSE( "OutOfValidityRange found for diphoton trigger SF");
550 return 1.;
551 default:
552 break;
553 }
554
555 return trig_sf;
556}

◆ 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 481 of file Trigger.cxx.

481 {
482
483 double sf(1.);
484
485 //Set the new systematic variation
486 if (trigExpr == "diLepton") {
487 StatusCode ret = m_trigGlobalEffCorrTool_diLep->applySystematicVariation(systConfig);
488 if (ret != StatusCode::SUCCESS) {
489 ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (dilepton trigger) for systematic var. " << systConfig.name() );
490 }
491 }
492
493 if (trigExpr == "multiLepton") {
494 StatusCode ret = m_trigGlobalEffCorrTool_multiLep->applySystematicVariation(systConfig);
495 if (ret != StatusCode::SUCCESS) {
496 ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (multi-lepton trigger) for systematic var. " << systConfig.name() );
497 }
498 }
499
500 //Get the SF for new config
501 sf = GetTriggerGlobalEfficiencySF (electrons, muons, trigExpr);
502
503 //Roll back to default
504 if (trigExpr == "diLepton") {
505 StatusCode ret = m_trigGlobalEffCorrTool_diLep->applySystematicVariation(m_currentSyst);
506 if (ret != StatusCode::SUCCESS) {
507 ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (dilepton trigger) back to default.");
508 }
509 }
510 if (trigExpr == "multiLepton") {
511 StatusCode ret = m_trigGlobalEffCorrTool_multiLep->applySystematicVariation(m_currentSyst);
512 if (ret != StatusCode::SUCCESS) {
513 ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (multi-lepton trigger) back to default.");
514 }
515 }
516
517 return sf;
518}
ST::SUSYObjDef_xAOD::GetTriggerGlobalEfficiencySF
double GetTriggerGlobalEfficiencySF(const xAOD::ElectronContainer &electrons, const xAOD::MuonContainer &muons, const std::string &trigExpr="diLepton") override final
Definition Trigger.cxx:425

◆ 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 558 of file Trigger.cxx.

558 {
559
560 double sf(1.);
561
562 //Set the new systematic variation
563 StatusCode ret = m_trigGlobalEffCorrTool_diPhoton->applySystematicVariation(systConfig);
564 if (ret != StatusCode::SUCCESS) {
565 ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (diphoton trigger) for systematic var. " << systConfig.name() );
566 }
567
568 //Get the SF for new config
569 sf = GetTriggerGlobalEfficiencySF (photons, trigExpr);
570
571 //Roll back to default
572 ret = m_trigGlobalEffCorrTool_diPhoton->applySystematicVariation(m_currentSyst);
573 if (ret != StatusCode::SUCCESS) {
574 ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (diphoton trigger) back to default.");
575 }
576
577 return sf;
578}

◆ GetTriggerOR()

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

Definition at line 314 of file Trigger.cxx.

314 {
315
316 static const std::string delOR = "_OR_";
317 std::vector<std::string> trigchains = {};
318 std::string newtrigExpr = TString(trigExpr).Copy().ReplaceAll("||",delOR).Data();
319 newtrigExpr = TString(trigExpr).Copy().ReplaceAll(" ","").Data();
320
321 size_t pos = 0;
322 while ((pos = newtrigExpr.find(delOR)) != std::string::npos) {
323 trigchains.push_back( "HLT_"+newtrigExpr.substr(0, pos) );
324 newtrigExpr.erase(0, pos + delOR.length());
325 }
326 if(pos==std::string::npos)
327 trigchains.push_back("HLT_"+newtrigExpr);
328
329 return trigchains;
330 }

◆ 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,
std::vector< std::string > & v_trigs23_cache,
std::vector< std::string > & v_trigs24_cache ) const

Definition at line 332 of file Trigger.cxx.

332 {
333
334 // 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
335
336 static const std::string del15 = "_2015_";
337 static const std::string del16 = "_2016_";
338 static const std::string del17 = "_2017_";
339
340 size_t pos = 0;
341 std::string token15, token16, token17, token18, token22, token23, token24;
342
343 //get trigger tokens for 2015, 2016, 2017, 2018 and 2022, 2023, 2024
344 if ( (pos = trigExpr.find(del15)) != std::string::npos) {
345 trigExpr.erase(0, pos + del15.length());
346
347 pos = 0;
348 while ((pos = trigExpr.find(del16)) != std::string::npos) {
349 token15 = trigExpr.substr(0, pos);
350 token16 = trigExpr.erase(0, pos + del16.length() + del17.length() - 1);
351 // 2016-2018 use exact the same trigger string
352 token17 = token16;
353 token18 = token16;
354 }
355 }
356
357 // Find year positions (or npos if not present)
358 size_t p22 = trigExpr.find("2022");
359 size_t p23 = trigExpr.find("2023");
360 size_t p24 = trigExpr.find("2024");
361
362 auto next_pos = [&](size_t self) {
363 size_t next = std::string::npos;
364
365 if (self == p22) {
366 if (p23 > self && p23 < next) next = p23;
367 if (p24 > self && p24 < next) next = p24;
368 }
369 else if (self == p23) {
370 if (p22 > self && p22 < next) next = p22;
371 if (p24 > self && p24 < next) next = p24;
372 }
373 else if (self == p24) {
374 if (p22 > self && p22 < next) next = p22;
375 if (p23 > self && p23 < next) next = p23;
376 }
377
378 return next;
379 };
380
381 // Extract 2022,2023,2024 block
382 if (p22 != std::string::npos) {size_t end = next_pos(p22); token22 = trigExpr.substr(p22, end - p22);}
383 if (p23 != std::string::npos) {size_t end = next_pos(p23); token23 = trigExpr.substr(p23, end - p23);}
384 if (p24 != std::string::npos) {size_t end = next_pos(p24); token24 = trigExpr.substr(p24, end - p24);}
385
386 // Remove trailing underscores from tokens if present
387 std::string* toks[] = { &token22, &token23, &token24 };
388 for (auto t : toks) {
389 while (!t->empty() && t->back() == '_') t->pop_back();
390 }
391
392 //Redefine in case of custom user input
393 if(!m_isRun3){
394 if(token15.empty()) token15 = trigExpr;
395 if(token16.empty()) token16 = trigExpr;
396 if(token17.empty()) token17 = trigExpr;
397 if(token18.empty()) token18 = trigExpr;
398 }
399 else{
400 if(token22.empty()) token22 = trigExpr;
401 if(token23.empty()) token23 = trigExpr;
402 if(token24.empty()) token24 = trigExpr;
403 }
404
405 //get trigger chains for matching in 2015 and 2018
406 if(!m_isRun3){
407 v_trigs15_cache = GetTriggerOR(token15);
408 v_trigs16_cache = GetTriggerOR(token16);
409 v_trigs17_cache = GetTriggerOR(token17);
410 v_trigs18_cache = GetTriggerOR(token18);
411 }
412 //get trigger chains for matching in 2022
413 else{
414 v_trigs22_cache = GetTriggerOR(token22);
415 v_trigs23_cache = GetTriggerOR(token23);
416 v_trigs24_cache = GetTriggerOR(token24);
417 }
418 }
ST::SUSYObjDef_xAOD::GetTriggerOR
std::vector< std::string > GetTriggerOR(const std::string &trigExpr) const
Definition Trigger.cxx:314
read_hist_ntuple.t
t
Definition read_hist_ntuple.py:8

◆ GetTrigPrescale()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 304 of file Trigger.cxx.

304 {
305 return m_trigDecTool->getPrescale(tr_item);
306}

◆ handle()

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

Function receiving incidents from IncidentSvc/Event.

Reimplemented in Trig::TrigDecisionTool.

Definition at line 135 of file AsgMetadataTool.cxx.

135 {
136
137 // Tell the user what's happening:
138 ATH_MSG_VERBOSE( "Callback received with incident: " << inc.type() );
139
140 // Call the appropriate member function:
141 if( inc.type() == IncidentType::BeginInputFile ) {
142 m_beginInputFileCalled = true;
143 if( beginInputFile().isFailure() ) {
144 ATH_MSG_FATAL( "Failed to call beginInputFile()" );
145 throw std::runtime_error( "Couldn't call beginInputFile()" );
146 }
147 } else if( inc.type() == IncidentType::EndInputFile ) {
148 if( endInputFile().isFailure() ) {
149 ATH_MSG_FATAL( "Failed to call endInputFile()" );
150 throw std::runtime_error( "Couldn't call endInputFile()" );
151 }
152 } else if( inc.type() == IncidentType::BeginEvent ) {
153 // If the tool didn't catch the begin input file incident for the
154 // first input file of the job, then call the appropriate function
155 // now.
156 if( ! m_beginInputFileCalled ) {
157 m_beginInputFileCalled = true;
158 if( beginInputFile().isFailure() ) {
159 ATH_MSG_FATAL( "Failed to call beginInputFile()" );
160 throw std::runtime_error( "Couldn't call beginInputFile()" );
161 }
162 }
163 if( beginEvent().isFailure() ) {
164 ATH_MSG_FATAL( "Failed to call beginEvent()" );
165 throw std::runtime_error( "Couldn't call beginEvent()" );
166 }
167
168 #ifdef XAOD_STANDALONE
169 } else if( inc.type() == IncidentType::MetaDataStop ) {
170 if( metaDataStop().isFailure() ) {
171 ATH_MSG_FATAL( "Failed to call metaDataStop()" );
172 throw std::runtime_error( "Couldn't call metaDataStop()" );
173 }
174
175 #endif // XAOD_STANDALONE
176 } else {
177 ATH_MSG_WARNING( "Unknown incident type received in AsgMetaDataTool: " << inc.type() );
178 }
179
180 return;
181 }
asg::AsgMetadataTool::beginInputFile
virtual StatusCode beginInputFile()
Function called when a new input file is opened.
Definition AsgMetadataTool.cxx:185
asg::AsgMetadataTool::beginEvent
virtual StatusCode beginEvent()
Function called when a new events is loaded.
Definition AsgMetadataTool.cxx:201
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
asg::AsgMetadataTool::endInputFile
virtual StatusCode endInputFile()
Function called when the currently open input file got completely processed.
Definition AsgMetadataTool.cxx:193
asg::AsgMetadataTool::metaDataStop
virtual StatusCode metaDataStop()
Function called when the tool should write out its metadata.
Definition AsgMetadataTool.cxx:209

◆ initialize()

StatusCode ST::SUSYObjDef_xAOD::initialize ( void )
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 911 of file SUSYObjDef_xAOD.cxx.

911 {
912
913 if (m_tool_init) {
914 ATH_MSG_ERROR("Initialising for a second time -- something is wrong!");
915 return StatusCode::FAILURE;
916 }
917
918 // Greet the user:
919 ATH_MSG_INFO( "Initialising... " );
920
921 bool autoconf(false);
922#ifndef XAOD_STANDALONE // For now metadata is Athena-only
923 if ( m_dataSource < 0 ) {
924 autoconf = true;
925 ATH_MSG_INFO("Autoconfiguring: dataSource, mcCampaign, isPHYSLITE");
926 std::string projectName = "";
927 ATH_CHECK( AthAnalysisHelper::retrieveMetadata("/TagInfo", "project_name", projectName, inputMetaStore() ) );
928 if ( projectName == "IS_SIMULATION" ) {
929 std::string simFlavour = "";
930 ATH_CHECK( AthAnalysisHelper::retrieveMetadata("/Simulation/Parameters", "SimulationFlavour", simFlavour, inputMetaStore() ) );
931 TString s(simFlavour); s.ToUpper();
932 m_dataSource = s.Contains("ATLFAST") ? AtlfastII : FullSim;
933 } else if (projectName.compare(0, 4, "data") == 0 ) {
934 m_dataSource = Data;
935 } else {
936 ATH_MSG_ERROR("Failed to autoconfigure -- project_name matches neither IS_SIMULATION nor data!");
937 return StatusCode::FAILURE;
938 }
939
940 }
941#endif
942
943 m_configFile = PathResolverFindCalibFile(m_configFile);
944
945 //Read configuration from file (stored as Property)
946 ATH_CHECK( readConfig() );
947
948 if (m_dataSource < 0) {
949 ATH_MSG_FATAL( "Data source incorrectly configured!!" );
950 ATH_MSG_FATAL("You must set the DataSource property to Data, FullSim or AtlfastII !!");
951 if (autoconf) ATH_MSG_FATAL("Autoconfiguration seems to have failed!");
952 // if(m_useLeptonTrigger<0) ATH_MSG_ERROR( "UseLeptonTrigger not set");
953 ATH_MSG_FATAL( "Exiting... " );
954 return StatusCode::FAILURE;
955 }
956 ATH_MSG_DEBUG( "Configured: IsData: " << isData() );
957 ATH_MSG_DEBUG( "Configured: IsAtlfast: " << isAtlfast() );
958
959 switch (m_jetInputType) {
960 case xAOD::JetInput::LCTopo:
961 case xAOD::JetInput::EMTopo:
962 case xAOD::JetInput::EMPFlow:
963 break;
964 default:
965 ATH_MSG_ERROR( "Invalid jet input type " << xAOD::JetInput::typeName(xAOD::JetInput::Type(m_jetInputType)) );
966 return StatusCode::FAILURE;
967 }
968
969 if (m_inputMETSuffix.empty()){
970 m_inputMETSuffix = "AntiKt4" + xAOD::JetInput::typeName(xAOD::JetInput::Type(m_jetInputType));
971 }
972 m_defaultJets = "AntiKt4" + xAOD::JetInput::typeName(xAOD::JetInput::Type(m_jetInputType)) + "Jets";
973 ATH_MSG_INFO( "Configured for jet collection: " << m_defaultJets );
974
975 m_defaultTruthJets = "AntiKt4TruthJets";
976 const xAOD::FileMetaData* fmd = nullptr;
977 std::string dataType;
978 if ( inputMetaStore()->contains<xAOD::FileMetaData>("FileMetaData") && inputMetaStore()->retrieve(fmd,"FileMetaData").isSuccess() )
979 fmd->value(xAOD::FileMetaData::dataType, dataType);
980 if ( dataType.compare("StreamDAOD_PHYS")==0 || dataType.compare("StreamDAOD_PHYSLITE")==0 ) m_defaultTruthJets = "AntiKt4TruthDressedWZJets";
981 if ( dataType.compare("StreamDAOD_PHYSLITE")==0) m_isPHYSLITE = true;
982
983 ATH_MSG_INFO( "Configured for truth jet collection: " << m_defaultTruthJets );
984
985 m_inputMETCore = m_isPHYSLITE? "MET_Core_AnalysisMET":"MET_Core_" + m_inputMETSuffix;
986 m_inputMETMap = m_isPHYSLITE? "METAssoc_AnalysisMET":"METAssoc_" + m_inputMETSuffix;
987
988 ATH_MSG_DEBUG ( "Build MET Core: " << m_inputMETCore);
989 ATH_MSG_DEBUG ( "Build MET with map: " << m_inputMETMap);
990
991 m_jetCleanDFName = TString::Format("DFCommonJets_jetClean_%s", m_badJetCut.c_str());
992 m_acc_jetClean = m_jetCleanDFName;
993
994 // the decorations are named like DFCommonElectronsLHTight, DFCommonElectronsDNNTight or DFCommonElectronsDNNTightNoCF
995 m_eleIdBaselineDFName = m_eleIdBaseline.find("DNN") == std::string::npos ? "DFCommonElectronsLH" : "DFCommonElectronsDNN";
996 m_eleIdBaselineDFName += TString(m_eleIdBaseline).ReplaceAll("LooseAndBLayer","LooseBL").ReplaceAll("LLH","").ReplaceAll("DNNnoCF","").ReplaceAll("DNN","").Data();
997 if (m_eleIdBaseline.find("noCF") != std::string::npos)
998 m_eleIdBaselineDFName += "NoCF";
999 m_acc_eleIdBaseline = m_eleIdBaselineDFName;
1000
1001 m_eleIdDFName = m_eleId.find("DNN") == std::string::npos ? "DFCommonElectronsLH" : "DFCommonElectronsDNN";
1002 m_eleIdDFName += TString(m_eleId).ReplaceAll("LooseAndBLayer","LooseBL").ReplaceAll("LLH","").ReplaceAll("DNNnoCF","").ReplaceAll("DNN","").Data();
1003 if (m_eleId.find("noCF") != std::string::npos)
1004 m_eleIdDFName += "NoCF";
1005 m_acc_eleId = m_eleIdDFName;
1006
1007 m_photonIdBaselineDFName = "DFCommonPhotonsIsEM";
1008 m_photonIdBaselineDFName += TString(m_photonIdBaseline).Data();
1009 m_acc_photonIdBaseline = m_photonIdBaselineDFName;
1010
1011 m_photonIdDFName = "DFCommonPhotonsIsEM";
1012 m_photonIdDFName += TString(m_photonId).Data();
1013 m_acc_photonId = m_photonIdDFName;
1014
1015 // autoconfigure PRW tool if m_autoconfigPRW==true
1016 if (m_autoconfigPRWPath == "dev/PileupReweighting/share/")
1017 ATH_CHECK( autoconfigurePileupRWTool(m_autoconfigPRWPath, m_autoconfigPRWFile, true, m_autoconfigPRWRPVmode, m_autoconfigPRWCombinedmode) );
1018 else
1019 // need to set a full path if you don't use the one in CVMFS
1020 ATH_CHECK( autoconfigurePileupRWTool(m_autoconfigPRWPath, m_autoconfigPRWFile, false, m_autoconfigPRWRPVmode, m_autoconfigPRWCombinedmode) );
1021
1022 // Read Handles
1023 ATH_CHECK( m_LRTCollectionName.initialize() );
1024 ATH_CHECK( m_GSFLRTCollectionName.initialize() );
1025
1026 // Write Handles
1027 ATH_CHECK( m_outElectronLocation.initialize() );
1028 ATH_CHECK( m_outMuonLocation.initialize() );
1029
1030 ATH_CHECK( this->SUSYToolsInit() );
1031
1032 ATH_MSG_VERBOSE("Done with tool retrieval");
1033
1034 m_tool_init = true;
1035
1036 // Return gracefully:
1037 return StatusCode::SUCCESS;
1038}
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_defaultTruthJets
std::string m_defaultTruthJets
Definition SUSYObjDef_xAOD.h:830
ST::SUSYObjDef_xAOD::m_eleIdDFName
std::string m_eleIdDFName
Definition SUSYObjDef_xAOD.h:1006
ST::SUSYObjDef_xAOD::m_jetCleanDFName
std::string m_jetCleanDFName
Definition SUSYObjDef_xAOD.h:1009
ST::SUSYObjDef_xAOD::m_photonIdBaselineDFName
std::string m_photonIdBaselineDFName
Definition SUSYObjDef_xAOD.h:1007
ST::SUSYObjDef_xAOD::readConfig
StatusCode readConfig() override final
Definition SUSYObjDef_xAOD.cxx:1361
ST::SUSYObjDef_xAOD::SUSYToolsInit
StatusCode SUSYToolsInit()
Definition SUSYToolsInit.cxx:112
ST::SUSYObjDef_xAOD::m_eleIdBaselineDFName
std::string m_eleIdBaselineDFName
Definition SUSYObjDef_xAOD.h:1005
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:1040
ST::SUSYObjDef_xAOD::m_photonIdDFName
std::string m_photonIdDFName
Definition SUSYObjDef_xAOD.h:1008
xAOD::FileMetaData_v1::dataType
@ dataType
Data type that's in the file [string].
Definition FileMetaData_v1.h:64
xAOD::JetInput::typeName
const std::string & typeName(Type id)
Definition JetContainerInfo.cxx:199

◆ 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 93 of file AsgMetadataTool.cxx.

93 {
94
95#ifdef XAOD_STANDALONE
96 return &m_inputMetaStore;
97#else // XAOD_STANDALONE
98 return m_inputMetaStore;
99#endif // XAOD_STANDALONE
100 }
asg::AsgMetadataTool::m_inputMetaStore
MetaStore_t m_inputMetaStore
Object accessing the input metadata store.
Definition AsgMetadataTool.h:119

◆ isAtlfast()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 158 of file SUSYObjDef_xAOD.h.

158{return m_dataSource == AtlfastII;}

◆ IsBadJet()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 763 of file Jets.cxx.

763 {
764
765 if ( !acc_passOR(input) ) return false;
766
767 float ptcut = 20e3;
768 if ( m_jetPt < ptcut ) ptcut = m_jetPt;
769
770 bool isPileup = !acc_passJvt(input);
771
772 if ( input.pt() <= ptcut || isPileup ) return false;
773
774 if (m_acc_jetClean.isAvailable(input)) {
775 dec_bad(input) = !m_acc_jetClean(input);
776 } else {
777 ATH_MSG_VERBOSE("DFCommon jet cleaning variable not available ... setting 'bad' decorator to 0.");
778 dec_bad(input) = 0;
779 // the jet cleaning decisions are only calculable at AOD now
780 // dec_bad(input) = m_jetCleaningTool.empty() ? false : !m_jetCleaningTool->keep(input);
781 }
782
783 ATH_MSG_VERBOSE( "JET isbad?: " << static_cast<int>(acc_bad(input)));
784
785 return acc_bad(input);
786 }
InDet::TrkOrigin::isPileup
bool isPileup(int origin)
from pileup
Definition InDetTrackTruthOriginDefs.h:62
Pythia8_A14_NNPDF23LO_forMGHT_EvtGen.ptcut
float ptcut
Definition Pythia8_A14_NNPDF23LO_forMGHT_EvtGen.py:9
ST::acc_bad
static const SG::ConstAccessor< char > acc_bad("bad")

◆ IsBadMuon()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 408 of file Muons.cxx.

409{
410 const static SG::Decorator<char> dec_bad("bad");
411 dec_bad(input) = false;
412
413 const static SG::Decorator<char> dec_bad_highPt("bad_highPt");
414 dec_bad_highPt(input) = false;
415
416 const xAOD::TrackParticle* track{nullptr};
417 if (input.muonType() == xAOD::Muon::MuonType::SiliconAssociatedForwardMuon) {
418 track = input.trackParticle(xAOD::Muon::TrackParticleType::CombinedTrackParticle);
419 if (!track) return false; // don't treat SAF muons without CB track further
420 }
421 else{
422 track = input.trackParticle(xAOD::Muon::TrackParticleType::Primary);
423 if (!track){
424 ATH_MSG_WARNING("Non-SAF muon without a track; cannot test IsBadMuon criteria");
425 return false;
426 }
427 }
428
429 float Rerr = Amg::error(track->definingParametersCovMatrix(), 4) / std::abs(track->qOverP());
430 ATH_MSG_VERBOSE( "Track momentum error (%): " << Rerr * 100 );
431 bool isbad = Rerr > qopcut;
432 bool isbadHighPt = Rerr > qopcut;
433
434 //new recommendation from MCP
435 isbad |= m_muonSelectionTool->isBadMuon(input);
436
437 //new recommendation from MCP (at HighPT)
438 isbadHighPt |= m_muonSelectionHighPtTool->isBadMuon(input);
439
440 dec_bad(input) = isbad;
441 dec_bad_highPt(input) = isbadHighPt;
442
443 ATH_MSG_VERBOSE( "MUON isbad?: " << isbad );
444 return isbad;
445}
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
SG::Decorator
SG::Decorator< T, ALLOC > Decorator
Helper class to provide type-safe access to aux data, specialized for JaggedVecElt.
Definition AuxElement.h:576

◆ IsBJet()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 789 of file Jets.cxx.

789 {
790
791 bool isbjet = bool(m_btagSelTool->accept(input));
792 dec_bjet(input) = isbjet;
793
794 if (SetBtagWeightDecorations(input, m_btagSelTool, m_BtagTagger).isFailure())
795 ANA_MSG_ERROR("Couldn't set b-tag decorations for jet, is-b = " << (isbjet?"true":"false") << ", pT = " << input.pt()/1000.);
796
797 return isbjet;
798 }
ANA_MSG_ERROR
#define ANA_MSG_ERROR(xmsg,...)
Macro printing error messages.
Definition Control/AthToolSupport/AsgMessaging/AsgMessaging/MessageCheck.h:295
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:1173
ST::dec_bjet
static const SG::Decorator< char > dec_bjet("bjet")

◆ IsBJetContinuous()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 811 of file Jets.cxx.

811 {
813 // Cheatsheet:
814 // returns 6 if between 65% and 0%
815 // returns 5 if between 70% and 65%
816 // returns 4 if between 77% and 70%
817 // returns 3 if between 85% and 77%
818 // returns 2 if between 90% and 85%
819 // returns 1 if between 100% and 90%
820 // returns 0 if smaller than -1e4-> should never happen
821 // return -1 if bigger than 1e4 or not in b-tagging acceptance
823
824 int isbjet = m_btagSelTool->getQuantile(input);
825 dec_bjet(input) = isbjet;
826
827 if(SetBtagWeightDecorations(input, m_btagSelTool, m_BtagTagger).isFailure())
828 ANA_MSG_ERROR("Couldn't set continuous b-tag decorations for jet, is-b = " << isbjet << ", pT = " << input.pt()/1000.);
829
830 return isbjet;
831 }

◆ IsBJetLoose()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 698 of file Jets.cxx.

698 {
699 bool isbjet_loose = false;
700 if (m_orBJetPtUpperThres < 0 || m_orBJetPtUpperThres > input.pt())
701 isbjet_loose = bool(m_btagSelTool_OR->accept(input)); //note : b-tag applies only to jet with eta < 2.5
702 return isbjet_loose;
703 }

◆ 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 447 of file Muons.cxx.

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

◆ isData()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 157 of file SUSYObjDef_xAOD.h.

157{return m_dataSource == Data;}

◆ IsHighPtMuon()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 389 of file Muons.cxx.

393{
394 if (input.pt() < 3e3){
395 ATH_MSG_DEBUG("No HighPt check supported for muons below 3GeV! False.");
396 dec_passedHighPtCuts(input) = false;
397 return false;
398 }
399
400 bool isHighPt=false;
401 isHighPt = bool(m_muonSelectionHighPtTool->accept(input));
402 dec_passedHighPtCuts(input) = isHighPt;
403
404 return isHighPt;
405}

◆ IsMETTrigPassed() [1/2]

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 57 of file Trigger.cxx.

57 {
58 // NB - this now applies to the entire function...
59
60 // First check if we're affected by the L1_XE50 bug
61 bool L1_pass = m_trigDecTool->isPassed(L1_name);
62 bool HLT_noalg_L1J400 = m_trigDecTool->isPassed("HLT_noalg_L1J400");
63 if (!L1_pass && j400_OR && HLT_noalg_L1J400) {
64 return emulateHLT(triggerName);
65 }
66 else if (L1_pass) {
67 // See if the TDT knows about this
68 {
69 std::scoped_lock lock (m_triggerCacheMutex);
70 if (isTrigInTDT(lock, triggerName) ) return m_trigDecTool->isPassed(triggerName);
71 }
72 return emulateHLT(triggerName);
73 }
74 return false;
75}
ST::SUSYObjDef_xAOD::emulateHLT
bool emulateHLT(const std::string &triggerName) const
Definition Trigger.cxx:91

◆ 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 = (runnumber>0)? runnumber : GetRunNumber();
38
39 int year = treatAsYear(rn);
40
41 if (year == 2015) return IsMETTrigPassed("HLT_xe70_mht",j400_OR); //2015
42 else if(year == 2016 && rn >= 296939 && rn <= 302872 ) return IsMETTrigPassed("HLT_xe90_mht_L1XE50",j400_OR); //2016 A-D3
43 else if(year == 2016 && rn >= 302919 && rn <= 303892 ) return IsMETTrigPassed("HLT_xe100_mht_L1XE50",j400_OR); //2016 D4-F1
44 else if(year == 2016 && rn >= 303943) return IsMETTrigPassed("HLT_xe110_mht_L1XE50",j400_OR); //2016 F2-(open)
45 // don't use complicated logic from IsMETTrigPassed if not needed
46 else if(year == 2017 && rn >= 325713 && rn <= 331975 ) return IsTrigPassed("HLT_xe110_pufit_L1XE55"); // 2017 B1-D5
47 else if(year == 2017 && rn >= 332303 ) return IsTrigPassed("HLT_xe110_pufit_L1XE50"); // 2017 D6-(open)
48 else if(year == 2018 && rn >= 348885 && rn <= 350013 ) return IsTrigPassed("HLT_xe110_pufit_xe70_L1XE50"); // 2018 B-C5
49 else if(year == 2018 && rn >= 350067 ) return IsTrigPassed("HLT_xe110_pufit_xe65_L1XE50"); // 2018 C5-(open)
50 else if(year == 2022 || year == 2023) return IsTrigPassed("HLT_xe65_cell_xe90_pfopufit_L1XE50");
51 else if(year == 2024 || year == 2025 || year == 2026) return IsTrigPassed("HLT_xe65_cell_xe105_nn_L1jXE100");
52
53 return false;
54}
ST::SUSYObjDef_xAOD::IsMETTrigPassed
bool IsMETTrigPassed(unsigned int runnumber=0, bool j400_OR=false) const override final
Definition Trigger.cxx:30
ST::SUSYObjDef_xAOD::GetRunNumber
unsigned int GetRunNumber() const override final
Definition SUSYObjDef_xAOD.cxx:3136
ST::SUSYObjDef_xAOD::IsTrigPassed
bool IsTrigPassed(const std::string &, unsigned int condition=TrigDefs::Physics) const override final
Definition Trigger.cxx:207
runnumber
static std::vector< uint32_t > runnumber
Definition iLumiCalc.h:37

◆ isNominal()

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

Definition at line 2181 of file SUSYObjDef_xAOD.cxx.

2181 {
2182 return syst.name().empty();
2183}

◆ isPrompt()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 24 of file Truth.cxx.

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

◆ 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 365 of file Electrons.cxx.

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

◆ 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 711 of file Jets.cxx.

711 {
712 if ( !acc_baseline(input) || !acc_passOR(input) ) return false;
713
714 if ( input.pt() <= ptcut || std::abs(input.eta()) >= etacut) return false;
715
716 bool isgoodjet = !acc_bad(input) && acc_passJvt(input);
717
718 dec_signal(input) = isgoodjet;
719
720 // For JVT calculation
721 dec_signal_less_JVT(input) = !acc_bad(input);
722
723
724 if (m_debug) {
725 float emfrac, hecf, LArQuality, HECQuality, Timing, fracSamplingMax, NegativeE, AverageLArQF;
726 std::vector<float> sumpttrk_vec;
727
728 input.getAttribute(xAOD::JetAttribute::EMFrac, emfrac);
729 input.getAttribute(xAOD::JetAttribute::HECFrac, hecf);
730 input.getAttribute(xAOD::JetAttribute::LArQuality, LArQuality);
731 input.getAttribute(xAOD::JetAttribute::HECQuality, HECQuality);
732 input.getAttribute(xAOD::JetAttribute::Timing, Timing);
733 input.getAttribute(xAOD::JetAttribute::SumPtTrkPt500, sumpttrk_vec);
734 input.getAttribute(xAOD::JetAttribute::FracSamplingMax, fracSamplingMax);
735 input.getAttribute(xAOD::JetAttribute::NegativeE, NegativeE);
736 input.getAttribute(xAOD::JetAttribute::AverageLArQF, AverageLArQF);
737
738 float sumpttrk;
739 if (!sumpttrk_vec.empty() && this->GetPrimVtx()) {
740 sumpttrk = sumpttrk_vec[this->GetPrimVtx()->index()];
741 } else {
742 sumpttrk = 0.;
743 }
744
745 ATH_MSG_INFO( "JET pt: " << input.pt() );
746 ATH_MSG_INFO( "JET eta: " << input.eta() );
747 ATH_MSG_INFO( "JET emfrac: " << emfrac );
748 ATH_MSG_INFO( "JET hecfrac: " << hecf );
749 ATH_MSG_INFO( "JET LArQuality: " << LArQuality );
750 ATH_MSG_INFO( "JET HECQuality: " << HECQuality );
751 ATH_MSG_INFO( "JET Timing: " << Timing );
752 ATH_MSG_INFO( "JET sumpttrk: " << sumpttrk );
753 ATH_MSG_INFO( "JET fracSamplingMax: " << fracSamplingMax );
754 ATH_MSG_INFO( "JET AverageLArQF: " << AverageLArQF );
755 }
756
757 ATH_MSG_VERBOSE( "JET isbad?: " << static_cast<int>(acc_bad(input)));
758
759 return isgoodjet;
760 }

◆ 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 347 of file Muons.cxx.

348{
349 if (!acc_baseline(input)) return false;
350 if (!acc_passSignalID(input)) return false;
351
352 if (input.pt() <= ptcut || input.pt() == 0) return false; // pT cut (might be necessary for leading muon to pass trigger)
353 if ( etacut==DUMMYDEF ){
354 if(std::abs(input.eta()) > m_muEta ) return false;
355 }
356 else if ( std::abs(input.eta()) > etacut ) return false;
357
358 if (z0cut > 0.0 && std::abs(acc_z0sinTheta(input)) > z0cut) return false; // longitudinal IP cut
359 if (acc_d0sig(input) != 0) {
360 if (d0sigcut > 0.0 && std::abs(acc_d0sig(input)) > d0sigcut) return false; // transverse IP cut
361 }
362
363 if (m_doMuIsoSignal) {
364 if ( !( (acc_isol(input) && input.pt()<m_muIsoHighPtThresh) || (acc_isolHighPt(input) && input.pt()>m_muIsoHighPtThresh)) ) return false;
365 ATH_MSG_VERBOSE( "IsSignalMuon: passed isolation");
366 }
367
368 //set HighPtMuon decoration
369 IsHighPtMuon(input);
370
371 dec_signal(input) = true;
372
373 if (m_muId == 4) { //i.e. HighPt muons
374 ATH_MSG_VERBOSE( "IsSignalMuon: mu pt " << input.pt()
375 << " signal? " << static_cast<int>(acc_signal(input))
376 << " isolation? " << static_cast<int>(acc_isol(input))
377 << " passedHighPtCuts? " << static_cast<int>(acc_passedHighPtCuts(input)));
378 } else {
379 ATH_MSG_VERBOSE( "IsSignalMuon: mu pt " << input.pt()
380 << " signal? " << static_cast<int>( acc_signal(input))
381 << " isolation? " << static_cast<int>( acc_isol(input)));
382 // Don't show HighPtFlag ... we didn't set it!
383 }
384
385 return acc_signal(input);
386}
ST::SUSYObjDef_xAOD::IsHighPtMuon
bool IsHighPtMuon(const xAOD::Muon &input) const override final
Definition Muons.cxx:389
ST::acc_passedHighPtCuts
static const SG::ConstAccessor< char > acc_passedHighPtCuts("passedHighPtCuts")

◆ 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 170 of file Photons.cxx.

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

◆ 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 115 of file Taus.cxx.

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

◆ IsTrackBJet()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 800 of file Jets.cxx.

800 {
801
802 bool isbjet = bool(m_btagSelTool_trkJet->accept(input));
803 dec_bjet(input) = isbjet;
804
805 if(SetBtagWeightDecorations(input, m_btagSelTool_trkJet, m_BtagTagger_trkJet).isFailure())
806 ANA_MSG_ERROR("Couldn't set b-tag decorations for trackjet, is-b = " << (isbjet?"true":"false") << ", pT = " << input.pt()/1000.);
807
808 return isbjet;
809 }

◆ IsTrackBJetContinuous()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 833 of file Jets.cxx.

833 {
834
835 int isbjet = m_btagSelTool_trkJet->getQuantile(input);
836 dec_bjet(input) = isbjet;
837
838 if(SetBtagWeightDecorations(input, m_btagSelTool_trkJet, m_BtagTagger_trkJet).isFailure())
839 ANA_MSG_ERROR("Couldn't set continuous b-tag decorations for trackjet, is-b = " << isbjet << ", pT = " << input.pt()/1000.);
840
841 return isbjet;
842 }

◆ isTrigInTDT()

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

Definition at line 77 of file Trigger.cxx.

79{
80 auto mapItr = m_checkedTriggers.find(triggerName);
81 if ( mapItr == m_checkedTriggers.end() ) {
82 const auto *cg = m_trigDecTool->getChainGroup(triggerName);
83 return m_checkedTriggers[triggerName] = cg->getListOfTriggers().size() != 0;
84 }
85 else {
86 return mapItr->second;
87 }
88}

◆ 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 227 of file Trigger.cxx.

227 {
228 return m_trigMatchingTool->match(v, tr_item);
229}

◆ 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 222 of file Trigger.cxx.

222 {
223 return m_trigMatchingTool->match(v, tr_item);
224}

◆ 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 212 of file Trigger.cxx.

212 {
213 return this->IsTrigMatched({part}, tr_item);
214}
ST::SUSYObjDef_xAOD::IsTrigMatched
bool IsTrigMatched(const xAOD::IParticle *part, const std::string &tr_item) override final
Definition Trigger.cxx:212

◆ 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 217 of file Trigger.cxx.

217 {
218 return this->IsTrigMatched({part1, part2}, tr_item);
219}

◆ 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 207 of file Trigger.cxx.

207 {
208 return m_trigDecTool->isPassed(tr_item, condition);
209}

◆ IsTruthBJet()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 301 of file Truth.cxx.

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

◆ isVariation()

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

Definition at line 2196 of file SUSYObjDef_xAOD.cxx.

2196 {
2197 // returns true if _any_ of the systematics affect kinematics. ignores effect on weights.
2198 for (const auto& sys : systSet) {
2199 auto info = getSystInfo(sys);
2200 if(info.affectsKinematics) { return true; }
2201 }
2202 return false;
2203}

◆ isWeight()

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

Definition at line 2185 of file SUSYObjDef_xAOD.cxx.

2185 {
2186 // returns true if all systematics do _not_ affect kinematics and _any_ of them affects the weight
2187 bool affectsWeights = false;
2188 for (const auto& sys : systSet) {
2189 auto info = getSystInfo(sys);
2190 if(info.affectsKinematics) { return false; }
2191 affectsWeights = affectsWeights or info.affectsWeights;
2192 }
2193 return affectsWeights;
2194}

◆ JetPassJVT()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 705 of file Jets.cxx.

705 {
706 char pass_jvt = !m_applyJVTCut || m_jetNNJvtSelectionTool->accept(&input);
707 dec_passJvt(input) = pass_jvt;
708 return pass_jvt;
709 }

◆ JVT_SF()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 1006 of file Jets.cxx.

1006 {
1007
1008 float totalSF = 1.;
1009 if (!m_applyJVTCut) return totalSF;
1010
1011 ConstDataVector<xAOD::JetContainer> jvtjets(SG::VIEW_ELEMENTS);
1012 for (const xAOD::Jet* jet : *jets) {
1013 // Only jets that were good for every cut except JVT
1014 if (acc_signal_less_JVT(*jet) && acc_passOR(*jet)) {
1015 jvtjets.push_back(jet);
1016 }
1017 }
1018
1019 for (const xAOD::Jet* jet : jvtjets) {
1020 float current_sf = 0;
1021
1022 // the SF are only applied for HS jets and implicitely requires the presence of the isHS decoration
1023 CP::CorrectionCode result;
1024 if (acc_passJvt(*jet)) {
1025 result = m_jetNNJvtEfficiencyTool->getEfficiencyScaleFactor(*jet,current_sf);
1026 }
1027 else {
1028 result = m_jetNNJvtEfficiencyTool->getInefficiencyScaleFactor(*jet,current_sf);
1029 }
1030
1031 switch (result) {
1032 case CP::CorrectionCode::Error:
1033 // this is probably not right, should report an error here
1034 ATH_MSG_ERROR("Inexplicably failed JVT calibration" );
1035 break;
1036 case CP::CorrectionCode::OutOfValidityRange:
1037 // no NNJvt SF for jet, that is ok e.g. for jets with |eta| > 2.5
1038 ATH_MSG_VERBOSE( "Skip SF application in SUSYTools_xAOD::JVT_SF as jet outside validate range" );
1039 break;
1040 default:
1041 ATH_MSG_VERBOSE( "Retrieve SF for jet in SUSYTools_xAOD::JVT_SF with value " << current_sf );
1042 totalSF *= current_sf;
1043 }
1044
1045 }
1046
1047 ATH_MSG_VERBOSE( "Retrieve total SF for jet container in SUSYTools_xAOD::JVT_SF with value " << totalSF );
1048
1049 return totalSF;
1050 }

◆ JVT_SFsys()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 1053 of file Jets.cxx.

1053 {
1054
1055 float totalSF = 1.;
1056 if (!m_applyJVTCut) return totalSF;
1057
1058 //Set the new systematic variation
1059 StatusCode ret = m_jetNNJvtEfficiencyTool->applySystematicVariation(systConfig);
1060 if ( ret != StatusCode::SUCCESS) {
1061 ATH_MSG_ERROR("Cannot configure NNjvtEfficiencyTool for systematic var. " << systConfig.name() );
1062 }
1063
1064 // Delegate
1065 totalSF = SUSYObjDef_xAOD::JVT_SF( jets );
1066
1067 // }
1068 if (m_applyJVTCut) {
1069 ret = m_jetNNJvtEfficiencyTool->applySystematicVariation(m_currentSyst);
1070 if ( ret != StatusCode::SUCCESS) {
1071 ATH_MSG_ERROR("Cannot configure NNjvtEfficiencyTool for systematic var. " << systConfig.name() );
1072 }
1073 }
1074
1075 return totalSF;
1076 }

◆ 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 ) {
78 setOriginalObjectLink(*getOriginalObject(*electron), *newElectron);
79 } else {
80 setOriginalObjectLink(*electron, *newElectron);
81 }
82
83 outputCol->push_back(newElectron);
84 }
85 }
86 return StatusCode::SUCCESS;
87}
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
ST::acc_isLRT
static const SG::ConstAccessor< char > acc_isLRT("isLRT")
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

◆ 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 56 of file Muons.cxx.

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

◆ 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 BookkeeperDumperTool, BookkeeperTool, xAODMaker::TriggerMenuMetaDataTool, and xAODMaker::TruthMetaDataTool.

Definition at line 209 of file AsgMetadataTool.cxx.

209 {
210
211 // Return gracefully:
212 return StatusCode::SUCCESS;
213 }

◆ msg()

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ 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 }
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition AthCommonMsg.h:24
MSG::name
const std::string & name(Level lvl)
Convenience function for translating message levels to strings.
Definition MsgLevel.cxx:19

◆ 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 3047 of file SUSYObjDef_xAOD.cxx.

3047 {
3048 // This getCloseByIsoCorrection is computationally less expensive and actually corrects the isoaltion
3049 // variables from the contribution of the close by leptons
3050 if (m_isoCloseByTool->getCloseByIsoCorrection(Gaudi::Hive::currentContext(), electrons,muons) != CP::CorrectionCode::Ok) {
3051 return StatusCode::FAILURE;
3052 }
3053 // All done, all good :-)
3054 return StatusCode::SUCCESS;
3055}

◆ 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 102 of file AsgMetadataTool.cxx.

102 {
103
104#ifdef XAOD_STANDALONE
105 return &m_outputMetaStore;
106#else // XAOD_STANDALONE
107 return m_outputMetaStore;
108#endif // XAOD_STANDALONE
109 }
asg::AsgMetadataTool::m_outputMetaStore
MetaStore_t m_outputMetaStore
Object accessing the output metadata store.
Definition AsgMetadataTool.h:121

◆ 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 3012 of file SUSYObjDef_xAOD.cxx.

3015{
3016
3017 if (this->GetPrimVtx() == nullptr) {
3018 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!");
3019 }
3020
3021 ATH_CHECK( m_orToolbox.masterTool->removeOverlaps(electrons, muons, jets, taujet, gamma, fatjets) );
3022
3023 /*
3024 // Count number of objects after overlap removal
3025 int Nel = 0;
3026 for (const auto& el : *electrons) {
3027 if (dec_passOR( *el )) Nel++;
3028 }
3029
3030 int Nmu = 0;
3031 for (const auto& mu : *muons) {
3032 if (dec_passOR( *mu )) Nmu++;
3033 }
3034
3035 int Njet = 0;
3036 for (const auto& jet : *jets) {
3037 if (dec_passOR( *jet )) Njet++;
3038 }
3039
3040 ATH_MSG_VERBOSE( "After overlap removal: Nel=" << Nel << ", Nmu=" << Nmu << ", Njet=" << Njet );
3041 */
3042
3043 return StatusCode::SUCCESS;
3044}

◆ 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}
ST::acc_lrtFilter
static const SG::ConstAccessor< char > acc_lrtFilter("passLRTFilter")

◆ prepareLRTMuons()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 74 of file Muons.cxx.

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

◆ print()

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

Print the state of the tool.

Implements asg::IAsgTool.

Reimplemented in AsgHelloTool, HI::HIPileupTool, JetBottomUpSoftDrop, JetConstituentsRetriever, JetDumper, JetFinder, JetFromPseudojet, JetModifiedMassDrop, JetPileupLabelingTool, JetPruner, JetPseudojetRetriever, JetReclusterer, JetReclusteringTool, JetRecTool, JetRecursiveSoftDrop, JetSoftDrop, JetSplitter, JetSubStructureMomentToolsBase, JetToolRunner, JetTrimmer, JetTruthLabelingTool, and KtDeltaRTool.

Definition at line 131 of file AsgTool.cxx.

131 {
132
133 ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
134 return;
135 }

◆ readConfig()

StatusCode ST::SUSYObjDef_xAOD::readConfig ( )
finaloverrideprotectedvirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 1361 of file SUSYObjDef_xAOD.cxx.

1362{
1363 ATH_MSG_INFO( "***** ***** ***** *****" );
1364 ATH_MSG_INFO( "Configuring from file " << m_configFile );
1365
1366 TEnv rEnv;
1367 int success = -1;
1368 success = rEnv.ReadFile(m_configFile.c_str(), kEnvAll);
1369 if (success != 0) return StatusCode::FAILURE;
1370
1371 ATH_MSG_INFO( "Config file opened" );
1372
1373 if (m_jetInputType == xAOD::JetInput::Uncategorized) {
1374 m_jetInputType = xAOD::JetInput::Type(rEnv.GetValue("Jet.InputType", 9));
1375 ATH_MSG_INFO( "readConfig(): Loaded property Jet.InputType with value " << static_cast<int>(m_jetInputType));
1376 }
1377 // Remove the item from the table
1378 rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject("Jet.InputType") );
1379
1380 if (m_muId == static_cast<int>(xAOD::Muon::Quality::VeryLoose)) {
1381 int muIdTmp = rEnv.GetValue("Muon.Id", 1);
1382 m_muId = (muIdTmp<4 ? static_cast<int>(xAOD::Muon::Quality(muIdTmp)) : muIdTmp);
1383 ATH_MSG_INFO( "readConfig(): Loaded property Muon.Id with value " << m_muId);
1384 // Remove the item from the table
1385 rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject("Muon.Id") );
1386 }
1387 if (m_muIdBaseline == static_cast<int>(xAOD::Muon::Quality::VeryLoose)) {
1388 int muIdTmp = rEnv.GetValue("MuonBaseline.Id", 1);
1389 m_muIdBaseline = (muIdTmp<4 ? static_cast<int>(xAOD::Muon::Quality(muIdTmp)) : muIdTmp);
1390 ATH_MSG_INFO( "readConfig(): Loaded property MuonBaseline.Id with value " << m_muIdBaseline);
1391 // Remove the item from the table
1392 rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject("MuonBaseline.Id") );
1393 }
1394
1395 // Deprecation warning
1396 std::string prop = rEnv.GetValue("Jet.JVT_WP", "");
1397 if ( !prop.empty() ) {
1398 ATH_MSG_WARNING("readConfig(): Found deprecated property name Jet.JVT_WP. Please move to using Jet.JvtWP. Propagating for now.");
1399 rEnv.SetValue("Jet.JvtWP", prop.c_str());
1400 rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject("Jet.JVT_WP") );
1401 }
1402
1403 //load config file to Properties map (only booleans for now)
1404 m_conf_to_prop["IsRun3"] = "IsRun3";
1405 m_conf_to_prop["StrictConfigCheck"] = "StrictConfigCheck";
1406 m_conf_to_prop["Btag.enable"] = "UseBtagging";
1407 m_conf_to_prop["BtagTrkJet.enable"] = "UseBtaggingTrkJet";
1408 m_conf_to_prop["Ele.CrackVeto"] = "EleCrackVeto";
1409 m_conf_to_prop["EleBaseline.CrackVeto"] = "EleBaselineCrackVeto";
1410 m_conf_to_prop["Ele.ForceNoId"] = "EleForceNoId";
1411 m_conf_to_prop["Ele.AllowRun3TrigSFFallback"] = "EleAllowRun3TrigSFFallback";
1412 m_conf_to_prop["Muon.ForceNoId"] = "MuonForceNoId";
1413 m_conf_to_prop["Muon.TTVASF"] = "MuonTTVASF";
1414 m_conf_to_prop["Muon.passedHighPt"] = "MuonRequireHighPtCuts";
1415 m_conf_to_prop["PhotonBaseline.CrackVeto"] = "PhotonBaselineCrackVeto";
1416 m_conf_to_prop["Photon.CrackVeto"] = "PhotonCrackVeto";
1417 m_conf_to_prop["Photon.AllowLate"] = "PhotonAllowLate";
1418
1419 m_conf_to_prop["FwdJet.doJVT"] = "FwdJetDoJVT";
1420
1421 m_conf_to_prop["OR.DoBoostedElectron"] = "DoBoostedElectronOR";
1422 m_conf_to_prop["OR.DoBoostedMuon"] = "DoBoostedMuonOR";
1423 m_conf_to_prop["OR.DoMuonJetGhostAssociation"] = "ORDoMuonJetGhostAssociation";
1424 m_conf_to_prop["OR.DoTau"] = "DoTauOR";
1425 m_conf_to_prop["OR.DoPhoton"] = "DoPhotonOR";
1426 m_conf_to_prop["OR.DoEleJet"] = "DoEleJetOR";
1427 m_conf_to_prop["OR.DoElEl"] = "DoElElOR";
1428 m_conf_to_prop["OR.DoElMu"] = "DoElMuOR";
1429 m_conf_to_prop["OR.DoMuonJet"] = "DoMuonJetOR";
1430 m_conf_to_prop["OR.Bjet"] = "DoBjetOR";
1431 m_conf_to_prop["OR.ElBjet"] = "DoElBjetOR";
1432 m_conf_to_prop["OR.MuBjet"] = "DoMuBjetOR";
1433 m_conf_to_prop["OR.TauBjet"] = "DoTauBjetOR";
1434 m_conf_to_prop["OR.DoFatJets"] = "DoFatJetOR";
1435 m_conf_to_prop["OR.RemoveCaloMuons"] = "ORRemoveCaloMuons";
1436 m_conf_to_prop["OR.MuJetApplyRelPt"] = "ORMuJetApplyRelPt";
1437 m_conf_to_prop["OR.InputLabel"] = "ORInputLabel";
1438 m_conf_to_prop["Trigger.UpstreamMatching"] = "TriggerUpstreamMatching";
1439
1440 m_conf_to_prop["SigLep.RequireIso"] = "SigLepRequireIso";
1441 m_conf_to_prop["SigEl.RequireIso"] = "SigElRequireIso";
1442 m_conf_to_prop["SigMu.RequireIso"] = "SigMuRequireIso";
1443 m_conf_to_prop["SigPh.RequireIso"] = "SigPhRequireIso";
1444 m_conf_to_prop["SigLepPh.IsoCloseByOR"] = "SigLepPhIsoCloseByOR";
1445 m_conf_to_prop["MET.RemoveOverlappingCaloTaggedMuons"] = "METRemoveORCaloTaggedMuons";
1446 m_conf_to_prop["MET.DoSetMuonJetEMScale"] = "METDoSetMuonJetEMScale";
1447 m_conf_to_prop["MET.DoRemoveMuonJets"] = "METDoRemoveMuonJets";
1448 m_conf_to_prop["MET.DoUseGhostMuons"] = "METUseGhostMuons";
1449 m_conf_to_prop["MET.DoMuonEloss"] = "METDoMuonEloss";
1450
1451 m_conf_to_prop["MET.DoTrkSyst"] = "METDoTrkSyst";
1452 m_conf_to_prop["MET.DoCaloSyst"] = "METDoCaloSyst";
1453
1454 m_conf_to_prop["Tau.DoTruthMatching"] = "TauDoTruthMatching";
1455 //
1456
1457 configFromFile(m_slices["ele"], "Slices.Ele", rEnv, true);
1458 configFromFile(m_slices["pho"], "Slices.Pho", rEnv, true);
1459 configFromFile(m_slices["mu"], "Slices.Mu", rEnv, true);
1460 configFromFile(m_slices["tau"], "Slices.Tau", rEnv, true);
1461 configFromFile(m_slices["jet"], "Slices.Jet", rEnv, true);
1462 configFromFile(m_slices["bjet"], "Slices.BJet", rEnv, true);
1463 configFromFile(m_slices["fjet"], "Slices.FJet", rEnv, true);
1464 configFromFile(m_slices["tjet"], "Slices.TJet", rEnv, true);
1465 configFromFile(m_slices["met"], "Slices.MET", rEnv, true);
1466 //
1467 configFromFile(m_isRun3, "IsRun3", rEnv, false);
1468 //
1469 configFromFile(m_eleBaselinePt, "EleBaseline.Pt", rEnv, 10000.);
1470 configFromFile(m_eleBaselineEta, "EleBaseline.Eta", rEnv, 2.47);
1471 configFromFile(m_eleIdBaseline, "EleBaseline.Id", rEnv, "LooseAndBLayerLLH");
1472 configFromFile(m_eleBaselineIso_WP, "EleBaseline.Iso", rEnv, "None");
1473 configFromFile(m_eleConfigBaseline, "EleBaseline.Config", rEnv, "None");
1474 configFromFile(m_eleBaselineCrackVeto, "EleBaseline.CrackVeto", rEnv, false);
1475 configFromFile(m_force_noElId, "Ele.ForceNoId", rEnv, false);
1476
1477 //
1478 configFromFile(m_elePt, "Ele.Et", rEnv, 25000.);
1479 configFromFile(m_eleEta, "Ele.Eta", rEnv, 2.47);
1480 configFromFile(m_eleCrackVeto, "Ele.CrackVeto", rEnv, false);
1481 configFromFile(m_eleIso_WP, "Ele.Iso", rEnv, "Loose_VarRad");
1482 configFromFile(m_eleIsoHighPt_WP, "Ele.IsoHighPt", rEnv, "HighPtCaloOnly");
1483 configFromFile(m_eleIsoHighPtThresh, "Ele.IsoHighPtThresh", rEnv, 200e3);
1484 configFromFile(m_eleChID_WP, "Ele.CFT", rEnv, "None"); // Loose is the only one supported for the moment, and not many clients yet.
1485 configFromFile(m_eleChIso, "Ele.CFTIso", rEnv, true); // use charge ID SFs without iso applied
1486 configFromFile(m_eleChID_signal, "Ele.CFTSignal", rEnv, !m_eleChID_WP.empty()); // Require ECID as part of the signal lepton definition
1487 configFromFile(m_eleId, "Ele.Id", rEnv, "TightLLH");
1488 configFromFile(m_eleLRT, "Ele.LRTOR", rEnv, false);
1489 configFromFile(m_eleLRT_strat, "Ele.LRTORStrat", rEnv, 0);
1490 configFromFile(m_eleConfig, "Ele.Config", rEnv, "None");
1491 configFromFile(m_eled0sig, "Ele.d0sig", rEnv, 5.);
1492 configFromFile(m_elez0, "Ele.z0", rEnv, 0.5);
1493 configFromFile(m_elebaselined0sig, "EleBaseline.d0sig", rEnv, -99.);
1494 configFromFile(m_elebaselinez0, "EleBaseline.z0", rEnv, 0.5);
1495 configFromFile(m_eleIdExpert, "Ele.IdExpert", rEnv, false);
1496 configFromFile(m_EG_corrModel, "Ele.EffNPcorrModel", rEnv, "TOTAL");
1497 configFromFile(m_EG_corrFNList, "Ele.EffCorrFNList", rEnv, "None");
1498 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");
1499 configFromFile(m_eleEffMapFilePath, "Ele.EffMapFilePath", rEnv, "ElectronEfficiencyCorrection/2015_2025/rel22.2/2026_Run2Run3_Recommendation_v2/map1.txt");
1500 configFromFile(m_eleAllowRun3TrigSFFallback, "Ele.AllowRun3TrigSFFallback", rEnv, false);
1501 configFromFile(m_eleForceFullSimCalib, "Ele.ForceFullSimCalib", rEnv, false);
1502
1503 configFromFile(m_trig2015combination_singleLep, "Trig.Singlelep2015", rEnv, "e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose || mu20_iloose_L1MU15_OR_mu40");
1504 configFromFile(m_trig2016combination_singleLep, "Trig.Singlelep2016", rEnv, "e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0 || mu26_ivarmedium_OR_mu50");
1505 configFromFile(m_trig2017combination_singleLep, "Trig.Singlelep2017", rEnv, "e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0 || mu26_ivarmedium_OR_mu50");
1506 configFromFile(m_trig2018combination_singleLep, "Trig.Singlelep2018", rEnv, "e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0 || mu26_ivarmedium_OR_mu50");
1507 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");
1508 configFromFile(m_trig2023combination_singleLep, "Trig.Singlelep2023", rEnv, "e26_lhtight_ivarloose_L1eEM26M_OR_e60_lhmedium_L1eEM26M_OR_e140_lhloose_L1eEM26M || HLT_mu24_ivarmedium_L1MU14FCH_OR_HLT_mu50_L1MU14FCH");
1509 configFromFile(m_trig2024combination_singleLep, "Trig.Singlelep2024", rEnv, "e26_lhtight_ivarloose_L1eEM26M_OR_e60_lhmedium_L1eEM26M_OR_e140_lhloose_L1eEM26M || HLT_mu24_ivarmedium_L1MU14FCH_OR_HLT_mu50_L1MU14FCH");
1510 configFromFile(m_trigNToys_diLep, "Trig.DilepNToys", rEnv, 250); // 0 means calculate from formula instead - needs to be supported for the trigger combination
1511 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");
1512 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");
1513 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");
1514 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");
1515 // configFromFile(m_trig2022combination_diLep, "Trig.Dilep2022", rEnv, "");
1516 configFromFile(m_trigNToys_multiLep, "Trig.MultiNToys", rEnv, 250); // 0 means calculate from formula instead - needs to be supported for the trigger combination
1517 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");
1518 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");
1519 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");
1520 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");
1521 // configFromFile(m_trig2022combination_multiLep, "Trig.Multi2022", rEnv, "");
1522 configFromFile(m_trigNToys_diPhoton, "Trig.DiphotonNToys", rEnv, 250); // 0 means calculate from formula instead - needs to be supported for the trigger combination
1523 configFromFile(m_trig2015combination_diPhoton, "Trig.Diphoton2015", rEnv, "g35_loose_g25_loose");
1524 configFromFile(m_trig2016combination_diPhoton, "Trig.Diphotonp2016", rEnv, "g35_loose_g25_loose");
1525 configFromFile(m_trig2017combination_diPhoton, "Trig.Diphotonp2017", rEnv, "g35_medium_g25_medium_L12EM20VH");
1526 configFromFile(m_trig2018combination_diPhoton, "Trig.Diphotonp2018", rEnv, "g35_medium_g25_medium_L12EM20VH");
1527 // configFromFile(m_trig2018combination_diPhoton, "Trig.Diphotonp2022", rEnv, "");
1528 //
1529 configFromFile(m_muBaselinePt, "MuonBaseline.Pt", rEnv, 10000.);
1530 configFromFile(m_muBaselineEta, "MuonBaseline.Eta", rEnv, 2.7);
1531 configFromFile(m_force_noMuId, "Muon.ForceNoId", rEnv, false);
1532 configFromFile(m_muBaselineIso_WP, "MuonBaseline.Iso", rEnv, "None");
1533 configFromFile(m_doTTVAsf, "Muon.TTVASF", rEnv, true);
1534 //
1535 configFromFile(m_muPt, "Muon.Pt", rEnv, 25000.);
1536 configFromFile(m_muEta, "Muon.Eta", rEnv, 2.7);
1537 configFromFile(m_muIso_WP, "Muon.Iso", rEnv, "Loose_VarRad");
1538 configFromFile(m_muIsoHighPt_WP, "Muon.IsoHighPt", rEnv, "Loose_VarRad");
1539 configFromFile(m_muIsoHighPtThresh, "Muon.IsoHighPtThresh", rEnv, 200e3);
1540 configFromFile(m_mud0sig, "Muon.d0sig", rEnv, 3.);
1541 configFromFile(m_muz0, "Muon.z0", rEnv, 0.5);
1542 configFromFile(m_mubaselined0sig, "MuonBaseline.d0sig", rEnv, -99.);
1543 configFromFile(m_mubaselinez0, "MuonBaseline.z0", rEnv, 0.5);
1544 configFromFile(m_murequirepassedHighPtCuts, "Muon.passedHighPt", rEnv, false);
1545 configFromFile(m_muHighPtExtraSmear, "Muon.HighPtExtraSmear", rEnv, false);
1546 configFromFile(m_muEffCorrForce1D, "Muon.EffCorrForce1D", rEnv, false);
1547 //
1548 configFromFile(m_muTriggerSFCalibRelease, "Muon.TriggerSFCalibRelease" ,rEnv, "None");
1549 configFromFile(m_muTriggerSFCalibFilename, "Muon.TriggerSFCalibFilename",rEnv, "None");
1550 //
1551 configFromFile(m_muCosmicz0, "MuonCosmic.z0", rEnv, 1.);
1552 configFromFile(m_muCosmicd0, "MuonCosmic.d0", rEnv, 0.2);
1553 //
1554 // LRT muons
1555 configFromFile(m_muLRT, "Muon.LRTOR", rEnv, false);
1556 //
1557 configFromFile(m_badmuQoverP, "BadMuon.qoverp", rEnv, 0.4);
1558 //
1559 configFromFile(m_muCalibrationMode, "Muon.CalibrationMode", rEnv, 0); // 0: correctData_CB
1560 //
1561 configFromFile(m_photonBaselinePt, "PhotonBaseline.Pt", rEnv, 25000.);
1562 configFromFile(m_photonBaselineEta, "PhotonBaseline.Eta", rEnv, 2.37);
1563 configFromFile(m_photonIdBaseline, "PhotonBaseline.Id", rEnv, "Tight");
1564 configFromFile(m_photonBaselineCrackVeto, "PhotonBaseline.CrackVeto", rEnv, true);
1565 configFromFile(m_photonBaselineIso_WP, "PhotonBaseline.Iso", rEnv, "None");
1566 //
1567 configFromFile(m_photonPt, "Photon.Pt", rEnv, 130000.);
1568 configFromFile(m_photonEta, "Photon.Eta", rEnv, 2.37);
1569 configFromFile(m_photonId, "Photon.Id", rEnv, "Tight");
1570 configFromFile(m_photonIso_WP, "Photon.Iso", rEnv, "FixedCutTight");
1571 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
1572 configFromFile(m_photonCrackVeto, "Photon.CrackVeto", rEnv, true);
1573 configFromFile(m_photonAllowLate, "Photon.AllowLate", rEnv, false);
1574 //
1575 configFromFile(m_tauPrePtCut, "Tau.PrePtCut", rEnv, 0.);
1576 configFromFile(m_tauPt, "Tau.Pt", rEnv, 20000.);
1577 configFromFile(m_tauEta, "Tau.Eta", rEnv, 2.5);
1578 configFromFile(m_tauTagger, "Tau.Tagger", rEnv, "RNN");
1579 configFromFile(m_tauId, "Tau.Id", rEnv, "Medium");
1580 configFromFile(m_tauEleId, "Tau.EleId", rEnv, true);
1581 configFromFile(m_tauMuOLR, "Tau.MuOLR", rEnv, false);
1582 configFromFile(m_tauConfigPath, "Tau.ConfigPath", rEnv, "default");
1583 configFromFile(m_tauIdBaseline, "TauBaseline.Id", rEnv, "Medium");
1584 configFromFile(m_tauEleIdBaseline, "TauBaseline.EleId", rEnv, true);
1585 configFromFile(m_tauMuOLRBaseline, "TauBaseline.MuOLR", rEnv, false);
1586 configFromFile(m_tauConfigPathBaseline, "TauBaseline.ConfigPath", rEnv, "default");
1587 configFromFile(m_tauDoTTM, "Tau.DoTruthMatching", rEnv, false);
1588 //
1589 configFromFile(m_tauSmearingToolRecommendationTag,"Tau.SmearingToolRecommendationTag", rEnv, "2025-prerec");
1590 configFromFile(m_tauEffToolRecommendationTag,"Tau.EffToolRecommendationTag", rEnv, "2025-prerec");
1591 configFromFile(m_ApplyMVATESQualityCheck, "Tau.MVATESQualityCheck", rEnv, true);
1592 //
1593 configFromFile(m_jetPt, "Jet.Pt", rEnv, 20000.);
1594 configFromFile(m_jetEta, "Jet.Eta", rEnv, 2.8);
1595 configFromFile(m_JvtWP, "Jet.JvtWP", rEnv, "FixedEffPt"); // https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/PileupJetRecommendations
1596 configFromFile(m_JvtPtMax, "Jet.JvtPtMax", rEnv, 60.0e3);
1597 configFromFile(m_JvtConfigRun2, "Jet.JvtConfigRun2", rEnv, "JetJvtEfficiency/May2024/NNJvtSFFile_Run2_EMPFlow.root", true); // empty string means dummy SF
1598 configFromFile(m_JvtConfigRun3, "Jet.JvtConfigRun3", rEnv, "JetJvtEfficiency/May2024/NNJvtSFFile_Run3_EMPFlow.root", true); // empty string means dummy SF
1599 configFromFile(m_jetUncertaintiesConfig, "Jet.UncertConfig", rEnv, getDefaultJetUncConfig() ); // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/JetUncertaintiesRel22/
1600 configFromFile(m_jetUncertaintiesAnalysisFile, "Jet.AnalysisFile", rEnv, "default"); // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/JetUncertaintiesRel21Summer2018SmallR
1601 configFromFile(m_jetUncertaintiesCalibArea, "Jet.UncertCalibArea", rEnv, "default"); // Defaults to default area set by tool
1602 configFromFile(m_jetUncertaintiesMCType, "Jet.UncertMCType", rEnv, "", true); // empty string means the MCType is guessed
1603 configFromFile(m_jetUncertaintiesPDsmearing, "Jet.UncertPDsmearing", rEnv, true); // 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.
1604 configFromFile(m_fatJets, "Jet.LargeRcollection", rEnv, "AntiKt10UFOCSSKSoftDropBeta100Zcut10Jets"); // set to "None" to turn off large jets
1605 configFromFile(m_fatJetUncConfig, "Jet.LargeRuncConfig", rEnv, "rel22/Spring2025_PreRec/R10_CategoryJES_FullJER_FullJMS.config");
1606 configFromFile(m_fatJetUncertaintiesPDsmearing, "Jet.LargeRUncertPDsmearing", rEnv, true); // 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.
1607 configFromFile(m_fatJetUncVars, "Jet.LargeRuncVars", rEnv, "default"); // do all if not specified
1608 configFromFile(m_WtagConfig, "Jet.WtaggerConfig", rEnv, "SmoothedContainedWTagger_AntiKt10UFOCSSKSoftDrop_FixedSignalEfficiency80_20220221.dat");
1609 configFromFile(m_ZtagConfig, "Jet.ZtaggerConfig", rEnv, "SmoothedContainedZTagger_AntiKt10UFOCSSKSoftDrop_FixedSignalEfficiency80_20220221.dat");
1610 configFromFile(m_WZTaggerCalibArea, "Jet.WZTaggerCalibArea", rEnv, "Winter2024_R22_PreRecs/SmoothedWZTaggers/");
1611 configFromFile(m_ToptagConfig, "Jet.ToptaggerConfig", rEnv, "DNNTagger_AntiKt10UFOSD_TopInclusive80_Oct30.dat");
1612 configFromFile(m_TopTaggerCalibArea, "Jet.TopTaggerCalibArea", rEnv, "Winter2024_R22_PreRecs/JSSWTopTaggerDNN/");
1613 configFromFile(m_JetTruthLabelName, "Jet.JetTruthLabelName", rEnv, "R10TruthLabel_R22v1");
1614 // Properties of the large-R truth labelling tool
1615 configFromFile(m_fatUngroomedTruthJets, "Jet.JetUngrLargeRTruthCollection", rEnv, "AntiKt10TruthJets");
1616 configFromFile(m_fatTruthJets, "Jet.JetLargeRTruthCollection", rEnv, "AntiKt10TruthSoftDropBeta100Zcut10Jets");
1617 configFromFile(m_getTruthGroomedJetValues, "Jet.GetTruthGroomedJetValues", rEnv, true);
1618 configFromFile(m_matchUngroomedParent, "Jet.MatchUngroomedParent", rEnv, true);
1619 configFromFile(m_dRTruthJet, "Jet.dRTruthJet", rEnv, 0.75);
1620 // JES/JER/JMS/JMR
1621 configFromFile(m_jesConfig, "Jet.JESConfig", rEnv, m_isRun3 ? "AntiKt4EMPFlow_MC23a_PreRecR22_Phase2_CalibConfig_ResPU_EtaJES_GSC_241208_InSitu.config" : "PreRec_R22_PFlow_ResPU_EtaJES_GSC_February23_230215.config"); //https://twiki.cern.ch/twiki/bin/view/AtlasProtected/ApplyJetCalibrationR22
1622 configFromFile(m_jesConfigAFII, "Jet.JESConfigAFII", rEnv, m_isRun3 ? "AntiKt4EMPFlow_MC23a_PreRecR22_Phase2_CalibConfig_ResPU_EtaJES_GSC_241208_InSitu.config" : "PreRec_R22_PFlow_ResPU_EtaJES_GSC_February23_230215.config");
1623 configFromFile(m_jesConfigJMS, "Jet.JESConfigJMS", rEnv, "JES_JMS_MC16Recommendation_Consolidated_MC_only_EMTopo_July2019_Rel21.config");
1624 configFromFile(m_jesConfigJMSData, "Jet.JESConfigJMSData", rEnv, "JES_JMS_MC16Recommendation_Consolidated_data_only_EMTopo_Sep2019_Rel21.config");
1625 configFromFile(m_jesConfigFat, "Jet.JESConfigFat", rEnv, "JES_MC20PreRecommendation_R10_UFO_CSSK_SoftDrop_JMS_R21Insitu_26Nov2024.config");
1626 configFromFile(m_jesConfigFatData, "Jet.JESConfigFatData", rEnv, "JES_MC20PreRecommendation_R10_UFO_CSSK_SoftDrop_JMS_R21Insitu_26Nov2024.config");
1627 configFromFile(m_jesCalibSeq, "Jet.CalibSeq", rEnv, "JetArea_Residual_EtaJES_GSC_Insitu");
1628 configFromFile(m_jesCalibSeqJMS, "Jet.CalibSeqJMS", rEnv, "JetArea_Residual_EtaJES_GSC");
1629 configFromFile(m_jesCalibSeqFat, "Jet.CalibSeqFat", rEnv, "EtaJES_JMS");
1630 configFromFile(m_jesCalibArea, "Jet.CalibArea", rEnv, m_isRun3 ? "00-04-83" : "00-04-82");
1631 //
1632 configFromFile(m_defaultTrackJets, "TrackJet.Coll", rEnv, "AntiKtVR30Rmax4Rmin02TrackJets");
1633 configFromFile(m_trkJetPt, "TrackJet.Pt", rEnv, 20000.);
1634 configFromFile(m_trkJetEta, "TrackJet.Eta", rEnv, 2.8);
1635 //
1636 configFromFile(m_badJetCut, "BadJet.Cut", rEnv, "LooseBad");
1637 //
1638 configFromFile(m_doFwdJVT, "FwdJet.doJVT", rEnv, false); // https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/PileupJetRecommendations
1639 configFromFile(m_fJvtWP, "FwdJet.JvtWP", rEnv, "Loose");
1640 configFromFile(m_fJvtPtMax, "FwdJet.JvtPtMax", rEnv, 60e3);
1641 configFromFile(m_fJvtEtaMin, "FwdJet.JvtEtaMin", rEnv, 2.5);
1642 configFromFile(m_fJvtConfigRun2, "FwdJet.JvtConfigRun2", rEnv, "JetJvtEfficiency/May2024/fJvtSFFile_Run2_EMPFlow.root", true); // empty string means dummy SF
1643 configFromFile(m_fJvtConfigRun3, "FwdJet.JvtConfigRun3", rEnv, "JetJvtEfficiency/May2024/fJvtSFFile_Run2_EMPFlow.root", true); // empty string means dummy SF
1644 configFromFile(m_JMScalib, "Jet.JMSCalib", rEnv, false);
1645 //
1646 configFromFile(m_useBtagging, "Btag.enable", rEnv, true);
1647 configFromFile(m_BtagTagger, "Btag.Tagger", rEnv, "GN2v01");
1648 configFromFile(m_BtagWP, "Btag.WP", rEnv, "Continuous");
1649 configFromFile(m_BtagMinPt, "Btag.MinPt", rEnv, -1.); // Not calibrated below 20
1650
1651 configFromFile(m_bTaggingCalibrationFilePath, "Btag.CalibPath", rEnv, m_isRun3 ? "xAODBTaggingEfficiency/13p6TeV/MC23_2026_05_13_GN2v01_v0.root": "xAODBTaggingEfficiency/13TeV/MC20_2025-06-17_GN2v01_v4.root");
1652 configFromFile(m_BtagSystStrategy, "Btag.SystStrategy", rEnv, "SFEigen");
1653 configFromFile(m_EigenvectorReductionB, "Btag.EigenvectorReductionB", rEnv, "Loose");
1654 configFromFile(m_EigenvectorReductionC, "Btag.EigenvectorReductionC", rEnv, "Loose");
1655 configFromFile(m_EigenvectorReductionLight, "Btag.EigenvectorReductionLight", rEnv, "Loose");
1656 configFromFile(m_BtagReadFromObject, "Btag.ReadFromObject", rEnv, false);
1657
1658 configFromFile(m_useBtagging_trkJet, "BtagTrkJet.enable", rEnv, true);
1659 configFromFile(m_BtagTagger_trkJet, "BtagTrkJet.Tagger", rEnv, "DL1r");
1660 configFromFile(m_BtagWP_trkJet, "BtagTrkJet.WP", rEnv, "FixedCutBEff_77");
1661 configFromFile(m_BtagMinPt_trkJet, "BtagTrkJet.MinPt", rEnv, -1.); // Not calibrated below 10
1662 configFromFile(m_BtagReadFromObject_trkJet, "BtagTrkJet.ReadFromObject", rEnv, false);
1663 //
1664 configFromFile(m_orDoBoostedElectron, "OR.DoBoostedElectron", rEnv, true);
1665 configFromFile(m_orBoostedElectronC1, "OR.BoostedElectronC1", rEnv, -999.); // set to positive number to override default
1666 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)
1667 configFromFile(m_orBoostedElectronMaxConeSize, "OR.BoostedElectronMaxConeSize", rEnv, -999.); // set to positive number to override default
1668 configFromFile(m_orDoBoostedMuon, "OR.DoBoostedMuon", rEnv, true);
1669 configFromFile(m_orBoostedMuonC1, "OR.BoostedMuonC1", rEnv, -999.); // set to positive number to override default
1670 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)
1671 configFromFile(m_orBoostedMuonMaxConeSize, "OR.BoostedMuonMaxConeSize", rEnv, -999.); // set to positive number to override default
1672 configFromFile(m_orDoMuonJetGhostAssociation, "OR.DoMuonJetGhostAssociation", rEnv, true);
1673 configFromFile(m_orDoTau, "OR.DoTau", rEnv, false);
1674 configFromFile(m_orDoPhoton, "OR.DoPhoton", rEnv, false);
1675 configFromFile(m_orDoEleJet, "OR.EleJet", rEnv, true);
1676 configFromFile(m_orDoElEl, "OR.ElEl", rEnv, false);
1677 configFromFile(m_orDoElMu, "OR.ElMu", rEnv, false);
1678 configFromFile(m_orDoMuonJet, "OR.MuonJet", rEnv, true);
1679 configFromFile(m_orDoBjet, "OR.Bjet", rEnv, false);
1680 configFromFile(m_orDoElBjet, "OR.ElBjet", rEnv, false);
1681 configFromFile(m_orDoMuBjet, "OR.MuBjet", rEnv, false);
1682 configFromFile(m_orDoTauBjet, "OR.TauBjet", rEnv, false);
1683 configFromFile(m_orApplyRelPt, "OR.MuJetApplyRelPt", rEnv, false);
1684 configFromFile(m_orMuJetPtRatio, "OR.MuJetPtRatio", rEnv, -999.);
1685 configFromFile(m_orMuJetTrkPtRatio, "OR.MuJetTrkPtRatio", rEnv, -999.);
1686 configFromFile(m_orRemoveCaloMuons, "OR.RemoveCaloMuons", rEnv, true);
1687 configFromFile(m_orMuJetInnerDR, "OR.MuJetInnerDR", rEnv, -999.);
1688 configFromFile(m_orBtagWP, "OR.BtagWP", rEnv, "FixedCutBEff_85");
1689 configFromFile(m_orInputLabel, "OR.InputLabel", rEnv, "selected"); //"baseline"
1690 configFromFile(m_orPhotonFavoured, "OR.PhotonFavoured", rEnv, false);
1691 configFromFile(m_orBJetPtUpperThres, "OR.BJetPtUpperThres", rEnv, -1.); // upper pt threshold of b-jet in OR in unit of MeV, -1 means no pt threshold
1692 configFromFile(m_orLinkOverlapObjects, "OR.LinkOverlapObjects", rEnv, false);
1693 //
1694 configFromFile(m_orDoFatjets, "OR.DoFatJets", rEnv, false);
1695 configFromFile(m_EleFatJetDR, "OR.EleFatJetDR", rEnv, -999.);
1696 configFromFile(m_JetFatJetDR, "OR.JetFatJetDR", rEnv, -999.);
1697 //
1698 configFromFile(m_upstreamTriggerMatching, "Trigger.UpstreamMatching", rEnv, false);
1699 configFromFile(m_trigMatchingPrefix, "Trigger.MatchingPrefix", rEnv, "", true);
1700 //
1701 configFromFile(m_doIsoSignal, "SigLep.RequireIso", rEnv, true);
1702 configFromFile(m_doElIsoSignal, "SigEl.RequireIso", rEnv, m_doIsoSignal);
1703 configFromFile(m_doMuIsoSignal, "SigMu.RequireIso", rEnv, m_doIsoSignal);
1704 configFromFile(m_doPhIsoSignal, "SigPh.RequireIso", rEnv, m_doIsoSignal);
1705 configFromFile(m_useSigLepForIsoCloseByOR, "SigLepPh.UseSigLepForIsoCloseByOR", rEnv, false);
1706 configFromFile(m_IsoCloseByORpassLabel, "SigLepPh.IsoCloseByORpassLabel", rEnv, "None");
1707
1708 //
1709 configFromFile(m_eleTerm, "MET.EleTerm", rEnv, "RefEle");
1710 configFromFile(m_gammaTerm, "MET.GammaTerm", rEnv, "RefGamma");
1711 configFromFile(m_tauTerm, "MET.TauTerm", rEnv, "RefTau");
1712 configFromFile(m_jetTerm, "MET.JetTerm", rEnv, "RefJet");
1713 configFromFile(m_muonTerm, "MET.MuonTerm", rEnv, "Muons");
1714 configFromFile(m_inputMETSuffix, "MET.InputSuffix", rEnv, "", true); // May be empty
1715 configFromFile(m_outMETTerm, "MET.OutputTerm", rEnv, "Final");
1716 configFromFile(m_metRemoveOverlappingCaloTaggedMuons, "MET.RemoveOverlappingCaloTaggedMuons", rEnv, true);
1717 configFromFile(m_metDoSetMuonJetEMScale, "Met.DoSetMuonJetEMScale", rEnv, true);
1718 configFromFile(m_metDoRemoveMuonJets, "MET.DoRemoveMuonJets", rEnv, true);
1719 configFromFile(m_metUseGhostMuons, "MET.UseGhostMuons", rEnv, false);
1720 configFromFile(m_metDoMuonEloss, "MET.DoMuonEloss", rEnv, false);
1721 configFromFile(m_metGreedyPhotons, "MET.DoGreedyPhotons", rEnv, false);
1722 configFromFile(m_metVeryGreedyPhotons, "MET.DoVeryGreedyPhotons", rEnv, false);
1723
1724 configFromFile(m_trkMETsyst, "MET.DoTrkSyst", rEnv, true);
1725 configFromFile(m_caloMETsyst, "MET.DoCaloSyst", rEnv, false);
1726 configFromFile(m_trkJetsyst, "MET.DoTrkJetSyst", rEnv, false);
1727 configFromFile(m_metsysConfigPrefix, "METSys.ConfigPrefix", rEnv, "METUtilities/R22_PreRecs");
1728 configFromFile(m_metJetSelection, "MET.JetSelection", rEnv, "Tight"); // Loose, Tight (default), Tighter, Tenacious
1729 configFromFile(m_softTermParam, "METSig.SoftTermParam", rEnv, met::Random);
1730 configFromFile(m_treatPUJets, "METSig.TreatPUJets", rEnv, true);
1731 configFromFile(m_doPhiReso, "METSig.DoPhiReso", rEnv, false);
1732 //
1733 configFromFile(m_prwActualMu2017File, "PRW.ActualMu2017File", rEnv, "GoodRunsLists/data17_13TeV/20180619/physics_25ns_Triggerno17e33prim.actualMu.OflLumi-13TeV-010.root");
1734 configFromFile(m_prwActualMu2018File, "PRW.ActualMu2018File", rEnv, "GoodRunsLists/data18_13TeV/20190318/physics_25ns_Triggerno17e33prim.actualMu.OflLumi-13TeV-010.root");
1735 configFromFile(m_prwActualMu2022File, "PRW.ActualMu2022File", rEnv, "GoodRunsLists/data22_13p6TeV/20250321/purw.actualMu.root");
1736 configFromFile(m_prwActualMu2023File, "PRW.ActualMu2023File", rEnv, "GoodRunsLists/data23_13p6TeV/20250321/purw.actualMu.root");
1737 configFromFile(m_prwActualMu2024File, "PRW.ActualMu2024File", rEnv, "GoodRunsLists/data24_13p6TeV/20260127/purw.actualMu.root");
1738 configFromFile(m_prwActualMu2025File, "PRW.ActualMu2025File", rEnv, "GoodRunsLists/data25_13p6TeV/20260129/purw.actualMu.root");
1739 configFromFile(m_prwDataSF, "PRW.DataSF", rEnv, 1./1.03); // default for mc16, see: https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/ExtendedPileupReweighting#Tool_Properties
1740 configFromFile(m_prwDataSF_UP, "PRW.DataSF_UP", rEnv, 1./0.99); // mc16 uncertainty? defaulting to the value in PRWtool
1741 configFromFile(m_prwDataSF_DW, "PRW.DataSF_DW", rEnv, 1./1.07); // mc16 uncertainty? defaulting to the value in PRWtool
1742 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.
1743 configFromFile(m_autoconfigPRWPath, "PRW.autoconfigPRWPath", rEnv, "dev/PileupReweighting/share/");
1744 configFromFile(m_autoconfigPRWFile, "PRW.autoconfigPRWFile", rEnv, "None");
1745 configFromFile(m_autoconfigPRWCombinedmode, "PRW.autoconfigPRWCombinedmode", rEnv, false);
1746 configFromFile(m_autoconfigPRWRPVmode, "PRW.autoconfigPRWRPVmode", rEnv, false);
1747 configFromFile(m_autoconfigPRWRtags, "PRW.autoconfigPRWRtags", rEnv, "mc20a:r13167_r14859,mc20d:r13144_r14860,mc20e:r13145_r14861,mc23a:r14622_r14932_r15540,mc23d:r15224_r15530,mc23e:r16083,mc23g:r17610"); // Tag details here: https://twiki.cern.ch/twiki/bin/view/AtlasProtected/AtlasProductionGroup
1748 configFromFile(m_commonPRWFileMC20a, "PRW.commonPRWFileMC20a", rEnv, "PileupReweighting/mc20_common/mc20a.284500.physlite.prw.v1.root");
1749 configFromFile(m_commonPRWFileMC20d, "PRW.commonPRWFileMC20d", rEnv, "PileupReweighting/mc20_common/mc20d.300000.physlite.prw.v1.root");
1750 configFromFile(m_commonPRWFileMC20e, "PRW.commonPRWFileMC20e", rEnv, "PileupReweighting/mc20_common/mc20e.310000.physlite.prw.v1.root");
1751 configFromFile(m_commonPRWFileMC23a, "PRW.commonPRWFileMC23a", rEnv, "PileupReweighting/mc23_common/mc23a.410000.physlite.prw.v2.root");
1752 configFromFile(m_commonPRWFileMC23d, "PRW.commonPRWFileMC23d", rEnv, "PileupReweighting/mc23_common/mc23d.450000.physlite.prw.v1.root");
1753 configFromFile(m_commonPRWFileMC23e, "PRW.commonPRWFileMC23e", rEnv, "PileupReweighting/mc23_common/mc23e.470000.physlite.prw.v1.root");
1754 configFromFile(m_commonPRWFileMC23g, "PRW.commonPRWFileMC23g", rEnv, "PileupReweighting/mc23_common/mc23g.495000.physlite.prw.v1.root");
1755 //
1756 configFromFile(m_strictConfigCheck, "StrictConfigCheck", rEnv, false);
1757
1758 // Translate tau config names
1759 if(!m_tauConfigPathBaseline.empty()) { //baseline taus
1760 m_tauInputFileBaseline = m_tauConfigPathBaseline;
1761 if( m_tauConfigPathBaseline=="default" ) {
1762 if (m_tauTagger == "RNN") m_tauInputFileBaseline = "SUSYTools/tau_selection";
1763 else if (m_tauTagger == "GNTau") m_tauInputFileBaseline = "SUSYTools/tau_selection_gntau";
1764 else if (m_tauTagger == "LowPt") m_tauInputFileBaseline = "SUSYTools/tau_selection_lowpt";
1765 else {
1766 ATH_MSG_ERROR("Invalid tau ID selected: " << m_tauTagger << " - " << m_tauIdBaseline);
1767 return StatusCode::FAILURE;
1768 }
1769 std::string tauWPLC = m_tauIdBaseline;
1770 std::transform(tauWPLC.begin(), tauWPLC.end(), tauWPLC.begin(), [](unsigned char c) { return std::tolower(c); });
1771 // wp
1772 m_tauInputFileBaseline += "_"+tauWPLC;
1773 // eleid & muOLR
1774 m_tauInputFileBaseline += (m_tauEleIdBaseline ? "_eleid" : "_noeleid");
1775 m_tauInputFileBaseline += (m_tauMuOLRBaseline ? "_muonolr" : "");
1776 m_tauInputFileBaseline += ".conf";
1777 }
1778 ANA_MSG_INFO("configFromFile(): Parsed Tau Baseline Config input: " << m_tauInputFileBaseline);
1779 }
1780 if(!m_tauConfigPathBaseline.empty()) { //signal taus
1781 m_tauInputFile = m_tauConfigPath;
1782 if( m_tauConfigPath=="default" ) {
1783 if (m_tauTagger == "RNN") m_tauInputFile = "SUSYTools/tau_selection";
1784 else if (m_tauTagger == "GNTau") m_tauInputFile = "SUSYTools/tau_selection_gntau";
1785 else if (m_tauTagger == "LowPt") m_tauInputFile = "SUSYTools/tau_selection_lowpt";
1786 else {
1787 ATH_MSG_ERROR("Invalid tau ID selected: " << m_tauTagger << " - " << m_tauId);
1788 return StatusCode::FAILURE;
1789 }
1790 std::string tauWPLC = m_tauId;
1791 std::transform(tauWPLC.begin(), tauWPLC.end(), tauWPLC.begin(), [](unsigned char c) { return std::tolower(c); });
1792 // wp
1793 m_tauInputFile += "_"+tauWPLC;
1794 // eleid & muOLR
1795 m_tauInputFile += (m_tauEleId ? "_eleid" : "_noeleid");
1796 m_tauInputFile += (m_tauMuOLR ? "_muonolr" : "");
1797 m_tauInputFile += ".conf";
1798 }
1799 ANA_MSG_INFO("configFromFile(): Parsed Tau Signal Config input: " << m_tauInputFile);
1800 }
1801
1802 // By now rEnv should be empty!
1803 if (rEnv.GetTable() && rEnv.GetTable()->GetSize()>0){
1804 ATH_MSG_ERROR("Found " << rEnv.GetTable()->GetSize() << " unparsed environment options:");
1805 rEnv.Print();
1806 ATH_MSG_ERROR("Please fix your configuration!");
1807 return StatusCode::FAILURE;
1808 }
1809
1810 // Set up the correct configuration files for the large-R jet tagging corresponding to the input tagger config
1811 if (!m_WtagConfig.empty()) {
1812 if (m_WtagConfig.find("Efficiency50") != std::string::npos){
1813 m_WTagUncConfig = "R10_SF_LCTopo_WTag_SigEff50.config";
1814 }
1815 else if (m_WtagConfig.find("Efficiency80") != std::string::npos){
1816 m_WTagUncConfig = "R10_SF_LCTopo_WTag_SigEff80.config";
1817 }
1818 else {
1819 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");
1820 }
1821 }
1822 if (!m_ZtagConfig.empty()) {
1823 if (m_ZtagConfig.find("Efficiency50") != std::string::npos){
1824 m_ZTagUncConfig = "R10_SF_LCTopo_ZTag_SigEff50.config";
1825 }
1826 else if (m_ZtagConfig.find("Efficiency80") != std::string::npos){
1827 m_ZTagUncConfig = "R10_SF_LCTopo_ZTag_SigEff80.config";
1828 }
1829 else {
1830 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");
1831 }
1832 }
1833 std::string TopTagEff = "";
1834 std::string TopTagType = "";
1835 if (!m_ToptagConfig.empty()) {
1836 if (m_ToptagConfig.find("50") != std::string::npos){
1837 TopTagEff = "50";
1838 }
1839 else if (m_ToptagConfig.find("80") != std::string::npos){
1840 TopTagEff = "80";
1841 }
1842 else {
1843 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");
1844 }
1845 //
1846 if (m_ToptagConfig.find("Inclusive") != std::string::npos){
1847 TopTagType = "Inclusive";
1848 }
1849 else if (m_ToptagConfig.find("Contained") != std::string::npos){
1850 TopTagType = "Contained";
1851 }
1852 else {
1853 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");
1854 }
1855 m_TopTagUncConfig = "R10_SF_LCTopo_TopTag"+TopTagType+"_SigEff"+TopTagEff+".config";
1856 }
1857
1858 //** validate configuration
1859 ATH_CHECK( validConfig(m_strictConfigCheck) );
1860
1861 //** cache trigger chains for electron matching
1862 GetTriggerTokens(m_electronTriggerSFStringSingle, m_v_trigs15_cache_singleEle, m_v_trigs16_cache_singleEle, m_v_trigs17_cache_singleEle, m_v_trigs18_cache_singleEle, m_v_trigs22_cache_singleEle, m_v_trigs23_cache_singleEle, m_v_trigs24_cache_singleEle);
1863
1864 //** cache trigger chains for matching (both electrons and muons)
1865 GetTriggerTokens(m_electronTriggerSFStringSingle, m_v_trigs15_cache_singleEle, m_v_trigs16_cache_singleEle, m_v_trigs17_cache_singleEle, m_v_trigs18_cache_singleEle, m_v_trigs22_cache_singleEle, m_v_trigs23_cache_singleEle, m_v_trigs24_cache_singleEle);
1866
1867 m_v_trigs15_cache_singleLep = GetTriggerOR(m_trig2015combination_singleLep);
1868 m_v_trigs16_cache_singleLep = GetTriggerOR(m_trig2016combination_singleLep);
1869 m_v_trigs17_cache_singleLep = GetTriggerOR(m_trig2017combination_singleLep);
1870 m_v_trigs18_cache_singleLep = GetTriggerOR(m_trig2018combination_singleLep);
1871 m_v_trigs22_cache_singleLep = GetTriggerOR(m_trig2022combination_singleLep);
1872 m_v_trigs23_cache_singleLep = GetTriggerOR(m_trig2023combination_singleLep);
1873 m_v_trigs24_cache_singleLep = GetTriggerOR(m_trig2024combination_singleLep);
1874
1875 m_v_trigs15_cache_diLep = GetTriggerOR(m_trig2015combination_diLep);
1876 m_v_trigs16_cache_diLep = GetTriggerOR(m_trig2016combination_diLep);
1877 m_v_trigs17_cache_diLep = GetTriggerOR(m_trig2017combination_diLep);
1878 m_v_trigs18_cache_diLep = GetTriggerOR(m_trig2018combination_diLep);
1879 m_v_trigs22_cache_diLep = GetTriggerOR(m_trig2022combination_diLep);
1880
1881 m_v_trigs15_cache_multiLep = GetTriggerOR(m_trig2015combination_multiLep);
1882 m_v_trigs16_cache_multiLep = GetTriggerOR(m_trig2016combination_multiLep);
1883 m_v_trigs17_cache_multiLep = GetTriggerOR(m_trig2017combination_multiLep);
1884 m_v_trigs18_cache_multiLep = GetTriggerOR(m_trig2018combination_multiLep);
1885 m_v_trigs22_cache_multiLep = GetTriggerOR(m_trig2022combination_multiLep);
1886
1887 return StatusCode::SUCCESS;
1888}
ANA_MSG_INFO
#define ANA_MSG_INFO(xmsg,...)
Macro printing info messages.
Definition Control/AthToolSupport/AsgMessaging/AsgMessaging/MessageCheck.h:291
ST::SUSYObjDef_xAOD::m_v_trigs23_cache_singleLep
std::vector< std::string > m_v_trigs23_cache_singleLep
Definition SUSYObjDef_xAOD.h:465
ST::SUSYObjDef_xAOD::m_v_trigs18_cache_multiLep
std::vector< std::string > m_v_trigs18_cache_multiLep
Definition SUSYObjDef_xAOD.h:477
ST::SUSYObjDef_xAOD::m_jesConfig
std::string m_jesConfig
Definition SUSYObjDef_xAOD.h:873
ST::SUSYObjDef_xAOD::m_jesCalibSeq
std::string m_jesCalibSeq
Definition SUSYObjDef_xAOD.h:879
ST::SUSYObjDef_xAOD::m_jesConfigJMS
std::string m_jesConfigJMS
Definition SUSYObjDef_xAOD.h:874
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 > &, std::vector< std::string > &, std::vector< std::string > &) const
Definition Trigger.cxx:332
ST::SUSYObjDef_xAOD::m_v_trigs22_cache_diLep
std::vector< std::string > m_v_trigs22_cache_diLep
Definition SUSYObjDef_xAOD.h:472
ST::SUSYObjDef_xAOD::m_jetUncertaintiesConfig
std::string m_jetUncertaintiesConfig
Prefix for trigger matchiing container name.
Definition SUSYObjDef_xAOD.h:531
ST::SUSYObjDef_xAOD::m_jetUncertaintiesCalibArea
std::string m_jetUncertaintiesCalibArea
Definition SUSYObjDef_xAOD.h:533
ST::SUSYObjDef_xAOD::m_v_trigs17_cache_multiLep
std::vector< std::string > m_v_trigs17_cache_multiLep
Definition SUSYObjDef_xAOD.h:476
ST::SUSYObjDef_xAOD::m_v_trigs22_cache_singleLep
std::vector< std::string > m_v_trigs22_cache_singleLep
Definition SUSYObjDef_xAOD.h:464
ST::SUSYObjDef_xAOD::m_v_trigs15_cache_multiLep
std::vector< std::string > m_v_trigs15_cache_multiLep
Definition SUSYObjDef_xAOD.h:474
ST::SUSYObjDef_xAOD::m_v_trigs17_cache_diLep
std::vector< std::string > m_v_trigs17_cache_diLep
Definition SUSYObjDef_xAOD.h:470
ST::SUSYObjDef_xAOD::m_v_trigs18_cache_singleLep
std::vector< std::string > m_v_trigs18_cache_singleLep
Definition SUSYObjDef_xAOD.h:463
ST::SUSYObjDef_xAOD::m_jesConfigJMSData
std::string m_jesConfigJMSData
Definition SUSYObjDef_xAOD.h:875
ST::SUSYObjDef_xAOD::m_v_trigs15_cache_diLep
std::vector< std::string > m_v_trigs15_cache_diLep
Definition SUSYObjDef_xAOD.h:468
ST::SUSYObjDef_xAOD::m_jesCalibArea
std::string m_jesCalibArea
Definition SUSYObjDef_xAOD.h:882
ST::SUSYObjDef_xAOD::m_v_trigs22_cache_multiLep
std::vector< std::string > m_v_trigs22_cache_multiLep
Definition SUSYObjDef_xAOD.h:478
ST::SUSYObjDef_xAOD::validConfig
StatusCode validConfig(bool strict=false) const
Definition SUSYObjDef_xAOD.cxx:2034
ST::SUSYObjDef_xAOD::m_jesCalibSeqJMS
std::string m_jesCalibSeqJMS
Definition SUSYObjDef_xAOD.h:880
ST::SUSYObjDef_xAOD::m_v_trigs24_cache_singleLep
std::vector< std::string > m_v_trigs24_cache_singleLep
Definition SUSYObjDef_xAOD.h:466
ST::SUSYObjDef_xAOD::m_v_trigs18_cache_diLep
std::vector< std::string > m_v_trigs18_cache_diLep
Definition SUSYObjDef_xAOD.h:471
ST::SUSYObjDef_xAOD::m_v_trigs16_cache_multiLep
std::vector< std::string > m_v_trigs16_cache_multiLep
Definition SUSYObjDef_xAOD.h:475
ST::SUSYObjDef_xAOD::m_jesConfigAFII
std::string m_jesConfigAFII
Definition SUSYObjDef_xAOD.h:876
ST::SUSYObjDef_xAOD::m_v_trigs16_cache_singleLep
std::vector< std::string > m_v_trigs16_cache_singleLep
Definition SUSYObjDef_xAOD.h:461
ST::SUSYObjDef_xAOD::m_v_trigs16_cache_diLep
std::vector< std::string > m_v_trigs16_cache_diLep
Definition SUSYObjDef_xAOD.h:469
ST::SUSYObjDef_xAOD::m_jetUncertaintiesAnalysisFile
std::string m_jetUncertaintiesAnalysisFile
Definition SUSYObjDef_xAOD.h:532
ST::SUSYObjDef_xAOD::m_jetUncertaintiesMCType
std::string m_jetUncertaintiesMCType
Definition SUSYObjDef_xAOD.h:534
ST::SUSYObjDef_xAOD::m_jesConfigFat
std::string m_jesConfigFat
Definition SUSYObjDef_xAOD.h:877
ST::SUSYObjDef_xAOD::configFromFile
void configFromFile(bool &property, const std::string &propname, TEnv &rEnv, bool defaultValue)
Definition SUSYObjDef_xAOD.cxx:1284
ST::SUSYObjDef_xAOD::m_v_trigs15_cache_singleLep
std::vector< std::string > m_v_trigs15_cache_singleLep
Definition SUSYObjDef_xAOD.h:460
ST::SUSYObjDef_xAOD::getDefaultJetUncConfig
std::string getDefaultJetUncConfig()
Definition SUSYObjDef_xAOD.cxx:1915
ST::SUSYObjDef_xAOD::m_v_trigs17_cache_singleLep
std::vector< std::string > m_v_trigs17_cache_singleLep
Definition SUSYObjDef_xAOD.h:462
ST::SUSYObjDef_xAOD::m_jesConfigFatData
std::string m_jesConfigFatData
Definition SUSYObjDef_xAOD.h:878
ST::SUSYObjDef_xAOD::m_jesCalibSeqFat
std::string m_jesCalibSeqFat
Definition SUSYObjDef_xAOD.h:881

◆ 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 368 of file AthCommonDataStore.h.

369 {
370 h.renounce();
371 PBASE::renounce (h);
372 }
AthCommonDataStore::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 > renounce(T &h)
Definition AthCommonDataStore.h:368

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 352 of file AthCommonDataStore.h.

352 {
353 handlesArray.renounce();
354 }

◆ resetSystematics()

StatusCode ST::SUSYObjDef_xAOD::resetSystematics ( )
finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2173 of file SUSYObjDef_xAOD.cxx.

2173 {
2174 return this->applySystematicVariation(m_defaultSyst);
2175}
ST::SUSYObjDef_xAOD::applySystematicVariation
StatusCode applySystematicVariation(const CP::SystematicSet &systConfig) override final
Definition SUSYObjDef_xAOD.cxx:2219
ST::SUSYObjDef_xAOD::m_defaultSyst
CP::SystematicSet m_defaultSyst
Definition SUSYObjDef_xAOD.h:832

◆ setBoolProperty()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 905 of file SUSYObjDef_xAOD.cxx.

905 {
906 m_bool_prop_set.insert(name);
907 return this->setProperty(name, property);
908}
setProperty
void setProperty(columnar::PythonToolHandle &self, const std::string &key, nb::object value)
Definition NanobindBindings.cxx:75

◆ 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 1173 of file Jets.cxx.

1173 {
1174 double weight = 0.;
1175 if ( btagSelTool->getTaggerWeight(input, weight, false/*useVetoWP=false*/) != CP::CorrectionCode::Ok ) {
1176 ATH_MSG_ERROR( btagSelTool->name() << ": could not retrieve b-tag weight (" << btagTagger << ")." );
1177 return StatusCode::FAILURE;
1178 }
1179 dec_btag_weight(input) = weight;
1180 ATH_MSG_DEBUG( btagSelTool->name() << " b-tag weight: " << weight );
1181
1182 double btag_pb(-10), btag_pc(-10), btag_pu(-10), btag_ptau(-10);
1183 // following name change is needed given different name is used for GN2v00 in derivation and in CDI
1184 std::string actualTagger = btagTagger;
1185 if (btagTagger == "GN2v00LegacyWP" || btagTagger == "GN2v00NewAliasWP"){
1186 actualTagger = "GN2v00";
1187 }
1188 SG::ConstAccessor<float> pbTaggerAcc (actualTagger+"_pb");
1189 SG::ConstAccessor<float> pcTaggerAcc (actualTagger+"_pc");
1190 SG::ConstAccessor<float> puTaggerAcc (actualTagger+"_pu");
1191 SG::ConstAccessor<float> ptauTaggerAcc (actualTagger+"_ptau");
1192 if (pbTaggerAcc.isAvailable(input) && pcTaggerAcc.isAvailable(input)
1193 && puTaggerAcc.isAvailable(input) && ptauTaggerAcc.isAvailable(input)) {
1194 btag_pb = pbTaggerAcc(input);
1195 btag_pc = pcTaggerAcc(input);
1196 btag_pu = puTaggerAcc(input);
1197 btag_ptau = ptauTaggerAcc(input);
1198 } else {
1199 xAOD::BTaggingUtilities::getBTagging(input)->pb(actualTagger, btag_pb);
1200 xAOD::BTaggingUtilities::getBTagging(input)->pc(actualTagger, btag_pc);
1201 xAOD::BTaggingUtilities::getBTagging(input)->pu(actualTagger, btag_pu);
1202 xAOD::BTaggingUtilities::getBTagging(input)->ptau(actualTagger, btag_ptau);
1203 }
1204 dec_btag_pb(input) = btag_pb;
1205 dec_btag_pc(input) = btag_pc;
1206 dec_btag_pu(input) = btag_pu;
1207 dec_btag_ptau(input) = btag_ptau;
1208 ATH_MSG_DEBUG( btagSelTool->name() << " b-tag " << btagTagger << "-type pb: " << btag_pb );
1209 ATH_MSG_DEBUG( btagSelTool->name() << " b-tag " << btagTagger << "-type pc: " << btag_pc );
1210 ATH_MSG_DEBUG( btagSelTool->name() << " b-tag " << btagTagger << "-type pu: " << btag_pu );
1211 ATH_MSG_DEBUG( btagSelTool->name() << " b-tag " << btagTagger << "-type ptau: " << btag_ptau );
1212
1213 return StatusCode::SUCCESS;
1214 }
IBTaggingSelectionTool::getTaggerWeight
virtual CP::CorrectionCode getTaggerWeight(const xAOD::Jet &jet, double &tagweight) const =0
xAOD::BTagging_v1::pc
bool pc(const std::string &taggername, double &value) const
Definition BTagging_v1.cxx:367
xAOD::BTagging_v1::pu
bool pu(const std::string &taggername, double &value) const
Definition BTagging_v1.cxx:353
xAOD::BTagging_v1::pb
bool pb(const std::string &taggername, double &value) const
Definition BTagging_v1.cxx:360
xAOD::BTagging_v1::ptau
bool ptau(const std::string &taggername, double &value) const
Definition BTagging_v1.cxx:374
ST::dec_btag_pc
static const SG::Decorator< float > dec_btag_pc("btag_pc")
ST::dec_btag_ptau
static const SG::Decorator< float > dec_btag_ptau("btag_ptau")
ST::dec_btag_pu
static const SG::Decorator< float > dec_btag_pu("btag_pu")
ST::dec_btag_pb
static const SG::Decorator< float > dec_btag_pb("btag_pb")
dqt_zlumi_pandas.weight
int weight
Definition dqt_zlumi_pandas.py:190
xAOD::BTaggingUtilities::getBTagging
const BTagging * getBTagging(const SG::AuxElement &part)
Access the default xAOD::BTagging object associated to an object.
Definition BTaggingUtilities.cxx:37

◆ setDataSource()

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

Definition at line 1233 of file SUSYObjDef_xAOD.cxx.

1233 {
1234 if (source == 0) m_dataSource = Data;
1235 else if (source == 1) m_dataSource = FullSim;
1236 else if (source == 2) m_dataSource = AtlfastII;
1237 else ATH_MSG_ERROR("Trying to set data source to unknown type (" << source << ")");
1238}

◆ setUseIncidents()

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

Definition at line 132 of file AsgMetadataTool.h.

133 {
134 m_useIncidents = flag;
135 }
master.flag
bool flag
Definition master.py:29

◆ split()

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

Definition at line 1891 of file SUSYObjDef_xAOD.cxx.

1891 {
1892 assert(delim.length() == 1);
1893 std::vector<std::string> retval;
1894 retval.reserve(std::count(s.begin(), s.end(), delim[0]) + 1);
1895 // if only 1
1896 if (s.find(delim)==std::string::npos) {
1897 retval.emplace_back(s);
1898 return retval;
1899 }
1900 // if need to split
1901 size_t last = 0;
1902 size_t next = 0;
1903 bool gothere=false;
1904 while ((next = s.find(delim, last)) != std::string::npos) {
1905 retval.emplace_back(s.substr(last, next - last));
1906 last = next + delim.length();
1907 gothere=true;
1908 }
1909 if(gothere)
1910 retval.emplace_back(s.substr(last));
1911
1912 return retval;
1913}
LArCellBinning_test.retval
retval
Definition LArCellBinning_test.py:112

◆ SUSYToolsInit()

StatusCode SUSYObjDef_xAOD::SUSYToolsInit ( )
private

Definition at line 112 of file SUSYToolsInit.cxx.

113{
114 if (m_dataSource < 0) {
115 ATH_MSG_FATAL("Data source incorrectly configured!!");
116 ATH_MSG_FATAL("You must set the DataSource property to Data, FullSim or AtlfastII !!");
117 ATH_MSG_FATAL("Expect segfaults if you're not checking status codes, which you should be !!");
118 return StatusCode::FAILURE;
119 }
120
121 if (m_subtool_init) {
122 ATH_MSG_INFO("SUSYTools subtools already created. Ignoring this call.");
123 ATH_MSG_INFO("Note: No longer necessary to explicitly call SUSYToolsInit. Will avoid creating tools again.");
124 return StatusCode::SUCCESS;
125 }
126
127 // /////////////////////////////////////////////////////////////////////////////////////////
128 // Initialise PileupReweighting Tool
129
130 if (!m_prwTool.isUserConfigured()) {
131 ATH_MSG_DEBUG("Will now init the PRW tool");
132 std::vector<std::string> file_conf;
133 for (UInt_t i = 0; i < m_prwConfFiles.size(); i++) {
134 ATH_MSG_INFO("Adding PRW file: " << m_prwConfFiles.at(i));
135 file_conf.push_back(m_prwConfFiles.at(i));
136 }
137
138 std::vector<std::string> file_ilumi;
139 for (UInt_t i = 0; i < m_prwLcalcFiles.size(); i++) {
140 ATH_MSG_INFO("Adding ilumicalc file: " << m_prwLcalcFiles.at(i));
141 file_ilumi.push_back(m_prwLcalcFiles.at(i));
142 }
143
144 m_prwTool.setTypeAndName("CP::PileupReweightingTool/PrwTool");
145 ATH_CHECK( m_prwTool.setProperty("ConfigFiles", file_conf) );
146 ATH_CHECK( m_prwTool.setProperty("LumiCalcFiles", file_ilumi) );
147 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
148 ATH_CHECK( m_prwTool.setProperty("DataScaleFactorUP", m_prwDataSF_UP) ); // 1. -> old value (mc15), as the one for mc16 is still missing
149 ATH_CHECK( m_prwTool.setProperty("DataScaleFactorDOWN", m_prwDataSF_DW) ); // 1./1.18 -> old value (mc15), as the one for mc16 is still missing
150 ATH_CHECK( m_prwTool.setProperty("TrigDecisionTool", m_trigDecTool.getHandle()) );
151 ATH_CHECK( m_prwTool.setProperty("UseRunDependentPrescaleWeight", m_runDepPrescaleWeightPRW) );
152 ATH_CHECK( m_prwTool.setProperty("OutputLevel", MSG::WARNING) );
153 ATH_CHECK( m_prwTool.retrieve() );
154 } else {
155 ATH_MSG_INFO("Using user-configured PRW tool");
156 ATH_CHECK( m_prwTool.retrieve() );
157 }
158
160 // Initialize LRT systematics tool
161 if (!m_LRTuncTool.isUserConfigured() && !isData())
162 {
163 ATH_MSG_INFO("Initializing LRT uncertainty tool");
164 m_LRTuncTool.setTypeAndName("InDet::InclusiveTrackFilterTool/LRTUncTool");
165 ATH_CHECK( m_LRTuncTool.setProperty("Seed", 1) );
166 if (m_isRun3) {
167 if (m_mcCampaign == "mc23d" || m_mcCampaign == "mc23e")
168 ATH_MSG_WARNING("Please note that current ID recommendations only cover mc23a and not (yet) mc23d/e!");
169 ATH_CHECK( m_LRTuncTool.setProperty("calibFileLRTEff", "InDetTrackSystematicsTools/CalibData_25.2_2025-v00/LargeD0TrackingRecommendations_mc23a.root") );
170 }
171 else
172 ATH_CHECK( m_LRTuncTool.setProperty("calibFileLRTEff", "InDetTrackSystematicsTools/CalibData_24.0_2023-v00/LargeD0TrackingRecommendations_20230824.root") );
173 ATH_CHECK(m_LRTuncTool.retrieve());
174 } else {
175 ATH_MSG_INFO("Using user-configured LRT uncertainty tool");
176 ATH_CHECK(m_LRTuncTool.retrieve());
177 }
178
179 std::string toolName; // to be used for tool init below, keeping explicit string constants a minimum /CO
180
181 std::string jetname,jetcoll,fatjetcoll;
182 if (m_slices["jet"]) {
184 // Initialise jet calibration tool
185
186 // pick the right config file for the JES tool : https://twiki.cern.ch/twiki/bin/view/AtlasProtected/ApplyJetCalibrationR22
187 jetname = "AntiKt4" + xAOD::JetInput::typeName(xAOD::JetInput::Type(m_jetInputType));
188 jetcoll = jetname + "Jets";
189
190 if (!m_jetCalibTool.isUserConfigured()) {
191 toolName = "JetCalibTool_" + jetname;
192 m_jetCalibTool.setTypeAndName("JetCalibrationTool/"+toolName);
193 std::string JES_config_file, calibseq;
194
195 if (m_jetInputType != xAOD::JetInput::EMPFlow) {
196 ATH_MSG_ERROR("Unknown (unsupported) jet collection is used, (m_jetInputType = " << m_jetInputType << ")");
197 return StatusCode::FAILURE;
198 }
199
200 std::string JESconfig = isAtlfast() ? m_jesConfigAFII : m_jesConfig;
201 if(isAtlfast() && m_isRun3) {
202 ATH_MSG_WARNING("Jet JES/JER recommendations currently not available for fast sim in Run 3, falling back to full sim version");
203 JESconfig = m_jesConfig;
204 }
205
206 calibseq = m_jesCalibSeq;
207 JES_config_file = JESconfig;
208
209 // remove Insitu if it's in the string if not data
210 if (!isData()) {
211 std::string insitu("_Insitu");
212 auto found = calibseq.find(insitu);
213 if(found != std::string::npos){
214 calibseq.erase(found, insitu.length());
215 }
216 }
217
218 // JMS calibration (if requested)
219 if (m_JMScalib){
220 ATH_MSG_ERROR("JMS calibration is not supported yet for R22. Please modify your settings.");
221 return StatusCode::FAILURE;
222 }
223
224 // now instantiate the tool
225 ATH_CHECK( m_jetCalibTool.setProperty("JetCollection", jetname) );
226 ATH_CHECK( m_jetCalibTool.setProperty("ConfigFile", JES_config_file) );
227 ATH_CHECK( m_jetCalibTool.setProperty("CalibSequence", calibseq) );
228 ATH_CHECK( m_jetCalibTool.setProperty("CalibArea", m_jesCalibArea) );
229 ATH_CHECK( m_jetCalibTool.setProperty("IsData", isData()) );
230 ATH_CHECK( m_jetCalibTool.setProperty("OutputLevel", this->msg().level()) );
231 ATH_CHECK( m_jetCalibTool.retrieve() );
232 } else ATH_CHECK(m_jetCalibTool.retrieve());
233 }
234
235 if (m_slices["fjet"]) {
236 //same for fat groomed jets
237 fatjetcoll = m_fatJets;
238
239 if(fatjetcoll == "AnalysisLargeRJets") {
240 ATH_MSG_DEBUG("Fall back to calibration for AntiKt10UFOCSSKSoftDropBeta100Zcut10Jets, original name for AnalysisLargeRJets");
241 fatjetcoll = "AntiKt10UFOCSSKSoftDropBeta100Zcut10Jets";
242 }
243 if (fatjetcoll.size()>3)fatjetcoll.erase(fatjetcoll.size()-4,4);
244 if (!m_jetFatCalibTool.isUserConfigured() && !m_fatJets.empty()) {
245 toolName = "JetFatCalibTool_" + m_fatJets;
246 m_jetFatCalibTool.setTypeAndName("JetCalibrationTool/"+toolName);
247
248 std::string jesConfigFat = m_jesConfigFat;
249 std::string jesCalibSeqFat = m_jesCalibSeqFat;
250 // add Insitu if data
251 if(isData()) jesCalibSeqFat += "_Insitu";
252
253 // now instantiate the tool
254 ATH_CHECK( m_jetFatCalibTool.setProperty("JetCollection", fatjetcoll) );
255 ATH_CHECK( m_jetFatCalibTool.setProperty("ConfigFile", jesConfigFat) );
256 ATH_CHECK( m_jetFatCalibTool.setProperty("CalibSequence", jesCalibSeqFat) );
257 // always set to false : https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/ApplyJetCalibrationR21
258 ATH_CHECK( m_jetFatCalibTool.setProperty("IsData", isData()) );
259 ATH_CHECK( m_jetFatCalibTool.setProperty("OutputLevel", this->msg().level()) );
260 ATH_CHECK( m_jetFatCalibTool.retrieve() );
261 } else if (m_jetFatCalibTool.isUserConfigured()) ATH_CHECK(m_jetFatCalibTool.retrieve());
262 }
263
264 if (m_slices["fjet"]) {
266 // Initialise Boson taggers: https://twiki.cern.ch/twiki/bin/view/AtlasProtected/BoostedJetTaggingRecommendationFullRun2#Higgs_taggers
267 if (!m_WTaggerTool.isUserConfigured() && !m_WtagConfig.empty()) {
268 m_WTaggerTool.setTypeAndName("SmoothedWZTagger/WTagger");
269 ATH_CHECK( m_WTaggerTool.setProperty("ContainerName", m_fatJets) );
270 ATH_CHECK( m_WTaggerTool.setProperty("ConfigFile", m_WtagConfig) );
271 ATH_CHECK( m_WTaggerTool.setProperty("CalibArea", m_WZTaggerCalibArea) );
272 ATH_CHECK( m_WTaggerTool.setProperty("IsMC",!isData()));
273#ifndef XAOD_STANDALONE
274 ATH_CHECK( m_WTaggerTool.setProperty("SuppressOutputDependence", true) );
275#endif
276 ATH_CHECK( m_WTaggerTool.setProperty("OutputLevel", this->msg().level()) );
277 ATH_CHECK( m_WTaggerTool.retrieve() );
278
279 // Retrieving DecorationName (needed to access tagging results downstream):
280 std::string WConfigPath = PathResolverFindCalibFile("BoostedJetTaggers/"+m_WZTaggerCalibArea+"/"+m_WtagConfig);
281 if ( m_WconfigReader.ReadFile( WConfigPath.c_str(), EEnvLevel(0) ) ) {
282 ATH_MSG_ERROR( "Error while reading large-R config file : " << WConfigPath );
283 return StatusCode::FAILURE;
284 }
285 else ATH_MSG_DEBUG( "Successfully read large-R config file : " << WConfigPath );
286
287 m_WDecorName = m_WconfigReader.GetValue("DecorationName" ,"");
288 ANA_MSG_DEBUG( "Found DecorationName in large-R config file : " << m_WDecorName );
289
290 } else if (m_WTaggerTool.isUserConfigured()) ATH_CHECK(m_WTaggerTool.retrieve());
291
292 if (!m_ZTaggerTool.isUserConfigured() && !m_ZtagConfig.empty()) {
293 m_ZTaggerTool.setTypeAndName("SmoothedWZTagger/ZTagger");
294 ATH_CHECK( m_ZTaggerTool.setProperty("ContainerName", m_fatJets) );
295 ATH_CHECK( m_ZTaggerTool.setProperty("ConfigFile", m_ZtagConfig) );
296 ATH_CHECK( m_ZTaggerTool.setProperty("CalibArea", m_WZTaggerCalibArea) );
297 ATH_CHECK( m_ZTaggerTool.setProperty("IsMC",!isData()));
298#ifndef XAOD_STANDALONE
299 ATH_CHECK( m_ZTaggerTool.setProperty("SuppressOutputDependence", true) );
300#endif
301 ATH_CHECK( m_ZTaggerTool.setProperty("OutputLevel", this->msg().level()) );
302 ATH_CHECK( m_ZTaggerTool.retrieve() );
303
304 // Retrieving DecorationName (needed to access tagging results downstream):
305 std::string ZConfigPath = PathResolverFindCalibFile("BoostedJetTaggers/"+m_WZTaggerCalibArea+"/"+m_ZtagConfig);
306 if ( m_ZconfigReader.ReadFile( ZConfigPath.c_str(), EEnvLevel(0) ) ) {
307 ATH_MSG_ERROR( "Error while reading large-R config file : " << ZConfigPath );
308 return StatusCode::FAILURE;
309 }
310 else ATH_MSG_DEBUG( "Successfully read large-R config file : " << ZConfigPath );
311
312 m_ZDecorName = m_ZconfigReader.GetValue("DecorationName" ,"");
313 ANA_MSG_DEBUG( "Found DecorationName in large-R config file : " << m_ZDecorName );
314
315 } else if (m_ZTaggerTool.isUserConfigured()) ATH_CHECK(m_ZTaggerTool.retrieve());
316
317 if (!m_TopTaggerTool.isUserConfigured() && !m_ToptagConfig.empty()) {
318 m_TopTaggerTool.setTypeAndName("JSSWTopTaggerDNN/TopTagger");
319 ATH_CHECK( m_TopTaggerTool.setProperty("ContainerName", m_fatJets) );
320 ATH_CHECK( m_TopTaggerTool.setProperty("ConfigFile", m_ToptagConfig) );
321 ATH_CHECK( m_TopTaggerTool.setProperty("CalibArea", m_TopTaggerCalibArea) );
322 ATH_CHECK( m_TopTaggerTool.setProperty("IsMC",!isData()));
323#ifndef XAOD_STANDALONE
324 ATH_CHECK( m_TopTaggerTool.setProperty("SuppressOutputDependence", true) );
325#endif
326 ATH_CHECK( m_TopTaggerTool.setProperty("OutputLevel", this->msg().level()) );
327 ATH_CHECK( m_TopTaggerTool.retrieve() );
328
329 // Retrieving DecorationName (needed to access tagging results downstream):
330 std::string TopConfigPath = PathResolverFindCalibFile("BoostedJetTaggers/"+m_TopTaggerCalibArea+"/"+m_ToptagConfig);
331 if ( m_TopconfigReader.ReadFile( TopConfigPath.c_str(), EEnvLevel(0) ) ) {
332 ATH_MSG_ERROR( "Error while reading large-R config file : " << TopConfigPath );
333 return StatusCode::FAILURE;
334 }
335 else ATH_MSG_DEBUG( "Successfully read large-R config file : " << TopConfigPath );
336
337 m_TopDecorName = m_TopconfigReader.GetValue("DecorationName" ,"");
338 ANA_MSG_DEBUG( "Found DecorationName in large-R config file : " << m_TopDecorName );
339
340 } else if (m_TopTaggerTool.isUserConfigured()) ATH_CHECK(m_TopTaggerTool.retrieve());
341
343 // Initialise JetTruthLabelingTool: https://twiki.cern.ch/twiki/bin/view/AtlasProtected/JetUncertaintiesRel21Summer2019LargeR#AnalysisBase_21_2_114_and_newer
344 if(!isData()) {
345 m_label_truthKey = fatjetcoll+"."+m_JetTruthLabelName;
346 ATH_CHECK(m_label_truthKey.initialize());
347
348 if (!m_jetTruthLabelingTool.isUserConfigured()) {
349 m_jetTruthLabelingTool.setTypeAndName("JetTruthLabelingTool/ST_JetTruthLabelingTool");
350 ATH_CHECK( m_jetTruthLabelingTool.setProperty("RecoJetContainer", m_fatJets) );
351 ATH_CHECK( m_jetTruthLabelingTool.setProperty("TruthJetContainer", m_fatUngroomedTruthJets) );
352 ATH_CHECK( m_jetTruthLabelingTool.setProperty("TruthGroomedJetContainer", m_fatTruthJets) );
353 ATH_CHECK( m_jetTruthLabelingTool.setProperty("GetTruthGroomedJetValues", m_getTruthGroomedJetValues) );
354 ATH_CHECK( m_jetTruthLabelingTool.setProperty("MatchUngroomedParent", m_matchUngroomedParent) );
355 ATH_CHECK( m_jetTruthLabelingTool.setProperty("dRTruthJet", m_dRTruthJet) );
356 ATH_CHECK( m_jetTruthLabelingTool.setProperty("TruthLabelName", m_JetTruthLabelName) );
357 ATH_CHECK( m_jetTruthLabelingTool.setProperty("OutputLevel", this->msg().level()) );
358 ATH_CHECK( m_jetTruthLabelingTool.retrieve() );
359 } else if (m_jetTruthLabelingTool.isUserConfigured()) ATH_CHECK(m_jetTruthLabelingTool.retrieve());
360 }
361 }
362
363 if (m_slices["jet"] || m_slices["fjet"]) {
364
365
367 // Initialise jet uncertainty tool
368 // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/JetUncertaintiesRel22
369 ATH_MSG_INFO("Set up Jet Uncertainty tool...");
370
371 // if not set, derive the MCType from the simulation type and MC campaign
372 if (m_jetUncertaintiesMCType.empty()) m_jetUncertaintiesMCType = m_isRun3 ? (isAtlfast() ? "MC23AF3" : "MC23") : (isAtlfast() ? "AF3" : "MC20");
373
374 // large-R jets use MC20AF3 instead of AF3
375 m_fatJetUncertaintiesMCType = m_jetUncertaintiesMCType;
376 if (m_fatJetUncertaintiesMCType == "AF3") {
377 m_fatJetUncertaintiesMCType = "MC20AF3";
378 }
379
380 if (!m_jetUncertaintiesTool.isUserConfigured()) {
381 std::string jetdef("AntiKt4" + xAOD::JetInput::typeName(xAOD::JetInput::Type(m_jetInputType)));
382
383 if(jetdef !="AntiKt4EMPFlow"){
384 ATH_MSG_WARNING("Jet Uncertaintes recommendations only exist for PFlow jets, falling back to AntiKt4EMPFlow");
385 jetdef = "AntiKt4EMPFlow";
386 }
387 toolName = "JetUncertaintiesTool_" + jetdef;
388
389 m_jetUncertaintiesTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
390
391 ATH_CHECK( m_jetUncertaintiesTool.setProperty("JetDefinition", jetdef) );
392 ATH_CHECK( m_jetUncertaintiesTool.setProperty("MCType", m_jetUncertaintiesMCType) );
393 ATH_CHECK( m_jetUncertaintiesTool.setProperty("IsData", false) ); // Never use the PDSmearing for the nominal tool.
394 ATH_CHECK( m_jetUncertaintiesTool.setProperty("ConfigFile", m_jetUncertaintiesConfig) );
395 if(m_jetUncertaintiesAnalysisFile!="default") ATH_CHECK( m_jetUncertaintiesTool.setProperty("AnalysisFile", m_jetUncertaintiesAnalysisFile) );
396 if (m_jetUncertaintiesCalibArea != "default") ATH_CHECK( m_jetUncertaintiesTool.setProperty("CalibArea", m_jetUncertaintiesCalibArea) );
397 ATH_CHECK( m_jetUncertaintiesTool.setProperty("OutputLevel", this->msg().level()) );
398 ATH_CHECK( m_jetUncertaintiesTool.retrieve() );
399 } else ATH_CHECK( m_jetUncertaintiesTool.retrieve() );
400
401 ATH_MSG_INFO("Set up Jet PD Smear Uncertainty tool...");
402
403 if (!m_jetUncertaintiesPDSmearTool.isUserConfigured() && m_jetUncertaintiesPDsmearing == true) {
404 std::string jetdef("AntiKt4" + xAOD::JetInput::typeName(xAOD::JetInput::Type(m_jetInputType)));
405
406 if(jetdef !="AntiKt4EMPFlow"){
407 ATH_MSG_WARNING("Jet Uncertaintes recommendations only exist for PFlow jets, falling back to AntiKt4EMPFlow");
408 jetdef = "AntiKt4EMPFlow";
409 }
410 toolName = "JetUncertaintiesPDSmearTool_" + jetdef;
411
412 m_jetUncertaintiesPDSmearTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
413
414 // 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.
415 bool JERUncPDsmearing = isData() ? isData() : m_jetUncertaintiesPDsmearing;
416 if (m_jetUncertaintiesConfig.find("SimpleJER") != std::string::npos && JERUncPDsmearing){
417 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.");
418 return StatusCode::FAILURE;
419 }
420 ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("JetDefinition", jetdef) );
421 ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("MCType", m_jetUncertaintiesMCType) );
422 ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("IsData", true) ); // Set to True by default for PDSmear-named tool.
423 ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("PseudoDataJERsmearingMode", true) );
424 ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("ConfigFile", m_jetUncertaintiesConfig) );
425 if (m_jetUncertaintiesCalibArea != "default") ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("CalibArea", m_jetUncertaintiesCalibArea) );
426 ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("OutputLevel", this->msg().level()) );
427 ATH_CHECK( m_jetUncertaintiesPDSmearTool.retrieve() );
428 } else{
429 ATH_MSG_DEBUG("Do not retrieve the jet PD Smearing tool if it is not configured");
430 //ATH_CHECK( m_jetUncertaintiesPDSmearTool.retrieve() );
431 }
432 }
433
434 if (m_slices["fjet"]) {
435
436 // JetUncertaintiesTool handles JES, JER and JMS uncertainties for large-R jets
437 if (!m_fatjetUncertaintiesTool.isUserConfigured() && !m_fatJets.empty() && !m_fatJetUncConfig.empty()) {
438
439 ATH_MSG_INFO("Set up Large-R Jet Uncertainty tool...");
440
441 // Print warning about missing large-R jets uncertainties for FastSim in mc23
442 if (m_isRun3 && isAtlfast())
443 ATH_MSG_WARNING("Uncertainties for large-R jets in mc23 and fast simulation not yet available; be aware uncertainties might be not complete!");
444
445 toolName = "JetUncertaintiesTool_" + m_fatJets;
446 m_fatjetUncertaintiesTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
447
448 ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("JetDefinition", fatjetcoll) );
449 ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("MCType", m_fatJetUncertaintiesMCType) );
450 ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("IsData", isData()) );
451 ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("ConfigFile", m_fatJetUncConfig) );
452 if (m_jetUncertaintiesCalibArea != "default") ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("CalibArea", m_jetUncertaintiesCalibArea) );
453
454 //Restrict variables to be shifted if (required)
455 if( m_fatJetUncVars != "default" ){
456 std::vector<std::string> shift_vars = {};
457
458 std::string temp(m_fatJetUncVars);
459 do {
460 auto pos = temp.find(',');
461 shift_vars.push_back(temp.substr(0, pos));
462 if (pos == std::string::npos)
463 temp = "";
464 else
465 temp = temp.substr(pos + 1);
466
467 }
468 while (!temp.empty() );
469
470 ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("VariablesToShift", shift_vars) );
471 }
472
473 ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("OutputLevel", this->msg().level()) );
474 ATH_CHECK( m_fatjetUncertaintiesTool.retrieve() );
475 } else if (m_fatjetUncertaintiesTool.isUserConfigured()) ATH_CHECK(m_fatjetUncertaintiesTool.retrieve());
476
477
478 if (!m_fatjetUncertaintiesPDSmearTool.isUserConfigured() && !m_fatJets.empty() && !m_fatJetUncConfig.empty() && m_fatJetUncertaintiesPDsmearing == true) {
479
480 ATH_MSG_INFO("Set up Jet PD Smear Uncertainty tool...");
481
482 toolName = "JetUncertaintiesPDSmearTool_" + m_fatJets;
483 m_fatjetUncertaintiesPDSmearTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
484
485 // 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.
486 bool JERUncPDsmearing = isData() ? isData() : m_fatJetUncertaintiesPDsmearing;
487 if (m_fatJetUncConfig.find("SimpleJER") != std::string::npos && JERUncPDsmearing){
488 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.");
489 return StatusCode::FAILURE;
490 }
491 ATH_CHECK( m_fatjetUncertaintiesPDSmearTool.setProperty("JetDefinition", fatjetcoll) );
492 ATH_CHECK( m_fatjetUncertaintiesPDSmearTool.setProperty("MCType", m_fatJetUncertaintiesMCType) );
493 ATH_CHECK( m_fatjetUncertaintiesPDSmearTool.setProperty("IsData", true) ); // Set to True by default for PDSmear-named tool.
494 ATH_CHECK( m_fatjetUncertaintiesPDSmearTool.setProperty("PseudoDataJERsmearingMode", true) );
495 ATH_CHECK( m_fatjetUncertaintiesPDSmearTool.setProperty("ConfigFile", m_fatJetUncConfig) );
496 if (m_jetUncertaintiesCalibArea != "default") ATH_CHECK( m_fatjetUncertaintiesPDSmearTool.setProperty("CalibArea", m_jetUncertaintiesCalibArea) );
497 ATH_CHECK( m_fatjetUncertaintiesPDSmearTool.setProperty("OutputLevel", this->msg().level()) );
498 ATH_CHECK( m_fatjetUncertaintiesPDSmearTool.retrieve() );
499 } else{
500 ATH_MSG_DEBUG("Do not retrieve the jet PD Smearing tool if it is not configured");
501 }
502
503
504 // FFSmearingTool handles JMR uncertainties for large-R jets
505 if (!m_fatjetFFSmearingTool.isUserConfigured() && !m_fatJets.empty() && !m_fatJetUncConfig.empty()) {
506
507 ATH_MSG_INFO("Set up Large-R FFJetSmearingTool ...");
508
509 toolName = "FFJetSmearingTool_" + m_fatJets;
510 m_fatjetFFSmearingTool.setTypeAndName("CP::FFJetSmearingTool/"+toolName);
511
512 ATH_CHECK( m_fatjetFFSmearingTool.setProperty("MassDef", "UFO") );
513 ATH_CHECK( m_fatjetFFSmearingTool.setProperty("MCType", m_fatJetUncertaintiesMCType) );
514 ATH_CHECK( m_fatjetFFSmearingTool.setProperty("ConfigFile", "rel22/Spring2025_PreRec/R10_FullJMR.config") );
515 ATH_CHECK( m_fatjetFFSmearingTool.setProperty("OutputLevel", this->msg().level()) );
516 ATH_CHECK( m_fatjetFFSmearingTool.retrieve() );
517 } else if (m_fatjetFFSmearingTool.isUserConfigured()) ATH_CHECK(m_fatjetFFSmearingTool.retrieve());
518
519 // Need to keep track of systematics of FFJetSmearingTool
520 if (!m_fatJets.empty()) {
521 // m_fatjetFFSmearingSyst = CP::make_systematics_vector(m_fatjetFFSmearingTool->recommendedSystematics());
522 ATH_MSG_INFO("The following uncertainties have been defined for the m_fatjetFFSmearingTool");
523 for (auto & sysSet : m_fatjetFFSmearingTool->recommendedSystematics()){
524 m_fatjetFFSmearingSyst.push_back(CP::SystematicSet({sysSet}));
525 ATH_MSG_INFO(" - " << sysSet.name());
526 }
527 }
528
529 ATH_MSG_INFO(" Won't initialise Wtagger uncertainty tool for fat jets until we get rec for UFO");
530 // Won't initialise Wtagger uncertainty tool for fat jets until we get rec for UFO
531 /*
532 if (!m_WTagjetUncertaintiesTool.isUserConfigured() && !m_fatJets.empty() && !m_WtagConfig.empty() && !m_WTagUncConfig.empty()) {
533
534 toolName = "WTagJetUncertaintiesTool_" + m_fatJets;
535 m_WTagjetUncertaintiesTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
536 ATH_CHECK( m_WTagjetUncertaintiesTool.setProperty("JetDefinition", fatjetcoll) );
537 ATH_CHECK( m_WTagjetUncertaintiesTool.setProperty("MCType", "MC16") );
538 ATH_CHECK( m_WTagjetUncertaintiesTool.setProperty("IsData", isData()) );
539 ATH_CHECK( m_WTagjetUncertaintiesTool.setProperty("ConfigFile", "rel21/Fall2020/"+m_WTagUncConfig) );
540 ATH_CHECK( m_WTagjetUncertaintiesTool.setProperty("OutputLevel", this->msg().level()) );
541 ATH_CHECK( m_WTagjetUncertaintiesTool.retrieve() );
542 } else if (m_WTagjetUncertaintiesTool.isUserConfigured()) ATH_CHECK(m_WTagjetUncertaintiesTool.retrieve());
543 */
544 ATH_MSG_INFO(" Won't initialise Ztagger uncertainty tool for fat jets until we get rec for UFO");
545 // Won't initialise Ztagger uncertainty tool for fat jets until we get rec for UFO
546 /*
547 if (!m_ZTagjetUncertaintiesTool.isUserConfigured() && !m_fatJets.empty() && !m_ZtagConfig.empty() && !m_ZTagUncConfig.empty()) {
548
549 toolName = "ZTagJetUncertaintiesTool_" + m_fatJets;
550 m_ZTagjetUncertaintiesTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
551 ATH_CHECK( m_ZTagjetUncertaintiesTool.setProperty("JetDefinition", fatjetcoll) );
552 ATH_CHECK( m_ZTagjetUncertaintiesTool.setProperty("ConfigFile", "rel21/Fall2020/"+m_ZTagUncConfig) );
553 ATH_CHECK( m_ZTagjetUncertaintiesTool.setProperty("MCType", "MC16") );
554 ATH_CHECK( m_ZTagjetUncertaintiesTool.setProperty("IsData", isData()) );
555 ATH_CHECK( m_ZTagjetUncertaintiesTool.setProperty("OutputLevel", this->msg().level()) );
556 ATH_CHECK( m_ZTagjetUncertaintiesTool.retrieve() );
557 } else if (m_ZTagjetUncertaintiesTool.isUserConfigured()) ATH_CHECK(m_ZTagjetUncertaintiesTool.retrieve());
558 */
559 ATH_MSG_INFO(" Won't initialise top-tagger uncertainty tool for fat jets until we get rec for UFO");
560 // Won't initialise top-tagger uncertainty tool for fat jets until we get rec for UFO
561 /*
562 if (!m_TopTagjetUncertaintiesTool.isUserConfigured() && !m_fatJets.empty() && !m_ToptagConfig.empty() && !m_TopTagUncConfig.empty()) {
563
564 toolName = "TopTagJetUncertaintiesTool_" + m_fatJets;
565 m_TopTagjetUncertaintiesTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
566 ATH_CHECK( m_TopTagjetUncertaintiesTool.setProperty("JetDefinition", fatjetcoll) );
567 ATH_CHECK( m_TopTagjetUncertaintiesTool.setProperty("MCType", "MC16") );
568 ATH_CHECK( m_TopTagjetUncertaintiesTool.setProperty("IsData", isData()) );
569 ATH_CHECK( m_TopTagjetUncertaintiesTool.setProperty("ConfigFile", "rel21/Fall2020/"+m_TopTagUncConfig) );
570 ATH_CHECK( m_TopTagjetUncertaintiesTool.setProperty("OutputLevel", this->msg().level()) );
571 ATH_CHECK( m_TopTagjetUncertaintiesTool.retrieve() );
572 } else if (m_TopTagjetUncertaintiesTool.isUserConfigured()) ATH_CHECK(m_TopTagjetUncertaintiesTool.retrieve());
573 */
574 }
575
576
577 // tagger SF and uncertainties
578 // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/BoostedJetTaggingRecommendationFullRun2
579 // To be implemented here
580
581 if (m_slices["jet"]) {
583 // Initialise jet cleaning tools
584
585 // see https://twiki.cern.ch/twiki/bin/view/AtlasProtected/HowToCleanJetsR22
586 if (m_badJetCut!="" && !m_jetCleaningTool.isUserConfigured()) {
587 toolName = "JetCleaningTool";
588 m_jetCleaningTool.setTypeAndName("JetCleaningTool/"+toolName);
589 ATH_CHECK( m_jetCleaningTool.setProperty("CutLevel", m_badJetCut) );
590 ATH_CHECK( m_jetCleaningTool.setProperty("DoUgly", false) );
591 ATH_CHECK( m_jetCleaningTool.setProperty("OutputLevel", this->msg().level()) );
592 ATH_CHECK( m_jetCleaningTool.retrieve() );
593 } else if (m_jetCleaningTool.isUserConfigured()) ATH_CHECK( m_jetCleaningTool.retrieve() );
594
596 // Initialise jet pileup labeling tool (required for labels used by JvtEfficiencyTools)
597
598 if(!m_jetPileupLabelingTool.isUserConfigured() && !isData()) {
599 toolName = "PileupLabelingTool";
600 m_jetPileupLabelingTool.setTypeAndName("JetPileupLabelingTool/"+toolName);
601 ATH_CHECK( m_jetPileupLabelingTool.setProperty("RecoJetContainer", m_defaultJets) );
602 ATH_CHECK( m_jetPileupLabelingTool.setProperty("TruthJetContainer", m_defaultTruthJets) );
603 #ifndef XAOD_STANDALONE
604 ATH_CHECK( m_jetPileupLabelingTool.setProperty("SuppressInputDependence", true) );
605 ATH_CHECK( m_jetPileupLabelingTool.setProperty("SuppressOutputDependence", true) );
606 #endif
607 ATH_CHECK( m_jetPileupLabelingTool.setProperty("OutputLevel", this->msg().level()) );
608 ATH_CHECK( m_jetPileupLabelingTool.retrieve() );
609 } else if (m_jetPileupLabelingTool.isUserConfigured()) ATH_CHECK( m_jetPileupLabelingTool.retrieve() );
610
612 // Initialise jet Jvt moment tool
613
614 if (!m_jetJvtMomentTool.isUserConfigured()) {
615 toolName = "JvtMomentTool";
616 m_jetJvtMomentTool.setTypeAndName("JetVertexTaggerTool/"+toolName);
617 ATH_CHECK( m_jetJvtMomentTool.setProperty("JetContainer", m_defaultJets) );
618 #ifndef XAOD_STANDALONE
619 ATH_CHECK( m_jetJvtMomentTool.setProperty("SuppressInputDependence", true) );
620 ATH_CHECK( m_jetJvtMomentTool.setProperty("SuppressOutputDependence", true) );
621 #endif
622 ATH_CHECK( m_jetJvtMomentTool.setProperty("OutputLevel", this->msg().level()) );
623 ATH_CHECK( m_jetJvtMomentTool.retrieve() );
624 } else if (m_jetJvtMomentTool.isUserConfigured()) ATH_CHECK( m_jetJvtMomentTool.retrieve() );
625
627 // Initialise jet NNJvt moment tool
628
629 m_applyJVTCut = !m_JvtWP.empty();
630 if (!m_jetNNJvtMomentTool.isUserConfigured() && m_applyJVTCut) {
631 toolName = "NNJvtMomentTool";
632 m_jetNNJvtMomentTool.setTypeAndName("JetPileupTag::JetVertexNNTagger/"+toolName);
633 ATH_CHECK( m_jetNNJvtMomentTool.setProperty("JetContainer", m_defaultJets) );
634 #ifndef XAOD_STANDALONE
635 ATH_CHECK( m_jetNNJvtMomentTool.setProperty("SuppressInputDependence", true) );
636 ATH_CHECK( m_jetNNJvtMomentTool.setProperty("SuppressOutputDependence", true) );
637 #endif
638 ATH_CHECK( m_jetNNJvtMomentTool.setProperty("OutputLevel", this->msg().level()) );
639 ATH_CHECK( m_jetNNJvtMomentTool.retrieve() );
640 } else if (m_jetNNJvtMomentTool.isUserConfigured()) ATH_CHECK( m_jetNNJvtMomentTool.retrieve() );
641
643 // Initialise jet NNJvt selection tool
644
645 if (!m_jetNNJvtSelectionTool.isUserConfigured() && m_applyJVTCut) {
646 toolName = "NNJvtSelectionTool";
647 m_jetNNJvtSelectionTool.setTypeAndName("CP::NNJvtSelectionTool/"+toolName);
648 ATH_CHECK( m_jetNNJvtSelectionTool.setProperty("JetContainer", m_defaultJets) );
649 ATH_CHECK( m_jetNNJvtSelectionTool.setProperty("WorkingPoint", m_JvtWP) );
650 ATH_CHECK( m_jetNNJvtSelectionTool.setProperty("MaxPtForJvt", m_JvtPtMax) );
651 ATH_CHECK( m_jetNNJvtSelectionTool.setProperty("JvtMomentName", "NNJvt") );
652 ATH_CHECK( m_jetNNJvtSelectionTool.setProperty("OutputLevel", this->msg().level()) );
653 ATH_CHECK( m_jetNNJvtSelectionTool.retrieve() );
654 } else if (m_jetNNJvtSelectionTool.isUserConfigured()) ATH_CHECK( m_jetNNJvtSelectionTool.retrieve() );
655
657 // Initialise jet NNJvt efficiency tool (scale factors)
658
659 if (!m_jetNNJvtEfficiencyTool.isUserConfigured() && m_applyJVTCut) {
660 toolName = "NNJvtEfficiencyTool";
661 m_jetNNJvtEfficiencyTool.setTypeAndName("CP::NNJvtEfficiencyTool/"+toolName);
662 ATH_CHECK( m_jetNNJvtEfficiencyTool.setProperty("JetContainer", m_defaultJets) );
663 ATH_CHECK( m_jetNNJvtEfficiencyTool.setProperty("WorkingPoint", m_JvtWP) );
664 ATH_CHECK( m_jetNNJvtEfficiencyTool.setProperty("MaxPtForJvt", m_JvtPtMax) );
665 ATH_CHECK( m_jetNNJvtEfficiencyTool.setProperty("SFFile", m_isRun3 ? m_JvtConfigRun3 : m_JvtConfigRun2) );
666 ATH_CHECK( m_jetNNJvtEfficiencyTool.setProperty("OutputLevel", this->msg().level()) );
667 ATH_CHECK( m_jetNNJvtEfficiencyTool.retrieve() );
668 } else if (m_jetNNJvtEfficiencyTool.isUserConfigured()) ATH_CHECK( m_jetNNJvtEfficiencyTool.retrieve() );
669
671 // Initialise jet fJvt selection tool
672
673 if (!m_jetfJvtSelectionTool.isUserConfigured() && m_doFwdJVT) {
674 toolName = "fJvtSelectionTool";
675 m_jetfJvtSelectionTool.setTypeAndName("CP::FJvtSelectionTool/"+toolName);
676 ATH_CHECK( m_jetfJvtSelectionTool.setProperty("JetContainer", m_defaultJets) );
677 ATH_CHECK( m_jetfJvtSelectionTool.setProperty("WorkingPoint", m_fJvtWP) );
678 ATH_CHECK( m_jetfJvtSelectionTool.setProperty("MaxPtForJvt", m_fJvtPtMax) );
679 ATH_CHECK( m_jetfJvtSelectionTool.setProperty("JvtMomentName", "DFCommonJets_fJvt") );
680 ATH_CHECK( m_jetfJvtSelectionTool.setProperty("OutputLevel", this->msg().level()) );
681 ATH_CHECK( m_jetfJvtSelectionTool.retrieve() );
682 } else if (m_jetfJvtSelectionTool.isUserConfigured()) ATH_CHECK( m_jetfJvtSelectionTool.retrieve() );
683
685 // Initialise jet fJvt efficiency tool for scale factors (scale factors)
686
687 if (!m_jetfJvtEfficiencyTool.isUserConfigured() && m_doFwdJVT) {
688 toolName = "fJvtEfficiencyTool";
689 m_jetfJvtEfficiencyTool.setTypeAndName("CP::FJvtEfficiencyTool/"+toolName);
690 ATH_CHECK( m_jetfJvtEfficiencyTool.setProperty("JetContainer", m_defaultJets) );
691 ATH_CHECK( m_jetfJvtEfficiencyTool.setProperty("WorkingPoint", m_fJvtWP) );
692 ATH_CHECK( m_jetfJvtEfficiencyTool.setProperty("MaxPtForJvt", m_fJvtPtMax) );
693 ATH_CHECK( m_jetfJvtEfficiencyTool.setProperty("SFFile", m_isRun3 ? m_fJvtConfigRun3 : m_fJvtConfigRun2) );
694 ATH_CHECK( m_jetfJvtEfficiencyTool.setProperty("OutputLevel", this->msg().level()) );
695 ATH_CHECK( m_jetfJvtEfficiencyTool.retrieve() );
696 } else ATH_CHECK( m_jetfJvtEfficiencyTool.retrieve() );
697 }
698
699
700 if (m_slices["mu"]) {
702 // Check muon baseline ID
703
704 std::string muQualBaseline = "";
705 switch (m_muIdBaseline) {
706 case static_cast<int>(xAOD::Muon::Quality::VeryLoose): muQualBaseline = "VeryLoose";
707 ATH_MSG_WARNING("No muon scale factors are available for VeryLoose working point.");
708 break;
709 case static_cast<int>(xAOD::Muon::Quality::Loose): muQualBaseline = "Loose"; break;
710 case static_cast<int>(xAOD::Muon::Quality::Medium): muQualBaseline = "Medium"; break;
711 case static_cast<int>(xAOD::Muon::Quality::Tight): muQualBaseline = "Tight"; break;
712 case 4: muQualBaseline = "HighPt"; break;
713 case 5: muQualBaseline = "LowPt"; break;
714 case 6: muQualBaseline = "LowPtMVA"; break;
715 case 7: muQualBaseline = "HighPt3Layers"; break;
716 default:
717 ATH_MSG_ERROR("Invalid muon working point provided: " << m_muIdBaseline << ". Cannot initialise!");
718 return StatusCode::FAILURE;
719 break;
720 }
721
723 // Initialise muon calibration tool
724 // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/MuonMomentumCorrectionsSubgroup#CP_MuonCalibrationAndSmearingToo
725 // Please not that for AthAnalysis we need to configure the MuonCalibTool within METSignificance manually and just can't pass the handle
726 // Hence, any changes here should also be propagated to the METSignificance setup further below
727
728 if (!m_muonCalibTool.isUserConfigured()) {
729 m_muonCalibTool.setTypeAndName("CP::MuonCalibTool/ST_MuonCalibrationTool");
730 if (m_isRun3) ATH_CHECK( m_muonCalibTool.setProperty("IsRun3Geo", true ));
731 ATH_CHECK( m_muonCalibTool.setProperty("calibMode", m_muCalibrationMode) );
732 ATH_CHECK( m_muonCalibTool.setProperty("OutputLevel", this->msg().level()) );
733 ATH_CHECK( m_muonCalibTool.setProperty("release", "Recs2025_12_11_Run2Run3" ));
734 int IdBaselineInt = m_muIdBaseline;
735 if (IdBaselineInt == 4) {
736 ATH_CHECK( m_muonCalibTool.setProperty("do2StationsHighPt", true) );
737 }
738 ATH_CHECK( m_muonCalibTool.setProperty("doExtraSmearing", m_muHighPtExtraSmear) );
739 ATH_CHECK( m_muonCalibTool.retrieve() );
740 } else ATH_CHECK( m_muonCalibTool.retrieve() );
741
743 // Initialise muon selection tool
744
745 if (!m_muonSelectionToolBaseline.isUserConfigured()) {
746 toolName = "MuonSelectionTool_Baseline_" + muQualBaseline;
747 m_muonSelectionToolBaseline.setTypeAndName("CP::MuonSelectionTool/"+toolName);
748 if (m_isRun3) ATH_CHECK( m_muonSelectionToolBaseline.setProperty("IsRun3Geo", true ));
749
750 if (m_muBaselineEta<m_muEta){ // Test for inconsistent configuration
751 ATH_MSG_ERROR( "Requested a baseline eta cut for muons (" << m_muBaselineEta <<
752 ") that is tighter than the signal cut (" << m_muEta << "). Please check your config." );
753 return StatusCode::FAILURE;
754 }
755 int IdBaselineInt = m_muIdBaseline;
756 ATH_CHECK( m_muonSelectionToolBaseline.setProperty( "MaxEta", m_muBaselineEta) );
757 if (IdBaselineInt == 6){
758 ATH_CHECK( m_muonSelectionToolBaseline.setProperty( "MuQuality", 5 ) );
759 ATH_CHECK( m_muonSelectionToolBaseline.setProperty( "UseMVALowPt", true));
760 } else if (IdBaselineInt == 7){
761 ATH_CHECK( m_muonSelectionToolBaseline.setProperty( "MuQuality", 4 ) );
762 ATH_CHECK( m_muonSelectionToolBaseline.setProperty( "Use2stationMuonsHighPt", false));
763 } else ATH_CHECK(m_muonSelectionToolBaseline.setProperty( "MuQuality", m_muIdBaseline ));
764 ATH_CHECK( m_muonSelectionToolBaseline.setProperty("OutputLevel", this->msg().level()) );
765 ATH_CHECK( m_muonSelectionToolBaseline.retrieve() );
766 } else ATH_CHECK( m_muonSelectionToolBaseline.retrieve() );
767
768
769 std::string muQual = "";
770 switch (m_muId) {
771 case static_cast<int>(xAOD::Muon::Quality::VeryLoose): muQual = "VeryLoose";
772 ATH_MSG_WARNING("No muon scale factors are available for VeryLoose working point.");
773 break;
774 case static_cast<int>(xAOD::Muon::Quality::Loose): muQual = "Loose"; break;
775 case static_cast<int>(xAOD::Muon::Quality::Medium): muQual = "Medium"; break;
776 case static_cast<int>(xAOD::Muon::Quality::Tight): muQual = "Tight"; break;
777 case 4: muQual = "HighPt"; break;
778 case 5: muQual = "LowPt"; break;
779 case 6: muQual = "LowPtMVA"; break;
780 case 7: muQual = "HighPt3Layers"; break;
781 default:
782 ATH_MSG_ERROR("Invalid muon working point provided: " << m_muId << ". Cannot initialise!");
783 return StatusCode::FAILURE;
784 break;
785 }
786
787 if (!m_muonSelectionTool.isUserConfigured()) {
788 toolName = "MuonSelectionTool_" + muQual;
789 m_muonSelectionTool.setTypeAndName("CP::MuonSelectionTool/"+toolName);
790 if (m_isRun3) ATH_CHECK( m_muonSelectionTool.setProperty("IsRun3Geo", true ));
791 ATH_CHECK( m_muonSelectionTool.setProperty( "MaxEta", m_muEta) );
792 int IdInt = m_muId;
793 if (IdInt == 6){
794 ATH_CHECK( m_muonSelectionTool.setProperty( "MuQuality", 5 ) );
795 ATH_CHECK( m_muonSelectionTool.setProperty( "UseMVALowPt", true));
796 } else if (IdInt == 7){
797 ATH_CHECK( m_muonSelectionTool.setProperty( "MuQuality", 4 ) );
798 ATH_CHECK( m_muonSelectionTool.setProperty( "Use2stationMuonsHighPt", false));
799 } else ATH_CHECK(m_muonSelectionTool.setProperty( "MuQuality", m_muId ));
800 ATH_CHECK( m_muonSelectionTool.setProperty("OutputLevel", this->msg().level()) );
801 ATH_CHECK( m_muonSelectionTool.retrieve() );
802 } else ATH_CHECK( m_muonSelectionTool.retrieve() );
803
804
805 if (!m_muonSelectionHighPtTool.isUserConfigured()) { //Fixed to HighPt WP
806 toolName = "MuonSelectionHighPtTool_" + muQual;
807 m_muonSelectionHighPtTool.setTypeAndName("CP::MuonSelectionTool/"+toolName);
808 if (m_isRun3) ATH_CHECK( m_muonSelectionHighPtTool.setProperty("IsRun3Geo", true ));
809 ATH_CHECK( m_muonSelectionHighPtTool.setProperty( "MaxEta", m_muEta) );
810 ATH_CHECK( m_muonSelectionHighPtTool.setProperty( "MuQuality", 4 ) );
811 ATH_CHECK( m_muonSelectionHighPtTool.setProperty("OutputLevel", this->msg().level()) );
812 ATH_CHECK( m_muonSelectionHighPtTool.retrieve() );
813 } else ATH_CHECK( m_muonSelectionHighPtTool.retrieve() );
814
815
817 // Initialise prompt/LRT muon OR tool
818 if (!m_muonLRTORTool.isUserConfigured()) {
819 toolName = "MuonLRTOverlapRemovalTool";
820 m_muonLRTORTool.setTypeAndName("CP::MuonLRTOverlapRemovalTool/"+toolName);
821 ATH_CHECK( m_muonLRTORTool.setProperty("overlapStrategy", CP::IMuonLRTOverlapRemovalTool::defaultStrategy) );
822 if (m_isRun3) ATH_CHECK( m_muonLRTORTool.setProperty("UseRun3WP", true ));
823 ATH_CHECK( m_muonLRTORTool.setProperty("OutputLevel", this->msg().level()) );
824 ATH_CHECK( m_muonLRTORTool.retrieve() );
825 } else ATH_CHECK( m_muonLRTORTool.retrieve() );
826
828 // Initialise muon efficiency tools
829
830 // Hotfix for the Run2 Muon Identification SFs for the Tight WP
831 std::string MuonCP_Run2_TightFix = "";
832 if(!m_isRun3) {
833 MuonCP_Run2_TightFix = (m_muId == static_cast<int>(xAOD::Muon::Quality::Tight)) ? "220725_Preliminary_r22run2" : "230213_Preliminary_r22run2_loosefix";
834 }
835 if (!m_muonEfficiencySFTool.isUserConfigured() && m_muId != static_cast<int>(xAOD::Muon::Quality::VeryLoose) && !isData()) {
836 toolName = "MuonEfficiencyScaleFactors_" + muQual;
837 m_muonEfficiencySFTool.setTypeAndName("CP::MuonEfficiencyScaleFactors/"+toolName);
838 ATH_CHECK( m_muonEfficiencySFTool.setProperty("WorkingPoint", muQual) );
839 ATH_CHECK( m_muonEfficiencySFTool.setProperty("CalibrationRelease", m_isRun3 ? "251211_Preliminary_r24run3" : MuonCP_Run2_TightFix) );
840 ATH_CHECK( m_muonEfficiencySFTool.setProperty("OutputLevel", this->msg().level()) );
841 ATH_CHECK( m_muonEfficiencySFTool.retrieve() );
842 } else if (m_muonEfficiencySFTool.isUserConfigured()) ATH_CHECK( m_muonEfficiencySFTool.retrieve() );
843
844
845 if (!m_muonEfficiencyBMHighPtSFTool.isUserConfigured() && !isData()){
846 toolName = "MuonEfficiencyScaleFactorsBMHighPt_" + muQual;
847 m_muonEfficiencyBMHighPtSFTool.setTypeAndName("CP::MuonEfficiencyScaleFactors/"+toolName);
848 ATH_CHECK( m_muonEfficiencyBMHighPtSFTool.setProperty("WorkingPoint", "BadMuonVeto_HighPt") );
849 ATH_CHECK( m_muonEfficiencyBMHighPtSFTool.setProperty("CalibrationRelease", m_isRun3? "220817_Preliminary_r22run3":"230213_Preliminary_r22run2_loosefix") ); //BadMuonVeto_HighPt currently not available for 240711_Preliminary_r24run3
850 ATH_CHECK( m_muonEfficiencyBMHighPtSFTool.setProperty("OutputLevel", this->msg().level()) );
851 ATH_CHECK( m_muonEfficiencyBMHighPtSFTool.retrieve() );
852 } else if (m_muonEfficiencyBMHighPtSFTool.isUserConfigured()) ATH_CHECK( m_muonEfficiencyBMHighPtSFTool.retrieve() );
853
854
855 if (m_doTTVAsf && m_mud0sig<0 && m_muz0<0){
856 ATH_MSG_WARNING("Requested TTVA SFs without d0sig and z0 cuts. Disabling scale factors as they will not make sense.");
857 m_doTTVAsf=false;
858 }
859
860 if (m_doTTVAsf && !m_muonTTVAEfficiencySFTool.isUserConfigured() && !isData()) {
861 toolName = "MuonTTVAEfficiencyScaleFactors";
862 m_muonTTVAEfficiencySFTool.setTypeAndName("CP::MuonEfficiencyScaleFactors/"+toolName);
863 ATH_CHECK( m_muonTTVAEfficiencySFTool.setProperty("WorkingPoint", "TTVA") );
864 ATH_CHECK( m_muonTTVAEfficiencySFTool.setProperty("CalibrationRelease", m_isRun3? "251211_Preliminary_r24run3":"230213_Preliminary_r22run2_loosefix") );
865 ATH_CHECK( m_muonTTVAEfficiencySFTool.setProperty("OutputLevel", this->msg().level()) );
866 ATH_CHECK( m_muonTTVAEfficiencySFTool.retrieve() );
867 } else if (m_muonTTVAEfficiencySFTool.isUserConfigured()) ATH_CHECK( m_muonTTVAEfficiencySFTool.retrieve() );
868
869
870
872 // Initialise muon isolation tool
873 if (!m_muonIsolationSFTool.isUserConfigured() && !m_muIso_WP.empty() && !isData()) {
874 toolName = "MuonIsolationScaleFactors_" + m_muIso_WP;
875
876 std::string tmp_muIso_WP = m_muIso_WP;
877 if ( !check_isOption(m_muIso_WP, m_mu_iso_support) ) { //check if supported
878 ATH_MSG_WARNING("Your selected muon Iso WP ("
879 << m_muIso_WP
880 << ") does not have SFs defined. Will try to find an appropriate fall-back.");
881 if (m_mu_iso_fallback.count(m_muIso_WP) > 0){
882 tmp_muIso_WP = m_mu_iso_fallback[m_muIso_WP];
883 ATH_MSG_WARNING("Your selected muon Iso WP ("
884 << m_muIso_WP
885 << " is not supported, and does not have SFs available. Falling back to "
886 << tmp_muIso_WP
887 << " for SF determination.");
888 } else {
889 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! ***");
890 return StatusCode::FAILURE;
891 }
892 }
893
894 m_muonIsolationSFTool.setTypeAndName("CP::MuonEfficiencyScaleFactors/"+toolName);
895 ATH_CHECK( m_muonIsolationSFTool.setProperty("WorkingPoint", tmp_muIso_WP + "Iso") );
896 ATH_CHECK( m_muonIsolationSFTool.setProperty("CalibrationRelease", m_isRun3? "251211_Preliminary_r24run3":"230213_Preliminary_r22run2_loosefix") );
897 ATH_CHECK( m_muonIsolationSFTool.setProperty("OutputLevel", this->msg().level()) );
898 ATH_CHECK( m_muonIsolationSFTool.retrieve() );
899
900 } else if (m_muonIsolationSFTool.isUserConfigured()) ATH_CHECK( m_muonIsolationSFTool.retrieve() );
901
902
903 if (!m_muonHighPtIsolationSFTool.isUserConfigured() && !m_muIsoHighPt_WP.empty() && !isData()) {
904 toolName = "MuonHighPtIsolationScaleFactors_" + m_muIsoHighPt_WP;
905
906 std::string tmp_muIsoHighPt_WP = m_muIsoHighPt_WP;
907 if ( !check_isOption(m_muIsoHighPt_WP, m_mu_iso_support) ) { //check if supported
908 ATH_MSG_WARNING("Your selected muon high-pt Iso WP ("
909 << m_muIsoHighPt_WP
910 << ") does not have SFs defined. Will try to find an appropriate fall-back.");
911 if (m_mu_iso_fallback.count(m_muIsoHighPt_WP) > 0){
912 tmp_muIsoHighPt_WP = m_mu_iso_fallback[m_muIsoHighPt_WP];
913 ATH_MSG_WARNING("Your selected muon high-pt Iso WP ("
914 << m_muIsoHighPt_WP
915 << " is not supported, and does not have SFs available. Falling back to "
916 << tmp_muIsoHighPt_WP
917 << " for SF determination.");
918 } else {
919 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! ***");
920 return StatusCode::FAILURE;
921 }
922 }
923
924 m_muonHighPtIsolationSFTool.setTypeAndName("CP::MuonEfficiencyScaleFactors/"+toolName);
925 // Use for the low-pt WP a dedicated set of isolation scale-factors having an extra uncertainty in place
926 ATH_CHECK( m_muonHighPtIsolationSFTool.setProperty("WorkingPoint", tmp_muIsoHighPt_WP + "Iso") );
927 ATH_CHECK( m_muonHighPtIsolationSFTool.setProperty("CalibrationRelease", m_isRun3? "251211_Preliminary_r24run3":"230213_Preliminary_r22run2_loosefix") );
928 ATH_CHECK( m_muonHighPtIsolationSFTool.setProperty("OutputLevel", this->msg().level()) );
929 ATH_CHECK( m_muonHighPtIsolationSFTool.retrieve() );
930
931 } else if (m_muonHighPtIsolationSFTool.isUserConfigured()) ATH_CHECK( m_muonHighPtIsolationSFTool.retrieve() );
932
933
935 // Initialise muon trigger scale factor tools
936
937 if (!m_muonTriggerSFTool.isUserConfigured() && !isData()) {
938 toolName = "MuonTriggerScaleFactors_" + muQual;
939 m_muonTriggerSFTool.setTypeAndName("CP::MuonTriggerScaleFactors/"+toolName);
940 if ( muQual=="LowPt" ) {
941 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!");
942 ATH_CHECK( m_muonTriggerSFTool.setProperty("MuonQuality", "Medium" ) );
943 }
944 else ATH_CHECK( m_muonTriggerSFTool.setProperty("MuonQuality", muQual) );
945 //ATH_CHECK( m_muonTriggerSFTool.setProperty("Isolation", m_muIso_WP)); This property has been depreacted long time ago
946 ATH_CHECK( m_muonTriggerSFTool.setProperty("AllowZeroSF", true) );
947 ATH_CHECK( m_muonTriggerSFTool.setProperty("OutputLevel", this->msg().level()) );
948 if(!m_muTriggerSFCalibRelease.empty() ) ATH_CHECK( m_muonTriggerSFTool.setProperty("CalibrationRelease",m_muTriggerSFCalibRelease) );
949 if(!m_muTriggerSFCalibFilename.empty()) ATH_CHECK( m_muonTriggerSFTool.setProperty("filename", m_muTriggerSFCalibFilename) );
950 if(!m_mcCampaign.empty()) ATH_CHECK( m_muonTriggerSFTool.setProperty("Campaign", m_mcCampaign) ); // if not set, loads all !86245
951 ATH_CHECK( m_muonTriggerSFTool.retrieve() );
952 m_muonTrigSFTools.push_back(m_muonTriggerSFTool.getHandle());
953 } else if (m_muonTriggerSFTool.isUserConfigured()) {
954 ATH_CHECK( m_muonTriggerSFTool.retrieve() );
955 m_muonTrigSFTools.push_back(m_muonTriggerSFTool.getHandle());
956 }
957 }
958
959 if (m_slices["ele"]) {
960 // /////////////////////////////////////////////////////////////////////////////////////////
961 // Initialise electron selector tools
962
963 // Signal Electrons
964 if (!m_elecSelLikelihood.isUserConfigured()) {
965 toolName = "EleSelLikelihood_" + m_eleId;
966
967 if (m_eleId.find("DNN") != std::string::npos) {
968 m_elecSelLikelihood.setTypeAndName("AsgElectronSelectorTool/"+toolName);
969 }
970 else {
971 m_elecSelLikelihood.setTypeAndName("AsgElectronLikelihoodTool/"+toolName);
972 }
973
974 if (! m_eleConfig.empty() ){
975 ATH_MSG_INFO("Overriding specified Ele.Id working point in favour of configuration file");
976 ATH_CHECK( m_elecSelLikelihood.setProperty("ConfigFile", m_eleConfig) );
977 } else if ( !check_isOption(m_eleId, m_el_id_support) ) { //check if supported
978 ATH_MSG_ERROR("Invalid electron ID selected: " << m_eleId);
979 return StatusCode::FAILURE;
980 }
981 else if (m_eleId == "VeryLooseLLH" || m_eleId == "LooseLLH") {
982 ATH_MSG_WARNING(" ****************************************************************************");
983 ATH_MSG_WARNING(" CAUTION: Setting " << m_eleId << " as signal electron ID");
984 ATH_MSG_WARNING(" These may be used for loose electron CRs but no scale factors are provided.");
985 ATH_MSG_WARNING(" ****************************************************************************");
986 ATH_CHECK( m_elecSelLikelihood.setProperty("WorkingPoint", EG_WP(m_eleId) ));
987 } else {
988 ATH_CHECK( m_elecSelLikelihood.setProperty("WorkingPoint", EG_WP(m_eleId) ));
989 }
990
991 ATH_CHECK( m_elecSelLikelihood.setProperty("OutputLevel", this->msg().level()) );
992 ATH_CHECK( m_elecSelLikelihood.retrieve() );
993 } else ATH_CHECK( m_elecSelLikelihood.retrieve() );
994
995 // Baseline Electrons
996 if (!m_elecSelLikelihoodBaseline.isUserConfigured()) {
997 toolName = "EleSelLikelihoodBaseline_" + m_eleIdBaseline;
998
999 if (m_eleIdBaseline.find("DNN") != std::string::npos) {
1000 m_elecSelLikelihoodBaseline.setTypeAndName("AsgElectronSelectorTool/"+toolName);
1001 }
1002 else {
1003 m_elecSelLikelihoodBaseline.setTypeAndName("AsgElectronLikelihoodTool/"+toolName);
1004 }
1005
1006 if (! m_eleConfigBaseline.empty() ){
1007 ATH_MSG_INFO("Overriding specified EleBaseline.Id working point in favour of configuration file");
1008 ATH_CHECK( m_elecSelLikelihoodBaseline.setProperty("ConfigFile", m_eleConfigBaseline ));
1009 } else if ( !check_isOption(m_eleIdBaseline, m_el_id_support) ) { //check if supported
1010 ATH_MSG_ERROR("Invalid electron ID selected: " << m_eleIdBaseline);
1011 return StatusCode::FAILURE;
1012 } else {
1013 ATH_CHECK( m_elecSelLikelihoodBaseline.setProperty("WorkingPoint", EG_WP(m_eleIdBaseline)) );
1014 }
1015
1016 ATH_CHECK( m_elecSelLikelihoodBaseline.setProperty("OutputLevel", this->msg().level()) );
1017 ATH_CHECK( m_elecSelLikelihoodBaseline.retrieve() );
1018 } else ATH_CHECK( m_elecSelLikelihoodBaseline.retrieve() );
1019 }
1020
1022 // Initialise prompt/LRT electron OR tool
1023 if (!m_elecLRTORTool.isUserConfigured()) {
1024 toolName = "ElectronLRTOverlapRemovalTool";
1025 m_elecLRTORTool.setTypeAndName("CP::ElectronLRTOverlapRemovalTool/"+toolName);
1026 ATH_MSG_DEBUG("Setting ElectronLRTOverlapRemovalTool strategy to "<<m_eleLRT_strat);
1027 ATH_CHECK( m_elecLRTORTool.setProperty("overlapStrategy", m_eleLRT_strat) );
1028 ATH_CHECK( m_elecLRTORTool.retrieve() );
1029 } else ATH_CHECK( m_elecLRTORTool.retrieve() );
1030
1031 if (m_slices["pho"]) {
1032 // /////////////////////////////////////////////////////////////////////////////////////////
1033 // Initialise photon selector tools
1034
1035 if (!m_photonSelIsEM.isUserConfigured()) {
1036 toolName = "PhotonSelIsEM_" + m_photonId;
1037 m_photonSelIsEM.setTypeAndName("AsgPhotonIsEMSelector/"+toolName);
1038
1039 if (!check_isOption(m_photonId, m_ph_id_support)){ //check if supported
1040 ATH_MSG_ERROR("Invalid photon ID selected: " << m_photonId);
1041 return StatusCode::FAILURE;
1042 }
1043
1044 ATH_CHECK( m_photonSelIsEM.setProperty("WorkingPoint", m_photonId+"Photon") );
1045 ATH_CHECK( m_photonSelIsEM.setProperty("OutputLevel", this->msg().level()) );
1046 ATH_CHECK( m_photonSelIsEM.retrieve() );
1047 } else ATH_CHECK( m_photonSelIsEM.retrieve() );
1048
1049 if (!m_photonSelIsEMBaseline.isUserConfigured()) {
1050 toolName = "PhotonSelIsEMBaseline_" + m_photonIdBaseline;
1051 m_photonSelIsEMBaseline.setTypeAndName("AsgPhotonIsEMSelector/"+toolName);
1052
1053 if(!check_isOption(m_photonIdBaseline, m_ph_id_support)){ //check if supported
1054 ATH_MSG_ERROR("Invalid photon ID selected: " << m_photonIdBaseline);
1055 return StatusCode::FAILURE;
1056 }
1057
1058 ATH_CHECK( m_photonSelIsEMBaseline.setProperty("WorkingPoint", m_photonIdBaseline+"Photon") );
1059 ATH_CHECK( m_photonSelIsEMBaseline.setProperty("OutputLevel", this->msg().level()) );
1060 ATH_CHECK( m_photonSelIsEMBaseline.retrieve() );
1061 } else ATH_CHECK( m_photonSelIsEMBaseline.retrieve() );
1062 }
1063
1064 if (m_slices["ele"]||m_slices["pho"]) {
1066 // Initialise DeadHVCellRemovalTool
1067 // https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/EGammaIdentificationRun2#Removal_of_Electron_Photon_clust
1068
1069 ATH_MSG_DEBUG("Setup AsgDeadHVCellRemovalTool/deadHVTool");
1070 m_deadHVTool.setTypeAndName("AsgDeadHVCellRemovalTool/deadHVTool");
1071 ATH_CHECK(m_deadHVTool.retrieve());
1072 }
1073
1074 if (m_slices["ele"]) {
1076 // Initialise electron efficiency tool
1077
1078 PATCore::ParticleDataType::DataType data_type(PATCore::ParticleDataType::Data);
1079 if (!isData()) {
1080 if (isAtlfast()) data_type = PATCore::ParticleDataType::Fast;
1081 else data_type = PATCore::ParticleDataType::Full;
1082 ATH_MSG_DEBUG( "Setting data type to " << data_type);
1083 }
1084
1085 m_eleEffMapFilePathTriggerRun2 = "ElectronEfficiencyCorrection/2015_2018/rel21.2/Precision_Summer2020_v1/map4.txt";
1086 m_eleEffMapFilePathTriggerRun3 = "ElectronEfficiencyCorrection/2015_2025/rel22.2/2025_Run3_Consolidated_Recommendation_v4/map2.txt";
1087
1088 if(!m_isRun3) {
1089 ATH_MSG_INFO( "Running on Run2 samples; Using egamma SF tools from R21 map for trigger");
1090 ATH_MSG_INFO( m_eleEffMapFilePathTriggerRun2);
1091 } else {
1092 ATH_MSG_INFO( "Running on Run3 samples; Using different egamma SF tools map for trigger");
1093 ATH_MSG_INFO( m_eleEffMapFilePathTriggerRun3);
1094 }
1095
1096 toolName = "AsgElectronEfficiencyCorrectionTool_reco";
1097 CONFIG_EG_EFF_TOOL_KEY(m_elecEfficiencySFTool_reco, toolName, "RecoKey", "Reconstruction", m_eleEffMapFilePath);
1098
1099 //-- get KEYS supported by egamma SF tools
1100 std::vector<std::string> eSF_keys = getElSFkeys( m_eleEffMapFilePath);
1101 std::vector<std::string> eSF_keys_trigger = getElSFkeys( m_isRun3? m_eleEffMapFilePathTriggerRun3 : m_eleEffMapFilePathTriggerRun2);
1102
1103 if (m_eleId.find("NoPix") != std::string::npos || m_eleId == "VeryLooseLLH" || m_eleId == "LooseLLH" || m_eleId == "Medium") {
1104 ATH_MSG_WARNING("Not configuring electron ID and trigger scale factors for " << m_eleId);
1105 }
1106 else {
1107 // This needs to be formatted for the scale factors: no _Rel20, no LH label, etc.
1108 std::string eleId = TString(m_eleId).ReplaceAll("AndBLayer", "BLayer").ReplaceAll("LLH", "LH").Data();
1109
1110 if (m_eleId.find("DNN") != std::string::npos) {
1111 eleId = TString(eleId).ReplaceAll("DNNnoCF", "").ReplaceAll("DNN", "").ReplaceAll("Loose", "LooseBLayer").Data();
1112 ATH_MSG_WARNING("Electron DNN ID working point " << m_eleId << " doesn't have SFs yet, fall back to " << eleId);
1113 }
1114
1115 // electron id
1116 toolName = "AsgElectronEfficiencyCorrectionTool_id_" + m_eleId;
1117 CONFIG_EG_EFF_TOOL_KEY(m_elecEfficiencySFTool_id, toolName, "IdKey", eleId, m_eleEffMapFilePath);
1118
1119 // override map file use if correction file list is set for WP
1120 std::map<std::string,std::string> corrFNList;
1121 if ( !m_EG_corrFNList.empty() ) {
1122 for ( const auto& WP_fname : split( m_EG_corrFNList, "," ) ) {
1123 std::string WP = WP_fname.substr(0,WP_fname.find(":"));
1124 std::string fname = WP_fname.substr(WP_fname.find(":")+1);
1125 corrFNList[WP] = fname;
1126 ATH_MSG_WARNING( "Correction file list defined for WP " << WP << ": " << fname << "." );
1127 ATH_MSG_WARNING( "Will use correction file rather than central map file." );
1128 }
1129 }
1130
1131 // electron iso
1132 std::string EleIso("");
1133 if (std::find(eSF_keys.begin(), eSF_keys.end(), eleId+"_"+m_eleIso_WP) != eSF_keys.end()){
1134 EleIso = m_eleIso_WP;
1135 } else if (std::find(eSF_keys.begin(), eSF_keys.end(), eleId+"_"+m_el_iso_fallback[m_eleIso_WP]) != eSF_keys.end()){
1136 //--- Check to see if the only issue is an unknown isolation working point
1137 EleIso = m_el_iso_fallback[m_eleIso_WP];
1138 ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool_iso_*) Your selected electron Iso WP ("
1139 << m_eleIso_WP
1140 << ") does not have iso SFs defined. Falling back to "
1141 << m_el_iso_fallback[m_eleIso_WP]
1142 << " for SF calculations");
1143 }
1144 else{
1145 ATH_MSG_ERROR("*** THE ELECTRON ISOLATION SF YOU SELECTED (" << m_eleIso_WP << ") GOT NO SUPPORT ***");
1146 return StatusCode::FAILURE;
1147 }
1148
1149 toolName = "AsgElectronEfficiencyCorrectionTool_iso_" + m_eleId + EleIso;
1150
1151 // if running with correction file list
1152 if ( (!m_EG_corrFNList.empty()) && corrFNList.find(EleIso)!=corrFNList.end() ) { // overriding central map file
1153 CONFIG_EG_EFF_TOOL( m_elecEfficiencySFTool_iso, toolName, corrFNList[EleIso] );
1154 }
1155 // can't do the iso tool via the macro, it needs two properties set
1156 else { // default: use map file
1157 if ( !m_elecEfficiencySFTool_iso.isUserConfigured() ) {
1158 if ( !check_isOption(EleIso, m_el_iso_support) ) { //check if supported
1159 ATH_MSG_WARNING( "(" << toolName << ") Your electron Iso WP: " << EleIso<< " is no longer supported. This will almost certainly cause a crash now.");
1160 }
1161
1162 m_elecEfficiencySFTool_iso.setTypeAndName("CP::AsgElectronEfficiencyCorrectionTool/"+toolName);
1163
1164 if ( m_EG_corrFNList.empty() ) {
1165 ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("MapFilePath", m_eleEffMapFilePath) );
1166 } else {
1167 ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("CorrectionFileNameList", corrFNList) );
1168 }
1169 ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("IdKey", eleId) );
1170 ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("IsoKey", EleIso) );
1171 if (!isData() && ((EleIso.find("TightTrackOnly_VarRad")!=std::string::npos)||
1172 (EleIso.find("TightTrackOnly_FixedRad")!=std::string::npos)||
1173 (EleIso.find("Tight_VarRad")!=std::string::npos)||
1174 (EleIso.find("Loose_VarRad")!=std::string::npos))) {
1175 if (isAtlfast()) ATH_MSG_WARNING("(CP::AsgElectronEfficiencyCorrectionTool/"+toolName+"). Your selected electron Iso WP (" + EleIso + ") don't have AFII SF. Falling back to FullSim");
1176 ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("ForceDataType", static_cast<int>(PATCore::ParticleDataType::Full)));
1177 }
1178 else if (!isData()){
1179 ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("ForceDataType", static_cast<int>(data_type)));
1180 }
1181 ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("CorrelationModel", m_EG_corrModel) );
1182 ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("OutputLevel", this->msg().level()) );
1183 ATH_CHECK( m_elecEfficiencySFTool_iso.initialize() );
1184 } else ATH_CHECK( m_elecEfficiencySFTool_iso.initialize() );
1185 }
1186
1187 // electron iso high-pt
1188 std::string EleIsohighPt("");
1189 if (std::find(eSF_keys.begin(), eSF_keys.end(), eleId+"_"+m_eleIsoHighPt_WP) != eSF_keys.end()){
1190 EleIsohighPt = m_eleIsoHighPt_WP;
1191 } else if (std::find(eSF_keys.begin(), eSF_keys.end(), eleId+"_"+m_el_iso_fallback[m_eleIsoHighPt_WP]) != eSF_keys.end()){
1192 //--- Check to see if the only issue is an unknown isolation working point
1193 EleIsohighPt = m_el_iso_fallback[m_eleIsoHighPt_WP];
1194 ATH_MSG_WARNING("(CP::AsgElectronEfficiencyCorrectionTool_iso_*) Your selected high-pT electron Iso WP ("
1195 << m_eleIsoHighPt_WP
1196 << ") does not have iso SFs defined. Falling back to "
1197 << m_el_iso_fallback[m_eleIsoHighPt_WP]
1198 << " for SF calculations");
1199 }
1200 else{
1201 ATH_MSG_ERROR("*** THE HIGH PT ELECTRON ISOLATION SF YOU SELECTED (" << m_eleIsoHighPt_WP << ") GOT NO SUPPORT");
1202 return StatusCode::FAILURE;
1203 }
1204
1205 toolName = "AsgElectronEfficiencyCorrectionTool_isoHigPt_" + m_eleId + EleIsohighPt;
1206
1207 // if running with correction file list
1208 if ( (!m_EG_corrFNList.empty()) && corrFNList.find(EleIsohighPt)!=corrFNList.end() ) { // overriding central map file
1209 CONFIG_EG_EFF_TOOL( m_elecEfficiencySFTool_isoHighPt, toolName, corrFNList[EleIsohighPt] );
1210 }
1211 // can't do the iso tool via the macro, it needs two properties set
1212 else { // default: use map file
1213 if ( !m_elecEfficiencySFTool_isoHighPt.isUserConfigured() ) {
1214
1215 if ( !check_isOption(EleIsohighPt, m_el_iso_support) ) { //check if supported
1216 ATH_MSG_WARNING( "(" << toolName << ") Your electron high-pt Iso WP: " << EleIsohighPt << " is no longer supported. This will almost certainly cause a crash now.");
1217 }
1218
1219 m_elecEfficiencySFTool_isoHighPt.setTypeAndName("CP::AsgElectronEfficiencyCorrectionTool/"+toolName);
1220
1221 ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.setProperty("MapFilePath", m_eleEffMapFilePath) );
1222 ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.setProperty("IdKey", eleId) );
1223 ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.setProperty("IsoKey", EleIsohighPt) );
1224 if (!isData()) {
1225 ATH_CHECK (m_elecEfficiencySFTool_isoHighPt.setProperty("ForceDataType", (int) data_type) );
1226 }
1227 ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.setProperty("CorrelationModel", m_EG_corrModel) );
1228 ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.setProperty("OutputLevel", this->msg().level()) );
1229 ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.initialize() );
1230 } else ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.initialize() );
1231 }
1232
1233 // electron triggers - first SFs (but we need to massage the id string since all combinations are not supported)
1234
1235 //single lepton
1236
1237 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_eleEffMapFilePathTriggerRun3);
1238 // This needs to be formatted for the trigger scale factors: no LH label
1239 std::string triggerEleID = m_isRun3? TString(eleId).ReplaceAll("LooseBLayer", "Loose").ReplaceAll("LH", "").Data() : TString(eleId).ReplaceAll("LH", "").Data();
1240 std::string triggerEleIso= m_eleIso_WP;
1241
1242 // This is an hack to work with ElectronEfficiencyCorrection/2015_2025/rel22.2/2022_Summer_Prerecom_v1/map4.txt to allow
1243
1244 if(m_isRun3 && m_eleAllowRun3TrigSFFallback){
1245 bool pass_isRun3TrigSFFallback = true;
1246 if (triggerEleID.find("Medium") != std::string::npos && triggerEleIso.find("Loose") != std::string::npos) {triggerEleID = "LooseBLayer";}
1247 else if (triggerEleID.find("Medium") != std::string::npos && triggerEleIso.find("Tight") != std::string::npos) {triggerEleID = "Tight"; triggerEleIso = "Tight_VarRad";}
1248 else if (triggerEleID.find("Medium") != std::string::npos && triggerEleIso.find("HighPtCaloOnly") != std::string::npos) {triggerEleID = "Tight"; triggerEleIso = "Tight_VarRad";}
1249 else if (triggerEleID.find("Tight") != std::string::npos && triggerEleIso.find("Loose") != std::string::npos) {triggerEleID = "LooseBLayer";}
1250 else if (triggerEleID.find("Tight") != std::string::npos && triggerEleIso.find("Tight") != std::string::npos) {triggerEleIso= "Tight_VarRad";}
1251 else if (triggerEleID.find("Tight") != std::string::npos && triggerEleIso.find("HighPtCaloOnly") != std::string::npos) {triggerEleID = "Tight"; triggerEleIso = "Tight_VarRad";}
1252 else if (triggerEleID.find("Loose") != std::string::npos && triggerEleIso.find("Tight") != std::string::npos) {triggerEleID = "LooseBLayer"; triggerEleIso = "Loose_VarRad";}
1253 else if (triggerEleID.find("Loose") != std::string::npos && triggerEleIso.find("HighPtCaloOnly") != std::string::npos) {triggerEleID = "LooseBLayer"; triggerEleIso = "Loose_VarRad";}
1254 else {pass_isRun3TrigSFFallback=false;}
1255 if(pass_isRun3TrigSFFallback){
1256 ATH_MSG_INFO(" ************** This is only for testing/studying purpose! ************** ");
1257 ATH_MSG_INFO(" ************** For official recommendation, please get in contact with the SUSY Bkg Forum ************** ");
1258 ATH_MSG_INFO("In the current map ("<<m_eleEffMapFilePathTriggerRun3<<"), the only supported Electron ID working-points supported for Electron Trigger Scale Factor are 'Loose_Loose_VarRad' and 'Tight_Tight_VarRad' ");
1259 ATH_MSG_INFO("Only for single-lepton trigger scale factor, fall back to Electron ID: -> "<< triggerEleID << " with Isolation: " << triggerEleIso);
1260 }
1261 }
1262
1263 // The L1 seed changed from 2023 and beyond, so we need to adjust the trigger key accordingly, the SF are now derived by year so we need to change the year in the key as well.
1264
1265 if(m_isRun3){
1266 // Find year positions (or npos if not present)
1267 size_t p22 = m_electronTriggerSFStringSingle.find("2022");
1268 size_t p23 = m_electronTriggerSFStringSingle.find("2023");
1269 size_t p24 = m_electronTriggerSFStringSingle.find("2024");
1270
1271 auto next_pos = [&](size_t self) {
1272 size_t next = std::string::npos;
1273
1274 if (self == p22) {
1275 if (p23 > self && p23 < next) next = p23;
1276 if (p24 > self && p24 < next) next = p24;
1277 }
1278 else if (self == p23) {
1279 if (p22 > self && p22 < next) next = p22;
1280 if (p24 > self && p24 < next) next = p24;
1281 }
1282 else if (self == p24) {
1283 if (p22 > self && p22 < next) next = p22;
1284 if (p23 > self && p23 < next) next = p23;
1285 }
1286
1287 return next;
1288 };
1289 std::string SFStringSingle22="";
1290 std::string SFStringSingle23="";
1291 std::string SFStringSingle24="";
1292
1293 // Extract 2022,2023,2025 block
1294 if (p22 != std::string::npos) {size_t end = next_pos(p22); SFStringSingle22 = m_electronTriggerSFStringSingle.substr(p22, end - p22);}
1295 if (p23 != std::string::npos) {size_t end = next_pos(p23); SFStringSingle23 = m_electronTriggerSFStringSingle.substr(p23, end - p23);}
1296 if (p24 != std::string::npos) {size_t end = next_pos(p24); SFStringSingle24 = m_electronTriggerSFStringSingle.substr(p24, end - p24);}
1297
1298 // Remove trailing underscores from tokens if present
1299 std::string* toks[] = { &SFStringSingle22, &SFStringSingle23, &SFStringSingle24 };
1300 for (auto t : toks) {
1301 while (!t->empty() && t->back() == '_') t->pop_back();
1302 }
1303
1304 if(m_mcCampaign == "mc23a") m_electronTriggerSFStringSingle = SFStringSingle22;
1305 else if(m_mcCampaign == "mc23d") m_electronTriggerSFStringSingle = SFStringSingle23;
1306 else if(m_mcCampaign == "mc23e") m_electronTriggerSFStringSingle = SFStringSingle24;
1307 else {
1308 ATH_MSG_WARNING("Unknown or unsupported mcCampaign for Run 3: " << m_mcCampaign << ". Please contact the SUSY Bkg Forum for assistance.");
1309 ATH_MSG_WARNING("Falling back to 2024 trigger SFs for single-electron triggers.");
1310 m_electronTriggerSFStringSingle = SFStringSingle24;
1311 }
1312 }
1313
1314
1315 ATH_MSG_INFO("eSF_keys: " << m_electronTriggerSFStringSingle<< "_"<<triggerEleID<<"_"<<triggerEleIso);
1316
1317 if (std::find(eSF_keys_trigger.begin(), eSF_keys_trigger.end(), m_electronTriggerSFStringSingle+"_"+triggerEleID+"_"+triggerEleIso) != eSF_keys_trigger.end()){
1318 triggerEleIso = m_eleIso_WP;
1319 } else if (std::find(eSF_keys_trigger.begin(), eSF_keys_trigger.end(), m_electronTriggerSFStringSingle+"_"+triggerEleID+"_"+m_el_iso_fallback[triggerEleIso]) != eSF_keys_trigger.end()){
1320 //--- Check to see if the only issue is an unknown isolation working point
1321 triggerEleIso = m_el_iso_fallback[triggerEleIso];
1322 ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool_trig_singleLep_*) Your selected electron Iso WP ("
1323 << m_eleIso_WP
1324 << ") does not have trigger SFs defined. Falling back to "
1325 << triggerEleIso
1326 << " for SF calculations");
1327 }
1328 else{
1329 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 << ") ***");
1330 return StatusCode::FAILURE;
1331 }
1332
1333 toolName = "AsgElectronEfficiencyCorrectionTool_trig_singleLep_" + triggerEleID;
1334 if ( !m_elecEfficiencySFTool_trig_singleLep.isUserConfigured() ) {
1335 m_elecEfficiencySFTool_trig_singleLep.setTypeAndName("CP::AsgElectronEfficiencyCorrectionTool/"+toolName);
1336 ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePathTriggerRun3 : m_eleEffMapFilePathTriggerRun2) );
1337 ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("TriggerKey", m_electronTriggerSFStringSingle) );
1338 ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("IdKey", triggerEleID) );
1339 ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("IsoKey", triggerEleIso) );
1340 ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("CorrelationModel", m_EG_corrModel) );
1341 if (!isData()) {
1342 ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("ForceDataType", (int) (data_type==PATCore::ParticleDataType::Fast)? PATCore::ParticleDataType::Full : data_type) );
1343 }
1344 ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("OutputLevel", this->msg().level()) );
1345 ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.initialize() );
1346 } else ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.retrieve() );
1347
1348
1349 toolName = "AsgElectronEfficiencyCorrectionTool_trigEff_singleLep_" + triggerEleID;
1350 if ( !m_elecEfficiencySFTool_trigEff_singleLep.isUserConfigured() ) {
1351 m_elecEfficiencySFTool_trigEff_singleLep.setTypeAndName("CP::AsgElectronEfficiencyCorrectionTool/"+toolName);
1352 ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePathTriggerRun3 : m_eleEffMapFilePathTriggerRun2) );
1353 ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("TriggerKey", "Eff_"+m_electronTriggerSFStringSingle) );
1354 ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("IdKey", triggerEleID) );
1355 ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("IsoKey", triggerEleIso) );
1356 ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("CorrelationModel", m_EG_corrModel) );
1357 if (!isData()) {
1358 ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("ForceDataType", (int) (data_type==PATCore::ParticleDataType::Fast)? PATCore::ParticleDataType::Full : data_type) );
1359 }
1360 ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("OutputLevel", this->msg().level()) );
1361 ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.initialize() );
1362 } else ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.retrieve() );
1363
1364 if (!m_isRun3){
1365 //mixed-leptons
1366 std::map<std::string,std::string> electronTriggerSFMapMixedLepton {
1367 // legs, Trigger keys,
1368 {"e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose,e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0", m_electronTriggerSFStringSingle},
1369 {"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"},
1370 {"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"},
1371 {"e17_lhloose,e17_lhloose_nod0","MULTI_L_2015_e17_lhloose_2016_2018_e17_lhloose_nod0"},
1372 {"e12_lhloose,e12_lhloose_nod0","MULTI_L_2015_e12_lhloose_2016_2018_e12_lhloose_nod0"},
1373 {"e7_lhmedium,e7_lhmedium_nod0","MULTI_L_2015_e7_lhmedium_2016_2018_e7_lhmedium_nod0"},
1374 {"e9_lhloose,e9_lhloose_nod0,e12_lhvloose_nod0_L1EM10VH","TRI_E_2015_e9_lhloose_2016_e9_lhloose_nod0_2017_2018_e12_lhvloose_nod0_L1EM10VH"}
1375
1376 };
1377
1378 // 2e17 trigger is used in 2017 or 2018?
1379 std::string triglist_2017to2018 = m_trig2017combination_diLep + "_" + m_trig2018combination_diLep + "_" + m_trig2017combination_multiLep + "_" + m_trig2018combination_multiLep;
1380 if (triglist_2017to2018.find("2e17_lhvloose_nod0_L12EM15VHI") != std::string::npos) {
1381 electronTriggerSFMapMixedLepton["e17_lhvloose_nod0_L1EM15VHI"] = "DI_E_2015_e12_lhloose_L1EM10VH_2016_e17_lhvloose_nod0_2017_2018_e17_lhvloose_nod0_L1EM15VHI";
1382 }
1383
1384 std::string triggerMixedEleIso("");
1385
1386 for(auto const& item : electronTriggerSFMapMixedLepton){
1387
1388 if (std::find(eSF_keys_trigger.begin(), eSF_keys_trigger.end(), item.second+"_"+triggerEleID+"_"+m_eleIso_WP) != eSF_keys_trigger.end()){
1389 triggerMixedEleIso = m_eleIso_WP;
1390 } else if (std::find(eSF_keys_trigger.begin(), eSF_keys_trigger.end(), item.second+"_"+triggerEleID+"_"+m_el_iso_fallback[m_eleIso_WP]) != eSF_keys_trigger.end()){
1391 //--- Check to see if the only issue is an unknown isolation working point
1392 triggerMixedEleIso = m_el_iso_fallback[m_eleIso_WP];
1393 ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool_trig_mixLep_*) Your selected electron Iso WP ("
1394 << m_eleIso_WP
1395 << ") does not have trigger SFs defined. Falling back to "
1396 << triggerMixedEleIso
1397 << " for SF calculations");
1398 } else {
1399 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! ***");
1400 return StatusCode::FAILURE;
1401 }
1402
1403 ATH_MSG_VERBOSE ("Selected WP: " << item.second << "_" << triggerEleID << "_" << triggerMixedEleIso);
1404
1405 toolName = "AsgElectronEfficiencyCorrectionTool_trig_mixLep_" + (item.first).substr(0,8) + m_eleId;
1406 auto t_sf = m_elecEfficiencySFTool_trig_mixLep.emplace(m_elecEfficiencySFTool_trig_mixLep.end(), "CP::AsgElectronEfficiencyCorrectionTool/"+toolName);
1407 ATH_CHECK( t_sf->setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePathTriggerRun3 : m_eleEffMapFilePathTriggerRun2) );
1408 ATH_CHECK( t_sf->setProperty("TriggerKey", item.second) );
1409 ATH_CHECK( t_sf->setProperty("IdKey", triggerEleID) );
1410 ATH_CHECK( t_sf->setProperty("IsoKey", triggerMixedEleIso) );
1411 ATH_CHECK( t_sf->setProperty("CorrelationModel", m_EG_corrModel) );
1412 if (!isData()) {
1413 ATH_CHECK( t_sf->setProperty("ForceDataType", (int) (data_type==PATCore::ParticleDataType::Fast)? PATCore::ParticleDataType::Full : data_type) );
1414 }
1415 ATH_CHECK( t_sf->setProperty("OutputLevel", this->msg().level()) );
1416 ATH_CHECK( t_sf->initialize() );
1417 m_elecTrigSFTools.push_back(t_sf->getHandle());
1418 #ifndef XAOD_STANDALONE
1419 m_legsPerTool[toolName] = item.first;
1420 #else
1421 m_legsPerTool["ToolSvc."+toolName] = item.first;
1422 #endif
1423
1424 toolName = "AsgElectronEfficiencyCorrectionTool_trigEff_mixLep_" + (item.first).substr(0,8) + m_eleId;
1425 auto t_eff = m_elecEfficiencySFTool_trigEff_mixLep.emplace(m_elecEfficiencySFTool_trigEff_mixLep.end(), "CP::AsgElectronEfficiencyCorrectionTool/"+toolName);
1426 ATH_CHECK( t_eff->setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePathTriggerRun3 : m_eleEffMapFilePathTriggerRun2) );
1427 ATH_CHECK( t_eff->setProperty("TriggerKey", "Eff_"+item.second) );
1428 ATH_CHECK( t_eff->setProperty("IdKey", triggerEleID) );
1429 ATH_CHECK( t_eff->setProperty("IsoKey", triggerMixedEleIso) );
1430 ATH_CHECK( t_eff->setProperty("CorrelationModel", m_EG_corrModel) );
1431 if (!isData()) {
1432 ATH_CHECK( t_eff->setProperty("ForceDataType", (int) (data_type==PATCore::ParticleDataType::Fast)? PATCore::ParticleDataType::Full : data_type) );
1433 }
1434 ATH_CHECK( t_eff->setProperty("OutputLevel", this->msg().level()) );
1435 ATH_CHECK( t_eff->initialize() );
1436 m_elecTrigEffTools.push_back(t_eff->getHandle());
1437 #ifndef XAOD_STANDALONE
1438 m_legsPerTool[toolName] = item.first;
1439 #else
1440 m_legsPerTool["ToolSvc."+toolName] = item.first;
1441 #endif
1442
1443 }
1444 }
1445 else ATH_MSG_WARNING("*** THE ELECTRON TRIGGER SF MIXED AND SF DILEP ARE CURRENTY NOT SUPPORTED IN RUN3 ***");
1446
1447 ATH_MSG_WARNING("*** THE ELECTRON CHARGE FLIP SF ARE CURRENTY NOT SUPPORTED ***");
1448 // all the iinitialisation of the related tools have been cleaned up
1449
1450 }
1451
1452 if (m_slices["pho"]) {
1453 // /////////////////////////////////////////////////////////////////////////////////////////
1454 // Initialise photon efficiency tool
1455
1456 if (!m_photonEfficiencySFTool.isUserConfigured() && !isData()) {
1457 m_photonEfficiencySFTool.setTypeAndName("CP::AsgPhotonEfficiencyCorrectionTool/AsgPhotonEfficiencyCorrectionTool_" + m_photonId);
1458
1459 if (m_photonId != "Tight" ) {
1460 ATH_MSG_WARNING( "No Photon efficiency available for " << m_photonId << ", using Tight instead..." );
1461 }
1462
1463 ATH_CHECK( m_photonEfficiencySFTool.setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2025/rel22.2/2026_Run3Consolidated_Recommendation_v1/map0.txt") );
1464 ATH_CHECK( m_photonEfficiencySFTool.setProperty("ForceDataType", isAtlfast()? (m_isRun3? 1: 3) : 1) ); // Set data type: 1 for FULLSIM, 3 for AtlFast. For Run3 pre-rec only FullSim SFs are available
1465 ATH_CHECK( m_photonEfficiencySFTool.setProperty("OutputLevel", this->msg().level()) );
1466 ATH_CHECK( m_photonEfficiencySFTool.retrieve() );
1467 } else if (m_photonEfficiencySFTool.isUserConfigured()) ATH_CHECK( m_photonEfficiencySFTool.retrieve() );
1468
1469 if (!m_photonIsolationSFTool.isUserConfigured() && !isData()) {
1470 m_photonIsolationSFTool.setTypeAndName("CP::AsgPhotonEfficiencyCorrectionTool/AsgPhotonEfficiencyCorrectionTool_isol" + m_photonIso_WP);
1471
1472 if (m_photonIso_WP != "FixedCutTight" && m_photonIso_WP != "FixedCutLoose" && m_photonIso_WP != "TightCaloOnly") {
1473 ATH_MSG_WARNING( "No Photon efficiency available for " << m_photonIso_WP);
1474 }
1475
1476 ATH_CHECK( m_photonIsolationSFTool.setProperty("MapFilePath", m_isRun3 ? "PhotonEfficiencyCorrection/2015_2025/rel22.2/2022_Summer_Prerecom_v1/map1.txt" : "PhotonEfficiencyCorrection/2015_2025/rel22.2/2022_Summer_Prerecom_v1/map0.txt") );
1477 ATH_CHECK( m_photonIsolationSFTool.setProperty("IsoKey", m_photonIso_WP != "TightCaloOnly" ? m_photonIso_WP.substr(8) : m_photonIso_WP )); // Set isolation WP: Loose,Tight,TightCaloOnly
1478 ATH_CHECK( m_photonIsolationSFTool.setProperty("ForceDataType", 1) ); // Set data type: 1 for FULLSIM, 3 for AF2
1479 ATH_CHECK( m_photonIsolationSFTool.setProperty("OutputLevel", this->msg().level()) );
1480 ATH_CHECK( m_photonIsolationSFTool.retrieve() );
1481 } else if (m_photonEfficiencySFTool.isUserConfigured()) ATH_CHECK( m_photonIsolationSFTool.retrieve() );
1482
1483 // trigger scale factors
1484 if (!m_photonTriggerSFTool.isUserConfigured() && !isData()) {
1485 m_photonTriggerSFTool.setTypeAndName("CP::AsgPhotonEfficiencyCorrectionTool/AsgPhotonEfficiencyCorrectionTool_trig" + m_photonTriggerName);
1486
1487 // Fallback to TightCaloOnly if Tight is selected
1488 std::string photonIso_forTrigSF = m_photonIso_WP;
1489 if (m_photonIso_WP == "FixedCutTight") {
1490 ATH_MSG_WARNING( "No Photon trigger SF available for " << m_photonIso_WP << ", using TightCaloOnly instead... Use at your own risk" );
1491 photonIso_forTrigSF = "TightCaloOnly";
1492 } else { // isolation WP supported: Loose or TightCaloOnly, removing "FixedCut" suffix..
1493 photonIso_forTrigSF = TString(m_photonIso_WP).ReplaceAll("FixedCut","").Data();
1494 }
1495
1496 // "symmetric" diphoton triggers (year dependent)
1497 ATH_CHECK( m_photonTriggerSFTool.setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2018/rel21.2/Summer2020_Rec_v1/map3.txt") );
1498 ATH_CHECK( m_photonTriggerSFTool.setProperty("IsoKey", photonIso_forTrigSF )); // Set isolation WP: Loose,TightCaloOnly
1499 ATH_CHECK( m_photonTriggerSFTool.setProperty("TriggerKey", m_photonTriggerName ));
1500 ATH_CHECK( m_photonTriggerSFTool.setProperty("ForceDataType", 1) ); // Set data type: 1 for FULLSIM, 3 for AF2
1501 ATH_CHECK( m_photonTriggerSFTool.setProperty("OutputLevel", this->msg().level()) );
1502 ATH_CHECK( m_photonTriggerSFTool.retrieve() );
1503
1504 // "asymmetric" diphoton triggers
1505 std::map<std::string,std::string> diphotonTriggerSFMapAsymmetric {
1506 // legs, Trigger keys,
1507 {"g25_loose,g25_medium_L1EM20VH", "DI_PH_2015_g25_loose_2016_g25_loose_2017_g25_medium_L1EM20VH_2018_g25_medium_L1EM20VH"},
1508 {"g35_loose,g35_medium_L1EM20VH", "DI_PH_2015_g35_loose_2016_g35_loose_2017_g35_medium_L1EM20VH_2018_g35_medium_L1EM20VH"},
1509 };
1510
1511 for(auto const& item : diphotonTriggerSFMapAsymmetric){
1512
1513 toolName = "AsgPhotonEfficiencyCorrectionTool_trigSF_asymm_diphoton_" + (item.first).substr(0,9) + photonIso_forTrigSF;
1514 auto ph_trigSF = m_photonEfficiencySFTool_trigSF_AsymDiphoton.emplace(m_photonEfficiencySFTool_trigSF_AsymDiphoton.end(), "CP::AsgPhotonEfficiencyCorrectionTool/"+toolName);
1515 ATH_CHECK( ph_trigSF->setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2018/rel21.2/Summer2020_Rec_v1/map3.txt") );
1516 ATH_CHECK( ph_trigSF->setProperty("IsoKey", photonIso_forTrigSF) );
1517 ATH_CHECK( ph_trigSF->setProperty("TriggerKey", item.second) );
1518 ATH_CHECK( ph_trigSF->setProperty("ForceDataType", 1) ); // Set DataType: 1 for FullSim and 3 for AFII
1519 ATH_CHECK( ph_trigSF->setProperty("OutputLevel", this->msg().level()) );
1520 ATH_CHECK( ph_trigSF->initialize() );
1521 m_photonTrigSFTools.push_back(ph_trigSF->getHandle());
1522 #ifndef XAOD_STANDALONE
1523 m_legsPerTool_ph[toolName] = item.first;
1524 #else
1525 m_legsPerTool_ph["ToolSvc."+toolName] = item.first;
1526 #endif
1527
1528 toolName = "AsgPhotonEfficiencyCorrectionTool_trigEff_asymm_diphoton_" + (item.first).substr(0,9) + photonIso_forTrigSF;
1529 auto ph_trigEff = m_photonEfficiencySFTool_trigEff_AsymDiphoton.emplace(m_photonEfficiencySFTool_trigEff_AsymDiphoton.end(), "CP::AsgPhotonEfficiencyCorrectionTool/"+toolName);
1530 ATH_CHECK( ph_trigEff->setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2018/rel21.2/Summer2020_Rec_v1/map3.txt") );
1531 ATH_CHECK( ph_trigEff->setProperty("IsoKey", photonIso_forTrigSF) );
1532 ATH_CHECK( ph_trigEff->setProperty("TriggerKey", "Eff_"+item.second) );
1533 ATH_CHECK( ph_trigEff->setProperty("ForceDataType", 1) ); // Set DataType: 1 for FullSim and 3 for AFII
1534 ATH_CHECK( ph_trigEff->setProperty("OutputLevel", this->msg().level()) );
1535 ATH_CHECK( ph_trigEff->initialize() );
1536 m_photonTrigEffTools.push_back(ph_trigEff->getHandle());
1537 #ifndef XAOD_STANDALONE
1538 m_legsPerTool_ph[toolName] = item.first;
1539 #else
1540 m_legsPerTool_ph["ToolSvc."+toolName] = item.first;
1541 #endif
1542
1543 }
1544 }
1545 }
1546
1547 }
1548 if (m_slices["ele"] || m_slices["pho"]) {
1550 // Initialize the EgammaAmbiguityTool
1551
1552 if (!m_egammaAmbiguityTool.isUserConfigured()) {
1553 m_egammaAmbiguityTool.setTypeAndName("EGammaAmbiguityTool/EGammaAmbiguityTool");
1554 ATH_CHECK( m_egammaAmbiguityTool.setProperty("OutputLevel", this->msg().level()) );
1555 ATH_CHECK( m_egammaAmbiguityTool.retrieve() );
1556 } else ATH_CHECK( m_egammaAmbiguityTool.retrieve() );
1557 }
1558
1559
1560 if (m_slices["ele"]) {
1561 //disable ///////////////////////////////////////////////////////////////////////////////////////////
1562 //disable // Initialize the AsgElectronChargeIDSelector
1563
1564 //disable if (!m_elecChargeIDSelectorTool.isUserConfigured()) {
1565
1566 //disable // For the selector, can use the nice function
1567 //disable std::string eleId = EG_WP(m_eleId);
1568 //disable m_elecChargeIDSelectorTool.setTypeAndName("AsgElectronChargeIDSelectorTool/ElectronChargeIDSelectorTool_"+eleId);
1569 //disable //default cut value for https://twiki.cern.ch/twiki/bin/view/AtlasProtected/ElectronChargeFlipTaggerTool
1570 //disable float BDTcut = -0.337671; // Loose 97%
1571 //disable if (m_eleChID_WP != "Loose" && !m_eleChID_WP.empty()) {
1572 //disable ATH_MSG_ERROR("Only Loose WP is supported in R21. Invalid ChargeIDSelector WP selected : " << m_eleChID_WP);
1573 //disable return StatusCode::FAILURE;
1574 //disable }
1575
1576 //disable ATH_CHECK( m_elecChargeIDSelectorTool.setProperty("TrainingFile", "ElectronPhotonSelectorTools/ChargeID/ECIDS_20180731rel21Summer2018.root"));
1577 //disable ATH_CHECK( m_elecChargeIDSelectorTool.setProperty("CutOnBDT", BDTcut));
1578 //disable ATH_CHECK( m_elecChargeIDSelectorTool.setProperty("OutputLevel", this->msg().level()) );
1579 //disable ATH_CHECK( m_elecChargeIDSelectorTool.retrieve() );
1580 //disable } else ATH_CHECK( m_elecChargeIDSelectorTool.retrieve() );
1581
1582
1584 // Initialise egamma calibration tool
1585
1586 if (!m_egammaCalibTool.isUserConfigured()) {
1587 m_egammaCalibTool.setTypeAndName("CP::EgammaCalibrationAndSmearingTool/EgammaCalibrationAndSmearingTool");
1588 ATH_MSG_DEBUG( "Initialising EgcalibTool " );
1589 ATH_CHECK( m_egammaCalibTool.setProperty("ESModel", m_isRun3 ? "es2024_Run3_v0" : "es2023_R22_Run2_v1") );
1590 ATH_CHECK( m_egammaCalibTool.setProperty("decorrelationModel", "1NP_v1") );
1591 // allows to bypass (intended) abort from of egamma calibration tool when configured for fastSim
1592 if (m_eleForceFullSimCalib) {
1593 ATH_MSG_WARNING( "Forcing EgcalibTool to use calibrations for full simulation" );
1594 ATH_CHECK( m_egammaCalibTool.setProperty("useFastSim", false) );
1595 }
1596 else {
1597 ATH_MSG_INFO("is Fast Sim:" << isAtlfast());
1598 ATH_CHECK( m_egammaCalibTool.setProperty("useFastSim", isAtlfast() ? 1 : 0) );
1599 }
1600 ATH_CHECK( m_egammaCalibTool.setProperty("OutputLevel", this->msg().level()) );
1601 ATH_CHECK( m_egammaCalibTool.retrieve() );
1602 } else ATH_CHECK( m_egammaCalibTool.retrieve() );
1603 }
1604
1605
1606 if (m_slices["tau"]) {
1608
1610 // Initialise path to tau config file and config reader
1611
1612 // Read in the config file so we can retrieve the fields later when configuring the efficiency tools
1613 if ( m_tauConfigReader.ReadFile( PathResolverFindCalibFile(m_tauInputFile).c_str(), EEnvLevel(0) ) ) {
1614 ATH_MSG_ERROR( "Error while reading tau config file : " << m_tauInputFile );
1615 return StatusCode::FAILURE;
1616 }
1617 else ATH_MSG_DEBUG( "Successfully read tau config file : " << m_tauInputFile );
1618
1619
1621 // Initialise tau selection tools
1622
1623 if (!m_tauSelTool.isUserConfigured()) {
1624 toolName = "TauSelectionTool_" + m_tauId;
1625 m_tauSelTool.setTypeAndName("TauAnalysisTools::TauSelectionTool/"+toolName);
1626 ATH_CHECK( m_tauSelTool.setProperty("ConfigPath", m_tauInputFile) );
1627 ATH_CHECK( m_tauSelTool.setProperty("OutputLevel", this->msg().level()) );
1628 ATH_CHECK( m_tauSelTool.retrieve() );
1629 } else ATH_CHECK( m_tauSelTool.retrieve() );
1630
1631
1632 if (!m_tauSelToolBaseline.isUserConfigured()) {
1633 toolName = "TauSelectionToolBaseline_" + m_tauIdBaseline;
1634 m_tauSelToolBaseline.setTypeAndName("TauAnalysisTools::TauSelectionTool/"+toolName);
1635 ATH_CHECK( m_tauSelToolBaseline.setProperty("ConfigPath", m_tauInputFileBaseline) );
1636 ATH_CHECK( m_tauSelToolBaseline.setProperty("OutputLevel", this->msg().level()) );
1637 ATH_CHECK( m_tauSelToolBaseline.retrieve() );
1638 } else ATH_CHECK( m_tauSelToolBaseline.retrieve() );
1639
1640
1642 // jetIDWP/elIDWP for efficiency tool + trigger tool
1643 std::string jetIDWP = m_tauConfigReader.GetValue("JetIDWP" ,"");
1644 ANA_MSG_DEBUG( "Found JetIDWP in tau config file : " << jetIDWP );
1645 int jet_id_lvl;
1646 // Read out the tau ID from the config file and map into the enum from tau CP
1647 if (jetIDWP == "JETIDNONE") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDNONE;
1648 else if (jetIDWP == "JETIDRNNVERYLOOSE") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDRNNVERYLOOSE;
1649 else if (jetIDWP == "JETIDRNNLOOSE") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDRNNLOOSE;
1650 else if (jetIDWP == "JETIDRNNMEDIUM") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDRNNMEDIUM;
1651 else if (jetIDWP == "JETIDRNNTIGHT") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDRNNTIGHT;
1652 else if (jetIDWP == "JETIDGNTAUVERYLOOSE") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDGNTAUVERYLOOSE;
1653 else if (jetIDWP == "JETIDGNTAULOOSE") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDGNTAULOOSE;
1654 else if (jetIDWP == "JETIDGNTAUMEDIUM") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDGNTAUMEDIUM;
1655 else if (jetIDWP == "JETIDGNTAUTIGHT") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDGNTAUTIGHT;
1656 else {
1657 ATH_MSG_ERROR("Invalid Tau ID in tau config file " << jetIDWP);
1658 return StatusCode::FAILURE;
1659 }
1660 // Read out the (optional) Ele OR from the config file and map into the enum from tau CP
1661 std::string eleIDWP = m_tauConfigReader.GetValue("EleIDWP" ,"");
1662 ANA_MSG_DEBUG( "Found EleIDWP in tau config file : " << eleIDWP );
1663 int ele_id_lvl = -1;
1664 if (eleIDWP == "ELEIDRNNLOOSE") ele_id_lvl = (int)TauAnalysisTools::EleID::ELEIDRNNLOOSE;
1665 else if (eleIDWP == "ELEIDRNNMEDIUM") ele_id_lvl = (int)TauAnalysisTools::EleID::ELEIDRNNMEDIUM;
1666 else if (eleIDWP == "ELEIDRNNTIGHT") ele_id_lvl = (int)TauAnalysisTools::EleID::ELEIDRNNTIGHT;
1667 else {
1668 ATH_MSG_INFO("No or invalid Ele OR in tau config file " << eleIDWP << " will not apply SFs for electro veto" );
1669 }
1670 if (jet_id_lvl == (int)TauAnalysisTools::JetID::JETIDRNNTIGHT || jet_id_lvl == (int)TauAnalysisTools::JetID::JETIDGNTAUTIGHT) {
1671 ATH_MSG_WARNING("EleOR with Tight TauID is currently not supported, please discuss with TauCP!");
1672 }
1673
1674 int jet_id_lvl_fb = jet_id_lvl;
1675 if (m_tau_id_fallback.count(jet_id_lvl) > 0) {
1676 jet_id_lvl_fb = m_tau_id_fallback[jet_id_lvl];
1677 ATH_MSG_WARNING("Configuring fallback RNN ID SF for GNTau config, do not use in production!");
1678 }
1679
1680
1682 // Initialise tau efficiency tool
1683
1684 // TEMPORARY: no recommendations yet for 2024+
1685 if (!m_tauEffTool.isUserConfigured() && !isData() && !(m_mcCampaign=="mc23e" || m_mcCampaign=="mc23g")) {
1686 toolName = "TauEffTool_" + m_tauId;
1687 m_tauEffTool.setTypeAndName("TauAnalysisTools::TauEfficiencyCorrectionsTool/"+toolName);
1688
1689 std::vector<int> correction_types;
1690 // Add retrieval of reco and ID SFs
1691 correction_types.insert(correction_types.end(), {TauAnalysisTools::EfficiencyCorrectionType::SFRecoHadTau,
1692 TauAnalysisTools::EfficiencyCorrectionType::SFJetIDHadTau});
1693
1694 // Add retrieval of electron veto SFs if its applied
1695 if (ele_id_lvl != -1 )
1696 correction_types.insert(correction_types.end(), {TauAnalysisTools::EfficiencyCorrectionType::SFEleIDHadTau,
1697 TauAnalysisTools::EfficiencyCorrectionType::SFEleIDElectron});
1698
1699 ATH_CHECK( m_tauEffTool.setProperty("JetIDLevel", jet_id_lvl_fb) );
1700 ATH_CHECK( m_tauEffTool.setProperty("EleIDLevel", ele_id_lvl) );
1701 ATH_CHECK( m_tauEffTool.setProperty("EfficiencyCorrectionTypes", correction_types) );
1702 ATH_CHECK( m_tauEffTool.setProperty("OutputLevel", this->msg().level()) );
1703 ATH_CHECK( m_tauEffTool.setProperty("useFastSim", isAtlfast()) );
1704 ATH_CHECK( m_tauEffTool.setProperty("RecommendationTag", m_tauEffToolRecommendationTag) );
1705 if (m_isRun3){ ATH_CHECK( m_tauEffTool.setProperty("Campaign", "mc23") );}
1706 else { ATH_CHECK( m_tauEffTool.setProperty("Campaign", "mc20") );}
1707 ATH_CHECK( m_tauEffTool.retrieve() );
1708 } else if (m_tauEffTool.isUserConfigured()) ATH_CHECK( m_tauEffTool.retrieve() );
1709
1710
1712 // Initialise tau trigger efficiency tool(s)
1713
1714 // TEMPORARY: no recommendations yet for 2024+
1715 if (!isData() && !(m_mcCampaign=="mc23e" || m_mcCampaign=="mc23g")) {
1716 // map format: SF file name, corresponding single-tau leg (comma-separated in case of OR)
1717 m_tau_trig_support = {
1718 {"HLT_tau25_medium1_tracktwo", "HLT_tau25_medium1_tracktwo"},
1719 {"HLT_tau35_medium1_tracktwo", "HLT_tau35_medium1_tracktwo"},
1720 {"HLT_tau50L1TAU12_medium1_tracktwo", "HLT_tau50_medium1_tracktwo_L1TAU12"},
1721 {"HLT_tau60_medium1_tracktwo", "HLT_tau60_medium1_tracktwo"},
1722 {"HLT_tau80L1TAU60_medium1_tracktwo", "HLT_tau80_medium1_tracktwo_L1TAU60"},
1723 {"HLT_tau125_medium1_tracktwo", "HLT_tau125_medium1_tracktwo"},
1724 {"HLT_tau160_medium1_tracktwo", "HLT_tau160_medium1_tracktwo"},
1725 {"HLT_tau160L1TAU100_medium1_tracktwo", "HLT_tau160_medium1_tracktwo_L1TAU100"},
1726 // whole 2018 data taking period
1727 {"HLT_tau25_medium1_tracktwoEF", "HLT_tau25_medium1_tracktwoEF"},
1728 {"HLT_tau35_medium1_tracktwoEF", "HLT_tau35_medium1_tracktwoEF"},
1729 {"HLT_tau60_medium1_tracktwoEF", "HLT_tau60_medium1_tracktwoEF"},
1730 {"HLT_tau80L1TAU60_medium1_tracktwoEF", "HLT_tau80_medium1_tracktwoEF_L1TAU60"},
1731 {"HLT_tau160L1TAU100_medium1_tracktwoEF", "HLT_tau160_medium1_tracktwoEF_L1TAU100"},
1732 };
1733
1734 if (m_isRun3){
1735 m_tau_trig_support = {
1736 // 2024,2025,2026
1737 // TBA
1738 // 2022, 2023
1739 {"HLT_tau25_mediumRNN_tracktwoMVA", "HLT_tau25_mediumRNN_tracktwoMVA"},
1740 {"HLT_tau35_mediumRNN_tracktwoMVA", "HLT_tau35_mediumRNN_tracktwoMVA"},
1741 // 2022, 2023 75-1800 bunches
1742 {"HLT_tau160_mediumRNN_tracktwoMVA", "HLT_tau160_mediumRNN_tracktwoMVA_L1TAU100"},
1743 // 2023 from 400 bunches
1744 {"HLT_tau160_mediumRNN_tracktwoMVA", "HLT_tau160_mediumRNN_tracktwoMVA_L1eTAU140"}
1745 };
1746 }
1747
1748 for(auto const& trigger : m_tau_trig_support) {
1749 toolName = "TauTrigEffTool_" + m_tauId + "_" + trigger.first;
1750 auto tau_trigSF = m_tauTrigEffTool.emplace(m_tauTrigEffTool.end(), "TauAnalysisTools::TauEfficiencyCorrectionsTool/"+toolName);
1751 ATH_CHECK( tau_trigSF->setProperty("EfficiencyCorrectionTypes", std::vector<int>({TauAnalysisTools::SFTriggerHadTau})) );
1752 ATH_CHECK( tau_trigSF->setProperty("TriggerName", trigger.first) );
1753 ATH_CHECK( tau_trigSF->setProperty("JetIDLevel", jet_id_lvl_fb) );
1754 ATH_CHECK( tau_trigSF->setProperty("EleIDLevel", ele_id_lvl) );
1755 ATH_CHECK( tau_trigSF->setProperty("OutputLevel", this->msg().level()) );
1756 ATH_CHECK( tau_trigSF->setProperty("useFastSim", isAtlfast()) );
1757 ATH_CHECK( tau_trigSF->setProperty("RecommendationTag", m_tauEffToolRecommendationTag) );
1758 if (m_isRun3){ ATH_CHECK( tau_trigSF->setProperty("Campaign", m_mcCampaign) );}
1759 else { ATH_CHECK( tau_trigSF->setProperty("Campaign", "mc20") );}
1760 ATH_CHECK( tau_trigSF->initialize() );
1761 }
1762 }
1763
1764
1766 // Initialise tau smearing tool
1767
1768 if (!m_tauSmearingTool.isUserConfigured()) {
1769 m_tauSmearingTool.setTypeAndName("TauAnalysisTools::TauSmearingTool/TauSmearingTool");
1770 ATH_CHECK( m_tauSmearingTool.setProperty("RecommendationTag", m_tauSmearingToolRecommendationTag) );
1771 if (m_isRun3){ ATH_CHECK( m_tauSmearingTool.setProperty("Campaign", "mc23") );}
1772 else { ATH_CHECK( m_tauSmearingTool.setProperty("Campaign", "mc20") );}
1773 ATH_CHECK( m_tauSmearingTool.setProperty("MVATESQualityCheck", m_ApplyMVATESQualityCheck) );
1774 ATH_CHECK( m_tauSmearingTool.setProperty("useFastSim", isAtlfast()) );
1775 ATH_CHECK( m_tauSmearingTool.setProperty("OutputLevel", this->msg().level()) );
1776 ATH_CHECK( m_tauSmearingTool.retrieve() );
1777 } else ATH_CHECK( m_tauSmearingTool.retrieve() );
1778
1779
1781 // Initialise tau truth matching tool
1782
1783 if (!m_tauTruthMatch.isUserConfigured() && m_tauDoTTM && !isData()) {
1784 m_tauTruthMatch.setTypeAndName("TauAnalysisTools::TauTruthMatchingTool/TauTruthMatch");
1785 ATH_CHECK( m_tauTruthMatch.setProperty("TruthJetContainerName", m_defaultTruthJets ) );
1786 ATH_CHECK( m_tauTruthMatch.setProperty("OutputLevel", this->msg().level()) );
1787 ATH_CHECK( m_tauTruthMatch.retrieve() );
1788 } else if (m_tauTruthMatch.isUserConfigured()) ATH_CHECK( m_tauTruthMatch.retrieve() );
1789
1790
1791 }
1792
1793
1794 if (m_slices["bjet"]) {
1796 // Initialise B-tagging tools
1797
1798 // btagSelectionTool
1799 std::string jetcollBTag = jetcoll;
1800 if (jetcoll == "AntiKt4LCTopoJets") {
1801 ATH_MSG_WARNING(" *** HACK *** Treating LCTopoJets jets as EMTopo -- use at your own risk!");
1802 jetcollBTag = "AntiKt4EMTopoJets";
1803 }
1804
1805 // print a warning if there is indication that the user supplied a CDI file not matching to the sample being processed
1806 // see --> https://twiki.cern.ch/twiki/bin/view/AtlasProtected/BTagRel22HighLevelSummary
1807 if( (m_bTaggingCalibrationFilePath.find(!m_isRun3 ? "MC20" : "MC23") == std::string::npos) && (m_bTaggingCalibrationFilePath.find(!m_isRun3 ? "MC20" : "MC21") == std::string::npos) ) {
1808 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"));
1809 }
1810
1811 if (m_useBtagging && !m_btagSelTool.isUserConfigured() && !m_BtagWP.empty()) {
1812 if (jetcollBTag.find("AntiKt4EMTopoJets") == std::string::npos && jetcollBTag.find("AntiKt4EMPFlowJets")==std::string::npos) {
1813 ATH_MSG_WARNING("** Only AntiKt4EMTopoJets and AntiKt4EMPFlowJets are supported with FTAG scale factors!");
1814 return StatusCode::FAILURE;
1815 }
1816
1817 toolName = "BTagSel_" + jetcollBTag + m_BtagTagger + m_BtagWP;
1818
1819 m_btagSelTool.setTypeAndName("BTaggingSelectionTool/"+toolName);
1820 ATH_CHECK( m_btagSelTool.setProperty("TaggerName", m_BtagTagger ) );
1821 ATH_CHECK( m_btagSelTool.setProperty("OperatingPoint", m_BtagWP ) );
1822 ATH_CHECK( m_btagSelTool.setProperty("JetAuthor", jetcollBTag ) );
1823 ATH_CHECK( m_btagSelTool.setProperty("MinPt", m_BtagMinPt ) );
1824 ATH_CHECK( m_btagSelTool.setProperty("FlvTagCutDefinitionsFileName", m_bTaggingCalibrationFilePath) );
1825 // Read from BTagging object. This will be needed until the input file is produced from
1826 // a derivation release that includes !80336.
1827 ATH_CHECK( m_btagSelTool.setProperty("readFromBTaggingObject", m_BtagReadFromObject ) );
1828 ATH_CHECK( m_btagSelTool.setProperty("OutputLevel", this->msg().level()) );
1829 ATH_CHECK( m_btagSelTool.retrieve() );
1830 } else if (m_btagSelTool.isUserConfigured()) ATH_CHECK( m_btagSelTool.retrieve() );
1831
1832
1833 if (m_useBtagging && !m_btagSelTool_OR.isUserConfigured() && !m_orBtagWP.empty()) {
1834 if (jetcoll != "AntiKt4EMTopoJets" && jetcoll != "AntiKt4EMPFlowJets") {
1835 ATH_MSG_WARNING("** Only AntiKt4EMTopoJets and AntiKt4EMPFlowJets are supported with FTAG scale factors!");
1836 return StatusCode::FAILURE;
1837 }
1838
1839 toolName = "BTagSelOR_" + jetcollBTag + m_orBtagWP;
1840 m_btagSelTool_OR.setTypeAndName("BTaggingSelectionTool/"+toolName);
1841 ATH_CHECK( m_btagSelTool_OR.setProperty("TaggerName", m_BtagTagger ) );
1842 ATH_CHECK( m_btagSelTool_OR.setProperty("OperatingPoint", m_orBtagWP ) );
1843 ATH_CHECK( m_btagSelTool_OR.setProperty("JetAuthor", jetcollBTag ) );
1844 ATH_CHECK( m_btagSelTool_OR.setProperty("MinPt", m_BtagMinPt ) );
1845 ATH_CHECK( m_btagSelTool_OR.setProperty("FlvTagCutDefinitionsFileName", m_bTaggingCalibrationFilePath) );
1846 // Read from BTagging object. This will be needed until the input file is produced from
1847 // a derivation release that includes !80336.
1848 ATH_CHECK( m_btagSelTool_OR.setProperty("readFromBTaggingObject", m_BtagReadFromObject ) );
1849 ATH_CHECK( m_btagSelTool_OR.setProperty("OutputLevel", this->msg().level()) );
1850 ATH_CHECK( m_btagSelTool_OR.retrieve() );
1851 } else if (m_btagSelTool_OR.isUserConfigured()) ATH_CHECK( m_btagSelTool_OR.retrieve() );
1852
1853
1854 std::string trkjetcoll = m_defaultTrackJets;
1855 const std::string& BTagColl_TrkJet = trkjetcoll;
1856 if (m_slices["tjet"]) {
1857 if ( m_useBtagging_trkJet && m_defaultTrackJets.empty()) {
1858 m_useBtagging_trkJet = false;
1859 ATH_MSG_INFO("TrackJet collection set to None: disabling btagging for TrackJets.");
1860 }
1861
1862 if (m_useBtagging_trkJet && !m_btagSelTool_trkJet.isUserConfigured() && !m_BtagWP_trkJet.empty()) {
1863 if (trkjetcoll.find("AntiKt2PV0TrackJets")==std::string::npos && trkjetcoll.find("AntiKtVR30Rmax4Rmin02TrackJets")==std::string::npos) {
1864 ATH_MSG_WARNING("** Only AntiKt2PV0TrackJets and AntiKtVR30Rmax4Rmin02TrackJets are supported with FTAG scale factors!");
1865 return StatusCode::FAILURE;
1866 }
1867
1868 toolName = "BTagSel_" + trkjetcoll + m_BtagTagger_trkJet + m_BtagWP_trkJet;
1869
1870 m_btagSelTool_trkJet.setTypeAndName("BTaggingSelectionTool/"+toolName);
1871 ATH_CHECK( m_btagSelTool_trkJet.setProperty("TaggerName", m_BtagTagger_trkJet ) );
1872 ATH_CHECK( m_btagSelTool_trkJet.setProperty("OperatingPoint", m_BtagWP_trkJet ) );
1873 ATH_CHECK( m_btagSelTool_trkJet.setProperty("MinPt", m_BtagMinPt_trkJet ) );
1874 ATH_CHECK( m_btagSelTool_trkJet.setProperty("JetAuthor", BTagColl_TrkJet ) );
1875 ATH_CHECK( m_btagSelTool_trkJet.setProperty("MinPt", m_BtagMinPt_trkJet ) );
1876 ATH_CHECK( m_btagSelTool_trkJet.setProperty("FlvTagCutDefinitionsFileName", m_bTaggingCalibrationFilePath) );
1877 // Read from BTagging object. This will be needed until the input file is produced from
1878 // a derivation release that includes !80336.
1879 ATH_CHECK( m_btagSelTool_trkJet.setProperty("readFromBTaggingObject", m_BtagReadFromObject_trkJet ) );
1880 ATH_CHECK( m_btagSelTool_trkJet.setProperty("OutputLevel", this->msg().level()) );
1881 ATH_CHECK( m_btagSelTool_trkJet.retrieve() );
1882 } else if (m_btagSelTool_trkJet.isUserConfigured()) ATH_CHECK( m_btagSelTool_trkJet.retrieve() );
1883 }
1884
1885 // Set MCshowerType for FTAG MC/MC SFs
1886 // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/BTagCalibrationRecommendationsRelease21#MC_MC_Scale_Factors_for_Analysis
1887 std::string MCshowerID;
1888 if(m_showerType==-1){
1889 ATH_MSG_ERROR( "Error! m_showerType=-1, which is an error case for FTAG MC/MC SFs." );
1890 return StatusCode::FAILURE;
1891 }
1892 if(m_BtagTagger=="DL1dv01"){
1893 if(!m_isRun3){
1894 MCshowerID= "default"; // Powheg+Pythia8 (410470) - PhPy8EG_A14
1895 if (m_showerType == 1) MCshowerID = "411233"; // PowhegHerwig7
1896 else if (m_showerType == 2) MCshowerID = "600666"; // PhH7EG_H7UE - 601414
1897 else if (m_showerType == 3) MCshowerID = "410250"; // Sherpa_221
1898 else if (m_showerType == 4) MCshowerID = "700122"; // Sh_2210
1899 else if (m_showerType == 5) MCshowerID = "700122"; // Sh_2211
1900 else if (m_showerType == 6) MCshowerID = "700660"; // Sh_2212 - 700660
1901 else if (m_showerType == 7) MCshowerID = "410464"; // aMcAtNloPy8
1902 else if (m_showerType == 8) MCshowerID = "412116"; // aMcAtNloHerwig7
1903 else if (m_showerType != 0){
1904 ATH_MSG_WARNING("Unknown ShowerID detected! Using default FTAG MC-MC SFs (Powheg+Pythia8). Please check if these are applicable for this sample!");
1905 }
1906 }
1907 else{
1908 MCshowerID= "default"; // Powheg+Pythia8 (601229) - PhPy8EG_A14
1909 if (m_showerType == 2) MCshowerID = "601414"; // POWHEG+Herwig721 - PhH7EG_A14
1910 else if (m_showerType == 6) MCshowerID = "700660"; // Sherpa 2.2.12 - Sh_2212
1911 else if (m_showerType != 0){
1912 ATH_MSG_WARNING("Unknown ShowerID detected! Using default FTAG MC-MC SFs (Powheg+Pythia8). Please check if these are applicable for this sample!");
1913 }
1914 }
1915 } else if (m_BtagTagger=="GN2v01"){
1916 if(!m_isRun3){
1917 MCshowerID= "default"; // PowhegPythia8EvtGen (410470)
1918 if (m_showerType == 2) MCshowerID = "411233"; // POWHEGHERWIG7 - 411233
1919 else if (m_showerType == 3) MCshowerID = "600666"; // PhH7EG_H7UE - 600666
1920 else if (m_showerType == 4) MCshowerID = "700660"; // Sh_2210 FTAGAnalysisConfig uses this, but docs say only 11-16 can be used
1921 else if (m_showerType == 5) MCshowerID = "700660"; // Sh_2211
1922 else if (m_showerType == 6) MCshowerID = "700660"; // Sh_2212
1923 else if (m_showerType == 7) MCshowerID = "700660"; // Sh_2214
1924 else if (m_showerType == 8) {
1925 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!");
1926 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.
1927 }
1928 else if (m_showerType != 0){
1929 ATH_MSG_WARNING("Unknown ShowerID detected! Using default FTAG MC-MC SFs (Powheg+Pythia8). Please check if these are applicable for this sample!");
1930 }
1931 }
1932 else {
1933 MCshowerID= "default"; // PowhegPythia8EvtGen (601229)
1934 if (m_showerType == 3) MCshowerID = "601414"; // PhH7EG_H7UE - 601414
1935 else if (m_showerType == 5) MCshowerID = "700808"; // Sh_2211
1936 else if (m_showerType == 6) MCshowerID = "700808"; // Sh_2212
1937 else if (m_showerType == 7) MCshowerID = "700808"; // Sh_2214
1938 else if (m_showerType == 8) {
1939 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!");
1940 MCshowerID = "700660"; // Unknown Sherpa Version
1941 }
1942 else if (m_showerType != 0){
1943 ATH_MSG_WARNING("Unknown ShowerID detected! Using default FTAG MC-MC SFs (Powheg+Pythia8). Please check if these are applicable for this sample!");
1944 }
1945 }
1946 } else {
1947 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!");
1948 MCshowerID= "default";
1949 }
1950
1951 // btagEfficiencyTool
1952 if (m_useBtagging && !m_btagEffTool.isUserConfigured() && !m_BtagWP.empty()) {
1953 if (jetcoll != "AntiKt4EMTopoJets" && jetcoll != "AntiKt4EMPFlowJets") {
1954 ATH_MSG_WARNING("** Only AntiKt4EMTopoJets and AntiKt4EMPFlowJets are supported with FTAG scale factors!");
1955 return StatusCode::FAILURE;
1956 }
1957
1958 toolName = "BTagSF_" + jetcollBTag + m_BtagTagger + m_BtagWP;
1959 m_btagEffTool.setTypeAndName("BTaggingEfficiencyTool/"+toolName);
1960 ATH_CHECK( m_btagEffTool.setProperty("TaggerName", m_BtagTagger ) );
1961 ATH_CHECK( m_btagEffTool.setProperty("ScaleFactorFileName", m_bTaggingCalibrationFilePath) );
1962 ATH_CHECK( m_btagEffTool.setProperty("OperatingPoint", m_BtagWP ) );
1963 ATH_CHECK( m_btagEffTool.setProperty("JetAuthor", jetcollBTag ) );
1964 // Read from BTagging object. This will be needed until the input file is produced from
1965 // a derivation release that includes !80336.
1966 ATH_CHECK( m_btagEffTool.setProperty("readFromBTaggingObject", m_BtagReadFromObject ) );
1967 ATH_CHECK( m_btagEffTool.setProperty("MinPt", m_BtagMinPt ) );
1968 ATH_CHECK( m_btagEffTool.setProperty("SystematicsStrategy", m_BtagSystStrategy ) );
1969 ATH_CHECK( m_btagEffTool.setProperty("EfficiencyBCalibrations", MCshowerID ));
1970 ATH_CHECK( m_btagEffTool.setProperty("EfficiencyCCalibrations", MCshowerID ));
1971 ATH_CHECK( m_btagEffTool.setProperty("EfficiencyTCalibrations", MCshowerID ));
1972 ATH_CHECK( m_btagEffTool.setProperty("EfficiencyLightCalibrations", MCshowerID ));
1973 ATH_CHECK( m_btagEffTool.setProperty("EigenvectorReductionB", m_EigenvectorReductionB ));
1974 ATH_CHECK( m_btagEffTool.setProperty("EigenvectorReductionC", m_EigenvectorReductionC ));
1975 ATH_CHECK( m_btagEffTool.setProperty("EigenvectorReductionLight", m_EigenvectorReductionLight ));
1976 ATH_CHECK( m_btagEffTool.setProperty("OutputLevel", this->msg().level()) );
1977 ATH_CHECK( m_btagEffTool.retrieve() );
1978 } else ATH_CHECK( m_btagEffTool.retrieve() );
1979
1980
1981 if (m_slices["tjet"]) {
1982 if (m_useBtagging_trkJet && !m_btagEffTool_trkJet.isUserConfigured() && !m_BtagWP_trkJet.empty()) {
1983 if (trkjetcoll.find("AntiKt2PV0TrackJets")==std::string::npos && trkjetcoll.find("AntiKtVR30Rmax4Rmin02TrackJets")==std::string::npos) {
1984 ATH_MSG_WARNING("** Only AntiKt2PV0TrackJets and AntiKtVR30Rmax4Rmin02TrackJets are supported with FTAG scale factors!");
1985 return StatusCode::FAILURE;
1986 }
1987
1988 toolName = "BTagSF_" + trkjetcoll;
1989 m_btagEffTool_trkJet.setTypeAndName("BTaggingEfficiencyTool/"+toolName);
1990 ATH_CHECK( m_btagEffTool_trkJet.setProperty("TaggerName", m_BtagTagger_trkJet ) );
1991 ATH_CHECK( m_btagEffTool_trkJet.setProperty("ScaleFactorFileName", m_bTaggingCalibrationFilePath) );
1992 ATH_CHECK( m_btagEffTool_trkJet.setProperty("OperatingPoint", m_BtagWP_trkJet ) );
1993 ATH_CHECK( m_btagEffTool_trkJet.setProperty("JetAuthor", BTagColl_TrkJet ) );
1994 // Read from BTagging object. This will be needed until the input file is produced from
1995 // a derivation release that includes !80336.
1996 ATH_CHECK( m_btagEffTool_trkJet.setProperty("readFromBTaggingObject", m_BtagReadFromObject_trkJet ) );
1997 ATH_CHECK( m_btagEffTool_trkJet.setProperty("MinPt", m_BtagMinPt_trkJet ) );
1998 ATH_CHECK( m_btagEffTool_trkJet.setProperty("SystematicsStrategy", m_BtagSystStrategy ) );
1999 ATH_CHECK( m_btagEffTool_trkJet.setProperty("EfficiencyBCalibrations", MCshowerID ));
2000 ATH_CHECK( m_btagEffTool_trkJet.setProperty("EfficiencyCCalibrations", MCshowerID ));
2001 ATH_CHECK( m_btagEffTool_trkJet.setProperty("EfficiencyTCalibrations", MCshowerID ));
2002 ATH_CHECK( m_btagEffTool_trkJet.setProperty("EfficiencyLightCalibrations", MCshowerID ));
2003 ATH_CHECK( m_btagEffTool_trkJet.setProperty("EigenvectorReductionB", m_EigenvectorReductionB ));
2004 ATH_CHECK( m_btagEffTool_trkJet.setProperty("EigenvectorReductionC", m_EigenvectorReductionC ));
2005 ATH_CHECK( m_btagEffTool_trkJet.setProperty("EigenvectorReductionLight", m_EigenvectorReductionLight ));
2006 ATH_CHECK( m_btagEffTool_trkJet.setProperty("OutputLevel", this->msg().level()) );
2007 ATH_CHECK( m_btagEffTool_trkJet.retrieve() );
2008 } else if (m_btagEffTool_trkJet.isUserConfigured()) ATH_CHECK( m_btagEffTool_trkJet.retrieve() );
2009 }
2010 }
2011
2012
2013 if (m_slices["met"]) {
2015 // Initialise MET tools
2016
2017 if (!m_metMaker.isUserConfigured()) {
2018 toolName = m_doFwdJVT ? m_metJetSelection+"_fJVT" : m_metJetSelection+"_NOfJVT";
2019 m_metMaker.setTypeAndName("met::METMaker/METMaker_ST_"+toolName);
2020
2021 ATH_CHECK( m_metMaker.setProperty("JetContainer", jetcoll) );
2022 ATH_CHECK( m_metMaker.setProperty("ORCaloTaggedMuons", m_metRemoveOverlappingCaloTaggedMuons) );
2023 ATH_CHECK( m_metMaker.setProperty("DoSetMuonJetEMScale", m_metDoSetMuonJetEMScale) );
2024 ATH_CHECK( m_metMaker.setProperty("DoRemoveMuonJets", m_metDoRemoveMuonJets) );
2025 ATH_CHECK( m_metMaker.setProperty("UseGhostMuons", m_metUseGhostMuons) );
2026 ATH_CHECK( m_metMaker.setProperty("DoMuonEloss", m_metDoMuonEloss) );
2027 ATH_CHECK( m_metMaker.setProperty("GreedyPhotons", m_metGreedyPhotons) );
2028 ATH_CHECK( m_metMaker.setProperty("VeryGreedyPhotons", m_metVeryGreedyPhotons) );
2029
2030 // set the jet selection if default empty string is overridden through config file
2031 if (m_metJetSelection.size()) {
2032 ATH_CHECK( m_metMaker.setProperty("JetSelection", m_metJetSelection) );
2033 }
2034 if (m_jetInputType == xAOD::JetInput::EMPFlow) {
2035 ATH_CHECK( m_metMaker.setProperty("DoPFlow", true) );
2036 }
2037
2038 ATH_CHECK( m_metMaker.setProperty("OutputLevel", this->msg().level()) );
2039 ATH_CHECK( m_metMaker.retrieve() );
2040 } else ATH_CHECK( m_metMaker.retrieve() );
2041
2042
2043 if (!m_metSystTool.isUserConfigured()) {
2044 m_metSystTool.setTypeAndName("met::METSystematicsTool/METSystTool");
2045 ATH_CHECK( m_metSystTool.setProperty("ConfigPrefix", m_metsysConfigPrefix) );
2046
2047 if (m_trkMETsyst && m_caloMETsyst){
2048 ATH_MSG_ERROR( "Can only have CST *or* TST configured for MET maker. Please unset either METDoCaloSyst or METDoTrkSyst in your config file" );
2049 return StatusCode::FAILURE;
2050 }
2051
2052 if (m_trkMETsyst) {
2053 ATH_CHECK( m_metSystTool.setProperty("ConfigSoftCaloFile", "") );
2054 ATH_CHECK( m_metSystTool.setProperty("ConfigSoftTrkFile", "TrackSoftTerms-pflow_Dec24.config") );
2055 }
2056
2057 if (m_caloMETsyst) {
2058 ATH_MSG_WARNING( "CST is no longer recommended by Jet/MET group");
2059 ATH_CHECK( m_metSystTool.setProperty("ConfigSoftTrkFile", "") );
2060 }
2061
2062 if (m_trkJetsyst) {
2063 ATH_CHECK( m_metSystTool.setProperty("ConfigJetTrkFile", "JetTrackSyst.config") );
2064 }
2065
2066 ATH_CHECK( m_metSystTool.setProperty("OutputLevel", this->msg().level()) );
2067 ATH_CHECK( m_metSystTool.retrieve());
2068 } else ATH_CHECK( m_metSystTool.retrieve());
2069
2070
2071 if (!m_metSignif.isUserConfigured()) {
2072 // See https://twiki.cern.ch/twiki/bin/view/AtlasProtected/MetSignificance
2073 m_metSignif.setTypeAndName("met::METSignificance/metSignificance_"+jetname);
2074#ifndef XAOD_STANDALONE // Athena and AthAnalysis; need to take into account that MuonCalibTool is private tool
2075 ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "SoftTermParam", m_softTermParam));
2076 ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "TreatPUJets", m_treatPUJets));
2077 ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "DoPhiReso", m_doPhiReso));
2078 if(jetname != "AntiKt4EMPFlow")
2079 ATH_MSG_WARNING("METSignificance recommendations only exist for AntiKt4EMPFlow jets, falling back to this.");
2080 ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "JetCollection", "AntiKt4EMPFlow"));
2081 // This is the only recommended set of jet resolutions for use with R22+ MET Significance until "Consolidated" recommendations are available
2082 ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "JetCalibConfig", "JES_data2017_2016_2015_Recommendation_PFlow_Aug2018_rel21.config") );
2083 ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "JetCalibSequence", "JetArea_Residual_EtaJES_GSC_Smear") );
2084 ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "JetCalibArea", "00-04-81") );
2085 ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "EgammaESModel", m_isRun3 ? "es2024_Run3_v0" : "es2023_R22_Run2_v1") );
2086 ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "EgammaDecorrelationModel", "1NP_v1") );
2087 ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "EgammaUseFastsim", isAtlfast()) );
2088 // setup a dedicated new muon calib tool for passing down to METSignificance
2089 ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "MuonCalibTool", "CP::MuonCalibTool/calibTool"));
2090 if (m_isRun3)
2091 ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.IsRun3Geo", true));
2092 ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.calibMode", m_muCalibrationMode));
2093 ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.OutputLevel",this->msg().level()));
2094 ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.release", "Recs2025_12_11_Run2Run3"));
2095 int IdBaselineInt = m_muIdBaseline;
2096 if (IdBaselineInt == 4)
2097 ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.do2StationsHighPt", true));
2098 ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.doExtraSmearing", m_muHighPtExtraSmear));
2099 ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "OutputLevel", this->msg().level()));
2100#else // AnalysisBase; can just pass the jet/egamma/muon calib tools configured above
2101 ATH_CHECK( m_metSignif.setProperty("SoftTermParam", m_softTermParam) );
2102 ATH_CHECK( m_metSignif.setProperty("TreatPUJets", m_treatPUJets) );
2103 ATH_CHECK( m_metSignif.setProperty("DoPhiReso", m_doPhiReso) );
2104 if(jetname != "AntiKt4EMPFlow")
2105 ATH_MSG_WARNING("METSignificance recommendations only exist for AntiKt4EMPFlow jets, falling back to this.");
2106 ATH_CHECK( m_metSignif.setProperty( "JetCollection", "AntiKt4EMPFlow"));
2107 // This is the only recommended set of jet resolutions for use with R22+ MET Significance until "Consolidated" recommendations are available
2108 ATH_CHECK( m_metSignif.setProperty( "JetCalibConfig", "JES_data2017_2016_2015_Recommendation_PFlow_Aug2018_rel21.config") );
2109 ATH_CHECK( m_metSignif.setProperty( "JetCalibSequence", "JetArea_Residual_EtaJES_GSC_Smear") );
2110 ATH_CHECK( m_metSignif.setProperty( "JetCalibArea", "00-04-81") );
2111 ATH_CHECK( m_metSignif.setProperty("egammaCalibTool", m_egammaCalibTool.getHandle()) );
2112 // just pass the muon calib tool
2113 ATH_CHECK( m_metSignif.setProperty("MuonCalibTool",m_muonCalibTool.getHandle()));
2114 ATH_CHECK( m_metSignif.setProperty("OutputLevel", this->msg().level()) );
2115#endif
2116 ATH_CHECK( m_metSignif.retrieve() );
2117 } else ATH_CHECK( m_metSignif.retrieve() );
2118 }
2119
2120
2122// Initialise trigger tools
2123
2124 if (!m_trigDecTool.isUserConfigured()) {
2125
2126 // The decision tool
2127 m_trigDecTool.setTypeAndName("Trig::TrigDecisionTool/TrigDecisionTool");
2128 ATH_CHECK( m_trigDecTool.setProperty("TrigDecisionKey", "xTrigDecision") );
2129 if (m_isRun3) {
2130 ATH_CHECK( m_trigDecTool.setProperty("NavigationFormat", "TrigComposite") );
2131 ATH_CHECK( m_trigDecTool.setProperty("HLTSummary", "HLTNav_Summary_DAODSlimmed") );
2132 }
2133 ATH_CHECK( m_trigDecTool.setProperty("OutputLevel", this->msg().level()) );
2134
2135#ifndef XAOD_STANDALONE // Athena and AthAnalysis
2136 // Clear the default tool handle to cause a fallback on the config service
2137 ATH_CHECK( m_trigDecTool.setProperty("ConfigTool", ""));
2138#else // AnalysisBase
2139 m_trigConfTool.setTypeAndName("TrigConf::xAODConfigTool/xAODConfigTool");
2140 ATH_CHECK(m_trigConfTool.retrieve() );
2141 ATH_CHECK( m_trigDecTool.setProperty("ConfigTool", m_trigConfTool.getHandle()) );
2142#endif
2143
2144 ATH_CHECK( m_trigDecTool.retrieve() );
2145
2146 } else ATH_CHECK( m_trigDecTool.retrieve() );
2147
2148 if (m_isRun3) {
2149 if (!m_trigDRScoringTool.isUserConfigured()) {
2150 m_trigDRScoringTool.setTypeAndName("Trig::DRScoringTool/TrigDRScoringTool");
2151 ATH_CHECK( m_trigDRScoringTool.setProperty("OutputLevel", this->msg().level()) );
2152 ATH_CHECK( m_trigDRScoringTool.retrieve() );
2153 } else ATH_CHECK( m_trigDRScoringTool.retrieve() );
2154 }
2155
2156 if (!m_trigMatchingTool.isUserConfigured()) {
2157 if (m_upstreamTriggerMatching){
2158 m_trigMatchingTool.setTypeAndName("Trig::MatchFromCompositeTool/TrigMatchFromCompositeTool");
2159 ATH_CHECK( m_trigMatchingTool.setProperty("InputPrefix", m_trigMatchingPrefix) );
2160 ATH_CHECK( m_trigMatchingTool.setProperty("RemapBrokenLinks", true) );
2161 }
2162 else {
2163 if (m_isRun3){
2164 m_trigMatchingTool.setTypeAndName("Trig::R3MatchingTool/TrigR3MatchingTool");
2165 ATH_CHECK( m_trigMatchingTool.setProperty("ScoringTool", m_trigDRScoringTool.getHandle()) );
2166 ATH_CHECK( m_trigMatchingTool.setProperty("TrigDecisionTool", m_trigDecTool.getHandle()) );
2167 }
2168 else {
2169 m_trigMatchingTool.setTypeAndName("Trig::MatchingTool/TrigMatchingTool");
2170 ATH_CHECK( m_trigMatchingTool.setProperty("TrigDecisionTool", m_trigDecTool.getHandle()) );
2171 }
2172 }
2173 ATH_CHECK( m_trigMatchingTool.setProperty("OutputLevel", this->msg().level()) );
2174 ATH_CHECK( m_trigMatchingTool.retrieve() );
2175 } else ATH_CHECK( m_trigMatchingTool.retrieve() );
2176
2178// Initialise trigGlobalEfficiencyCorrection tool
2179
2180 if (!m_trigGlobalEffCorrTool_diLep.isUserConfigured() && !isData()) {
2181
2182 std::string no2e17("");
2183 if (m_trig2017combination_diLep.find("||2e17_lhvloose_nod0_L12EM15VHI") != std::string::npos) {
2184 auto pos_2e17 = m_trig2017combination_diLep.find("||2e17_lhvloose_nod0_L12EM15VHI");
2185 no2e17 = m_trig2017combination_diLep.substr(0, pos_2e17) + m_trig2017combination_diLep.substr(pos_2e17+31, m_trig2017combination_diLep.size());
2186 } else if (m_trig2017combination_diLep.find("2e17_lhvloose_nod0_L12EM15VHI||") != std::string::npos) {
2187 auto pos_2e17 = m_trig2017combination_diLep.find("2e17_lhvloose_nod0_L12EM15VHI||");
2188 no2e17 = m_trig2017combination_diLep.substr(0, pos_2e17) + m_trig2017combination_diLep.substr(pos_2e17+31, m_trig2017combination_diLep.size());
2189 } else {
2190 no2e17 = m_trig2017combination_diLep;
2191 }
2192 ATH_MSG_DEBUG( "TrigGlobalEfficiencyCorrectionTool/TrigGlobal_diLep: no2e17 trigger string: " << no2e17 );
2193
2194 std::map<std::string,std::string> triggers_diLep;
2195 triggers_diLep["2015"] = m_trig2015combination_diLep;
2196 triggers_diLep["2016"] = m_trig2016combination_diLep;
2197 triggers_diLep["324320-326695"] = m_trig2017combination_diLep; // 2017 before accidental prescale of L12EM15VHI
2198 triggers_diLep["326834-328393"] = no2e17; // 2017 during accidental prescale
2199 triggers_diLep["329385-340453"] = m_trig2017combination_diLep; // 2017 after accidental prescale
2200 triggers_diLep["2018"] = m_trig2018combination_diLep;
2201
2202 m_trigGlobalEffCorrTool_diLep.setTypeAndName("TrigGlobalEfficiencyCorrectionTool/TrigGlobal_diLep");
2203 ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("ElectronEfficiencyTools", m_elecTrigEffTools) );
2204 ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("ElectronScaleFactorTools", m_elecTrigSFTools) );
2205 ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("MuonTools", m_muonTrigSFTools) );
2206 ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("TriggerCombination", triggers_diLep) );
2207 ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("TriggerMatchingTool", m_trigMatchingTool.getHandle()) );
2208 ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("ListOfLegsPerTool", m_legsPerTool) );
2209 ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("NumberOfToys", m_trigNToys_diLep) );
2210 ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("OutputLevel", this->msg().level()) );
2211 ATH_CHECK( m_trigGlobalEffCorrTool_diLep.initialize() );
2212 } else if (m_trigGlobalEffCorrTool_diLep.isUserConfigured()) ATH_CHECK( m_trigGlobalEffCorrTool_diLep.retrieve() );
2213
2214
2215 if (!m_trigGlobalEffCorrTool_multiLep.isUserConfigured() && !isData()) {
2216
2217 std::string no2e17("");
2218 if (m_trig2017combination_multiLep.find("||2e17_lhvloose_nod0_L12EM15VHI") != std::string::npos) {
2219 auto pos_2e17 = m_trig2017combination_multiLep.find("||2e17_lhvloose_nod0_L12EM15VHI");
2220 no2e17 = m_trig2017combination_multiLep.substr(0, pos_2e17) + m_trig2017combination_multiLep.substr(pos_2e17+31, m_trig2017combination_multiLep.size());
2221 } else if (m_trig2017combination_multiLep.find("2e17_lhvloose_nod0_L12EM15VHI||") != std::string::npos) {
2222 auto pos_2e17 = m_trig2017combination_multiLep.find("2e17_lhvloose_nod0_L12EM15VHI||");
2223 no2e17 = m_trig2017combination_multiLep.substr(0, pos_2e17) + m_trig2017combination_multiLep.substr(pos_2e17+31, m_trig2017combination_multiLep.size());
2224 } else {
2225 no2e17 = m_trig2017combination_multiLep;
2226 }
2227 ATH_MSG_DEBUG( "TrigGlobalEfficiencyCorrectionTool/TrigGlobal_multiLep: no2e17 trigger string: " << no2e17 );
2228
2229 std::map<std::string,std::string> triggers_multiLep;
2230 triggers_multiLep["2015"] = m_trig2015combination_multiLep;
2231 triggers_multiLep["2016"] = m_trig2016combination_multiLep;
2232 triggers_multiLep["324320-326695"] = m_trig2017combination_multiLep; // 2017 before accidental prescale of L12EM15VHI
2233 triggers_multiLep["326834-328393"] = no2e17; // 2017 during accidental prescale
2234 triggers_multiLep["329385-340453"] = m_trig2017combination_multiLep; // 2017 after accidental prescale
2235 triggers_multiLep["2018"] = m_trig2018combination_multiLep;
2236
2237 m_trigGlobalEffCorrTool_multiLep.setTypeAndName("TrigGlobalEfficiencyCorrectionTool/TrigGlobal_multiLep");
2238 ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("ElectronEfficiencyTools", m_elecTrigEffTools) );
2239 ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("ElectronScaleFactorTools", m_elecTrigSFTools) );
2240 ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("MuonTools", m_muonTrigSFTools) );
2241 ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("TriggerCombination", triggers_multiLep) );
2242 ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("TriggerMatchingTool", m_trigMatchingTool.getHandle()) );
2243 ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("ListOfLegsPerTool", m_legsPerTool) );
2244 ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("NumberOfToys", m_trigNToys_multiLep) );
2245 ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("OutputLevel", this->msg().level()) );
2246 ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.initialize() );
2247 } else if (m_trigGlobalEffCorrTool_multiLep.isUserConfigured()) ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.retrieve() );
2248
2249
2250 if (!m_trigGlobalEffCorrTool_diPhoton.isUserConfigured() && !isData()) {
2251 m_trigGlobalEffCorrTool_diPhoton.setTypeAndName("TrigGlobalEfficiencyCorrectionTool/TrigGlobal_diPhoton");
2252 ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("PhotonEfficiencyTools", m_photonTrigEffTools) );
2253 ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("PhotonScaleFactorTools", m_photonTrigSFTools) );
2254 ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("TriggerCombination2015", m_trig2015combination_diPhoton) );
2255 ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("TriggerCombination2016", m_trig2016combination_diPhoton) );
2256 ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("TriggerCombination2017", m_trig2017combination_diPhoton) );
2257 ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("TriggerCombination2018", m_trig2018combination_diPhoton) );
2258 ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("ListOfLegsPerTool", m_legsPerTool_ph) );
2259 ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("NumberOfToys", m_trigNToys_diPhoton) );
2260 ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("OutputLevel", this->msg().level()) );
2261 ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.initialize() );
2262 } else if (m_trigGlobalEffCorrTool_diPhoton.isUserConfigured()) ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.retrieve() );
2263
2264
2265 if (m_slices["ele"] || m_slices["pho"] || m_slices["mu"]) {
2266 // /////////////////////////////////////////////////////////////////////////////////////////
2267 // Initialise Isolation Correction Tool
2268
2269 if ( !m_isoCorrTool.isUserConfigured() ) {
2270 m_isoCorrTool.setTypeAndName("CP::IsolationCorrectionTool/IsoCorrTool");
2271 ATH_CHECK( m_isoCorrTool.setProperty( "ToolVer", "REL22") );
2272 ATH_CHECK( m_isoCorrTool.setProperty( "IsMC", !isData()) );
2273 ATH_CHECK( m_isoCorrTool.setProperty( "AFII_corr", isAtlfast()) );
2274 ATH_CHECK( m_isoCorrTool.setProperty( "Apply_SC_leakcorr", false) );
2275 ATH_CHECK( m_isoCorrTool.setProperty( "FixTimingIssueInCore", true) ); // Similar to https://gitlab.cern.ch/atlas/athena/-/merge_requests/83939
2276 ATH_CHECK( m_isoCorrTool.setProperty( "CorrFile", "IsolationCorrections/v6/isolation_ptcorrections_rel22_mc20.root") );
2277 ATH_CHECK( m_isoCorrTool.setProperty( "OutputLevel", this->msg().level()) );
2278 ATH_CHECK( m_isoCorrTool.retrieve() );
2279 } else ATH_CHECK( m_isoCorrTool.retrieve() );
2280
2281
2282 // /////////////////////////////////////////////////////////////////////////////////////////
2283 // Initialise Isolation Tool
2284 if (!m_isoTool.isUserConfigured()) {
2285 m_isoTool.setTypeAndName("CP::IsolationSelectionTool/IsoTool");
2286 ATH_CHECK( m_isoTool.setProperty("ElectronWP", m_eleIso_WP.empty() ? "Loose_VarRad" : m_eleIso_WP) );
2287 ATH_CHECK( m_isoTool.setProperty("MuonWP", m_muIso_WP.empty() ? "Loose_VarRad" : m_muIso_WP) );
2288 ATH_CHECK( m_isoTool.setProperty("PhotonWP", m_photonIso_WP.empty() ? "FixedCutTight" : m_photonIso_WP ) );
2289 ATH_CHECK( m_isoTool.setProperty("OutputLevel", this->msg().level()) );
2290 ATH_CHECK( m_isoTool.retrieve() );
2291 } else ATH_CHECK( m_isoTool.retrieve() );
2292
2293 //disable if (!m_isoToolLowPtPLV.isUserConfigured()) {
2294 //disable m_isoToolLowPtPLV.setTypeAndName("CP::IsolationLowPtPLVTool/IsoToolLowPtPLV");
2295 //disable ATH_CHECK( m_isoToolLowPtPLV.setProperty("OutputLevel", this->msg().level()) );
2296 //disable ATH_CHECK( m_isoToolLowPtPLV.retrieve() );
2297 //disable } else ATH_CHECK( m_isoToolLowPtPLV.retrieve() );
2298
2299
2300 if (!m_isoBaselineTool.isUserConfigured()) {
2301 m_isoBaselineTool.setTypeAndName("CP::IsolationSelectionTool/IsoBaselineTool");
2302 ATH_CHECK( m_isoBaselineTool.setProperty("ElectronWP", m_eleBaselineIso_WP.empty() ? "Loose_VarRad" : m_eleBaselineIso_WP ) );
2303 ATH_CHECK( m_isoBaselineTool.setProperty("MuonWP", m_muBaselineIso_WP.empty() ? "Loose_VarRad" : m_muBaselineIso_WP ) );
2304 ATH_CHECK( m_isoBaselineTool.setProperty("PhotonWP", m_photonBaselineIso_WP.empty() ? "FixedCutTight" : m_photonBaselineIso_WP ) );
2305 ATH_CHECK( m_isoBaselineTool.setProperty("OutputLevel", this->msg().level()) );
2306 ATH_CHECK( m_isoBaselineTool.retrieve() );
2307 } else ATH_CHECK( m_isoBaselineTool.retrieve() );
2308
2309
2310 if (!m_isoHighPtTool.isUserConfigured()) {
2311 m_isoHighPtTool.setTypeAndName("CP::IsolationSelectionTool/IsoHighPtTool");
2312 ATH_CHECK( m_isoHighPtTool.setProperty("ElectronWP", m_eleIsoHighPt_WP.empty() ? "Loose_VarRad" : m_eleIsoHighPt_WP) );
2313 ATH_CHECK( m_isoHighPtTool.setProperty("MuonWP", m_muIsoHighPt_WP.empty() ? "Loose_VarRad" : m_muIsoHighPt_WP ) );
2314 ATH_CHECK( m_isoHighPtTool.setProperty("PhotonWP", m_photonIso_WP.empty() ? "FixedCutTight" : m_photonIso_WP ) );
2315 ATH_CHECK( m_isoHighPtTool.setProperty("OutputLevel", this->msg().level()) );
2316 ATH_CHECK( m_isoHighPtTool.retrieve() );
2317 } else ATH_CHECK( m_isoHighPtTool.retrieve() );
2318
2319
2320 // /////////////////////////////////////////////////////////////////////////////////////////
2321 // Initialise IsolationCloseByCorrectionTool Tool
2322 if (!m_isoCloseByTool.isUserConfigured()) {
2323 m_isoCloseByTool.setTypeAndName("CP::IsolationCloseByCorrectionTool/IsoCloseByTool");
2324 // Actually we could debate about what is the proper tool to choose if the users have different baseline & signal islation WP's
2325 ATH_CHECK( m_isoCloseByTool.setProperty("IsolationSelectionTool", m_useSigLepForIsoCloseByOR ? m_isoTool : m_isoBaselineTool));
2326 ATH_CHECK( m_isoCloseByTool.setProperty("PassoverlapDecorator", m_IsoCloseByORpassLabel) );
2327 ATH_CHECK( m_isoCloseByTool.setProperty("SelectionDecorator", m_useSigLepForIsoCloseByOR ? "signal" : "baseline") );
2328 // Make this propery configurable as well?
2329 ATH_CHECK( m_isoCloseByTool.setProperty("BackupPrefix", "ORIG") );
2330 // The isolation selection decorator is updated as well by the tool
2331 ATH_CHECK( m_isoCloseByTool.setProperty("IsolationSelectionDecorator", "isol") );
2332
2333 ATH_CHECK( m_isoCloseByTool.setProperty("OutputLevel", this->msg().level()) );
2334#ifndef XAOD_ANALYSIS
2335 ATH_CHECK( m_isoCloseByTool.setProperty("ParticleCaloExtensionTool", "") );
2336#endif
2337 ATH_CHECK( m_isoCloseByTool.retrieve() );
2338 } else ATH_CHECK( m_isoCloseByTool.retrieve() );
2339 }
2340
2341
2342// /////////////////////////////////////////////////////////////////////////////////////////
2343// Initialise Overlap Removal Tool
2344 if ( m_orToolbox.masterTool.empty() ){
2345
2346 // set up the master tool
2347 std::string suffix = "";
2348 if (m_orDoTau) suffix += "Tau";
2349 if (m_orDoPhoton) suffix += "Gamma";
2350 if (m_orDoBjet) suffix += "Bjet";
2351 std::string toolName = "ORTool" + suffix;
2352 ATH_MSG_INFO("SUSYTools: Autoconfiguring " << toolName);
2353
2354 std::string bJetLabel = "";
2355 //overwrite lepton flags if the global is false (yes?)
2356 if (!m_orDoBjet || !m_useBtagging) {
2357 m_orDoElBjet = false;
2358 m_orDoMuBjet = false;
2359 m_orDoTauBjet = false;
2360 }
2361 if (m_orDoElBjet || m_orDoMuBjet || m_orDoTauBjet) {
2362 bJetLabel = "bjet_loose";
2363 }
2364
2365 // Set the generic flags
2366 ORUtils::ORFlags orFlags(toolName, m_orInputLabel, "passOR");
2367 orFlags.bJetLabel = bJetLabel;
2368 orFlags.boostedLeptons = (m_orDoBoostedElectron || m_orDoBoostedMuon);
2369 orFlags.outputPassValue = true;
2370 orFlags.linkOverlapObjects = m_orLinkOverlapObjects;
2371 if (m_orDoElEl) {
2372 orFlags.doEleEleOR = true;
2373 } else orFlags.doEleEleOR = false;
2374 orFlags.doElectrons = true;
2375 orFlags.doMuons = true;
2376 orFlags.doJets = true;
2377 orFlags.doTaus = m_orDoTau;
2378 orFlags.doPhotons = m_orDoPhoton;
2379 orFlags.doFatJets = m_orDoFatjets;
2380
2381 //set up all recommended tools
2382 ATH_CHECK( ORUtils::recommendedTools(orFlags, m_orToolbox));
2383
2384 // We don't currently have a good way to determine here which object
2385 // definitions are disabled, so we currently just configure all overlap
2386 // tools and disable the pointer safety checks
2387 ATH_CHECK( m_orToolbox.setGlobalProperty("OutputLevel", this->msg().level()) );
2388 ATH_CHECK( m_orToolbox.masterTool.setProperty("RequireExpectedPointers", false) );
2389
2390 // Override boosted OR sliding cone options
2391 ATH_CHECK( m_orToolbox.eleJetORT.setProperty("UseSlidingDR", m_orDoBoostedElectron) );
2392 ATH_CHECK( m_orToolbox.muJetORT.setProperty("UseSlidingDR", m_orDoBoostedMuon) );
2393
2394 //add custom tau-jet OR tool
2395 if(m_orDoTau){
2396 m_orToolbox.tauJetORT.setTypeAndName("ORUtils::TauJetOverlapTool/" + orFlags.masterName + ".TauJetORT");
2397 ATH_CHECK( m_orToolbox.tauJetORT.setProperty("BJetLabel", m_orDoTauBjet?bJetLabel:"") );
2398 }
2399
2400 // override sliding cone params if sliding dR is on and the user-provided parameter values are non-negative
2401 if (m_orDoBoostedElectron) {
2402 if (m_orBoostedElectronC1 > 0) ATH_CHECK( m_orToolbox.eleJetORT.setProperty("SlidingDRC1", m_orBoostedElectronC1) );
2403 if (m_orBoostedElectronC2 > 0) ATH_CHECK( m_orToolbox.eleJetORT.setProperty("SlidingDRC2", m_orBoostedElectronC2) );
2404 if (m_orBoostedElectronMaxConeSize > 0) ATH_CHECK( m_orToolbox.eleJetORT.setProperty("SlidingDRMaxCone", m_orBoostedElectronMaxConeSize) );
2405 }
2406 if (m_orDoBoostedMuon) {
2407 if (m_orBoostedMuonC1 > 0) ATH_CHECK( m_orToolbox.muJetORT.setProperty("SlidingDRC1", m_orBoostedMuonC1) );
2408 if (m_orBoostedMuonC2 > 0) ATH_CHECK( m_orToolbox.muJetORT.setProperty("SlidingDRC2", m_orBoostedMuonC2) );
2409 if (m_orBoostedMuonMaxConeSize > 0) ATH_CHECK( m_orToolbox.muJetORT.setProperty("SlidingDRMaxCone", m_orBoostedMuonMaxConeSize) );
2410 }
2411
2412 // and switch off lep-bjet check if not requested
2413 if (!m_orDoElBjet) {
2414 ATH_CHECK(m_orToolbox.eleJetORT.setProperty("BJetLabel", ""));
2415 }
2416 if (!m_orDoMuBjet) {
2417 ATH_CHECK(m_orToolbox.muJetORT.setProperty("BJetLabel", ""));
2418 }
2419
2420 // propagate the mu-jet ghost-association option which might be set by the user (default is true)
2421 ATH_CHECK(m_orToolbox.muJetORT.setProperty("UseGhostAssociation", m_orDoMuonJetGhostAssociation));
2422
2423 // propagate mu-jet OR settings if requested
2424 ATH_CHECK(m_orToolbox.muJetORT.setProperty("ApplyRelPt", m_orApplyRelPt) );
2425 if(m_orApplyRelPt){
2426 if (m_orMuJetPtRatio > 0) ATH_CHECK(m_orToolbox.muJetORT.setProperty("MuJetPtRatio", m_orMuJetPtRatio) );
2427 if (m_orMuJetTrkPtRatio > 0) ATH_CHECK(m_orToolbox.muJetORT.setProperty("MuJetTrkPtRatio", m_orMuJetTrkPtRatio) );
2428 }
2429 if (m_orMuJetInnerDR > 0) ATH_CHECK(m_orToolbox.muJetORT.setProperty("InnerDR", m_orMuJetInnerDR) );
2430
2431 // propagate the calo muon setting for EleMuORT
2432 ATH_CHECK(m_orToolbox.eleMuORT.setProperty("RemoveCaloMuons", m_orRemoveCaloMuons) );
2433
2434 // Use electron-muon DR matching to remove electrons within DR < 0.01 of Muons.
2435 if (m_orDoElMu){
2436 ATH_CHECK(m_orToolbox.eleMuORT.setProperty("UseDRMatching", m_orDoElMu) );
2437 }
2438
2439 // propagate the fatjets OR settings
2440 if(m_orDoFatjets){
2441 if(m_EleFatJetDR>0) ATH_CHECK(m_orToolbox.eleFatJetORT.setProperty("DR", m_EleFatJetDR));
2442 if(m_JetFatJetDR>0) ATH_CHECK(m_orToolbox.jetFatJetORT.setProperty("DR", m_JetFatJetDR));
2443 }
2444
2445 // Make sure that we deal with prorities correctly
2446 ATH_CHECK(m_orToolbox.eleJetORT.setProperty("EnableUserPriority", true));
2447 ATH_CHECK(m_orToolbox.muJetORT.setProperty("EnableUserPriority", true));
2448 if (m_orDoTau) ATH_CHECK(m_orToolbox.tauJetORT.setProperty("EnableUserPriority", true));
2449 if (m_orDoPhoton) ATH_CHECK(m_orToolbox.phoJetORT.setProperty("EnableUserPriority", true));
2450
2451 if ( m_orPhotonFavoured ) {
2452 ATH_CHECK(m_orToolbox.phoEleORT.setProperty("SwapContainerPrecedence", true));
2453 ATH_CHECK(m_orToolbox.phoMuORT.setProperty("SwapContainerPrecedence", true));
2454 }
2455
2456 if (!m_orDoEleJet){
2457 // Disable the electron removal part of e-j overlap removal
2458 ATH_CHECK( m_orToolbox.eleJetORT.setProperty("OuterDR",-1.) );
2459 ATH_CHECK( m_orToolbox.eleJetORT.setProperty("SlidingDRMaxCone",-1.) );
2460 }
2461 if (!m_orDoMuonJet){
2462 // Disable the muon removal part of m-j overlap removal
2463 ATH_CHECK( m_orToolbox.muJetORT.setProperty("OuterDR",-1.) );
2464 ATH_CHECK( m_orToolbox.muJetORT.setProperty("SlidingDRMaxCone",-1.) );
2465 }
2466
2467 ATH_CHECK( m_orToolbox.initialize() );
2468
2469 }
2470 // Done with the OR toolbox setup!
2471
2472// /////////////////////////////////////////////////////////////////////////////////////////
2473// Initialise PMG Tools
2474 if (!m_pmgSHnjetWeighter.isUserConfigured() && !isData()) {
2475 m_pmgSHnjetWeighter.setTypeAndName("PMGTools::PMGSherpa22VJetsWeightTool/PMGSHVjetReweighter");
2476 ATH_CHECK( m_pmgSHnjetWeighter.setProperty( "TruthJetContainer", "AntiKt4TruthJets"));
2477 ATH_CHECK( m_pmgSHnjetWeighter.setProperty("OutputLevel", this->msg().level()) );
2478 ATH_CHECK( m_pmgSHnjetWeighter.retrieve());
2479 } else if (m_pmgSHnjetWeighter.isUserConfigured()) ATH_CHECK( m_pmgSHnjetWeighter.retrieve());
2480
2481
2482 if (!m_pmgSHnjetWeighterWZ.isUserConfigured() && !isData()) {
2483 m_pmgSHnjetWeighterWZ.setTypeAndName("PMGTools::PMGSherpa22VJetsWeightTool/PMGSHVjetReweighterWZ");
2484 ATH_CHECK( m_pmgSHnjetWeighterWZ.setProperty( "TruthJetContainer", "AntiKt4TruthWZJets"));
2485 ATH_CHECK( m_pmgSHnjetWeighterWZ.setProperty("OutputLevel", this->msg().level()) );
2486 ATH_CHECK( m_pmgSHnjetWeighterWZ.retrieve() );
2487 } else if (m_pmgSHnjetWeighterWZ.isUserConfigured()) ATH_CHECK( m_pmgSHnjetWeighterWZ.retrieve() );
2488
2489
2490 // prevent these initialiation snippets from being run again
2491 m_subtool_init = true;
2492
2493 ATH_MSG_INFO("Done initialising SUSYTools");
2494
2495 return StatusCode::SUCCESS;
2496}
ANA_MSG_DEBUG
#define ANA_MSG_DEBUG(xmsg,...)
Macro printing debug messages.
Definition Control/AthToolSupport/AsgMessaging/AsgMessaging/MessageCheck.h:289
bJetLabel
const std::string bJetLabel
Definition OverlapRemovalTester.cxx:70
CONFIG_EG_EFF_TOOL
#define CONFIG_EG_EFF_TOOL(TOOLHANDLE, TOOLNAME, CORRFILE)
Definition SUSYToolsInit.cxx:87
CONFIG_EG_EFF_TOOL_KEY
#define CONFIG_EG_EFF_TOOL_KEY(TOOLHANDLE, TOOLNAME, KEYNAME, KEY, MAP)
Definition SUSYToolsInit.cxx:99
if
if(pathvar)
Definition SealSharedLib.cxx:168
AAH::setProperty
static StatusCode setProperty(const GaudiHandleBase &toolHandle, const std::string &property, const int &value, bool override=true)
Definition AthAnalysisHelper.h:401
ST::SUSYObjDef_xAOD::m_tauConfigReader
TEnv m_tauConfigReader
Definition SUSYObjDef_xAOD.h:754
ST::SUSYObjDef_xAOD::m_fatJetUncertaintiesMCType
std::string m_fatJetUncertaintiesMCType
Definition SUSYObjDef_xAOD.h:535
ST::SUSYObjDef_xAOD::m_TopconfigReader
TEnv m_TopconfigReader
Definition SUSYObjDef_xAOD.h:552
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_trig_mixLep
std::vector< asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > > m_elecEfficiencySFTool_trig_mixLep
Definition SUSYObjDef_xAOD.h:906
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_trigEff_mixLep
std::vector< asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > > m_elecEfficiencySFTool_trigEff_mixLep
Definition SUSYObjDef_xAOD.h:907
ST::SUSYObjDef_xAOD::m_eleEffMapFilePathTriggerRun2
std::string m_eleEffMapFilePathTriggerRun2
Definition SUSYObjDef_xAOD.h:714
ST::SUSYObjDef_xAOD::m_legsPerTool_ph
std::map< std::string, std::string > m_legsPerTool_ph
Definition SUSYObjDef_xAOD.h:843
ST::SUSYObjDef_xAOD::m_photonEfficiencySFTool_trigSF_AsymDiphoton
std::vector< asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > > m_photonEfficiencySFTool_trigSF_AsymDiphoton
Definition SUSYObjDef_xAOD.h:924
ST::SUSYObjDef_xAOD::EG_WP
std::string EG_WP(const std::string &wp) const
Definition SUSYObjDef_xAOD.cxx:1253
ST::SUSYObjDef_xAOD::m_WconfigReader
TEnv m_WconfigReader
Definition SUSYObjDef_xAOD.h:550
ST::SUSYObjDef_xAOD::m_ZconfigReader
TEnv m_ZconfigReader
Definition SUSYObjDef_xAOD.h:551
ST::SUSYObjDef_xAOD::check_isOption
bool check_isOption(const std::string &wp, const std::vector< std::string > &list) const
Definition SUSYObjDef_xAOD.cxx:1241
ST::SUSYObjDef_xAOD::getElSFkeys
std::vector< std::string > getElSFkeys(const std::string &mapFile) const
Definition SUSYObjDef_xAOD.cxx:1265
ST::SUSYObjDef_xAOD::m_legsPerTool
std::map< std::string, std::string > m_legsPerTool
Definition SUSYObjDef_xAOD.h:842
ST::SUSYObjDef_xAOD::m_photonEfficiencySFTool_trigEff_AsymDiphoton
std::vector< asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > > m_photonEfficiencySFTool_trigEff_AsymDiphoton
Definition SUSYObjDef_xAOD.h:925
ST::SUSYObjDef_xAOD::m_eleEffMapFilePathTriggerRun3
std::string m_eleEffMapFilePathTriggerRun3
Definition SUSYObjDef_xAOD.h:715
xAOD::int
setRawEt setRawPhi int
Definition TrigCaloCluster_v1.cxx:33

◆ 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 115 of file AsgMetadataTool.cxx.

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

◆ 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 3193 of file SUSYObjDef_xAOD.cxx.

3193 {
3194 // Use the run number we are passed if we are passed one, otherwise
3195 // use the run number from the GetRunNumber function
3196 int theRunNumber = runNumber>0?runNumber:GetRunNumber();
3197 if (theRunNumber<290000) return 2015;
3198 else if (theRunNumber<320000) return 2016;
3199 else if (theRunNumber<342000) return 2017;
3200 else if (theRunNumber<400000) return 2018;
3201 else if (theRunNumber<445000) return 2022;
3202 else if (theRunNumber<465000) return 2023;
3203 else if (theRunNumber<490000) return 2024;
3204 else if (theRunNumber<510000) return 2025;
3205 return 2026;
3206}

◆ 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 261 of file Trigger.cxx.

261 {
262 for(const auto& p : v) {
263 this->TrigMatch(p, items);
264 }
265}

◆ 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 299 of file Trigger.cxx.

299 {
300 return this->TrigMatch(v, {item});
301}

◆ 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 268 of file Trigger.cxx.

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

◆ 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 244 of file Trigger.cxx.

244 {
245 this->TrigMatch(p, items.begin(), items.end());
246}

◆ TrigMatch() [5/10]

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 289 of file Trigger.cxx.

289 {
290 return this->TrigMatch(p, {item});
291}

◆ 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 249 of file Trigger.cxx.

249 {
250 dec_trigmatched(*p) = 0;
251
252 for(const auto& item: items) {
253 auto result = static_cast<int>(this->IsTrigMatched(p, item));
254 dec_trigmatched(*p) += result;
255 const SG::Decorator<char> dec(item);
256 dec(*p) = result;
257 }
258}
ST::dec_trigmatched
static const SG::Decorator< char > dec_trigmatched("trigmatched")

◆ 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 232 of file Trigger.cxx.

232 {
233 dec_trigmatched(*p) = 0;
234
235 for(const auto *it = i1; it != i2; ++it) {
236 auto result = static_cast<int>(this->IsTrigMatched(p, *it));
237 dec_trigmatched(*p) += result;
238 const SG::Decorator<char> dec(*it);
239 dec(*p) = result;
240 }
241}

◆ 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 282 of file Trigger.cxx.

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

◆ TrigMatch() [9/10]

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 294 of file Trigger.cxx.

294 {
295 return this->TrigMatch(v, {item});
296}

◆ 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 275 of file Trigger.cxx.

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

◆ TrigSingleLep()

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

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2171 of file SUSYObjDef_xAOD.cxx.

2171{ return m_electronTriggerSFStringSingle; }

◆ updateVHKA()

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

Definition at line 298 of file AthCommonDataStore.h.

298 {
299 for (auto &a : m_vhka) {
300 std::vector<SG::VarHandleKey*> keys = a->keys();
301 for (auto k : keys) {
302 k->setOwner(this);
303 }
304 }
305 }
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition AthCommonDataStore.h:386

◆ 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 2034 of file SUSYObjDef_xAOD.cxx.

2034 {
2035 // Validate configuration (i.e. that signal settings are tighter than baseline, etc)
2036 // :: Throw SC::FAILURE if strict mode is enabled, just a WARNING if not
2037
2038 // Electrons
2039 if( m_elePt < m_eleBaselinePt ){
2040 ATH_MSG_WARNING("Your electron pt configuration is inconsistent! Signal : " << m_elePt << " < Baseline : " << m_eleBaselinePt);
2041 if(strict) return StatusCode::FAILURE;
2042 }
2043 if( m_eleEta > m_eleBaselineEta ){
2044 ATH_MSG_WARNING("Your electron eta configuration is inconsistent! Signal : " << m_eleEta << " < Baseline : " << m_eleBaselineEta);
2045 if(strict) return StatusCode::FAILURE;
2046 }
2047
2048 if( check_isTighter(m_eleIdBaseline, m_eleId, m_el_id_support) ){
2049 ATH_MSG_WARNING("Your electron ID configuration is inconsistent! Signal : " << m_eleId << " looser than Baseline : " << m_eleIdBaseline);
2050 if(strict) return StatusCode::FAILURE;
2051 }
2052 if( !m_eleCrackVeto && m_eleBaselineCrackVeto){
2053 ATH_MSG_WARNING("Your electron crack removal is inconsistent! Signal : " << m_eleCrackVeto << " while Baseline : " << m_eleBaselineCrackVeto);
2054 if(strict) return StatusCode::FAILURE;
2055 }
2056
2057 // Muons
2058 if( m_muPt < m_muBaselinePt ){
2059 ATH_MSG_WARNING("Your muon pt configuration is inconsistent! Signal : " << m_muPt << " < Baseline : " << m_muBaselinePt);
2060 if(strict) return StatusCode::FAILURE;
2061 }
2062 if( m_muEta > m_muBaselineEta ){
2063 ATH_MSG_WARNING("Your muon eta configuration is inconsistent! Signal : " << m_muEta << " < Baseline : " << m_muBaselineEta);
2064 if(strict) return StatusCode::FAILURE;
2065 }
2066 if( m_muId > m_muIdBaseline ){
2067 ATH_MSG_WARNING("Your muon ID configuration is inconsistent! Signal : " << m_muId << " < Baseline : " << m_muIdBaseline);
2068 if(strict) return StatusCode::FAILURE;
2069 }
2070
2071 // Photons
2072 if( m_photonPt < m_photonBaselinePt ){
2073 ATH_MSG_WARNING("Your photon pt configuration is inconsistent! Signal : " << m_photonPt << " < Baseline : " << m_photonBaselinePt);
2074 if(strict) return StatusCode::FAILURE;
2075 }
2076 if( m_photonEta > m_photonBaselineEta ){
2077 ATH_MSG_WARNING("Your photon eta configuration is inconsistent! Signal : " << m_photonEta << " < Baseline : " << m_photonBaselineEta);
2078 if(strict) return StatusCode::FAILURE;
2079 }
2080 if( m_photonId=="Loose" && m_photonIdBaseline=="Tight" ){
2081 ATH_MSG_WARNING("Your photon ID configuration is inconsistent! Signal : " << m_photonId << " < Baseline : " << m_photonIdBaseline);
2082 if(strict) return StatusCode::FAILURE;
2083 }
2084 if( !m_photonCrackVeto && m_photonBaselineCrackVeto){
2085 ATH_MSG_WARNING("Your photon crack removal is inconsistent! Signal : " << m_photonCrackVeto << " while Baseline : " << m_photonBaselineCrackVeto);
2086 if(strict) return StatusCode::FAILURE;
2087 }
2088
2089 // Jets
2090 if ( m_jetPt < 20e3 ){
2091 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!");
2092 }
2093
2094 //Btagging //OR-wp looser than signal-wp?
2095 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)
2096 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()) ){
2097 ATH_MSG_WARNING("Your btagging configuration is inconsistent! Signal : " << m_BtagWP << " is looser than OR-Baseline : " << m_orBtagWP);
2098 }
2099 }
2100 if (m_BtagMinPt < 20e3 || m_BtagMinPt_trkJet < 10e3) {
2101 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).");
2102 }
2103
2104 //Taus
2106 if(m_tauPrePtCut > 0 and m_tauPrePtCut > m_tauPt) {
2107 ATH_MSG_WARNING("Your tau pt configuration is inconsistent! Signal pt cut : " << m_tauPt << " < Baseline (pre) pt cut : " << m_tauPrePtCut);
2108 if(strict) return StatusCode::FAILURE;
2109 }
2111 if( check_isTighter(m_tauIdBaseline, m_tauId, m_tau_id_support) ){
2112 ATH_MSG_WARNING("Your tau ID configuration is inconsistent! Signal : " << m_tauId << " looser than Baseline : " << m_tauIdBaseline);
2113 if(strict) return StatusCode::FAILURE;
2114 }
2115
2117 std::vector<float> pT_window;
2118 std::vector<float> eta_window;
2119 bool elOLR=false;
2120 bool muVeto=false;
2121 bool muOLR=false;
2122
2123 if(!m_tauConfigPathBaseline.empty()) { //baseline taus
2124
2125 //read config
2126 ANA_CHECK(getTauConfig(m_tauInputFileBaseline, pT_window, eta_window, elOLR, muVeto, muOLR));
2127
2128 //pt-eta checks
2129 if( m_tauPrePtCut > 0 and (m_tauPrePtCut != 1000*pT_window[0] or (pT_window[1] > 0 and m_tauPrePtCut > 1000*pT_window[1]))) {
2130 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] << "]");
2131 if(strict) return StatusCode::FAILURE;
2132 }
2133
2134 if( m_tauPt > 0 and (m_tauPt != 1000*pT_window[0] or (pT_window[1] > 0 and m_tauPt > 1000*pT_window[1]))) {
2135 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] << "]");
2136 if(strict) return StatusCode::FAILURE;
2137 }
2138
2139 if( m_tauEta > 0 and m_tauEta != eta_window[eta_window.size()-1]) { // eta window can have 4 entries
2140 ATH_MSG_WARNING("Your baseline tau eta configuration is inconsistent! eta cut : " << m_tauEta << " != TauSelectionTool max eta : " << eta_window[eta_window.size()-1]);
2141 if(strict) return StatusCode::FAILURE;
2142 }
2143 }
2144
2145 if(!m_tauConfigPath.empty()) { //signal taus
2146
2147 ANA_CHECK(getTauConfig(m_tauInputFile, pT_window, eta_window, elOLR, muVeto, muOLR));
2148
2149 if( m_tauPrePtCut > 0 and (m_tauPrePtCut != 1000*pT_window[0] or (pT_window[1] > 0 and m_tauPrePtCut > 1000*pT_window[1]))) {
2150 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] << "]");
2151 if(strict) return StatusCode::FAILURE;
2152 }
2153
2154 if( m_tauPt > 0 and (m_tauPt != 1000*pT_window[0] or (pT_window[1] > 0 and m_tauPt > 1000*pT_window[1]))) {
2155 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] << "]");
2156 if(strict) return StatusCode::FAILURE;
2157 }
2158
2159 if( m_tauEta > 0 and m_tauEta != eta_window[eta_window.size()-1]) { // eta window can have 4 entries
2160 ATH_MSG_WARNING("Your tau eta configuration is inconsistent! eta cut : " << m_tauEta << " != TauSelectionTool max eta : " << eta_window[eta_window.size()-1]);
2161 if(strict) return StatusCode::FAILURE;
2162 }
2163 }
2164
2165
2166 return StatusCode::SUCCESS;
2167}
ANA_CHECK
#define ANA_CHECK(EXP)
check whether the given expression was successful
Definition Control/AthToolSupport/AsgMessaging/AsgMessaging/MessageCheck.h:325
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:1246
ST::SUSYObjDef_xAOD::getTauConfig
StatusCode 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:1922
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:40

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/2]

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

Definition at line 445 of file SUSYObjDef_xAOD.h.

◆ ATLAS_THREAD_SAFE [2/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.

◆ lrt_electrons

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

Definition at line 212 of file SUSYObjDef_xAOD.h.

◆ lrt_muons

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

Definition at line 206 of file SUSYObjDef_xAOD.h.

◆ m_acc_eleId

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

Definition at line 1012 of file SUSYObjDef_xAOD.h.

◆ m_acc_eleIdBaseline

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

Definition at line 1011 of file SUSYObjDef_xAOD.h.

◆ m_acc_jetClean

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

Definition at line 1015 of file SUSYObjDef_xAOD.h.

◆ m_acc_photonId

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

Definition at line 1014 of file SUSYObjDef_xAOD.h.

◆ m_acc_photonIdBaseline

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

Definition at line 1013 of file SUSYObjDef_xAOD.h.

◆ m_applyJVTCut

bool ST::SUSYObjDef_xAOD::m_applyJVTCut
protected

Definition at line 838 of file SUSYObjDef_xAOD.h.

◆ m_ApplyMVATESQualityCheck

bool ST::SUSYObjDef_xAOD::m_ApplyMVATESQualityCheck
protected

Definition at line 753 of file SUSYObjDef_xAOD.h.

◆ m_autoconfigPRW

bool ST::SUSYObjDef_xAOD::m_autoconfigPRW
protected

Definition at line 602 of file SUSYObjDef_xAOD.h.

◆ m_autoconfigPRWCombinedmode

bool ST::SUSYObjDef_xAOD::m_autoconfigPRWCombinedmode
protected

Definition at line 605 of file SUSYObjDef_xAOD.h.

◆ m_autoconfigPRWFile

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

Definition at line 604 of file SUSYObjDef_xAOD.h.

◆ m_autoconfigPRWPath

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

Definition at line 603 of file SUSYObjDef_xAOD.h.

◆ m_autoconfigPRWRPVmode

bool ST::SUSYObjDef_xAOD::m_autoconfigPRWRPVmode
protected

Definition at line 606 of file SUSYObjDef_xAOD.h.

◆ m_autoconfigPRWRtags

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

Definition at line 607 of file SUSYObjDef_xAOD.h.

◆ m_badJetCut

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

Definition at line 544 of file SUSYObjDef_xAOD.h.

◆ m_badmuQoverP

double ST::SUSYObjDef_xAOD::m_badmuQoverP
protected

Definition at line 731 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 940 of file SUSYObjDef_xAOD.h.

◆ m_btagEffTool_trkJet

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

Definition at line 943 of file SUSYObjDef_xAOD.h.

◆ m_bTaggingCalibrationFilePath

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

Definition at line 840 of file SUSYObjDef_xAOD.h.

◆ m_BtagMinPt

double ST::SUSYObjDef_xAOD::m_BtagMinPt
protected

Definition at line 691 of file SUSYObjDef_xAOD.h.

◆ m_BtagMinPt_trkJet

double ST::SUSYObjDef_xAOD::m_BtagMinPt_trkJet
protected

Definition at line 699 of file SUSYObjDef_xAOD.h.

◆ m_BtagReadFromObject

bool ST::SUSYObjDef_xAOD::m_BtagReadFromObject
protected

Definition at line 696 of file SUSYObjDef_xAOD.h.

◆ m_BtagReadFromObject_trkJet

bool ST::SUSYObjDef_xAOD::m_BtagReadFromObject_trkJet
protected

Definition at line 700 of file SUSYObjDef_xAOD.h.

◆ m_btagSelTool

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

Definition at line 941 of file SUSYObjDef_xAOD.h.

◆ m_btagSelTool_OR

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

Definition at line 942 of file SUSYObjDef_xAOD.h.

◆ m_btagSelTool_trkJet

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

Definition at line 944 of file SUSYObjDef_xAOD.h.

◆ m_BtagSystStrategy

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

Definition at line 692 of file SUSYObjDef_xAOD.h.

◆ m_BtagTagger

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

Definition at line 690 of file SUSYObjDef_xAOD.h.

◆ m_BtagTagger_trkJet

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

Definition at line 698 of file SUSYObjDef_xAOD.h.

◆ m_BtagWP

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

Definition at line 689 of file SUSYObjDef_xAOD.h.

◆ m_BtagWP_trkJet

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

Definition at line 697 of file SUSYObjDef_xAOD.h.

◆ m_caloMETsyst

bool ST::SUSYObjDef_xAOD::m_caloMETsyst
protected

Definition at line 595 of file SUSYObjDef_xAOD.h.

◆ m_commonPRWFileMC20a

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

Definition at line 612 of file SUSYObjDef_xAOD.h.

◆ m_commonPRWFileMC20d

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

Definition at line 613 of file SUSYObjDef_xAOD.h.

◆ m_commonPRWFileMC20e

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

Definition at line 614 of file SUSYObjDef_xAOD.h.

◆ m_commonPRWFileMC23a

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

Definition at line 615 of file SUSYObjDef_xAOD.h.

◆ m_commonPRWFileMC23d

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

Definition at line 616 of file SUSYObjDef_xAOD.h.

◆ m_commonPRWFileMC23e

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

Definition at line 617 of file SUSYObjDef_xAOD.h.

◆ m_commonPRWFileMC23g

std::string ST::SUSYObjDef_xAOD::m_commonPRWFileMC23g
protected

Definition at line 618 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 522 of file SUSYObjDef_xAOD.h.

◆ m_currentSyst

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

Definition at line 833 of file SUSYObjDef_xAOD.h.

◆ m_dataSource

int ST::SUSYObjDef_xAOD::m_dataSource
protected

Definition at line 519 of file SUSYObjDef_xAOD.h.

◆ m_deadHVTool

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

Definition at line 919 of file SUSYObjDef_xAOD.h.

◆ m_debug

bool ST::SUSYObjDef_xAOD::m_debug
protected

Definition at line 540 of file SUSYObjDef_xAOD.h.

◆ m_defaultJets

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

Definition at line 827 of file SUSYObjDef_xAOD.h.

◆ m_defaultSyst

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

Definition at line 832 of file SUSYObjDef_xAOD.h.

◆ m_defaultTrackJets

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

Definition at line 828 of file SUSYObjDef_xAOD.h.

◆ m_defaultTruthJets

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

Definition at line 830 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 381 of file AthCommonDataStore.h.

◆ m_doElIsoSignal

bool ST::SUSYObjDef_xAOD::m_doElIsoSignal
protected

Definition at line 812 of file SUSYObjDef_xAOD.h.

◆ m_doFwdJVT

bool ST::SUSYObjDef_xAOD::m_doFwdJVT
protected

Definition at line 767 of file SUSYObjDef_xAOD.h.

◆ m_doIsoSignal

bool ST::SUSYObjDef_xAOD::m_doIsoSignal
protected

Definition at line 811 of file SUSYObjDef_xAOD.h.

◆ m_doModifiedEleId

bool ST::SUSYObjDef_xAOD::m_doModifiedEleId
protected

Definition at line 527 of file SUSYObjDef_xAOD.h.

◆ m_doMuIsoSignal

bool ST::SUSYObjDef_xAOD::m_doMuIsoSignal
protected

Definition at line 814 of file SUSYObjDef_xAOD.h.

◆ m_doPhiReso

bool ST::SUSYObjDef_xAOD::m_doPhiReso
protected

Definition at line 600 of file SUSYObjDef_xAOD.h.

◆ m_doPhIsoSignal

bool ST::SUSYObjDef_xAOD::m_doPhIsoSignal
protected

Definition at line 813 of file SUSYObjDef_xAOD.h.

◆ m_doTTVAsf

bool ST::SUSYObjDef_xAOD::m_doTTVAsf
protected

Definition at line 526 of file SUSYObjDef_xAOD.h.

◆ m_dRTruthJet

double ST::SUSYObjDef_xAOD::m_dRTruthJet
protected

Definition at line 570 of file SUSYObjDef_xAOD.h.

◆ m_EG_corrFNList

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

Definition at line 837 of file SUSYObjDef_xAOD.h.

◆ m_EG_corrModel

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

Definition at line 836 of file SUSYObjDef_xAOD.h.

◆ m_egammaAmbiguityTool

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

Definition at line 929 of file SUSYObjDef_xAOD.h.

◆ m_egammaCalibTool

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

Combined electron collection.

Definition at line 914 of file SUSYObjDef_xAOD.h.

◆ m_EigenvectorReductionB

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

Definition at line 693 of file SUSYObjDef_xAOD.h.

◆ m_EigenvectorReductionC

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

Definition at line 694 of file SUSYObjDef_xAOD.h.

◆ m_EigenvectorReductionLight

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

Definition at line 695 of file SUSYObjDef_xAOD.h.

◆ m_el_id_support

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

Definition at line 635 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 643 of file SUSYObjDef_xAOD.h.

◆ m_el_iso_support

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

Definition at line 639 of file SUSYObjDef_xAOD.h.

◆ m_eleAllowRun3TrigSFFallback

bool ST::SUSYObjDef_xAOD::m_eleAllowRun3TrigSFFallback
protected

Definition at line 716 of file SUSYObjDef_xAOD.h.

◆ m_eleBaselineCrackVeto

bool ST::SUSYObjDef_xAOD::m_eleBaselineCrackVeto
protected

Definition at line 705 of file SUSYObjDef_xAOD.h.

◆ m_elebaselined0sig

double ST::SUSYObjDef_xAOD::m_elebaselined0sig
protected

Definition at line 711 of file SUSYObjDef_xAOD.h.

◆ m_eleBaselineEta

double ST::SUSYObjDef_xAOD::m_eleBaselineEta
protected

Definition at line 704 of file SUSYObjDef_xAOD.h.

◆ m_eleBaselineIso_WP

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

Definition at line 656 of file SUSYObjDef_xAOD.h.

◆ m_eleBaselinePt

double ST::SUSYObjDef_xAOD::m_eleBaselinePt
protected

Definition at line 703 of file SUSYObjDef_xAOD.h.

◆ m_elebaselinez0

double ST::SUSYObjDef_xAOD::m_elebaselinez0
protected

Definition at line 712 of file SUSYObjDef_xAOD.h.

◆ m_elecChargeEffCorrTool

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

Definition at line 931 of file SUSYObjDef_xAOD.h.

◆ m_elecChargeIDSelectorTool

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

Definition at line 930 of file SUSYObjDef_xAOD.h.

◆ m_elecEfficiencySFTool_chf

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

Definition at line 904 of file SUSYObjDef_xAOD.h.

◆ m_elecEfficiencySFTool_id

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

Definition at line 899 of file SUSYObjDef_xAOD.h.

◆ m_elecEfficiencySFTool_iso

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

Definition at line 902 of file SUSYObjDef_xAOD.h.

◆ m_elecEfficiencySFTool_isoHighPt

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

Definition at line 903 of file SUSYObjDef_xAOD.h.

◆ m_elecEfficiencySFTool_reco

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

Combined muon collection.

Definition at line 898 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 906 of file SUSYObjDef_xAOD.h.

◆ m_elecEfficiencySFTool_trig_singleLep

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

Definition at line 900 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 907 of file SUSYObjDef_xAOD.h.

◆ m_elecEfficiencySFTool_trigEff_singleLep

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

Definition at line 901 of file SUSYObjDef_xAOD.h.

◆ m_eleChID_signal

bool ST::SUSYObjDef_xAOD::m_eleChID_signal
protected

Definition at line 676 of file SUSYObjDef_xAOD.h.

◆ m_eleChID_WP

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

Definition at line 672 of file SUSYObjDef_xAOD.h.

◆ m_eleChIso

bool ST::SUSYObjDef_xAOD::m_eleChIso
protected

Definition at line 675 of file SUSYObjDef_xAOD.h.

◆ m_elecLRTORTool

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

Definition at line 910 of file SUSYObjDef_xAOD.h.

◆ m_eleConfig

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

Definition at line 654 of file SUSYObjDef_xAOD.h.

◆ m_eleConfigBaseline

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

Definition at line 655 of file SUSYObjDef_xAOD.h.

◆ m_eleCrackVeto

bool ST::SUSYObjDef_xAOD::m_eleCrackVeto
protected

Definition at line 708 of file SUSYObjDef_xAOD.h.

◆ m_elecSelLikelihood

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

Definition at line 915 of file SUSYObjDef_xAOD.h.

◆ m_elecSelLikelihoodBaseline

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

Definition at line 916 of file SUSYObjDef_xAOD.h.

◆ m_elecTrigEffTools

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

Definition at line 909 of file SUSYObjDef_xAOD.h.

◆ m_elecTrigSFTools

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

Definition at line 908 of file SUSYObjDef_xAOD.h.

◆ m_electronTriggerSFStringSingle

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

Definition at line 648 of file SUSYObjDef_xAOD.h.

◆ m_eled0sig

double ST::SUSYObjDef_xAOD::m_eled0sig
protected

Definition at line 709 of file SUSYObjDef_xAOD.h.

◆ m_eleEffMapFilePath

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

Definition at line 713 of file SUSYObjDef_xAOD.h.

◆ m_eleEffMapFilePathTriggerRun2

std::string ST::SUSYObjDef_xAOD::m_eleEffMapFilePathTriggerRun2
protected

Definition at line 714 of file SUSYObjDef_xAOD.h.

◆ m_eleEffMapFilePathTriggerRun3

std::string ST::SUSYObjDef_xAOD::m_eleEffMapFilePathTriggerRun3
protected

Definition at line 715 of file SUSYObjDef_xAOD.h.

◆ m_eleEta

double ST::SUSYObjDef_xAOD::m_eleEta
protected

Definition at line 707 of file SUSYObjDef_xAOD.h.

◆ m_EleFatJetDR

double ST::SUSYObjDef_xAOD::m_EleFatJetDR
protected

Definition at line 808 of file SUSYObjDef_xAOD.h.

◆ m_eleForceFullSimCalib

bool ST::SUSYObjDef_xAOD::m_eleForceFullSimCalib
protected

Definition at line 717 of file SUSYObjDef_xAOD.h.

◆ m_eleId

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

Definition at line 652 of file SUSYObjDef_xAOD.h.

◆ m_eleIdBaseline

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

Definition at line 653 of file SUSYObjDef_xAOD.h.

◆ m_eleIdBaselineDFName

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

Definition at line 1005 of file SUSYObjDef_xAOD.h.

◆ m_eleIdDFName

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

Definition at line 1006 of file SUSYObjDef_xAOD.h.

◆ m_eleIdExpert

bool ST::SUSYObjDef_xAOD::m_eleIdExpert
protected

Definition at line 657 of file SUSYObjDef_xAOD.h.

◆ m_eleIso_WP

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

Definition at line 669 of file SUSYObjDef_xAOD.h.

◆ m_eleIsoHighPt_WP

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

Definition at line 670 of file SUSYObjDef_xAOD.h.

◆ m_eleIsoHighPtThresh

double ST::SUSYObjDef_xAOD::m_eleIsoHighPtThresh
protected

Definition at line 671 of file SUSYObjDef_xAOD.h.

◆ m_eleLRT

bool ST::SUSYObjDef_xAOD::m_eleLRT
protected

Definition at line 673 of file SUSYObjDef_xAOD.h.

◆ m_eleLRT_strat

int ST::SUSYObjDef_xAOD::m_eleLRT_strat
protected

Definition at line 674 of file SUSYObjDef_xAOD.h.

◆ m_elePt

double ST::SUSYObjDef_xAOD::m_elePt
protected

Definition at line 706 of file SUSYObjDef_xAOD.h.

◆ m_eleTerm

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

Definition at line 575 of file SUSYObjDef_xAOD.h.

◆ m_elez0

double ST::SUSYObjDef_xAOD::m_elez0
protected

Definition at line 710 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 378 of file AthCommonDataStore.h.

◆ m_fatjetFFSmearingSyst

std::vector<CP::SystematicSet> ST::SUSYObjDef_xAOD::m_fatjetFFSmearingSyst
protected

Definition at line 834 of file SUSYObjDef_xAOD.h.

◆ m_fatjetFFSmearingTool

asg::AnaToolHandle<ICPJetCorrectionTool> ST::SUSYObjDef_xAOD::m_fatjetFFSmearingTool
protected

Definition at line 851 of file SUSYObjDef_xAOD.h.

◆ m_fatJets

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

Definition at line 829 of file SUSYObjDef_xAOD.h.

◆ m_fatJetUncConfig

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

Definition at line 546 of file SUSYObjDef_xAOD.h.

◆ m_fatJetUncertaintiesMCType

std::string ST::SUSYObjDef_xAOD::m_fatJetUncertaintiesMCType
protected

Definition at line 535 of file SUSYObjDef_xAOD.h.

◆ m_fatJetUncertaintiesPDsmearing

bool ST::SUSYObjDef_xAOD::m_fatJetUncertaintiesPDsmearing
protected

Definition at line 547 of file SUSYObjDef_xAOD.h.

◆ m_fatjetUncertaintiesPDSmearTool

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

Definition at line 850 of file SUSYObjDef_xAOD.h.

◆ m_fatjetUncertaintiesTool

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

Definition at line 849 of file SUSYObjDef_xAOD.h.

◆ m_fatJetUncVars

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

Definition at line 548 of file SUSYObjDef_xAOD.h.

◆ m_fatTruthJets

std::string ST::SUSYObjDef_xAOD::m_fatTruthJets
protected

Definition at line 567 of file SUSYObjDef_xAOD.h.

◆ m_fatUngroomedTruthJets

std::string ST::SUSYObjDef_xAOD::m_fatUngroomedTruthJets
protected

Definition at line 566 of file SUSYObjDef_xAOD.h.

◆ m_fJvtConfigRun2

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

Definition at line 771 of file SUSYObjDef_xAOD.h.

◆ m_fJvtConfigRun3

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

Definition at line 772 of file SUSYObjDef_xAOD.h.

◆ m_fJvtEtaMin

double ST::SUSYObjDef_xAOD::m_fJvtEtaMin
protected

Definition at line 770 of file SUSYObjDef_xAOD.h.

◆ m_fJvtPtMax

double ST::SUSYObjDef_xAOD::m_fJvtPtMax
protected

Definition at line 769 of file SUSYObjDef_xAOD.h.

◆ m_fJvtWP

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

Definition at line 768 of file SUSYObjDef_xAOD.h.

◆ m_force_noElId

bool ST::SUSYObjDef_xAOD::m_force_noElId
protected

Definition at line 524 of file SUSYObjDef_xAOD.h.

◆ m_force_noMuId

bool ST::SUSYObjDef_xAOD::m_force_noMuId
protected

Definition at line 525 of file SUSYObjDef_xAOD.h.

◆ m_gammaTerm

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

Definition at line 576 of file SUSYObjDef_xAOD.h.

◆ m_getTruthGroomedJetValues

bool ST::SUSYObjDef_xAOD::m_getTruthGroomedJetValues
protected

Definition at line 568 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 482 of file SUSYObjDef_xAOD.h.

482{this, "GSFLRTCollectionName", "LRTGSFTrackParticles", "GSF LRT collection name"};

◆ 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 582 of file SUSYObjDef_xAOD.h.

◆ m_inputMETMap

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

Definition at line 581 of file SUSYObjDef_xAOD.h.

◆ m_inputMETRef

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

Definition at line 583 of file SUSYObjDef_xAOD.h.

◆ m_inputMETSuffix

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

Definition at line 580 of file SUSYObjDef_xAOD.h.

◆ m_isoBaselineTool

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

Definition at line 991 of file SUSYObjDef_xAOD.h.

◆ m_IsoCloseByORpassLabel

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

Definition at line 817 of file SUSYObjDef_xAOD.h.

◆ m_isoCloseByTool

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

Definition at line 993 of file SUSYObjDef_xAOD.h.

◆ m_isoCorrTool

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

Definition at line 988 of file SUSYObjDef_xAOD.h.

◆ m_isoHighPtTool

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

Definition at line 992 of file SUSYObjDef_xAOD.h.

◆ m_isoTool

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

Definition at line 989 of file SUSYObjDef_xAOD.h.

◆ m_isPHYSLITE

bool ST::SUSYObjDef_xAOD::m_isPHYSLITE
protected

Definition at line 821 of file SUSYObjDef_xAOD.h.

◆ m_isRun3

bool ST::SUSYObjDef_xAOD::m_isRun3
protected

Definition at line 820 of file SUSYObjDef_xAOD.h.

◆ m_jesCalibArea

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

Definition at line 882 of file SUSYObjDef_xAOD.h.

◆ m_jesCalibSeq

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

Definition at line 879 of file SUSYObjDef_xAOD.h.

◆ m_jesCalibSeqFat

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

Definition at line 881 of file SUSYObjDef_xAOD.h.

◆ m_jesCalibSeqJMS

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

Definition at line 880 of file SUSYObjDef_xAOD.h.

◆ m_jesConfig

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

Definition at line 873 of file SUSYObjDef_xAOD.h.

◆ m_jesConfigAFII

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

Definition at line 876 of file SUSYObjDef_xAOD.h.

◆ m_jesConfigFat

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

Definition at line 877 of file SUSYObjDef_xAOD.h.

◆ m_jesConfigFatData

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

Definition at line 878 of file SUSYObjDef_xAOD.h.

◆ m_jesConfigJMS

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

Definition at line 874 of file SUSYObjDef_xAOD.h.

◆ m_jesConfigJMSData

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

Definition at line 875 of file SUSYObjDef_xAOD.h.

◆ m_jetCalibTool

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

Definition at line 845 of file SUSYObjDef_xAOD.h.

◆ m_jetCleanDFName

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

Definition at line 1009 of file SUSYObjDef_xAOD.h.

◆ m_jetCleaningTool

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

Definition at line 852 of file SUSYObjDef_xAOD.h.

◆ m_jetEta

double ST::SUSYObjDef_xAOD::m_jetEta
protected

Definition at line 757 of file SUSYObjDef_xAOD.h.

◆ m_jetFatCalibTool

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

Definition at line 846 of file SUSYObjDef_xAOD.h.

◆ m_JetFatJetDR

double ST::SUSYObjDef_xAOD::m_JetFatJetDR
protected

Definition at line 809 of file SUSYObjDef_xAOD.h.

◆ m_jetfJvtEfficiencyTool

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

Definition at line 860 of file SUSYObjDef_xAOD.h.

◆ m_jetfJvtSelectionTool

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

Definition at line 859 of file SUSYObjDef_xAOD.h.

◆ m_jetInputType

int ST::SUSYObjDef_xAOD::m_jetInputType
protected

Definition at line 520 of file SUSYObjDef_xAOD.h.

◆ m_jetJvt

double ST::SUSYObjDef_xAOD::m_jetJvt
protected

Definition at line 758 of file SUSYObjDef_xAOD.h.

◆ m_jetJvtMomentTool

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

Definition at line 855 of file SUSYObjDef_xAOD.h.

◆ m_jetNNJvtEfficiencyTool

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

Definition at line 858 of file SUSYObjDef_xAOD.h.

◆ m_jetNNJvtMomentTool

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

Definition at line 856 of file SUSYObjDef_xAOD.h.

◆ m_jetNNJvtSelectionTool

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

Definition at line 857 of file SUSYObjDef_xAOD.h.

◆ m_jetPileupLabelingTool

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

Definition at line 854 of file SUSYObjDef_xAOD.h.

◆ m_jetPt

double ST::SUSYObjDef_xAOD::m_jetPt
protected

Definition at line 756 of file SUSYObjDef_xAOD.h.

◆ m_jetTerm

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

Definition at line 578 of file SUSYObjDef_xAOD.h.

◆ m_jetTruthLabelingTool

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

Definition at line 865 of file SUSYObjDef_xAOD.h.

◆ m_JetTruthLabelName

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

Definition at line 564 of file SUSYObjDef_xAOD.h.

◆ m_jetUncertaintiesAnalysisFile

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

Definition at line 532 of file SUSYObjDef_xAOD.h.

◆ m_jetUncertaintiesCalibArea

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

Definition at line 533 of file SUSYObjDef_xAOD.h.

◆ m_jetUncertaintiesConfig

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

Prefix for trigger matchiing container name.

Definition at line 531 of file SUSYObjDef_xAOD.h.

◆ m_jetUncertaintiesMCType

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

Definition at line 534 of file SUSYObjDef_xAOD.h.

◆ m_jetUncertaintiesPDsmearing

bool ST::SUSYObjDef_xAOD::m_jetUncertaintiesPDsmearing
protected

Definition at line 536 of file SUSYObjDef_xAOD.h.

◆ m_jetUncertaintiesPDSmearTool

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

Definition at line 848 of file SUSYObjDef_xAOD.h.

◆ m_jetUncertaintiesTool

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

Definition at line 847 of file SUSYObjDef_xAOD.h.

◆ m_JMScalib

bool ST::SUSYObjDef_xAOD::m_JMScalib
protected

Definition at line 774 of file SUSYObjDef_xAOD.h.

◆ m_JvtConfigRun2

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

Definition at line 761 of file SUSYObjDef_xAOD.h.

◆ m_JvtConfigRun3

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

Definition at line 762 of file SUSYObjDef_xAOD.h.

◆ m_JvtPtMax

double ST::SUSYObjDef_xAOD::m_JvtPtMax
protected

Definition at line 760 of file SUSYObjDef_xAOD.h.

◆ m_JvtWP

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

Definition at line 759 of file SUSYObjDef_xAOD.h.

◆ m_label_truthKey

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

Definition at line 870 of file SUSYObjDef_xAOD.h.

◆ m_legsPerTool

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

Definition at line 842 of file SUSYObjDef_xAOD.h.

◆ m_legsPerTool_ph

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

Definition at line 843 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 481 of file SUSYObjDef_xAOD.h.

481{this, "LRTCollectionName", "InDetLargeD0TrackParticles", "LRT collection name"};

◆ m_LRTuncTool

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

Definition at line 997 of file SUSYObjDef_xAOD.h.

◆ m_matchUngroomedParent

bool ST::SUSYObjDef_xAOD::m_matchUngroomedParent
protected

Definition at line 569 of file SUSYObjDef_xAOD.h.

◆ m_mcCampaign

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

Definition at line 608 of file SUSYObjDef_xAOD.h.

◆ m_mcChannel

int ST::SUSYObjDef_xAOD::m_mcChannel
protected

Definition at line 609 of file SUSYObjDef_xAOD.h.

◆ m_metDoMuonEloss

bool ST::SUSYObjDef_xAOD::m_metDoMuonEloss
protected

Definition at line 589 of file SUSYObjDef_xAOD.h.

◆ m_metDoRemoveMuonJets

bool ST::SUSYObjDef_xAOD::m_metDoRemoveMuonJets
protected

Definition at line 587 of file SUSYObjDef_xAOD.h.

◆ m_metDoSetMuonJetEMScale

bool ST::SUSYObjDef_xAOD::m_metDoSetMuonJetEMScale
protected

Definition at line 586 of file SUSYObjDef_xAOD.h.

◆ m_metGreedyPhotons

bool ST::SUSYObjDef_xAOD::m_metGreedyPhotons
protected

Definition at line 590 of file SUSYObjDef_xAOD.h.

◆ m_metJetSelection

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

Definition at line 823 of file SUSYObjDef_xAOD.h.

◆ m_metMaker

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

Definition at line 946 of file SUSYObjDef_xAOD.h.

◆ m_metRemoveOverlappingCaloTaggedMuons

bool ST::SUSYObjDef_xAOD::m_metRemoveOverlappingCaloTaggedMuons
protected

Definition at line 585 of file SUSYObjDef_xAOD.h.

◆ m_metSignif

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

Definition at line 948 of file SUSYObjDef_xAOD.h.

◆ m_metsysConfigPrefix

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

Definition at line 592 of file SUSYObjDef_xAOD.h.

◆ m_metSystTool

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

Definition at line 947 of file SUSYObjDef_xAOD.h.

◆ m_metUseGhostMuons

bool ST::SUSYObjDef_xAOD::m_metUseGhostMuons
protected

Definition at line 588 of file SUSYObjDef_xAOD.h.

◆ m_metVeryGreedyPhotons

bool ST::SUSYObjDef_xAOD::m_metVeryGreedyPhotons
protected

Definition at line 591 of file SUSYObjDef_xAOD.h.

◆ m_mu_id_support

int ST::SUSYObjDef_xAOD::m_mu_id_support
protected

Definition at line 637 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 644 of file SUSYObjDef_xAOD.h.

◆ m_mu_iso_support

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

Definition at line 640 of file SUSYObjDef_xAOD.h.

◆ m_mubaselined0sig

double ST::SUSYObjDef_xAOD::m_mubaselined0sig
protected

Definition at line 726 of file SUSYObjDef_xAOD.h.

◆ m_muBaselineEta

double ST::SUSYObjDef_xAOD::m_muBaselineEta
protected

Definition at line 721 of file SUSYObjDef_xAOD.h.

◆ m_muBaselineIso_WP

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

Definition at line 681 of file SUSYObjDef_xAOD.h.

◆ m_muBaselinePt

double ST::SUSYObjDef_xAOD::m_muBaselinePt
protected

Definition at line 720 of file SUSYObjDef_xAOD.h.

◆ m_mubaselinez0

double ST::SUSYObjDef_xAOD::m_mubaselinez0
protected

Definition at line 727 of file SUSYObjDef_xAOD.h.

◆ m_muCalibrationMode

int ST::SUSYObjDef_xAOD::m_muCalibrationMode
protected

Definition at line 732 of file SUSYObjDef_xAOD.h.

◆ m_muCosmicd0

double ST::SUSYObjDef_xAOD::m_muCosmicd0
protected

Definition at line 730 of file SUSYObjDef_xAOD.h.

◆ m_muCosmicz0

double ST::SUSYObjDef_xAOD::m_muCosmicz0
protected

Definition at line 729 of file SUSYObjDef_xAOD.h.

◆ m_mud0sig

double ST::SUSYObjDef_xAOD::m_mud0sig
protected

Definition at line 724 of file SUSYObjDef_xAOD.h.

◆ m_muEffCorrForce1D

bool ST::SUSYObjDef_xAOD::m_muEffCorrForce1D
protected

Definition at line 686 of file SUSYObjDef_xAOD.h.

◆ m_muEta

double ST::SUSYObjDef_xAOD::m_muEta
protected

Definition at line 723 of file SUSYObjDef_xAOD.h.

◆ m_muHighPtExtraSmear

bool ST::SUSYObjDef_xAOD::m_muHighPtExtraSmear
protected

Definition at line 685 of file SUSYObjDef_xAOD.h.

◆ m_muId

int ST::SUSYObjDef_xAOD::m_muId
protected

Definition at line 658 of file SUSYObjDef_xAOD.h.

◆ m_muIdBaseline

int ST::SUSYObjDef_xAOD::m_muIdBaseline
protected

Definition at line 659 of file SUSYObjDef_xAOD.h.

◆ m_muIso_WP

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

Definition at line 682 of file SUSYObjDef_xAOD.h.

◆ m_muIsoHighPt_WP

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

Definition at line 683 of file SUSYObjDef_xAOD.h.

◆ m_muIsoHighPtThresh

double ST::SUSYObjDef_xAOD::m_muIsoHighPtThresh
protected

Definition at line 684 of file SUSYObjDef_xAOD.h.

◆ m_muLRT

bool ST::SUSYObjDef_xAOD::m_muLRT
protected

Definition at line 733 of file SUSYObjDef_xAOD.h.

◆ m_muonCalibTool

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

Definition at line 887 of file SUSYObjDef_xAOD.h.

◆ m_muonEfficiencyBMHighPtSFTool

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

Definition at line 889 of file SUSYObjDef_xAOD.h.

◆ m_muonEfficiencySFTool

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

Definition at line 888 of file SUSYObjDef_xAOD.h.

◆ m_muonHighPtIsolationSFTool

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

Definition at line 892 of file SUSYObjDef_xAOD.h.

◆ m_muonIsolationSFTool

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

Definition at line 891 of file SUSYObjDef_xAOD.h.

◆ m_muonLRTORTool

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

Definition at line 895 of file SUSYObjDef_xAOD.h.

◆ m_muonSelectionHighPtTool

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

Definition at line 885 of file SUSYObjDef_xAOD.h.

◆ m_muonSelectionTool

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

Definition at line 884 of file SUSYObjDef_xAOD.h.

◆ m_muonSelectionToolBaseline

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

Definition at line 886 of file SUSYObjDef_xAOD.h.

◆ m_muonTerm

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

Definition at line 579 of file SUSYObjDef_xAOD.h.

◆ m_muonTriggerSFTool

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

Definition at line 893 of file SUSYObjDef_xAOD.h.

◆ m_muonTrigSFTools

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

Definition at line 894 of file SUSYObjDef_xAOD.h.

◆ m_muonTTVAEfficiencySFTool

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

Definition at line 890 of file SUSYObjDef_xAOD.h.

◆ m_muPt

double ST::SUSYObjDef_xAOD::m_muPt
protected

Definition at line 722 of file SUSYObjDef_xAOD.h.

◆ m_murequirepassedHighPtCuts

bool ST::SUSYObjDef_xAOD::m_murequirepassedHighPtCuts
protected

Definition at line 728 of file SUSYObjDef_xAOD.h.

◆ m_muTriggerSFCalibFilename

std::string ST::SUSYObjDef_xAOD::m_muTriggerSFCalibFilename
protected

Definition at line 688 of file SUSYObjDef_xAOD.h.

◆ m_muTriggerSFCalibRelease

std::string ST::SUSYObjDef_xAOD::m_muTriggerSFCalibRelease
protected

Definition at line 687 of file SUSYObjDef_xAOD.h.

◆ m_muz0

double ST::SUSYObjDef_xAOD::m_muz0
protected

Definition at line 725 of file SUSYObjDef_xAOD.h.

◆ m_orApplyRelPt

bool ST::SUSYObjDef_xAOD::m_orApplyRelPt
protected

Definition at line 795 of file SUSYObjDef_xAOD.h.

◆ m_orBJetPtUpperThres

double ST::SUSYObjDef_xAOD::m_orBJetPtUpperThres
protected

Definition at line 804 of file SUSYObjDef_xAOD.h.

◆ m_orBoostedElectronC1

double ST::SUSYObjDef_xAOD::m_orBoostedElectronC1
protected

Definition at line 788 of file SUSYObjDef_xAOD.h.

◆ m_orBoostedElectronC2

double ST::SUSYObjDef_xAOD::m_orBoostedElectronC2
protected

Definition at line 789 of file SUSYObjDef_xAOD.h.

◆ m_orBoostedElectronMaxConeSize

double ST::SUSYObjDef_xAOD::m_orBoostedElectronMaxConeSize
protected

Definition at line 790 of file SUSYObjDef_xAOD.h.

◆ m_orBoostedMuonC1

double ST::SUSYObjDef_xAOD::m_orBoostedMuonC1
protected

Definition at line 792 of file SUSYObjDef_xAOD.h.

◆ m_orBoostedMuonC2

double ST::SUSYObjDef_xAOD::m_orBoostedMuonC2
protected

Definition at line 793 of file SUSYObjDef_xAOD.h.

◆ m_orBoostedMuonMaxConeSize

double ST::SUSYObjDef_xAOD::m_orBoostedMuonMaxConeSize
protected

Definition at line 794 of file SUSYObjDef_xAOD.h.

◆ m_orBtagWP

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

Definition at line 801 of file SUSYObjDef_xAOD.h.

◆ m_orDoBjet

bool ST::SUSYObjDef_xAOD::m_orDoBjet
protected

Definition at line 783 of file SUSYObjDef_xAOD.h.

◆ m_orDoBoostedElectron

bool ST::SUSYObjDef_xAOD::m_orDoBoostedElectron
protected

Definition at line 787 of file SUSYObjDef_xAOD.h.

◆ m_orDoBoostedMuon

bool ST::SUSYObjDef_xAOD::m_orDoBoostedMuon
protected

Definition at line 791 of file SUSYObjDef_xAOD.h.

◆ m_orDoElBjet

bool ST::SUSYObjDef_xAOD::m_orDoElBjet
protected

Definition at line 784 of file SUSYObjDef_xAOD.h.

◆ m_orDoEleJet

bool ST::SUSYObjDef_xAOD::m_orDoEleJet
protected

Definition at line 779 of file SUSYObjDef_xAOD.h.

◆ m_orDoElEl

bool ST::SUSYObjDef_xAOD::m_orDoElEl
protected

Definition at line 780 of file SUSYObjDef_xAOD.h.

◆ m_orDoElMu

bool ST::SUSYObjDef_xAOD::m_orDoElMu
protected

Definition at line 781 of file SUSYObjDef_xAOD.h.

◆ m_orDoFatjets

bool ST::SUSYObjDef_xAOD::m_orDoFatjets
protected

Definition at line 807 of file SUSYObjDef_xAOD.h.

◆ m_orDoMuBjet

bool ST::SUSYObjDef_xAOD::m_orDoMuBjet
protected

Definition at line 785 of file SUSYObjDef_xAOD.h.

◆ m_orDoMuonJet

bool ST::SUSYObjDef_xAOD::m_orDoMuonJet
protected

Definition at line 782 of file SUSYObjDef_xAOD.h.

◆ m_orDoMuonJetGhostAssociation

bool ST::SUSYObjDef_xAOD::m_orDoMuonJetGhostAssociation
protected

Definition at line 799 of file SUSYObjDef_xAOD.h.

◆ m_orDoPhoton

bool ST::SUSYObjDef_xAOD::m_orDoPhoton
protected

Definition at line 778 of file SUSYObjDef_xAOD.h.

◆ m_orDoTau

bool ST::SUSYObjDef_xAOD::m_orDoTau
protected

Overlap removal options.

Definition at line 777 of file SUSYObjDef_xAOD.h.

◆ m_orDoTauBjet

bool ST::SUSYObjDef_xAOD::m_orDoTauBjet
protected

Definition at line 786 of file SUSYObjDef_xAOD.h.

◆ m_orInputLabel

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

Definition at line 802 of file SUSYObjDef_xAOD.h.

◆ m_orLinkOverlapObjects

bool ST::SUSYObjDef_xAOD::m_orLinkOverlapObjects
protected

Definition at line 805 of file SUSYObjDef_xAOD.h.

◆ m_orMuJetInnerDR

double ST::SUSYObjDef_xAOD::m_orMuJetInnerDR
protected

Definition at line 798 of file SUSYObjDef_xAOD.h.

◆ m_orMuJetPtRatio

double ST::SUSYObjDef_xAOD::m_orMuJetPtRatio
protected

Definition at line 796 of file SUSYObjDef_xAOD.h.

◆ m_orMuJetTrkPtRatio

double ST::SUSYObjDef_xAOD::m_orMuJetTrkPtRatio
protected

Definition at line 797 of file SUSYObjDef_xAOD.h.

◆ m_orPhotonFavoured

bool ST::SUSYObjDef_xAOD::m_orPhotonFavoured
protected

Definition at line 803 of file SUSYObjDef_xAOD.h.

◆ m_orRemoveCaloMuons

bool ST::SUSYObjDef_xAOD::m_orRemoveCaloMuons
protected

Definition at line 800 of file SUSYObjDef_xAOD.h.

◆ m_orToolbox

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

Definition at line 1000 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 911 of file SUSYObjDef_xAOD.h.

911{this, "OutputElectronLocation", "StdWithLRTElectrons", "name of the muon container to write"};

◆ m_outMETTerm

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

Definition at line 584 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 896 of file SUSYObjDef_xAOD.h.

896{this, "OutputMuonLocation", "StdWithLRTMuons", "name of the muon container to write"};

◆ 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 636 of file SUSYObjDef_xAOD.h.

◆ m_photonAllowLate

bool ST::SUSYObjDef_xAOD::m_photonAllowLate
protected

Definition at line 741 of file SUSYObjDef_xAOD.h.

◆ m_photonBaselineCrackVeto

bool ST::SUSYObjDef_xAOD::m_photonBaselineCrackVeto
protected

Definition at line 739 of file SUSYObjDef_xAOD.h.

◆ m_photonBaselineEta

double ST::SUSYObjDef_xAOD::m_photonBaselineEta
protected

Definition at line 736 of file SUSYObjDef_xAOD.h.

◆ m_photonBaselineIso_WP

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

Definition at line 678 of file SUSYObjDef_xAOD.h.

◆ m_photonBaselinePt

double ST::SUSYObjDef_xAOD::m_photonBaselinePt
protected

Definition at line 735 of file SUSYObjDef_xAOD.h.

◆ m_photonCrackVeto

bool ST::SUSYObjDef_xAOD::m_photonCrackVeto
protected

Definition at line 740 of file SUSYObjDef_xAOD.h.

◆ m_photonEfficiencySFTool

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

Definition at line 920 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 925 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 924 of file SUSYObjDef_xAOD.h.

◆ m_photonEta

double ST::SUSYObjDef_xAOD::m_photonEta
protected

Definition at line 737 of file SUSYObjDef_xAOD.h.

◆ m_photonId

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

Definition at line 660 of file SUSYObjDef_xAOD.h.

◆ m_photonIdBaseline

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

Definition at line 661 of file SUSYObjDef_xAOD.h.

◆ m_photonIdBaselineDFName

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

Definition at line 1007 of file SUSYObjDef_xAOD.h.

◆ m_photonIdDFName

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

Definition at line 1008 of file SUSYObjDef_xAOD.h.

◆ m_photonIso_WP

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

Definition at line 679 of file SUSYObjDef_xAOD.h.

◆ m_photonIsolationSFTool

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

Definition at line 921 of file SUSYObjDef_xAOD.h.

◆ m_photonPt

double ST::SUSYObjDef_xAOD::m_photonPt
protected

Definition at line 738 of file SUSYObjDef_xAOD.h.

◆ m_photonSelIsEM

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

Definition at line 917 of file SUSYObjDef_xAOD.h.

◆ m_photonSelIsEMBaseline

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

Definition at line 918 of file SUSYObjDef_xAOD.h.

◆ m_photonTrigEffTools

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

Definition at line 927 of file SUSYObjDef_xAOD.h.

◆ m_photonTriggerName

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

Definition at line 680 of file SUSYObjDef_xAOD.h.

◆ m_photonTriggerSFTool

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

Definition at line 922 of file SUSYObjDef_xAOD.h.

◆ m_photonTrigSFTools

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

Definition at line 926 of file SUSYObjDef_xAOD.h.

◆ m_pmgSHnjetWeighter

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

Definition at line 1002 of file SUSYObjDef_xAOD.h.

◆ m_pmgSHnjetWeighterWZ

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

Definition at line 1003 of file SUSYObjDef_xAOD.h.

◆ m_prwActualMu2017File

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

Definition at line 622 of file SUSYObjDef_xAOD.h.

◆ m_prwActualMu2018File

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

Definition at line 623 of file SUSYObjDef_xAOD.h.

◆ m_prwActualMu2022File

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

Definition at line 624 of file SUSYObjDef_xAOD.h.

◆ m_prwActualMu2023File

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

Definition at line 625 of file SUSYObjDef_xAOD.h.

◆ m_prwActualMu2024File

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

Definition at line 626 of file SUSYObjDef_xAOD.h.

◆ m_prwActualMu2025File

std::string ST::SUSYObjDef_xAOD::m_prwActualMu2025File
protected

Definition at line 627 of file SUSYObjDef_xAOD.h.

◆ m_prwConfFiles

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

Definition at line 620 of file SUSYObjDef_xAOD.h.

◆ m_prwDataSF

double ST::SUSYObjDef_xAOD::m_prwDataSF
protected

Definition at line 629 of file SUSYObjDef_xAOD.h.

◆ m_prwDataSF_DW

double ST::SUSYObjDef_xAOD::m_prwDataSF_DW
protected

Definition at line 631 of file SUSYObjDef_xAOD.h.

◆ m_prwDataSF_UP

double ST::SUSYObjDef_xAOD::m_prwDataSF_UP
protected

Definition at line 630 of file SUSYObjDef_xAOD.h.

◆ m_prwLcalcFiles

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

Definition at line 621 of file SUSYObjDef_xAOD.h.

◆ m_prwTool

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

Definition at line 995 of file SUSYObjDef_xAOD.h.

◆ m_runDepPrescaleWeightPRW

bool ST::SUSYObjDef_xAOD::m_runDepPrescaleWeightPRW
protected

Definition at line 632 of file SUSYObjDef_xAOD.h.

◆ m_runECIS

bool ST::SUSYObjDef_xAOD::m_runECIS
protected

Definition at line 677 of file SUSYObjDef_xAOD.h.

◆ m_showerType

int ST::SUSYObjDef_xAOD::m_showerType
protected

Definition at line 825 of file SUSYObjDef_xAOD.h.

◆ m_slices

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

Definition at line 819 of file SUSYObjDef_xAOD.h.

◆ m_softTermParam

int ST::SUSYObjDef_xAOD::m_softTermParam
protected

Definition at line 598 of file SUSYObjDef_xAOD.h.

◆ m_strictConfigCheck

bool ST::SUSYObjDef_xAOD::m_strictConfigCheck
protected

Definition at line 542 of file SUSYObjDef_xAOD.h.

◆ m_subtool_init

bool ST::SUSYObjDef_xAOD::m_subtool_init
protected

Definition at line 573 of file SUSYObjDef_xAOD.h.

◆ m_tau_id_fallback

std::map<int, int> ST::SUSYObjDef_xAOD::m_tau_id_fallback
protected

Definition at line 645 of file SUSYObjDef_xAOD.h.

◆ m_tau_id_support

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

Definition at line 638 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 650 of file SUSYObjDef_xAOD.h.

◆ m_tauConfigPath

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

Definition at line 746 of file SUSYObjDef_xAOD.h.

◆ m_tauConfigPathBaseline

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

Definition at line 747 of file SUSYObjDef_xAOD.h.

◆ m_tauConfigReader

TEnv ST::SUSYObjDef_xAOD::m_tauConfigReader
protected

Definition at line 754 of file SUSYObjDef_xAOD.h.

◆ m_tauDoTTM

bool ST::SUSYObjDef_xAOD::m_tauDoTTM
protected

Definition at line 750 of file SUSYObjDef_xAOD.h.

◆ m_tauEffTool

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

Definition at line 937 of file SUSYObjDef_xAOD.h.

◆ m_tauEffToolRecommendationTag

std::string ST::SUSYObjDef_xAOD::m_tauEffToolRecommendationTag
protected

Definition at line 752 of file SUSYObjDef_xAOD.h.

◆ m_tauEleId

bool ST::SUSYObjDef_xAOD::m_tauEleId
protected

Definition at line 665 of file SUSYObjDef_xAOD.h.

◆ m_tauEleIdBaseline

bool ST::SUSYObjDef_xAOD::m_tauEleIdBaseline
protected

Definition at line 666 of file SUSYObjDef_xAOD.h.

◆ m_tauEta

double ST::SUSYObjDef_xAOD::m_tauEta
protected

Definition at line 745 of file SUSYObjDef_xAOD.h.

◆ m_tauId

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

Definition at line 663 of file SUSYObjDef_xAOD.h.

◆ m_tauIdBaseline

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

Definition at line 664 of file SUSYObjDef_xAOD.h.

◆ m_tauInputFile

std::string ST::SUSYObjDef_xAOD::m_tauInputFile
protected

Definition at line 748 of file SUSYObjDef_xAOD.h.

◆ m_tauInputFileBaseline

std::string ST::SUSYObjDef_xAOD::m_tauInputFileBaseline
protected

Definition at line 749 of file SUSYObjDef_xAOD.h.

◆ m_tauJetORtool

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

Definition at line 999 of file SUSYObjDef_xAOD.h.

◆ m_tauMuOLR

bool ST::SUSYObjDef_xAOD::m_tauMuOLR
protected

Definition at line 667 of file SUSYObjDef_xAOD.h.

◆ m_tauMuOLRBaseline

bool ST::SUSYObjDef_xAOD::m_tauMuOLRBaseline
protected

Definition at line 668 of file SUSYObjDef_xAOD.h.

◆ m_tauPrePtCut

double ST::SUSYObjDef_xAOD::m_tauPrePtCut
protected

Definition at line 743 of file SUSYObjDef_xAOD.h.

◆ m_tauPt

double ST::SUSYObjDef_xAOD::m_tauPt
protected

Definition at line 744 of file SUSYObjDef_xAOD.h.

◆ m_tauSelTool

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

Definition at line 933 of file SUSYObjDef_xAOD.h.

◆ m_tauSelToolBaseline

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

Definition at line 934 of file SUSYObjDef_xAOD.h.

◆ m_tauSmearingTool

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

Definition at line 935 of file SUSYObjDef_xAOD.h.

◆ m_tauSmearingToolRecommendationTag

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

Definition at line 751 of file SUSYObjDef_xAOD.h.

◆ m_tauTagger

std::string ST::SUSYObjDef_xAOD::m_tauTagger
protected

Definition at line 662 of file SUSYObjDef_xAOD.h.

◆ m_tauTerm

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

Definition at line 577 of file SUSYObjDef_xAOD.h.

◆ m_tauTrigEffTool

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

Definition at line 938 of file SUSYObjDef_xAOD.h.

◆ m_tauTruthMatch

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

Definition at line 936 of file SUSYObjDef_xAOD.h.

◆ m_tool_init

bool ST::SUSYObjDef_xAOD::m_tool_init
protected

Definition at line 572 of file SUSYObjDef_xAOD.h.

◆ m_TopconfigReader

TEnv ST::SUSYObjDef_xAOD::m_TopconfigReader
protected

Definition at line 552 of file SUSYObjDef_xAOD.h.

◆ m_TopDecorName

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

Definition at line 555 of file SUSYObjDef_xAOD.h.

◆ m_ToptagConfig

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

Definition at line 558 of file SUSYObjDef_xAOD.h.

◆ m_TopTaggerCalibArea

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

Definition at line 560 of file SUSYObjDef_xAOD.h.

◆ m_TopTaggerTool

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

Definition at line 864 of file SUSYObjDef_xAOD.h.

◆ m_TopTagjetUncertaintiesTool

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

Definition at line 868 of file SUSYObjDef_xAOD.h.

◆ m_TopTagUncConfig

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

Definition at line 563 of file SUSYObjDef_xAOD.h.

◆ m_treatPUJets

bool ST::SUSYObjDef_xAOD::m_treatPUJets
protected

Definition at line 599 of file SUSYObjDef_xAOD.h.

◆ m_trig2015combination_diLep

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

Definition at line 959 of file SUSYObjDef_xAOD.h.

◆ m_trig2015combination_diPhoton

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

Definition at line 975 of file SUSYObjDef_xAOD.h.

◆ m_trig2015combination_multiLep

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

Definition at line 967 of file SUSYObjDef_xAOD.h.

◆ m_trig2015combination_singleLep

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

Definition at line 950 of file SUSYObjDef_xAOD.h.

◆ m_trig2016combination_diLep

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

Definition at line 960 of file SUSYObjDef_xAOD.h.

◆ m_trig2016combination_diPhoton

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

Definition at line 976 of file SUSYObjDef_xAOD.h.

◆ m_trig2016combination_multiLep

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

Definition at line 968 of file SUSYObjDef_xAOD.h.

◆ m_trig2016combination_singleLep

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

Definition at line 951 of file SUSYObjDef_xAOD.h.

◆ m_trig2017combination_diLep

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

Definition at line 961 of file SUSYObjDef_xAOD.h.

◆ m_trig2017combination_diPhoton

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

Definition at line 977 of file SUSYObjDef_xAOD.h.

◆ m_trig2017combination_multiLep

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

Definition at line 969 of file SUSYObjDef_xAOD.h.

◆ m_trig2017combination_singleLep

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

Definition at line 952 of file SUSYObjDef_xAOD.h.

◆ m_trig2018combination_diLep

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

Definition at line 962 of file SUSYObjDef_xAOD.h.

◆ m_trig2018combination_diPhoton

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

Definition at line 978 of file SUSYObjDef_xAOD.h.

◆ m_trig2018combination_multiLep

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

Definition at line 970 of file SUSYObjDef_xAOD.h.

◆ m_trig2018combination_singleLep

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

Definition at line 953 of file SUSYObjDef_xAOD.h.

◆ m_trig2022combination_diLep

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

Definition at line 963 of file SUSYObjDef_xAOD.h.

◆ m_trig2022combination_diPhoton

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

Definition at line 979 of file SUSYObjDef_xAOD.h.

◆ m_trig2022combination_multiLep

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

Definition at line 971 of file SUSYObjDef_xAOD.h.

◆ m_trig2022combination_singleLep

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

Definition at line 954 of file SUSYObjDef_xAOD.h.

◆ m_trig2023combination_singleLep

std::string ST::SUSYObjDef_xAOD::m_trig2023combination_singleLep
protected

Definition at line 955 of file SUSYObjDef_xAOD.h.

◆ m_trig2024combination_singleLep

std::string ST::SUSYObjDef_xAOD::m_trig2024combination_singleLep
protected

Definition at line 956 of file SUSYObjDef_xAOD.h.

◆ m_trigConfTool

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

Definition at line 982 of file SUSYObjDef_xAOD.h.

◆ m_trigDecTool

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

Definition at line 983 of file SUSYObjDef_xAOD.h.

◆ m_trigDRScoringTool

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

Definition at line 986 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 964 of file SUSYObjDef_xAOD.h.

◆ m_trigGlobalEffCorrTool_diPhoton

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

Definition at line 980 of file SUSYObjDef_xAOD.h.

◆ m_trigGlobalEffCorrTool_multiLep

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

Definition at line 972 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 529 of file SUSYObjDef_xAOD.h.

◆ m_trigMatchingTool

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

Definition at line 984 of file SUSYObjDef_xAOD.h.

◆ m_trigMatchScoringTool

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

Definition at line 985 of file SUSYObjDef_xAOD.h.

◆ m_trigNToys_diLep

int ST::SUSYObjDef_xAOD::m_trigNToys_diLep
protected

Definition at line 958 of file SUSYObjDef_xAOD.h.

◆ m_trigNToys_diPhoton

int ST::SUSYObjDef_xAOD::m_trigNToys_diPhoton
protected

Definition at line 974 of file SUSYObjDef_xAOD.h.

◆ m_trigNToys_multiLep

int ST::SUSYObjDef_xAOD::m_trigNToys_multiLep
protected

Definition at line 966 of file SUSYObjDef_xAOD.h.

◆ m_trkJetEta

double ST::SUSYObjDef_xAOD::m_trkJetEta
protected

Definition at line 765 of file SUSYObjDef_xAOD.h.

◆ m_trkJetPt

double ST::SUSYObjDef_xAOD::m_trkJetPt
protected

Definition at line 764 of file SUSYObjDef_xAOD.h.

◆ m_trkJetsyst

bool ST::SUSYObjDef_xAOD::m_trkJetsyst
protected

Definition at line 596 of file SUSYObjDef_xAOD.h.

◆ m_trkMETsyst

bool ST::SUSYObjDef_xAOD::m_trkMETsyst
protected

Definition at line 594 of file SUSYObjDef_xAOD.h.

◆ m_upstreamTriggerMatching

bool ST::SUSYObjDef_xAOD::m_upstreamTriggerMatching
protected

Definition at line 528 of file SUSYObjDef_xAOD.h.

◆ m_useBtagging

bool ST::SUSYObjDef_xAOD::m_useBtagging
protected

Definition at line 538 of file SUSYObjDef_xAOD.h.

◆ m_useBtagging_trkJet

bool ST::SUSYObjDef_xAOD::m_useBtagging_trkJet
protected

Definition at line 539 of file SUSYObjDef_xAOD.h.

◆ m_useCommonPRWFiles

bool ST::SUSYObjDef_xAOD::m_useCommonPRWFiles
protected

Definition at line 611 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 816 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 468 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 474 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 460 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 469 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 475 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 461 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 470 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 476 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 462 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 471 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 477 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 463 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 472 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 478 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 464 of file SUSYObjDef_xAOD.h.

◆ m_v_trigs23_cache_singleEle

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

Definition at line 457 of file SUSYObjDef_xAOD.h.

◆ m_v_trigs23_cache_singleLep

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

Definition at line 465 of file SUSYObjDef_xAOD.h.

◆ m_v_trigs24_cache_singleEle

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

Definition at line 458 of file SUSYObjDef_xAOD.h.

◆ m_v_trigs24_cache_singleLep

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

Definition at line 466 of file SUSYObjDef_xAOD.h.

◆ m_varHandleArraysDeclared

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

Definition at line 387 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 386 of file AthCommonDataStore.h.

◆ m_WconfigReader

TEnv ST::SUSYObjDef_xAOD::m_WconfigReader
protected

Definition at line 550 of file SUSYObjDef_xAOD.h.

◆ m_WDecorName

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

Definition at line 553 of file SUSYObjDef_xAOD.h.

◆ m_WtagConfig

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

Definition at line 556 of file SUSYObjDef_xAOD.h.

◆ m_WTaggerTool

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

Definition at line 862 of file SUSYObjDef_xAOD.h.

◆ m_WTagjetUncertaintiesTool

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

Definition at line 866 of file SUSYObjDef_xAOD.h.

◆ m_WTagUncConfig

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

Definition at line 561 of file SUSYObjDef_xAOD.h.

◆ m_WZTaggerCalibArea

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

Definition at line 559 of file SUSYObjDef_xAOD.h.

◆ m_ZconfigReader

TEnv ST::SUSYObjDef_xAOD::m_ZconfigReader
protected

Definition at line 551 of file SUSYObjDef_xAOD.h.

◆ m_ZDecorName

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

Definition at line 554 of file SUSYObjDef_xAOD.h.

◆ m_ZtagConfig

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

Definition at line 557 of file SUSYObjDef_xAOD.h.

◆ m_ZTaggerTool

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

Definition at line 863 of file SUSYObjDef_xAOD.h.

◆ m_ZTagjetUncertaintiesTool

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

Definition at line 867 of file SUSYObjDef_xAOD.h.

◆ m_ZTagUncConfig

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

Definition at line 562 of file SUSYObjDef_xAOD.h.

◆ prompt_electrons

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

Definition at line 211 of file SUSYObjDef_xAOD.h.

◆ prompt_muons

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

Definition at line 205 of file SUSYObjDef_xAOD.h.

The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.17.0