#include <SUSYObjDef_xAOD.h>

Inheritance diagram for ST::SUSYObjDef_xAOD:

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

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

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

Public Attributes
const xAOD::MuonContainer *	prompt_muons = nullptr
const xAOD::MuonContainer *	lrt_muons = nullptr
const xAOD::ElectronContainer *	prompt_electrons = nullptr
const xAOD::ElectronContainer *	lrt_electrons = nullptr

Protected Member Functions
StatusCode	autoconfigurePileupRWTool (const std::string &PRWfilesDir="dev/PileupReweighting/share/", const std::string &PRWfileName="", bool usePathResolver=true, bool RPVLLmode=false, bool Combinedmode=false, const std::string &HFFilter="")
StatusCode	readConfig () override final
StatusCode	validConfig (bool strict=false) const
const std::vector< std::string >	split (const std::string &s, const std::string &delim) const
std::string	getDefaultJetUncConfig ()
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
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.
Callback functions helping in metadata reading/writing
void	setUseIncidents (const bool flag)
virtual void	handle (const Incident &inc)
	Function receiving incidents from IncidentSvc/TEvent.
virtual StatusCode	beginInputFile ()
	Function called when a new input file is opened.
virtual StatusCode	endInputFile ()
	Function called when the currently open input file got completely processed.
virtual StatusCode	beginEvent ()
	Function called when a new events is loaded.
virtual StatusCode	metaDataStop ()
	Function called when the tool should write out its metadata.

Protected Attributes
int	m_dataSource
int	m_jetInputType
std::string	m_configFile
bool	m_force_noElId
bool	m_force_noMuId
bool	m_doTTVAsf
bool	m_doModifiedEleId
bool	m_upstreamTriggerMatching
std::string	m_trigMatchingPrefix
	Use composite trigger matching tool if matching was done upstream.
std::string	m_jetUncertaintiesConfig
	Prefix for trigger matchiing container name.
std::string	m_jetUncertaintiesAnalysisFile
std::string	m_jetUncertaintiesCalibArea
std::string	m_jetUncertaintiesMCType
std::string	m_fatJetUncertaintiesMCType
bool	m_jetUncertaintiesPDsmearing
bool	m_useBtagging
bool	m_useBtagging_trkJet
bool	m_debug
bool	m_strictConfigCheck
std::string	m_badJetCut
std::string	m_fatJetUncConfig
bool	m_fatJetUncertaintiesPDsmearing
std::string	m_fatJetUncVars
TEnv	m_WconfigReader
TEnv	m_ZconfigReader
TEnv	m_TopconfigReader
std::string	m_WDecorName
std::string	m_ZDecorName
std::string	m_TopDecorName
std::string	m_WtagConfig
std::string	m_ZtagConfig
std::string	m_ToptagConfig
std::string	m_WZTaggerCalibArea
std::string	m_TopTaggerCalibArea
std::string	m_WTagUncConfig
std::string	m_ZTagUncConfig
std::string	m_TopTagUncConfig
std::string	m_JetTruthLabelName
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.
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.
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool >	m_elecEfficiencySFTool_id
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool >	m_elecEfficiencySFTool_trig_singleLep
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool >	m_elecEfficiencySFTool_trigEff_singleLep
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool >	m_elecEfficiencySFTool_iso
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool >	m_elecEfficiencySFTool_isoHighPt
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool >	m_elecEfficiencySFTool_chf
std::vector< asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > >	m_elecEfficiencySFTool_trig_mixLep
std::vector< asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > >	m_elecEfficiencySFTool_trigEff_mixLep
ToolHandleArray< IAsgElectronEfficiencyCorrectionTool >	m_elecTrigSFTools
ToolHandleArray< IAsgElectronEfficiencyCorrectionTool >	m_elecTrigEffTools
asg::AnaToolHandle< CP::IElectronLRTOverlapRemovalTool >	m_elecLRTORTool
SG::WriteHandleKey< xAOD::ElectronContainer >	m_outElectronLocation {this, "OutputElectronLocation", "StdWithLRTElectrons", "name of the muon container to write"}
asg::AnaToolHandle< CP::IEgammaCalibrationAndSmearingTool >	m_egammaCalibTool
	Combined electron collection.
asg::AnaToolHandle< IAsgElectronLikelihoodTool >	m_elecSelLikelihood
asg::AnaToolHandle< IAsgElectronLikelihoodTool >	m_elecSelLikelihoodBaseline
asg::AnaToolHandle< IAsgPhotonIsEMSelector >	m_photonSelIsEM
asg::AnaToolHandle< IAsgPhotonIsEMSelector >	m_photonSelIsEMBaseline
asg::AnaToolHandle< IAsgDeadHVCellRemovalTool >	m_deadHVTool
asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool >	m_photonEfficiencySFTool
asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool >	m_photonIsolationSFTool
asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool >	m_photonTriggerSFTool
std::vector< asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > >	m_photonEfficiencySFTool_trigSF_AsymDiphoton
std::vector< asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > >	m_photonEfficiencySFTool_trigEff_AsymDiphoton
ToolHandleArray< IAsgPhotonEfficiencyCorrectionTool >	m_photonTrigSFTools
ToolHandleArray< IAsgPhotonEfficiencyCorrectionTool >	m_photonTrigEffTools
asg::AnaToolHandle< IEGammaAmbiguityTool >	m_egammaAmbiguityTool
asg::AnaToolHandle< IAsgElectronLikelihoodTool >	m_elecChargeIDSelectorTool
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool >	m_elecChargeEffCorrTool
asg::AnaToolHandle< TauAnalysisTools::ITauSelectionTool >	m_tauSelTool
asg::AnaToolHandle< TauAnalysisTools::ITauSelectionTool >	m_tauSelToolBaseline
asg::AnaToolHandle< TauAnalysisTools::ITauSmearingTool >	m_tauSmearingTool
asg::AnaToolHandle< TauAnalysisTools::ITauTruthMatchingTool >	m_tauTruthMatch
asg::AnaToolHandle< TauAnalysisTools::ITauEfficiencyCorrectionsTool >	m_tauEffTool
std::vector< asg::AnaToolHandle< TauAnalysisTools::ITauEfficiencyCorrectionsTool > >	m_tauTrigEffTool
asg::AnaToolHandle< IBTaggingEfficiencyTool >	m_btagEffTool
asg::AnaToolHandle< IBTaggingSelectionTool >	m_btagSelTool
asg::AnaToolHandle< IBTaggingSelectionTool >	m_btagSelTool_OR
asg::AnaToolHandle< IBTaggingEfficiencyTool >	m_btagEffTool_trkJet
asg::AnaToolHandle< IBTaggingSelectionTool >	m_btagSelTool_trkJet
asg::AnaToolHandle< IMETMaker >	m_metMaker
asg::AnaToolHandle< IMETSystematicsTool >	m_metSystTool
asg::AnaToolHandle< IMETSignificance >	m_metSignif
std::string	m_trig2015combination_singleLep
std::string	m_trig2016combination_singleLep
std::string	m_trig2017combination_singleLep
std::string	m_trig2018combination_singleLep
std::string	m_trig2022combination_singleLep
std::string	m_trig2023combination_singleLep
std::string	m_trig2024combination_singleLep
int	m_trigNToys_diLep
std::string	m_trig2015combination_diLep
std::string	m_trig2016combination_diLep
std::string	m_trig2017combination_diLep
std::string	m_trig2018combination_diLep
std::string	m_trig2022combination_diLep
asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionTool >	m_trigGlobalEffCorrTool_diLep
int	m_trigNToys_multiLep
std::string	m_trig2015combination_multiLep
std::string	m_trig2016combination_multiLep
std::string	m_trig2017combination_multiLep
std::string	m_trig2018combination_multiLep
std::string	m_trig2022combination_multiLep
asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionTool >	m_trigGlobalEffCorrTool_multiLep
int	m_trigNToys_diPhoton
std::string	m_trig2015combination_diPhoton
std::string	m_trig2016combination_diPhoton
std::string	m_trig2017combination_diPhoton
std::string	m_trig2018combination_diPhoton
std::string	m_trig2022combination_diPhoton
asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionTool >	m_trigGlobalEffCorrTool_diPhoton
asg::AnaToolHandle< TrigConf::ITrigConfigTool >	m_trigConfTool
asg::AnaToolHandle< Trig::TrigDecisionTool >	m_trigDecTool
asg::AnaToolHandle< Trig::IMatchingTool >	m_trigMatchingTool
asg::AnaToolHandle< Trig::IMatchScoringTool >	m_trigMatchScoringTool
asg::AnaToolHandle< Trig::IMatchScoringTool >	m_trigDRScoringTool
asg::AnaToolHandle< CP::IIsolationCorrectionTool >	m_isoCorrTool
asg::AnaToolHandle< CP::IIsolationSelectionTool >	m_isoTool
asg::AnaToolHandle< CP::IIsolationSelectionTool >	m_isoBaselineTool
asg::AnaToolHandle< CP::IIsolationSelectionTool >	m_isoHighPtTool
asg::AnaToolHandle< CP::IIsolationCloseByCorrectionTool >	m_isoCloseByTool
asg::AnaToolHandle< CP::IPileupReweightingTool >	m_prwTool
asg::AnaToolHandle< InDet::IInclusiveTrackFilterTool >	m_LRTuncTool
asg::AnaToolHandle< ORUtils::IOverlapTool >	m_tauJetORtool
ORUtils::ToolBox	m_orToolbox
asg::AnaToolHandle< IWeightTool >	m_pmgSHnjetWeighter
asg::AnaToolHandle< IWeightTool >	m_pmgSHnjetWeighterWZ
std::string	m_eleIdBaselineDFName
std::string	m_eleIdDFName
std::string	m_photonIdBaselineDFName
std::string	m_photonIdDFName
std::string	m_jetCleanDFName
SG::ConstAccessor< char >	m_acc_eleIdBaseline
SG::ConstAccessor< char >	m_acc_eleId
SG::ConstAccessor< char >	m_acc_photonIdBaseline
SG::ConstAccessor< char >	m_acc_photonId
SG::ConstAccessor< char >	m_acc_jetClean

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	SUSYToolsInit ()
bool	emulateHLT (const std::string &triggerName) const
bool	isTrigInTDT (std::scoped_lock< std::mutex > &lock, const std::string &triggerName) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

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

Detailed Description

Definition at line 141 of file SUSYObjDef_xAOD.h.

Member Typedef Documentation

◆ MetaStore_t

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

inherited

Type of the metadata store object in Athena.

Definition at line 66 of file AsgMetadataTool.h.

◆ MetaStorePtr_t

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

inherited

Type of the metadata store pointer in standalone mode.

Definition at line 68 of file AsgMetadataTool.h.

◆ StoreGateSvc_t

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

privateinherited

Definition at line 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 100 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_trig2023combination_singleLep(""),
    m_trig2024combination_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 3135 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
}

{
  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 1013 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, TauAnalysisTools::CommonSmearingTool, TauAnalysisTools::DiTauEfficiencyCorrectionsTool, TauAnalysisTools::DiTauSelectionTool, TauAnalysisTools::TauEfficiencyCorrectionsTool, TauAnalysisTools::TauSelectionTool, Trig::TrigConfBunchCrossingTool, Trig::TrigDecisionTool, Trig::xAODBunchCrossingTool, TrigConf::xAODConfigTool, and xAODMaker::TriggerMenuMetaDataTool.

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

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 826 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 907 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 887 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 968 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 1214 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 1219 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 1257 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 1272 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 1288 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 1304 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 2106 of file SUSYObjDef_xAOD.cxx.

                                                                {
  return m_currentSyst;
}

◆ currentSystematicIsNominal()

bool ST::SUSYObjDef_xAOD::currentSystematicIsNominal ( ) const

Definition at line 2134 of file SUSYObjDef_xAOD.cxx.

                                                       {
  return isNominal(m_currentSyst);
}

◆ currentSystematicIsVariation()

bool ST::SUSYObjDef_xAOD::currentSystematicIsVariation ( ) const

Definition at line 2138 of file SUSYObjDef_xAOD.cxx.

                                                         {
  return isVariation(m_currentSyst);
}

◆ currentSystematicIsWeight()

bool ST::SUSYObjDef_xAOD::currentSystematicIsWeight ( ) const

Definition at line 2142 of file SUSYObjDef_xAOD.cxx.

                                                      {
  return isWeight(m_currentSyst);
}

◆ declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareProperty()

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.

95{ return m_detStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ EG_WP()

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

protected

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

Definition at line 193 of file AsgMetadataTool.cxx.

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

◆ evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

85{ return m_evtStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ 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 383 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 208 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 77 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 643 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 1060 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 1106 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 3034 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 3029 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 3024 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 1834 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 592 of file Electrons.cxx.

                                                                                                       {
 
  std::string single_str = "SINGLE_E";
  std::string single_Run3 = "202";  
  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_Run3) != 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 558 of file Electrons.cxx.

                                                                                                         {
 
  double trig_sf(1.);
 
  std::string single_str = "SINGLE_E";
  std::string single_Run3 = "202";  
  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_Run3) != 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 1238 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 2986 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 242 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 3093 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 3081 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 73 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 321 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.

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

ST::getMCShowerType

static int getMCShowerType(const std::string &sample_name, const std::string &tagger="")

Definition ISUSYObjDef_xAODTool.h:168

◆ 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 101 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 533 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 2994 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 3019 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 3004 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 2925 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<class T>

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

inherited

Get one of the tool's properties.

◆ getProperty() [2/2]

template<typename T>

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

inlineinherited

Definition at line 239 of file ISUSYObjDef_xAODTool.h.

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

◆ GetRandomRunNumber()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 3043 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 3065 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 2894 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 2909 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 if (this->treatAsYear()==2022) trigMChains = m_v_trigs22_cache_singleEle;
      else if (this->treatAsYear()==2023) trigMChains = m_v_trigs23_cache_singleEle;
      else trigMChains = m_v_trigs24_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 480 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 130 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 160 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 3039 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 2576 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 2541 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 1841 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 31 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 194 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;
  for (auto part : std::views::split(map_it->second, ','))  chains.emplace_back(&*part.begin(), std::ranges::distance(part));
  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 627 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 640 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 1130 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 1143 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 602 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 622 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 547 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;  }
    newtrigExpr = std::regex_replace(newtrigExpr, std::regex("HLT_"), "");
 
    for (auto part : std::views::split(newtrigExpr, '_')) {
      std::string mutrig(&*part.begin(), std::ranges::distance(part));
      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 228 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 250 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 169 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 426 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 586 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 647 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 431 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 529 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 487 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 564 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,
		std::vector< std::string > &	v_trigs23_cache,
		std::vector< std::string > &	v_trigs24_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_";
 
    size_t pos = 0;
    std::string token15, token16, token17, token18, token22, token23, token24;
 
    //get trigger tokens for 2015, 2016, 2017, 2018 and 2022, 2023, 2024
    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;
      }
    }
 
    // Find year positions (or npos if not present)
    size_t p22 = trigExpr.find("2022");
    size_t p23 = trigExpr.find("2023");
    size_t p24 = trigExpr.find("2024");
 
    auto next_pos = [&](size_t self) {
        size_t next = std::string::npos;
 
        if (self == p22) {
            if (p23 > self && p23 < next) next = p23;
            if (p24 > self && p24 < next) next = p24;
        }
        else if (self == p23) {
            if (p22 > self && p22 < next) next = p22;
            if (p24 > self && p24 < next) next = p24;
        }
        else if (self == p24) {
            if (p22 > self && p22 < next) next = p22;
            if (p23 > self && p23 < next) next = p23;
        }
 
        return next;
    };
 
    // Extract 2022,2023,2024 block
    if (p22 != std::string::npos) {size_t end = next_pos(p22); token22 = trigExpr.substr(p22, end - p22);}
    if (p23 != std::string::npos) {size_t end = next_pos(p23); token23 = trigExpr.substr(p23, end - p23);}
    if (p24 != std::string::npos) {size_t end = next_pos(p24); token24 = trigExpr.substr(p24, end - p24);}
 
    // Remove trailing underscores from tokens if present
    std::string* toks[] = { &token22, &token23, &token24 };
    for (auto t : toks) {
      while (!t->empty() && t->back() == '_') t->pop_back();
    }
 
    //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;
      if(token23.empty()) token23 = trigExpr;
      if(token24.empty()) token24 = 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);
      v_trigs23_cache = GetTriggerOR(token23);
      v_trigs24_cache = GetTriggerOR(token24);
    }
  }

◆ 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 ( void )

finaloverridevirtual

Dummy implementation of the initialisation function.

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

Reimplemented from asg::AsgTool.

Definition at line 884 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.

158{return m_dataSource == AtlfastII;}

◆ IsBadJet()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 745 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 405 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 771 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 793 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 680 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 444 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.

157{return m_dataSource == Data;}

◆ IsHighPtMuon()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 386 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 2110 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 693 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 344 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 112 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 782 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 815 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 2125 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 2114 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 687 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 988 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 1035 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 56 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 BookkeeperDumperTool, BookkeeperTool, xAODMaker::TriggerMenuMetaDataTool, and xAODMaker::TruthMetaDataTool.

Definition at line 209 of file AsgMetadataTool.cxx.

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

◆ msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

◆ 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 2976 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 2941 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 74 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()

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

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

Definition at line 131 of file AsgTool.cxx.

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

◆ readConfig()

StatusCode ST::SUSYObjDef_xAOD::readConfig ( )

finaloverrideprotectedvirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 1334 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_Recommendation_v4/map2.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_trig2023combination_singleLep, "Trig.Singlelep2023", rEnv, "e26_lhtight_ivarloose_L1eEM26M_OR_e60_lhmedium_L1eEM26M_OR_e140_lhloose_L1eEM26M || HLT_mu24_ivarmedium_L1MU14FCH_OR_HLT_mu50_L1MU14FCH");
  configFromFile(m_trig2024combination_singleLep, "Trig.Singlelep2024", rEnv, "e26_lhtight_ivarloose_L1eEM26M_OR_e60_lhmedium_L1eEM26M_OR_e140_lhloose_L1eEM26M || HLT_mu24_ivarmedium_L1MU14FCH_OR_HLT_mu50_L1MU14FCH");
  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, m_v_trigs23_cache_singleEle, m_v_trigs24_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_trigs23_cache_singleEle, m_v_trigs24_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_trigs23_cache_singleLep = GetTriggerOR(m_trig2023combination_singleLep);
  m_v_trigs24_cache_singleLep = GetTriggerOR(m_trig2024combination_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 2102 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 878 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 1155 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 1206 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 1810 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);
        }
      }
 
      // The L1 seed changed from 2023 and beyond, so we need to adjust the trigger key accordingly, the SF are now derived by year so we need to change the year in the key as well.
 
      if(m_isRun3){
        // Find year positions (or npos if not present)
        size_t p22 = m_electronTriggerSFStringSingle.find("2022");
        size_t p23 = m_electronTriggerSFStringSingle.find("2023");
        size_t p24 = m_electronTriggerSFStringSingle.find("2024");
 
        auto next_pos = [&](size_t self) {
            size_t next = std::string::npos;
 
            if (self == p22) {
                if (p23 > self && p23 < next) next = p23;
                if (p24 > self && p24 < next) next = p24;
            }
            else if (self == p23) {
                if (p22 > self && p22 < next) next = p22;
                if (p24 > self && p24 < next) next = p24;
            }
            else if (self == p24) {
                if (p22 > self && p22 < next) next = p22;
                if (p23 > self && p23 < next) next = p23;
            }
 
            return next;
        };
        std::string SFStringSingle22="";
        std::string SFStringSingle23="";
        std::string SFStringSingle24="";
 
        // Extract 2022,2023,2025 block
        if (p22 != std::string::npos) {size_t end = next_pos(p22); SFStringSingle22 = m_electronTriggerSFStringSingle.substr(p22, end - p22);}
        if (p23 != std::string::npos) {size_t end = next_pos(p23); SFStringSingle23 = m_electronTriggerSFStringSingle.substr(p23, end - p23);}
        if (p24 != std::string::npos) {size_t end = next_pos(p24); SFStringSingle24 = m_electronTriggerSFStringSingle.substr(p24, end - p24);}
 
        // Remove trailing underscores from tokens if present
        std::string* toks[] = { &SFStringSingle22, &SFStringSingle23, &SFStringSingle24 };
        for (auto t : toks) {
          while (!t->empty() && t->back() == '_') t->pop_back();
        }
 
        if(m_mcCampaign == "mc23a") m_electronTriggerSFStringSingle = SFStringSingle22;
        else if(m_mcCampaign == "mc23d") m_electronTriggerSFStringSingle = SFStringSingle23;
        else if(m_mcCampaign == "mc23e") m_electronTriggerSFStringSingle = SFStringSingle24;
        else {
          ATH_MSG_WARNING("Unknown or unsupported mcCampaign for Run 3: " << m_mcCampaign << ". Please contact the SUSY Bkg Forum for assistance.");
          ATH_MSG_WARNING("Falling back to 2024 trigger SFs for single-electron triggers.");
          m_electronTriggerSFStringSingle = SFStringSingle24;
        }
      }
 
      
      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::JETIDNONE;
      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("JetContainer", jetcoll) );
      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));
      if(jetname != "AntiKt4EMPFlow")
        ATH_MSG_WARNING("METSignificance recommendations only exist for AntiKt4EMPFlow jets, falling back to this.");
      ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "JetCollection", "AntiKt4EMPFlow"));
      // This is the only recommended set of jet resolutions for use with R22+ MET Significance until "Consolidated" recommendations are available
      ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "JetCalibConfig", "JES_data2017_2016_2015_Recommendation_PFlow_Aug2018_rel21.config") );
      ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "JetCalibSequence", "JetArea_Residual_EtaJES_GSC_Smear") );
      ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "JetCalibArea", "00-04-81") );
      ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "EgammaESModel", m_isRun3 ? "es2024_Run3_v0" : "es2023_R22_Run2_v1") );
      ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "EgammaDecorrelationModel", "1NP_v1") );
      ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "EgammaUseFastsim", isAtlfast()) );
      // 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 jet/egamma/muon calib tools 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) );
      if(jetname != "AntiKt4EMPFlow")
        ATH_MSG_WARNING("METSignificance recommendations only exist for AntiKt4EMPFlow jets, falling back to this.");
      ATH_CHECK( m_metSignif.setProperty( "JetCollection", "AntiKt4EMPFlow"));
      // This is the only recommended set of jet resolutions for use with R22+ MET Significance until "Consolidated" recommendations are available
      ATH_CHECK( m_metSignif.setProperty( "JetCalibConfig", "JES_data2017_2016_2015_Recommendation_PFlow_Aug2018_rel21.config") );
      ATH_CHECK( m_metSignif.setProperty( "JetCalibSequence", "JetArea_Residual_EtaJES_GSC_Smear") );
      ATH_CHECK( m_metSignif.setProperty( "JetCalibArea", "00-04-81") );
      ATH_CHECK( m_metSignif.setProperty("egammaCalibTool", m_egammaCalibTool.getHandle()) );
      // 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( "FixTimingIssueInCore", true) ); // Similar to https://gitlab.cern.ch/atlas/athena/-/merge_requests/83939
      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 3122 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 2100 of file SUSYObjDef_xAOD.cxx.

2100{ 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 1945 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.

bool asg::AsgMetadataTool::m_beginInputFileCalled

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

private

Definition at line 482 of file SUSYObjDef_xAOD.h.

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

◆ m_inputMetaStore

MetaStore_t asg::AsgMetadataTool::m_inputMetaStore

std::string ST::SUSYObjDef_xAOD::m_jetUncertaintiesConfig

Definition at line 898 of file SUSYObjDef_xAOD.h.

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

◆ m_outMETTerm

std::string ST::SUSYObjDef_xAOD::m_outMETTerm

protected

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

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

◆ m_outputMetaStore

MetaStore_t asg::AsgMetadataTool::m_outputMetaStore

◆ m_ZTagjetUncertaintiesTool

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

protected

Definition at line 854 of file SUSYObjDef_xAOD.h.

◆ m_ZTagUncConfig

std::string ST::SUSYObjDef_xAOD::m_ZTagUncConfig

protected

Definition at line 562 of file SUSYObjDef_xAOD.h.

◆ prompt_electrons

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

Definition at line 211 of file SUSYObjDef_xAOD.h.

◆ prompt_muons

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

Definition at line 205 of file SUSYObjDef_xAOD.h.

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ MetaStore_t

◆ MetaStorePtr_t

◆ StoreGateSvc_t

Member Enumeration Documentation

◆ DataSource

Constructor & Destructor Documentation

◆ SUSYObjDef_xAOD()

◆ ~SUSYObjDef_xAOD()

Member Function Documentation

◆ ApplyLRTUncertainty()

◆ ApplyPRWTool()

◆ applySystematicVariation()

◆ autoconfigurePileupRWTool()

◆ beginEvent()

◆ beginInputFile()

◆ BtagSF()

◆ BtagSF_trkJet()

◆ BtagSFsys()

◆ BtagSFsys_trkJet()

◆ check_isOption()

◆ check_isTighter()

◆ configFromFile() [1/4]

◆ configFromFile() [2/4]

◆ configFromFile() [3/4]

◆ configFromFile() [4/4]

◆ currentSystematic()

◆ currentSystematicIsNominal()

◆ currentSystematicIsVariation()

◆ currentSystematicIsWeight()

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ EG_WP()

◆ emulateHLT()

◆ endInputFile()

◆ evtStore()

◆ extraDeps_update_handler()

◆ FillElectron()

◆ FillJet()

◆ FillMuon()

◆ FillPhoton()

◆ FillTau()

◆ FillTrackJet()

◆ FindSusyHardProc() [1/2]

◆ FindSusyHardProc() [2/2]

◆ FindSusyHP() [1/3]

◆ FindSusyHP() [2/3]

◆ FindSusyHP() [3/3]

◆ FJVT_SF()

◆ FJVT_SFsys()

◆ GetCorrectedActualInteractionsPerCrossing()

◆ GetCorrectedAverageInteractionsPerCrossing()

◆ GetDataWeight()

◆ getDefaultJetUncConfig()

◆ GetElectrons()

◆ GetEleTriggerEfficiency()

◆ GetEleTriggerEfficiencySF()

◆ getElSFkeys()

◆ GetEventInfo()

◆ GetFatJets()

◆ GetInDetLargeD0GSFTracks()

◆ GetInDetLargeD0Tracks()

◆ GetJets()

◆ GetJetsSyst()

◆ getKey()

◆ getMCShowerType()

◆ GetMET()

◆ GetMETSig()

◆ GetMuons()