#include <SUSYObjDef_xAOD.h>

Inheritance diagram for ST::SUSYObjDef_xAOD:

Collaboration diagram for ST::SUSYObjDef_xAOD:

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

Public Member Functions
	SUSYObjDef_xAOD (const std::string &name)

	~SUSYObjDef_xAOD ()

StatusCode	initialize () override final
	Dummy implementation of the initialisation function. More...

bool	isData () const override final

bool	isAtlfast () const override final

StatusCode	setBoolProperty (const std::string &name, const bool &property) override final

void	setDataSource (int source)

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

StatusCode	FillTrackJet (xAOD::Jet &input) override final

StatusCode	FillTau (xAOD::TauJet &input) override final

StatusCode	FillMuon (xAOD::Muon &input, const float ptcut, const float etacut) override final

StatusCode	FillElectron (xAOD::Electron &input, const float etcut, const float etacut) override final

StatusCode	FillPhoton (xAOD::Photon &input, const float ptcut, const float etacut) override final

const xAOD::Vertex *	GetPrimVtx () const override final

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

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

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

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

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

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

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

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

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

StatusCode	GetTrackMET (xAOD::MissingETContainer &met, const xAOD::JetContainer jet, const xAOD::ElectronContainer elec=nullptr, const xAOD::MuonContainer *muon=nullptr) override final

StatusCode	GetMETSig (xAOD::MissingETContainer &met, double &metSignificance, bool doTST=true, bool doJVTCut=true) override final

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

StatusCode	prepareLRTMuons (const xAOD::MuonContainer inMuons, xAOD::MuonContainer copy) const override final

StatusCode	MergeElectrons (const xAOD::ElectronContainer &electrons, xAOD::ElectronContainer outputCol, const std::set< const xAOD::Electron > &ElectronsToRemove) const override final

StatusCode	prepareLRTElectrons (const xAOD::ElectronContainer inMuons, xAOD::ElectronContainer copy) const override final

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

bool	IsPFlowCrackVetoCleaning (const xAOD::ElectronContainer elec=nullptr, const xAOD::PhotonContainer gamma=nullptr) const override final

bool	IsSignalJet (const xAOD::Jet &input, const float ptcut, const float etacut) const override final

bool	IsBadJet (const xAOD::Jet &input) const override final

bool	IsBJetLoose (const xAOD::Jet &input) const override final

bool	JetPassJVT (xAOD::Jet &input) override final

bool	IsSignalMuon (const xAOD::Muon &input, const float ptcut, const float d0sigcut, const float z0cut, const float etacut=DUMMYDEF) const override final

bool	IsSignalElectron (const xAOD::Electron &input, const float etcut, const float d0sigcut, const float z0cut, const float etacut=DUMMYDEF) const override final

bool	IsCosmicMuon (const xAOD::Muon &input, const float z0cut, const float d0cut) const override final

bool	IsHighPtMuon (const xAOD::Muon &input) const override final

bool	IsSignalTau (const xAOD::TauJet &input, const float ptcut, const float etacut) const override final

bool	IsBadMuon (const xAOD::Muon &input, const float qopcut) const override final

bool	IsSignalPhoton (const xAOD::Photon &input, const float ptcut, const float etacut=DUMMYDEF) const override final

bool	IsBJet (const xAOD::Jet &input) const override final

bool	IsTrackBJet (const xAOD::Jet &input) const override final

bool	IsTruthBJet (const xAOD::Jet &input) const override final

int	IsBJetContinuous (const xAOD::Jet &input) const override final

int	IsTrackBJetContinuous (const xAOD::Jet &input) const override final

float	BtagSF (const xAOD::JetContainer *jets) override final

float	BtagSFsys (const xAOD::JetContainer *jets, const CP::SystematicSet &systConfig) override final

float	BtagSF_trkJet (const xAOD::JetContainer *trkjets) override final

float	BtagSFsys_trkJet (const xAOD::JetContainer *trkjets, const CP::SystematicSet &systConfig) override final

double	JVT_SF (const xAOD::JetContainer *jets) override final

double	JVT_SFsys (const xAOD::JetContainer *jets, const CP::SystematicSet &systConfig) override final

double	FJVT_SF (const xAOD::JetContainer *jets) override final

double	FJVT_SFsys (const xAOD::JetContainer *jets, const CP::SystematicSet &systConfig) override final

float	GetSignalMuonSF (const xAOD::Muon &mu, const bool recoSF=true, const bool isoSF=true, const bool doBadMuonHP=true, const bool warnOVR=true) override final

double	GetMuonTriggerEfficiency (const xAOD::Muon &mu, const std::string &trigExpr, const bool isdata=false) override final

double	GetTotalMuonTriggerSF (const xAOD::MuonContainer &sfmuons, const std::string &trigExpr) override final

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

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

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

double	GetEleTriggerEfficiency (const xAOD::Electron &el, const std::string &trigExpr="SINGLE_E_2015_e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose_2016_2018_e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0") const override final

double	GetTriggerGlobalEfficiency (const xAOD::ElectronContainer &electrons, const xAOD::MuonContainer &muons, const std::string &trigExpr="diLepton") override final

double	GetTriggerGlobalEfficiency (const xAOD::PhotonContainer &photons, const std::string &trigExpr="diPhoton") override final

double	GetEleTriggerEfficiencySF (const xAOD::Electron &el, const std::string &trigExpr="SINGLE_E_2015_e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose_2016_2018_e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0") const override final

double	GetTriggerGlobalEfficiencySF (const xAOD::ElectronContainer &electrons, const xAOD::MuonContainer &muons, const std::string &trigExpr="diLepton") override final

double	GetTriggerGlobalEfficiencySF (const xAOD::PhotonContainer &photons, const std::string &trigExpr="diPhoton") override final

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

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

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

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

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

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

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

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

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

double	GetSignalPhotonSF (const xAOD::Photon &ph, const bool effSF=true, const bool isoSF=true, const bool triggerSF=false) const override final

double	GetSignalPhotonSFsys (const xAOD::Photon &ph, const CP::SystematicSet &systConfig, const bool effSF=true, const bool isoSF=true, const bool triggerSF=false) override final

double	GetTotalPhotonSF (const xAOD::PhotonContainer &photons, const bool effSF=true, const bool isoSF=true, const bool triggerSF=false) const override final

double	GetTotalPhotonSFsys (const xAOD::PhotonContainer &photons, const CP::SystematicSet &systConfig, const bool effSF=true, const bool isoSF=true, const bool triggerSF=false) override final

double	GetTotalJetSF (const xAOD::JetContainer *jets, const bool btagSF=true, const bool jvtSF=true, const bool fjvtSF=false) override final

double	GetTotalJetSFsys (const xAOD::JetContainer *jets, const CP::SystematicSet &systConfig, const bool btagSF=true, const bool jvtSF=true, const bool fjvtSF=false) override final

bool	IsMETTrigPassed (unsigned int runnumber=0, bool j400_OR=false) const override final

bool	IsMETTrigPassed (const std::string &triggerName, bool j400_OR=false) const override final

bool	IsTrigPassed (const std::string &, unsigned int condition=TrigDefs::Physics) const override final

bool	IsTrigMatched (const xAOD::IParticle *part, const std::string &tr_item) override final

bool	IsTrigMatched (const xAOD::IParticle part1, const xAOD::IParticle part2, const std::string &tr_item) override final

bool	IsTrigMatched (const std::vector< const xAOD::IParticle * > &v, const std::string &tr_item) override final

bool	IsTrigMatched (const std::initializer_list< const xAOD::IParticle * > &v, const std::string &tr_item) override final

void	TrigMatch (const xAOD::IParticle *p, std::initializer_list< std::string >::iterator, std::initializer_list< std::string >::iterator) override final

void	TrigMatch (const xAOD::IParticle *p, const std::vector< std::string > &items) override final

void	TrigMatch (const xAOD::IParticle *p, const std::initializer_list< std::string > &items) override final

void	TrigMatch (const xAOD::IParticleContainer *v, const std::vector< std::string > &items) override final

void	TrigMatch (const xAOD::IParticleContainer *v, const std::initializer_list< std::string > &items) override final

void	TrigMatch (const std::initializer_list< const xAOD::IParticle * > &v, const std::vector< std::string > &items) override final

void	TrigMatch (const std::initializer_list< const xAOD::IParticle * > &v, const std::initializer_list< std::string > &items) override final

void	TrigMatch (const xAOD::IParticle *p, const std::string &item) override final

void	TrigMatch (const xAOD::IParticleContainer *v, const std::string &item) override final

void	TrigMatch (const std::initializer_list< const xAOD::IParticle * > &v, const std::string &item) override final

float	GetTrigPrescale (const std::string &) const override final

const Trig::ChainGroup *	GetTrigChainGroup (const std::string &) const override final

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

void	GetTriggerTokens (std::string, std::vector< std::string > &, std::vector< std::string > &, std::vector< std::string > &, std::vector< std::string > &, std::vector< std::string > &) const

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

const xAOD::EventInfo *	GetEventInfo () const override final

float	GetPileupWeight () override final

float	GetPileupWeightPrescaledTrigger (const std::string &trigger_expr) override final

ULong64_t	GetPileupWeightHash () override final

float	GetDataWeight (const std::string &) override final

float	GetCorrectedAverageInteractionsPerCrossing (bool includeDataSF=false) override final

float	GetCorrectedActualInteractionsPerCrossing (bool includeDataSF=false) override final

double	GetSumOfWeights (int channel) override final

unsigned int	GetRandomRunNumber (bool muDependentRRN=true) override final

StatusCode	ApplyPRWTool (bool muDependentRRN=true) override final

unsigned int	GetRunNumber () const override final

const xAOD::TrackParticleContainer &	GetInDetLargeD0Tracks (const EventContext &ctx) const override final

const xAOD::TrackParticleContainer &	GetInDetLargeD0GSFTracks (const EventContext &ctx) const override final

StatusCode	ApplyLRTUncertainty () override final

int	treatAsYear (const int runNumber=-1) const override final

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

StatusCode	NearbyLeptonCorrections (xAOD::ElectronContainer electrons=nullptr, xAOD::MuonContainer muons=nullptr) const override final

StatusCode	resetSystematics () override final

const CP::SystematicSet &	currentSystematic () const

StatusCode	applySystematicVariation (const CP::SystematicSet &systConfig) override final

bool	isPrompt (const xAOD::IParticle *part) const override final

StatusCode	FindSusyHP (int &pdgid1, int &pdgid2) const

StatusCode	FindSusyHP (const xAOD::TruthParticleContainer *truthP, int &pdgid1, int &pdgid2, bool isTruth3=false) const override final

StatusCode	FindSusyHP (const xAOD::TruthEvent *truthE, int &pdgid1, int &pdgid2) const override final

std::string	TrigSingleLep () const override final

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

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

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

bool	currentSystematicIsNominal () const

bool	currentSystematicIsVariation () const

bool	currentSystematicIsWeight () const

ST::SystInfo	getSystInfo (const CP::SystematicVariation &sys) const override final

std::vector< ST::SystInfo >	getSystInfoList () const override final

float	getSherpaVjetsNjetsWeight () const override final

float	getSherpaVjetsNjetsWeight (const std::string &jetContainer) const override final

int	getMCShowerType (const std::string &sample_name="") const override final

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

virtual void	print () const =0
	Print the state of the tool. More...

virtual StatusCode	sysInitialize ()
	Function initialising the tool in the correct way in Athena. More...

virtual void	print () const
	Print the state of the tool. More...

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

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

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

Public Attributes
const xAOD::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

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

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

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

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

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

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

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

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

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

void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

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

void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...

Protected Attributes
int	m_dataSource

int	m_jetInputType

std::string	m_configFile

bool	m_force_noElId

bool	m_force_noMuId

bool	m_doTTVAsf

bool	m_doModifiedEleId

bool	m_upstreamTriggerMatching

std::string	m_trigMatchingPrefix
	Use composite trigger matching tool if matching was done upstream. More...

std::string	m_jetUncertaintiesConfig
	Prefix for trigger matchiing container name. More...

std::string	m_jetUncertaintiesAnalysisFile

std::string	m_jetUncertaintiesCalibArea

std::string	m_jetUncertaintiesMCType

bool	m_jetUncertaintiesPDsmearing

bool	m_useBtagging

bool	m_useBtagging_trkJet

bool	m_debug

bool	m_strictConfigCheck

std::string	m_badJetCut

std::string	m_fatJetUncConfig

std::string	m_fatJetUncVars

TEnv	m_WconfigReader

TEnv	m_ZconfigReader

TEnv	m_TopconfigReader

std::string	m_WDecorName

std::string	m_ZDecorName

std::string	m_TopDecorName

std::string	m_WtagConfig

std::string	m_ZtagConfig

std::string	m_ToptagConfig

std::string	m_WZTaggerCalibArea

std::string	m_TopTaggerCalibArea

std::string	m_WTagUncConfig

std::string	m_ZTagUncConfig

std::string	m_TopTagUncConfig

std::string	m_JetTruthLabelName

bool	m_tool_init

bool	m_subtool_init

std::string	m_eleTerm

std::string	m_gammaTerm

std::string	m_tauTerm

std::string	m_jetTerm

std::string	m_muonTerm

std::string	m_inputMETSuffix

std::string	m_inputMETMap

std::string	m_inputMETCore

std::string	m_inputMETRef

std::string	m_outMETTerm

bool	m_metRemoveOverlappingCaloTaggedMuons

bool	m_metDoSetMuonJetEMScale

bool	m_metDoRemoveMuonJets

bool	m_metUseGhostMuons

bool	m_metDoMuonEloss

bool	m_metGreedyPhotons

bool	m_metVeryGreedyPhotons

std::string	m_metsysConfigPrefix

bool	m_trkMETsyst

bool	m_caloMETsyst

bool	m_trkJetsyst

int	m_softTermParam

bool	m_treatPUJets

bool	m_doPhiReso

bool	m_autoconfigPRW

std::string	m_autoconfigPRWPath

std::string	m_autoconfigPRWFile

bool	m_autoconfigPRWCombinedmode

bool	m_autoconfigPRWRPVmode

std::string	m_autoconfigPRWRtags

std::string	m_mcCampaign

int	m_mcChannel

bool	m_useCommonPRWFiles

std::string	m_commonPRWFileMC20a

std::string	m_commonPRWFileMC20d

std::string	m_commonPRWFileMC20e

std::string	m_commonPRWFileMC21a

std::string	m_commonPRWFileMC23a

std::string	m_commonPRWFileMC23c

std::string	m_commonPRWFileMC23d

std::string	m_commonPRWFileMC23e

std::vector< std::string >	m_prwConfFiles

std::vector< std::string >	m_prwLcalcFiles

std::string	m_prwActualMu2017File

std::string	m_prwActualMu2018File

std::string	m_prwActualMu2022File

std::string	m_prwActualMu2023File

std::string	m_prwActualMu2024File

double	m_prwDataSF

double	m_prwDataSF_UP

double	m_prwDataSF_DW

bool	m_runDepPrescaleWeightPRW

std::vector< std::string >	m_el_id_support

std::vector< std::string >	m_ph_id_support

int	m_mu_id_support

std::vector< std::string >	m_tau_id_support

std::vector< std::string >	m_el_iso_support

std::vector< std::string >	m_mu_iso_support

std::map< std::string, std::string >	m_el_iso_fallback

std::map< std::string, std::string >	m_mu_iso_fallback

std::string	m_electronTriggerSFStringSingle

std::map< std::string, std::string >	m_tau_trig_support

std::string	m_eleId

std::string	m_eleIdBaseline

std::string	m_eleConfig

std::string	m_eleConfigBaseline

std::string	m_eleBaselineIso_WP

bool	m_eleIdExpert

int	m_muId

int	m_muIdBaseline

std::string	m_photonId

std::string	m_photonIdBaseline

std::string	m_tauId

std::string	m_tauIdBaseline

std::string	m_eleIso_WP

std::string	m_eleIsoHighPt_WP

double	m_eleIsoHighPtThresh

std::string	m_eleChID_WP

bool	m_eleLRT

int	m_eleLRT_strat

bool	m_eleChIso

bool	m_eleChID_signal

bool	m_runECIS

std::string	m_photonBaselineIso_WP

std::string	m_photonIso_WP

std::string	m_photonTriggerName

std::string	m_muBaselineIso_WP

std::string	m_muIso_WP

std::string	m_muIsoHighPt_WP

double	m_muIsoHighPtThresh

bool	m_muHighPtExtraSmear

bool	m_muEffCorrForce1D

std::string	m_BtagWP

std::string	m_BtagTagger

double	m_BtagMinPt

std::string	m_BtagKeyOverride

std::string	m_BtagSystStrategy

std::string	m_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

double	m_muBaselinePt

double	m_muBaselineEta

double	m_muPt

double	m_muEta

double	m_mud0sig

double	m_muz0

double	m_mubaselined0sig

double	m_mubaselinez0

bool	m_murequirepassedHighPtCuts

double	m_muCosmicz0

double	m_muCosmicd0

double	m_badmuQoverP

int	m_muCalibrationMode

bool	m_muLRT

double	m_photonBaselinePt

double	m_photonBaselineEta

double	m_photonEta

double	m_photonPt

bool	m_photonBaselineCrackVeto

bool	m_photonCrackVeto

bool	m_photonAllowLate

double	m_tauPrePtCut

double	m_tauPt

double	m_tauEta

std::string	m_tauConfigPath

std::string	m_tauConfigPathBaseline

bool	m_tauDoTTM

std::string	m_tauSmearingToolRecommendationTag

std::string	m_tauSmearingToolGenerator

TEnv	m_tauConfigReader

double	m_jetPt

double	m_jetEta

double	m_jetJvt

std::string	m_JvtWP

double	m_JvtPtMax

std::string	m_JvtConfigRun2

std::string	m_JvtConfigRun3

double	m_trkJetPt

double	m_trkJetEta

bool	m_doFwdJVT

std::string	m_fJvtWP

double	m_fJvtPtMax

double	m_fJvtEtaMin

std::string	m_fJvtConfigRun2

std::string	m_fJvtConfigRun3

bool	m_JMScalib

bool	m_orDoTau
	Overlap removal options. More...

bool	m_orDoPhoton

bool	m_orDoEleJet

bool	m_orDoElEl

bool	m_orDoElMu

bool	m_orDoMuonJet

bool	m_orDoBjet

bool	m_orDoElBjet

bool	m_orDoMuBjet

bool	m_orDoTauBjet

bool	m_orDoBoostedElectron

double	m_orBoostedElectronC1

double	m_orBoostedElectronC2

double	m_orBoostedElectronMaxConeSize

bool	m_orDoBoostedMuon

double	m_orBoostedMuonC1

double	m_orBoostedMuonC2

double	m_orBoostedMuonMaxConeSize

bool	m_orApplyRelPt

double	m_orMuJetPtRatio

double	m_orMuJetTrkPtRatio

double	m_orMuJetInnerDR

bool	m_orDoMuonJetGhostAssociation

bool	m_orRemoveCaloMuons

std::string	m_orBtagWP

std::string	m_orInputLabel

bool	m_orPhotonFavoured

double	m_orBJetPtUpperThres

bool	m_orLinkOverlapObjects

bool	m_orDoFatjets

double	m_EleFatJetDR

double	m_JetFatJetDR

bool	m_doIsoSignal

bool	m_doElIsoSignal

bool	m_doPhIsoSignal

bool	m_doMuIsoSignal

bool	m_useSigLepForIsoCloseByOR

std::string	m_IsoCloseByORpassLabel

bool	m_useTRUTH3

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

bool	m_isRun3

bool	m_isPHYSLITE

std::string	m_metJetSelection

int	m_showerType

std::string	m_defaultJets

std::string	m_defaultTrackJets

std::string	m_fatJets

std::string	m_defaultTruthJets

CP::SystematicSet	m_defaultSyst = CP::SystematicSet()

CP::SystematicSet	m_currentSyst

std::string	m_EG_corrModel

std::string	m_EG_corrFNList

bool	m_applyJVTCut

std::string	m_bTaggingCalibrationFilePath

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

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

asg::AnaToolHandle< 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< IJetSelector >	m_jetCleaningTool

asg::AnaToolHandle< IJetUpdateJvt >	m_jetJvtUpdateTool

asg::AnaToolHandle< JetPileupLabelingTool >	m_jetPileupLabelingTool

asg::AnaToolHandle< JetPileupTag::JetVertexNNTagger >	m_jetNNJvtMomentTool

asg::AnaToolHandle< IAsgSelectionTool >	m_jetNNJvtSelectionTool

asg::AnaToolHandle< CP::IJvtEfficiencyTool >	m_jetNNJvtEfficiencyTool

asg::AnaToolHandle< IAsgSelectionTool >	m_jetfJvtSelectionTool

asg::AnaToolHandle< CP::IJvtEfficiencyTool >	m_jetfJvtEfficiencyTool

asg::AnaToolHandle< SmoothedWZTagger >	m_WTaggerTool

asg::AnaToolHandle< SmoothedWZTagger >	m_ZTaggerTool

asg::AnaToolHandle< JSSWTopTaggerDNN >	m_TopTaggerTool

asg::AnaToolHandle< JetTruthLabelingTool >	m_jetTruthLabelingTool

asg::AnaToolHandle< ICPJetUncertaintiesTool >	m_WTagjetUncertaintiesTool

asg::AnaToolHandle< ICPJetUncertaintiesTool >	m_ZTagjetUncertaintiesTool

asg::AnaToolHandle< ICPJetUncertaintiesTool >	m_TopTagjetUncertaintiesTool

SG::ReadDecorHandleKey< xAOD::JetContainer >	m_label_truthKey

std::string	m_jesConfig

std::string	m_jesConfigJMS

std::string	m_jesConfigJMSData

std::string	m_jesConfigAFII

std::string	m_jesConfigFat

std::string	m_jesConfigFatData

std::string	m_jesCalibSeq

std::string	m_jesCalibSeqJMS

std::string	m_jesCalibSeqFat

std::string	m_jesCalibArea

asg::AnaToolHandle< CP::IMuonSelectionTool >	m_muonSelectionTool

asg::AnaToolHandle< CP::IMuonSelectionTool >	m_muonSelectionHighPtTool

asg::AnaToolHandle< CP::IMuonSelectionTool >	m_muonSelectionToolBaseline

asg::AnaToolHandle< CP::IMuonCalibrationAndSmearingTool >	m_muonCalibTool

asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors >	m_muonEfficiencySFTool

asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors >	m_muonEfficiencyBMHighPtSFTool

asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors >	m_muonTTVAEfficiencySFTool

asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors >	m_muonIsolationSFTool

asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors >	m_muonHighPtIsolationSFTool

asg::AnaToolHandle< CP::IMuonTriggerScaleFactors >	m_muonTriggerSFTool

ToolHandleArray< CP::IMuonTriggerScaleFactors >	m_muonTrigSFTools

asg::AnaToolHandle< CP::IMuonLRTOverlapRemovalTool >	m_muonLRTORTool

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

asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool >	m_elecEfficiencySFTool_reco
	Combined muon collection. More...

asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool >	m_elecEfficiencySFTool_id

asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool >	m_elecEfficiencySFTool_trig_singleLep

asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool >	m_elecEfficiencySFTool_trigEff_singleLep

asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool >	m_elecEfficiencySFTool_iso

asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool >	m_elecEfficiencySFTool_isoHighPt

asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool >	m_elecEfficiencySFTool_chf

std::vector< asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > >	m_elecEfficiencySFTool_trig_mixLep

std::vector< asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > >	m_elecEfficiencySFTool_trigEff_mixLep

ToolHandleArray< IAsgElectronEfficiencyCorrectionTool >	m_elecTrigSFTools

ToolHandleArray< IAsgElectronEfficiencyCorrectionTool >	m_elecTrigEffTools

asg::AnaToolHandle< CP::IElectronLRTOverlapRemovalTool >	m_elecLRTORTool

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

asg::AnaToolHandle< CP::IEgammaCalibrationAndSmearingTool >	m_egammaCalibTool
	Combined electron collection. More...

asg::AnaToolHandle< IAsgElectronLikelihoodTool >	m_elecSelLikelihood

asg::AnaToolHandle< IAsgElectronLikelihoodTool >	m_elecSelLikelihoodBaseline

asg::AnaToolHandle< IAsgPhotonIsEMSelector >	m_photonSelIsEM

asg::AnaToolHandle< IAsgPhotonIsEMSelector >	m_photonSelIsEMBaseline

asg::AnaToolHandle< IAsgDeadHVCellRemovalTool >	m_deadHVTool

asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool >	m_photonEfficiencySFTool

asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool >	m_photonIsolationSFTool

asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool >	m_photonTriggerSFTool

std::vector< asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > >	m_photonEfficiencySFTool_trigSF_AsymDiphoton

std::vector< asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > >	m_photonEfficiencySFTool_trigEff_AsymDiphoton

ToolHandleArray< IAsgPhotonEfficiencyCorrectionTool >	m_photonTrigSFTools

ToolHandleArray< IAsgPhotonEfficiencyCorrectionTool >	m_photonTrigEffTools

asg::AnaToolHandle< IEGammaAmbiguityTool >	m_egammaAmbiguityTool

asg::AnaToolHandle< IAsgElectronLikelihoodTool >	m_elecChargeIDSelectorTool

asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool >	m_elecChargeEffCorrTool

asg::AnaToolHandle< TauAnalysisTools::ITauSelectionTool >	m_tauSelTool

asg::AnaToolHandle< TauAnalysisTools::ITauSelectionTool >	m_tauSelToolBaseline

asg::AnaToolHandle< TauAnalysisTools::ITauSmearingTool >	m_tauSmearingTool

asg::AnaToolHandle< TauAnalysisTools::ITauTruthMatchingTool >	m_tauTruthMatch

asg::AnaToolHandle< TauAnalysisTools::ITauEfficiencyCorrectionsTool >	m_tauEffTool

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

asg::AnaToolHandle< IBTaggingEfficiencyTool >	m_btagEffTool

asg::AnaToolHandle< IBTaggingSelectionTool >	m_btagSelTool

asg::AnaToolHandle< IBTaggingSelectionTool >	m_btagSelTool_OR

asg::AnaToolHandle< IBTaggingEfficiencyTool >	m_btagEffTool_trkJet

asg::AnaToolHandle< IBTaggingSelectionTool >	m_btagSelTool_trkJet

asg::AnaToolHandle< IMETMaker >	m_metMaker

asg::AnaToolHandle< IMETSystematicsTool >	m_metSystTool

asg::AnaToolHandle< IMETSignificance >	m_metSignif

std::string	m_trig2015combination_singleLep

std::string	m_trig2016combination_singleLep

std::string	m_trig2017combination_singleLep

std::string	m_trig2018combination_singleLep

std::string	m_trig2022combination_singleLep

int	m_trigNToys_diLep

std::string	m_trig2015combination_diLep

std::string	m_trig2016combination_diLep

std::string	m_trig2017combination_diLep

std::string	m_trig2018combination_diLep

std::string	m_trig2022combination_diLep

asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionTool >	m_trigGlobalEffCorrTool_diLep

int	m_trigNToys_multiLep

std::string	m_trig2015combination_multiLep

std::string	m_trig2016combination_multiLep

std::string	m_trig2017combination_multiLep

std::string	m_trig2018combination_multiLep

std::string	m_trig2022combination_multiLep

asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionTool >	m_trigGlobalEffCorrTool_multiLep

int	m_trigNToys_diPhoton

std::string	m_trig2015combination_diPhoton

std::string	m_trig2016combination_diPhoton

std::string	m_trig2017combination_diPhoton

std::string	m_trig2018combination_diPhoton

std::string	m_trig2022combination_diPhoton

asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionTool >	m_trigGlobalEffCorrTool_diPhoton

asg::AnaToolHandle< TrigConf::ITrigConfigTool >	m_trigConfTool

asg::AnaToolHandle< Trig::TrigDecisionTool >	m_trigDecTool

asg::AnaToolHandle< Trig::IMatchingTool >	m_trigMatchingTool

asg::AnaToolHandle< Trig::IMatchScoringTool >	m_trigMatchScoringTool

asg::AnaToolHandle< Trig::IMatchScoringTool >	m_trigDRScoringTool

asg::AnaToolHandle< CP::IIsolationCorrectionTool >	m_isoCorrTool

asg::AnaToolHandle< CP::IIsolationSelectionTool >	m_isoTool

asg::AnaToolHandle< CP::IIsolationSelectionTool >	m_isoBaselineTool

asg::AnaToolHandle< CP::IIsolationSelectionTool >	m_isoHighPtTool

asg::AnaToolHandle< CP::IIsolationCloseByCorrectionTool >	m_isoCloseByTool

asg::AnaToolHandle< CP::IPileupReweightingTool >	m_prwTool

asg::AnaToolHandle< InDet::IInclusiveTrackFilterTool >	m_LRTuncTool

asg::AnaToolHandle< ORUtils::IOverlapTool >	m_tauJetORtool

ORUtils::ToolBox	m_orToolbox

asg::AnaToolHandle< IWeightTool >	m_pmgSHnjetWeighter

asg::AnaToolHandle< IWeightTool >	m_pmgSHnjetWeighterWZ

std::string	m_eleIdBaselineDFName

std::string	m_eleIdDFName

std::string	m_photonIdBaselineDFName

std::string	m_photonIdDFName

std::string	m_jetCleanDFName

SG::AuxElement::ConstAccessor< char >	m_acc_eleIdBaseline

SG::AuxElement::ConstAccessor< char >	m_acc_eleId

SG::AuxElement::ConstAccessor< char >	m_acc_photonIdBaseline

SG::AuxElement::ConstAccessor< char >	m_acc_photonId

SG::AuxElement::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 > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
std::map< std::string, std::string >	m_conf_to_prop

std::set< std::string >	m_bool_prop_set

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

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

std::mutex	m_triggerCacheMutex

std::vector< std::string >	m_v_trigs15_cache_singleEle

std::vector< std::string >	m_v_trigs16_cache_singleEle

std::vector< std::string >	m_v_trigs17_cache_singleEle

std::vector< std::string >	m_v_trigs18_cache_singleEle

std::vector< std::string >	m_v_trigs22_cache_singleEle

std::vector< std::string >	m_v_trigs15_cache_singleLep

std::vector< std::string >	m_v_trigs16_cache_singleLep

std::vector< std::string >	m_v_trigs17_cache_singleLep

std::vector< std::string >	m_v_trigs18_cache_singleLep

std::vector< std::string >	m_v_trigs22_cache_singleLep

std::vector< std::string >	m_v_trigs15_cache_diLep

std::vector< std::string >	m_v_trigs16_cache_diLep

std::vector< std::string >	m_v_trigs17_cache_diLep

std::vector< std::string >	m_v_trigs18_cache_diLep

std::vector< std::string >	m_v_trigs22_cache_diLep

std::vector< std::string >	m_v_trigs15_cache_multiLep

std::vector< std::string >	m_v_trigs16_cache_multiLep

std::vector< std::string >	m_v_trigs17_cache_multiLep

std::vector< std::string >	m_v_trigs18_cache_multiLep

std::vector< std::string >	m_v_trigs22_cache_multiLep

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

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

MetaStore_t	m_inputMetaStore
	Object accessing the input metadata store. More...

MetaStore_t	m_outputMetaStore
	Object accessing the output metadata store. More...

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

bool	m_useIncidents

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Callback functions helping in metadata reading/writing
void	setUseIncidents (const bool flag)

virtual void	handle (const Incident &inc)
	Function receiving incidents from IncidentSvc/TEvent. More...

virtual StatusCode	beginInputFile ()
	Function called when a new input file is opened. More...

virtual StatusCode	endInputFile ()
	Function called when the currently open input file got completely processed. More...

virtual StatusCode	beginEvent ()
	Function called when a new events is loaded. More...

virtual StatusCode	metaDataStop ()
	Function called when the tool should write out its metadata. More...

Detailed Description

Definition at line 140 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 462 of file ISUSYObjDef_xAODTool.h.

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

Constructor & Destructor Documentation

◆ SUSYObjDef_xAOD()

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

Override for the b-tagging jet collection

Definition at line 101 of file SUSYObjDef_xAOD.cxx.

   : asg::AsgMetadataTool( name ),
     m_dataSource(Undefined),
     m_jetInputType(xAOD::JetInput::Uncategorized),
     m_force_noElId(false),
     m_force_noMuId(false),
     m_doTTVAsf(true),
     m_upstreamTriggerMatching(false),
     m_trigMatchingPrefix(""),
     m_useBtagging(false),
     m_useBtagging_trkJet(false),
     m_debug(false),
     m_strictConfigCheck(false),
     m_badJetCut(""),
     m_fatJetUncConfig(""),
     m_fatJetUncVars(""),
     m_WDecorName(""),
     m_ZDecorName(""),
     m_TopDecorName(""),
     m_WtagConfig(""),
     m_ZtagConfig(""),
     m_ToptagConfig(""),
     m_WZTaggerCalibArea(""),
     m_TopTaggerCalibArea(""),
     m_WTagUncConfig(""),
     m_ZTagUncConfig(""),
     m_TopTagUncConfig(""),
     m_JetTruthLabelName(""),
     m_tool_init(false),
     m_subtool_init(false),
     // set dummies for configuration
     m_eleTerm(""),
     m_gammaTerm(""),
     m_tauTerm(""),
     m_jetTerm(""),
     m_muonTerm(""),
     m_inputMETSuffix(""),
     m_outMETTerm(""),
     m_metRemoveOverlappingCaloTaggedMuons(true),
     m_metDoSetMuonJetEMScale(true),
     m_metDoRemoveMuonJets(true),
     m_metUseGhostMuons(false),
     m_metDoMuonEloss(false),
     m_metGreedyPhotons(false),
     m_metVeryGreedyPhotons(false),
     m_metsysConfigPrefix(""),
     m_trkMETsyst(true),
     m_caloMETsyst(false),
     m_softTermParam(-99),
     m_treatPUJets(true),
     m_doPhiReso(true),
     m_autoconfigPRW(false),
     m_autoconfigPRWPath(""),
     m_autoconfigPRWFile(""),
     m_autoconfigPRWCombinedmode(false),
     m_autoconfigPRWRPVmode(false),
     m_autoconfigPRWRtags(""),
     m_mcCampaign(""),
     m_mcChannel(-99),
     m_useCommonPRWFiles(false),
     m_commonPRWFileMC20a(""),
     m_commonPRWFileMC20d(""),
     m_commonPRWFileMC20e(""),
     m_commonPRWFileMC21a(""),
     m_commonPRWFileMC23a(""),
     m_commonPRWFileMC23c(""),
     m_commonPRWFileMC23d(""),
     m_commonPRWFileMC23e(""),
     m_prwDataSF(-99.),
     m_prwDataSF_UP(-99.),
     m_prwDataSF_DW(-99.),
     m_runDepPrescaleWeightPRW(false),
     m_electronTriggerSFStringSingle(""),
     m_eleId(""),
     m_eleIdBaseline(""),
     m_eleConfig(""),
     m_eleConfigBaseline(""),
     m_eleBaselineIso_WP(""),
     m_eleIdExpert(false),
     m_muId(static_cast<int>(xAOD::Muon::Quality(xAOD::Muon::VeryLoose))),
     m_muIdBaseline(static_cast<int>(xAOD::Muon::Quality(xAOD::Muon::VeryLoose))),
     m_photonId(""),
     m_photonIdBaseline(""),
     m_tauId(""),
     m_tauIdBaseline(""),
     m_eleIso_WP(""),
     m_eleIsoHighPt_WP(""),
     m_eleIsoHighPtThresh(-99.),
     m_eleChID_WP(""),
     m_eleLRT_strat(-99),
     m_eleChIso(true),
     m_eleChID_signal(false),
     m_runECIS(false),
     m_photonBaselineIso_WP(""),
     m_photonIso_WP(""),
     m_photonTriggerName(""),
     m_muBaselineIso_WP(""),
     m_muIso_WP(""),
     m_muIsoHighPt_WP(""),
     m_muIsoHighPtThresh(-99.),
     m_muHighPtExtraSmear(false),
     m_muEffCorrForce1D(false),
     m_BtagWP(""),
     m_BtagTagger(""),
     m_BtagMinPt(-99.),
     m_BtagKeyOverride(""),
     m_BtagSystStrategy(""),
     m_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_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_tauSmearingToolGenerator(""),
     //
     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_EG_corrModel(""),
     m_EG_corrFNList(""),
     m_applyJVTCut(true),
     //
     // set toolhandles empty by default
     m_jetCalibTool(""),
     m_jetFatCalibTool(""),
     m_jetUncertaintiesTool(""),
     m_jetUncertaintiesPDSmearTool(""),
     m_fatjetUncertaintiesTool(""),
     m_jetCleaningTool(""),
     m_jetJvtUpdateTool(""),
     m_jetPileupLabelingTool(""),
     m_jetNNJvtMomentTool(""),
     m_jetNNJvtSelectionTool(""),
     m_jetNNJvtEfficiencyTool(""),
     m_jetfJvtSelectionTool(""),
     m_jetfJvtEfficiencyTool(""),    
     //
     m_WTaggerTool(""),
     m_ZTaggerTool(""),
     m_TopTaggerTool(""),
     m_jetTruthLabelingTool(""),
     m_WTagjetUncertaintiesTool(""),
     m_ZTagjetUncertaintiesTool(""),
     m_TopTagjetUncertaintiesTool(""),
     //
     m_muonSelectionTool(""),
     m_muonSelectionHighPtTool(""),
     m_muonSelectionToolBaseline(""),
     m_muonCalibTool(""),
     m_muonEfficiencySFTool(""),
     m_muonEfficiencyBMHighPtSFTool(""),
     m_muonTTVAEfficiencySFTool(""),
     m_muonIsolationSFTool(""),
     m_muonHighPtIsolationSFTool(""),
     m_muonTriggerSFTool(""),
     //
     m_elecEfficiencySFTool_reco(""),
     m_elecEfficiencySFTool_id(""),
     m_elecEfficiencySFTool_trig_singleLep(""),
     m_elecEfficiencySFTool_trigEff_singleLep(""),
     m_elecEfficiencySFTool_iso(""),
     m_elecEfficiencySFTool_isoHighPt(""),
     //
     m_egammaCalibTool(""),
     m_elecSelLikelihood(""),
     m_elecSelLikelihoodBaseline(""),
     m_photonSelIsEM(""),
     m_photonSelIsEMBaseline(""),
     m_photonEfficiencySFTool(""),
     m_photonIsolationSFTool(""),
     m_photonTriggerSFTool(""),
     m_egammaAmbiguityTool(""),
     m_elecChargeIDSelectorTool(""),
     m_elecChargeEffCorrTool(""),
     //
     m_tauSelTool(""),
     m_tauSelToolBaseline(""),
     m_tauSmearingTool(""),
     m_tauTruthMatch(""),
     m_tauEffTool(""),
     //
     m_btagEffTool(""),
     m_btagSelTool(""),
     m_btagSelTool_OR(""),
     m_btagEffTool_trkJet(""),
     m_btagSelTool_trkJet(""),
     //
     m_metMaker(""),
     m_metSystTool(""),
     m_metSignif(""),
     //
     m_trig2015combination_singleLep(""),
     m_trig2016combination_singleLep(""),
     m_trig2017combination_singleLep(""),
     m_trig2018combination_singleLep(""),
     m_trig2022combination_singleLep(""),
     m_trigNToys_diLep(-99),
     m_trig2015combination_diLep(""),
     m_trig2016combination_diLep(""),
     m_trig2017combination_diLep(""),
     m_trig2018combination_diLep(""),
     m_trig2022combination_diLep(""),
     m_trigGlobalEffCorrTool_diLep(""),
     m_trigNToys_multiLep(-99),
     m_trig2015combination_multiLep(""),
     m_trig2016combination_multiLep(""),
     m_trig2017combination_multiLep(""),
     m_trig2018combination_multiLep(""),
     m_trig2022combination_multiLep(""),
     m_trigGlobalEffCorrTool_multiLep(""),
     m_trigNToys_diPhoton(-99),
     m_trig2015combination_diPhoton(""),
     m_trig2016combination_diPhoton(""),
     m_trig2017combination_diPhoton(""),
     m_trig2018combination_diPhoton(""),
     m_trig2022combination_diPhoton(""),
     m_trigGlobalEffCorrTool_diPhoton(""),
     m_trigConfTool(""),
     m_trigDecTool(""),
     m_trigMatchingTool(""),
     m_trigMatchScoringTool(""),
     m_trigDRScoringTool(""),
     //
     m_isoCorrTool(""),
     m_isoTool(""),
     //disable m_isoToolLowPtPLV(""),
     m_isoBaselineTool(""),
     m_isoHighPtTool(""),
     //
     m_prwTool(""),
     //
     m_LRTuncTool(""),
     //
     m_orToolbox("ORToolbox",this),
     //
     m_pmgSHnjetWeighter(""),
     m_pmgSHnjetWeighterWZ(""),
     //
     m_acc_eleIdBaseline("DFCommonElectronsLHLooseBL"),
     m_acc_eleId("DFCommonElectronsLHTight"),
     m_acc_photonIdBaseline("DFCommonPhotonsIsEMTight"),
     m_acc_photonId("DFCommonPhotonsIsEMTight"),
     //
     m_acc_jetClean("DFCommonJets_jetClean_LooseBad")
 {
   //General settings
   declareProperty( "DataSource", m_dataSource = Undefined );
   declareProperty( "DebugMode",  m_debug );
   declareProperty( "ConfigFile",  m_configFile = "SUSYTools/SUSYTools_Default.conf" );
   //Overlap Removal
   declareProperty( "DoTauOR",       m_orDoTau );
   declareProperty( "DoPhotonOR",    m_orDoPhoton );
   declareProperty( "DoEleJetOR",    m_orDoEleJet );
   declareProperty( "DoElElOR",    m_orDoElEl );
   declareProperty( "DoElMuOR",    m_orDoElMu );
   declareProperty( "DoMuonJetOR",   m_orDoMuonJet );
   declareProperty( "DoBjetOR",      m_orDoBjet );
   declareProperty( "DoElBjetOR",    m_orDoElBjet );
   declareProperty( "DoMuBjetOR",    m_orDoMuBjet );
   declareProperty( "DoTauBjetOR",    m_orDoTauBjet );
   declareProperty( "UseBtagging",   m_useBtagging );
   declareProperty( "UseBtaggingTrkJet",   m_useBtagging_trkJet );
   declareProperty( "DoBoostedElectronOR", m_orDoBoostedElectron );
   declareProperty( "BoostedElectronORC1", m_orBoostedElectronC1 );
   declareProperty( "BoostedElectronORC2", m_orBoostedElectronC2 );
   declareProperty( "BoostedElectronORMaxConeSize", m_orBoostedElectronMaxConeSize );
   declareProperty( "DoBoostedMuonOR", m_orDoBoostedMuon );
   declareProperty( "BoostedMuonORC1", m_orBoostedMuonC1 );
   declareProperty( "BoostedMuonORC2", m_orBoostedMuonC2 );
   declareProperty( "BoostedMuonORMaxConeSize", m_orBoostedMuonMaxConeSize );
   declareProperty( "ORDoMuonJetGhostAssociation", m_orDoMuonJetGhostAssociation );
   declareProperty( "ORRemoveCaloMuons", m_orRemoveCaloMuons );
   declareProperty( "ORMuJetApplyRelPt", m_orApplyRelPt);
   declareProperty( "ORMuJetPtRatio", m_orMuJetPtRatio);
   declareProperty( "ORMuJetInnerDR", m_orMuJetInnerDR );
   declareProperty( "ORJetTrkPtRatio", m_orMuJetTrkPtRatio);
   declareProperty( "ORInputLabel", m_orInputLabel);
   declareProperty( "ORPhotonFavoured", m_orPhotonFavoured);
   declareProperty( "ORBJetPtUpperThres", m_orBJetPtUpperThres);
   declareProperty( "ORLinkOverlapObjects", m_orLinkOverlapObjects);
  
   declareProperty( "DoFatJetOR", m_orDoFatjets);
   declareProperty( "OREleFatJetDR", m_EleFatJetDR);
   declareProperty( "ORJetFatJetDR", m_JetFatJetDR);
   declareProperty( "TriggerUpstreamMatching", m_upstreamTriggerMatching, "Use alternative trigger matching tool based on upstream (in-derivation) matching");
   declareProperty( "TriggerMatchingPrefix", m_trigMatchingPrefix, "Prefix for trigger matching containers (Analysis for PHSYLITE derivations");
  
   //--- Object definitions
   //MET
   declareProperty( "METEleTerm",     m_eleTerm   );
   declareProperty( "METGammaTerm",   m_gammaTerm );
   declareProperty( "METTauTerm",     m_tauTerm   );
   declareProperty( "METJetTerm",     m_jetTerm   );
   declareProperty( "METMuonTerm",    m_muonTerm  );
   declareProperty( "METInputSuffix", m_inputMETSuffix );
   declareProperty( "METOutputTerm",  m_outMETTerm );
   declareProperty( "METDoTrkSyst",   m_trkMETsyst  );
   declareProperty( "METDoCaloSyst",  m_caloMETsyst );
   declareProperty( "METDoTrkJetSyst",  m_trkJetsyst );
   declareProperty( "METJetSelection",  m_metJetSelection );
   declareProperty( "METSysConfigPrefix",  m_metsysConfigPrefix );
  
   declareProperty( "METRemoveORCaloTaggedMuons", m_metRemoveOverlappingCaloTaggedMuons);
   declareProperty( "METDoSetMuonJetEMScale", m_metDoSetMuonJetEMScale);
   declareProperty( "METDoRemoveMuonJets",  m_metDoRemoveMuonJets );
   declareProperty( "METUseGhostMuons",  m_metUseGhostMuons );
   declareProperty( "METDoMuonEloss",  m_metDoMuonEloss );
   declareProperty( "METDoGreedyPhotons",  m_metGreedyPhotons );
   declareProperty( "METDoVeryGreedyPhotons",  m_metVeryGreedyPhotons );
  
  
   declareProperty( "SoftTermParam",  m_softTermParam);
   declareProperty( "TreatPUJets",  m_treatPUJets);
   declareProperty( "DoPhiReso",  m_doPhiReso);
  
   //JETS
   declareProperty( "JetInputType",  m_jetInputType );
  
   declareProperty( "FwdJetDoJVT",  m_doFwdJVT );
  
   declareProperty( "JetJMSCalib",  m_JMScalib );
   declareProperty( "JetLargeRcollection",  m_fatJets );
  
   //BTAGGING
   declareProperty( "BtagTagger", m_BtagTagger);
   declareProperty( "BtagWPOR", m_orBtagWP); //the one used in the Overlap Removal
   declareProperty( "BtagWP", m_BtagWP);     //the one used in FillJet() afterwards
   declareProperty( "BtagMinPt", m_BtagMinPt);    // minimum jetPt cut (MR31061) >=20 GeV EM jets & >=10 GeV TrackJets (not calibrated below)
   declareProperty( "BtagKeyOverride", m_BtagKeyOverride); 
   declareProperty( "BtagCalibPath", m_bTaggingCalibrationFilePath);
   declareProperty( "BtagTaggerTrkJet", m_BtagTagger_trkJet);
   declareProperty( "BtagMinPtTrkJet", m_BtagMinPt_trkJet);    // minimum jetPt cut (MR31061) >=20 GeV EM jets & >=10 GeV TrackJets (not calibrated below)
   declareProperty( "BtagWPTrkJet", m_BtagWP_trkJet);  //the one used in FillTrackJet() afterwards
   //ELECTRONS
   declareProperty( "EleBaselinePt", m_eleBaselinePt);
   declareProperty( "ElePt", m_elePt);
   declareProperty( "EleBaselineEta", m_eleBaselineEta);
   declareProperty( "EleEta", m_eleEta);
   declareProperty( "EleBaselineId", m_eleIdBaseline);
   declareProperty( "EleBaselineConfig", m_eleConfigBaseline);
   declareProperty( "EleBaselineCrackVeto", m_eleBaselineCrackVeto);
   declareProperty( "EleId", m_eleId);
   declareProperty( "EleConfig", m_eleConfig);
   declareProperty( "EleIso", m_eleIso_WP);
   declareProperty( "EleIsoHighPt", m_eleIsoHighPt_WP);
   declareProperty( "EleIsoHighPtThresh", m_eleIsoHighPtThresh);
   declareProperty( "EleCFT", m_eleChID_WP);
   declareProperty( "EleCFTIso", m_eleChIso);
   declareProperty( "EleCFTSignal", m_eleChID_signal);
   declareProperty( "EleD0sig", m_eled0sig);
   declareProperty( "EleZ0", m_elez0);
   declareProperty( "EleBaselineD0sig", m_elebaselined0sig);
   declareProperty( "EleBaselineZ0", m_elebaselinez0);
   declareProperty( "EleCrackVeto", m_eleCrackVeto);
   declareProperty( "EleForceNoId", m_force_noElId );
   declareProperty( "EleEffMapFilePath", m_eleEffMapFilePath);
   declareProperty( "EleAllowRun3TrigSFFallback", m_eleAllowRun3TrigSFFallback);
  
   //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);
  
   //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);
  
   //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_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_jetJvtUpdateTool.declarePropertyFor( this, "JetJvtUpdateTool", "The JetJvtUpdateTool" );
   m_jetPileupLabelingTool.declarePropertyFor( this, "JetPileupLabelingTool", "The JetPileupLabelingTool" );
   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 3074 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)
   // The PDSmear systematics have been initialised as the second component of the JET_JER systematic, here we'll catch the uncertainties which are to use the PDSmear initialised tool.
   if (!m_jetUncertaintiesTool.empty() && systConfig.name().find("__2") == 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("__2") != 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()) {
     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_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 996 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.find("ATLFASTII")==0) simType = "AFII";
       else if(simFlavour.find("ATLFAST3")==0) simType = "AF3";
       else simType = "FS";
  
       bool found = false;
       while ( mcCampaignMD.empty() ) {
          for ( const auto& campaign_rtags : PRWRtags ) {                                 // consider all campaigns
             for ( const auto& rtag: campaign_rtags.second ) {                            // consider all rtags
                if (found) continue;
                if (amiTag.find(rtag)!=string::npos) {                             // find matching tag
                   mcCampaignMD = campaign_rtags.first.substr(0,5);                // save campaign
                   standard_like = (campaign_rtags.first.find("ns")?true:false);   // track non-standard r-tags
                   found = true;                                                   // break if found
                }
             }
          }
          // in case not found
          if (!found) {
             ATH_MSG_ERROR( "autoconfigurePileupRWTool(): unrecognized xAOD::FileMetaData::amiTag, \'" << amiTag << "'. Please check your input sample.");
              return StatusCode::FAILURE;
          }
          //
          ATH_MSG_INFO( "Setting up autoconfigurePileupRWTool for mc campaign " << mcCampaignMD << " (from amiTag " << amiTag << ") (standard-like = " << (standard_like?"true":"false") << ")." );
          if ( (!standard_like) && (!RPVLLmode) )
             ATH_MSG_WARNING("Non-standard r-tag found (" << amiTag.data() << "), but RPVLLmode not set. Perhaps you want to set \"PRW.autoconfigPRWRPVmode: 1\" in the config?");
       }
     } else {
 #ifndef XAOD_STANDALONE
       ATH_MSG_ERROR( "autoconfigurePileupRWTool(): access to FileMetaData failed, can't get mc channel number.");
       return StatusCode::FAILURE;
 #else
  
       if ( m_mcCampaign == "mc20a" || m_mcCampaign == "mc20d" || m_mcCampaign == "mc20e" || m_mcCampaign == "mc21a" || m_mcCampaign == "mc23a" || m_mcCampaign == "mc23c" || m_mcCampaign == "mc23d" || m_mcCampaign == "mc23e") {
     // First see if the user set the mcCampaign/run number by property (hopefully temporary workaround)
     if ( m_mcChannel > 0) {
       ATH_MSG_WARNING( "autoconfigurePileupRWTool(): access to FileMetaData failed -> getting the mc channel number (DSID) and campaign from configuration." );
       std::string NoMetadataButPropertyOK("");
       NoMetadataButPropertyOK += "autoconfigurePileupRWTool(): 'mcCampaign' is used and passed to SUSYTools as '";
       NoMetadataButPropertyOK += m_mcCampaign;
       NoMetadataButPropertyOK += "'. 'mcChannel' is used and passed to SUSYTools as '";
       NoMetadataButPropertyOK += std::to_string(m_mcChannel);
       NoMetadataButPropertyOK += "'. Autocongiguring PRW accordingly.";
       ATH_MSG_WARNING( NoMetadataButPropertyOK );
       mcCampaignMD = m_mcCampaign;
       dsid = m_mcChannel;
     } else {
       // OK, this is a fall-back option without using MetaData but one has to manually set 'mcCampaign' property
       ATH_MSG_WARNING( "autoconfigurePileupRWTool(): access to FileMetaData failed -> getting the mc channel number (DSID) from the event store." );
       const xAOD::EventInfo* evtInfo = GetEventInfo();
       dsid = evtInfo->mcChannelNumber();
  
       std::string NoMetadataButPropertyOK("");
       NoMetadataButPropertyOK += "autoconfigurePileupRWTool(): 'mcCampaign' is used and passed to SUSYTools as '";
       NoMetadataButPropertyOK += m_mcCampaign;
       NoMetadataButPropertyOK += "'. Autoconfiguring PRW accordingly.";
       ATH_MSG_WARNING( NoMetadataButPropertyOK );
       mcCampaignMD = m_mcCampaign;
     }
       } else {
     ATH_MSG_ERROR( "autoconfigurePileupRWTool(): `mcCampaign' is not set properly.");
     return StatusCode::FAILURE;
       }
 #endif
     }
  
     // If requested set the PRW file to common PRW file of the processed MC campaign
     if (m_useCommonPRWFiles) {
       ATH_MSG_INFO( "autoconfigurePileupRWTool(): retrieving the common PRW file for MC campaign: " << mcCampaignMD );
       if      (mcCampaignMD == "mc20a") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC20a);}
       else if (mcCampaignMD == "mc20d") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC20d);}
       else if (mcCampaignMD == "mc20e") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC20e);}
       else if (mcCampaignMD == "mc21a") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC21a);}
       else if (mcCampaignMD == "mc23a") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC23a);}
       else if (mcCampaignMD == "mc23c") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC23c);}
       else if (mcCampaignMD == "mc23d") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC23d);}
       else if (mcCampaignMD == "mc23e") {prwConfigFile = PathResolverFindCalibFile(m_commonPRWFileMC23e);}
       else {
         ATH_MSG_ERROR( "autoconfigurePileupRWTool(): no common PRW file known for MC campaign: " << mcCampaignMD);
         return StatusCode::FAILURE;
       }
     }
     // Otherwise try finding the dedicated PRW file on /cvmfs
     else {
       // Retrieve the input file
       int DSID_INT = static_cast<int>(dsid);
       prwConfigFile += "DSID" + std::to_string(DSID_INT/1000) + "xxx/pileup_" + mcCampaignMD + "_dsid" + std::to_string(DSID_INT) + "_" + simType + ".root";
  
       if (RPVLLmode) prwConfigFile = TString(prwConfigFile).ReplaceAll(".root","_rpvll.root").Data();
  
       // PRW file specified by user
       // e.g. DSID700xxx/pileup_mc20a_dsid700015_FS.root
       if (!PRWfileName.empty()) {
       prwConfigFile = PRWfilesDir + PRWfileName;
       ATH_MSG_INFO( "autoconfigurePileupRWTool(): PRW file was specifed by user: " << prwConfigFile.data() );
       }
     }
  
     m_prwConfFiles.clear();
  
     // Combined mode can be only used when running with full data with the same MC samples
     if (Combinedmode) {
       if (mcCampaignMD.find("mc20") == std::string::npos) {
         ATH_MSG_ERROR( "autoconfigurePileupRWTool(): combined mode currently onlys supported for mc20! Impossible to autoconfigure PRW. Aborting." );
         return StatusCode::FAILURE;
       }
       // When using the common PRW files we can directly add them
       if (m_useCommonPRWFiles) {
         m_prwConfFiles.push_back( m_commonPRWFileMC20a );
         m_prwConfFiles.push_back( m_commonPRWFileMC20d );
         m_prwConfFiles.push_back( m_commonPRWFileMC20e );
       }
       // Otherwise we have to replace the mc campaign in the name accordingly
       else {
         m_prwConfFiles.emplace_back( TString(prwConfigFile).ReplaceAll(mcCampaignMD, "mc20a").Data() );
         m_prwConfFiles.emplace_back( TString(prwConfigFile).ReplaceAll(mcCampaignMD, "mc20d").Data() );
         m_prwConfFiles.emplace_back( TString(prwConfigFile).ReplaceAll(mcCampaignMD, "mc20e").Data() );
       }
       m_prwConfFiles.push_back( PathResolverFindCalibFile(m_prwActualMu2017File) );
       m_prwConfFiles.push_back( PathResolverFindCalibFile(m_prwActualMu2018File) );
     } else {
       m_prwConfFiles.push_back( prwConfigFile );
       if ( mcCampaignMD == "mc20d") {
         m_prwConfFiles.push_back( PathResolverFindCalibFile(m_prwActualMu2017File) );
       } else if (mcCampaignMD == "mc20e") {
         m_prwConfFiles.push_back( PathResolverFindCalibFile(m_prwActualMu2018File) );
       } else if (mcCampaignMD == "mc21a" || mcCampaignMD == "mc23a") {
         m_prwConfFiles.push_back( PathResolverFindCalibFile(m_prwActualMu2022File) );
       } else if (mcCampaignMD == "mc23c" || mcCampaignMD == "mc23d") {
         m_prwConfFiles.push_back( PathResolverFindCalibFile(m_prwActualMu2023File) );
       } else if (mcCampaignMD == "mc23e") {
         m_prwConfFiles.push_back( PathResolverFindCalibFile(m_prwActualMu2024File) );
       }
  
     }
     prwConfigFile = usePathResolver ? PathResolverFindCalibFile(prwConfigFile) : prwConfigFile;
  
     // Test if file exists (i.e. was requested already to /cvmfs if the DSID-specific PRW files are used) and is usable
     TFile testF(prwConfigFile.data(),"read");
     if (testF.IsZombie()) {
       ATH_MSG_ERROR( "autoconfigurePileupRWTool(): file not found -> " << prwConfigFile.data() << " ! Impossible to autoconfigure PRW. Aborting." );
       if ( (!standard_like) && (!RPVLLmode) )
          ATH_MSG_WARNING("Running with non-standard r-tag (" << amiTag.data() << "), but RPVLLmode not set. Perhaps you want to set \"PRW.autoconfigPRWRPVmode: 1\" in the config?");
       return StatusCode::FAILURE;
     }
  
     ATH_MSG_INFO( "autoconfigurePileupRWTool(): configuring PRW tool using " << prwConfigFile.data() );
   }
   // Return gracefully
   return StatusCode::SUCCESS;
 }

◆ beginEvent()

StatusCode asg::AsgMetadataTool::beginEvent ( )

protectedvirtualinherited

Function called when a new events is loaded.

Dummy implementation that can be overridden by the derived tool.

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

Definition at line 196 of file AsgMetadataTool.cxx.

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

◆ beginInputFile()

StatusCode asg::AsgMetadataTool::beginInputFile ( )

protectedvirtualinherited

Function called when a new input file is opened.

Dummy implementation that can be overridden by the derived tool.

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

Definition at line 180 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 785 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 866 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 846 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 927 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 1197 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 1202 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 1240 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 1255 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 1271 of file SUSYObjDef_xAOD.cxx.

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

◆ configFromFile() [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 1287 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 2068 of file SUSYObjDef_xAOD.cxx.

                                                                 {
   return m_currentSyst;
 }

◆ currentSystematicIsNominal()

bool ST::SUSYObjDef_xAOD::currentSystematicIsNominal ( ) const

Definition at line 2096 of file SUSYObjDef_xAOD.cxx.

                                                        {
   return isNominal(m_currentSyst);
 }

◆ currentSystematicIsVariation()

bool ST::SUSYObjDef_xAOD::currentSystematicIsVariation ( ) const

Definition at line 2100 of file SUSYObjDef_xAOD.cxx.

                                                          {
   return isVariation(m_currentSyst);
 }

◆ currentSystematicIsWeight()

bool ST::SUSYObjDef_xAOD::currentSystematicIsWeight ( ) const

Definition at line 2104 of file SUSYObjDef_xAOD.cxx.

                                                       {
   return isWeight(m_currentSyst);
 }

◆ declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

inlineprivateinherited

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

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

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

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

Definition at line 245 of file AthCommonDataStore.h.

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

◆ declareProperty() [2/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

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

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

Definition at line 221 of file AthCommonDataStore.h.

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

◆ declareProperty() [3/6]

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

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

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

◆ declareProperty() [4/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

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

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

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

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

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

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > & 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; }

◆ EG_WP()

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

protected

Definition at line 1209 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 106 of file Trigger.cxx.

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

◆ endInputFile()

StatusCode asg::AsgMetadataTool::endInputFile ( )

protectedvirtualinherited

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

Dummy implementation that can be overridden by the derived tool.

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

Definition at line 188 of file AsgMetadataTool.cxx.

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

◆ evtStore() [1/2]

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

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

protectedinherited

Add StoreName to extra input/output deps as needed.

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

◆ FillElectron()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 221 of file Electrons.cxx.

                                                                                        {
  
   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 379 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) {
           ATH_CHECK(m_WTaggerTool->tag(input));
           ATH_CHECK(m_ZTaggerTool->tag(input));
           ATH_CHECK(m_TopTaggerTool->tag(input));
  
           // Retrieve large-R tagging results for W/Z/top
           if (!m_WtagConfig.empty()) {
             // 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()) {
             // 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()) {
             // 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()) {
           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." );
         }
         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("__2") == 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("__2") != std::string::npos){
          // Use the PDSmeared uncertainties tool on the systematic with PDsmear 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 205 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;
  
   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 || 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; 
     }
   }
  
   //Object quality cut as described at https://twiki.cern.ch/twiki/bin/view/AtlasProtected/EGammaIdentificationRun2#Object_quality_cut
   if (!input.isGoodOQ(xAOD::EgammaParameters::BADCLUSPHOTON))
     return StatusCode::SUCCESS;
  
   //Photon quality as in https://twiki.cern.ch/twiki/bin/view/AtlasProtected/EGammaIdentificationRun2#Photon_cleaning
   bool passPhCleaning = false;
   if (acc_passPhCleaning.isAvailable(input) && acc_passPhCleaningNoTime.isAvailable(input)) {
     if ( (!m_photonAllowLate && acc_passPhCleaning(input)) || (m_photonAllowLate && acc_passPhCleaningNoTime(input)) ) passPhCleaning = true;
   } else {
     ATH_MSG_VERBOSE ("DFCommonPhotonsCleaning is not found in DAOD..");
     if ( (!m_photonAllowLate && PhotonHelpers::passOQquality(input)) || 
          ( m_photonAllowLate && PhotonHelpers::passOQqualityDelayed(input)) ) passPhCleaning = true;
   }
   if (!passPhCleaning) return StatusCode::SUCCESS;
  
  
   bool passBaseID = false;
   if (m_acc_photonIdBaseline.isAvailable(input)) {
     passBaseID = bool(m_acc_photonIdBaseline(input));
   } else {
     passBaseID = bool(m_photonSelIsEMBaseline->accept(&input));
   }
   if (!passBaseID) return StatusCode::SUCCESS;
  
   //--- Do baseline isolation check
   if ( !( m_photonBaselineIso_WP.empty() ) &&  !( m_isoBaselineTool->accept(input) ) ) return StatusCode::SUCCESS;
  
   dec_baseline(input) = true;
   dec_selected(input) = 2;
   if (!m_photonIso_WP.empty()) dec_isol(input) = bool(m_isoTool->accept(input));
  
   ATH_MSG_VERBOSE("FillPhoton: passed baseline selection.");
   return StatusCode::SUCCESS;
 }

◆ FillTau()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 76 of file Taus.cxx.

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

◆ FillTrackJet()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 603 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 231 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 ((tp->absPdgId() > 1000000 && tp->absPdgId() < 1000007) || // squarkL
         (tp->absPdgId() > 1000010 && tp->absPdgId() < 1000017) || // sleptonL
         (tp->absPdgId() > 2000000 && tp->absPdgId() < 2000007) || // squarkR
         (tp->absPdgId() > 2000010 && tp->absPdgId() < 2000017) || // sleptonR
         (tp->absPdgId() > 1000020 && tp->absPdgId() < 1000040)) { // gauginos
  
       if (tp->nParents() != 0) {
         if ( tp->parent(0)->absPdgId()  < 1000000) {
           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 (firstsp->absPdgId() > 1000000) pdgid1 = firstsp->pdgId();
   if (secondsp->absPdgId() > 1000000) 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 125 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) {
  
     //check ifSUSY particle
     if ((tp->absPdgId() > 1000000 && tp->absPdgId() < 1000007) || // squarkL
         (tp->absPdgId() > 1000010 && tp->absPdgId() < 1000017) || // sleptonL
         (tp->absPdgId() > 2000000 && tp->absPdgId() < 2000007) || // squarkR
         (tp->absPdgId() > 2000010 && tp->absPdgId() < 2000017) || // sleptonR
         (tp->absPdgId() > 1000020 && tp->absPdgId() < 1000040)) { // gauginos
  
       if (tp->nParents() != 0) {
         if ( tp->parent(0)->absPdgId()  < 1000000) {
           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 (firstsp->absPdgId() > 1000000) pdgid1 = firstsp->pdgId();
   if (secondsp->absPdgId() > 1000000) 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 214 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 105 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 75 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 1019 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 1065 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 2977 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 2972 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 2967 of file SUSYObjDef_xAOD.cxx.

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

◆ 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) );
       }
     }
   }
  
   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;
   }
  
   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 588 of file Electrons.cxx.

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

◆ GetEleTriggerEfficiencySF()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 554 of file Electrons.cxx.

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

◆ getElSFkeys()

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

protected

Definition at line 1221 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 2929 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 238 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 3036 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 3024 of file SUSYObjDef_xAOD.cxx.

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

◆ GetJets()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 74 of file Jets.cxx.

   {
     if (!m_tool_init) {
       ATH_MSG_ERROR("SUSYTools was not initialized!!");
       return StatusCode::FAILURE;
     }
  
   if (m_isPHYSLITE && jetkey.find("AnalysisJets") == std::string::npos){
     ATH_MSG_ERROR("You are running on PHYSLITE derivation. Please change the Jets container to 'AnalysisJets'");
     return StatusCode::FAILURE;
   }
  
     ATH_MSG_DEBUG("Default jetkey:           " << m_defaultJets);
     ATH_MSG_DEBUG("Function argument jetkey: " << jetkey);
  
     // load default regular & btag jet keys
     std::string jetkey_tmp = m_defaultJets;                                           // use default for regular jetkey_tmp
  
     // override default if user is passing a jetkey
     if (!jetkey.empty()) {
       jetkey_tmp = jetkey;
     }
  
     // final settings
     ATH_MSG_DEBUG("Key for retrieving jet collection:             jetkey      = " << jetkey_tmp);
  
     const xAOD::JetContainer* jets = nullptr;
     if (copy==nullptr) { // empty container provided
       if (containerToBeCopied != nullptr) {
         jets = containerToBeCopied;
       }
       else {
         ATH_MSG_DEBUG("Retrieve jet collection: " << jetkey_tmp);
         ATH_CHECK( evtStore()->retrieve(jets, jetkey_tmp) );
       }
       std::pair<xAOD::JetContainer*, xAOD::ShallowAuxContainer*> shallowcopy = xAOD::shallowCopyContainer(*jets);
       copy = shallowcopy.first;
       copyaux = shallowcopy.second;
       bool setLinks = xAOD::setOriginalObjectLink(*jets, *copy);
       if (!setLinks) {
         ATH_MSG_WARNING("Failed to set original object links on " << jetkey_tmp);
       }
     } else { // use the user-supplied collection instead
       ATH_MSG_DEBUG("Not retrieving jet collecton, using existing one provided by user");
       jets = copy;
     }
  
     // Calibrate the jets
     ATH_CHECK(m_jetCalibTool->applyCalibration(*copy));
  
     // Add isHS labels to jets (required for JvtEfficiencyTools)
     if (!isData()) {
       ATH_CHECK(m_jetPileupLabelingTool->decorate(*copy));
     }
  
     // 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 317 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

inlinefinaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 428 of file SUSYObjDef_xAOD.h.

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

◆ GetMET()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 23 of file MET.cxx.

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

◆ GetMETSig()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 240 of file MET.cxx.

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

◆ GetMuons()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 100 of file Muons.cxx.

 {
   if (!m_tool_init) {
     ATH_MSG_ERROR("SUSYTools was not initialized!!");
     return StatusCode::FAILURE;
   }
  
   // Initializing prompt/LRT OR procedure
   auto outputCol = std::make_unique<xAOD::MuonContainer>();
   std::unique_ptr<xAOD::MuonAuxContainer> outputAuxCol;
   outputAuxCol = std::make_unique<xAOD::MuonAuxContainer>();
   outputCol->setStore(outputAuxCol.get());
   ATH_CHECK( m_outMuonLocation.initialize() );
  
   if (bool(m_muLRT) && !lrtmuonkey.empty() && evtStore()->contains<xAOD::MuonContainer>(lrtmuonkey)){
     ATH_MSG_DEBUG("Applying prompt/LRT muon OR procedure"); 
  
     // First identify if merged container has already been made (for instances where GetMuons() is called more than once)
     if (evtStore()->contains<xAOD::MuonContainer>("StdWithLRTMuons")) {
       ATH_MSG_DEBUG("Merged prompt/LRT container already created in TStore");  
     } else {
       ATH_MSG_DEBUG("Creating merged prompt/LRT container in TStore");
  
       // Retrieve prompt and LRT muons from TStore
       ATH_CHECK( evtStore()->retrieve(prompt_muons, muonkey) );
       ATH_CHECK( evtStore()->retrieve(lrt_muons, lrtmuonkey) );
  
       // Remove LRT muons as flagged by filter for uncertainty
       auto filtered_muons = std::make_unique<xAOD::MuonContainer>();
       std::unique_ptr<xAOD::MuonAuxContainer> filtered_muons_aux = std::make_unique<xAOD::MuonAuxContainer>();
       filtered_muons->setStore(filtered_muons_aux.get());
       ATH_CHECK(prepareLRTMuons(lrt_muons, filtered_muons.get()));
  
       // Check overlap between prompt and LRT collections
       std::vector<bool> writePromptMuon;
       std::vector<bool> writeLRTMuon;
       m_muonLRTORTool->checkOverlap(*prompt_muons, *filtered_muons, writePromptMuon, writeLRTMuon);
     
       // Decorate muons with prompt/LRT
       for (const xAOD::Muon* mu : *prompt_muons)   dec_isLRT(*mu) = 0;
       for (const xAOD::Muon* mu : *filtered_muons) dec_isLRT(*mu) = 1;
  
       // Create merged StdWithLRTMuons container
       outputCol->reserve(prompt_muons->size() + filtered_muons->size());
       ATH_CHECK(MergeMuons(*prompt_muons, writePromptMuon, outputCol.get()) );
       ATH_CHECK(MergeMuons(*filtered_muons, writeLRTMuon, outputCol.get()) );
  
       // Save merged StdWithLRTMuons container to TStore
       ATH_CHECK(evtStore()->record(std::move(outputCol), m_outMuonLocation.key())); 
       ATH_CHECK(evtStore()->record(std::move(outputAuxCol), m_outMuonLocation.key() + "Aux.") );
  
     }
   } else if (!lrtmuonkey.empty()) {
     if (evtStore()->contains<xAOD::MuonContainer>(lrtmuonkey) == false && bool(m_muLRT) == true) ATH_MSG_WARNING("prompt/LRT OR procedure attempted but " << lrtmuonkey << " not in ROOT file, check config!");
     ATH_MSG_DEBUG("Not applying prompt/LRT muon OR procedure"); 
   }
   
   if (m_isPHYSLITE && muonkey.find("AnalysisMuons")==std::string::npos){
     ATH_MSG_ERROR("You are running on PHYSLITE derivation. Please change the Muons container to 'AnalysisMuons'");
     return StatusCode::FAILURE;
   }
  
   const xAOD::MuonContainer* muons = nullptr;
   if (bool(m_muLRT) && evtStore()->contains<xAOD::MuonContainer>(lrtmuonkey)){
       ATH_MSG_DEBUG("Using container: " << m_outMuonLocation.key());
       ATH_CHECK( evtStore()->retrieve(muons, m_outMuonLocation.key())); 
   }
   else { 
     if (copy==nullptr) { // empty container provided
         ATH_MSG_DEBUG("Empty container provided");
       if (containerToBeCopied != nullptr) {
         ATH_MSG_DEBUG("Containter to be copied not nullptr");
         muons = containerToBeCopied;
       }
       else {
         ATH_MSG_DEBUG("Getting Muons collection");
         ATH_CHECK( evtStore()->retrieve(muons, muonkey) );
       }
     }
   }
  
   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;
   }
  
   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 530 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 2937 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 2962 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 2947 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 2868 of file SUSYObjDef_xAOD.cxx.

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

◆ getProperty() [1/2]

template<typename T >

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

inlineinherited

Definition at line 224 of file ISUSYObjDef_xAODTool.h.

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

◆ getProperty() [2/2]

template<class T >

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

inherited

Get one of the tool's properties.

◆ GetRandomRunNumber()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2986 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 3008 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 2837 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 2852 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 418 of file Electrons.cxx.

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

◆ GetSignalMuonSF()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 477 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 203 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 244 of file Photons.cxx.

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

◆ GetSignalTauSF()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 129 of file Taus.cxx.

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

◆ GetSignalTauSFsys()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 159 of file Taus.cxx.

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

◆ GetSumOfWeights()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2982 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 2531 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 (sys.name().find("__2") == std::string::npos) {
     if (!m_jetUncertaintiesTool.empty()) {
       if ( m_jetUncertaintiesTool->isAffectedBySystematic( CP::SystematicVariation(sys.basename(), CP::SystematicVariation::CONTINUOUS) ) ) {
     sysInfo.affectsKinematics = true;
     sysInfo.affectsType = SystObjType::Jet;
       }
     }
   }
   if (sys.name().find("__2") != std::string::npos) {
     if (!m_jetUncertaintiesPDSmearTool.empty()) {
       if ( m_jetUncertaintiesPDSmearTool->isAffectedBySystematic( CP::SystematicVariation(sys.basename(), CP::SystematicVariation::CONTINUOUS) ) ) {
     sysInfo.affectsKinematics = true;
     sysInfo.affectsType = SystObjType::Jet;
       }
     }
   }
  
   if (!m_fatjetUncertaintiesTool.empty()) {
     if ( m_fatjetUncertaintiesTool->isAffectedBySystematic( CP::SystematicVariation(sys.basename(), CP::SystematicVariation::CONTINUOUS) ) ) {
       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 2488 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));
     if (sys.basename().find("JET_JER") != std::string::npos && m_jetUncertaintiesPDsmearing == true) {
       // Add the additional PDSmear JET_JER systematics to the systematics registry if we're using the PDSmear. Otherwise they don't need to be added.
       std::string JER_systematicName = sys.name();
       JER_systematicName = std::regex_replace(JER_systematicName, std::regex("__1"), "__2");
       CP::SystematicVariation sys_JER(JER_systematicName);
       sysInfoList.push_back(getSystInfo(sys_JER));
     }
     }
  
   }
  
   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 1803 of file SUSYObjDef_xAOD.cxx.

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

◆ GetTaus()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 30 of file Taus.cxx.

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

◆ GetTauTriggerEfficiencySF()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 193 of file Taus.cxx.

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

◆ GetTotalElectronSF()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 623 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 636 of file Electrons.cxx.

                                                                                                                                                                                                                                                                      {
   float sf(1.);
  
   //Set the new systematic variation
   StatusCode ret = m_elecEfficiencySFTool_reco->applySystematicVariation(systConfig);
   if (ret != StatusCode::SUCCESS) {
     ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (reco) for systematic var. " << systConfig.name() );
   }
  
   ret = m_elecEfficiencySFTool_id->applySystematicVariation(systConfig);
   if (ret != StatusCode::SUCCESS) {
     ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (id) for systematic var. " << systConfig.name() );
   }
  
   ret = m_elecEfficiencySFTool_trig_singleLep->applySystematicVariation(systConfig);
   if (ret != StatusCode::SUCCESS) {
     ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (trigger) for systematic var. " << systConfig.name() );
   }
  
   ret = m_elecEfficiencySFTool_iso->applySystematicVariation(systConfig);
   if (ret != StatusCode::SUCCESS) {
     ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (iso) for systematic var. " << systConfig.name() );
   }
  
   ret = m_elecEfficiencySFTool_isoHighPt->applySystematicVariation(systConfig);
   if (ret != StatusCode::SUCCESS) {
     ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (iso high-pt) for systematic var. " << systConfig.name() );
   }
  
   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
   ret = m_elecEfficiencySFTool_reco->applySystematicVariation(m_currentSyst);
   if (ret != StatusCode::SUCCESS) {
     ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (reco) back to default.");
   }
  
   ret = m_elecEfficiencySFTool_id->applySystematicVariation(m_currentSyst);
   if (ret != StatusCode::SUCCESS) {
     ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (id) back to default.");
   }
  
   ret = m_elecEfficiencySFTool_trig_singleLep->applySystematicVariation(m_currentSyst);
   if (ret != StatusCode::SUCCESS) {
     ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (trigger) back to default.");
   }
  
   ret = m_elecEfficiencySFTool_iso->applySystematicVariation(m_currentSyst);
   if (ret != StatusCode::SUCCESS) {
     ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (iso) back to default.");
   }
  
   ret = m_elecEfficiencySFTool_isoHighPt->applySystematicVariation(m_currentSyst);
   if (ret != StatusCode::SUCCESS) {
     ATH_MSG_ERROR("Cannot configure AsgElectronEfficiencyCorrectionTool (iso high-pt) back to default.");
   }
  
   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 1089 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 1102 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 599 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 619 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 544 of file Muons.cxx.

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

◆ GetTotalPhotonSF()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 317 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 329 of file Photons.cxx.

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

◆ GetTotalTauSF()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 227 of file Taus.cxx.

                                                                                                                                        {
  
   double sf(1.);
  
   for (const xAOD::TauJet* tau : taus) {
     // check existence of OR information
     if (!acc_passOR.isAvailable(*tau)) { 
       ATH_MSG_WARNING("Tau does not have Overlap Removal decision set. You should only call GetTotalTauSF with taus that have been passed through OR. SF will NOT be applied!");
       break;
     }
  
     // Call this for all taus, which will add the decoration
     double tmpSF = GetSignalTauSF(*tau, idSF, triggerSF, trigExpr);
     if (acc_signal(*tau) && acc_passOR(*tau)) {
       sf *= tmpSF;
     }
   }
  
   return sf;
 }

◆ GetTotalTauSFsys()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 249 of file Taus.cxx.

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

◆ GetTrackJets()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 165 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 324 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 402 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 562 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 623 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 407 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 505 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 463 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 540 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 329 of file Trigger.cxx.

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

◆ GetTriggerTokens()

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

Definition at line 347 of file Trigger.cxx.

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

◆ GetTrigPrescale()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 319 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 130 of file AsgMetadataTool.cxx.

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

◆ initialize()

StatusCode ST::SUSYObjDef_xAOD::initialize ( )

finaloverridevirtual

Dummy implementation of the initialisation function.

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

Reimplemented from asg::AsgTool.

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

157 {return m_dataSource == AtlfastII;}

◆ IsBadJet()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 705 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 402 of file Muons.cxx.

 {
   const static SG::AuxElement::Decorator<char> dec_bad("bad");
   dec_bad(input) = false;
  
   const static SG::AuxElement::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 731 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 753 of file Jets.cxx.

                                                                   {
     // Cheatsheet:
     // returns 5 if between 60% and 0%
     // returns 4 if between 70% and 60%
     // returns 3 if between 77% and 70%
     // returns 2 if between 85% and 77%
     // returns 1 if between 100% and 85%
     // 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 640 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 441 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 156 of file SUSYObjDef_xAOD.h.

156 {return m_dataSource == Data;}

◆ IsHighPtMuon()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 383 of file Muons.cxx.

 {
   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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 70 of file Trigger.cxx.

                                                                                       {
   // NB - this now applies to the entire function...
   //std::string L1item = "L1_XE50"; For now, I'll assume all the triggers use L1_XE50 - might need changing in the future.
  
   // First check if we're affected by the L1_XE50 bug
   bool L1_XE50 = m_trigDecTool->isPassed("L1_XE50");
   bool L1_XE55 = m_trigDecTool->isPassed("L1_XE55");
   bool HLT_noalg_L1J400 = m_trigDecTool->isPassed("HLT_noalg_L1J400");
   if (!L1_XE50 && j400_OR && HLT_noalg_L1J400) {
     return emulateHLT(triggerName);
   }
   else if (L1_XE50 || L1_XE55) {
     // 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); // 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)
                                                               || IsMETTrigPassed("HLT_xe80_cell_xe115_tcpufit_L1XE50 ",false)); // 2022
   else if(year == 2023)                                  return (IsMETTrigPassed("HLT_xe55_cell_xe70_tcpufit_xe90_pfsum_vssk_L1XE50",false)
                                                               || IsMETTrigPassed("HLT_xe55_cell_xe70_tcpufit_xe95_pfsum_cssk_L1XE50",false)
                                                               || IsMETTrigPassed("HLT_xe60_cell_xe95_pfsum_cssk_L1XE50",false)
                                                               || IsMETTrigPassed("HLT_xe65_cell_xe100_mhtpufit_pf_L1XE50",false)
                                                               || IsMETTrigPassed("HLT_xe65_cell_xe105_mhtpufit_em_L1XE50",false)
                                                               || IsMETTrigPassed("HLT_xe75_cell_xe65_tcpufit_xe90_trkmht_L1XE50",false)
                                                               || IsMETTrigPassed("HLT_xe65_cell_xe90_pfopufit_L1XE50",false)
                                                               || IsMETTrigPassed("HLT_xe80_cell_xe115_tcpufit_L1XE50 ",false)); // 2023
  
   return false; 
 }

◆ isNominal()

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

Definition at line 2072 of file SUSYObjDef_xAOD.cxx.

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

◆ IsPFlowCrackVetoCleaning()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 261 of file MET.cxx.

                                                                  {
  
   if (m_jetInputType != xAOD::JetInput::EMPFlow) {
     return true;
   }
  
   bool passPFlowCVCleaning = true;
  
   if (elec) {
     for (const xAOD::Electron* el : *elec) {
       if (acc_passCrackVetoCleaning.isAvailable(*el)) {
     if (!acc_passCrackVetoCleaning(*el)) {
       passPFlowCVCleaning = false;
       break;
     }
       } else {
     ATH_MSG_WARNING("DFCommonCrackVetoCleaning variable is not available! Use p3830 onwards for PFlow jets!");
       }
     }
   }
  
   if (passPFlowCVCleaning && gamma) {
     for (const xAOD::Photon* ph : *gamma) {
       if (acc_passCrackVetoCleaning.isAvailable(*ph)) {
     if (!acc_passCrackVetoCleaning(*ph)) {
       passPFlowCVCleaning = false;
       break;
     }
       } else {
     ATH_MSG_WARNING("DFCommonCrackVetoCleaning variable is not available! Use p3830 onwards for PFlow jets!");
       }
     }
   }
  
   return passPFlowCVCleaning;
 }

◆ isPrompt()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 23 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 360 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 653 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 341 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 164 of file Photons.cxx.

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

◆ IsSignalTau()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 111 of file Taus.cxx.

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

◆ IsTrackBJet()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 742 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 774 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 92 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 242 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 237 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 227 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 232 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 222 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 309 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::AuxElement::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 2087 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 2076 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 647 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 947 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 994 of file Jets.cxx.

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

◆ MergeElectrons()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 61 of file Electrons.cxx.

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

◆ MergeMuons()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 55 of file Muons.cxx.

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

◆ metaDataStop()

StatusCode asg::AsgMetadataTool::metaDataStop ( )

protectedvirtualinherited

Function called when the tool should write out its metadata.

Dummy implementation that can be overridden by the derived tool.

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

Definition at line 204 of file AsgMetadataTool.cxx.

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

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msg_level_name()

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

inherited

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

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

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

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

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

Definition at line 101 of file AsgTool.cxx.

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

◆ msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

◆ NearbyLeptonCorrections()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2919 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 97 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 2884 of file SUSYObjDef_xAOD.cxx.

 {
  
   if (this->GetPrimVtx() == nullptr) {
     ATH_MSG_WARNING( "Will now call the OR tool on an event without a primary vertex, and it will likely crash. Please require a PV earlier in your analysis code!");
   }
  
   ATH_CHECK( m_orToolbox.masterTool->removeOverlaps(electrons, muons, jets, taujet, gamma, fatjets) );
  
   /*
   // Count number of objects after overlap removal
   int Nel = 0;
   for (const auto& el : *electrons) {
     if (dec_passOR( *el )) Nel++;
   }
  
   int Nmu = 0;
   for (const auto& mu : *muons) {
     if (dec_passOR( *mu )) Nmu++;
   }
  
   int Njet = 0;
   for (const auto& jet : *jets) {
     if (dec_passOR( *jet )) Njet++;
   }
  
   ATH_MSG_VERBOSE( "After overlap removal: Nel=" << Nel << ", Nmu=" << Nmu << ", Njet=" << Njet );
   */
  
   return StatusCode::SUCCESS;
 }

◆ prepareLRTElectrons()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 90 of file Electrons.cxx.

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

◆ prepareLRTMuons()

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

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 73 of file Muons.cxx.

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

◆ print() [1/2]

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

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

Definition at line 131 of file AsgTool.cxx.

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

◆ print() [2/2]

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

pure virtualinherited

Print the state of the tool.

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

◆ readConfig()

StatusCode ST::SUSYObjDef_xAOD::readConfig ( )

finaloverrideprotectedvirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 1317 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/2022_Summer_Prerecom_v1/map4.txt");
   configFromFile(m_eleAllowRun3TrigSFFallback, "Ele.AllowRun3TrigSFFallback", rEnv, false);
   
   configFromFile(m_trig2015combination_singleLep, "Trig.Singlelep2015", rEnv, "e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose || mu20_iloose_L1MU15_OR_mu40");
   configFromFile(m_trig2016combination_singleLep, "Trig.Singlelep2016", rEnv, "e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0 || mu26_ivarmedium_OR_mu50");
   configFromFile(m_trig2017combination_singleLep, "Trig.Singlelep2017", rEnv, "e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0 || mu26_ivarmedium_OR_mu50");
   configFromFile(m_trig2018combination_singleLep, "Trig.Singlelep2018", rEnv, "e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0 || mu26_ivarmedium_OR_mu50");
   configFromFile(m_trig2022combination_singleLep, "Trig.Singlelep2022", rEnv, "e26_lhtight_ivarloose_L1EM22VHI_OR_e60_lhmedium_L1EM22VHI_OR_e140_lhloose_L1EM22VHI || HLT_mu24_ivarmedium_L1MU14FCH_OR_HLT_mu50_L1MU14FCH");
   configFromFile(m_trigNToys_diLep, "Trig.DilepNToys", rEnv, 250); // 0 means calculate from formula instead - needs to be supported for the trigger combination
   configFromFile(m_trig2015combination_diLep, "Trig.Dilep2015", rEnv, "e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose || mu20_iloose_L1MU15_OR_mu40 || 2e12_lhloose_L12EM10VH || e17_lhloose_mu14 || e7_lhmedium_mu24 || mu18_mu8noL1 || 2mu10");
   configFromFile(m_trig2016combination_diLep, "Trig.Dilep2016", rEnv, "e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0 || mu26_ivarmedium_OR_mu50 || 2e17_lhvloose_nod0 || e17_lhloose_nod0_mu14 || e7_lhmedium_nod0_mu24 || e26_lhmedium_nod0_L1EM22VHI_mu8noL1 || mu22_mu8noL1 || 2mu14");
   configFromFile(m_trig2017combination_diLep, "Trig.Dilep2017", rEnv, "e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0 || mu26_ivarmedium_OR_mu50 || 2e24_lhvloose_nod0 || e17_lhloose_nod0_mu14 || e7_lhmedium_nod0_mu24 || e26_lhmedium_nod0_mu8noL1 || mu22_mu8noL1 || 2mu14");
   configFromFile(m_trig2018combination_diLep, "Trig.Dilep2018", rEnv, "e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0 || mu26_ivarmedium_OR_mu50 || 2e24_lhvloose_nod0 || e17_lhloose_nod0_mu14 || e7_lhmedium_nod0_mu24 || e26_lhmedium_nod0_mu8noL1 || mu22_mu8noL1 || 2mu14");
   // configFromFile(m_trig2022combination_diLep, "Trig.Dilep2022", rEnv, "");
   configFromFile(m_trigNToys_multiLep, "Trig.MultiNToys", rEnv, 250); // 0 means calculate from formula instead - needs to be supported for the trigger combination
   configFromFile(m_trig2015combination_multiLep, "Trig.Multi2015", rEnv, "e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose || mu20_iloose_L1MU15_OR_mu40 || 2e12_lhloose_L12EM10VH || e17_lhloose_2e9_lhloose || 2e12_lhloose_mu10 || e12_lhloose_2mu10 || e17_lhloose_mu14 || e7_lhmedium_mu24 || mu18_mu8noL1 || 2mu10 || 3mu6");
   configFromFile(m_trig2016combination_multiLep, "Trig.Multi2016", rEnv, "e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0 || mu26_ivarmedium_OR_mu50 || 2e17_lhvloose_nod0 || e17_lhloose_nod0_mu14 || e7_lhmedium_nod0_mu24 || e26_lhmedium_nod0_L1EM22VHI_mu8noL1 || e17_lhloose_nod0_2e9_lhloose_nod0 || e12_lhloose_nod0_2mu10 || 2e12_lhloose_nod0_mu10 || mu22_mu8noL1 || 2mu14 || 3mu6");
   configFromFile(m_trig2017combination_multiLep, "Trig.Multi2017", rEnv, "e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0 || mu26_ivarmedium_OR_mu50 || 2e24_lhvloose_nod0 || e17_lhloose_nod0_mu14 || e7_lhmedium_nod0_mu24 || e26_lhmedium_nod0_mu8noL1 || e24_lhvloose_nod0_2e12_lhvloose_nod0_L1EM20VH_3EM10VH || e12_lhloose_nod0_2mu10 || 2e12_lhloose_nod0_mu10 || mu22_mu8noL1 || 2mu14 || 3mu6");
   configFromFile(m_trig2018combination_multiLep, "Trig.Multi2018", rEnv, "e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0 || mu26_ivarmedium_OR_mu50 || 2e24_lhvloose_nod0 || e17_lhloose_nod0_mu14 || e7_lhmedium_nod0_mu24 || e26_lhmedium_nod0_mu8noL1 || e24_lhvloose_nod0_2e12_lhvloose_nod0_L1EM20VH_3EM10VH || e12_lhloose_nod0_2mu10 || 2e12_lhloose_nod0_mu10 || mu22_mu8noL1 || 2mu14 || 3mu6");
   // configFromFile(m_trig2022combination_multiLep, "Trig.Multi2022", rEnv, "");
   configFromFile(m_trigNToys_diPhoton, "Trig.DiphotonNToys", rEnv, 250); // 0 means calculate from formula instead - needs to be supported for the trigger combination
   configFromFile(m_trig2015combination_diPhoton, "Trig.Diphoton2015", rEnv, "g35_loose_g25_loose");
   configFromFile(m_trig2016combination_diPhoton, "Trig.Diphotonp2016", rEnv, "g35_loose_g25_loose");
   configFromFile(m_trig2017combination_diPhoton, "Trig.Diphotonp2017", rEnv, "g35_medium_g25_medium_L12EM20VH");
   configFromFile(m_trig2018combination_diPhoton, "Trig.Diphotonp2018", rEnv, "g35_medium_g25_medium_L12EM20VH");
   // configFromFile(m_trig2018combination_diPhoton, "Trig.Diphotonp2022", rEnv, "");
   //
   configFromFile(m_muBaselinePt, "MuonBaseline.Pt", rEnv, 10000.);
   configFromFile(m_muBaselineEta, "MuonBaseline.Eta", rEnv, 2.7);
   configFromFile(m_force_noMuId, "Muon.ForceNoId", rEnv, false);
   configFromFile(m_muBaselineIso_WP, "MuonBaseline.Iso", rEnv, "None");
   configFromFile(m_doTTVAsf, "Muon.TTVASF", rEnv, true);
   //
   configFromFile(m_muPt, "Muon.Pt", rEnv, 25000.);
   configFromFile(m_muEta, "Muon.Eta", rEnv, 2.7);
   configFromFile(m_muIso_WP, "Muon.Iso", rEnv, "Loose_VarRad");
   configFromFile(m_muIsoHighPt_WP, "Muon.IsoHighPt", rEnv, "Loose_VarRad");
   configFromFile(m_muIsoHighPtThresh, "Muon.IsoHighPtThresh", rEnv, 200e3);
   configFromFile(m_mud0sig, "Muon.d0sig", rEnv, 3.);
   configFromFile(m_muz0, "Muon.z0", rEnv, 0.5);
   configFromFile(m_mubaselined0sig, "MuonBaseline.d0sig", rEnv, -99.);
   configFromFile(m_mubaselinez0, "MuonBaseline.z0", rEnv, 0.5);
   configFromFile(m_murequirepassedHighPtCuts, "Muon.passedHighPt", rEnv, false);
   configFromFile(m_muHighPtExtraSmear, "Muon.HighPtExtraSmear", rEnv, false);
   configFromFile(m_muEffCorrForce1D, "Muon.EffCorrForce1D", rEnv, false);
   //
   configFromFile(m_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, "2022-prerec");
   configFromFile(m_tauSmearingToolGenerator,"Tau.SmearingToolGenerator", rEnv, "PoPy");
   //
   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, m_isRun3 ? "rel22/Summer2024_PreRec/R4_CategoryReduction_FullJER.config" : "rel22/Summer2023_PreRec/R4_CategoryReduction_FullJER.config"); // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/JetUncertaintiesRel22/
   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, false); // for non "SimpleJER" config, run the PDSmear systematics. This are labelled with an __2 if they are being used, but otherwise will have the same tree name as the JET_JER systematic trees.
   configFromFile(m_fatJets, "Jet.LargeRcollection", rEnv, "AntiKt10UFOCSSKSoftDropBeta100Zcut10Jets"); // set to "None" to turn off large jets
   configFromFile(m_fatJetUncConfig, "Jet.LargeRuncConfig", rEnv, ""); // waiting for rec
   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_240306_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_240306_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_10Mar2023.config");
   configFromFile(m_jesConfigFatData, "Jet.JESConfigFatData", rEnv, "JES_MC20PreRecommendation_R10_UFO_CSSK_SoftDrop_JMS_R21Insitu_10Mar2023.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, "DL1dv01");
   configFromFile(m_BtagWP, "Btag.WP", rEnv, "FixedCutBEff_77");
   configFromFile(m_BtagMinPt, "Btag.MinPt", rEnv, -1.); // Not calibrated below 20
  
   configFromFile(m_bTaggingCalibrationFilePath, "Btag.CalibPath", rEnv, m_isRun3 ? "xAODBTaggingEfficiency/13p6TeV/2023-22-13TeV-MC21-CDI-2023-09-13_v1.root": "xAODBTaggingEfficiency/13TeV/2023-22-13TeV-MC20-CDI-2023-09-13_v1.root");
   configFromFile(m_BtagSystStrategy, "Btag.SystStrategy", rEnv, "SFEigen");
  
   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/20230207/purw.actualMu.2022.root");
   configFromFile(m_prwActualMu2023File, "PRW.ActualMu2023File", rEnv, "GoodRunsLists/data23_13p6TeV/20230828/purw.actualMu.2023.root");
   configFromFile(m_prwActualMu2024File, "PRW.ActualMu2024File", rEnv, "GoodRunsLists/data24_13p6TeV/20240723/purw.actualMu.root");
   configFromFile(m_prwDataSF, "PRW.DataSF", rEnv, 1./1.03); // default for mc16, see: https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/ExtendedPileupReweighting#Tool_Properties
   configFromFile(m_prwDataSF_UP, "PRW.DataSF_UP", rEnv, 1./0.99); // mc16 uncertainty? defaulting to the value in PRWtool
   configFromFile(m_prwDataSF_DW, "PRW.DataSF_DW", rEnv, 1./1.07); // mc16 uncertainty? defaulting to the value in PRWtool
   configFromFile(m_runDepPrescaleWeightPRW, "PRW.UseRunDependentPrescaleWeight", rEnv, false); // If set to true, the prescale weight is the luminosity-average prescale over the lumiblocks in the unprescaled lumicalc file in the PRW tool.
   configFromFile(m_autoconfigPRWPath, "PRW.autoconfigPRWPath", rEnv, "dev/PileupReweighting/share/");
   configFromFile(m_autoconfigPRWFile, "PRW.autoconfigPRWFile", rEnv, "None");
   configFromFile(m_autoconfigPRWCombinedmode, "PRW.autoconfigPRWCombinedmode", rEnv, false);
   configFromFile(m_autoconfigPRWRPVmode, "PRW.autoconfigPRWRPVmode", rEnv, false);
   configFromFile(m_autoconfigPRWRtags, "PRW.autoconfigPRWRtags", rEnv, "mc20a:r13167_r14859,mc20d:r13144_r14860,mc20e:r13145_r14861,mc21a:r13752_r13829,mc23a:r14622_r14932_r15540,mc23c:r14799_r14908,mc23d:r15224_r15530,mc23e:r16083"); // Tag details here: https://twiki.cern.ch/twiki/bin/view/AtlasProtected/AtlasProductionGroup
   configFromFile(m_commonPRWFileMC20a, "PRW.commonPRWFileMC20a", rEnv, "PileupReweighting/mc20_common/mc20a.284500.physlite.prw.v1.root");
   configFromFile(m_commonPRWFileMC20d, "PRW.commonPRWFileMC20d", rEnv, "PileupReweighting/mc20_common/mc20d.300000.physlite.prw.v1.root");
   configFromFile(m_commonPRWFileMC20e, "PRW.commonPRWFileMC20e", rEnv, "PileupReweighting/mc20_common/mc20e.310000.physlite.prw.v1.root");
   configFromFile(m_commonPRWFileMC21a, "PRW.commonPRWFileMC21a", rEnv, "PileupReweighting/mc21_common/mc21a.410000.physlite.prw.v1.root");
   configFromFile(m_commonPRWFileMC23a, "PRW.commonPRWFileMC23a", rEnv, "PileupReweighting/mc23_common/mc23a.410000.physlite.prw.v2.root");
   configFromFile(m_commonPRWFileMC23c, "PRW.commonPRWFileMC23c", rEnv, "PileupReweighting/mc23_common/mc23c.450000.physlite.prw.v1.root");
   configFromFile(m_commonPRWFileMC23d, "PRW.commonPRWFileMC23d", rEnv, "PileupReweighting/mc23_common/mc23d.450000.physlite.prw.v1.root");
   configFromFile(m_commonPRWFileMC23e, "PRW.commonPRWFileMC23e", rEnv, "PileupReweighting/mc23_common/mc23e.470000.physlite.prw.v1.root");
   //
   configFromFile(m_strictConfigCheck, "StrictConfigCheck", rEnv, false);
  
   // By now rEnv should be empty!
   if (rEnv.GetTable() && rEnv.GetTable()->GetSize()>0){
     ATH_MSG_ERROR("Found " << rEnv.GetTable()->GetSize() << " unparsed environment options:");
     rEnv.Print();
     ATH_MSG_ERROR("Please fix your configuration!");
     return StatusCode::FAILURE;
   }
  
   // Set up the correct configuration files for the large-R jet tagging corresponding to the input tagger config
   if (!m_WtagConfig.empty()) {
     if (m_WtagConfig.find("Efficiency50") != std::string::npos){
       m_WTagUncConfig = "R10_SF_LCTopo_WTag_SigEff50.config";
     }
     else if (m_WtagConfig.find("Efficiency80") != std::string::npos){
       m_WTagUncConfig = "R10_SF_LCTopo_WTag_SigEff80.config";
     }
     else {
       ATH_MSG_ERROR("You have specified a large-R W-tag config without a matching uncertainties file. Please fix this. Currently the 50% and 80% WPs are supported");
     }
   }
   if (!m_ZtagConfig.empty()) {
     if (m_ZtagConfig.find("Efficiency50") != std::string::npos){
       m_ZTagUncConfig = "R10_SF_LCTopo_ZTag_SigEff50.config";
     }
     else if (m_ZtagConfig.find("Efficiency80") != std::string::npos){
       m_ZTagUncConfig = "R10_SF_LCTopo_ZTag_SigEff80.config";
     }
     else {
       ATH_MSG_ERROR("You have specified a large-R Z-tag config without a matching uncertainties file. Please fix this. Currently the 50% and 80% WPs are supported");
     }
   }
   std::string TopTagEff = "";
   std::string TopTagType = "";
   if (!m_ToptagConfig.empty()) {
     if (m_ToptagConfig.find("50") != std::string::npos){
       TopTagEff = "50";
     }
     else if (m_ToptagConfig.find("80") != std::string::npos){
       TopTagEff = "80";
     }
     else {
       ATH_MSG_ERROR("You have specified a large-R Top-tag config without a matching uncertainties file. Please fix this. Currently the 50% and 80% WPs are supported");
     }
     //
     if (m_ToptagConfig.find("Inclusive") != std::string::npos){
       TopTagType = "Inclusive";
     }
     else if (m_ToptagConfig.find("Contained") != std::string::npos){
       TopTagType = "Contained";
     }
     else {
       ATH_MSG_ERROR("You have specified a large-R Top-tag config without a matching uncertainties file. Please fix this. Currently the contained and inclusive WPs are supported");
     }
     m_TopTagUncConfig = "R10_SF_LCTopo_TopTag"+TopTagType+"_SigEff"+TopTagEff+".config";
   }
  
   //** validate configuration
   ATH_CHECK( validConfig(m_strictConfigCheck) );
  
   //** cache trigger chains for electron matching
   GetTriggerTokens(m_electronTriggerSFStringSingle, m_v_trigs15_cache_singleEle, m_v_trigs16_cache_singleEle, m_v_trigs17_cache_singleEle, m_v_trigs18_cache_singleEle,m_v_trigs22_cache_singleEle);
  
   //** cache trigger chains for matching (both electrons and muons)
   GetTriggerTokens(m_electronTriggerSFStringSingle, m_v_trigs15_cache_singleEle, m_v_trigs16_cache_singleEle, m_v_trigs17_cache_singleEle, m_v_trigs18_cache_singleEle,m_v_trigs22_cache_singleEle);
  
   m_v_trigs15_cache_singleLep = GetTriggerOR(m_trig2015combination_singleLep);
   m_v_trigs16_cache_singleLep = GetTriggerOR(m_trig2016combination_singleLep);
   m_v_trigs17_cache_singleLep = GetTriggerOR(m_trig2017combination_singleLep);
   m_v_trigs18_cache_singleLep = GetTriggerOR(m_trig2018combination_singleLep);
   m_v_trigs22_cache_singleLep = GetTriggerOR(m_trig2022combination_singleLep);
  
   m_v_trigs15_cache_diLep = GetTriggerOR(m_trig2015combination_diLep);
   m_v_trigs16_cache_diLep = GetTriggerOR(m_trig2016combination_diLep);
   m_v_trigs17_cache_diLep = GetTriggerOR(m_trig2017combination_diLep);
   m_v_trigs18_cache_diLep = GetTriggerOR(m_trig2018combination_diLep);
   m_v_trigs22_cache_diLep = GetTriggerOR(m_trig2022combination_diLep);
  
   m_v_trigs15_cache_multiLep = GetTriggerOR(m_trig2015combination_multiLep);
   m_v_trigs16_cache_multiLep = GetTriggerOR(m_trig2016combination_multiLep);
   m_v_trigs17_cache_multiLep = GetTriggerOR(m_trig2017combination_multiLep);
   m_v_trigs18_cache_multiLep = GetTriggerOR(m_trig2018combination_multiLep);
   m_v_trigs22_cache_multiLep = GetTriggerOR(m_trig2022combination_multiLep);
  
   return StatusCode::SUCCESS;
 }

◆ renounce()

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

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                           {
     handlesArray.renounce();
   }

◆ resetSystematics()

StatusCode ST::SUSYObjDef_xAOD::resetSystematics ( )

finaloverridevirtual

Implements ST::ISUSYObjDef_xAODTool.

Definition at line 2064 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 861 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 1114 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 1189 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 1779 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 109 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())
   {
     ATH_MSG_INFO("Initializing LRT uncertainty tool");
     m_LRTuncTool.setTypeAndName("InDet::InclusiveTrackFilterTool/LRTUncTool");    
     ATH_CHECK( m_LRTuncTool.setProperty("Seed", 1) );
     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 ? "MC23" : (isAtlfast() ? "AF3" : "MC20");
  
     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;
  
       if (m_isRun3 && isAtlfast()) {
           ATH_MSG_WARNING("Jet Uncertaintes pre-recommendations for Run3 only exist for full sim");
       }
  
       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("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"]) {
     ATH_MSG_INFO("Won't initialise jet uncertainty tool for fat jets until we get rec for UFO");
     // Won't initialise jet uncertainty tool for fat jets until we get rec for UFO
     /*
     if (!m_fatjetUncertaintiesTool.isUserConfigured() && !m_fatJets.empty() && !m_fatJetUncConfig.empty()) {
  
       toolName = "JetUncertaintiesTool_" + m_fatJets;
       m_fatjetUncertaintiesTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
  
       ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("JetDefinition", fatjetcoll) );
       ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("MCType", "MC16") );
       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());
     */
     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()){
       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 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", "Recs2024_05_06_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) {
       toolName = "MuonEfficiencyScaleFactors_" + muQual;
       m_muonEfficiencySFTool.setTypeAndName("CP::MuonEfficiencyScaleFactors/"+toolName);
       ATH_CHECK( m_muonEfficiencySFTool.setProperty("WorkingPoint", muQual) );
       ATH_CHECK( m_muonEfficiencySFTool.setProperty("CalibrationRelease", m_isRun3? "240711_Preliminary_r24run3":"230213_Preliminary_r22run2") );
       ATH_CHECK( m_muonEfficiencySFTool.setProperty("OutputLevel", this->msg().level()) );
       ATH_CHECK( m_muonEfficiencySFTool.retrieve() );
     } else  ATH_CHECK( m_muonEfficiencySFTool.retrieve() );
  
  
     if (!m_muonEfficiencyBMHighPtSFTool.isUserConfigured()){
       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  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()) {
       toolName = "MuonTTVAEfficiencyScaleFactors";
       m_muonTTVAEfficiencySFTool.setTypeAndName("CP::MuonEfficiencyScaleFactors/"+toolName);
       ATH_CHECK( m_muonTTVAEfficiencySFTool.setProperty("WorkingPoint", "TTVA") );
       ATH_CHECK( m_muonTTVAEfficiencySFTool.setProperty("CalibrationRelease", m_isRun3? "240711_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()) {
       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? "240711_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()) {
       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? "240711_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()) {
       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()) );
       ATH_CHECK( m_muonTriggerSFTool.retrieve() );
       m_muonTrigSFTools.push_back(m_muonTriggerSFTool.getHandle());
     } else {
           ATH_CHECK( m_muonTriggerSFTool.retrieve() );
           m_muonTrigSFTools.push_back(m_muonTriggerSFTool.getHandle());
     }
   }
  
   if (m_slices["ele"]) {
     // /////////////////////////////////////////////////////////////////////////////////////////
     // Initialise electron selector tools
  
     // Signal Electrons
     if (!m_elecSelLikelihood.isUserConfigured()) {
       toolName = "EleSelLikelihood_" + m_eleId;
  
       if (m_eleId.find("DNN") != std::string::npos) {
         m_elecSelLikelihood.setTypeAndName("AsgElectronSelectorTool/"+toolName);
       }
       else {
         m_elecSelLikelihood.setTypeAndName("AsgElectronLikelihoodTool/"+toolName);
       }
  
       if (! m_eleConfig.empty() ){
         ATH_MSG_INFO("Overriding specified Ele.Id working point in favour of configuration file");
         ATH_CHECK( m_elecSelLikelihood.setProperty("ConfigFile", m_eleConfig) );
       } else if ( !check_isOption(m_eleId, m_el_id_support) ) { //check if supported
         ATH_MSG_ERROR("Invalid electron ID selected: " << m_eleId);
         return StatusCode::FAILURE;
       }
       else if (m_eleId == "VeryLooseLLH" || m_eleId == "LooseLLH") {
         ATH_MSG_WARNING(" ****************************************************************************");
         ATH_MSG_WARNING(" CAUTION: Setting " << m_eleId << " as signal electron ID");
         ATH_MSG_WARNING(" These may be used for loose electron CRs but no scale factors are provided.");
         ATH_MSG_WARNING(" ****************************************************************************");
         ATH_CHECK( m_elecSelLikelihood.setProperty("WorkingPoint", EG_WP(m_eleId) ));
       } else {
         ATH_CHECK( m_elecSelLikelihood.setProperty("WorkingPoint", EG_WP(m_eleId) ));
       }
  
       ATH_CHECK( m_elecSelLikelihood.setProperty("OutputLevel", this->msg().level()) );
       ATH_CHECK( m_elecSelLikelihood.retrieve() );
     } else  ATH_CHECK( m_elecSelLikelihood.retrieve() );
  
     // Baseline Electrons
     if (!m_elecSelLikelihoodBaseline.isUserConfigured()) {
       toolName = "EleSelLikelihoodBaseline_" + m_eleIdBaseline;
  
       if (m_eleIdBaseline.find("DNN") != std::string::npos) {
         m_elecSelLikelihoodBaseline.setTypeAndName("AsgElectronSelectorTool/"+toolName);
       }
       else {
         m_elecSelLikelihoodBaseline.setTypeAndName("AsgElectronLikelihoodTool/"+toolName);
       }
  
       if (! m_eleConfigBaseline.empty() ){
         ATH_MSG_INFO("Overriding specified EleBaseline.Id working point in favour of configuration file");
         ATH_CHECK( m_elecSelLikelihoodBaseline.setProperty("ConfigFile", m_eleConfigBaseline ));
       } else if ( !check_isOption(m_eleIdBaseline, m_el_id_support) ) { //check if supported
         ATH_MSG_ERROR("Invalid electron ID selected: " << m_eleIdBaseline);
         return StatusCode::FAILURE;
       } else {
         ATH_CHECK( m_elecSelLikelihoodBaseline.setProperty("WorkingPoint", EG_WP(m_eleIdBaseline)) );
       }
  
       ATH_CHECK( m_elecSelLikelihoodBaseline.setProperty("OutputLevel", this->msg().level()) );
       ATH_CHECK( m_elecSelLikelihoodBaseline.retrieve() );
     } else ATH_CHECK( m_elecSelLikelihoodBaseline.retrieve() );
   }
  
     // Initialise prompt/LRT electron OR tool
     if (!m_elecLRTORTool.isUserConfigured()) {
         toolName = "ElectronLRTOverlapRemovalTool";
         m_elecLRTORTool.setTypeAndName("CP::ElectronLRTOverlapRemovalTool/"+toolName);
         ATH_MSG_DEBUG("Setting ElectronLRTOverlapRemovalTool strategy to "<<m_eleLRT_strat);
         ATH_CHECK( m_elecLRTORTool.setProperty("overlapStrategy", m_eleLRT_strat) );
         ATH_CHECK( m_elecLRTORTool.retrieve() );
     } else ATH_CHECK( m_elecLRTORTool.retrieve() );
  
   if (m_slices["pho"]) {
     // /////////////////////////////////////////////////////////////////////////////////////////
     // Initialise photon selector tools
  
     if (!m_photonSelIsEM.isUserConfigured()) {
       toolName = "PhotonSelIsEM_" + m_photonId;
       m_photonSelIsEM.setTypeAndName("AsgPhotonIsEMSelector/"+toolName);
  
       if (!check_isOption(m_photonId, m_ph_id_support)){ //check if supported
         ATH_MSG_ERROR("Invalid photon ID selected: " << m_photonId);
         return StatusCode::FAILURE;
       }
  
       ATH_CHECK( m_photonSelIsEM.setProperty("WorkingPoint", m_photonId+"Photon") );
       ATH_CHECK( m_photonSelIsEM.setProperty("OutputLevel", this->msg().level()) );
       ATH_CHECK( m_photonSelIsEM.retrieve() );
     } else ATH_CHECK( m_photonSelIsEM.retrieve() );
  
     if (!m_photonSelIsEMBaseline.isUserConfigured()) {
       toolName = "PhotonSelIsEMBaseline_" + m_photonIdBaseline;
       m_photonSelIsEMBaseline.setTypeAndName("AsgPhotonIsEMSelector/"+toolName);
  
       if(!check_isOption(m_photonIdBaseline, m_ph_id_support)){ //check if supported
         ATH_MSG_ERROR("Invalid photon ID selected: " << m_photonIdBaseline);
         return StatusCode::FAILURE;
       }
  
       ATH_CHECK( m_photonSelIsEMBaseline.setProperty("WorkingPoint", m_photonIdBaseline+"Photon") );
       ATH_CHECK( m_photonSelIsEMBaseline.setProperty("OutputLevel", this->msg().level()) );
       ATH_CHECK( m_photonSelIsEMBaseline.retrieve() );
     } else  ATH_CHECK( m_photonSelIsEMBaseline.retrieve() );
   }
  
   if (m_slices["ele"]||m_slices["pho"]) {
     // Initialise DeadHVCellRemovalTool
     // https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/EGammaIdentificationRun2#Removal_of_Electron_Photon_clust
  
     ATH_MSG_DEBUG("Setup AsgDeadHVCellRemovalTool/deadHVTool");
     m_deadHVTool.setTypeAndName("AsgDeadHVCellRemovalTool/deadHVTool");
     ATH_CHECK(m_deadHVTool.retrieve());
   }
  
   if (m_slices["ele"]) {
     // Initialise electron efficiency tool
  
     PATCore::ParticleDataType::DataType data_type(PATCore::ParticleDataType::Data);
     if (!isData()) {
       if (isAtlfast()) data_type = PATCore::ParticleDataType::Fast;
       else data_type = PATCore::ParticleDataType::Full;
       ATH_MSG_DEBUG( "Setting data type to " << data_type);
     }
  
     m_eleEffMapFilePathRun2 = "ElectronEfficiencyCorrection/2015_2018/rel21.2/Precision_Summer2020_v1/map4.txt";
  
     if(!m_isRun3) {
       ATH_MSG_INFO( "Running on Run2 samples; Using egamma SF tools from R21 map ");
       ATH_MSG_INFO( m_eleEffMapFilePathRun2);
     }
  
     toolName = "AsgElectronEfficiencyCorrectionTool_reco";
     CONFIG_EG_EFF_TOOL_KEY(m_elecEfficiencySFTool_reco, toolName, "RecoKey", "Reconstruction", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2);
  
     //-- get KEYS supported by egamma SF tools
     std::vector<std::string> eSF_keys = getElSFkeys( m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2);
  
     if (m_eleId.find("NoPix") != std::string::npos || m_eleId == "VeryLooseLLH" || m_eleId == "LooseLLH" || m_eleId == "Medium") {
       ATH_MSG_WARNING("Not configuring electron ID and trigger scale factors for " << m_eleId);
     }
     else {
       // This needs to be formatted for the scale factors: no _Rel20, no LH label, etc.
       std::string eleId = TString(m_eleId).ReplaceAll("AndBLayer", "BLayer").ReplaceAll("LLH", "").Data();
  
       if (m_eleId.find("DNN") != std::string::npos) {
         eleId = TString(eleId).ReplaceAll("DNNnoCF", "").ReplaceAll("DNN", "").ReplaceAll("Loose", "LooseBLayer").Data();
         ATH_MSG_WARNING("Electron DNN ID working point " << m_eleId <<  " doesn't have SFs yet, fall back to " << eleId);
       }
  
       // electron id
       toolName = "AsgElectronEfficiencyCorrectionTool_id_" + m_eleId;
       CONFIG_EG_EFF_TOOL_KEY(m_elecEfficiencySFTool_id, toolName, "IdKey", eleId, m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2);
  
       // override map file use if correction file list is set for WP
       std::map<std::string,std::string> corrFNList;
       if ( !m_EG_corrFNList.empty() ) {
          for ( const auto& WP_fname : split( m_EG_corrFNList, "," ) ) {
             std::string WP = WP_fname.substr(0,WP_fname.find(":"));
             std::string fname = WP_fname.substr(WP_fname.find(":")+1);
             corrFNList[WP] = fname;
             ATH_MSG_WARNING( "Correction file list defined for WP " << WP << ": " << fname << "." );
             ATH_MSG_WARNING( "Will use correction file rather than central map file." );
          }
       }
  
       // electron iso
       std::string EleIso("");
       if (std::find(eSF_keys.begin(), eSF_keys.end(), eleId+"_"+m_eleIso_WP) != eSF_keys.end()){
         EleIso   = m_eleIso_WP;
       } else if (std::find(eSF_keys.begin(), eSF_keys.end(), eleId+"_"+m_el_iso_fallback[m_eleIso_WP]) != eSF_keys.end()){
         //--- Check to see if the only issue is an unknown isolation working point
         EleIso = m_el_iso_fallback[m_eleIso_WP];
         ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool_iso_*) Your selected electron Iso WP ("
           << m_eleIso_WP
           << ") does not have iso SFs defined. Falling back to "
           << m_el_iso_fallback[m_eleIso_WP]
           << " for SF calculations");
       }
       else{
         ATH_MSG_ERROR("***  THE ELECTRON ISOLATION SF YOU SELECTED (" << m_eleIso_WP << ") GOT NO SUPPORT ***");
         return StatusCode::FAILURE;
       }
  
       toolName = "AsgElectronEfficiencyCorrectionTool_iso_" + m_eleId + EleIso;
  
       // if running with correction file list
       if ( (!m_EG_corrFNList.empty()) && corrFNList.find(EleIso)!=corrFNList.end() ) {                // overriding central map file
         CONFIG_EG_EFF_TOOL( m_elecEfficiencySFTool_iso, toolName, corrFNList[EleIso] );
       }
       // can't do the iso tool via the macro, it needs two properties set
       else {                                                                                          // default: use map file
         if ( !m_elecEfficiencySFTool_iso.isUserConfigured() ) {
           if ( !check_isOption(EleIso, m_el_iso_support) ) { //check if supported
             ATH_MSG_WARNING( "(" << toolName << ") Your electron Iso WP: " << EleIso<< " is no longer supported. This will almost certainly cause a crash now.");
           }
  
           m_elecEfficiencySFTool_iso.setTypeAndName("AsgElectronEfficiencyCorrectionTool/"+toolName);
  
           if ( m_EG_corrFNList.empty() ) {
             ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
           } else {
             ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("CorrectionFileNameList", corrFNList) );
           }
           ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("IdKey", eleId) );
           ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("IsoKey", EleIso) );
           if (!isData() && ((EleIso.find("TightTrackOnly_VarRad")!=std::string::npos)||
                             (EleIso.find("TightTrackOnly_FixedRad")!=std::string::npos)||
                             (EleIso.find("Tight_VarRad")!=std::string::npos)||
                             (EleIso.find("Loose_VarRad")!=std::string::npos))) {
             if (isAtlfast()) ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool/"+toolName+"). Your selected electron Iso WP (" + EleIso + ") don't have AFII SF. Falling back to FullSim");
             ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("ForceDataType", static_cast<int>(PATCore::ParticleDataType::Full)));
           }
           else if (!isData()){
             ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("ForceDataType", static_cast<int>(data_type)));
           }
           ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("CorrelationModel", m_EG_corrModel) );
           ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("OutputLevel", this->msg().level()) );
           ATH_CHECK( m_elecEfficiencySFTool_iso.initialize() );
         } else ATH_CHECK( m_elecEfficiencySFTool_iso.initialize() );
       }
  
       // electron iso high-pt
       std::string EleIsohighPt("");
       if (std::find(eSF_keys.begin(), eSF_keys.end(), eleId+"_"+m_eleIsoHighPt_WP) != eSF_keys.end()){
         EleIsohighPt   = m_eleIsoHighPt_WP;
       } else if (std::find(eSF_keys.begin(), eSF_keys.end(), eleId+"_"+m_el_iso_fallback[m_eleIsoHighPt_WP]) != eSF_keys.end()){
         //--- Check to see if the only issue is an unknown isolation working point
         EleIsohighPt = m_el_iso_fallback[m_eleIsoHighPt_WP];
         ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool_iso_*) Your selected high-pT electron Iso WP ("
           << m_eleIsoHighPt_WP
           << ") does not have iso SFs defined. Falling back to "
           << m_el_iso_fallback[m_eleIsoHighPt_WP]
           << " for SF calculations");
       }
       else{
         ATH_MSG_ERROR("***  THE HIGH PT ELECTRON ISOLATION SF YOU SELECTED (" << m_eleIsoHighPt_WP << ") GOT NO SUPPORT");
         return StatusCode::FAILURE;
       }
  
       toolName = "AsgElectronEfficiencyCorrectionTool_isoHigPt_" + m_eleId + EleIsohighPt;
  
       // if running with correction file list
       if ( (!m_EG_corrFNList.empty()) && corrFNList.find(EleIsohighPt)!=corrFNList.end() ) {                // overriding central map file
         CONFIG_EG_EFF_TOOL( m_elecEfficiencySFTool_isoHighPt, toolName, corrFNList[EleIsohighPt] );
       }
       // can't do the iso tool via the macro, it needs two properties set
       else {                                                                                                     // default: use map file
         if ( !m_elecEfficiencySFTool_isoHighPt.isUserConfigured() ) {
  
           if ( !check_isOption(EleIsohighPt, m_el_iso_support) ) { //check if supported
             ATH_MSG_WARNING( "(" << toolName << ") Your electron high-pt Iso WP: " << EleIsohighPt << " is no longer supported. This will almost certainly cause a crash now.");
           }
  
           m_elecEfficiencySFTool_isoHighPt.setTypeAndName("AsgElectronEfficiencyCorrectionTool/"+toolName);
  
           ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
           ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.setProperty("IdKey", eleId) );
           ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.setProperty("IsoKey", EleIsohighPt) );
           if (!isData()) {
             ATH_CHECK (m_elecEfficiencySFTool_isoHighPt.setProperty("ForceDataType", (int) data_type) );
           }
           ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.setProperty("CorrelationModel", m_EG_corrModel) );
           ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.setProperty("OutputLevel", this->msg().level()) );
           ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.initialize() );
         } else   ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.initialize() );
       }
  
       // electron triggers - first SFs (but we need to massage the id string since all combinations are not supported)
   
       //single lepton
       
       if(m_isRun3 && eleId.find("LooseBLayer") != std::string::npos) ATH_MSG_WARNING("Replacing 'LooseBLayer' with 'Loose' for Electron ID while configuring single-ele trigger SF using: " << m_eleEffMapFilePath);
       std::string triggerEleID = m_isRun3? TString(eleId).ReplaceAll("LooseBLayer", "Loose").Data() : eleId;
       std::string triggerEleIso= m_eleIso_WP;
       
       // This is an hack to work with ElectronEfficiencyCorrection/2015_2025/rel22.2/2022_Summer_Prerecom_v1/map4.txt to allow 
  
       if(m_isRun3 && m_eleAllowRun3TrigSFFallback){
         bool pass_isRun3TrigSFFallback = true;
         if (triggerEleID.find("Medium") != std::string::npos && triggerEleIso.find("Loose") != std::string::npos)                {triggerEleID = "Loose";}
         else if (triggerEleID.find("Medium") != std::string::npos && triggerEleIso.find("Tight") != std::string::npos)           {triggerEleID = "Tight"; triggerEleIso = "Tight_VarRad";}
         else if (triggerEleID.find("Medium") != std::string::npos && triggerEleIso.find("HighPtCaloOnly") != std::string::npos)  {triggerEleID = "Tight"; triggerEleIso = "Tight_VarRad";}
         else if (triggerEleID.find("Tight")  != std::string::npos && triggerEleIso.find("Loose") != std::string::npos)           {triggerEleID = "Loose";}
         else if (triggerEleID.find("Tight")  != std::string::npos && triggerEleIso.find("Tight") != std::string::npos)           {triggerEleIso= "Tight_VarRad";}
         else if (triggerEleID.find("Tight")  != std::string::npos && triggerEleIso.find("HighPtCaloOnly") != std::string::npos)  {triggerEleID = "Tight"; triggerEleIso = "Tight_VarRad";}
         else if (triggerEleID.find("Loose")  != std::string::npos && triggerEleIso.find("Tight") != std::string::npos)           {triggerEleID = "Loose"; triggerEleIso = "Loose_VarRad";}
         else if (triggerEleID.find("Loose")  != std::string::npos && triggerEleIso.find("HighPtCaloOnly") != std::string::npos)  {triggerEleID = "Loose"; triggerEleIso = "Loose_VarRad";}
         else {pass_isRun3TrigSFFallback=false;}
         if(pass_isRun3TrigSFFallback){
           ATH_MSG_INFO(" ************** This is only for testing/studying purpose! ************** ");
           ATH_MSG_INFO(" ************** For official recommendation, please get in contact with the SUSY Bkg Forum ************** ");
           ATH_MSG_INFO("In the current map ("<<m_eleEffMapFilePath<<"), the only supported Electron ID working-points supported for Electron Trigger Scale Factor are 'Loose_Loose_VarRad' and 'Tight_Tight_VarRad' ");
           ATH_MSG_INFO("Only for single-lepton trigger scale factor, fall back to Electron ID:  -> "<< triggerEleID << " with Isolation: " << triggerEleIso);
         }
       }
       
       
       ATH_MSG_INFO("eSF_keys: " << m_electronTriggerSFStringSingle<< "_"<<triggerEleID<<"_"<<triggerEleIso);
  
       if (std::find(eSF_keys.begin(), eSF_keys.end(), m_electronTriggerSFStringSingle+"_"+triggerEleID+"_"+triggerEleIso) != eSF_keys.end()){
         triggerEleIso   = m_eleIso_WP;
       } else if (std::find(eSF_keys.begin(), eSF_keys.end(), m_electronTriggerSFStringSingle+"_"+triggerEleID+"_"+m_el_iso_fallback[triggerEleIso]) != eSF_keys.end()){
         //--- Check to see if the only issue is an unknown isolation working point
         triggerEleIso = m_el_iso_fallback[triggerEleIso];
         ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool_trig_singleLep_*) Your selected electron Iso WP ("
           << m_eleIso_WP
           << ") does not have trigger SFs defined. Falling back to "
           << triggerEleIso
           << " for SF calculations");
       }
       else{
         ATH_MSG_ERROR("***  THE SINGLE ELECTRON TRIGGER SF YOU SELECTED (" << m_electronTriggerSFStringSingle << ") GOT NO SUPPORT FOR YOUR ID+ISO WPs (" << m_eleId << "+" << m_eleIso_WP << ") ***");
         return StatusCode::FAILURE;
       }
   
       toolName = "AsgElectronEfficiencyCorrectionTool_trig_singleLep_" + triggerEleID;
       if ( !m_elecEfficiencySFTool_trig_singleLep.isUserConfigured() ) {
         m_elecEfficiencySFTool_trig_singleLep.setTypeAndName("AsgElectronEfficiencyCorrectionTool/"+toolName);
         ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
         ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("TriggerKey", m_electronTriggerSFStringSingle) );
         ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("IdKey", triggerEleID) );
         ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("IsoKey", triggerEleIso) );
         ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("CorrelationModel", m_EG_corrModel) );
         if (!isData()) {
           ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("ForceDataType", (int) (data_type==PATCore::ParticleDataType::Fast)? PATCore::ParticleDataType::Full : data_type) );
         }
         ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("OutputLevel", this->msg().level()) );
         ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.initialize() );
       } else ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.retrieve() );
       
   
       toolName = "AsgElectronEfficiencyCorrectionTool_trigEff_singleLep_" + triggerEleID;
       if ( !m_elecEfficiencySFTool_trigEff_singleLep.isUserConfigured() ) {
         m_elecEfficiencySFTool_trigEff_singleLep.setTypeAndName("AsgElectronEfficiencyCorrectionTool/"+toolName);
         ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
         ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("TriggerKey", "Eff_"+m_electronTriggerSFStringSingle) );
         ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("IdKey", triggerEleID) );
         ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("IsoKey", triggerEleIso) );
         ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("CorrelationModel", m_EG_corrModel) );
         if (!isData()) {
           ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("ForceDataType", (int) (data_type==PATCore::ParticleDataType::Fast)? PATCore::ParticleDataType::Full : data_type) );
         }
         ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("OutputLevel", this->msg().level()) );
         ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.initialize() );
       } else  ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.retrieve() );
     
       if (!m_isRun3){
         //mixed-leptons
         std::map<std::string,std::string> electronTriggerSFMapMixedLepton {
           // legs, Trigger keys, 
           {"e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose,e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0", m_electronTriggerSFStringSingle},
           {"e24_lhvloose_nod0_L1EM20VH,e17_lhvloose_nod0,e12_lhloose_L1EM10VH","DI_E_2015_e12_lhloose_L1EM10VH_2016_e17_lhvloose_nod0_2017_2018_e24_lhvloose_nod0_L1EM20VH"},
           {"e26_lhmedium_nod0_L1EM22VHI,e26_lhmedium_nod0","MULTI_L_2015_e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose_2016_e26_lhmedium_nod0_L1EM22VHI_2017_2018_e26_lhmedium_nod0"},
           {"e17_lhloose,e17_lhloose_nod0","MULTI_L_2015_e17_lhloose_2016_2018_e17_lhloose_nod0"},
           {"e12_lhloose,e12_lhloose_nod0","MULTI_L_2015_e12_lhloose_2016_2018_e12_lhloose_nod0"},
           {"e7_lhmedium,e7_lhmedium_nod0","MULTI_L_2015_e7_lhmedium_2016_2018_e7_lhmedium_nod0"},
           {"e9_lhloose,e9_lhloose_nod0,e12_lhvloose_nod0_L1EM10VH","TRI_E_2015_e9_lhloose_2016_e9_lhloose_nod0_2017_2018_e12_lhvloose_nod0_L1EM10VH"}
           
         };
         
         // 2e17 trigger is used in 2017 or 2018?
         std::string triglist_2017to2018 = m_trig2017combination_diLep + "_" + m_trig2018combination_diLep + "_" + m_trig2017combination_multiLep + "_" + m_trig2018combination_multiLep;
         if (triglist_2017to2018.find("2e17_lhvloose_nod0_L12EM15VHI") != std::string::npos) { 
           electronTriggerSFMapMixedLepton["e17_lhvloose_nod0_L1EM15VHI"] = "DI_E_2015_e12_lhloose_L1EM10VH_2016_e17_lhvloose_nod0_2017_2018_e17_lhvloose_nod0_L1EM15VHI";
         }
     
         std::string triggerMixedEleIso("");
     
         for(auto const& item : electronTriggerSFMapMixedLepton){
     
           if (std::find(eSF_keys.begin(), eSF_keys.end(), item.second+"_"+eleId+"_"+m_eleIso_WP) != eSF_keys.end()){
             triggerMixedEleIso = m_eleIso_WP;
           } else if (std::find(eSF_keys.begin(), eSF_keys.end(), item.second+"_"+eleId+"_"+m_el_iso_fallback[m_eleIso_WP]) != eSF_keys.end()){
             //--- Check to see if the only issue is an unknown isolation working point
             triggerMixedEleIso = m_el_iso_fallback[m_eleIso_WP];
             ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool_trig_mixLep_*) Your selected electron Iso WP ("
               << m_eleIso_WP
               << ") does not have trigger SFs defined. Falling back to "
               << triggerMixedEleIso
               << " for SF calculations");
           } else {
             ATH_MSG_ERROR("***  THE MIXED ELECTRON TRIGGER SF YOU SELECTED (" << item.second << ") GOT NO SUPPORT FOR YOUR ID+ISO WPs (" << m_eleId << "+" << m_eleIso_WP << "). The fallback options failed as well sorry! ***");
             return StatusCode::FAILURE;
           }
     
           ATH_MSG_VERBOSE ("Selected WP: " << item.second << "_" << eleId << "_" << triggerMixedEleIso);
     
           toolName = "AsgElectronEfficiencyCorrectionTool_trig_mixLep_" + (item.first).substr(0,8) + m_eleId;
           auto t_sf = m_elecEfficiencySFTool_trig_mixLep.emplace(m_elecEfficiencySFTool_trig_mixLep.end(), "AsgElectronEfficiencyCorrectionTool/"+toolName);
           ATH_CHECK( t_sf->setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
           ATH_CHECK( t_sf->setProperty("TriggerKey", item.second) );
           ATH_CHECK( t_sf->setProperty("IdKey", eleId) );
           ATH_CHECK( t_sf->setProperty("IsoKey", triggerMixedEleIso) );
           ATH_CHECK( t_sf->setProperty("CorrelationModel", m_EG_corrModel) );
           if (!isData()) {
             ATH_CHECK( t_sf->setProperty("ForceDataType", (int) (data_type==PATCore::ParticleDataType::Fast)? PATCore::ParticleDataType::Full : data_type) );
           }
           ATH_CHECK( t_sf->setProperty("OutputLevel", this->msg().level()) );
           ATH_CHECK( t_sf->initialize() );
           m_elecTrigSFTools.push_back(t_sf->getHandle());
           #ifndef XAOD_STANDALONE
             m_legsPerTool[toolName] = item.first;
           #else
             m_legsPerTool["ToolSvc."+toolName] = item.first;
           #endif
     
           toolName = "AsgElectronEfficiencyCorrectionTool_trigEff_mixLep_" + (item.first).substr(0,8) + m_eleId;
           auto t_eff = m_elecEfficiencySFTool_trigEff_mixLep.emplace(m_elecEfficiencySFTool_trigEff_mixLep.end(), "AsgElectronEfficiencyCorrectionTool/"+toolName);
           ATH_CHECK( t_eff->setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
           ATH_CHECK( t_eff->setProperty("TriggerKey", "Eff_"+item.second) );
           ATH_CHECK( t_eff->setProperty("IdKey", eleId) );
           ATH_CHECK( t_eff->setProperty("IsoKey", triggerMixedEleIso) );
           ATH_CHECK( t_eff->setProperty("CorrelationModel", m_EG_corrModel) );
           if (!isData()) {
             ATH_CHECK( t_eff->setProperty("ForceDataType", (int) (data_type==PATCore::ParticleDataType::Fast)? PATCore::ParticleDataType::Full : data_type) );
           }
           ATH_CHECK( t_eff->setProperty("OutputLevel", this->msg().level()) );
           ATH_CHECK( t_eff->initialize() );
           m_elecTrigEffTools.push_back(t_eff->getHandle());
           #ifndef XAOD_STANDALONE
             m_legsPerTool[toolName] = item.first;
           #else
             m_legsPerTool["ToolSvc."+toolName] = item.first;
           #endif
     
         }
       }
       else ATH_MSG_WARNING("*** THE ELECTRON TRIGGER SF MIXED AND SF DILEP ARE CURRENTY NOT SUPPORTED IN RUN3 ***");
     
     ATH_MSG_WARNING("*** THE ELECTRON CHARGE FLIP SF ARE CURRENTY NOT SUPPORTED ***");
     // all the iinitialisation of the related tools have been cleaned up
  
   }
  
   if (m_slices["pho"]) {
     // /////////////////////////////////////////////////////////////////////////////////////////
     // Initialise photon efficiency tool
  
     if (!m_photonEfficiencySFTool.isUserConfigured() && !isData()) {
       m_photonEfficiencySFTool.setTypeAndName("AsgPhotonEfficiencyCorrectionTool/AsgPhotonEfficiencyCorrectionTool_" + m_photonId);
  
       if (m_photonId != "Tight" ) {
         ATH_MSG_WARNING( "No Photon efficiency available for " << m_photonId << ", using Tight instead..." );
       }
  
       ATH_CHECK( m_photonEfficiencySFTool.setProperty("MapFilePath", m_isRun3? "PhotonEfficiencyCorrection/2015_2025/rel22.2/2022_Summer_Prerecom_v1/map0.txt":"PhotonEfficiencyCorrection/2015_2018/rel21.2/Summer2020_Rec_v1/map1.txt") );
       ATH_CHECK( m_photonEfficiencySFTool.setProperty("ForceDataType", 1) ); // Set data type: 1 for FULLSIM, 3 for AF2
       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 != "FixedCutTightCaloOnly") {
        ATH_MSG_WARNING( "No Photon efficiency available for " << m_photonIso_WP);
      }
  
      ATH_CHECK( m_photonIsolationSFTool.setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2018/rel21.2/Summer2020_Rec_v1/map1.txt") );
      ATH_CHECK( m_photonIsolationSFTool.setProperty("IsoKey", m_photonIso_WP.substr(8) ));    // 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/map1.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/map1.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/map1.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 ? "es2022_R22_PRE" : "es2023_R22_Run2_v0") );
       ATH_CHECK( m_egammaCalibTool.setProperty("decorrelationModel", "1NP_v1") );
       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()) {
       toolName = "TauEffTool_" + m_tauId;
       m_tauEffTool.setTypeAndName("TauAnalysisTools::TauEfficiencyCorrectionsTool/"+toolName);
       ATH_CHECK( m_tauEffTool.setProperty("PileupReweightingTool",m_prwTool.getHandle()) );
  
       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.retrieve() );
     } else ATH_CHECK( m_tauEffTool.retrieve() );
  
  
     // Initialise tau trigger efficiency tool(s)
  
     if (!isData()) {
       int iTauID = (int) TauAnalysisTools::JETIDNONEUNCONFIGURED;
       if (m_tauId == "rnn001")   iTauID = (int) TauAnalysisTools::JETIDNONE;
       else if (m_tauId == "VeryLoose")   iTauID = (int) TauAnalysisTools::JETIDRNNVERYLOOSE;
       else if (m_tauId == "Loose")  iTauID = (int) TauAnalysisTools::JETIDRNNLOOSE;
       else if (m_tauId == "Medium") iTauID = (int) TauAnalysisTools::JETIDRNNMEDIUM;
       else if (m_tauId == "Tight")  iTauID = (int) TauAnalysisTools::JETIDRNNTIGHT;
       else {
         ATH_MSG_ERROR("Invalid tau ID selected: " << m_tauId);
         return StatusCode::FAILURE;
       }
  
       // map format: SF file name, corresponding single-tau leg (comma-separated in case of OR)
       m_tau_trig_support = {
         {"HLT_tau25_medium1_tracktwo", "HLT_tau25_medium1_tracktwo"},
         {"HLT_tau35_medium1_tracktwo", "HLT_tau35_medium1_tracktwo"},
         {"HLT_tau50L1TAU12_medium1_tracktwo", "HLT_tau50_medium1_tracktwo_L1TAU12"},
         {"HLT_tau60_medium1_tracktwo", "HLT_tau60_medium1_tracktwo"},
         {"HLT_tau80L1TAU60_medium1_tracktwo", "HLT_tau80_medium1_tracktwo_L1TAU60"},
         {"HLT_tau125_medium1_tracktwo", "HLT_tau125_medium1_tracktwo"},
         {"HLT_tau160_medium1_tracktwo", "HLT_tau160_medium1_tracktwo"},
         {"HLT_tau160L1TAU100_medium1_tracktwo", "HLT_tau160_medium1_tracktwo_L1TAU100"},
         // whole 2018 data taking period
         {"HLT_tau25_medium1_tracktwoEF", "HLT_tau25_medium1_tracktwoEF"},
         {"HLT_tau35L1TAU12IM_medium1_tracktwoEF", "HLT_tau35_medium1_tracktwoEF_L1TAU12IM"},
         {"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"},
         // 2018 data after TS1, run >= 355261
         {"HLT_tau25_medium1_tracktwoEF_OR_mediumRNN_tracktwoMVA", "HLT_tau25_medium1_tracktwoEF,HLT_tau25_mediumRNN_tracktwoMVA"},
         {"HLT_tau35L1TAU12IM_medium1_tracktwoEF_OR_mediumRNN_tracktwoMVA", "HLT_tau35_medium1_tracktwoEF_L1TAU12IM,HLT_tau35_mediumRNN_tracktwoMVA_L1TAU12IM"},
         {"HLT_tau35_medium1_tracktwoEF_OR_mediumRNN_tracktwoMVA", "HLT_tau35_medium1_tracktwoEF,HLT_tau35_mediumRNN_tracktwoMVA"},
         {"HLT_tau60_medium1_tracktwoEF_OR_mediumRNN_tracktwoMVA", "HLT_tau60_medium1_tracktwoEF,HLT_tau60_mediumRNN_tracktwoMVA"},
         {"HLT_tau80L1TAU60_medium1_tracktwoEF_OR_mediumRNN_tracktwoMVA", "HLT_tau80_medium1_tracktwoEF_L1TAU60,HLT_tau80_mediumRNN_tracktwoMVA_L1TAU60"},
         {"HLT_tau160L1TAU100_medium1_tracktwoEF_OR_mediumRNN_tracktwoMVA", "HLT_tau160_medium1_tracktwoEF_L1TAU100,HLT_tau160_mediumRNN_tracktwoMVA_L1TAU100"}
       };
  
       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("PileupReweightingTool", m_prwTool.getHandle()) );
         ATH_CHECK( tau_trigSF->setProperty("OutputLevel", this->msg().level()) );
         ATH_CHECK( tau_trigSF->setProperty("useFastSim", isAtlfast()) );
         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", "mc21") );}
       else         { ATH_CHECK( m_tauSmearingTool.setProperty("Campaign", "mc20") );}
       ATH_CHECK( m_tauSmearingTool.setProperty("Generator", m_tauSmearingToolGenerator) );
       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) {
       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
     // for the GN2v00 tagger the Run 2 and Run 3 files are the same, so we skip this check
     // see --> https://twiki.cern.ch/twiki/bin/view/AtlasProtected/BTagRel22HighLevelSummary
     if( (m_bTaggingCalibrationFilePath.find(!m_isRun3 ? "MC20" : "MC21") == std::string::npos) && (m_BtagTagger.find("GN2v00") != 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) );
       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) );
       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) );
         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_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{
       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
     }
  
     // 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 ) );
       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("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("OutputLevel", this->msg().level()) );
         ATH_CHECK( m_btagEffTool_trkJet.retrieve() );
       } else if (m_btagEffTool_trkJet.isUserConfigured()) ATH_CHECK( m_btagEffTool_trkJet.retrieve() );
     }
   }
  
  
   if (m_slices["met"]) {
   // Initialise MET tools
  
     if (!m_metMaker.isUserConfigured()) {
       toolName = m_doFwdJVT ? m_metJetSelection+"_fJVT" : m_metJetSelection+"_NOfJVT";
       m_metMaker.setTypeAndName("met::METMaker/METMaker_ST_"+toolName);
  
       ATH_CHECK( m_metMaker.setProperty("ORCaloTaggedMuons", m_metRemoveOverlappingCaloTaggedMuons) );
       ATH_CHECK( m_metMaker.setProperty("DoSetMuonJetEMScale", m_metDoSetMuonJetEMScale) );
       ATH_CHECK( m_metMaker.setProperty("DoRemoveMuonJets", m_metDoRemoveMuonJets) );
       ATH_CHECK( m_metMaker.setProperty("UseGhostMuons", m_metUseGhostMuons) );
       ATH_CHECK( m_metMaker.setProperty("DoMuonEloss", m_metDoMuonEloss) );
       ATH_CHECK( m_metMaker.setProperty("GreedyPhotons", m_metGreedyPhotons) );
       ATH_CHECK( m_metMaker.setProperty("VeryGreedyPhotons", m_metVeryGreedyPhotons) );
  
       // set the jet selection if default empty string is overridden through config file
       if (m_metJetSelection.size()) {
         ATH_CHECK( m_metMaker.setProperty("JetSelection", m_metJetSelection) );
       }
       if (m_jetInputType == xAOD::JetInput::EMPFlow) {
         ATH_CHECK( m_metMaker.setProperty("DoPFlow", true) );
       }
  
       ATH_CHECK( m_metMaker.setProperty("OutputLevel", this->msg().level()) );
       ATH_CHECK( m_metMaker.retrieve() );
     } else ATH_CHECK( m_metMaker.retrieve() );
  
  
     if (!m_metSystTool.isUserConfigured()) {
       m_metSystTool.setTypeAndName("met::METSystematicsTool/METSystTool");
       ATH_CHECK( m_metSystTool.setProperty("ConfigPrefix", m_metsysConfigPrefix) );
  
       if (m_trkMETsyst && m_caloMETsyst){
         ATH_MSG_ERROR( "Can only have CST *or* TST configured for MET maker.  Please unset either METDoCaloSyst or METDoTrkSyst in your config file" );
         return StatusCode::FAILURE;
       }
  
       if (m_trkMETsyst) {
         ATH_CHECK( m_metSystTool.setProperty("ConfigSoftCaloFile", "") );
         ATH_CHECK( m_metSystTool.setProperty("ConfigSoftTrkFile", "TrackSoftTerms-pflow.config") );
       }
  
       if (m_caloMETsyst) {
         ATH_MSG_WARNING( "CST is no longer recommended by Jet/MET group");
         ATH_CHECK( m_metSystTool.setProperty("ConfigSoftTrkFile", "") );
       }
  
       if (m_trkJetsyst) {
         ATH_CHECK( m_metSystTool.setProperty("ConfigJetTrkFile", "JetTrackSyst.config") );
       }
  
       ATH_CHECK( m_metSystTool.setProperty("OutputLevel", this->msg().level()) );
       ATH_CHECK( m_metSystTool.retrieve());
     } else ATH_CHECK( m_metSystTool.retrieve());
  
  
     if (!m_metSignif.isUserConfigured()) {
       // See https://twiki.cern.ch/twiki/bin/view/AtlasProtected/MetSignificance
       m_metSignif.setTypeAndName("met::METSignificance/metSignificance_"+jetname);
 #ifndef XAOD_STANDALONE // Athena and AthAnalysis; need to take into account that MuonCalibTool is private tool
       ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "SoftTermParam", m_softTermParam));
       ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "TreatPUJets", m_treatPUJets));
       ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "DoPhiReso", m_doPhiReso));
       ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "IsAFII", isAtlfast()));
       if(jetname == "AntiKt4EMTopo" || jetname =="AntiKt4EMPFlow"){
         ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "JetCollection", jetname) );
       } else {
           ATH_MSG_WARNING("Object-based METSignificance recommendations only exist for EMTopo and PFlow, falling back to AntiKt4EMTopo");
           ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "JetCollection", "AntiKt4EMTopo") );
       }
       // setup a dedicated new muon calib tool for passing down to METSignificance
       ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "MuonCalibTool", "CP::MuonCalibTool/calibTool"));
       if (m_isRun3)
         ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.IsRun3Geo", true));
       ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.calibMode", m_muCalibrationMode));
       ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.OutputLevel",this->msg().level()));
       ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.release", "Recs2024_05_06_Run2Run3"));
       int IdBaselineInt = m_muIdBaseline;
       if (IdBaselineInt == 4)
         ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.do2StationsHighPt", true));
       ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.doExtraSmearing", m_muHighPtExtraSmear));
       ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "OutputLevel", this->msg().level()));
 #else // AnalysisBase; can just pass the muon calib tool configured above
       ATH_CHECK( m_metSignif.setProperty("SoftTermParam", m_softTermParam) );
       ATH_CHECK( m_metSignif.setProperty("TreatPUJets", m_treatPUJets) );
       ATH_CHECK( m_metSignif.setProperty("DoPhiReso", m_doPhiReso) );
       ATH_CHECK( m_metSignif.setProperty("IsAFII", isAtlfast()) );
       if(jetname == "AntiKt4EMTopo" || jetname =="AntiKt4EMPFlow"){
         ATH_CHECK( m_metSignif.setProperty("JetCollection", jetname) );
       } else {
         ATH_MSG_WARNING("Object-based METSignificance recommendations only exist for EMTopo and PFlow, falling back to AntiKt4EMTopo");
         ATH_CHECK( m_metSignif.setProperty("JetCollection", "AntiKt4EMTopo") );
       }
       // just pass the muon calib tool
       ATH_CHECK( m_metSignif.setProperty("MuonCalibTool",m_muonCalibTool.getHandle()));
       ATH_CHECK( m_metSignif.setProperty("OutputLevel", this->msg().level()) );
 #endif
       ATH_CHECK( m_metSignif.retrieve() );
     } else ATH_CHECK( m_metSignif.retrieve() );
   }
  
  
 // Initialise trigger tools
  
   if (!m_trigDecTool.isUserConfigured()) {
  
     // The decision tool
     m_trigDecTool.setTypeAndName("Trig::TrigDecisionTool/TrigDecisionTool");
     ATH_CHECK( m_trigDecTool.setProperty("TrigDecisionKey", "xTrigDecision") );
     if (m_isRun3) {
       ATH_CHECK( m_trigDecTool.setProperty("NavigationFormat", "TrigComposite") );
       ATH_CHECK( m_trigDecTool.setProperty("HLTSummary", "HLTNav_Summary_DAODSlimmed") );
     }
     ATH_CHECK( m_trigDecTool.setProperty("OutputLevel", this->msg().level()) );
  
 #ifndef XAOD_STANDALONE // Athena and AthAnalysis
     // Clear the default tool handle to cause a fallback on the config service
     ATH_CHECK( m_trigDecTool.setProperty("ConfigTool", ""));
 #else // AnalysisBase
     m_trigConfTool.setTypeAndName("TrigConf::xAODConfigTool/xAODConfigTool");
     ATH_CHECK(m_trigConfTool.retrieve() );
     ATH_CHECK( m_trigDecTool.setProperty("ConfigTool", m_trigConfTool.getHandle()) );
 #endif
  
     ATH_CHECK( m_trigDecTool.retrieve() );
  
   } else  ATH_CHECK( m_trigDecTool.retrieve() );
  
   if (m_isRun3) {
     if (!m_trigDRScoringTool.isUserConfigured()) {
       m_trigDRScoringTool.setTypeAndName("Trig::DRScoringTool/TrigDRScoringTool");
       ATH_CHECK( m_trigDRScoringTool.setProperty("OutputLevel", this->msg().level()) );
       ATH_CHECK( m_trigDRScoringTool.retrieve() );
     } else  ATH_CHECK( m_trigDRScoringTool.retrieve() );
   }
  
   if (!m_trigMatchingTool.isUserConfigured()) {
     if (m_upstreamTriggerMatching){
       m_trigMatchingTool.setTypeAndName("Trig::MatchFromCompositeTool/TrigMatchFromCompositeTool");
       ATH_CHECK( m_trigMatchingTool.setProperty("InputPrefix", m_trigMatchingPrefix) );
       ATH_CHECK( m_trigMatchingTool.setProperty("RemapBrokenLinks", true) );
     }
     else {
       if (m_isRun3){
         m_trigMatchingTool.setTypeAndName("Trig::R3MatchingTool/TrigR3MatchingTool");
         ATH_CHECK( m_trigMatchingTool.setProperty("ScoringTool", m_trigDRScoringTool.getHandle()) );
         ATH_CHECK( m_trigMatchingTool.setProperty("TrigDecisionTool", m_trigDecTool.getHandle()) );
       }
       else {
         m_trigMatchingTool.setTypeAndName("Trig::MatchingTool/TrigMatchingTool");
         ATH_CHECK( m_trigMatchingTool.setProperty("TrigDecisionTool", m_trigDecTool.getHandle()) );
       }
     }
     ATH_CHECK( m_trigMatchingTool.setProperty("OutputLevel", this->msg().level()) );
     ATH_CHECK( m_trigMatchingTool.retrieve() );
   } else  ATH_CHECK( m_trigMatchingTool.retrieve() );
  
 // Initialise trigGlobalEfficiencyCorrection tool
  
   if (!m_trigGlobalEffCorrTool_diLep.isUserConfigured()) {
  
     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  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.initialize() );
  
  
   if (!m_trigGlobalEffCorrTool_multiLep.isUserConfigured()) {
  
     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 ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.initialize() );
  
  
   if (!m_trigGlobalEffCorrTool_diPhoton.isUserConfigured()) {
     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  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.initialize() );
  
  
   if (m_slices["ele"] || m_slices["pho"] || m_slices["mu"]) {
   // /////////////////////////////////////////////////////////////////////////////////////////
   // Initialise Isolation Correction Tool
  
     if ( !m_isoCorrTool.isUserConfigured() ) {
       m_isoCorrTool.setTypeAndName("CP::IsolationCorrectionTool/IsoCorrTool");
       ATH_CHECK( m_isoCorrTool.setProperty( "ToolVer", "REL22") );
       ATH_CHECK( m_isoCorrTool.setProperty( "IsMC", !isData()) );
       ATH_CHECK( m_isoCorrTool.setProperty( "AFII_corr", isAtlfast()) );
       ATH_CHECK( m_isoCorrTool.setProperty( "Apply_SC_leakcorr", false) );
       ATH_CHECK( m_isoCorrTool.setProperty( "CorrFile", "IsolationCorrections/v6/isolation_ptcorrections_rel22_mc20.root") );
       ATH_CHECK( m_isoCorrTool.setProperty( "OutputLevel", this->msg().level()) );
       ATH_CHECK( m_isoCorrTool.retrieve() );
     } else  ATH_CHECK( m_isoCorrTool.retrieve() );
  
  
   // /////////////////////////////////////////////////////////////////////////////////////////
   // Initialise Isolation Tool
     if (!m_isoTool.isUserConfigured()) {
       m_isoTool.setTypeAndName("CP::IsolationSelectionTool/IsoTool");
       ATH_CHECK( m_isoTool.setProperty("ElectronWP", m_eleIso_WP.empty()    ? "Loose_VarRad" : m_eleIso_WP) );
       ATH_CHECK( m_isoTool.setProperty("MuonWP",     m_muIso_WP.empty()     ? "Loose_VarRad" : m_muIso_WP) );
       ATH_CHECK( m_isoTool.setProperty("PhotonWP",   m_photonIso_WP.empty() ? "FixedCutTight" : m_photonIso_WP ) );
       ATH_CHECK( m_isoTool.setProperty("OutputLevel", this->msg().level()) );
       ATH_CHECK( m_isoTool.retrieve() );
     } else  ATH_CHECK( m_isoTool.retrieve() );
  
     //disable if (!m_isoToolLowPtPLV.isUserConfigured()) {
     //disable   m_isoToolLowPtPLV.setTypeAndName("CP::IsolationLowPtPLVTool/IsoToolLowPtPLV");
     //disable   ATH_CHECK( m_isoToolLowPtPLV.setProperty("OutputLevel", this->msg().level()) );
     //disable   ATH_CHECK( m_isoToolLowPtPLV.retrieve() );
     //disable } else  ATH_CHECK( m_isoToolLowPtPLV.retrieve() );
  
  
     if (!m_isoBaselineTool.isUserConfigured()) {
       m_isoBaselineTool.setTypeAndName("CP::IsolationSelectionTool/IsoBaselineTool");
       ATH_CHECK( m_isoBaselineTool.setProperty("ElectronWP", m_eleBaselineIso_WP.empty()    ? "Loose_VarRad" : m_eleBaselineIso_WP    ) );
       ATH_CHECK( m_isoBaselineTool.setProperty("MuonWP",     m_muBaselineIso_WP.empty()     ? "Loose_VarRad" : m_muBaselineIso_WP     ) );
       ATH_CHECK( m_isoBaselineTool.setProperty("PhotonWP",   m_photonBaselineIso_WP.empty() ? "FixedCutTight" : m_photonBaselineIso_WP ) );
       ATH_CHECK( m_isoBaselineTool.setProperty("OutputLevel", this->msg().level()) );
       ATH_CHECK( m_isoBaselineTool.retrieve() );
     } else ATH_CHECK( m_isoBaselineTool.retrieve() );
  
  
     if (!m_isoHighPtTool.isUserConfigured()) {
       m_isoHighPtTool.setTypeAndName("CP::IsolationSelectionTool/IsoHighPtTool");
       ATH_CHECK( m_isoHighPtTool.setProperty("ElectronWP", m_eleIsoHighPt_WP.empty() ? "Loose_VarRad" : m_eleIsoHighPt_WP) );
       ATH_CHECK( m_isoHighPtTool.setProperty("MuonWP",     m_muIsoHighPt_WP.empty()  ? "Loose_VarRad" : m_muIsoHighPt_WP ) );
       ATH_CHECK( m_isoHighPtTool.setProperty("PhotonWP",   m_photonIso_WP.empty()    ? "FixedCutTight" : m_photonIso_WP ) );
       ATH_CHECK( m_isoHighPtTool.setProperty("OutputLevel", this->msg().level()) );
       ATH_CHECK( m_isoHighPtTool.retrieve() );
     } else ATH_CHECK( m_isoHighPtTool.retrieve() );
  
  
   // /////////////////////////////////////////////////////////////////////////////////////////
   // Initialise IsolationCloseByCorrectionTool Tool
     if (!m_isoCloseByTool.isUserConfigured()) {
       m_isoCloseByTool.setTypeAndName("CP::IsolationCloseByCorrectionTool/IsoCloseByTool");
       // Actually we could debate about what is the proper tool to choose if the users have different baseline & signal islation WP's
       ATH_CHECK( m_isoCloseByTool.setProperty("IsolationSelectionTool", m_useSigLepForIsoCloseByOR ? m_isoTool : m_isoBaselineTool));
       ATH_CHECK( m_isoCloseByTool.setProperty("PassoverlapDecorator", m_IsoCloseByORpassLabel) );
       ATH_CHECK( m_isoCloseByTool.setProperty("SelectionDecorator", m_useSigLepForIsoCloseByOR ? "signal" : "baseline") );
       // Make this propery configurable as well?
       ATH_CHECK( m_isoCloseByTool.setProperty("BackupPrefix", "ORIG") );
       // The isolation selection decorator is updated as well by the tool
       ATH_CHECK( m_isoCloseByTool.setProperty("IsolationSelectionDecorator", "isol") );
  
       ATH_CHECK( m_isoCloseByTool.setProperty("OutputLevel", this->msg().level()) );
 #ifndef XAOD_ANALYSIS
       ATH_CHECK( m_isoCloseByTool.setProperty("ParticleCaloExtensionTool", "") );
 #endif
       ATH_CHECK( m_isoCloseByTool.retrieve() );
     } else  ATH_CHECK( m_isoCloseByTool.retrieve() );
   }
  
  
 // /////////////////////////////////////////////////////////////////////////////////////////
 // Initialise Overlap Removal Tool
   if ( m_orToolbox.masterTool.empty() ){
  
     // set up the master tool
     std::string suffix = "";
     if (m_orDoTau) suffix += "Tau";
     if (m_orDoPhoton) suffix += "Gamma";
     if (m_orDoBjet) suffix += "Bjet";
     std::string toolName = "ORTool" + suffix;
     ATH_MSG_INFO("SUSYTools: Autoconfiguring " << toolName);
  
     std::string bJetLabel = "";
     //overwrite lepton flags if the global is false (yes?)
     if (!m_orDoBjet || !m_useBtagging) {
       m_orDoElBjet = false;
       m_orDoMuBjet = false;
       m_orDoTauBjet = false;
     }
     if (m_orDoElBjet || m_orDoMuBjet || m_orDoTauBjet) {
       bJetLabel = "bjet_loose";
     }
  
     // Set the generic flags
     ORUtils::ORFlags orFlags(toolName, m_orInputLabel, "passOR");
     orFlags.bJetLabel      = bJetLabel;
     orFlags.boostedLeptons = (m_orDoBoostedElectron || m_orDoBoostedMuon);
     orFlags.outputPassValue = true;
     orFlags.linkOverlapObjects = m_orLinkOverlapObjects;
     if (m_orDoElEl) {
       orFlags.doEleEleOR = true;
     } else orFlags.doEleEleOR = false;
     orFlags.doElectrons = true;
     orFlags.doMuons = true;
     orFlags.doJets = true;
     orFlags.doTaus = m_orDoTau;
     orFlags.doPhotons = m_orDoPhoton;
     orFlags.doFatJets = m_orDoFatjets;
  
     //set up all recommended tools
     ATH_CHECK( ORUtils::recommendedTools(orFlags, m_orToolbox));
  
     // We don't currently have a good way to determine here which object
     // definitions are disabled, so we currently just configure all overlap
     // tools and disable the pointer safety checks
     ATH_CHECK( m_orToolbox.setGlobalProperty("OutputLevel", this->msg().level()) );
     ATH_CHECK( m_orToolbox.masterTool.setProperty("RequireExpectedPointers", false) );
  
     // Override boosted OR sliding cone options
     ATH_CHECK( m_orToolbox.eleJetORT.setProperty("UseSlidingDR", m_orDoBoostedElectron) );
     ATH_CHECK( m_orToolbox.muJetORT.setProperty("UseSlidingDR", m_orDoBoostedMuon) );
  
     //add custom tau-jet OR tool
     if(m_orDoTau){
       m_orToolbox.tauJetORT.setTypeAndName("ORUtils::TauJetOverlapTool/" + orFlags.masterName + ".TauJetORT");
       ATH_CHECK( m_orToolbox.tauJetORT.setProperty("BJetLabel", m_orDoTauBjet?bJetLabel:"") );
     }
  
     // override sliding cone params if sliding dR is on and the user-provided parameter values are non-negative
     if (m_orDoBoostedElectron) {
       if (m_orBoostedElectronC1 > 0) ATH_CHECK( m_orToolbox.eleJetORT.setProperty("SlidingDRC1", m_orBoostedElectronC1) );
       if (m_orBoostedElectronC2 > 0) ATH_CHECK( m_orToolbox.eleJetORT.setProperty("SlidingDRC2", m_orBoostedElectronC2) );
       if (m_orBoostedElectronMaxConeSize > 0) ATH_CHECK( m_orToolbox.eleJetORT.setProperty("SlidingDRMaxCone", m_orBoostedElectronMaxConeSize) );
     }
     if (m_orDoBoostedMuon) {
       if (m_orBoostedMuonC1 > 0) ATH_CHECK( m_orToolbox.muJetORT.setProperty("SlidingDRC1", m_orBoostedMuonC1) );
       if (m_orBoostedMuonC2 > 0) ATH_CHECK( m_orToolbox.muJetORT.setProperty("SlidingDRC2", m_orBoostedMuonC2) );
       if (m_orBoostedMuonMaxConeSize > 0) ATH_CHECK( m_orToolbox.muJetORT.setProperty("SlidingDRMaxCone", m_orBoostedMuonMaxConeSize) );
     }
  
     // and switch off lep-bjet check if not requested
     if (!m_orDoElBjet) {
       ATH_CHECK(m_orToolbox.eleJetORT.setProperty("BJetLabel", ""));
     }
     if (!m_orDoMuBjet) {
       ATH_CHECK(m_orToolbox.muJetORT.setProperty("BJetLabel", ""));
     }
  
     // propagate the mu-jet ghost-association option which might be set by the user (default is true)
     ATH_CHECK(m_orToolbox.muJetORT.setProperty("UseGhostAssociation", m_orDoMuonJetGhostAssociation));
  
     // propagate mu-jet OR settings if requested
     ATH_CHECK(m_orToolbox.muJetORT.setProperty("ApplyRelPt", m_orApplyRelPt) );
     if(m_orApplyRelPt){
       if (m_orMuJetPtRatio > 0)    ATH_CHECK(m_orToolbox.muJetORT.setProperty("MuJetPtRatio", m_orMuJetPtRatio) );
       if (m_orMuJetTrkPtRatio > 0) ATH_CHECK(m_orToolbox.muJetORT.setProperty("MuJetTrkPtRatio", m_orMuJetTrkPtRatio) );
     }
     if (m_orMuJetInnerDR > 0)    ATH_CHECK(m_orToolbox.muJetORT.setProperty("InnerDR", m_orMuJetInnerDR) );
  
     // propagate the calo muon setting for EleMuORT
     ATH_CHECK(m_orToolbox.eleMuORT.setProperty("RemoveCaloMuons", m_orRemoveCaloMuons) );
  
     // Use electron-muon DR matching to remove electrons within DR <  0.01 of Muons.
     if (m_orDoElMu){
       ATH_CHECK(m_orToolbox.eleMuORT.setProperty("UseDRMatching", m_orDoElMu) );
     }
  
     // propagate the fatjets OR settings
     if(m_orDoFatjets){
       if(m_EleFatJetDR>0) ATH_CHECK(m_orToolbox.eleFatJetORT.setProperty("DR", m_EleFatJetDR));
       if(m_JetFatJetDR>0) ATH_CHECK(m_orToolbox.jetFatJetORT.setProperty("DR", m_JetFatJetDR));
     }
  
     // Make sure that we deal with prorities correctly
     ATH_CHECK(m_orToolbox.eleJetORT.setProperty("EnableUserPriority", true));
     ATH_CHECK(m_orToolbox.muJetORT.setProperty("EnableUserPriority", true));
     if (m_orDoTau) ATH_CHECK(m_orToolbox.tauJetORT.setProperty("EnableUserPriority", true));
     if (m_orDoPhoton) ATH_CHECK(m_orToolbox.phoJetORT.setProperty("EnableUserPriority", true));
  
     if ( m_orPhotonFavoured ) {
        ATH_CHECK(m_orToolbox.phoEleORT.setProperty("SwapContainerPrecedence", true));
        ATH_CHECK(m_orToolbox.phoMuORT.setProperty("SwapContainerPrecedence", true));
     }
  
     if (!m_orDoEleJet){
       // Disable the electron removal part of e-j overlap removal
       ATH_CHECK( m_orToolbox.eleJetORT.setProperty("OuterDR",-1.) );
       ATH_CHECK( m_orToolbox.eleJetORT.setProperty("SlidingDRMaxCone",-1.) );
     }
     if (!m_orDoMuonJet){
       // Disable the muon removal part of m-j overlap removal
       ATH_CHECK( m_orToolbox.muJetORT.setProperty("OuterDR",-1.) );
       ATH_CHECK( m_orToolbox.muJetORT.setProperty("SlidingDRMaxCone",-1.) );
     }
  
     ATH_CHECK( m_orToolbox.initialize() );
  
   }
   // Done with the OR toolbox setup!
  
 // /////////////////////////////////////////////////////////////////////////////////////////
 // Initialise PMG Tools
   if (!m_pmgSHnjetWeighter.isUserConfigured()) {
     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  ATH_CHECK( m_pmgSHnjetWeighter.retrieve());
  
  
   if (!m_pmgSHnjetWeighterWZ.isUserConfigured()) {
     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  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 110 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 3062 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<450000) return 2022;
   return 2023;
 }

◆ 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 276 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 314 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 283 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 259 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 304 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 264 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::AuxElement::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 247 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::AuxElement::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 297 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 309 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 290 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 2062 of file SUSYObjDef_xAOD.cxx.

2062 { 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 1907 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 211 of file SUSYObjDef_xAOD.h.

double ST::SUSYObjDef_xAOD::m_badmuQoverP

protected

Definition at line 703 of file SUSYObjDef_xAOD.h.

◆ m_beginInputFileCalled

bool asg::AsgMetadataTool::m_beginInputFileCalled

Definition at line 871 of file SUSYObjDef_xAOD.h.

◆ m_elecEfficiencySFTool_reco

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

protected

Definition at line 747 of file SUSYObjDef_xAOD.h.

◆ m_orDoTau

bool ST::SUSYObjDef_xAOD::m_orDoTau

◆ m_ZTagUncConfig

std::string ST::SUSYObjDef_xAOD::m_ZTagUncConfig

protected

Definition at line 554 of file SUSYObjDef_xAOD.h.

◆ prompt_electrons

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

Definition at line 210 of file SUSYObjDef_xAOD.h.

◆ prompt_muons

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

Definition at line 204 of file SUSYObjDef_xAOD.h.

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

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Callback functions helping in metadata reading/writing

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() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ EG_WP()

◆ emulateHLT()

◆ endInputFile()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

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

◆ GetElectrons()

◆ GetEleTriggerEfficiency()

◆ GetEleTriggerEfficiencySF()

◆ getElSFkeys()

◆ GetEventInfo()

◆ GetFatJets()