ST::SUSYObjDef_xAOD Class Reference

#include <SUSYObjDef_xAOD.h>

Inheritance diagram for ST::SUSYObjDef_xAOD:

Collaboration diagram for ST::SUSYObjDef_xAOD:

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

Public Member Functions
	SUSYObjDef_xAOD (const std::string &name)
	~SUSYObjDef_xAOD ()
StatusCode	initialize () override final
	Dummy implementation of the initialisation function. More...
bool	isData () const override final
bool	isAtlfast () const override final
StatusCode	setBoolProperty (const std::string &name, const bool &property) override final
void	setDataSource (int source)
StatusCode	FillJet (xAOD::Jet &input, const bool doCalib=true, bool isFat=false, bool doLargeRdecorations=false) override final
StatusCode	FillTrackJet (xAOD::Jet &input) override final
StatusCode	FillTau (xAOD::TauJet &input) override final
StatusCode	FillMuon (xAOD::Muon &input, const float ptcut, const float etacut) override final
StatusCode	FillElectron (xAOD::Electron &input, const float etcut, const float etacut) override final
StatusCode	FillPhoton (xAOD::Photon &input, const float ptcut, const float etacut) override final
const xAOD::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 > &) 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 void	print () const =0
	Print the state of the tool. More...
virtual StatusCode	sysInitialize ()
	Function initialising the tool in the correct way in Athena. More...
virtual void	print () const
	Print the state of the tool. More...
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

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

Public Attributes
const xAOD::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 ()
void	getTauConfig (const std::string &tauConfigPath, std::vector< float > &pT_window, std::vector< float > &eta_window, bool &eleOLR, bool &muVeto, bool &muOLR) const
void	configFromFile (bool &property, const std::string &propname, TEnv &rEnv, bool defaultValue)
void	configFromFile (double &property, const std::string &propname, TEnv &rEnv, double defaultValue)
void	configFromFile (int &property, const std::string &propname, TEnv &rEnv, int defaultValue)
void	configFromFile (std::string &property, const std::string &propname, TEnv &rEnv, const std::string &defaultValue, bool allowEmpty=false)
bool	check_isOption (const std::string &wp, const std::vector< std::string > &list) const
bool	check_isTighter (const std::string &wp1, const std::string &wp, const std::vector< std::string > &list) const
std::string	EG_WP (const std::string &wp) const
std::vector< std::string >	getElSFkeys (const std::string &mapFile) const
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...

Protected Attributes
int	m_dataSource
int	m_jetInputType
std::string	m_configFile
bool	m_force_noElId
bool	m_force_noMuId
bool	m_doTTVAsf
bool	m_doModifiedEleId
bool	m_upstreamTriggerMatching
std::string	m_trigMatchingPrefix
	Use composite trigger matching tool if matching was done upstream. More...
std::string	m_jetUncertaintiesConfig
	Prefix for trigger matchiing container name. More...
std::string	m_jetUncertaintiesAnalysisFile
std::string	m_jetUncertaintiesCalibArea
std::string	m_jetUncertaintiesMCType
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
bool	m_tool_init
bool	m_subtool_init
std::string	m_eleTerm
std::string	m_gammaTerm
std::string	m_tauTerm
std::string	m_jetTerm
std::string	m_muonTerm
std::string	m_inputMETSuffix
std::string	m_inputMETMap
std::string	m_inputMETCore
std::string	m_inputMETRef
std::string	m_outMETTerm
bool	m_metRemoveOverlappingCaloTaggedMuons
bool	m_metDoSetMuonJetEMScale
bool	m_metDoRemoveMuonJets
bool	m_metUseGhostMuons
bool	m_metDoMuonEloss
bool	m_metGreedyPhotons
bool	m_metVeryGreedyPhotons
std::string	m_metsysConfigPrefix
bool	m_trkMETsyst
bool	m_caloMETsyst
bool	m_trkJetsyst
int	m_softTermParam
bool	m_treatPUJets
bool	m_doPhiReso
bool	m_autoconfigPRW
std::string	m_autoconfigPRWPath
std::string	m_autoconfigPRWFile
bool	m_autoconfigPRWCombinedmode
bool	m_autoconfigPRWRPVmode
std::string	m_autoconfigPRWRtags
std::string	m_mcCampaign
int	m_mcChannel
bool	m_useCommonPRWFiles
std::string	m_commonPRWFileMC20a
std::string	m_commonPRWFileMC20d
std::string	m_commonPRWFileMC20e
std::string	m_commonPRWFileMC21a
std::string	m_commonPRWFileMC23a
std::string	m_commonPRWFileMC23c
std::string	m_commonPRWFileMC23d
std::string	m_commonPRWFileMC23e
std::vector< std::string >	m_prwConfFiles
std::vector< std::string >	m_prwLcalcFiles
std::string	m_prwActualMu2017File
std::string	m_prwActualMu2018File
std::string	m_prwActualMu2022File
std::string	m_prwActualMu2023File
std::string	m_prwActualMu2024File
double	m_prwDataSF
double	m_prwDataSF_UP
double	m_prwDataSF_DW
bool	m_runDepPrescaleWeightPRW
std::vector< std::string >	m_el_id_support
std::vector< std::string >	m_ph_id_support
int	m_mu_id_support
std::vector< std::string >	m_tau_id_support
std::vector< std::string >	m_el_iso_support
std::vector< std::string >	m_mu_iso_support
std::map< std::string, std::string >	m_el_iso_fallback
std::map< std::string, std::string >	m_mu_iso_fallback
std::string	m_electronTriggerSFStringSingle
std::map< std::string, std::string >	m_tau_trig_support
std::string	m_eleId
std::string	m_eleIdBaseline
std::string	m_eleConfig
std::string	m_eleConfigBaseline
std::string	m_eleBaselineIso_WP
bool	m_eleIdExpert
int	m_muId
int	m_muIdBaseline
std::string	m_photonId
std::string	m_photonIdBaseline
std::string	m_tauId
std::string	m_tauIdBaseline
std::string	m_eleIso_WP
std::string	m_eleIsoHighPt_WP
double	m_eleIsoHighPtThresh
std::string	m_eleChID_WP
bool	m_eleLRT
int	m_eleLRT_strat
bool	m_eleChIso
bool	m_eleChID_signal
bool	m_runECIS
std::string	m_photonBaselineIso_WP
std::string	m_photonIso_WP
std::string	m_photonTriggerName
std::string	m_muBaselineIso_WP
std::string	m_muIso_WP
std::string	m_muIsoHighPt_WP
double	m_muIsoHighPtThresh
bool	m_muHighPtExtraSmear
bool	m_muEffCorrForce1D
std::string	m_muTriggerSFCalibRelease
std::string	m_muTriggerSFCalibFilename
std::string	m_BtagWP
std::string	m_BtagTagger
double	m_BtagMinPt
std::string	m_BtagKeyOverride
std::string	m_BtagSystStrategy
std::string	m_EigenvectorReductionB
std::string	m_EigenvectorReductionC
std::string	m_EigenvectorReductionLight
std::string	m_BtagWP_trkJet
std::string	m_BtagTagger_trkJet
double	m_BtagMinPt_trkJet
double	m_eleBaselinePt
double	m_eleBaselineEta
bool	m_eleBaselineCrackVeto
double	m_elePt
double	m_eleEta
bool	m_eleCrackVeto
double	m_eled0sig
double	m_elez0
double	m_elebaselined0sig
double	m_elebaselinez0
std::string	m_eleEffMapFilePath
std::string	m_eleEffMapFilePathRun2
bool	m_eleAllowRun3TrigSFFallback
bool	m_eleForceFullSimCalib
double	m_muBaselinePt
double	m_muBaselineEta
double	m_muPt
double	m_muEta
double	m_mud0sig
double	m_muz0
double	m_mubaselined0sig
double	m_mubaselinez0
bool	m_murequirepassedHighPtCuts
double	m_muCosmicz0
double	m_muCosmicd0
double	m_badmuQoverP
int	m_muCalibrationMode
bool	m_muLRT
double	m_photonBaselinePt
double	m_photonBaselineEta
double	m_photonEta
double	m_photonPt
bool	m_photonBaselineCrackVeto
bool	m_photonCrackVeto
bool	m_photonAllowLate
double	m_tauPrePtCut
double	m_tauPt
double	m_tauEta
std::string	m_tauConfigPath
std::string	m_tauConfigPathBaseline
bool	m_tauDoTTM
std::string	m_tauSmearingToolRecommendationTag
std::string	m_tauEffToolRecommendationTag
std::string	m_tauSmearingToolGenerator
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. More...
bool	m_orDoPhoton
bool	m_orDoEleJet
bool	m_orDoElEl
bool	m_orDoElMu
bool	m_orDoMuonJet
bool	m_orDoBjet
bool	m_orDoElBjet
bool	m_orDoMuBjet
bool	m_orDoTauBjet
bool	m_orDoBoostedElectron
double	m_orBoostedElectronC1
double	m_orBoostedElectronC2
double	m_orBoostedElectronMaxConeSize
bool	m_orDoBoostedMuon
double	m_orBoostedMuonC1
double	m_orBoostedMuonC2
double	m_orBoostedMuonMaxConeSize
bool	m_orApplyRelPt
double	m_orMuJetPtRatio
double	m_orMuJetTrkPtRatio
double	m_orMuJetInnerDR
bool	m_orDoMuonJetGhostAssociation
bool	m_orRemoveCaloMuons
std::string	m_orBtagWP
std::string	m_orInputLabel
bool	m_orPhotonFavoured
double	m_orBJetPtUpperThres
bool	m_orLinkOverlapObjects
bool	m_orDoFatjets
double	m_EleFatJetDR
double	m_JetFatJetDR
bool	m_doIsoSignal
bool	m_doElIsoSignal
bool	m_doPhIsoSignal
bool	m_doMuIsoSignal
bool	m_useSigLepForIsoCloseByOR
std::string	m_IsoCloseByORpassLabel
bool	m_useTRUTH3
std::map< std::string, bool >	m_slices
bool	m_isRun3
bool	m_isPHYSLITE
std::string	m_metJetSelection
int	m_showerType
std::string	m_defaultJets
std::string	m_defaultTrackJets
std::string	m_fatJets
std::string	m_defaultTruthJets
CP::SystematicSet	m_defaultSyst = CP::SystematicSet()
CP::SystematicSet	m_currentSyst
std::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. More...
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. More...
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
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> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
std::map< std::string, std::string >	m_conf_to_prop
std::set< std::string >	m_bool_prop_set
std::map< std::string, std::function< bool()> > m_metTriggerFuncs	ATLAS_THREAD_SAFE
std::map< std::string, bool > m_checkedTriggers	ATLAS_THREAD_SAFE
std::mutex	m_triggerCacheMutex
std::vector< std::string >	m_v_trigs15_cache_singleEle
std::vector< std::string >	m_v_trigs16_cache_singleEle
std::vector< std::string >	m_v_trigs17_cache_singleEle
std::vector< std::string >	m_v_trigs18_cache_singleEle
std::vector< std::string >	m_v_trigs22_cache_singleEle
std::vector< std::string >	m_v_trigs15_cache_singleLep
std::vector< std::string >	m_v_trigs16_cache_singleLep
std::vector< std::string >	m_v_trigs17_cache_singleLep
std::vector< std::string >	m_v_trigs18_cache_singleLep
std::vector< std::string >	m_v_trigs22_cache_singleLep
std::vector< std::string >	m_v_trigs15_cache_diLep
std::vector< std::string >	m_v_trigs16_cache_diLep
std::vector< std::string >	m_v_trigs17_cache_diLep
std::vector< std::string >	m_v_trigs18_cache_diLep
std::vector< std::string >	m_v_trigs22_cache_diLep
std::vector< std::string >	m_v_trigs15_cache_multiLep
std::vector< std::string >	m_v_trigs16_cache_multiLep
std::vector< std::string >	m_v_trigs17_cache_multiLep
std::vector< std::string >	m_v_trigs18_cache_multiLep
std::vector< std::string >	m_v_trigs22_cache_multiLep
SG::ReadHandleKey< xAOD::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. More...
MetaStore_t	m_outputMetaStore
	Object accessing the output metadata store. More...
bool	m_beginInputFileCalled
	Flag helping to discover when the tool misses the opening of the first input file. More...
bool	m_useIncidents
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

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

Detailed Description

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

Member Enumeration Documentation

DataSource

enum ST::ISUSYObjDef_xAODTool::DataSource

inherited

Enumerator
Undefined
Data
FullSim
AtlfastII

Definition at line 476 of file ISUSYObjDef_xAODTool.h.

                    {
      Undefined = -1,
      Data,
      FullSim,
      AtlfastII
    };

Constructor & Destructor Documentation

SUSYObjDef_xAOD()

ST::SUSYObjDef_xAOD::SUSYObjDef_xAOD

(

const std::string &

name

)

Override for the b-tagging jet collection

Definition at line 101 of file SUSYObjDef_xAOD.cxx.

  : asg::AsgMetadataTool( name ),
    m_dataSource(Undefined),
    m_jetInputType(xAOD::JetInput::Uncategorized),
    m_force_noElId(false),
    m_force_noMuId(false),
    m_doTTVAsf(true),
    m_upstreamTriggerMatching(false),
    m_trigMatchingPrefix(""),
    m_useBtagging(false),
    m_useBtagging_trkJet(false),
    m_debug(false),
    m_strictConfigCheck(false),
    m_badJetCut(""),
    m_fatJetUncConfig(""),
    m_fatJetUncVars(""),
    m_WDecorName(""),
    m_ZDecorName(""),
    m_TopDecorName(""),
    m_WtagConfig(""),
    m_ZtagConfig(""),
    m_ToptagConfig(""),
    m_WZTaggerCalibArea(""),
    m_TopTaggerCalibArea(""),
    m_WTagUncConfig(""),
    m_ZTagUncConfig(""),
    m_TopTagUncConfig(""),
    m_JetTruthLabelName(""),
    m_tool_init(false),
    m_subtool_init(false),
    // set dummies for configuration
    m_eleTerm(""),
    m_gammaTerm(""),
    m_tauTerm(""),
    m_jetTerm(""),
    m_muonTerm(""),
    m_inputMETSuffix(""),
    m_outMETTerm(""),
    m_metRemoveOverlappingCaloTaggedMuons(true),
    m_metDoSetMuonJetEMScale(true),
    m_metDoRemoveMuonJets(true),
    m_metUseGhostMuons(false),
    m_metDoMuonEloss(false),
    m_metGreedyPhotons(false),
    m_metVeryGreedyPhotons(false),
    m_metsysConfigPrefix(""),
    m_trkMETsyst(true),
    m_caloMETsyst(false),
    m_softTermParam(-99),
    m_treatPUJets(true),
    m_doPhiReso(true),
    m_autoconfigPRW(false),
    m_autoconfigPRWPath(""),
    m_autoconfigPRWFile(""),
    m_autoconfigPRWCombinedmode(false),
    m_autoconfigPRWRPVmode(false),
    m_autoconfigPRWRtags(""),
    m_mcCampaign(""),
    m_mcChannel(-99),
    m_useCommonPRWFiles(false),
    m_commonPRWFileMC20a(""),
    m_commonPRWFileMC20d(""),
    m_commonPRWFileMC20e(""),
    m_commonPRWFileMC21a(""),
    m_commonPRWFileMC23a(""),
    m_commonPRWFileMC23c(""),
    m_commonPRWFileMC23d(""),
    m_commonPRWFileMC23e(""),
    m_prwDataSF(-99.),
    m_prwDataSF_UP(-99.),
    m_prwDataSF_DW(-99.),
    m_runDepPrescaleWeightPRW(false),
    m_electronTriggerSFStringSingle(""),
    m_eleId(""),
    m_eleIdBaseline(""),
    m_eleConfig(""),
    m_eleConfigBaseline(""),
    m_eleBaselineIso_WP(""),
    m_eleIdExpert(false),
    m_muId(static_cast<int>(xAOD::Muon::Quality(xAOD::Muon::VeryLoose))),
    m_muIdBaseline(static_cast<int>(xAOD::Muon::Quality(xAOD::Muon::VeryLoose))),
    m_photonId(""),
    m_photonIdBaseline(""),
    m_tauId(""),
    m_tauIdBaseline(""),
    m_eleIso_WP(""),
    m_eleIsoHighPt_WP(""),
    m_eleIsoHighPtThresh(-99.),
    m_eleChID_WP(""),
    m_eleLRT_strat(-99),
    m_eleChIso(true),
    m_eleChID_signal(false),
    m_runECIS(false),
    m_photonBaselineIso_WP(""),
    m_photonIso_WP(""),
    m_photonTriggerName(""),
    m_muBaselineIso_WP(""),
    m_muIso_WP(""),
    m_muIsoHighPt_WP(""),
    m_muIsoHighPtThresh(-99.),
    m_muHighPtExtraSmear(false),
    m_muEffCorrForce1D(false),
    m_BtagWP(""),
    m_BtagTagger(""),
    m_BtagMinPt(-99.),
    m_BtagKeyOverride(""),
    m_BtagSystStrategy(""),
    m_EigenvectorReductionB(""),
    m_EigenvectorReductionC(""),
    m_EigenvectorReductionLight(""),
    m_BtagWP_trkJet(""),
    m_BtagTagger_trkJet(""),
    m_BtagMinPt_trkJet(-99.),
    //configurable cuts here
    m_eleBaselinePt(-99.),
    m_eleBaselineEta(-99.),
    m_eleBaselineCrackVeto(false),
    m_elePt(-99.),
    m_eleEta(-99.),
    m_eleCrackVeto(false),
    m_eled0sig(-99.),
    m_elez0(-99.),
    m_elebaselined0sig(-99.),
    m_elebaselinez0(-99),
    m_eleAllowRun3TrigSFFallback(false),
    m_eleForceFullSimCalib(false),
    //
    m_muBaselinePt(-99.),
    m_muBaselineEta(-99.),
    m_muPt(-99.),
    m_muEta(-99.),
    m_mud0sig(-99.),
    m_muz0(-99.),
    m_mubaselined0sig(-99.),
    m_mubaselinez0(-99.),
    m_murequirepassedHighPtCuts(false),
    m_muCosmicz0(-99.),
    m_muCosmicd0(-99.),
    m_badmuQoverP(-99.),
    m_muCalibrationMode(-99.),
    //
    m_photonBaselinePt(-99.),
    m_photonBaselineEta(-99.),
    m_photonEta(-99.),
    m_photonPt(-99.),
    m_photonBaselineCrackVeto(true),
    m_photonCrackVeto(true),
    m_photonAllowLate(false),
    //
    m_tauPrePtCut(-99.),
    m_tauPt(-99.),
    m_tauEta(-99.),
    m_tauConfigPath(""),
    m_tauConfigPathBaseline(""),
    m_tauDoTTM(false),
    m_tauSmearingToolRecommendationTag(""),
    m_tauEffToolRecommendationTag(""),
    m_tauSmearingToolGenerator(""),
    m_ApplyMVATESQualityCheck(true),
    //
    m_jetPt(-99.),
    m_jetEta(-99.),
    m_jetJvt(-99.),
    m_JvtWP(""),
    m_JvtPtMax(-99.),
    m_JvtConfigRun2(""),
    m_JvtConfigRun3(""),
    m_trkJetPt(-99.),
    m_trkJetEta(-99.),
    m_doFwdJVT(false),
    m_fJvtWP(""),
    m_fJvtPtMax(-99.),
    m_fJvtEtaMin(-99.),
    m_fJvtConfigRun2(""),
    m_fJvtConfigRun3(""),
    m_JMScalib(false),
    //
    m_orDoTau(false),
    m_orDoPhoton(false),
    m_orDoEleJet(true),
    m_orDoElEl(false),
    m_orDoElMu(false),
    m_orDoMuonJet(true),
    m_orDoBjet(false),
    m_orDoElBjet(true),
    m_orDoMuBjet(true),
    m_orDoTauBjet(true),
    m_orDoBoostedElectron(false),
    m_orBoostedElectronC1(-999.), // set to positive value to activate
    m_orBoostedElectronC2(-999.), // set to positive value to activate
    m_orBoostedElectronMaxConeSize(-999.), // set to positive value to activate
    m_orDoBoostedMuon(true),
    m_orBoostedMuonC1(-999.), // set to positive value to activate
    m_orBoostedMuonC2(-999.), // set to positive value to activate
    m_orBoostedMuonMaxConeSize(-999.), // set to positive value to activate
    m_orApplyRelPt(false),
    m_orMuJetPtRatio(-999.),
    m_orMuJetTrkPtRatio(-999.),
    m_orMuJetInnerDR(-999),
    m_orDoMuonJetGhostAssociation(true),
    m_orRemoveCaloMuons(true),
    m_orBtagWP(""),
    m_orInputLabel(""),
    m_orPhotonFavoured(false),
    m_orBJetPtUpperThres(-999.),
    m_orLinkOverlapObjects(false),
    m_orDoFatjets(false),
    m_EleFatJetDR(-999.),
    m_JetFatJetDR(-999.),
    m_doIsoSignal(true),
    m_doElIsoSignal(true),
    m_doPhIsoSignal(true),
    m_doMuIsoSignal(true),
 
    m_useSigLepForIsoCloseByOR(false),
    m_IsoCloseByORpassLabel(""),
 
    m_useTRUTH3(true),
 
    m_slices(std::map<std::string,bool>()),
    m_isRun3(false),
    m_isPHYSLITE(false),
 
    m_metJetSelection(""),
    m_fatJets(""),
    //
    m_currentSyst(),
    m_fatjetFFSmearingSyst(),
    m_EG_corrModel(""),
    m_EG_corrFNList(""),
    m_applyJVTCut(true),
    //
    // set toolhandles empty by default
    m_jetCalibTool(""),
    m_jetFatCalibTool(""),
    m_jetUncertaintiesTool(""),
    m_jetUncertaintiesPDSmearTool(""),
    m_fatjetUncertaintiesTool(""),
    m_fatjetUncertaintiesPDSmearTool(""),
    m_fatjetFFSmearingTool(""),
    m_jetCleaningTool(""),
    m_jetPileupLabelingTool(""),
    m_jetJvtMomentTool(""),
    m_jetNNJvtMomentTool(""),
    m_jetNNJvtSelectionTool(""),
    m_jetNNJvtEfficiencyTool(""),
    m_jetfJvtSelectionTool(""),
    m_jetfJvtEfficiencyTool(""),    
    //
    m_WTaggerTool(""),
    m_ZTaggerTool(""),
    m_TopTaggerTool(""),
    m_jetTruthLabelingTool(""),
    m_WTagjetUncertaintiesTool(""),
    m_ZTagjetUncertaintiesTool(""),
    m_TopTagjetUncertaintiesTool(""),
    //
    m_muonSelectionTool(""),
    m_muonSelectionHighPtTool(""),
    m_muonSelectionToolBaseline(""),
    m_muonCalibTool(""),
    m_muonEfficiencySFTool(""),
    m_muonEfficiencyBMHighPtSFTool(""),
    m_muonTTVAEfficiencySFTool(""),
    m_muonIsolationSFTool(""),
    m_muonHighPtIsolationSFTool(""),
    m_muonTriggerSFTool(""),
    //
    m_elecEfficiencySFTool_reco(""),
    m_elecEfficiencySFTool_id(""),
    m_elecEfficiencySFTool_trig_singleLep(""),
    m_elecEfficiencySFTool_trigEff_singleLep(""),
    m_elecEfficiencySFTool_iso(""),
    m_elecEfficiencySFTool_isoHighPt(""),
    //
    m_egammaCalibTool(""),
    m_elecSelLikelihood(""),
    m_elecSelLikelihoodBaseline(""),
    m_photonSelIsEM(""),
    m_photonSelIsEMBaseline(""),
    m_photonEfficiencySFTool(""),
    m_photonIsolationSFTool(""),
    m_photonTriggerSFTool(""),
    m_egammaAmbiguityTool(""),
    m_elecChargeIDSelectorTool(""),
    m_elecChargeEffCorrTool(""),
    //
    m_tauSelTool(""),
    m_tauSelToolBaseline(""),
    m_tauSmearingTool(""),
    m_tauTruthMatch(""),
    m_tauEffTool(""),
    //
    m_btagEffTool(""),
    m_btagSelTool(""),
    m_btagSelTool_OR(""),
    m_btagEffTool_trkJet(""),
    m_btagSelTool_trkJet(""),
    //
    m_metMaker(""),
    m_metSystTool(""),
    m_metSignif(""),
    //
    m_trig2015combination_singleLep(""),
    m_trig2016combination_singleLep(""),
    m_trig2017combination_singleLep(""),
    m_trig2018combination_singleLep(""),
    m_trig2022combination_singleLep(""),
    m_trigNToys_diLep(-99),
    m_trig2015combination_diLep(""),
    m_trig2016combination_diLep(""),
    m_trig2017combination_diLep(""),
    m_trig2018combination_diLep(""),
    m_trig2022combination_diLep(""),
    m_trigGlobalEffCorrTool_diLep(""),
    m_trigNToys_multiLep(-99),
    m_trig2015combination_multiLep(""),
    m_trig2016combination_multiLep(""),
    m_trig2017combination_multiLep(""),
    m_trig2018combination_multiLep(""),
    m_trig2022combination_multiLep(""),
    m_trigGlobalEffCorrTool_multiLep(""),
    m_trigNToys_diPhoton(-99),
    m_trig2015combination_diPhoton(""),
    m_trig2016combination_diPhoton(""),
    m_trig2017combination_diPhoton(""),
    m_trig2018combination_diPhoton(""),
    m_trig2022combination_diPhoton(""),
    m_trigGlobalEffCorrTool_diPhoton(""),
    m_trigConfTool(""),
    m_trigDecTool(""),
    m_trigMatchingTool(""),
    m_trigMatchScoringTool(""),
    m_trigDRScoringTool(""),
    //
    m_isoCorrTool(""),
    m_isoTool(""),
    //disable m_isoToolLowPtPLV(""),
    m_isoBaselineTool(""),
    m_isoHighPtTool(""),
    //
    m_prwTool(""),
    //
    m_LRTuncTool(""),
    //
    m_orToolbox("ORToolbox",this),
    //
    m_pmgSHnjetWeighter(""),
    m_pmgSHnjetWeighterWZ(""),
    //
    m_acc_eleIdBaseline("DFCommonElectronsLHLooseBL"),
    m_acc_eleId("DFCommonElectronsLHTight"),
    m_acc_photonIdBaseline("DFCommonPhotonsIsEMTight"),
    m_acc_photonId("DFCommonPhotonsIsEMTight"),
    //
    m_acc_jetClean("DFCommonJets_jetClean_LooseBad")
{
  //General settings
  declareProperty( "DataSource", m_dataSource = Undefined );
  declareProperty( "DebugMode",  m_debug );
  declareProperty( "ConfigFile",  m_configFile = "SUSYTools/SUSYTools_Default.conf" );
  //Overlap Removal
  declareProperty( "DoTauOR",       m_orDoTau );
  declareProperty( "DoPhotonOR",    m_orDoPhoton );
  declareProperty( "DoEleJetOR",    m_orDoEleJet );
  declareProperty( "DoElElOR",    m_orDoElEl );
  declareProperty( "DoElMuOR",    m_orDoElMu );
  declareProperty( "DoMuonJetOR",   m_orDoMuonJet );
  declareProperty( "DoBjetOR",      m_orDoBjet );
  declareProperty( "DoElBjetOR",    m_orDoElBjet );
  declareProperty( "DoMuBjetOR",    m_orDoMuBjet );
  declareProperty( "DoTauBjetOR",    m_orDoTauBjet );
  declareProperty( "UseBtagging",   m_useBtagging );
  declareProperty( "UseBtaggingTrkJet",   m_useBtagging_trkJet );
  declareProperty( "DoBoostedElectronOR", m_orDoBoostedElectron );
  declareProperty( "BoostedElectronORC1", m_orBoostedElectronC1 );
  declareProperty( "BoostedElectronORC2", m_orBoostedElectronC2 );
  declareProperty( "BoostedElectronORMaxConeSize", m_orBoostedElectronMaxConeSize );
  declareProperty( "DoBoostedMuonOR", m_orDoBoostedMuon );
  declareProperty( "BoostedMuonORC1", m_orBoostedMuonC1 );
  declareProperty( "BoostedMuonORC2", m_orBoostedMuonC2 );
  declareProperty( "BoostedMuonORMaxConeSize", m_orBoostedMuonMaxConeSize );
  declareProperty( "ORDoMuonJetGhostAssociation", m_orDoMuonJetGhostAssociation );
  declareProperty( "ORRemoveCaloMuons", m_orRemoveCaloMuons );
  declareProperty( "ORMuJetApplyRelPt", m_orApplyRelPt);
  declareProperty( "ORMuJetPtRatio", m_orMuJetPtRatio);
  declareProperty( "ORMuJetInnerDR", m_orMuJetInnerDR );
  declareProperty( "ORJetTrkPtRatio", m_orMuJetTrkPtRatio);
  declareProperty( "ORInputLabel", m_orInputLabel);
  declareProperty( "ORPhotonFavoured", m_orPhotonFavoured);
  declareProperty( "ORBJetPtUpperThres", m_orBJetPtUpperThres);
  declareProperty( "ORLinkOverlapObjects", m_orLinkOverlapObjects);
 
  declareProperty( "DoFatJetOR", m_orDoFatjets);
  declareProperty( "OREleFatJetDR", m_EleFatJetDR);
  declareProperty( "ORJetFatJetDR", m_JetFatJetDR);
  declareProperty( "TriggerUpstreamMatching", m_upstreamTriggerMatching, "Use alternative trigger matching tool based on upstream (in-derivation) matching");
  declareProperty( "TriggerMatchingPrefix", m_trigMatchingPrefix, "Prefix for trigger matching containers (Analysis for PHSYLITE derivations");
 
  //--- Object definitions
  //MET
  declareProperty( "METEleTerm",     m_eleTerm   );
  declareProperty( "METGammaTerm",   m_gammaTerm );
  declareProperty( "METTauTerm",     m_tauTerm   );
  declareProperty( "METJetTerm",     m_jetTerm   );
  declareProperty( "METMuonTerm",    m_muonTerm  );
  declareProperty( "METInputSuffix", m_inputMETSuffix );
  declareProperty( "METOutputTerm",  m_outMETTerm );
  declareProperty( "METDoTrkSyst",   m_trkMETsyst  );
  declareProperty( "METDoCaloSyst",  m_caloMETsyst );
  declareProperty( "METDoTrkJetSyst",  m_trkJetsyst );
  declareProperty( "METJetSelection",  m_metJetSelection );
  declareProperty( "METSysConfigPrefix",  m_metsysConfigPrefix );
 
  declareProperty( "METRemoveORCaloTaggedMuons", m_metRemoveOverlappingCaloTaggedMuons);
  declareProperty( "METDoSetMuonJetEMScale", m_metDoSetMuonJetEMScale);
  declareProperty( "METDoRemoveMuonJets",  m_metDoRemoveMuonJets );
  declareProperty( "METUseGhostMuons",  m_metUseGhostMuons );
  declareProperty( "METDoMuonEloss",  m_metDoMuonEloss );
  declareProperty( "METDoGreedyPhotons",  m_metGreedyPhotons );
  declareProperty( "METDoVeryGreedyPhotons",  m_metVeryGreedyPhotons );
 
 
  declareProperty( "SoftTermParam",  m_softTermParam);
  declareProperty( "TreatPUJets",  m_treatPUJets);
  declareProperty( "DoPhiReso",  m_doPhiReso);
 
  //JETS
  declareProperty( "JetInputType",  m_jetInputType );
 
  declareProperty( "FwdJetDoJVT",  m_doFwdJVT );
 
  declareProperty( "JetJMSCalib",  m_JMScalib );
  declareProperty( "JetLargeRcollection",  m_fatJets );
 
  //BTAGGING
  declareProperty( "BtagTagger", m_BtagTagger);
  declareProperty( "BtagWPOR", m_orBtagWP); //the one used in the Overlap Removal
  declareProperty( "BtagWP", m_BtagWP);     //the one used in FillJet() afterwards
  declareProperty( "BtagMinPt", m_BtagMinPt);    // minimum jetPt cut (MR31061) >=20 GeV EM jets & >=10 GeV TrackJets (not calibrated below)
  declareProperty( "BtagKeyOverride", m_BtagKeyOverride); 
  declareProperty( "BtagCalibPath", m_bTaggingCalibrationFilePath);
  declareProperty( "BtagTaggerTrkJet", m_BtagTagger_trkJet);
  declareProperty( "BtagMinPtTrkJet", m_BtagMinPt_trkJet);    // minimum jetPt cut (MR31061) >=20 GeV EM jets & >=10 GeV TrackJets (not calibrated below)
  declareProperty( "BtagWPTrkJet", m_BtagWP_trkJet);  //the one used in FillTrackJet() afterwards
  //ELECTRONS
  declareProperty( "EleBaselinePt", m_eleBaselinePt);
  declareProperty( "ElePt", m_elePt);
  declareProperty( "EleBaselineEta", m_eleBaselineEta);
  declareProperty( "EleEta", m_eleEta);
  declareProperty( "EleBaselineId", m_eleIdBaseline);
  declareProperty( "EleBaselineConfig", m_eleConfigBaseline);
  declareProperty( "EleBaselineCrackVeto", m_eleBaselineCrackVeto);
  declareProperty( "EleId", m_eleId);
  declareProperty( "EleConfig", m_eleConfig);
  declareProperty( "EleIso", m_eleIso_WP);
  declareProperty( "EleIsoHighPt", m_eleIsoHighPt_WP);
  declareProperty( "EleIsoHighPtThresh", m_eleIsoHighPtThresh);
  declareProperty( "EleCFT", m_eleChID_WP);
  declareProperty( "EleCFTIso", m_eleChIso);
  declareProperty( "EleCFTSignal", m_eleChID_signal);
  declareProperty( "EleD0sig", m_eled0sig);
  declareProperty( "EleZ0", m_elez0);
  declareProperty( "EleBaselineD0sig", m_elebaselined0sig);
  declareProperty( "EleBaselineZ0", m_elebaselinez0);
  declareProperty( "EleCrackVeto", m_eleCrackVeto);
  declareProperty( "EleForceNoId", m_force_noElId );
  declareProperty( "EleEffMapFilePath", m_eleEffMapFilePath);
  declareProperty( "EleAllowRun3TrigSFFallback", m_eleAllowRun3TrigSFFallback);
  declareProperty( "EleForceFullSimCalib", m_eleForceFullSimCalib);
 
  //MUONS
  declareProperty( "MuonBaselinePt", m_muBaselinePt);
  declareProperty( "MuonPt", m_muPt);
  declareProperty( "MuonBaselineEta", m_muBaselineEta);
  declareProperty( "MuonEta", m_muEta);
  declareProperty( "MuonBaselineId", m_muIdBaseline);
  declareProperty( "MuonId", m_muId);
  declareProperty( "MuonIso", m_muIso_WP);
  declareProperty( "MuonIsoHighPt", m_muIsoHighPt_WP);
  declareProperty( "MuonIsoHighPtThresh", m_muIsoHighPtThresh);
  declareProperty( "MuonHighPtExtraSmear", m_muHighPtExtraSmear);
  declareProperty( "MuonEffCorrForce1D", m_muEffCorrForce1D);
  declareProperty( "MuonD0sig", m_mud0sig);
  declareProperty( "MuonZ0", m_muz0);
  declareProperty( "MuonBaselineD0sig", m_mubaselined0sig);
  declareProperty( "MuonBaselineZ0", m_mubaselinez0);
  declareProperty( "MuonRequireHighPtCuts",  m_murequirepassedHighPtCuts);
  declareProperty( "MuonForceNoId", m_force_noMuId );
  declareProperty( "MuonTTVASF", m_doTTVAsf );
  declareProperty( "MuonCalibrationMode", m_muCalibrationMode);
  //MUONS TRIGGER SCALE FACTOR
  declareProperty( "MuonTriggerSFCalibRelease",   m_muTriggerSFCalibRelease  );
  declareProperty( "MuonTriggerSFCalibFilename",  m_muTriggerSFCalibFilename );
  //PHOTONS
  declareProperty( "PhotonBaselinePt", m_photonBaselinePt);
  declareProperty( "PhotonPt", m_photonPt);
  declareProperty( "PhotonBaselineEta", m_photonBaselineEta);
  declareProperty( "PhotonEta", m_photonEta);
  declareProperty( "PhotonBaselineId", m_photonIdBaseline);
  declareProperty( "PhotonId", m_photonId);
  declareProperty( "PhotonIso", m_photonIso_WP);
  declareProperty( "PhotonTriggerName", m_photonTriggerName);
  declareProperty( "PhotonBaselineCrackVeto", m_photonBaselineCrackVeto);
  declareProperty( "PhotonCrackVeto", m_photonCrackVeto);
  declareProperty( "PhotonAllowLate", m_photonAllowLate);
 
  //TAUS
  declareProperty( "TauBaselineId", m_tauIdBaseline);
  declareProperty( "TauId", m_tauId);
  declareProperty( "TauIdConfigPathBaseline", m_tauConfigPathBaseline);
  declareProperty( "TauIdConfigPath", m_tauConfigPath);
  declareProperty( "TauDoTruthMatching", m_tauDoTTM);
  declareProperty( "TauSmearingToolRecommendationTag", m_tauSmearingToolRecommendationTag);
  declareProperty( "TauSmearingToolGenerator", m_tauSmearingToolGenerator);
  declareProperty( "TauEffToolRecommendationTag", m_tauEffToolRecommendationTag);
  declareProperty( "TauMVATESQualityCheck", m_ApplyMVATESQualityCheck);
 
  //Leptons
  declareProperty( "SigLepRequireIso", m_doIsoSignal ); //leave here for back-compatibility
  declareProperty( "SigElRequireIso", m_doElIsoSignal );
  declareProperty( "SigMuRequireIso", m_doMuIsoSignal );
  declareProperty( "SigPhRequireIso", m_doPhIsoSignal );
 
  //Isolation correction for leptons and photons
  declareProperty( "UseSigLepForIsoCloseByOR", m_useSigLepForIsoCloseByOR );
  declareProperty( "IsoCloseByORpassLabel", m_IsoCloseByORpassLabel );
 
  //Truth
  declareProperty( "UseTRUTH3", m_useTRUTH3 ); // true if using TRUTH3 type containers
 
  //--- Tools configuration
  //PRW
  declareProperty( "AutoconfigurePRWTool", m_autoconfigPRW );
  declareProperty( "AutoconfigurePRWToolPath", m_autoconfigPRWPath ); // e.g. dev/PileupReweighting/share/
  declareProperty( "AutoconfigurePRWToolFile", m_autoconfigPRWFile ); // e.g. DSID407xxx/pileup_mc16a_dsid407352_FS.root
  declareProperty( "AutoconfigurePRWToolCombinedmode", m_autoconfigPRWCombinedmode );
  declareProperty( "AutoconfigurePRWToolRPVmode", m_autoconfigPRWRPVmode );
  declareProperty( "AutoconfigurePRWToolRtags", m_autoconfigPRWRtags );
  declareProperty( "mcCampaign",           m_mcCampaign );
  declareProperty( "mcChannel",            m_mcChannel );
  declareProperty( "PRWConfigFiles",       m_prwConfFiles );
  declareProperty( "PRWLumiCalcFiles",     m_prwLcalcFiles );
  declareProperty( "PRWActualMu2017File",  m_prwActualMu2017File );
  declareProperty( "PRWActualMu2018File",  m_prwActualMu2018File );
  declareProperty( "PRWActualMu2022File",  m_prwActualMu2022File );
  declareProperty( "PRWActualMu2023File",  m_prwActualMu2023File );
  declareProperty( "PRWActualMu2024File",  m_prwActualMu2024File );
  declareProperty( "PRWDataScaleFactor",   m_prwDataSF);
  declareProperty( "PRWDataScaleFactorUP", m_prwDataSF_UP);
  declareProperty( "PRWDataScaleFactorDOWN", m_prwDataSF_DW);
  declareProperty( "PRWUseRunDependentPrescaleWeight", m_runDepPrescaleWeightPRW);
  declareProperty( "PRWUseCommonMCFiles", m_useCommonPRWFiles);
  declareProperty( "PRWCommonFileMC20a", m_commonPRWFileMC20a);
  declareProperty( "PRWCommonFileMC20d", m_commonPRWFileMC20d);
  declareProperty( "PRWCommonFileMC20e", m_commonPRWFileMC20e);
  declareProperty( "PRWCommonFileMC21a", m_commonPRWFileMC21a);
  declareProperty( "PRWCommonFileMC23a", m_commonPRWFileMC23a);
  declareProperty( "PRWCommonFileMC23c", m_commonPRWFileMC23c);
  declareProperty( "PRWCommonFileMC23d", m_commonPRWFileMC23d);
  declareProperty( "PRWCommonFileMC23e", m_commonPRWFileMC23e);
  //LargeR uncertainties config, as from https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/JetUncertainties2016PrerecLargeR#Understanding_which_configuratio
  declareProperty( "JetLargeRuncConfig",  m_fatJetUncConfig );
  declareProperty( "JetLargeRuncVars",  m_fatJetUncVars );
  declareProperty( "JetWtaggerConfig",  m_WtagConfig );
  declareProperty( "JetZtaggerConfig",  m_ZtagConfig );
  declareProperty( "JetWZTaggerCalibArea",  m_WZTaggerCalibArea );
  declareProperty( "JetToptaggerConfig",  m_ToptagConfig );
  declareProperty( "JetTruthLabelName",  m_JetTruthLabelName );
  declareProperty( "JetTopTaggerCalibArea",  m_TopTaggerCalibArea );
  declareProperty( "JetWTaguncConfig",  m_WTagUncConfig );
  declareProperty( "JetZTaguncConfig",  m_ZTagUncConfig );
  declareProperty( "JetTopTaguncConfig",  m_TopTagUncConfig );
  //Btagging MCtoMC SFs
  declareProperty( "ShowerType",    m_showerType = 0 );
  //Egamma NP correlation model
  declareProperty( "EleEffNPcorrModel", m_EG_corrModel );
  //Egamma correction file list override
  declareProperty( "EleEffCorrFNList", m_EG_corrFNList );
  declareProperty( "IsRun3", m_isRun3 );
  declareProperty( "IsPHYSLITE", m_isPHYSLITE );
 
  //For electron trigger SF tools
  declareProperty( "ElectronTriggerSFStringSingle",      m_electronTriggerSFStringSingle);
 
  //--- Tool pointers    /MT : we may want to improve the descriptions :)
  m_jetCalibTool.declarePropertyFor( this, "JetCalibTool", "The JetCalibTool" );
  m_jetFatCalibTool.declarePropertyFor( this, "FatJetCalibTool", "The JetCalibTool for large-R jets" );
  m_jetUncertaintiesTool.declarePropertyFor( this, "JetUncertaintiesTool", "The JetUncertaintiesTool" );
  m_jetUncertaintiesPDSmearTool.declarePropertyFor( this, "JetPDSmearUncertaintiesTool", "The JetPDSmearUncertaintiesTool" );
  m_fatjetUncertaintiesTool.declarePropertyFor( this, "FatJetUncertaintiesTool", "The JetUncertaintiesTool for large-R jets" );
  m_fatjetUncertaintiesPDSmearTool.declarePropertyFor( this, "FatJetPDSmearUncertaintiesTool", "The FatJetPDSmearUncertaintiesTool" );
  m_fatjetFFSmearingTool.declarePropertyFor( this, "FatJetFFSmearingTool", "The FFSmearingTool for large-R jets" );
  m_WTagjetUncertaintiesTool.declarePropertyFor( this, "WJetUncertaintiesTool", "The JetUncertaintiesTool for large-R W-tagged jets" );
  m_ZTagjetUncertaintiesTool.declarePropertyFor( this, "ZJetUncertaintiesTool", "The JetUncertaintiesTool for large-R Z-tagged jets" );
  m_TopTagjetUncertaintiesTool.declarePropertyFor( this, "TopJetUncertaintiesTool", "The JetUncertaintiesTool for large-R Top-tagged jets" );
  m_jetCleaningTool.declarePropertyFor( this, "JetCleaningTool", "The JetCleaningTool" );
  m_jetPileupLabelingTool.declarePropertyFor( this, "JetPileupLabelingTool", "The JetPileupLabelingTool" );
  m_jetJvtMomentTool.declarePropertyFor( this, "JetJvtMomentTool", "The JetJvtMomentTool" );
  m_jetNNJvtMomentTool.declarePropertyFor( this, "JetNNJvtMomentTool", "The JetNNJvtMomentTool" );
  m_jetNNJvtSelectionTool.declarePropertyFor( this, "JetNNJvtSelectionTool", "The JetNNJvtSelectionTool" );
  m_jetNNJvtEfficiencyTool.declarePropertyFor( this, "JetNNJvtEfficiencyTool", "The JetNNJvtEfficiencyTool" );
  m_jetfJvtSelectionTool.declarePropertyFor( this, "JetfJvtSelectionTool", "The JetfJvtSelectionTool" );
  m_jetfJvtEfficiencyTool.declarePropertyFor( this, "JetfJvtEfficiencyTool", "The JetfJvtEfficiencyTool" );
  //
  m_WTaggerTool.declarePropertyFor( this, "WTaggerTool", "The SmoothedWZTaggerTool" );
  m_ZTaggerTool.declarePropertyFor( this, "ZTaggerTool", "The SmoothedWZTaggerTool" );
  m_TopTaggerTool.declarePropertyFor( this, "TopTaggerTool", "The DNNTopTaggerTool" );
  m_jetTruthLabelingTool.declarePropertyFor( this, "JetTruthLabelingTool", "The JetTruthLabelingTool" );
  //
  m_muonSelectionTool.declarePropertyFor( this, "MuonSelectionTool", "The MuonSelectionTool for signal muons" );
  m_muonSelectionHighPtTool.declarePropertyFor( this, "MuonSelectionHighPtTool", "The MuonSelectionTool for signal muons (HighPt WP)" );
  m_muonSelectionToolBaseline.declarePropertyFor( this, "MuonSelectionToolBaseline", "The MuonSelectionTool for baseline muons" );
  m_muonCalibTool.declarePropertyFor( this, "MuonCalibTool", "The MuonCalibTool" );
  m_muonEfficiencySFTool.declarePropertyFor( this, "MuonEfficiencyScaleFactorsTool", "The MuonEfficiencySFTool" );
  m_muonEfficiencyBMHighPtSFTool.declarePropertyFor( this, "MuonBadMuonHighPtScaleFactorsTool", "The MuonBadMuonHighPtSFTool" );
  m_muonTTVAEfficiencySFTool.declarePropertyFor( this, "MuonTTVAEfficiencyScaleFactorsTool", "The MuonTTVAEfficiencySFTool" );
  m_muonIsolationSFTool.declarePropertyFor( this, "MuonIsolationScaleFactorsTool", "The MuonIsolationSFTool" );
  m_muonHighPtIsolationSFTool.declarePropertyFor( this, "MuonHighPtIsolationScaleFactorsTool", "The MuonIsolationSFTool" );
  m_muonTriggerSFTool.declarePropertyFor( this, "MuonTriggerScaleFactorsTool", "The MuonTriggerSFTool" );
  m_muonLRTORTool.declarePropertyFor( this, "MuonLRTOverlapRemovalTool", "Prompt/LRT muon OR Tool" );
  //
  m_elecEfficiencySFTool_reco.declarePropertyFor( this, "ElectronEfficiencyCorrectionTool_reco", "The ElectronEfficiencyCorrectionTool for reconstruction SFs" );
  m_elecEfficiencySFTool_trig_singleLep.declarePropertyFor( this, "ElectronEfficiencyCorrectionTool_trig_singleLep", "The ElectronEfficiencyCorrectionTool for single-e triggers" );
  m_elecEfficiencySFTool_id.declarePropertyFor( this, "ElectronEfficiencyCorrectionTool_id", "The ElectronEfficiencyCorrectionTool for ID SFs" );
  m_elecEfficiencySFTool_iso.declarePropertyFor( this, "ElectronEfficiencyCorrectionTool_iso" , "The ElectronEfficiencyCorrectionTool for iso SFs" );
  m_elecEfficiencySFTool_isoHighPt.declarePropertyFor( this, "ElectronEfficiencyCorrectionTool_isoHigPt" , "The ElectronEfficiencyCorrectionTool for iso high-pt SFs" );
  m_elecSelLikelihood.declarePropertyFor( this, "ElectronLikelihoodTool" , "The ElectronSelLikelihoodTool for signal electrons" );
  m_elecSelLikelihoodBaseline.declarePropertyFor( this, "ElectronLikelihoodToolBaseline" , "The ElectronSelLikelihoodTool for baseline electrons" );
  m_egammaAmbiguityTool.declarePropertyFor( this, "EgammaAmbiguityTool", "The EgammaAmbiguityTool" );
  m_elecChargeIDSelectorTool.declarePropertyFor( this, "ElectronChargeIDSelectorTool", "The ElectronChargeIDSelectorTool" );
  m_elecChargeEffCorrTool.declarePropertyFor( this, "ElectronChargeEffCorrectionTool", "The ElectronChargeEffCorrectionTool" );
  m_elecLRTORTool.declarePropertyFor( this, "ElectronLRTOverlapRemovalTool", "Prompt/LRT electron OR Tool" );
  //
  m_photonSelIsEM.declarePropertyFor( this, "PhotonIsEMSelector" , "The PhotonIsEMSelectorTool for signal photons" );
  m_photonSelIsEMBaseline.declarePropertyFor( this, "PhotonIsEMSelectorBaseline" , "The PhotonIsEMSelectorTool for baseline photons" );
  m_photonEfficiencySFTool.declarePropertyFor( this, "PhotonEfficiencyCorrectionTool", "The PhotonEfficiencyCorrectionTool for reco SFs" );
  m_photonIsolationSFTool.declarePropertyFor( this, "PhotonIsolationCorrectionTool", "The PhotonEfficiencyCorrectionTool for iso SFs" );
  m_photonTriggerSFTool.declarePropertyFor( this, "PhotonTriggerEfficiencyCorrectionTool", "The PhotonEfficiencyCorrectionTool for trigger SFs" );
  //
  m_egammaCalibTool.declarePropertyFor( this, "EgammaCalibrationAndSmearingTool", "The EgammaCalibrationAndSmearingTool");
  //
  m_tauSelTool.declarePropertyFor( this, "TauSelectionTool", "The TauSelectionTool for signal taus" );
  m_tauSelToolBaseline.declarePropertyFor( this, "TauSelectionToolBaseline", "The TauSelectionTool for baseline taus" );
  m_tauSmearingTool.declarePropertyFor( this, "TauSmearingTool", "The TauSmearingTool" );
  m_tauTruthMatch.declarePropertyFor( this, "TauTruthMatch", "The TTMT" );
  m_tauEffTool.declarePropertyFor( this, "TauEfficiencyCorrectionsTool", "The TauEfficiencyCorrectionsTool" );
  //
  m_btagEffTool.declarePropertyFor( this, "BTaggingEfficiencyTool", "The BTaggingEfficiencyTool" );
  m_btagSelTool.declarePropertyFor( this, "BTaggingSelectionTool", "The main BTaggingSelectionTool" );
  m_btagSelTool_OR.declarePropertyFor( this, "BTaggingSelectionTool_OR", "The BTaggingSelectionTool used to select b-jets for overlap removal" );
  m_btagEffTool_trkJet.declarePropertyFor( this, "BTaggingEfficiencyTool_trkJet", "The BTaggingEfficiencyTool for track jets" );
  m_btagSelTool_trkJet.declarePropertyFor( this, "BTaggingSelectionTool_trkJet", "The main BTaggingSelectionTool for track jets" );
  //
  m_metMaker.declarePropertyFor( this, "METMaker", "The METMaker instance");
  m_metSystTool.declarePropertyFor( this, "METSystTool", "The METSystematicsTool");
  m_metSignif.declarePropertyFor( this, "METSignificance", "The METSignifiance instance");
  //
  m_trigGlobalEffCorrTool_diLep.declarePropertyFor( this, "TrigGlobalEfficiencyCorrection_diLep", "The TrigGlobalEfficiencyCorrection tool for dilepton" );
  m_trigGlobalEffCorrTool_multiLep.declarePropertyFor( this, "TrigGlobalEfficiencyCorrection_multiLep", "The TrigGlobalEfficiencyCorrection tool for trilepton" );
  m_trigGlobalEffCorrTool_diPhoton.declarePropertyFor( this, "TrigGlobalEfficiencyCorrection_diPhoton", "The TrigGlobalEfficiencyCorrection tool for asymmetric diphoton" );
  m_trigConfTool.declarePropertyFor( this, "TrigConfigTool", "The TrigConfigTool" );
  m_trigDecTool.declarePropertyFor( this, "TrigDecisionTool", "The TrigDecisionTool" );
  m_trigMatchingTool.declarePropertyFor( this, "TrigMatchTool", "The TrigMatchingTool" );
  m_trigMatchScoringTool.declarePropertyFor( this, "TrigMatchScoringTool", "The TrigMatchScoringTool" );
  m_trigDRScoringTool.declarePropertyFor( this, "TrigDRScoringTool", "The TrigDRScoringTool" );
  //
  m_isoCorrTool.declarePropertyFor( this, "IsolationCorrectionTool", "The IsolationCorrectionTool" );
  m_isoTool.declarePropertyFor( this, "IsolationSelectionTool", "The IsolationSelectionTool");
  //disable m_isoToolLowPtPLV.declarePropertyFor( this, "IsolationLowPtPLVTool", "The IsolationLowPtPLVTool");
  m_isoBaselineTool.declarePropertyFor( this, "IsolationSelectionTool_Baseline", "The IsolationSelectionTool for baseline objects");
  m_isoHighPtTool.declarePropertyFor( this, "IsolationSelectionTool_HighPt", "The IsolationSelectionTool for High Pt");
  m_isoCloseByTool.declarePropertyFor( this, "IsolationCloseByCorrectionTool", "The IsolationCloseByCorrectionTool");
  //
  m_prwTool.declarePropertyFor( this, "PileupReweightingTool", "The PRW tool" );
  //
  m_LRTuncTool.declarePropertyFor( this, "InclusiveTrackFilterTool", "The LRT uncertainty tool"); 
  //
  m_pmgSHnjetWeighter.declarePropertyFor( this, "PMGSHVjetReweightTool", "The PMGSHVjetReweightTool (AntiKt4TruthJets)" );
  m_pmgSHnjetWeighterWZ.declarePropertyFor( this, "PMGSHVjetReweightWZTool", "The PMGSHVjetReweightTool (AntiKt4TruthWZJets)" );
  //
  m_tauJetORtool.declarePropertyFor( this, "TauJetOverlapTool", "The TauJetOverlapTool");
  //disable m_orToolbox.declarePropertyFor( this, "OverlapRemovalTool", "The overlap removal tool");
 
  //load supported WPs (by tightness order)
  m_el_id_support.push_back("VeryLooseNoPix");    // WPs for LRT Electron
  m_el_id_support.push_back("VeryLooseLLH");
  m_el_id_support.push_back("LooseNoPix");        // WPs for LRT Electron
  m_el_id_support.push_back("LooseLLH");
  m_el_id_support.push_back("LooseAndBLayerLLH");
  m_el_id_support.push_back("LooseDNNnoCF");
  m_el_id_support.push_back("LooseDNN");
  m_el_id_support.push_back("MediumNoPix");       // WPs for LRT Electron
  m_el_id_support.push_back("MediumLLH");
  m_el_id_support.push_back("MediumDNNnoCF");
  m_el_id_support.push_back("MediumDNN");
  m_el_id_support.push_back("TightNoPix");        // WPs for LRT Electron
  m_el_id_support.push_back("TightLLH");
  m_el_id_support.push_back("TightDNNnoCF");
  m_el_id_support.push_back("TightDNN");
 
  m_ph_id_support.push_back("Loose");
  m_ph_id_support.push_back("Medium");
  m_ph_id_support.push_back("Tight");
  m_ph_id_support.push_back("TightPtIncl"); // Should not be mixed with Tight
 
  m_mu_id_support = 4; //maximum value supported
 
  // Tau ID WPs
  m_tau_id_support.push_back("rnn001");
  m_tau_id_support.push_back("VeryLoose");
  m_tau_id_support.push_back("Loose");
  m_tau_id_support.push_back("Medium");
  m_tau_id_support.push_back("Tight");
 
  // Iso WPs
  // -- see https://twiki.cern.ch/twiki/bin/view/AtlasProtected/RecommendedIsolationWPs#Current_official_working_points
  // -- the el iso points are those which have (or will have) SFs available
  m_el_iso_support = {
     "FCLoose", "FCTight",                             // current WPs
     "FCHighPtCaloOnly",                               // current HighPtCaloOnly WPs
     "Gradient",                                       //
     "HighPtCaloOnly",                                 //
     "TightTrackOnly_VarRad","TightTrackOnly_FixedRad",//
     "Tight_VarRad","Loose_VarRad",                    //
     "PLVLoose", "PLVTight",                           // PLV recommended WPs, fallback support below b/o SFs and & egamma map file
     "PLImprovedTight", "PLImprovedVeryTight"          // New PLIV WPs, fallback support below b/o SFs & egamma map file
  };
  // -- the muon iso points are those which have SFs available
  // -- more details https://indico.cern.ch/event/878781/contributions/3721998/attachments/1976194/3289315/20200127_IFFshort_2.pdf
  m_mu_iso_support = {
     "PflowLoose_FixedRad", "PflowLoose_VarRad", "PflowTight_FixedRad", "PflowTight_VarRad",  // PFlow (new naming) recommended WPs
     "TightTrackOnly_FixedRad", "TightTrackOnly_VarRad", "HighPtTrackOnly",                   // TrackOnly (new naming) recommended WPs
     "PLVLoose", "PLVTight",                                                                  // PLV recommended WPs
     "Loose_VarRad", "Loose_FixedRad", "Tight_VarRad", "Tight_FixedRad",                      // Other WPs (new naming)
     "PLImprovedTight", "PLImprovedVeryTight"                                                 // New PLIV WPs, fallback support below b/o SFs
  };
 
  // Construct electron fallback WPs for SFs
  for (const auto& x : m_el_iso_support) { m_el_iso_fallback[x] = x; } // all current WPs
  m_el_iso_fallback["PLVTight"] = "FCTight";                    // plus actual fallback
  m_el_iso_fallback["PLVLoose"] = "FCLoose";
  m_el_iso_fallback["PLImprovedTight"] = "FCTight";
  m_el_iso_fallback["PLImprovedVeryTight"] = "FCTight";
  m_el_iso_fallback["HighPtCaloOnly"] = "FCHighPtCaloOnly";
  m_el_iso_fallback["TightTrackOnly_VarRad"] = "FCTight";
  m_el_iso_fallback["TightTrackOnly_FixedRad"] = "FCTight";
  m_el_iso_fallback["Tight_VarRad"] = "FCTight";
  m_el_iso_fallback["Loose_VarRad"] = "FCLoose";
 
  // Construct muon fallback WPs for SFs
  m_mu_iso_fallback = {};
  m_mu_iso_fallback["PLImprovedTight"] = "PLVTight";
  m_mu_iso_fallback["PLImprovedVeryTight"] = "PLVTight";
}

~SUSYObjDef_xAOD()

ST::SUSYObjDef_xAOD::~SUSYObjDef_xAOD

(

)

Definition at line 3130 of file SUSYObjDef_xAOD.cxx.

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

Member Function Documentation

ApplyLRTUncertainty()

StatusCode ST::SUSYObjDef_xAOD::ApplyLRTUncertainty ( )

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3097 of file SUSYObjDef_xAOD.cxx.

                                               {
 
  // Don't apply variations for data
  if (isData()) return StatusCode::SUCCESS;
  
  const EventContext& ctx = Gaudi::Hive::currentContext();
 
  // Loop over tracks and call LRT uncertainty tool
  ATH_MSG_DEBUG ( "Applying LRT filter tool decorations for uncertainty");
  const xAOD::TrackParticleContainer inTracks = GetInDetLargeD0Tracks(ctx);
  for(const auto trk: inTracks)  dec_lrtFilter(*trk) = m_LRTuncTool->accept(trk);
 
  // Loop over GSF LRT tracks and call uncertainty tool
  const xAOD::TrackParticleContainer inGSFTracks = GetInDetLargeD0GSFTracks(ctx);
  for(const auto trk: inGSFTracks) dec_lrtFilter(*trk) = m_LRTuncTool->accept(trk);
 
  return StatusCode::SUCCESS;
}

ApplyPRWTool()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3052 of file SUSYObjDef_xAOD.cxx.

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

applySystematicVariation()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2143 of file SUSYObjDef_xAOD.cxx.

{
  if (!m_tool_init) {
    ATH_MSG_ERROR("SUSYTools was not initialized!!");
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_DEBUG(" in SUSYObjDef_xAOD::applySystematicVariation \"" << systConfig.name() << "\" size " << systConfig.size());
 
  m_currentSyst = systConfig;
 
  // NB: SystematicSet typically has only one component (see SUSYToolsTester macro)
  if (!m_jetUncertaintiesTool.empty() && systConfig.name().find("PseudoData") == std::string::npos) {
    StatusCode ret = m_jetUncertaintiesTool->applySystematicVariation(systConfig);
    if ( ret != StatusCode::SUCCESS) {
      ATH_MSG_VERBOSE("Cannot configure JetUncertaintiesTool for systematic var. " << systConfig.name() );
    } else {
      ATH_MSG_VERBOSE("Configured JetUncertaintiesTool for systematic var. " << systConfig.name() );
    }
  }
  if (!m_jetUncertaintiesPDSmearTool.empty() && systConfig.name().find("PseudoData") != std::string::npos) {
    StatusCode ret = m_jetUncertaintiesPDSmearTool->applySystematicVariation(systConfig);
    if ( ret != StatusCode::SUCCESS) {
      ATH_MSG_VERBOSE("Cannot configure JetUncertaintiesPDSmearTool for systematic var. " << systConfig.name() );
    } else {
      ATH_MSG_VERBOSE("Configured JetUncertaintiesPDSmearTool for systematic var. " << systConfig.name() );
    }
  }
  if (!m_WTagjetUncertaintiesTool.empty() && !m_WTagUncConfig.empty()) {
    StatusCode ret = m_WTagjetUncertaintiesTool->applySystematicVariation(systConfig);
    if ( ret != StatusCode::SUCCESS) {
      ATH_MSG_VERBOSE("Cannot configure (Fat)JetUncertaintiesTool (WTag) for systematic var. " << systConfig.name() );
    } else {
      ATH_MSG_VERBOSE("Configured (Fat)JetUncertaintiesTool (WTag) for systematic var. " << systConfig.name() );
    }
  }
  if (!m_ZTagjetUncertaintiesTool.empty() && !m_ZTagUncConfig.empty()) {
    StatusCode ret = m_ZTagjetUncertaintiesTool->applySystematicVariation(systConfig);
    if ( ret != StatusCode::SUCCESS) {
      ATH_MSG_VERBOSE("Cannot configure (Fat)JetUncertaintiesTool (ZTag) for systematic var. " << systConfig.name() );
    } else {
      ATH_MSG_VERBOSE("Configured (Fat)JetUncertaintiesTool (ZTag) for systematic var. " << systConfig.name() );
    }
  }
 
  if (!m_TopTagjetUncertaintiesTool.empty() && !m_TopTagUncConfig.empty()) {
    StatusCode ret = m_TopTagjetUncertaintiesTool->applySystematicVariation(systConfig);
    if ( ret != StatusCode::SUCCESS) {
      ATH_MSG_VERBOSE("Cannot configure (Fat)JetUncertaintiesTool (TopTag) for systematic var. " << systConfig.name() );
    } else {
      ATH_MSG_VERBOSE("Configured (Fat)JetUncertaintiesTool (TopTag) for systematic var. " << systConfig.name() );
    }
  }
  if (!m_fatjetUncertaintiesTool.empty() && systConfig.name().find("PseudoData") == std::string::npos) {
    StatusCode ret = m_fatjetUncertaintiesTool->applySystematicVariation(systConfig);
    if ( ret != StatusCode::SUCCESS) {
      ATH_MSG_VERBOSE("Cannot configure (Fat)JetUncertaintiesTool (main) for systematic var. " << systConfig.name() );
    } else {
      ATH_MSG_VERBOSE("Configured (Fat)JetUncertaintiesTool (main) for systematic var. " << systConfig.name() );
    }
  }
  if (!m_fatjetUncertaintiesPDSmearTool.empty() && systConfig.name().find("PseudoData") != std::string::npos) {
    StatusCode ret = m_fatjetUncertaintiesPDSmearTool->applySystematicVariation(systConfig);
    if ( ret != StatusCode::SUCCESS) {
      ATH_MSG_VERBOSE("Cannot configure FatJetUncertaintiesPDSmearTool for systematic var. " << systConfig.name() );
    } else {
      ATH_MSG_VERBOSE("Configured FatJetUncertaintiesPDSmearTool for systematic var. " << systConfig.name() );
    }
  }
  if (!m_fatjetFFSmearingTool.empty() && std::find(m_fatjetFFSmearingSyst.begin(), m_fatjetFFSmearingSyst.end(), systConfig) != m_fatjetFFSmearingSyst.end()) {
    StatusCode ret = m_fatjetFFSmearingTool->applySystematicVariation(systConfig);
    if ( ret != StatusCode::SUCCESS) {
      ATH_MSG_VERBOSE("Cannot configure (Fat)JetFFSmearingTool (main) for systematic var. " << systConfig.name() );
    } else {
      ATH_MSG_VERBOSE("Configured (Fat)JetFFSmearingTool (main) for systematic var. " << systConfig.name() );
    }
  }
  if (!m_jetNNJvtEfficiencyTool.empty()) {
    StatusCode ret = m_jetNNJvtEfficiencyTool->applySystematicVariation(systConfig);
    if ( ret != StatusCode::SUCCESS) {
      ATH_MSG_VERBOSE("Cannot configure NNJvtEfficiency for systematic var. " << systConfig.name() );
    } else {
      ATH_MSG_VERBOSE("Configured NNJvtEfficiency for systematic var. " << systConfig.name() );
    }
  }  
  if (!m_jetfJvtEfficiencyTool.empty()) {
    StatusCode ret = m_jetfJvtEfficiencyTool->applySystematicVariation(systConfig);
    if ( ret != StatusCode::SUCCESS) {
      ATH_MSG_VERBOSE("Cannot configure fJvtEfficiency for systematic var. " << systConfig.name() );
    } else {
      ATH_MSG_VERBOSE("Configured fJvtEfficiency for systematic var. " << systConfig.name() );
    }
  }  
  if (!m_muonCalibTool.empty()) {
    StatusCode ret =   m_muonCalibTool->applySystematicVariation(systConfig);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure MuonCalibTool for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("MuonCalibTool configured for systematic var. " << systConfig.name() );
    }
  }
  if (!m_muonEfficiencySFTool.empty()) {
    StatusCode ret  = m_muonEfficiencySFTool->applySystematicVariation(systConfig);
    if ( ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure MuonEfficiencyScaleFactors for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("MuonEfficiencyScaleFactors configured for systematic var. " << systConfig.name() );
    }
  }
  if (!m_muonEfficiencyBMHighPtSFTool.empty()) {
    StatusCode ret  = m_muonEfficiencyBMHighPtSFTool->applySystematicVariation(systConfig);
    if ( ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure MuonBadMuonHighPtScaleFactors for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("MuonBadMuonHighPtScaleFactors configured for systematic var. " << systConfig.name() );
    }
  }
  if (!m_muonTTVAEfficiencySFTool.empty()) {
    StatusCode ret  = m_muonTTVAEfficiencySFTool->applySystematicVariation(systConfig);
    if ( ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure MuonTTVAEfficiencyScaleFactors for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("MuonTTVAEfficiencyScaleFactors configured for systematic var. " << systConfig.name() );
    }
  }
  if (!m_muonIsolationSFTool.empty()) {
    StatusCode ret  = m_muonIsolationSFTool->applySystematicVariation(systConfig);
    if ( ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure MuonIsolationScaleFactors for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("MuonIsolationScaleFactors configured for systematic var. " << systConfig.name() );
    }
  }
  if (!m_muonTriggerSFTool.empty()) {
    StatusCode ret  = m_muonTriggerSFTool->applySystematicVariation(systConfig);
    if ( ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure MuonTriggerScaleFactors for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("MuonTriggerScaleFactors configured for systematic var. " << systConfig.name() );
    }
  }
  if (!m_elecEfficiencySFTool_reco.empty()) {
    StatusCode ret = m_elecEfficiencySFTool_reco->applySystematicVariation(systConfig);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (reco) for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("AsgElectronEfficiencyCorrectionTool (reco) configured for systematic var. " << systConfig.name() );
    }
  }
  if (!m_elecEfficiencySFTool_id.empty()) {
    StatusCode ret = m_elecEfficiencySFTool_id->applySystematicVariation(systConfig);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (id) for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("AsgElectronEfficiencyCorrectionTool (id) configured for systematic var. " << systConfig.name() );
    }
  }
  if (!m_elecEfficiencySFTool_trig_singleLep.empty()) {
    StatusCode ret = m_elecEfficiencySFTool_trig_singleLep->applySystematicVariation(systConfig);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (trigger) for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("AsgElectronEfficiencyCorrectionTool (trigger) configured for systematic var. " << systConfig.name() );
    }
  }
  if (!m_elecEfficiencySFTool_trigEff_singleLep.empty()) {
    StatusCode ret = m_elecEfficiencySFTool_trigEff_singleLep->applySystematicVariation(systConfig);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (trigger SFTool) for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("AsgElectronEfficiencyCorrectionTool (trigger SFTool) configured for systematic var. " << systConfig.name() );
    }
  }
  if (!m_trigGlobalEffCorrTool_diLep.empty()) {
    StatusCode ret = m_trigGlobalEffCorrTool_diLep->applySystematicVariation(systConfig);
    for(auto &sfop : m_elecTrigEffTools){
      StatusCode ret1 = sfop->applySystematicVariation(systConfig);
      if (ret1 != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure m_elecTrigEffTools (dilepton trigger) for systematic var. " << systConfig.name() ); return ret1; }
    }
    for(auto &sfop : m_elecTrigSFTools){
      StatusCode ret1 = sfop->applySystematicVariation(systConfig);
      if (ret1 != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure m_elecTrigSFTools (dilepton trigger) for systematic var. " << systConfig.name() ); return ret1; }
    }
    for(auto &sfop : m_muonTrigSFTools){
      StatusCode ret1 = sfop->applySystematicVariation(systConfig);
      if (ret1 != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure m_muonTrigSFTools (dilepton trigger) for systematic var. " << systConfig.name() ); return ret1; }
    }
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (dilepton trigger) for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("TrigGlobalEfficiencyCorrectionTool (dilepton trigger) configured for systematic var. " << systConfig.name() );
    }
  }
  if (!m_trigGlobalEffCorrTool_multiLep.empty()) {
    StatusCode ret = m_trigGlobalEffCorrTool_multiLep->applySystematicVariation(systConfig);
    for(auto &sfop : m_elecTrigEffTools){
      StatusCode ret1 = sfop->applySystematicVariation(systConfig);
      if (ret1 != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure m_elecTrigEffTools (multilep trigger) for systematic var. " << systConfig.name() ); return ret1; }
    }
    for(auto &sfop : m_elecTrigSFTools){
      StatusCode ret1 = sfop->applySystematicVariation(systConfig);
      if (ret1 != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure m_elecTrigSFTools (multilep trigger) for systematic var. " << systConfig.name() ); return ret1; }
    }
    for(auto &sfop : m_muonTrigSFTools){
      StatusCode ret1 = sfop->applySystematicVariation(systConfig);
      if (ret1 != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure m_muonTrigSFTools (multilep trigger) for systematic var. " << systConfig.name() ); return ret1; }
    }
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (multi-lepton trigger) for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("TrigGlobalEfficiencyCorrectionTool (multi-lepton trigger) configured for systematic var. " << systConfig.name() );
    }
  }
  if (!m_elecEfficiencySFTool_iso.empty()) {
    StatusCode ret = m_elecEfficiencySFTool_iso->applySystematicVariation(systConfig);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (iso) for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("AsgElectronEfficiencyCorrectionTool (iso) configured for systematic var. " << systConfig.name() );
    }
  }
  if (!m_elecEfficiencySFTool_isoHighPt.empty()) {
    StatusCode ret = m_elecEfficiencySFTool_isoHighPt->applySystematicVariation(systConfig);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (iso high-pt) for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("AsgElectronEfficiencyCorrectionTool (iso high-pt) configured for systematic var. " << systConfig.name() );
    }
  }
  if (!m_elecChargeEffCorrTool.empty()) {
    StatusCode ret = m_elecChargeEffCorrTool->applySystematicVariation(systConfig);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure ElectronChargeEffCorrectionTool for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("ElectronChargeEffCorrectionTool configured for systematic var. " << systConfig.name() );
    }
  }
  if (!isData() && !m_photonEfficiencySFTool.empty()) {
    StatusCode ret = m_photonEfficiencySFTool->applySystematicVariation(systConfig);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure AsgPhotonEfficiencyCorrectionTool (reco) for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("AsgPhotonEfficiencyCorrectionTool (reco) configured for systematic var. " << systConfig.name() );
    }
  }
  if (!isData() && !m_photonIsolationSFTool.empty()) {
    StatusCode ret = m_photonIsolationSFTool->applySystematicVariation(systConfig);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure AsgPhotonEfficiencyCorrectionTool (iso) for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("AsgPhotonEfficiencyCorrectionTool configured (iso) for systematic var. " << systConfig.name() );
    }
  }
  if (!isData() && !m_photonTriggerSFTool.empty()) {
    StatusCode ret = m_photonTriggerSFTool->applySystematicVariation(systConfig);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure AsgPhotonEfficiencyCorrectionTool (trigger) for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("AsgPhotonEfficiencyCorrectionTool configured (trigger) for systematic var. " << systConfig.name() );
    }
  }
  if (!m_trigGlobalEffCorrTool_diPhoton.empty()) {
    StatusCode ret = m_trigGlobalEffCorrTool_diPhoton->applySystematicVariation(systConfig);
    for(auto &sfop : m_photonTrigEffTools){
      StatusCode ret1 = sfop->applySystematicVariation(systConfig);
      if (ret1 != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure m_photonTrigEffTools (diphoton trigger) for systematic var. " << systConfig.name() ); return ret1; }
    }
    for(auto &sfop : m_photonTrigSFTools){
      StatusCode ret1 = sfop->applySystematicVariation(systConfig);
      if (ret1 != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure m_photonTrigSFTools (diphoton trigger) for systematic var. " << systConfig.name() ); return ret1; }
    }
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (diphoton trigger) for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("TrigGlobalEfficiencyCorrectionTool (diphoton trigger) configured for systematic var. " << systConfig.name() );
    }
  }
  if (!m_egammaCalibTool.empty()) {
    StatusCode ret = m_egammaCalibTool->applySystematicVariation(systConfig);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure EgammaCalibrationAndSmearingTool for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("EgammaCalibrationAndSmearingTool configured for systematic var. " << systConfig.name() );
    }
  }
  if (!m_isoCorrTool.empty()) {
    StatusCode ret = m_isoCorrTool->applySystematicVariation(systConfig);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure IsolationCorrectionTool for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("IsolationCorrectionTool configured for systematic var. " << systConfig.name() );
    }
  }
  if (!m_btagEffTool.empty()) {
    //if ( systConfig.size() > 0 && m_btagEffTool->isAffectedBySystematic(*systConfig.begin()) ) {
    StatusCode ret = m_btagEffTool->applySystematicVariation(systConfig);
    if ( ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure xAODBTaggingEfficiency for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("Configured xAODBTaggingEfficiency for systematic var. " << systConfig.name() );
    }
    //}
  }
  if (!m_btagEffTool_trkJet.empty()) {
    StatusCode ret = m_btagEffTool_trkJet->applySystematicVariation(systConfig);
    if ( ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure xAODBTaggingEfficiency (track jets) for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("Configured xAODBTaggingEfficiency (track jets) for systematic var. " << systConfig.name() );
    }
  }
  if (!m_tauSmearingTool.empty()) {
    StatusCode ret = m_tauSmearingTool->applySystematicVariation(systConfig);
    if ( ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure TauSmearingTool for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("Configured TauSmearingTool for systematic var. " << systConfig.name() );
    }
  }
  if (!m_tauEffTool.empty()) {
    StatusCode ret = m_tauEffTool->applySystematicVariation(systConfig);
    if ( ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure TauEfficiencyCorrectionsTool for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("Configured TauEfficiencyCorrectionsTool for systematic var. " << systConfig.name() );
    }
  }
  for(auto &tool : m_tauTrigEffTool) {
    StatusCode ret = tool->applySystematicVariation(systConfig);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure " << tool->name() << " for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("Configured " << tool->name() << " for systematic var. " << systConfig.name() );
    }
  }
  if (!m_metSystTool.empty()) {
    StatusCode ret = m_metSystTool->applySystematicVariation(systConfig);
    if ( ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure METSystematicsTool for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("Configured METSystematicsTool for systematic var. " << systConfig.name() );
    }
  }
  if (!m_prwTool.empty()) {
    StatusCode ret = m_prwTool->applySystematicVariation(systConfig);
    if ( ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure PileupReweightingTool for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("Configured PileupReweightingTool for systematic var. " << systConfig.name() );
    }
  }
 
  if (!m_LRTuncTool.empty()) {
    StatusCode ret = m_LRTuncTool->applySystematicVariation(systConfig);
    if ( ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure InDetTrackFilterTool for systematic var. " << systConfig.name() );
      return ret;
    } else {
      ATH_MSG_VERBOSE("Configured InDetTrackFilterTool for systematic var. " << systConfig.name() );
    }
  }
 
  return StatusCode::SUCCESS;
}

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

                                                                                                                                                                                              {
 
  // this will contain the path of the PRW file on /cvmfs which needs to be reverse engineered from the DSID and MC campaign
  // the path(s) will be added to m_prwConfFiles which is later used in the configuration of the CP PRW tool
  std::string prwConfigFile("");
 
  if ( !isData() && m_autoconfigPRW ) {
 
    prwConfigFile = PRWfilesDir;
 
    float dsid = -999;
    std::string amiTag("");
    std::string mcCampaignMD("");
    std::string simFlavour("");
    std::string simType("");
    const xAOD::FileMetaData* fmd = nullptr;
 
    // configure PRW rtag options from m_autoconfigPRWRtags string
    // e.g. "mc20a:r13167_r14859,mc20d:r13144_r14860,mc20e:r13145_r14861,mc21a:r13752_r13829,mc23a:r14622_r14932_r15540,mc23c:r14799_r14908,mc23d:r15224_r15530,mc23e:r16083"
    std::map<std::string,std::vector<std::string>> PRWRtags = {};
    std::string allcampaigns = "mc20a.mc20d.mc20e.mc21a.mc23a.mc23c.mc23d.mc23e";
    bool standard_like = true;
    for ( const auto& campaign_rtags : split( m_autoconfigPRWRtags, "," ) ) {                                          // split string by ","
       std::string icampaign = campaign_rtags.substr(0, campaign_rtags.find(":"));                              // first field = campaign, split by ":"
       std::vector<std::string> irtags = split( campaign_rtags.substr(campaign_rtags.find(":")+1), "_" );       // remaining fields = rtags, split by "_"
       PRWRtags[icampaign] = irtags;
       ATH_MSG_DEBUG( "PRW autoconfigure considering rtags " <<  campaign_rtags.substr(campaign_rtags.find("_")+1) << " for campaign " << icampaign );
    }
    for ( const auto& x : PRWRtags ) {
       if ( allcampaigns.find(x.first)==string::npos ) {
          ATH_MSG_ERROR("m_autoconfigPRWRtags contains invalid campaign: " << x.first << " (" << m_autoconfigPRWRtags << ")");
          ATH_MSG_ERROR("use any of " << allcampaigns);
          return StatusCode::FAILURE;
       }
    }
 
    // let's use MetaData to extract sample information
    if ( inputMetaStore()->contains<xAOD::FileMetaData>("FileMetaData") && inputMetaStore()->retrieve(fmd,"FileMetaData").isSuccess() ) {
      fmd->value(xAOD::FileMetaData::mcProcID, dsid);
      fmd->value(xAOD::FileMetaData::amiTag, amiTag);
      fmd->value(xAOD::FileMetaData::simFlavour, simFlavour);
 
      if(simFlavour.starts_with("ATLFASTII")) simType = "AFII";
      else if(simFlavour.starts_with("ATLFAST3")) simType = "AF3";
      else simType = "FS";
 
      bool found = false;
      while ( mcCampaignMD.empty() ) {
         for ( const auto& campaign_rtags : PRWRtags ) {                                 // consider all campaigns
            for ( const auto& rtag: campaign_rtags.second ) {                            // consider all rtags
               if (found) continue;
               if (amiTag.find(rtag)!=string::npos) {                             // find matching tag
                  mcCampaignMD = campaign_rtags.first.substr(0,5);                // save campaign
                  standard_like = (campaign_rtags.first.find("ns")?true:false);   // track non-standard r-tags
                  found = true;                                                   // break if found
               }
            }
         }
         // in case not found
         if (!found) {
            ATH_MSG_ERROR( "autoconfigurePileupRWTool(): unrecognized xAOD::FileMetaData::amiTag, \'" << amiTag << "'. Please check your input sample.");
             return StatusCode::FAILURE;
         }
         //
         ATH_MSG_INFO( "Setting up autoconfigurePileupRWTool for mc campaign " << mcCampaignMD << " (from amiTag " << amiTag << ") (standard-like = " << (standard_like?"true":"false") << ")." );
         if ( (!standard_like) && (!RPVLLmode) )
            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?");
      }
    } else {
#ifndef XAOD_STANDALONE
      ATH_MSG_ERROR( "autoconfigurePileupRWTool(): access to FileMetaData failed, can't get mc channel number.");
      return StatusCode::FAILURE;
#else
 
      if ( m_mcCampaign == "mc20a" || m_mcCampaign == "mc20d" || m_mcCampaign == "mc20e" || m_mcCampaign == "mc21a" || m_mcCampaign == "mc23a" || m_mcCampaign == "mc23c" || m_mcCampaign == "mc23d" || m_mcCampaign == "mc23e") {
    // First see if the user set the mcCampaign/run number by property (hopefully temporary workaround)
    if ( m_mcChannel > 0) {
      ATH_MSG_WARNING( "autoconfigurePileupRWTool(): access to FileMetaData failed -> getting the mc channel number (DSID) and campaign from configuration." );
      std::string NoMetadataButPropertyOK("");
      NoMetadataButPropertyOK += "autoconfigurePileupRWTool(): 'mcCampaign' is used and passed to SUSYTools as '";
      NoMetadataButPropertyOK += m_mcCampaign;
      NoMetadataButPropertyOK += "'. 'mcChannel' is used and passed to SUSYTools as '";
      NoMetadataButPropertyOK += std::to_string(m_mcChannel);
      NoMetadataButPropertyOK += "'. Autocongiguring PRW accordingly.";
      ATH_MSG_WARNING( NoMetadataButPropertyOK );
      mcCampaignMD = m_mcCampaign;
      dsid = m_mcChannel;
    } else {
      // OK, this is a fall-back option without using MetaData but one has to manually set 'mcCampaign' property
      ATH_MSG_WARNING( "autoconfigurePileupRWTool(): access to FileMetaData failed -> getting the mc channel number (DSID) from the event store." );
      const xAOD::EventInfo* evtInfo = GetEventInfo();
      dsid = evtInfo->mcChannelNumber();
 
      std::string NoMetadataButPropertyOK("");
      NoMetadataButPropertyOK += "autoconfigurePileupRWTool(): 'mcCampaign' is used and passed to SUSYTools as '";
      NoMetadataButPropertyOK += m_mcCampaign;
      NoMetadataButPropertyOK += "'. Autoconfiguring PRW accordingly.";
      ATH_MSG_WARNING( NoMetadataButPropertyOK );
      mcCampaignMD = m_mcCampaign;
    }
      } else {
    ATH_MSG_ERROR( "autoconfigurePileupRWTool(): `mcCampaign' is not set properly.");
    return StatusCode::FAILURE;
      }
#endif
    }
 
    // If requested set the PRW file to common PRW file of the processed MC campaign
    if (m_useCommonPRWFiles) {
      ATH_MSG_INFO( "autoconfigurePileupRWTool(): retrieving the common PRW file for MC campaign: " << mcCampaignMD );
      if      (mcCampaignMD == "mc20a") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC20a);}
      else if (mcCampaignMD == "mc20d") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC20d);}
      else if (mcCampaignMD == "mc20e") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC20e);}
      else if (mcCampaignMD == "mc21a") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC21a);}
      else if (mcCampaignMD == "mc23a") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC23a);}
      else if (mcCampaignMD == "mc23c") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC23c);}
      else if (mcCampaignMD == "mc23d") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC23d);}
      else if (mcCampaignMD == "mc23e") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC23e);}
      else {
        ATH_MSG_ERROR( "autoconfigurePileupRWTool(): no common PRW file known for MC campaign: " << mcCampaignMD);
        return StatusCode::FAILURE;
      }
    }
    // Otherwise try finding the dedicated PRW file on /cvmfs
    else {
      // Retrieve the input file
      int DSID_INT = static_cast<int>(dsid);
      prwConfigFile += "DSID" + std::to_string(DSID_INT/1000) + "xxx/pileup_" + mcCampaignMD + "_dsid" + std::to_string(DSID_INT) + "_" + simType + ".root";
 
      if (RPVLLmode) prwConfigFile = TString(prwConfigFile).ReplaceAll(".root","_rpvll.root").Data();
 
      // PRW file specified by user
      // e.g. DSID700xxx/pileup_mc20a_dsid700015_FS.root
      if (!PRWfileName.empty()) {
      prwConfigFile = PRWfilesDir + PRWfileName;
      ATH_MSG_INFO( "autoconfigurePileupRWTool(): PRW file was specifed by user: " << prwConfigFile.data() );
      }
    }
 
    m_prwConfFiles.clear();
 
    // Combined mode can be only used when running with full data with the same MC samples
    if (Combinedmode) {
      if (mcCampaignMD.find("mc20") == std::string::npos) {
        ATH_MSG_ERROR( "autoconfigurePileupRWTool(): combined mode currently onlys supported for mc20! Impossible to autoconfigure PRW. Aborting." );
        return StatusCode::FAILURE;
      }
      // When using the common PRW files we can directly add them
      if (m_useCommonPRWFiles) {
        m_prwConfFiles.push_back( m_commonPRWFileMC20a );
        m_prwConfFiles.push_back( m_commonPRWFileMC20d );
        m_prwConfFiles.push_back( m_commonPRWFileMC20e );
      }
      // Otherwise we have to replace the mc campaign in the name accordingly
      else {
        m_prwConfFiles.emplace_back( TString(prwConfigFile).ReplaceAll(mcCampaignMD, "mc20a").Data() );
        m_prwConfFiles.emplace_back( TString(prwConfigFile).ReplaceAll(mcCampaignMD, "mc20d").Data() );
        m_prwConfFiles.emplace_back( TString(prwConfigFile).ReplaceAll(mcCampaignMD, "mc20e").Data() );
      }
      m_prwConfFiles.push_back( PathResolverFindCalibFile(m_prwActualMu2017File) );
      m_prwConfFiles.push_back( PathResolverFindCalibFile(m_prwActualMu2018File) );
    } else {
      m_prwConfFiles.push_back( prwConfigFile );
      if ( mcCampaignMD == "mc20d") {
        m_prwConfFiles.push_back( PathResolverFindCalibFile(m_prwActualMu2017File) );
      } else if (mcCampaignMD == "mc20e") {
        m_prwConfFiles.push_back( PathResolverFindCalibFile(m_prwActualMu2018File) );
      } else if (mcCampaignMD == "mc21a" || mcCampaignMD == "mc23a") {
        m_prwConfFiles.push_back( PathResolverFindCalibFile(m_prwActualMu2022File) );
      } else if (mcCampaignMD == "mc23c" || mcCampaignMD == "mc23d") {
        m_prwConfFiles.push_back( PathResolverFindCalibFile(m_prwActualMu2023File) );
      } else if (mcCampaignMD == "mc23e") {
        m_prwConfFiles.push_back( PathResolverFindCalibFile(m_prwActualMu2024File) );
      }
 
    }
    prwConfigFile = usePathResolver ? PathResolverFindCalibFile(prwConfigFile) : prwConfigFile;
 
    // Test if file exists (i.e. was requested already to /cvmfs if the DSID-specific PRW files are used) and is usable
    TFile testF(prwConfigFile.data(),"read");
    if (testF.IsZombie()) {
      ATH_MSG_ERROR( "autoconfigurePileupRWTool(): file not found -> " << prwConfigFile.data() << " ! Impossible to autoconfigure PRW. Aborting." );
      if ( (!standard_like) && (!RPVLLmode) )
         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?");
      return StatusCode::FAILURE;
    }
 
    ATH_MSG_INFO( "autoconfigurePileupRWTool(): configuring PRW tool using " << prwConfigFile.data() );
  }
  // Return gracefully
  return StatusCode::SUCCESS;
}

beginEvent()

StatusCode asg::AsgMetadataTool::beginEvent ( )

protectedvirtualinherited

Function called when a new events is loaded.

Dummy implementation that can be overridden by the derived tool.

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

Definition at line 201 of file AsgMetadataTool.cxx.

                                          {
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

beginInputFile()

StatusCode asg::AsgMetadataTool::beginInputFile ( )

protectedvirtualinherited

Function called when a new input file is opened.

Dummy implementation that can be overridden by the derived tool.

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

Definition at line 185 of file AsgMetadataTool.cxx.

                                              {
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

BtagSF()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 827 of file Jets.cxx.

                                                            {
 
    float totalSF = 1.;
    for ( const xAOD::Jet* jet : *jets ) {
 
      float sf = 1.;
 
      if ( std::abs(jet->eta()) > 2.5 ) {
        ATH_MSG_VERBOSE( "Trying to retrieve b-tagging SF for jet with |eta|>2.5 (jet eta=" << jet->eta() << "), jet will be skipped");
      } else if ( jet->pt() < 20e3 ){
        ATH_MSG_VERBOSE( "Trying to retrieve b-tagging SF for jet with invalid pt (jet pt=" << jet->pt() << "), jet will be skipped");
      } else {
 
        CP::CorrectionCode result;
        int truthlabel(-1);
        if (!jet->getAttribute("HadronConeExclTruthLabelID", truthlabel)) {
          ATH_MSG_ERROR("Failed to get jet truth label!");
        }
        ATH_MSG_VERBOSE("This jet is " << (acc_bjet(*jet) ? "" : "not ") << "b-tagged.");
        ATH_MSG_VERBOSE("This jet's truth label is " << truthlabel);
 
        if ( acc_bjet(*jet) or m_BtagWP == "Continuous") {
          result = m_btagEffTool->getScaleFactor(*jet, sf);
 
          switch (result) {
          case CP::CorrectionCode::Error:
            ATH_MSG_ERROR( "Failed to retrieve SF for b-tagged jets in SUSYTools_xAOD::BtagSF" );
            break;
          case CP::CorrectionCode::OutOfValidityRange:
            ATH_MSG_VERBOSE( "No valid SF for b-tagged jets in SUSYTools_xAOD::BtagSF" );
            break;
          default:
            ATH_MSG_VERBOSE( "Retrieve SF for b-tagged jets in SUSYTools_xAOD::BtagSF with value " << sf );
          }
        } else {
 
          result = m_btagEffTool->getInefficiencyScaleFactor(*jet, sf);
 
          switch (result) {
          case CP::CorrectionCode::Error:
            ATH_MSG_ERROR( "Failed to retrieve SF for non-b-tagged jets in SUSYTools_xAOD::BtagSF" );
            break;
          case CP::CorrectionCode::OutOfValidityRange:
            ATH_MSG_VERBOSE( "No valid inefficiency SF for non-b-tagged jets in SUSYTools_xAOD::BtagSF" );
            break;
          default:
            ATH_MSG_VERBOSE( "Retrieve SF for non-b-tagged jets in SUSYTools_xAOD::BtagSF with value " << sf );
          }
        }
      }
 
      dec_effscalefact(*jet) = sf;
 
      if( acc_signal(*jet) && acc_passOR(*jet) ) totalSF *= sf; //consider goodjets only
 
    }
 
    return totalSF;
  }

BtagSF_trkJet()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 908 of file Jets.cxx.

                                                                      {
 
    float totalSF = 1.;
    for ( const xAOD::Jet* trkjet : *trkjets ) {
 
      float sf = 1.;
 
      if ( std::abs(trkjet->eta()) > 2.5 ) {
        ATH_MSG_VERBOSE( "Trying to retrieve b-tagging SF for trkjet with |eta|>2.5 (trkjet eta=" << trkjet->eta() << "), trkjet will be skipped");
      } else if ( trkjet->pt() < 10e3 ){
        ATH_MSG_VERBOSE( "Trying to retrieve b-tagging SF for trkjet with invalid pt (trkjet pt=" << trkjet->pt() << "), jet will be skipped");
      } else {
 
        CP::CorrectionCode result;
        int truthlabel(-1);
        if (!trkjet->getAttribute("HadronConeExclTruthLabelID", truthlabel)) {
          ATH_MSG_ERROR("Failed to get jet truth label!");
        }
        ATH_MSG_VERBOSE("This jet is " << (acc_bjet(*trkjet) ? "" : "not ") << "b-tagged.");
        ATH_MSG_VERBOSE("This jet's truth label is " << truthlabel);
 
        if ( acc_bjet(*trkjet) ) {
          result = m_btagEffTool_trkJet->getScaleFactor(*trkjet, sf);
 
          switch (result) {
          case CP::CorrectionCode::Error:
            ATH_MSG_ERROR( "Failed to retrieve SF for b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet" );
            break;
          case CP::CorrectionCode::OutOfValidityRange:
            ATH_MSG_VERBOSE( "No valid SF for b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet" );
            break;
          default:
            ATH_MSG_VERBOSE( "Retrieve SF for b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet with value " << sf );
          }
        } else {
 
          result = m_btagEffTool_trkJet->getInefficiencyScaleFactor(*trkjet, sf);
 
          switch (result) {
          case CP::CorrectionCode::Error:
            ATH_MSG_ERROR( "Failed to retrieve SF for non-b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet" );
            break;
          case CP::CorrectionCode::OutOfValidityRange:
            ATH_MSG_VERBOSE( "No valid inefficiency SF for non-b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet" );
            break;
          default:
            ATH_MSG_VERBOSE( "Retrieve SF for non-b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet with value " << sf );
          }
        }
      }
 
      dec_effscalefact(*trkjet) = sf;
 
      if( acc_signal(*trkjet) ) totalSF *= sf;
 
    }
 
    return totalSF;
  }

BtagSFsys()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 888 of file Jets.cxx.

  {
    float totalSF = 1.;
 
    //Set the new systematic variation
    StatusCode ret = m_btagEffTool->applySystematicVariation(systConfig);
    if ( ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure BTaggingEfficiencyTool for systematic var. " << systConfig.name() );
    }
 
    totalSF = BtagSF( jets );
 
    ret = m_btagEffTool->applySystematicVariation(m_currentSyst);
    if ( ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure BTaggingEfficiencyTool for systematic var. " << systConfig.name() );
    }
 
    return totalSF;
  }

BtagSFsys_trkJet()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 969 of file Jets.cxx.

  {
    float totalSF = 1.;
 
    //Set the new systematic variation
    StatusCode ret = m_btagEffTool_trkJet->applySystematicVariation(systConfig);
    if ( ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure BTaggingEfficiencyTool (track jets) for systematic var. " << systConfig.name() );
    }
 
    totalSF = BtagSF_trkJet( trkjets );
 
    ret = m_btagEffTool_trkJet->applySystematicVariation(m_currentSyst);
    if ( ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure BTaggingEfficiencyTool (track jets) for systematic var. " << systConfig.name() );
    }
 
    return totalSF;
  }

check_isOption()

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

protected

Definition at line 1213 of file SUSYObjDef_xAOD.cxx.

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

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

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

configFromFile() [1/4]

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

protected

Definition at line 1256 of file SUSYObjDef_xAOD.cxx.

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

configFromFile() [2/4]

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

protected

Definition at line 1271 of file SUSYObjDef_xAOD.cxx.

{
  // ignore if already configured
  if (property > -90.) {
    ATH_MSG_INFO( "configFromFile(): property \"" << propname << "\" already set with value " << property << ". Ignoring change request." );
    rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(propname.c_str() ) );
    return;
  }
  property = rEnv.GetValue(propname.c_str(), defaultValue);
  ATH_MSG_INFO( "configFromFile(): Loaded property \"" << propname << "\" with value " << property );
  // Remove the item from the table
  rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(propname.c_str() ) );
}

configFromFile() [3/4]

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

protected

Definition at line 1287 of file SUSYObjDef_xAOD.cxx.

{
  // ignore if already configured
  if (property > -90){
    ATH_MSG_INFO( "configFromFile(): property \"" << propname << "\" already set with value " << property << ". Ignoring change request." );
    rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(propname.c_str() ) );
    return;
  }
  property = rEnv.GetValue(propname.c_str(), defaultValue);
  ATH_MSG_INFO( "configFromFile(): Loaded property \"" << propname << "\" with value " << property );
  // Remove the item from the table
  rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(propname.c_str() ) );
}

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

{
  // ignore if already configured
  if (!property.empty()){
    ATH_MSG_INFO( "configFromFile(): property \"" << propname << "\" already set with value " << property << ". Ignoring change request." );
    rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(propname.c_str() ) );
    return;
  }
  property = rEnv.GetValue(propname.c_str(), defaultValue.c_str());
  if (property.empty() && !allowEmpty) {
    ATH_MSG_FATAL("Read empty string property from text file (property name: " << propname << ")");
  }
 
  // post-processing to get rid of leading/trailing spaces and comments
  std::string tmp_prop = property.substr(0, property.find('#', 0));
  property = TString(tmp_prop).ReplaceAll(" ","").Data();
 
  // Interpret None as an empty string
  if (property=="None" || property=="NONE" || property=="none") {
    ATH_MSG_VERBOSE( "Property \"" << propname << "\" being set to empty string due to specification of \"" << property << "\"" );
    property = "";
  }
 
  ATH_MSG_INFO( "configFromFile(): Loaded property \"" << propname << "\" with value " << property );
  // Remove the item from the table
  rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(propname.c_str() ) );
}

currentSystematic()

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

(

)

const

Definition at line 2101 of file SUSYObjDef_xAOD.cxx.

                                                                {
  return m_currentSyst;
}

currentSystematicIsNominal()

bool ST::SUSYObjDef_xAOD::currentSystematicIsNominal

(

)

const

Definition at line 2129 of file SUSYObjDef_xAOD.cxx.

                                                       {
  return isNominal(m_currentSyst);
}

currentSystematicIsVariation()

bool ST::SUSYObjDef_xAOD::currentSystematicIsVariation

(

)

const

Definition at line 2133 of file SUSYObjDef_xAOD.cxx.

                                                         {
  return isVariation(m_currentSyst);
}

currentSystematicIsWeight()

bool ST::SUSYObjDef_xAOD::currentSystematicIsWeight

(

)

const

Definition at line 2137 of file SUSYObjDef_xAOD.cxx.

                                                      {
  return isWeight(m_currentSyst);
}

declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareGaudiProperty() [2/4]

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.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
  }

declareGaudiProperty() [4/4]

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

inlineprivateinherited

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

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

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

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

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

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

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

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

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

Definition at line 333 of file AthCommonDataStore.h.

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

declareProperty() [5/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

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

Definition at line 352 of file AthCommonDataStore.h.

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

declareProperty() [6/6]

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

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.

{ return m_detStore; }

EG_WP()

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

protected

Definition at line 1225 of file SUSYObjDef_xAOD.cxx.

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

emulateHLT()

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

private

Definition at line 97 of file Trigger.cxx.

                                                                   {
  std::scoped_lock lock (m_triggerCacheMutex);
  // First, check if we've already tried using this trigger
  auto funcItr = m_metTriggerFuncs.find(triggerName);
  if (funcItr != m_metTriggerFuncs.end() )
    return funcItr->second();
 
  // Next, check that it really is a HLT MET trigger
  if (triggerName.substr(0,6) != "HLT_xe") {
    ATH_MSG_ERROR( "Requested trigger " << triggerName << " isn't a MET trigger! (HLT MET items should begin with 'HLT_xe'). Will return false." );
    return false;
  }
 
  // Next, parse the name to work out which containers are needed to emulate the decision
  std::vector<std::pair<int, std::string> > hypos; // algorithms and thresholds needed
  std::string temp(triggerName);
  // Note, we need to split on '_AND_' used for the combined mht+cell trigger
  do {
    auto pos = temp.find("_AND_");
    std::string itemName = temp.substr(0, pos);
    ATH_MSG_DEBUG( "Split trigger item " << itemName );
    if (pos == std::string::npos)
      temp = "";
    else
      temp = temp.substr(pos + 5);
 
    std::regex expr("HLT_xe([[:digit:]]+)_?(mht|pufit|pueta|tc_lcw|)_?(?:L1XE([[:digit:]]+)|)");
    std::smatch sm;
    if (!std::regex_match(itemName, sm, expr) ) {
      ATH_MSG_WARNING( "Regex reading for item " << itemName << " (" << triggerName << ") failed! Will be ignored!" );
      continue;
    }
    if (sm.size() < 4) { // first object is the whole match, then there are three capture groups
      ATH_MSG_WARNING( "Regex failed to capture the right groups for item " << itemName << " (" << triggerName << ") failed! Will be ignored!" );
      for (unsigned int ii = 0; ii < sm.size(); ++ii) {
        ATH_MSG_WARNING( sm[ii] );
      }
      continue;
    }
    int threshold = std::stoi(sm[1] );
    std::string algKey = sm[2];
    std::string metContBaseName = "HLT_xAOD__TrigMissingETContainer_TrigEFMissingET";
    if (algKey.empty()) hypos.push_back(std::make_pair(threshold, metContBaseName) );
    else if (algKey == "mht") hypos.push_back(std::make_pair(threshold, metContBaseName+"_mht") );
    else if (algKey == "pufit") hypos.push_back(std::make_pair(threshold, metContBaseName+"_topocl_PUC") );
    else if (algKey == "pueta") hypos.push_back(std::make_pair(threshold, metContBaseName+"_topocl_PS") );
    else if (algKey == "tc_lcw") hypos.push_back(std::make_pair(threshold, metContBaseName+"topocl") );
 
    ATH_MSG_DEBUG( "Container: " << hypos.back().second << ", Threshold: " << hypos.back().first );
   
    if (sm[3] != "" && sm[3] != "50") {
      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" );
      // Note, now the L1 part is done in the previous section. However I'm keeping this warning here.
    }
  }
  while (!temp.empty());
 
  // Check if we have the containers and construct the lambda
  // Already done the L1 decision - only care about HLT
  std::function<bool()> lambda;
  bool hasRequired = true;
  if (hypos.empty()) lambda = [] () {return false;};
  else { 
    for (const auto& pair : hypos) {
      if (evtStore()->contains<xAOD::TrigMissingETContainer>(pair.second) ) {
        auto lambda_hypo = [this, pair] () {
          const xAOD::TrigMissingETContainer* cont(nullptr);
          if (evtStore()->retrieve(cont, pair.second) ) {
            if (cont->empty()) return false;
            float ex = cont->front()->ex() * 0.001;
            float ey = cont->front()->ey() * 0.001;
            float met = std::sqrt(ex*ex + ey*ey);
            return met > pair.first;
          }
          else {
            return false;
          }
        };
        // an empty std::function evaluates to false
        if (lambda) {
          lambda = [lambda, lambda_hypo] () {
            return lambda() && lambda_hypo();
          };
        }
        else {
          lambda = lambda_hypo;
        }
      }
      else {
        hasRequired = false;
        ATH_MSG_WARNING( "Container: " << pair.second << " missing!" );
      }
    }
  }
  if (hasRequired) {
    m_metTriggerFuncs[triggerName] = lambda;
    return m_metTriggerFuncs.at(triggerName)();
  }
  // We can't get the exact trigger decision :( . Look for an alternative
  std::vector<std::string> replacementTriggers({"HLT_xe110_mht_L1XE50", "HLT_xe100_mht_L1XE50", "HLT_xe90_mht_L1XE50", "HLT_xe70_mht"});
  for (const std::string& trigName : replacementTriggers) {
    if (isTrigInTDT(lock, trigName) ) {
      ATH_MSG_WARNING( "Trigger " << triggerName << " not available and direct emulation impossible! Will use " << trigName << " instead!");
      m_metTriggerFuncs[triggerName] = [this, trigName] () { 
        return m_trigDecTool->isPassed(trigName);
      };
      return m_metTriggerFuncs.at(triggerName)();
    }
  }
  ATH_MSG_ERROR( "Cannot find the trigger in the menu, direct emulation is impossible and no replacement triggers are available! Will return false" );
  m_metTriggerFuncs.at(triggerName) = [] () {return false;};
  return m_metTriggerFuncs.at(triggerName)();
}

endInputFile()

StatusCode asg::AsgMetadataTool::endInputFile ( )

protectedvirtualinherited

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

Dummy implementation that can be overridden by the derived tool.

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

Definition at line 193 of file AsgMetadataTool.cxx.

                                            {
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

evtStore() [1/2]

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

{ 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 223 of file Electrons.cxx.

                                                                                       {
 
  ATH_MSG_VERBOSE( "Starting FillElectron on el with pre-calibration pt=" << input.pt() );
 
  // According to https://twiki.cern.ch/twiki/bin/view/AtlasProtected/EGammaIdentificationRun2#Electron_identification:
  // "Please apply the identification to uncalibrated electron object. ID scale factors are to be applied to calibrated objects."
  dec_baseline(input) = false;
  dec_selected(input) = 0;
  dec_signal(input) = false;
  dec_isol(input) = false;
  dec_isolHighPt(input) = false;
  dec_passSignalID(input) = false;
  dec_passChID(input) = false;
  dec_ecisBDT(input) = -999.;
 
  const xAOD::EventInfo* evtInfo = nullptr;
  ATH_CHECK( evtStore()->retrieve( evtInfo, "EventInfo" ) );
  const xAOD::Vertex* pv = this->GetPrimVtx();
  const xAOD::TrackParticle* track =  input.trackParticle();
  if (!track) {
    ATH_MSG_DEBUG("No primary track particle for this electron. Skipping.");
    return StatusCode::SUCCESS;
  }
  double primvertex_z = pv ? pv->z() : 0;
  double el_z0 = track->z0() + track->vz() - primvertex_z;
  dec_z0sinTheta(input) = el_z0 * TMath::Sin(input.p4().Theta());
  //protect against exception thrown for null or negative d0sig
  try{
    dec_d0sig(input) = xAOD::TrackingHelpers::d0significance( track , evtInfo->beamPosSigmaX(), evtInfo->beamPosSigmaY(), evtInfo->beamPosSigmaXY() );
  }
  catch(...){
    float d0sigError = -99.;
    ATH_MSG_WARNING("FillElectron : Exception catched from d0significance() calculation. Setting dummy decoration d0sig=" << d0sigError );
    dec_d0sig(input) = d0sigError;
  }
 
  // don't bother calibrating or computing WP
  if ( input.pt() < 4e3 ) return StatusCode::SUCCESS;
  if ( !input.caloCluster() ) { ATH_MSG_WARNING( "FillElectron: no caloCluster found: " << input.caloCluster() ); return StatusCode::SUCCESS; }
 
  //Check DeadHVCellRemoval
  bool pass_deadHVTool = m_deadHVTool->accept(&input);
 
  if (m_debug) {
    unsigned char el_nPixHits(0), el_nSCTHits(0);
    input.trackParticle()->summaryValue(el_nPixHits, xAOD::numberOfPixelHits);
    input.trackParticle()->summaryValue(el_nSCTHits, xAOD::numberOfSCTHits);
 
    ATH_MSG_INFO( "ELECTRON eta: "         << input.eta());
    ATH_MSG_INFO( "ELECTRON phi: "         << input.phi());
    ATH_MSG_INFO( "ELECTRON cl eta: "      << input.caloCluster()->eta());
    ATH_MSG_INFO( "ELECTRON cl phi: "      << input.caloCluster()->phi());
    ATH_MSG_INFO( "ELECTRON cl e: "        << input.caloCluster()->e());
    ATH_MSG_INFO( "ELECTRON trk eta: "     << input.trackParticle()->eta());
    ATH_MSG_INFO( "ELECTRON trk phi: "     << input.trackParticle()->phi());
    ATH_MSG_INFO( "ELECTRON author: "      << input.author());
    ATH_MSG_INFO( "ELECTRON OQ: "          << acc_OQ(input));
    ATH_MSG_INFO( "ELECTRON nPixHits: "    << static_cast<int>(el_nPixHits));
    ATH_MSG_INFO( "ELECTRON nSCTHits: "    << static_cast<int>(el_nSCTHits));
    ATH_MSG_INFO( "ELECTRON deadHVTools: " << static_cast<bool>(pass_deadHVTool));
  }
 
  if (!pass_deadHVTool) return StatusCode::SUCCESS;
  if (!input.isGoodOQ(xAOD::EgammaParameters::BADCLUSELECTRON)) return StatusCode::SUCCESS;
 
  if ( m_elecSelLikelihoodBaseline.empty()) {
    ATH_MSG_ERROR("No baseline electron selector defined!");
    return StatusCode::FAILURE;
  }
 
  bool passBaseID = false;
  if (m_eleIdExpert) {
    passBaseID = bool(m_elecSelLikelihoodBaseline->accept(&input));
  } else {
    if (m_acc_eleIdBaseline.isAvailable(input)) {
      passBaseID = m_acc_eleIdBaseline(input); 
    } else {
      ATH_MSG_VERBOSE ("DFCommonElectronsLHxxx variables are not found. Calculating the ID from LH tool..");
      passBaseID = bool(m_elecSelLikelihoodBaseline->accept(&input));
    }
  }
 
  if ( !passBaseID && !m_force_noElId ) return StatusCode::SUCCESS;
 
  //baseline ID decoration for TauEl OR
  //dec_passBaseID(input) = true;
 
  // calibrate the electron 4-vector here only if within eta window
  if (std::abs(input.caloCluster()->etaBE(2)) >= etacut) return StatusCode::SUCCESS;
 
  if (m_eleBaselineCrackVeto){
    if  ( std::abs( input.caloCluster()->etaBE(2) ) >1.37 &&  std::abs( input.caloCluster()->etaBE(2) ) <1.52) {
      return StatusCode::SUCCESS;
    }
  }
 
  // corrections described in https://twiki.cern.ch/twiki/bin/view/AtlasProtected/EGammaCalibrationRun2
  if ( m_egammaCalibTool->applyCorrection(input) != CP::CorrectionCode::Ok)
    ATH_MSG_ERROR( "FillElectron: EgammaCalibTool applyCorrection failed ");
 
  if (m_isoCorrTool->applyCorrection(input)  != CP::CorrectionCode::Ok)
    ATH_MSG_ERROR("FillElectron: IsolationCorrectionTool applyCorrection failed");
 
  ATH_MSG_VERBOSE( "FillElectron: post-calibration pt=" << input.pt() );
 
  if (input.pt() < etcut) return StatusCode::SUCCESS;
 
  if (m_elebaselinez0>0. && std::abs(acc_z0sinTheta(input))>m_elebaselinez0) return StatusCode::SUCCESS;
  if (m_elebaselined0sig>0. && std::abs(acc_d0sig(input))>m_elebaselined0sig) return StatusCode::SUCCESS;
 
  //--- Do baseline isolation check
  if ( !( m_eleBaselineIso_WP.empty() ) &&  !( m_isoBaselineTool->accept(input) ) ) return StatusCode::SUCCESS;
 
  dec_baseline(input) = true;
  dec_selected(input) = 2;
  //disable if (!m_eleIso_WP.empty() && m_eleIso_WP.find("PLV")!=std::string::npos) ATH_CHECK(  ->augmentPLV(input) );
  if (!m_eleIso_WP.empty()) dec_isol(input) = bool(m_isoTool->accept(input));
  if (!m_eleIsoHighPt_WP.empty()) dec_isolHighPt(input) = bool(m_isoHighPtTool->accept(input));
 
  //ChargeIDSelector
  if( m_runECIS ){
    if (acc_passECIDS.isAvailable(input)) {
      dec_passChID(input) = acc_passECIDS(input); // Loose 97% WP!
    } else {
      dec_passChID(input) = bool(m_elecChargeIDSelectorTool->accept(&input));
      //disable double bdt = m_elecChargeIDSelectorTool->calculate(&input).getResult("bdt");
      //disable dec_ecisBDT(input) = bdt;
    }
  }
  else{
    dec_passChID(input) = true;
  }
 
  ATH_MSG_VERBOSE( "FillElectron: passed baseline selection" );
 
  return StatusCode::SUCCESS;
}

FillJet()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 384 of file Jets.cxx.

                                                                                                        {
 
    ATH_MSG_VERBOSE( "Starting FillJet on jet with pt=" << input.pt() );
    ATH_MSG_VERBOSE(  "jet (pt,eta,phi) before calibration " << input.pt() << " " << input.eta() << " " << input.phi() );
 
    static const SG::ConstAccessor<bool> acc_wValidKinRange(m_WDecorName+"_ValidKinRange");
    static const SG::ConstAccessor<bool> acc_zValidKinRange(m_ZDecorName+"_ValidKinRange");
    static const SG::ConstAccessor<bool> acc_topValidKinRange(m_TopDecorName+"_ValidKinRange");
    static const SG::ConstAccessor<bool> acc_wtagged(m_WDecorName+"_Tagged");
    static const SG::ConstAccessor<bool> acc_ztagged(m_ZDecorName+"_Tagged");
    static const SG::ConstAccessor<bool> acc_toptagged(m_TopDecorName+"_Tagged");
 
    if (doCalib) {
      if(!isFat){
        //disable - obsoleted ATH_CHECK( m_jetCalibTool->applyCalibration(input) );
      }
      else {
        //disable - obsoleted ATH_CHECK( m_jetFatCalibTool->applyCalibration(input) );
        dec_baseline(input) = ( input.pt() > m_jetPt ) || ( input.pt() > 20e3 ); // Allows for setting m_jetPt < 20e3
        dec_bad(input) = false;
        dec_signal(input) = false;
        dec_bjet_loose(input) = false;
        dec_effscalefact(input) = 1.;
        dec_passOR(input) = true;
        dec_bjet_jetunc(input) = false;
        dec_btag_weight(input) = -999.;
 
        dec_wtagged(input) = -1;
        dec_ztagged(input) = -1;
        dec_toptagged(input) = -1;
        if (doLargeRdecorations) {
 
          // Retrieve large-R tagging results for W/Z/top
          if (!m_WtagConfig.empty()) {
            ATH_CHECK(m_WTaggerTool->tag(input));
            // Only tag jets if they are inside the kinematic range
            if ( !acc_wValidKinRange(input) ) {
              ATH_MSG_VERBOSE("Large-R W candidate jet outside of recommended tagging range. Will set score to 0.");
              dec_wtagged(input) = 0;
            }
            else dec_wtagged(input) = acc_wtagged(input);
          }
          if (!m_ZtagConfig.empty()) {
            ATH_CHECK(m_ZTaggerTool->tag(input));
            // Only tag jets if they are inside the kinematic range
            if ( !acc_zValidKinRange(input) ) {
              ATH_MSG_VERBOSE("Large-R Z candidate jet outside of recommended tagging range. Will set score to 0.");
              dec_ztagged(input) = 0;
            }
            else dec_ztagged(input) = acc_ztagged(input);
          }
          if (!m_ToptagConfig.empty()) {
            ATH_CHECK(m_TopTaggerTool->tag(input));
            // Only tag jets if they are inside the kinematic range
            if ( !acc_topValidKinRange(input) ) {
              ATH_MSG_VERBOSE("Large-R Top candidate jet outside of recommended tagging range. Will set score to 0.");
              dec_toptagged(input) = 0;
            }
            else dec_toptagged(input) = acc_toptagged(input);
          }
 
        }
 
        // If a user hasn't specified an uncertainty config, then this tool will be empty
        // for large R jets
        if (!m_WTagjetUncertaintiesTool.empty() && !m_WTagUncConfig.empty() && !m_WtagConfig.empty() && doLargeRdecorations) {
          CP::CorrectionCode result = m_WTagjetUncertaintiesTool->applyCorrection(input);
          switch (result) {
          case CP::CorrectionCode::Error:
            ATH_MSG_ERROR( "Failed to apply largeR W-tag jet scale uncertainties.");
            return StatusCode::FAILURE;
            //break;
                case CP::CorrectionCode::OutOfValidityRange:
                  ATH_MSG_VERBOSE( "No valid pt/eta/m range for largeR W-tag jet scale uncertainties. ");
                  break;
          default:
            break;
          }
        } else {
          ATH_MSG_DEBUG( "No valid large-R W-tagged fat jet uncertainty, but FillJet called with a fat jet. Skipping uncertainties." );
        }
 
        if (!m_ZTagjetUncertaintiesTool.empty() && !m_ZTagUncConfig.empty() && !m_ZtagConfig.empty() && doLargeRdecorations) {
          CP::CorrectionCode result = m_ZTagjetUncertaintiesTool->applyCorrection(input);
          switch (result) {
          case CP::CorrectionCode::Error:
            ATH_MSG_ERROR( "Failed to apply largeR Z-tag jet scale uncertainties.");
            return StatusCode::FAILURE;
            //break;
          case CP::CorrectionCode::OutOfValidityRange:
            ATH_MSG_VERBOSE( "No valid pt/eta/m range for largeR Z-tag jet scale uncertainties. ");
            break;
          default:
            break;
          }
        } else {
          ATH_MSG_DEBUG( "No valid large-R Z-tagged fat jet uncertainty, but FillJet called with a fat jet. Skipping uncertainties." );
        }
 
        if (!m_TopTagjetUncertaintiesTool.empty() && !m_TopTagUncConfig.empty() && !m_ToptagConfig.empty() && doLargeRdecorations) {
          CP::CorrectionCode result = m_TopTagjetUncertaintiesTool->applyCorrection(input);
          switch (result) {
          case CP::CorrectionCode::Error:
            ATH_MSG_ERROR( "Failed to apply largeR Top-tag jet scale uncertainties.");
            return StatusCode::FAILURE;
            //break;
          case CP::CorrectionCode::OutOfValidityRange:
            ATH_MSG_VERBOSE( "No valid pt/eta/m range for largeR Top-tag jet scale uncertainties. ");
            break;
          default:
            break;
          }
        } else {
          ATH_MSG_DEBUG( "No valid large-R Top-tagged fat jet uncertainty, but FillJet called with a fat jet. Skipping uncertainties." );
        }
 
        if (!m_fatjetUncertaintiesTool.empty() && m_currentSyst.name().find("PseudoData") == std::string::npos) {
          CP::CorrectionCode result = m_fatjetUncertaintiesTool->applyCorrection(input);
          switch (result) {
          case CP::CorrectionCode::Error:
            ATH_MSG_ERROR( "Failed to apply largeR jet scale uncertainties.");
            return StatusCode::FAILURE;
            //break;
          case CP::CorrectionCode::OutOfValidityRange:
            ATH_MSG_VERBOSE( "No valid pt/eta/m range for largeR jet scale uncertainties. ");
            break;
          default:
            break;
          }
        } else {
          ATH_MSG_DEBUG( "No valid fat jet uncertainty, but FillJet called with a fat jet. Skipping uncertainties." );
        }
 
        // Use the PDSmeared uncertainties tool on the systematic with PseudoData in the name
        if (!m_fatjetUncertaintiesPDSmearTool.empty() && m_fatJetUncertaintiesPDsmearing && m_currentSyst.name().find("PseudoData")) {
          CP::CorrectionCode result = m_fatjetUncertaintiesPDSmearTool->applyCorrection(input);
          switch (result) {
          case CP::CorrectionCode::Error:
            ATH_MSG_ERROR( "Failed to apply largeR jet scale PD uncertainties.");
            return StatusCode::FAILURE;
            //break;
          case CP::CorrectionCode::OutOfValidityRange:
            ATH_MSG_VERBOSE( "No valid pt/eta/m range for largeR jet scale uncertainties. ");
            break;
          default:
            break;
          }
        } else {
          ATH_MSG_DEBUG( "No valid fat jet uncertainty, but FillJet called with a fat jet. Skipping uncertainties." );
        }
 
        if (!m_fatjetFFSmearingTool.empty() && std::find(m_fatjetFFSmearingSyst.begin(), m_fatjetFFSmearingSyst.end(), m_currentSyst) != m_fatjetFFSmearingSyst.end()) {
          CP::CorrectionCode result = m_fatjetFFSmearingTool->applyCorrection(input);
          switch (result) {
          case CP::CorrectionCode::Error:
            ATH_MSG_ERROR( "Failed to apply largeR jet scale uncertainties.");
            return StatusCode::FAILURE;
            //break;
          case CP::CorrectionCode::OutOfValidityRange:
            ATH_MSG_VERBOSE( "No valid pt/eta/m range for largeR jet scale uncertainties. ");
            break;
          default:
            break;
          }
        } else {
          ATH_MSG_DEBUG( "No valid fat jet uncertainty, but FillJet called with a fat jet. Skipping uncertainties." );
        }
 
        ATH_MSG_VERBOSE(  "Large-R jet (pt,eta,phi) after calibration " << input.pt() << " " << input.eta() << " " << input.phi() );
 
        return StatusCode::SUCCESS;
      }
      ATH_MSG_VERBOSE(  "jet (pt,eta,phi) after calibration " << input.pt() << " " << input.eta() << " " << input.phi() );
 
    }
 
    dec_passOR(input) = true;
    dec_bjet_jetunc(input) = false;
 
    if (m_useBtagging) {
      if (m_BtagWP != "Continuous") this->IsBJet(input);
      else this->IsBJetContinuous(input);
    }
 
   if ( (input.pt() > m_jetPt) || (input.pt() > 15e3) ) {
     if(!isFat && m_currentSyst.name().find("PseudoData") == std::string::npos) {
       // Use the normal jet uncertainties tool for this systematic and do not use the PDSmeared initialised tool
       CP::CorrectionCode result = m_jetUncertaintiesTool->applyCorrection(input);
       switch (result) {
         case CP::CorrectionCode::Error:
           ATH_MSG_ERROR( "Failed to apply JES correction" );
           break;
         case CP::CorrectionCode::OutOfValidityRange:
           ATH_MSG_WARNING( "JES correction OutOfValidity range."); // Jet (pt,eta,phi) = (" << input.pt() << ", " << input.eta() << ", " << input.phi() << ")");
           break;
         default:
                break;
       }
     }
   }
 
   if (m_jetUncertaintiesPDsmearing) {
     if ( (input.pt() > m_jetPt) || (input.pt() > 15e3) ) {
       if(!isFat && m_currentSyst.name().find("PseudoData")){
         // Use the PDSmeared uncertainties tool on the systematic with PseudoData in the name
         CP::CorrectionCode result = m_jetUncertaintiesPDSmearTool->applyCorrection(input);
         switch (result) {
           case CP::CorrectionCode::Error:
             ATH_MSG_ERROR( "Failed to apply JES correction" );
             break;
           case CP::CorrectionCode::OutOfValidityRange:
             ATH_MSG_WARNING( "JES correction OutOfValidity range."); // Jet (pt,eta,phi) = (" << input.pt() << ", " << input.eta() << ", " << input.phi() << ")");
             break;
           default:
             break;
         }
       }
     }
   }
 
 
    ATH_MSG_VERBOSE(  "jet (pt,eta,phi) after JES correction " << input.pt() << " " << input.eta() << " " << input.phi() );
 
    dec_passJvt(input) = !m_applyJVTCut || m_jetNNJvtSelectionTool->accept(&input);
    dec_passFJvt(input) = !m_doFwdJVT ||  m_jetfJvtSelectionTool->accept(&input);
    dec_baseline(input) = ( input.pt() > m_jetPt ) || ( input.pt() > 20e3 ); // Allows for setting m_jetPt < 20e3
    dec_bad(input) = false;
    dec_signal_less_JVT(input) = false;
    dec_signal(input) = false;
    dec_bjet_loose(input) = false;
    dec_effscalefact(input) = 1.;
 
    //new state for OR   .  0=non-baseline objects, 1=for baseline jets not passing JVT, 2=for any other baseline object
    if (acc_baseline(input) ){
      if( acc_passJvt(input) ) dec_selected(input) = 2;
      else                     dec_selected(input) = 1;
    }
    else{
      dec_selected(input) = 0;
    }
 
    if (m_useBtagging && !m_orBtagWP.empty()) {
      dec_bjet_loose(input) = this->IsBJetLoose(input);
    }
 
    if (m_debug) {
      ATH_MSG_INFO( "JET pt: " << input.pt() );
      ATH_MSG_INFO( "JET eta: " << input.eta() );
      ATH_MSG_INFO( "JET phi: " << input.phi() );
      ATH_MSG_INFO( "JET E: " << input.e() );
      ATH_MSG_INFO( "JET Ceta: " << input.jetP4(xAOD::JetConstitScaleMomentum).eta() );
      ATH_MSG_INFO( "JET Cphi: " << input.jetP4(xAOD::JetConstitScaleMomentum).phi() );
      ATH_MSG_INFO( "JET CE: " << input.jetP4(xAOD::JetConstitScaleMomentum).e() );
      ATH_MSG_INFO( "JET Cm: " << input.jetP4(xAOD::JetConstitScaleMomentum).M() ); // fix-me M
 
    }
 
    return StatusCode::SUCCESS;
  }

FillMuon()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 207 of file Muons.cxx.

                                                                               {
  
  ATH_MSG_VERBOSE( "Starting FillMuon on mu with pt=" << input.pt() );
  
  dec_baseline(input) = false;
  dec_selected(input) = 0;
  dec_signal(input) = false;
  dec_isol(input) = false;
  dec_isolHighPt(input) = false;
  dec_passedHighPtCuts(input) = false;
  dec_passSignalID(input) = false;
 
  if (m_muEffCorrForce1D) {
    dec_DFCommonJetDr(input) = -2.0;
  } else if (!acc_DFCommonJetDr.isAvailable(input)) {
    dec_dRJet(input) = -2.0;
  }
 
  // don't bother calibrating or computing WP
  if ( input.pt() < 3e3 ) return StatusCode::SUCCESS;
 
  ATH_MSG_VERBOSE( "MUON pt before calibration " << input.pt() );
 
  ATH_MSG_VERBOSE( "MUON eta  = " << input.eta() );
  ATH_MSG_VERBOSE( "MUON type = " << input.muonType() );
  ATH_MSG_VERBOSE( "MUON author = " << input.author() );
 
  if (m_muonCalibTool->applyCorrection( input ) == CP::CorrectionCode::OutOfValidityRange){
    ATH_MSG_VERBOSE("FillMuon: applyCorrection out of validity range");
  }
 
  ATH_MSG_VERBOSE( "MUON pt after calibration " << input.pt() );
 
  const xAOD::EventInfo* evtInfo = nullptr;
  ATH_CHECK( evtStore()->retrieve( evtInfo, "EventInfo" ) );
  const xAOD::Vertex* pv = this->GetPrimVtx();
  double primvertex_z = pv ? pv->z() : 0;
  //const xAOD::TrackParticle* track = input.primaryTrackParticle();
  const xAOD::TrackParticle* track;
  if (input.muonType() == xAOD::Muon::SiliconAssociatedForwardMuon) {
    track = input.trackParticle(xAOD::Muon::CombinedTrackParticle);
    if (!track) return StatusCode::SUCCESS; // don't treat SAF muons without CB track further  
  }
  else {
    track = input.primaryTrackParticle();
  }
 
  //impact parameters (after applyCorrection() so to have the primaryTrack links restored in old buggy samples)
  if (track){
    dec_z0sinTheta(input) = (track->z0() + track->vz() - primvertex_z) * TMath::Sin(input.p4().Theta());
  } else {
    ATH_MSG_WARNING("FillMuon: Muon of pT and eta " << input.pt() << " MeV " << input.eta() << " has no associated track");
  }
  //protect against exception thrown for null or negative d0sig
  try {
    if (track)
      dec_d0sig(input) = xAOD::TrackingHelpers::d0significance( track , evtInfo->beamPosSigmaX(), evtInfo->beamPosSigmaY(), evtInfo->beamPosSigmaXY() );
    else
      dec_d0sig(input) = -99.;
  }
  catch (...) {
    float d0sigError = -99.; 
    ATH_MSG_WARNING("FillMuon : Exception caught from d0significance() calculation. Setting dummy decoration d0sig=" << d0sigError );
    dec_d0sig(input) = d0sigError;
  }
  
  if (m_debug) {
    // Summary variables in
    // /cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.0.3/xAODTracking/Root/TrackSummaryAccessors_v1.cxx
 
    unsigned char nBLHits(0), nPixHits(0), nPixelDeadSensors(0), nPixHoles(0),
      nSCTHits(0), nSCTDeadSensors(0), nSCTHoles(0), nTRTHits(0), nTRTOutliers(0);
 
    if (track){
      track->summaryValue( nBLHits, xAOD::numberOfBLayerHits);
      track->summaryValue( nPixHits, xAOD::numberOfPixelHits);
      track->summaryValue( nPixelDeadSensors, xAOD::numberOfPixelDeadSensors);
      track->summaryValue( nPixHoles, xAOD::numberOfPixelHoles);
 
      track->summaryValue( nSCTHits, xAOD::numberOfSCTHits);
      track->summaryValue( nSCTDeadSensors, xAOD::numberOfSCTDeadSensors);
      track->summaryValue( nSCTHoles, xAOD::numberOfSCTHoles);
 
      track->summaryValue( nTRTHits, xAOD::numberOfTRTHits);
      track->summaryValue( nTRTOutliers, xAOD::numberOfTRTOutliers);
    }
 
    ATH_MSG_INFO( "MUON pt:   " << input.pt() );
    ATH_MSG_INFO( "MUON eta:  " << input.eta() );
    ATH_MSG_INFO( "MUON phi:  " << input.phi() );
    ATH_MSG_INFO( "MUON comb: " << (input.muonType() == xAOD::Muon::Combined));
    ATH_MSG_INFO( "MUON sTag: " << (input.muonType() == xAOD::Muon::SegmentTagged));
    ATH_MSG_INFO( "MUON loose:" << (input.quality() == xAOD::Muon::Loose));
    ATH_MSG_INFO( "MUON bHit: " << static_cast<int>( nBLHits ));
    ATH_MSG_INFO( "MUON pHit: " << static_cast<int>( nPixHits ));
    ATH_MSG_INFO( "MUON pDead:" << static_cast<int>( nPixelDeadSensors ));
    ATH_MSG_INFO( "MUON pHole:" << static_cast<int>( nPixHoles ));
    ATH_MSG_INFO( "MUON sHit: " << static_cast<int>( nSCTHits));
    ATH_MSG_INFO( "MUON sDead:" << static_cast<int>( nSCTDeadSensors ));
    ATH_MSG_INFO( "MUON sHole:" << static_cast<int>( nSCTHoles ));
    ATH_MSG_INFO( "MUON tHit: " << static_cast<int>( nTRTHits ));
    ATH_MSG_INFO( "MUON tOut: " << static_cast<int>( nTRTOutliers ));
 
    const xAOD::TrackParticle* idtrack =
      input.trackParticle( xAOD::Muon::InnerDetectorTrackParticle );
 
    if ( !idtrack) {
      ATH_MSG_VERBOSE( "No ID track!! " );
    } else {
      ATH_MSG_VERBOSE( "ID track pt: "  << idtrack->pt());
    }
  }
  
  if ( !m_force_noMuId && !m_muonSelectionToolBaseline->accept(input)) return StatusCode::SUCCESS;
  
  if (input.pt() <= ptcut || std::abs(input.eta()) >= etacut) return StatusCode::SUCCESS;
 
  if (m_mubaselinez0>0. && std::abs(acc_z0sinTheta(input))>m_mubaselinez0) return StatusCode::SUCCESS;
  if (m_mubaselined0sig>0. && std::abs(acc_d0sig(input))>m_mubaselined0sig) return StatusCode::SUCCESS;
 
  //--- Do baseline isolation check
  if ( !( m_muBaselineIso_WP.empty() ) &&  !( m_isoBaselineTool->accept(input) ) ) return StatusCode::SUCCESS;
 
  dec_baseline(input) = true;
  dec_selected(input) = 2;
 
  //disable  if (!m_muIso_WP.empty() && m_muIso_WP.find("PLV")!=std::string::npos) ATH_CHECK( m_isoToolLowPtPLV->augmentPLV(input) );
  if (!m_muIso_WP.empty()) dec_isol(input) = bool(m_isoTool->accept(input));
  if (!m_muIsoHighPt_WP.empty()) dec_isolHighPt(input) = bool(m_isoHighPtTool->accept(input));
  dec_passSignalID(input) = bool(m_muonSelectionTool->accept(input));
  
  ATH_MSG_VERBOSE("FillMuon: passed baseline selection");
  return StatusCode::SUCCESS;
}

FillPhoton()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 78 of file Photons.cxx.

                                                                                   {
 
  ATH_MSG_VERBOSE( "Starting FillPhoton on ph with pre-calibration pt=" << input.pt() );
 
  if ( !input.caloCluster() ) {
     ATH_MSG_WARNING( "FillPhoton: no caloCluster found: " << input.caloCluster() );
     return StatusCode::SUCCESS;
  }
 
 //Check DeadHVCellRemoval
  bool pass_deadHVTool = m_deadHVTool->accept(&input);
 
  if (m_debug) {
    ATH_MSG_INFO( "PHOTON eta: " << input.eta() );
    ATH_MSG_INFO( "PHOTON phi: " << input.phi() );
    ATH_MSG_INFO( "PHOTON cl eta: " << input.caloCluster()->eta() );
    ATH_MSG_INFO( "PHOTON cl phi: " << input.caloCluster()->phi() );
    ATH_MSG_INFO( "PHOTON cl e: " << input.caloCluster()->e() );
    ATH_MSG_INFO( "PHOTON OQ: " << input.OQ() );
    ATH_MSG_INFO( "PHOTON author: " << input.author() );
    ATH_MSG_INFO( "PHOTON deadHVTools: " << pass_deadHVTool );
  }
 
  dec_baseline(input) = false;
  dec_selected(input) = 0;
  dec_isol(input) = false;
  dec_isEM(input) = 0;
 
  if (!pass_deadHVTool) return StatusCode::SUCCESS; 
 
  // Author cuts needed according to https://twiki.cern.ch/twiki/bin/view/AtlasProtected/EGammaIdentificationRun2#Photon_authors
  if ( !(input.author() & (xAOD::EgammaParameters::AuthorPhoton + xAOD::EgammaParameters::AuthorAmbiguous)) )
    return StatusCode::SUCCESS;
 
  // calibrate the photon 4-vector here only if within eta window
  if (std::abs(input.caloCluster()->etaBE(2)) >= etacut) return StatusCode::SUCCESS;
 
  if (m_photonBaselineCrackVeto){
    if  ( std::abs( input.caloCluster()->etaBE(2) ) >1.37 &&  std::abs( input.caloCluster()->etaBE(2) ) <1.52) {
      return StatusCode::SUCCESS;
    }
  }
 
  if (m_egammaCalibTool->applyCorrection(input)  != CP::CorrectionCode::Ok)
    ATH_MSG_ERROR("FillPhoton: EgammaCalibTool applyCorrection failed");
 
  if (m_isoCorrTool->applyCorrection(input)  != CP::CorrectionCode::Ok)
    ATH_MSG_ERROR("FillPhoton: IsolationCorrectionTool applyCorrection failed");
 
  ATH_MSG_VERBOSE( "FillPhoton: post-calibration pt=" << input.pt() );
 
  if (input.pt() < ptcut) return StatusCode::SUCCESS;
 
  //Object quality cut as described at https://twiki.cern.ch/twiki/bin/view/AtlasProtected/EGammaIdentificationRun2#Object_quality_cut
  if (!input.isGoodOQ(xAOD::EgammaParameters::BADCLUSPHOTON))
    return StatusCode::SUCCESS;
 
  //Photon quality as in https://twiki.cern.ch/twiki/bin/view/AtlasProtected/EGammaIdentificationRun2#Photon_cleaning
  bool passPhCleaning = false;
  if (acc_passPhCleaning.isAvailable(input) && acc_passPhCleaningNoTime.isAvailable(input)) {
    if ( (!m_photonAllowLate && acc_passPhCleaning(input)) || (m_photonAllowLate && acc_passPhCleaningNoTime(input)) ) passPhCleaning = true;
  } else {
    ATH_MSG_VERBOSE ("DFCommonPhotonsCleaning is not found in DAOD..");
    if ( (!m_photonAllowLate && PhotonHelpers::passOQquality(input)) || 
         ( m_photonAllowLate && PhotonHelpers::passOQqualityDelayed(input)) ) passPhCleaning = true;
  }
  if (!passPhCleaning) return StatusCode::SUCCESS;
 
 
  bool passBaseID = false;
  if (m_acc_photonIdBaseline.isAvailable(input)) {
    passBaseID = bool(m_acc_photonIdBaseline(input));
  } else {
    passBaseID = bool(m_photonSelIsEMBaseline->accept(&input));
  }
  if (!passBaseID) return StatusCode::SUCCESS;
 
  //--- Do baseline isolation check
  if ( !( m_photonBaselineIso_WP.empty() ) &&  !( m_isoBaselineTool->accept(input) ) ) return StatusCode::SUCCESS;
 
  dec_baseline(input) = true;
  dec_selected(input) = 2;
  if (!m_photonIso_WP.empty()) dec_isol(input) = bool(m_isoTool->accept(input));
 
  ATH_MSG_VERBOSE("FillPhoton: passed baseline selection.");
  return StatusCode::SUCCESS;
}

FillTau()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 76 of file Taus.cxx.

                                                     {
 
  ATH_MSG_VERBOSE( "Starting FillTau on tau with pT = " << input.pt()/1000 << " GeV" );
  ATH_MSG_VERBOSE( "TAU pT before smearing " << input.pt()/1000 << " GeV");
 
  // do truth matching first (required unless already done in AOD->DAOD and truth matching info kept in DAOD)
  if (m_tauDoTTM && !isData()) m_tauTruthMatch->getTruth(input);
  ATH_MSG_VERBOSE("Tau truth matching done");
 
  // apply the calibration to data as well (not needed in R22, unless MVA TES gets updated)
  if (std::abs(input.eta()) <= 2.5 && input.nTracks() > 0) {
    if (m_tauSmearingTool->applyCorrection(input) != CP::CorrectionCode::Ok) {
      ATH_MSG_ERROR(" Tau smearing failed " );
    } else { ATH_MSG_VERBOSE("Tau smearing done"); }
  }
  
  ATH_MSG_VERBOSE( "TAU pt after smearing " << input.pt()/1000. );
 
  // if tauPrePtCut set, apply min pT cut here before calling tau selection tool 
  // (avoid exceptions when running on derivations with removed tracks for low-pT taus, e.g. HIGG4D2)
  if (input.pt() > m_tauPrePtCut) {
    dec_baseline(input) = bool(m_tauSelToolBaseline->accept( input ));
  }
  else {
    dec_baseline(input) = false;
  }
  if (acc_baseline(input)) dec_selected(input) = 2;
  else                     dec_selected(input) = 0;
 
  if (acc_baseline(input)) ATH_MSG_VERBOSE("FillTau: passed baseline selection");
  else ATH_MSG_VERBOSE("FillTau: failed baseline selection");
  return StatusCode::SUCCESS;
}

FillTrackJet()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 644 of file Jets.cxx.

                                                         {
 
    ATH_MSG_VERBOSE( "Starting FillTrackJet on jet with pt=" << input.pt() );
 
    dec_btag_weight(input) = -999.;
    dec_effscalefact(input) = 1.;
 
    if (m_defaultTrackJets == "AntiKtVR30Rmax4Rmin02TrackJets") {
      // VR recommendation
      // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/BTagCalib2017#Recommendations_for_variable_rad
      dec_baseline(input) = input.pt() >= 5e3 && input.numConstituents() >= 2;
      if (m_trkJetPt < 10e3)
        ATH_MSG_WARNING ("The pt threshold of VR jets you set is: " << m_trkJetPt/1000. << " GeV. But VR jets with pt < 10GeV are uncalibrated.");
      dec_signal(input) = acc_baseline(input) && input.pt() >= m_trkJetPt && std::abs(input.eta()) <= m_trkJetEta;
      dec_VRradius(input) = std::max(0.02,std::min(0.4,30000./input.pt()));
      dec_passDRcut(input) = acc_signal(input);
    } else {
      dec_baseline(input) = input.pt() >= m_trkJetPt && std::abs(input.eta()) <= m_trkJetEta;
      dec_signal(input) = acc_baseline(input);
    }
 
    if (m_useBtagging_trkJet) {
      if (m_BtagWP_trkJet != "Continuous") this->IsTrackBJet(input);
      else this->IsTrackBJetContinuous(input);
    }
 
    if (m_debug) {
      ATH_MSG_INFO( "TRK JET pt: " << input.pt() );
      ATH_MSG_INFO( "TRK JET eta: " << input.eta() );
      ATH_MSG_INFO( "TRK JET phi: " << input.phi() );
      ATH_MSG_INFO( "TRK JET E: " << input.e() );
    }
 
    return StatusCode::SUCCESS;
  }

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.

                                                                                             {
 
  pdgid1 = 0;
  pdgid2 = 0;
 
  //go for TRUTH1-like ...
  const xAOD::TruthParticle* firstsp(nullptr);
  const xAOD::TruthParticle* secondsp(nullptr);
 
  for (unsigned int p=0; p < truthE->nTruthParticles(); ++p){
 
    const xAOD::TruthParticle* tp = truthE->truthParticle(p);
 
    //check ifSUSY particle
    if (MC::isSquark(tp) || MC::isSlepton(tp) || MC::isGaugino(tp)) {
 
      if (tp->nParents() != 0) {
        if ( !MC::isSUSY(tp->parent(0))) {
          if (!firstsp) {
            firstsp = tp;
          } else if (!secondsp) {
            secondsp = tp;
          } else {
            if (firstsp->nChildren() != 0 && HepMC::is_same_particle(tp,firstsp->child(0))) {
              firstsp = tp;
            }
            else if (secondsp->nChildren() != 0 && HepMC::is_same_particle(tp,secondsp->child(0))) {
              secondsp = tp;
            }
            else if (firstsp->nChildren() != 0 && HepMC::is_same_particle(firstsp->child(0),secondsp)) {
              firstsp = secondsp;
              secondsp = tp;
            }
            else if (secondsp->nChildren() != 0 && HepMC::is_same_particle(secondsp->child(0),firstsp)) {
              secondsp = firstsp;
              firstsp = tp;
            }
          }
        }
      }
    }
  }
 
  // quit if no sparticles found
  if (!firstsp && !secondsp) return true; // should find none or two
  
  if (firstsp->nChildren() == 1) {
    for (unsigned int p=0; p < truthE->nTruthParticles(); ++p){
      const xAOD::TruthParticle* tp = truthE->truthParticle(p);
      if (HepMC::is_same_particle(tp,firstsp->child(0)) && tp->pdgId() != firstsp->pdgId()) {
        firstsp = tp;
        break;
      }
    }
  }
 
  if (secondsp->nChildren() == 1) {
    for (unsigned int p=0; p < truthE->nTruthParticles(); ++p){
      const xAOD::TruthParticle* tp = truthE->truthParticle(p);
      if (HepMC::is_same_particle(tp,secondsp->child(0)) && tp->pdgId() != secondsp->pdgId()) {
        secondsp = tp;
        break;
      }
    }
  }
 
  if (MC::isSUSY(firstsp)) pdgid1 = firstsp->pdgId();
  if (MC::isSUSY(secondsp)) pdgid2 = secondsp->pdgId();
 
  // Return gracefully:
  return true;
}

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.

                                                                                                                        {
 
  pdgid1 = 0;
  pdgid2 = 0;
 
  //check for TRUTH3 structure first
  if(isTruth3){
    if(!truthP || truthP->size()<2){
      return false;
    }
    
    //get ID of first two BSM particles
    pdgid1 = (*truthP)[0]->pdgId();
    pdgid2 = (*truthP)[1]->pdgId();
    return true;
  }
 
  //go for TRUTH1-like if not...
  const xAOD::TruthParticle* firstsp(nullptr);
  const xAOD::TruthParticle* secondsp(nullptr);
 
  if (!truthP || truthP->empty()) {
    return false;
  }
  for (const xAOD::TruthParticle* tp : *truthP) {
    if (MC::isSquark(tp) || MC::isSlepton(tp) || MC::isGaugino(tp)) {
 
      if (tp->nParents() != 0) {
 
        if ( !MC::isSUSY(tp->parent(0))) {
          if (!firstsp) {
            firstsp = tp;
          } else if (!secondsp) {
            secondsp = tp;
          } else {
            if (firstsp->nChildren() != 0 && HepMC::is_same_particle(tp,firstsp->child(0))) {
              firstsp = tp;
            }
            else if (secondsp->nChildren() != 0 && HepMC::is_same_particle(tp,secondsp->child(0))) {
              secondsp = tp;
            }
            else if (firstsp->nChildren() != 0 && HepMC::is_same_particle(firstsp->child(0),secondsp)) {
              firstsp = secondsp;
              secondsp = tp;
            }
            else if (secondsp->nChildren() != 0 && HepMC::is_same_particle(secondsp->child(0),firstsp)) {
              secondsp = firstsp;
              firstsp = tp;
            }
          }
        }
      }
    }
  }
 
  // quit if no sparticles found
  if (!firstsp && !secondsp) return true; // should find none or two
 
  if (firstsp->nChildren() == 1) {
    for (const xAOD::TruthParticle* tp : *truthP) {
      if (HepMC::is_same_particle(tp,firstsp->child(0)) && tp->pdgId() != firstsp->pdgId()) {
        firstsp = tp;
        break;
      }
    }
  }
 
  if (secondsp->nChildren() == 1) {
    for (const xAOD::TruthParticle* tp : *truthP) {
      if (HepMC::is_same_particle(tp,secondsp->child(0)) && tp->pdgId() != secondsp->pdgId()) {
        secondsp = tp;
        break;
      }
    }
  }
 
  if (MC::isSUSY(firstsp)) pdgid1 = firstsp->pdgId();
  if (MC::isSUSY(secondsp)) pdgid2 = secondsp->pdgId();
 
  // Return gracefully:
  return true;
}

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.

                                                                                                   {
 
  if (!truthE) {
    ATH_MSG_ERROR("Null TruthEvent pointer!!");
    return StatusCode::FAILURE;
  }
  if ( !SUSYObjDef_xAOD::FindSusyHardProc(truthE, pdgid1, pdgid2) ) {
    ATH_MSG_ERROR("Problem finding SUSY hard process");
    return StatusCode::FAILURE;
  }
  if (pdgid1 == 0 || pdgid2 == 0) {
    ATH_MSG_DEBUG("No sparticles found!");
  }
  return StatusCode::SUCCESS;
}

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.

                                                                                                                              {
  if (!truthP) {
    ATH_MSG_ERROR("Null TruthParticleContainer pointer!!");
    return StatusCode::FAILURE;
  }
  if (truthP->empty()) {
    ATH_MSG_ERROR("Empty TruthParticleContainer!!");
    return StatusCode::FAILURE;
  }
  if ( !SUSYObjDef_xAOD::FindSusyHardProc(truthP, pdgid1, pdgid2, isTruth3) ) {
    ATH_MSG_ERROR("Problem finding SUSY hard process");
    return StatusCode::FAILURE;
  }
  if (pdgid1 == 0 || pdgid2 == 0) {
    ATH_MSG_DEBUG("No sparticles found!");
  }
  return StatusCode::SUCCESS;
}

FindSusyHP() [3/3]

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

Definition at line 76 of file Truth.cxx.

                                                                     {
 
  const xAOD::TruthParticleContainer* truthP = nullptr;
  bool isTruth3 = false;
  std::string key_T1 = "TruthParticles"; 
  std::string key_T3 = "TruthBSM";
 
  ATH_MSG_DEBUG("Contains " << key_T1 << ": " << ((evtStore()->contains<xAOD::TruthParticleContainer>( key_T1 ))?1:0));
  ATH_MSG_DEBUG("Contains " << key_T3 << ": " << ((evtStore()->contains<xAOD::TruthParticleContainer>( key_T3 ))?1:0));
 
  if(evtStore()->contains<xAOD::TruthParticleContainer>( key_T1 )){
    ATH_CHECK( evtStore()->retrieve(truthP, key_T1) );
    ATH_MSG_DEBUG("Retrieved " << key_T1 << " : size = " << truthP->size());
    if (truthP->empty()) { ATH_MSG_WARNING(key_T1 << " is empty. Skipping FindSusyHP."); return StatusCode::SUCCESS; }
  }
  else if(evtStore()->contains<xAOD::TruthParticleContainer>( key_T3 )){
    isTruth3=true;    
    ATH_CHECK( evtStore()->retrieve(truthP, key_T3) );
    ATH_MSG_DEBUG("Retrieved " << key_T3 << " : size = " << truthP->size());
    if (truthP->empty()) { ATH_MSG_WARNING(key_T3 << " is empty. Skipping FindSusyHP."); return StatusCode::SUCCESS; }
  }
  else {
    ATH_MSG_WARNING("Neither " << key_T1 << " nor " << key_T3 << " are avaible. Skipping FindSusyHP.");
    return StatusCode::SUCCESS;
  }
 
  return SUSYObjDef_xAOD::FindSusyHP(truthP, pdgid1, pdgid2, isTruth3);
}

FJVT_SF()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 1061 of file Jets.cxx.

                                                              {
 
    float totalSF = 1.;
    if (!m_doFwdJVT) return totalSF;
 
    ConstDataVector<xAOD::JetContainer> fjvtjets(SG::VIEW_ELEMENTS);
    for (const xAOD::Jet* jet : *jets) {
      // Only jets that were good for every cut except JVT
      if (acc_signal_less_JVT(*jet) && acc_passOR(*jet)) {
        fjvtjets.push_back(jet);
      }
    }
 
    for (const xAOD::Jet* jet : fjvtjets) {
      float current_sf = 0;
 
      // the SF are only applied for HS jets and implicitely requires the presense of the isHS decoration
      CP::CorrectionCode result;
      if (acc_passFJvt(*jet)) {
        result = m_jetfJvtEfficiencyTool->getEfficiencyScaleFactor(*jet,current_sf);
      }
      else {
        result = m_jetfJvtEfficiencyTool->getInefficiencyScaleFactor(*jet,current_sf);
      }
 
      switch (result) {
        case CP::CorrectionCode::Error:
          // this is probably not right, should report an error here
          ATH_MSG_ERROR("Inexplicably failed fJVT calibration" );
          break;
        case CP::CorrectionCode::OutOfValidityRange:
          // no fJvt SF for jet, that is ok e.g. for jets with |eta| < 2.5
          ATH_MSG_VERBOSE( "Skip SF application in SUSYTools_xAOD::FJVT_SF as jet outside validate range" );
          break;
        default:
          ATH_MSG_VERBOSE( "Retrieve SF for jet in SUSYTools_xAOD::FJVT_SF with value " << current_sf );
          totalSF *= current_sf;
      }
 
    }
 
    ATH_MSG_VERBOSE( "Retrieve total SF for jet container in SUSYTools_xAOD::FJVT_SF with value " << totalSF );
 
    return totalSF;
  }

FJVT_SFsys()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 1107 of file Jets.cxx.

                                                                                                    {
 
    float totalSF = 1.;
    if (!m_doFwdJVT) return totalSF;
 
    //Set the new systematic variation
    StatusCode ret = m_jetfJvtEfficiencyTool->applySystematicVariation(systConfig);
    if ( ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure fJvtEfficiencyTool for systematic var. " << systConfig.name() );
    }
 
    // Delegate
    totalSF = SUSYObjDef_xAOD::FJVT_SF( jets );
 
    if (m_doFwdJVT) {
      ret = m_jetfJvtEfficiencyTool->applySystematicVariation(m_currentSyst);
      if ( ret != StatusCode::SUCCESS) {
        ATH_MSG_ERROR("Cannot configure fJvtEfficiencyTool for systematic var. " << systConfig.name() );
      }
    }
 
    return totalSF;
  }

GetCorrectedActualInteractionsPerCrossing()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3029 of file SUSYObjDef_xAOD.cxx.

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

GetCorrectedAverageInteractionsPerCrossing()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3024 of file SUSYObjDef_xAOD.cxx.

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

GetDataWeight()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3019 of file SUSYObjDef_xAOD.cxx.

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

getDefaultJetUncConfig()

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

protected

Definition at line 1829 of file SUSYObjDef_xAOD.cxx.

                                                  {
  if (m_isRun3)
    return isAtlfast() ? "rel22/Spring2025_PreRec/R4_CategoryReduction_FullJER_MC23.config" : "rel22/Spring2025_PreRec/R4_CategoryReduction_FullJER_MC23.config";
  else
    return isAtlfast() ? "rel22/Spring2025_PreRec/R4_CategoryReduction_FullJER_MC20_MC21.config" : "rel22/Spring2025_PreRec/R4_CategoryReduction_FullJER_MC20_MC21.config";  
}

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.

{
  if (!m_tool_init) {
    ATH_MSG_ERROR("SUSYTools was not initialized!!");
    return StatusCode::FAILURE;
  }
 
   // Initializing prompt/LRT OR procedure
  auto outputCol = std::make_unique<xAOD::ElectronContainer>();
  std::unique_ptr<xAOD::ElectronAuxContainer> outputAuxCol;
  outputAuxCol = std::make_unique<xAOD::ElectronAuxContainer>();
  outputCol->setStore(outputAuxCol.get());
  ATH_CHECK( m_outElectronLocation.initialize() );
 
  if (bool(m_eleLRT) && !lrtelekey.empty() && evtStore()->contains<xAOD::ElectronContainer>(lrtelekey)){
    ATH_MSG_DEBUG("Applying prompt/LRT electron OR procedure"); 
 
    // First identify if merged container has already been made (for instances where GetElectrons() is called more than once)
    if (evtStore()->contains<xAOD::ElectronContainer>("StdWithLRTElectrons")) {
      ATH_MSG_DEBUG("Merged prompt/LRT container already created in TStore");  
    } else {
      ATH_MSG_DEBUG("Creating merged prompt/LRT container in TStore");
 
      // Retrieve prompt and LRT electrons from TStore
      ATH_CHECK( evtStore()->retrieve(prompt_electrons, elekey) );
      ATH_CHECK( evtStore()->retrieve(lrt_electrons, lrtelekey) );
 
      // Remove LRT electrons as flagged by filter for uncertainty
      auto filtered_electrons = std::make_unique<xAOD::ElectronContainer>();
      std::unique_ptr<xAOD::ElectronAuxContainer> filtered_electrons_aux = std::make_unique<xAOD::ElectronAuxContainer>();
      filtered_electrons->setStore(filtered_electrons_aux.get());
      ATH_CHECK(prepareLRTElectrons(lrt_electrons, filtered_electrons.get()));
 
      // Check overlap between prompt and LRT collections
      std::set<const xAOD::Electron *> ElectronsToRemove;
      m_elecLRTORTool->checkOverlap(*prompt_electrons, *filtered_electrons, ElectronsToRemove);
    
      // Decorate electrons with prompt/LRT
      for (const xAOD::Electron* el : *prompt_electrons)   dec_isLRT(*el) = 0;
      for (const xAOD::Electron* el : *filtered_electrons) dec_isLRT(*el) = 1;
 
      // Create merged StdWithLRTElectrons container
      outputCol->reserve(prompt_electrons->size() + filtered_electrons->size());
      ATH_CHECK(MergeElectrons(*prompt_electrons, outputCol.get(), ElectronsToRemove ));
      ATH_CHECK(MergeElectrons(*filtered_electrons, outputCol.get(), ElectronsToRemove ));
 
      // Save merged StdWithLRTElectrons container to TStore
      ATH_CHECK(evtStore()->record(std::move(outputCol), m_outElectronLocation.key())); 
      ATH_CHECK(evtStore()->record(std::move(outputAuxCol), m_outElectronLocation.key() + "Aux.") );
    }
  } else if (!lrtelekey.empty()) {
    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!");
    ATH_MSG_DEBUG("Not applying prompt/LRT electron OR procedure"); 
  }
 
  if (m_isPHYSLITE && elekey.find("AnalysisElectrons")==std::string::npos){
    ATH_MSG_ERROR("You are running on PHYSLITE derivation. Please change the Electrons container to 'AnalysisElectrons'");
    return StatusCode::FAILURE;
  }
 
  const xAOD::ElectronContainer* electrons = nullptr;
  if (bool(m_eleLRT) && evtStore()->contains<xAOD::ElectronContainer>(lrtelekey)){
      ATH_MSG_DEBUG("Using container: " << m_outElectronLocation.key());
      ATH_CHECK( evtStore()->retrieve(electrons, m_outElectronLocation.key())); 
  }
  else { 
    if (copy==nullptr) { // empty container provided
        ATH_MSG_DEBUG("Empty container provided");
      if (containerToBeCopied != nullptr) {
        ATH_MSG_DEBUG("Containter to be copied not nullptr");
        electrons = containerToBeCopied;
      }
      else {
        ATH_MSG_DEBUG("Getting Electrons collection");
        ATH_CHECK( evtStore()->retrieve(electrons, elekey) );
      }
    }
  }
 
  if (copy==nullptr) { // empty container provided
    std::pair<xAOD::ElectronContainer*, xAOD::ShallowAuxContainer*> shallowcopy = xAOD::shallowCopyContainer(*electrons);
    copy = shallowcopy.first;
    copyaux = shallowcopy.second;
    bool setLinks = xAOD::setOriginalObjectLink(*electrons, *copy);
    if (!setLinks) {
      ATH_MSG_WARNING("Failed to set original object links on " << elekey);
    }
  } else { // use the user-supplied collection instead
    ATH_MSG_DEBUG("Not retrieving electron collection, using existing one provided by user");
    electrons=copy; // this does nothing
  }
 
  for (const auto electron : *copy) {
    ATH_CHECK( this->FillElectron(*electron, m_eleBaselinePt, m_eleBaselineEta) );
    this->IsSignalElectron(*electron, m_elePt, m_eled0sig, m_elez0, m_eleEta);
  }
 
  if (recordSG) {
    ATH_CHECK( evtStore()->record(copy, "STCalib" + elekey + m_currentSyst.name()) );
    ATH_CHECK( evtStore()->record(copyaux, "STCalib" + elekey + m_currentSyst.name() + "Aux.") );
  }
  return StatusCode::SUCCESS;
}

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

                                                                                                       {
 
  std::string single_str = "SINGLE_E";
  std::string single_str_2022 = "2022_";
  std::string dilep_str  = "DI_E";
  std::string multi_str  = "MULTI_L";
 
  double trig_eff(1.);
 
  CP::CorrectionCode result;
  if ( trigExpr.find(single_str) != std::string::npos || trigExpr.find(single_str_2022) != std::string::npos)
    result = m_elecEfficiencySFTool_trigEff_singleLep->getEfficiencyScaleFactor(el, trig_eff);
  else if ( trigExpr.find(dilep_str) != std::string::npos )
    ATH_MSG_ERROR( "Use GetTriggerGlobalEfficiency for logical OR of lepton triggers");
  else if ( trigExpr.find(multi_str) != std::string::npos )
    ATH_MSG_ERROR( "Use GetTriggerGlobalEfficiency for logical OR of lepton triggers");
  else
    ATH_MSG_ERROR( "The trigger expression (" << trigExpr << ") is not supported by the electron trigger efficiency!");
 
  switch (result) {
  case CP::CorrectionCode::Error:
    ATH_MSG_ERROR( "Failed to retrieve signal electron trigger efficiency");
    return 1.;
  case CP::CorrectionCode::OutOfValidityRange:
    ATH_MSG_VERBOSE( "OutOfValidityRange found for signal electron trigger efficiency");
    return 1.;
  default:
    break;
  }
 
  return trig_eff;
}

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

                                                                                                         {
 
  double trig_sf(1.);
 
  std::string single_str = "SINGLE_E";
  std::string single_str_2022 = "2022_";
  std::string dilep_str  = "DI_E";
  std::string multi_str  = "MULTI_L";
 
  CP::CorrectionCode result;
  if ( trigExpr.find(single_str) != std::string::npos || trigExpr.find(single_str_2022) != std::string::npos)
    result = m_elecEfficiencySFTool_trig_singleLep->getEfficiencyScaleFactor(el, trig_sf);
  else if ( trigExpr.find(dilep_str) != std::string::npos )
    ATH_MSG_ERROR( "Use GetTriggerGlobalEfficiency for logical OR of lepton triggers");
  else if ( trigExpr.find(multi_str) != std::string::npos )
    ATH_MSG_ERROR( "Use GetTriggerGlobalEfficiency for logical OR of lepton triggers");
  else
    ATH_MSG_ERROR( "The trigger expression (" << trigExpr << ") is not supported by the electron trigger SF!");
 
  switch (result) {
    case CP::CorrectionCode::Error:
      ATH_MSG_ERROR( "Failed to retrieve signal electron trigger SF");
      return 1.;
    case CP::CorrectionCode::OutOfValidityRange:
      ATH_MSG_VERBOSE( "OutOfValidityRange found for signal electron trigger SF");
      return 1.;
    default:
      break;
  }
 
  return trig_sf;
}

getElSFkeys()

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

protected

Definition at line 1237 of file SUSYObjDef_xAOD.cxx.

                                                                                {
 
  if( mapFile.empty() )
    return {};
 
  std::vector<std::string> theKeys;
 
  std::string filename = PathResolverFindCalibFile(mapFile);
  std::ifstream input( filename );
  for( std::string line; getline( input, line ); ){
    std::vector<std::string> tokens = split((const std::string)line,"=");
    if(tokens.size()){
      theKeys.push_back(tokens.at(0));
    }
  }
 
  return theKeys;
}

GetEventInfo()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2981 of file SUSYObjDef_xAOD.cxx.

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

GetFatJets()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 243 of file Jets.cxx.

  {
    if (!m_tool_init) {
      ATH_MSG_ERROR("SUSYTools was not initialized!!");
      return StatusCode::FAILURE;
    }
 
    if (m_fatJets.empty()) {
      ATH_MSG_ERROR("JetFatCalibTool was not initialized for largeR jet!!");
      return StatusCode::FAILURE;
    }
 
    std::string jetkey_tmp = jetkey;
    if (jetkey.empty()) {
      jetkey_tmp = m_fatJets;
    }
 
    const xAOD::JetContainer* jets = nullptr;
    if (copy==nullptr) { // empty container provided
      if (containerToBeCopied != nullptr) {
        jets = containerToBeCopied;
      }
      else {
        ATH_MSG_DEBUG("Retrieve jet collection: " << jetkey_tmp);
        ATH_CHECK( evtStore()->retrieve(jets, jetkey_tmp) );
      }
 
      std::pair<xAOD::JetContainer*, xAOD::ShallowAuxContainer*> shallowcopy = xAOD::shallowCopyContainer(*jets);
      copy = shallowcopy.first;
      copyaux = shallowcopy.second;
      bool setLinks = xAOD::setOriginalObjectLink(*jets, *copy);
      if (!setLinks) {
        ATH_MSG_WARNING("Failed to set original object links on " << jetkey_tmp);
      }
    } else { // use the user-supplied collection instead
      ATH_MSG_DEBUG("Not retrieving jet collection, using existing one provided by user");
      jets=copy;
    }
 
    if(jets->size()==0) {
        ATH_MSG_DEBUG("Large R jet collection is empty");
        return StatusCode::SUCCESS;
      }
 
    // Calibrate the jets - only insitu for data for now
    if (isData()) ATH_CHECK(m_jetFatCalibTool->applyCalibration(*copy));
 
 
    if (!isData() && !m_JetTruthLabelName.empty()){
      ATH_MSG_DEBUG("Checking if decorator for JetTruthLabelingTool is available:");
      std::string fatjetcoll = m_fatJets;
      m_label_truthKey = fatjetcoll+"."+m_JetTruthLabelName;
      SG::ReadDecorHandle<xAOD::JetContainer, int> labelHandle_truthKey(m_label_truthKey);
      ATH_MSG_DEBUG("Reading JetTruthLabelingTool truthKey:" << m_label_truthKey << " isAvailable " << labelHandle_truthKey.isAvailable());
      // Truth Labeling (MC only)
      if (!labelHandle_truthKey.isAvailable() && !m_isPHYSLITE) ATH_CHECK(m_jetTruthLabelingTool->decorate(*copy));
    }
 
 
    for (const auto jet : *copy) {
 
      ATH_CHECK( this->FillJet(*jet, true, true, doLargeRdecorations) );
      //
      //  For OR, selected if it passed cuts
      if ( acc_baseline(*jet) ){
        dec_selected(*jet) = 1;
      }
      else{
        dec_selected(*jet) = 0;
      }
    }
    if (recordSG) {
      ATH_CHECK( evtStore()->record(copy, "STCalib" + jetkey_tmp + m_currentSyst.name()) );
      ATH_CHECK( evtStore()->record(copyaux, "STCalib" + jetkey_tmp + m_currentSyst.name() + "Aux.") );
    }
    return StatusCode::SUCCESS;
  }

GetInDetLargeD0GSFTracks()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3088 of file SUSYObjDef_xAOD.cxx.

                                                                                                         {
  SG::ReadHandle<xAOD::TrackParticleContainer> tracks(m_GSFLRTCollectionName, ctx);
 
  if ( !tracks.isValid() ) {
    throw std::runtime_error("Unable to fetch LargeD0 GSF tracks.");
  }
  return *tracks;
}

GetInDetLargeD0Tracks()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3076 of file SUSYObjDef_xAOD.cxx.

                                                                                                      {
  SG::ReadHandle<xAOD::TrackParticleContainer> tracks(m_LRTCollectionName, ctx);
 
  if ( !tracks.isValid() ) {
    throw std::runtime_error("Unable to fetch LargeD0 tracks.");
  }
 
  //const xAOD::TrackParticleContainer out = *tracks;
 
  return *tracks;
}

GetJets()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 74 of file Jets.cxx.

  {
    if (!m_tool_init) {
      ATH_MSG_ERROR("SUSYTools was not initialized!!");
      return StatusCode::FAILURE;
    }
 
  if (m_isPHYSLITE && jetkey.find("AnalysisJets") == std::string::npos){
    ATH_MSG_ERROR("You are running on PHYSLITE derivation. Please change the Jets container to 'AnalysisJets'");
    return StatusCode::FAILURE;
  }
 
    ATH_MSG_DEBUG("Default jetkey:           " << m_defaultJets);
    ATH_MSG_DEBUG("Function argument jetkey: " << jetkey);
 
    // load default regular & btag jet keys
    std::string jetkey_tmp = m_defaultJets;                                           // use default for regular jetkey_tmp
 
    // override default if user is passing a jetkey
    if (!jetkey.empty()) {
      jetkey_tmp = jetkey;
    }
 
    // final settings
    ATH_MSG_DEBUG("Key for retrieving jet collection:             jetkey      = " << jetkey_tmp);
 
    const xAOD::JetContainer* jets = nullptr;
    if (copy==nullptr) { // empty container provided
      if (containerToBeCopied != nullptr) {
        jets = containerToBeCopied;
      }
      else {
        ATH_MSG_DEBUG("Retrieve jet collection: " << jetkey_tmp);
        ATH_CHECK( evtStore()->retrieve(jets, jetkey_tmp) );
      }
      std::pair<xAOD::JetContainer*, xAOD::ShallowAuxContainer*> shallowcopy = xAOD::shallowCopyContainer(*jets);
      copy = shallowcopy.first;
      copyaux = shallowcopy.second;
      bool setLinks = xAOD::setOriginalObjectLink(*jets, *copy);
      if (!setLinks) {
        ATH_MSG_WARNING("Failed to set original object links on " << jetkey_tmp);
      }
    } else { // use the user-supplied collection instead
      ATH_MSG_DEBUG("Not retrieving jet collecton, using existing one provided by user");
      jets = copy;
    }
 
    // Calibrate the jets
    ATH_CHECK(m_jetCalibTool->applyCalibration(*copy));
 
    // Add isHS labels to jets (required for JvtEfficiencyTools)
    if (!isData()) {
      ATH_CHECK(m_jetPileupLabelingTool->decorate(*copy));
    }
 
    // Calculate Jvt scores (required by METSignificance)
    for (const auto jet : *copy) {
      dec_jvt(*jet) = m_jetJvtMomentTool->updateJvt(*jet);
    }
 
    // Re-calculate NNJvt scores
    if (m_applyJVTCut) ATH_CHECK(m_jetNNJvtMomentTool->decorate(*copy));
 
    // Update the jets
    for (const auto jet : *copy) {
      ATH_CHECK( this->FillJet(*jet) );
    }
 
    for (const auto jet : *copy) {
      // Update the JVT decorations if needed
      if( m_doFwdJVT){
        dec_passJvt(*jet) = acc_passFJvt(*jet) && acc_passJvt(*jet);
        dec_fjvt(*jet) = acc_fjvt(*jet);
 
        //new state for OR   .  0=non-baseline objects, 1=for baseline jets not passing JVT, 2=for any other baseline object
        if ( acc_baseline(*jet) ){
          if( acc_passJvt(*jet) )     dec_selected(*jet) = 2;
          else                        dec_selected(*jet) = 1;
        }
        else{
          dec_selected(*jet) = 0;
        }
      }
      this->IsBadJet(*jet);
      this->IsSignalJet(*jet, m_jetPt, m_jetEta);
      if (!isData())this->IsTruthBJet(*jet);
    }
    if (recordSG) {
      std::string auxname = copyaux->name();
      if (auxname.compare("UNKNOWN")==0) copyaux->setName(std::string("STCalib" + jetkey_tmp + m_currentSyst.name() + "AuxCopy").c_str());
      ATH_CHECK( evtStore()->record(copy, "STCalib" + jetkey_tmp + m_currentSyst.name()) );
      ATH_CHECK( evtStore()->record(copyaux, "STCalib" + jetkey_tmp + m_currentSyst.name() + "Aux.") );
    }
    return StatusCode::SUCCESS;
  }

GetJetsSyst()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 322 of file Jets.cxx.

  {
    if (!m_tool_init) {
      ATH_MSG_ERROR("SUSYTools was not initialized!!");
      return StatusCode::FAILURE;
    }
 
    std::string jetkey_tmp = jetkey;
    if (jetkey.empty()) {
      jetkey_tmp = m_defaultJets;
    }
 
    std::pair<xAOD::JetContainer*, xAOD::ShallowAuxContainer*> shallowcopy = xAOD::shallowCopyContainer(calibjets);
    copy = shallowcopy.first;
    copyaux = shallowcopy.second;
 
    bool setLinks = xAOD::setOriginalObjectLink(calibjets, *copy);
    if (!setLinks) {
      ATH_MSG_WARNING("Failed to set original object links on " << jetkey_tmp);
    }
 
    // ghost associate the muons to the jets (needed by MET muon-jet OR later)
    ATH_MSG_VERBOSE("Run muon-to-jet ghost association");
    const xAOD::MuonContainer* muons = nullptr;
    // Do a little guessing
    if (jetkey!="AnalysisJets"){
      ATH_CHECK( evtStore()->retrieve(muons, "Muons") );
    } else {
      ATH_CHECK( evtStore()->retrieve(muons, "AnalysisMuons") );
    }
    met::addGhostMuonsToJets(*muons, *copy);
 
    // Update the jets
    for (const auto jet : *copy) {
      ATH_CHECK( this->FillJet(*jet, false) );
    }
 
    for (const auto jet : *copy) {
      // Update the JVT decorations if needed
      if( m_doFwdJVT){
        dec_passJvt(*jet) = acc_passFJvt(*jet) && acc_passJvt(*jet);
 
        //new state for OR   .  0=non-baseline objects, 1=for baseline jets not passing JVT, 2=for any other baseline object
        if ( acc_baseline(*jet) ){
          if( acc_passJvt(*jet) )     dec_selected(*jet) = 2;
          else                        dec_selected(*jet) = 1;
        }
        else{
          dec_selected(*jet) = 0;
        }
      }
      this->IsBadJet(*jet);
      this->IsSignalJet(*jet, m_jetPt, m_jetEta);
      if (!isData())this->IsTruthBJet(*jet);
    }
    if (recordSG) {
      ATH_CHECK( evtStore()->record(copy, "STCalib" + jetkey_tmp + m_currentSyst.name()) );
      ATH_CHECK( evtStore()->record(copyaux, "STCalib" + jetkey_tmp + m_currentSyst.name() + "Aux.") );
    }
    return StatusCode::SUCCESS;
  }

getKey()

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

inherited

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

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

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

See also

asg::AsgTool::getName

Parameters

ptr	The 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.

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

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.

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

GetMET()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 23 of file MET.cxx.

                                                                        {
  if (!m_tool_init) {
    ATH_MSG_ERROR("SUSYTools was not initialized!!");
    return StatusCode::FAILURE;
  }
 
  const xAOD::MissingETContainer* metcore(nullptr);
  if ( evtStore()->retrieve( metcore, m_inputMETCore ).isFailure() ) {
    ATH_MSG_WARNING( "Unable to retrieve MET core container: " << m_inputMETCore );
    return StatusCode::FAILURE;
  }
  const xAOD::MissingETAssociationMap* metMap(nullptr);
  if ( evtStore()->retrieve(metMap, m_inputMETMap).isFailure() ) {
    ATH_MSG_WARNING("Unable to retrieve MissingETAssociationMap: " << m_inputMETMap);
    return StatusCode::FAILURE;
  }
  // Helper keeps track of object selection flags for this map
  xAOD::MissingETAssociationHelper metHelper(&(*metMap));
 
  std::string softTerm = "SoftClus";
  if (doTST) {
    softTerm = "PVSoftTrk";
  } else if (doJVTCut) {
    ATH_MSG_WARNING( "Requested CST MET and a JVT cut.  This is not a recommended configuration - please consider switching to TST." );
  }
 
  metHelper.resetObjSelectionFlags();
 
  // allow creation of proxy MET by flagging objects for "neutrino/ification" as already selected
  if (invis) {
    ATH_CHECK( m_metMaker->markInvisible(invis, metHelper, &met) );
  }
 
  if (elec) {
    ATH_MSG_VERBOSE("Build electron MET");
    ConstDataVector<xAOD::ElectronContainer> metelectron(SG::VIEW_ELEMENTS);
    for (const xAOD::Electron* el : *elec) {
      // pass baseline selection
      if (acc_baseline(*el)) {
        bool veto(false);
        if (invis) {
          for (const xAOD::IParticle* ipart : *invis) {
            if (ipart == el) {veto = true; break;}
          }
        }
        if (!veto) metelectron.push_back(el);
      }
    }
    ATH_CHECK( m_metMaker->rebuildMET(m_eleTerm, xAOD::Type::Electron, &met, metelectron.asDataVector(), metHelper) );
  }
 
  if (gamma) {
    ATH_MSG_VERBOSE("Build photon MET");
    ConstDataVector<xAOD::PhotonContainer> metgamma(SG::VIEW_ELEMENTS);
    for (const xAOD::Photon* ph : *gamma) {
      // pass baseline selection
      if (acc_baseline(*ph)) {
        bool veto(false);
        if (invis) {
          for (const xAOD::IParticle* ipart : *invis) {
            if (ipart == ph) {veto = true; break;}
          }
        }
        if (!veto) metgamma.push_back(ph);
      }
    }
    ATH_CHECK( m_metMaker->rebuildMET(m_gammaTerm, xAOD::Type::Photon, &met, metgamma.asDataVector(), metHelper) );
  }
 
  if (taujet) {
    ATH_MSG_VERBOSE("Build tau MET");
    ConstDataVector<xAOD::TauJetContainer> mettau(SG::VIEW_ELEMENTS);
    for (const xAOD::TauJet* tau : *taujet) {
      // pass baseline selection
      if (acc_baseline(*tau)) {
        bool veto(false);
        if (invis) {
          for (const xAOD::IParticle* ipart : *invis) {
            if (ipart == tau) {veto = true; break;}
          }
        }
        if (!veto) mettau.push_back(tau);
      }
    }
    ATH_CHECK( m_metMaker->rebuildMET(m_tauTerm, xAOD::Type::Tau, &met, mettau.asDataVector(), metHelper) );
  }
 
  if (muon) {
    ATH_MSG_VERBOSE("Build muon MET");
    ConstDataVector<xAOD::MuonContainer> metmuon(SG::VIEW_ELEMENTS);
    for (const xAOD::Muon* mu : *muon) {
      bool veto(false);
      // pass baseline selection
      if (acc_baseline(*mu)) {
        if (invis) {
          for (const xAOD::IParticle* ipart : *invis) {
            if (ipart == mu) {veto = true; break;}
          }
        }
        if (!veto) metmuon.push_back(mu);
      }
    }
    ATH_CHECK( m_metMaker->rebuildMET(m_muonTerm, xAOD::Type::Muon, &met, metmuon.asDataVector(), metHelper) );
  }
 
  if (!jet) {
    ATH_MSG_WARNING("Invalid jet container specified for MET rebuilding!");
    return StatusCode::SUCCESS;
  }
 
  ATH_MSG_VERBOSE("Build jet/soft MET");
  ATH_CHECK( m_metMaker->rebuildJetMET(m_jetTerm, softTerm, &met, jet, metcore, metHelper, doJVTCut) );
 
  if (!isData()) {
    m_metSystTool->setRandomSeed(static_cast<int>(1e6*met[softTerm]->phi()));
    ATH_MSG_VERBOSE("Original soft term " << met[softTerm]->name() << " (met: " << met[softTerm]->met() << ")" );
    if ( m_metSystTool->applyCorrection(*met[softTerm], metHelper) != CP::CorrectionCode::Ok ) {
      ATH_MSG_WARNING("GetMET: Failed to apply MET soft term systematics.");
    }
    ATH_MSG_VERBOSE("New soft term value: " << met[softTerm]->met() );
  }
 
  ATH_MSG_VERBOSE("Build MET sum");
  ATH_CHECK( met::buildMETSum(m_outMETTerm, &met, met[softTerm]->source()) );
  ATH_MSG_VERBOSE( "Rebuilt MET: Missing Et (x,y): (" << met[m_outMETTerm]->mpx() << "," <<  met[m_outMETTerm]->mpy() << ")");
  ATH_MSG_VERBOSE( "Done rebuilding MET." );
 
  return StatusCode::SUCCESS;
}

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.

                                                                 {
 
  std::string softTerm = "SoftClus";
  if (doTST) {
    softTerm = "PVSoftTrk";
  } else if (doJVTCut) {
    ATH_MSG_WARNING( "Requested CST MET and a JVT cut.  This is not a recommended configuration - please consider switching to TST." );
  }
 
  const xAOD::EventInfo* evtInfo = nullptr;
  ATH_CHECK( evtStore()->retrieve( evtInfo, "EventInfo" ) );
  ATH_CHECK( m_metSignif->varianceMET( &met, evtInfo->averageInteractionsPerCrossing(), m_jetTerm, softTerm, m_outMETTerm) );
  metSignificance = m_metSignif->GetSignificance();
  ATH_MSG_VERBOSE( "Obtained MET Significance: " << metSignificance  );
 
  return StatusCode::SUCCESS;
}

GetMuons()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 100 of file Muons.cxx.

{
  if (!m_tool_init) {
    ATH_MSG_ERROR("SUSYTools was not initialized!!");
    return StatusCode::FAILURE;
  }
 
  // Initializing prompt/LRT OR procedure
  auto outputCol = std::make_unique<xAOD::MuonContainer>();
  std::unique_ptr<xAOD::MuonAuxContainer> outputAuxCol;
  outputAuxCol = std::make_unique<xAOD::MuonAuxContainer>();
  outputCol->setStore(outputAuxCol.get());
  ATH_CHECK( m_outMuonLocation.initialize() );
 
  if (bool(m_muLRT) && !lrtmuonkey.empty() && evtStore()->contains<xAOD::MuonContainer>(lrtmuonkey)){
    ATH_MSG_DEBUG("Applying prompt/LRT muon OR procedure"); 
 
    // First identify if merged container has already been made (for instances where GetMuons() is called more than once)
    if (evtStore()->contains<xAOD::MuonContainer>("StdWithLRTMuons")) {
      ATH_MSG_DEBUG("Merged prompt/LRT container already created in TStore");  
    } else {
      ATH_MSG_DEBUG("Creating merged prompt/LRT container in TStore");
 
      // Retrieve prompt and LRT muons from TStore
      ATH_CHECK( evtStore()->retrieve(prompt_muons, muonkey) );
      ATH_CHECK( evtStore()->retrieve(lrt_muons, lrtmuonkey) );
 
      // Remove LRT muons as flagged by filter for uncertainty
      auto filtered_muons = std::make_unique<xAOD::MuonContainer>();
      std::unique_ptr<xAOD::MuonAuxContainer> filtered_muons_aux = std::make_unique<xAOD::MuonAuxContainer>();
      filtered_muons->setStore(filtered_muons_aux.get());
      ATH_CHECK(prepareLRTMuons(lrt_muons, filtered_muons.get()));
 
      // Check overlap between prompt and LRT collections
      std::vector<bool> writePromptMuon;
      std::vector<bool> writeLRTMuon;
      m_muonLRTORTool->checkOverlap(*prompt_muons, *filtered_muons, writePromptMuon, writeLRTMuon);
    
      // Decorate muons with prompt/LRT
      for (const xAOD::Muon* mu : *prompt_muons)   dec_isLRT(*mu) = 0;
      for (const xAOD::Muon* mu : *filtered_muons) dec_isLRT(*mu) = 1;
 
      // Create merged StdWithLRTMuons container
      outputCol->reserve(prompt_muons->size() + filtered_muons->size());
      ATH_CHECK(MergeMuons(*prompt_muons, writePromptMuon, outputCol.get()) );
      ATH_CHECK(MergeMuons(*filtered_muons, writeLRTMuon, outputCol.get()) );
 
      // Save merged StdWithLRTMuons container to TStore
      ATH_CHECK(evtStore()->record(std::move(outputCol), m_outMuonLocation.key())); 
      ATH_CHECK(evtStore()->record(std::move(outputAuxCol), m_outMuonLocation.key() + "Aux.") );
 
    }
  } else if (!lrtmuonkey.empty()) {
    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!");
    ATH_MSG_DEBUG("Not applying prompt/LRT muon OR procedure"); 
  }
  
  if (m_isPHYSLITE && muonkey.find("AnalysisMuons")==std::string::npos){
    ATH_MSG_ERROR("You are running on PHYSLITE derivation. Please change the Muons container to 'AnalysisMuons'");
    return StatusCode::FAILURE;
  }
 
  const xAOD::MuonContainer* muons = nullptr;
  if (bool(m_muLRT) && evtStore()->contains<xAOD::MuonContainer>(lrtmuonkey)){
    ATH_MSG_DEBUG("Using container: " << m_outMuonLocation.key());
    ATH_CHECK( evtStore()->retrieve(muons, m_outMuonLocation.key())); 
  }
  else { 
    if (copy==nullptr) { // empty container provided
        ATH_MSG_DEBUG("Empty container provided");
      if (containerToBeCopied != nullptr) {
        ATH_MSG_DEBUG("Containter to be copied not nullptr");
        muons = containerToBeCopied;
      }
      else {
        ATH_MSG_DEBUG("Getting Muons collection");
        ATH_CHECK( evtStore()->retrieve(muons, muonkey) );
      }
    }
  }
 
  if (copy==nullptr) { // empty container provided
    std::pair<xAOD::MuonContainer*, xAOD::ShallowAuxContainer*> shallowcopy = xAOD::shallowCopyContainer(*muons);
    copy = shallowcopy.first;
    copyaux = shallowcopy.second;
    bool setLinks = xAOD::setOriginalObjectLink(*muons, *copy);
    if (!setLinks) {
      ATH_MSG_WARNING("Failed to set original object links on " << muonkey);
    }
  } else { // use the user-supplied collection instead 
    ATH_MSG_DEBUG("Not retrieving muon collection, using existing one provided by user");
    muons=copy; // this does nothing
  }
 
  for (const auto muon : *copy) {
    ATH_CHECK( this->FillMuon(*muon, m_muBaselinePt, m_muBaselineEta) );
    this->IsSignalMuon(*muon, m_muPt, m_mud0sig, m_muz0, m_muEta);
    this->IsCosmicMuon(*muon, m_muCosmicz0, m_muCosmicd0);
    this->IsBadMuon(*muon, m_badmuQoverP);
  }
  if (recordSG) {
    ATH_CHECK( evtStore()->record(copy, "STCalib" + muonkey + m_currentSyst.name()) );
    ATH_CHECK( evtStore()->record(copyaux, "STCalib" + muonkey + m_currentSyst.name() + "Aux.") );
  }
  return StatusCode::SUCCESS;
}

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

                                                                                                                 {
 
  double eff(1.);
 
  if (m_muonTriggerSFTool->getTriggerEfficiency(mu, eff, trigExpr, isdata) != CP::CorrectionCode::Ok) {
    ATH_MSG_WARNING("Problem retrieving signal muon trigger efficiency for " << trigExpr );
  }
  else{
    ATH_MSG_DEBUG("Got efficiency " << eff << " for " << trigExpr );
  }
  return eff;
}

getName()

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

inherited

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

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

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

See also

asg::AsgTool::getKey

Parameters

ptr	The 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.

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

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.

{
  if (!m_tool_init) {
    ATH_MSG_ERROR("SUSYTools was not initialized!!");
    return StatusCode::FAILURE;
  }
 
  if (m_isPHYSLITE && photonkey.find("AnalysisPhotons")==std::string::npos){
    ATH_MSG_ERROR("You are running on PHYSLITE derivation. Please change the Photons container to 'AnalysisPhotons'");
    return StatusCode::FAILURE;
  }
 
  const xAOD::PhotonContainer* photons = nullptr;
  if (copy==nullptr) { // empty container provided
    if (containerToBeCopied != nullptr) {
      photons = containerToBeCopied;
    }
    else {
      ATH_CHECK( evtStore()->retrieve(photons, photonkey) );
    }
    std::pair<xAOD::PhotonContainer*, xAOD::ShallowAuxContainer*> shallowcopy = xAOD::shallowCopyContainer(*photons);
    copy = shallowcopy.first;
    copyaux = shallowcopy.second;
    bool setLinks = xAOD::setOriginalObjectLink(*photons, *copy);
    if (!setLinks) {
      ATH_MSG_WARNING("Failed to set original object links on " << photonkey);
    }
  } else { // use the user-supplied collection instead 
    ATH_MSG_DEBUG("Not retrieving photon collecton, using existing one provided by user");
    photons=copy;
  }  
 
  for (const auto photon : *copy) {
    ATH_CHECK( this->FillPhoton(*photon, m_photonBaselinePt, m_photonBaselineEta) );
    this->IsSignalPhoton(*photon, m_photonPt, m_photonEta);
  }
 
  if (recordSG) {
    ATH_CHECK( evtStore()->record(copy, "STCalib" + photonkey + m_currentSyst.name()) );
    ATH_CHECK( evtStore()->record(copyaux, "STCalib" + photonkey + m_currentSyst.name() + "Aux.") );
  }
  return StatusCode::SUCCESS;
}

GetPileupWeight()

float ST::SUSYObjDef_xAOD::GetPileupWeight ( )

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2989 of file SUSYObjDef_xAOD.cxx.

                                       {
 
  const xAOD::EventInfo* evtInfo = GetEventInfo();
  float pu_weight = m_prwTool->getCombinedWeight(*evtInfo);
 
  if(!isfinite(pu_weight)) pu_weight = 1.;
 
  return pu_weight;
}

GetPileupWeightHash()

ULong64_t ST::SUSYObjDef_xAOD::GetPileupWeightHash ( )

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3014 of file SUSYObjDef_xAOD.cxx.

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

GetPileupWeightPrescaledTrigger()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2999 of file SUSYObjDef_xAOD.cxx.

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

GetPrimVtx()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2920 of file SUSYObjDef_xAOD.cxx.

                                                    {
  const xAOD::VertexContainer* vertices = nullptr;
  if ( evtStore()->retrieve( vertices, "PrimaryVertices" ).isSuccess() ) {
    for ( const auto vx : *vertices ) {
      if (vx->vertexType() == xAOD::VxType::PriVtx) {
        ATH_MSG_DEBUG("PrimaryVertex found with z=" << vx->z());
        return vx;
      }
    }
  } else {
    ATH_MSG_WARNING("Failed to retrieve VertexContainer \"PrimaryVertices\", returning nullptr");
  }
  return nullptr;
}

getProperty() [1/2]

template<typename T >

const T* ST::ISUSYObjDef_xAODTool::getProperty ( const std::string &  name )

inlineinherited

Definition at line 239 of file ISUSYObjDef_xAODTool.h.

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

getProperty() [2/2]

template<class T >

const T* asg::AsgTool::getProperty ( const std::string &  name ) const

inherited

Get one of the tool's properties.

GetRandomRunNumber()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3038 of file SUSYObjDef_xAOD.cxx.

                                                                    {
 
  const xAOD::EventInfo* evtInfo = GetEventInfo();
  if (randomrunnumber.isAvailable(*(evtInfo)) && muDependentRRN) {
    return randomrunnumber(*(evtInfo));
  }
  else if (!muDependentRRN) {
    return m_prwTool->getRandomRunNumber( *evtInfo, muDependentRRN );
  }
  ATH_MSG_ERROR ( "Failed to find RandomRunNumber decoration! You need to call ApplyPRWTool() beforehand!" );
  return 0;
}

GetRunNumber()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3060 of file SUSYObjDef_xAOD.cxx.

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

getSherpaVjetsNjetsWeight() [1/2]

float ST::SUSYObjDef_xAOD::getSherpaVjetsNjetsWeight ( ) const

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2889 of file SUSYObjDef_xAOD.cxx.

                                                       {
 
  //Retrieve the truth jets
  if( evtStore()->contains<xAOD::JetContainer>("AntiKt4TruthWZJets") ){
    return getSherpaVjetsNjetsWeight("AntiKt4TruthWZJets");
  }
  else if( evtStore()->contains<xAOD::JetContainer>("AntiKt4TruthJets")){
    return getSherpaVjetsNjetsWeight("AntiKt4TruthJets" );
  }
  else{
    ATH_MSG_WARNING("No TruthJetContainer found! Dummy null weight retrieved.");
  }
  return 0.;
}

getSherpaVjetsNjetsWeight() [2/2]

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2904 of file SUSYObjDef_xAOD.cxx.

                                                                                    {
 
  if(jetContainer=="AntiKt4TruthWZJets"){
    return m_pmgSHnjetWeighterWZ->getWeight();
  }
  else if (jetContainer=="AntiKt4TruthJets"){
    return m_pmgSHnjetWeighter->getWeight();
  }
  else{
    ATH_MSG_WARNING(jetContainer << " is no supported by PMGSherpa22VJetsWeightTool! Please check...");
  }
  return 1.;
 
}

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

                                                          {
 
  if ((m_eleId == "VeryLooseLLH" || m_eleId == "LooseLLH" || m_eleId == "Loose" || m_eleId == "Medium" || m_eleId == "Tight") && (idSF || triggerSF || isoSF)) {
    ATH_MSG_ERROR("No signal electron ID or trigger scale factors provided for the selected working point!");
    ATH_MSG_ERROR("I will now die messily.");
  }
 
  //shortcut keys for trigger SF config
  std::string singleLepStr = "singleLepton";
  std::string diLepStr     = "diLepton";
  std::string multiLepStr  = "multiLepton";
 
  float sf(1.);
 
  if (recoSF) {
    double reco_sf(1.);
 
    CP::CorrectionCode result = m_elecEfficiencySFTool_reco->getEfficiencyScaleFactor(el, reco_sf);
    switch (result) {
    case CP::CorrectionCode::Ok:
      sf *= reco_sf;
      break;
    case CP::CorrectionCode::Error:
      ATH_MSG_ERROR( "Failed to retrieve signal electron reco SF");
      break;
    case CP::CorrectionCode::OutOfValidityRange:
      ATH_MSG_VERBOSE( "OutOfValidityRange found for signal electron reco SF");
      break;
    default:
      ATH_MSG_WARNING( "Don't know what to do for signal electron reco SF");
    }
  }
 
  if (idSF) {
    double id_sf(1.);
 
    CP::CorrectionCode result = m_elecEfficiencySFTool_id->getEfficiencyScaleFactor(el, id_sf);
    switch (result) {
    case CP::CorrectionCode::Ok:
      sf *= id_sf;
      break;
    case CP::CorrectionCode::Error:
      ATH_MSG_ERROR( "Failed to retrieve signal electron id SF");
      break;
    case CP::CorrectionCode::OutOfValidityRange:
      ATH_MSG_VERBOSE( "OutOfValidityRange found for signal electron id SF");
      break;
    default:
      ATH_MSG_WARNING( "Don't know what to do for signal electron id SF");
    }
  }
 
  if (triggerSF) {
 
    std::vector<std::string> trigMChains={};
    std::string theExpr ("");
    if(trigExpr==singleLepStr) {
      if (this->treatAsYear()==2015) trigMChains = m_v_trigs15_cache_singleEle;
      else if (this->treatAsYear()==2016) trigMChains = m_v_trigs16_cache_singleEle;
      else if (this->treatAsYear()==2017) trigMChains = m_v_trigs17_cache_singleEle;
      else if (this->treatAsYear()==2018) trigMChains = m_v_trigs18_cache_singleEle;
      else trigMChains = m_v_trigs22_cache_singleEle;
      theExpr=m_electronTriggerSFStringSingle;
    }
    else{
      ATH_MSG_WARNING( "Only single lepton trigger SFs are supported in GetSignalElecSF(). Use GetTriggerGlobalEfficiencySF() for dilepton or multilepton triggers!");
    }
 
    //check matching
    this->TrigMatch({&el}, trigMChains);
 
    if(!acc_trigmatched(el)){
      ATH_MSG_DEBUG( "Electron was not matched to trigger " << theExpr << " - scale factor does not apply (year " << this->treatAsYear() << ")  Returning 1." );
    }
    else{ //is trig-matched electron, go for it!
      if (trigExpr==multiLepStr || trigExpr==diLepStr) {
        ATH_MSG_WARNING( "The dilepton or multilepton trigger SFs are not supported in GetSignalElecSF(). Use GetTriggerGlobalEfficiencySF()!");
      }
      else {
        double trig_sf = GetEleTriggerEfficiencySF( el , theExpr );
        sf *= trig_sf;
      }
    }
  }
 
  if (isoSF) {
    double iso_sf(1.);
    CP::CorrectionCode result;
    if (acc_isolHighPt(el) && el.pt()>m_eleIsoHighPtThresh)
      result = m_elecEfficiencySFTool_isoHighPt->getEfficiencyScaleFactor(el, iso_sf);
    else
      result = m_elecEfficiencySFTool_iso->getEfficiencyScaleFactor(el, iso_sf);
 
    switch (result) {
    case CP::CorrectionCode::Ok:
      sf *= iso_sf;
      break;
    case CP::CorrectionCode::Error:
      ATH_MSG_ERROR( "Failed to retrieve signal electron iso SF");
      break;
    case CP::CorrectionCode::OutOfValidityRange:
      ATH_MSG_VERBOSE( "OutOfValidityRange found for signal electron iso SF");
      break;
    default:
      ATH_MSG_WARNING( "Don't know what to do for signal electron iso SF");
    }
  }
 
  // Charge flip SF: combined ECIDs & charge ID
  if ( ecidsSF || cidSF ) {
    double chf_sf(1.);
    // 1. ECIDs SF
    if ( ecidsSF ) {
      sf *= chf_sf;
      ATH_MSG_WARNING( "ECID SF ARE NOT YET SUPPORTED IN R22" );
      }
    // 2. CID SF
    if ( cidSF ) {
        sf *= chf_sf;
        dec_sfChIDEff(el) = chf_sf;
        ATH_MSG_WARNING( "CID SF ARE NOT YET SUPPORTED IN R22" );
    }
  }
 
  dec_effscalefact(el) = sf;
  return sf;
}

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

{
  float sf(1.);
 
  if (recoSF) {
    float sf_reco(1.);
    if (m_muonEfficiencySFTool->getEfficiencyScaleFactor( mu, sf_reco ) == CP::CorrectionCode::OutOfValidityRange) {
      if(warnOVR) ATH_MSG_WARNING(" GetSignalMuonSF: Reco getEfficiencyScaleFactor out of validity range");
    }
    ATH_MSG_VERBOSE( "MuonReco ScaleFactor " << sf_reco );
    sf *= sf_reco;
 
    float sf_ttva(1.);
    if(m_doTTVAsf){
      if (m_muonTTVAEfficiencySFTool->getEfficiencyScaleFactor( mu, sf_ttva ) == CP::CorrectionCode::OutOfValidityRange) {
    if(warnOVR) ATH_MSG_WARNING(" GetSignalMuonSF: TTVA getEfficiencyScaleFactor out of validity range");
      }
      ATH_MSG_VERBOSE( "MuonTTVA ScaleFactor " << sf_ttva );
      sf *= sf_ttva;
    }
 
    float sf_badHighPt(1.);
    if(m_muId == 4 && doBadMuonHP){
      if (m_muonEfficiencyBMHighPtSFTool->getEfficiencyScaleFactor( mu, sf_badHighPt ) == CP::CorrectionCode::OutOfValidityRange) {
    if(warnOVR) ATH_MSG_WARNING(" GetSignalMuonSF: BadMuonHighPt getEfficiencyScaleFactor out of validity range");
      }
      ATH_MSG_VERBOSE( "MuonBadMuonHighPt ScaleFactor " << sf_badHighPt );
      sf *= sf_badHighPt;
    }
  }
 
 
  if (isoSF) {
    float sf_iso(1.);
    if (acc_isolHighPt(mu) && mu.pt()>m_muIsoHighPtThresh) {
      if (m_muonHighPtIsolationSFTool->getEfficiencyScaleFactor( mu, sf_iso ) == CP::CorrectionCode::OutOfValidityRange) {
        if(warnOVR) ATH_MSG_WARNING(" GetSignalMuonSF: high-pt Iso getEfficiencyScaleFactor out of validity range");
      } 
    } else if (acc_isol(mu) && mu.pt()<m_muIsoHighPtThresh) {
      if (m_muonIsolationSFTool->getEfficiencyScaleFactor( mu, sf_iso ) == CP::CorrectionCode::OutOfValidityRange) {
        if(warnOVR) ATH_MSG_WARNING(" GetSignalMuonSF: Iso getEfficiencyScaleFactor out of validity range");
      } 
    }
    ATH_MSG_VERBOSE( "MuonIso ScaleFactor " << sf_iso );
    sf *= sf_iso;
  }
 
 
  dec_effscalefact(mu) = sf;
  return sf;
}

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

{
  double sf(1.);
 
  if (effSF) {
 
    double sf_eff = 1.;
 
    CP::CorrectionCode res = m_photonEfficiencySFTool->getEfficiencyScaleFactor( ph, sf_eff );
    if (res == CP::CorrectionCode::OutOfValidityRange) ATH_MSG_WARNING(" GetSignalPhotonSF: EfficiencyScaleFactor out of validity range");
 
    sf *= sf_eff;
  }
 
  if (isoSF) {
 
    double sf_iso = 1.;
 
    CP::CorrectionCode res = m_photonIsolationSFTool->getEfficiencyScaleFactor( ph, sf_iso );
    if (res == CP::CorrectionCode::OutOfValidityRange) ATH_MSG_WARNING(" GetSignalPhotonSF: IsolationScaleFactor out of validity range");
 
    sf *= sf_iso;
  }
 
  if (triggerSF) {
 
    double sf_trigger = 1.;
 
    CP::CorrectionCode res = m_photonTriggerSFTool->getEfficiencyScaleFactor( ph, sf_trigger );
    if (res == CP::CorrectionCode::OutOfValidityRange) ATH_MSG_WARNING(" GetSignalPhotonSF: TriggerScaleFactor out of validity range");
 
    sf *= sf_trigger;
  }
 
  ATH_MSG_VERBOSE( "ScaleFactor " << sf );
 
  dec_effscalefact(ph) = sf;
  return sf;
}

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

{
  double sf(1.);
 
  //Set the new systematic variation
  StatusCode ret = m_photonEfficiencySFTool->applySystematicVariation(systConfig);
  if (ret != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("Cannot configure AsgPhotonEfficiencyCorrectionTool (reco) for systematic var. " << systConfig.name() );
  }
 
  ret = m_photonIsolationSFTool->applySystematicVariation(systConfig);
  if (ret != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("Cannot configure AsgPhotonEfficiencyCorrectionTool (iso) for systematic var. " << systConfig.name() );
  }
 
  ret = m_photonTriggerSFTool->applySystematicVariation(systConfig);
  if (ret != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("Cannot configure AsgPhotonEfficiencyCorrectionTool (trigger) for systematic var. " << systConfig.name() );
  }
 
  if (effSF) {
 
    double sf_eff = 1.;
 
    CP::CorrectionCode res = m_photonEfficiencySFTool->getEfficiencyScaleFactor( ph, sf_eff );
    if (res == CP::CorrectionCode::OutOfValidityRange) ATH_MSG_WARNING(" GetSignalPhotonSF: getEfficiencyScaleFactor out of validity range");
 
    sf *= sf_eff;
  }
 
  if (isoSF) {
 
    double sf_iso = 1.;
 
    CP::CorrectionCode res = m_photonIsolationSFTool->getEfficiencyScaleFactor( ph, sf_iso );
    if (res == CP::CorrectionCode::OutOfValidityRange) ATH_MSG_WARNING(" GetSignalPhotonSF: getEfficiencyScaleFactor out of validity range");
 
    sf *= sf_iso;
  }
 
  if (triggerSF) {
 
    double sf_trigger = 1.;
 
    CP::CorrectionCode res = m_photonTriggerSFTool->getEfficiencyScaleFactor( ph, sf_trigger );
    if (res == CP::CorrectionCode::OutOfValidityRange) ATH_MSG_WARNING(" GetSignalPhotonSF: getEfficiencyScaleFactor out of validity range");
 
    sf *= sf_trigger;
  }
 
  //Roll back to current sys
  ret = m_photonEfficiencySFTool->applySystematicVariation(m_currentSyst);
  if (ret != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("Cannot configure AsgPhotonEfficiencyCorrectionTool back to default.");
  }
 
  ret = m_photonIsolationSFTool->applySystematicVariation(m_currentSyst);
  if (ret != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("Cannot configure AsgPhotonEfficiencyCorrectionTool (iso) for systematic var. " << systConfig.name() );
  }
 
  ret = m_photonTriggerSFTool->applySystematicVariation(m_currentSyst);
  if (ret != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("Cannot configure AsgPhotonEfficiencyCorrectionTool (trigger) for systematic var. " << systConfig.name() );
  }
 
  ATH_MSG_VERBOSE( "ScaleFactor " << sf );
 
  dec_effscalefact(ph) = sf;
  return sf;
}

GetSignalTauSF()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 129 of file Taus.cxx.

{
  double sf(1.);
 
  if (acc_signal(tau)) {
    if (idSF) {
      if (m_tauEffTool->getEfficiencyScaleFactor(tau, sf) != CP::CorrectionCode::Ok) {
        ATH_MSG_WARNING("Failed to retrieve tau efficiency scale factor.");
      }
      ATH_MSG_VERBOSE(" Retrieved tau SF  " << sf);
    }
 
    if (triggerSF) {
      double trig_sf = GetTauTriggerEfficiencySF(tau, trigExpr);
      
      if (trig_sf > -90) {
    sf *= trig_sf;
    ATH_MSG_VERBOSE(" Retrieved tau trig SF  " << trig_sf);
      }
    }
  }
 
  dec_effscalefact(tau) = sf;
  return sf;
}

GetSignalTauSFsys()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 159 of file Taus.cxx.

{
  double sf(1.);
 
  //Set the new systematic variation
  StatusCode ret = m_tauEffTool->applySystematicVariation(systConfig);
  if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure TauEfficiencyCorrectionsTool for systematic var. " << systConfig.name() ); }
 
  for (auto& tool : m_tauTrigEffTool) {
    ret = tool->applySystematicVariation(systConfig);
    if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure " << tool->name() << " for systematic var. " << systConfig.name()); }
  }
  
  sf *= GetSignalTauSF(tau, idSF, triggerSF, trigExpr);  
 
  //Roll back to default
  ret = m_tauEffTool->applySystematicVariation(m_currentSyst);
  if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure TauEfficiencyCorrectionsTool back to default"); }
 
  for (auto& tool : m_tauTrigEffTool) {
    ret = tool->applySystematicVariation(m_currentSyst);
    if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure " << tool->name() << " back to default"); }
  }
  
  dec_effscalefact(tau) = sf;
 
  return sf;
}

GetSumOfWeights()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3034 of file SUSYObjDef_xAOD.cxx.

                                                   {
  return m_prwTool->GetSumOfEventWeights(channel);
}

getSystInfo()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2571 of file SUSYObjDef_xAOD.cxx.

                                                                              {
 
  SystInfo sysInfo;
  sysInfo.affectsKinematics = false;
  sysInfo.affectsWeights = false;
  sysInfo.affectedWeights.clear();
  sysInfo.systset.insert(sys);
 
  if (!m_jetNNJvtEfficiencyTool.empty()) {
    if ( m_jetNNJvtEfficiencyTool->isAffectedBySystematic( sys ) ) {
      sysInfo.affectsWeights = true;
      sysInfo.affectsType = SystObjType::Jet;
      sysInfo.affectedWeights.insert(ST::Weights::Jet::JVT);
    }
  }  
 
  if (!m_jetfJvtEfficiencyTool.empty()) {
    if ( m_jetfJvtEfficiencyTool->isAffectedBySystematic( sys ) ) {
      sysInfo.affectsWeights = true;
      sysInfo.affectsType = SystObjType::Jet;
      sysInfo.affectedWeights.insert(ST::Weights::Jet::FJVT);
    }
  }
 
  if (!m_jetUncertaintiesTool.empty()) {
    if ( m_jetUncertaintiesTool->isAffectedBySystematic( sys ) ) {
      sysInfo.affectsKinematics = true;
      sysInfo.affectsType = SystObjType::Jet;
    }
  }
  if (!m_jetUncertaintiesPDSmearTool.empty()) {
    if ( m_jetUncertaintiesPDSmearTool->isAffectedBySystematic( sys ) ) {
      sysInfo.affectsKinematics = true;
      sysInfo.affectsType = SystObjType::Jet;
    }
  }
 
  if (!m_fatjetUncertaintiesTool.empty()) {
    if ( m_fatjetUncertaintiesTool->isAffectedBySystematic( sys ) ) {
      sysInfo.affectsKinematics = true;
      sysInfo.affectsType = SystObjType::Jet;
    }
  }
  if (!m_fatjetUncertaintiesPDSmearTool.empty()) {
    if ( m_fatjetUncertaintiesPDSmearTool->isAffectedBySystematic( sys ) ) {
      sysInfo.affectsKinematics = true;
      sysInfo.affectsType = SystObjType::Jet;
    }
  }
 
  if (!m_fatjetFFSmearingTool.empty()) {
    CP::SystematicSet dummy;
    dummy.insert(sys);
    if ( std::find(m_fatjetFFSmearingSyst.begin(), m_fatjetFFSmearingSyst.end(), dummy) != m_fatjetFFSmearingSyst.end() ) {
      sysInfo.affectsKinematics = true;
      sysInfo.affectsType = SystObjType::Jet;
    }
  }
 
  if (!m_WTagjetUncertaintiesTool.empty()) {
    if ( m_WTagjetUncertaintiesTool->isAffectedBySystematic( CP::SystematicVariation(sys.basename(), CP::SystematicVariation::CONTINUOUS) ) ) {
      sysInfo.affectsKinematics = true;
      sysInfo.affectsType = SystObjType::Jet;
    }
  }
  if (!m_ZTagjetUncertaintiesTool.empty()) {
    if ( m_ZTagjetUncertaintiesTool->isAffectedBySystematic( CP::SystematicVariation(sys.basename(), CP::SystematicVariation::CONTINUOUS) ) ) {
      sysInfo.affectsKinematics = true;
      sysInfo.affectsType = SystObjType::Jet;
    }
  }
  if (!m_TopTagjetUncertaintiesTool.empty()) {
    if ( m_TopTagjetUncertaintiesTool->isAffectedBySystematic( CP::SystematicVariation(sys.basename(), CP::SystematicVariation::CONTINUOUS) ) ) {
      sysInfo.affectsKinematics = true;
      sysInfo.affectsType = SystObjType::Jet;
    }
  }
 
  if (!m_muonCalibTool.empty()) {
    if ( m_muonCalibTool->isAffectedBySystematic(sys) ) {
      sysInfo.affectsKinematics = true;
      sysInfo.affectsType = SystObjType::Muon;
    }
  }
  if (!m_elecEfficiencySFTool_trig_singleLep.empty()) {
    if ( m_elecEfficiencySFTool_trig_singleLep->isAffectedBySystematic(sys) ) {
      sysInfo.affectsWeights = true;
      sysInfo.affectsType = SystObjType::Electron;
      sysInfo.affectedWeights.insert(ST::Weights::Electron::Trigger);
    }
  }
  if (!m_elecEfficiencySFTool_trigEff_singleLep.empty()) {
    if ( m_elecEfficiencySFTool_trigEff_singleLep->isAffectedBySystematic(sys) ) {
      sysInfo.affectsWeights = true;
      sysInfo.affectsType = SystObjType::Electron;
      sysInfo.affectedWeights.insert(ST::Weights::Electron::Trigger);
    }
  }
  if (!m_muonEfficiencySFTool.empty()) {
    if ( m_muonEfficiencySFTool->isAffectedBySystematic(sys) ) {
      sysInfo.affectsWeights = true;
      sysInfo.affectsType = SystObjType::Muon;
      sysInfo.affectedWeights.insert(ST::Weights::Muon::Reconstruction);
    }
  }
  if (!m_muonEfficiencyBMHighPtSFTool.empty()) {
    if ( m_muonEfficiencyBMHighPtSFTool->isAffectedBySystematic(sys) ) {
      sysInfo.affectsWeights = true;
      sysInfo.affectsType = SystObjType::Muon;
      sysInfo.affectedWeights.insert(ST::Weights::Muon::Reconstruction);
    }
  }
  if (!m_muonTTVAEfficiencySFTool.empty()) {
    if ( m_muonTTVAEfficiencySFTool->isAffectedBySystematic(sys) ) {
      sysInfo.affectsWeights = true;
      sysInfo.affectsType = SystObjType::Muon;
      sysInfo.affectedWeights.insert(ST::Weights::Muon::Reconstruction);
    }
  }
  if (!m_muonIsolationSFTool.empty()) {
    if ( m_muonIsolationSFTool->isAffectedBySystematic(sys) ) {
      sysInfo.affectsWeights = true;
      sysInfo.affectsType = SystObjType::Muon;
      sysInfo.affectedWeights.insert(ST::Weights::Muon::Isolation);
    }
  }
  if (!m_muonTriggerSFTool.empty()) {
    if ( m_muonTriggerSFTool->isAffectedBySystematic(sys) ) {
      sysInfo.affectsWeights = true;
      sysInfo.affectsType = SystObjType::Muon;
      sysInfo.affectedWeights.insert(ST::Weights::Muon::Trigger);
    }
  }
  if (!m_elecEfficiencySFTool_reco.empty()) {
    if ( m_elecEfficiencySFTool_reco->isAffectedBySystematic(sys) ) {
      sysInfo.affectsWeights = true;
      sysInfo.affectsType = SystObjType::Electron;
      sysInfo.affectedWeights.insert(ST::Weights::Electron::Reconstruction);
    }
  }
  if (!m_elecEfficiencySFTool_id.empty()) {
    if ( m_elecEfficiencySFTool_id->isAffectedBySystematic(sys) ) {
      sysInfo.affectsWeights = true;
      sysInfo.affectsType = SystObjType::Electron;
      sysInfo.affectedWeights.insert(ST::Weights::Electron::ID);
    }
  }
  if (!m_trigGlobalEffCorrTool_diLep.empty()) {
    if ( m_trigGlobalEffCorrTool_diLep->isAffectedBySystematic(sys) ) {
      sysInfo.affectsWeights = true;
      sysInfo.affectsType = SystObjType::Electron;
      sysInfo.affectedWeights.insert(ST::Weights::Electron::Trigger);
    }
  }
  if (!m_trigGlobalEffCorrTool_multiLep.empty()) {
    if ( m_trigGlobalEffCorrTool_multiLep->isAffectedBySystematic(sys) ) {
      sysInfo.affectsWeights = true;
      sysInfo.affectsType = SystObjType::Electron;
      sysInfo.affectedWeights.insert(ST::Weights::Electron::Trigger);
    }
  }
  if (!m_elecEfficiencySFTool_iso.empty() ) {
    if ( m_elecEfficiencySFTool_iso->isAffectedBySystematic(sys) ) {
      sysInfo.affectsWeights = true;
      sysInfo.affectsType = SystObjType::Electron;
      sysInfo.affectedWeights.insert(ST::Weights::Electron::Isolation);
    }
  }
  if (!m_elecEfficiencySFTool_isoHighPt.empty() ) {
    if ( m_elecEfficiencySFTool_isoHighPt->isAffectedBySystematic(sys) ) {
      sysInfo.affectsWeights = true;
      sysInfo.affectsType = SystObjType::Electron;
      sysInfo.affectedWeights.insert(ST::Weights::Electron::Isolation);
    }
  }
  if (!m_egammaCalibTool.empty()) {
    if ( m_egammaCalibTool->isAffectedBySystematic(sys) ) {
      sysInfo.affectsKinematics = true;
      if (sys.basename().compare(0, 3, "EG_") == 0) {
    sysInfo.affectsType = SystObjType::Egamma;
      } else if (sys.basename().compare(0, 3, "PH_") == 0) {
    sysInfo.affectsType = SystObjType::Photon;
      } else if (sys.basename().compare(0, 3, "EL_") == 0) {
    sysInfo.affectsType = SystObjType::Electron;
      }
    }
  }
  if (!isData() && !m_isoCorrTool.empty()) {
    if (m_isoCorrTool->isAffectedBySystematic(sys)){
      sysInfo.affectsWeights = false;
      sysInfo.affectsKinematics = true;
      sysInfo.affectsType = SystObjType::Photon;
    }
  }
  if (!isData() && !m_photonEfficiencySFTool.empty()) {
    if (m_photonEfficiencySFTool->isAffectedBySystematic(CP::SystematicVariation(sys.basename(), CP::SystematicVariation::CONTINUOUS)) ) {
      sysInfo.affectsWeights = true;
      sysInfo.affectsType = SystObjType::Photon;
      sysInfo.affectedWeights.insert(ST::Weights::Photon::Reconstruction);
    }
  }
  if (!isData() && !m_photonIsolationSFTool.empty()) {
    if (m_photonIsolationSFTool->isAffectedBySystematic(sys)) {
      sysInfo.affectsWeights = true;
      sysInfo.affectsType = SystObjType::Photon;
      sysInfo.affectedWeights.insert(ST::Weights::Photon::Isolation);
    }
  }
  if (!isData() && !m_photonTriggerSFTool.empty()) {
    if (m_photonTriggerSFTool->isAffectedBySystematic(sys)) {
      sysInfo.affectsWeights = true;
      sysInfo.affectsType = SystObjType::Photon;
      sysInfo.affectedWeights.insert(ST::Weights::Photon::Trigger);
    }
  }
  if (!m_trigGlobalEffCorrTool_diPhoton.empty()) {
    if ( m_trigGlobalEffCorrTool_diPhoton->isAffectedBySystematic(sys) ) {
      sysInfo.affectsWeights = true;
      sysInfo.affectsType = SystObjType::Photon;
      sysInfo.affectedWeights.insert(ST::Weights::Photon::Trigger);
    }
  }
  if ( !m_btagEffTool.empty() ) {
    if ( m_btagEffTool->isAffectedBySystematic(sys) ) {
      sysInfo.affectsWeights = true;
      sysInfo.affectsType = SystObjType::BTag;
      sysInfo.affectedWeights.insert(ST::Weights::Jet::Btag);
    }
  }
  if ( !m_btagEffTool_trkJet.empty() ) {
    if ( m_btagEffTool_trkJet->isAffectedBySystematic(sys) ) {
      sysInfo.affectsWeights = true;
      sysInfo.affectsType = SystObjType::BTag;
      sysInfo.affectedWeights.insert(ST::Weights::Jet::Btag_Track);
    }
  }
  if (!m_tauSmearingTool.empty()) {
    if ( m_tauSmearingTool->isAffectedBySystematic(sys) ) {
      sysInfo.affectsKinematics = true;
      sysInfo.affectsType = SystObjType::Tau;
    }
  }
  if (!m_tauEffTool.empty()) {
    if ( m_tauEffTool->isAffectedBySystematic(sys) ) {
      sysInfo.affectsWeights = true;
      sysInfo.affectsType = SystObjType::Tau;
      sysInfo.affectedWeights.insert(ST::Weights::Tau::Reconstruction);
    }
  }
  for(const auto &tool : m_tauTrigEffTool) {
    if(tool->isAffectedBySystematic(sys)) {
      sysInfo.affectsWeights = true;
      sysInfo.affectsType = SystObjType::Tau;
      sysInfo.affectedWeights.insert(ST::Weights::Tau::Trigger);
      break;
    }
  }
  if (!m_metSystTool.empty()) {
    if ( m_metSystTool->isAffectedBySystematic(sys) ) {
      sysInfo.affectsKinematics = true;
      switch (met::getSystType(sys)) {
      case met::SOFTCALO:
    sysInfo.affectsType = SystObjType::MET_CST;
    break;
      case met::SOFTTRK:
    sysInfo.affectsType = SystObjType::MET_TST;
    break;
      case met::JETTRK:
    sysInfo.affectsType = SystObjType::MET_Track;
    break;
      default:
    ATH_MSG_ERROR("Unsupported systematic!");
      }
    }
  }
  if (!m_prwTool.empty()) {
    if ( m_prwTool->isAffectedBySystematic(sys) ) {
      sysInfo.affectsWeights = true;
      sysInfo.affectsType = SystObjType::EventWeight;
    }
  }
 
  if (!m_LRTuncTool.empty()){
    if ( m_LRTuncTool->isAffectedBySystematic(sys) ) {
      sysInfo.affectsKinematics = true;
      sysInfo.affectsType = SystObjType::LRT_Object;
    }
  }
 
  std::string affectedType;
  switch (sysInfo.affectsType) {
  case Unknown     : affectedType = "UNKNOWN";  break;
  case Jet         : affectedType = "JET";      break;
  case Egamma      : affectedType = "EGAMMA";   break;
  case Electron    : affectedType = "ELECTRON"; break;
  case Photon      : affectedType = "PHOTON";   break;
  case Muon        : affectedType = "MUON";     break;
  case Tau         : affectedType = "TAU";      break;
  case BTag        : affectedType = "BTAG";     break;
  case MET_TST     : affectedType = "MET_TST";  break;
  case MET_CST     : affectedType = "MET_CST";  break;
  case MET_Track   : affectedType = "MET_Track";  break;
  case EventWeight : affectedType = "EVENT WEIGHT"; break;
  case LRT_Object  : affectedType = "LRT_OBJECT"; break;
  }
 
  ATH_MSG_VERBOSE("Variation " << sys.name() << " affects "
          << ( sysInfo.affectsWeights ? "weights " : "" )
          << ( sysInfo.affectsKinematics ? "kinematics " : "" )
          << "for " << affectedType );
 
  return sysInfo;
 
}

getSystInfoList()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2536 of file SUSYObjDef_xAOD.cxx.

                                                             {
  if (!m_tool_init) {
    ATH_MSG_ERROR("SUSYTools was not initialized!!");
    return vector<ST::SystInfo>();
  }
 
  ATH_MSG_INFO("Extracting systematics info list");
 
  // Now we can look at systematics:
  const CP::SystematicRegistry& registry = CP::SystematicRegistry::getInstance();
  const CP::SystematicSet& recommendedSystematics = registry.recommendedSystematics();
 
  vector<SystInfo> sysInfoList;
  sysInfoList.reserve(recommendedSystematics.size() * 2); // allow for continuous systematics
 
  // this is the nominal set
  SystInfo infodef;
  infodef.affectsKinematics = false;
  infodef.affectsWeights = false;
  infodef.affectsType = Unknown;
  infodef.affectedWeights.clear();
  sysInfoList.push_back(infodef);
 
 
  // add all recommended systematics
  for (const auto& systSet : CP::make_systematics_vector(recommendedSystematics)) {
    for (const auto& sys : systSet) {
      sysInfoList.push_back(getSystInfo(sys));
    }
  }
 
  ATH_MSG_INFO("Returning list of " << sysInfoList.size() << " systematic variations");
  return sysInfoList;
}

getTauConfig()

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

protected

Definition at line 1836 of file SUSYObjDef_xAOD.cxx.

                                                                                                                                                                           {
 
  if(tauConfigPath.empty()) return;
 
  TEnv rEnv;
  auto filename = PathResolverFindCalibFile(tauConfigPath);
  rEnv.ReadFile(filename.c_str(), kEnvAll);
 
  std::vector<std::string> cuts;
  if (rEnv.Defined("SelectionCuts")) {
    cuts = split(rEnv.GetValue("SelectionCuts", " "), " ");
  } else {
    auto *l = rEnv.GetTable();
    for( Int_t i = 0; i < l->GetEntries(); ++i ) {
      cuts.push_back( l->At(i)->GetName() );
    }
  }
 
  //default OR settings
  eleOLR=false;
  muOLR=false;
  muVeto=false;
 
  static const std::string trueBool = "TRUE";
 
  // Now find the pT and eta window
  std::vector<std::string> v_pT_window;
  std::vector<std::string> v_eta_window;
  pT_window.clear();
  eta_window.clear();
  float pT_min = -99.0;
  float pT_max = -99.0;
  float eta_min = -99.0;
  float eta_max = -99.0;
  for (const auto& cut : cuts) {
    if(cut == "PtRegion") {
      v_pT_window = split(rEnv.GetValue("PtRegion", ""), ";");
      std::transform(std::begin(v_pT_window),
             std::end(v_pT_window),
             std::back_inserter(pT_window),
             [](const std::string& s) { return std::stof(s); }
             );
    } else if (cut == "PtMin") {
      pT_min = rEnv.GetValue("PtMin", NAN);
    } else if (cut == "PtMax") {
      pT_max = rEnv.GetValue("PtMax", NAN);
    } else if (cut == "AbsEtaRegion") {
      v_eta_window = split(rEnv.GetValue("AbsEtaRegion", ""), ";");
      std::transform(std::begin(v_eta_window),
             std::end(v_eta_window),
             std::back_inserter(eta_window),
             [](const std::string& s) { return std::stof(s); }
             );
    } else if (cut == "AbsEtaMin") {
      eta_min = rEnv.GetValue("AbsEtaMin", NAN);
    } else if (cut == "AbsEtaMax") {
      eta_max = rEnv.GetValue("AbsEtaMax", NAN);
    }
 
    //OR settings
    else if (cut == "EleOLR"){
      eleOLR = (rEnv.GetValue("EleOLR", "FALSE") == trueBool);
    }
    else if (cut == "MuonVeto"){
      muVeto = (rEnv.GetValue("MuonVeto", "FALSE") == trueBool);
    }
    else if (cut == "MuonOLR"){
      muOLR = (rEnv.GetValue("MuonOLR", "FALSE") == trueBool);
    }
  }
 
  if(pT_window.empty()) {
    if(pT_min == pT_min) {
      // fails on NaN
      pT_window.push_back(pT_min);
    } else {
      pT_window.push_back(-std::numeric_limits<float>::infinity());
    }
 
    if(pT_max == pT_max) {
      // fails on NaN
      pT_window.push_back(pT_max);
    } else {
      pT_window.push_back(std::numeric_limits<float>::infinity());
    }
  }
 
  if(eta_window.empty()) {
    if(eta_min == eta_min) {
      // fails on NaN
      eta_window.push_back(eta_min);
    } else {
      eta_window.push_back(-std::numeric_limits<float>::infinity());
    }
 
    if(eta_max == eta_max) {
      // fails on NaN
      eta_window.push_back(eta_max);
    } else {
      eta_window.push_back(std::numeric_limits<float>::infinity());
    }
  }
}

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.

{
  if (!m_tool_init) {
    ATH_MSG_ERROR("SUSYTools was not initialized!!");
    return StatusCode::FAILURE;
  }
  
  if (m_isPHYSLITE && taukey.find("AnalysisTauJets")==std::string::npos){
    ATH_MSG_ERROR("You are running on PHYSLITE derivation. Please change the Taus container to 'AnalysisTauJets'");
    return StatusCode::FAILURE;
  }
 
  const xAOD::TauJetContainer* taus = nullptr;
  if (copy==nullptr) { // empty container provided
    if (containerToBeCopied != nullptr) {
      taus = containerToBeCopied;
    }
    else {
      ATH_CHECK( evtStore()->retrieve(taus, taukey) );
    }
    std::pair<xAOD::TauJetContainer*, xAOD::ShallowAuxContainer*> shallowcopy = xAOD::shallowCopyContainer(*taus);
    copy = shallowcopy.first;
    copyaux = shallowcopy.second;
    bool setLinks = xAOD::setOriginalObjectLink(*taus, *copy);
    if (!setLinks) {
      ATH_MSG_WARNING("Failed to set original object links on " << taukey);
    }
  } else { // use the user-supplied collection instead 
    ATH_MSG_DEBUG("Not retrieving tau collecton, using existing one provided by user");
    taus=copy;
  }
 
  for (const auto tau : *copy) {
    ATH_CHECK( this->FillTau(*tau) );
    this->IsSignalTau(*tau, m_tauPt, m_tauEta);
  }
  if (recordSG) {
    ATH_CHECK( evtStore()->record(copy, "STCalib" + taukey + m_currentSyst.name()) );
    ATH_CHECK( evtStore()->record(copyaux, "STCalib" + taukey + m_currentSyst.name() + "Aux.") );
  }
  return StatusCode::SUCCESS;
}

GetTauTriggerEfficiencySF()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 193 of file Taus.cxx.

                                                                                                  {
 
  double eff(1.);
 
  auto map_it = m_tau_trig_support.find(trigExpr); 
  if (map_it == m_tau_trig_support.end()) {
    ATH_MSG_WARNING("The trigger item requested ("  << trigExpr << ") is not supported! Please check. Setting SF to 1.");
    return eff;
  }
 
  // trigger matching (dR=0.2)
  std::vector<std::string> chains;
  boost::split(chains, map_it->second, [](char c){return c == ',';});
  bool match = false;
  for (const std::string& chain : chains)
    if (m_trigMatchingTool->match({&tau}, chain, 0.2)) {
      match = true;
      break;
    }
  if (!match) {
    ATH_MSG_VERBOSE("Tau did not match trigger " << trigExpr);
    return eff;
  }
 
  int trigIdx = std::distance(std::begin(m_tau_trig_support), map_it);
  if (m_tauTrigEffTool.at(trigIdx)->getEfficiencyScaleFactor(tau, eff) != CP::CorrectionCode::Ok) {
    ATH_MSG_ERROR("Some problem found to retrieve SF for trigger item  requested ("  << trigExpr << ")");
    eff = -99;
  }
  
  return eff;
}

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

                                                                                                                                                                                                                             {
  float sf(1.);
 
  for (const xAOD::Electron* electron : electrons) {
    if (!acc_passOR(*electron)) continue;
    if (acc_signal(*electron)) { sf *= this->GetSignalElecSF(*electron, recoSF, idSF, triggerSF, isoSF, trigExpr, ecidsSF, cidSF); }
    else { this->GetSignalElecSF(*electron, recoSF, idSF, triggerSF, isoSF, trigExpr, ecidsSF, cidSF); }
  }
 
  return sf;
}

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

                                                                                                                                                                                                                                                                     {
  float sf(1.);
 
  //Set the new systematic variation
  StatusCode ret(StatusCode::SUCCESS);
  if(!m_elecEfficiencySFTool_reco.empty()){
    ret = m_elecEfficiencySFTool_reco->applySystematicVariation(systConfig);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (reco) for systematic var. " << systConfig.name() );
    }
  }
 
  if(!m_elecEfficiencySFTool_id.empty()){
    ret = m_elecEfficiencySFTool_id->applySystematicVariation(systConfig);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (id) for systematic var. " << systConfig.name() );
    }
  }
 
  if(!m_elecEfficiencySFTool_trig_singleLep.empty()){
    ret = m_elecEfficiencySFTool_trig_singleLep->applySystematicVariation(systConfig);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (trigger) for systematic var. " << systConfig.name() );
    }
  }
 
  if(!m_elecEfficiencySFTool_iso.empty()){
    ret = m_elecEfficiencySFTool_iso->applySystematicVariation(systConfig);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (iso) for systematic var. " << systConfig.name() );
    }
  }
 
  if(!m_elecEfficiencySFTool_isoHighPt.empty()){
    ret = m_elecEfficiencySFTool_isoHighPt->applySystematicVariation(systConfig);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (iso high-pt) for systematic var. " << systConfig.name() );
    }
  }
 
  if(!m_elecChargeEffCorrTool.empty()){
    ret = m_elecChargeEffCorrTool->applySystematicVariation(systConfig);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure ElectronChargeEfficiencyCorrectionTool for systematic var. " << systConfig.name() );
    }
  }
 
 
  //Get the total SF for new config
  sf = GetTotalElectronSF(electrons, recoSF, idSF, triggerSF, isoSF, trigExpr, ecidsSF, cidSF);
 
  //Roll back to default
  if(!m_elecEfficiencySFTool_reco.empty()){
    ret = m_elecEfficiencySFTool_reco->applySystematicVariation(m_currentSyst);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (reco) back to default.");
    }
  }
 
  if(!m_elecEfficiencySFTool_id.empty()){
    ret = m_elecEfficiencySFTool_id->applySystematicVariation(m_currentSyst);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (id) back to default.");
    }
  }
 
  if(!m_elecEfficiencySFTool_trig_singleLep.empty()){
    ret = m_elecEfficiencySFTool_trig_singleLep->applySystematicVariation(m_currentSyst);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (trigger) back to default.");
    }
  }
 
  if(!m_elecEfficiencySFTool_iso.empty()){
    ret = m_elecEfficiencySFTool_iso->applySystematicVariation(m_currentSyst);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (iso) back to default.");
    }
  }
 
  if(!m_elecEfficiencySFTool_isoHighPt.empty()){
    ret = m_elecEfficiencySFTool_isoHighPt->applySystematicVariation(m_currentSyst);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (iso high-pt) back to default.");
    }
  }
 
  if(!m_elecChargeEffCorrTool.empty()){
    ret = m_elecChargeEffCorrTool->applySystematicVariation(m_currentSyst);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure ElectronChargeEfficiencyCorrectionTool back to default.");
    }
  }
 
  return sf;
}

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

                                                                                                                            {
 
    double totalSF = 1.;
    if (btagSF) totalSF *= BtagSF(jets);
 
    if (jvtSF && m_applyJVTCut) totalSF *= JVT_SF(jets);
 
    if (fjvtSF) totalSF *= FJVT_SF(jets);
 
    return totalSF;
  }

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

                                                                                                                                                                  {
 
    double totalSF = 1.;
    if (btagSF) totalSF *= BtagSFsys(jets, systConfig);
 
    if (jvtSF && m_applyJVTCut) totalSF *= JVT_SFsys(jets, systConfig);
 
    if (fjvtSF) totalSF *= FJVT_SFsys(jets, systConfig);
 
    return totalSF;
  }

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

                                                                                                                                                         {
  double sf(1.);
 
  ConstDataVector<xAOD::MuonContainer> sfmuons(SG::VIEW_ELEMENTS);
  for (const xAOD::Muon* muon : muons) {
    if( !acc_passOR(*muon) ) continue;
    if (acc_signal(*muon)) {
      sfmuons.push_back(muon);
      if (recoSF || isoSF) { sf *= this->GetSignalMuonSF(*muon, recoSF, isoSF, bmhptSF); }
    } else { // decorate baseline muons as well
      if (recoSF || isoSF) { this->GetSignalMuonSF(*muon, recoSF, isoSF, bmhptSF, false); } //avoid OVR warnings in this case
    }
  }
 
  sf *= GetTotalMuonTriggerSF(*sfmuons.asDataVector(), trigExpr);
  
  return sf;
}

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

                                                                                                                                                                                                 {
  double sf(1.);
  //Set the new systematic variation
  StatusCode ret = m_muonEfficiencySFTool->applySystematicVariation(systConfig);
  if ( ret != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("Cannot configure MuonEfficiencyScaleFactors for systematic var. " << systConfig.name() );
  }
 
  ret = m_muonEfficiencyBMHighPtSFTool->applySystematicVariation(systConfig);
  if ( ret != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("Cannot configure MuonBadMuonHighPtScaleFactors for systematic var. " << systConfig.name() );
  }
 
  ret = m_muonTTVAEfficiencySFTool->applySystematicVariation(systConfig);
  if ( ret != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("Cannot configure MuonTTVAEfficiencyScaleFactors for systematic var. " << systConfig.name() );
  }
 
  ret  = m_muonIsolationSFTool->applySystematicVariation(systConfig);
  if ( ret != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("Cannot configure MuonIsolationScaleFactors for systematic var. " << systConfig.name() );
  }
 
  ret  = m_muonHighPtIsolationSFTool->applySystematicVariation(systConfig);
  if ( ret != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("Cannot configure MuonHighPtIsolationScaleFactors for systematic var. " << systConfig.name() );
  }
 
  ret  = m_muonTriggerSFTool->applySystematicVariation(systConfig);
  if ( ret != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("Cannot configure MuonTriggerScaleFactors for systematic var. " << systConfig.name() );
  }
 
  ret = m_trigGlobalEffCorrTool_diLep->applySystematicVariation(systConfig);
  if (ret != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (trigger) for systematic var. " << systConfig.name() );
  }
 
  ret = m_trigGlobalEffCorrTool_multiLep->applySystematicVariation(systConfig);
  if (ret != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (trigger) for systematic var. " << systConfig.name() );
  }
 
  sf = GetTotalMuonSF(muons, recoSF, isoSF, trigExpr, bmhptSF);
 
  //Roll back to default
  ret  = m_muonEfficiencySFTool->applySystematicVariation(m_currentSyst);
  if ( ret != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("Cannot configure MuonEfficiencyScaleFactors back to default.");
  }
 
  ret = m_muonEfficiencyBMHighPtSFTool->applySystematicVariation(m_currentSyst);
  if ( ret != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("Cannot configure MuonBadMuonHighPtScaleFactors back to default.");
  }
 
  ret  = m_muonTTVAEfficiencySFTool->applySystematicVariation(m_currentSyst);
  if ( ret != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("Cannot configure MuonTTVAEfficiencyScaleFactors back to default.");
  }
 
  ret  = m_muonIsolationSFTool->applySystematicVariation(m_currentSyst);
  if ( ret != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("Cannot configure MuonIsolationScaleFactors back to default.");
  }
 
  ret  = m_muonHighPtIsolationSFTool->applySystematicVariation(m_currentSyst);
  if ( ret != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("Cannot configure MuonIsolationScaleFactors back to default.");
  }
 
  ret  = m_muonTriggerSFTool->applySystematicVariation(m_currentSyst);
  if ( ret != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("Cannot configure MuonTriggerScaleFactors back to default.");
  }
 
  ret = m_trigGlobalEffCorrTool_diLep->applySystematicVariation(m_currentSyst);
  if (ret != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (trigger) back to default.");
  }
 
  ret = m_trigGlobalEffCorrTool_multiLep->applySystematicVariation(m_currentSyst);
  if (ret != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (trigger) back to default.");
  }
 
  return sf;
}

GetTotalMuonTriggerSF()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 546 of file Muons.cxx.

                                                                                                         {
 
  if (trigExpr.empty() || sfmuons.empty()) return 1.;
 
 
  double trig_sf = 1.;
 
  int mulegs = 0;
  const char *tmp = trigExpr.c_str();
  while( (tmp = strstr(tmp, "mu")) ){
    mulegs++;
    tmp++;
  }
 
  bool isdimuon = (trigExpr.find("2mu") != std::string::npos);
  bool isOR = (trigExpr.find("OR") != std::string::npos);
  
  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
    if (m_muonTriggerSFTool->getTriggerScaleFactor( sfmuons, trig_sf, trigExpr ) == CP::CorrectionCode::Ok) {
      ATH_MSG_DEBUG( "MuonTrig ScaleFactor " << trig_sf );
    }
    else{
      ATH_MSG_DEBUG( "MuonTrig FAILED SOMEHOW");
    }
  }
  else if(mulegs!=2 && isOR){ //Case 2: not supported. Not efficiency defined for (at least) one leg. Sorry...
    ATH_MSG_WARNING( "SF for " << trigExpr << " are only supported for two muon events!");
  }
  else{ //Case 3: let's go the hard way...
        //Following https://twiki.cern.ch/twiki/bin/view/Atlas/TrigMuonEfficiency
    std::string newtrigExpr = TString(trigExpr).Copy().ReplaceAll("HLT_2","").Data();
 
    //redefine dimuon triggers here (2mu14 --> mu14_mu14)
    if (isdimuon) { newtrigExpr += "_"+newtrigExpr;  }
    boost::replace_all(newtrigExpr, "HLT_", "");
    boost::char_separator<char> sep("_");
 
    for (const auto& mutrig : boost::tokenizer<boost::char_separator<char>>(newtrigExpr, sep)) {
      double dataFactor = 1.;
      double mcFactor   = 1.;
      
      for (const xAOD::Muon* mu : sfmuons) {
        // No need for additional trigger matching
        dataFactor *= (1 - GetMuonTriggerEfficiency(*mu, "HLT_"+mutrig, true));
        mcFactor   *= (1 - GetMuonTriggerEfficiency(*mu, "HLT_"+mutrig, false));
      }
      if( (1-mcFactor) > 0. )
        trig_sf *= (1-dataFactor)/(1-mcFactor);
    }
  }
 
  return trig_sf;
}

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

{
  double sf(1.);
 
  for (const xAOD::Photon* photon : photons) {
    if (acc_signal(*photon) && acc_passOR(*photon)) { sf *= this->GetSignalPhotonSF(*photon, effSF, isoSF, triggerSF); }
  }
 
  return sf;
}

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

{
  double sf(1.);
 
  for (const xAOD::Photon* photon : photons) {
    if (acc_signal(*photon) && acc_passOR(*photon)) { sf *= this->GetSignalPhotonSFsys(*photon, systConfig, effSF, isoSF, triggerSF); }
  }
 
  return sf;
}

GetTotalTauSF()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 227 of file Taus.cxx.

                                                                                                                                       {
 
  double sf(1.);
 
  for (const xAOD::TauJet* tau : taus) {
    // check existence of OR information
    if (!acc_passOR.isAvailable(*tau)) { 
      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!");
      break;
    }
 
    // Call this for all taus, which will add the decoration
    double tmpSF = GetSignalTauSF(*tau, idSF, triggerSF, trigExpr);
    if (acc_signal(*tau) && acc_passOR(*tau)) {
      sf *= tmpSF;
    }
  }
 
  return sf;
}

GetTotalTauSFsys()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 249 of file Taus.cxx.

                                                                                                                                                                            {
  double sf(1.);
 
  //Set the new systematic variation
  StatusCode ret = m_tauEffTool->applySystematicVariation(systConfig);
  if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure TauEfficiencyCorrectionsTool for systematic var. " << systConfig.name() ); }
 
  for (auto& tool : m_tauTrigEffTool) {
    ret = tool->applySystematicVariation(systConfig);
    if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure " << tool->name() << " for systematic var. " << systConfig.name()); }
  }
 
  sf = GetTotalTauSF(taus, idSF, triggerSF, trigExpr);
 
  //Roll back to default
  ret = m_tauEffTool->applySystematicVariation(m_currentSyst);
  if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure TauEfficiencyCorrectionsTool back to default"); }
 
  for (auto& tool : m_tauTrigEffTool) {
    ret = tool->applySystematicVariation(m_currentSyst);
    if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure " << tool->name() << " back to default"); }
  }
 
  return sf;
}

GetTrackJets()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 170 of file Jets.cxx.

  {
    if (!m_tool_init) {
      ATH_MSG_ERROR("SUSYTools was not initialized!!");
      return StatusCode::FAILURE;
    }
 
    ATH_MSG_DEBUG("Default jetkey (trkjet):           " << m_defaultTrackJets);
    ATH_MSG_DEBUG("Function argument jetkey (trkjet): " << jetkey);
 
    // load default regular & btag jet keys
    std::string jetkey_tmp = m_defaultTrackJets;
 
    // override default if user is passing a jetkey
    if (!jetkey.empty()) {
      jetkey_tmp = jetkey;
    }
 
    // final settings
    ATH_MSG_DEBUG("Key for retrieving trkjet collection (as well as bjet info):      jetkey      = " << jetkey_tmp);
 
    const xAOD::JetContainer* jets = nullptr;
    if (copy==nullptr) { // empty container provided
      if (containerToBeCopied != nullptr) {
        jets = containerToBeCopied;
      }
      else {
        ATH_MSG_DEBUG("Retrieve jet collection: " << jetkey_tmp);
        ATH_CHECK( evtStore()->retrieve(jets, jetkey_tmp) );
      }
      std::pair<xAOD::JetContainer*, xAOD::ShallowAuxContainer*> shallowcopy = xAOD::shallowCopyContainer(*jets);
      copy = shallowcopy.first;
      copyaux = shallowcopy.second;
      bool setLinks = xAOD::setOriginalObjectLink(*jets, *copy);
      if (!setLinks) {
        ATH_MSG_WARNING("Failed to set original object links on " << jetkey_tmp);
      }
    } else { // use the user-supplied collection instead
      ATH_MSG_DEBUG("Not retrieving jet collection, using existing one provided by user");
      jets = copy;
    }
 
    //disable - notfortrackjets? // Calibrate the jets
    //disable - notfortrackjets? ATH_CHECK(m_jetCalibTool->applyCalibration(*copy));
 
    // Update the jets
    for (const auto jet : *copy) {
      ATH_CHECK( this->FillTrackJet(*jet) );
    }
 
    if (copy->size() > 1 && m_defaultTrackJets == "AntiKtVR30Rmax4Rmin02TrackJets") {
        // Use iterators to avoid pairing the jets twice
        for (xAOD::JetContainer::const_iterator j1 = copy->begin()+1; j1!= copy->end();++j1) {
          const xAOD::Jet* jet1 = (*j1);
          if (!acc_signal(*jet1)) continue;
          for (xAOD::JetContainer::const_iterator j2 = copy->begin(); j2 != j1; ++j2) {
            const xAOD::Jet* jet2 = (*j2);
            if (!acc_baseline(*jet2)) continue;
            //Reference to the use method in P4Helper: deltaR2( const xAOD::IParticle& p4, const xAOD::IParticle& , bool useRapidity=true )
            float dr_jets =  xAOD::P4Helpers::deltaR(jet1,jet2, false);
            const xAOD::Jet* to_check = acc_VRradius(*jet1) < acc_VRradius(*jet2) ? jet1 : jet2;
            if( dr_jets < acc_VRradius(*to_check)) dec_passDRcut(*to_check) = false;
            //break the loop at this point???
          }
        }
    }
    if (recordSG) {
      ATH_CHECK( evtStore()->record(copy, "STCalib" + jetkey_tmp + m_currentSyst.name()) );
      ATH_CHECK( evtStore()->record(copyaux, "STCalib" + jetkey_tmp + m_currentSyst.name() + "Aux.") );
    }
    return StatusCode::SUCCESS;
  }

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.

                                                                       {
  if (!m_tool_init) {
    ATH_MSG_ERROR("SUSYTools was not initialized!!");
    return StatusCode::FAILURE;
  }
 
  const xAOD::MissingETContainer* metcore(nullptr);
  if ( evtStore()->retrieve( metcore, m_inputMETCore ).isFailure() ) {
    ATH_MSG_WARNING( "Unable to retrieve MET core container: " << m_inputMETCore );
    return StatusCode::FAILURE;
  }
  const xAOD::MissingETAssociationMap* metMap(nullptr);
  if ( evtStore()->retrieve(metMap, m_inputMETMap).isFailure() ) {
    ATH_MSG_WARNING("Unable to retrieve MissingETAssociationMap: " << m_inputMETMap);
    return StatusCode::FAILURE;
  }
  // Helper keeps track of object selection flags for this map
  xAOD::MissingETAssociationHelper metHelper(&(*metMap));
 
  metHelper.resetObjSelectionFlags();
 
  if (elec) {
    ATH_MSG_VERBOSE("Build electron MET");
    ConstDataVector<xAOD::ElectronContainer> metelectron(SG::VIEW_ELEMENTS);
    for (const xAOD::Electron* el : *elec) {
      // pass baseline selection
      if (acc_baseline(*el)) metelectron.push_back(el);
    }
    ATH_CHECK( m_metMaker->rebuildMET(m_eleTerm, xAOD::Type::Electron, &met, metelectron.asDataVector(), metHelper) );
  }
 
  if (muon) {
    ATH_MSG_VERBOSE("Build muon MET");
    ConstDataVector<xAOD::MuonContainer> metmuon(SG::VIEW_ELEMENTS);
    for (const xAOD::Muon* mu : *muon) {
      // pass baseline selection
      if (acc_baseline(*mu)) metmuon.push_back(mu);
    }
    ATH_CHECK( m_metMaker->rebuildMET(m_muonTerm, xAOD::Type::Muon, &met, metmuon.asDataVector(), metHelper) );
  }
 
  if (!jet) {
    ATH_MSG_WARNING("Invalid jet container specified for MET rebuilding!");
    return StatusCode::SUCCESS;
  }
  ATH_MSG_VERBOSE("Build jet/soft MET_Track");
 
  std::string softTerm = "PVSoftTrk";
  ATH_CHECK( m_metMaker->rebuildTrackMET(m_jetTerm, softTerm, &met, jet, metcore, metHelper, true) );
 
  if (!isData()) {
    m_metSystTool->setRandomSeed(static_cast<int>(1e6*met[softTerm]->phi()));
 
    if (m_trkMETsyst) {
      ATH_MSG_VERBOSE("Apply trkMET systematics");
      if ( m_metSystTool->applyCorrection(*met[softTerm],metHelper) != CP::CorrectionCode::Ok )
    ATH_MSG_WARNING("GetMET: Failed to apply MET track (PVSoftTrk) systematics.");
    }
 
    if (m_trkJetsyst) {
      ATH_MSG_VERBOSE("Apply Ref Jet trkMET systematics");
      if ( m_metSystTool->applyCorrection(*met[m_jetTerm],metHelper) != CP::CorrectionCode::Ok )
    ATH_MSG_WARNING("GetMET: Failed to apply MET track (RefJet) systematics.");
    }
 
  }
 
  ATH_MSG_VERBOSE("Build MET sum");
  ATH_CHECK( met::buildMETSum("Track", &met, met[softTerm]->source()) );
  ATH_MSG_VERBOSE( "Done rebuilding MET." );
 
  ATH_MSG_VERBOSE( "Track MET: Missing Et (x,y): (" << met["Track"]->mpx() << "," << met["Track"]->mpy() << ")");
 
  return StatusCode::SUCCESS;
}

GetTrigChainGroup()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 315 of file Trigger.cxx.

                                                                                       {
  return m_trigDecTool->getChainGroup(tr_item);
}

GetTriggerFeatures()

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

Definition at line 393 of file Trigger.cxx.

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

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

                                                                                                                                                    {
 
  double trig_eff(1.);
  double trig_eff_data(1.);
 
  if (trigExpr!="multiLepton" && trigExpr!="diLepton") {
    ATH_MSG_ERROR( "Failed to retrieve multi-lepton trigger efficiency");
    return trig_eff;
  }
 
  std::vector<const xAOD::Electron*> elec_trig;
  for (const xAOD::Electron* electron : electrons) {
    if (!acc_passOR(*electron)) continue;
    if (!acc_signal(*electron)) continue;
    elec_trig.push_back(electron);
  }
 
  std::vector<const xAOD::Muon*> muon_trig;
  for (const xAOD::Muon* muon : muons) {
    if (!acc_passOR(*muon)) continue;
    if (!acc_signal(*muon)) continue;
    muon_trig.push_back(muon);
  }
 
  bool matched = false;
  if ((elec_trig.size()+muon_trig.size())>1 && trigExpr=="diLepton") {
    if ( m_trigGlobalEffCorrTool_diLep->checkTriggerMatching( matched, elec_trig, muon_trig) != CP::CorrectionCode::Ok ) { 
      ATH_MSG_ERROR ("trigGlobEffCorrTool::Trigger matching could not be checked, interrupting execution.");
    }
  } else if ((elec_trig.size()+muon_trig.size())>2 && trigExpr=="multiLepton") {
    if ( m_trigGlobalEffCorrTool_multiLep->checkTriggerMatching( matched, elec_trig, muon_trig) != CP::CorrectionCode::Ok ) { 
      ATH_MSG_ERROR ("trigGlobEffCorrTool::Trigger matching could not be checked, interrupting execution.");
    }
  }
 
  CP::CorrectionCode result;
  if ((elec_trig.size()+muon_trig.size())>1 && trigExpr=="diLepton" && matched) {
    result = m_trigGlobalEffCorrTool_diLep->getEfficiency( elec_trig, muon_trig, trig_eff_data, trig_eff);
  }
  else if ((elec_trig.size()+muon_trig.size())>2 && trigExpr=="multiLepton" && matched) {
    result = m_trigGlobalEffCorrTool_multiLep->getEfficiency( elec_trig, muon_trig, trig_eff_data, trig_eff);
  }
 
  switch (result) {
  case CP::CorrectionCode::Error:
    ATH_MSG_ERROR( "Failed to retrieve multi-lepton trigger efficiency");
    return 1.;
  case CP::CorrectionCode::OutOfValidityRange:
    ATH_MSG_VERBOSE( "OutOfValidityRange found for multi-lepton trigger efficiency");
    return 1.;
  default:
    break;
  }
 
  if (isData()) return trig_eff_data;
  else return trig_eff;
}

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

                                                                                                                {
 
  double trig_eff(1.);
  double trig_eff_data(1.);
 
  if (trigExpr!="diPhoton") {
    ATH_MSG_ERROR( "Failed to retrieve diphoton trigger efficiency");
    return trig_eff;
  }
 
  std::vector<const xAOD::Photon*> ph_trig;
  for (const xAOD::Photon* photon : photons) {
    if (!acc_passOR(*photon)) continue;
    if (!acc_signal(*photon)) continue;
    ph_trig.push_back(photon);
  }
 
  CP::CorrectionCode result;
  if (ph_trig.size()>1) {
    result = m_trigGlobalEffCorrTool_diPhoton->getEfficiency(ph_trig, trig_eff_data, trig_eff);
  }
 
  switch (result) {
  case CP::CorrectionCode::Error:
    ATH_MSG_ERROR( "Failed to retrieve diphoton trigger efficiency");
    return 1.;
  case CP::CorrectionCode::OutOfValidityRange:
    ATH_MSG_VERBOSE( "OutOfValidityRange found for diphoton trigger efficiency");
    return 1.;
  default:
    break;
  }
 
  if (isData()) return trig_eff_data;
  else return trig_eff;
}

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

                                                                                                                                                      {
 
  double trig_sf(1.);
 
  if (trigExpr!="multiLepton" && trigExpr!="diLepton") {
    ATH_MSG_ERROR( "Failed to retrieve multi-lepton trigger SF");
    return trig_sf;
  }
 
  std::vector<const xAOD::Electron*> elec_trig;
  for (const xAOD::Electron* electron : electrons) {
    if (!acc_passOR(*electron)) continue;
    if (!acc_signal(*electron)) continue;
    elec_trig.push_back(electron);
  }
 
  std::vector<const xAOD::Muon*> muon_trig;
  for (const xAOD::Muon* muon : muons) {
    if (!acc_passOR(*muon)) continue;
    if (!acc_signal(*muon)) continue;
    muon_trig.push_back(muon);
  }
 
  bool matched = false;
  if ((elec_trig.size()+muon_trig.size())>1 && trigExpr=="diLepton") {
    if ( m_trigGlobalEffCorrTool_diLep->checkTriggerMatching( matched, elec_trig, muon_trig) != CP::CorrectionCode::Ok ) { 
      ATH_MSG_ERROR ("trigGlobEffCorrTool::Trigger matching could not be checked, interrupting execution.");
    }
  } else if ((elec_trig.size()+muon_trig.size())>2 && trigExpr=="multiLepton") {
    if ( m_trigGlobalEffCorrTool_multiLep->checkTriggerMatching( matched, elec_trig, muon_trig) != CP::CorrectionCode::Ok ) { 
      ATH_MSG_ERROR ("trigGlobEffCorrTool::Trigger matching could not be checked, interrupting execution.");
    }
  }
 
  CP::CorrectionCode result;
  if ((elec_trig.size()+muon_trig.size())>1 && trigExpr=="diLepton" && matched) {
    result = m_trigGlobalEffCorrTool_diLep->getEfficiencyScaleFactor( elec_trig, muon_trig, trig_sf);
  }
  else if ((elec_trig.size()+muon_trig.size())>2 && trigExpr=="multiLepton" && matched) {
    result = m_trigGlobalEffCorrTool_multiLep->getEfficiencyScaleFactor( elec_trig, muon_trig, trig_sf);
  }
 
  switch (result) {
  case CP::CorrectionCode::Error:
    ATH_MSG_ERROR( "Failed to retrieve multi-lepton trigger SF");
    return 1.;
  case CP::CorrectionCode::OutOfValidityRange:
    ATH_MSG_VERBOSE( "OutOfValidityRange found for multi-lepton trigger SF");
    return 1.;
  default:
    break;
  }
 
  return trig_sf;
}

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

                                                                                                                  {
 
  double trig_sf(1.);
 
  if (trigExpr!="diPhoton") {
    ATH_MSG_ERROR( "Failed to retrieve diphoton trigger SF");
    return trig_sf;
  }
 
  std::vector<const xAOD::Photon*> ph_trig;
  for (const xAOD::Photon* photon : photons) {
    if (!acc_passOR(*photon)) continue;
    if (!acc_signal(*photon)) continue;
    ph_trig.push_back(photon);
  }
 
  CP::CorrectionCode result;
  if (ph_trig.size()>1) {
    result = m_trigGlobalEffCorrTool_diPhoton->getEfficiencyScaleFactor(ph_trig, trig_sf);
  }
 
  switch (result) {
  case CP::CorrectionCode::Error:
    ATH_MSG_ERROR( "Failed to retrieve diphoton trigger SF");
    return 1.;
  case CP::CorrectionCode::OutOfValidityRange:
    ATH_MSG_VERBOSE( "OutOfValidityRange found for diphoton trigger SF");
    return 1.;
  default:
    break;
  }
 
  return trig_sf;
}

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

                                                                                                                                                                                            {
  
  double sf(1.);
 
  //Set the new systematic variation
  if (trigExpr == "diLepton") {
    StatusCode ret = m_trigGlobalEffCorrTool_diLep->applySystematicVariation(systConfig);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (dilepton trigger) for systematic var. " << systConfig.name() );
    }
  }
 
  if (trigExpr == "multiLepton") {
    StatusCode ret = m_trigGlobalEffCorrTool_multiLep->applySystematicVariation(systConfig);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (multi-lepton trigger) for systematic var. " << systConfig.name() );
    }
  }
 
  //Get the SF for new config
  sf = GetTriggerGlobalEfficiencySF (electrons, muons, trigExpr);
 
  //Roll back to default
  if (trigExpr == "diLepton") {
    StatusCode ret = m_trigGlobalEffCorrTool_diLep->applySystematicVariation(m_currentSyst);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (dilepton trigger) back to default.");
    }
  }
  if (trigExpr == "multiLepton") {
    StatusCode ret = m_trigGlobalEffCorrTool_multiLep->applySystematicVariation(m_currentSyst);
    if (ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (multi-lepton trigger) back to default.");
    }
  }
 
  return sf;
}

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

                                                                                                                                                        {
  
  double sf(1.);
 
  //Set the new systematic variation
  StatusCode ret = m_trigGlobalEffCorrTool_diPhoton->applySystematicVariation(systConfig);
  if (ret != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (diphoton trigger) for systematic var. " << systConfig.name() );
  }
 
  //Get the SF for new config
  sf = GetTriggerGlobalEfficiencySF (photons, trigExpr);
 
  //Roll back to default
  ret = m_trigGlobalEffCorrTool_diPhoton->applySystematicVariation(m_currentSyst);
  if (ret != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("Cannot configure TrigGlobalEfficiencyCorrectionTool (diphoton trigger) back to default.");
  }
 
  return sf;
}

GetTriggerOR()

std::vector< std::string > ST::SUSYObjDef_xAOD::GetTriggerOR

(

const std::string &

trigExpr

)

const

Definition at line 320 of file Trigger.cxx.

                                                                                    {
 
    static const std::string delOR = "_OR_";
    std::vector<std::string> trigchains = {};
    std::string newtrigExpr = TString(trigExpr).Copy().ReplaceAll("||",delOR).Data();
    newtrigExpr = TString(trigExpr).Copy().ReplaceAll(" ","").Data();
 
    size_t pos = 0;
    while ((pos = newtrigExpr.find(delOR)) != std::string::npos) {
      trigchains.push_back( "HLT_"+newtrigExpr.substr(0, pos) );
      newtrigExpr.erase(0, pos + delOR.length());
    }
    if(pos==std::string::npos)
      trigchains.push_back("HLT_"+newtrigExpr);
    
    return trigchains;
  }

GetTriggerTokens()

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

Definition at line 338 of file Trigger.cxx.

                                                                                                                                                                                                                                                                    {
 
    // 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
 
    static const std::string del15 = "_2015_";
    static const std::string del16 = "_2016_";
    static const std::string del17 = "_2017_";
    static const std::string del18 = "_2018_";
    static const std::string del22 = "_2022_";
 
    size_t pos = 0;
    std::string token15, token16, token17, token18, token22;
 
    //get trigger tokens for 2015, 2016, 2017, 2018 and 2022 
    if ( (pos = trigExpr.find(del15)) != std::string::npos) {
      trigExpr.erase(0, pos + del15.length()); 
 
      pos = 0;
      while ((pos = trigExpr.find(del16)) != std::string::npos) {
        token15 = trigExpr.substr(0, pos);
        token16 = trigExpr.erase(0, pos + del16.length() + del17.length() - 1);
        // 2016-2018 use exact the same trigger string
        token17 = token16; 
        token18 = token16;
      }
    }
 
    if ( (pos = trigExpr.find(del22)) != std::string::npos) {
      trigExpr.erase(0, pos + del22.length()); 
    }
 
    //redefine in case of custom user input
    if(!m_isRun3){
      if(token15.empty()) token15 = trigExpr;
      if(token16.empty()) token16 = trigExpr;
      if(token17.empty()) token17 = trigExpr;
      if(token18.empty()) token18 = trigExpr;
    }
    else{
      if(token22.empty()) token22 = trigExpr;
    }
 
  //get trigger chains for matching in 2015 and 2018
    if(!m_isRun3){
      v_trigs15_cache = GetTriggerOR(token15);
      v_trigs16_cache = GetTriggerOR(token16);
      v_trigs17_cache = GetTriggerOR(token17);
      v_trigs18_cache = GetTriggerOR(token18);
    }
    //get trigger chains for matching in 2022
    else{
      v_trigs22_cache = GetTriggerOR(token22);
    }
  }

GetTrigPrescale()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 310 of file Trigger.cxx.

                                                                      {
  return m_trigDecTool->getPrescale(tr_item);
}

handle()

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

protectedvirtualinherited

Function receiving incidents from IncidentSvc/TEvent.

Reimplemented in Trig::TrigDecisionTool.

Definition at line 135 of file AsgMetadataTool.cxx.

                                                     {
 
      // Tell the user what's happening:
      ATH_MSG_VERBOSE( "Callback received with incident: " << inc.type() );
 
      // Call the appropriate member function:
      if( inc.type() == IncidentType::BeginInputFile ) {
        m_beginInputFileCalled = true;
        if( beginInputFile().isFailure() ) {
          ATH_MSG_FATAL( "Failed to call beginInputFile()" );
          throw std::runtime_error( "Couldn't call beginInputFile()" );
         }
      } else if( inc.type() == IncidentType::EndInputFile ) {
        if( endInputFile().isFailure() ) {
          ATH_MSG_FATAL( "Failed to call endInputFile()" );
          throw std::runtime_error( "Couldn't call endInputFile()" );
         }
      } else if( inc.type() == IncidentType::BeginEvent ) {
         // If the tool didn't catch the begin input file incident for the
         // first input file of the job, then call the appropriate function
         // now.
         if( ! m_beginInputFileCalled ) {
            m_beginInputFileCalled = true;
            if( beginInputFile().isFailure() ) {
               ATH_MSG_FATAL( "Failed to call beginInputFile()" );
               throw std::runtime_error( "Couldn't call beginInputFile()" );
            }
         }
         if( beginEvent().isFailure() ) {
            ATH_MSG_FATAL( "Failed to call beginEvent()" );
            throw std::runtime_error( "Couldn't call beginEvent()" );
         }
 
     #ifdef XAOD_STANDALONE
      } else if( inc.type() == IncidentType::MetaDataStop ) {
         if( metaDataStop().isFailure() ) {
            ATH_MSG_FATAL( "Failed to call metaDataStop()" );
            throw std::runtime_error( "Couldn't call metaDataStop()" );
         }
         
     #endif // XAOD_STANDALONE
      } else {
         ATH_MSG_WARNING( "Unknown incident type received in AsgMetaDataTool: " << inc.type() );
      }
 
      return;
   }

initialize()

StatusCode ST::SUSYObjDef_xAOD::initialize ( )

finaloverridevirtual

Dummy implementation of the initialisation function.

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

Reimplemented from asg::AsgTool.

Definition at line 883 of file SUSYObjDef_xAOD.cxx.

                                       {
 
  if (m_tool_init) {
    ATH_MSG_ERROR("Initialising for a second time -- something is wrong!");
    return StatusCode::FAILURE;
  }
 
  // Greet the user:
  ATH_MSG_INFO( "Initialising... " );
 
  bool autoconf(false);
#ifndef XAOD_STANDALONE // For now metadata is Athena-only
  if ( m_dataSource < 0 ) {
    autoconf = true;
    ATH_MSG_INFO("Autoconfiguring: dataSource, mcCampaign, isPHYSLITE");
    std::string projectName = "";
    ATH_CHECK( AthAnalysisHelper::retrieveMetadata("/TagInfo", "project_name", projectName, inputMetaStore() ) );
    if ( projectName == "IS_SIMULATION" ) {
        std::string simFlavour = "";
        ATH_CHECK( AthAnalysisHelper::retrieveMetadata("/Simulation/Parameters", "SimulationFlavour", simFlavour, inputMetaStore() ) );
        TString s(simFlavour); s.ToUpper();
        m_dataSource = s.Contains("ATLFAST") ? AtlfastII : FullSim;
    } else if (projectName.compare(0, 4, "data") == 0 ) {
        m_dataSource = Data;
    } else {
      ATH_MSG_ERROR("Failed to autoconfigure -- project_name matches neither IS_SIMULATION nor data!");
      return StatusCode::FAILURE;
    }
 
  }
#endif
 
  m_configFile = (PathResolverFindCalibFile(m_configFile)).c_str();
 
  //Read configuration from file (stored as Property)
  ATH_CHECK( readConfig() );
 
  if (m_dataSource < 0) {
    ATH_MSG_FATAL( "Data source incorrectly configured!!" );
    ATH_MSG_FATAL("You must set the DataSource property to Data, FullSim or AtlfastII !!");
    if (autoconf) ATH_MSG_FATAL("Autoconfiguration seems to have failed!");
    // if(m_useLeptonTrigger<0) ATH_MSG_ERROR( "UseLeptonTrigger not set");
    ATH_MSG_FATAL( "Exiting... " );
    return StatusCode::FAILURE;
  }
  ATH_MSG_DEBUG( "Configured: IsData: " << isData() );
  ATH_MSG_DEBUG( "Configured: IsAtlfast: " << isAtlfast() );
 
  switch (m_jetInputType) {
  case xAOD::JetInput::LCTopo:
  case xAOD::JetInput::EMTopo:
  case xAOD::JetInput::EMPFlow:
    break;
  default:
    ATH_MSG_ERROR( "Invalid jet input type " << xAOD::JetInput::typeName(xAOD::JetInput::Type(m_jetInputType)) );
    return StatusCode::FAILURE;
  }
 
  if (m_inputMETSuffix.empty()){
    m_inputMETSuffix = "AntiKt4" + xAOD::JetInput::typeName(xAOD::JetInput::Type(m_jetInputType));
  }
  m_defaultJets = "AntiKt4" + xAOD::JetInput::typeName(xAOD::JetInput::Type(m_jetInputType)) + "Jets";
  ATH_MSG_INFO( "Configured for jet collection: " << m_defaultJets );
 
  m_defaultTruthJets = "AntiKt4TruthJets";
  const xAOD::FileMetaData* fmd = nullptr;
  std::string dataType;
  if ( inputMetaStore()->contains<xAOD::FileMetaData>("FileMetaData") && inputMetaStore()->retrieve(fmd,"FileMetaData").isSuccess() )
     fmd->value(xAOD::FileMetaData::dataType, dataType);
  if ( dataType.compare("StreamDAOD_PHYS")==0 || dataType.compare("StreamDAOD_PHYSLITE")==0 ) m_defaultTruthJets = "AntiKt4TruthDressedWZJets";
  if ( dataType.compare("StreamDAOD_PHYSLITE")==0) m_isPHYSLITE = true;
 
  ATH_MSG_INFO( "Configured for truth jet collection: " << m_defaultTruthJets );
 
  m_inputMETCore = m_isPHYSLITE? "MET_Core_AnalysisMET":"MET_Core_" + m_inputMETSuffix;
  m_inputMETMap  = m_isPHYSLITE? "METAssoc_AnalysisMET":"METAssoc_" + m_inputMETSuffix;
 
  ATH_MSG_DEBUG ( "Build MET Core:     " << m_inputMETCore);
  ATH_MSG_DEBUG ( "Build MET with map: " << m_inputMETMap);
 
  m_jetCleanDFName = TString::Format("DFCommonJets_jetClean_%s", m_badJetCut.c_str());
  m_acc_jetClean = m_jetCleanDFName;
 
  // the decorations are named like DFCommonElectronsLHTight, DFCommonElectronsDNNTight or DFCommonElectronsDNNTightNoCF
  m_eleIdBaselineDFName = m_eleIdBaseline.find("DNN") == std::string::npos ? "DFCommonElectronsLH" : "DFCommonElectronsDNN";
  m_eleIdBaselineDFName += TString(m_eleIdBaseline).ReplaceAll("LooseAndBLayer","LooseBL").ReplaceAll("LLH","").ReplaceAll("DNNnoCF","").ReplaceAll("DNN","").Data();
  if (m_eleIdBaseline.find("noCF") != std::string::npos)
    m_eleIdBaselineDFName += "NoCF";
  m_acc_eleIdBaseline = m_eleIdBaselineDFName;
 
  m_eleIdDFName = m_eleId.find("DNN") == std::string::npos ? "DFCommonElectronsLH" : "DFCommonElectronsDNN";
  m_eleIdDFName += TString(m_eleId).ReplaceAll("LooseAndBLayer","LooseBL").ReplaceAll("LLH","").ReplaceAll("DNNnoCF","").ReplaceAll("DNN","").Data();
  if (m_eleId.find("noCF") != std::string::npos)
    m_eleIdDFName += "NoCF";
  m_acc_eleId = m_eleIdDFName;
 
  m_photonIdBaselineDFName = "DFCommonPhotonsIsEM";
  m_photonIdBaselineDFName += TString(m_photonIdBaseline).Data();
  m_acc_photonIdBaseline = m_photonIdBaselineDFName;
 
  m_photonIdDFName = "DFCommonPhotonsIsEM";
  m_photonIdDFName += TString(m_photonId).Data();
  m_acc_photonId = m_photonIdDFName;
 
  // autoconfigure PRW tool if m_autoconfigPRW==true
  if (m_autoconfigPRWPath == "dev/PileupReweighting/share/")
    ATH_CHECK( autoconfigurePileupRWTool(m_autoconfigPRWPath, m_autoconfigPRWFile, true, m_autoconfigPRWRPVmode, m_autoconfigPRWCombinedmode) );
  else
    // need to set a full path if you don't use the one in CVMFS
    ATH_CHECK( autoconfigurePileupRWTool(m_autoconfigPRWPath, m_autoconfigPRWFile, false, m_autoconfigPRWRPVmode, m_autoconfigPRWCombinedmode) );
 
  // Read Handles
  ATH_CHECK( m_LRTCollectionName.initialize() );
  ATH_CHECK( m_GSFLRTCollectionName.initialize() );
 
  // Write Handles
  ATH_CHECK( m_outElectronLocation.initialize() );
  ATH_CHECK( m_outMuonLocation.initialize() );
 
  ATH_CHECK( this->SUSYToolsInit() );
 
  ATH_MSG_VERBOSE("Done with tool retrieval");
 
  m_tool_init = true;
 
  // Return gracefully:
  return StatusCode::SUCCESS;
}

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.

                                                                       {
 
#ifdef XAOD_STANDALONE
      return &m_inputMetaStore;
#else // XAOD_STANDALONE
      return m_inputMetaStore;
#endif // XAOD_STANDALONE
   }

isAtlfast()

bool ST::SUSYObjDef_xAOD::isAtlfast ( ) const

inlinefinaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 158 of file SUSYObjDef_xAOD.h.

{return m_dataSource == AtlfastII;}

IsBadJet()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 746 of file Jets.cxx.

                                                           {
 
    if ( !acc_passOR(input) ) return false;
 
    float ptcut = 20e3;
    if ( m_jetPt < ptcut ) ptcut = m_jetPt;
 
    bool  isPileup = !acc_passJvt(input);
 
    if ( input.pt() <= ptcut || isPileup ) return false;
 
    if (m_acc_jetClean.isAvailable(input)) {
      dec_bad(input) = !m_acc_jetClean(input);
    } else {
      ATH_MSG_VERBOSE("DFCommon jet cleaning variable not available ... setting 'bad' decorator to 0.");
      dec_bad(input) = 0;
      // the jet cleaning decisions are only calculable at AOD now
      // dec_bad(input) = m_jetCleaningTool.empty() ? false : !m_jetCleaningTool->keep(input);
    }
 
    ATH_MSG_VERBOSE( "JET isbad?: " << static_cast<int>(acc_bad(input)));
 
    return acc_bad(input);
  }

IsBadMuon()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 404 of file Muons.cxx.

{
  const static SG::Decorator<char> dec_bad("bad");
  dec_bad(input) = false;
 
  const static SG::Decorator<char> dec_bad_highPt("bad_highPt");
  dec_bad_highPt(input) = false;
 
  const xAOD::TrackParticle* track;
  if (input.muonType() == xAOD::Muon::SiliconAssociatedForwardMuon) {
    track = input.trackParticle(xAOD::Muon::CombinedTrackParticle);
    if (!track) return false; // don't treat SAF muons without CB track further
  }
  else{
    track = input.primaryTrackParticle();
    if (!track){
      ATH_MSG_WARNING("Non-SAF muon without a track; cannot test IsBadMuon criteria");
      return false;
    }
  }
 
  float Rerr = Amg::error(track->definingParametersCovMatrix(), 4) / std::abs(track->qOverP());
  ATH_MSG_VERBOSE( "Track momentum error (%): " << Rerr * 100 );
  bool isbad = Rerr > qopcut;
  bool isbadHighPt = Rerr > qopcut;
 
  //new recommendation from MCP
  isbad |= m_muonSelectionTool->isBadMuon(input);
 
  //new recommendation from MCP (at HighPT)
  isbadHighPt |= m_muonSelectionHighPtTool->isBadMuon(input);
 
  dec_bad(input) = isbad;
  dec_bad_highPt(input) = isbadHighPt;
 
  ATH_MSG_VERBOSE( "MUON isbad?: " << isbad );
  return isbad;
}

IsBJet()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 772 of file Jets.cxx.

                                                         {
 
    bool isbjet = bool(m_btagSelTool->accept(input));
    dec_bjet(input) = isbjet;
 
    if (SetBtagWeightDecorations(input, m_btagSelTool, m_BtagTagger).isFailure())
       ANA_MSG_ERROR("Couldn't set b-tag decorations for jet, is-b = " << (isbjet?"true":"false") << ", pT = " << input.pt()/1000.);
 
    return isbjet;
  }

IsBJetContinuous()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 794 of file Jets.cxx.

                                                                  {
    // Cheatsheet:
    // returns 6 if between 65% and 0%
    // returns 5 if between 70% and 65%
    // returns 4 if between 77% and 70%
    // returns 3 if between 85% and 77%
    // returns 2 if between 90% and 85%
    // returns 1 if between 100% and 90%
    // returns 0 if smaller than -1e4-> should never happen
    // return -1 if bigger than 1e4 or not in b-tagging acceptance
 
    int isbjet = m_btagSelTool->getQuantile(input);
    dec_bjet(input) = isbjet;
 
    if(SetBtagWeightDecorations(input, m_btagSelTool, m_BtagTagger).isFailure())
       ANA_MSG_ERROR("Couldn't set continuous b-tag decorations for jet, is-b = " << isbjet << ", pT = " << input.pt()/1000.);
 
    return isbjet;
  }

IsBJetLoose()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 681 of file Jets.cxx.

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

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

{
  dec_cosmic(input) = false;
 
  const xAOD::TrackParticle* track(nullptr);
  if (input.muonType() == xAOD::Muon::SiliconAssociatedForwardMuon) {
    track = input.trackParticle(xAOD::Muon::CombinedTrackParticle);
    if (!track){
      ATH_MSG_VERBOSE("WARNING: SAF muon without CB track found. Not possible to check cosmic muon criteria");
      return false; // don't treat SAF muons without CB track further  
    }
  }
  else {
    track = input.primaryTrackParticle();
    if (!track){
      ATH_MSG_WARNING("Non-SAF muon without primary track particle found. Not possible to check cosmic muon criteria");
      return false;
    }
  }
 
  double mu_d0 = track->d0();
  const xAOD::Vertex* pv = this->GetPrimVtx();
  double primvertex_z = pv ? pv->z() : 0;
  double mu_z0_exPV = track->z0() + track->vz() - primvertex_z;
  
  bool isCosmicMuon = (std::abs(mu_z0_exPV) >= z0cut || std::abs(mu_d0) >= d0cut);
 
  if (isCosmicMuon) {
    ATH_MSG_VERBOSE("COSMIC PV Z = " << primvertex_z << ", track z0 = " << mu_z0_exPV << ", track d0 = " << mu_d0);
  }
 
  dec_cosmic(input) = isCosmicMuon;
  return isCosmicMuon;
}

isData()

bool ST::SUSYObjDef_xAOD::isData ( ) const

inlinefinaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 157 of file SUSYObjDef_xAOD.h.

{return m_dataSource == Data;}

IsHighPtMuon()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 385 of file Muons.cxx.

{
  if (input.pt() < 3e3){
    ATH_MSG_DEBUG("No HighPt check supported for muons below 3GeV! False.");
    dec_passedHighPtCuts(input) = false;
    return false;
  }
 
  bool isHighPt=false;
  isHighPt = bool(m_muonSelectionHighPtTool->accept(input));
  dec_passedHighPtCuts(input) = isHighPt;
 
  return isHighPt;
}

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

                                                                                                                {
  // NB - this now applies to the entire function...
 
  // First check if we're affected by the L1_XE50 bug
  bool L1_pass = m_trigDecTool->isPassed(L1_name);
  bool HLT_noalg_L1J400 = m_trigDecTool->isPassed("HLT_noalg_L1J400");
  if (!L1_pass && j400_OR && HLT_noalg_L1J400) {
    return emulateHLT(triggerName);
  }
  else if (L1_pass) {
    // See if the TDT knows about this
    {
      std::scoped_lock lock (m_triggerCacheMutex);
      if (isTrigInTDT(lock, triggerName) ) return m_trigDecTool->isPassed(triggerName);
    }
    return emulateHLT(triggerName);
  }
  return false;
}

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.

                                                                                {
 
  // Returns MET trigger decision for recommended lowest unprescaled evolution described in 
  // https://twiki.cern.ch/twiki/bin/viewauth/Atlas/LowestUnprescaled
  // For period vs run number, see https://atlas-tagservices.cern.ch/tagservices/RunBrowser/runBrowserReport/rBR_Period_Report.php
 
  // if no runNumber specified, just read it from the current event
  unsigned int rn;
  if(runnumber>0){
    rn = runnumber;
  }
  else{
    rn = GetRunNumber(); // it takes care of dealing with data and MC
  }
  
  int year = treatAsYear(rn);
 
  if (year == 2015)                                      return IsMETTrigPassed("HLT_xe70_mht",j400_OR); //2015
  else if(year == 2016 && rn >= 296939 && rn <= 302872 ) return IsMETTrigPassed("HLT_xe90_mht_L1XE50",j400_OR); //2016 A-D3
  else if(year == 2016 && rn >= 302919 && rn <= 303892 ) return IsMETTrigPassed("HLT_xe100_mht_L1XE50",j400_OR); //2016 D4-F1
  else if(year == 2016 && rn >= 303943)                  return IsMETTrigPassed("HLT_xe110_mht_L1XE50",j400_OR); //2016 F2-(open) 
  else if(year == 2017 && rn >= 325713 && rn <= 331975 ) return IsMETTrigPassed("HLT_xe110_pufit_L1XE55", false,"L1_XE55"); // 2017 B1-D5
  else if(year == 2017 && rn >= 332303 )                 return IsMETTrigPassed("HLT_xe110_pufit_L1XE50", false); // 2017 D6-(open)
  else if(year == 2018 && rn >= 348885 && rn <= 350013 ) return IsMETTrigPassed("HLT_xe110_pufit_xe70_L1XE50", false); // 2018 B-C5
  else if(year == 2018 && rn >= 350067 )                 return IsMETTrigPassed("HLT_xe110_pufit_xe65_L1XE50", false); // 2018 C5-(open)
  else if(year == 2022)                                  return IsMETTrigPassed("HLT_xe65_cell_xe90_pfopufit_L1XE50",false); // 2022
  else if(year == 2023)                                  return IsMETTrigPassed("HLT_xe65_cell_xe90_pfopufit_L1XE50",false); // 2023
  else if(year == 2024)                                  return IsMETTrigPassed("HLT_xe65_cell_xe105_nn_L1jXE100",false,"L1_jXE100"); // 2024
 
  return false; 
}

isNominal()

bool ST::SUSYObjDef_xAOD::isNominal

(

const CP::SystematicSet &

syst

)

const

Definition at line 2105 of file SUSYObjDef_xAOD.cxx.

                                                                 {
  return syst.name().empty();
}

isPrompt()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 24 of file Truth.cxx.

                                                                {
 
  const int type  = acc_truthType(*part);
  int origin      = acc_truthOrigin(*part);
  int originbkg   = 0;
  if(acc_bkgTruthOrigin.isAvailable(*part)){ //only in SUSY2,3,5 for the moment!
    originbkg = acc_bkgTruthOrigin(*part);
  }
  else{
    ATH_MSG_DEBUG("::isPrompt() : No bkgTruthOrigin decoration available. Returning false by default.");
    return false;
  }
 
  //Electrons 
  if( part->type() == xAOD::Type::Electron ){ 
    switch(type){
    case MCTruthPartClassifier::BkgElectron:
      if(origin != MCTruthPartClassifier::PhotonConv) return false;
      if(originbkg == MCTruthPartClassifier::FSRPhot || originbkg == MCTruthPartClassifier::BremPhot) return true;
      origin = originbkg;
      /* FALLTHRU */
    case MCTruthPartClassifier::IsoElectron:
      return (origin == MCTruthPartClassifier::top
          || origin == MCTruthPartClassifier::WBoson
          || origin == MCTruthPartClassifier::ZBoson
          || origin == MCTruthPartClassifier::Higgs
          || origin == MCTruthPartClassifier::HiggsMSSM
          || origin == MCTruthPartClassifier::HeavyBoson
          || origin == MCTruthPartClassifier::WBosonLRSM
          || origin == MCTruthPartClassifier::NuREle
          || origin == MCTruthPartClassifier::NuRMu
          || origin == MCTruthPartClassifier::NuRTau
          || origin == MCTruthPartClassifier::LQ
          || origin == MCTruthPartClassifier::SUSY);
    default:
      return false;
    }
    // NB: will classify a few muon/quark brems as prompt electrons, but a small effect
  }
  if( part->type() == xAOD::Type::Muon ){ 
    return (type == MCTruthPartClassifier::IsoMuon);
  }
  else{
    ATH_MSG_DEBUG("::isPrompt() : Only Electrons supported at the moment!");
  }
 
  //Photons ... ?
  //Taus ... ?
  return false;
}

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

{
  if (!acc_baseline(input)) return false;
 
  dec_passSignalID(input) = false;
 
  if (m_eleIdExpert) {
    if ( !m_elecSelLikelihood.empty() && m_elecSelLikelihood->accept(&input) ) dec_passSignalID(input) = true;
    } 
  else {
    if (m_acc_eleId.isAvailable(input)) {
      dec_passSignalID(input) = m_acc_eleId(input); 
    } else {
      ATH_MSG_VERBOSE ("DFCommonElectronsLHxxx variables are not found. Calculating the ID from LH tool..");
      if ( !m_elecSelLikelihood.empty() && m_elecSelLikelihood->accept(&input) ) dec_passSignalID(input) = true;
    }
  }
 
  //overwrite ID selection if forced by user
  if(m_force_noElId) dec_passSignalID(input) = true;
 
  if (!acc_passSignalID(input)) return false;
 
  if (input.p4().Perp2() <= etcut * etcut || input.p4().Perp2() == 0) return false; // eT cut (might be necessary for leading electron to pass trigger)
  if ( etacut==DUMMYDEF ){
    if(std::abs(input.caloCluster()->etaBE(2)) > m_eleEta ) return false;
  }
  else if ( std::abs(input.caloCluster()->etaBE(2)) > etacut ) return false;
 
  if (m_eleCrackVeto){
    if  ( std::abs( input.caloCluster()->etaBE(2) ) >1.37 &&  std::abs( input.caloCluster()->etaBE(2) ) <1.52) {
      return false;
    }
  }
 
  if (acc_d0sig(input) != 0) {
    if (d0sigcut > 0.0 && std::abs(acc_d0sig(input)) > d0sigcut) return false; // transverse IP cut
  }
 
  if (z0cut > 0.0 && std::abs(acc_z0sinTheta(input)) > z0cut) return false; // longitudinal IP cut
 
 
  ATH_MSG_VERBOSE( "IsSignalElectron: " << m_eleId << " " << acc_passSignalID(input) << " d0sig " << acc_d0sig(input) << " z0 sin(theta) " << acc_z0sinTheta(input) );
 
  if (m_doElIsoSignal) {
    if ( !( (acc_isol(input) && input.pt()<m_eleIsoHighPtThresh) || (acc_isolHighPt(input) && input.pt()>m_eleIsoHighPtThresh)) ) return false;
    ATH_MSG_VERBOSE( "IsSignalElectron: passed isolation" );
  }
 
  if(m_eleChID_signal && !acc_passChID(input)) return false; //add charge flip check to signal definition
 
  dec_signal(input) = true;
 
  ATH_MSG_VERBOSE( "IsSignalElectron: passed selection" );
  return true;
}

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

                                                                                         {
    if ( !acc_baseline(input)  || !acc_passOR(input) ) return false;
 
    if ( input.pt() <= ptcut || std::abs(input.eta()) >= etacut) return false;
 
    bool isgoodjet = !acc_bad(input) && acc_passJvt(input);
 
    dec_signal(input) = isgoodjet;
 
    // For JVT calculation
    dec_signal_less_JVT(input) = !acc_bad(input);
 
 
    if (m_debug) {
      float emfrac, hecf, LArQuality, HECQuality, Timing,  fracSamplingMax, NegativeE, AverageLArQF;
      std::vector<float> sumpttrk_vec;
 
      input.getAttribute(xAOD::JetAttribute::EMFrac, emfrac);
      input.getAttribute(xAOD::JetAttribute::HECFrac, hecf);
      input.getAttribute(xAOD::JetAttribute::LArQuality, LArQuality);
      input.getAttribute(xAOD::JetAttribute::HECQuality, HECQuality);
      input.getAttribute(xAOD::JetAttribute::Timing, Timing);
      input.getAttribute(xAOD::JetAttribute::SumPtTrkPt500, sumpttrk_vec);
      input.getAttribute(xAOD::JetAttribute::FracSamplingMax, fracSamplingMax);
      input.getAttribute(xAOD::JetAttribute::NegativeE, NegativeE);
      input.getAttribute(xAOD::JetAttribute::AverageLArQF, AverageLArQF);
 
      float sumpttrk;
      if (!sumpttrk_vec.empty() && this->GetPrimVtx()) {
        sumpttrk = sumpttrk_vec[this->GetPrimVtx()->index()];
      } else {
        sumpttrk = 0.;
      }
 
      ATH_MSG_INFO( "JET pt: " << input.pt() );
      ATH_MSG_INFO( "JET eta: " << input.eta() );
      ATH_MSG_INFO( "JET emfrac: " << emfrac );
      ATH_MSG_INFO( "JET hecfrac: " << hecf );
      ATH_MSG_INFO( "JET LArQuality: " << LArQuality );
      ATH_MSG_INFO( "JET HECQuality: " << HECQuality );
      ATH_MSG_INFO( "JET Timing: " << Timing );
      ATH_MSG_INFO( "JET sumpttrk: " << sumpttrk );
      ATH_MSG_INFO( "JET fracSamplingMax: " << fracSamplingMax );
      ATH_MSG_INFO( "JET AverageLArQF: " << AverageLArQF );
    }
 
    ATH_MSG_VERBOSE( "JET isbad?: " << static_cast<int>(acc_bad(input)));
 
    return isgoodjet;
  }

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

{
  if (!acc_baseline(input)) return false;
  if (!acc_passSignalID(input)) return false;
 
  if (input.pt() <= ptcut || input.pt() == 0) return false; // pT cut (might be necessary for leading muon to pass trigger)
  if ( etacut==DUMMYDEF ){
    if(std::abs(input.eta()) > m_muEta ) return false;
  }
  else if ( std::abs(input.eta()) > etacut ) return false;
 
  if (z0cut > 0.0 && std::abs(acc_z0sinTheta(input)) > z0cut) return false; // longitudinal IP cut
  if (acc_d0sig(input) != 0) {
    if (d0sigcut > 0.0 && std::abs(acc_d0sig(input)) > d0sigcut) return false; // transverse IP cut
  }
 
  if (m_doMuIsoSignal) {
    if ( !( (acc_isol(input) && input.pt()<m_muIsoHighPtThresh) || (acc_isolHighPt(input) && input.pt()>m_muIsoHighPtThresh)) ) return false;
    ATH_MSG_VERBOSE( "IsSignalMuon: passed isolation");
  } 
 
  //set HighPtMuon decoration
  IsHighPtMuon(input);
 
  dec_signal(input) = true;
 
  if (m_muId == 4) { //i.e. HighPt muons
    ATH_MSG_VERBOSE( "IsSignalMuon: mu pt "   << input.pt()
                     << " signal? "           << static_cast<int>(acc_signal(input))
                     << " isolation? "        << static_cast<int>(acc_isol(input))
                     << " passedHighPtCuts? " << static_cast<int>(acc_passedHighPtCuts(input)));
  } else {
    ATH_MSG_VERBOSE( "IsSignalMuon: mu pt "   << input.pt()
                     << " signal? "           << static_cast<int>( acc_signal(input))
                     << " isolation? "        << static_cast<int>( acc_isol(input)));
    // Don't show HighPtFlag ... we didn't set it!
  }
 
  return acc_signal(input);
}

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

{
  dec_signal(input) = false;
 
  if ( !acc_baseline(input) ) return false;
 
  if ( !m_egammaAmbiguityTool->accept(input) ) return false;
 
  if ( input.pt() < ptcut ) return false;
  if ( etacut==DUMMYDEF ){
    if(std::abs(input.caloCluster()->etaBE(2)) > m_photonEta ) return false;
  }
  else if ( std::abs(input.caloCluster()->etaBE(2)) > etacut ) return false;
 
  if (m_photonCrackVeto){
    if  ( std::abs( input.caloCluster()->etaBE(2) ) >1.37 &&  std::abs( input.caloCluster()->etaBE(2) ) <1.52) {
      return false; 
    }
  }
 
  if (acc_isol(input) || !m_doPhIsoSignal) {
    ATH_MSG_VERBOSE( "IsSignalPhoton: passed isolation");
  } else return false;
 
  bool passID = false;
  if (m_acc_photonId.isAvailable(input)) {
    passID = m_acc_photonId(input);
  } else {
    ATH_MSG_VERBOSE ("DFCommonPhotonsIsEMxxx variables are not found. Calculating the ID from Photon ID tool..");
    passID = bool(m_photonSelIsEM->accept(&input));
  }
  if ( !passID ) return false;
  
  dec_signal(input) = true;
 
  return true;
}

IsSignalTau()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 111 of file Taus.cxx.

                                                                                          {
 
  dec_signal(input) = false;
 
  if ( !acc_baseline(input) ) return false;
 
  if (input.pt() <= ptcut) return false;
 
  if (std::abs(input.eta()) >= etacut) return false;
 
  if (!m_tauSelTool->accept( input )) return false;
 
  dec_signal(input) = true; 
 
  return true;
}

IsTrackBJet()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 783 of file Jets.cxx.

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

IsTrackBJetContinuous()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 816 of file Jets.cxx.

                                                                       {
 
    int isbjet = m_btagSelTool_trkJet->getQuantile(input);
    dec_bjet(input) = isbjet;
 
    if(SetBtagWeightDecorations(input, m_btagSelTool_trkJet, m_BtagTagger_trkJet).isFailure())
       ANA_MSG_ERROR("Couldn't set continuous b-tag decorations for trackjet, is-b = " << isbjet << ", pT = " << input.pt()/1000.);
 
    return isbjet;
  }

isTrigInTDT()

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

private

Definition at line 83 of file Trigger.cxx.

{
  auto mapItr = m_checkedTriggers.find(triggerName);
  if ( mapItr == m_checkedTriggers.end() ) {
    const auto *cg = m_trigDecTool->getChainGroup(triggerName);
    return m_checkedTriggers[triggerName] = cg->getListOfTriggers().size() != 0;
  }
  else {
    return mapItr->second;
  }
}

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

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

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

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

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

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

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

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

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

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

IsTruthBJet()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 301 of file Truth.cxx.

                                                            {
  //Method to set correctly the IsBjet decoration needed by the JetUncertainties tool
  bool isBjet = false;
  if (acc_signal(input)) {
 
    int truthlabel(-1);
    if (!input.getAttribute("HadronConeExclTruthLabelID", truthlabel)) {
      ATH_MSG_ERROR("Failed to get jet truth label!");
    }
 
    isBjet = std::abs(truthlabel) == 5;
  }
 
  const static SG::Decorator<char> dec_bjet_jetunc("bjet_jetunc"); //added for JetUncertainties usage
  dec_bjet_jetunc(input) = isBjet;
 
  return isBjet;
}

isVariation()

bool ST::SUSYObjDef_xAOD::isVariation

(

const CP::SystematicSet &

syst

)

const

Definition at line 2120 of file SUSYObjDef_xAOD.cxx.

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

isWeight()

bool ST::SUSYObjDef_xAOD::isWeight

(

const CP::SystematicSet &

systSet

)

const

Definition at line 2109 of file SUSYObjDef_xAOD.cxx.

                                                                   {
  // returns true if all systematics do _not_ affect kinematics and _any_ of them affects the weight
  bool affectsWeights = false;
  for (const auto& sys : systSet) {
    auto info = getSystInfo(sys);
    if(info.affectsKinematics) { return false; }
    affectsWeights = affectsWeights or info.affectsWeights;
  }
  return affectsWeights;
}

JetPassJVT()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 688 of file Jets.cxx.

                                                 {
    char pass_jvt = !m_applyJVTCut || m_jetNNJvtSelectionTool->accept(&input);
    dec_passJvt(input) = pass_jvt;
    return pass_jvt;
  }

JVT_SF()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 989 of file Jets.cxx.

                                                             {
 
    float totalSF = 1.;
    if (!m_applyJVTCut) return totalSF;
 
    ConstDataVector<xAOD::JetContainer> jvtjets(SG::VIEW_ELEMENTS);
    for (const xAOD::Jet* jet : *jets) {
      // Only jets that were good for every cut except JVT
      if (acc_signal_less_JVT(*jet) && acc_passOR(*jet)) {
        jvtjets.push_back(jet);
      }
    }
 
    for (const xAOD::Jet* jet : jvtjets) {
      float current_sf = 0;
 
      // the SF are only applied for HS jets and implicitely requires the presence of the isHS decoration
      CP::CorrectionCode result;
      if (acc_passJvt(*jet)) {
        result = m_jetNNJvtEfficiencyTool->getEfficiencyScaleFactor(*jet,current_sf);
      }
      else {
        result = m_jetNNJvtEfficiencyTool->getInefficiencyScaleFactor(*jet,current_sf);
      }
 
      switch (result) {
        case CP::CorrectionCode::Error:
          // this is probably not right, should report an error here
          ATH_MSG_ERROR("Inexplicably failed JVT calibration" );
          break;
        case CP::CorrectionCode::OutOfValidityRange:
          // no NNJvt SF for jet, that is ok e.g. for jets with |eta| > 2.5
          ATH_MSG_VERBOSE( "Skip SF application in SUSYTools_xAOD::JVT_SF as jet outside validate range" );
          break;
        default:
          ATH_MSG_VERBOSE( "Retrieve SF for jet in SUSYTools_xAOD::JVT_SF with value " << current_sf );
          totalSF *= current_sf;
      }
 
    }
 
    ATH_MSG_VERBOSE( "Retrieve total SF for jet container in SUSYTools_xAOD::JVT_SF with value " << totalSF );
 
    return totalSF;
  }

JVT_SFsys()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 1036 of file Jets.cxx.

                                                                                                   {
 
    float totalSF = 1.;
    if (!m_applyJVTCut) return totalSF;
 
    //Set the new systematic variation
    StatusCode ret = m_jetNNJvtEfficiencyTool->applySystematicVariation(systConfig);
    if ( ret != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Cannot configure NNjvtEfficiencyTool for systematic var. " << systConfig.name() );
    }
 
    // Delegate
    totalSF = SUSYObjDef_xAOD::JVT_SF( jets );
 
    // }
    if (m_applyJVTCut) {
      ret = m_jetNNJvtEfficiencyTool->applySystematicVariation(m_currentSyst);
      if ( ret != StatusCode::SUCCESS) {
        ATH_MSG_ERROR("Cannot configure NNjvtEfficiencyTool for systematic var. " << systConfig.name() );
      }
    }
 
    return totalSF;
  }

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.

                                                                                                                                                                                {
 
    if (electrons.empty()) return StatusCode::SUCCESS;
    for (const xAOD::Electron* electron: electrons) {
        if (ElectronsToRemove.find(electron) != ElectronsToRemove.end()){
            ATH_MSG_DEBUG( "Removing electron from output collection (isLRT?) : ("<< static_cast<int>(acc_isLRT(*electron)) << ")" );
            ATH_MSG_DEBUG( "ELECTRON cl eta: "                                    << electron->caloCluster()->eta());
            ATH_MSG_DEBUG( "ELECTRON cl phi: "                                    << electron->caloCluster()->phi());
            continue;
        // add electron into output 
        } else {
            ATH_MSG_DEBUG( "Adding electron to output collection (isLRT?) : ("    << static_cast<int>(acc_isLRT(*electron)) << ")" );
            ATH_MSG_DEBUG( "ELECTRON cl eta: "                                    << electron->caloCluster()->eta());
            ATH_MSG_DEBUG( "ELECTRON cl phi: "                                    << electron->caloCluster()->phi());
            auto newElectron = new xAOD::Electron(*electron);
 
            if ( getOriginalObject(*electron) != nullptr ) {
              setOriginalObjectLink(*getOriginalObject(*electron), *newElectron);
            } else {
              setOriginalObjectLink(*electron, *newElectron);
            }
 
            outputCol->push_back(newElectron); 
        }
    }
    return StatusCode::SUCCESS;
}

MergeMuons()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 55 of file Muons.cxx.

                                                                                                                                           {
    if (muons.empty()) return StatusCode::SUCCESS;
    for (const xAOD::Muon* muon: muons) {
        // add muon into output 
        if (writeMuon.at(muon->index())){
            auto newMuon = new xAOD::Muon(*muon);
 
            if ( getOriginalObject(*muon) != nullptr ) {
              setOriginalObjectLink(*getOriginalObject(*muon), *newMuon);
            } else {
              setOriginalObjectLink(*muon, *newMuon);
            }
            outputCol->push_back(newMuon); 
        }
    }
    return StatusCode::SUCCESS;
}

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

Definition at line 209 of file AsgMetadataTool.cxx.

                                            {
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

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.

                                                  {
 
      return MSG::name( msg().level() );
   }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

NearbyLeptonCorrections()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2971 of file SUSYObjDef_xAOD.cxx.

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

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.

                                                                        {
 
#ifdef XAOD_STANDALONE
      return &m_outputMetaStore;
#else // XAOD_STANDALONE
      return m_outputMetaStore;
#endif // XAOD_STANDALONE
   }

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

{
 
  if (this->GetPrimVtx() == nullptr) {
    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!");
  }
 
  ATH_CHECK( m_orToolbox.masterTool->removeOverlaps(electrons, muons, jets, taujet, gamma, fatjets) );
 
  /*
  // Count number of objects after overlap removal
  int Nel = 0;
  for (const auto& el : *electrons) {
    if (dec_passOR( *el )) Nel++;
  }
 
  int Nmu = 0;
  for (const auto& mu : *muons) {
    if (dec_passOR( *mu )) Nmu++;
  }
 
  int Njet = 0;
  for (const auto& jet : *jets) {
    if (dec_passOR( *jet )) Njet++;
  }
 
  ATH_MSG_VERBOSE( "After overlap removal: Nel=" << Nel << ", Nmu=" << Nmu << ", Njet=" << Njet );
  */
 
  return StatusCode::SUCCESS;
}

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.

                                                                                                                          {
  for (const xAOD::Electron *electron: *inElectrons){
    const xAOD::TrackParticle* idtrack = electron->trackParticle();
    
    // Save electron if the id track passes the LRT filter
    if ( acc_lrtFilter.isAvailable(*idtrack) )
    {
      if ( static_cast<int>(acc_lrtFilter(*idtrack) ) ){
        std::unique_ptr<xAOD::Electron> copyElectron = std::make_unique<xAOD::Electron>(*electron);
 
        // transfer original electron link
 
        setOriginalObjectLink(*electron, *copyElectron);
        copy->push_back( std::move(copyElectron) );        
      }  
    } 
    else // Keep electron if flag is not available
    {
      std::unique_ptr<xAOD::Electron> copyElectron = std::make_unique<xAOD::Electron>(*electron);
      
      setOriginalObjectLink(*electron, *copyElectron);
      copy->push_back( std::move(copyElectron) );
    }
  }
  return StatusCode::SUCCESS;
}

prepareLRTMuons()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 73 of file Muons.cxx.

                                                                                                          {
  for (const xAOD::Muon *muon: *inMuons){
    const xAOD::TrackParticle* idtrack = muon->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
 
    // Save muon if the id track passes the LRT filter
    if ( acc_lrtFilter.isAvailable(*idtrack) )
    {
      if ( static_cast<int>(acc_lrtFilter(*idtrack) ) ){ 
        std::unique_ptr<xAOD::Muon> copyMuon = std::make_unique<xAOD::Muon>(*muon);
 
        // transfer original muon link
        setOriginalObjectLink(*muon, *copyMuon);
        copy->push_back( std::move(copyMuon) );
      } 
    }
    else // Keep muon if flag is not available
    {  
      std::unique_ptr<xAOD::Muon> copyMuon = std::make_unique<xAOD::Muon>(*muon);
 
      setOriginalObjectLink(*muon, *copyMuon);
      copy->push_back( std::move(copyMuon) );
    }
    
  }
    return StatusCode::SUCCESS;
}

print() [1/2]

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

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

Definition at line 131 of file AsgTool.cxx.

                             {
 
      ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
      return;
   }

print() [2/2]

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

pure virtualinherited

Print the state of the tool.

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

readConfig()

StatusCode ST::SUSYObjDef_xAOD::readConfig ( )

finaloverrideprotectedvirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 1333 of file SUSYObjDef_xAOD.cxx.

{
  ATH_MSG_INFO( "*****     *****     *****     *****" );
  ATH_MSG_INFO( "Configuring from file " << m_configFile );
 
  TEnv rEnv;
  int success = -1;
  success = rEnv.ReadFile(m_configFile.c_str(), kEnvAll);
  if (success != 0) return StatusCode::FAILURE;
 
  ATH_MSG_INFO( "Config file opened" );
 
  if (m_jetInputType == xAOD::JetInput::Uncategorized) {
    m_jetInputType = xAOD::JetInput::Type(rEnv.GetValue("Jet.InputType", 9));
    ATH_MSG_INFO( "readConfig(): Loaded property Jet.InputType with value " << static_cast<int>(m_jetInputType));
  }
  // Remove the item from the table
  rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject("Jet.InputType") );
 
  if (m_muId == static_cast<int>(xAOD::Muon::Quality(xAOD::Muon::VeryLoose))) {
    int muIdTmp = rEnv.GetValue("Muon.Id", 1);
    m_muId = (muIdTmp<4 ? static_cast<int>(xAOD::Muon::Quality(muIdTmp)) : muIdTmp);
    ATH_MSG_INFO( "readConfig(): Loaded property Muon.Id with value " << m_muId);
    // Remove the item from the table
    rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject("Muon.Id") );
  }
  if (m_muIdBaseline == static_cast<int>(xAOD::Muon::Quality(xAOD::Muon::VeryLoose))) {
    int muIdTmp = rEnv.GetValue("MuonBaseline.Id", 1);
    m_muIdBaseline = (muIdTmp<4 ? static_cast<int>(xAOD::Muon::Quality(muIdTmp)) : muIdTmp);
    ATH_MSG_INFO( "readConfig(): Loaded property MuonBaseline.Id with value " << m_muIdBaseline);
    // Remove the item from the table
    rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject("MuonBaseline.Id") );
  }
 
  // Deprecation warning
  std::string prop = rEnv.GetValue("Jet.JVT_WP", "");
  if ( !prop.empty() ) {
     ATH_MSG_WARNING("readConfig(): Found deprecated property name Jet.JVT_WP. Please move to using Jet.JvtWP. Propagating for now.");
     rEnv.SetValue("Jet.JvtWP", prop.c_str());
     rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject("Jet.JVT_WP") );
  }
 
  //load config file to Properties map  (only booleans for now)
  m_conf_to_prop["IsRun3"] = "IsRun3";
  m_conf_to_prop["StrictConfigCheck"] = "StrictConfigCheck";
  m_conf_to_prop["Btag.enable"] = "UseBtagging";
  m_conf_to_prop["BtagTrkJet.enable"] = "UseBtaggingTrkJet";
  m_conf_to_prop["Ele.CrackVeto"] = "EleCrackVeto";
  m_conf_to_prop["EleBaseline.CrackVeto"] = "EleBaselineCrackVeto";
  m_conf_to_prop["Ele.ForceNoId"] = "EleForceNoId";
  m_conf_to_prop["Ele.AllowRun3TrigSFFallback"] = "EleAllowRun3TrigSFFallback";
  m_conf_to_prop["Muon.ForceNoId"] = "MuonForceNoId";
  m_conf_to_prop["Muon.TTVASF"] = "MuonTTVASF";
  m_conf_to_prop["Muon.passedHighPt"] = "MuonRequireHighPtCuts";
  m_conf_to_prop["PhotonBaseline.CrackVeto"] = "PhotonBaselineCrackVeto";
  m_conf_to_prop["Photon.CrackVeto"] = "PhotonCrackVeto";
  m_conf_to_prop["Photon.AllowLate"] = "PhotonAllowLate";
 
  m_conf_to_prop["FwdJet.doJVT"] = "FwdJetDoJVT";
 
  m_conf_to_prop["OR.DoBoostedElectron"] = "DoBoostedElectronOR";
  m_conf_to_prop["OR.DoBoostedMuon"] = "DoBoostedMuonOR";
  m_conf_to_prop["OR.DoMuonJetGhostAssociation"] = "ORDoMuonJetGhostAssociation";
  m_conf_to_prop["OR.DoTau"] = "DoTauOR";
  m_conf_to_prop["OR.DoPhoton"] = "DoPhotonOR";
  m_conf_to_prop["OR.DoEleJet"] = "DoEleJetOR";
  m_conf_to_prop["OR.DoElEl"] = "DoElElOR";
  m_conf_to_prop["OR.DoElMu"] = "DoElMuOR";
  m_conf_to_prop["OR.DoMuonJet"] = "DoMuonJetOR";
  m_conf_to_prop["OR.Bjet"] = "DoBjetOR";
  m_conf_to_prop["OR.ElBjet"] = "DoElBjetOR";
  m_conf_to_prop["OR.MuBjet"] = "DoMuBjetOR";
  m_conf_to_prop["OR.TauBjet"] = "DoTauBjetOR";
  m_conf_to_prop["OR.DoFatJets"] = "DoFatJetOR";
  m_conf_to_prop["OR.RemoveCaloMuons"] = "ORRemoveCaloMuons";
  m_conf_to_prop["OR.MuJetApplyRelPt"] = "ORMuJetApplyRelPt";
  m_conf_to_prop["OR.InputLabel"] = "ORInputLabel";
  m_conf_to_prop["Trigger.UpstreamMatching"] = "TriggerUpstreamMatching";
 
  m_conf_to_prop["SigLep.RequireIso"] = "SigLepRequireIso";
  m_conf_to_prop["SigEl.RequireIso"] = "SigElRequireIso";
  m_conf_to_prop["SigMu.RequireIso"] = "SigMuRequireIso";
  m_conf_to_prop["SigPh.RequireIso"] = "SigPhRequireIso";
  m_conf_to_prop["SigLepPh.IsoCloseByOR"] = "SigLepPhIsoCloseByOR";
  m_conf_to_prop["MET.RemoveOverlappingCaloTaggedMuons"] = "METRemoveORCaloTaggedMuons";
  m_conf_to_prop["MET.DoSetMuonJetEMScale"] = "METDoSetMuonJetEMScale";
  m_conf_to_prop["MET.DoRemoveMuonJets"] = "METDoRemoveMuonJets";
  m_conf_to_prop["MET.DoUseGhostMuons"] = "METUseGhostMuons";
  m_conf_to_prop["MET.DoMuonEloss"] = "METDoMuonEloss";
 
  m_conf_to_prop["MET.DoTrkSyst"] = "METDoTrkSyst";
  m_conf_to_prop["MET.DoCaloSyst"] = "METDoCaloSyst";
 
  m_conf_to_prop["Tau.DoTruthMatching"] = "TauDoTruthMatching";
  //
 
  configFromFile(m_slices["ele"],  "Slices.Ele",  rEnv, true);
  configFromFile(m_slices["pho"],  "Slices.Pho",  rEnv, true);
  configFromFile(m_slices["mu"],   "Slices.Mu",   rEnv, true);
  configFromFile(m_slices["tau"],  "Slices.Tau",  rEnv, true);
  configFromFile(m_slices["jet"],  "Slices.Jet",  rEnv, true);
  configFromFile(m_slices["bjet"], "Slices.BJet", rEnv, true);
  configFromFile(m_slices["fjet"], "Slices.FJet", rEnv, true);
  configFromFile(m_slices["tjet"], "Slices.TJet", rEnv, true);
  configFromFile(m_slices["met"],  "Slices.MET",  rEnv, true);
  //
  configFromFile(m_isRun3, "IsRun3", rEnv, false);
  //
  configFromFile(m_eleBaselinePt, "EleBaseline.Pt", rEnv, 10000.);
  configFromFile(m_eleBaselineEta, "EleBaseline.Eta", rEnv, 2.47);
  configFromFile(m_eleIdBaseline, "EleBaseline.Id", rEnv, "LooseAndBLayerLLH");
  configFromFile(m_eleBaselineIso_WP, "EleBaseline.Iso", rEnv, "None");
  configFromFile(m_eleConfigBaseline, "EleBaseline.Config", rEnv, "None");
  configFromFile(m_eleBaselineCrackVeto, "EleBaseline.CrackVeto", rEnv, false);
  configFromFile(m_force_noElId, "Ele.ForceNoId", rEnv, false);
  
  //
  configFromFile(m_elePt, "Ele.Et", rEnv, 25000.);
  configFromFile(m_eleEta, "Ele.Eta", rEnv, 2.47);
  configFromFile(m_eleCrackVeto, "Ele.CrackVeto", rEnv, false);
  configFromFile(m_eleIso_WP, "Ele.Iso", rEnv, "Loose_VarRad");
  configFromFile(m_eleIsoHighPt_WP, "Ele.IsoHighPt", rEnv, "HighPtCaloOnly");
  configFromFile(m_eleIsoHighPtThresh, "Ele.IsoHighPtThresh", rEnv, 200e3);
  configFromFile(m_eleChID_WP, "Ele.CFT", rEnv, "None"); // Loose is the only one supported for the moment, and not many clients yet.
  configFromFile(m_eleChIso, "Ele.CFTIso", rEnv, true); // use charge ID SFs without iso applied
  configFromFile(m_eleChID_signal, "Ele.CFTSignal", rEnv, !m_eleChID_WP.empty()); // Require ECID as part of the signal lepton definition
  configFromFile(m_eleId, "Ele.Id", rEnv, "TightLLH");
  configFromFile(m_eleLRT, "Ele.LRTOR", rEnv, false);
  configFromFile(m_eleLRT_strat, "Ele.LRTORStrat", rEnv, 0);
  configFromFile(m_eleConfig, "Ele.Config", rEnv, "None");
  configFromFile(m_eled0sig, "Ele.d0sig", rEnv, 5.);
  configFromFile(m_elez0, "Ele.z0", rEnv, 0.5);
  configFromFile(m_elebaselined0sig, "EleBaseline.d0sig", rEnv, -99.);
  configFromFile(m_elebaselinez0, "EleBaseline.z0", rEnv, 0.5);
  configFromFile(m_eleIdExpert, "Ele.IdExpert", rEnv, false);
  configFromFile(m_EG_corrModel, "Ele.EffNPcorrModel", rEnv, "TOTAL");
  configFromFile(m_EG_corrFNList, "Ele.EffCorrFNList", rEnv, "None");
  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");
  configFromFile(m_eleEffMapFilePath, "Ele.EffMapFilePath", rEnv, "ElectronEfficiencyCorrection/2015_2025/rel22.2/2025_Run3_Consolidated_Prerecom_v3/map1.txt");
  configFromFile(m_eleAllowRun3TrigSFFallback, "Ele.AllowRun3TrigSFFallback", rEnv, false);
  configFromFile(m_eleForceFullSimCalib, "Ele.ForceFullSimCalib", rEnv, false);
  
  configFromFile(m_trig2015combination_singleLep, "Trig.Singlelep2015", rEnv, "e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose || mu20_iloose_L1MU15_OR_mu40");
  configFromFile(m_trig2016combination_singleLep, "Trig.Singlelep2016", rEnv, "e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0 || mu26_ivarmedium_OR_mu50");
  configFromFile(m_trig2017combination_singleLep, "Trig.Singlelep2017", rEnv, "e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0 || mu26_ivarmedium_OR_mu50");
  configFromFile(m_trig2018combination_singleLep, "Trig.Singlelep2018", rEnv, "e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0 || mu26_ivarmedium_OR_mu50");
  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");
  configFromFile(m_trigNToys_diLep, "Trig.DilepNToys", rEnv, 250); // 0 means calculate from formula instead - needs to be supported for the trigger combination
  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");
  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");
  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");
  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");
  // configFromFile(m_trig2022combination_diLep, "Trig.Dilep2022", rEnv, "");
  configFromFile(m_trigNToys_multiLep, "Trig.MultiNToys", rEnv, 250); // 0 means calculate from formula instead - needs to be supported for the trigger combination
  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");
  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");
  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");
  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");
  // configFromFile(m_trig2022combination_multiLep, "Trig.Multi2022", rEnv, "");
  configFromFile(m_trigNToys_diPhoton, "Trig.DiphotonNToys", rEnv, 250); // 0 means calculate from formula instead - needs to be supported for the trigger combination
  configFromFile(m_trig2015combination_diPhoton, "Trig.Diphoton2015", rEnv, "g35_loose_g25_loose");
  configFromFile(m_trig2016combination_diPhoton, "Trig.Diphotonp2016", rEnv, "g35_loose_g25_loose");
  configFromFile(m_trig2017combination_diPhoton, "Trig.Diphotonp2017", rEnv, "g35_medium_g25_medium_L12EM20VH");
  configFromFile(m_trig2018combination_diPhoton, "Trig.Diphotonp2018", rEnv, "g35_medium_g25_medium_L12EM20VH");
  // configFromFile(m_trig2018combination_diPhoton, "Trig.Diphotonp2022", rEnv, "");
  //
  configFromFile(m_muBaselinePt, "MuonBaseline.Pt", rEnv, 10000.);
  configFromFile(m_muBaselineEta, "MuonBaseline.Eta", rEnv, 2.7);
  configFromFile(m_force_noMuId, "Muon.ForceNoId", rEnv, false);
  configFromFile(m_muBaselineIso_WP, "MuonBaseline.Iso", rEnv, "None");
  configFromFile(m_doTTVAsf, "Muon.TTVASF", rEnv, true);
  //
  configFromFile(m_muPt, "Muon.Pt", rEnv, 25000.);
  configFromFile(m_muEta, "Muon.Eta", rEnv, 2.7);
  configFromFile(m_muIso_WP, "Muon.Iso", rEnv, "Loose_VarRad");
  configFromFile(m_muIsoHighPt_WP, "Muon.IsoHighPt", rEnv, "Loose_VarRad");
  configFromFile(m_muIsoHighPtThresh, "Muon.IsoHighPtThresh", rEnv, 200e3);
  configFromFile(m_mud0sig, "Muon.d0sig", rEnv, 3.);
  configFromFile(m_muz0, "Muon.z0", rEnv, 0.5);
  configFromFile(m_mubaselined0sig, "MuonBaseline.d0sig", rEnv, -99.);
  configFromFile(m_mubaselinez0, "MuonBaseline.z0", rEnv, 0.5);
  configFromFile(m_murequirepassedHighPtCuts, "Muon.passedHighPt", rEnv, false);
  configFromFile(m_muHighPtExtraSmear, "Muon.HighPtExtraSmear", rEnv, false);
  configFromFile(m_muEffCorrForce1D, "Muon.EffCorrForce1D", rEnv, false);
  //
  configFromFile(m_muTriggerSFCalibRelease,   "Muon.TriggerSFCalibRelease" ,rEnv, "None");
  configFromFile(m_muTriggerSFCalibFilename,  "Muon.TriggerSFCalibFilename",rEnv, "None");
  //
  configFromFile(m_muCosmicz0, "MuonCosmic.z0", rEnv, 1.);
  configFromFile(m_muCosmicd0, "MuonCosmic.d0", rEnv, 0.2);
  //
  // LRT muons
  configFromFile(m_muLRT, "Muon.LRTOR", rEnv, false);
  //
  configFromFile(m_badmuQoverP, "BadMuon.qoverp", rEnv, 0.4);
  //
  configFromFile(m_muCalibrationMode, "Muon.CalibrationMode", rEnv, 0); // 0: correctData_CB
  //
  configFromFile(m_photonBaselinePt, "PhotonBaseline.Pt", rEnv, 25000.);
  configFromFile(m_photonBaselineEta, "PhotonBaseline.Eta", rEnv, 2.37);
  configFromFile(m_photonIdBaseline, "PhotonBaseline.Id", rEnv, "Tight");
  configFromFile(m_photonBaselineCrackVeto, "PhotonBaseline.CrackVeto", rEnv, true);
  configFromFile(m_photonBaselineIso_WP, "PhotonBaseline.Iso", rEnv, "None");
  //
  configFromFile(m_photonPt, "Photon.Pt", rEnv, 130000.);
  configFromFile(m_photonEta, "Photon.Eta", rEnv, 2.37);
  configFromFile(m_photonId, "Photon.Id", rEnv, "Tight");
  configFromFile(m_photonIso_WP, "Photon.Iso", rEnv, "FixedCutTight");
  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
  configFromFile(m_photonCrackVeto, "Photon.CrackVeto", rEnv, true);
  configFromFile(m_photonAllowLate, "Photon.AllowLate", rEnv, false);
  //
  configFromFile(m_tauPrePtCut, "Tau.PrePtCut", rEnv, 0.);
  configFromFile(m_tauPt, "Tau.Pt", rEnv, 20000.);
  configFromFile(m_tauEta, "Tau.Eta", rEnv, 2.5);
  configFromFile(m_tauId, "Tau.Id", rEnv, "Medium");
  configFromFile(m_tauConfigPath, "Tau.ConfigPath", rEnv, "default");
  configFromFile(m_tauIdBaseline, "TauBaseline.Id", rEnv, "Medium");
  configFromFile(m_tauConfigPathBaseline, "TauBaseline.ConfigPath", rEnv, "default");
  configFromFile(m_tauDoTTM, "Tau.DoTruthMatching", rEnv, false);
  //
  configFromFile(m_tauSmearingToolRecommendationTag,"Tau.SmearingToolRecommendationTag", rEnv, "2025-prerec");
  configFromFile(m_tauSmearingToolGenerator,"Tau.SmearingToolGenerator", rEnv, "PoPy");
  configFromFile(m_tauEffToolRecommendationTag,"Tau.EffToolRecommendationTag", rEnv, "2025-prerec");
  configFromFile(m_ApplyMVATESQualityCheck, "Tau.MVATESQualityCheck", rEnv, true);
  //
  configFromFile(m_jetPt, "Jet.Pt", rEnv, 20000.);
  configFromFile(m_jetEta, "Jet.Eta", rEnv, 2.8);
  configFromFile(m_JvtWP, "Jet.JvtWP", rEnv, "FixedEffPt"); // https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/PileupJetRecommendations
  configFromFile(m_JvtPtMax, "Jet.JvtPtMax", rEnv, 60.0e3);
  configFromFile(m_JvtConfigRun2, "Jet.JvtConfigRun2", rEnv, "JetJvtEfficiency/May2024/NNJvtSFFile_Run2_EMPFlow.root", true); // empty string means dummy SF
  configFromFile(m_JvtConfigRun3, "Jet.JvtConfigRun3", rEnv, "JetJvtEfficiency/May2024/NNJvtSFFile_Run3_EMPFlow.root", true); // empty string means dummy SF
  configFromFile(m_jetUncertaintiesConfig, "Jet.UncertConfig", rEnv, getDefaultJetUncConfig() ); // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/JetUncertaintiesRel22/
  configFromFile(m_jetUncertaintiesAnalysisFile, "Jet.AnalysisFile", rEnv, "default"); // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/JetUncertaintiesRel21Summer2018SmallR
  configFromFile(m_jetUncertaintiesCalibArea, "Jet.UncertCalibArea", rEnv, "default"); // Defaults to default area set by tool
  configFromFile(m_jetUncertaintiesMCType, "Jet.UncertMCType", rEnv, "", true); // empty string means the MCType is guessed
  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.
  configFromFile(m_fatJets, "Jet.LargeRcollection", rEnv, "AntiKt10UFOCSSKSoftDropBeta100Zcut10Jets"); // set to "None" to turn off large jets
  configFromFile(m_fatJetUncConfig, "Jet.LargeRuncConfig", rEnv, "rel22/Spring2025_PreRec/R10_CategoryJES_FullJER_FullJMS.config");
  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.
  configFromFile(m_fatJetUncVars, "Jet.LargeRuncVars", rEnv, "default"); // do all if not specified
  configFromFile(m_WtagConfig, "Jet.WtaggerConfig", rEnv, "SmoothedContainedWTagger_AntiKt10UFOCSSKSoftDrop_FixedSignalEfficiency80_20220221.dat");
  configFromFile(m_ZtagConfig, "Jet.ZtaggerConfig", rEnv, "SmoothedContainedZTagger_AntiKt10UFOCSSKSoftDrop_FixedSignalEfficiency80_20220221.dat");
  configFromFile(m_WZTaggerCalibArea, "Jet.WZTaggerCalibArea", rEnv, "Winter2024_R22_PreRecs/SmoothedWZTaggers/");
  configFromFile(m_ToptagConfig, "Jet.ToptaggerConfig", rEnv, "DNNTagger_AntiKt10UFOSD_TopInclusive80_Oct30.dat");
  configFromFile(m_JetTruthLabelName, "Jet.JetTruthLabelName", rEnv, "R10TruthLabel_R21Precision_2022v1");
  configFromFile(m_TopTaggerCalibArea, "Jet.TopTaggerCalibArea", rEnv, "Winter2024_R22_PreRecs/JSSWTopTaggerDNN/"); 
  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
  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");
  configFromFile(m_jesConfigJMS, "Jet.JESConfigJMS", rEnv, "JES_JMS_MC16Recommendation_Consolidated_MC_only_EMTopo_July2019_Rel21.config");
  configFromFile(m_jesConfigJMSData, "Jet.JESConfigJMSData", rEnv, "JES_JMS_MC16Recommendation_Consolidated_data_only_EMTopo_Sep2019_Rel21.config");
  configFromFile(m_jesConfigFat, "Jet.JESConfigFat", rEnv, "JES_MC20PreRecommendation_R10_UFO_CSSK_SoftDrop_JMS_R21Insitu_26Nov2024.config");
  configFromFile(m_jesConfigFatData, "Jet.JESConfigFatData", rEnv, "JES_MC20PreRecommendation_R10_UFO_CSSK_SoftDrop_JMS_R21Insitu_26Nov2024.config");
  configFromFile(m_jesCalibSeq, "Jet.CalibSeq", rEnv, "JetArea_Residual_EtaJES_GSC_Insitu");
  configFromFile(m_jesCalibSeqJMS, "Jet.CalibSeqJMS", rEnv, "JetArea_Residual_EtaJES_GSC");
  configFromFile(m_jesCalibSeqFat, "Jet.CalibSeqFat", rEnv, "EtaJES_JMS");
  configFromFile(m_jesCalibArea, "Jet.CalibArea", rEnv, m_isRun3 ? "00-04-83" : "00-04-82");
  //
  configFromFile(m_defaultTrackJets, "TrackJet.Coll", rEnv, "AntiKtVR30Rmax4Rmin02TrackJets");
  configFromFile(m_trkJetPt, "TrackJet.Pt", rEnv, 20000.);
  configFromFile(m_trkJetEta, "TrackJet.Eta", rEnv, 2.8);
  //
  configFromFile(m_badJetCut, "BadJet.Cut", rEnv, "LooseBad");
  //
  configFromFile(m_doFwdJVT, "FwdJet.doJVT", rEnv, false); // https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/PileupJetRecommendations
  configFromFile(m_fJvtWP, "FwdJet.JvtWP", rEnv, "Loose");
  configFromFile(m_fJvtPtMax, "FwdJet.JvtPtMax", rEnv, 60e3);
  configFromFile(m_fJvtEtaMin, "FwdJet.JvtEtaMin", rEnv, 2.5);
  configFromFile(m_fJvtConfigRun2, "FwdJet.JvtConfigRun2", rEnv, "JetJvtEfficiency/May2024/fJvtSFFile_Run2_EMPFlow.root", true); // empty string means dummy SF
  configFromFile(m_fJvtConfigRun3, "FwdJet.JvtConfigRun3", rEnv, "JetJvtEfficiency/May2024/fJvtSFFile_Run2_EMPFlow.root", true); // empty string means dummy SF
  configFromFile(m_JMScalib, "Jet.JMSCalib", rEnv, false);
  //
  configFromFile(m_useBtagging, "Btag.enable", rEnv, true);
  configFromFile(m_BtagTagger, "Btag.Tagger", rEnv, "GN2v01");
  configFromFile(m_BtagWP, "Btag.WP", rEnv, "Continuous");
  configFromFile(m_BtagMinPt, "Btag.MinPt", rEnv, -1.); // Not calibrated below 20
 
  configFromFile(m_bTaggingCalibrationFilePath, "Btag.CalibPath", rEnv, m_isRun3 ? "xAODBTaggingEfficiency/13p6TeV/MC23_2025-06-17_GN2v01_v4.root": "xAODBTaggingEfficiency/13TeV/MC20_2025-06-17_GN2v01_v4.root");
  configFromFile(m_BtagSystStrategy, "Btag.SystStrategy", rEnv, "SFEigen");
  configFromFile(m_EigenvectorReductionB, "Btag.EigenvectorReductionB", rEnv, "Loose");
  configFromFile(m_EigenvectorReductionC, "Btag.EigenvectorReductionC", rEnv, "Loose");
  configFromFile(m_EigenvectorReductionLight, "Btag.EigenvectorReductionLight", rEnv, "Loose");
 
  configFromFile(m_useBtagging_trkJet, "BtagTrkJet.enable", rEnv, true);
  configFromFile(m_BtagTagger_trkJet, "BtagTrkJet.Tagger", rEnv, "DL1r");
  configFromFile(m_BtagWP_trkJet, "BtagTrkJet.WP", rEnv, "FixedCutBEff_77");
  configFromFile(m_BtagMinPt_trkJet, "BtagTrkJet.MinPt", rEnv, -1.); // Not calibrated below 10
  configFromFile(m_BtagKeyOverride, "Btag.KeyOverride", rEnv, "", true);
  //
  configFromFile(m_orDoBoostedElectron, "OR.DoBoostedElectron", rEnv, true);
  configFromFile(m_orBoostedElectronC1, "OR.BoostedElectronC1", rEnv, -999.); // set to positive number to override default
  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)
  configFromFile(m_orBoostedElectronMaxConeSize, "OR.BoostedElectronMaxConeSize", rEnv, -999.); // set to positive number to override default
  configFromFile(m_orDoBoostedMuon, "OR.DoBoostedMuon", rEnv, true);
  configFromFile(m_orBoostedMuonC1, "OR.BoostedMuonC1", rEnv, -999.); // set to positive number to override default
  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)
  configFromFile(m_orBoostedMuonMaxConeSize, "OR.BoostedMuonMaxConeSize", rEnv, -999.); // set to positive number to override default
  configFromFile(m_orDoMuonJetGhostAssociation, "OR.DoMuonJetGhostAssociation", rEnv, true);
  configFromFile(m_orDoTau, "OR.DoTau", rEnv, false);
  configFromFile(m_orDoPhoton, "OR.DoPhoton", rEnv, false);
  configFromFile(m_orDoEleJet, "OR.EleJet", rEnv, true);
  configFromFile(m_orDoElEl, "OR.ElEl", rEnv, false);
  configFromFile(m_orDoElMu, "OR.ElMu", rEnv, false);
  configFromFile(m_orDoMuonJet, "OR.MuonJet", rEnv, true);
  configFromFile(m_orDoBjet, "OR.Bjet", rEnv, false);
  configFromFile(m_orDoElBjet, "OR.ElBjet", rEnv, false);
  configFromFile(m_orDoMuBjet, "OR.MuBjet", rEnv, false);
  configFromFile(m_orDoTauBjet, "OR.TauBjet", rEnv, false);
  configFromFile(m_orApplyRelPt, "OR.MuJetApplyRelPt", rEnv, false);
  configFromFile(m_orMuJetPtRatio, "OR.MuJetPtRatio", rEnv, -999.);
  configFromFile(m_orMuJetTrkPtRatio, "OR.MuJetTrkPtRatio", rEnv, -999.);
  configFromFile(m_orRemoveCaloMuons, "OR.RemoveCaloMuons", rEnv, true);
  configFromFile(m_orMuJetInnerDR, "OR.MuJetInnerDR", rEnv, -999.);
  configFromFile(m_orBtagWP, "OR.BtagWP", rEnv, "FixedCutBEff_85");
  configFromFile(m_orInputLabel, "OR.InputLabel", rEnv, "selected"); //"baseline"
  configFromFile(m_orPhotonFavoured, "OR.PhotonFavoured", rEnv, false);
  configFromFile(m_orBJetPtUpperThres, "OR.BJetPtUpperThres", rEnv, -1.); // upper pt threshold of b-jet in OR in unit of MeV, -1 means no pt threshold
  configFromFile(m_orLinkOverlapObjects, "OR.LinkOverlapObjects", rEnv, false);
  //
  configFromFile(m_orDoFatjets, "OR.DoFatJets", rEnv, false);
  configFromFile(m_EleFatJetDR, "OR.EleFatJetDR", rEnv, -999.);
  configFromFile(m_JetFatJetDR, "OR.JetFatJetDR", rEnv, -999.);
  //
  configFromFile(m_useTRUTH3, "Truth.UseTRUTH3", rEnv, true);
  configFromFile(m_upstreamTriggerMatching, "Trigger.UpstreamMatching", rEnv, false);
  configFromFile(m_trigMatchingPrefix, "Trigger.MatchingPrefix", rEnv, "", true);
  //
  configFromFile(m_doIsoSignal, "SigLep.RequireIso", rEnv, true);
  configFromFile(m_doElIsoSignal, "SigEl.RequireIso", rEnv, m_doIsoSignal);
  configFromFile(m_doMuIsoSignal, "SigMu.RequireIso", rEnv, m_doIsoSignal);
  configFromFile(m_doPhIsoSignal, "SigPh.RequireIso", rEnv, m_doIsoSignal);
  configFromFile(m_useSigLepForIsoCloseByOR, "SigLepPh.UseSigLepForIsoCloseByOR", rEnv, false);
  configFromFile(m_IsoCloseByORpassLabel, "SigLepPh.IsoCloseByORpassLabel", rEnv, "None");
 
  //
  configFromFile(m_eleTerm, "MET.EleTerm", rEnv, "RefEle");
  configFromFile(m_gammaTerm, "MET.GammaTerm", rEnv, "RefGamma");
  configFromFile(m_tauTerm, "MET.TauTerm", rEnv, "RefTau");
  configFromFile(m_jetTerm, "MET.JetTerm", rEnv, "RefJet");
  configFromFile(m_muonTerm, "MET.MuonTerm", rEnv, "Muons");
  configFromFile(m_inputMETSuffix, "MET.InputSuffix", rEnv, "", true); // May be empty
  configFromFile(m_outMETTerm, "MET.OutputTerm", rEnv, "Final");
  configFromFile(m_metRemoveOverlappingCaloTaggedMuons, "MET.RemoveOverlappingCaloTaggedMuons", rEnv, true);
  configFromFile(m_metDoSetMuonJetEMScale, "Met.DoSetMuonJetEMScale", rEnv, true);
  configFromFile(m_metDoRemoveMuonJets, "MET.DoRemoveMuonJets", rEnv, true);
  configFromFile(m_metUseGhostMuons, "MET.UseGhostMuons", rEnv, false);
  configFromFile(m_metDoMuonEloss, "MET.DoMuonEloss", rEnv, false);
  configFromFile(m_metGreedyPhotons, "MET.DoGreedyPhotons", rEnv, false);
  configFromFile(m_metVeryGreedyPhotons, "MET.DoVeryGreedyPhotons", rEnv, false);
 
  configFromFile(m_trkMETsyst, "MET.DoTrkSyst", rEnv, true);
  configFromFile(m_caloMETsyst, "MET.DoCaloSyst", rEnv, false);
  configFromFile(m_trkJetsyst, "MET.DoTrkJetSyst", rEnv, false);
  configFromFile(m_metsysConfigPrefix, "METSys.ConfigPrefix", rEnv, "METUtilities/R22_PreRecs");
  configFromFile(m_metJetSelection, "MET.JetSelection", rEnv, "Tight"); // Loose, Tight (default), Tighter, Tenacious
  configFromFile(m_softTermParam, "METSig.SoftTermParam", rEnv, met::Random);
  configFromFile(m_treatPUJets, "METSig.TreatPUJets", rEnv, true);
  configFromFile(m_doPhiReso, "METSig.DoPhiReso", rEnv, false);
  //
  configFromFile(m_prwActualMu2017File, "PRW.ActualMu2017File", rEnv, "GoodRunsLists/data17_13TeV/20180619/physics_25ns_Triggerno17e33prim.actualMu.OflLumi-13TeV-010.root");
  configFromFile(m_prwActualMu2018File, "PRW.ActualMu2018File", rEnv, "GoodRunsLists/data18_13TeV/20190318/physics_25ns_Triggerno17e33prim.actualMu.OflLumi-13TeV-010.root");
  configFromFile(m_prwActualMu2022File, "PRW.ActualMu2022File", rEnv, "GoodRunsLists/data22_13p6TeV/20250321/purw.actualMu.root");
  configFromFile(m_prwActualMu2023File, "PRW.ActualMu2023File", rEnv, "GoodRunsLists/data23_13p6TeV/20250321/purw.actualMu.root");
  configFromFile(m_prwActualMu2024File, "PRW.ActualMu2024File", rEnv, "GoodRunsLists/data24_13p6TeV/20241118/purw.actualMu.root");
  configFromFile(m_prwDataSF, "PRW.DataSF", rEnv, 1./1.03); // default for mc16, see: https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/ExtendedPileupReweighting#Tool_Properties
  configFromFile(m_prwDataSF_UP, "PRW.DataSF_UP", rEnv, 1./0.99); // mc16 uncertainty? defaulting to the value in PRWtool
  configFromFile(m_prwDataSF_DW, "PRW.DataSF_DW", rEnv, 1./1.07); // mc16 uncertainty? defaulting to the value in PRWtool
  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.
  configFromFile(m_autoconfigPRWPath, "PRW.autoconfigPRWPath", rEnv, "dev/PileupReweighting/share/");
  configFromFile(m_autoconfigPRWFile, "PRW.autoconfigPRWFile", rEnv, "None");
  configFromFile(m_autoconfigPRWCombinedmode, "PRW.autoconfigPRWCombinedmode", rEnv, false);
  configFromFile(m_autoconfigPRWRPVmode, "PRW.autoconfigPRWRPVmode", rEnv, false);
  configFromFile(m_autoconfigPRWRtags, "PRW.autoconfigPRWRtags", rEnv, "mc20a:r13167_r14859,mc20d:r13144_r14860,mc20e:r13145_r14861,mc21a:r13752_r13829,mc23a:r14622_r14932_r15540,mc23c:r14799_r14908,mc23d:r15224_r15530,mc23e:r16083"); // Tag details here: https://twiki.cern.ch/twiki/bin/view/AtlasProtected/AtlasProductionGroup
  configFromFile(m_commonPRWFileMC20a, "PRW.commonPRWFileMC20a", rEnv, "PileupReweighting/mc20_common/mc20a.284500.physlite.prw.v1.root");
  configFromFile(m_commonPRWFileMC20d, "PRW.commonPRWFileMC20d", rEnv, "PileupReweighting/mc20_common/mc20d.300000.physlite.prw.v1.root");
  configFromFile(m_commonPRWFileMC20e, "PRW.commonPRWFileMC20e", rEnv, "PileupReweighting/mc20_common/mc20e.310000.physlite.prw.v1.root");
  configFromFile(m_commonPRWFileMC21a, "PRW.commonPRWFileMC21a", rEnv, "PileupReweighting/mc21_common/mc21a.410000.physlite.prw.v1.root");
  configFromFile(m_commonPRWFileMC23a, "PRW.commonPRWFileMC23a", rEnv, "PileupReweighting/mc23_common/mc23a.410000.physlite.prw.v2.root");
  configFromFile(m_commonPRWFileMC23c, "PRW.commonPRWFileMC23c", rEnv, "PileupReweighting/mc23_common/mc23c.450000.physlite.prw.v1.root");
  configFromFile(m_commonPRWFileMC23d, "PRW.commonPRWFileMC23d", rEnv, "PileupReweighting/mc23_common/mc23d.450000.physlite.prw.v1.root");
  configFromFile(m_commonPRWFileMC23e, "PRW.commonPRWFileMC23e", rEnv, "PileupReweighting/mc23_common/mc23e.470000.physlite.prw.v1.root");
  //
  configFromFile(m_strictConfigCheck, "StrictConfigCheck", rEnv, false);
 
  // By now rEnv should be empty!
  if (rEnv.GetTable() && rEnv.GetTable()->GetSize()>0){
    ATH_MSG_ERROR("Found " << rEnv.GetTable()->GetSize() << " unparsed environment options:");
    rEnv.Print();
    ATH_MSG_ERROR("Please fix your configuration!");
    return StatusCode::FAILURE;
  }
 
  // Set up the correct configuration files for the large-R jet tagging corresponding to the input tagger config
  if (!m_WtagConfig.empty()) {
    if (m_WtagConfig.find("Efficiency50") != std::string::npos){
      m_WTagUncConfig = "R10_SF_LCTopo_WTag_SigEff50.config";
    }
    else if (m_WtagConfig.find("Efficiency80") != std::string::npos){
      m_WTagUncConfig = "R10_SF_LCTopo_WTag_SigEff80.config";
    }
    else {
      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");
    }
  }
  if (!m_ZtagConfig.empty()) {
    if (m_ZtagConfig.find("Efficiency50") != std::string::npos){
      m_ZTagUncConfig = "R10_SF_LCTopo_ZTag_SigEff50.config";
    }
    else if (m_ZtagConfig.find("Efficiency80") != std::string::npos){
      m_ZTagUncConfig = "R10_SF_LCTopo_ZTag_SigEff80.config";
    }
    else {
      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");
    }
  }
  std::string TopTagEff = "";
  std::string TopTagType = "";
  if (!m_ToptagConfig.empty()) {
    if (m_ToptagConfig.find("50") != std::string::npos){
      TopTagEff = "50";
    }
    else if (m_ToptagConfig.find("80") != std::string::npos){
      TopTagEff = "80";
    }
    else {
      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");
    }
    //
    if (m_ToptagConfig.find("Inclusive") != std::string::npos){
      TopTagType = "Inclusive";
    }
    else if (m_ToptagConfig.find("Contained") != std::string::npos){
      TopTagType = "Contained";
    }
    else {
      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");
    }
    m_TopTagUncConfig = "R10_SF_LCTopo_TopTag"+TopTagType+"_SigEff"+TopTagEff+".config";
  }
 
  //** validate configuration
  ATH_CHECK( validConfig(m_strictConfigCheck) );
 
  //** cache trigger chains for electron matching
  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);
 
  //** cache trigger chains for matching (both electrons and muons)
  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_trigs15_cache_singleLep = GetTriggerOR(m_trig2015combination_singleLep);
  m_v_trigs16_cache_singleLep = GetTriggerOR(m_trig2016combination_singleLep);
  m_v_trigs17_cache_singleLep = GetTriggerOR(m_trig2017combination_singleLep);
  m_v_trigs18_cache_singleLep = GetTriggerOR(m_trig2018combination_singleLep);
  m_v_trigs22_cache_singleLep = GetTriggerOR(m_trig2022combination_singleLep);
 
  m_v_trigs15_cache_diLep = GetTriggerOR(m_trig2015combination_diLep);
  m_v_trigs16_cache_diLep = GetTriggerOR(m_trig2016combination_diLep);
  m_v_trigs17_cache_diLep = GetTriggerOR(m_trig2017combination_diLep);
  m_v_trigs18_cache_diLep = GetTriggerOR(m_trig2018combination_diLep);
  m_v_trigs22_cache_diLep = GetTriggerOR(m_trig2022combination_diLep);
 
  m_v_trigs15_cache_multiLep = GetTriggerOR(m_trig2015combination_multiLep);
  m_v_trigs16_cache_multiLep = GetTriggerOR(m_trig2016combination_multiLep);
  m_v_trigs17_cache_multiLep = GetTriggerOR(m_trig2017combination_multiLep);
  m_v_trigs18_cache_multiLep = GetTriggerOR(m_trig2018combination_multiLep);
  m_v_trigs22_cache_multiLep = GetTriggerOR(m_trig2022combination_multiLep);
 
  return StatusCode::SUCCESS;
}

renounce()

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

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

resetSystematics()

StatusCode ST::SUSYObjDef_xAOD::resetSystematics ( )

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2097 of file SUSYObjDef_xAOD.cxx.

                                             {
  return this->applySystematicVariation(m_defaultSyst);
}

setBoolProperty()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 877 of file SUSYObjDef_xAOD.cxx.

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

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

                                                                                                                                                                           {
    double weight = 0.;
    if ( btagSelTool->getTaggerWeight(input, weight, false/*useVetoWP=false*/) != CP::CorrectionCode::Ok ) {
      ATH_MSG_ERROR( btagSelTool->name() << ": could not retrieve b-tag weight (" << btagTagger << ")." );
      return StatusCode::FAILURE;
    }
    dec_btag_weight(input) = weight;
    ATH_MSG_DEBUG( btagSelTool->name() << " b-tag weight: " << weight );
 
    double btag_pb(-10), btag_pc(-10), btag_pu(-10), btag_ptau(-10);
    // following name change is needed given different name is used for GN2v00 in derivation and in CDI
    std::string actualTagger = btagTagger;
    if (btagTagger == "GN2v00LegacyWP" || btagTagger == "GN2v00NewAliasWP"){
      actualTagger = "GN2v00";
    }
    xAOD::BTaggingUtilities::getBTagging(input)->pb(actualTagger, btag_pb);
    xAOD::BTaggingUtilities::getBTagging(input)->pc(actualTagger, btag_pc);
    xAOD::BTaggingUtilities::getBTagging(input)->pu(actualTagger, btag_pu);
    xAOD::BTaggingUtilities::getBTagging(input)->pu(actualTagger, btag_ptau);
    dec_btag_pb(input) = btag_pb;
    dec_btag_pc(input) = btag_pc;
    dec_btag_pu(input) = btag_pu;
    dec_btag_ptau(input) = btag_ptau;
    ATH_MSG_DEBUG( btagSelTool->name() << " b-tag " << btagTagger << "-type pb:   " << btag_pb );
    ATH_MSG_DEBUG( btagSelTool->name() << " b-tag " << btagTagger << "-type pc:   " << btag_pc );
    ATH_MSG_DEBUG( btagSelTool->name() << " b-tag " << btagTagger << "-type pu:   " << btag_pu );
    ATH_MSG_DEBUG( btagSelTool->name() << " b-tag " << btagTagger << "-type ptau: " << btag_ptau );
    // backwards compatibility
    if ( btagSelTool->name().find("DL1")!=std::string::npos ) {
       dec_btag_dl1pb(input) = btag_pb;
       dec_btag_dl1pc(input) = btag_pc;
       dec_btag_dl1pu(input) = btag_pu;
    }
    else {
       dec_btag_dl1pb(input) = -10;
       dec_btag_dl1pc(input) = -10;
       dec_btag_dl1pu(input) = -10;
    }
    return StatusCode::SUCCESS;
  }

setDataSource()

void ST::SUSYObjDef_xAOD::setDataSource

(

int

source

)

Definition at line 1205 of file SUSYObjDef_xAOD.cxx.

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

setUseIncidents()

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

inlineprotectedinherited

Definition at line 132 of file AsgMetadataTool.h.

   {
      m_useIncidents = flag;
   }

split()

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

protected

Definition at line 1805 of file SUSYObjDef_xAOD.cxx.

                                                                                                  {
  assert(delim.length() == 1);
  std::vector<std::string> retval;
  retval.reserve(std::count(s.begin(), s.end(), delim[0]) + 1);
  // if only 1
  if (s.find(delim)==std::string::npos) {
     retval.emplace_back(s);
     return retval;
  }
  // if need to split
  size_t last = 0;
  size_t next = 0;
  bool gothere=false;
  while ((next = s.find(delim, last)) != std::string::npos) {
    retval.emplace_back(s.substr(last, next - last));
    last = next + delim.length();
    gothere=true;
  }
  if(gothere)
    retval.emplace_back(s.substr(last));
 
  return retval;
}

SUSYToolsInit()

StatusCode SUSYObjDef_xAOD::SUSYToolsInit ( )

private

Definition at line 113 of file SUSYToolsInit.cxx.

{
  if (m_dataSource < 0) {
    ATH_MSG_FATAL("Data source incorrectly configured!!");
    ATH_MSG_FATAL("You must set the DataSource property to Data, FullSim or AtlfastII !!");
    ATH_MSG_FATAL("Expect segfaults if you're not checking status codes, which you should be !!");
    return StatusCode::FAILURE;
  }
 
  if (m_subtool_init) {
    ATH_MSG_INFO("SUSYTools subtools already created. Ignoring this call.");
    ATH_MSG_INFO("Note: No longer necessary to explicitly call SUSYToolsInit. Will avoid creating tools again.");
    return StatusCode::SUCCESS;
  }
 
  // /////////////////////////////////////////////////////////////////////////////////////////
  // Initialise PileupReweighting Tool
 
  if (!m_prwTool.isUserConfigured()) {
    ATH_MSG_DEBUG("Will now init the PRW tool");
    std::vector<std::string> file_conf;
    for (UInt_t i = 0; i < m_prwConfFiles.size(); i++) {
      ATH_MSG_INFO("Adding PRW file: " << m_prwConfFiles.at(i));
      file_conf.push_back(m_prwConfFiles.at(i));
    }
 
    std::vector<std::string> file_ilumi;
    for (UInt_t i = 0; i < m_prwLcalcFiles.size(); i++) {
      ATH_MSG_INFO("Adding ilumicalc file: " << m_prwLcalcFiles.at(i));
      file_ilumi.push_back(m_prwLcalcFiles.at(i));
    }
 
    m_prwTool.setTypeAndName("CP::PileupReweightingTool/PrwTool");
    ATH_CHECK( m_prwTool.setProperty("ConfigFiles", file_conf) );
    ATH_CHECK( m_prwTool.setProperty("LumiCalcFiles", file_ilumi) );
    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
    ATH_CHECK( m_prwTool.setProperty("DataScaleFactorUP",   m_prwDataSF_UP) ); // 1. -> old value (mc15), as the one for mc16 is still missing
    ATH_CHECK( m_prwTool.setProperty("DataScaleFactorDOWN", m_prwDataSF_DW) ); // 1./1.18 -> old value (mc15), as the one for mc16 is still missing
    ATH_CHECK( m_prwTool.setProperty("TrigDecisionTool", m_trigDecTool.getHandle()) );
    ATH_CHECK( m_prwTool.setProperty("UseRunDependentPrescaleWeight", m_runDepPrescaleWeightPRW) );
    ATH_CHECK( m_prwTool.setProperty("OutputLevel", MSG::WARNING) );
    ATH_CHECK( m_prwTool.retrieve() );
  } else {
    ATH_MSG_INFO("Using user-configured PRW tool");
    ATH_CHECK( m_prwTool.retrieve() );
  }
 
  // Initialize LRT systematics tool
  if (!m_LRTuncTool.isUserConfigured() && !isData())
  {
    ATH_MSG_INFO("Initializing LRT uncertainty tool");
    m_LRTuncTool.setTypeAndName("InDet::InclusiveTrackFilterTool/LRTUncTool");    
    ATH_CHECK( m_LRTuncTool.setProperty("Seed", 1) );
    if (m_isRun3) {
      if (m_mcCampaign == "mc23d" || m_mcCampaign == "mc23e")
        ATH_MSG_WARNING("Please note that current ID recommendations only cover mc23a and not (yet) mc23d/e!");
      ATH_CHECK( m_LRTuncTool.setProperty("calibFileLRTEff", "InDetTrackSystematicsTools/CalibData_25.2_2025-v00/LargeD0TrackingRecommendations_mc23a.root") );
    }
    else
      ATH_CHECK( m_LRTuncTool.setProperty("calibFileLRTEff", "InDetTrackSystematicsTools/CalibData_24.0_2023-v00/LargeD0TrackingRecommendations_20230824.root") );
    ATH_CHECK(m_LRTuncTool.retrieve());
  } else {
    ATH_MSG_INFO("Using user-configured LRT uncertainty tool");
    ATH_CHECK(m_LRTuncTool.retrieve());
  }
 
  std::string toolName; // to be used for tool init below, keeping explicit string constants a minimum /CO
 
  std::string jetname,jetcoll,fatjetcoll;
  if (m_slices["jet"]) {
    // Initialise jet calibration tool
 
    // pick the right config file for the JES tool : https://twiki.cern.ch/twiki/bin/view/AtlasProtected/ApplyJetCalibrationR22
    jetname = "AntiKt4" + xAOD::JetInput::typeName(xAOD::JetInput::Type(m_jetInputType));
    jetcoll = jetname + "Jets";
 
    if (!m_jetCalibTool.isUserConfigured()) {
      toolName = "JetCalibTool_" + jetname;
      m_jetCalibTool.setTypeAndName("JetCalibrationTool/"+toolName);
      std::string JES_config_file, calibseq;
 
      if (m_jetInputType != xAOD::JetInput::EMPFlow) {
        ATH_MSG_ERROR("Unknown (unsupported) jet collection is used, (m_jetInputType = " << m_jetInputType << ")");
        return StatusCode::FAILURE;
      }
 
      std::string JESconfig = isAtlfast() ? m_jesConfigAFII : m_jesConfig;
      if(isAtlfast() && m_isRun3) {
        ATH_MSG_WARNING("Jet JES/JER recommendations currently not available for fast sim in Run 3, falling back to full sim version");
        JESconfig = m_jesConfig;
      }
 
      calibseq = m_jesCalibSeq;
      JES_config_file = JESconfig;
 
      // remove Insitu if it's in the string if not data
      if (!isData()) {
        std::string insitu("_Insitu");
        auto found = calibseq.find(insitu);
        if(found != std::string::npos){
          calibseq.erase(found, insitu.length());
        }
      }
 
      // JMS calibration (if requested)
      if (m_JMScalib){
          ATH_MSG_ERROR("JMS calibration is not supported yet for R22. Please modify your settings.");
          return StatusCode::FAILURE;
        }
 
      // now instantiate the tool
      ATH_CHECK( m_jetCalibTool.setProperty("JetCollection", jetname) );
      ATH_CHECK( m_jetCalibTool.setProperty("ConfigFile", JES_config_file) );
      ATH_CHECK( m_jetCalibTool.setProperty("CalibSequence", calibseq) );
      ATH_CHECK( m_jetCalibTool.setProperty("CalibArea", m_jesCalibArea) );
      ATH_CHECK( m_jetCalibTool.setProperty("IsData", isData()) );
      ATH_CHECK( m_jetCalibTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_jetCalibTool.retrieve() );
    } else ATH_CHECK(m_jetCalibTool.retrieve());
  }
 
  if (m_slices["fjet"]) {
    //same for fat groomed jets
    fatjetcoll = m_fatJets;
 
    if(fatjetcoll == "AnalysisLargeRJets") {
      ATH_MSG_DEBUG("Fall back to calibration for AntiKt10UFOCSSKSoftDropBeta100Zcut10Jets, original name for AnalysisLargeRJets");
      fatjetcoll = "AntiKt10UFOCSSKSoftDropBeta100Zcut10Jets";
    }
    if (fatjetcoll.size()>3)fatjetcoll.erase(fatjetcoll.size()-4,4);
    if (!m_jetFatCalibTool.isUserConfigured() && !m_fatJets.empty()) {
      toolName = "JetFatCalibTool_" + m_fatJets;
      m_jetFatCalibTool.setTypeAndName("JetCalibrationTool/"+toolName);
 
      std::string jesConfigFat = m_jesConfigFat;
      std::string jesCalibSeqFat = m_jesCalibSeqFat;
      // add Insitu if data
      if(isData()) jesCalibSeqFat += "_Insitu";
 
      // now instantiate the tool
      ATH_CHECK( m_jetFatCalibTool.setProperty("JetCollection", fatjetcoll) );
      ATH_CHECK( m_jetFatCalibTool.setProperty("ConfigFile", jesConfigFat) );
      ATH_CHECK( m_jetFatCalibTool.setProperty("CalibSequence", jesCalibSeqFat) );
      // always set to false : https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/ApplyJetCalibrationR21
      ATH_CHECK( m_jetFatCalibTool.setProperty("IsData", isData()) );
      ATH_CHECK( m_jetFatCalibTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_jetFatCalibTool.retrieve() );
    } else if (m_jetFatCalibTool.isUserConfigured()) ATH_CHECK(m_jetFatCalibTool.retrieve());
  }
 
  if (m_slices["fjet"]) {
    // Initialise Boson taggers: https://twiki.cern.ch/twiki/bin/view/AtlasProtected/BoostedJetTaggingRecommendationFullRun2#Higgs_taggers
    if (!m_WTaggerTool.isUserConfigured() && !m_WtagConfig.empty()) {
      m_WTaggerTool.setTypeAndName("SmoothedWZTagger/WTagger");
      ATH_CHECK( m_WTaggerTool.setProperty("ContainerName", m_fatJets) );
      ATH_CHECK( m_WTaggerTool.setProperty("ConfigFile", m_WtagConfig) );
      ATH_CHECK( m_WTaggerTool.setProperty("CalibArea", m_WZTaggerCalibArea) );
      ATH_CHECK( m_WTaggerTool.setProperty("IsMC",!isData()));
      ATH_CHECK( m_WTaggerTool.setProperty("TruthBosonContainerName", "TruthBoson") );  // Set this if you are using a TRUTH3 style truth boson container;
      ATH_CHECK( m_WTaggerTool.setProperty("TruthTopQuarkContainerName", "TruthTop") );  // Set this if you are using a TRUTH3 style truth boson container;
#ifndef XAOD_STANDALONE
      ATH_CHECK( m_WTaggerTool.setProperty("SuppressOutputDependence", true) );
#endif
      ATH_CHECK( m_WTaggerTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_WTaggerTool.retrieve() );
 
      // Retrieving DecorationName (needed to access tagging results downstream):
      std::string WConfigPath = PathResolverFindCalibFile("BoostedJetTaggers/"+m_WZTaggerCalibArea+"/"+m_WtagConfig);
      if ( m_WconfigReader.ReadFile( WConfigPath.c_str(), EEnvLevel(0) ) ) {
        ATH_MSG_ERROR( "Error while reading large-R config file : " << WConfigPath );
        return StatusCode::FAILURE;
      }
      else ATH_MSG_DEBUG( "Successfully read large-R config file : " << WConfigPath );
 
      m_WDecorName = m_WconfigReader.GetValue("DecorationName" ,"");
      ANA_MSG_DEBUG( "Found DecorationName in large-R config file : " << m_WDecorName );
 
    } else if (m_WTaggerTool.isUserConfigured()) ATH_CHECK(m_WTaggerTool.retrieve());
 
    if (!m_ZTaggerTool.isUserConfigured() && !m_ZtagConfig.empty()) {
      m_ZTaggerTool.setTypeAndName("SmoothedWZTagger/ZTagger");
      ATH_CHECK( m_ZTaggerTool.setProperty("ContainerName", m_fatJets) );
      ATH_CHECK( m_ZTaggerTool.setProperty("ConfigFile", m_ZtagConfig) );
      ATH_CHECK( m_ZTaggerTool.setProperty("CalibArea", m_WZTaggerCalibArea) );
      ATH_CHECK( m_ZTaggerTool.setProperty("IsMC",!isData()));
      ATH_CHECK( m_ZTaggerTool.setProperty("TruthBosonContainerName", "TruthBoson") );  // Set this if you are using a TRUTH3 style truth boson container;
      ATH_CHECK( m_ZTaggerTool.setProperty("TruthTopQuarkContainerName", "TruthTop") );  // Set this if you are using a TRUTH3 style truth boson container;
#ifndef XAOD_STANDALONE
      ATH_CHECK( m_ZTaggerTool.setProperty("SuppressOutputDependence", true) );
#endif
      ATH_CHECK( m_ZTaggerTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_ZTaggerTool.retrieve() );
 
      // Retrieving DecorationName (needed to access tagging results downstream):
      std::string ZConfigPath = PathResolverFindCalibFile("BoostedJetTaggers/"+m_WZTaggerCalibArea+"/"+m_ZtagConfig);
      if ( m_ZconfigReader.ReadFile( ZConfigPath.c_str(), EEnvLevel(0) ) ) {
        ATH_MSG_ERROR( "Error while reading large-R config file : " << ZConfigPath );
        return StatusCode::FAILURE;
      }
      else ATH_MSG_DEBUG( "Successfully read large-R config file : " << ZConfigPath );
 
      m_ZDecorName = m_ZconfigReader.GetValue("DecorationName" ,"");
      ANA_MSG_DEBUG( "Found DecorationName in large-R config file : " << m_ZDecorName );
 
    } else if (m_ZTaggerTool.isUserConfigured()) ATH_CHECK(m_ZTaggerTool.retrieve());
 
    if (!m_TopTaggerTool.isUserConfigured() && !m_ToptagConfig.empty()) {
      m_TopTaggerTool.setTypeAndName("JSSWTopTaggerDNN/TopTagger");
      ATH_CHECK( m_TopTaggerTool.setProperty("ContainerName", m_fatJets) );
      ATH_CHECK( m_TopTaggerTool.setProperty("ConfigFile", m_ToptagConfig) );
      ATH_CHECK( m_TopTaggerTool.setProperty("CalibArea", m_TopTaggerCalibArea) );
      ATH_CHECK( m_TopTaggerTool.setProperty("IsMC",!isData()));
      ATH_CHECK( m_TopTaggerTool.setProperty("TruthBosonContainerName", "TruthBoson") );  // Set this if you are using a TRUTH3 style truth boson container;
      ATH_CHECK( m_TopTaggerTool.setProperty("TruthTopQuarkContainerName", "TruthTop") );  // Set this if you are using a TRUTH3 style truth boson container;
#ifndef XAOD_STANDALONE
      ATH_CHECK( m_TopTaggerTool.setProperty("SuppressOutputDependence", true) );
#endif
      ATH_CHECK( m_TopTaggerTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_TopTaggerTool.retrieve() );
 
      // Retrieving DecorationName (needed to access tagging results downstream):
      std::string TopConfigPath = PathResolverFindCalibFile("BoostedJetTaggers/"+m_TopTaggerCalibArea+"/"+m_ToptagConfig);
      if ( m_TopconfigReader.ReadFile( TopConfigPath.c_str(), EEnvLevel(0) ) ) {
        ATH_MSG_ERROR( "Error while reading large-R config file : " << TopConfigPath );
        return StatusCode::FAILURE;
      }
      else ATH_MSG_DEBUG( "Successfully read large-R config file : " << TopConfigPath );
 
      m_TopDecorName = m_TopconfigReader.GetValue("DecorationName" ,"");
      ANA_MSG_DEBUG( "Found DecorationName in large-R config file : " << m_TopDecorName );
 
    } else if (m_TopTaggerTool.isUserConfigured()) ATH_CHECK(m_TopTaggerTool.retrieve());
 
    // Initialise JetTruthLabelingTool: https://twiki.cern.ch/twiki/bin/view/AtlasProtected/JetUncertaintiesRel21Summer2019LargeR#AnalysisBase_21_2_114_and_newer
    if(!isData()) {
      m_label_truthKey = fatjetcoll+"."+m_JetTruthLabelName;
      ATH_CHECK(m_label_truthKey.initialize());
 
      if (!m_jetTruthLabelingTool.isUserConfigured()) {
    m_jetTruthLabelingTool.setTypeAndName("JetTruthLabelingTool/ST_JetTruthLabelingTool");
    ATH_CHECK( m_jetTruthLabelingTool.setProperty("RecoJetContainer", m_fatJets) );
    ATH_CHECK( m_jetTruthLabelingTool.setProperty("TruthLabelName", m_JetTruthLabelName) );
    ATH_CHECK( m_jetTruthLabelingTool.setProperty("UseTRUTH3", m_useTRUTH3) );                 // Set this to false only if you have the FULL !TruthParticles container in your input file
    ATH_CHECK( m_jetTruthLabelingTool.setProperty("TruthParticleContainerName", "TruthParticles") );
    ATH_CHECK( m_jetTruthLabelingTool.setProperty("TruthBosonContainerName", "TruthBoson") );  // Set this if you are using a TRUTH3 style truth boson container
    ATH_CHECK( m_jetTruthLabelingTool.setProperty("TruthTopQuarkContainerName", "TruthTop") ); // Set this if you are using a TRUTH3 style truth top quark container
    ATH_CHECK( m_jetTruthLabelingTool.setProperty("OutputLevel", this->msg().level()) );
    ATH_CHECK( m_jetTruthLabelingTool.retrieve() );
      } else if (m_jetTruthLabelingTool.isUserConfigured()) ATH_CHECK(m_jetTruthLabelingTool.retrieve());
    }
  }
 
  if (m_slices["jet"] || m_slices["fjet"]) {
 
 
    // Initialise jet uncertainty tool
    // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/JetUncertaintiesRel22
    ATH_MSG_INFO("Set up Jet Uncertainty tool...");
 
    // if not set, derive the MCType from the simulation type and MC campaign
    if (m_jetUncertaintiesMCType.empty()) m_jetUncertaintiesMCType = m_isRun3 ? (isAtlfast() ? "MC23AF3" : "MC23") : (isAtlfast() ? "AF3" : "MC20");
 
    // large-R jets use MC20AF3 instead of AF3
    m_fatJetUncertaintiesMCType = m_jetUncertaintiesMCType;
    if (m_fatJetUncertaintiesMCType == "AF3") {
        m_fatJetUncertaintiesMCType = "MC20AF3";
    }
 
    if (!m_jetUncertaintiesTool.isUserConfigured()) {
      std::string jetdef("AntiKt4" + xAOD::JetInput::typeName(xAOD::JetInput::Type(m_jetInputType)));
 
      if(jetdef !="AntiKt4EMPFlow"){
        ATH_MSG_WARNING("Jet Uncertaintes recommendations only exist for PFlow jets, falling back to AntiKt4EMPFlow");
        jetdef = "AntiKt4EMPFlow";
      }
      toolName = "JetUncertaintiesTool_" + jetdef;
 
      m_jetUncertaintiesTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
 
      ATH_CHECK( m_jetUncertaintiesTool.setProperty("JetDefinition", jetdef) );
      ATH_CHECK( m_jetUncertaintiesTool.setProperty("MCType", m_jetUncertaintiesMCType) );
      ATH_CHECK( m_jetUncertaintiesTool.setProperty("IsData", false) ); // Never use the PDSmearing for the nominal tool.
      ATH_CHECK( m_jetUncertaintiesTool.setProperty("ConfigFile", m_jetUncertaintiesConfig) );
      if(m_jetUncertaintiesAnalysisFile!="default") ATH_CHECK( m_jetUncertaintiesTool.setProperty("AnalysisFile", m_jetUncertaintiesAnalysisFile) );
      if (m_jetUncertaintiesCalibArea != "default") ATH_CHECK( m_jetUncertaintiesTool.setProperty("CalibArea", m_jetUncertaintiesCalibArea) );
      ATH_CHECK( m_jetUncertaintiesTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_jetUncertaintiesTool.retrieve() );
    } else  ATH_CHECK( m_jetUncertaintiesTool.retrieve() );
 
    ATH_MSG_INFO("Set up Jet PD Smear Uncertainty tool...");
 
    if (!m_jetUncertaintiesPDSmearTool.isUserConfigured() && m_jetUncertaintiesPDsmearing == true) {
      std::string jetdef("AntiKt4" + xAOD::JetInput::typeName(xAOD::JetInput::Type(m_jetInputType)));
 
      if(jetdef !="AntiKt4EMPFlow"){
        ATH_MSG_WARNING("Jet Uncertaintes recommendations only exist for PFlow jets, falling back to AntiKt4EMPFlow");
        jetdef = "AntiKt4EMPFlow";
      }
      toolName = "JetUncertaintiesPDSmearTool_" + jetdef;
 
      m_jetUncertaintiesPDSmearTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
 
      // 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.
      bool JERUncPDsmearing = isData() ? isData() : m_jetUncertaintiesPDsmearing;
      if (m_jetUncertaintiesConfig.find("SimpleJER") != std::string::npos && JERUncPDsmearing){
        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.");
        return StatusCode::FAILURE;
      }
      ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("JetDefinition", jetdef) );
      ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("MCType", m_jetUncertaintiesMCType) );
      ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("IsData", true) ); // Set to True by default for PDSmear-named tool.
      ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("PseudoDataJERsmearingMode", true) );
      ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("ConfigFile", m_jetUncertaintiesConfig) );
      if (m_jetUncertaintiesCalibArea != "default") ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("CalibArea", m_jetUncertaintiesCalibArea) );
      ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_jetUncertaintiesPDSmearTool.retrieve() );
    } else{
      ATH_MSG_DEBUG("Do not retrieve the jet PD Smearing tool if it is not configured");
      //ATH_CHECK( m_jetUncertaintiesPDSmearTool.retrieve() );
    }
  }
 
  if (m_slices["fjet"]) {
 
    // JetUncertaintiesTool handles JES, JER and JMS uncertainties for large-R jets
    if (!m_fatjetUncertaintiesTool.isUserConfigured() && !m_fatJets.empty() && !m_fatJetUncConfig.empty()) {
 
      ATH_MSG_INFO("Set up Large-R Jet Uncertainty tool...");
 
      // Print warning about missing large-R jets uncertainties for FastSim in mc23
      if (m_isRun3 && isAtlfast())
        ATH_MSG_WARNING("Uncertainties for large-R jets in mc23 and fast simulation not yet available; be aware uncertainties might be not complete!");
 
      toolName = "JetUncertaintiesTool_" + m_fatJets;
      m_fatjetUncertaintiesTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
 
      ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("JetDefinition", fatjetcoll) );
      ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("MCType", m_fatJetUncertaintiesMCType) );
      ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("IsData", isData()) );
      ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("ConfigFile", m_fatJetUncConfig) );
      if (m_jetUncertaintiesCalibArea != "default") ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("CalibArea", m_jetUncertaintiesCalibArea) );
 
      //Restrict variables to be shifted if (required)
      if( m_fatJetUncVars != "default" ){
        std::vector<std::string> shift_vars = {};
 
        std::string temp(m_fatJetUncVars);
        do {
          auto pos = temp.find(',');
          shift_vars.push_back(temp.substr(0, pos));
          if (pos == std::string::npos)
            temp = "";
          else
            temp = temp.substr(pos + 1);
 
        }
        while (!temp.empty() );
 
        ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("VariablesToShift", shift_vars) );
      }
 
      ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_fatjetUncertaintiesTool.retrieve() );
    } else if (m_fatjetUncertaintiesTool.isUserConfigured()) ATH_CHECK(m_fatjetUncertaintiesTool.retrieve());
 
 
    if (!m_fatjetUncertaintiesPDSmearTool.isUserConfigured() && !m_fatJets.empty() && !m_fatJetUncConfig.empty() && m_fatJetUncertaintiesPDsmearing == true) {
 
      ATH_MSG_INFO("Set up Jet PD Smear Uncertainty tool...");
 
      toolName = "JetUncertaintiesPDSmearTool_" + m_fatJets;
      m_fatjetUncertaintiesPDSmearTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
 
      // 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.
      bool JERUncPDsmearing = isData() ? isData() : m_fatJetUncertaintiesPDsmearing;
      if (m_fatJetUncConfig.find("SimpleJER") != std::string::npos && JERUncPDsmearing){
        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.");
        return StatusCode::FAILURE;
      }
      ATH_CHECK( m_fatjetUncertaintiesPDSmearTool.setProperty("JetDefinition", fatjetcoll) );
      ATH_CHECK( m_fatjetUncertaintiesPDSmearTool.setProperty("MCType", m_fatJetUncertaintiesMCType) );
      ATH_CHECK( m_fatjetUncertaintiesPDSmearTool.setProperty("IsData", true) ); // Set to True by default for PDSmear-named tool.
      ATH_CHECK( m_fatjetUncertaintiesPDSmearTool.setProperty("PseudoDataJERsmearingMode", true) );
      ATH_CHECK( m_fatjetUncertaintiesPDSmearTool.setProperty("ConfigFile", m_fatJetUncConfig) );
      if (m_jetUncertaintiesCalibArea != "default") ATH_CHECK( m_fatjetUncertaintiesPDSmearTool.setProperty("CalibArea", m_jetUncertaintiesCalibArea) );
      ATH_CHECK( m_fatjetUncertaintiesPDSmearTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_fatjetUncertaintiesPDSmearTool.retrieve() );
    } else{
      ATH_MSG_DEBUG("Do not retrieve the jet PD Smearing tool if it is not configured");
    }
 
 
    // FFSmearingTool handles JMR uncertainties for large-R jets
    if (!m_fatjetFFSmearingTool.isUserConfigured() && !m_fatJets.empty() && !m_fatJetUncConfig.empty()) {
 
      ATH_MSG_INFO("Set up Large-R FFJetSmearingTool ...");
 
      toolName = "FFJetSmearingTool_" + m_fatJets;
      m_fatjetFFSmearingTool.setTypeAndName("CP::FFJetSmearingTool/"+toolName);
 
      ATH_CHECK( m_fatjetFFSmearingTool.setProperty("MassDef", "UFO") );
      ATH_CHECK( m_fatjetFFSmearingTool.setProperty("MCType", m_fatJetUncertaintiesMCType) );
      ATH_CHECK( m_fatjetFFSmearingTool.setProperty("ConfigFile", "rel22/Spring2025_PreRec/R10_FullJMR.config") );
      ATH_CHECK( m_fatjetFFSmearingTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_fatjetFFSmearingTool.retrieve() );
    } else if (m_fatjetFFSmearingTool.isUserConfigured()) ATH_CHECK(m_fatjetFFSmearingTool.retrieve());
 
    // Need to keep track of systematics of FFJetSmearingTool
    if (!m_fatJets.empty()) {
      // m_fatjetFFSmearingSyst = CP::make_systematics_vector(m_fatjetFFSmearingTool->recommendedSystematics());
      ATH_MSG_INFO("The following uncertainties have been defined for the m_fatjetFFSmearingTool");
      for (auto & sysSet : m_fatjetFFSmearingTool->recommendedSystematics()){
        m_fatjetFFSmearingSyst.push_back(CP::SystematicSet({sysSet}));
        ATH_MSG_INFO("   - " << sysSet.name());
      }
    }
 
    ATH_MSG_INFO(" Won't initialise Wtagger uncertainty tool for fat jets until we get rec for UFO");
    // Won't initialise Wtagger uncertainty tool for fat jets until we get rec for UFO
    /*
    if (!m_WTagjetUncertaintiesTool.isUserConfigured() && !m_fatJets.empty() && !m_WtagConfig.empty() && !m_WTagUncConfig.empty()) {
 
      toolName = "WTagJetUncertaintiesTool_" + m_fatJets;
      m_WTagjetUncertaintiesTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
      ATH_CHECK( m_WTagjetUncertaintiesTool.setProperty("JetDefinition", fatjetcoll) );
      ATH_CHECK( m_WTagjetUncertaintiesTool.setProperty("MCType", "MC16") );
      ATH_CHECK( m_WTagjetUncertaintiesTool.setProperty("IsData", isData()) );
      ATH_CHECK( m_WTagjetUncertaintiesTool.setProperty("ConfigFile", "rel21/Fall2020/"+m_WTagUncConfig) );
      ATH_CHECK( m_WTagjetUncertaintiesTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_WTagjetUncertaintiesTool.retrieve() );
    } else if (m_WTagjetUncertaintiesTool.isUserConfigured()) ATH_CHECK(m_WTagjetUncertaintiesTool.retrieve());
    */
    ATH_MSG_INFO(" Won't initialise Ztagger uncertainty tool for fat jets until we get rec for UFO");
    // Won't initialise Ztagger uncertainty tool for fat jets until we get rec for UFO
    /*
    if (!m_ZTagjetUncertaintiesTool.isUserConfigured() && !m_fatJets.empty() && !m_ZtagConfig.empty() && !m_ZTagUncConfig.empty()) {
 
      toolName = "ZTagJetUncertaintiesTool_" + m_fatJets;
      m_ZTagjetUncertaintiesTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
      ATH_CHECK( m_ZTagjetUncertaintiesTool.setProperty("JetDefinition", fatjetcoll) );
      ATH_CHECK( m_ZTagjetUncertaintiesTool.setProperty("ConfigFile", "rel21/Fall2020/"+m_ZTagUncConfig) );
      ATH_CHECK( m_ZTagjetUncertaintiesTool.setProperty("MCType", "MC16") );
      ATH_CHECK( m_ZTagjetUncertaintiesTool.setProperty("IsData", isData()) );
      ATH_CHECK( m_ZTagjetUncertaintiesTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_ZTagjetUncertaintiesTool.retrieve() );
    } else if (m_ZTagjetUncertaintiesTool.isUserConfigured()) ATH_CHECK(m_ZTagjetUncertaintiesTool.retrieve());
    */
    ATH_MSG_INFO(" Won't initialise top-tagger uncertainty tool for fat jets until we get rec for UFO");
    // Won't initialise top-tagger uncertainty tool for fat jets until we get rec for UFO
    /*
    if (!m_TopTagjetUncertaintiesTool.isUserConfigured() && !m_fatJets.empty() && !m_ToptagConfig.empty() && !m_TopTagUncConfig.empty()) {
 
      toolName = "TopTagJetUncertaintiesTool_" + m_fatJets;
      m_TopTagjetUncertaintiesTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
      ATH_CHECK( m_TopTagjetUncertaintiesTool.setProperty("JetDefinition", fatjetcoll) );
      ATH_CHECK( m_TopTagjetUncertaintiesTool.setProperty("MCType", "MC16") );
      ATH_CHECK( m_TopTagjetUncertaintiesTool.setProperty("IsData", isData()) );
      ATH_CHECK( m_TopTagjetUncertaintiesTool.setProperty("ConfigFile", "rel21/Fall2020/"+m_TopTagUncConfig) );
      ATH_CHECK( m_TopTagjetUncertaintiesTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_TopTagjetUncertaintiesTool.retrieve() );
    } else if (m_TopTagjetUncertaintiesTool.isUserConfigured()) ATH_CHECK(m_TopTagjetUncertaintiesTool.retrieve());
    */
  }
 
 
  // tagger SF and uncertainties
  // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/BoostedJetTaggingRecommendationFullRun2
  // To be implemented here
 
  if (m_slices["jet"]) {
    // Initialise jet cleaning tools
 
    // see https://twiki.cern.ch/twiki/bin/view/AtlasProtected/HowToCleanJetsR22
    if (m_badJetCut!="" && !m_jetCleaningTool.isUserConfigured()) {
      toolName = "JetCleaningTool";
      m_jetCleaningTool.setTypeAndName("JetCleaningTool/"+toolName);
      ATH_CHECK( m_jetCleaningTool.setProperty("CutLevel", m_badJetCut) );
      ATH_CHECK( m_jetCleaningTool.setProperty("DoUgly", false) );
      ATH_CHECK( m_jetCleaningTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_jetCleaningTool.retrieve() );
    } else if (m_jetCleaningTool.isUserConfigured()) ATH_CHECK( m_jetCleaningTool.retrieve() );
 
    // Initialise jet pileup labeling tool (required for labels used by JvtEfficiencyTools)
 
    if(!m_jetPileupLabelingTool.isUserConfigured() && !isData()) {
      toolName = "PileupLabelingTool";
      m_jetPileupLabelingTool.setTypeAndName("JetPileupLabelingTool/"+toolName);
      ATH_CHECK( m_jetPileupLabelingTool.setProperty("RecoJetContainer", m_defaultJets) );
      ATH_CHECK( m_jetPileupLabelingTool.setProperty("TruthJetContainer", m_defaultTruthJets) );
  #ifndef XAOD_STANDALONE
      ATH_CHECK( m_jetPileupLabelingTool.setProperty("SuppressInputDependence", true) );
      ATH_CHECK( m_jetPileupLabelingTool.setProperty("SuppressOutputDependence", true) );
  #endif
      ATH_CHECK( m_jetPileupLabelingTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_jetPileupLabelingTool.retrieve() );  
    } else if (m_jetPileupLabelingTool.isUserConfigured()) ATH_CHECK( m_jetPileupLabelingTool.retrieve() );
 
    // Initialise jet Jvt moment tool
 
    if (!m_jetJvtMomentTool.isUserConfigured()) {
      toolName = "JvtMomentTool";
      m_jetJvtMomentTool.setTypeAndName("JetVertexTaggerTool/"+toolName);
      ATH_CHECK( m_jetJvtMomentTool.setProperty("JetContainer", m_defaultJets) );
  #ifndef XAOD_STANDALONE
      ATH_CHECK( m_jetJvtMomentTool.setProperty("SuppressInputDependence", true) );
      ATH_CHECK( m_jetJvtMomentTool.setProperty("SuppressOutputDependence", true) );
  #endif
      ATH_CHECK( m_jetJvtMomentTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_jetJvtMomentTool.retrieve() );
    } else if (m_jetJvtMomentTool.isUserConfigured()) ATH_CHECK( m_jetJvtMomentTool.retrieve() );
 
    // Initialise jet NNJvt moment tool
 
    m_applyJVTCut = !m_JvtWP.empty();
    if (!m_jetNNJvtMomentTool.isUserConfigured() && m_applyJVTCut) {
      toolName = "NNJvtMomentTool";
      m_jetNNJvtMomentTool.setTypeAndName("JetPileupTag::JetVertexNNTagger/"+toolName);
      ATH_CHECK( m_jetNNJvtMomentTool.setProperty("JetContainer", m_defaultJets) );
  #ifndef XAOD_STANDALONE
      ATH_CHECK( m_jetNNJvtMomentTool.setProperty("SuppressInputDependence", true) );
      ATH_CHECK( m_jetNNJvtMomentTool.setProperty("SuppressOutputDependence", true) );
  #endif
      ATH_CHECK( m_jetNNJvtMomentTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_jetNNJvtMomentTool.retrieve() );
    } else if (m_jetNNJvtMomentTool.isUserConfigured()) ATH_CHECK( m_jetNNJvtMomentTool.retrieve() );
 
    // Initialise jet NNJvt selection tool
 
    if (!m_jetNNJvtSelectionTool.isUserConfigured() && m_applyJVTCut) {
      toolName = "NNJvtSelectionTool";
      m_jetNNJvtSelectionTool.setTypeAndName("CP::NNJvtSelectionTool/"+toolName);
      ATH_CHECK( m_jetNNJvtSelectionTool.setProperty("JetContainer", m_defaultJets) );      
      ATH_CHECK( m_jetNNJvtSelectionTool.setProperty("WorkingPoint", m_JvtWP) );
      ATH_CHECK( m_jetNNJvtSelectionTool.setProperty("MaxPtForJvt", m_JvtPtMax) );
      ATH_CHECK( m_jetNNJvtSelectionTool.setProperty("JvtMomentName", "NNJvt") );
      ATH_CHECK( m_jetNNJvtSelectionTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_jetNNJvtSelectionTool.retrieve() );
    } else if (m_jetNNJvtSelectionTool.isUserConfigured()) ATH_CHECK( m_jetNNJvtSelectionTool.retrieve() );
 
    // Initialise jet NNJvt efficiency tool (scale factors)
 
    if (!m_jetNNJvtEfficiencyTool.isUserConfigured() && m_applyJVTCut) {
      toolName = "NNJvtEfficiencyTool";
      m_jetNNJvtEfficiencyTool.setTypeAndName("CP::NNJvtEfficiencyTool/"+toolName);
      ATH_CHECK( m_jetNNJvtEfficiencyTool.setProperty("JetContainer", m_defaultJets) );  
      ATH_CHECK( m_jetNNJvtEfficiencyTool.setProperty("WorkingPoint", m_JvtWP) );
      ATH_CHECK( m_jetNNJvtEfficiencyTool.setProperty("MaxPtForJvt", m_JvtPtMax) );
      ATH_CHECK( m_jetNNJvtEfficiencyTool.setProperty("SFFile", m_isRun3 ? m_JvtConfigRun3 : m_JvtConfigRun2) );
      ATH_CHECK( m_jetNNJvtEfficiencyTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_jetNNJvtEfficiencyTool.retrieve() );
    } else if (m_jetNNJvtEfficiencyTool.isUserConfigured()) ATH_CHECK( m_jetNNJvtEfficiencyTool.retrieve() );
 
    // Initialise jet fJvt selection tool
 
    if (!m_jetfJvtSelectionTool.isUserConfigured() && m_doFwdJVT) {
      toolName = "fJvtSelectionTool";
      m_jetfJvtSelectionTool.setTypeAndName("CP::FJvtSelectionTool/"+toolName);
      ATH_CHECK( m_jetfJvtSelectionTool.setProperty("JetContainer", m_defaultJets) );  
      ATH_CHECK( m_jetfJvtSelectionTool.setProperty("WorkingPoint", m_fJvtWP) );
      ATH_CHECK( m_jetfJvtSelectionTool.setProperty("MaxPtForJvt", m_fJvtPtMax) );
      ATH_CHECK( m_jetfJvtSelectionTool.setProperty("JvtMomentName", "DFCommonJets_fJvt") );
      ATH_CHECK( m_jetfJvtSelectionTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_jetfJvtSelectionTool.retrieve() );
    } else if (m_jetfJvtSelectionTool.isUserConfigured()) ATH_CHECK( m_jetfJvtSelectionTool.retrieve() );
 
    // Initialise jet fJvt efficiency tool for scale factors (scale factors)
 
    if (!m_jetfJvtEfficiencyTool.isUserConfigured() && m_doFwdJVT) {
      toolName = "fJvtEfficiencyTool";
      m_jetfJvtEfficiencyTool.setTypeAndName("CP::FJvtEfficiencyTool/"+toolName);
      ATH_CHECK( m_jetfJvtEfficiencyTool.setProperty("JetContainer", m_defaultJets) );  
      ATH_CHECK( m_jetfJvtEfficiencyTool.setProperty("WorkingPoint", m_fJvtWP) );
      ATH_CHECK( m_jetfJvtEfficiencyTool.setProperty("MaxPtForJvt", m_fJvtPtMax) );
      ATH_CHECK( m_jetfJvtEfficiencyTool.setProperty("SFFile", m_isRun3 ? m_fJvtConfigRun3 : m_fJvtConfigRun2) );
      ATH_CHECK( m_jetfJvtEfficiencyTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_jetfJvtEfficiencyTool.retrieve() );
    } else  ATH_CHECK( m_jetfJvtEfficiencyTool.retrieve() );
  }
 
 
  if (m_slices["mu"]) {
    // Check muon baseline ID
 
    std::string muQualBaseline = "";
    switch (m_muIdBaseline) {
    case xAOD::Muon::VeryLoose: muQualBaseline = "VeryLoose";
      ATH_MSG_WARNING("No muon scale factors are available for VeryLoose working point.");
      break;
    case xAOD::Muon::Loose:     muQualBaseline = "Loose";  break;
    case xAOD::Muon::Medium:    muQualBaseline = "Medium"; break;
    case xAOD::Muon::Tight:     muQualBaseline = "Tight";  break;
    case 4:                     muQualBaseline = "HighPt";  break;
    case 5:                     muQualBaseline = "LowPt";  break;
    case 6:                     muQualBaseline = "LowPtMVA"; break;
    case 7:                     muQualBaseline = "HighPt3Layers"; break;
    default:
      ATH_MSG_ERROR("Invalid muon working point provided: " << m_muIdBaseline << ". Cannot initialise!");
      return StatusCode::FAILURE;
      break;
    }
 
    // Initialise muon calibration tool
    // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/MuonMomentumCorrectionsSubgroup#CP_MuonCalibrationAndSmearingToo
    // Please not that for AthAnalysis we need to configure the MuonCalibTool within METSignificance manually and just can't pass the handle
    // Hence, any changes here should also be propagated to the METSignificance setup further below
 
    if (!m_muonCalibTool.isUserConfigured()) {
      m_muonCalibTool.setTypeAndName("CP::MuonCalibTool/ST_MuonCalibrationTool");
      if (m_isRun3) ATH_CHECK( m_muonCalibTool.setProperty("IsRun3Geo", true ));
      ATH_CHECK( m_muonCalibTool.setProperty("calibMode", m_muCalibrationMode) );
      ATH_CHECK( m_muonCalibTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_muonCalibTool.setProperty("release", "Recs2025_03_26_Run2Run3" ));
      int IdBaselineInt = m_muIdBaseline;
      if (IdBaselineInt == 4) {
        ATH_CHECK( m_muonCalibTool.setProperty("do2StationsHighPt", true) );
      }
      ATH_CHECK( m_muonCalibTool.setProperty("doExtraSmearing", m_muHighPtExtraSmear) );
      ATH_CHECK( m_muonCalibTool.retrieve() );
    } else  ATH_CHECK( m_muonCalibTool.retrieve() );
 
    // Initialise muon selection tool
 
    if (!m_muonSelectionToolBaseline.isUserConfigured()) {
      toolName = "MuonSelectionTool_Baseline_" + muQualBaseline;
      m_muonSelectionToolBaseline.setTypeAndName("CP::MuonSelectionTool/"+toolName);
      if (m_isRun3) ATH_CHECK( m_muonSelectionToolBaseline.setProperty("IsRun3Geo", true ));
 
      if (m_muBaselineEta<m_muEta){  // Test for inconsistent configuration
        ATH_MSG_ERROR( "Requested a baseline eta cut for muons (" << m_muBaselineEta <<
                       ") that is tighter than the signal cut (" << m_muEta << ").  Please check your config." );
        return StatusCode::FAILURE;
      }
      int IdBaselineInt = m_muIdBaseline;
      ATH_CHECK( m_muonSelectionToolBaseline.setProperty( "MaxEta", m_muBaselineEta) );
      if (IdBaselineInt == 6){
          ATH_CHECK( m_muonSelectionToolBaseline.setProperty( "MuQuality", 5 ) );
          ATH_CHECK( m_muonSelectionToolBaseline.setProperty( "UseMVALowPt", true));
      } else if (IdBaselineInt == 7){
          ATH_CHECK( m_muonSelectionToolBaseline.setProperty( "MuQuality", 4 ) );
          ATH_CHECK( m_muonSelectionToolBaseline.setProperty( "Use2stationMuonsHighPt", false));
      } else ATH_CHECK(m_muonSelectionToolBaseline.setProperty( "MuQuality", m_muIdBaseline ));
      ATH_CHECK( m_muonSelectionToolBaseline.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_muonSelectionToolBaseline.retrieve() );
    } else ATH_CHECK( m_muonSelectionToolBaseline.retrieve() );
 
 
    std::string muQual = "";
    switch (m_muId) {
    case xAOD::Muon::VeryLoose: muQual = "VeryLoose";
      ATH_MSG_WARNING("No muon scale factors are available for VeryLoose working point.");
      break;
    case xAOD::Muon::Loose:     muQual = "Loose";  break;
    case xAOD::Muon::Medium:    muQual = "Medium"; break;
    case xAOD::Muon::Tight:     muQual = "Tight";  break;
    case 4:                     muQual = "HighPt";  break;
    case 5:                     muQual = "LowPt";  break;
    case 6:                     muQual = "LowPtMVA"; break;
    case 7:                     muQual = "HighPt3Layers"; break;
    default:
      ATH_MSG_ERROR("Invalid muon working point provided: " << m_muId << ". Cannot initialise!");
      return StatusCode::FAILURE;
      break;
    }
 
    if (!m_muonSelectionTool.isUserConfigured()) {
      toolName = "MuonSelectionTool_" + muQual;
      m_muonSelectionTool.setTypeAndName("CP::MuonSelectionTool/"+toolName);
      if (m_isRun3) ATH_CHECK( m_muonSelectionTool.setProperty("IsRun3Geo", true ));
      ATH_CHECK( m_muonSelectionTool.setProperty( "MaxEta", m_muEta) );
      int IdInt = m_muId;
      if (IdInt == 6){
          ATH_CHECK( m_muonSelectionTool.setProperty( "MuQuality", 5 ) );
          ATH_CHECK( m_muonSelectionTool.setProperty( "UseMVALowPt", true));
      } else if (IdInt == 7){
          ATH_CHECK( m_muonSelectionTool.setProperty( "MuQuality", 4 ) );
          ATH_CHECK( m_muonSelectionTool.setProperty( "Use2stationMuonsHighPt", false));
      } else ATH_CHECK(m_muonSelectionTool.setProperty( "MuQuality", m_muId ));
      ATH_CHECK( m_muonSelectionTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_muonSelectionTool.retrieve() );
    } else ATH_CHECK( m_muonSelectionTool.retrieve() );
 
 
    if (!m_muonSelectionHighPtTool.isUserConfigured()) { //Fixed to HighPt WP
      toolName = "MuonSelectionHighPtTool_" + muQual;
      m_muonSelectionHighPtTool.setTypeAndName("CP::MuonSelectionTool/"+toolName);
      if (m_isRun3) ATH_CHECK( m_muonSelectionHighPtTool.setProperty("IsRun3Geo", true ));
      ATH_CHECK( m_muonSelectionHighPtTool.setProperty( "MaxEta", m_muEta) );
      ATH_CHECK( m_muonSelectionHighPtTool.setProperty( "MuQuality", 4 ) );
      ATH_CHECK( m_muonSelectionHighPtTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_muonSelectionHighPtTool.retrieve() );
    } else  ATH_CHECK( m_muonSelectionHighPtTool.retrieve() );
 
 
    // Initialise prompt/LRT muon OR tool
    if (!m_muonLRTORTool.isUserConfigured()) {
        toolName = "MuonLRTOverlapRemovalTool";
        m_muonLRTORTool.setTypeAndName("CP::MuonLRTOverlapRemovalTool/"+toolName);
        ATH_CHECK( m_muonLRTORTool.setProperty("overlapStrategy", CP::IMuonLRTOverlapRemovalTool::defaultStrategy) );
        if (m_isRun3) ATH_CHECK( m_muonLRTORTool.setProperty("UseRun3WP", true ));
        ATH_CHECK( m_muonLRTORTool.setProperty("OutputLevel", this->msg().level()) );
        ATH_CHECK( m_muonLRTORTool.retrieve() );
    } else ATH_CHECK( m_muonLRTORTool.retrieve() );
 
    // Initialise muon efficiency tools
    if (!m_muonEfficiencySFTool.isUserConfigured() && m_muId != xAOD::Muon::VeryLoose && !isData()) {
      toolName = "MuonEfficiencyScaleFactors_" + muQual;
      m_muonEfficiencySFTool.setTypeAndName("CP::MuonEfficiencyScaleFactors/"+toolName);
      ATH_CHECK( m_muonEfficiencySFTool.setProperty("WorkingPoint", muQual) );
      ATH_CHECK( m_muonEfficiencySFTool.setProperty("CalibrationRelease", m_isRun3? "250418_Preliminary_r24run3":"230213_Preliminary_r22run2") );
      ATH_CHECK( m_muonEfficiencySFTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_muonEfficiencySFTool.retrieve() );
    } else if (m_muonEfficiencySFTool.isUserConfigured()) ATH_CHECK( m_muonEfficiencySFTool.retrieve() );
 
 
    if (!m_muonEfficiencyBMHighPtSFTool.isUserConfigured() && !isData()){
      toolName = "MuonEfficiencyScaleFactorsBMHighPt_" + muQual;
      m_muonEfficiencyBMHighPtSFTool.setTypeAndName("CP::MuonEfficiencyScaleFactors/"+toolName);
      ATH_CHECK( m_muonEfficiencyBMHighPtSFTool.setProperty("WorkingPoint", "BadMuonVeto_HighPt") );
      ATH_CHECK( m_muonEfficiencyBMHighPtSFTool.setProperty("CalibrationRelease", m_isRun3? "220817_Preliminary_r22run3":"230213_Preliminary_r22run2") ); //BadMuonVeto_HighPt currently not available for 240711_Preliminary_r24run3
      ATH_CHECK( m_muonEfficiencyBMHighPtSFTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_muonEfficiencyBMHighPtSFTool.retrieve() );
    } else if (m_muonEfficiencyBMHighPtSFTool.isUserConfigured()) ATH_CHECK( m_muonEfficiencyBMHighPtSFTool.retrieve() );
 
 
    if (m_doTTVAsf && m_mud0sig<0 && m_muz0<0){
      ATH_MSG_WARNING("Requested TTVA SFs without d0sig and z0 cuts. Disabling scale factors as they will not make sense.");
      m_doTTVAsf=false;
    }
 
    if (m_doTTVAsf && !m_muonTTVAEfficiencySFTool.isUserConfigured() && !isData()) {
      toolName = "MuonTTVAEfficiencyScaleFactors";
      m_muonTTVAEfficiencySFTool.setTypeAndName("CP::MuonEfficiencyScaleFactors/"+toolName);
      ATH_CHECK( m_muonTTVAEfficiencySFTool.setProperty("WorkingPoint", "TTVA") );
      ATH_CHECK( m_muonTTVAEfficiencySFTool.setProperty("CalibrationRelease", m_isRun3? "250418_Preliminary_r24run3":"230213_Preliminary_r22run2") );
      ATH_CHECK( m_muonTTVAEfficiencySFTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_muonTTVAEfficiencySFTool.retrieve() );
    } else if (m_muonTTVAEfficiencySFTool.isUserConfigured()) ATH_CHECK( m_muonTTVAEfficiencySFTool.retrieve() );
 
 
 
    // Initialise muon isolation tool
    if (!m_muonIsolationSFTool.isUserConfigured() && !m_muIso_WP.empty() && !isData()) {
      toolName = "MuonIsolationScaleFactors_" + m_muIso_WP;
 
      std::string tmp_muIso_WP = m_muIso_WP;
      if ( !check_isOption(m_muIso_WP, m_mu_iso_support) ) { //check if supported
        ATH_MSG_WARNING("Your selected muon Iso WP ("
          << m_muIso_WP
          << ") does not have SFs defined. Will try to find an appropriate fall-back.");
        if (m_mu_iso_fallback.count(m_muIso_WP) > 0){
          tmp_muIso_WP = m_mu_iso_fallback[m_muIso_WP];
          ATH_MSG_WARNING("Your selected muon Iso WP ("
            << m_muIso_WP
            << " is not supported, and does not have SFs available.  Falling back to "
            << tmp_muIso_WP
            << " for SF determination.");
        } else {
          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! ***");
          return StatusCode::FAILURE;
        }
      }
 
      m_muonIsolationSFTool.setTypeAndName("CP::MuonEfficiencyScaleFactors/"+toolName);
      ATH_CHECK( m_muonIsolationSFTool.setProperty("WorkingPoint", tmp_muIso_WP + "Iso") );
      ATH_CHECK( m_muonIsolationSFTool.setProperty("CalibrationRelease", m_isRun3? "250418_Preliminary_r24run3":"230213_Preliminary_r22run2") );
      ATH_CHECK( m_muonIsolationSFTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_muonIsolationSFTool.retrieve() );
 
    } else if (m_muonIsolationSFTool.isUserConfigured()) ATH_CHECK( m_muonIsolationSFTool.retrieve() );
 
 
    if (!m_muonHighPtIsolationSFTool.isUserConfigured() && !m_muIsoHighPt_WP.empty() && !isData()) {
      toolName = "MuonHighPtIsolationScaleFactors_" + m_muIsoHighPt_WP;
 
      std::string tmp_muIsoHighPt_WP = m_muIsoHighPt_WP;
      if ( !check_isOption(m_muIsoHighPt_WP, m_mu_iso_support) ) { //check if supported
        ATH_MSG_WARNING("Your selected muon high-pt Iso WP ("
          << m_muIsoHighPt_WP
          << ") does not have SFs defined. Will try to find an appropriate fall-back.");
        if (m_mu_iso_fallback.count(m_muIsoHighPt_WP) > 0){
          tmp_muIsoHighPt_WP = m_mu_iso_fallback[m_muIsoHighPt_WP];
          ATH_MSG_WARNING("Your selected muon high-pt Iso WP ("
            << m_muIsoHighPt_WP
            << " is not supported, and does not have SFs available.  Falling back to "
            << tmp_muIsoHighPt_WP
            << " for SF determination.");
        } else {
          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! ***");
          return StatusCode::FAILURE;
        }
      }
 
      m_muonHighPtIsolationSFTool.setTypeAndName("CP::MuonEfficiencyScaleFactors/"+toolName);
      // Use for the low-pt WP a dedicated set of isolation scale-factors having an extra uncertainty in place
      ATH_CHECK( m_muonHighPtIsolationSFTool.setProperty("WorkingPoint", tmp_muIsoHighPt_WP + "Iso") );
      ATH_CHECK( m_muonHighPtIsolationSFTool.setProperty("CalibrationRelease", m_isRun3? "250418_Preliminary_r24run3":"230213_Preliminary_r22run2") );
      ATH_CHECK( m_muonHighPtIsolationSFTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_muonHighPtIsolationSFTool.retrieve() );
 
    } else if (m_muonHighPtIsolationSFTool.isUserConfigured()) ATH_CHECK( m_muonHighPtIsolationSFTool.retrieve() );
 
 
    // Initialise muon trigger scale factor tools
 
    if (!m_muonTriggerSFTool.isUserConfigured() && !isData()) {
      toolName = "MuonTriggerScaleFactors_" + muQual;
      m_muonTriggerSFTool.setTypeAndName("CP::MuonTriggerScaleFactors/"+toolName);
      if ( muQual=="LowPt" ) {
        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!");
        ATH_CHECK( m_muonTriggerSFTool.setProperty("MuonQuality", "Medium" ) );
      }
      else ATH_CHECK( m_muonTriggerSFTool.setProperty("MuonQuality", muQual) );
      //ATH_CHECK( m_muonTriggerSFTool.setProperty("Isolation", m_muIso_WP)); This property has been depreacted long time ago
      ATH_CHECK( m_muonTriggerSFTool.setProperty("AllowZeroSF", true) );
      ATH_CHECK( m_muonTriggerSFTool.setProperty("OutputLevel", this->msg().level()) );
      if(!m_muTriggerSFCalibRelease.empty() ) ATH_CHECK(  m_muonTriggerSFTool.setProperty("CalibrationRelease",m_muTriggerSFCalibRelease) );
      if(!m_muTriggerSFCalibFilename.empty()) ATH_CHECK(  m_muonTriggerSFTool.setProperty("filename",          m_muTriggerSFCalibFilename) );
      ATH_CHECK( m_muonTriggerSFTool.retrieve() );
      m_muonTrigSFTools.push_back(m_muonTriggerSFTool.getHandle());
    } else if (m_muonTriggerSFTool.isUserConfigured()) {
      ATH_CHECK( m_muonTriggerSFTool.retrieve() );
      m_muonTrigSFTools.push_back(m_muonTriggerSFTool.getHandle());
    }
  }
 
  if (m_slices["ele"]) {
    // /////////////////////////////////////////////////////////////////////////////////////////
    // Initialise electron selector tools
 
    // Signal Electrons
    if (!m_elecSelLikelihood.isUserConfigured()) {
      toolName = "EleSelLikelihood_" + m_eleId;
 
      if (m_eleId.find("DNN") != std::string::npos) {
        m_elecSelLikelihood.setTypeAndName("AsgElectronSelectorTool/"+toolName);
      }
      else {
        m_elecSelLikelihood.setTypeAndName("AsgElectronLikelihoodTool/"+toolName);
      }
 
      if (! m_eleConfig.empty() ){
        ATH_MSG_INFO("Overriding specified Ele.Id working point in favour of configuration file");
        ATH_CHECK( m_elecSelLikelihood.setProperty("ConfigFile", m_eleConfig) );
      } else if ( !check_isOption(m_eleId, m_el_id_support) ) { //check if supported
        ATH_MSG_ERROR("Invalid electron ID selected: " << m_eleId);
        return StatusCode::FAILURE;
      }
      else if (m_eleId == "VeryLooseLLH" || m_eleId == "LooseLLH") {
        ATH_MSG_WARNING(" ****************************************************************************");
        ATH_MSG_WARNING(" CAUTION: Setting " << m_eleId << " as signal electron ID");
        ATH_MSG_WARNING(" These may be used for loose electron CRs but no scale factors are provided.");
        ATH_MSG_WARNING(" ****************************************************************************");
        ATH_CHECK( m_elecSelLikelihood.setProperty("WorkingPoint", EG_WP(m_eleId) ));
      } else {
        ATH_CHECK( m_elecSelLikelihood.setProperty("WorkingPoint", EG_WP(m_eleId) ));
      }
 
      ATH_CHECK( m_elecSelLikelihood.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_elecSelLikelihood.retrieve() );
    } else  ATH_CHECK( m_elecSelLikelihood.retrieve() );
 
    // Baseline Electrons
    if (!m_elecSelLikelihoodBaseline.isUserConfigured()) {
      toolName = "EleSelLikelihoodBaseline_" + m_eleIdBaseline;
 
      if (m_eleIdBaseline.find("DNN") != std::string::npos) {
        m_elecSelLikelihoodBaseline.setTypeAndName("AsgElectronSelectorTool/"+toolName);
      }
      else {
        m_elecSelLikelihoodBaseline.setTypeAndName("AsgElectronLikelihoodTool/"+toolName);
      }
 
      if (! m_eleConfigBaseline.empty() ){
        ATH_MSG_INFO("Overriding specified EleBaseline.Id working point in favour of configuration file");
        ATH_CHECK( m_elecSelLikelihoodBaseline.setProperty("ConfigFile", m_eleConfigBaseline ));
      } else if ( !check_isOption(m_eleIdBaseline, m_el_id_support) ) { //check if supported
        ATH_MSG_ERROR("Invalid electron ID selected: " << m_eleIdBaseline);
        return StatusCode::FAILURE;
      } else {
        ATH_CHECK( m_elecSelLikelihoodBaseline.setProperty("WorkingPoint", EG_WP(m_eleIdBaseline)) );
      }
 
      ATH_CHECK( m_elecSelLikelihoodBaseline.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_elecSelLikelihoodBaseline.retrieve() );
    } else ATH_CHECK( m_elecSelLikelihoodBaseline.retrieve() );
  }
 
    // Initialise prompt/LRT electron OR tool
    if (!m_elecLRTORTool.isUserConfigured()) {
        toolName = "ElectronLRTOverlapRemovalTool";
        m_elecLRTORTool.setTypeAndName("CP::ElectronLRTOverlapRemovalTool/"+toolName);
        ATH_MSG_DEBUG("Setting ElectronLRTOverlapRemovalTool strategy to "<<m_eleLRT_strat);
        ATH_CHECK( m_elecLRTORTool.setProperty("overlapStrategy", m_eleLRT_strat) );
        ATH_CHECK( m_elecLRTORTool.retrieve() );
    } else ATH_CHECK( m_elecLRTORTool.retrieve() );
 
  if (m_slices["pho"]) {
    // /////////////////////////////////////////////////////////////////////////////////////////
    // Initialise photon selector tools
 
    if (!m_photonSelIsEM.isUserConfigured()) {
      toolName = "PhotonSelIsEM_" + m_photonId;
      m_photonSelIsEM.setTypeAndName("AsgPhotonIsEMSelector/"+toolName);
 
      if (!check_isOption(m_photonId, m_ph_id_support)){ //check if supported
        ATH_MSG_ERROR("Invalid photon ID selected: " << m_photonId);
        return StatusCode::FAILURE;
      }
 
      ATH_CHECK( m_photonSelIsEM.setProperty("WorkingPoint", m_photonId+"Photon") );
      ATH_CHECK( m_photonSelIsEM.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_photonSelIsEM.retrieve() );
    } else ATH_CHECK( m_photonSelIsEM.retrieve() );
 
    if (!m_photonSelIsEMBaseline.isUserConfigured()) {
      toolName = "PhotonSelIsEMBaseline_" + m_photonIdBaseline;
      m_photonSelIsEMBaseline.setTypeAndName("AsgPhotonIsEMSelector/"+toolName);
 
      if(!check_isOption(m_photonIdBaseline, m_ph_id_support)){ //check if supported
        ATH_MSG_ERROR("Invalid photon ID selected: " << m_photonIdBaseline);
        return StatusCode::FAILURE;
      }
 
      ATH_CHECK( m_photonSelIsEMBaseline.setProperty("WorkingPoint", m_photonIdBaseline+"Photon") );
      ATH_CHECK( m_photonSelIsEMBaseline.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_photonSelIsEMBaseline.retrieve() );
    } else  ATH_CHECK( m_photonSelIsEMBaseline.retrieve() );
  }
 
  if (m_slices["ele"]||m_slices["pho"]) {
    // Initialise DeadHVCellRemovalTool
    // https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/EGammaIdentificationRun2#Removal_of_Electron_Photon_clust
 
    ATH_MSG_DEBUG("Setup AsgDeadHVCellRemovalTool/deadHVTool");
    m_deadHVTool.setTypeAndName("AsgDeadHVCellRemovalTool/deadHVTool");
    ATH_CHECK(m_deadHVTool.retrieve());
  }
 
  if (m_slices["ele"]) {
    // Initialise electron efficiency tool
 
    PATCore::ParticleDataType::DataType data_type(PATCore::ParticleDataType::Data);
    if (!isData()) {
      if (isAtlfast()) data_type = PATCore::ParticleDataType::Fast;
      else data_type = PATCore::ParticleDataType::Full;
      ATH_MSG_DEBUG( "Setting data type to " << data_type);
    }
 
    m_eleEffMapFilePathRun2 = "ElectronEfficiencyCorrection/2015_2018/rel21.2/Precision_Summer2020_v1/map4.txt";
 
    if(!m_isRun3) {
      ATH_MSG_INFO( "Running on Run2 samples; Using egamma SF tools from R21 map ");
      ATH_MSG_INFO( m_eleEffMapFilePathRun2);
    }
 
    toolName = "AsgElectronEfficiencyCorrectionTool_reco";
    CONFIG_EG_EFF_TOOL_KEY(m_elecEfficiencySFTool_reco, toolName, "RecoKey", "Reconstruction", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2);
 
    //-- get KEYS supported by egamma SF tools
    std::vector<std::string> eSF_keys = getElSFkeys( m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2);
 
    if (m_eleId.find("NoPix") != std::string::npos || m_eleId == "VeryLooseLLH" || m_eleId == "LooseLLH" || m_eleId == "Medium") {
      ATH_MSG_WARNING("Not configuring electron ID and trigger scale factors for " << m_eleId);
    }
    else {
      // This needs to be formatted for the scale factors: no _Rel20, no LH label, etc.
      std::string eleId = TString(m_eleId).ReplaceAll("AndBLayer", "BLayer").ReplaceAll("LLH", "").Data();
 
      if (m_eleId.find("DNN") != std::string::npos) {
        eleId = TString(eleId).ReplaceAll("DNNnoCF", "").ReplaceAll("DNN", "").ReplaceAll("Loose", "LooseBLayer").Data();
        ATH_MSG_WARNING("Electron DNN ID working point " << m_eleId <<  " doesn't have SFs yet, fall back to " << eleId);
      }
 
      // electron id
      toolName = "AsgElectronEfficiencyCorrectionTool_id_" + m_eleId;
      CONFIG_EG_EFF_TOOL_KEY(m_elecEfficiencySFTool_id, toolName, "IdKey", eleId, m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2);
 
      // override map file use if correction file list is set for WP
      std::map<std::string,std::string> corrFNList;
      if ( !m_EG_corrFNList.empty() ) {
         for ( const auto& WP_fname : split( m_EG_corrFNList, "," ) ) {
            std::string WP = WP_fname.substr(0,WP_fname.find(":"));
            std::string fname = WP_fname.substr(WP_fname.find(":")+1);
            corrFNList[WP] = fname;
            ATH_MSG_WARNING( "Correction file list defined for WP " << WP << ": " << fname << "." );
            ATH_MSG_WARNING( "Will use correction file rather than central map file." );
         }
      }
 
      // electron iso
      std::string EleIso("");
      if (std::find(eSF_keys.begin(), eSF_keys.end(), eleId+"_"+m_eleIso_WP) != eSF_keys.end()){
        EleIso   = m_eleIso_WP;
      } else if (std::find(eSF_keys.begin(), eSF_keys.end(), eleId+"_"+m_el_iso_fallback[m_eleIso_WP]) != eSF_keys.end()){
        //--- Check to see if the only issue is an unknown isolation working point
        EleIso = m_el_iso_fallback[m_eleIso_WP];
        ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool_iso_*) Your selected electron Iso WP ("
          << m_eleIso_WP
          << ") does not have iso SFs defined. Falling back to "
          << m_el_iso_fallback[m_eleIso_WP]
          << " for SF calculations");
      }
      else{
        ATH_MSG_ERROR("***  THE ELECTRON ISOLATION SF YOU SELECTED (" << m_eleIso_WP << ") GOT NO SUPPORT ***");
        return StatusCode::FAILURE;
      }
 
      toolName = "AsgElectronEfficiencyCorrectionTool_iso_" + m_eleId + EleIso;
 
      // if running with correction file list
      if ( (!m_EG_corrFNList.empty()) && corrFNList.find(EleIso)!=corrFNList.end() ) {                // overriding central map file
        CONFIG_EG_EFF_TOOL( m_elecEfficiencySFTool_iso, toolName, corrFNList[EleIso] );
      }
      // can't do the iso tool via the macro, it needs two properties set
      else {                                                                                          // default: use map file
        if ( !m_elecEfficiencySFTool_iso.isUserConfigured() ) {
          if ( !check_isOption(EleIso, m_el_iso_support) ) { //check if supported
            ATH_MSG_WARNING( "(" << toolName << ") Your electron Iso WP: " << EleIso<< " is no longer supported. This will almost certainly cause a crash now.");
          }
 
          m_elecEfficiencySFTool_iso.setTypeAndName("AsgElectronEfficiencyCorrectionTool/"+toolName);
 
          if ( m_EG_corrFNList.empty() ) {
            ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
          } else {
            ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("CorrectionFileNameList", corrFNList) );
          }
          ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("IdKey", eleId) );
          ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("IsoKey", EleIso) );
          if (!isData() && ((EleIso.find("TightTrackOnly_VarRad")!=std::string::npos)||
                            (EleIso.find("TightTrackOnly_FixedRad")!=std::string::npos)||
                            (EleIso.find("Tight_VarRad")!=std::string::npos)||
                            (EleIso.find("Loose_VarRad")!=std::string::npos))) {
            if (isAtlfast()) ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool/"+toolName+"). Your selected electron Iso WP (" + EleIso + ") don't have AFII SF. Falling back to FullSim");
            ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("ForceDataType", static_cast<int>(PATCore::ParticleDataType::Full)));
          }
          else if (!isData()){
            ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("ForceDataType", static_cast<int>(data_type)));
          }
          ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("CorrelationModel", m_EG_corrModel) );
          ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("OutputLevel", this->msg().level()) );
          ATH_CHECK( m_elecEfficiencySFTool_iso.initialize() );
        } else ATH_CHECK( m_elecEfficiencySFTool_iso.initialize() );
      }
 
      // electron iso high-pt
      std::string EleIsohighPt("");
      if (std::find(eSF_keys.begin(), eSF_keys.end(), eleId+"_"+m_eleIsoHighPt_WP) != eSF_keys.end()){
        EleIsohighPt   = m_eleIsoHighPt_WP;
      } else if (std::find(eSF_keys.begin(), eSF_keys.end(), eleId+"_"+m_el_iso_fallback[m_eleIsoHighPt_WP]) != eSF_keys.end()){
        //--- Check to see if the only issue is an unknown isolation working point
        EleIsohighPt = m_el_iso_fallback[m_eleIsoHighPt_WP];
        ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool_iso_*) Your selected high-pT electron Iso WP ("
          << m_eleIsoHighPt_WP
          << ") does not have iso SFs defined. Falling back to "
          << m_el_iso_fallback[m_eleIsoHighPt_WP]
          << " for SF calculations");
      }
      else{
        ATH_MSG_ERROR("***  THE HIGH PT ELECTRON ISOLATION SF YOU SELECTED (" << m_eleIsoHighPt_WP << ") GOT NO SUPPORT");
        return StatusCode::FAILURE;
      }
 
      toolName = "AsgElectronEfficiencyCorrectionTool_isoHigPt_" + m_eleId + EleIsohighPt;
 
      // if running with correction file list
      if ( (!m_EG_corrFNList.empty()) && corrFNList.find(EleIsohighPt)!=corrFNList.end() ) {                // overriding central map file
        CONFIG_EG_EFF_TOOL( m_elecEfficiencySFTool_isoHighPt, toolName, corrFNList[EleIsohighPt] );
      }
      // can't do the iso tool via the macro, it needs two properties set
      else {                                                                                                     // default: use map file
        if ( !m_elecEfficiencySFTool_isoHighPt.isUserConfigured() ) {
 
          if ( !check_isOption(EleIsohighPt, m_el_iso_support) ) { //check if supported
            ATH_MSG_WARNING( "(" << toolName << ") Your electron high-pt Iso WP: " << EleIsohighPt << " is no longer supported. This will almost certainly cause a crash now.");
          }
 
          m_elecEfficiencySFTool_isoHighPt.setTypeAndName("AsgElectronEfficiencyCorrectionTool/"+toolName);
 
          ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
          ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.setProperty("IdKey", eleId) );
          ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.setProperty("IsoKey", EleIsohighPt) );
          if (!isData()) {
            ATH_CHECK (m_elecEfficiencySFTool_isoHighPt.setProperty("ForceDataType", (int) data_type) );
          }
          ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.setProperty("CorrelationModel", m_EG_corrModel) );
          ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.setProperty("OutputLevel", this->msg().level()) );
          ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.initialize() );
        } else   ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.initialize() );
      }
 
      // electron triggers - first SFs (but we need to massage the id string since all combinations are not supported)
  
      //single lepton
      
      if(m_isRun3 && eleId.find("LooseBLayer") != std::string::npos) ATH_MSG_WARNING("Replacing 'LooseBLayer' with 'Loose' for Electron ID while configuring single-ele trigger SF using: " << m_eleEffMapFilePath);
      std::string triggerEleID = m_isRun3? TString(eleId).ReplaceAll("LooseBLayer", "Loose").Data() : eleId;
      std::string triggerEleIso= m_eleIso_WP;
      
      // This is an hack to work with ElectronEfficiencyCorrection/2015_2025/rel22.2/2022_Summer_Prerecom_v1/map4.txt to allow 
 
      if(m_isRun3 && m_eleAllowRun3TrigSFFallback){
        bool pass_isRun3TrigSFFallback = true;
        if (triggerEleID.find("Medium") != std::string::npos && triggerEleIso.find("Loose") != std::string::npos)                {triggerEleID = "Loose";}
        else if (triggerEleID.find("Medium") != std::string::npos && triggerEleIso.find("Tight") != std::string::npos)           {triggerEleID = "Tight"; triggerEleIso = "Tight_VarRad";}
        else if (triggerEleID.find("Medium") != std::string::npos && triggerEleIso.find("HighPtCaloOnly") != std::string::npos)  {triggerEleID = "Tight"; triggerEleIso = "Tight_VarRad";}
        else if (triggerEleID.find("Tight")  != std::string::npos && triggerEleIso.find("Loose") != std::string::npos)           {triggerEleID = "Loose";}
        else if (triggerEleID.find("Tight")  != std::string::npos && triggerEleIso.find("Tight") != std::string::npos)           {triggerEleIso= "Tight_VarRad";}
        else if (triggerEleID.find("Tight")  != std::string::npos && triggerEleIso.find("HighPtCaloOnly") != std::string::npos)  {triggerEleID = "Tight"; triggerEleIso = "Tight_VarRad";}
        else if (triggerEleID.find("Loose")  != std::string::npos && triggerEleIso.find("Tight") != std::string::npos)           {triggerEleID = "Loose"; triggerEleIso = "Loose_VarRad";}
        else if (triggerEleID.find("Loose")  != std::string::npos && triggerEleIso.find("HighPtCaloOnly") != std::string::npos)  {triggerEleID = "Loose"; triggerEleIso = "Loose_VarRad";}
        else {pass_isRun3TrigSFFallback=false;}
        if(pass_isRun3TrigSFFallback){
          ATH_MSG_INFO(" ************** This is only for testing/studying purpose! ************** ");
          ATH_MSG_INFO(" ************** For official recommendation, please get in contact with the SUSY Bkg Forum ************** ");
          ATH_MSG_INFO("In the current map ("<<m_eleEffMapFilePath<<"), the only supported Electron ID working-points supported for Electron Trigger Scale Factor are 'Loose_Loose_VarRad' and 'Tight_Tight_VarRad' ");
          ATH_MSG_INFO("Only for single-lepton trigger scale factor, fall back to Electron ID:  -> "<< triggerEleID << " with Isolation: " << triggerEleIso);
        }
      }
      
      
      ATH_MSG_INFO("eSF_keys: " << m_electronTriggerSFStringSingle<< "_"<<triggerEleID<<"_"<<triggerEleIso);
 
      if (std::find(eSF_keys.begin(), eSF_keys.end(), m_electronTriggerSFStringSingle+"_"+triggerEleID+"_"+triggerEleIso) != eSF_keys.end()){
        triggerEleIso   = m_eleIso_WP;
      } else if (std::find(eSF_keys.begin(), eSF_keys.end(), m_electronTriggerSFStringSingle+"_"+triggerEleID+"_"+m_el_iso_fallback[triggerEleIso]) != eSF_keys.end()){
        //--- Check to see if the only issue is an unknown isolation working point
        triggerEleIso = m_el_iso_fallback[triggerEleIso];
        ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool_trig_singleLep_*) Your selected electron Iso WP ("
          << m_eleIso_WP
          << ") does not have trigger SFs defined. Falling back to "
          << triggerEleIso
          << " for SF calculations");
      }
      else{
        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 << ") ***");
        return StatusCode::FAILURE;
      }
  
      toolName = "AsgElectronEfficiencyCorrectionTool_trig_singleLep_" + triggerEleID;
      if ( !m_elecEfficiencySFTool_trig_singleLep.isUserConfigured() ) {
        m_elecEfficiencySFTool_trig_singleLep.setTypeAndName("AsgElectronEfficiencyCorrectionTool/"+toolName);
        ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
        ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("TriggerKey", m_electronTriggerSFStringSingle) );
        ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("IdKey", triggerEleID) );
        ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("IsoKey", triggerEleIso) );
        ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("CorrelationModel", m_EG_corrModel) );
        if (!isData()) {
          ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("ForceDataType", (int) (data_type==PATCore::ParticleDataType::Fast)? PATCore::ParticleDataType::Full : data_type) );
        }
        ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("OutputLevel", this->msg().level()) );
        ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.initialize() );
      } else ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.retrieve() );
      
  
      toolName = "AsgElectronEfficiencyCorrectionTool_trigEff_singleLep_" + triggerEleID;
      if ( !m_elecEfficiencySFTool_trigEff_singleLep.isUserConfigured() ) {
        m_elecEfficiencySFTool_trigEff_singleLep.setTypeAndName("AsgElectronEfficiencyCorrectionTool/"+toolName);
        ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
        ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("TriggerKey", "Eff_"+m_electronTriggerSFStringSingle) );
        ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("IdKey", triggerEleID) );
        ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("IsoKey", triggerEleIso) );
        ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("CorrelationModel", m_EG_corrModel) );
        if (!isData()) {
          ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("ForceDataType", (int) (data_type==PATCore::ParticleDataType::Fast)? PATCore::ParticleDataType::Full : data_type) );
        }
        ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("OutputLevel", this->msg().level()) );
        ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.initialize() );
      } else  ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.retrieve() );
    
      if (!m_isRun3){
        //mixed-leptons
        std::map<std::string,std::string> electronTriggerSFMapMixedLepton {
          // legs, Trigger keys, 
          {"e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose,e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0", m_electronTriggerSFStringSingle},
          {"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"},
          {"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"},
          {"e17_lhloose,e17_lhloose_nod0","MULTI_L_2015_e17_lhloose_2016_2018_e17_lhloose_nod0"},
          {"e12_lhloose,e12_lhloose_nod0","MULTI_L_2015_e12_lhloose_2016_2018_e12_lhloose_nod0"},
          {"e7_lhmedium,e7_lhmedium_nod0","MULTI_L_2015_e7_lhmedium_2016_2018_e7_lhmedium_nod0"},
          {"e9_lhloose,e9_lhloose_nod0,e12_lhvloose_nod0_L1EM10VH","TRI_E_2015_e9_lhloose_2016_e9_lhloose_nod0_2017_2018_e12_lhvloose_nod0_L1EM10VH"}
          
        };
        
        // 2e17 trigger is used in 2017 or 2018?
        std::string triglist_2017to2018 = m_trig2017combination_diLep + "_" + m_trig2018combination_diLep + "_" + m_trig2017combination_multiLep + "_" + m_trig2018combination_multiLep;
        if (triglist_2017to2018.find("2e17_lhvloose_nod0_L12EM15VHI") != std::string::npos) { 
          electronTriggerSFMapMixedLepton["e17_lhvloose_nod0_L1EM15VHI"] = "DI_E_2015_e12_lhloose_L1EM10VH_2016_e17_lhvloose_nod0_2017_2018_e17_lhvloose_nod0_L1EM15VHI";
        }
    
        std::string triggerMixedEleIso("");
    
        for(auto const& item : electronTriggerSFMapMixedLepton){
    
          if (std::find(eSF_keys.begin(), eSF_keys.end(), item.second+"_"+eleId+"_"+m_eleIso_WP) != eSF_keys.end()){
            triggerMixedEleIso = m_eleIso_WP;
          } else if (std::find(eSF_keys.begin(), eSF_keys.end(), item.second+"_"+eleId+"_"+m_el_iso_fallback[m_eleIso_WP]) != eSF_keys.end()){
            //--- Check to see if the only issue is an unknown isolation working point
            triggerMixedEleIso = m_el_iso_fallback[m_eleIso_WP];
            ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool_trig_mixLep_*) Your selected electron Iso WP ("
              << m_eleIso_WP
              << ") does not have trigger SFs defined. Falling back to "
              << triggerMixedEleIso
              << " for SF calculations");
          } else {
            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! ***");
            return StatusCode::FAILURE;
          }
    
          ATH_MSG_VERBOSE ("Selected WP: " << item.second << "_" << eleId << "_" << triggerMixedEleIso);
    
          toolName = "AsgElectronEfficiencyCorrectionTool_trig_mixLep_" + (item.first).substr(0,8) + m_eleId;
          auto t_sf = m_elecEfficiencySFTool_trig_mixLep.emplace(m_elecEfficiencySFTool_trig_mixLep.end(), "AsgElectronEfficiencyCorrectionTool/"+toolName);
          ATH_CHECK( t_sf->setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
          ATH_CHECK( t_sf->setProperty("TriggerKey", item.second) );
          ATH_CHECK( t_sf->setProperty("IdKey", eleId) );
          ATH_CHECK( t_sf->setProperty("IsoKey", triggerMixedEleIso) );
          ATH_CHECK( t_sf->setProperty("CorrelationModel", m_EG_corrModel) );
          if (!isData()) {
            ATH_CHECK( t_sf->setProperty("ForceDataType", (int) (data_type==PATCore::ParticleDataType::Fast)? PATCore::ParticleDataType::Full : data_type) );
          }
          ATH_CHECK( t_sf->setProperty("OutputLevel", this->msg().level()) );
          ATH_CHECK( t_sf->initialize() );
          m_elecTrigSFTools.push_back(t_sf->getHandle());
          #ifndef XAOD_STANDALONE
            m_legsPerTool[toolName] = item.first;
          #else
            m_legsPerTool["ToolSvc."+toolName] = item.first;
          #endif
    
          toolName = "AsgElectronEfficiencyCorrectionTool_trigEff_mixLep_" + (item.first).substr(0,8) + m_eleId;
          auto t_eff = m_elecEfficiencySFTool_trigEff_mixLep.emplace(m_elecEfficiencySFTool_trigEff_mixLep.end(), "AsgElectronEfficiencyCorrectionTool/"+toolName);
          ATH_CHECK( t_eff->setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
          ATH_CHECK( t_eff->setProperty("TriggerKey", "Eff_"+item.second) );
          ATH_CHECK( t_eff->setProperty("IdKey", eleId) );
          ATH_CHECK( t_eff->setProperty("IsoKey", triggerMixedEleIso) );
          ATH_CHECK( t_eff->setProperty("CorrelationModel", m_EG_corrModel) );
          if (!isData()) {
            ATH_CHECK( t_eff->setProperty("ForceDataType", (int) (data_type==PATCore::ParticleDataType::Fast)? PATCore::ParticleDataType::Full : data_type) );
          }
          ATH_CHECK( t_eff->setProperty("OutputLevel", this->msg().level()) );
          ATH_CHECK( t_eff->initialize() );
          m_elecTrigEffTools.push_back(t_eff->getHandle());
          #ifndef XAOD_STANDALONE
            m_legsPerTool[toolName] = item.first;
          #else
            m_legsPerTool["ToolSvc."+toolName] = item.first;
          #endif
    
        }
      }
      else ATH_MSG_WARNING("*** THE ELECTRON TRIGGER SF MIXED AND SF DILEP ARE CURRENTY NOT SUPPORTED IN RUN3 ***");
    
    ATH_MSG_WARNING("*** THE ELECTRON CHARGE FLIP SF ARE CURRENTY NOT SUPPORTED ***");
    // all the iinitialisation of the related tools have been cleaned up
 
  }
 
  if (m_slices["pho"]) {
    // /////////////////////////////////////////////////////////////////////////////////////////
    // Initialise photon efficiency tool
 
    if (!m_photonEfficiencySFTool.isUserConfigured() && !isData()) {
      m_photonEfficiencySFTool.setTypeAndName("AsgPhotonEfficiencyCorrectionTool/AsgPhotonEfficiencyCorrectionTool_" + m_photonId);
 
      if (m_photonId != "Tight" ) {
        ATH_MSG_WARNING( "No Photon efficiency available for " << m_photonId << ", using Tight instead..." );
      }
 
      ATH_CHECK( m_photonEfficiencySFTool.setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2025/rel22.2/2024_FinalRun2_Recommendation_v1/map1.txt") );
      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
      ATH_CHECK( m_photonEfficiencySFTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_photonEfficiencySFTool.retrieve() );
    } else if (m_photonEfficiencySFTool.isUserConfigured()) ATH_CHECK( m_photonEfficiencySFTool.retrieve() );
 
   if (!m_photonIsolationSFTool.isUserConfigured() && !isData()) {
     m_photonIsolationSFTool.setTypeAndName("AsgPhotonEfficiencyCorrectionTool/AsgPhotonEfficiencyCorrectionTool_isol" + m_photonIso_WP);
 
     if (m_photonIso_WP != "FixedCutTight" && m_photonIso_WP != "FixedCutLoose" && m_photonIso_WP != "TightCaloOnly") {
       ATH_MSG_WARNING( "No Photon efficiency available for " << m_photonIso_WP);
     }
 
     ATH_CHECK( m_photonIsolationSFTool.setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2025/rel22.2/2022_Summer_Prerecom_v1/map1.txt") );
     ATH_CHECK( m_photonIsolationSFTool.setProperty("IsoKey", m_photonIso_WP != "TightCaloOnly" ? m_photonIso_WP.substr(8) : m_photonIso_WP ));    // Set isolation WP: Loose,Tight,TightCaloOnly
     ATH_CHECK( m_photonIsolationSFTool.setProperty("ForceDataType", 1) ); // Set data type: 1 for FULLSIM, 3 for AF2
     ATH_CHECK( m_photonIsolationSFTool.setProperty("OutputLevel", this->msg().level()) );
     ATH_CHECK( m_photonIsolationSFTool.retrieve() );
   } else if (m_photonEfficiencySFTool.isUserConfigured()) ATH_CHECK( m_photonIsolationSFTool.retrieve() );
 
    // trigger scale factors
    if (!m_photonTriggerSFTool.isUserConfigured() && !isData()) {
      m_photonTriggerSFTool.setTypeAndName("AsgPhotonEfficiencyCorrectionTool/AsgPhotonEfficiencyCorrectionTool_trig" + m_photonTriggerName);
 
      // Fallback to TightCaloOnly if Tight is selected
      std::string photonIso_forTrigSF = m_photonIso_WP;
      if (m_photonIso_WP == "FixedCutTight") {
        ATH_MSG_WARNING( "No Photon trigger SF available for " << m_photonIso_WP << ", using TightCaloOnly instead... Use at your own risk" );
        photonIso_forTrigSF = "TightCaloOnly";
      } else { //  isolation WP supported: Loose or TightCaloOnly, removing "FixedCut" suffix..
        photonIso_forTrigSF = TString(m_photonIso_WP).ReplaceAll("FixedCut","").Data();
      }
 
      // "symmetric" diphoton triggers (year dependent)
      ATH_CHECK( m_photonTriggerSFTool.setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2018/rel21.2/Summer2020_Rec_v1/map3.txt") );
      ATH_CHECK( m_photonTriggerSFTool.setProperty("IsoKey", photonIso_forTrigSF ));    // Set isolation WP: Loose,TightCaloOnly
      ATH_CHECK( m_photonTriggerSFTool.setProperty("TriggerKey", m_photonTriggerName ));
      ATH_CHECK( m_photonTriggerSFTool.setProperty("ForceDataType", 1) ); // Set data type: 1 for FULLSIM, 3 for AF2
      ATH_CHECK( m_photonTriggerSFTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_photonTriggerSFTool.retrieve() );
 
      // "asymmetric" diphoton triggers
      std::map<std::string,std::string> diphotonTriggerSFMapAsymmetric {
        // legs, Trigger keys,
        {"g25_loose,g25_medium_L1EM20VH", "DI_PH_2015_g25_loose_2016_g25_loose_2017_g25_medium_L1EM20VH_2018_g25_medium_L1EM20VH"},
        {"g35_loose,g35_medium_L1EM20VH", "DI_PH_2015_g35_loose_2016_g35_loose_2017_g35_medium_L1EM20VH_2018_g35_medium_L1EM20VH"},
      };
 
      for(auto const& item : diphotonTriggerSFMapAsymmetric){
 
        toolName = "AsgPhotonEfficiencyCorrectionTool_trigSF_asymm_diphoton_" + (item.first).substr(0,9) + photonIso_forTrigSF;
        auto ph_trigSF = m_photonEfficiencySFTool_trigSF_AsymDiphoton.emplace(m_photonEfficiencySFTool_trigSF_AsymDiphoton.end(), "AsgPhotonEfficiencyCorrectionTool/"+toolName);
        ATH_CHECK( ph_trigSF->setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2018/rel21.2/Summer2020_Rec_v1/map3.txt") );
        ATH_CHECK( ph_trigSF->setProperty("IsoKey", photonIso_forTrigSF) );
        ATH_CHECK( ph_trigSF->setProperty("TriggerKey", item.second) );
        ATH_CHECK( ph_trigSF->setProperty("ForceDataType", 1) ); // Set DataType: 1 for FullSim and 3 for AFII
        ATH_CHECK( ph_trigSF->setProperty("OutputLevel", this->msg().level()) );
        ATH_CHECK( ph_trigSF->initialize() );
        m_photonTrigSFTools.push_back(ph_trigSF->getHandle());
        #ifndef XAOD_STANDALONE
          m_legsPerTool_ph[toolName] = item.first;
        #else
          m_legsPerTool_ph["ToolSvc."+toolName] = item.first;
        #endif
 
        toolName = "AsgPhotonEfficiencyCorrectionTool_trigEff_asymm_diphoton_" + (item.first).substr(0,9) + photonIso_forTrigSF;
        auto ph_trigEff = m_photonEfficiencySFTool_trigEff_AsymDiphoton.emplace(m_photonEfficiencySFTool_trigEff_AsymDiphoton.end(), "AsgPhotonEfficiencyCorrectionTool/"+toolName);
        ATH_CHECK( ph_trigEff->setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2018/rel21.2/Summer2020_Rec_v1/map3.txt") );
        ATH_CHECK( ph_trigEff->setProperty("IsoKey", photonIso_forTrigSF) );
        ATH_CHECK( ph_trigEff->setProperty("TriggerKey", "Eff_"+item.second) );
        ATH_CHECK( ph_trigEff->setProperty("ForceDataType", 1) ); // Set DataType: 1 for FullSim and 3 for AFII
        ATH_CHECK( ph_trigEff->setProperty("OutputLevel", this->msg().level()) );
        ATH_CHECK( ph_trigEff->initialize() );
        m_photonTrigEffTools.push_back(ph_trigEff->getHandle());
        #ifndef XAOD_STANDALONE
          m_legsPerTool_ph[toolName] = item.first;
        #else
          m_legsPerTool_ph["ToolSvc."+toolName] = item.first;
        #endif
 
        }
      }
    }
 
  }
  if (m_slices["ele"] || m_slices["pho"]) {
    // Initialize the EgammaAmbiguityTool
 
    if (!m_egammaAmbiguityTool.isUserConfigured()) {
      m_egammaAmbiguityTool.setTypeAndName("EGammaAmbiguityTool/EGammaAmbiguityTool");
      ATH_CHECK( m_egammaAmbiguityTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_egammaAmbiguityTool.retrieve() );
    } else ATH_CHECK( m_egammaAmbiguityTool.retrieve() );
  }
 
 
  if (m_slices["ele"]) {
    //disable ///////////////////////////////////////////////////////////////////////////////////////////
    //disable // Initialize the AsgElectronChargeIDSelector
 
    //disable if (!m_elecChargeIDSelectorTool.isUserConfigured()) {
 
    //disable   // For the selector, can use the nice function
    //disable   std::string eleId = EG_WP(m_eleId);
    //disable   m_elecChargeIDSelectorTool.setTypeAndName("AsgElectronChargeIDSelectorTool/ElectronChargeIDSelectorTool_"+eleId);
    //disable   //default cut value for https://twiki.cern.ch/twiki/bin/view/AtlasProtected/ElectronChargeFlipTaggerTool
    //disable   float BDTcut = -0.337671; // Loose 97%
    //disable   if (m_eleChID_WP != "Loose" && !m_eleChID_WP.empty()) {
    //disable     ATH_MSG_ERROR("Only Loose WP is supported in R21. Invalid ChargeIDSelector WP selected : " << m_eleChID_WP);
    //disable     return StatusCode::FAILURE;
    //disable   }
 
    //disable   ATH_CHECK( m_elecChargeIDSelectorTool.setProperty("TrainingFile", "ElectronPhotonSelectorTools/ChargeID/ECIDS_20180731rel21Summer2018.root"));
    //disable   ATH_CHECK( m_elecChargeIDSelectorTool.setProperty("CutOnBDT", BDTcut));
    //disable   ATH_CHECK( m_elecChargeIDSelectorTool.setProperty("OutputLevel", this->msg().level()) );
    //disable   ATH_CHECK( m_elecChargeIDSelectorTool.retrieve() );
    //disable } else  ATH_CHECK( m_elecChargeIDSelectorTool.retrieve() );
 
 
    // Initialise egamma calibration tool
 
    if (!m_egammaCalibTool.isUserConfigured()) {
      m_egammaCalibTool.setTypeAndName("CP::EgammaCalibrationAndSmearingTool/EgammaCalibrationAndSmearingTool");
      ATH_MSG_DEBUG( "Initialising EgcalibTool " );
      ATH_CHECK( m_egammaCalibTool.setProperty("ESModel", m_isRun3 ? "es2024_Run3_v0" : "es2023_R22_Run2_v1") );
      ATH_CHECK( m_egammaCalibTool.setProperty("decorrelationModel", "1NP_v1") );
      // allows to bypass (intended) abort from of egamma calibration tool when configured for fastSim
      if (m_eleForceFullSimCalib) {
        ATH_MSG_WARNING( "Forcing EgcalibTool to use calibrations for full simulation" );
        ATH_CHECK( m_egammaCalibTool.setProperty("useFastSim", false) );
      }
      else {
        ATH_MSG_INFO("is Fast Sim:" << isAtlfast());
        ATH_CHECK( m_egammaCalibTool.setProperty("useFastSim", isAtlfast() ? 1 : 0) );
      }
      ATH_CHECK( m_egammaCalibTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_egammaCalibTool.retrieve() );
    } else ATH_CHECK( m_egammaCalibTool.retrieve() );
  }
 
 
  if (m_slices["tau"]) {
 
    // Initialise path to tau config file and config reader
 
    std::string inputfile = "";
    if (!m_tauConfigPath.empty() && (m_tauConfigPath!="default")) inputfile = m_tauConfigPath;
    else if (m_tauId == "rnn001") inputfile = "SUSYTools/tau_selection_rnn001.conf";
    else if (m_tauId == "VeryLoose") inputfile = "SUSYTools/tau_selection_veryloose.conf";
    else if (m_tauId == "Loose") inputfile = "SUSYTools/tau_selection_loose.conf";
    else if (m_tauId == "Medium") inputfile = "SUSYTools/tau_selection_medium.conf";
    else if (m_tauId == "Tight") inputfile = "SUSYTools/tau_selection_tight.conf";
    else {
      ATH_MSG_ERROR("Invalid tau ID selected: " << m_tauId);
      return StatusCode::FAILURE;
    }
 
    // Read in the config file so we can retrieve the fields later when configuring the efficiency tools
    if ( m_tauConfigReader.ReadFile( PathResolverFindCalibFile(inputfile).c_str(), EEnvLevel(0) ) ) {
      ATH_MSG_ERROR( "Error while reading tau config file : " << inputfile );
      return StatusCode::FAILURE;
    }
    else ATH_MSG_DEBUG( "Successfully read tau config file : " << inputfile );
 
 
    // Initialise tau selection tools
 
    if (!m_tauSelTool.isUserConfigured()) {
      toolName = "TauSelectionTool_" + m_tauId;
      m_tauSelTool.setTypeAndName("TauAnalysisTools::TauSelectionTool/"+toolName);
      ATH_CHECK( m_tauSelTool.setProperty("ConfigPath", inputfile) );
      ATH_CHECK( m_tauSelTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_tauSelTool.retrieve() );
    } else  ATH_CHECK( m_tauSelTool.retrieve() );
 
 
    if (!m_tauSelToolBaseline.isUserConfigured()) {
      std::string inputfile = "";
      if (!m_tauConfigPathBaseline.empty() && (m_tauConfigPathBaseline!="default")) inputfile = m_tauConfigPathBaseline;
      else if (m_tauIdBaseline == "rnn001") inputfile = "SUSYTools/tau_selection_rnn001.conf";
      else if (m_tauIdBaseline == "VeryLoose") inputfile = "SUSYTools/tau_selection_veryloose.conf";
      else if (m_tauIdBaseline == "Loose") inputfile = "SUSYTools/tau_selection_loose.conf";
      else if (m_tauIdBaseline == "Medium") inputfile = "SUSYTools/tau_selection_medium.conf";
      else if (m_tauIdBaseline == "Tight") inputfile = "SUSYTools/tau_selection_tight.conf";
      else {
        ATH_MSG_ERROR("Invalid baseline tau ID selected: " << m_tauIdBaseline);
        return StatusCode::FAILURE;
      }
      toolName = "TauSelectionToolBaseline_" + m_tauIdBaseline;
      m_tauSelToolBaseline.setTypeAndName("TauAnalysisTools::TauSelectionTool/"+toolName);
      ATH_CHECK( m_tauSelToolBaseline.setProperty("ConfigPath", inputfile) );
 
      ATH_CHECK( m_tauSelToolBaseline.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_tauSelToolBaseline.retrieve() );
    } else  ATH_CHECK( m_tauSelToolBaseline.retrieve() );
 
 
    // Initialise tau efficiency tool
 
    if (!m_tauEffTool.isUserConfigured() && !isData()) {
      toolName = "TauEffTool_" + m_tauId;
      m_tauEffTool.setTypeAndName("TauAnalysisTools::TauEfficiencyCorrectionsTool/"+toolName);
 
      std::vector<int> correction_types;
      // Read out the tau ID from the config file and map into the enum from tau CP
      std::string jetIDWP = m_tauConfigReader.GetValue("JetIDWP" ,"");
      ANA_MSG_DEBUG( "Found JetIDWP in tau config file : " << jetIDWP );
      int jet_id_lvl;
      if (jetIDWP == "JETIDNONE") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDNONE;
      else if (jetIDWP == "JETIDRNNVERYLOOSE") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDRNNVERYLOOSE;
      else if (jetIDWP == "JETIDRNNLOOSE") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDRNNLOOSE;
      else if (jetIDWP == "JETIDRNNMEDIUM") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDRNNMEDIUM;
      else if (jetIDWP == "JETIDRNNTIGHT") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDRNNTIGHT;
      else {
        ATH_MSG_ERROR("Invalid Tau ID in tau config file " << jetIDWP);
        return StatusCode::FAILURE; 
      }
      // Add retrieval of reco and ID SFs
      correction_types.insert(correction_types.end(), {TauAnalysisTools::EfficiencyCorrectionType::SFRecoHadTau,
                                                       TauAnalysisTools::EfficiencyCorrectionType::SFJetIDHadTau});
 
      // Read out the (optional) Ele OR from the config file and map into the enum from tau CP
      std::string eleIDWP = m_tauConfigReader.GetValue("EleIDWP" ,"");
      ANA_MSG_DEBUG( "Found EleIDWP in tau config file : " << eleIDWP );
      int ele_id_lvl = -1;
      if (eleIDWP == "ELEIDRNNLOOSE") ele_id_lvl = (int)TauAnalysisTools::EleID::ELEIDRNNLOOSE;
      else if (eleIDWP == "ELEIDRNNMEDIUM") ele_id_lvl = (int)TauAnalysisTools::EleID::ELEIDRNNMEDIUM;
      else if (eleIDWP == "ELEIDRNNTIGHT") ele_id_lvl = (int)TauAnalysisTools::EleID::ELEIDRNNTIGHT;
      else {
        ATH_MSG_INFO("No or invalid Ele OR in tau config file " << eleIDWP << " will not apply SFs for electro veto" );
      }
      // Add retrieval of electron veto SFs if its applied
      if (ele_id_lvl != -1 )
        correction_types.insert(correction_types.end(), {TauAnalysisTools::EfficiencyCorrectionType::SFEleIDHadTau,
                                                         TauAnalysisTools::EfficiencyCorrectionType::SFEleIDElectron});
 
      ATH_CHECK( m_tauEffTool.setProperty("JetIDLevel", jet_id_lvl) );
      ATH_CHECK( m_tauEffTool.setProperty("EleIDLevel", ele_id_lvl) );
      ATH_CHECK( m_tauEffTool.setProperty("EfficiencyCorrectionTypes", correction_types) );
      ATH_CHECK( m_tauEffTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_tauEffTool.setProperty("useFastSim", isAtlfast()) );
      ATH_CHECK( m_tauEffTool.setProperty("RecommendationTag", m_tauEffToolRecommendationTag) );
      if (m_isRun3){ ATH_CHECK( m_tauEffTool.setProperty("Campaign", "mc23") );}
      else         { ATH_CHECK( m_tauEffTool.setProperty("Campaign", "mc20") );}
      ATH_CHECK( m_tauEffTool.retrieve() );
    } else if (m_tauEffTool.isUserConfigured()) ATH_CHECK( m_tauEffTool.retrieve() );
 
 
    // Initialise tau trigger efficiency tool(s)
 
    if (!isData()) {
      int iTauID = (int) TauAnalysisTools::JETIDNONEUNCONFIGURED;
      if (m_tauId == "rnn001")   iTauID = (int) TauAnalysisTools::JETIDNONE;
      else if (m_tauId == "VeryLoose")   iTauID = (int) TauAnalysisTools::JETIDRNNVERYLOOSE;
      else if (m_tauId == "Loose")  iTauID = (int) TauAnalysisTools::JETIDRNNLOOSE;
      else if (m_tauId == "Medium") iTauID = (int) TauAnalysisTools::JETIDRNNMEDIUM;
      else if (m_tauId == "Tight")  iTauID = (int) TauAnalysisTools::JETIDRNNTIGHT;
      else {
        ATH_MSG_ERROR("Invalid tau ID selected: " << m_tauId);
        return StatusCode::FAILURE;
      }
 
      // map format: SF file name, corresponding single-tau leg (comma-separated in case of OR)
      m_tau_trig_support = {
        {"HLT_tau25_medium1_tracktwo", "HLT_tau25_medium1_tracktwo"},
        {"HLT_tau35_medium1_tracktwo", "HLT_tau35_medium1_tracktwo"},
        {"HLT_tau50L1TAU12_medium1_tracktwo", "HLT_tau50_medium1_tracktwo_L1TAU12"},
        {"HLT_tau60_medium1_tracktwo", "HLT_tau60_medium1_tracktwo"},
        {"HLT_tau80L1TAU60_medium1_tracktwo", "HLT_tau80_medium1_tracktwo_L1TAU60"},
        {"HLT_tau125_medium1_tracktwo", "HLT_tau125_medium1_tracktwo"},
        {"HLT_tau160_medium1_tracktwo", "HLT_tau160_medium1_tracktwo"},
        {"HLT_tau160L1TAU100_medium1_tracktwo", "HLT_tau160_medium1_tracktwo_L1TAU100"},
        // whole 2018 data taking period
        {"HLT_tau25_medium1_tracktwoEF", "HLT_tau25_medium1_tracktwoEF"},
        {"HLT_tau35_medium1_tracktwoEF", "HLT_tau35_medium1_tracktwoEF"},
        {"HLT_tau60_medium1_tracktwoEF", "HLT_tau60_medium1_tracktwoEF"},
        {"HLT_tau80L1TAU60_medium1_tracktwoEF", "HLT_tau80_medium1_tracktwoEF_L1TAU60"},
        {"HLT_tau160L1TAU100_medium1_tracktwoEF", "HLT_tau160_medium1_tracktwoEF_L1TAU100"},
      };
 
      if (m_isRun3){
          m_tau_trig_support = {
            // 2022, 2023
            {"HLT_tau25_mediumRNN_tracktwoMVA", "HLT_tau25_mediumRNN_tracktwoMVA"},
            {"HLT_tau35_mediumRNN_tracktwoMVA", "HLT_tau35_mediumRNN_tracktwoMVA"},
            // 2022, 2023 75-1800 bunches
            {"HLT_tau160_mediumRNN_tracktwoMVA", "HLT_tau160_mediumRNN_tracktwoMVA_L1TAU100"},
            // 2023 from 400 bunches
            {"HLT_tau160_mediumRNN_tracktwoMVA", "HLT_tau160_mediumRNN_tracktwoMVA_L1eTAU140"}
          };
      }
 
      for(auto const& trigger : m_tau_trig_support) {
        toolName = "TauTrigEffTool_" + m_tauId + "_" + trigger.first;
        auto tau_trigSF = m_tauTrigEffTool.emplace(m_tauTrigEffTool.end(), "TauAnalysisTools::TauEfficiencyCorrectionsTool/"+toolName);
        ATH_CHECK( tau_trigSF->setProperty("EfficiencyCorrectionTypes", std::vector<int>({TauAnalysisTools::SFTriggerHadTau})) );
        ATH_CHECK( tau_trigSF->setProperty("TriggerName", trigger.first) );
        ATH_CHECK( tau_trigSF->setProperty("JetIDLevel", iTauID) );
        ATH_CHECK( tau_trigSF->setProperty("OutputLevel", this->msg().level()) );
        ATH_CHECK( tau_trigSF->setProperty("useFastSim", isAtlfast()) );
        ATH_CHECK( tau_trigSF->setProperty("RecommendationTag", m_tauEffToolRecommendationTag) );
        if (m_isRun3){ ATH_CHECK( tau_trigSF->setProperty("Campaign", m_mcCampaign) );}
        else         { ATH_CHECK( tau_trigSF->setProperty("Campaign", "mc20") );}
        ATH_CHECK( tau_trigSF->initialize() );
      }
    }
 
 
    // Initialise tau smearing tool
 
    if (!m_tauSmearingTool.isUserConfigured()) {
      m_tauSmearingTool.setTypeAndName("TauAnalysisTools::TauSmearingTool/TauSmearingTool");
      ATH_CHECK( m_tauSmearingTool.setProperty("RecommendationTag", m_tauSmearingToolRecommendationTag) );
      if (m_isRun3){ ATH_CHECK( m_tauSmearingTool.setProperty("Campaign", "mc23") );}
      else         { ATH_CHECK( m_tauSmearingTool.setProperty("Campaign", "mc20") );}
      ATH_CHECK( m_tauSmearingTool.setProperty("Generator", m_tauSmearingToolGenerator) );
      ATH_CHECK( m_tauSmearingTool.setProperty("MVATESQualityCheck", m_ApplyMVATESQualityCheck) );
      ATH_CHECK( m_tauSmearingTool.setProperty("useFastSim", isAtlfast()) );
      ATH_CHECK( m_tauSmearingTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_tauSmearingTool.retrieve() );
    } else ATH_CHECK( m_tauSmearingTool.retrieve() );
 
 
    // Initialise tau truth matching tool
 
    if (!m_tauTruthMatch.isUserConfigured() && m_tauDoTTM && !isData()) {
      m_tauTruthMatch.setTypeAndName("TauAnalysisTools::TauTruthMatchingTool/TauTruthMatch");
      ATH_CHECK( m_tauTruthMatch.setProperty("TruthJetContainerName", m_defaultTruthJets ) );
      ATH_CHECK( m_tauTruthMatch.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_tauTruthMatch.retrieve() );
    } else if (m_tauTruthMatch.isUserConfigured()) ATH_CHECK( m_tauTruthMatch.retrieve() );
 
 
  }
 
 
  if (m_slices["bjet"]) {
  // Initialise B-tagging tools
 
    // btagSelectionTool
    std::string jetcollBTag = jetcoll;
    if (jetcoll == "AntiKt4LCTopoJets") {
      ATH_MSG_WARNING("  *** HACK *** Treating LCTopoJets jets as EMTopo -- use at your own risk!");
      jetcollBTag = "AntiKt4EMTopoJets";
    }
 
    // print a warning if there is indication that the user supplied a CDI file not matching to the sample being processed
    // see --> https://twiki.cern.ch/twiki/bin/view/AtlasProtected/BTagRel22HighLevelSummary
    if( (m_bTaggingCalibrationFilePath.find(!m_isRun3 ? "MC20" : "MC23") == std::string::npos) && (m_bTaggingCalibrationFilePath.find(!m_isRun3 ? "MC20" : "MC21") == std::string::npos) ) {
      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"));
    }
 
    if (m_useBtagging && !m_btagSelTool.isUserConfigured() && !m_BtagWP.empty()) {
      if (jetcollBTag.find("AntiKt4EMTopoJets") == std::string::npos && jetcollBTag.find("AntiKt4EMPFlowJets")==std::string::npos) {
        ATH_MSG_WARNING("** Only AntiKt4EMTopoJets and AntiKt4EMPFlowJets are supported with FTAG scale factors!");
          return StatusCode::FAILURE;
      }
 
      toolName = "BTagSel_" + jetcollBTag + m_BtagTagger + m_BtagWP;
 
      m_btagSelTool.setTypeAndName("BTaggingSelectionTool/"+toolName);
      ATH_CHECK( m_btagSelTool.setProperty("TaggerName",     m_BtagTagger ) );
      ATH_CHECK( m_btagSelTool.setProperty("OperatingPoint", m_BtagWP  ) );
      ATH_CHECK( m_btagSelTool.setProperty("JetAuthor",      jetcollBTag   ) );
      ATH_CHECK( m_btagSelTool.setProperty("MinPt",          m_BtagMinPt   ) );
      ATH_CHECK( m_btagSelTool.setProperty("FlvTagCutDefinitionsFileName",  m_bTaggingCalibrationFilePath) );
      // Read from BTagging object. This will be needed until the input file is produced from
      // a derivation release that includes !80336.
      ATH_CHECK( m_btagSelTool.setProperty("readFromBTaggingObject", true ) );  
      ATH_CHECK( m_btagSelTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_btagSelTool.retrieve() );
    } else if (m_btagSelTool.isUserConfigured()) ATH_CHECK( m_btagSelTool.retrieve() );
 
 
    if (m_useBtagging && !m_btagSelTool_OR.isUserConfigured() && !m_orBtagWP.empty()) {
      if (jetcoll != "AntiKt4EMTopoJets" && jetcoll != "AntiKt4EMPFlowJets") {
        ATH_MSG_WARNING("** Only AntiKt4EMTopoJets and AntiKt4EMPFlowJets are supported with FTAG scale factors!");
          return StatusCode::FAILURE;
      }
 
      toolName = "BTagSelOR_" + jetcollBTag + m_orBtagWP;
      m_btagSelTool_OR.setTypeAndName("BTaggingSelectionTool/"+toolName);
      ATH_CHECK( m_btagSelTool_OR.setProperty("TaggerName",     m_BtagTagger  ) );
      ATH_CHECK( m_btagSelTool_OR.setProperty("OperatingPoint", m_orBtagWP  ) );
      ATH_CHECK( m_btagSelTool_OR.setProperty("JetAuthor",      jetcollBTag   ) );
      ATH_CHECK( m_btagSelTool_OR.setProperty("MinPt",          m_BtagMinPt   ) );
      ATH_CHECK( m_btagSelTool_OR.setProperty("FlvTagCutDefinitionsFileName",  m_bTaggingCalibrationFilePath) );
      // Read from BTagging object. This will be needed until the input file is produced from
      // a derivation release that includes !80336.
      ATH_CHECK( m_btagSelTool_OR.setProperty("readFromBTaggingObject", true ) );  
      ATH_CHECK( m_btagSelTool_OR.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_btagSelTool_OR.retrieve() );
    } else if (m_btagSelTool_OR.isUserConfigured()) ATH_CHECK( m_btagSelTool_OR.retrieve() );
 
 
    std::string trkjetcoll = m_defaultTrackJets;
    const std::string& BTagColl_TrkJet = trkjetcoll;
    if (m_slices["tjet"]) {
      if ( m_useBtagging_trkJet && m_defaultTrackJets.empty()) {
         m_useBtagging_trkJet = false;
         ATH_MSG_INFO("TrackJet collection set to None: disabling btagging for TrackJets.");
      }
 
      if (m_useBtagging_trkJet && !m_btagSelTool_trkJet.isUserConfigured() && !m_BtagWP_trkJet.empty()) {
        if (trkjetcoll.find("AntiKt2PV0TrackJets")==std::string::npos && trkjetcoll.find("AntiKtVR30Rmax4Rmin02TrackJets")==std::string::npos) {
          ATH_MSG_WARNING("** Only AntiKt2PV0TrackJets and AntiKtVR30Rmax4Rmin02TrackJets are supported with FTAG scale factors!");
            return StatusCode::FAILURE;
        }
 
        toolName = "BTagSel_" + trkjetcoll + m_BtagTagger_trkJet + m_BtagWP_trkJet;
 
        m_btagSelTool_trkJet.setTypeAndName("BTaggingSelectionTool/"+toolName);
        ATH_CHECK( m_btagSelTool_trkJet.setProperty("TaggerName",     m_BtagTagger_trkJet ) );
        ATH_CHECK( m_btagSelTool_trkJet.setProperty("OperatingPoint", m_BtagWP_trkJet  ) );
        ATH_CHECK( m_btagSelTool_trkJet.setProperty("MinPt",          m_BtagMinPt_trkJet  ) );
        ATH_CHECK( m_btagSelTool_trkJet.setProperty("JetAuthor",      BTagColl_TrkJet   ) );
        ATH_CHECK( m_btagSelTool_trkJet.setProperty("MinPt",          m_BtagMinPt_trkJet ) );
        ATH_CHECK( m_btagSelTool_trkJet.setProperty("FlvTagCutDefinitionsFileName",  m_bTaggingCalibrationFilePath) );
        // Read from BTagging object. This will be needed until the input file is produced from
        // a derivation release that includes !80336.
        ATH_CHECK( m_btagSelTool_trkJet.setProperty("readFromBTaggingObject", true ) );  
        ATH_CHECK( m_btagSelTool_trkJet.setProperty("OutputLevel", this->msg().level()) );
        ATH_CHECK( m_btagSelTool_trkJet.retrieve() );
      } else if (m_btagSelTool_trkJet.isUserConfigured()) ATH_CHECK( m_btagSelTool_trkJet.retrieve() );
    }
 
   // Set MCshowerType for FTAG MC/MC SFs
    // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/BTagCalibrationRecommendationsRelease21#MC_MC_Scale_Factors_for_Analysis
    std::string MCshowerID;
    if(m_showerType==-1){
        ATH_MSG_ERROR( "Error! m_showerType=-1, which is an error case for FTAG MC/MC SFs." );
        return StatusCode::FAILURE;
    }
    if(m_BtagTagger=="DL1dv01"){
      if(!m_isRun3){
        MCshowerID= "default";                             // Powheg+Pythia8 (410470)  - PhPy8EG_A14
        if (m_showerType == 1)      MCshowerID = "411233"; // PowhegHerwig7 
        else if (m_showerType == 2) MCshowerID = "600666"; // PhH7EG_H7UE - 601414
        else if (m_showerType == 3) MCshowerID = "410250"; // Sherpa_221
        else if (m_showerType == 4) MCshowerID = "700122"; // Sh_2210
        else if (m_showerType == 5) MCshowerID = "700122"; // Sh_2211
        else if (m_showerType == 6) MCshowerID = "700660"; // Sh_2212 - 700660
        else if (m_showerType == 7) MCshowerID = "410464"; // aMcAtNloPy8
        else if (m_showerType == 8) MCshowerID = "412116"; // aMcAtNloHerwig7
        else if (m_showerType != 0){
            ATH_MSG_WARNING("Unknown ShowerID detected! Using default FTAG MC-MC SFs (Powheg+Pythia8). Please check if these are applicable for this sample!");
        }
      }
      else{
        MCshowerID= "default";                              // Powheg+Pythia8 (601229)  - PhPy8EG_A14
        if (m_showerType == 2)      MCshowerID = "601414";  // POWHEG+Herwig721         - PhH7EG_A14
        else if (m_showerType == 6) MCshowerID = "700660";  // Sherpa 2.2.12            - Sh_2212
        else if (m_showerType != 0){
            ATH_MSG_WARNING("Unknown ShowerID detected! Using default FTAG MC-MC SFs (Powheg+Pythia8). Please check if these are applicable for this sample!");
        }
      }
    } else if (m_BtagTagger=="GN2v01"){
      if(!m_isRun3){
        MCshowerID= "default";                              // PowhegPythia8EvtGen (410470)
        if (m_showerType == 2) MCshowerID = "411233";  // POWHEGHERWIG7 - 411233
        else if (m_showerType == 3) MCshowerID = "600666";  // PhH7EG_H7UE - 600666
        else if (m_showerType == 4) MCshowerID = "700660"; // Sh_2210 FTAGAnalysisConfig uses this, but docs say only 11-16 can be used
        else if (m_showerType == 5) MCshowerID = "700660"; // Sh_2211
        else if (m_showerType == 6) MCshowerID = "700660"; // Sh_2212
        else if (m_showerType == 7) MCshowerID = "700660"; // Sh_2214
        else if (m_showerType == 8) {
            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!"); 
            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.
        }
        else if (m_showerType != 0){
            ATH_MSG_WARNING("Unknown ShowerID detected! Using default FTAG MC-MC SFs (Powheg+Pythia8). Please check if these are applicable for this sample!");
        }
      }
      else {
        MCshowerID= "default";                              // PowhegPythia8EvtGen (601229)
        if (m_showerType == 3) MCshowerID = "601414";  // PhH7EG_H7UE - 601414 
        else if (m_showerType == 5) MCshowerID = "700808"; // Sh_2211
        else if (m_showerType == 6) MCshowerID = "700808"; // Sh_2212
        else if (m_showerType == 7) MCshowerID = "700808"; // Sh_2214
        else if (m_showerType == 8) {
            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!");
            MCshowerID = "700660"; // Unknown Sherpa Version
        }
        else if (m_showerType != 0){
            ATH_MSG_WARNING("Unknown ShowerID detected! Using default FTAG MC-MC SFs (Powheg+Pythia8). Please check if these are applicable for this sample!");
        }
      }
    } else {
        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!");
        MCshowerID= "default";
    }
 
    // btagEfficiencyTool
    if (m_useBtagging && !m_btagEffTool.isUserConfigured() && !m_BtagWP.empty()) {
      if (jetcoll != "AntiKt4EMTopoJets" && jetcoll != "AntiKt4EMPFlowJets") {
        ATH_MSG_WARNING("** Only AntiKt4EMTopoJets and AntiKt4EMPFlowJets are supported with FTAG scale factors!");
          return StatusCode::FAILURE;
      }
 
      toolName = "BTagSF_" + jetcollBTag + m_BtagTagger + m_BtagWP;
      m_btagEffTool.setTypeAndName("BTaggingEfficiencyTool/"+toolName);
      ATH_CHECK( m_btagEffTool.setProperty("TaggerName",     m_BtagTagger ) );
      ATH_CHECK( m_btagEffTool.setProperty("ScaleFactorFileName",  m_bTaggingCalibrationFilePath) );
      ATH_CHECK( m_btagEffTool.setProperty("OperatingPoint", m_BtagWP ) );
      ATH_CHECK( m_btagEffTool.setProperty("JetAuthor",      jetcollBTag ) );
      // Read from BTagging object. This will be needed until the input file is produced from
      // a derivation release that includes !80336.
      ATH_CHECK( m_btagEffTool.setProperty("readFromBTaggingObject", true) );
      ATH_CHECK( m_btagEffTool.setProperty("MinPt",          m_BtagMinPt ) );
      ATH_CHECK( m_btagEffTool.setProperty("SystematicsStrategy", m_BtagSystStrategy ) );
      ATH_CHECK( m_btagEffTool.setProperty("EfficiencyBCalibrations",     MCshowerID   ));
      ATH_CHECK( m_btagEffTool.setProperty("EfficiencyCCalibrations",     MCshowerID   ));
      ATH_CHECK( m_btagEffTool.setProperty("EfficiencyTCalibrations",     MCshowerID   ));
      ATH_CHECK( m_btagEffTool.setProperty("EfficiencyLightCalibrations", MCshowerID   ));
      ATH_CHECK( m_btagEffTool.setProperty("EigenvectorReductionB", m_EigenvectorReductionB ));
      ATH_CHECK( m_btagEffTool.setProperty("EigenvectorReductionC", m_EigenvectorReductionC ));
      ATH_CHECK( m_btagEffTool.setProperty("EigenvectorReductionLight", m_EigenvectorReductionLight ));
      ATH_CHECK( m_btagEffTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_btagEffTool.retrieve() );
    } else ATH_CHECK( m_btagEffTool.retrieve() );
 
 
    if (m_slices["tjet"]) {
      if (m_useBtagging_trkJet && !m_btagEffTool_trkJet.isUserConfigured() && !m_BtagWP_trkJet.empty()) {
        if (trkjetcoll.find("AntiKt2PV0TrackJets")==std::string::npos && trkjetcoll.find("AntiKtVR30Rmax4Rmin02TrackJets")==std::string::npos) {
          ATH_MSG_WARNING("** Only AntiKt2PV0TrackJets and AntiKtVR30Rmax4Rmin02TrackJets are supported with FTAG scale factors!");
            return StatusCode::FAILURE;
        }
 
        toolName = "BTagSF_" + trkjetcoll;
        m_btagEffTool_trkJet.setTypeAndName("BTaggingEfficiencyTool/"+toolName);
        ATH_CHECK( m_btagEffTool_trkJet.setProperty("TaggerName",     m_BtagTagger_trkJet ) );
        ATH_CHECK( m_btagEffTool_trkJet.setProperty("ScaleFactorFileName",   m_bTaggingCalibrationFilePath) );
        ATH_CHECK( m_btagEffTool_trkJet.setProperty("OperatingPoint", m_BtagWP_trkJet ) );
        ATH_CHECK( m_btagEffTool_trkJet.setProperty("JetAuthor",      BTagColl_TrkJet ) );
        ATH_CHECK( m_btagEffTool_trkJet.setProperty("MinPt",          m_BtagMinPt_trkJet ) );
        ATH_CHECK( m_btagEffTool_trkJet.setProperty("SystematicsStrategy", m_BtagSystStrategy ) );
        ATH_CHECK( m_btagEffTool_trkJet.setProperty("EfficiencyBCalibrations",     MCshowerID   ));
        ATH_CHECK( m_btagEffTool_trkJet.setProperty("EfficiencyCCalibrations",     MCshowerID   ));
        ATH_CHECK( m_btagEffTool_trkJet.setProperty("EfficiencyTCalibrations",     MCshowerID   ));
        ATH_CHECK( m_btagEffTool_trkJet.setProperty("EfficiencyLightCalibrations", MCshowerID   ));
        ATH_CHECK( m_btagEffTool_trkJet.setProperty("EigenvectorReductionB", m_EigenvectorReductionB ));
        ATH_CHECK( m_btagEffTool_trkJet.setProperty("EigenvectorReductionC", m_EigenvectorReductionC ));
        ATH_CHECK( m_btagEffTool_trkJet.setProperty("EigenvectorReductionLight", m_EigenvectorReductionLight ));
        ATH_CHECK( m_btagEffTool_trkJet.setProperty("OutputLevel", this->msg().level()) );
        ATH_CHECK( m_btagEffTool_trkJet.retrieve() );
      } else if (m_btagEffTool_trkJet.isUserConfigured()) ATH_CHECK( m_btagEffTool_trkJet.retrieve() );
    }
  }
 
 
  if (m_slices["met"]) {
  // Initialise MET tools
 
    if (!m_metMaker.isUserConfigured()) {
      toolName = m_doFwdJVT ? m_metJetSelection+"_fJVT" : m_metJetSelection+"_NOfJVT";
      m_metMaker.setTypeAndName("met::METMaker/METMaker_ST_"+toolName);
 
      ATH_CHECK( m_metMaker.setProperty("ORCaloTaggedMuons", m_metRemoveOverlappingCaloTaggedMuons) );
      ATH_CHECK( m_metMaker.setProperty("DoSetMuonJetEMScale", m_metDoSetMuonJetEMScale) );
      ATH_CHECK( m_metMaker.setProperty("DoRemoveMuonJets", m_metDoRemoveMuonJets) );
      ATH_CHECK( m_metMaker.setProperty("UseGhostMuons", m_metUseGhostMuons) );
      ATH_CHECK( m_metMaker.setProperty("DoMuonEloss", m_metDoMuonEloss) );
      ATH_CHECK( m_metMaker.setProperty("GreedyPhotons", m_metGreedyPhotons) );
      ATH_CHECK( m_metMaker.setProperty("VeryGreedyPhotons", m_metVeryGreedyPhotons) );
 
      // set the jet selection if default empty string is overridden through config file
      if (m_metJetSelection.size()) {
        ATH_CHECK( m_metMaker.setProperty("JetSelection", m_metJetSelection) );
      }
      if (m_jetInputType == xAOD::JetInput::EMPFlow) {
        ATH_CHECK( m_metMaker.setProperty("DoPFlow", true) );
      }
 
      ATH_CHECK( m_metMaker.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_metMaker.retrieve() );
    } else ATH_CHECK( m_metMaker.retrieve() );
 
 
    if (!m_metSystTool.isUserConfigured()) {
      m_metSystTool.setTypeAndName("met::METSystematicsTool/METSystTool");
      ATH_CHECK( m_metSystTool.setProperty("ConfigPrefix", m_metsysConfigPrefix) );
 
      if (m_trkMETsyst && m_caloMETsyst){
        ATH_MSG_ERROR( "Can only have CST *or* TST configured for MET maker.  Please unset either METDoCaloSyst or METDoTrkSyst in your config file" );
        return StatusCode::FAILURE;
      }
 
      if (m_trkMETsyst) {
        ATH_CHECK( m_metSystTool.setProperty("ConfigSoftCaloFile", "") );
        ATH_CHECK( m_metSystTool.setProperty("ConfigSoftTrkFile", "TrackSoftTerms-pflow_Dec24.config") );
      }
 
      if (m_caloMETsyst) {
        ATH_MSG_WARNING( "CST is no longer recommended by Jet/MET group");
        ATH_CHECK( m_metSystTool.setProperty("ConfigSoftTrkFile", "") );
      }
 
      if (m_trkJetsyst) {
        ATH_CHECK( m_metSystTool.setProperty("ConfigJetTrkFile", "JetTrackSyst.config") );
      }
 
      ATH_CHECK( m_metSystTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_metSystTool.retrieve());
    } else ATH_CHECK( m_metSystTool.retrieve());
 
 
    if (!m_metSignif.isUserConfigured()) {
      // See https://twiki.cern.ch/twiki/bin/view/AtlasProtected/MetSignificance
      m_metSignif.setTypeAndName("met::METSignificance/metSignificance_"+jetname);
#ifndef XAOD_STANDALONE // Athena and AthAnalysis; need to take into account that MuonCalibTool is private tool
      ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "SoftTermParam", m_softTermParam));
      ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "TreatPUJets", m_treatPUJets));
      ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "DoPhiReso", m_doPhiReso));
      ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "IsAFII", isAtlfast()));
      if(jetname == "AntiKt4EMTopo" || jetname =="AntiKt4EMPFlow"){
        ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "JetCollection", jetname) );
      } else {
          ATH_MSG_WARNING("Object-based METSignificance recommendations only exist for EMTopo and PFlow, falling back to AntiKt4EMTopo");
          ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "JetCollection", "AntiKt4EMTopo") );
      }
      // setup a dedicated new muon calib tool for passing down to METSignificance
      ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "MuonCalibTool", "CP::MuonCalibTool/calibTool"));
      if (m_isRun3)
        ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.IsRun3Geo", true));
      ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.calibMode", m_muCalibrationMode));
      ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.OutputLevel",this->msg().level()));
      ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.release", "Recs2025_03_26_Run2Run3"));
      int IdBaselineInt = m_muIdBaseline;
      if (IdBaselineInt == 4)
        ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.do2StationsHighPt", true));
      ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.doExtraSmearing", m_muHighPtExtraSmear));
      ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "OutputLevel", this->msg().level()));
#else // AnalysisBase; can just pass the muon calib tool configured above
      ATH_CHECK( m_metSignif.setProperty("SoftTermParam", m_softTermParam) );
      ATH_CHECK( m_metSignif.setProperty("TreatPUJets", m_treatPUJets) );
      ATH_CHECK( m_metSignif.setProperty("DoPhiReso", m_doPhiReso) );
      ATH_CHECK( m_metSignif.setProperty("IsAFII", isAtlfast()) );
      if(jetname == "AntiKt4EMTopo" || jetname =="AntiKt4EMPFlow"){
        ATH_CHECK( m_metSignif.setProperty("JetCollection", jetname) );
      } else {
        ATH_MSG_WARNING("Object-based METSignificance recommendations only exist for EMTopo and PFlow, falling back to AntiKt4EMTopo");
        ATH_CHECK( m_metSignif.setProperty("JetCollection", "AntiKt4EMTopo") );
      }
      // just pass the muon calib tool
      ATH_CHECK( m_metSignif.setProperty("MuonCalibTool",m_muonCalibTool.getHandle()));
      ATH_CHECK( m_metSignif.setProperty("OutputLevel", this->msg().level()) );
#endif
      ATH_CHECK( m_metSignif.retrieve() );
    } else ATH_CHECK( m_metSignif.retrieve() );
  }
 
 
// Initialise trigger tools
 
  if (!m_trigDecTool.isUserConfigured()) {
 
    // The decision tool
    m_trigDecTool.setTypeAndName("Trig::TrigDecisionTool/TrigDecisionTool");
    ATH_CHECK( m_trigDecTool.setProperty("TrigDecisionKey", "xTrigDecision") );
    if (m_isRun3) {
      ATH_CHECK( m_trigDecTool.setProperty("NavigationFormat", "TrigComposite") );
      ATH_CHECK( m_trigDecTool.setProperty("HLTSummary", "HLTNav_Summary_DAODSlimmed") );
    }
    ATH_CHECK( m_trigDecTool.setProperty("OutputLevel", this->msg().level()) );
 
#ifndef XAOD_STANDALONE // Athena and AthAnalysis
    // Clear the default tool handle to cause a fallback on the config service
    ATH_CHECK( m_trigDecTool.setProperty("ConfigTool", ""));
#else // AnalysisBase
    m_trigConfTool.setTypeAndName("TrigConf::xAODConfigTool/xAODConfigTool");
    ATH_CHECK(m_trigConfTool.retrieve() );
    ATH_CHECK( m_trigDecTool.setProperty("ConfigTool", m_trigConfTool.getHandle()) );
#endif
 
    ATH_CHECK( m_trigDecTool.retrieve() );
 
  } else  ATH_CHECK( m_trigDecTool.retrieve() );
 
  if (m_isRun3) {
    if (!m_trigDRScoringTool.isUserConfigured()) {
      m_trigDRScoringTool.setTypeAndName("Trig::DRScoringTool/TrigDRScoringTool");
      ATH_CHECK( m_trigDRScoringTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_trigDRScoringTool.retrieve() );
    } else  ATH_CHECK( m_trigDRScoringTool.retrieve() );
  }
 
  if (!m_trigMatchingTool.isUserConfigured()) {
    if (m_upstreamTriggerMatching){
      m_trigMatchingTool.setTypeAndName("Trig::MatchFromCompositeTool/TrigMatchFromCompositeTool");
      ATH_CHECK( m_trigMatchingTool.setProperty("InputPrefix", m_trigMatchingPrefix) );
      ATH_CHECK( m_trigMatchingTool.setProperty("RemapBrokenLinks", true) );
    }
    else {
      if (m_isRun3){
        m_trigMatchingTool.setTypeAndName("Trig::R3MatchingTool/TrigR3MatchingTool");
        ATH_CHECK( m_trigMatchingTool.setProperty("ScoringTool", m_trigDRScoringTool.getHandle()) );
        ATH_CHECK( m_trigMatchingTool.setProperty("TrigDecisionTool", m_trigDecTool.getHandle()) );
      }
      else {
        m_trigMatchingTool.setTypeAndName("Trig::MatchingTool/TrigMatchingTool");
        ATH_CHECK( m_trigMatchingTool.setProperty("TrigDecisionTool", m_trigDecTool.getHandle()) );
      }
    }
    ATH_CHECK( m_trigMatchingTool.setProperty("OutputLevel", this->msg().level()) );
    ATH_CHECK( m_trigMatchingTool.retrieve() );
  } else  ATH_CHECK( m_trigMatchingTool.retrieve() );
 
// Initialise trigGlobalEfficiencyCorrection tool
 
  if (!m_trigGlobalEffCorrTool_diLep.isUserConfigured() && !isData()) {
 
    std::string no2e17("");
    if (m_trig2017combination_diLep.find("||2e17_lhvloose_nod0_L12EM15VHI") != std::string::npos) {
      auto pos_2e17 = m_trig2017combination_diLep.find("||2e17_lhvloose_nod0_L12EM15VHI");
      no2e17 = m_trig2017combination_diLep.substr(0, pos_2e17) + m_trig2017combination_diLep.substr(pos_2e17+31, m_trig2017combination_diLep.size());
    } else if (m_trig2017combination_diLep.find("2e17_lhvloose_nod0_L12EM15VHI||") != std::string::npos) {
      auto pos_2e17 = m_trig2017combination_diLep.find("2e17_lhvloose_nod0_L12EM15VHI||");
      no2e17 = m_trig2017combination_diLep.substr(0, pos_2e17) + m_trig2017combination_diLep.substr(pos_2e17+31, m_trig2017combination_diLep.size());
    } else {
      no2e17 = m_trig2017combination_diLep;
    }
    ATH_MSG_DEBUG( "TrigGlobalEfficiencyCorrectionTool/TrigGlobal_diLep: no2e17 trigger string: " << no2e17 );
 
    std::map<std::string,std::string> triggers_diLep;
    triggers_diLep["2015"] = m_trig2015combination_diLep;
    triggers_diLep["2016"] = m_trig2016combination_diLep;
    triggers_diLep["324320-326695"] = m_trig2017combination_diLep; // 2017 before accidental prescale of L12EM15VHI
    triggers_diLep["326834-328393"] = no2e17;                      // 2017 during accidental prescale
    triggers_diLep["329385-340453"] = m_trig2017combination_diLep; // 2017 after accidental prescale
    triggers_diLep["2018"] = m_trig2018combination_diLep;
 
    m_trigGlobalEffCorrTool_diLep.setTypeAndName("TrigGlobalEfficiencyCorrectionTool/TrigGlobal_diLep");
    ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("ElectronEfficiencyTools", m_elecTrigEffTools) );
    ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("ElectronScaleFactorTools", m_elecTrigSFTools) );
    ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("MuonTools", m_muonTrigSFTools) );
    ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("TriggerCombination", triggers_diLep) );
    ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("TriggerMatchingTool", m_trigMatchingTool.getHandle()) );
    ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("ListOfLegsPerTool", m_legsPerTool) );
    ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("NumberOfToys", m_trigNToys_diLep) );
    ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("OutputLevel", this->msg().level()) );
    ATH_CHECK( m_trigGlobalEffCorrTool_diLep.initialize() );
  } else if (m_trigGlobalEffCorrTool_diLep.isUserConfigured()) ATH_CHECK( m_trigGlobalEffCorrTool_diLep.retrieve() );
 
 
  if (!m_trigGlobalEffCorrTool_multiLep.isUserConfigured() && !isData()) {
 
    std::string no2e17("");
    if (m_trig2017combination_multiLep.find("||2e17_lhvloose_nod0_L12EM15VHI") != std::string::npos) {
      auto pos_2e17 = m_trig2017combination_multiLep.find("||2e17_lhvloose_nod0_L12EM15VHI");
      no2e17 = m_trig2017combination_multiLep.substr(0, pos_2e17) + m_trig2017combination_multiLep.substr(pos_2e17+31, m_trig2017combination_multiLep.size());
    } else if (m_trig2017combination_multiLep.find("2e17_lhvloose_nod0_L12EM15VHI||") != std::string::npos) {
      auto pos_2e17 = m_trig2017combination_multiLep.find("2e17_lhvloose_nod0_L12EM15VHI||");
      no2e17 = m_trig2017combination_multiLep.substr(0, pos_2e17) + m_trig2017combination_multiLep.substr(pos_2e17+31, m_trig2017combination_multiLep.size());
    } else {
      no2e17 = m_trig2017combination_multiLep;
    }
    ATH_MSG_DEBUG( "TrigGlobalEfficiencyCorrectionTool/TrigGlobal_multiLep: no2e17 trigger string: " << no2e17 );
 
    std::map<std::string,std::string> triggers_multiLep;
    triggers_multiLep["2015"] = m_trig2015combination_multiLep;
    triggers_multiLep["2016"] = m_trig2016combination_multiLep;
    triggers_multiLep["324320-326695"] = m_trig2017combination_multiLep; // 2017 before accidental prescale of L12EM15VHI
    triggers_multiLep["326834-328393"] = no2e17;                         // 2017 during accidental prescale
    triggers_multiLep["329385-340453"] = m_trig2017combination_multiLep; // 2017 after accidental prescale
    triggers_multiLep["2018"] = m_trig2018combination_multiLep;
 
    m_trigGlobalEffCorrTool_multiLep.setTypeAndName("TrigGlobalEfficiencyCorrectionTool/TrigGlobal_multiLep");
    ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("ElectronEfficiencyTools", m_elecTrigEffTools) );
    ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("ElectronScaleFactorTools", m_elecTrigSFTools) );
    ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("MuonTools", m_muonTrigSFTools) );
    ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("TriggerCombination", triggers_multiLep) );
    ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("TriggerMatchingTool", m_trigMatchingTool.getHandle()) );
    ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("ListOfLegsPerTool", m_legsPerTool) );
    ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("NumberOfToys", m_trigNToys_multiLep) );
    ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("OutputLevel", this->msg().level()) );
    ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.initialize() );
  } else if (m_trigGlobalEffCorrTool_multiLep.isUserConfigured()) ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.retrieve() );
 
 
  if (!m_trigGlobalEffCorrTool_diPhoton.isUserConfigured() && !isData()) {
    m_trigGlobalEffCorrTool_diPhoton.setTypeAndName("TrigGlobalEfficiencyCorrectionTool/TrigGlobal_diPhoton");
    ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("PhotonEfficiencyTools", m_photonTrigEffTools) );
    ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("PhotonScaleFactorTools", m_photonTrigSFTools) );
    ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("TriggerCombination2015", m_trig2015combination_diPhoton) );
    ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("TriggerCombination2016", m_trig2016combination_diPhoton) );
    ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("TriggerCombination2017", m_trig2017combination_diPhoton) );
    ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("TriggerCombination2018", m_trig2018combination_diPhoton) );
    ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("ListOfLegsPerTool", m_legsPerTool_ph) );
    ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("NumberOfToys", m_trigNToys_diPhoton) );
    ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("OutputLevel", this->msg().level()) );
    ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.initialize() );
  } else if (m_trigGlobalEffCorrTool_diPhoton.isUserConfigured()) ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.retrieve() );
 
 
  if (m_slices["ele"] || m_slices["pho"] || m_slices["mu"]) {
  // /////////////////////////////////////////////////////////////////////////////////////////
  // Initialise Isolation Correction Tool
 
    if ( !m_isoCorrTool.isUserConfigured() ) {
      m_isoCorrTool.setTypeAndName("CP::IsolationCorrectionTool/IsoCorrTool");
      ATH_CHECK( m_isoCorrTool.setProperty( "ToolVer", "REL22") );
      ATH_CHECK( m_isoCorrTool.setProperty( "IsMC", !isData()) );
      ATH_CHECK( m_isoCorrTool.setProperty( "AFII_corr", isAtlfast()) );
      ATH_CHECK( m_isoCorrTool.setProperty( "Apply_SC_leakcorr", false) );
      ATH_CHECK( m_isoCorrTool.setProperty( "CorrFile", "IsolationCorrections/v6/isolation_ptcorrections_rel22_mc20.root") );
      ATH_CHECK( m_isoCorrTool.setProperty( "OutputLevel", this->msg().level()) );
      ATH_CHECK( m_isoCorrTool.retrieve() );
    } else  ATH_CHECK( m_isoCorrTool.retrieve() );
 
 
  // /////////////////////////////////////////////////////////////////////////////////////////
  // Initialise Isolation Tool
    if (!m_isoTool.isUserConfigured()) {
      m_isoTool.setTypeAndName("CP::IsolationSelectionTool/IsoTool");
      ATH_CHECK( m_isoTool.setProperty("ElectronWP", m_eleIso_WP.empty()    ? "Loose_VarRad" : m_eleIso_WP) );
      ATH_CHECK( m_isoTool.setProperty("MuonWP",     m_muIso_WP.empty()     ? "Loose_VarRad" : m_muIso_WP) );
      ATH_CHECK( m_isoTool.setProperty("PhotonWP",   m_photonIso_WP.empty() ? "FixedCutTight" : m_photonIso_WP ) );
      ATH_CHECK( m_isoTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_isoTool.retrieve() );
    } else  ATH_CHECK( m_isoTool.retrieve() );
 
    //disable if (!m_isoToolLowPtPLV.isUserConfigured()) {
    //disable   m_isoToolLowPtPLV.setTypeAndName("CP::IsolationLowPtPLVTool/IsoToolLowPtPLV");
    //disable   ATH_CHECK( m_isoToolLowPtPLV.setProperty("OutputLevel", this->msg().level()) );
    //disable   ATH_CHECK( m_isoToolLowPtPLV.retrieve() );
    //disable } else  ATH_CHECK( m_isoToolLowPtPLV.retrieve() );
 
 
    if (!m_isoBaselineTool.isUserConfigured()) {
      m_isoBaselineTool.setTypeAndName("CP::IsolationSelectionTool/IsoBaselineTool");
      ATH_CHECK( m_isoBaselineTool.setProperty("ElectronWP", m_eleBaselineIso_WP.empty()    ? "Loose_VarRad" : m_eleBaselineIso_WP    ) );
      ATH_CHECK( m_isoBaselineTool.setProperty("MuonWP",     m_muBaselineIso_WP.empty()     ? "Loose_VarRad" : m_muBaselineIso_WP     ) );
      ATH_CHECK( m_isoBaselineTool.setProperty("PhotonWP",   m_photonBaselineIso_WP.empty() ? "FixedCutTight" : m_photonBaselineIso_WP ) );
      ATH_CHECK( m_isoBaselineTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_isoBaselineTool.retrieve() );
    } else ATH_CHECK( m_isoBaselineTool.retrieve() );
 
 
    if (!m_isoHighPtTool.isUserConfigured()) {
      m_isoHighPtTool.setTypeAndName("CP::IsolationSelectionTool/IsoHighPtTool");
      ATH_CHECK( m_isoHighPtTool.setProperty("ElectronWP", m_eleIsoHighPt_WP.empty() ? "Loose_VarRad" : m_eleIsoHighPt_WP) );
      ATH_CHECK( m_isoHighPtTool.setProperty("MuonWP",     m_muIsoHighPt_WP.empty()  ? "Loose_VarRad" : m_muIsoHighPt_WP ) );
      ATH_CHECK( m_isoHighPtTool.setProperty("PhotonWP",   m_photonIso_WP.empty()    ? "FixedCutTight" : m_photonIso_WP ) );
      ATH_CHECK( m_isoHighPtTool.setProperty("OutputLevel", this->msg().level()) );
      ATH_CHECK( m_isoHighPtTool.retrieve() );
    } else ATH_CHECK( m_isoHighPtTool.retrieve() );
 
 
  // /////////////////////////////////////////////////////////////////////////////////////////
  // Initialise IsolationCloseByCorrectionTool Tool
    if (!m_isoCloseByTool.isUserConfigured()) {
      m_isoCloseByTool.setTypeAndName("CP::IsolationCloseByCorrectionTool/IsoCloseByTool");
      // Actually we could debate about what is the proper tool to choose if the users have different baseline & signal islation WP's
      ATH_CHECK( m_isoCloseByTool.setProperty("IsolationSelectionTool", m_useSigLepForIsoCloseByOR ? m_isoTool : m_isoBaselineTool));
      ATH_CHECK( m_isoCloseByTool.setProperty("PassoverlapDecorator", m_IsoCloseByORpassLabel) );
      ATH_CHECK( m_isoCloseByTool.setProperty("SelectionDecorator", m_useSigLepForIsoCloseByOR ? "signal" : "baseline") );
      // Make this propery configurable as well?
      ATH_CHECK( m_isoCloseByTool.setProperty("BackupPrefix", "ORIG") );
      // The isolation selection decorator is updated as well by the tool
      ATH_CHECK( m_isoCloseByTool.setProperty("IsolationSelectionDecorator", "isol") );
 
      ATH_CHECK( m_isoCloseByTool.setProperty("OutputLevel", this->msg().level()) );
#ifndef XAOD_ANALYSIS
      ATH_CHECK( m_isoCloseByTool.setProperty("ParticleCaloExtensionTool", "") );
#endif
      ATH_CHECK( m_isoCloseByTool.retrieve() );
    } else  ATH_CHECK( m_isoCloseByTool.retrieve() );
  }
 
 
// /////////////////////////////////////////////////////////////////////////////////////////
// Initialise Overlap Removal Tool
  if ( m_orToolbox.masterTool.empty() ){
 
    // set up the master tool
    std::string suffix = "";
    if (m_orDoTau) suffix += "Tau";
    if (m_orDoPhoton) suffix += "Gamma";
    if (m_orDoBjet) suffix += "Bjet";
    std::string toolName = "ORTool" + suffix;
    ATH_MSG_INFO("SUSYTools: Autoconfiguring " << toolName);
 
    std::string bJetLabel = "";
    //overwrite lepton flags if the global is false (yes?)
    if (!m_orDoBjet || !m_useBtagging) {
      m_orDoElBjet = false;
      m_orDoMuBjet = false;
      m_orDoTauBjet = false;
    }
    if (m_orDoElBjet || m_orDoMuBjet || m_orDoTauBjet) {
      bJetLabel = "bjet_loose";
    }
 
    // Set the generic flags
    ORUtils::ORFlags orFlags(toolName, m_orInputLabel, "passOR");
    orFlags.bJetLabel      = bJetLabel;
    orFlags.boostedLeptons = (m_orDoBoostedElectron || m_orDoBoostedMuon);
    orFlags.outputPassValue = true;
    orFlags.linkOverlapObjects = m_orLinkOverlapObjects;
    if (m_orDoElEl) {
      orFlags.doEleEleOR = true;
    } else orFlags.doEleEleOR = false;
    orFlags.doElectrons = true;
    orFlags.doMuons = true;
    orFlags.doJets = true;
    orFlags.doTaus = m_orDoTau;
    orFlags.doPhotons = m_orDoPhoton;
    orFlags.doFatJets = m_orDoFatjets;
 
    //set up all recommended tools
    ATH_CHECK( ORUtils::recommendedTools(orFlags, m_orToolbox));
 
    // We don't currently have a good way to determine here which object
    // definitions are disabled, so we currently just configure all overlap
    // tools and disable the pointer safety checks
    ATH_CHECK( m_orToolbox.setGlobalProperty("OutputLevel", this->msg().level()) );
    ATH_CHECK( m_orToolbox.masterTool.setProperty("RequireExpectedPointers", false) );
 
    // Override boosted OR sliding cone options
    ATH_CHECK( m_orToolbox.eleJetORT.setProperty("UseSlidingDR", m_orDoBoostedElectron) );
    ATH_CHECK( m_orToolbox.muJetORT.setProperty("UseSlidingDR", m_orDoBoostedMuon) );
 
    //add custom tau-jet OR tool
    if(m_orDoTau){
      m_orToolbox.tauJetORT.setTypeAndName("ORUtils::TauJetOverlapTool/" + orFlags.masterName + ".TauJetORT");
      ATH_CHECK( m_orToolbox.tauJetORT.setProperty("BJetLabel", m_orDoTauBjet?bJetLabel:"") );
    }
 
    // override sliding cone params if sliding dR is on and the user-provided parameter values are non-negative
    if (m_orDoBoostedElectron) {
      if (m_orBoostedElectronC1 > 0) ATH_CHECK( m_orToolbox.eleJetORT.setProperty("SlidingDRC1", m_orBoostedElectronC1) );
      if (m_orBoostedElectronC2 > 0) ATH_CHECK( m_orToolbox.eleJetORT.setProperty("SlidingDRC2", m_orBoostedElectronC2) );
      if (m_orBoostedElectronMaxConeSize > 0) ATH_CHECK( m_orToolbox.eleJetORT.setProperty("SlidingDRMaxCone", m_orBoostedElectronMaxConeSize) );
    }
    if (m_orDoBoostedMuon) {
      if (m_orBoostedMuonC1 > 0) ATH_CHECK( m_orToolbox.muJetORT.setProperty("SlidingDRC1", m_orBoostedMuonC1) );
      if (m_orBoostedMuonC2 > 0) ATH_CHECK( m_orToolbox.muJetORT.setProperty("SlidingDRC2", m_orBoostedMuonC2) );
      if (m_orBoostedMuonMaxConeSize > 0) ATH_CHECK( m_orToolbox.muJetORT.setProperty("SlidingDRMaxCone", m_orBoostedMuonMaxConeSize) );
    }
 
    // and switch off lep-bjet check if not requested
    if (!m_orDoElBjet) {
      ATH_CHECK(m_orToolbox.eleJetORT.setProperty("BJetLabel", ""));
    }
    if (!m_orDoMuBjet) {
      ATH_CHECK(m_orToolbox.muJetORT.setProperty("BJetLabel", ""));
    }
 
    // propagate the mu-jet ghost-association option which might be set by the user (default is true)
    ATH_CHECK(m_orToolbox.muJetORT.setProperty("UseGhostAssociation", m_orDoMuonJetGhostAssociation));
 
    // propagate mu-jet OR settings if requested
    ATH_CHECK(m_orToolbox.muJetORT.setProperty("ApplyRelPt", m_orApplyRelPt) );
    if(m_orApplyRelPt){
      if (m_orMuJetPtRatio > 0)    ATH_CHECK(m_orToolbox.muJetORT.setProperty("MuJetPtRatio", m_orMuJetPtRatio) );
      if (m_orMuJetTrkPtRatio > 0) ATH_CHECK(m_orToolbox.muJetORT.setProperty("MuJetTrkPtRatio", m_orMuJetTrkPtRatio) );
    }
    if (m_orMuJetInnerDR > 0)    ATH_CHECK(m_orToolbox.muJetORT.setProperty("InnerDR", m_orMuJetInnerDR) );
 
    // propagate the calo muon setting for EleMuORT
    ATH_CHECK(m_orToolbox.eleMuORT.setProperty("RemoveCaloMuons", m_orRemoveCaloMuons) );
 
    // Use electron-muon DR matching to remove electrons within DR <  0.01 of Muons.
    if (m_orDoElMu){
      ATH_CHECK(m_orToolbox.eleMuORT.setProperty("UseDRMatching", m_orDoElMu) );
    }
 
    // propagate the fatjets OR settings
    if(m_orDoFatjets){
      if(m_EleFatJetDR>0) ATH_CHECK(m_orToolbox.eleFatJetORT.setProperty("DR", m_EleFatJetDR));
      if(m_JetFatJetDR>0) ATH_CHECK(m_orToolbox.jetFatJetORT.setProperty("DR", m_JetFatJetDR));
    }
 
    // Make sure that we deal with prorities correctly
    ATH_CHECK(m_orToolbox.eleJetORT.setProperty("EnableUserPriority", true));
    ATH_CHECK(m_orToolbox.muJetORT.setProperty("EnableUserPriority", true));
    if (m_orDoTau) ATH_CHECK(m_orToolbox.tauJetORT.setProperty("EnableUserPriority", true));
    if (m_orDoPhoton) ATH_CHECK(m_orToolbox.phoJetORT.setProperty("EnableUserPriority", true));
 
    if ( m_orPhotonFavoured ) {
       ATH_CHECK(m_orToolbox.phoEleORT.setProperty("SwapContainerPrecedence", true));
       ATH_CHECK(m_orToolbox.phoMuORT.setProperty("SwapContainerPrecedence", true));
    }
 
    if (!m_orDoEleJet){
      // Disable the electron removal part of e-j overlap removal
      ATH_CHECK( m_orToolbox.eleJetORT.setProperty("OuterDR",-1.) );
      ATH_CHECK( m_orToolbox.eleJetORT.setProperty("SlidingDRMaxCone",-1.) );
    }
    if (!m_orDoMuonJet){
      // Disable the muon removal part of m-j overlap removal
      ATH_CHECK( m_orToolbox.muJetORT.setProperty("OuterDR",-1.) );
      ATH_CHECK( m_orToolbox.muJetORT.setProperty("SlidingDRMaxCone",-1.) );
    }
 
    ATH_CHECK( m_orToolbox.initialize() );
 
  }
  // Done with the OR toolbox setup!
 
// /////////////////////////////////////////////////////////////////////////////////////////
// Initialise PMG Tools
  if (!m_pmgSHnjetWeighter.isUserConfigured() && !isData()) {
    m_pmgSHnjetWeighter.setTypeAndName("PMGTools::PMGSherpa22VJetsWeightTool/PMGSHVjetReweighter");
    ATH_CHECK( m_pmgSHnjetWeighter.setProperty( "TruthJetContainer", "AntiKt4TruthJets"));
    ATH_CHECK( m_pmgSHnjetWeighter.setProperty("OutputLevel", this->msg().level()) );
    ATH_CHECK( m_pmgSHnjetWeighter.retrieve());
  } else if (m_pmgSHnjetWeighter.isUserConfigured()) ATH_CHECK( m_pmgSHnjetWeighter.retrieve());
 
 
  if (!m_pmgSHnjetWeighterWZ.isUserConfigured() && !isData()) {
    m_pmgSHnjetWeighterWZ.setTypeAndName("PMGTools::PMGSherpa22VJetsWeightTool/PMGSHVjetReweighterWZ");
    ATH_CHECK( m_pmgSHnjetWeighterWZ.setProperty( "TruthJetContainer", "AntiKt4TruthWZJets"));
    ATH_CHECK( m_pmgSHnjetWeighterWZ.setProperty("OutputLevel", this->msg().level()) );
    ATH_CHECK( m_pmgSHnjetWeighterWZ.retrieve() );
  } else if (m_pmgSHnjetWeighterWZ.isUserConfigured()) ATH_CHECK( m_pmgSHnjetWeighterWZ.retrieve() );
 
 
  // prevent these initialiation snippets from being run again
  m_subtool_init = true;
 
  ATH_MSG_INFO("Done initialising SUSYTools");
 
  return StatusCode::SUCCESS;
}

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.

                                             {
 
#ifndef XAOD_STANDALONE
      if (m_useIncidents) {
         // Connect to the IncidentSvc:
         ServiceHandle< IIncidentSvc > incSvc( "IncidentSvc", name() );
         ATH_CHECK( incSvc.retrieve() );
 
         // Set up the right callbacks: don't rethrow exceptions, any failure and we should end
         incSvc->addListener( this, IncidentType::BeginEvent, 0, false );
      }
      // Let the base class do its thing:
      ATH_CHECK( AlgTool::sysInitialize() );
 
#endif // not XAOD_STANDALONE
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

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

                                                          {
  // Use the run number we are passed if we are passed one, otherwise
  //  use the run number from the GetRunNumber function
  int theRunNumber = runNumber>0?runNumber:GetRunNumber();
  if (theRunNumber<290000) return 2015;
  else if (theRunNumber<320000) return 2016;
  else if (theRunNumber<342000) return 2017;
  else if (theRunNumber<400000) return 2018;
  else if (theRunNumber<445000) return 2022;
  else if (theRunNumber<465000) return 2023;
  return 2024;
}

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

                                                                                                                               {
  for(const auto& p : v) {
    this->TrigMatch(p, items);
  }
}

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

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

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

                                                                                                                     {
  for(const auto& p : v) {
    this->TrigMatch(p, items);
  }
}

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

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

TrigMatch() [5/10]

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 295 of file Trigger.cxx.

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

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

                                                                                         {
  dec_trigmatched(*p) = 0;
 
  for(const auto& item: items) {
    auto result = static_cast<int>(this->IsTrigMatched(p, item));
    dec_trigmatched(*p) += result;
    const SG::Decorator<char> dec(item);
    dec(*p) = result;
  }
}

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

                                                                                                                                            {
  dec_trigmatched(*p) = 0;
 
  for(const auto *it = i1; it != i2; ++it) {
    auto result = static_cast<int>(this->IsTrigMatched(p, *it));
    dec_trigmatched(*p) += result;
    const SG::Decorator<char> dec(*it);
    dec(*p) = result;
  }
}

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

                                                                                                            {
  for(const auto p : *v) {
    this->TrigMatch(p, items);
  }
}

TrigMatch() [9/10]

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 300 of file Trigger.cxx.

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

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

                                                                                                  {
  for(const auto p : *v) {
    this->TrigMatch(p, items);
  }
}

TrigSingleLep()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2095 of file SUSYObjDef_xAOD.cxx.

{ return m_electronTriggerSFStringSingle; }

updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

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

                                                         {
  // Validate configuration (i.e. that signal settings are tighter than baseline, etc)
  // :: Throw SC::FAILURE if strict mode is enabled, just a WARNING if not
 
  // Electrons
  if( m_elePt < m_eleBaselinePt ){
    ATH_MSG_WARNING("Your electron pt configuration is inconsistent!  Signal : " << m_elePt << " < Baseline : " << m_eleBaselinePt);
    if(strict) return StatusCode::FAILURE;
  }
  if( m_eleEta > m_eleBaselineEta ){
    ATH_MSG_WARNING("Your electron eta configuration is inconsistent!  Signal : " << m_eleEta << " < Baseline : " << m_eleBaselineEta);
    if(strict) return StatusCode::FAILURE;
  }
 
  if( check_isTighter(m_eleIdBaseline, m_eleId, m_el_id_support) ){
    ATH_MSG_WARNING("Your electron ID configuration is inconsistent!  Signal : " << m_eleId << " looser than Baseline : " << m_eleIdBaseline);
    if(strict) return StatusCode::FAILURE;
  }
  if( !m_eleCrackVeto && m_eleBaselineCrackVeto){
    ATH_MSG_WARNING("Your electron crack removal is inconsistent!  Signal : " << m_eleCrackVeto << " while Baseline : " << m_eleBaselineCrackVeto);
    if(strict) return StatusCode::FAILURE;
  }
 
  // Muons
  if( m_muPt < m_muBaselinePt ){
    ATH_MSG_WARNING("Your muon pt configuration is inconsistent!  Signal : " << m_muPt << " < Baseline : " << m_muBaselinePt);
    if(strict) return StatusCode::FAILURE;
  }
  if( m_muEta > m_muBaselineEta ){
    ATH_MSG_WARNING("Your muon eta configuration is inconsistent!  Signal : " << m_muEta << " < Baseline : " << m_muBaselineEta);
    if(strict) return StatusCode::FAILURE;
  }
  if( m_muId > m_muIdBaseline ){
    ATH_MSG_WARNING("Your muon ID configuration is inconsistent!  Signal : " << m_muId << " < Baseline : " << m_muIdBaseline);
    if(strict) return StatusCode::FAILURE;
  }
 
  // Photons
  if( m_photonPt < m_photonBaselinePt ){
    ATH_MSG_WARNING("Your photon pt configuration is inconsistent!  Signal : " << m_photonPt << " < Baseline : " << m_photonBaselinePt);
    if(strict) return StatusCode::FAILURE;
  }
  if( m_photonEta > m_photonBaselineEta ){
    ATH_MSG_WARNING("Your photon eta configuration is inconsistent!  Signal : " << m_photonEta << " < Baseline : " << m_photonBaselineEta);
    if(strict) return StatusCode::FAILURE;
  }
  if( m_photonId=="Loose" && m_photonIdBaseline=="Tight" ){
    ATH_MSG_WARNING("Your photon ID configuration is inconsistent!  Signal : " << m_photonId << " < Baseline : " << m_photonIdBaseline);
    if(strict) return StatusCode::FAILURE;
  }
  if( !m_photonCrackVeto && m_photonBaselineCrackVeto){
    ATH_MSG_WARNING("Your photon crack removal is inconsistent!  Signal : " << m_photonCrackVeto << " while Baseline : " << m_photonBaselineCrackVeto);
    if(strict) return StatusCode::FAILURE;
  }
 
  // Jets
  if ( m_jetPt < 20e3 ){
    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!");
  }
 
  //Btagging //OR-wp looser than signal-wp?
  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)
    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()) ){
      ATH_MSG_WARNING("Your btagging configuration is inconsistent!  Signal : " << m_BtagWP << " is looser than OR-Baseline : " << m_orBtagWP);
    }
  }
  if (m_BtagMinPt < 20e3 || m_BtagMinPt_trkJet < 10e3) {
     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).");
  }
 
  //Taus
  if(m_tauPrePtCut > 0 and m_tauPrePtCut > m_tauPt) {
    ATH_MSG_WARNING("Your tau pt configuration is inconsistent! Signal pt cut : " << m_tauPt << " < Baseline (pre) pt cut : " << m_tauPrePtCut);
    if(strict) return StatusCode::FAILURE;
  }
  if( check_isTighter(m_tauIdBaseline, m_tauId, m_tau_id_support) ){
    ATH_MSG_WARNING("Your tau ID configuration is inconsistent!  Signal : " << m_tauId << " looser than Baseline : " << m_tauIdBaseline);
    if(strict) return StatusCode::FAILURE;
  }
 
  std::vector<float> pT_window;
  std::vector<float> eta_window;
  bool elOLR=false;
  bool muVeto=false;
  bool muOLR=false;
 
  if(!m_tauConfigPathBaseline.empty()) { //baseline taus
 
    std::string theConfig = m_tauConfigPathBaseline;
    if( m_tauConfigPathBaseline=="default" ){
      if (m_tauId == "rnn001")   theConfig = "SUSYTools/tau_selection_rnn001.conf";
      else if (m_tauId == "VeryLoose")   theConfig = "SUSYTools/tau_selection_veryloose.conf";
      else if (m_tauId == "Loose")  theConfig = "SUSYTools/tau_selection_loose.conf";
      else if (m_tauId == "Medium") theConfig = "SUSYTools/tau_selection_medium.conf";
      else if (m_tauId == "Tight")  theConfig = "SUSYTools/tau_selection_tight.conf";
    }
 
    //read config
    getTauConfig(theConfig, pT_window, eta_window, elOLR, muVeto, muOLR);
 
    //pt-eta checks
    if( m_tauPrePtCut > 0 and (m_tauPrePtCut != 1000*pT_window[0] or (pT_window[1] > 0 and m_tauPrePtCut > 1000*pT_window[1]))) {
      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] << "]");
      if(strict) return StatusCode::FAILURE;
    }
 
    if( m_tauPt > 0 and (m_tauPt != 1000*pT_window[0] or (pT_window[1] > 0 and m_tauPt > 1000*pT_window[1]))) {
      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] << "]");
      if(strict) return StatusCode::FAILURE;
    }
 
    if( m_tauEta > 0 and m_tauEta != eta_window[eta_window.size()-1]) { // eta window can have 4 entries
      ATH_MSG_WARNING("Your baseline tau eta configuration is inconsistent! eta cut : " << m_tauEta << " != TauSelectionTool max eta : " << eta_window[eta_window.size()-1]);
      if(strict) return StatusCode::FAILURE;
    }
  }
 
  if(!m_tauConfigPath.empty()) { //signal taus
 
    std::string theConfig = m_tauConfigPath;
    if( m_tauConfigPath=="default" ){
      if (m_tauId == "rnn001")   theConfig = "SUSYTools/tau_selection_rnn001.conf";
      else if (m_tauId == "VeryLoose")   theConfig = "SUSYTools/tau_selection_veryloose.conf";
      else if (m_tauId == "Loose")  theConfig = "SUSYTools/tau_selection_loose.conf";
      else if (m_tauId == "Medium") theConfig = "SUSYTools/tau_selection_medium.conf";
      else if (m_tauId == "Tight")  theConfig = "SUSYTools/tau_selection_tight.conf";
    }
 
    getTauConfig(theConfig, pT_window, eta_window, elOLR, muVeto, muOLR);
 
    if( m_tauPrePtCut > 0 and (m_tauPrePtCut != 1000*pT_window[0] or (pT_window[1] > 0 and m_tauPrePtCut > 1000*pT_window[1]))) {
      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] << "]");
      if(strict) return StatusCode::FAILURE;
    }
 
    if( m_tauPt > 0 and (m_tauPt != 1000*pT_window[0] or (pT_window[1] > 0 and m_tauPt > 1000*pT_window[1]))) {
      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] << "]");
      if(strict) return StatusCode::FAILURE;
    }
 
    if( m_tauEta > 0 and m_tauEta != eta_window[eta_window.size()-1]) { // eta window can have 4 entries
      ATH_MSG_WARNING("Your tau eta configuration is inconsistent! eta cut : " << m_tauEta << " != TauSelectionTool max eta : " << eta_window[eta_window.size()-1]);
      if(strict) return StatusCode::FAILURE;
    }
  }
 
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

ATLAS_THREAD_SAFE [1/2]

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

mutableprivate

Definition at line 443 of file SUSYObjDef_xAOD.h.

ATLAS_THREAD_SAFE [2/2]

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

mutableprivate

Definition at line 445 of file SUSYObjDef_xAOD.h.

lrt_electrons

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

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

m_acc_eleIdBaseline

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

protected

Definition at line 992 of file SUSYObjDef_xAOD.h.

m_acc_jetClean

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

protected

Definition at line 996 of file SUSYObjDef_xAOD.h.

m_acc_photonId

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

protected

Definition at line 995 of file SUSYObjDef_xAOD.h.

m_acc_photonIdBaseline

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

protected

Definition at line 994 of file SUSYObjDef_xAOD.h.

m_applyJVTCut

bool ST::SUSYObjDef_xAOD::m_applyJVTCut

protected

Definition at line 821 of file SUSYObjDef_xAOD.h.

m_ApplyMVATESQualityCheck

bool ST::SUSYObjDef_xAOD::m_ApplyMVATESQualityCheck

protected

Definition at line 734 of file SUSYObjDef_xAOD.h.

m_autoconfigPRW

bool ST::SUSYObjDef_xAOD::m_autoconfigPRW

protected

Definition at line 592 of file SUSYObjDef_xAOD.h.

m_autoconfigPRWCombinedmode

bool ST::SUSYObjDef_xAOD::m_autoconfigPRWCombinedmode

protected

Definition at line 595 of file SUSYObjDef_xAOD.h.

m_autoconfigPRWFile

std::string ST::SUSYObjDef_xAOD::m_autoconfigPRWFile

protected

Definition at line 594 of file SUSYObjDef_xAOD.h.

m_autoconfigPRWPath

std::string ST::SUSYObjDef_xAOD::m_autoconfigPRWPath

protected

Definition at line 593 of file SUSYObjDef_xAOD.h.

m_autoconfigPRWRPVmode

bool ST::SUSYObjDef_xAOD::m_autoconfigPRWRPVmode

protected

Definition at line 596 of file SUSYObjDef_xAOD.h.

m_autoconfigPRWRtags

std::string ST::SUSYObjDef_xAOD::m_autoconfigPRWRtags

protected

Definition at line 597 of file SUSYObjDef_xAOD.h.

m_badJetCut

std::string ST::SUSYObjDef_xAOD::m_badJetCut

protected

Definition at line 540 of file SUSYObjDef_xAOD.h.

m_badmuQoverP

double ST::SUSYObjDef_xAOD::m_badmuQoverP

protected

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

m_btagEffTool_trkJet

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

protected

Definition at line 926 of file SUSYObjDef_xAOD.h.

m_bTaggingCalibrationFilePath

std::string ST::SUSYObjDef_xAOD::m_bTaggingCalibrationFilePath

protected

Definition at line 823 of file SUSYObjDef_xAOD.h.

m_BtagKeyOverride

std::string ST::SUSYObjDef_xAOD::m_BtagKeyOverride

protected

Definition at line 676 of file SUSYObjDef_xAOD.h.

m_BtagMinPt

double ST::SUSYObjDef_xAOD::m_BtagMinPt

protected

Definition at line 675 of file SUSYObjDef_xAOD.h.

m_BtagMinPt_trkJet

double ST::SUSYObjDef_xAOD::m_BtagMinPt_trkJet

protected

Definition at line 683 of file SUSYObjDef_xAOD.h.

m_btagSelTool

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

protected

Definition at line 924 of file SUSYObjDef_xAOD.h.

m_btagSelTool_OR

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

protected

Definition at line 925 of file SUSYObjDef_xAOD.h.

m_btagSelTool_trkJet

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

protected

Definition at line 927 of file SUSYObjDef_xAOD.h.

m_BtagSystStrategy

std::string ST::SUSYObjDef_xAOD::m_BtagSystStrategy

protected

Definition at line 677 of file SUSYObjDef_xAOD.h.

m_BtagTagger

std::string ST::SUSYObjDef_xAOD::m_BtagTagger

protected

Definition at line 674 of file SUSYObjDef_xAOD.h.

m_BtagTagger_trkJet

std::string ST::SUSYObjDef_xAOD::m_BtagTagger_trkJet

protected

Definition at line 682 of file SUSYObjDef_xAOD.h.

m_BtagWP

std::string ST::SUSYObjDef_xAOD::m_BtagWP

protected

Definition at line 673 of file SUSYObjDef_xAOD.h.

m_BtagWP_trkJet

std::string ST::SUSYObjDef_xAOD::m_BtagWP_trkJet

protected

Definition at line 681 of file SUSYObjDef_xAOD.h.

m_caloMETsyst

bool ST::SUSYObjDef_xAOD::m_caloMETsyst

protected

Definition at line 585 of file SUSYObjDef_xAOD.h.

m_commonPRWFileMC20a

std::string ST::SUSYObjDef_xAOD::m_commonPRWFileMC20a

protected

Definition at line 602 of file SUSYObjDef_xAOD.h.

m_commonPRWFileMC20d

std::string ST::SUSYObjDef_xAOD::m_commonPRWFileMC20d

protected

Definition at line 603 of file SUSYObjDef_xAOD.h.

m_commonPRWFileMC20e

std::string ST::SUSYObjDef_xAOD::m_commonPRWFileMC20e

protected

Definition at line 604 of file SUSYObjDef_xAOD.h.

m_commonPRWFileMC21a

std::string ST::SUSYObjDef_xAOD::m_commonPRWFileMC21a

protected

Definition at line 605 of file SUSYObjDef_xAOD.h.

m_commonPRWFileMC23a

std::string ST::SUSYObjDef_xAOD::m_commonPRWFileMC23a

protected

Definition at line 606 of file SUSYObjDef_xAOD.h.

m_commonPRWFileMC23c

std::string ST::SUSYObjDef_xAOD::m_commonPRWFileMC23c

protected

Definition at line 607 of file SUSYObjDef_xAOD.h.

m_commonPRWFileMC23d

std::string ST::SUSYObjDef_xAOD::m_commonPRWFileMC23d

protected

Definition at line 608 of file SUSYObjDef_xAOD.h.

m_commonPRWFileMC23e

std::string ST::SUSYObjDef_xAOD::m_commonPRWFileMC23e

protected

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

m_currentSyst

CP::SystematicSet ST::SUSYObjDef_xAOD::m_currentSyst

protected

Definition at line 816 of file SUSYObjDef_xAOD.h.

m_dataSource

int ST::SUSYObjDef_xAOD::m_dataSource

protected

Definition at line 515 of file SUSYObjDef_xAOD.h.

m_deadHVTool

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

protected

Definition at line 902 of file SUSYObjDef_xAOD.h.

m_debug

bool ST::SUSYObjDef_xAOD::m_debug

protected

Definition at line 536 of file SUSYObjDef_xAOD.h.

m_defaultJets

std::string ST::SUSYObjDef_xAOD::m_defaultJets

protected

Definition at line 810 of file SUSYObjDef_xAOD.h.

m_defaultSyst

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

protected

Definition at line 815 of file SUSYObjDef_xAOD.h.

m_defaultTrackJets

std::string ST::SUSYObjDef_xAOD::m_defaultTrackJets

protected

Definition at line 811 of file SUSYObjDef_xAOD.h.

m_defaultTruthJets

std::string ST::SUSYObjDef_xAOD::m_defaultTruthJets

protected

Definition at line 813 of file SUSYObjDef_xAOD.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_doElIsoSignal

bool ST::SUSYObjDef_xAOD::m_doElIsoSignal

protected

Definition at line 793 of file SUSYObjDef_xAOD.h.

m_doFwdJVT

bool ST::SUSYObjDef_xAOD::m_doFwdJVT

protected

Definition at line 748 of file SUSYObjDef_xAOD.h.

m_doIsoSignal

bool ST::SUSYObjDef_xAOD::m_doIsoSignal

protected

Definition at line 792 of file SUSYObjDef_xAOD.h.

m_doModifiedEleId

bool ST::SUSYObjDef_xAOD::m_doModifiedEleId

protected

Definition at line 523 of file SUSYObjDef_xAOD.h.

m_doMuIsoSignal

bool ST::SUSYObjDef_xAOD::m_doMuIsoSignal

protected

Definition at line 795 of file SUSYObjDef_xAOD.h.

m_doPhiReso

bool ST::SUSYObjDef_xAOD::m_doPhiReso

protected

Definition at line 590 of file SUSYObjDef_xAOD.h.

m_doPhIsoSignal

bool ST::SUSYObjDef_xAOD::m_doPhIsoSignal

protected

Definition at line 794 of file SUSYObjDef_xAOD.h.

m_doTTVAsf

bool ST::SUSYObjDef_xAOD::m_doTTVAsf

protected

Definition at line 522 of file SUSYObjDef_xAOD.h.

m_EG_corrFNList

std::string ST::SUSYObjDef_xAOD::m_EG_corrFNList

protected

Definition at line 820 of file SUSYObjDef_xAOD.h.

m_EG_corrModel

std::string ST::SUSYObjDef_xAOD::m_EG_corrModel

protected

Definition at line 819 of file SUSYObjDef_xAOD.h.

m_egammaAmbiguityTool

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

protected

Definition at line 912 of file SUSYObjDef_xAOD.h.

m_egammaCalibTool

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

protected

Combined electron collection.

Definition at line 897 of file SUSYObjDef_xAOD.h.

m_EigenvectorReductionB

std::string ST::SUSYObjDef_xAOD::m_EigenvectorReductionB

protected

Definition at line 678 of file SUSYObjDef_xAOD.h.

m_EigenvectorReductionC

std::string ST::SUSYObjDef_xAOD::m_EigenvectorReductionC

protected

Definition at line 679 of file SUSYObjDef_xAOD.h.

m_EigenvectorReductionLight

std::string ST::SUSYObjDef_xAOD::m_EigenvectorReductionLight

protected

Definition at line 680 of file SUSYObjDef_xAOD.h.

m_el_id_support

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

protected

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

m_el_iso_support

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

protected

Definition at line 629 of file SUSYObjDef_xAOD.h.

m_eleAllowRun3TrigSFFallback

bool ST::SUSYObjDef_xAOD::m_eleAllowRun3TrigSFFallback

protected

Definition at line 698 of file SUSYObjDef_xAOD.h.

m_eleBaselineCrackVeto

bool ST::SUSYObjDef_xAOD::m_eleBaselineCrackVeto

protected

Definition at line 688 of file SUSYObjDef_xAOD.h.

m_elebaselined0sig

double ST::SUSYObjDef_xAOD::m_elebaselined0sig

protected

Definition at line 694 of file SUSYObjDef_xAOD.h.

m_eleBaselineEta

double ST::SUSYObjDef_xAOD::m_eleBaselineEta

protected

Definition at line 687 of file SUSYObjDef_xAOD.h.

m_eleBaselineIso_WP

std::string ST::SUSYObjDef_xAOD::m_eleBaselineIso_WP

protected

Definition at line 645 of file SUSYObjDef_xAOD.h.

m_eleBaselinePt

double ST::SUSYObjDef_xAOD::m_eleBaselinePt

protected

Definition at line 686 of file SUSYObjDef_xAOD.h.

m_elebaselinez0

double ST::SUSYObjDef_xAOD::m_elebaselinez0

protected

Definition at line 695 of file SUSYObjDef_xAOD.h.

m_elecChargeEffCorrTool

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

protected

Definition at line 914 of file SUSYObjDef_xAOD.h.

m_elecChargeIDSelectorTool

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

protected

Definition at line 913 of file SUSYObjDef_xAOD.h.

m_elecEfficiencySFTool_chf

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

protected

Definition at line 887 of file SUSYObjDef_xAOD.h.

m_elecEfficiencySFTool_id

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

protected

Definition at line 882 of file SUSYObjDef_xAOD.h.

m_elecEfficiencySFTool_iso

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

protected

Definition at line 885 of file SUSYObjDef_xAOD.h.

m_elecEfficiencySFTool_isoHighPt

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

protected

Definition at line 886 of file SUSYObjDef_xAOD.h.

m_elecEfficiencySFTool_reco

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

protected

Combined muon collection.

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

m_elecEfficiencySFTool_trig_singleLep

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

protected

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

m_elecEfficiencySFTool_trigEff_singleLep

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

protected

Definition at line 884 of file SUSYObjDef_xAOD.h.

m_eleChID_signal

bool ST::SUSYObjDef_xAOD::m_eleChID_signal

protected

Definition at line 660 of file SUSYObjDef_xAOD.h.

m_eleChID_WP

std::string ST::SUSYObjDef_xAOD::m_eleChID_WP

protected

Definition at line 656 of file SUSYObjDef_xAOD.h.

m_eleChIso

bool ST::SUSYObjDef_xAOD::m_eleChIso

protected

Definition at line 659 of file SUSYObjDef_xAOD.h.

m_elecLRTORTool

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

protected

Definition at line 893 of file SUSYObjDef_xAOD.h.

m_eleConfig

std::string ST::SUSYObjDef_xAOD::m_eleConfig

protected

Definition at line 643 of file SUSYObjDef_xAOD.h.

m_eleConfigBaseline

std::string ST::SUSYObjDef_xAOD::m_eleConfigBaseline

protected

Definition at line 644 of file SUSYObjDef_xAOD.h.

m_eleCrackVeto

bool ST::SUSYObjDef_xAOD::m_eleCrackVeto

protected

Definition at line 691 of file SUSYObjDef_xAOD.h.

m_elecSelLikelihood

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

protected

Definition at line 898 of file SUSYObjDef_xAOD.h.

m_elecSelLikelihoodBaseline

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

protected

Definition at line 899 of file SUSYObjDef_xAOD.h.

m_elecTrigEffTools

ToolHandleArray<IAsgElectronEfficiencyCorrectionTool> ST::SUSYObjDef_xAOD::m_elecTrigEffTools

protected

Definition at line 892 of file SUSYObjDef_xAOD.h.

m_elecTrigSFTools

ToolHandleArray<IAsgElectronEfficiencyCorrectionTool> ST::SUSYObjDef_xAOD::m_elecTrigSFTools

protected

Definition at line 891 of file SUSYObjDef_xAOD.h.

m_electronTriggerSFStringSingle

std::string ST::SUSYObjDef_xAOD::m_electronTriggerSFStringSingle

protected

Definition at line 637 of file SUSYObjDef_xAOD.h.

m_eled0sig

double ST::SUSYObjDef_xAOD::m_eled0sig

protected

Definition at line 692 of file SUSYObjDef_xAOD.h.

m_eleEffMapFilePath

std::string ST::SUSYObjDef_xAOD::m_eleEffMapFilePath

protected

Definition at line 696 of file SUSYObjDef_xAOD.h.

m_eleEffMapFilePathRun2

std::string ST::SUSYObjDef_xAOD::m_eleEffMapFilePathRun2

protected

Definition at line 697 of file SUSYObjDef_xAOD.h.

m_eleEta

double ST::SUSYObjDef_xAOD::m_eleEta

protected

Definition at line 690 of file SUSYObjDef_xAOD.h.

m_EleFatJetDR

double ST::SUSYObjDef_xAOD::m_EleFatJetDR

protected

Definition at line 789 of file SUSYObjDef_xAOD.h.

m_eleForceFullSimCalib

bool ST::SUSYObjDef_xAOD::m_eleForceFullSimCalib

protected

Definition at line 699 of file SUSYObjDef_xAOD.h.

m_eleId

std::string ST::SUSYObjDef_xAOD::m_eleId

protected

Definition at line 641 of file SUSYObjDef_xAOD.h.

m_eleIdBaseline

std::string ST::SUSYObjDef_xAOD::m_eleIdBaseline

protected

Definition at line 642 of file SUSYObjDef_xAOD.h.

m_eleIdBaselineDFName

std::string ST::SUSYObjDef_xAOD::m_eleIdBaselineDFName

protected

Definition at line 986 of file SUSYObjDef_xAOD.h.

m_eleIdDFName

std::string ST::SUSYObjDef_xAOD::m_eleIdDFName

protected

Definition at line 987 of file SUSYObjDef_xAOD.h.

m_eleIdExpert

bool ST::SUSYObjDef_xAOD::m_eleIdExpert

protected

Definition at line 646 of file SUSYObjDef_xAOD.h.

m_eleIso_WP

std::string ST::SUSYObjDef_xAOD::m_eleIso_WP

protected

Definition at line 653 of file SUSYObjDef_xAOD.h.

m_eleIsoHighPt_WP

std::string ST::SUSYObjDef_xAOD::m_eleIsoHighPt_WP

protected

Definition at line 654 of file SUSYObjDef_xAOD.h.

m_eleIsoHighPtThresh

double ST::SUSYObjDef_xAOD::m_eleIsoHighPtThresh

protected

Definition at line 655 of file SUSYObjDef_xAOD.h.

m_eleLRT

bool ST::SUSYObjDef_xAOD::m_eleLRT

protected

Definition at line 657 of file SUSYObjDef_xAOD.h.

m_eleLRT_strat

int ST::SUSYObjDef_xAOD::m_eleLRT_strat

protected

Definition at line 658 of file SUSYObjDef_xAOD.h.

m_elePt

double ST::SUSYObjDef_xAOD::m_elePt

protected

Definition at line 689 of file SUSYObjDef_xAOD.h.

m_eleTerm

std::string ST::SUSYObjDef_xAOD::m_eleTerm

protected

Definition at line 565 of file SUSYObjDef_xAOD.h.

m_elez0

double ST::SUSYObjDef_xAOD::m_elez0

protected

Definition at line 693 of file SUSYObjDef_xAOD.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_fatjetFFSmearingSyst

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

protected

Definition at line 817 of file SUSYObjDef_xAOD.h.

m_fatjetFFSmearingTool

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

protected

Definition at line 834 of file SUSYObjDef_xAOD.h.

m_fatJets

std::string ST::SUSYObjDef_xAOD::m_fatJets

protected

Definition at line 812 of file SUSYObjDef_xAOD.h.

m_fatJetUncConfig

std::string ST::SUSYObjDef_xAOD::m_fatJetUncConfig

protected

Definition at line 542 of file SUSYObjDef_xAOD.h.

m_fatJetUncertaintiesMCType

std::string ST::SUSYObjDef_xAOD::m_fatJetUncertaintiesMCType

protected

Definition at line 531 of file SUSYObjDef_xAOD.h.

m_fatJetUncertaintiesPDsmearing

bool ST::SUSYObjDef_xAOD::m_fatJetUncertaintiesPDsmearing

protected

Definition at line 543 of file SUSYObjDef_xAOD.h.

m_fatjetUncertaintiesPDSmearTool

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

protected

Definition at line 833 of file SUSYObjDef_xAOD.h.

m_fatjetUncertaintiesTool

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

protected

Definition at line 832 of file SUSYObjDef_xAOD.h.

m_fatJetUncVars

std::string ST::SUSYObjDef_xAOD::m_fatJetUncVars

protected

Definition at line 544 of file SUSYObjDef_xAOD.h.

m_fJvtConfigRun2

std::string ST::SUSYObjDef_xAOD::m_fJvtConfigRun2

protected

Definition at line 752 of file SUSYObjDef_xAOD.h.

m_fJvtConfigRun3

std::string ST::SUSYObjDef_xAOD::m_fJvtConfigRun3

protected

Definition at line 753 of file SUSYObjDef_xAOD.h.

m_fJvtEtaMin

double ST::SUSYObjDef_xAOD::m_fJvtEtaMin

protected

Definition at line 751 of file SUSYObjDef_xAOD.h.

m_fJvtPtMax

double ST::SUSYObjDef_xAOD::m_fJvtPtMax

protected

Definition at line 750 of file SUSYObjDef_xAOD.h.

m_fJvtWP

std::string ST::SUSYObjDef_xAOD::m_fJvtWP

protected

Definition at line 749 of file SUSYObjDef_xAOD.h.

m_force_noElId

bool ST::SUSYObjDef_xAOD::m_force_noElId

protected

Definition at line 520 of file SUSYObjDef_xAOD.h.

m_force_noMuId

bool ST::SUSYObjDef_xAOD::m_force_noMuId

protected

Definition at line 521 of file SUSYObjDef_xAOD.h.

m_gammaTerm

std::string ST::SUSYObjDef_xAOD::m_gammaTerm

protected

Definition at line 566 of file SUSYObjDef_xAOD.h.

m_GSFLRTCollectionName

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

private

Definition at line 478 of file SUSYObjDef_xAOD.h.

m_inputMetaStore

MetaStore_t asg::AsgMetadataTool::m_inputMetaStore

privateinherited

Object accessing the input metadata store.

Definition at line 119 of file AsgMetadataTool.h.

m_inputMETCore

std::string ST::SUSYObjDef_xAOD::m_inputMETCore

protected

Definition at line 572 of file SUSYObjDef_xAOD.h.

m_inputMETMap

std::string ST::SUSYObjDef_xAOD::m_inputMETMap

protected

Definition at line 571 of file SUSYObjDef_xAOD.h.

m_inputMETRef

std::string ST::SUSYObjDef_xAOD::m_inputMETRef

protected

Definition at line 573 of file SUSYObjDef_xAOD.h.

m_inputMETSuffix

std::string ST::SUSYObjDef_xAOD::m_inputMETSuffix

protected

Definition at line 570 of file SUSYObjDef_xAOD.h.

m_isoBaselineTool

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

protected

Definition at line 972 of file SUSYObjDef_xAOD.h.

m_IsoCloseByORpassLabel

std::string ST::SUSYObjDef_xAOD::m_IsoCloseByORpassLabel

protected

Definition at line 798 of file SUSYObjDef_xAOD.h.

m_isoCloseByTool

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

protected

Definition at line 974 of file SUSYObjDef_xAOD.h.

m_isoCorrTool

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

protected

Definition at line 969 of file SUSYObjDef_xAOD.h.

m_isoHighPtTool

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

protected

Definition at line 973 of file SUSYObjDef_xAOD.h.

m_isoTool

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

protected

Definition at line 970 of file SUSYObjDef_xAOD.h.

m_isPHYSLITE

bool ST::SUSYObjDef_xAOD::m_isPHYSLITE

protected

Definition at line 804 of file SUSYObjDef_xAOD.h.

m_isRun3

bool ST::SUSYObjDef_xAOD::m_isRun3

protected

Definition at line 803 of file SUSYObjDef_xAOD.h.

m_jesCalibArea

std::string ST::SUSYObjDef_xAOD::m_jesCalibArea

protected

Definition at line 865 of file SUSYObjDef_xAOD.h.

m_jesCalibSeq

std::string ST::SUSYObjDef_xAOD::m_jesCalibSeq

protected

Definition at line 862 of file SUSYObjDef_xAOD.h.

m_jesCalibSeqFat

std::string ST::SUSYObjDef_xAOD::m_jesCalibSeqFat

protected

Definition at line 864 of file SUSYObjDef_xAOD.h.

m_jesCalibSeqJMS

std::string ST::SUSYObjDef_xAOD::m_jesCalibSeqJMS

protected

Definition at line 863 of file SUSYObjDef_xAOD.h.

m_jesConfig

std::string ST::SUSYObjDef_xAOD::m_jesConfig

protected

Definition at line 856 of file SUSYObjDef_xAOD.h.

m_jesConfigAFII

std::string ST::SUSYObjDef_xAOD::m_jesConfigAFII

protected

Definition at line 859 of file SUSYObjDef_xAOD.h.

m_jesConfigFat

std::string ST::SUSYObjDef_xAOD::m_jesConfigFat

protected

Definition at line 860 of file SUSYObjDef_xAOD.h.

m_jesConfigFatData

std::string ST::SUSYObjDef_xAOD::m_jesConfigFatData

protected

Definition at line 861 of file SUSYObjDef_xAOD.h.

m_jesConfigJMS

std::string ST::SUSYObjDef_xAOD::m_jesConfigJMS

protected

Definition at line 857 of file SUSYObjDef_xAOD.h.

m_jesConfigJMSData

std::string ST::SUSYObjDef_xAOD::m_jesConfigJMSData

protected

Definition at line 858 of file SUSYObjDef_xAOD.h.

m_jetCalibTool

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

protected

Definition at line 828 of file SUSYObjDef_xAOD.h.

m_jetCleanDFName

std::string ST::SUSYObjDef_xAOD::m_jetCleanDFName

protected

Definition at line 990 of file SUSYObjDef_xAOD.h.

m_jetCleaningTool

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

protected

Definition at line 835 of file SUSYObjDef_xAOD.h.

m_jetEta

double ST::SUSYObjDef_xAOD::m_jetEta

protected

Definition at line 738 of file SUSYObjDef_xAOD.h.

m_jetFatCalibTool

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

protected

Definition at line 829 of file SUSYObjDef_xAOD.h.

m_JetFatJetDR

double ST::SUSYObjDef_xAOD::m_JetFatJetDR

protected

Definition at line 790 of file SUSYObjDef_xAOD.h.

m_jetfJvtEfficiencyTool

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

protected

Definition at line 843 of file SUSYObjDef_xAOD.h.

m_jetfJvtSelectionTool

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

protected

Definition at line 842 of file SUSYObjDef_xAOD.h.

m_jetInputType

int ST::SUSYObjDef_xAOD::m_jetInputType

protected

Definition at line 516 of file SUSYObjDef_xAOD.h.

m_jetJvt

double ST::SUSYObjDef_xAOD::m_jetJvt

protected

Definition at line 739 of file SUSYObjDef_xAOD.h.

m_jetJvtMomentTool

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

protected

Definition at line 838 of file SUSYObjDef_xAOD.h.

m_jetNNJvtEfficiencyTool

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

protected

Definition at line 841 of file SUSYObjDef_xAOD.h.

m_jetNNJvtMomentTool

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

protected

Definition at line 839 of file SUSYObjDef_xAOD.h.

m_jetNNJvtSelectionTool

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

protected

Definition at line 840 of file SUSYObjDef_xAOD.h.

m_jetPileupLabelingTool

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

protected

Definition at line 837 of file SUSYObjDef_xAOD.h.

m_jetPt

double ST::SUSYObjDef_xAOD::m_jetPt

protected

Definition at line 737 of file SUSYObjDef_xAOD.h.

m_jetTerm

std::string ST::SUSYObjDef_xAOD::m_jetTerm

protected

Definition at line 568 of file SUSYObjDef_xAOD.h.

m_jetTruthLabelingTool

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

protected

Definition at line 848 of file SUSYObjDef_xAOD.h.

m_JetTruthLabelName

std::string ST::SUSYObjDef_xAOD::m_JetTruthLabelName

protected

Definition at line 560 of file SUSYObjDef_xAOD.h.

m_jetUncertaintiesAnalysisFile

std::string ST::SUSYObjDef_xAOD::m_jetUncertaintiesAnalysisFile

protected

Definition at line 528 of file SUSYObjDef_xAOD.h.

m_jetUncertaintiesCalibArea

std::string ST::SUSYObjDef_xAOD::m_jetUncertaintiesCalibArea

protected

Definition at line 529 of file SUSYObjDef_xAOD.h.

m_jetUncertaintiesConfig

std::string ST::SUSYObjDef_xAOD::m_jetUncertaintiesConfig

protected

Prefix for trigger matchiing container name.

Definition at line 527 of file SUSYObjDef_xAOD.h.

m_jetUncertaintiesMCType

std::string ST::SUSYObjDef_xAOD::m_jetUncertaintiesMCType

protected

Definition at line 530 of file SUSYObjDef_xAOD.h.

m_jetUncertaintiesPDsmearing

bool ST::SUSYObjDef_xAOD::m_jetUncertaintiesPDsmearing

protected

Definition at line 532 of file SUSYObjDef_xAOD.h.

m_jetUncertaintiesPDSmearTool

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

protected

Definition at line 831 of file SUSYObjDef_xAOD.h.

m_jetUncertaintiesTool

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

protected

Definition at line 830 of file SUSYObjDef_xAOD.h.

m_JMScalib

bool ST::SUSYObjDef_xAOD::m_JMScalib

protected

Definition at line 755 of file SUSYObjDef_xAOD.h.

m_JvtConfigRun2

std::string ST::SUSYObjDef_xAOD::m_JvtConfigRun2

protected

Definition at line 742 of file SUSYObjDef_xAOD.h.

m_JvtConfigRun3

std::string ST::SUSYObjDef_xAOD::m_JvtConfigRun3

protected

Definition at line 743 of file SUSYObjDef_xAOD.h.

m_JvtPtMax

double ST::SUSYObjDef_xAOD::m_JvtPtMax

protected

Definition at line 741 of file SUSYObjDef_xAOD.h.

m_JvtWP

std::string ST::SUSYObjDef_xAOD::m_JvtWP

protected

Definition at line 740 of file SUSYObjDef_xAOD.h.

m_label_truthKey

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

protected

Definition at line 853 of file SUSYObjDef_xAOD.h.

m_legsPerTool

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

protected

Definition at line 825 of file SUSYObjDef_xAOD.h.

m_legsPerTool_ph

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

protected

Definition at line 826 of file SUSYObjDef_xAOD.h.

m_LRTCollectionName

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

private

Definition at line 477 of file SUSYObjDef_xAOD.h.

m_LRTuncTool

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

protected

Definition at line 978 of file SUSYObjDef_xAOD.h.

m_mcCampaign

std::string ST::SUSYObjDef_xAOD::m_mcCampaign

protected

Definition at line 598 of file SUSYObjDef_xAOD.h.

m_mcChannel

int ST::SUSYObjDef_xAOD::m_mcChannel

protected

Definition at line 599 of file SUSYObjDef_xAOD.h.

m_metDoMuonEloss

bool ST::SUSYObjDef_xAOD::m_metDoMuonEloss

protected

Definition at line 579 of file SUSYObjDef_xAOD.h.

m_metDoRemoveMuonJets

bool ST::SUSYObjDef_xAOD::m_metDoRemoveMuonJets

protected

Definition at line 577 of file SUSYObjDef_xAOD.h.

m_metDoSetMuonJetEMScale

bool ST::SUSYObjDef_xAOD::m_metDoSetMuonJetEMScale

protected

Definition at line 576 of file SUSYObjDef_xAOD.h.

m_metGreedyPhotons

bool ST::SUSYObjDef_xAOD::m_metGreedyPhotons

protected

Definition at line 580 of file SUSYObjDef_xAOD.h.

m_metJetSelection

std::string ST::SUSYObjDef_xAOD::m_metJetSelection

protected

Definition at line 806 of file SUSYObjDef_xAOD.h.

m_metMaker

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

protected

Definition at line 929 of file SUSYObjDef_xAOD.h.

m_metRemoveOverlappingCaloTaggedMuons

bool ST::SUSYObjDef_xAOD::m_metRemoveOverlappingCaloTaggedMuons

protected

Definition at line 575 of file SUSYObjDef_xAOD.h.

m_metSignif

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

protected

Definition at line 931 of file SUSYObjDef_xAOD.h.

m_metsysConfigPrefix

std::string ST::SUSYObjDef_xAOD::m_metsysConfigPrefix

protected

Definition at line 582 of file SUSYObjDef_xAOD.h.

m_metSystTool

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

protected

Definition at line 930 of file SUSYObjDef_xAOD.h.

m_metUseGhostMuons

bool ST::SUSYObjDef_xAOD::m_metUseGhostMuons

protected

Definition at line 578 of file SUSYObjDef_xAOD.h.

m_metVeryGreedyPhotons

bool ST::SUSYObjDef_xAOD::m_metVeryGreedyPhotons

protected

Definition at line 581 of file SUSYObjDef_xAOD.h.

m_mu_id_support

int ST::SUSYObjDef_xAOD::m_mu_id_support

protected

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

m_mu_iso_support

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

protected

Definition at line 630 of file SUSYObjDef_xAOD.h.

m_mubaselined0sig

double ST::SUSYObjDef_xAOD::m_mubaselined0sig

protected

Definition at line 708 of file SUSYObjDef_xAOD.h.

m_muBaselineEta

double ST::SUSYObjDef_xAOD::m_muBaselineEta

protected

Definition at line 703 of file SUSYObjDef_xAOD.h.

m_muBaselineIso_WP

std::string ST::SUSYObjDef_xAOD::m_muBaselineIso_WP

protected

Definition at line 665 of file SUSYObjDef_xAOD.h.

m_muBaselinePt

double ST::SUSYObjDef_xAOD::m_muBaselinePt

protected

Definition at line 702 of file SUSYObjDef_xAOD.h.

m_mubaselinez0

double ST::SUSYObjDef_xAOD::m_mubaselinez0

protected

Definition at line 709 of file SUSYObjDef_xAOD.h.

m_muCalibrationMode

int ST::SUSYObjDef_xAOD::m_muCalibrationMode

protected

Definition at line 714 of file SUSYObjDef_xAOD.h.

m_muCosmicd0

double ST::SUSYObjDef_xAOD::m_muCosmicd0

protected

Definition at line 712 of file SUSYObjDef_xAOD.h.

m_muCosmicz0

double ST::SUSYObjDef_xAOD::m_muCosmicz0

protected

Definition at line 711 of file SUSYObjDef_xAOD.h.

m_mud0sig

double ST::SUSYObjDef_xAOD::m_mud0sig

protected

Definition at line 706 of file SUSYObjDef_xAOD.h.

m_muEffCorrForce1D

bool ST::SUSYObjDef_xAOD::m_muEffCorrForce1D

protected

Definition at line 670 of file SUSYObjDef_xAOD.h.

m_muEta

double ST::SUSYObjDef_xAOD::m_muEta

protected

Definition at line 705 of file SUSYObjDef_xAOD.h.

m_muHighPtExtraSmear

bool ST::SUSYObjDef_xAOD::m_muHighPtExtraSmear

protected

Definition at line 669 of file SUSYObjDef_xAOD.h.

m_muId

int ST::SUSYObjDef_xAOD::m_muId

protected

Definition at line 647 of file SUSYObjDef_xAOD.h.

m_muIdBaseline

int ST::SUSYObjDef_xAOD::m_muIdBaseline

protected

Definition at line 648 of file SUSYObjDef_xAOD.h.

m_muIso_WP

std::string ST::SUSYObjDef_xAOD::m_muIso_WP

protected

Definition at line 666 of file SUSYObjDef_xAOD.h.

m_muIsoHighPt_WP

std::string ST::SUSYObjDef_xAOD::m_muIsoHighPt_WP

protected

Definition at line 667 of file SUSYObjDef_xAOD.h.

m_muIsoHighPtThresh

double ST::SUSYObjDef_xAOD::m_muIsoHighPtThresh

protected

Definition at line 668 of file SUSYObjDef_xAOD.h.

m_muLRT

bool ST::SUSYObjDef_xAOD::m_muLRT

protected

Definition at line 715 of file SUSYObjDef_xAOD.h.

m_muonCalibTool

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

protected

Definition at line 870 of file SUSYObjDef_xAOD.h.

m_muonEfficiencyBMHighPtSFTool

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

protected

Definition at line 872 of file SUSYObjDef_xAOD.h.

m_muonEfficiencySFTool

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

protected

Definition at line 871 of file SUSYObjDef_xAOD.h.

m_muonHighPtIsolationSFTool

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

protected

Definition at line 875 of file SUSYObjDef_xAOD.h.

m_muonIsolationSFTool

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

protected

Definition at line 874 of file SUSYObjDef_xAOD.h.

m_muonLRTORTool

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

protected

Definition at line 878 of file SUSYObjDef_xAOD.h.

m_muonSelectionHighPtTool

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

protected

Definition at line 868 of file SUSYObjDef_xAOD.h.

m_muonSelectionTool

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

protected

Definition at line 867 of file SUSYObjDef_xAOD.h.

m_muonSelectionToolBaseline

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

protected

Definition at line 869 of file SUSYObjDef_xAOD.h.

m_muonTerm

std::string ST::SUSYObjDef_xAOD::m_muonTerm

protected

Definition at line 569 of file SUSYObjDef_xAOD.h.

m_muonTriggerSFTool

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

protected

Definition at line 876 of file SUSYObjDef_xAOD.h.

m_muonTrigSFTools

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

protected

Definition at line 877 of file SUSYObjDef_xAOD.h.

m_muonTTVAEfficiencySFTool

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

protected

Definition at line 873 of file SUSYObjDef_xAOD.h.

m_muPt

double ST::SUSYObjDef_xAOD::m_muPt

protected

Definition at line 704 of file SUSYObjDef_xAOD.h.

m_murequirepassedHighPtCuts

bool ST::SUSYObjDef_xAOD::m_murequirepassedHighPtCuts

protected

Definition at line 710 of file SUSYObjDef_xAOD.h.

m_muTriggerSFCalibFilename

std::string ST::SUSYObjDef_xAOD::m_muTriggerSFCalibFilename

protected

Definition at line 672 of file SUSYObjDef_xAOD.h.

m_muTriggerSFCalibRelease

std::string ST::SUSYObjDef_xAOD::m_muTriggerSFCalibRelease

protected

Definition at line 671 of file SUSYObjDef_xAOD.h.

m_muz0

double ST::SUSYObjDef_xAOD::m_muz0

protected

Definition at line 707 of file SUSYObjDef_xAOD.h.

m_orApplyRelPt

bool ST::SUSYObjDef_xAOD::m_orApplyRelPt

protected

Definition at line 776 of file SUSYObjDef_xAOD.h.

m_orBJetPtUpperThres

double ST::SUSYObjDef_xAOD::m_orBJetPtUpperThres

protected

Definition at line 785 of file SUSYObjDef_xAOD.h.

m_orBoostedElectronC1

double ST::SUSYObjDef_xAOD::m_orBoostedElectronC1

protected

Definition at line 769 of file SUSYObjDef_xAOD.h.

m_orBoostedElectronC2

double ST::SUSYObjDef_xAOD::m_orBoostedElectronC2

protected

Definition at line 770 of file SUSYObjDef_xAOD.h.

m_orBoostedElectronMaxConeSize

double ST::SUSYObjDef_xAOD::m_orBoostedElectronMaxConeSize

protected

Definition at line 771 of file SUSYObjDef_xAOD.h.

m_orBoostedMuonC1

double ST::SUSYObjDef_xAOD::m_orBoostedMuonC1

protected

Definition at line 773 of file SUSYObjDef_xAOD.h.

m_orBoostedMuonC2

double ST::SUSYObjDef_xAOD::m_orBoostedMuonC2

protected

Definition at line 774 of file SUSYObjDef_xAOD.h.

m_orBoostedMuonMaxConeSize

double ST::SUSYObjDef_xAOD::m_orBoostedMuonMaxConeSize

protected

Definition at line 775 of file SUSYObjDef_xAOD.h.

m_orBtagWP

std::string ST::SUSYObjDef_xAOD::m_orBtagWP

protected

Definition at line 782 of file SUSYObjDef_xAOD.h.

m_orDoBjet

bool ST::SUSYObjDef_xAOD::m_orDoBjet

protected

Definition at line 764 of file SUSYObjDef_xAOD.h.

m_orDoBoostedElectron

bool ST::SUSYObjDef_xAOD::m_orDoBoostedElectron

protected

Definition at line 768 of file SUSYObjDef_xAOD.h.

m_orDoBoostedMuon

bool ST::SUSYObjDef_xAOD::m_orDoBoostedMuon

protected

Definition at line 772 of file SUSYObjDef_xAOD.h.

m_orDoElBjet

bool ST::SUSYObjDef_xAOD::m_orDoElBjet

protected

Definition at line 765 of file SUSYObjDef_xAOD.h.

m_orDoEleJet

bool ST::SUSYObjDef_xAOD::m_orDoEleJet

protected

Definition at line 760 of file SUSYObjDef_xAOD.h.

m_orDoElEl

bool ST::SUSYObjDef_xAOD::m_orDoElEl

protected

Definition at line 761 of file SUSYObjDef_xAOD.h.

m_orDoElMu

bool ST::SUSYObjDef_xAOD::m_orDoElMu

protected

Definition at line 762 of file SUSYObjDef_xAOD.h.

m_orDoFatjets

bool ST::SUSYObjDef_xAOD::m_orDoFatjets

protected

Definition at line 788 of file SUSYObjDef_xAOD.h.

m_orDoMuBjet

bool ST::SUSYObjDef_xAOD::m_orDoMuBjet

protected

Definition at line 766 of file SUSYObjDef_xAOD.h.

m_orDoMuonJet

bool ST::SUSYObjDef_xAOD::m_orDoMuonJet

protected

Definition at line 763 of file SUSYObjDef_xAOD.h.

m_orDoMuonJetGhostAssociation

bool ST::SUSYObjDef_xAOD::m_orDoMuonJetGhostAssociation

protected

Definition at line 780 of file SUSYObjDef_xAOD.h.

m_orDoPhoton

bool ST::SUSYObjDef_xAOD::m_orDoPhoton

protected

Definition at line 759 of file SUSYObjDef_xAOD.h.

m_orDoTau

bool ST::SUSYObjDef_xAOD::m_orDoTau

protected

Overlap removal options.

Definition at line 758 of file SUSYObjDef_xAOD.h.

m_orDoTauBjet

bool ST::SUSYObjDef_xAOD::m_orDoTauBjet

protected

Definition at line 767 of file SUSYObjDef_xAOD.h.

m_orInputLabel

std::string ST::SUSYObjDef_xAOD::m_orInputLabel

protected

Definition at line 783 of file SUSYObjDef_xAOD.h.

m_orLinkOverlapObjects

bool ST::SUSYObjDef_xAOD::m_orLinkOverlapObjects

protected

Definition at line 786 of file SUSYObjDef_xAOD.h.

m_orMuJetInnerDR

double ST::SUSYObjDef_xAOD::m_orMuJetInnerDR

protected

Definition at line 779 of file SUSYObjDef_xAOD.h.

m_orMuJetPtRatio

double ST::SUSYObjDef_xAOD::m_orMuJetPtRatio

protected

Definition at line 777 of file SUSYObjDef_xAOD.h.

m_orMuJetTrkPtRatio

double ST::SUSYObjDef_xAOD::m_orMuJetTrkPtRatio

protected

Definition at line 778 of file SUSYObjDef_xAOD.h.

m_orPhotonFavoured

bool ST::SUSYObjDef_xAOD::m_orPhotonFavoured

protected

Definition at line 784 of file SUSYObjDef_xAOD.h.

m_orRemoveCaloMuons

bool ST::SUSYObjDef_xAOD::m_orRemoveCaloMuons

protected

Definition at line 781 of file SUSYObjDef_xAOD.h.

m_orToolbox

ORUtils::ToolBox ST::SUSYObjDef_xAOD::m_orToolbox

protected

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

m_outMETTerm

std::string ST::SUSYObjDef_xAOD::m_outMETTerm

protected

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

m_outputMetaStore

MetaStore_t asg::AsgMetadataTool::m_outputMetaStore

privateinherited

Object accessing the output metadata store.

Definition at line 121 of file AsgMetadataTool.h.

m_ph_id_support

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

protected

Definition at line 626 of file SUSYObjDef_xAOD.h.

m_photonAllowLate

bool ST::SUSYObjDef_xAOD::m_photonAllowLate

protected

Definition at line 723 of file SUSYObjDef_xAOD.h.

m_photonBaselineCrackVeto

bool ST::SUSYObjDef_xAOD::m_photonBaselineCrackVeto

protected

Definition at line 721 of file SUSYObjDef_xAOD.h.

m_photonBaselineEta

double ST::SUSYObjDef_xAOD::m_photonBaselineEta

protected

Definition at line 718 of file SUSYObjDef_xAOD.h.

m_photonBaselineIso_WP

std::string ST::SUSYObjDef_xAOD::m_photonBaselineIso_WP

protected

Definition at line 662 of file SUSYObjDef_xAOD.h.

m_photonBaselinePt

double ST::SUSYObjDef_xAOD::m_photonBaselinePt

protected

Definition at line 717 of file SUSYObjDef_xAOD.h.

m_photonCrackVeto

bool ST::SUSYObjDef_xAOD::m_photonCrackVeto

protected

Definition at line 722 of file SUSYObjDef_xAOD.h.

m_photonEfficiencySFTool

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

protected

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

m_photonEta

double ST::SUSYObjDef_xAOD::m_photonEta

protected

Definition at line 719 of file SUSYObjDef_xAOD.h.

m_photonId

std::string ST::SUSYObjDef_xAOD::m_photonId

protected

Definition at line 649 of file SUSYObjDef_xAOD.h.

m_photonIdBaseline

std::string ST::SUSYObjDef_xAOD::m_photonIdBaseline

protected

Definition at line 650 of file SUSYObjDef_xAOD.h.

m_photonIdBaselineDFName

std::string ST::SUSYObjDef_xAOD::m_photonIdBaselineDFName

protected

Definition at line 988 of file SUSYObjDef_xAOD.h.

m_photonIdDFName

std::string ST::SUSYObjDef_xAOD::m_photonIdDFName

protected

Definition at line 989 of file SUSYObjDef_xAOD.h.

m_photonIso_WP

std::string ST::SUSYObjDef_xAOD::m_photonIso_WP

protected

Definition at line 663 of file SUSYObjDef_xAOD.h.

m_photonIsolationSFTool

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

protected

Definition at line 904 of file SUSYObjDef_xAOD.h.

m_photonPt

double ST::SUSYObjDef_xAOD::m_photonPt

protected

Definition at line 720 of file SUSYObjDef_xAOD.h.

m_photonSelIsEM

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

protected

Definition at line 900 of file SUSYObjDef_xAOD.h.

m_photonSelIsEMBaseline

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

protected

Definition at line 901 of file SUSYObjDef_xAOD.h.

m_photonTrigEffTools

ToolHandleArray<IAsgPhotonEfficiencyCorrectionTool> ST::SUSYObjDef_xAOD::m_photonTrigEffTools

protected

Definition at line 910 of file SUSYObjDef_xAOD.h.

m_photonTriggerName

std::string ST::SUSYObjDef_xAOD::m_photonTriggerName

protected

Definition at line 664 of file SUSYObjDef_xAOD.h.

m_photonTriggerSFTool

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

protected

Definition at line 905 of file SUSYObjDef_xAOD.h.

m_photonTrigSFTools

ToolHandleArray<IAsgPhotonEfficiencyCorrectionTool> ST::SUSYObjDef_xAOD::m_photonTrigSFTools

protected

Definition at line 909 of file SUSYObjDef_xAOD.h.

m_pmgSHnjetWeighter

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

protected

Definition at line 983 of file SUSYObjDef_xAOD.h.

m_pmgSHnjetWeighterWZ

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

protected

Definition at line 984 of file SUSYObjDef_xAOD.h.

m_prwActualMu2017File

std::string ST::SUSYObjDef_xAOD::m_prwActualMu2017File

protected

Definition at line 613 of file SUSYObjDef_xAOD.h.

m_prwActualMu2018File

std::string ST::SUSYObjDef_xAOD::m_prwActualMu2018File

protected

Definition at line 614 of file SUSYObjDef_xAOD.h.

m_prwActualMu2022File

std::string ST::SUSYObjDef_xAOD::m_prwActualMu2022File

protected

Definition at line 615 of file SUSYObjDef_xAOD.h.

m_prwActualMu2023File

std::string ST::SUSYObjDef_xAOD::m_prwActualMu2023File

protected

Definition at line 616 of file SUSYObjDef_xAOD.h.

m_prwActualMu2024File

std::string ST::SUSYObjDef_xAOD::m_prwActualMu2024File

protected

Definition at line 617 of file SUSYObjDef_xAOD.h.

m_prwConfFiles

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

protected

Definition at line 611 of file SUSYObjDef_xAOD.h.

m_prwDataSF

double ST::SUSYObjDef_xAOD::m_prwDataSF

protected

Definition at line 619 of file SUSYObjDef_xAOD.h.

m_prwDataSF_DW

double ST::SUSYObjDef_xAOD::m_prwDataSF_DW

protected

Definition at line 621 of file SUSYObjDef_xAOD.h.

m_prwDataSF_UP

double ST::SUSYObjDef_xAOD::m_prwDataSF_UP

protected

Definition at line 620 of file SUSYObjDef_xAOD.h.

m_prwLcalcFiles

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

protected

Definition at line 612 of file SUSYObjDef_xAOD.h.

m_prwTool

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

protected

Definition at line 976 of file SUSYObjDef_xAOD.h.

m_runDepPrescaleWeightPRW

bool ST::SUSYObjDef_xAOD::m_runDepPrescaleWeightPRW

protected

Definition at line 622 of file SUSYObjDef_xAOD.h.

m_runECIS

bool ST::SUSYObjDef_xAOD::m_runECIS

protected

Definition at line 661 of file SUSYObjDef_xAOD.h.

m_showerType

int ST::SUSYObjDef_xAOD::m_showerType

protected

Definition at line 808 of file SUSYObjDef_xAOD.h.

m_slices

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

protected

Definition at line 802 of file SUSYObjDef_xAOD.h.

m_softTermParam

int ST::SUSYObjDef_xAOD::m_softTermParam

protected

Definition at line 588 of file SUSYObjDef_xAOD.h.

m_strictConfigCheck

bool ST::SUSYObjDef_xAOD::m_strictConfigCheck

protected

Definition at line 538 of file SUSYObjDef_xAOD.h.

m_subtool_init

bool ST::SUSYObjDef_xAOD::m_subtool_init

protected

Definition at line 563 of file SUSYObjDef_xAOD.h.

m_tau_id_support

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

protected

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

m_tauConfigPath

std::string ST::SUSYObjDef_xAOD::m_tauConfigPath

protected

Definition at line 728 of file SUSYObjDef_xAOD.h.

m_tauConfigPathBaseline

std::string ST::SUSYObjDef_xAOD::m_tauConfigPathBaseline

protected

Definition at line 729 of file SUSYObjDef_xAOD.h.

m_tauConfigReader

TEnv ST::SUSYObjDef_xAOD::m_tauConfigReader

protected

Definition at line 735 of file SUSYObjDef_xAOD.h.

m_tauDoTTM

bool ST::SUSYObjDef_xAOD::m_tauDoTTM

protected

Definition at line 730 of file SUSYObjDef_xAOD.h.

m_tauEffTool

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

protected

Definition at line 920 of file SUSYObjDef_xAOD.h.

m_tauEffToolRecommendationTag

std::string ST::SUSYObjDef_xAOD::m_tauEffToolRecommendationTag

protected

Definition at line 732 of file SUSYObjDef_xAOD.h.

m_tauEta

double ST::SUSYObjDef_xAOD::m_tauEta

protected

Definition at line 727 of file SUSYObjDef_xAOD.h.

m_tauId

std::string ST::SUSYObjDef_xAOD::m_tauId

protected

Definition at line 651 of file SUSYObjDef_xAOD.h.

m_tauIdBaseline

std::string ST::SUSYObjDef_xAOD::m_tauIdBaseline

protected

Definition at line 652 of file SUSYObjDef_xAOD.h.

m_tauJetORtool

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

protected

Definition at line 980 of file SUSYObjDef_xAOD.h.

m_tauPrePtCut

double ST::SUSYObjDef_xAOD::m_tauPrePtCut

protected

Definition at line 725 of file SUSYObjDef_xAOD.h.

m_tauPt

double ST::SUSYObjDef_xAOD::m_tauPt

protected

Definition at line 726 of file SUSYObjDef_xAOD.h.

m_tauSelTool

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

protected

Definition at line 916 of file SUSYObjDef_xAOD.h.

m_tauSelToolBaseline

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

protected

Definition at line 917 of file SUSYObjDef_xAOD.h.

m_tauSmearingTool

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

protected

Definition at line 918 of file SUSYObjDef_xAOD.h.

m_tauSmearingToolGenerator

std::string ST::SUSYObjDef_xAOD::m_tauSmearingToolGenerator

protected

Definition at line 733 of file SUSYObjDef_xAOD.h.

m_tauSmearingToolRecommendationTag

std::string ST::SUSYObjDef_xAOD::m_tauSmearingToolRecommendationTag

protected

Definition at line 731 of file SUSYObjDef_xAOD.h.

m_tauTerm

std::string ST::SUSYObjDef_xAOD::m_tauTerm

protected

Definition at line 567 of file SUSYObjDef_xAOD.h.

m_tauTrigEffTool

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

protected

Definition at line 921 of file SUSYObjDef_xAOD.h.

m_tauTruthMatch

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

protected

Definition at line 919 of file SUSYObjDef_xAOD.h.

m_tool_init

bool ST::SUSYObjDef_xAOD::m_tool_init

protected

Definition at line 562 of file SUSYObjDef_xAOD.h.

m_TopconfigReader

TEnv ST::SUSYObjDef_xAOD::m_TopconfigReader

protected

Definition at line 548 of file SUSYObjDef_xAOD.h.

m_TopDecorName

std::string ST::SUSYObjDef_xAOD::m_TopDecorName

protected

Definition at line 551 of file SUSYObjDef_xAOD.h.

m_ToptagConfig

std::string ST::SUSYObjDef_xAOD::m_ToptagConfig

protected

Definition at line 554 of file SUSYObjDef_xAOD.h.

m_TopTaggerCalibArea

std::string ST::SUSYObjDef_xAOD::m_TopTaggerCalibArea

protected

Definition at line 556 of file SUSYObjDef_xAOD.h.

m_TopTaggerTool

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

protected

Definition at line 847 of file SUSYObjDef_xAOD.h.

m_TopTagjetUncertaintiesTool

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

protected

Definition at line 851 of file SUSYObjDef_xAOD.h.

m_TopTagUncConfig

std::string ST::SUSYObjDef_xAOD::m_TopTagUncConfig

protected

Definition at line 559 of file SUSYObjDef_xAOD.h.

m_treatPUJets

bool ST::SUSYObjDef_xAOD::m_treatPUJets

protected

Definition at line 589 of file SUSYObjDef_xAOD.h.

m_trig2015combination_diLep

std::string ST::SUSYObjDef_xAOD::m_trig2015combination_diLep

protected

Definition at line 940 of file SUSYObjDef_xAOD.h.

m_trig2015combination_diPhoton

std::string ST::SUSYObjDef_xAOD::m_trig2015combination_diPhoton

protected

Definition at line 956 of file SUSYObjDef_xAOD.h.

m_trig2015combination_multiLep

std::string ST::SUSYObjDef_xAOD::m_trig2015combination_multiLep

protected

Definition at line 948 of file SUSYObjDef_xAOD.h.

m_trig2015combination_singleLep

std::string ST::SUSYObjDef_xAOD::m_trig2015combination_singleLep

protected

Definition at line 933 of file SUSYObjDef_xAOD.h.

m_trig2016combination_diLep

std::string ST::SUSYObjDef_xAOD::m_trig2016combination_diLep

protected

Definition at line 941 of file SUSYObjDef_xAOD.h.

m_trig2016combination_diPhoton

std::string ST::SUSYObjDef_xAOD::m_trig2016combination_diPhoton

protected

Definition at line 957 of file SUSYObjDef_xAOD.h.

m_trig2016combination_multiLep

std::string ST::SUSYObjDef_xAOD::m_trig2016combination_multiLep

protected

Definition at line 949 of file SUSYObjDef_xAOD.h.

m_trig2016combination_singleLep

std::string ST::SUSYObjDef_xAOD::m_trig2016combination_singleLep

protected

Definition at line 934 of file SUSYObjDef_xAOD.h.

m_trig2017combination_diLep

std::string ST::SUSYObjDef_xAOD::m_trig2017combination_diLep

protected

Definition at line 942 of file SUSYObjDef_xAOD.h.

m_trig2017combination_diPhoton

std::string ST::SUSYObjDef_xAOD::m_trig2017combination_diPhoton

protected

Definition at line 958 of file SUSYObjDef_xAOD.h.

m_trig2017combination_multiLep

std::string ST::SUSYObjDef_xAOD::m_trig2017combination_multiLep

protected

Definition at line 950 of file SUSYObjDef_xAOD.h.

m_trig2017combination_singleLep

std::string ST::SUSYObjDef_xAOD::m_trig2017combination_singleLep

protected

Definition at line 935 of file SUSYObjDef_xAOD.h.

m_trig2018combination_diLep

std::string ST::SUSYObjDef_xAOD::m_trig2018combination_diLep

protected

Definition at line 943 of file SUSYObjDef_xAOD.h.

m_trig2018combination_diPhoton

std::string ST::SUSYObjDef_xAOD::m_trig2018combination_diPhoton

protected

Definition at line 959 of file SUSYObjDef_xAOD.h.

m_trig2018combination_multiLep

std::string ST::SUSYObjDef_xAOD::m_trig2018combination_multiLep

protected

Definition at line 951 of file SUSYObjDef_xAOD.h.

m_trig2018combination_singleLep

std::string ST::SUSYObjDef_xAOD::m_trig2018combination_singleLep

protected

Definition at line 936 of file SUSYObjDef_xAOD.h.

m_trig2022combination_diLep

std::string ST::SUSYObjDef_xAOD::m_trig2022combination_diLep

protected

Definition at line 944 of file SUSYObjDef_xAOD.h.

m_trig2022combination_diPhoton

std::string ST::SUSYObjDef_xAOD::m_trig2022combination_diPhoton

protected

Definition at line 960 of file SUSYObjDef_xAOD.h.

m_trig2022combination_multiLep

std::string ST::SUSYObjDef_xAOD::m_trig2022combination_multiLep

protected

Definition at line 952 of file SUSYObjDef_xAOD.h.

m_trig2022combination_singleLep

std::string ST::SUSYObjDef_xAOD::m_trig2022combination_singleLep

protected

Definition at line 937 of file SUSYObjDef_xAOD.h.

m_trigConfTool

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

protected

Definition at line 963 of file SUSYObjDef_xAOD.h.

m_trigDecTool

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

protected

Definition at line 964 of file SUSYObjDef_xAOD.h.

m_trigDRScoringTool

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

protected

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

m_trigGlobalEffCorrTool_diPhoton

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

protected

Definition at line 961 of file SUSYObjDef_xAOD.h.

m_trigGlobalEffCorrTool_multiLep

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

protected

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

m_trigMatchingTool

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

protected

Definition at line 965 of file SUSYObjDef_xAOD.h.

m_trigMatchScoringTool

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

protected

Definition at line 966 of file SUSYObjDef_xAOD.h.

m_trigNToys_diLep

int ST::SUSYObjDef_xAOD::m_trigNToys_diLep

protected

Definition at line 939 of file SUSYObjDef_xAOD.h.

m_trigNToys_diPhoton

int ST::SUSYObjDef_xAOD::m_trigNToys_diPhoton

protected

Definition at line 955 of file SUSYObjDef_xAOD.h.

m_trigNToys_multiLep

int ST::SUSYObjDef_xAOD::m_trigNToys_multiLep

protected

Definition at line 947 of file SUSYObjDef_xAOD.h.

m_trkJetEta

double ST::SUSYObjDef_xAOD::m_trkJetEta

protected

Definition at line 746 of file SUSYObjDef_xAOD.h.

m_trkJetPt

double ST::SUSYObjDef_xAOD::m_trkJetPt

protected

Definition at line 745 of file SUSYObjDef_xAOD.h.

m_trkJetsyst

bool ST::SUSYObjDef_xAOD::m_trkJetsyst

protected

Definition at line 586 of file SUSYObjDef_xAOD.h.

m_trkMETsyst

bool ST::SUSYObjDef_xAOD::m_trkMETsyst

protected

Definition at line 584 of file SUSYObjDef_xAOD.h.

m_upstreamTriggerMatching

bool ST::SUSYObjDef_xAOD::m_upstreamTriggerMatching

protected

Definition at line 524 of file SUSYObjDef_xAOD.h.

m_useBtagging

bool ST::SUSYObjDef_xAOD::m_useBtagging

protected

Definition at line 534 of file SUSYObjDef_xAOD.h.

m_useBtagging_trkJet

bool ST::SUSYObjDef_xAOD::m_useBtagging_trkJet

protected

Definition at line 535 of file SUSYObjDef_xAOD.h.

m_useCommonPRWFiles

bool ST::SUSYObjDef_xAOD::m_useCommonPRWFiles

protected

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

m_useTRUTH3

bool ST::SUSYObjDef_xAOD::m_useTRUTH3

protected

Definition at line 800 of file SUSYObjDef_xAOD.h.

m_v_trigs15_cache_diLep

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

private

Definition at line 464 of file SUSYObjDef_xAOD.h.

m_v_trigs15_cache_multiLep

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

private

Definition at line 470 of file SUSYObjDef_xAOD.h.

m_v_trigs15_cache_singleEle

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

private

Definition at line 452 of file SUSYObjDef_xAOD.h.

m_v_trigs15_cache_singleLep

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

private

Definition at line 458 of file SUSYObjDef_xAOD.h.

m_v_trigs16_cache_diLep

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

private

Definition at line 465 of file SUSYObjDef_xAOD.h.

m_v_trigs16_cache_multiLep

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

private

Definition at line 471 of file SUSYObjDef_xAOD.h.

m_v_trigs16_cache_singleEle

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

private

Definition at line 453 of file SUSYObjDef_xAOD.h.

m_v_trigs16_cache_singleLep

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

private

Definition at line 459 of file SUSYObjDef_xAOD.h.

m_v_trigs17_cache_diLep

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

private

Definition at line 466 of file SUSYObjDef_xAOD.h.

m_v_trigs17_cache_multiLep

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

private

Definition at line 472 of file SUSYObjDef_xAOD.h.

m_v_trigs17_cache_singleEle

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

private

Definition at line 454 of file SUSYObjDef_xAOD.h.

m_v_trigs17_cache_singleLep

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

private

Definition at line 460 of file SUSYObjDef_xAOD.h.

m_v_trigs18_cache_diLep

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

private

Definition at line 467 of file SUSYObjDef_xAOD.h.

m_v_trigs18_cache_multiLep

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

private

Definition at line 473 of file SUSYObjDef_xAOD.h.

m_v_trigs18_cache_singleEle

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

private

Definition at line 455 of file SUSYObjDef_xAOD.h.

m_v_trigs18_cache_singleLep

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

private

Definition at line 461 of file SUSYObjDef_xAOD.h.

m_v_trigs22_cache_diLep

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

private

Definition at line 468 of file SUSYObjDef_xAOD.h.

m_v_trigs22_cache_multiLep

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

private

Definition at line 474 of file SUSYObjDef_xAOD.h.

m_v_trigs22_cache_singleEle

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

private

Definition at line 456 of file SUSYObjDef_xAOD.h.

m_v_trigs22_cache_singleLep

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

private

Definition at line 462 of file SUSYObjDef_xAOD.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_WconfigReader

TEnv ST::SUSYObjDef_xAOD::m_WconfigReader

protected

Definition at line 546 of file SUSYObjDef_xAOD.h.

m_WDecorName

std::string ST::SUSYObjDef_xAOD::m_WDecorName

protected

Definition at line 549 of file SUSYObjDef_xAOD.h.

m_WtagConfig

std::string ST::SUSYObjDef_xAOD::m_WtagConfig

protected

Definition at line 552 of file SUSYObjDef_xAOD.h.

m_WTaggerTool

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

protected

Definition at line 845 of file SUSYObjDef_xAOD.h.

m_WTagjetUncertaintiesTool

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

protected

Definition at line 849 of file SUSYObjDef_xAOD.h.

m_WTagUncConfig

std::string ST::SUSYObjDef_xAOD::m_WTagUncConfig

protected

Definition at line 557 of file SUSYObjDef_xAOD.h.

m_WZTaggerCalibArea

std::string ST::SUSYObjDef_xAOD::m_WZTaggerCalibArea

protected

Definition at line 555 of file SUSYObjDef_xAOD.h.

m_ZconfigReader

TEnv ST::SUSYObjDef_xAOD::m_ZconfigReader

protected

Definition at line 547 of file SUSYObjDef_xAOD.h.

m_ZDecorName

std::string ST::SUSYObjDef_xAOD::m_ZDecorName

protected

Definition at line 550 of file SUSYObjDef_xAOD.h.

m_ZtagConfig

std::string ST::SUSYObjDef_xAOD::m_ZtagConfig

protected

Definition at line 553 of file SUSYObjDef_xAOD.h.

m_ZTaggerTool

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

protected

Definition at line 846 of file SUSYObjDef_xAOD.h.

m_ZTagjetUncertaintiesTool

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

protected

Definition at line 850 of file SUSYObjDef_xAOD.h.

m_ZTagUncConfig

std::string ST::SUSYObjDef_xAOD::m_ZTagUncConfig

protected

Definition at line 558 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:

• SUSYObjDef_xAOD.h
• Electrons.cxx
• Jets.cxx
• MET.cxx
• Muons.cxx
• Photons.cxx
• SUSYObjDef_xAOD.cxx
• SUSYToolsInit.cxx
• Taus.cxx
• Trigger.cxx
• Truth.cxx