 |
ATLAS Offline Software
|
#include <SUSYObjDef_xAOD.h>
|
| | 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 *©, xAOD::ShallowAuxContainer *©aux, const bool recordSG=true, const std::string &jetkey="", const xAOD::JetContainer *containerToBeCopied=nullptr) override final |
| |
| StatusCode | GetTrackJets (xAOD::JetContainer *©, xAOD::ShallowAuxContainer *©aux, const bool recordSG=true, const std::string &jetkey="", const xAOD::JetContainer *containerToBeCopied=nullptr) override final |
| |
| StatusCode | GetJetsSyst (const xAOD::JetContainer &calibjets, xAOD::JetContainer *©, xAOD::ShallowAuxContainer *©aux, const bool recordSG=true, const std::string &jetkey="") override final |
| |
| StatusCode | GetFatJets (xAOD::JetContainer *©, xAOD::ShallowAuxContainer *©aux, const bool recordSG=false, const std::string &jetkey="", const bool doLargeRdecorations=false, const xAOD::JetContainer *containerToBeCopied=nullptr) override final |
| |
| StatusCode | GetTaus (xAOD::TauJetContainer *©, xAOD::ShallowAuxContainer *©aux, const bool recordSG=true, const std::string &taukey="TauJets", const xAOD::TauJetContainer *containerToBeCopied=nullptr) override final |
| |
| StatusCode | GetMuons (xAOD::MuonContainer *©, xAOD::ShallowAuxContainer *©aux, 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 *©, xAOD::ShallowAuxContainer *©aux, 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 *©, xAOD::ShallowAuxContainer *©aux, const bool recordSG=true, const std::string &photonkey="Photons", const xAOD::PhotonContainer *containerToBeCopied=nullptr) override final |
| |
| StatusCode | GetMET (xAOD::MissingETContainer &met, const xAOD::JetContainer *jet, const xAOD::ElectronContainer *elec=nullptr, const xAOD::MuonContainer *muon=nullptr, const xAOD::PhotonContainer *gamma=nullptr, const xAOD::TauJetContainer *taujet=nullptr, bool doTST=true, bool doJVTCut=true, const xAOD::IParticleContainer *invis=nullptr) override final |
| |
| StatusCode | GetTrackMET (xAOD::MissingETContainer &met, const xAOD::JetContainer *jet, const xAOD::ElectronContainer *elec=nullptr, const xAOD::MuonContainer *muon=nullptr) override final |
| |
| StatusCode | GetMETSig (xAOD::MissingETContainer &met, double &metSignificance, bool doTST=true, bool doJVTCut=true) override final |
| |
| StatusCode | MergeMuons (const xAOD::MuonContainer &muons, const std::vector< bool > &writeMuon, xAOD::MuonContainer *outputCol) const override final |
| |
| StatusCode | prepareLRTMuons (const xAOD::MuonContainer *inMuons, xAOD::MuonContainer *copy) const override final |
| |
| StatusCode | MergeElectrons (const xAOD::ElectronContainer &electrons, xAOD::ElectronContainer *outputCol, const std::set< const xAOD::Electron * > &ElectronsToRemove) const override final |
| |
| StatusCode | prepareLRTElectrons (const xAOD::ElectronContainer *inMuons, xAOD::ElectronContainer *copy) const override final |
| |
| StatusCode | SetBtagWeightDecorations (const xAOD::Jet &input, const asg::AnaToolHandle< IBTaggingSelectionTool > &btagSelTool, const std::string &btagTagger) const override final |
| |
| bool | IsSignalJet (const xAOD::Jet &input, const float ptcut, const float etacut) const override final |
| |
| bool | IsBadJet (const xAOD::Jet &input) const override final |
| |
| bool | IsBJetLoose (const xAOD::Jet &input) const override final |
| |
| bool | JetPassJVT (xAOD::Jet &input) override final |
| |
| bool | IsSignalMuon (const xAOD::Muon &input, const float ptcut, const float d0sigcut, const float z0cut, const float etacut=DUMMYDEF) const override final |
| |
| bool | IsSignalElectron (const xAOD::Electron &input, const float etcut, const float d0sigcut, const float z0cut, const float etacut=DUMMYDEF) const override final |
| |
| bool | IsCosmicMuon (const xAOD::Muon &input, const float z0cut, const float d0cut) const override final |
| |
| bool | IsHighPtMuon (const xAOD::Muon &input) const override final |
| |
| bool | IsSignalTau (const xAOD::TauJet &input, const float ptcut, const float etacut) const override final |
| |
| bool | IsBadMuon (const xAOD::Muon &input, const float qopcut) const override final |
| |
| bool | IsSignalPhoton (const xAOD::Photon &input, const float ptcut, const float etacut=DUMMYDEF) const override final |
| |
| bool | IsBJet (const xAOD::Jet &input) const override final |
| |
| bool | IsTrackBJet (const xAOD::Jet &input) const override final |
| |
| bool | IsTruthBJet (const xAOD::Jet &input) const override final |
| |
| int | IsBJetContinuous (const xAOD::Jet &input) const override final |
| |
| int | IsTrackBJetContinuous (const xAOD::Jet &input) const override final |
| |
| float | BtagSF (const xAOD::JetContainer *jets) override final |
| |
| float | BtagSFsys (const xAOD::JetContainer *jets, const CP::SystematicSet &systConfig) override final |
| |
| float | BtagSF_trkJet (const xAOD::JetContainer *trkjets) override final |
| |
| float | BtagSFsys_trkJet (const xAOD::JetContainer *trkjets, const CP::SystematicSet &systConfig) override final |
| |
| double | JVT_SF (const xAOD::JetContainer *jets) override final |
| |
| double | JVT_SFsys (const xAOD::JetContainer *jets, const CP::SystematicSet &systConfig) override final |
| |
| double | FJVT_SF (const xAOD::JetContainer *jets) override final |
| |
| double | FJVT_SFsys (const xAOD::JetContainer *jets, const CP::SystematicSet &systConfig) override final |
| |
| float | GetSignalMuonSF (const xAOD::Muon &mu, const bool recoSF=true, const bool isoSF=true, const bool doBadMuonHP=true, const bool warnOVR=true) override final |
| |
| double | GetMuonTriggerEfficiency (const xAOD::Muon &mu, const std::string &trigExpr, const bool isdata=false) override final |
| |
| double | GetTotalMuonTriggerSF (const xAOD::MuonContainer &sfmuons, const std::string &trigExpr) override final |
| |
| double | GetTotalMuonSF (const xAOD::MuonContainer &muons, const bool recoSF=true, const bool isoSF=true, const std::string &trigExpr="HLT_mu20_iloose_L1MU15_OR_HLT_mu50", const bool bmhptSF=true) override final |
| |
| double | GetTotalMuonSFsys (const xAOD::MuonContainer &muons, const CP::SystematicSet &systConfig, const bool recoSF=true, const bool isoSF=true, const std::string &trigExpr="HLT_mu20_iloose_L1MU15_OR_HLT_mu50", const bool bmhptSF=true) override final |
| |
| float | GetSignalElecSF (const xAOD::Electron &el, const bool recoSF=true, const bool idSF=true, const bool triggerSF=true, const bool isoSF=true, const std::string &trigExpr="singleLepton", const bool ecidsSF=false, const bool cidSF=false) override final |
| |
| double | GetEleTriggerEfficiency (const xAOD::Electron &el, const std::string &trigExpr="SINGLE_E_2015_e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose_2016_2018_e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0") const override final |
| |
| double | GetTriggerGlobalEfficiency (const xAOD::ElectronContainer &electrons, const xAOD::MuonContainer &muons, const std::string &trigExpr="diLepton") override final |
| |
| double | GetTriggerGlobalEfficiency (const xAOD::PhotonContainer &photons, const std::string &trigExpr="diPhoton") override final |
| |
| double | GetEleTriggerEfficiencySF (const xAOD::Electron &el, const std::string &trigExpr="SINGLE_E_2015_e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose_2016_2018_e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0") const override final |
| |
| double | GetTriggerGlobalEfficiencySF (const xAOD::ElectronContainer &electrons, const xAOD::MuonContainer &muons, const std::string &trigExpr="diLepton") override final |
| |
| double | GetTriggerGlobalEfficiencySF (const xAOD::PhotonContainer &photons, const std::string &trigExpr="diPhoton") override final |
| |
| double | GetTriggerGlobalEfficiencySFsys (const xAOD::ElectronContainer &electrons, const xAOD::MuonContainer &muons, const CP::SystematicSet &systConfig, const std::string &trigExpr="diLepton") override final |
| |
| double | GetTriggerGlobalEfficiencySFsys (const xAOD::PhotonContainer &photons, const CP::SystematicSet &systConfig, const std::string &trigExpr="diPhoton") override final |
| |
| float | GetTotalElectronSF (const xAOD::ElectronContainer &electrons, const bool recoSF=true, const bool idSF=true, const bool triggerSF=true, const bool isoSF=true, const std::string &trigExpr="singleLepton", const bool ecidsSF=false, const bool cidSF=false) override final |
| |
| float | GetTotalElectronSFsys (const xAOD::ElectronContainer &electrons, const CP::SystematicSet &systConfig, const bool recoSF=true, const bool idSF=true, const bool triggerSF=true, const bool isoSF=true, const std::string &trigExpr="singleLepton", const bool ecidsSF=false, const bool cidSF=false) override final |
| |
| double | GetSignalTauSF (const xAOD::TauJet &tau, const bool idSF=true, const bool triggerSF=true, const std::string &trigExpr="tau25_medium1_tracktwo") override final |
| |
| double | GetSignalTauSFsys (const xAOD::TauJet &tau, const CP::SystematicSet &systConfig, const bool idSF=true, const bool triggerSF=true, const std::string &trigExpr="tau25_medium1_tracktwo") override final |
| |
| double | GetTauTriggerEfficiencySF (const xAOD::TauJet &tau, const std::string &trigExpr="tau25_medium1_tracktwo") override final |
| |
| double | GetTotalTauSF (const xAOD::TauJetContainer &taus, const bool idSF=true, const bool triggerSF=true, const std::string &trigExpr="tau25_medium1_tracktwo") override final |
| |
| double | GetTotalTauSFsys (const xAOD::TauJetContainer &taus, const CP::SystematicSet &systConfig, const bool idSF=true, const bool triggerSF=true, const std::string &trigExpr="tau25_medium1_tracktwo") override final |
| |
| double | GetSignalPhotonSF (const xAOD::Photon &ph, const bool effSF=true, const bool isoSF=true, const bool triggerSF=false) const override final |
| |
| double | GetSignalPhotonSFsys (const xAOD::Photon &ph, const CP::SystematicSet &systConfig, const bool effSF=true, const bool isoSF=true, const bool triggerSF=false) override final |
| |
| double | GetTotalPhotonSF (const xAOD::PhotonContainer &photons, const bool effSF=true, const bool isoSF=true, const bool triggerSF=false) const override final |
| |
| double | GetTotalPhotonSFsys (const xAOD::PhotonContainer &photons, const CP::SystematicSet &systConfig, const bool effSF=true, const bool isoSF=true, const bool triggerSF=false) override final |
| |
| double | GetTotalJetSF (const xAOD::JetContainer *jets, const bool btagSF=true, const bool jvtSF=true, const bool fjvtSF=false) override final |
| |
| double | GetTotalJetSFsys (const xAOD::JetContainer *jets, const CP::SystematicSet &systConfig, const bool btagSF=true, const bool jvtSF=true, const bool fjvtSF=false) override final |
| |
| bool | IsMETTrigPassed (unsigned int runnumber=0, bool j400_OR=false) const override final |
| |
| bool | IsMETTrigPassed (const std::string &triggerName, bool j400_OR=false, const std::string &L1_name="L1_XE50") const override final |
| |
| bool | IsTrigPassed (const std::string &, unsigned int condition=TrigDefs::Physics) const override final |
| |
| bool | IsTrigMatched (const xAOD::IParticle *part, const std::string &tr_item) override final |
| |
| bool | IsTrigMatched (const xAOD::IParticle *part1, const xAOD::IParticle *part2, const std::string &tr_item) override final |
| |
| bool | IsTrigMatched (const std::vector< const xAOD::IParticle * > &v, const std::string &tr_item) override final |
| |
| bool | IsTrigMatched (const std::initializer_list< const xAOD::IParticle * > &v, const std::string &tr_item) override final |
| |
| void | TrigMatch (const xAOD::IParticle *p, std::initializer_list< std::string >::iterator, std::initializer_list< std::string >::iterator) override final |
| |
| void | TrigMatch (const xAOD::IParticle *p, const std::vector< std::string > &items) override final |
| |
| void | TrigMatch (const xAOD::IParticle *p, const std::initializer_list< std::string > &items) override final |
| |
| void | TrigMatch (const xAOD::IParticleContainer *v, const std::vector< std::string > &items) override final |
| |
| void | TrigMatch (const xAOD::IParticleContainer *v, const std::initializer_list< std::string > &items) override final |
| |
| void | TrigMatch (const std::initializer_list< const xAOD::IParticle * > &v, const std::vector< std::string > &items) override final |
| |
| void | TrigMatch (const std::initializer_list< const xAOD::IParticle * > &v, const std::initializer_list< std::string > &items) override final |
| |
| void | TrigMatch (const xAOD::IParticle *p, const std::string &item) override final |
| |
| void | TrigMatch (const xAOD::IParticleContainer *v, const std::string &item) override final |
| |
| void | TrigMatch (const std::initializer_list< const xAOD::IParticle * > &v, const std::string &item) override final |
| |
| float | GetTrigPrescale (const std::string &) const override final |
| |
| const Trig::ChainGroup * | GetTrigChainGroup (const std::string &) const override final |
| |
| std::vector< std::string > | GetTriggerOR (const std::string &trigExpr) const |
| |
| void | GetTriggerTokens (std::string, std::vector< std::string > &, std::vector< std::string > &, std::vector< std::string > &, std::vector< std::string > &, std::vector< std::string > &, std::vector< std::string > &, std::vector< std::string > &) const |
| |
| Trig::FeatureContainer | GetTriggerFeatures (const std::string &chainName="EF_.*", unsigned int condition=TrigDefs::Physics) const |
| |
| const xAOD::EventInfo * | GetEventInfo () const override final |
| |
| float | GetPileupWeight () override final |
| |
| float | GetPileupWeightPrescaledTrigger (const std::string &trigger_expr) override final |
| |
| ULong64_t | GetPileupWeightHash () override final |
| |
| float | GetDataWeight (const std::string &) override final |
| |
| float | GetCorrectedAverageInteractionsPerCrossing (bool includeDataSF=false) override final |
| |
| float | GetCorrectedActualInteractionsPerCrossing (bool includeDataSF=false) override final |
| |
| double | GetSumOfWeights (int channel) override final |
| |
| unsigned int | GetRandomRunNumber (bool muDependentRRN=true) override final |
| |
| StatusCode | ApplyPRWTool (bool muDependentRRN=true) override final |
| |
| unsigned int | GetRunNumber () const override final |
| |
| const xAOD::TrackParticleContainer & | GetInDetLargeD0Tracks (const EventContext &ctx) const override final |
| |
| const xAOD::TrackParticleContainer & | GetInDetLargeD0GSFTracks (const EventContext &ctx) const override final |
| |
| StatusCode | ApplyLRTUncertainty () override final |
| |
| int | treatAsYear (const int runNumber=-1) const override final |
| |
| StatusCode | OverlapRemoval (const xAOD::ElectronContainer *electrons, const xAOD::MuonContainer *muons, const xAOD::JetContainer *jets, const xAOD::PhotonContainer *gamma=nullptr, const xAOD::TauJetContainer *taujet=nullptr, const xAOD::JetContainer *fatjets=nullptr) override final |
| |
| StatusCode | NearbyLeptonCorrections (xAOD::ElectronContainer *electrons=nullptr, xAOD::MuonContainer *muons=nullptr) const override final |
| |
| StatusCode | resetSystematics () override final |
| |
| const CP::SystematicSet & | currentSystematic () const |
| |
| StatusCode | applySystematicVariation (const CP::SystematicSet &systConfig) override final |
| |
| bool | isPrompt (const xAOD::IParticle *part) const override final |
| |
| StatusCode | FindSusyHP (int &pdgid1, int &pdgid2) const |
| |
| StatusCode | FindSusyHP (const xAOD::TruthParticleContainer *truthP, int &pdgid1, int &pdgid2, bool isTruth3=false) const override final |
| |
| StatusCode | FindSusyHP (const xAOD::TruthEvent *truthE, int &pdgid1, int &pdgid2) const override final |
| |
| std::string | TrigSingleLep () const override final |
| |
| bool | isNominal (const CP::SystematicSet &syst) const |
| |
| bool | isWeight (const CP::SystematicSet &systSet) const |
| |
| bool | isVariation (const CP::SystematicSet &syst) const |
| |
| bool | currentSystematicIsNominal () const |
| |
| bool | currentSystematicIsVariation () const |
| |
| bool | currentSystematicIsWeight () const |
| |
| ST::SystInfo | getSystInfo (const CP::SystematicVariation &sys) const override final |
| |
| std::vector< ST::SystInfo > | getSystInfoList () const override final |
| |
| float | getSherpaVjetsNjetsWeight () const override final |
| |
| float | getSherpaVjetsNjetsWeight (const std::string &jetContainer) const override final |
| |
| int | getMCShowerType (const std::string &sample_name="", const std::string &tagger="") const override final |
| |
| template<typename T > |
| const T * | getProperty (const std::string &name) |
| |
| virtual void | print () const =0 |
| | Print the state of the tool. More...
|
| |
| virtual StatusCode | sysInitialize () |
| | Function initialising the tool in the correct way in Athena. More...
|
| |
| virtual void | print () const |
| | Print the state of the tool. More...
|
| |
| ServiceHandle< StoreGateSvc > & | evtStore () |
| | The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
|
| |
| const ServiceHandle< StoreGateSvc > & | evtStore () const |
| | The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
|
| |
| const ServiceHandle< StoreGateSvc > & | detStore () const |
| | The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
|
| |
| virtual StatusCode | sysStart () override |
| | Handle START transition. More...
|
| |
| virtual std::vector< Gaudi::DataHandle * > | inputHandles () const override |
| | Return this algorithm's input handles. More...
|
| |
| virtual std::vector< Gaudi::DataHandle * > | outputHandles () const override |
| | Return this algorithm's output handles. More...
|
| |
| Gaudi::Details::PropertyBase & | declareProperty (Gaudi::Property< T, V, H > &t) |
| |
| Gaudi::Details::PropertyBase * | declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &) |
| | Declare a new Gaudi property. More...
|
| |
| Gaudi::Details::PropertyBase * | declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &) |
| | Declare a new Gaudi property. More...
|
| |
| Gaudi::Details::PropertyBase * | declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &) |
| |
| Gaudi::Details::PropertyBase * | declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &) |
| | Declare a new Gaudi property. More...
|
| |
| Gaudi::Details::PropertyBase * | declareProperty (const std::string &name, T &property, const std::string &doc="none") |
| | Declare a new Gaudi property. More...
|
| |
| void | updateVHKA (Gaudi::Details::PropertyBase &) |
| |
| MsgStream & | msg () const |
| |
| MsgStream & | msg (const MSG::Level lvl) const |
| |
| bool | msgLvl (const MSG::Level lvl) const |
| |
|
| StatusCode | autoconfigurePileupRWTool (const std::string &PRWfilesDir="dev/PileupReweighting/share/", const std::string &PRWfileName="", bool usePathResolver=true, bool RPVLLmode=false, bool Combinedmode=false, const std::string &HFFilter="") |
| |
| StatusCode | readConfig () override final |
| |
| StatusCode | validConfig (bool strict=false) const |
| |
| const std::vector< std::string > | split (const std::string &s, const std::string &delim) const |
| |
| std::string | getDefaultJetUncConfig () |
| |
| void | getTauConfig (const std::string &tauConfigPath, std::vector< float > &pT_window, std::vector< float > &eta_window, bool &eleOLR, bool &muVeto, bool &muOLR) const |
| |
| void | configFromFile (bool &property, const std::string &propname, TEnv &rEnv, bool defaultValue) |
| |
| void | configFromFile (double &property, const std::string &propname, TEnv &rEnv, double defaultValue) |
| |
| void | configFromFile (int &property, const std::string &propname, TEnv &rEnv, int defaultValue) |
| |
| void | configFromFile (std::string &property, const std::string &propname, TEnv &rEnv, const std::string &defaultValue, bool allowEmpty=false) |
| |
| bool | check_isOption (const std::string &wp, const std::vector< std::string > &list) const |
| |
| bool | check_isTighter (const std::string &wp1, const std::string &wp, const std::vector< std::string > &list) const |
| |
| std::string | EG_WP (const std::string &wp) const |
| |
| std::vector< std::string > | getElSFkeys (const std::string &mapFile) const |
| |
| void | renounceArray (SG::VarHandleKeyArray &handlesArray) |
| | remove all handles from I/O resolution More...
|
| |
| std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > | renounce (T &h) |
| |
| void | extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps) |
| | Add StoreName to extra input/output deps as needed. More...
|
| |
|
| int | m_dataSource |
| |
| int | m_jetInputType |
| |
| std::string | m_configFile |
| |
| bool | m_force_noElId |
| |
| bool | m_force_noMuId |
| |
| bool | m_doTTVAsf |
| |
| bool | m_doModifiedEleId |
| |
| bool | m_upstreamTriggerMatching |
| |
| std::string | m_trigMatchingPrefix |
| | Use composite trigger matching tool if matching was done upstream. More...
|
| |
| std::string | m_jetUncertaintiesConfig |
| | Prefix for trigger matchiing container name. More...
|
| |
| std::string | m_jetUncertaintiesAnalysisFile |
| |
| std::string | m_jetUncertaintiesCalibArea |
| |
| std::string | m_jetUncertaintiesMCType |
| |
| std::string | m_fatJetUncertaintiesMCType |
| |
| bool | m_jetUncertaintiesPDsmearing |
| |
| bool | m_useBtagging |
| |
| bool | m_useBtagging_trkJet |
| |
| bool | m_debug |
| |
| bool | m_strictConfigCheck |
| |
| std::string | m_badJetCut |
| |
| std::string | m_fatJetUncConfig |
| |
| bool | m_fatJetUncertaintiesPDsmearing |
| |
| std::string | m_fatJetUncVars |
| |
| TEnv | m_WconfigReader |
| |
| TEnv | m_ZconfigReader |
| |
| TEnv | m_TopconfigReader |
| |
| std::string | m_WDecorName |
| |
| std::string | m_ZDecorName |
| |
| std::string | m_TopDecorName |
| |
| std::string | m_WtagConfig |
| |
| std::string | m_ZtagConfig |
| |
| std::string | m_ToptagConfig |
| |
| std::string | m_WZTaggerCalibArea |
| |
| std::string | m_TopTaggerCalibArea |
| |
| std::string | m_WTagUncConfig |
| |
| std::string | m_ZTagUncConfig |
| |
| std::string | m_TopTagUncConfig |
| |
| std::string | m_JetTruthLabelName |
| |
| bool | m_tool_init |
| |
| bool | m_subtool_init |
| |
| std::string | m_eleTerm |
| |
| std::string | m_gammaTerm |
| |
| std::string | m_tauTerm |
| |
| std::string | m_jetTerm |
| |
| std::string | m_muonTerm |
| |
| std::string | m_inputMETSuffix |
| |
| std::string | m_inputMETMap |
| |
| std::string | m_inputMETCore |
| |
| std::string | m_inputMETRef |
| |
| std::string | m_outMETTerm |
| |
| bool | m_metRemoveOverlappingCaloTaggedMuons |
| |
| bool | m_metDoSetMuonJetEMScale |
| |
| bool | m_metDoRemoveMuonJets |
| |
| bool | m_metUseGhostMuons |
| |
| bool | m_metDoMuonEloss |
| |
| bool | m_metGreedyPhotons |
| |
| bool | m_metVeryGreedyPhotons |
| |
| std::string | m_metsysConfigPrefix |
| |
| bool | m_trkMETsyst |
| |
| bool | m_caloMETsyst |
| |
| bool | m_trkJetsyst |
| |
| int | m_softTermParam |
| |
| bool | m_treatPUJets |
| |
| bool | m_doPhiReso |
| |
| bool | m_autoconfigPRW |
| |
| std::string | m_autoconfigPRWPath |
| |
| std::string | m_autoconfigPRWFile |
| |
| bool | m_autoconfigPRWCombinedmode |
| |
| bool | m_autoconfigPRWRPVmode |
| |
| std::string | m_autoconfigPRWRtags |
| |
| std::string | m_mcCampaign |
| |
| int | m_mcChannel |
| |
| bool | m_useCommonPRWFiles |
| |
| std::string | m_commonPRWFileMC20a |
| |
| std::string | m_commonPRWFileMC20d |
| |
| std::string | m_commonPRWFileMC20e |
| |
| std::string | m_commonPRWFileMC21a |
| |
| std::string | m_commonPRWFileMC23a |
| |
| std::string | m_commonPRWFileMC23c |
| |
| std::string | m_commonPRWFileMC23d |
| |
| std::string | m_commonPRWFileMC23e |
| |
| std::vector< std::string > | m_prwConfFiles |
| |
| std::vector< std::string > | m_prwLcalcFiles |
| |
| std::string | m_prwActualMu2017File |
| |
| std::string | m_prwActualMu2018File |
| |
| std::string | m_prwActualMu2022File |
| |
| std::string | m_prwActualMu2023File |
| |
| std::string | m_prwActualMu2024File |
| |
| double | m_prwDataSF |
| |
| double | m_prwDataSF_UP |
| |
| double | m_prwDataSF_DW |
| |
| bool | m_runDepPrescaleWeightPRW |
| |
| std::vector< std::string > | m_el_id_support |
| |
| std::vector< std::string > | m_ph_id_support |
| |
| int | m_mu_id_support |
| |
| std::vector< std::string > | m_tau_id_support |
| |
| std::vector< std::string > | m_el_iso_support |
| |
| std::vector< std::string > | m_mu_iso_support |
| |
| std::map< std::string, std::string > | m_el_iso_fallback |
| |
| std::map< std::string, std::string > | m_mu_iso_fallback |
| |
| std::string | m_electronTriggerSFStringSingle |
| |
| std::map< std::string, std::string > | m_tau_trig_support |
| |
| std::string | m_eleId |
| |
| std::string | m_eleIdBaseline |
| |
| std::string | m_eleConfig |
| |
| std::string | m_eleConfigBaseline |
| |
| std::string | m_eleBaselineIso_WP |
| |
| bool | m_eleIdExpert |
| |
| int | m_muId |
| |
| int | m_muIdBaseline |
| |
| std::string | m_photonId |
| |
| std::string | m_photonIdBaseline |
| |
| std::string | m_tauId |
| |
| std::string | m_tauIdBaseline |
| |
| std::string | m_eleIso_WP |
| |
| std::string | m_eleIsoHighPt_WP |
| |
| double | m_eleIsoHighPtThresh |
| |
| std::string | m_eleChID_WP |
| |
| bool | m_eleLRT |
| |
| int | m_eleLRT_strat |
| |
| bool | m_eleChIso |
| |
| bool | m_eleChID_signal |
| |
| bool | m_runECIS |
| |
| std::string | m_photonBaselineIso_WP |
| |
| std::string | m_photonIso_WP |
| |
| std::string | m_photonTriggerName |
| |
| std::string | m_muBaselineIso_WP |
| |
| std::string | m_muIso_WP |
| |
| std::string | m_muIsoHighPt_WP |
| |
| double | m_muIsoHighPtThresh |
| |
| bool | m_muHighPtExtraSmear |
| |
| bool | m_muEffCorrForce1D |
| |
| std::string | m_muTriggerSFCalibRelease |
| |
| std::string | m_muTriggerSFCalibFilename |
| |
| std::string | m_BtagWP |
| |
| std::string | m_BtagTagger |
| |
| double | m_BtagMinPt |
| |
| std::string | m_BtagKeyOverride |
| |
| std::string | m_BtagSystStrategy |
| |
| std::string | m_EigenvectorReductionB |
| |
| std::string | m_EigenvectorReductionC |
| |
| std::string | m_EigenvectorReductionLight |
| |
| std::string | m_BtagWP_trkJet |
| |
| std::string | m_BtagTagger_trkJet |
| |
| double | m_BtagMinPt_trkJet |
| |
| double | m_eleBaselinePt |
| |
| double | m_eleBaselineEta |
| |
| bool | m_eleBaselineCrackVeto |
| |
| double | m_elePt |
| |
| double | m_eleEta |
| |
| bool | m_eleCrackVeto |
| |
| double | m_eled0sig |
| |
| double | m_elez0 |
| |
| double | m_elebaselined0sig |
| |
| double | m_elebaselinez0 |
| |
| std::string | m_eleEffMapFilePath |
| |
| std::string | m_eleEffMapFilePathRun2 |
| |
| bool | m_eleAllowRun3TrigSFFallback |
| |
| bool | m_eleForceFullSimCalib |
| |
| double | m_muBaselinePt |
| |
| double | m_muBaselineEta |
| |
| double | m_muPt |
| |
| double | m_muEta |
| |
| double | m_mud0sig |
| |
| double | m_muz0 |
| |
| double | m_mubaselined0sig |
| |
| double | m_mubaselinez0 |
| |
| bool | m_murequirepassedHighPtCuts |
| |
| double | m_muCosmicz0 |
| |
| double | m_muCosmicd0 |
| |
| double | m_badmuQoverP |
| |
| int | m_muCalibrationMode |
| |
| bool | m_muLRT |
| |
| double | m_photonBaselinePt |
| |
| double | m_photonBaselineEta |
| |
| double | m_photonEta |
| |
| double | m_photonPt |
| |
| bool | m_photonBaselineCrackVeto |
| |
| bool | m_photonCrackVeto |
| |
| bool | m_photonAllowLate |
| |
| double | m_tauPrePtCut |
| |
| double | m_tauPt |
| |
| double | m_tauEta |
| |
| std::string | m_tauConfigPath |
| |
| std::string | m_tauConfigPathBaseline |
| |
| bool | m_tauDoTTM |
| |
| std::string | m_tauSmearingToolRecommendationTag |
| |
| std::string | m_tauEffToolRecommendationTag |
| |
| std::string | m_tauSmearingToolGenerator |
| |
| bool | m_ApplyMVATESQualityCheck |
| |
| TEnv | m_tauConfigReader |
| |
| double | m_jetPt |
| |
| double | m_jetEta |
| |
| double | m_jetJvt |
| |
| std::string | m_JvtWP |
| |
| double | m_JvtPtMax |
| |
| std::string | m_JvtConfigRun2 |
| |
| std::string | m_JvtConfigRun3 |
| |
| double | m_trkJetPt |
| |
| double | m_trkJetEta |
| |
| bool | m_doFwdJVT |
| |
| std::string | m_fJvtWP |
| |
| double | m_fJvtPtMax |
| |
| double | m_fJvtEtaMin |
| |
| std::string | m_fJvtConfigRun2 |
| |
| std::string | m_fJvtConfigRun3 |
| |
| bool | m_JMScalib |
| |
| bool | m_orDoTau |
| | Overlap removal options. More...
|
| |
| bool | m_orDoPhoton |
| |
| bool | m_orDoEleJet |
| |
| bool | m_orDoElEl |
| |
| bool | m_orDoElMu |
| |
| bool | m_orDoMuonJet |
| |
| bool | m_orDoBjet |
| |
| bool | m_orDoElBjet |
| |
| bool | m_orDoMuBjet |
| |
| bool | m_orDoTauBjet |
| |
| bool | m_orDoBoostedElectron |
| |
| double | m_orBoostedElectronC1 |
| |
| double | m_orBoostedElectronC2 |
| |
| double | m_orBoostedElectronMaxConeSize |
| |
| bool | m_orDoBoostedMuon |
| |
| double | m_orBoostedMuonC1 |
| |
| double | m_orBoostedMuonC2 |
| |
| double | m_orBoostedMuonMaxConeSize |
| |
| bool | m_orApplyRelPt |
| |
| double | m_orMuJetPtRatio |
| |
| double | m_orMuJetTrkPtRatio |
| |
| double | m_orMuJetInnerDR |
| |
| bool | m_orDoMuonJetGhostAssociation |
| |
| bool | m_orRemoveCaloMuons |
| |
| std::string | m_orBtagWP |
| |
| std::string | m_orInputLabel |
| |
| bool | m_orPhotonFavoured |
| |
| double | m_orBJetPtUpperThres |
| |
| bool | m_orLinkOverlapObjects |
| |
| bool | m_orDoFatjets |
| |
| double | m_EleFatJetDR |
| |
| double | m_JetFatJetDR |
| |
| bool | m_doIsoSignal |
| |
| bool | m_doElIsoSignal |
| |
| bool | m_doPhIsoSignal |
| |
| bool | m_doMuIsoSignal |
| |
| bool | m_useSigLepForIsoCloseByOR |
| |
| std::string | m_IsoCloseByORpassLabel |
| |
| bool | m_useTRUTH3 |
| |
| std::map< std::string, bool > | m_slices |
| |
| bool | m_isRun3 |
| |
| bool | m_isPHYSLITE |
| |
| std::string | m_metJetSelection |
| |
| int | m_showerType |
| |
| std::string | m_defaultJets |
| |
| std::string | m_defaultTrackJets |
| |
| std::string | m_fatJets |
| |
| std::string | m_defaultTruthJets |
| |
| CP::SystematicSet | m_defaultSyst = CP::SystematicSet() |
| |
| CP::SystematicSet | m_currentSyst |
| |
| std::vector< CP::SystematicSet > | m_fatjetFFSmearingSyst |
| |
| std::string | m_EG_corrModel |
| |
| std::string | m_EG_corrFNList |
| |
| bool | m_applyJVTCut |
| |
| std::string | m_bTaggingCalibrationFilePath |
| |
| std::map< std::string, std::string > | m_legsPerTool |
| |
| std::map< std::string, std::string > | m_legsPerTool_ph |
| |
| asg::AnaToolHandle< IJetCalibrationTool > | m_jetCalibTool |
| |
| asg::AnaToolHandle< IJetCalibrationTool > | m_jetFatCalibTool |
| |
| asg::AnaToolHandle< ICPJetUncertaintiesTool > | m_jetUncertaintiesTool |
| |
| asg::AnaToolHandle< ICPJetUncertaintiesTool > | m_jetUncertaintiesPDSmearTool |
| |
| asg::AnaToolHandle< ICPJetUncertaintiesTool > | m_fatjetUncertaintiesTool |
| |
| asg::AnaToolHandle< ICPJetUncertaintiesTool > | m_fatjetUncertaintiesPDSmearTool |
| |
| asg::AnaToolHandle< ICPJetCorrectionTool > | m_fatjetFFSmearingTool |
| |
| asg::AnaToolHandle< IJetSelector > | m_jetCleaningTool |
| |
| asg::AnaToolHandle< JetPileupLabelingTool > | m_jetPileupLabelingTool |
| |
| asg::AnaToolHandle< JetVertexTaggerTool > | m_jetJvtMomentTool |
| |
| asg::AnaToolHandle< JetPileupTag::JetVertexNNTagger > | m_jetNNJvtMomentTool |
| |
| asg::AnaToolHandle< IAsgSelectionTool > | m_jetNNJvtSelectionTool |
| |
| asg::AnaToolHandle< CP::IJvtEfficiencyTool > | m_jetNNJvtEfficiencyTool |
| |
| asg::AnaToolHandle< IAsgSelectionTool > | m_jetfJvtSelectionTool |
| |
| asg::AnaToolHandle< CP::IJvtEfficiencyTool > | m_jetfJvtEfficiencyTool |
| |
| asg::AnaToolHandle< SmoothedWZTagger > | m_WTaggerTool |
| |
| asg::AnaToolHandle< SmoothedWZTagger > | m_ZTaggerTool |
| |
| asg::AnaToolHandle< JSSWTopTaggerDNN > | m_TopTaggerTool |
| |
| asg::AnaToolHandle< JetTruthLabelingTool > | m_jetTruthLabelingTool |
| |
| asg::AnaToolHandle< ICPJetUncertaintiesTool > | m_WTagjetUncertaintiesTool |
| |
| asg::AnaToolHandle< ICPJetUncertaintiesTool > | m_ZTagjetUncertaintiesTool |
| |
| asg::AnaToolHandle< ICPJetUncertaintiesTool > | m_TopTagjetUncertaintiesTool |
| |
| SG::ReadDecorHandleKey< xAOD::JetContainer > | m_label_truthKey |
| |
| std::string | m_jesConfig |
| |
| std::string | m_jesConfigJMS |
| |
| std::string | m_jesConfigJMSData |
| |
| std::string | m_jesConfigAFII |
| |
| std::string | m_jesConfigFat |
| |
| std::string | m_jesConfigFatData |
| |
| std::string | m_jesCalibSeq |
| |
| std::string | m_jesCalibSeqJMS |
| |
| std::string | m_jesCalibSeqFat |
| |
| std::string | m_jesCalibArea |
| |
| asg::AnaToolHandle< CP::IMuonSelectionTool > | m_muonSelectionTool |
| |
| asg::AnaToolHandle< CP::IMuonSelectionTool > | m_muonSelectionHighPtTool |
| |
| asg::AnaToolHandle< CP::IMuonSelectionTool > | m_muonSelectionToolBaseline |
| |
| asg::AnaToolHandle< CP::IMuonCalibrationAndSmearingTool > | m_muonCalibTool |
| |
| asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > | m_muonEfficiencySFTool |
| |
| asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > | m_muonEfficiencyBMHighPtSFTool |
| |
| asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > | m_muonTTVAEfficiencySFTool |
| |
| asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > | m_muonIsolationSFTool |
| |
| asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > | m_muonHighPtIsolationSFTool |
| |
| asg::AnaToolHandle< CP::IMuonTriggerScaleFactors > | m_muonTriggerSFTool |
| |
| ToolHandleArray< CP::IMuonTriggerScaleFactors > | m_muonTrigSFTools |
| |
| asg::AnaToolHandle< CP::IMuonLRTOverlapRemovalTool > | m_muonLRTORTool |
| |
| SG::WriteHandleKey< xAOD::MuonContainer > | m_outMuonLocation {this, "OutputMuonLocation", "StdWithLRTMuons", "name of the muon container to write"} |
| |
| asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > | m_elecEfficiencySFTool_reco |
| | Combined muon collection. More...
|
| |
| asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > | m_elecEfficiencySFTool_id |
| |
| asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > | m_elecEfficiencySFTool_trig_singleLep |
| |
| asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > | m_elecEfficiencySFTool_trigEff_singleLep |
| |
| asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > | m_elecEfficiencySFTool_iso |
| |
| asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > | m_elecEfficiencySFTool_isoHighPt |
| |
| asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > | m_elecEfficiencySFTool_chf |
| |
| std::vector< asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > > | m_elecEfficiencySFTool_trig_mixLep |
| |
| std::vector< asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > > | m_elecEfficiencySFTool_trigEff_mixLep |
| |
| ToolHandleArray< IAsgElectronEfficiencyCorrectionTool > | m_elecTrigSFTools |
| |
| ToolHandleArray< IAsgElectronEfficiencyCorrectionTool > | m_elecTrigEffTools |
| |
| asg::AnaToolHandle< CP::IElectronLRTOverlapRemovalTool > | m_elecLRTORTool |
| |
| SG::WriteHandleKey< xAOD::ElectronContainer > | m_outElectronLocation {this, "OutputElectronLocation", "StdWithLRTElectrons", "name of the muon container to write"} |
| |
| asg::AnaToolHandle< CP::IEgammaCalibrationAndSmearingTool > | m_egammaCalibTool |
| | Combined electron collection. More...
|
| |
| asg::AnaToolHandle< IAsgElectronLikelihoodTool > | m_elecSelLikelihood |
| |
| asg::AnaToolHandle< IAsgElectronLikelihoodTool > | m_elecSelLikelihoodBaseline |
| |
| asg::AnaToolHandle< IAsgPhotonIsEMSelector > | m_photonSelIsEM |
| |
| asg::AnaToolHandle< IAsgPhotonIsEMSelector > | m_photonSelIsEMBaseline |
| |
| asg::AnaToolHandle< IAsgDeadHVCellRemovalTool > | m_deadHVTool |
| |
| asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > | m_photonEfficiencySFTool |
| |
| asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > | m_photonIsolationSFTool |
| |
| asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > | m_photonTriggerSFTool |
| |
| std::vector< asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > > | m_photonEfficiencySFTool_trigSF_AsymDiphoton |
| |
| std::vector< asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > > | m_photonEfficiencySFTool_trigEff_AsymDiphoton |
| |
| ToolHandleArray< IAsgPhotonEfficiencyCorrectionTool > | m_photonTrigSFTools |
| |
| ToolHandleArray< IAsgPhotonEfficiencyCorrectionTool > | m_photonTrigEffTools |
| |
| asg::AnaToolHandle< IEGammaAmbiguityTool > | m_egammaAmbiguityTool |
| |
| asg::AnaToolHandle< IAsgElectronLikelihoodTool > | m_elecChargeIDSelectorTool |
| |
| asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > | m_elecChargeEffCorrTool |
| |
| asg::AnaToolHandle< TauAnalysisTools::ITauSelectionTool > | m_tauSelTool |
| |
| asg::AnaToolHandle< TauAnalysisTools::ITauSelectionTool > | m_tauSelToolBaseline |
| |
| asg::AnaToolHandle< TauAnalysisTools::ITauSmearingTool > | m_tauSmearingTool |
| |
| asg::AnaToolHandle< TauAnalysisTools::ITauTruthMatchingTool > | m_tauTruthMatch |
| |
| asg::AnaToolHandle< TauAnalysisTools::ITauEfficiencyCorrectionsTool > | m_tauEffTool |
| |
| std::vector< asg::AnaToolHandle< TauAnalysisTools::ITauEfficiencyCorrectionsTool > > | m_tauTrigEffTool |
| |
| asg::AnaToolHandle< IBTaggingEfficiencyTool > | m_btagEffTool |
| |
| asg::AnaToolHandle< IBTaggingSelectionTool > | m_btagSelTool |
| |
| asg::AnaToolHandle< IBTaggingSelectionTool > | m_btagSelTool_OR |
| |
| asg::AnaToolHandle< IBTaggingEfficiencyTool > | m_btagEffTool_trkJet |
| |
| asg::AnaToolHandle< IBTaggingSelectionTool > | m_btagSelTool_trkJet |
| |
| asg::AnaToolHandle< IMETMaker > | m_metMaker |
| |
| asg::AnaToolHandle< IMETSystematicsTool > | m_metSystTool |
| |
| asg::AnaToolHandle< IMETSignificance > | m_metSignif |
| |
| std::string | m_trig2015combination_singleLep |
| |
| std::string | m_trig2016combination_singleLep |
| |
| std::string | m_trig2017combination_singleLep |
| |
| std::string | m_trig2018combination_singleLep |
| |
| std::string | m_trig2022combination_singleLep |
| |
| std::string | m_trig2023combination_singleLep |
| |
| std::string | m_trig2024combination_singleLep |
| |
| int | m_trigNToys_diLep |
| |
| std::string | m_trig2015combination_diLep |
| |
| std::string | m_trig2016combination_diLep |
| |
| std::string | m_trig2017combination_diLep |
| |
| std::string | m_trig2018combination_diLep |
| |
| std::string | m_trig2022combination_diLep |
| |
| asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionTool > | m_trigGlobalEffCorrTool_diLep |
| |
| int | m_trigNToys_multiLep |
| |
| std::string | m_trig2015combination_multiLep |
| |
| std::string | m_trig2016combination_multiLep |
| |
| std::string | m_trig2017combination_multiLep |
| |
| std::string | m_trig2018combination_multiLep |
| |
| std::string | m_trig2022combination_multiLep |
| |
| asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionTool > | m_trigGlobalEffCorrTool_multiLep |
| |
| int | m_trigNToys_diPhoton |
| |
| std::string | m_trig2015combination_diPhoton |
| |
| std::string | m_trig2016combination_diPhoton |
| |
| std::string | m_trig2017combination_diPhoton |
| |
| std::string | m_trig2018combination_diPhoton |
| |
| std::string | m_trig2022combination_diPhoton |
| |
| asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionTool > | m_trigGlobalEffCorrTool_diPhoton |
| |
| asg::AnaToolHandle< TrigConf::ITrigConfigTool > | m_trigConfTool |
| |
| asg::AnaToolHandle< Trig::TrigDecisionTool > | m_trigDecTool |
| |
| asg::AnaToolHandle< Trig::IMatchingTool > | m_trigMatchingTool |
| |
| asg::AnaToolHandle< Trig::IMatchScoringTool > | m_trigMatchScoringTool |
| |
| asg::AnaToolHandle< Trig::IMatchScoringTool > | m_trigDRScoringTool |
| |
| asg::AnaToolHandle< CP::IIsolationCorrectionTool > | m_isoCorrTool |
| |
| asg::AnaToolHandle< CP::IIsolationSelectionTool > | m_isoTool |
| |
| asg::AnaToolHandle< CP::IIsolationSelectionTool > | m_isoBaselineTool |
| |
| asg::AnaToolHandle< CP::IIsolationSelectionTool > | m_isoHighPtTool |
| |
| asg::AnaToolHandle< CP::IIsolationCloseByCorrectionTool > | m_isoCloseByTool |
| |
| asg::AnaToolHandle< CP::IPileupReweightingTool > | m_prwTool |
| |
| asg::AnaToolHandle< InDet::IInclusiveTrackFilterTool > | m_LRTuncTool |
| |
| asg::AnaToolHandle< ORUtils::IOverlapTool > | m_tauJetORtool |
| |
| ORUtils::ToolBox | m_orToolbox |
| |
| asg::AnaToolHandle< IWeightTool > | m_pmgSHnjetWeighter |
| |
| asg::AnaToolHandle< IWeightTool > | m_pmgSHnjetWeighterWZ |
| |
| std::string | m_eleIdBaselineDFName |
| |
| std::string | m_eleIdDFName |
| |
| std::string | m_photonIdBaselineDFName |
| |
| std::string | m_photonIdDFName |
| |
| std::string | m_jetCleanDFName |
| |
| SG::ConstAccessor< char > | m_acc_eleIdBaseline |
| |
| SG::ConstAccessor< char > | m_acc_eleId |
| |
| SG::ConstAccessor< char > | m_acc_photonIdBaseline |
| |
| SG::ConstAccessor< char > | m_acc_photonId |
| |
| SG::ConstAccessor< char > | m_acc_jetClean |
| |
|
| StatusCode | SUSYToolsInit () |
| |
| bool | emulateHLT (const std::string &triggerName) const |
| |
| bool | isTrigInTDT (std::scoped_lock< std::mutex > &lock, const std::string &triggerName) const |
| |
| Gaudi::Details::PropertyBase & | declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &) |
| | specialization for handling Gaudi::Property<SG::VarHandleKey> More...
|
| |
| Gaudi::Details::PropertyBase & | declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &) |
| | specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
|
| |
| Gaudi::Details::PropertyBase & | declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &) |
| | specialization for handling Gaudi::Property<SG::VarHandleBase> More...
|
| |
| Gaudi::Details::PropertyBase & | declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &) |
| | specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
|
| |
Definition at line 141 of file SUSYObjDef_xAOD.h.
◆ MetaStore_t
◆ MetaStorePtr_t
Type of the metadata store pointer in standalone mode.
Definition at line 68 of file AsgMetadataTool.h.
◆ StoreGateSvc_t
◆ DataSource
◆ 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.
320 m_slices(std::map<std::string,bool>()),
822 "FCLoose",
"FCTight",
826 "TightTrackOnly_VarRad",
"TightTrackOnly_FixedRad",
827 "Tight_VarRad",
"Loose_VarRad",
828 "PLVLoose",
"PLVTight",
829 "PLImprovedTight",
"PLImprovedVeryTight"
834 "PflowLoose_FixedRad",
"PflowLoose_VarRad",
"PflowTight_FixedRad",
"PflowTight_VarRad",
835 "TightTrackOnly_FixedRad",
"TightTrackOnly_VarRad",
"HighPtTrackOnly",
836 "PLVLoose",
"PLVTight",
837 "Loose_VarRad",
"Loose_FixedRad",
"Tight_VarRad",
"Tight_FixedRad",
838 "PLImprovedTight",
"PLImprovedVeryTight"
◆ ~SUSYObjDef_xAOD()
| ST::SUSYObjDef_xAOD::~SUSYObjDef_xAOD |
( |
| ) |
|
Definition at line 3136 of file SUSYObjDef_xAOD.cxx.
3138 #ifdef XAOD_STANDALONE
3144 if (asg::ToolStore::contains<Trig::TrigDecisionTool>(
"ToolSvc.TrigDecisionTool") ){
◆ ApplyLRTUncertainty()
| StatusCode ST::SUSYObjDef_xAOD::ApplyLRTUncertainty |
( |
| ) |
|
|
finaloverridevirtual |
◆ ApplyPRWTool()
| StatusCode ST::SUSYObjDef_xAOD::ApplyPRWTool |
( |
bool |
muDependentRRN = true | ) |
|
|
finaloverridevirtual |
◆ applySystematicVariation()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 2149 of file SUSYObjDef_xAOD.cxx.
2153 return StatusCode::FAILURE;
2156 ATH_MSG_DEBUG(
" in SUSYObjDef_xAOD::applySystematicVariation \"" << systConfig.
name() <<
"\" size " << systConfig.
size());
2163 if ( ret != StatusCode::SUCCESS) {
2164 ATH_MSG_VERBOSE(
"Cannot configure JetUncertaintiesTool for systematic var. " << systConfig.
name() );
2166 ATH_MSG_VERBOSE(
"Configured JetUncertaintiesTool for systematic var. " << systConfig.
name() );
2171 if ( ret != StatusCode::SUCCESS) {
2172 ATH_MSG_VERBOSE(
"Cannot configure JetUncertaintiesPDSmearTool for systematic var. " << systConfig.
name() );
2174 ATH_MSG_VERBOSE(
"Configured JetUncertaintiesPDSmearTool for systematic var. " << systConfig.
name() );
2179 if ( ret != StatusCode::SUCCESS) {
2180 ATH_MSG_VERBOSE(
"Cannot configure (Fat)JetUncertaintiesTool (WTag) for systematic var. " << systConfig.
name() );
2182 ATH_MSG_VERBOSE(
"Configured (Fat)JetUncertaintiesTool (WTag) for systematic var. " << systConfig.
name() );
2187 if ( ret != StatusCode::SUCCESS) {
2188 ATH_MSG_VERBOSE(
"Cannot configure (Fat)JetUncertaintiesTool (ZTag) for systematic var. " << systConfig.
name() );
2190 ATH_MSG_VERBOSE(
"Configured (Fat)JetUncertaintiesTool (ZTag) for systematic var. " << systConfig.
name() );
2196 if ( ret != StatusCode::SUCCESS) {
2197 ATH_MSG_VERBOSE(
"Cannot configure (Fat)JetUncertaintiesTool (TopTag) for systematic var. " << systConfig.
name() );
2199 ATH_MSG_VERBOSE(
"Configured (Fat)JetUncertaintiesTool (TopTag) for systematic var. " << systConfig.
name() );
2204 if ( ret != StatusCode::SUCCESS) {
2205 ATH_MSG_VERBOSE(
"Cannot configure (Fat)JetUncertaintiesTool (main) for systematic var. " << systConfig.
name() );
2207 ATH_MSG_VERBOSE(
"Configured (Fat)JetUncertaintiesTool (main) for systematic var. " << systConfig.
name() );
2212 if ( ret != StatusCode::SUCCESS) {
2213 ATH_MSG_VERBOSE(
"Cannot configure FatJetUncertaintiesPDSmearTool for systematic var. " << systConfig.
name() );
2215 ATH_MSG_VERBOSE(
"Configured FatJetUncertaintiesPDSmearTool for systematic var. " << systConfig.
name() );
2220 if ( ret != StatusCode::SUCCESS) {
2221 ATH_MSG_VERBOSE(
"Cannot configure (Fat)JetFFSmearingTool (main) for systematic var. " << systConfig.
name() );
2223 ATH_MSG_VERBOSE(
"Configured (Fat)JetFFSmearingTool (main) for systematic var. " << systConfig.
name() );
2228 if ( ret != StatusCode::SUCCESS) {
2229 ATH_MSG_VERBOSE(
"Cannot configure NNJvtEfficiency for systematic var. " << systConfig.
name() );
2236 if ( ret != StatusCode::SUCCESS) {
2237 ATH_MSG_VERBOSE(
"Cannot configure fJvtEfficiency for systematic var. " << systConfig.
name() );
2244 if (ret != StatusCode::SUCCESS) {
2245 ATH_MSG_ERROR(
"Cannot configure MuonCalibTool for systematic var. " << systConfig.
name() );
2253 if ( ret != StatusCode::SUCCESS) {
2254 ATH_MSG_ERROR(
"Cannot configure MuonEfficiencyScaleFactors for systematic var. " << systConfig.
name() );
2257 ATH_MSG_VERBOSE(
"MuonEfficiencyScaleFactors configured for systematic var. " << systConfig.
name() );
2262 if ( ret != StatusCode::SUCCESS) {
2263 ATH_MSG_ERROR(
"Cannot configure MuonBadMuonHighPtScaleFactors for systematic var. " << systConfig.
name() );
2266 ATH_MSG_VERBOSE(
"MuonBadMuonHighPtScaleFactors configured for systematic var. " << systConfig.
name() );
2271 if ( ret != StatusCode::SUCCESS) {
2272 ATH_MSG_ERROR(
"Cannot configure MuonTTVAEfficiencyScaleFactors for systematic var. " << systConfig.
name() );
2275 ATH_MSG_VERBOSE(
"MuonTTVAEfficiencyScaleFactors configured for systematic var. " << systConfig.
name() );
2280 if ( ret != StatusCode::SUCCESS) {
2281 ATH_MSG_ERROR(
"Cannot configure MuonIsolationScaleFactors for systematic var. " << systConfig.
name() );
2284 ATH_MSG_VERBOSE(
"MuonIsolationScaleFactors configured for systematic var. " << systConfig.
name() );
2289 if ( ret != StatusCode::SUCCESS) {
2290 ATH_MSG_ERROR(
"Cannot configure MuonTriggerScaleFactors for systematic var. " << systConfig.
name() );
2293 ATH_MSG_VERBOSE(
"MuonTriggerScaleFactors configured for systematic var. " << systConfig.
name() );
2298 if (ret != StatusCode::SUCCESS) {
2299 ATH_MSG_ERROR(
"Cannot configure AsgElectronEfficiencyCorrectionTool (reco) for systematic var. " << systConfig.
name() );
2302 ATH_MSG_VERBOSE(
"AsgElectronEfficiencyCorrectionTool (reco) configured for systematic var. " << systConfig.
name() );
2307 if (ret != StatusCode::SUCCESS) {
2308 ATH_MSG_ERROR(
"Cannot configure AsgElectronEfficiencyCorrectionTool (id) for systematic var. " << systConfig.
name() );
2311 ATH_MSG_VERBOSE(
"AsgElectronEfficiencyCorrectionTool (id) configured for systematic var. " << systConfig.
name() );
2316 if (ret != StatusCode::SUCCESS) {
2317 ATH_MSG_ERROR(
"Cannot configure AsgElectronEfficiencyCorrectionTool (trigger) for systematic var. " << systConfig.
name() );
2320 ATH_MSG_VERBOSE(
"AsgElectronEfficiencyCorrectionTool (trigger) configured for systematic var. " << systConfig.
name() );
2325 if (ret != StatusCode::SUCCESS) {
2326 ATH_MSG_ERROR(
"Cannot configure AsgElectronEfficiencyCorrectionTool (trigger SFTool) for systematic var. " << systConfig.
name() );
2329 ATH_MSG_VERBOSE(
"AsgElectronEfficiencyCorrectionTool (trigger SFTool) configured for systematic var. " << systConfig.
name() );
2335 StatusCode ret1 = sfop->applySystematicVariation(systConfig);
2336 if (ret1 != StatusCode::SUCCESS) {
ATH_MSG_ERROR(
"Cannot configure m_elecTrigEffTools (dilepton trigger) for systematic var. " << systConfig.
name() );
return ret1; }
2339 StatusCode ret1 = sfop->applySystematicVariation(systConfig);
2340 if (ret1 != StatusCode::SUCCESS) {
ATH_MSG_ERROR(
"Cannot configure m_elecTrigSFTools (dilepton trigger) for systematic var. " << systConfig.
name() );
return ret1; }
2343 StatusCode ret1 = sfop->applySystematicVariation(systConfig);
2344 if (ret1 != StatusCode::SUCCESS) {
ATH_MSG_ERROR(
"Cannot configure m_muonTrigSFTools (dilepton trigger) for systematic var. " << systConfig.
name() );
return ret1; }
2346 if (ret != StatusCode::SUCCESS) {
2347 ATH_MSG_ERROR(
"Cannot configure TrigGlobalEfficiencyCorrectionTool (dilepton trigger) for systematic var. " << systConfig.
name() );
2350 ATH_MSG_VERBOSE(
"TrigGlobalEfficiencyCorrectionTool (dilepton trigger) configured for systematic var. " << systConfig.
name() );
2356 StatusCode ret1 = sfop->applySystematicVariation(systConfig);
2357 if (ret1 != StatusCode::SUCCESS) {
ATH_MSG_ERROR(
"Cannot configure m_elecTrigEffTools (multilep trigger) for systematic var. " << systConfig.
name() );
return ret1; }
2360 StatusCode ret1 = sfop->applySystematicVariation(systConfig);
2361 if (ret1 != StatusCode::SUCCESS) {
ATH_MSG_ERROR(
"Cannot configure m_elecTrigSFTools (multilep trigger) for systematic var. " << systConfig.
name() );
return ret1; }
2364 StatusCode ret1 = sfop->applySystematicVariation(systConfig);
2365 if (ret1 != StatusCode::SUCCESS) {
ATH_MSG_ERROR(
"Cannot configure m_muonTrigSFTools (multilep trigger) for systematic var. " << systConfig.
name() );
return ret1; }
2367 if (ret != StatusCode::SUCCESS) {
2368 ATH_MSG_ERROR(
"Cannot configure TrigGlobalEfficiencyCorrectionTool (multi-lepton trigger) for systematic var. " << systConfig.
name() );
2371 ATH_MSG_VERBOSE(
"TrigGlobalEfficiencyCorrectionTool (multi-lepton trigger) configured for systematic var. " << systConfig.
name() );
2376 if (ret != StatusCode::SUCCESS) {
2377 ATH_MSG_ERROR(
"Cannot configure AsgElectronEfficiencyCorrectionTool (iso) for systematic var. " << systConfig.
name() );
2380 ATH_MSG_VERBOSE(
"AsgElectronEfficiencyCorrectionTool (iso) configured for systematic var. " << systConfig.
name() );
2385 if (ret != StatusCode::SUCCESS) {
2386 ATH_MSG_ERROR(
"Cannot configure AsgElectronEfficiencyCorrectionTool (iso high-pt) for systematic var. " << systConfig.
name() );
2389 ATH_MSG_VERBOSE(
"AsgElectronEfficiencyCorrectionTool (iso high-pt) configured for systematic var. " << systConfig.
name() );
2394 if (ret != StatusCode::SUCCESS) {
2395 ATH_MSG_ERROR(
"Cannot configure ElectronChargeEffCorrectionTool for systematic var. " << systConfig.
name() );
2398 ATH_MSG_VERBOSE(
"ElectronChargeEffCorrectionTool configured for systematic var. " << systConfig.
name() );
2403 if (ret != StatusCode::SUCCESS) {
2404 ATH_MSG_ERROR(
"Cannot configure AsgPhotonEfficiencyCorrectionTool (reco) for systematic var. " << systConfig.
name() );
2407 ATH_MSG_VERBOSE(
"AsgPhotonEfficiencyCorrectionTool (reco) configured for systematic var. " << systConfig.
name() );
2412 if (ret != StatusCode::SUCCESS) {
2413 ATH_MSG_ERROR(
"Cannot configure AsgPhotonEfficiencyCorrectionTool (iso) for systematic var. " << systConfig.
name() );
2416 ATH_MSG_VERBOSE(
"AsgPhotonEfficiencyCorrectionTool configured (iso) for systematic var. " << systConfig.
name() );
2421 if (ret != StatusCode::SUCCESS) {
2422 ATH_MSG_ERROR(
"Cannot configure AsgPhotonEfficiencyCorrectionTool (trigger) for systematic var. " << systConfig.
name() );
2425 ATH_MSG_VERBOSE(
"AsgPhotonEfficiencyCorrectionTool configured (trigger) for systematic var. " << systConfig.
name() );
2431 StatusCode ret1 = sfop->applySystematicVariation(systConfig);
2432 if (ret1 != StatusCode::SUCCESS) {
ATH_MSG_ERROR(
"Cannot configure m_photonTrigEffTools (diphoton trigger) for systematic var. " << systConfig.
name() );
return ret1; }
2435 StatusCode ret1 = sfop->applySystematicVariation(systConfig);
2436 if (ret1 != StatusCode::SUCCESS) {
ATH_MSG_ERROR(
"Cannot configure m_photonTrigSFTools (diphoton trigger) for systematic var. " << systConfig.
name() );
return ret1; }
2438 if (ret != StatusCode::SUCCESS) {
2439 ATH_MSG_ERROR(
"Cannot configure TrigGlobalEfficiencyCorrectionTool (diphoton trigger) for systematic var. " << systConfig.
name() );
2442 ATH_MSG_VERBOSE(
"TrigGlobalEfficiencyCorrectionTool (diphoton trigger) configured for systematic var. " << systConfig.
name() );
2447 if (ret != StatusCode::SUCCESS) {
2448 ATH_MSG_ERROR(
"Cannot configure EgammaCalibrationAndSmearingTool for systematic var. " << systConfig.
name() );
2451 ATH_MSG_VERBOSE(
"EgammaCalibrationAndSmearingTool configured for systematic var. " << systConfig.
name() );
2456 if (ret != StatusCode::SUCCESS) {
2457 ATH_MSG_ERROR(
"Cannot configure IsolationCorrectionTool for systematic var. " << systConfig.
name() );
2460 ATH_MSG_VERBOSE(
"IsolationCorrectionTool configured for systematic var. " << systConfig.
name() );
2466 if ( ret != StatusCode::SUCCESS) {
2467 ATH_MSG_ERROR(
"Cannot configure xAODBTaggingEfficiency for systematic var. " << systConfig.
name() );
2470 ATH_MSG_VERBOSE(
"Configured xAODBTaggingEfficiency for systematic var. " << systConfig.
name() );
2476 if ( ret != StatusCode::SUCCESS) {
2477 ATH_MSG_ERROR(
"Cannot configure xAODBTaggingEfficiency (track jets) for systematic var. " << systConfig.
name() );
2480 ATH_MSG_VERBOSE(
"Configured xAODBTaggingEfficiency (track jets) for systematic var. " << systConfig.
name() );
2485 if ( ret != StatusCode::SUCCESS) {
2486 ATH_MSG_ERROR(
"Cannot configure TauSmearingTool for systematic var. " << systConfig.
name() );
2494 if ( ret != StatusCode::SUCCESS) {
2495 ATH_MSG_ERROR(
"Cannot configure TauEfficiencyCorrectionsTool for systematic var. " << systConfig.
name() );
2498 ATH_MSG_VERBOSE(
"Configured TauEfficiencyCorrectionsTool for systematic var. " << systConfig.
name() );
2503 if (ret != StatusCode::SUCCESS) {
2504 ATH_MSG_ERROR(
"Cannot configure " <<
tool->name() <<
" for systematic var. " << systConfig.
name() );
2512 if ( ret != StatusCode::SUCCESS) {
2513 ATH_MSG_ERROR(
"Cannot configure METSystematicsTool for systematic var. " << systConfig.
name() );
2516 ATH_MSG_VERBOSE(
"Configured METSystematicsTool for systematic var. " << systConfig.
name() );
2521 if ( ret != StatusCode::SUCCESS) {
2522 ATH_MSG_ERROR(
"Cannot configure PileupReweightingTool for systematic var. " << systConfig.
name() );
2525 ATH_MSG_VERBOSE(
"Configured PileupReweightingTool for systematic var. " << systConfig.
name() );
2531 if ( ret != StatusCode::SUCCESS) {
2532 ATH_MSG_ERROR(
"Cannot configure InDetTrackFilterTool for systematic var. " << systConfig.
name() );
2535 ATH_MSG_VERBOSE(
"Configured InDetTrackFilterTool for systematic var. " << systConfig.
name() );
2539 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 1014 of file SUSYObjDef_xAOD.cxx.
1018 std::string prwConfigFile(
"");
1022 prwConfigFile = PRWfilesDir;
1026 std::string mcCampaignMD(
"");
1027 std::string simFlavour(
"");
1028 std::string simType(
"");
1033 std::map<std::string,std::vector<std::string>> PRWRtags = {};
1034 std::string allcampaigns =
"mc20a.mc20d.mc20e.mc21a.mc23a.mc23c.mc23d.mc23e";
1035 bool standard_like =
true;
1037 std::string icampaign = campaign_rtags.substr(0, campaign_rtags.find(
":"));
1038 std::vector<std::string> irtags =
split( campaign_rtags.substr(campaign_rtags.find(
":")+1),
"_" );
1039 PRWRtags[icampaign] = irtags;
1040 ATH_MSG_DEBUG(
"PRW autoconfigure considering rtags " << campaign_rtags.substr(campaign_rtags.find(
"_")+1) <<
" for campaign " << icampaign );
1042 for (
const auto&
x : PRWRtags ) {
1043 if ( allcampaigns.find(
x.first)==string::npos ) {
1046 return StatusCode::FAILURE;
1056 if(simFlavour.starts_with(
"ATLFASTII")) simType =
"AFII";
1057 else if(simFlavour.starts_with(
"ATLFAST3")) simType =
"AF3";
1058 else simType =
"FS";
1061 while ( mcCampaignMD.empty() ) {
1062 for (
const auto& campaign_rtags : PRWRtags ) {
1063 for (
const auto& rtag: campaign_rtags.second ) {
1064 if (
found)
continue;
1065 if (
amiTag.find(rtag)!=string::npos) {
1066 mcCampaignMD = campaign_rtags.first.substr(0,5);
1067 standard_like = (campaign_rtags.first.find(
"ns")?
true:
false);
1074 ATH_MSG_ERROR(
"autoconfigurePileupRWTool(): unrecognized xAOD::FileMetaData::amiTag, \'" <<
amiTag <<
"'. Please check your input sample.");
1075 return StatusCode::FAILURE;
1078 ATH_MSG_INFO(
"Setting up autoconfigurePileupRWTool for mc campaign " << mcCampaignMD <<
" (from amiTag " <<
amiTag <<
") (standard-like = " << (standard_like?
"true":
"false") <<
")." );
1079 if ( (!standard_like) && (!RPVLLmode) )
1080 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?");
1083 #ifndef XAOD_STANDALONE
1084 ATH_MSG_ERROR(
"autoconfigurePileupRWTool(): access to FileMetaData failed, can't get mc channel number.");
1085 return StatusCode::FAILURE;
1091 ATH_MSG_WARNING(
"autoconfigurePileupRWTool(): access to FileMetaData failed -> getting the mc channel number (DSID) and campaign from configuration." );
1092 std::string NoMetadataButPropertyOK(
"");
1093 NoMetadataButPropertyOK +=
"autoconfigurePileupRWTool(): 'mcCampaign' is used and passed to SUSYTools as '";
1095 NoMetadataButPropertyOK +=
"'. 'mcChannel' is used and passed to SUSYTools as '";
1097 NoMetadataButPropertyOK +=
"'. Autocongiguring PRW accordingly.";
1103 ATH_MSG_WARNING(
"autoconfigurePileupRWTool(): access to FileMetaData failed -> getting the mc channel number (DSID) from the event store." );
1107 std::string NoMetadataButPropertyOK(
"");
1108 NoMetadataButPropertyOK +=
"autoconfigurePileupRWTool(): 'mcCampaign' is used and passed to SUSYTools as '";
1110 NoMetadataButPropertyOK +=
"'. Autoconfiguring PRW accordingly.";
1115 ATH_MSG_ERROR(
"autoconfigurePileupRWTool(): `mcCampaign' is not set properly.");
1116 return StatusCode::FAILURE;
1123 ATH_MSG_INFO(
"autoconfigurePileupRWTool(): retrieving the common PRW file for MC campaign: " << mcCampaignMD );
1133 ATH_MSG_ERROR(
"autoconfigurePileupRWTool(): no common PRW file known for MC campaign: " << mcCampaignMD);
1134 return StatusCode::FAILURE;
1140 int DSID_INT =
static_cast<int>(
dsid);
1141 prwConfigFile +=
"DSID" +
std::to_string(DSID_INT/1000) +
"xxx/pileup_" + mcCampaignMD +
"_dsid" +
std::to_string(DSID_INT) +
"_" + simType +
".root";
1143 if (RPVLLmode) prwConfigFile = TString(prwConfigFile).ReplaceAll(
".root",
"_rpvll.root").Data();
1147 if (!PRWfileName.empty()) {
1148 prwConfigFile = PRWfilesDir + PRWfileName;
1149 ATH_MSG_INFO(
"autoconfigurePileupRWTool(): PRW file was specifed by user: " << prwConfigFile.data() );
1157 if (mcCampaignMD.find(
"mc20") == std::string::npos) {
1158 ATH_MSG_ERROR(
"autoconfigurePileupRWTool(): combined mode currently onlys supported for mc20! Impossible to autoconfigure PRW. Aborting." );
1159 return StatusCode::FAILURE;
1169 m_prwConfFiles.emplace_back( TString(prwConfigFile).ReplaceAll(mcCampaignMD,
"mc20a").
Data() );
1170 m_prwConfFiles.emplace_back( TString(prwConfigFile).ReplaceAll(mcCampaignMD,
"mc20d").
Data() );
1171 m_prwConfFiles.emplace_back( TString(prwConfigFile).ReplaceAll(mcCampaignMD,
"mc20e").
Data() );
1177 if ( mcCampaignMD ==
"mc20d") {
1179 }
else if (mcCampaignMD ==
"mc20e") {
1181 }
else if (mcCampaignMD ==
"mc21a" || mcCampaignMD ==
"mc23a") {
1183 }
else if (mcCampaignMD ==
"mc23c" || mcCampaignMD ==
"mc23d") {
1185 }
else if (mcCampaignMD ==
"mc23e") {
1193 TFile testF(prwConfigFile.data(),
"read");
1194 if (testF.IsZombie()) {
1195 ATH_MSG_ERROR(
"autoconfigurePileupRWTool(): file not found -> " << prwConfigFile.data() <<
" ! Impossible to autoconfigure PRW. Aborting." );
1196 if ( (!standard_like) && (!RPVLLmode) )
1197 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?");
1198 return StatusCode::FAILURE;
1201 ATH_MSG_INFO(
"autoconfigurePileupRWTool(): configuring PRW tool using " << prwConfigFile.data() );
1204 return StatusCode::SUCCESS;
◆ beginEvent()
| StatusCode asg::AsgMetadataTool::beginEvent |
( |
| ) |
|
|
protectedvirtualinherited |
Function called when a new events is loaded.
Dummy implementation that can be overridden by the derived tool.
Reimplemented in AsgElectronEfficiencyCorrectionTool, TrigConf::xAODConfigTool, TauAnalysisTools::TauSelectionTool, TauAnalysisTools::DiTauSelectionTool, TauAnalysisTools::CommonSmearingTool, TauAnalysisTools::DiTauEfficiencyCorrectionsTool, Trig::TrigDecisionTool, TauAnalysisTools::TauEfficiencyCorrectionsTool, Trig::TrigConfBunchCrossingTool, xAODMaker::TriggerMenuMetaDataTool, and Trig::xAODBunchCrossingTool.
Definition at line 201 of file AsgMetadataTool.cxx.
204 return StatusCode::SUCCESS;
◆ beginInputFile()
| StatusCode asg::AsgMetadataTool::beginInputFile |
( |
| ) |
|
|
protectedvirtualinherited |
Function called when a new input file is opened.
Dummy implementation that can be overridden by the derived tool.
Reimplemented in AsgElectronEfficiencyCorrectionTool, TrigConf::xAODConfigTool, PMGTools::PMGTruthWeightTool, BookkeeperTool, BookkeeperDumperTool, Trig::TrigDecisionTool, xAODMaker::TriggerMenuMetaDataTool, xAODMaker::TruthMetaDataTool, Trig::xAODBunchCrossingTool, TauAnalysisTools::TauEfficiencyCorrectionsTool, and TauAnalysisTools::TauSmearingTool.
Definition at line 185 of file AsgMetadataTool.cxx.
188 return StatusCode::SUCCESS;
◆ BtagSF()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 827 of file Jets.cxx.
834 if ( std::abs(
jet->eta()) > 2.5 ) {
835 ATH_MSG_VERBOSE(
"Trying to retrieve b-tagging SF for jet with |eta|>2.5 (jet eta=" <<
jet->eta() <<
"), jet will be skipped");
836 }
else if (
jet->pt() < 20
e3 ){
837 ATH_MSG_VERBOSE(
"Trying to retrieve b-tagging SF for jet with invalid pt (jet pt=" <<
jet->pt() <<
"), jet will be skipped");
842 if (!
jet->getAttribute(
"HadronConeExclTruthLabelID", truthlabel)) {
853 ATH_MSG_ERROR(
"Failed to retrieve SF for b-tagged jets in SUSYTools_xAOD::BtagSF" );
856 ATH_MSG_VERBOSE(
"No valid SF for b-tagged jets in SUSYTools_xAOD::BtagSF" );
859 ATH_MSG_VERBOSE(
"Retrieve SF for b-tagged jets in SUSYTools_xAOD::BtagSF with value " <<
sf );
867 ATH_MSG_ERROR(
"Failed to retrieve SF for non-b-tagged jets in SUSYTools_xAOD::BtagSF" );
870 ATH_MSG_VERBOSE(
"No valid inefficiency SF for non-b-tagged jets in SUSYTools_xAOD::BtagSF" );
873 ATH_MSG_VERBOSE(
"Retrieve SF for non-b-tagged jets in SUSYTools_xAOD::BtagSF with value " <<
sf );
878 dec_effscalefact(*
jet) =
sf;
880 if( acc_signal(*
jet) && acc_passOR(*
jet) ) totalSF *=
sf;
◆ BtagSF_trkJet()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 908 of file Jets.cxx.
911 for (
const xAOD::Jet* trkjet : *trkjets ) {
915 if ( std::abs(trkjet->eta()) > 2.5 ) {
916 ATH_MSG_VERBOSE(
"Trying to retrieve b-tagging SF for trkjet with |eta|>2.5 (trkjet eta=" << trkjet->eta() <<
"), trkjet will be skipped");
917 }
else if ( trkjet->pt() < 10
e3 ){
918 ATH_MSG_VERBOSE(
"Trying to retrieve b-tagging SF for trkjet with invalid pt (trkjet pt=" << trkjet->pt() <<
"), jet will be skipped");
923 if (!trkjet->getAttribute(
"HadronConeExclTruthLabelID", truthlabel)) {
926 ATH_MSG_VERBOSE(
"This jet is " << (acc_bjet(*trkjet) ?
"" :
"not ") <<
"b-tagged.");
929 if ( acc_bjet(*trkjet) ) {
934 ATH_MSG_ERROR(
"Failed to retrieve SF for b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet" );
937 ATH_MSG_VERBOSE(
"No valid SF for b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet" );
940 ATH_MSG_VERBOSE(
"Retrieve SF for b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet with value " <<
sf );
948 ATH_MSG_ERROR(
"Failed to retrieve SF for non-b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet" );
951 ATH_MSG_VERBOSE(
"No valid inefficiency SF for non-b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet" );
954 ATH_MSG_VERBOSE(
"Retrieve SF for non-b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet with value " <<
sf );
959 dec_effscalefact(*trkjet) =
sf;
961 if( acc_signal(*trkjet) ) totalSF *=
sf;
◆ BtagSFsys()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 888 of file Jets.cxx.
894 if ( ret != StatusCode::SUCCESS) {
895 ATH_MSG_ERROR(
"Cannot configure BTaggingEfficiencyTool for systematic var. " << systConfig.
name() );
901 if ( ret != StatusCode::SUCCESS) {
902 ATH_MSG_ERROR(
"Cannot configure BTaggingEfficiencyTool for systematic var. " << systConfig.
name() );
◆ BtagSFsys_trkJet()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 969 of file Jets.cxx.
975 if ( ret != StatusCode::SUCCESS) {
976 ATH_MSG_ERROR(
"Cannot configure BTaggingEfficiencyTool (track jets) for systematic var. " << systConfig.
name() );
982 if ( ret != StatusCode::SUCCESS) {
983 ATH_MSG_ERROR(
"Cannot configure BTaggingEfficiencyTool (track jets) for systematic var. " << systConfig.
name() );
◆ check_isOption()
| bool ST::SUSYObjDef_xAOD::check_isOption |
( |
const std::string & |
wp, |
|
|
const std::vector< std::string > & |
list |
|
) |
| const |
|
protected |
◆ check_isTighter()
| bool ST::SUSYObjDef_xAOD::check_isTighter |
( |
const std::string & |
wp1, |
|
|
const std::string & |
wp, |
|
|
const std::vector< std::string > & |
list |
|
) |
| const |
|
protected |
◆ configFromFile() [1/4]
| void ST::SUSYObjDef_xAOD::configFromFile |
( |
bool & |
property, |
|
|
const std::string & |
propname, |
|
|
TEnv & |
rEnv, |
|
|
bool |
defaultValue |
|
) |
| |
|
protected |
Definition at line 1258 of file SUSYObjDef_xAOD.cxx.
1262 ATH_MSG_INFO(
"configFromFile(): property \"" << propname <<
"\" already set with value " << property <<
". Ignoring change request." );
1263 rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(propname.c_str() ) );
1266 property = rEnv.GetValue(propname.c_str(),
static_cast<int>(defaultValue));
1267 ATH_MSG_INFO(
"configFromFile(): Loaded property \"" << propname <<
"\" with value " << property );
1269 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 1273 of file SUSYObjDef_xAOD.cxx.
1277 if (property > -90.) {
1278 ATH_MSG_INFO(
"configFromFile(): property \"" << propname <<
"\" already set with value " << property <<
". Ignoring change request." );
1279 rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(propname.c_str() ) );
1282 property = rEnv.GetValue(propname.c_str(), defaultValue);
1283 ATH_MSG_INFO(
"configFromFile(): Loaded property \"" << propname <<
"\" with value " << property );
1285 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 1289 of file SUSYObjDef_xAOD.cxx.
1293 if (property > -90){
1294 ATH_MSG_INFO(
"configFromFile(): property \"" << propname <<
"\" already set with value " << property <<
". Ignoring change request." );
1295 rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(propname.c_str() ) );
1298 property = rEnv.GetValue(propname.c_str(), defaultValue);
1299 ATH_MSG_INFO(
"configFromFile(): Loaded property \"" << propname <<
"\" with value " << property );
1301 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 1305 of file SUSYObjDef_xAOD.cxx.
1309 if (!property.empty()){
1310 ATH_MSG_INFO(
"configFromFile(): property \"" << propname <<
"\" already set with value " << property <<
". Ignoring change request." );
1311 rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(propname.c_str() ) );
1314 property = rEnv.GetValue(propname.c_str(), defaultValue.c_str());
1315 if (property.empty() && !allowEmpty) {
1316 ATH_MSG_FATAL(
"Read empty string property from text file (property name: " << propname <<
")");
1320 std::string tmp_prop =
property.substr(0, property.find(
'#', 0));
1321 property = TString(tmp_prop).ReplaceAll(
" ",
"").Data();
1324 if (property==
"None" || property==
"NONE" || property==
"none") {
1325 ATH_MSG_VERBOSE(
"Property \"" << propname <<
"\" being set to empty string due to specification of \"" << property <<
"\"" );
1329 ATH_MSG_INFO(
"configFromFile(): Loaded property \"" << propname <<
"\" with value " << property );
1331 rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(propname.c_str() ) );
◆ currentSystematic()
◆ currentSystematicIsNominal()
| bool ST::SUSYObjDef_xAOD::currentSystematicIsNominal |
( |
| ) |
const |
◆ currentSystematicIsVariation()
| bool ST::SUSYObjDef_xAOD::currentSystematicIsVariation |
( |
| ) |
const |
◆ currentSystematicIsWeight()
| bool ST::SUSYObjDef_xAOD::currentSystematicIsWeight |
( |
| ) |
const |
◆ declareGaudiProperty() [1/4]
specialization for handling Gaudi::Property<SG::VarHandleKeyArray>
Definition at line 170 of file AthCommonDataStore.h.
175 hndl.documentation());
◆ declareGaudiProperty() [2/4]
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition at line 156 of file AthCommonDataStore.h.
161 hndl.documentation());
◆ declareGaudiProperty() [3/4]
specialization for handling Gaudi::Property<SG::VarHandleBase>
Definition at line 184 of file AthCommonDataStore.h.
189 hndl.documentation());
◆ declareGaudiProperty() [4/4]
◆ declareProperty() [1/6]
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.
250 this->declare(hndl.
vhKey());
251 hndl.
vhKey().setOwner(
this);
253 return PBASE::declareProperty(
name,hndl,
doc);
◆ declareProperty() [2/6]
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.
229 return PBASE::declareProperty(
name,hndl,
doc);
◆ declareProperty() [3/6]
◆ declareProperty() [4/6]
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.
338 return PBASE::declareProperty(
name, property,
doc);
◆ declareProperty() [5/6]
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.
◆ declareProperty() [6/6]
◆ detStore()
◆ EG_WP()
| std::string ST::SUSYObjDef_xAOD::EG_WP |
( |
const std::string & |
wp | ) |
const |
|
protected |
Definition at line 1227 of file SUSYObjDef_xAOD.cxx.
1230 TString
copy = TString(
wp).Copy().ReplaceAll(
"AndBLayer",
"BL").ReplaceAll(
"LLH",
"LHElectron");
1232 if (
wp.find(
"DNNnoCF") != std::string::npos)
1233 copy.ReplaceAll(
"DNNnoCF",
"DNNnoCFElectron");
1234 else if (
wp.find(
"DNN") != std::string::npos)
1235 copy.ReplaceAll(
"DNN",
"DNNElectron");
◆ emulateHLT()
| bool ST::SUSYObjDef_xAOD::emulateHLT |
( |
const std::string & |
triggerName | ) |
const |
|
private |
Definition at line 97 of file Trigger.cxx.
100 auto funcItr = m_metTriggerFuncs.find(triggerName);
101 if (funcItr != m_metTriggerFuncs.end() )
102 return funcItr->second();
105 if (triggerName.substr(0,6) !=
"HLT_xe") {
106 ATH_MSG_ERROR(
"Requested trigger " << triggerName <<
" isn't a MET trigger! (HLT MET items should begin with 'HLT_xe'). Will return false." );
111 std::vector<std::pair<int, std::string> > hypos;
112 std::string temp(triggerName);
115 auto pos = temp.find(
"_AND_");
116 std::string itemName = temp.substr(0,
pos);
118 if (
pos == std::string::npos)
121 temp = temp.substr(
pos + 5);
123 std::regex expr(
"HLT_xe([[:digit:]]+)_?(mht|pufit|pueta|tc_lcw|)_?(?:L1XE([[:digit:]]+)|)");
125 if (!std::regex_match(itemName, sm, expr) ) {
126 ATH_MSG_WARNING(
"Regex reading for item " << itemName <<
" (" << triggerName <<
") failed! Will be ignored!" );
130 ATH_MSG_WARNING(
"Regex failed to capture the right groups for item " << itemName <<
" (" << triggerName <<
") failed! Will be ignored!" );
131 for (
unsigned int ii = 0; ii < sm.size(); ++ii) {
137 std::string algKey = sm[2];
138 std::string metContBaseName =
"HLT_xAOD__TrigMissingETContainer_TrigEFMissingET";
139 if (algKey.empty()) hypos.push_back(std::make_pair(
threshold, metContBaseName) );
140 else if (algKey ==
"mht") hypos.push_back(std::make_pair(
threshold, metContBaseName+
"_mht") );
141 else if (algKey ==
"pufit") hypos.push_back(std::make_pair(
threshold, metContBaseName+
"_topocl_PUC") );
142 else if (algKey ==
"pueta") hypos.push_back(std::make_pair(
threshold, metContBaseName+
"_topocl_PS") );
143 else if (algKey ==
"tc_lcw") hypos.push_back(std::make_pair(
threshold, metContBaseName+
"topocl") );
145 ATH_MSG_DEBUG(
"Container: " << hypos.back().second <<
", Threshold: " << hypos.back().first );
147 if (sm[3] !=
"" && sm[3] !=
"50") {
148 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" );
152 while (!temp.empty());
156 std::function<
bool()> lambda;
157 bool hasRequired =
true;
158 if (hypos.empty()) lambda = [] () {
return false;};
160 for (
const auto& pair : hypos) {
162 auto lambda_hypo = [
this, pair] () {
165 if (cont->empty())
return false;
166 float ex = cont->front()->ex() * 0.001;
167 float ey = cont->front()->ey() * 0.001;
168 float met = std::sqrt(ex*ex + ey*ey);
169 return met > pair.first;
177 lambda = [lambda, lambda_hypo] () {
178 return lambda() && lambda_hypo();
182 lambda = lambda_hypo;
192 m_metTriggerFuncs[triggerName] = lambda;
193 return m_metTriggerFuncs.at(triggerName)();
196 std::vector<std::string> replacementTriggers({
"HLT_xe110_mht_L1XE50",
"HLT_xe100_mht_L1XE50",
"HLT_xe90_mht_L1XE50",
"HLT_xe70_mht"});
197 for (
const std::string& trigName : replacementTriggers) {
199 ATH_MSG_WARNING(
"Trigger " << triggerName <<
" not available and direct emulation impossible! Will use " << trigName <<
" instead!");
200 m_metTriggerFuncs[triggerName] = [
this, trigName] () {
203 return m_metTriggerFuncs.at(triggerName)();
206 ATH_MSG_ERROR(
"Cannot find the trigger in the menu, direct emulation is impossible and no replacement triggers are available! Will return false" );
207 m_metTriggerFuncs.at(triggerName) = [] () {
return false;};
208 return m_metTriggerFuncs.at(triggerName)();
◆ endInputFile()
| StatusCode asg::AsgMetadataTool::endInputFile |
( |
| ) |
|
|
protectedvirtualinherited |
◆ evtStore() [1/2]
◆ evtStore() [2/2]
◆ extraDeps_update_handler()
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()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 223 of file Electrons.cxx.
229 dec_baseline(input) =
false;
230 dec_selected(input) = 0;
231 dec_signal(input) =
false;
232 dec_isol(input) =
false;
233 dec_isolHighPt(input) =
false;
234 dec_passSignalID(input) =
false;
235 dec_passChID(input) =
false;
236 dec_ecisBDT(input) = -999.;
243 ATH_MSG_DEBUG(
"No primary track particle for this electron. Skipping.");
244 return StatusCode::SUCCESS;
246 double primvertex_z =
pv ?
pv->z() : 0;
247 double el_z0 =
track->z0() +
track->vz() - primvertex_z;
248 dec_z0sinTheta(input) = el_z0 * TMath::Sin(
input.p4().Theta());
254 float d0sigError = -99.;
255 ATH_MSG_WARNING(
"FillElectron : Exception catched from d0significance() calculation. Setting dummy decoration d0sig=" << d0sigError );
256 dec_d0sig(input) = d0sigError;
260 if (
input.pt() < 4
e3 )
return StatusCode::SUCCESS;
261 if ( !
input.caloCluster() ) {
ATH_MSG_WARNING(
"FillElectron: no caloCluster found: " <<
input.caloCluster() );
return StatusCode::SUCCESS; }
267 unsigned char el_nPixHits(0), el_nSCTHits(0);
280 ATH_MSG_INFO(
"ELECTRON nPixHits: " <<
static_cast<int>(el_nPixHits));
281 ATH_MSG_INFO(
"ELECTRON nSCTHits: " <<
static_cast<int>(el_nSCTHits));
282 ATH_MSG_INFO(
"ELECTRON deadHVTools: " <<
static_cast<bool>(pass_deadHVTool));
285 if (!pass_deadHVTool)
return StatusCode::SUCCESS;
290 return StatusCode::FAILURE;
293 bool passBaseID =
false;
300 ATH_MSG_VERBOSE (
"DFCommonElectronsLHxxx variables are not found. Calculating the ID from LH tool..");
311 if (std::abs(
input.caloCluster()->etaBE(2)) >= etacut)
return StatusCode::SUCCESS;
314 if ( std::abs(
input.caloCluster()->etaBE(2) ) >1.37 && std::abs(
input.caloCluster()->etaBE(2) ) <1.52) {
315 return StatusCode::SUCCESS;
321 ATH_MSG_ERROR(
"FillElectron: EgammaCalibTool applyCorrection failed ");
324 ATH_MSG_ERROR(
"FillElectron: IsolationCorrectionTool applyCorrection failed");
328 if (
input.pt() < etcut)
return StatusCode::SUCCESS;
336 dec_baseline(input) =
true;
337 dec_selected(input) = 2;
345 dec_passChID(input) = acc_passECIDS(input);
353 dec_passChID(input) =
true;
358 return StatusCode::SUCCESS;
◆ FillJet()
| StatusCode ST::SUSYObjDef_xAOD::FillJet |
( |
xAOD::Jet & |
input, |
|
|
const bool |
doCalib = true, |
|
|
bool |
isFat = false, |
|
|
bool |
doLargeRdecorations = false |
|
) |
| |
|
finaloverridevirtual |
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 384 of file Jets.cxx.
403 dec_bad(input) =
false;
404 dec_signal(input) =
false;
405 dec_bjet_loose(input) =
false;
406 dec_effscalefact(input) = 1.;
407 dec_passOR(input) =
true;
408 dec_bjet_jetunc(input) =
false;
409 dec_btag_weight(input) = -999.;
411 dec_wtagged(input) = -1;
412 dec_ztagged(input) = -1;
413 dec_toptagged(input) = -1;
414 if (doLargeRdecorations) {
420 if ( !acc_wValidKinRange(input) ) {
421 ATH_MSG_VERBOSE(
"Large-R W candidate jet outside of recommended tagging range. Will set score to 0.");
422 dec_wtagged(input) = 0;
424 else dec_wtagged(input) = acc_wtagged(input);
429 if ( !acc_zValidKinRange(input) ) {
430 ATH_MSG_VERBOSE(
"Large-R Z candidate jet outside of recommended tagging range. Will set score to 0.");
431 dec_ztagged(input) = 0;
433 else dec_ztagged(input) = acc_ztagged(input);
438 if ( !acc_topValidKinRange(input) ) {
439 ATH_MSG_VERBOSE(
"Large-R Top candidate jet outside of recommended tagging range. Will set score to 0.");
440 dec_toptagged(input) = 0;
442 else dec_toptagged(input) = acc_toptagged(input);
453 ATH_MSG_ERROR(
"Failed to apply largeR W-tag jet scale uncertainties.");
454 return StatusCode::FAILURE;
457 ATH_MSG_VERBOSE(
"No valid pt/eta/m range for largeR W-tag jet scale uncertainties. ");
463 ATH_MSG_DEBUG(
"No valid large-R W-tagged fat jet uncertainty, but FillJet called with a fat jet. Skipping uncertainties." );
470 ATH_MSG_ERROR(
"Failed to apply largeR Z-tag jet scale uncertainties.");
471 return StatusCode::FAILURE;
474 ATH_MSG_VERBOSE(
"No valid pt/eta/m range for largeR Z-tag jet scale uncertainties. ");
480 ATH_MSG_DEBUG(
"No valid large-R Z-tagged fat jet uncertainty, but FillJet called with a fat jet. Skipping uncertainties." );
487 ATH_MSG_ERROR(
"Failed to apply largeR Top-tag jet scale uncertainties.");
488 return StatusCode::FAILURE;
491 ATH_MSG_VERBOSE(
"No valid pt/eta/m range for largeR Top-tag jet scale uncertainties. ");
497 ATH_MSG_DEBUG(
"No valid large-R Top-tagged fat jet uncertainty, but FillJet called with a fat jet. Skipping uncertainties." );
504 ATH_MSG_ERROR(
"Failed to apply largeR jet scale uncertainties.");
505 return StatusCode::FAILURE;
508 ATH_MSG_VERBOSE(
"No valid pt/eta/m range for largeR jet scale uncertainties. ");
514 ATH_MSG_DEBUG(
"No valid fat jet uncertainty, but FillJet called with a fat jet. Skipping uncertainties." );
522 ATH_MSG_ERROR(
"Failed to apply largeR jet scale PD uncertainties.");
523 return StatusCode::FAILURE;
526 ATH_MSG_VERBOSE(
"No valid pt/eta/m range for largeR jet scale uncertainties. ");
532 ATH_MSG_DEBUG(
"No valid fat jet uncertainty, but FillJet called with a fat jet. Skipping uncertainties." );
539 ATH_MSG_ERROR(
"Failed to apply largeR jet scale uncertainties.");
540 return StatusCode::FAILURE;
543 ATH_MSG_VERBOSE(
"No valid pt/eta/m range for largeR jet scale uncertainties. ");
549 ATH_MSG_DEBUG(
"No valid fat jet uncertainty, but FillJet called with a fat jet. Skipping uncertainties." );
554 return StatusCode::SUCCESS;
560 dec_passOR(input) =
true;
561 dec_bjet_jetunc(input) =
false;
610 dec_bad(input) =
false;
611 dec_signal_less_JVT(input) =
false;
612 dec_signal(input) =
false;
613 dec_bjet_loose(input) =
false;
614 dec_effscalefact(input) = 1.;
617 if (acc_baseline(input) ){
618 if( acc_passJvt(input) ) dec_selected(input) = 2;
619 else dec_selected(input) = 1;
622 dec_selected(input) = 0;
641 return StatusCode::SUCCESS;
◆ FillMuon()
| StatusCode ST::SUSYObjDef_xAOD::FillMuon |
( |
xAOD::Muon & |
input, |
|
|
const float |
ptcut, |
|
|
const float |
etacut |
|
) |
| |
|
finaloverridevirtual |
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 208 of file Muons.cxx.
212 dec_baseline(input) =
false;
213 dec_selected(input) = 0;
214 dec_signal(input) =
false;
215 dec_isol(input) =
false;
216 dec_isolHighPt(input) =
false;
217 dec_passedHighPtCuts(input) =
false;
218 dec_passSignalID(input) =
false;
221 dec_DFCommonJetDr(input) = -2.0;
222 }
else if (!acc_DFCommonJetDr.
isAvailable(input)) {
223 dec_dRJet(input) = -2.0;
227 if (
input.pt() < 3
e3 )
return StatusCode::SUCCESS;
244 double primvertex_z =
pv ?
pv->z() : 0;
247 if (
input.muonType() == xAOD::Muon::SiliconAssociatedForwardMuon) {
248 track =
input.trackParticle(xAOD::Muon::CombinedTrackParticle);
249 if (!
track)
return StatusCode::SUCCESS;
257 dec_z0sinTheta(input) = (
track->z0() +
track->vz() - primvertex_z) * TMath::Sin(
input.p4().Theta());
266 dec_d0sig(input) = -99.;
269 float d0sigError = -99.;
270 ATH_MSG_WARNING(
"FillMuon : Exception caught from d0significance() calculation. Setting dummy decoration d0sig=" << d0sigError );
271 dec_d0sig(input) = d0sigError;
301 ATH_MSG_INFO(
"MUON bHit: " <<
static_cast<int>( nBLHits ));
302 ATH_MSG_INFO(
"MUON pHit: " <<
static_cast<int>( nPixHits ));
304 ATH_MSG_INFO(
"MUON pHole:" <<
static_cast<int>( nPixHoles ));
309 ATH_MSG_INFO(
"MUON tOut: " <<
static_cast<int>( nTRTOutliers ));
312 input.trackParticle( xAOD::Muon::InnerDetectorTrackParticle );
323 if (
input.pt() <=
ptcut || std::abs(
input.eta()) >= etacut)
return StatusCode::SUCCESS;
331 dec_baseline(input) =
true;
332 dec_selected(input) = 2;
340 return StatusCode::SUCCESS;
◆ FillPhoton()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 78 of file Photons.cxx.
82 if ( !
input.caloCluster() ) {
84 return StatusCode::SUCCESS;
98 ATH_MSG_INFO(
"PHOTON deadHVTools: " << pass_deadHVTool );
101 dec_baseline(input) =
false;
102 dec_selected(input) = 0;
103 dec_isol(input) =
false;
106 if (!pass_deadHVTool)
return StatusCode::SUCCESS;
110 return StatusCode::SUCCESS;
113 if (std::abs(
input.caloCluster()->etaBE(2)) >= etacut)
return StatusCode::SUCCESS;
116 if ( std::abs(
input.caloCluster()->etaBE(2) ) >1.37 && std::abs(
input.caloCluster()->etaBE(2) ) <1.52) {
117 return StatusCode::SUCCESS;
122 ATH_MSG_ERROR(
"FillPhoton: EgammaCalibTool applyCorrection failed");
125 ATH_MSG_ERROR(
"FillPhoton: IsolationCorrectionTool applyCorrection failed");
129 if (
input.pt() <
ptcut)
return StatusCode::SUCCESS;
133 return StatusCode::SUCCESS;
136 bool passPhCleaning =
false;
137 if (acc_passPhCleaning.isAvailable(input) && acc_passPhCleaningNoTime.isAvailable(input)) {
144 if (!passPhCleaning)
return StatusCode::SUCCESS;
147 bool passBaseID =
false;
153 if (!passBaseID)
return StatusCode::SUCCESS;
158 dec_baseline(input) =
true;
159 dec_selected(input) = 2;
163 return StatusCode::SUCCESS;
◆ FillTau()
| StatusCode ST::SUSYObjDef_xAOD::FillTau |
( |
xAOD::TauJet & |
input | ) |
|
|
finaloverridevirtual |
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 77 of file Taus.cxx.
87 if (std::abs(
input.eta()) <= 2.5 &&
input.nTracks() > 0) {
101 dec_baseline(input) =
false;
103 if (acc_baseline(input)) dec_selected(input) = 2;
104 else dec_selected(input) = 0;
106 if (acc_baseline(input))
ATH_MSG_VERBOSE(
"FillTau: passed baseline selection");
108 return StatusCode::SUCCESS;
◆ FillTrackJet()
| StatusCode ST::SUSYObjDef_xAOD::FillTrackJet |
( |
xAOD::Jet & |
input | ) |
|
|
finaloverridevirtual |
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 644 of file Jets.cxx.
648 dec_btag_weight(input) = -999.;
649 dec_effscalefact(input) = 1.;
654 dec_baseline(input) =
input.pt() >= 5
e3 &&
input.numConstituents() >= 2;
656 ATH_MSG_WARNING (
"The pt threshold of VR jets you set is: " <<
m_trkJetPt/1000. <<
" GeV. But VR jets with pt < 10GeV are uncalibrated.");
659 dec_passDRcut(input) = acc_signal(input);
662 dec_signal(input) = acc_baseline(input);
677 return StatusCode::SUCCESS;
◆ FindSusyHardProc() [1/2]
| bool ST::SUSYObjDef_xAOD::FindSusyHardProc |
( |
const xAOD::TruthEvent * |
truthE, |
|
|
int & |
pdgid1, |
|
|
int & |
pdgid2 |
|
) |
| |
|
static |
Definition at line 227 of file Truth.cxx.
243 if (
tp->nParents() != 0) {
247 }
else if (!secondsp) {
271 if (!firstsp && !secondsp)
return true;
273 if (firstsp->nChildren() == 1) {
283 if (secondsp->nChildren() == 1) {
293 if (
MC::isSUSY(firstsp)) pdgid1 = firstsp->pdgId();
294 if (
MC::isSUSY(secondsp)) pdgid2 = secondsp->pdgId();
◆ FindSusyHardProc() [2/2]
Definition at line 126 of file Truth.cxx.
133 if(!truthP || truthP->
size()<2){
138 pdgid1 = (*truthP)[0]->pdgId();
139 pdgid2 = (*truthP)[1]->pdgId();
147 if (!truthP || truthP->
empty()) {
153 if (
tp->nParents() != 0) {
158 }
else if (!secondsp) {
182 if (!firstsp && !secondsp)
return true;
184 if (firstsp->nChildren() == 1) {
193 if (secondsp->nChildren() == 1) {
202 if (
MC::isSUSY(firstsp)) pdgid1 = firstsp->pdgId();
203 if (
MC::isSUSY(secondsp)) pdgid2 = secondsp->pdgId();
◆ FindSusyHP() [1/3]
| StatusCode ST::SUSYObjDef_xAOD::FindSusyHP |
( |
const xAOD::TruthEvent * |
truthE, |
|
|
int & |
pdgid1, |
|
|
int & |
pdgid2 |
|
) |
| const |
|
finaloverridevirtual |
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 210 of file Truth.cxx.
214 return StatusCode::FAILURE;
218 return StatusCode::FAILURE;
220 if (pdgid1 == 0 || pdgid2 == 0) {
223 return StatusCode::SUCCESS;
◆ FindSusyHP() [2/3]
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 106 of file Truth.cxx.
109 return StatusCode::FAILURE;
111 if (truthP->
empty()) {
113 return StatusCode::FAILURE;
117 return StatusCode::FAILURE;
119 if (pdgid1 == 0 || pdgid2 == 0) {
122 return StatusCode::SUCCESS;
◆ FindSusyHP() [3/3]
| StatusCode ST::SUSYObjDef_xAOD::FindSusyHP |
( |
int & |
pdgid1, |
|
|
int & |
pdgid2 |
|
) |
| const |
Definition at line 76 of file Truth.cxx.
79 bool isTruth3 =
false;
80 std::string key_T1 =
"TruthParticles";
81 std::string key_T3 =
"TruthBSM";
83 ATH_MSG_DEBUG(
"Contains " << key_T1 <<
": " << ((
evtStore()->contains<xAOD::TruthParticleContainer>( key_T1 ))?1:0));
84 ATH_MSG_DEBUG(
"Contains " << key_T3 <<
": " << ((
evtStore()->contains<xAOD::TruthParticleContainer>( key_T3 ))?1:0));
86 if(
evtStore()->contains<xAOD::TruthParticleContainer>( key_T1 )){
89 if (truthP->
empty()) {
ATH_MSG_WARNING(key_T1 <<
" is empty. Skipping FindSusyHP.");
return StatusCode::SUCCESS; }
91 else if(
evtStore()->contains<xAOD::TruthParticleContainer>( key_T3 )){
95 if (truthP->
empty()) {
ATH_MSG_WARNING(key_T3 <<
" is empty. Skipping FindSusyHP.");
return StatusCode::SUCCESS; }
98 ATH_MSG_WARNING(
"Neither " << key_T1 <<
" nor " << key_T3 <<
" are avaible. Skipping FindSusyHP.");
99 return StatusCode::SUCCESS;
◆ FJVT_SF()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 1061 of file Jets.cxx.
1069 if (acc_signal_less_JVT(*
jet) && acc_passOR(*
jet)) {
1070 fjvtjets.push_back(
jet);
1075 float current_sf = 0;
1079 if (acc_passFJvt(*
jet)) {
1093 ATH_MSG_VERBOSE(
"Skip SF application in SUSYTools_xAOD::FJVT_SF as jet outside validate range" );
1096 ATH_MSG_VERBOSE(
"Retrieve SF for jet in SUSYTools_xAOD::FJVT_SF with value " << current_sf );
1097 totalSF *= current_sf;
1102 ATH_MSG_VERBOSE(
"Retrieve total SF for jet container in SUSYTools_xAOD::FJVT_SF with value " << totalSF );
◆ FJVT_SFsys()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 1107 of file Jets.cxx.
1114 if ( ret != StatusCode::SUCCESS) {
1115 ATH_MSG_ERROR(
"Cannot configure fJvtEfficiencyTool for systematic var. " << systConfig.
name() );
1123 if ( ret != StatusCode::SUCCESS) {
1124 ATH_MSG_ERROR(
"Cannot configure fJvtEfficiencyTool for systematic var. " << systConfig.
name() );
◆ GetCorrectedActualInteractionsPerCrossing()
| float ST::SUSYObjDef_xAOD::GetCorrectedActualInteractionsPerCrossing |
( |
bool |
includeDataSF = false | ) |
|
|
finaloverridevirtual |
◆ GetCorrectedAverageInteractionsPerCrossing()
| float ST::SUSYObjDef_xAOD::GetCorrectedAverageInteractionsPerCrossing |
( |
bool |
includeDataSF = false | ) |
|
|
finaloverridevirtual |
◆ GetDataWeight()
| float ST::SUSYObjDef_xAOD::GetDataWeight |
( |
const std::string & |
trig | ) |
|
|
finaloverridevirtual |
◆ getDefaultJetUncConfig()
| std::string ST::SUSYObjDef_xAOD::getDefaultJetUncConfig |
( |
| ) |
|
|
protected |
Definition at line 1835 of file SUSYObjDef_xAOD.cxx.
1837 return isAtlfast() ?
"rel22/Spring2025_PreRec/R4_CategoryReduction_FullJER_MC23.config" :
"rel22/Spring2025_PreRec/R4_CategoryReduction_FullJER_MC23.config";
1839 return isAtlfast() ?
"rel22/Spring2025_PreRec/R4_CategoryReduction_FullJER_MC20_MC21.config" :
"rel22/Spring2025_PreRec/R4_CategoryReduction_FullJER_MC20_MC21.config";
◆ GetElectrons()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 118 of file Electrons.cxx.
122 return StatusCode::FAILURE;
126 auto outputCol = std::make_unique<xAOD::ElectronContainer>();
127 std::unique_ptr<xAOD::ElectronAuxContainer> outputAuxCol;
128 outputAuxCol = std::make_unique<xAOD::ElectronAuxContainer>();
129 outputCol->setStore(outputAuxCol.get());
132 if (
bool(
m_eleLRT) && !lrtelekey.empty() &&
evtStore()->contains<xAOD::ElectronContainer>(lrtelekey)){
136 if (
evtStore()->contains<xAOD::ElectronContainer>(
"StdWithLRTElectrons")) {
137 ATH_MSG_DEBUG(
"Merged prompt/LRT container already created in TStore");
139 ATH_MSG_DEBUG(
"Creating merged prompt/LRT container in TStore");
146 auto filtered_electrons = std::make_unique<xAOD::ElectronContainer>();
147 std::unique_ptr<xAOD::ElectronAuxContainer> filtered_electrons_aux = std::make_unique<xAOD::ElectronAuxContainer>();
148 filtered_electrons->setStore(filtered_electrons_aux.get());
152 std::set<const xAOD::Electron *> ElectronsToRemove;
168 }
else if (!lrtelekey.empty()) {
169 if(
evtStore()->contains<xAOD::ElectronContainer>(lrtelekey) ==
false &&
bool(
m_eleLRT) ==
true)
ATH_MSG_WARNING(
"prompt/LRT OR procedure attempted but " << lrtelekey <<
" not in ROOT file, check config!");
170 ATH_MSG_DEBUG(
"Not applying prompt/LRT electron OR procedure");
173 if (
m_isPHYSLITE && elekey.find(
"AnalysisElectrons")==std::string::npos){
174 ATH_MSG_ERROR(
"You are running on PHYSLITE derivation. Please change the Electrons container to 'AnalysisElectrons'");
175 return StatusCode::FAILURE;
179 if (
bool(
m_eleLRT) &&
evtStore()->contains<xAOD::ElectronContainer>(lrtelekey)){
186 if (containerToBeCopied !=
nullptr) {
199 copy = shallowcopy.first;
200 copyaux = shallowcopy.second;
206 ATH_MSG_DEBUG(
"Not retrieving electron collection, using existing one provided by user");
219 return StatusCode::SUCCESS;
◆ GetEleTriggerEfficiency()
| double ST::SUSYObjDef_xAOD::GetEleTriggerEfficiency |
( |
const xAOD::Electron & |
el, |
|
|
const std::string & |
trigExpr = "SINGLE_E_2015_e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose_2016_2018_e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0" |
|
) |
| const |
|
finaloverridevirtual |
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 592 of file Electrons.cxx.
594 std::string single_str =
"SINGLE_E";
595 std::string single_Run3 =
"202";
596 std::string dilep_str =
"DI_E";
597 std::string multi_str =
"MULTI_L";
602 if ( trigExpr.find(single_str) != std::string::npos || trigExpr.find(single_Run3) != std::string::npos)
604 else if ( trigExpr.find(dilep_str) != std::string::npos )
605 ATH_MSG_ERROR(
"Use GetTriggerGlobalEfficiency for logical OR of lepton triggers");
606 else if ( trigExpr.find(multi_str) != std::string::npos )
607 ATH_MSG_ERROR(
"Use GetTriggerGlobalEfficiency for logical OR of lepton triggers");
609 ATH_MSG_ERROR(
"The trigger expression (" << trigExpr <<
") is not supported by the electron trigger efficiency!");
613 ATH_MSG_ERROR(
"Failed to retrieve signal electron trigger efficiency");
616 ATH_MSG_VERBOSE(
"OutOfValidityRange found for signal electron trigger efficiency");
◆ GetEleTriggerEfficiencySF()
| double ST::SUSYObjDef_xAOD::GetEleTriggerEfficiencySF |
( |
const xAOD::Electron & |
el, |
|
|
const std::string & |
trigExpr = "SINGLE_E_2015_e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose_2016_2018_e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0" |
|
) |
| const |
|
finaloverridevirtual |
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 558 of file Electrons.cxx.
562 std::string single_str =
"SINGLE_E";
563 std::string single_Run3 =
"202";
564 std::string dilep_str =
"DI_E";
565 std::string multi_str =
"MULTI_L";
568 if ( trigExpr.find(single_str) != std::string::npos || trigExpr.find(single_Run3) != std::string::npos)
570 else if ( trigExpr.find(dilep_str) != std::string::npos )
571 ATH_MSG_ERROR(
"Use GetTriggerGlobalEfficiency for logical OR of lepton triggers");
572 else if ( trigExpr.find(multi_str) != std::string::npos )
573 ATH_MSG_ERROR(
"Use GetTriggerGlobalEfficiency for logical OR of lepton triggers");
575 ATH_MSG_ERROR(
"The trigger expression (" << trigExpr <<
") is not supported by the electron trigger SF!");
579 ATH_MSG_ERROR(
"Failed to retrieve signal electron trigger SF");
582 ATH_MSG_VERBOSE(
"OutOfValidityRange found for signal electron trigger SF");
◆ getElSFkeys()
| std::vector< std::string > ST::SUSYObjDef_xAOD::getElSFkeys |
( |
const std::string & |
mapFile | ) |
const |
|
protected |
Definition at line 1239 of file SUSYObjDef_xAOD.cxx.
1241 if( mapFile.empty() )
1244 std::vector<std::string> theKeys;
1248 for( std::string
line; getline( input,
line ); ){
1251 theKeys.push_back(
tokens.at(0));
◆ GetEventInfo()
◆ GetFatJets()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 243 of file Jets.cxx.
247 return StatusCode::FAILURE;
251 ATH_MSG_ERROR(
"JetFatCalibTool was not initialized for largeR jet!!");
252 return StatusCode::FAILURE;
255 std::string jetkey_tmp = jetkey;
256 if (jetkey.empty()) {
262 if (containerToBeCopied !=
nullptr) {
263 jets = containerToBeCopied;
271 copy = shallowcopy.first;
272 copyaux = shallowcopy.second;
275 ATH_MSG_WARNING(
"Failed to set original object links on " << jetkey_tmp);
278 ATH_MSG_DEBUG(
"Not retrieving jet collection, using existing one provided by user");
282 if(
jets->size()==0) {
284 return StatusCode::SUCCESS;
292 ATH_MSG_DEBUG(
"Checking if decorator for JetTruthLabelingTool is available:");
307 if ( acc_baseline(*
jet) ){
308 dec_selected(*
jet) = 1;
311 dec_selected(*
jet) = 0;
318 return StatusCode::SUCCESS;
◆ GetInDetLargeD0GSFTracks()
◆ GetInDetLargeD0Tracks()
◆ GetJets()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 74 of file Jets.cxx.
78 return StatusCode::FAILURE;
81 if (
m_isPHYSLITE && jetkey.find(
"AnalysisJets") == std::string::npos){
82 ATH_MSG_ERROR(
"You are running on PHYSLITE derivation. Please change the Jets container to 'AnalysisJets'");
83 return StatusCode::FAILURE;
93 if (!jetkey.empty()) {
98 ATH_MSG_DEBUG(
"Key for retrieving jet collection: jetkey = " << jetkey_tmp);
102 if (containerToBeCopied !=
nullptr) {
103 jets = containerToBeCopied;
110 copy = shallowcopy.first;
111 copyaux = shallowcopy.second;
114 ATH_MSG_WARNING(
"Failed to set original object links on " << jetkey_tmp);
117 ATH_MSG_DEBUG(
"Not retrieving jet collecton, using existing one provided by user");
142 for (
const auto jet : *copy) {
145 dec_passJvt(*
jet) = acc_passFJvt(*
jet) && acc_passJvt(*
jet);
146 dec_fjvt(*
jet) = acc_fjvt(*
jet);
149 if ( acc_baseline(*
jet) ){
150 if( acc_passJvt(*
jet) ) dec_selected(*
jet) = 2;
151 else dec_selected(*
jet) = 1;
154 dec_selected(*
jet) = 0;
162 std::string auxname = copyaux->
name();
163 if (auxname.compare(
"UNKNOWN")==0) copyaux->
setName(std::string(
"STCalib" + jetkey_tmp +
m_currentSyst.
name() +
"AuxCopy").c_str());
167 return StatusCode::SUCCESS;
◆ GetJetsSyst()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 322 of file Jets.cxx.
326 return StatusCode::FAILURE;
329 std::string jetkey_tmp = jetkey;
330 if (jetkey.empty()) {
335 copy = shallowcopy.first;
336 copyaux = shallowcopy.second;
340 ATH_MSG_WARNING(
"Failed to set original object links on " << jetkey_tmp);
347 if (jetkey!=
"AnalysisJets"){
359 for (
const auto jet : *copy) {
362 dec_passJvt(*
jet) = acc_passFJvt(*
jet) && acc_passJvt(*
jet);
365 if ( acc_baseline(*
jet) ){
366 if( acc_passJvt(*
jet) ) dec_selected(*
jet) = 2;
367 else dec_selected(*
jet) = 1;
370 dec_selected(*
jet) = 0;
381 return StatusCode::SUCCESS;
◆ getKey()
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.
121 #ifdef XAOD_STANDALONE
127 return (
proxy ==
nullptr ? 0 :
proxy->sgkey() );
128 #endif // XAOD_STANDALONE
◆ getMCShowerType()
| int ST::SUSYObjDef_xAOD::getMCShowerType |
( |
const std::string & |
sample_name = "", |
|
|
const std::string & |
tagger = "" |
|
) |
| const |
|
inlinefinaloverridevirtual |
◆ GetMET()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 23 of file MET.cxx.
33 return StatusCode::FAILURE;
39 return StatusCode::FAILURE;
44 return StatusCode::FAILURE;
49 std::string softTerm =
"SoftClus";
51 softTerm =
"PVSoftTrk";
52 }
else if (doJVTCut) {
53 ATH_MSG_WARNING(
"Requested CST MET and a JVT cut. This is not a recommended configuration - please consider switching to TST." );
56 metHelper.resetObjSelectionFlags();
68 if (acc_baseline(*
el)) {
72 if (ipart ==
el) {
veto =
true;
break;}
75 if (!
veto) metelectron.push_back(
el);
86 if (acc_baseline(*ph)) {
90 if (ipart == ph) {
veto =
true;
break;}
93 if (!
veto) metgamma.push_back(ph);
104 if (acc_baseline(*tau)) {
108 if (ipart == tau) {
veto =
true;
break;}
111 if (!
veto) mettau.push_back(tau);
123 if (acc_baseline(*
mu)) {
126 if (ipart ==
mu) {
veto =
true;
break;}
129 if (!
veto) metmuon.push_back(
mu);
136 ATH_MSG_WARNING(
"Invalid jet container specified for MET rebuilding!");
137 return StatusCode::SUCCESS;
157 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.
244 std::string softTerm =
"SoftClus";
246 softTerm =
"PVSoftTrk";
247 }
else if (doJVTCut) {
248 ATH_MSG_WARNING(
"Requested CST MET and a JVT cut. This is not a recommended configuration - please consider switching to TST." );
257 return StatusCode::SUCCESS;
◆ GetMuons()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 101 of file Muons.cxx.
105 return StatusCode::FAILURE;
109 auto outputCol = std::make_unique<xAOD::MuonContainer>();
110 std::unique_ptr<xAOD::MuonAuxContainer> outputAuxCol;
111 outputAuxCol = std::make_unique<xAOD::MuonAuxContainer>();
112 outputCol->setStore(outputAuxCol.get());
115 if (
bool(
m_muLRT) && !lrtmuonkey.empty() &&
evtStore()->contains<xAOD::MuonContainer>(lrtmuonkey)){
119 if (
evtStore()->contains<xAOD::MuonContainer>(
"StdWithLRTMuons")) {
120 ATH_MSG_DEBUG(
"Merged prompt/LRT container already created in TStore");
122 ATH_MSG_DEBUG(
"Creating merged prompt/LRT container in TStore");
129 auto filtered_muons = std::make_unique<xAOD::MuonContainer>();
130 std::unique_ptr<xAOD::MuonAuxContainer> filtered_muons_aux = std::make_unique<xAOD::MuonAuxContainer>();
131 filtered_muons->setStore(filtered_muons_aux.get());
135 std::vector<bool> writePromptMuon;
136 std::vector<bool> writeLRTMuon;
153 }
else if (!lrtmuonkey.empty()) {
154 if (
evtStore()->contains<xAOD::MuonContainer>(lrtmuonkey) ==
false &&
bool(
m_muLRT) ==
true)
ATH_MSG_WARNING(
"prompt/LRT OR procedure attempted but " << lrtmuonkey <<
" not in ROOT file, check config!");
158 if (
m_isPHYSLITE && muonkey.find(
"AnalysisMuons")==std::string::npos){
159 ATH_MSG_ERROR(
"You are running on PHYSLITE derivation. Please change the Muons container to 'AnalysisMuons'");
160 return StatusCode::FAILURE;
164 if (
bool(
m_muLRT) &&
evtStore()->contains<xAOD::MuonContainer>(lrtmuonkey)){
171 if (containerToBeCopied !=
nullptr) {
173 muons = containerToBeCopied;
184 copy = shallowcopy.first;
185 copyaux = shallowcopy.second;
191 ATH_MSG_DEBUG(
"Not retrieving muon collection, using existing one provided by user");
205 return StatusCode::SUCCESS;
◆ GetMuonTriggerEfficiency()
| double ST::SUSYObjDef_xAOD::GetMuonTriggerEfficiency |
( |
const xAOD::Muon & |
mu, |
|
|
const std::string & |
trigExpr, |
|
|
const bool |
isdata = false |
|
) |
| |
|
finaloverridevirtual |
◆ 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.
108 #ifdef XAOD_STANDALONE
114 static const std::string
dummy =
"";
116 #endif // XAOD_STANDALONE
◆ GetPhotons()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 33 of file Photons.cxx.
37 return StatusCode::FAILURE;
40 if (
m_isPHYSLITE && photonkey.find(
"AnalysisPhotons")==std::string::npos){
41 ATH_MSG_ERROR(
"You are running on PHYSLITE derivation. Please change the Photons container to 'AnalysisPhotons'");
42 return StatusCode::FAILURE;
47 if (containerToBeCopied !=
nullptr) {
48 photons = containerToBeCopied;
54 copy = shallowcopy.first;
55 copyaux = shallowcopy.second;
58 ATH_MSG_WARNING(
"Failed to set original object links on " << photonkey);
61 ATH_MSG_DEBUG(
"Not retrieving photon collecton, using existing one provided by user");
74 return StatusCode::SUCCESS;
◆ GetPileupWeight()
| float ST::SUSYObjDef_xAOD::GetPileupWeight |
( |
| ) |
|
|
finaloverridevirtual |
◆ GetPileupWeightHash()
| ULong64_t ST::SUSYObjDef_xAOD::GetPileupWeightHash |
( |
| ) |
|
|
finaloverridevirtual |
◆ GetPileupWeightPrescaledTrigger()
| float ST::SUSYObjDef_xAOD::GetPileupWeightPrescaledTrigger |
( |
const std::string & |
trigger_expr | ) |
|
|
finaloverridevirtual |
◆ GetPrimVtx()
◆ getProperty() [1/2]
template<typename T >
| const T* ST::ISUSYObjDef_xAODTool::getProperty |
( |
const std::string & |
name | ) |
|
|
inlineinherited |
◆ 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 3044 of file SUSYObjDef_xAOD.cxx.
3047 if (randomrunnumber.isAvailable(*(evtInfo)) && muDependentRRN) {
3048 return randomrunnumber(*(evtInfo));
3050 else if (!muDependentRRN) {
3053 ATH_MSG_ERROR (
"Failed to find RandomRunNumber decoration! You need to call ApplyPRWTool() beforehand!" );
◆ GetRunNumber()
| unsigned int ST::SUSYObjDef_xAOD::GetRunNumber |
( |
| ) |
const |
|
finaloverridevirtual |
◆ getSherpaVjetsNjetsWeight() [1/2]
| float ST::SUSYObjDef_xAOD::getSherpaVjetsNjetsWeight |
( |
| ) |
const |
|
finaloverridevirtual |
◆ getSherpaVjetsNjetsWeight() [2/2]
| float ST::SUSYObjDef_xAOD::getSherpaVjetsNjetsWeight |
( |
const std::string & |
jetContainer | ) |
const |
|
finaloverridevirtual |
◆ GetSignalElecSF()
| float ST::SUSYObjDef_xAOD::GetSignalElecSF |
( |
const xAOD::Electron & |
el, |
|
|
const bool |
recoSF = true, |
|
|
const bool |
idSF = true, |
|
|
const bool |
triggerSF = true, |
|
|
const bool |
isoSF = true, |
|
|
const std::string & |
trigExpr = "singleLepton", |
|
|
const bool |
ecidsSF = false, |
|
|
const bool |
cidSF = false |
|
) |
| |
|
finaloverridevirtual |
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 420 of file Electrons.cxx.
430 ATH_MSG_ERROR(
"No signal electron ID or trigger scale factors provided for the selected working point!");
435 std::string singleLepStr =
"singleLepton";
436 std::string diLepStr =
"diLepton";
437 std::string multiLepStr =
"multiLepton";
450 ATH_MSG_ERROR(
"Failed to retrieve signal electron reco SF");
453 ATH_MSG_VERBOSE(
"OutOfValidityRange found for signal electron reco SF");
472 ATH_MSG_VERBOSE(
"OutOfValidityRange found for signal electron id SF");
481 std::vector<std::string> trigMChains={};
482 std::string theExpr (
"");
483 if(trigExpr==singleLepStr) {
494 ATH_MSG_WARNING(
"Only single lepton trigger SFs are supported in GetSignalElecSF(). Use GetTriggerGlobalEfficiencySF() for dilepton or multilepton triggers!");
500 if(!acc_trigmatched(
el)){
501 ATH_MSG_DEBUG(
"Electron was not matched to trigger " << theExpr <<
" - scale factor does not apply (year " << this->
treatAsYear() <<
") Returning 1." );
504 if (trigExpr==multiLepStr || trigExpr==diLepStr) {
505 ATH_MSG_WARNING(
"The dilepton or multilepton trigger SFs are not supported in GetSignalElecSF(). Use GetTriggerGlobalEfficiencySF()!");
530 ATH_MSG_VERBOSE(
"OutOfValidityRange found for signal electron iso SF");
538 if ( ecidsSF || cidSF ) {
548 dec_sfChIDEff(
el) = chf_sf;
553 dec_effscalefact(
el) =
sf;
◆ GetSignalMuonSF()
| float ST::SUSYObjDef_xAOD::GetSignalMuonSF |
( |
const xAOD::Muon & |
mu, |
|
|
const bool |
recoSF = true, |
|
|
const bool |
isoSF = true, |
|
|
const bool |
doBadMuonHP = true, |
|
|
const bool |
warnOVR = true |
|
) |
| |
|
finaloverridevirtual |
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 480 of file Muons.cxx.
487 if(warnOVR)
ATH_MSG_WARNING(
" GetSignalMuonSF: Reco getEfficiencyScaleFactor out of validity range");
495 if(warnOVR)
ATH_MSG_WARNING(
" GetSignalMuonSF: TTVA getEfficiencyScaleFactor out of validity range");
501 float sf_badHighPt(1.);
502 if(
m_muId == 4 && doBadMuonHP){
504 if(warnOVR)
ATH_MSG_WARNING(
" GetSignalMuonSF: BadMuonHighPt getEfficiencyScaleFactor out of validity range");
516 if(warnOVR)
ATH_MSG_WARNING(
" GetSignalMuonSF: high-pt Iso getEfficiencyScaleFactor out of validity range");
520 if(warnOVR)
ATH_MSG_WARNING(
" GetSignalMuonSF: Iso getEfficiencyScaleFactor out of validity range");
528 dec_effscalefact(
mu) =
sf;
◆ GetSignalPhotonSF()
◆ GetSignalPhotonSFsys()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 247 of file Photons.cxx.
253 if (ret != StatusCode::SUCCESS) {
254 ATH_MSG_ERROR(
"Cannot configure AsgPhotonEfficiencyCorrectionTool (reco) for systematic var. " << systConfig.
name() );
258 if (ret != StatusCode::SUCCESS) {
259 ATH_MSG_ERROR(
"Cannot configure AsgPhotonEfficiencyCorrectionTool (iso) for systematic var. " << systConfig.
name() );
263 if (ret != StatusCode::SUCCESS) {
264 ATH_MSG_ERROR(
"Cannot configure AsgPhotonEfficiencyCorrectionTool (trigger) for systematic var. " << systConfig.
name() );
289 double sf_trigger = 1.;
299 if (ret != StatusCode::SUCCESS) {
300 ATH_MSG_ERROR(
"Cannot configure AsgPhotonEfficiencyCorrectionTool back to default.");
304 if (ret != StatusCode::SUCCESS) {
305 ATH_MSG_ERROR(
"Cannot configure AsgPhotonEfficiencyCorrectionTool (iso) for systematic var. " << systConfig.
name() );
309 if (ret != StatusCode::SUCCESS) {
310 ATH_MSG_ERROR(
"Cannot configure AsgPhotonEfficiencyCorrectionTool (trigger) for systematic var. " << systConfig.
name() );
315 dec_effscalefact(ph) =
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 |
◆ GetSignalTauSFsys()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 160 of file Taus.cxx.
170 if (ret != StatusCode::SUCCESS) {
ATH_MSG_ERROR(
"Cannot configure TauEfficiencyCorrectionsTool for systematic var. " << systConfig.
name() ); }
173 ret =
tool->applySystematicVariation(systConfig);
174 if (ret != StatusCode::SUCCESS) {
ATH_MSG_ERROR(
"Cannot configure " <<
tool->name() <<
" for systematic var. " << systConfig.
name()); }
181 if (ret != StatusCode::SUCCESS) {
ATH_MSG_ERROR(
"Cannot configure TauEfficiencyCorrectionsTool back to default"); }
185 if (ret != StatusCode::SUCCESS) {
ATH_MSG_ERROR(
"Cannot configure " <<
tool->name() <<
" back to default"); }
188 dec_effscalefact(tau) =
sf;
◆ GetSumOfWeights()
| double ST::SUSYObjDef_xAOD::GetSumOfWeights |
( |
int |
channel | ) |
|
|
finaloverridevirtual |
◆ getSystInfo()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 2577 of file SUSYObjDef_xAOD.cxx.
2580 sysInfo.affectsKinematics =
false;
2581 sysInfo.affectsWeights =
false;
2582 sysInfo.affectedWeights.clear();
2583 sysInfo.systset.insert(
sys);
2587 sysInfo.affectsWeights =
true;
2589 sysInfo.affectedWeights.insert(ST::Weights::Jet::JVT);
2595 sysInfo.affectsWeights =
true;
2597 sysInfo.affectedWeights.insert(ST::Weights::Jet::FJVT);
2603 sysInfo.affectsKinematics =
true;
2609 sysInfo.affectsKinematics =
true;
2616 sysInfo.affectsKinematics =
true;
2622 sysInfo.affectsKinematics =
true;
2631 sysInfo.affectsKinematics =
true;
2638 sysInfo.affectsKinematics =
true;
2644 sysInfo.affectsKinematics =
true;
2650 sysInfo.affectsKinematics =
true;
2657 sysInfo.affectsKinematics =
true;
2663 sysInfo.affectsWeights =
true;
2665 sysInfo.affectedWeights.insert(ST::Weights::Electron::Trigger);
2670 sysInfo.affectsWeights =
true;
2672 sysInfo.affectedWeights.insert(ST::Weights::Electron::Trigger);
2677 sysInfo.affectsWeights =
true;
2679 sysInfo.affectedWeights.insert(ST::Weights::Muon::Reconstruction);
2684 sysInfo.affectsWeights =
true;
2686 sysInfo.affectedWeights.insert(ST::Weights::Muon::Reconstruction);
2691 sysInfo.affectsWeights =
true;
2693 sysInfo.affectedWeights.insert(ST::Weights::Muon::Reconstruction);
2698 sysInfo.affectsWeights =
true;
2700 sysInfo.affectedWeights.insert(ST::Weights::Muon::Isolation);
2705 sysInfo.affectsWeights =
true;
2707 sysInfo.affectedWeights.insert(ST::Weights::Muon::Trigger);
2712 sysInfo.affectsWeights =
true;
2714 sysInfo.affectedWeights.insert(ST::Weights::Electron::Reconstruction);
2719 sysInfo.affectsWeights =
true;
2721 sysInfo.affectedWeights.insert(ST::Weights::Electron::ID);
2726 sysInfo.affectsWeights =
true;
2728 sysInfo.affectedWeights.insert(ST::Weights::Electron::Trigger);
2733 sysInfo.affectsWeights =
true;
2735 sysInfo.affectedWeights.insert(ST::Weights::Electron::Trigger);
2740 sysInfo.affectsWeights =
true;
2742 sysInfo.affectedWeights.insert(ST::Weights::Electron::Isolation);
2747 sysInfo.affectsWeights =
true;
2749 sysInfo.affectedWeights.insert(ST::Weights::Electron::Isolation);
2754 sysInfo.affectsKinematics =
true;
2755 if (
sys.basename().compare(0, 3,
"EG_") == 0) {
2757 }
else if (
sys.basename().compare(0, 3,
"PH_") == 0) {
2759 }
else if (
sys.basename().compare(0, 3,
"EL_") == 0) {
2766 sysInfo.affectsWeights =
false;
2767 sysInfo.affectsKinematics =
true;
2773 sysInfo.affectsWeights =
true;
2775 sysInfo.affectedWeights.insert(ST::Weights::Photon::Reconstruction);
2780 sysInfo.affectsWeights =
true;
2782 sysInfo.affectedWeights.insert(ST::Weights::Photon::Isolation);
2787 sysInfo.affectsWeights =
true;
2789 sysInfo.affectedWeights.insert(ST::Weights::Photon::Trigger);
2794 sysInfo.affectsWeights =
true;
2796 sysInfo.affectedWeights.insert(ST::Weights::Photon::Trigger);
2801 sysInfo.affectsWeights =
true;
2803 sysInfo.affectedWeights.insert(ST::Weights::Jet::Btag);
2808 sysInfo.affectsWeights =
true;
2810 sysInfo.affectedWeights.insert(ST::Weights::Jet::Btag_Track);
2815 sysInfo.affectsKinematics =
true;
2821 sysInfo.affectsWeights =
true;
2823 sysInfo.affectedWeights.insert(ST::Weights::Tau::Reconstruction);
2827 if(
tool->isAffectedBySystematic(
sys)) {
2828 sysInfo.affectsWeights =
true;
2830 sysInfo.affectedWeights.insert(ST::Weights::Tau::Trigger);
2836 sysInfo.affectsKinematics =
true;
2854 sysInfo.affectsWeights =
true;
2861 sysInfo.affectsKinematics =
true;
2866 std::string affectedType;
2867 switch (sysInfo.affectsType) {
2868 case Unknown : affectedType =
"UNKNOWN";
break;
2869 case Jet : affectedType =
"JET";
break;
2870 case Egamma : affectedType =
"EGAMMA";
break;
2871 case Electron : affectedType =
"ELECTRON";
break;
2872 case Photon : affectedType =
"PHOTON";
break;
2873 case Muon : affectedType =
"MUON";
break;
2874 case Tau : affectedType =
"TAU";
break;
2875 case BTag : affectedType =
"BTAG";
break;
2876 case MET_TST : affectedType =
"MET_TST";
break;
2877 case MET_CST : affectedType =
"MET_CST";
break;
2878 case MET_Track : affectedType =
"MET_Track";
break;
2879 case EventWeight : affectedType =
"EVENT WEIGHT";
break;
2880 case LRT_Object : affectedType =
"LRT_OBJECT";
break;
2884 << ( sysInfo.affectsWeights ?
"weights " :
"" )
2885 << ( sysInfo.affectsKinematics ?
"kinematics " :
"" )
2886 <<
"for " << affectedType );
◆ getSystInfoList()
| std::vector< ST::SystInfo > ST::SUSYObjDef_xAOD::getSystInfoList |
( |
| ) |
const |
|
finaloverridevirtual |
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 2542 of file SUSYObjDef_xAOD.cxx.
2545 return vector<ST::SystInfo>();
2554 vector<SystInfo> sysInfoList;
2555 sysInfoList.reserve(recommendedSystematics.
size() * 2);
2559 infodef.affectsKinematics =
false;
2560 infodef.affectsWeights =
false;
2561 infodef.affectsType =
Unknown;
2562 infodef.affectedWeights.clear();
2563 sysInfoList.push_back(infodef);
2568 for (
const auto&
sys : systSet) {
2573 ATH_MSG_INFO(
"Returning list of " << sysInfoList.size() <<
" systematic variations");
◆ 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 1842 of file SUSYObjDef_xAOD.cxx.
1844 if(tauConfigPath.empty())
return;
1848 rEnv.ReadFile(
filename.c_str(), kEnvAll);
1850 std::vector<std::string>
cuts;
1851 if (rEnv.Defined(
"SelectionCuts")) {
1852 cuts =
split(rEnv.GetValue(
"SelectionCuts",
" "),
" ");
1854 auto *
l = rEnv.GetTable();
1855 for( Int_t
i = 0;
i <
l->GetEntries(); ++
i ) {
1856 cuts.push_back(
l->At(
i)->GetName() );
1865 static const std::string trueBool =
"TRUE";
1868 std::vector<std::string> v_pT_window;
1869 std::vector<std::string> v_eta_window;
1872 float pT_min = -99.0;
1873 float pT_max = -99.0;
1874 float eta_min = -99.0;
1875 float eta_max = -99.0;
1876 for (
const auto&
cut :
cuts) {
1877 if(
cut ==
"PtRegion") {
1878 v_pT_window =
split(rEnv.GetValue(
"PtRegion",
""),
";");
1881 std::back_inserter(pT_window),
1882 [](
const std::string&
s) {
return std::stof(
s); }
1884 }
else if (
cut ==
"PtMin") {
1885 pT_min = rEnv.GetValue(
"PtMin", NAN);
1886 }
else if (
cut ==
"PtMax") {
1887 pT_max = rEnv.GetValue(
"PtMax", NAN);
1888 }
else if (
cut ==
"AbsEtaRegion") {
1889 v_eta_window =
split(rEnv.GetValue(
"AbsEtaRegion",
""),
";");
1892 std::back_inserter(eta_window),
1893 [](
const std::string&
s) {
return std::stof(
s); }
1895 }
else if (
cut ==
"AbsEtaMin") {
1896 eta_min = rEnv.GetValue(
"AbsEtaMin", NAN);
1897 }
else if (
cut ==
"AbsEtaMax") {
1898 eta_max = rEnv.GetValue(
"AbsEtaMax", NAN);
1902 else if (
cut ==
"EleOLR"){
1903 eleOLR = (rEnv.GetValue(
"EleOLR",
"FALSE") == trueBool);
1905 else if (
cut ==
"MuonVeto"){
1906 muVeto = (rEnv.GetValue(
"MuonVeto",
"FALSE") == trueBool);
1908 else if (
cut ==
"MuonOLR"){
1909 muOLR = (rEnv.GetValue(
"MuonOLR",
"FALSE") == trueBool);
1913 if(pT_window.empty()) {
1914 if(pT_min == pT_min) {
1916 pT_window.push_back(pT_min);
1918 pT_window.push_back(-std::numeric_limits<float>::infinity());
1921 if(pT_max == pT_max) {
1923 pT_window.push_back(pT_max);
1925 pT_window.push_back(std::numeric_limits<float>::infinity());
1929 if(eta_window.empty()) {
1930 if(eta_min == eta_min) {
1932 eta_window.push_back(eta_min);
1934 eta_window.push_back(-std::numeric_limits<float>::infinity());
1937 if(eta_max == eta_max) {
1939 eta_window.push_back(eta_max);
1941 eta_window.push_back(std::numeric_limits<float>::infinity());
◆ GetTaus()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 31 of file Taus.cxx.
36 return StatusCode::FAILURE;
39 if (
m_isPHYSLITE && taukey.find(
"AnalysisTauJets")==std::string::npos){
40 ATH_MSG_ERROR(
"You are running on PHYSLITE derivation. Please change the Taus container to 'AnalysisTauJets'");
41 return StatusCode::FAILURE;
46 if (containerToBeCopied !=
nullptr) {
47 taus = containerToBeCopied;
53 copy = shallowcopy.first;
54 copyaux = shallowcopy.second;
60 ATH_MSG_DEBUG(
"Not retrieving tau collecton, using existing one provided by user");
64 for (
const auto tau : *
copy) {
72 return StatusCode::SUCCESS;
◆ GetTauTriggerEfficiencySF()
| double ST::SUSYObjDef_xAOD::GetTauTriggerEfficiencySF |
( |
const xAOD::TauJet & |
tau, |
|
|
const std::string & |
trigExpr = "tau25_medium1_tracktwo" |
|
) |
| |
|
finaloverridevirtual |
◆ GetTotalElectronSF()
◆ GetTotalElectronSFsys()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 640 of file Electrons.cxx.
647 if (ret != StatusCode::SUCCESS) {
648 ATH_MSG_ERROR(
"Cannot configure AsgElectronEfficiencyCorrectionTool (reco) for systematic var. " << systConfig.
name() );
654 if (ret != StatusCode::SUCCESS) {
655 ATH_MSG_ERROR(
"Cannot configure AsgElectronEfficiencyCorrectionTool (id) for systematic var. " << systConfig.
name() );
661 if (ret != StatusCode::SUCCESS) {
662 ATH_MSG_ERROR(
"Cannot configure AsgElectronEfficiencyCorrectionTool (trigger) for systematic var. " << systConfig.
name() );
668 if (ret != StatusCode::SUCCESS) {
669 ATH_MSG_ERROR(
"Cannot configure AsgElectronEfficiencyCorrectionTool (iso) for systematic var. " << systConfig.
name() );
675 if (ret != StatusCode::SUCCESS) {
676 ATH_MSG_ERROR(
"Cannot configure AsgElectronEfficiencyCorrectionTool (iso high-pt) for systematic var. " << systConfig.
name() );
682 if (ret != StatusCode::SUCCESS) {
683 ATH_MSG_ERROR(
"Cannot configure ElectronChargeEfficiencyCorrectionTool for systematic var. " << systConfig.
name() );
694 if (ret != StatusCode::SUCCESS) {
695 ATH_MSG_ERROR(
"Cannot configure AsgElectronEfficiencyCorrectionTool (reco) back to default.");
701 if (ret != StatusCode::SUCCESS) {
702 ATH_MSG_ERROR(
"Cannot configure AsgElectronEfficiencyCorrectionTool (id) back to default.");
708 if (ret != StatusCode::SUCCESS) {
709 ATH_MSG_ERROR(
"Cannot configure AsgElectronEfficiencyCorrectionTool (trigger) back to default.");
715 if (ret != StatusCode::SUCCESS) {
716 ATH_MSG_ERROR(
"Cannot configure AsgElectronEfficiencyCorrectionTool (iso) back to default.");
722 if (ret != StatusCode::SUCCESS) {
723 ATH_MSG_ERROR(
"Cannot configure AsgElectronEfficiencyCorrectionTool (iso high-pt) back to default.");
729 if (ret != StatusCode::SUCCESS) {
730 ATH_MSG_ERROR(
"Cannot configure ElectronChargeEfficiencyCorrectionTool back to default.");
◆ GetTotalJetSF()
◆ GetTotalJetSFsys()
◆ 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 |
◆ GetTotalMuonSFsys()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 622 of file Muons.cxx.
626 if ( ret != StatusCode::SUCCESS) {
627 ATH_MSG_ERROR(
"Cannot configure MuonEfficiencyScaleFactors for systematic var. " << systConfig.
name() );
631 if ( ret != StatusCode::SUCCESS) {
632 ATH_MSG_ERROR(
"Cannot configure MuonBadMuonHighPtScaleFactors for systematic var. " << systConfig.
name() );
636 if ( ret != StatusCode::SUCCESS) {
637 ATH_MSG_ERROR(
"Cannot configure MuonTTVAEfficiencyScaleFactors for systematic var. " << systConfig.
name() );
641 if ( ret != StatusCode::SUCCESS) {
642 ATH_MSG_ERROR(
"Cannot configure MuonIsolationScaleFactors for systematic var. " << systConfig.
name() );
646 if ( ret != StatusCode::SUCCESS) {
647 ATH_MSG_ERROR(
"Cannot configure MuonHighPtIsolationScaleFactors for systematic var. " << systConfig.
name() );
651 if ( ret != StatusCode::SUCCESS) {
652 ATH_MSG_ERROR(
"Cannot configure MuonTriggerScaleFactors for systematic var. " << systConfig.
name() );
656 if (ret != StatusCode::SUCCESS) {
657 ATH_MSG_ERROR(
"Cannot configure TrigGlobalEfficiencyCorrectionTool (trigger) for systematic var. " << systConfig.
name() );
661 if (ret != StatusCode::SUCCESS) {
662 ATH_MSG_ERROR(
"Cannot configure TrigGlobalEfficiencyCorrectionTool (trigger) for systematic var. " << systConfig.
name() );
669 if ( ret != StatusCode::SUCCESS) {
670 ATH_MSG_ERROR(
"Cannot configure MuonEfficiencyScaleFactors back to default.");
674 if ( ret != StatusCode::SUCCESS) {
675 ATH_MSG_ERROR(
"Cannot configure MuonBadMuonHighPtScaleFactors back to default.");
679 if ( ret != StatusCode::SUCCESS) {
680 ATH_MSG_ERROR(
"Cannot configure MuonTTVAEfficiencyScaleFactors back to default.");
684 if ( ret != StatusCode::SUCCESS) {
685 ATH_MSG_ERROR(
"Cannot configure MuonIsolationScaleFactors back to default.");
689 if ( ret != StatusCode::SUCCESS) {
690 ATH_MSG_ERROR(
"Cannot configure MuonIsolationScaleFactors back to default.");
694 if ( ret != StatusCode::SUCCESS) {
695 ATH_MSG_ERROR(
"Cannot configure MuonTriggerScaleFactors back to default.");
699 if (ret != StatusCode::SUCCESS) {
700 ATH_MSG_ERROR(
"Cannot configure TrigGlobalEfficiencyCorrectionTool (trigger) back to default.");
704 if (ret != StatusCode::SUCCESS) {
705 ATH_MSG_ERROR(
"Cannot configure TrigGlobalEfficiencyCorrectionTool (trigger) back to default.");
◆ GetTotalMuonTriggerSF()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 547 of file Muons.cxx.
549 if (trigExpr.empty() || sfmuons.
empty())
return 1.;
555 const char *
tmp = trigExpr.c_str();
556 while( (
tmp = strstr(
tmp,
"mu")) ){
561 bool isdimuon = (trigExpr.find(
"2mu") != std::string::npos);
562 bool isOR = (trigExpr.find(
"OR") != std::string::npos);
564 if((!isdimuon && mulegs<2) || (isdimuon && sfmuons.
size()==2) || (mulegs>=2 && isOR)){
572 else if(mulegs!=2 && isOR){
573 ATH_MSG_WARNING(
"SF for " << trigExpr <<
" are only supported for two muon events!");
577 std::string newtrigExpr = TString(trigExpr).Copy().ReplaceAll(
"HLT_2",
"").Data();
580 if (isdimuon) { newtrigExpr +=
"_"+newtrigExpr; }
581 newtrigExpr = std::regex_replace(newtrigExpr,
std::regex(
"HLT_"),
"");
585 double dataFactor = 1.;
586 double mcFactor = 1.;
593 if( (1-mcFactor) > 0. )
594 trig_sf *= (1-dataFactor)/(1-mcFactor);
◆ GetTotalPhotonSF()
◆ GetTotalPhotonSFsys()
◆ GetTotalTauSF()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 228 of file Taus.cxx.
234 if (!acc_passOR.isAvailable(*tau)) {
235 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!");
241 if (acc_signal(*tau) && acc_passOR(*tau)) {
◆ GetTotalTauSFsys()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 250 of file Taus.cxx.
255 if (ret != StatusCode::SUCCESS) {
ATH_MSG_ERROR(
"Cannot configure TauEfficiencyCorrectionsTool for systematic var. " << systConfig.
name() ); }
258 ret =
tool->applySystematicVariation(systConfig);
259 if (ret != StatusCode::SUCCESS) {
ATH_MSG_ERROR(
"Cannot configure " <<
tool->name() <<
" for systematic var. " << systConfig.
name()); }
266 if (ret != StatusCode::SUCCESS) {
ATH_MSG_ERROR(
"Cannot configure TauEfficiencyCorrectionsTool back to default"); }
270 if (ret != StatusCode::SUCCESS) {
ATH_MSG_ERROR(
"Cannot configure " <<
tool->name() <<
" back to default"); }
◆ GetTrackJets()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 170 of file Jets.cxx.
174 return StatusCode::FAILURE;
178 ATH_MSG_DEBUG(
"Function argument jetkey (trkjet): " << jetkey);
184 if (!jetkey.empty()) {
189 ATH_MSG_DEBUG(
"Key for retrieving trkjet collection (as well as bjet info): jetkey = " << jetkey_tmp);
193 if (containerToBeCopied !=
nullptr) {
194 jets = containerToBeCopied;
201 copy = shallowcopy.first;
202 copyaux = shallowcopy.second;
205 ATH_MSG_WARNING(
"Failed to set original object links on " << jetkey_tmp);
208 ATH_MSG_DEBUG(
"Not retrieving jet collection, using existing one provided by user");
224 if (!acc_signal(*jet1))
continue;
227 if (!acc_baseline(*jet2))
continue;
230 const xAOD::Jet* to_check = acc_VRradius(*jet1) < acc_VRradius(*jet2) ? jet1 : jet2;
231 if( dr_jets < acc_VRradius(*to_check)) dec_passDRcut(*to_check) =
false;
240 return StatusCode::SUCCESS;
◆ GetTrackMET()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 161 of file MET.cxx.
167 return StatusCode::FAILURE;
173 return StatusCode::FAILURE;
178 return StatusCode::FAILURE;
183 metHelper.resetObjSelectionFlags();
190 if (acc_baseline(*
el)) metelectron.push_back(
el);
200 if (acc_baseline(*
mu)) metmuon.push_back(
mu);
206 ATH_MSG_WARNING(
"Invalid jet container specified for MET rebuilding!");
207 return StatusCode::SUCCESS;
211 std::string softTerm =
"PVSoftTrk";
220 ATH_MSG_WARNING(
"GetMET: Failed to apply MET track (PVSoftTrk) systematics.");
226 ATH_MSG_WARNING(
"GetMET: Failed to apply MET track (RefJet) systematics.");
235 ATH_MSG_VERBOSE(
"Track MET: Missing Et (x,y): (" <<
met[
"Track"]->mpx() <<
"," <<
met[
"Track"]->mpy() <<
")");
237 return StatusCode::SUCCESS;
◆ GetTrigChainGroup()
◆ GetTriggerFeatures()
| Trig::FeatureContainer ST::SUSYObjDef_xAOD::GetTriggerFeatures |
( |
const std::string & |
chainName = "EF_.*", |
|
|
unsigned int |
condition = TrigDefs::Physics |
|
) |
| const |
◆ GetTriggerGlobalEfficiency() [1/2]
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 586 of file Trigger.cxx.
589 double trig_eff_data(1.);
591 if (trigExpr!=
"multiLepton" && trigExpr!=
"diLepton") {
592 ATH_MSG_ERROR(
"Failed to retrieve multi-lepton trigger efficiency");
596 std::vector<const xAOD::Electron*> elec_trig;
598 if (!acc_passOR(*
electron))
continue;
599 if (!acc_signal(*
electron))
continue;
603 std::vector<const xAOD::Muon*> muon_trig;
605 if (!acc_passOR(*
muon))
continue;
606 if (!acc_signal(*
muon))
continue;
607 muon_trig.push_back(
muon);
611 if ((elec_trig.size()+muon_trig.size())>1 && trigExpr==
"diLepton") {
613 ATH_MSG_ERROR (
"trigGlobEffCorrTool::Trigger matching could not be checked, interrupting execution.");
615 }
else if ((elec_trig.size()+muon_trig.size())>2 && trigExpr==
"multiLepton") {
617 ATH_MSG_ERROR (
"trigGlobEffCorrTool::Trigger matching could not be checked, interrupting execution.");
622 if ((elec_trig.size()+muon_trig.size())>1 && trigExpr==
"diLepton" &&
matched) {
625 else if ((elec_trig.size()+muon_trig.size())>2 && trigExpr==
"multiLepton" &&
matched) {
631 ATH_MSG_ERROR(
"Failed to retrieve multi-lepton trigger efficiency");
634 ATH_MSG_VERBOSE(
"OutOfValidityRange found for multi-lepton trigger efficiency");
640 if (
isData())
return trig_eff_data;
641 else return trig_eff;
◆ GetTriggerGlobalEfficiency() [2/2]
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 647 of file Trigger.cxx.
650 double trig_eff_data(1.);
652 if (trigExpr!=
"diPhoton") {
653 ATH_MSG_ERROR(
"Failed to retrieve diphoton trigger efficiency");
657 std::vector<const xAOD::Photon*> ph_trig;
659 if (!acc_passOR(*
photon))
continue;
660 if (!acc_signal(*
photon))
continue;
661 ph_trig.push_back(
photon);
665 if (ph_trig.size()>1) {
671 ATH_MSG_ERROR(
"Failed to retrieve diphoton trigger efficiency");
674 ATH_MSG_VERBOSE(
"OutOfValidityRange found for diphoton trigger efficiency");
680 if (
isData())
return trig_eff_data;
681 else return trig_eff;
◆ GetTriggerGlobalEfficiencySF() [1/2]
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 431 of file Trigger.cxx.
435 if (trigExpr!=
"multiLepton" && trigExpr!=
"diLepton") {
436 ATH_MSG_ERROR(
"Failed to retrieve multi-lepton trigger SF");
440 std::vector<const xAOD::Electron*> elec_trig;
442 if (!acc_passOR(*
electron))
continue;
443 if (!acc_signal(*
electron))
continue;
447 std::vector<const xAOD::Muon*> muon_trig;
449 if (!acc_passOR(*
muon))
continue;
450 if (!acc_signal(*
muon))
continue;
451 muon_trig.push_back(
muon);
455 if ((elec_trig.size()+muon_trig.size())>1 && trigExpr==
"diLepton") {
457 ATH_MSG_ERROR (
"trigGlobEffCorrTool::Trigger matching could not be checked, interrupting execution.");
459 }
else if ((elec_trig.size()+muon_trig.size())>2 && trigExpr==
"multiLepton") {
461 ATH_MSG_ERROR (
"trigGlobEffCorrTool::Trigger matching could not be checked, interrupting execution.");
466 if ((elec_trig.size()+muon_trig.size())>1 && trigExpr==
"diLepton" &&
matched) {
469 else if ((elec_trig.size()+muon_trig.size())>2 && trigExpr==
"multiLepton" &&
matched) {
475 ATH_MSG_ERROR(
"Failed to retrieve multi-lepton trigger SF");
478 ATH_MSG_VERBOSE(
"OutOfValidityRange found for multi-lepton trigger SF");
◆ GetTriggerGlobalEfficiencySF() [2/2]
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 529 of file Trigger.cxx.
533 if (trigExpr!=
"diPhoton") {
538 std::vector<const xAOD::Photon*> ph_trig;
540 if (!acc_passOR(*
photon))
continue;
541 if (!acc_signal(*
photon))
continue;
542 ph_trig.push_back(
photon);
546 if (ph_trig.size()>1) {
◆ GetTriggerGlobalEfficiencySFsys() [1/2]
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 487 of file Trigger.cxx.
492 if (trigExpr ==
"diLepton") {
494 if (ret != StatusCode::SUCCESS) {
495 ATH_MSG_ERROR(
"Cannot configure TrigGlobalEfficiencyCorrectionTool (dilepton trigger) for systematic var. " << systConfig.
name() );
499 if (trigExpr ==
"multiLepton") {
501 if (ret != StatusCode::SUCCESS) {
502 ATH_MSG_ERROR(
"Cannot configure TrigGlobalEfficiencyCorrectionTool (multi-lepton trigger) for systematic var. " << systConfig.
name() );
510 if (trigExpr ==
"diLepton") {
512 if (ret != StatusCode::SUCCESS) {
513 ATH_MSG_ERROR(
"Cannot configure TrigGlobalEfficiencyCorrectionTool (dilepton trigger) back to default.");
516 if (trigExpr ==
"multiLepton") {
518 if (ret != StatusCode::SUCCESS) {
519 ATH_MSG_ERROR(
"Cannot configure TrigGlobalEfficiencyCorrectionTool (multi-lepton trigger) back to default.");
◆ GetTriggerGlobalEfficiencySFsys() [2/2]
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 564 of file Trigger.cxx.
570 if (ret != StatusCode::SUCCESS) {
571 ATH_MSG_ERROR(
"Cannot configure TrigGlobalEfficiencyCorrectionTool (diphoton trigger) for systematic var. " << systConfig.
name() );
579 if (ret != StatusCode::SUCCESS) {
580 ATH_MSG_ERROR(
"Cannot configure TrigGlobalEfficiencyCorrectionTool (diphoton trigger) back to default.");
◆ GetTriggerOR()
| std::vector< std::string > ST::SUSYObjDef_xAOD::GetTriggerOR |
( |
const std::string & |
trigExpr | ) |
const |
Definition at line 320 of file Trigger.cxx.
322 static const std::string delOR =
"_OR_";
323 std::vector<std::string> trigchains = {};
324 std::string newtrigExpr = TString(trigExpr).Copy().ReplaceAll(
"||",delOR).Data();
325 newtrigExpr = TString(trigExpr).Copy().ReplaceAll(
" ",
"").Data();
328 while ((
pos = newtrigExpr.find(delOR)) != std::string::npos) {
329 trigchains.push_back(
"HLT_"+newtrigExpr.substr(0,
pos) );
330 newtrigExpr.erase(0,
pos + delOR.length());
332 if(
pos==std::string::npos)
333 trigchains.push_back(
"HLT_"+newtrigExpr);
◆ GetTriggerTokens()
| void ST::SUSYObjDef_xAOD::GetTriggerTokens |
( |
std::string |
trigExpr, |
|
|
std::vector< std::string > & |
v_trigs15_cache, |
|
|
std::vector< std::string > & |
v_trigs16_cache, |
|
|
std::vector< std::string > & |
v_trigs17_cache, |
|
|
std::vector< std::string > & |
v_trigs18_cache, |
|
|
std::vector< std::string > & |
v_trigs22_cache, |
|
|
std::vector< std::string > & |
v_trigs23_cache, |
|
|
std::vector< std::string > & |
v_trigs24_cache |
|
) |
| const |
Definition at line 338 of file Trigger.cxx.
342 static const std::string del15 =
"_2015_";
343 static const std::string del16 =
"_2016_";
344 static const std::string del17 =
"_2017_";
347 std::string token15, token16, token17, token18, token22, token23, token24;
350 if ( (
pos = trigExpr.find(del15)) != std::string::npos) {
351 trigExpr.erase(0,
pos + del15.length());
354 while ((
pos = trigExpr.find(del16)) != std::string::npos) {
355 token15 = trigExpr.substr(0,
pos);
356 token16 = trigExpr.erase(0,
pos + del16.length() + del17.length() - 1);
364 size_t p22 = trigExpr.find(
"2022");
365 size_t p23 = trigExpr.find(
"2023");
366 size_t p24 = trigExpr.find(
"2024");
368 auto next_pos = [&](
size_t self) {
369 size_t next = std::string::npos;
372 if (p23 >
self && p23 <
next)
next = p23;
373 if (p24 >
self && p24 <
next)
next = p24;
375 else if (
self == p23) {
376 if (p22 >
self && p22 <
next)
next = p22;
377 if (p24 >
self && p24 <
next)
next = p24;
379 else if (
self == p24) {
380 if (p22 >
self && p22 <
next)
next = p22;
381 if (p23 >
self && p23 <
next)
next = p23;
388 if (p22 != std::string::npos) {
size_t end = next_pos(p22); token22 = trigExpr.substr(p22,
end - p22);}
389 if (p23 != std::string::npos) {
size_t end = next_pos(p23); token23 = trigExpr.substr(p23,
end - p23);}
390 if (p24 != std::string::npos) {
size_t end = next_pos(p24); token24 = trigExpr.substr(p24,
end - p24);}
393 std::string* toks[] = { &token22, &token23, &token24 };
394 for (
auto t : toks) {
395 while (!
t->empty() &&
t->back() ==
'_')
t->pop_back();
400 if(token15.empty()) token15 = trigExpr;
401 if(token16.empty()) token16 = trigExpr;
402 if(token17.empty()) token17 = trigExpr;
403 if(token18.empty()) token18 = trigExpr;
406 if(token22.empty()) token22 = trigExpr;
407 if(token23.empty()) token23 = trigExpr;
408 if(token24.empty()) token24 = trigExpr;
◆ GetTrigPrescale()
| float ST::SUSYObjDef_xAOD::GetTrigPrescale |
( |
const std::string & |
tr_item | ) |
const |
|
finaloverridevirtual |
◆ handle()
| void asg::AsgMetadataTool::handle |
( |
const Incident & |
inc | ) |
|
|
protectedvirtualinherited |
Function receiving incidents from IncidentSvc/TEvent.
Reimplemented in Trig::TrigDecisionTool.
Definition at line 135 of file AsgMetadataTool.cxx.
141 if( inc.type() == IncidentType::BeginInputFile ) {
145 throw std::runtime_error(
"Couldn't call beginInputFile()" );
147 }
else if( inc.type() == IncidentType::EndInputFile ) {
150 throw std::runtime_error(
"Couldn't call endInputFile()" );
152 }
else if( inc.type() == IncidentType::BeginEvent ) {
160 throw std::runtime_error(
"Couldn't call beginInputFile()" );
165 throw std::runtime_error(
"Couldn't call beginEvent()" );
168 #ifdef XAOD_STANDALONE
169 }
else if( inc.type() == IncidentType::MetaDataStop ) {
172 throw std::runtime_error(
"Couldn't call metaDataStop()" );
175 #endif // XAOD_STANDALONE
177 ATH_MSG_WARNING(
"Unknown incident type received in AsgMetaDataTool: " << inc.type() );
◆ 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 885 of file SUSYObjDef_xAOD.cxx.
888 ATH_MSG_ERROR(
"Initialising for a second time -- something is wrong!");
889 return StatusCode::FAILURE;
895 bool autoconf(
false);
896 #ifndef XAOD_STANDALONE // For now metadata is Athena-only
899 ATH_MSG_INFO(
"Autoconfiguring: dataSource, mcCampaign, isPHYSLITE");
900 std::string projectName =
"";
902 if ( projectName ==
"IS_SIMULATION" ) {
903 std::string simFlavour =
"";
905 TString
s(simFlavour);
s.ToUpper();
907 }
else if (projectName.compare(0, 4,
"data") == 0 ) {
910 ATH_MSG_ERROR(
"Failed to autoconfigure -- project_name matches neither IS_SIMULATION nor data!");
911 return StatusCode::FAILURE;
924 ATH_MSG_FATAL(
"You must set the DataSource property to Data, FullSim or AtlfastII !!");
925 if (autoconf)
ATH_MSG_FATAL(
"Autoconfiguration seems to have failed!");
928 return StatusCode::FAILURE;
940 return StatusCode::FAILURE;
975 m_eleIdDFName =
m_eleId.find(
"DNN") == std::string::npos ?
"DFCommonElectronsLH" :
"DFCommonElectronsDNN";
976 m_eleIdDFName += TString(
m_eleId).ReplaceAll(
"LooseAndBLayer",
"LooseBL").ReplaceAll(
"LLH",
"").ReplaceAll(
"DNNnoCF",
"").ReplaceAll(
"DNN",
"").Data();
977 if (
m_eleId.find(
"noCF") != std::string::npos)
1011 return StatusCode::SUCCESS;
◆ inputHandles()
Return this algorithm's input handles.
We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.
◆ inputMetaStore()
| AsgMetadataTool::MetaStorePtr_t asg::AsgMetadataTool::inputMetaStore |
( |
| ) |
const |
|
inherited |
Accessor for the input metadata store.
Definition at line 93 of file AsgMetadataTool.cxx.
95 #ifdef XAOD_STANDALONE
97 #else // XAOD_STANDALONE
99 #endif // XAOD_STANDALONE
◆ isAtlfast()
| bool ST::SUSYObjDef_xAOD::isAtlfast |
( |
| ) |
const |
|
inlinefinaloverridevirtual |
◆ IsBadJet()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 746 of file Jets.cxx.
748 if ( !acc_passOR(input) )
return false;
753 bool isPileup = !acc_passJvt(input);
760 ATH_MSG_VERBOSE(
"DFCommon jet cleaning variable not available ... setting 'bad' decorator to 0.");
768 return acc_bad(input);
◆ IsBadMuon()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 405 of file Muons.cxx.
408 dec_bad(input) =
false;
411 dec_bad_highPt(input) =
false;
414 if (
input.muonType() == xAOD::Muon::SiliconAssociatedForwardMuon) {
415 track =
input.trackParticle(xAOD::Muon::CombinedTrackParticle);
416 if (!
track)
return false;
421 ATH_MSG_WARNING(
"Non-SAF muon without a track; cannot test IsBadMuon criteria");
428 bool isbad = Rerr > qopcut;
429 bool isbadHighPt = Rerr > qopcut;
437 dec_bad(input) = isbad;
438 dec_bad_highPt(input) = isbadHighPt;
◆ IsBJet()
◆ IsBJetContinuous()
| int ST::SUSYObjDef_xAOD::IsBJetContinuous |
( |
const xAOD::Jet & |
input | ) |
const |
|
finaloverridevirtual |
◆ IsBJetLoose()
| bool ST::SUSYObjDef_xAOD::IsBJetLoose |
( |
const xAOD::Jet & |
input | ) |
const |
|
finaloverridevirtual |
◆ IsCosmicMuon()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 444 of file Muons.cxx.
446 dec_cosmic(input) =
false;
449 if (
input.muonType() == xAOD::Muon::SiliconAssociatedForwardMuon) {
450 track =
input.trackParticle(xAOD::Muon::CombinedTrackParticle);
452 ATH_MSG_VERBOSE(
"WARNING: SAF muon without CB track found. Not possible to check cosmic muon criteria");
459 ATH_MSG_WARNING(
"Non-SAF muon without primary track particle found. Not possible to check cosmic muon criteria");
464 double mu_d0 =
track->d0();
466 double primvertex_z =
pv ?
pv->z() : 0;
467 double mu_z0_exPV =
track->z0() +
track->vz() - primvertex_z;
469 bool isCosmicMuon = (std::abs(mu_z0_exPV) >= z0cut || std::abs(mu_d0) >= d0cut);
472 ATH_MSG_VERBOSE(
"COSMIC PV Z = " << primvertex_z <<
", track z0 = " << mu_z0_exPV <<
", track d0 = " << mu_d0);
475 dec_cosmic(input) = isCosmicMuon;
◆ isData()
| bool ST::SUSYObjDef_xAOD::isData |
( |
| ) |
const |
|
inlinefinaloverridevirtual |
◆ IsHighPtMuon()
◆ IsMETTrigPassed() [1/2]
| bool ST::SUSYObjDef_xAOD::IsMETTrigPassed |
( |
const std::string & |
triggerName, |
|
|
bool |
j400_OR = false, |
|
|
const std::string & |
L1_name = "L1_XE50" |
|
) |
| const |
|
finaloverridevirtual |
◆ IsMETTrigPassed() [2/2]
| bool ST::SUSYObjDef_xAOD::IsMETTrigPassed |
( |
unsigned int |
runnumber = 0, |
|
|
bool |
j400_OR = false |
|
) |
| const |
|
finaloverridevirtual |
◆ isNominal()
◆ isPrompt()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 24 of file Truth.cxx.
26 const int type = acc_truthType(*
part);
27 int origin = acc_truthOrigin(*
part);
29 if(acc_bkgTruthOrigin.isAvailable(*
part)){
30 originbkg = acc_bkgTruthOrigin(*
part);
33 ATH_MSG_DEBUG(
"::isPrompt() : No bkgTruthOrigin decoration available. Returning false by default.");
45 case MCTruthPartClassifier::IsoElectron:
67 ATH_MSG_DEBUG(
"::isPrompt() : Only Electrons supported at the moment!");
◆ IsSignalElectron()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 362 of file Electrons.cxx.
364 if (!acc_baseline(input))
return false;
366 dec_passSignalID(input) =
false;
375 ATH_MSG_VERBOSE (
"DFCommonElectronsLHxxx variables are not found. Calculating the ID from LH tool..");
383 if (!acc_passSignalID(input))
return false;
385 if (
input.p4().Perp2() <= etcut * etcut ||
input.p4().Perp2() == 0)
return false;
386 if ( etacut==DUMMYDEF ){
387 if(std::abs(
input.caloCluster()->etaBE(2)) >
m_eleEta )
return false;
389 else if ( std::abs(
input.caloCluster()->etaBE(2)) > etacut )
return false;
392 if ( std::abs(
input.caloCluster()->etaBE(2) ) >1.37 && std::abs(
input.caloCluster()->etaBE(2) ) <1.52) {
397 if (acc_d0sig(input) != 0) {
398 if (d0sigcut > 0.0 && std::abs(acc_d0sig(input)) > d0sigcut)
return false;
401 if (z0cut > 0.0 && std::abs(acc_z0sinTheta(input)) > z0cut)
return false;
404 ATH_MSG_VERBOSE(
"IsSignalElectron: " <<
m_eleId <<
" " << acc_passSignalID(input) <<
" d0sig " << acc_d0sig(input) <<
" z0 sin(theta) " << acc_z0sinTheta(input) );
413 dec_signal(input) =
true;
◆ IsSignalJet()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 694 of file Jets.cxx.
695 if ( !acc_baseline(input) || !acc_passOR(input) )
return false;
697 if (
input.pt() <=
ptcut || std::abs(
input.eta()) >= etacut)
return false;
699 bool isgoodjet = !acc_bad(input) && acc_passJvt(input);
701 dec_signal(input) = isgoodjet;
704 dec_signal_less_JVT(input) = !acc_bad(input);
708 float emfrac, hecf, LArQuality, HECQuality, Timing, fracSamplingMax, NegativeE, AverageLArQF;
709 std::vector<float> sumpttrk_vec;
722 if (!sumpttrk_vec.empty() && this->GetPrimVtx()) {
736 ATH_MSG_INFO(
"JET fracSamplingMax: " << fracSamplingMax );
◆ IsSignalMuon()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 344 of file Muons.cxx.
346 if (!acc_baseline(input))
return false;
347 if (!acc_passSignalID(input))
return false;
350 if ( etacut==DUMMYDEF ){
353 else if ( std::abs(
input.eta()) > etacut )
return false;
355 if (z0cut > 0.0 && std::abs(acc_z0sinTheta(input)) > z0cut)
return false;
356 if (acc_d0sig(input) != 0) {
357 if (d0sigcut > 0.0 && std::abs(acc_d0sig(input)) > d0sigcut)
return false;
368 dec_signal(input) =
true;
372 <<
" signal? " <<
static_cast<int>(acc_signal(input))
373 <<
" isolation? " <<
static_cast<int>(acc_isol(input))
374 <<
" passedHighPtCuts? " <<
static_cast<int>(acc_passedHighPtCuts(input)));
377 <<
" signal? " <<
static_cast<int>( acc_signal(input))
378 <<
" isolation? " <<
static_cast<int>( acc_isol(input)));
382 return acc_signal(input);
◆ IsSignalPhoton()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 167 of file Photons.cxx.
169 dec_signal(input) =
false;
171 if ( !acc_baseline(input) )
return false;
176 if ( etacut==DUMMYDEF ){
179 else if ( std::abs(
input.caloCluster()->etaBE(2)) > etacut )
return false;
182 if ( std::abs(
input.caloCluster()->etaBE(2) ) >1.37 && std::abs(
input.caloCluster()->etaBE(2) ) <1.52) {
195 ATH_MSG_VERBOSE (
"DFCommonPhotonsIsEMxxx variables are not found. Calculating the ID from Photon ID tool..");
198 if ( !passID )
return false;
200 dec_signal(input) =
true;
◆ IsSignalTau()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 112 of file Taus.cxx.
114 dec_signal(input) =
false;
116 if ( !acc_baseline(input) )
return false;
120 if (std::abs(
input.eta()) >= etacut)
return false;
124 dec_signal(input) =
true;
◆ IsTrackBJet()
| bool ST::SUSYObjDef_xAOD::IsTrackBJet |
( |
const xAOD::Jet & |
input | ) |
const |
|
finaloverridevirtual |
◆ IsTrackBJetContinuous()
| int ST::SUSYObjDef_xAOD::IsTrackBJetContinuous |
( |
const xAOD::Jet & |
input | ) |
const |
|
finaloverridevirtual |
◆ isTrigInTDT()
| bool ST::SUSYObjDef_xAOD::isTrigInTDT |
( |
std::scoped_lock< std::mutex > & |
lock, |
|
|
const std::string & |
triggerName |
|
) |
| const |
|
private |
Definition at line 83 of file Trigger.cxx.
86 auto mapItr = m_checkedTriggers.find(triggerName);
87 if ( mapItr == m_checkedTriggers.end() ) {
92 return mapItr->second;
◆ IsTrigMatched() [1/4]
◆ IsTrigMatched() [2/4]
◆ IsTrigMatched() [3/4]
◆ IsTrigMatched() [4/4]
◆ IsTrigPassed()
| bool ST::SUSYObjDef_xAOD::IsTrigPassed |
( |
const std::string & |
tr_item, |
|
|
unsigned int |
condition = TrigDefs::Physics |
|
) |
| const |
|
finaloverridevirtual |
◆ IsTruthBJet()
| bool ST::SUSYObjDef_xAOD::IsTruthBJet |
( |
const xAOD::Jet & |
input | ) |
const |
|
finaloverridevirtual |
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 301 of file Truth.cxx.
304 if (acc_signal(input)) {
307 if (!
input.getAttribute(
"HadronConeExclTruthLabelID", truthlabel)) {
311 isBjet = std::abs(truthlabel) == 5;
315 dec_bjet_jetunc(input) = isBjet;
◆ isVariation()
◆ isWeight()
Definition at line 2115 of file SUSYObjDef_xAOD.cxx.
2117 bool affectsWeights =
false;
2118 for (
const auto&
sys : systSet) {
2120 if(
info.affectsKinematics) {
return false; }
2121 affectsWeights = affectsWeights or
info.affectsWeights;
2123 return affectsWeights;
◆ JetPassJVT()
| bool ST::SUSYObjDef_xAOD::JetPassJVT |
( |
xAOD::Jet & |
input | ) |
|
|
finaloverridevirtual |
◆ JVT_SF()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 989 of file Jets.cxx.
997 if (acc_signal_less_JVT(*
jet) && acc_passOR(*
jet)) {
998 jvtjets.push_back(
jet);
1003 float current_sf = 0;
1007 if (acc_passJvt(*
jet)) {
1021 ATH_MSG_VERBOSE(
"Skip SF application in SUSYTools_xAOD::JVT_SF as jet outside validate range" );
1024 ATH_MSG_VERBOSE(
"Retrieve SF for jet in SUSYTools_xAOD::JVT_SF with value " << current_sf );
1025 totalSF *= current_sf;
1030 ATH_MSG_VERBOSE(
"Retrieve total SF for jet container in SUSYTools_xAOD::JVT_SF with value " << totalSF );
◆ JVT_SFsys()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 1036 of file Jets.cxx.
1043 if ( ret != StatusCode::SUCCESS) {
1044 ATH_MSG_ERROR(
"Cannot configure NNjvtEfficiencyTool for systematic var. " << systConfig.
name() );
1053 if ( ret != StatusCode::SUCCESS) {
1054 ATH_MSG_ERROR(
"Cannot configure NNjvtEfficiencyTool for systematic var. " << systConfig.
name() );
◆ MergeElectrons()
◆ MergeMuons()
◆ metaDataStop()
| StatusCode asg::AsgMetadataTool::metaDataStop |
( |
| ) |
|
|
protectedvirtualinherited |
◆ msg() [1/2]
◆ msg() [2/2]
◆ 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.
◆ msgLvl()
◆ NearbyLeptonCorrections()
◆ outputHandles()
Return this algorithm's output handles.
We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.
◆ outputMetaStore()
| AsgMetadataTool::MetaStorePtr_t asg::AsgMetadataTool::outputMetaStore |
( |
| ) |
const |
|
inherited |
Accessor for the output metadata store.
Definition at line 102 of file AsgMetadataTool.cxx.
104 #ifdef XAOD_STANDALONE
106 #else // XAOD_STANDALONE
108 #endif // XAOD_STANDALONE
◆ OverlapRemoval()
◆ prepareLRTElectrons()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 90 of file Electrons.cxx.
95 if ( acc_lrtFilter.isAvailable(*idtrack) )
97 if (
static_cast<int>(acc_lrtFilter(*idtrack) ) ){
98 std::unique_ptr<xAOD::Electron> copyElectron = std::make_unique<xAOD::Electron>(*
electron);
103 copy->push_back( std::move(copyElectron) );
108 std::unique_ptr<xAOD::Electron> copyElectron = std::make_unique<xAOD::Electron>(*
electron);
111 copy->push_back( std::move(copyElectron) );
114 return StatusCode::SUCCESS;
◆ prepareLRTMuons()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 74 of file Muons.cxx.
79 if ( acc_lrtFilter.isAvailable(*idtrack) )
81 if (
static_cast<int>(acc_lrtFilter(*idtrack) ) ){
82 std::unique_ptr<xAOD::Muon> copyMuon = std::make_unique<xAOD::Muon>(*
muon);
86 copy->push_back( std::move(copyMuon) );
91 std::unique_ptr<xAOD::Muon> copyMuon = std::make_unique<xAOD::Muon>(*
muon);
94 copy->push_back( std::move(copyMuon) );
98 return StatusCode::SUCCESS;
◆ print() [1/2]
| void asg::AsgTool::print |
( |
| ) |
const |
|
virtualinherited |
Print the state of the tool.
Implements asg::IAsgTool.
Reimplemented in JetRecTool, JetFinder, JetModifiedMassDrop, JetFromPseudojet, JetReclusterer, JetReclusteringTool, JetTruthLabelingTool, JetPileupLabelingTool, HI::HIPileupTool, LundVariablesTool, JetDumper, JetBottomUpSoftDrop, JetRecursiveSoftDrop, JetSoftDrop, JetConstituentsRetriever, JetSubStructureMomentToolsBase, JetSplitter, JetToolRunner, JetPruner, JetPseudojetRetriever, JetTrimmer, AsgHelloTool, and KtDeltaRTool.
Definition at line 131 of file AsgTool.cxx.
◆ print() [2/2]
| virtual void asg::IAsgTool::print |
( |
| ) |
const |
|
pure virtualinherited |
Print the state of the tool.
Implemented in JetRecTool, JetFinder, JetModifiedMassDrop, JetFromPseudojet, JetReclusterer, JetReclusteringTool, JetTruthLabelingTool, JetPileupLabelingTool, HI::HIPileupTool, LundVariablesTool, asg::AsgTool, JetDumper, JetBottomUpSoftDrop, JetRecursiveSoftDrop, JetSoftDrop, JetConstituentsRetriever, JetSubStructureMomentToolsBase, JetSplitter, JetToolRunner, JetPruner, JetPseudojetRetriever, JetTrimmer, AsgHelloTool, and KtDeltaRTool.
◆ readConfig()
| StatusCode ST::SUSYObjDef_xAOD::readConfig |
( |
| ) |
|
|
finaloverrideprotectedvirtual |
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 1335 of file SUSYObjDef_xAOD.cxx.
1342 success = rEnv.ReadFile(
m_configFile.c_str(), kEnvAll);
1343 if (success != 0)
return StatusCode::FAILURE;
1352 rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(
"Jet.InputType") );
1355 int muIdTmp = rEnv.GetValue(
"Muon.Id", 1);
1356 m_muId = (muIdTmp<4 ? static_cast<int>(xAOD::Muon::Quality(muIdTmp)) : muIdTmp);
1359 rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(
"Muon.Id") );
1362 int muIdTmp = rEnv.GetValue(
"MuonBaseline.Id", 1);
1363 m_muIdBaseline = (muIdTmp<4 ? static_cast<int>(xAOD::Muon::Quality(muIdTmp)) : muIdTmp);
1366 rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(
"MuonBaseline.Id") );
1370 std::string prop = rEnv.GetValue(
"Jet.JVT_WP",
"");
1371 if ( !prop.empty() ) {
1372 ATH_MSG_WARNING(
"readConfig(): Found deprecated property name Jet.JVT_WP. Please move to using Jet.JvtWP. Propagating for now.");
1373 rEnv.SetValue(
"Jet.JvtWP", prop.c_str());
1374 rEnv.GetTable()->Remove( rEnv.GetTable()->FindObject(
"Jet.JVT_WP") );
1383 m_conf_to_prop[
"EleBaseline.CrackVeto"] =
"EleBaselineCrackVeto";
1385 m_conf_to_prop[
"Ele.AllowRun3TrigSFFallback"] =
"EleAllowRun3TrigSFFallback";
1389 m_conf_to_prop[
"PhotonBaseline.CrackVeto"] =
"PhotonBaselineCrackVeto";
1397 m_conf_to_prop[
"OR.DoMuonJetGhostAssociation"] =
"ORDoMuonJetGhostAssociation";
1412 m_conf_to_prop[
"Trigger.UpstreamMatching"] =
"TriggerUpstreamMatching";
1418 m_conf_to_prop[
"SigLepPh.IsoCloseByOR"] =
"SigLepPhIsoCloseByOR";
1419 m_conf_to_prop[
"MET.RemoveOverlappingCaloTaggedMuons"] =
"METRemoveORCaloTaggedMuons";
1420 m_conf_to_prop[
"MET.DoSetMuonJetEMScale"] =
"METDoSetMuonJetEMScale";
1472 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");
1473 configFromFile(
m_eleEffMapFilePath,
"Ele.EffMapFilePath", rEnv,
"ElectronEfficiencyCorrection/2015_2025/rel22.2/2025_Run3_Consolidated_Recommendation_v4/map2.txt");
1485 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");
1486 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");
1487 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");
1488 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");
1491 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");
1492 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");
1493 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");
1494 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");
1578 configFromFile(
m_WtagConfig,
"Jet.WtaggerConfig", rEnv,
"SmoothedContainedWTagger_AntiKt10UFOCSSKSoftDrop_FixedSignalEfficiency80_20220221.dat");
1579 configFromFile(
m_ZtagConfig,
"Jet.ZtaggerConfig", rEnv,
"SmoothedContainedZTagger_AntiKt10UFOCSSKSoftDrop_FixedSignalEfficiency80_20220221.dat");
1584 configFromFile(
m_jesConfig,
"Jet.JESConfig", rEnv,
m_isRun3 ?
"AntiKt4EMPFlow_MC23a_PreRecR22_Phase2_CalibConfig_ResPU_EtaJES_GSC_241208_InSitu.config" :
"PreRec_R22_PFlow_ResPU_EtaJES_GSC_February23_230215.config");
1585 configFromFile(
m_jesConfigAFII,
"Jet.JESConfigAFII", rEnv,
m_isRun3 ?
"AntiKt4EMPFlow_MC23a_PreRecR22_Phase2_CalibConfig_ResPU_EtaJES_GSC_241208_InSitu.config" :
"PreRec_R22_PFlow_ResPU_EtaJES_GSC_February23_230215.config");
1586 configFromFile(
m_jesConfigJMS,
"Jet.JESConfigJMS", rEnv,
"JES_JMS_MC16Recommendation_Consolidated_MC_only_EMTopo_July2019_Rel21.config");
1588 configFromFile(
m_jesConfigFat,
"Jet.JESConfigFat", rEnv,
"JES_MC20PreRecommendation_R10_UFO_CSSK_SoftDrop_JMS_R21Insitu_26Nov2024.config");
1697 configFromFile(
m_prwActualMu2017File,
"PRW.ActualMu2017File", rEnv,
"GoodRunsLists/data17_13TeV/20180619/physics_25ns_Triggerno17e33prim.actualMu.OflLumi-13TeV-010.root");
1698 configFromFile(
m_prwActualMu2018File,
"PRW.ActualMu2018File", rEnv,
"GoodRunsLists/data18_13TeV/20190318/physics_25ns_Triggerno17e33prim.actualMu.OflLumi-13TeV-010.root");
1710 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");
1723 if (rEnv.GetTable() && rEnv.GetTable()->GetSize()>0){
1724 ATH_MSG_ERROR(
"Found " << rEnv.GetTable()->GetSize() <<
" unparsed environment options:");
1727 return StatusCode::FAILURE;
1732 if (
m_WtagConfig.find(
"Efficiency50") != std::string::npos){
1735 else if (
m_WtagConfig.find(
"Efficiency80") != std::string::npos){
1739 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");
1743 if (
m_ZtagConfig.find(
"Efficiency50") != std::string::npos){
1746 else if (
m_ZtagConfig.find(
"Efficiency80") != std::string::npos){
1750 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");
1753 std::string TopTagEff =
"";
1754 std::string TopTagType =
"";
1763 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");
1767 TopTagType =
"Inclusive";
1770 TopTagType =
"Contained";
1773 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");
1775 m_TopTagUncConfig =
"R10_SF_LCTopo_TopTag"+TopTagType+
"_SigEff"+TopTagEff+
".config";
1807 return StatusCode::SUCCESS;
◆ renounce()
◆ renounceArray()
◆ resetSystematics()
| StatusCode ST::SUSYObjDef_xAOD::resetSystematics |
( |
| ) |
|
|
finaloverridevirtual |
◆ setBoolProperty()
| StatusCode ST::SUSYObjDef_xAOD::setBoolProperty |
( |
const std::string & |
name, |
|
|
const bool & |
property |
|
) |
| |
|
finaloverridevirtual |
◆ SetBtagWeightDecorations()
Implements ST::ISUSYObjDef_xAODTool.
Definition at line 1156 of file Jets.cxx.
1159 ATH_MSG_ERROR( btagSelTool->name() <<
": could not retrieve b-tag weight (" << btagTagger <<
")." );
1160 return StatusCode::FAILURE;
1162 dec_btag_weight(input) =
weight;
1165 double btag_pb(-10), btag_pc(-10), btag_pu(-10), btag_ptau(-10);
1167 std::string actualTagger = btagTagger;
1168 if (btagTagger ==
"GN2v00LegacyWP" || btagTagger ==
"GN2v00NewAliasWP"){
1169 actualTagger =
"GN2v00";
1175 dec_btag_pb(input) = btag_pb;
1176 dec_btag_pc(input) = btag_pc;
1177 dec_btag_pu(input) = btag_pu;
1178 dec_btag_ptau(input) = btag_ptau;
1179 ATH_MSG_DEBUG( btagSelTool->name() <<
" b-tag " << btagTagger <<
"-type pb: " << btag_pb );
1180 ATH_MSG_DEBUG( btagSelTool->name() <<
" b-tag " << btagTagger <<
"-type pc: " << btag_pc );
1181 ATH_MSG_DEBUG( btagSelTool->name() <<
" b-tag " << btagTagger <<
"-type pu: " << btag_pu );
1182 ATH_MSG_DEBUG( btagSelTool->name() <<
" b-tag " << btagTagger <<
"-type ptau: " << btag_ptau );
1184 if ( btagSelTool->name().find(
"DL1")!=std::string::npos ) {
1185 dec_btag_dl1pb(input) = btag_pb;
1186 dec_btag_dl1pc(input) = btag_pc;
1187 dec_btag_dl1pu(input) = btag_pu;
1190 dec_btag_dl1pb(input) = -10;
1191 dec_btag_dl1pc(input) = -10;
1192 dec_btag_dl1pu(input) = -10;
1194 return StatusCode::SUCCESS;
◆ setDataSource()
| void ST::SUSYObjDef_xAOD::setDataSource |
( |
int |
source | ) |
|
◆ setUseIncidents()
| void asg::AsgMetadataTool::setUseIncidents |
( |
const bool |
flag | ) |
|
|
inlineprotectedinherited |
◆ split()
| const std::vector< std::string > ST::SUSYObjDef_xAOD::split |
( |
const std::string & |
s, |
|
|
const std::string & |
delim |
|
) |
| const |
|
protected |
Definition at line 1811 of file SUSYObjDef_xAOD.cxx.
1812 assert(delim.length() == 1);
1813 std::vector<std::string>
retval;
1816 if (
s.find(delim)==std::string::npos) {
1824 while ((
next =
s.find(delim, last)) != std::string::npos) {
1826 last =
next + delim.length();
1830 retval.emplace_back(
s.substr(last));
◆ SUSYToolsInit()
| StatusCode SUSYObjDef_xAOD::SUSYToolsInit |
( |
| ) |
|
|
private |
Definition at line 113 of file SUSYToolsInit.cxx.
117 ATH_MSG_FATAL(
"You must set the DataSource property to Data, FullSim or AtlfastII !!");
118 ATH_MSG_FATAL(
"Expect segfaults if you're not checking status codes, which you should be !!");
119 return StatusCode::FAILURE;
123 ATH_MSG_INFO(
"SUSYTools subtools already created. Ignoring this call.");
124 ATH_MSG_INFO(
"Note: No longer necessary to explicitly call SUSYToolsInit. Will avoid creating tools again.");
125 return StatusCode::SUCCESS;
133 std::vector<std::string> file_conf;
139 std::vector<std::string> file_ilumi;
169 ATH_MSG_WARNING(
"Please note that current ID recommendations only cover mc23a and not (yet) mc23d/e!");
173 ATH_CHECK(
m_LRTuncTool.
setProperty(
"calibFileLRTEff",
"InDetTrackSystematicsTools/CalibData_24.0_2023-v00/LargeD0TrackingRecommendations_20230824.root") );
176 ATH_MSG_INFO(
"Using user-configured LRT uncertainty tool");
180 std::string toolName;
182 std::string jetname,
jetcoll,fatjetcoll;
192 toolName =
"JetCalibTool_" + jetname;
194 std::string JES_config_file, calibseq;
198 return StatusCode::FAILURE;
203 ATH_MSG_WARNING(
"Jet JES/JER recommendations currently not available for fast sim in Run 3, falling back to full sim version");
208 JES_config_file = JESconfig;
212 std::string insitu(
"_Insitu");
213 auto found = calibseq.find(insitu);
214 if(
found != std::string::npos){
215 calibseq.erase(
found, insitu.length());
221 ATH_MSG_ERROR(
"JMS calibration is not supported yet for R22. Please modify your settings.");
222 return StatusCode::FAILURE;
240 if(fatjetcoll ==
"AnalysisLargeRJets") {
241 ATH_MSG_DEBUG(
"Fall back to calibration for AntiKt10UFOCSSKSoftDropBeta100Zcut10Jets, original name for AnalysisLargeRJets");
242 fatjetcoll =
"AntiKt10UFOCSSKSoftDropBeta100Zcut10Jets";
244 if (fatjetcoll.size()>3)fatjetcoll.erase(fatjetcoll.size()-4,4);
246 toolName =
"JetFatCalibTool_" +
m_fatJets;
252 if(
isData()) jesCalibSeqFat +=
"_Insitu";
276 #ifndef XAOD_STANDALONE
285 ATH_MSG_ERROR(
"Error while reading large-R config file : " << WConfigPath );
286 return StatusCode::FAILURE;
288 else ATH_MSG_DEBUG(
"Successfully read large-R config file : " << WConfigPath );
303 #ifndef XAOD_STANDALONE
312 ATH_MSG_ERROR(
"Error while reading large-R config file : " << ZConfigPath );
313 return StatusCode::FAILURE;
315 else ATH_MSG_DEBUG(
"Successfully read large-R config file : " << ZConfigPath );
330 #ifndef XAOD_STANDALONE
339 ATH_MSG_ERROR(
"Error while reading large-R config file : " << TopConfigPath );
340 return StatusCode::FAILURE;
342 else ATH_MSG_DEBUG(
"Successfully read large-R config file : " << TopConfigPath );
389 if(jetdef !=
"AntiKt4EMPFlow"){
390 ATH_MSG_WARNING(
"Jet Uncertaintes recommendations only exist for PFlow jets, falling back to AntiKt4EMPFlow");
391 jetdef =
"AntiKt4EMPFlow";
393 toolName =
"JetUncertaintiesTool_" + jetdef;
407 ATH_MSG_INFO(
"Set up Jet PD Smear Uncertainty tool...");
412 if(jetdef !=
"AntiKt4EMPFlow"){
413 ATH_MSG_WARNING(
"Jet Uncertaintes recommendations only exist for PFlow jets, falling back to AntiKt4EMPFlow");
414 jetdef =
"AntiKt4EMPFlow";
416 toolName =
"JetUncertaintiesPDSmearTool_" + jetdef;
423 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.");
424 return StatusCode::FAILURE;
435 ATH_MSG_DEBUG(
"Do not retrieve the jet PD Smearing tool if it is not configured");
449 ATH_MSG_WARNING(
"Uncertainties for large-R jets in mc23 and fast simulation not yet available; be aware uncertainties might be not complete!");
451 toolName =
"JetUncertaintiesTool_" +
m_fatJets;
462 std::vector<std::string> shift_vars = {};
467 shift_vars.push_back(
temp.substr(0,
pos));
468 if (
pos == std::string::npos)
474 while (!
temp.empty() );
486 ATH_MSG_INFO(
"Set up Jet PD Smear Uncertainty tool...");
488 toolName =
"JetUncertaintiesPDSmearTool_" +
m_fatJets;
493 if (
m_fatJetUncConfig.find(
"SimpleJER") != std::string::npos && JERUncPDsmearing){
494 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.");
495 return StatusCode::FAILURE;
506 ATH_MSG_DEBUG(
"Do not retrieve the jet PD Smearing tool if it is not configured");
515 toolName =
"FFJetSmearingTool_" +
m_fatJets;
528 ATH_MSG_INFO(
"The following uncertainties have been defined for the m_fatjetFFSmearingTool");
535 ATH_MSG_INFO(
" Won't initialise Wtagger uncertainty tool for fat jets until we get rec for UFO");
550 ATH_MSG_INFO(
" Won't initialise Ztagger uncertainty tool for fat jets until we get rec for UFO");
565 ATH_MSG_INFO(
" Won't initialise top-tagger uncertainty tool for fat jets until we get rec for UFO");
593 toolName =
"JetCleaningTool";
605 toolName =
"PileupLabelingTool";
609 #ifndef XAOD_STANDALONE
621 toolName =
"JvtMomentTool";
624 #ifndef XAOD_STANDALONE
637 toolName =
"NNJvtMomentTool";
640 #ifndef XAOD_STANDALONE
652 toolName =
"NNJvtSelectionTool";
666 toolName =
"NNJvtEfficiencyTool";
680 toolName =
"fJvtSelectionTool";
694 toolName =
"fJvtEfficiencyTool";
710 std::string muQualBaseline =
"";
713 ATH_MSG_WARNING(
"No muon scale factors are available for VeryLoose working point.");
718 case 4: muQualBaseline =
"HighPt";
break;
719 case 5: muQualBaseline =
"LowPt";
break;
720 case 6: muQualBaseline =
"LowPtMVA";
break;
721 case 7: muQualBaseline =
"HighPt3Layers";
break;
724 return StatusCode::FAILURE;
741 if (IdBaselineInt == 4) {
752 toolName =
"MuonSelectionTool_Baseline_" + muQualBaseline;
758 ") that is tighter than the signal cut (" <<
m_muEta <<
"). Please check your config." );
759 return StatusCode::FAILURE;
763 if (IdBaselineInt == 6){
766 }
else if (IdBaselineInt == 7){
775 std::string muQual =
"";
778 ATH_MSG_WARNING(
"No muon scale factors are available for VeryLoose working point.");
783 case 4: muQual =
"HighPt";
break;
784 case 5: muQual =
"LowPt";
break;
785 case 6: muQual =
"LowPtMVA";
break;
786 case 7: muQual =
"HighPt3Layers";
break;
788 ATH_MSG_ERROR(
"Invalid muon working point provided: " <<
m_muId <<
". Cannot initialise!");
789 return StatusCode::FAILURE;
794 toolName =
"MuonSelectionTool_" + muQual;
802 }
else if (IdInt == 7){
812 toolName =
"MuonSelectionHighPtTool_" + muQual;
825 toolName =
"MuonLRTOverlapRemovalTool";
836 toolName =
"MuonEfficiencyScaleFactors_" + muQual;
846 toolName =
"MuonEfficiencyScaleFactorsBMHighPt_" + muQual;
856 ATH_MSG_WARNING(
"Requested TTVA SFs without d0sig and z0 cuts. Disabling scale factors as they will not make sense.");
861 toolName =
"MuonTTVAEfficiencyScaleFactors";
874 toolName =
"MuonIsolationScaleFactors_" +
m_muIso_WP;
880 <<
") does not have SFs defined. Will try to find an appropriate fall-back.");
885 <<
" is not supported, and does not have SFs available. Falling back to "
887 <<
" for SF determination.");
889 ATH_MSG_ERROR(
"*** The muon isolation WP you selected (" <<
m_muIso_WP <<
") is not currentely supported, and no known fall-back option for SFs exists. Sorry! ***");
890 return StatusCode::FAILURE;
910 <<
") does not have SFs defined. Will try to find an appropriate fall-back.");
915 <<
" is not supported, and does not have SFs available. Falling back to "
916 << tmp_muIsoHighPt_WP
917 <<
" for SF determination.");
919 ATH_MSG_ERROR(
"*** The muon isolation WP you selected (" <<
m_muIsoHighPt_WP <<
") is not currentely supported, and no known fall-back option for SFs exists. Sorry! ***");
920 return StatusCode::FAILURE;
938 toolName =
"MuonTriggerScaleFactors_" + muQual;
940 if ( muQual==
"LowPt" ) {
941 ATH_MSG_WARNING(
"You're using the LowPt muon selection, which is not supported yet in terms of muon trigger scale facorts. TEMPORAIRLY configuring the muonTriggerSFTool for Medium muons. Beware!");
964 toolName =
"EleSelLikelihood_" +
m_eleId;
966 if (
m_eleId.find(
"DNN") != std::string::npos) {
974 ATH_MSG_INFO(
"Overriding specified Ele.Id working point in favour of configuration file");
978 return StatusCode::FAILURE;
981 ATH_MSG_WARNING(
" ****************************************************************************");
983 ATH_MSG_WARNING(
" These may be used for loose electron CRs but no scale factors are provided.");
984 ATH_MSG_WARNING(
" ****************************************************************************");
1006 ATH_MSG_INFO(
"Overriding specified EleBaseline.Id working point in favour of configuration file");
1010 return StatusCode::FAILURE;
1023 toolName =
"ElectronLRTOverlapRemovalTool";
1040 return StatusCode::FAILURE;
1054 return StatusCode::FAILURE;
1087 ATH_MSG_INFO(
"Running on Run2 samples; Using egamma SF tools from R21 map ");
1091 toolName =
"AsgElectronEfficiencyCorrectionTool_reco";
1102 std::string eleId = TString(
m_eleId).ReplaceAll(
"AndBLayer",
"BLayer").ReplaceAll(
"LLH",
"").Data();
1104 if (
m_eleId.find(
"DNN") != std::string::npos) {
1105 eleId = TString(eleId).ReplaceAll(
"DNNnoCF",
"").ReplaceAll(
"DNN",
"").ReplaceAll(
"Loose",
"LooseBLayer").Data();
1106 ATH_MSG_WARNING(
"Electron DNN ID working point " <<
m_eleId <<
" doesn't have SFs yet, fall back to " << eleId);
1110 toolName =
"AsgElectronEfficiencyCorrectionTool_id_" +
m_eleId;
1114 std::map<std::string,std::string> corrFNList;
1117 std::string
WP = WP_fname.substr(0,WP_fname.find(
":"));
1118 std::string
fname = WP_fname.substr(WP_fname.find(
":")+1);
1121 ATH_MSG_WARNING(
"Will use correction file rather than central map file." );
1126 std::string EleIso(
"");
1132 ATH_MSG_WARNING(
"(AsgElectronEfficiencyCorrectionTool_iso_*) Your selected electron Iso WP ("
1134 <<
") does not have iso SFs defined. Falling back to "
1136 <<
" for SF calculations");
1140 return StatusCode::FAILURE;
1143 toolName =
"AsgElectronEfficiencyCorrectionTool_iso_" +
m_eleId + EleIso;
1146 if ( (!
m_EG_corrFNList.empty()) && corrFNList.find(EleIso)!=corrFNList.end() ) {
1153 ATH_MSG_WARNING(
"(" << toolName <<
") Your electron Iso WP: " << EleIso<<
" is no longer supported. This will almost certainly cause a crash now.");
1165 if (!
isData() && ((EleIso.find(
"TightTrackOnly_VarRad")!=std::string::npos)||
1166 (EleIso.find(
"TightTrackOnly_FixedRad")!=std::string::npos)||
1167 (EleIso.find(
"Tight_VarRad")!=std::string::npos)||
1168 (EleIso.find(
"Loose_VarRad")!=std::string::npos))) {
1169 if (
isAtlfast())
ATH_MSG_WARNING(
"(AsgElectronEfficiencyCorrectionTool/"+toolName+
"). Your selected electron Iso WP (" + EleIso +
") don't have AFII SF. Falling back to FullSim");
1182 std::string EleIsohighPt(
"");
1188 ATH_MSG_WARNING(
"(AsgElectronEfficiencyCorrectionTool_iso_*) Your selected high-pT electron Iso WP ("
1190 <<
") does not have iso SFs defined. Falling back to "
1192 <<
" for SF calculations");
1196 return StatusCode::FAILURE;
1199 toolName =
"AsgElectronEfficiencyCorrectionTool_isoHigPt_" +
m_eleId + EleIsohighPt;
1202 if ( (!
m_EG_corrFNList.empty()) && corrFNList.find(EleIsohighPt)!=corrFNList.end() ) {
1210 ATH_MSG_WARNING(
"(" << toolName <<
") Your electron high-pt Iso WP: " << EleIsohighPt <<
" is no longer supported. This will almost certainly cause a crash now.");
1231 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);
1232 std::string triggerEleID =
m_isRun3? TString(eleId).ReplaceAll(
"LooseBLayer",
"Loose").Data() : eleId;
1238 bool pass_isRun3TrigSFFallback =
true;
1239 if (triggerEleID.find(
"Medium") != std::string::npos && triggerEleIso.find(
"Loose") != std::string::npos) {triggerEleID =
"Loose";}
1240 else if (triggerEleID.find(
"Medium") != std::string::npos && triggerEleIso.find(
"Tight") != std::string::npos) {triggerEleID =
"Tight"; triggerEleIso =
"Tight_VarRad";}
1241 else if (triggerEleID.find(
"Medium") != std::string::npos && triggerEleIso.find(
"HighPtCaloOnly") != std::string::npos) {triggerEleID =
"Tight"; triggerEleIso =
"Tight_VarRad";}
1242 else if (triggerEleID.find(
"Tight") != std::string::npos && triggerEleIso.find(
"Loose") != std::string::npos) {triggerEleID =
"Loose";}
1243 else if (triggerEleID.find(
"Tight") != std::string::npos && triggerEleIso.find(
"Tight") != std::string::npos) {triggerEleIso=
"Tight_VarRad";}
1244 else if (triggerEleID.find(
"Tight") != std::string::npos && triggerEleIso.find(
"HighPtCaloOnly") != std::string::npos) {triggerEleID =
"Tight"; triggerEleIso =
"Tight_VarRad";}
1245 else if (triggerEleID.find(
"Loose") != std::string::npos && triggerEleIso.find(
"Tight") != std::string::npos) {triggerEleID =
"Loose"; triggerEleIso =
"Loose_VarRad";}
1246 else if (triggerEleID.find(
"Loose") != std::string::npos && triggerEleIso.find(
"HighPtCaloOnly") != std::string::npos) {triggerEleID =
"Loose"; triggerEleIso =
"Loose_VarRad";}
1247 else {pass_isRun3TrigSFFallback=
false;}
1248 if(pass_isRun3TrigSFFallback){
1249 ATH_MSG_INFO(
" ************** This is only for testing/studying purpose! ************** ");
1250 ATH_MSG_INFO(
" ************** For official recommendation, please get in contact with the SUSY Bkg Forum ************** ");
1251 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' ");
1252 ATH_MSG_INFO(
"Only for single-lepton trigger scale factor, fall back to Electron ID: -> "<< triggerEleID <<
" with Isolation: " << triggerEleIso);
1264 auto next_pos = [&](
size_t self) {
1265 size_t next = std::string::npos;
1268 if (p23 >
self && p23 <
next)
next = p23;
1269 if (p24 >
self && p24 <
next)
next = p24;
1271 else if (
self == p23) {
1272 if (p22 >
self && p22 <
next)
next = p22;
1273 if (p24 >
self && p24 <
next)
next = p24;
1275 else if (
self == p24) {
1276 if (p22 >
self && p22 <
next)
next = p22;
1277 if (p23 >
self && p23 <
next)
next = p23;
1282 std::string SFStringSingle22=
"";
1283 std::string SFStringSingle23=
"";
1284 std::string SFStringSingle24=
"";
1292 std::string* toks[] = { &SFStringSingle22, &SFStringSingle23, &SFStringSingle24 };
1293 for (
auto t : toks) {
1294 while (!
t->empty() &&
t->back() ==
'_')
t->pop_back();
1301 ATH_MSG_WARNING(
"Unknown or unsupported mcCampaign for Run 3: " <<
m_mcCampaign <<
". Please contact the SUSY Bkg Forum for assistance.");
1302 ATH_MSG_WARNING(
"Falling back to 2024 trigger SFs for single-electron triggers.");
1315 ATH_MSG_WARNING(
"(AsgElectronEfficiencyCorrectionTool_trig_singleLep_*) Your selected electron Iso WP ("
1317 <<
") does not have trigger SFs defined. Falling back to "
1319 <<
" for SF calculations");
1323 return StatusCode::FAILURE;
1326 toolName =
"AsgElectronEfficiencyCorrectionTool_trig_singleLep_" + triggerEleID;
1342 toolName =
"AsgElectronEfficiencyCorrectionTool_trigEff_singleLep_" + triggerEleID;
1359 std::map<std::string,std::string> electronTriggerSFMapMixedLepton {
1361 {
"e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose,e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0",
m_electronTriggerSFStringSingle},
1362 {
"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"},
1363 {
"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"},
1364 {
"e17_lhloose,e17_lhloose_nod0",
"MULTI_L_2015_e17_lhloose_2016_2018_e17_lhloose_nod0"},
1365 {
"e12_lhloose,e12_lhloose_nod0",
"MULTI_L_2015_e12_lhloose_2016_2018_e12_lhloose_nod0"},
1366 {
"e7_lhmedium,e7_lhmedium_nod0",
"MULTI_L_2015_e7_lhmedium_2016_2018_e7_lhmedium_nod0"},
1367 {
"e9_lhloose,e9_lhloose_nod0,e12_lhvloose_nod0_L1EM10VH",
"TRI_E_2015_e9_lhloose_2016_e9_lhloose_nod0_2017_2018_e12_lhvloose_nod0_L1EM10VH"}
1373 if (triglist_2017to2018.find(
"2e17_lhvloose_nod0_L12EM15VHI") != std::string::npos) {
1374 electronTriggerSFMapMixedLepton[
"e17_lhvloose_nod0_L1EM15VHI"] =
"DI_E_2015_e12_lhloose_L1EM10VH_2016_e17_lhvloose_nod0_2017_2018_e17_lhvloose_nod0_L1EM15VHI";
1377 std::string triggerMixedEleIso(
"");
1379 for(
auto const&
item : electronTriggerSFMapMixedLepton){
1386 ATH_MSG_WARNING(
"(AsgElectronEfficiencyCorrectionTool_trig_mixLep_*) Your selected electron Iso WP ("
1388 <<
") does not have trigger SFs defined. Falling back to "
1389 << triggerMixedEleIso
1390 <<
" for SF calculations");
1392 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! ***");
1393 return StatusCode::FAILURE;
1396 ATH_MSG_VERBOSE (
"Selected WP: " <<
item.second <<
"_" << eleId <<
"_" << triggerMixedEleIso);
1398 toolName =
"AsgElectronEfficiencyCorrectionTool_trig_mixLep_" + (
item.first).substr(0,8) +
m_eleId;
1402 ATH_CHECK( t_sf->setProperty(
"IdKey", eleId) );
1403 ATH_CHECK( t_sf->setProperty(
"IsoKey", triggerMixedEleIso) );
1408 ATH_CHECK( t_sf->setProperty(
"OutputLevel", this->msg().level()) );
1411 #ifndef XAOD_STANDALONE
1417 toolName =
"AsgElectronEfficiencyCorrectionTool_trigEff_mixLep_" + (
item.first).substr(0,8) +
m_eleId;
1420 ATH_CHECK( t_eff->setProperty(
"TriggerKey",
"Eff_"+
item.second) );
1421 ATH_CHECK( t_eff->setProperty(
"IdKey", eleId) );
1422 ATH_CHECK( t_eff->setProperty(
"IsoKey", triggerMixedEleIso) );
1427 ATH_CHECK( t_eff->setProperty(
"OutputLevel", this->msg().level()) );
1430 #ifndef XAOD_STANDALONE
1438 else ATH_MSG_WARNING(
"*** THE ELECTRON TRIGGER SF MIXED AND SF DILEP ARE CURRENTY NOT SUPPORTED IN RUN3 ***");
1440 ATH_MSG_WARNING(
"*** THE ELECTRON CHARGE FLIP SF ARE CURRENTY NOT SUPPORTED ***");
1484 photonIso_forTrigSF =
"TightCaloOnly";
1486 photonIso_forTrigSF = TString(
m_photonIso_WP).ReplaceAll(
"FixedCut",
"").Data();
1498 std::map<std::string,std::string> diphotonTriggerSFMapAsymmetric {
1500 {
"g25_loose,g25_medium_L1EM20VH",
"DI_PH_2015_g25_loose_2016_g25_loose_2017_g25_medium_L1EM20VH_2018_g25_medium_L1EM20VH"},
1501 {
"g35_loose,g35_medium_L1EM20VH",
"DI_PH_2015_g35_loose_2016_g35_loose_2017_g35_medium_L1EM20VH_2018_g35_medium_L1EM20VH"},
1504 for(
auto const&
item : diphotonTriggerSFMapAsymmetric){
1506 toolName =
"AsgPhotonEfficiencyCorrectionTool_trigSF_asymm_diphoton_" + (
item.first).substr(0,9) + photonIso_forTrigSF;
1508 ATH_CHECK( ph_trigSF->setProperty(
"MapFilePath",
"PhotonEfficiencyCorrection/2015_2018/rel21.2/Summer2020_Rec_v1/map3.txt") );
1509 ATH_CHECK( ph_trigSF->setProperty(
"IsoKey", photonIso_forTrigSF) );
1510 ATH_CHECK( ph_trigSF->setProperty(
"TriggerKey",
item.second) );
1511 ATH_CHECK( ph_trigSF->setProperty(
"ForceDataType", 1) );
1512 ATH_CHECK( ph_trigSF->setProperty(
"OutputLevel", this->msg().level()) );
1515 #ifndef XAOD_STANDALONE
1521 toolName =
"AsgPhotonEfficiencyCorrectionTool_trigEff_asymm_diphoton_" + (
item.first).substr(0,9) + photonIso_forTrigSF;
1523 ATH_CHECK( ph_trigEff->setProperty(
"MapFilePath",
"PhotonEfficiencyCorrection/2015_2018/rel21.2/Summer2020_Rec_v1/map3.txt") );
1524 ATH_CHECK( ph_trigEff->setProperty(
"IsoKey", photonIso_forTrigSF) );
1525 ATH_CHECK( ph_trigEff->setProperty(
"TriggerKey",
"Eff_"+
item.second) );
1526 ATH_CHECK( ph_trigEff->setProperty(
"ForceDataType", 1) );
1527 ATH_CHECK( ph_trigEff->setProperty(
"OutputLevel", this->msg().level()) );
1530 #ifndef XAOD_STANDALONE
1586 ATH_MSG_WARNING(
"Forcing EgcalibTool to use calibrations for full simulation" );
1607 else if (
m_tauId ==
"rnn001")
inputfile =
"SUSYTools/tau_selection_rnn001.conf";
1608 else if (
m_tauId ==
"VeryLoose")
inputfile =
"SUSYTools/tau_selection_veryloose.conf";
1609 else if (
m_tauId ==
"Loose")
inputfile =
"SUSYTools/tau_selection_loose.conf";
1610 else if (
m_tauId ==
"Medium")
inputfile =
"SUSYTools/tau_selection_medium.conf";
1611 else if (
m_tauId ==
"Tight")
inputfile =
"SUSYTools/tau_selection_tight.conf";
1614 return StatusCode::FAILURE;
1620 return StatusCode::FAILURE;
1629 toolName =
"TauSelectionTool_" +
m_tauId;
1647 return StatusCode::FAILURE;
1662 toolName =
"TauEffTool_" +
m_tauId;
1665 std::vector<int> correction_types;
1668 ANA_MSG_DEBUG(
"Found JetIDWP in tau config file : " << jetIDWP );
1676 ATH_MSG_ERROR(
"Invalid Tau ID in tau config file " << jetIDWP);
1677 return StatusCode::FAILURE;
1680 correction_types.insert(correction_types.end(), {TauAnalysisTools::EfficiencyCorrectionType::SFRecoHadTau,
1681 TauAnalysisTools::EfficiencyCorrectionType::SFJetIDHadTau});
1685 ANA_MSG_DEBUG(
"Found EleIDWP in tau config file : " << eleIDWP );
1686 int ele_id_lvl = -1;
1691 ATH_MSG_INFO(
"No or invalid Ele OR in tau config file " << eleIDWP <<
" will not apply SFs for electro veto" );
1694 if (ele_id_lvl != -1 )
1695 correction_types.insert(correction_types.end(), {TauAnalysisTools::EfficiencyCorrectionType::SFEleIDHadTau,
1696 TauAnalysisTools::EfficiencyCorrectionType::SFEleIDElectron});
1722 return StatusCode::FAILURE;
1727 {
"HLT_tau25_medium1_tracktwo",
"HLT_tau25_medium1_tracktwo"},
1728 {
"HLT_tau35_medium1_tracktwo",
"HLT_tau35_medium1_tracktwo"},
1729 {
"HLT_tau50L1TAU12_medium1_tracktwo",
"HLT_tau50_medium1_tracktwo_L1TAU12"},
1730 {
"HLT_tau60_medium1_tracktwo",
"HLT_tau60_medium1_tracktwo"},
1731 {
"HLT_tau80L1TAU60_medium1_tracktwo",
"HLT_tau80_medium1_tracktwo_L1TAU60"},
1732 {
"HLT_tau125_medium1_tracktwo",
"HLT_tau125_medium1_tracktwo"},
1733 {
"HLT_tau160_medium1_tracktwo",
"HLT_tau160_medium1_tracktwo"},
1734 {
"HLT_tau160L1TAU100_medium1_tracktwo",
"HLT_tau160_medium1_tracktwo_L1TAU100"},
1736 {
"HLT_tau25_medium1_tracktwoEF",
"HLT_tau25_medium1_tracktwoEF"},
1737 {
"HLT_tau35_medium1_tracktwoEF",
"HLT_tau35_medium1_tracktwoEF"},
1738 {
"HLT_tau60_medium1_tracktwoEF",
"HLT_tau60_medium1_tracktwoEF"},
1739 {
"HLT_tau80L1TAU60_medium1_tracktwoEF",
"HLT_tau80_medium1_tracktwoEF_L1TAU60"},
1740 {
"HLT_tau160L1TAU100_medium1_tracktwoEF",
"HLT_tau160_medium1_tracktwoEF_L1TAU100"},
1746 {
"HLT_tau25_mediumRNN_tracktwoMVA",
"HLT_tau25_mediumRNN_tracktwoMVA"},
1747 {
"HLT_tau35_mediumRNN_tracktwoMVA",
"HLT_tau35_mediumRNN_tracktwoMVA"},
1749 {
"HLT_tau160_mediumRNN_tracktwoMVA",
"HLT_tau160_mediumRNN_tracktwoMVA_L1TAU100"},
1751 {
"HLT_tau160_mediumRNN_tracktwoMVA",
"HLT_tau160_mediumRNN_tracktwoMVA_L1eTAU140"}
1756 toolName =
"TauTrigEffTool_" +
m_tauId +
"_" + trigger.first;
1758 ATH_CHECK( tau_trigSF->setProperty(
"EfficiencyCorrectionTypes", std::vector<int>({TauAnalysisTools::SFTriggerHadTau})) );
1759 ATH_CHECK( tau_trigSF->setProperty(
"TriggerName", trigger.first) );
1760 ATH_CHECK( tau_trigSF->setProperty(
"JetIDLevel", iTauID) );
1761 ATH_CHECK( tau_trigSF->setProperty(
"OutputLevel", this->msg().level()) );
1765 else {
ATH_CHECK( tau_trigSF->setProperty(
"Campaign",
"mc20") );}
1806 std::string jetcollBTag =
jetcoll;
1807 if (
jetcoll ==
"AntiKt4LCTopoJets") {
1808 ATH_MSG_WARNING(
" *** HACK *** Treating LCTopoJets jets as EMTopo -- use at your own risk!");
1809 jetcollBTag =
"AntiKt4EMTopoJets";
1815 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"));
1819 if (jetcollBTag.find(
"AntiKt4EMTopoJets") == std::string::npos && jetcollBTag.find(
"AntiKt4EMPFlowJets")==std::string::npos) {
1820 ATH_MSG_WARNING(
"** Only AntiKt4EMTopoJets and AntiKt4EMPFlowJets are supported with FTAG scale factors!");
1821 return StatusCode::FAILURE;
1841 if (
jetcoll !=
"AntiKt4EMTopoJets" &&
jetcoll !=
"AntiKt4EMPFlowJets") {
1842 ATH_MSG_WARNING(
"** Only AntiKt4EMTopoJets and AntiKt4EMPFlowJets are supported with FTAG scale factors!");
1843 return StatusCode::FAILURE;
1846 toolName =
"BTagSelOR_" + jetcollBTag +
m_orBtagWP;
1862 const std::string& BTagColl_TrkJet = trkjetcoll;
1866 ATH_MSG_INFO(
"TrackJet collection set to None: disabling btagging for TrackJets.");
1870 if (trkjetcoll.find(
"AntiKt2PV0TrackJets")==std::string::npos && trkjetcoll.find(
"AntiKtVR30Rmax4Rmin02TrackJets")==std::string::npos) {
1871 ATH_MSG_WARNING(
"** Only AntiKt2PV0TrackJets and AntiKtVR30Rmax4Rmin02TrackJets are supported with FTAG scale factors!");
1872 return StatusCode::FAILURE;
1894 std::string MCshowerID;
1896 ATH_MSG_ERROR(
"Error! m_showerType=-1, which is an error case for FTAG MC/MC SFs." );
1897 return StatusCode::FAILURE;
1901 MCshowerID=
"default";
1911 ATH_MSG_WARNING(
"Unknown ShowerID detected! Using default FTAG MC-MC SFs (Powheg+Pythia8). Please check if these are applicable for this sample!");
1915 MCshowerID=
"default";
1919 ATH_MSG_WARNING(
"Unknown ShowerID detected! Using default FTAG MC-MC SFs (Powheg+Pythia8). Please check if these are applicable for this sample!");
1924 MCshowerID=
"default";
1932 ATH_MSG_WARNING(
"Unknown Sherpa version detected! Using FTAG MC-MC SFs for Sherpa 2.2.11-2.2.16. Please check if these are applicable for this sample!");
1933 MCshowerID =
"700660";
1936 ATH_MSG_WARNING(
"Unknown ShowerID detected! Using default FTAG MC-MC SFs (Powheg+Pythia8). Please check if these are applicable for this sample!");
1940 MCshowerID=
"default";
1946 ATH_MSG_WARNING(
"Unknown Sherpa version detected! Using FTAG MC-MC SFs for Sherpa 2.2.11-2.2.16. Please check if these are applicable for this sample!");
1947 MCshowerID =
"700660";
1950 ATH_MSG_WARNING(
"Unknown ShowerID detected! Using default FTAG MC-MC SFs (Powheg+Pythia8). Please check if these are applicable for this sample!");
1954 ATH_MSG_WARNING(
"Unknown b-tagger detected! Only DL1dv01 and GN2v01 are supported. Falling back to default FTAG MC-MC SFs (Powheg+Pythia8). Please check if these are applicable for this sample!");
1955 MCshowerID=
"default";
1960 if (
jetcoll !=
"AntiKt4EMTopoJets" &&
jetcoll !=
"AntiKt4EMPFlowJets") {
1961 ATH_MSG_WARNING(
"** Only AntiKt4EMTopoJets and AntiKt4EMPFlowJets are supported with FTAG scale factors!");
1962 return StatusCode::FAILURE;
1990 if (trkjetcoll.find(
"AntiKt2PV0TrackJets")==std::string::npos && trkjetcoll.find(
"AntiKtVR30Rmax4Rmin02TrackJets")==std::string::npos) {
1991 ATH_MSG_WARNING(
"** Only AntiKt2PV0TrackJets and AntiKtVR30Rmax4Rmin02TrackJets are supported with FTAG scale factors!");
1992 return StatusCode::FAILURE;
1995 toolName =
"BTagSF_" + trkjetcoll;
2051 ATH_MSG_ERROR(
"Can only have CST *or* TST configured for MET maker. Please unset either METDoCaloSyst or METDoTrkSyst in your config file" );
2052 return StatusCode::FAILURE;
2077 #ifndef XAOD_STANDALONE // Athena and AthAnalysis; need to take into account that MuonCalibTool is private tool
2081 if(jetname !=
"AntiKt4EMPFlow")
2082 ATH_MSG_WARNING(
"METSignificance recommendations only exist for AntiKt4EMPFlow jets, falling back to this.");
2099 if (IdBaselineInt == 4)
2103 #else // AnalysisBase; can just pass the jet/egamma/muon calib tools configured above
2107 if(jetname !=
"AntiKt4EMPFlow")
2108 ATH_MSG_WARNING(
"METSignificance recommendations only exist for AntiKt4EMPFlow jets, falling back to this.");
2138 #ifndef XAOD_STANDALONE // Athena and AthAnalysis
2141 #else // AnalysisBase
2185 std::string no2e17(
"");
2195 ATH_MSG_DEBUG(
"TrigGlobalEfficiencyCorrectionTool/TrigGlobal_diLep: no2e17 trigger string: " << no2e17 );
2197 std::map<std::string,std::string> triggers_diLep;
2201 triggers_diLep[
"326834-328393"] = no2e17;
2220 std::string no2e17(
"");
2230 ATH_MSG_DEBUG(
"TrigGlobalEfficiencyCorrectionTool/TrigGlobal_multiLep: no2e17 trigger string: " << no2e17 );
2232 std::map<std::string,std::string> triggers_multiLep;
2236 triggers_multiLep[
"326834-328393"] = no2e17;
2337 #ifndef XAOD_ANALYSIS
2354 std::string toolName =
"ORTool" +
suffix;
2355 ATH_MSG_INFO(
"SUSYTools: Autoconfiguring " << toolName);
2372 orFlags.outputPassValue =
true;
2375 orFlags.doEleEleOR =
true;
2376 }
else orFlags.doEleEleOR =
false;
2377 orFlags.doElectrons =
true;
2378 orFlags.doMuons =
true;
2379 orFlags.doJets =
true;
2498 return StatusCode::SUCCESS;
◆ sysInitialize()
| StatusCode asg::AsgMetadataTool::sysInitialize |
( |
| ) |
|
|
virtualinherited |
Function initialising the tool in the correct way in Athena.
This function is used to set up the callbacks from IncidentSvc in Athena at the right time during initialisation, without the user having to do anything special in his/her code.
Reimplemented from AthCommonDataStore< AthCommonMsg< AlgTool > >.
Definition at line 115 of file AsgMetadataTool.cxx.
117 #ifndef XAOD_STANDALONE
124 incSvc->addListener(
this, IncidentType::BeginEvent, 0,
false );
129 #endif // not XAOD_STANDALONE
132 return StatusCode::SUCCESS;
◆ sysStart()
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 3123 of file SUSYObjDef_xAOD.cxx.
3127 if (theRunNumber<290000)
return 2015;
3128 else if (theRunNumber<320000)
return 2016;
3129 else if (theRunNumber<342000)
return 2017;
3130 else if (theRunNumber<400000)
return 2018;
3131 else if (theRunNumber<445000)
return 2022;
3132 else if (theRunNumber<465000)
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 |
◆ TrigMatch() [2/10]
◆ TrigMatch() [3/10]
◆ TrigMatch() [4/10]
◆ TrigMatch() [5/10]
◆ TrigMatch() [6/10]
◆ TrigMatch() [7/10]
◆ TrigMatch() [8/10]
◆ TrigMatch() [9/10]
◆ TrigMatch() [10/10]
◆ TrigSingleLep()
| std::string ST::SUSYObjDef_xAOD::TrigSingleLep |
( |
| ) |
const |
|
finaloverridevirtual |
◆ updateVHKA()
◆ 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 1946 of file SUSYObjDef_xAOD.cxx.
1953 if(
strict)
return StatusCode::FAILURE;
1957 if(
strict)
return StatusCode::FAILURE;
1962 if(
strict)
return StatusCode::FAILURE;
1966 if(
strict)
return StatusCode::FAILURE;
1972 if(
strict)
return StatusCode::FAILURE;
1976 if(
strict)
return StatusCode::FAILURE;
1980 if(
strict)
return StatusCode::FAILURE;
1986 if(
strict)
return StatusCode::FAILURE;
1990 if(
strict)
return StatusCode::FAILURE;
1994 if(
strict)
return StatusCode::FAILURE;
1998 if(
strict)
return StatusCode::FAILURE;
2003 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!");
2013 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).");
2020 if(
strict)
return StatusCode::FAILURE;
2025 if(
strict)
return StatusCode::FAILURE;
2029 std::vector<float> pT_window;
2030 std::vector<float> eta_window;
2039 if (
m_tauId ==
"rnn001") theConfig =
"SUSYTools/tau_selection_rnn001.conf";
2040 else if (
m_tauId ==
"VeryLoose") theConfig =
"SUSYTools/tau_selection_veryloose.conf";
2041 else if (
m_tauId ==
"Loose") theConfig =
"SUSYTools/tau_selection_loose.conf";
2042 else if (
m_tauId ==
"Medium") theConfig =
"SUSYTools/tau_selection_medium.conf";
2043 else if (
m_tauId ==
"Tight") theConfig =
"SUSYTools/tau_selection_tight.conf";
2047 getTauConfig(theConfig, pT_window, eta_window, elOLR, muVeto, muOLR);
2051 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] <<
"]");
2052 if(
strict)
return StatusCode::FAILURE;
2055 if(
m_tauPt > 0 and (
m_tauPt != 1000*pT_window[0] or (pT_window[1] > 0 and
m_tauPt > 1000*pT_window[1]))) {
2056 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] <<
"]");
2057 if(
strict)
return StatusCode::FAILURE;
2061 ATH_MSG_WARNING(
"Your baseline tau eta configuration is inconsistent! eta cut : " <<
m_tauEta <<
" != TauSelectionTool max eta : " << eta_window[eta_window.size()-1]);
2062 if(
strict)
return StatusCode::FAILURE;
2070 if (
m_tauId ==
"rnn001") theConfig =
"SUSYTools/tau_selection_rnn001.conf";
2071 else if (
m_tauId ==
"VeryLoose") theConfig =
"SUSYTools/tau_selection_veryloose.conf";
2072 else if (
m_tauId ==
"Loose") theConfig =
"SUSYTools/tau_selection_loose.conf";
2073 else if (
m_tauId ==
"Medium") theConfig =
"SUSYTools/tau_selection_medium.conf";
2074 else if (
m_tauId ==
"Tight") theConfig =
"SUSYTools/tau_selection_tight.conf";
2077 getTauConfig(theConfig, pT_window, eta_window, elOLR, muVeto, muOLR);
2080 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] <<
"]");
2081 if(
strict)
return StatusCode::FAILURE;
2084 if(
m_tauPt > 0 and (
m_tauPt != 1000*pT_window[0] or (pT_window[1] > 0 and
m_tauPt > 1000*pT_window[1]))) {
2085 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] <<
"]");
2086 if(
strict)
return StatusCode::FAILURE;
2090 ATH_MSG_WARNING(
"Your tau eta configuration is inconsistent! eta cut : " <<
m_tauEta <<
" != TauSelectionTool max eta : " << eta_window[eta_window.size()-1]);
2091 if(
strict)
return StatusCode::FAILURE;
2096 return StatusCode::SUCCESS;
◆ ATLAS_THREAD_SAFE [1/2]
| std::map<std::string, std::function<bool()> > m_metTriggerFuncs ST::SUSYObjDef_xAOD::ATLAS_THREAD_SAFE |
|
mutableprivate |
◆ ATLAS_THREAD_SAFE [2/2]
| std::map<std::string, bool> m_checkedTriggers ST::SUSYObjDef_xAOD::ATLAS_THREAD_SAFE |
|
mutableprivate |
◆ lrt_electrons
◆ lrt_muons
◆ m_acc_eleId
◆ m_acc_eleIdBaseline
◆ m_acc_jetClean
◆ m_acc_photonId
◆ m_acc_photonIdBaseline
◆ m_applyJVTCut
| bool ST::SUSYObjDef_xAOD::m_applyJVTCut |
|
protected |
◆ m_ApplyMVATESQualityCheck
| bool ST::SUSYObjDef_xAOD::m_ApplyMVATESQualityCheck |
|
protected |
◆ m_autoconfigPRW
| bool ST::SUSYObjDef_xAOD::m_autoconfigPRW |
|
protected |
◆ m_autoconfigPRWCombinedmode
| bool ST::SUSYObjDef_xAOD::m_autoconfigPRWCombinedmode |
|
protected |
◆ m_autoconfigPRWFile
| std::string ST::SUSYObjDef_xAOD::m_autoconfigPRWFile |
|
protected |
◆ m_autoconfigPRWPath
| std::string ST::SUSYObjDef_xAOD::m_autoconfigPRWPath |
|
protected |
◆ m_autoconfigPRWRPVmode
| bool ST::SUSYObjDef_xAOD::m_autoconfigPRWRPVmode |
|
protected |
◆ m_autoconfigPRWRtags
| std::string ST::SUSYObjDef_xAOD::m_autoconfigPRWRtags |
|
protected |
◆ m_badJetCut
| std::string ST::SUSYObjDef_xAOD::m_badJetCut |
|
protected |
◆ m_badmuQoverP
| double ST::SUSYObjDef_xAOD::m_badmuQoverP |
|
protected |
◆ m_beginInputFileCalled
| bool asg::AsgMetadataTool::m_beginInputFileCalled |
|
privateinherited |
Flag helping to discover when the tool misses the opening of the first input file.
Definition at line 126 of file AsgMetadataTool.h.
◆ m_bool_prop_set
| std::set<std::string> ST::SUSYObjDef_xAOD::m_bool_prop_set |
|
private |
◆ m_btagEffTool
◆ m_btagEffTool_trkJet
◆ m_bTaggingCalibrationFilePath
| std::string ST::SUSYObjDef_xAOD::m_bTaggingCalibrationFilePath |
|
protected |
◆ m_BtagKeyOverride
| std::string ST::SUSYObjDef_xAOD::m_BtagKeyOverride |
|
protected |
◆ m_BtagMinPt
| double ST::SUSYObjDef_xAOD::m_BtagMinPt |
|
protected |
◆ m_BtagMinPt_trkJet
| double ST::SUSYObjDef_xAOD::m_BtagMinPt_trkJet |
|
protected |
◆ m_btagSelTool
◆ m_btagSelTool_OR
◆ m_btagSelTool_trkJet
◆ m_BtagSystStrategy
| std::string ST::SUSYObjDef_xAOD::m_BtagSystStrategy |
|
protected |
◆ m_BtagTagger
| std::string ST::SUSYObjDef_xAOD::m_BtagTagger |
|
protected |
◆ m_BtagTagger_trkJet
| std::string ST::SUSYObjDef_xAOD::m_BtagTagger_trkJet |
|
protected |
◆ m_BtagWP
| std::string ST::SUSYObjDef_xAOD::m_BtagWP |
|
protected |
◆ m_BtagWP_trkJet
| std::string ST::SUSYObjDef_xAOD::m_BtagWP_trkJet |
|
protected |
◆ m_caloMETsyst
| bool ST::SUSYObjDef_xAOD::m_caloMETsyst |
|
protected |
◆ m_commonPRWFileMC20a
| std::string ST::SUSYObjDef_xAOD::m_commonPRWFileMC20a |
|
protected |
◆ m_commonPRWFileMC20d
| std::string ST::SUSYObjDef_xAOD::m_commonPRWFileMC20d |
|
protected |
◆ m_commonPRWFileMC20e
| std::string ST::SUSYObjDef_xAOD::m_commonPRWFileMC20e |
|
protected |
◆ m_commonPRWFileMC21a
| std::string ST::SUSYObjDef_xAOD::m_commonPRWFileMC21a |
|
protected |
◆ m_commonPRWFileMC23a
| std::string ST::SUSYObjDef_xAOD::m_commonPRWFileMC23a |
|
protected |
◆ m_commonPRWFileMC23c
| std::string ST::SUSYObjDef_xAOD::m_commonPRWFileMC23c |
|
protected |
◆ m_commonPRWFileMC23d
| std::string ST::SUSYObjDef_xAOD::m_commonPRWFileMC23d |
|
protected |
◆ m_commonPRWFileMC23e
| std::string ST::SUSYObjDef_xAOD::m_commonPRWFileMC23e |
|
protected |
◆ m_conf_to_prop
| std::map<std::string, std::string> ST::SUSYObjDef_xAOD::m_conf_to_prop |
|
private |
◆ m_configFile
| std::string ST::SUSYObjDef_xAOD::m_configFile |
|
protected |
◆ m_currentSyst
◆ m_dataSource
| int ST::SUSYObjDef_xAOD::m_dataSource |
|
protected |
◆ m_deadHVTool
◆ m_debug
| bool ST::SUSYObjDef_xAOD::m_debug |
|
protected |
◆ m_defaultJets
| std::string ST::SUSYObjDef_xAOD::m_defaultJets |
|
protected |
◆ m_defaultSyst
◆ m_defaultTrackJets
| std::string ST::SUSYObjDef_xAOD::m_defaultTrackJets |
|
protected |
◆ m_defaultTruthJets
| std::string ST::SUSYObjDef_xAOD::m_defaultTruthJets |
|
protected |
◆ m_detStore
◆ m_doElIsoSignal
| bool ST::SUSYObjDef_xAOD::m_doElIsoSignal |
|
protected |
◆ m_doFwdJVT
| bool ST::SUSYObjDef_xAOD::m_doFwdJVT |
|
protected |
◆ m_doIsoSignal
| bool ST::SUSYObjDef_xAOD::m_doIsoSignal |
|
protected |
◆ m_doModifiedEleId
| bool ST::SUSYObjDef_xAOD::m_doModifiedEleId |
|
protected |
◆ m_doMuIsoSignal
| bool ST::SUSYObjDef_xAOD::m_doMuIsoSignal |
|
protected |
◆ m_doPhiReso
| bool ST::SUSYObjDef_xAOD::m_doPhiReso |
|
protected |
◆ m_doPhIsoSignal
| bool ST::SUSYObjDef_xAOD::m_doPhIsoSignal |
|
protected |
◆ m_doTTVAsf
| bool ST::SUSYObjDef_xAOD::m_doTTVAsf |
|
protected |
◆ m_EG_corrFNList
| std::string ST::SUSYObjDef_xAOD::m_EG_corrFNList |
|
protected |
◆ m_EG_corrModel
| std::string ST::SUSYObjDef_xAOD::m_EG_corrModel |
|
protected |
◆ m_egammaAmbiguityTool
◆ m_egammaCalibTool
◆ m_EigenvectorReductionB
| std::string ST::SUSYObjDef_xAOD::m_EigenvectorReductionB |
|
protected |
◆ m_EigenvectorReductionC
| std::string ST::SUSYObjDef_xAOD::m_EigenvectorReductionC |
|
protected |
◆ m_EigenvectorReductionLight
| std::string ST::SUSYObjDef_xAOD::m_EigenvectorReductionLight |
|
protected |
◆ m_el_id_support
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_el_id_support |
|
protected |
◆ m_el_iso_fallback
| std::map<std::string, std::string> ST::SUSYObjDef_xAOD::m_el_iso_fallback |
|
protected |
◆ m_el_iso_support
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_el_iso_support |
|
protected |
◆ m_eleAllowRun3TrigSFFallback
| bool ST::SUSYObjDef_xAOD::m_eleAllowRun3TrigSFFallback |
|
protected |
◆ m_eleBaselineCrackVeto
| bool ST::SUSYObjDef_xAOD::m_eleBaselineCrackVeto |
|
protected |
◆ m_elebaselined0sig
| double ST::SUSYObjDef_xAOD::m_elebaselined0sig |
|
protected |
◆ m_eleBaselineEta
| double ST::SUSYObjDef_xAOD::m_eleBaselineEta |
|
protected |
◆ m_eleBaselineIso_WP
| std::string ST::SUSYObjDef_xAOD::m_eleBaselineIso_WP |
|
protected |
◆ m_eleBaselinePt
| double ST::SUSYObjDef_xAOD::m_eleBaselinePt |
|
protected |
◆ m_elebaselinez0
| double ST::SUSYObjDef_xAOD::m_elebaselinez0 |
|
protected |
◆ m_elecChargeEffCorrTool
◆ m_elecChargeIDSelectorTool
◆ m_elecEfficiencySFTool_chf
◆ m_elecEfficiencySFTool_id
◆ m_elecEfficiencySFTool_iso
◆ m_elecEfficiencySFTool_isoHighPt
◆ m_elecEfficiencySFTool_reco
◆ m_elecEfficiencySFTool_trig_mixLep
◆ m_elecEfficiencySFTool_trig_singleLep
◆ m_elecEfficiencySFTool_trigEff_mixLep
◆ m_elecEfficiencySFTool_trigEff_singleLep
◆ m_eleChID_signal
| bool ST::SUSYObjDef_xAOD::m_eleChID_signal |
|
protected |
◆ m_eleChID_WP
| std::string ST::SUSYObjDef_xAOD::m_eleChID_WP |
|
protected |
◆ m_eleChIso
| bool ST::SUSYObjDef_xAOD::m_eleChIso |
|
protected |
◆ m_elecLRTORTool
◆ m_eleConfig
| std::string ST::SUSYObjDef_xAOD::m_eleConfig |
|
protected |
◆ m_eleConfigBaseline
| std::string ST::SUSYObjDef_xAOD::m_eleConfigBaseline |
|
protected |
◆ m_eleCrackVeto
| bool ST::SUSYObjDef_xAOD::m_eleCrackVeto |
|
protected |
◆ m_elecSelLikelihood
◆ m_elecSelLikelihoodBaseline
◆ m_elecTrigEffTools
◆ m_elecTrigSFTools
◆ m_electronTriggerSFStringSingle
| std::string ST::SUSYObjDef_xAOD::m_electronTriggerSFStringSingle |
|
protected |
◆ m_eled0sig
| double ST::SUSYObjDef_xAOD::m_eled0sig |
|
protected |
◆ m_eleEffMapFilePath
| std::string ST::SUSYObjDef_xAOD::m_eleEffMapFilePath |
|
protected |
◆ m_eleEffMapFilePathRun2
| std::string ST::SUSYObjDef_xAOD::m_eleEffMapFilePathRun2 |
|
protected |
◆ m_eleEta
| double ST::SUSYObjDef_xAOD::m_eleEta |
|
protected |
◆ m_EleFatJetDR
| double ST::SUSYObjDef_xAOD::m_EleFatJetDR |
|
protected |
◆ m_eleForceFullSimCalib
| bool ST::SUSYObjDef_xAOD::m_eleForceFullSimCalib |
|
protected |
◆ m_eleId
| std::string ST::SUSYObjDef_xAOD::m_eleId |
|
protected |
◆ m_eleIdBaseline
| std::string ST::SUSYObjDef_xAOD::m_eleIdBaseline |
|
protected |
◆ m_eleIdBaselineDFName
| std::string ST::SUSYObjDef_xAOD::m_eleIdBaselineDFName |
|
protected |
◆ m_eleIdDFName
| std::string ST::SUSYObjDef_xAOD::m_eleIdDFName |
|
protected |
◆ m_eleIdExpert
| bool ST::SUSYObjDef_xAOD::m_eleIdExpert |
|
protected |
◆ m_eleIso_WP
| std::string ST::SUSYObjDef_xAOD::m_eleIso_WP |
|
protected |
◆ m_eleIsoHighPt_WP
| std::string ST::SUSYObjDef_xAOD::m_eleIsoHighPt_WP |
|
protected |
◆ m_eleIsoHighPtThresh
| double ST::SUSYObjDef_xAOD::m_eleIsoHighPtThresh |
|
protected |
◆ m_eleLRT
| bool ST::SUSYObjDef_xAOD::m_eleLRT |
|
protected |
◆ m_eleLRT_strat
| int ST::SUSYObjDef_xAOD::m_eleLRT_strat |
|
protected |
◆ m_elePt
| double ST::SUSYObjDef_xAOD::m_elePt |
|
protected |
◆ m_eleTerm
| std::string ST::SUSYObjDef_xAOD::m_eleTerm |
|
protected |
◆ m_elez0
| double ST::SUSYObjDef_xAOD::m_elez0 |
|
protected |
◆ m_evtStore
◆ m_fatjetFFSmearingSyst
◆ m_fatjetFFSmearingTool
◆ m_fatJets
| std::string ST::SUSYObjDef_xAOD::m_fatJets |
|
protected |
◆ m_fatJetUncConfig
| std::string ST::SUSYObjDef_xAOD::m_fatJetUncConfig |
|
protected |
◆ m_fatJetUncertaintiesMCType
| std::string ST::SUSYObjDef_xAOD::m_fatJetUncertaintiesMCType |
|
protected |
◆ m_fatJetUncertaintiesPDsmearing
| bool ST::SUSYObjDef_xAOD::m_fatJetUncertaintiesPDsmearing |
|
protected |
◆ m_fatjetUncertaintiesPDSmearTool
◆ m_fatjetUncertaintiesTool
◆ m_fatJetUncVars
| std::string ST::SUSYObjDef_xAOD::m_fatJetUncVars |
|
protected |
◆ m_fJvtConfigRun2
| std::string ST::SUSYObjDef_xAOD::m_fJvtConfigRun2 |
|
protected |
◆ m_fJvtConfigRun3
| std::string ST::SUSYObjDef_xAOD::m_fJvtConfigRun3 |
|
protected |
◆ m_fJvtEtaMin
| double ST::SUSYObjDef_xAOD::m_fJvtEtaMin |
|
protected |
◆ m_fJvtPtMax
| double ST::SUSYObjDef_xAOD::m_fJvtPtMax |
|
protected |
◆ m_fJvtWP
| std::string ST::SUSYObjDef_xAOD::m_fJvtWP |
|
protected |
◆ m_force_noElId
| bool ST::SUSYObjDef_xAOD::m_force_noElId |
|
protected |
◆ m_force_noMuId
| bool ST::SUSYObjDef_xAOD::m_force_noMuId |
|
protected |
◆ m_gammaTerm
| std::string ST::SUSYObjDef_xAOD::m_gammaTerm |
|
protected |
◆ m_GSFLRTCollectionName
◆ m_inputMetaStore
◆ m_inputMETCore
| std::string ST::SUSYObjDef_xAOD::m_inputMETCore |
|
protected |
◆ m_inputMETMap
| std::string ST::SUSYObjDef_xAOD::m_inputMETMap |
|
protected |
◆ m_inputMETRef
| std::string ST::SUSYObjDef_xAOD::m_inputMETRef |
|
protected |
◆ m_inputMETSuffix
| std::string ST::SUSYObjDef_xAOD::m_inputMETSuffix |
|
protected |
◆ m_isoBaselineTool
◆ m_IsoCloseByORpassLabel
| std::string ST::SUSYObjDef_xAOD::m_IsoCloseByORpassLabel |
|
protected |
◆ m_isoCloseByTool
◆ m_isoCorrTool
◆ m_isoHighPtTool
◆ m_isoTool
◆ m_isPHYSLITE
| bool ST::SUSYObjDef_xAOD::m_isPHYSLITE |
|
protected |
◆ m_isRun3
| bool ST::SUSYObjDef_xAOD::m_isRun3 |
|
protected |
◆ m_jesCalibArea
| std::string ST::SUSYObjDef_xAOD::m_jesCalibArea |
|
protected |
◆ m_jesCalibSeq
| std::string ST::SUSYObjDef_xAOD::m_jesCalibSeq |
|
protected |
◆ m_jesCalibSeqFat
| std::string ST::SUSYObjDef_xAOD::m_jesCalibSeqFat |
|
protected |
◆ m_jesCalibSeqJMS
| std::string ST::SUSYObjDef_xAOD::m_jesCalibSeqJMS |
|
protected |
◆ m_jesConfig
| std::string ST::SUSYObjDef_xAOD::m_jesConfig |
|
protected |
◆ m_jesConfigAFII
| std::string ST::SUSYObjDef_xAOD::m_jesConfigAFII |
|
protected |
◆ m_jesConfigFat
| std::string ST::SUSYObjDef_xAOD::m_jesConfigFat |
|
protected |
◆ m_jesConfigFatData
| std::string ST::SUSYObjDef_xAOD::m_jesConfigFatData |
|
protected |
◆ m_jesConfigJMS
| std::string ST::SUSYObjDef_xAOD::m_jesConfigJMS |
|
protected |
◆ m_jesConfigJMSData
| std::string ST::SUSYObjDef_xAOD::m_jesConfigJMSData |
|
protected |
◆ m_jetCalibTool
◆ m_jetCleanDFName
| std::string ST::SUSYObjDef_xAOD::m_jetCleanDFName |
|
protected |
◆ m_jetCleaningTool
◆ m_jetEta
| double ST::SUSYObjDef_xAOD::m_jetEta |
|
protected |
◆ m_jetFatCalibTool
◆ m_JetFatJetDR
| double ST::SUSYObjDef_xAOD::m_JetFatJetDR |
|
protected |
◆ m_jetfJvtEfficiencyTool
◆ m_jetfJvtSelectionTool
◆ m_jetInputType
| int ST::SUSYObjDef_xAOD::m_jetInputType |
|
protected |
◆ m_jetJvt
| double ST::SUSYObjDef_xAOD::m_jetJvt |
|
protected |
◆ m_jetJvtMomentTool
◆ m_jetNNJvtEfficiencyTool
◆ m_jetNNJvtMomentTool
◆ m_jetNNJvtSelectionTool
◆ m_jetPileupLabelingTool
◆ m_jetPt
| double ST::SUSYObjDef_xAOD::m_jetPt |
|
protected |
◆ m_jetTerm
| std::string ST::SUSYObjDef_xAOD::m_jetTerm |
|
protected |
◆ m_jetTruthLabelingTool
◆ m_JetTruthLabelName
| std::string ST::SUSYObjDef_xAOD::m_JetTruthLabelName |
|
protected |
◆ m_jetUncertaintiesAnalysisFile
| std::string ST::SUSYObjDef_xAOD::m_jetUncertaintiesAnalysisFile |
|
protected |
◆ m_jetUncertaintiesCalibArea
| std::string ST::SUSYObjDef_xAOD::m_jetUncertaintiesCalibArea |
|
protected |
◆ m_jetUncertaintiesConfig
| std::string ST::SUSYObjDef_xAOD::m_jetUncertaintiesConfig |
|
protected |
◆ m_jetUncertaintiesMCType
| std::string ST::SUSYObjDef_xAOD::m_jetUncertaintiesMCType |
|
protected |
◆ m_jetUncertaintiesPDsmearing
| bool ST::SUSYObjDef_xAOD::m_jetUncertaintiesPDsmearing |
|
protected |
◆ m_jetUncertaintiesPDSmearTool
◆ m_jetUncertaintiesTool
◆ m_JMScalib
| bool ST::SUSYObjDef_xAOD::m_JMScalib |
|
protected |
◆ m_JvtConfigRun2
| std::string ST::SUSYObjDef_xAOD::m_JvtConfigRun2 |
|
protected |
◆ m_JvtConfigRun3
| std::string ST::SUSYObjDef_xAOD::m_JvtConfigRun3 |
|
protected |
◆ m_JvtPtMax
| double ST::SUSYObjDef_xAOD::m_JvtPtMax |
|
protected |
◆ m_JvtWP
| std::string ST::SUSYObjDef_xAOD::m_JvtWP |
|
protected |
◆ m_label_truthKey
◆ m_legsPerTool
| std::map<std::string,std::string> ST::SUSYObjDef_xAOD::m_legsPerTool |
|
protected |
◆ m_legsPerTool_ph
| std::map<std::string,std::string> ST::SUSYObjDef_xAOD::m_legsPerTool_ph |
|
protected |
◆ m_LRTCollectionName
◆ m_LRTuncTool
◆ m_mcCampaign
| std::string ST::SUSYObjDef_xAOD::m_mcCampaign |
|
protected |
◆ m_mcChannel
| int ST::SUSYObjDef_xAOD::m_mcChannel |
|
protected |
◆ m_metDoMuonEloss
| bool ST::SUSYObjDef_xAOD::m_metDoMuonEloss |
|
protected |
◆ m_metDoRemoveMuonJets
| bool ST::SUSYObjDef_xAOD::m_metDoRemoveMuonJets |
|
protected |
◆ m_metDoSetMuonJetEMScale
| bool ST::SUSYObjDef_xAOD::m_metDoSetMuonJetEMScale |
|
protected |
◆ m_metGreedyPhotons
| bool ST::SUSYObjDef_xAOD::m_metGreedyPhotons |
|
protected |
◆ m_metJetSelection
| std::string ST::SUSYObjDef_xAOD::m_metJetSelection |
|
protected |
◆ m_metMaker
◆ m_metRemoveOverlappingCaloTaggedMuons
| bool ST::SUSYObjDef_xAOD::m_metRemoveOverlappingCaloTaggedMuons |
|
protected |
◆ m_metSignif
◆ m_metsysConfigPrefix
| std::string ST::SUSYObjDef_xAOD::m_metsysConfigPrefix |
|
protected |
◆ m_metSystTool
◆ m_metUseGhostMuons
| bool ST::SUSYObjDef_xAOD::m_metUseGhostMuons |
|
protected |
◆ m_metVeryGreedyPhotons
| bool ST::SUSYObjDef_xAOD::m_metVeryGreedyPhotons |
|
protected |
◆ m_mu_id_support
| int ST::SUSYObjDef_xAOD::m_mu_id_support |
|
protected |
◆ m_mu_iso_fallback
| std::map<std::string, std::string> ST::SUSYObjDef_xAOD::m_mu_iso_fallback |
|
protected |
◆ m_mu_iso_support
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_mu_iso_support |
|
protected |
◆ m_mubaselined0sig
| double ST::SUSYObjDef_xAOD::m_mubaselined0sig |
|
protected |
◆ m_muBaselineEta
| double ST::SUSYObjDef_xAOD::m_muBaselineEta |
|
protected |
◆ m_muBaselineIso_WP
| std::string ST::SUSYObjDef_xAOD::m_muBaselineIso_WP |
|
protected |
◆ m_muBaselinePt
| double ST::SUSYObjDef_xAOD::m_muBaselinePt |
|
protected |
◆ m_mubaselinez0
| double ST::SUSYObjDef_xAOD::m_mubaselinez0 |
|
protected |
◆ m_muCalibrationMode
| int ST::SUSYObjDef_xAOD::m_muCalibrationMode |
|
protected |
◆ m_muCosmicd0
| double ST::SUSYObjDef_xAOD::m_muCosmicd0 |
|
protected |
◆ m_muCosmicz0
| double ST::SUSYObjDef_xAOD::m_muCosmicz0 |
|
protected |
◆ m_mud0sig
| double ST::SUSYObjDef_xAOD::m_mud0sig |
|
protected |
◆ m_muEffCorrForce1D
| bool ST::SUSYObjDef_xAOD::m_muEffCorrForce1D |
|
protected |
◆ m_muEta
| double ST::SUSYObjDef_xAOD::m_muEta |
|
protected |
◆ m_muHighPtExtraSmear
| bool ST::SUSYObjDef_xAOD::m_muHighPtExtraSmear |
|
protected |
◆ m_muId
| int ST::SUSYObjDef_xAOD::m_muId |
|
protected |
◆ m_muIdBaseline
| int ST::SUSYObjDef_xAOD::m_muIdBaseline |
|
protected |
◆ m_muIso_WP
| std::string ST::SUSYObjDef_xAOD::m_muIso_WP |
|
protected |
◆ m_muIsoHighPt_WP
| std::string ST::SUSYObjDef_xAOD::m_muIsoHighPt_WP |
|
protected |
◆ m_muIsoHighPtThresh
| double ST::SUSYObjDef_xAOD::m_muIsoHighPtThresh |
|
protected |
◆ m_muLRT
| bool ST::SUSYObjDef_xAOD::m_muLRT |
|
protected |
◆ m_muonCalibTool
◆ m_muonEfficiencyBMHighPtSFTool
◆ m_muonEfficiencySFTool
◆ m_muonHighPtIsolationSFTool
◆ m_muonIsolationSFTool
◆ m_muonLRTORTool
◆ m_muonSelectionHighPtTool
◆ m_muonSelectionTool
◆ m_muonSelectionToolBaseline
◆ m_muonTerm
| std::string ST::SUSYObjDef_xAOD::m_muonTerm |
|
protected |
◆ m_muonTriggerSFTool
◆ m_muonTrigSFTools
◆ m_muonTTVAEfficiencySFTool
◆ m_muPt
| double ST::SUSYObjDef_xAOD::m_muPt |
|
protected |
◆ m_murequirepassedHighPtCuts
| bool ST::SUSYObjDef_xAOD::m_murequirepassedHighPtCuts |
|
protected |
◆ m_muTriggerSFCalibFilename
| std::string ST::SUSYObjDef_xAOD::m_muTriggerSFCalibFilename |
|
protected |
◆ m_muTriggerSFCalibRelease
| std::string ST::SUSYObjDef_xAOD::m_muTriggerSFCalibRelease |
|
protected |
◆ m_muz0
| double ST::SUSYObjDef_xAOD::m_muz0 |
|
protected |
◆ m_orApplyRelPt
| bool ST::SUSYObjDef_xAOD::m_orApplyRelPt |
|
protected |
◆ m_orBJetPtUpperThres
| double ST::SUSYObjDef_xAOD::m_orBJetPtUpperThres |
|
protected |
◆ m_orBoostedElectronC1
| double ST::SUSYObjDef_xAOD::m_orBoostedElectronC1 |
|
protected |
◆ m_orBoostedElectronC2
| double ST::SUSYObjDef_xAOD::m_orBoostedElectronC2 |
|
protected |
◆ m_orBoostedElectronMaxConeSize
| double ST::SUSYObjDef_xAOD::m_orBoostedElectronMaxConeSize |
|
protected |
◆ m_orBoostedMuonC1
| double ST::SUSYObjDef_xAOD::m_orBoostedMuonC1 |
|
protected |
◆ m_orBoostedMuonC2
| double ST::SUSYObjDef_xAOD::m_orBoostedMuonC2 |
|
protected |
◆ m_orBoostedMuonMaxConeSize
| double ST::SUSYObjDef_xAOD::m_orBoostedMuonMaxConeSize |
|
protected |
◆ m_orBtagWP
| std::string ST::SUSYObjDef_xAOD::m_orBtagWP |
|
protected |
◆ m_orDoBjet
| bool ST::SUSYObjDef_xAOD::m_orDoBjet |
|
protected |
◆ m_orDoBoostedElectron
| bool ST::SUSYObjDef_xAOD::m_orDoBoostedElectron |
|
protected |
◆ m_orDoBoostedMuon
| bool ST::SUSYObjDef_xAOD::m_orDoBoostedMuon |
|
protected |
◆ m_orDoElBjet
| bool ST::SUSYObjDef_xAOD::m_orDoElBjet |
|
protected |
◆ m_orDoEleJet
| bool ST::SUSYObjDef_xAOD::m_orDoEleJet |
|
protected |
◆ m_orDoElEl
| bool ST::SUSYObjDef_xAOD::m_orDoElEl |
|
protected |
◆ m_orDoElMu
| bool ST::SUSYObjDef_xAOD::m_orDoElMu |
|
protected |
◆ m_orDoFatjets
| bool ST::SUSYObjDef_xAOD::m_orDoFatjets |
|
protected |
◆ m_orDoMuBjet
| bool ST::SUSYObjDef_xAOD::m_orDoMuBjet |
|
protected |
◆ m_orDoMuonJet
| bool ST::SUSYObjDef_xAOD::m_orDoMuonJet |
|
protected |
◆ m_orDoMuonJetGhostAssociation
| bool ST::SUSYObjDef_xAOD::m_orDoMuonJetGhostAssociation |
|
protected |
◆ m_orDoPhoton
| bool ST::SUSYObjDef_xAOD::m_orDoPhoton |
|
protected |
◆ m_orDoTau
| bool ST::SUSYObjDef_xAOD::m_orDoTau |
|
protected |
◆ m_orDoTauBjet
| bool ST::SUSYObjDef_xAOD::m_orDoTauBjet |
|
protected |
◆ m_orInputLabel
| std::string ST::SUSYObjDef_xAOD::m_orInputLabel |
|
protected |
◆ m_orLinkOverlapObjects
| bool ST::SUSYObjDef_xAOD::m_orLinkOverlapObjects |
|
protected |
◆ m_orMuJetInnerDR
| double ST::SUSYObjDef_xAOD::m_orMuJetInnerDR |
|
protected |
◆ m_orMuJetPtRatio
| double ST::SUSYObjDef_xAOD::m_orMuJetPtRatio |
|
protected |
◆ m_orMuJetTrkPtRatio
| double ST::SUSYObjDef_xAOD::m_orMuJetTrkPtRatio |
|
protected |
◆ m_orPhotonFavoured
| bool ST::SUSYObjDef_xAOD::m_orPhotonFavoured |
|
protected |
◆ m_orRemoveCaloMuons
| bool ST::SUSYObjDef_xAOD::m_orRemoveCaloMuons |
|
protected |
◆ m_orToolbox
◆ m_outElectronLocation
◆ m_outMETTerm
| std::string ST::SUSYObjDef_xAOD::m_outMETTerm |
|
protected |
◆ m_outMuonLocation
◆ m_outputMetaStore
◆ m_ph_id_support
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_ph_id_support |
|
protected |
◆ m_photonAllowLate
| bool ST::SUSYObjDef_xAOD::m_photonAllowLate |
|
protected |
◆ m_photonBaselineCrackVeto
| bool ST::SUSYObjDef_xAOD::m_photonBaselineCrackVeto |
|
protected |
◆ m_photonBaselineEta
| double ST::SUSYObjDef_xAOD::m_photonBaselineEta |
|
protected |
◆ m_photonBaselineIso_WP
| std::string ST::SUSYObjDef_xAOD::m_photonBaselineIso_WP |
|
protected |
◆ m_photonBaselinePt
| double ST::SUSYObjDef_xAOD::m_photonBaselinePt |
|
protected |
◆ m_photonCrackVeto
| bool ST::SUSYObjDef_xAOD::m_photonCrackVeto |
|
protected |
◆ m_photonEfficiencySFTool
◆ m_photonEfficiencySFTool_trigEff_AsymDiphoton
◆ m_photonEfficiencySFTool_trigSF_AsymDiphoton
◆ m_photonEta
| double ST::SUSYObjDef_xAOD::m_photonEta |
|
protected |
◆ m_photonId
| std::string ST::SUSYObjDef_xAOD::m_photonId |
|
protected |
◆ m_photonIdBaseline
| std::string ST::SUSYObjDef_xAOD::m_photonIdBaseline |
|
protected |
◆ m_photonIdBaselineDFName
| std::string ST::SUSYObjDef_xAOD::m_photonIdBaselineDFName |
|
protected |
◆ m_photonIdDFName
| std::string ST::SUSYObjDef_xAOD::m_photonIdDFName |
|
protected |
◆ m_photonIso_WP
| std::string ST::SUSYObjDef_xAOD::m_photonIso_WP |
|
protected |
◆ m_photonIsolationSFTool
◆ m_photonPt
| double ST::SUSYObjDef_xAOD::m_photonPt |
|
protected |
◆ m_photonSelIsEM
◆ m_photonSelIsEMBaseline
◆ m_photonTrigEffTools
◆ m_photonTriggerName
| std::string ST::SUSYObjDef_xAOD::m_photonTriggerName |
|
protected |
◆ m_photonTriggerSFTool
◆ m_photonTrigSFTools
◆ m_pmgSHnjetWeighter
◆ m_pmgSHnjetWeighterWZ
◆ m_prwActualMu2017File
| std::string ST::SUSYObjDef_xAOD::m_prwActualMu2017File |
|
protected |
◆ m_prwActualMu2018File
| std::string ST::SUSYObjDef_xAOD::m_prwActualMu2018File |
|
protected |
◆ m_prwActualMu2022File
| std::string ST::SUSYObjDef_xAOD::m_prwActualMu2022File |
|
protected |
◆ m_prwActualMu2023File
| std::string ST::SUSYObjDef_xAOD::m_prwActualMu2023File |
|
protected |
◆ m_prwActualMu2024File
| std::string ST::SUSYObjDef_xAOD::m_prwActualMu2024File |
|
protected |
◆ m_prwConfFiles
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_prwConfFiles |
|
protected |
◆ m_prwDataSF
| double ST::SUSYObjDef_xAOD::m_prwDataSF |
|
protected |
◆ m_prwDataSF_DW
| double ST::SUSYObjDef_xAOD::m_prwDataSF_DW |
|
protected |
◆ m_prwDataSF_UP
| double ST::SUSYObjDef_xAOD::m_prwDataSF_UP |
|
protected |
◆ m_prwLcalcFiles
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_prwLcalcFiles |
|
protected |
◆ m_prwTool
◆ m_runDepPrescaleWeightPRW
| bool ST::SUSYObjDef_xAOD::m_runDepPrescaleWeightPRW |
|
protected |
◆ m_runECIS
| bool ST::SUSYObjDef_xAOD::m_runECIS |
|
protected |
◆ m_showerType
| int ST::SUSYObjDef_xAOD::m_showerType |
|
protected |
◆ m_slices
| std::map<std::string,bool> ST::SUSYObjDef_xAOD::m_slices |
|
protected |
◆ m_softTermParam
| int ST::SUSYObjDef_xAOD::m_softTermParam |
|
protected |
◆ m_strictConfigCheck
| bool ST::SUSYObjDef_xAOD::m_strictConfigCheck |
|
protected |
◆ m_subtool_init
| bool ST::SUSYObjDef_xAOD::m_subtool_init |
|
protected |
◆ m_tau_id_support
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_tau_id_support |
|
protected |
◆ m_tau_trig_support
| std::map<std::string, std::string> ST::SUSYObjDef_xAOD::m_tau_trig_support |
|
protected |
◆ m_tauConfigPath
| std::string ST::SUSYObjDef_xAOD::m_tauConfigPath |
|
protected |
◆ m_tauConfigPathBaseline
| std::string ST::SUSYObjDef_xAOD::m_tauConfigPathBaseline |
|
protected |
◆ m_tauConfigReader
| TEnv ST::SUSYObjDef_xAOD::m_tauConfigReader |
|
protected |
◆ m_tauDoTTM
| bool ST::SUSYObjDef_xAOD::m_tauDoTTM |
|
protected |
◆ m_tauEffTool
◆ m_tauEffToolRecommendationTag
| std::string ST::SUSYObjDef_xAOD::m_tauEffToolRecommendationTag |
|
protected |
◆ m_tauEta
| double ST::SUSYObjDef_xAOD::m_tauEta |
|
protected |
◆ m_tauId
| std::string ST::SUSYObjDef_xAOD::m_tauId |
|
protected |
◆ m_tauIdBaseline
| std::string ST::SUSYObjDef_xAOD::m_tauIdBaseline |
|
protected |
◆ m_tauJetORtool
◆ m_tauPrePtCut
| double ST::SUSYObjDef_xAOD::m_tauPrePtCut |
|
protected |
◆ m_tauPt
| double ST::SUSYObjDef_xAOD::m_tauPt |
|
protected |
◆ m_tauSelTool
◆ m_tauSelToolBaseline
◆ m_tauSmearingTool
◆ m_tauSmearingToolGenerator
| std::string ST::SUSYObjDef_xAOD::m_tauSmearingToolGenerator |
|
protected |
◆ m_tauSmearingToolRecommendationTag
| std::string ST::SUSYObjDef_xAOD::m_tauSmearingToolRecommendationTag |
|
protected |
◆ m_tauTerm
| std::string ST::SUSYObjDef_xAOD::m_tauTerm |
|
protected |
◆ m_tauTrigEffTool
◆ m_tauTruthMatch
◆ m_tool_init
| bool ST::SUSYObjDef_xAOD::m_tool_init |
|
protected |
◆ m_TopconfigReader
| TEnv ST::SUSYObjDef_xAOD::m_TopconfigReader |
|
protected |
◆ m_TopDecorName
| std::string ST::SUSYObjDef_xAOD::m_TopDecorName |
|
protected |
◆ m_ToptagConfig
| std::string ST::SUSYObjDef_xAOD::m_ToptagConfig |
|
protected |
◆ m_TopTaggerCalibArea
| std::string ST::SUSYObjDef_xAOD::m_TopTaggerCalibArea |
|
protected |
◆ m_TopTaggerTool
◆ m_TopTagjetUncertaintiesTool
◆ m_TopTagUncConfig
| std::string ST::SUSYObjDef_xAOD::m_TopTagUncConfig |
|
protected |
◆ m_treatPUJets
| bool ST::SUSYObjDef_xAOD::m_treatPUJets |
|
protected |
◆ m_trig2015combination_diLep
| std::string ST::SUSYObjDef_xAOD::m_trig2015combination_diLep |
|
protected |
◆ m_trig2015combination_diPhoton
| std::string ST::SUSYObjDef_xAOD::m_trig2015combination_diPhoton |
|
protected |
◆ m_trig2015combination_multiLep
| std::string ST::SUSYObjDef_xAOD::m_trig2015combination_multiLep |
|
protected |
◆ m_trig2015combination_singleLep
| std::string ST::SUSYObjDef_xAOD::m_trig2015combination_singleLep |
|
protected |
◆ m_trig2016combination_diLep
| std::string ST::SUSYObjDef_xAOD::m_trig2016combination_diLep |
|
protected |
◆ m_trig2016combination_diPhoton
| std::string ST::SUSYObjDef_xAOD::m_trig2016combination_diPhoton |
|
protected |
◆ m_trig2016combination_multiLep
| std::string ST::SUSYObjDef_xAOD::m_trig2016combination_multiLep |
|
protected |
◆ m_trig2016combination_singleLep
| std::string ST::SUSYObjDef_xAOD::m_trig2016combination_singleLep |
|
protected |
◆ m_trig2017combination_diLep
| std::string ST::SUSYObjDef_xAOD::m_trig2017combination_diLep |
|
protected |
◆ m_trig2017combination_diPhoton
| std::string ST::SUSYObjDef_xAOD::m_trig2017combination_diPhoton |
|
protected |
◆ m_trig2017combination_multiLep
| std::string ST::SUSYObjDef_xAOD::m_trig2017combination_multiLep |
|
protected |
◆ m_trig2017combination_singleLep
| std::string ST::SUSYObjDef_xAOD::m_trig2017combination_singleLep |
|
protected |
◆ m_trig2018combination_diLep
| std::string ST::SUSYObjDef_xAOD::m_trig2018combination_diLep |
|
protected |
◆ m_trig2018combination_diPhoton
| std::string ST::SUSYObjDef_xAOD::m_trig2018combination_diPhoton |
|
protected |
◆ m_trig2018combination_multiLep
| std::string ST::SUSYObjDef_xAOD::m_trig2018combination_multiLep |
|
protected |
◆ m_trig2018combination_singleLep
| std::string ST::SUSYObjDef_xAOD::m_trig2018combination_singleLep |
|
protected |
◆ m_trig2022combination_diLep
| std::string ST::SUSYObjDef_xAOD::m_trig2022combination_diLep |
|
protected |
◆ m_trig2022combination_diPhoton
| std::string ST::SUSYObjDef_xAOD::m_trig2022combination_diPhoton |
|
protected |
◆ m_trig2022combination_multiLep
| std::string ST::SUSYObjDef_xAOD::m_trig2022combination_multiLep |
|
protected |
◆ m_trig2022combination_singleLep
| std::string ST::SUSYObjDef_xAOD::m_trig2022combination_singleLep |
|
protected |
◆ m_trig2023combination_singleLep
| std::string ST::SUSYObjDef_xAOD::m_trig2023combination_singleLep |
|
protected |
◆ m_trig2024combination_singleLep
| std::string ST::SUSYObjDef_xAOD::m_trig2024combination_singleLep |
|
protected |
◆ m_trigConfTool
◆ m_trigDecTool
◆ m_trigDRScoringTool
◆ m_triggerCacheMutex
| std::mutex ST::SUSYObjDef_xAOD::m_triggerCacheMutex |
|
mutableprivate |
◆ m_trigGlobalEffCorrTool_diLep
◆ m_trigGlobalEffCorrTool_diPhoton
◆ m_trigGlobalEffCorrTool_multiLep
◆ m_trigMatchingPrefix
| std::string ST::SUSYObjDef_xAOD::m_trigMatchingPrefix |
|
protected |
Use composite trigger matching tool if matching was done upstream.
Definition at line 529 of file SUSYObjDef_xAOD.h.
◆ m_trigMatchingTool
◆ m_trigMatchScoringTool
◆ m_trigNToys_diLep
| int ST::SUSYObjDef_xAOD::m_trigNToys_diLep |
|
protected |
◆ m_trigNToys_diPhoton
| int ST::SUSYObjDef_xAOD::m_trigNToys_diPhoton |
|
protected |
◆ m_trigNToys_multiLep
| int ST::SUSYObjDef_xAOD::m_trigNToys_multiLep |
|
protected |
◆ m_trkJetEta
| double ST::SUSYObjDef_xAOD::m_trkJetEta |
|
protected |
◆ m_trkJetPt
| double ST::SUSYObjDef_xAOD::m_trkJetPt |
|
protected |
◆ m_trkJetsyst
| bool ST::SUSYObjDef_xAOD::m_trkJetsyst |
|
protected |
◆ m_trkMETsyst
| bool ST::SUSYObjDef_xAOD::m_trkMETsyst |
|
protected |
◆ m_upstreamTriggerMatching
| bool ST::SUSYObjDef_xAOD::m_upstreamTriggerMatching |
|
protected |
◆ m_useBtagging
| bool ST::SUSYObjDef_xAOD::m_useBtagging |
|
protected |
◆ m_useBtagging_trkJet
| bool ST::SUSYObjDef_xAOD::m_useBtagging_trkJet |
|
protected |
◆ m_useCommonPRWFiles
| bool ST::SUSYObjDef_xAOD::m_useCommonPRWFiles |
|
protected |
◆ m_useIncidents
| bool asg::AsgMetadataTool::m_useIncidents |
|
privateinherited |
◆ m_useSigLepForIsoCloseByOR
| bool ST::SUSYObjDef_xAOD::m_useSigLepForIsoCloseByOR |
|
protected |
◆ m_useTRUTH3
| bool ST::SUSYObjDef_xAOD::m_useTRUTH3 |
|
protected |
◆ m_v_trigs15_cache_diLep
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs15_cache_diLep |
|
private |
◆ m_v_trigs15_cache_multiLep
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs15_cache_multiLep |
|
private |
◆ m_v_trigs15_cache_singleEle
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs15_cache_singleEle |
|
private |
◆ m_v_trigs15_cache_singleLep
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs15_cache_singleLep |
|
private |
◆ m_v_trigs16_cache_diLep
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs16_cache_diLep |
|
private |
◆ m_v_trigs16_cache_multiLep
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs16_cache_multiLep |
|
private |
◆ m_v_trigs16_cache_singleEle
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs16_cache_singleEle |
|
private |
◆ m_v_trigs16_cache_singleLep
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs16_cache_singleLep |
|
private |
◆ m_v_trigs17_cache_diLep
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs17_cache_diLep |
|
private |
◆ m_v_trigs17_cache_multiLep
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs17_cache_multiLep |
|
private |
◆ m_v_trigs17_cache_singleEle
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs17_cache_singleEle |
|
private |
◆ m_v_trigs17_cache_singleLep
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs17_cache_singleLep |
|
private |
◆ m_v_trigs18_cache_diLep
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs18_cache_diLep |
|
private |
◆ m_v_trigs18_cache_multiLep
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs18_cache_multiLep |
|
private |
◆ m_v_trigs18_cache_singleEle
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs18_cache_singleEle |
|
private |
◆ m_v_trigs18_cache_singleLep
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs18_cache_singleLep |
|
private |
◆ m_v_trigs22_cache_diLep
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs22_cache_diLep |
|
private |
◆ m_v_trigs22_cache_multiLep
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs22_cache_multiLep |
|
private |
◆ m_v_trigs22_cache_singleEle
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs22_cache_singleEle |
|
private |
◆ m_v_trigs22_cache_singleLep
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs22_cache_singleLep |
|
private |
◆ m_v_trigs23_cache_singleEle
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs23_cache_singleEle |
|
private |
◆ m_v_trigs23_cache_singleLep
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs23_cache_singleLep |
|
private |
◆ m_v_trigs24_cache_singleEle
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs24_cache_singleEle |
|
private |
◆ m_v_trigs24_cache_singleLep
| std::vector<std::string> ST::SUSYObjDef_xAOD::m_v_trigs24_cache_singleLep |
|
private |
◆ m_varHandleArraysDeclared
◆ m_vhka
◆ m_WconfigReader
| TEnv ST::SUSYObjDef_xAOD::m_WconfigReader |
|
protected |
◆ m_WDecorName
| std::string ST::SUSYObjDef_xAOD::m_WDecorName |
|
protected |
◆ m_WtagConfig
| std::string ST::SUSYObjDef_xAOD::m_WtagConfig |
|
protected |
◆ m_WTaggerTool
◆ m_WTagjetUncertaintiesTool
◆ m_WTagUncConfig
| std::string ST::SUSYObjDef_xAOD::m_WTagUncConfig |
|
protected |
◆ m_WZTaggerCalibArea
| std::string ST::SUSYObjDef_xAOD::m_WZTaggerCalibArea |
|
protected |
◆ m_ZconfigReader
| TEnv ST::SUSYObjDef_xAOD::m_ZconfigReader |
|
protected |
◆ m_ZDecorName
| std::string ST::SUSYObjDef_xAOD::m_ZDecorName |
|
protected |
◆ m_ZtagConfig
| std::string ST::SUSYObjDef_xAOD::m_ZtagConfig |
|
protected |
◆ m_ZTaggerTool
◆ m_ZTagjetUncertaintiesTool
◆ m_ZTagUncConfig
| std::string ST::SUSYObjDef_xAOD::m_ZTagUncConfig |
|
protected |
◆ prompt_electrons
◆ prompt_muons
The documentation for this class was generated from the following files:
std::vector< std::string > m_v_trigs15_cache_singleLep
def retrieve(aClass, aKey=None)
bool m_autoconfigPRWCombinedmode
double GetTauTriggerEfficiencySF(const xAOD::TauJet &tau, const std::string &trigExpr="tau25_medium1_tracktwo") override final
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonEfficiencySFTool
bool emulateHLT(const std::string &triggerName) const
const std::string bJetLabel
asg::AnaToolHandle< CP::IIsolationSelectionTool > m_isoHighPtTool
std::string m_photonIdBaselineDFName
std::string m_autoconfigPRWRtags
SG::WriteHandleKey< xAOD::ElectronContainer > m_outElectronLocation
virtual double pt() const override final
The transverse momentum ( ) of the particle.
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_GSFLRTCollectionName
double m_orBoostedElectronC1
@ numberOfPixelHoles
number of pixel layers on track with absence of hits [unit8_t].
SG::ConstAccessor< char > m_acc_photonIdBaseline
double m_photonBaselinePt
bool IsHighPtMuon(const xAOD::Muon &input) const override final
StatusCode MergeElectrons(const xAOD::ElectronContainer &electrons, xAOD::ElectronContainer *outputCol, const std::set< const xAOD::Electron * > &ElectronsToRemove) const override final
asg::AnaToolHandle< IAsgDeadHVCellRemovalTool > m_deadHVTool
float nPixelDeadSensors(const U &p)
asg::AnaToolHandle< CP::IJvtEfficiencyTool > m_jetfJvtEfficiencyTool
asg::AnaToolHandle< TauAnalysisTools::ITauSelectionTool > m_tauSelTool
bool isGaugino(const T &p)
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
std::string m_trig2022combination_multiLep
std::string m_commonPRWFileMC23e
double GetTotalTauSF(const xAOD::TauJetContainer &taus, const bool idSF=true, const bool triggerSF=true, const std::string &trigExpr="tau25_medium1_tracktwo") override final
bool m_metDoSetMuonJetEMScale
std::vector< std::string > m_v_trigs18_cache_diLep
Const iterator class for DataVector/DataList.
float BtagSF(const xAOD::JetContainer *jets) override final
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_ZTagjetUncertaintiesTool
asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionTool > m_trigGlobalEffCorrTool_multiLep
int IsTrackBJetContinuous(const xAOD::Jet &input) const override final
bool IsTruthBJet(const xAOD::Jet &input) const override final
Electron_v1 Electron
Definition of the current "egamma version".
Egamma_v1 Egamma
Definition of the current "egamma version".
std::string m_trig2022combination_diPhoton
std::mutex m_triggerCacheMutex
std::string m_jetUncertaintiesCalibArea
std::string m_prwActualMu2022File
std::string m_jesConfigAFII
std::string m_BtagSystStrategy
std::string m_tauEffToolRecommendationTag
std::string m_tauIdBaseline
bool IsSignalElectron(const xAOD::Electron &input, const float etcut, const float d0sigcut, const float z0cut, const float etacut=DUMMYDEF) const override final
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecChargeEffCorrTool
StatusCode prepareLRTMuons(const xAOD::MuonContainer *inMuons, xAOD::MuonContainer *copy) const override final
ToolHandleArray< IAsgPhotonEfficiencyCorrectionTool > m_photonTrigEffTools
SG::ConstAccessor< char > m_acc_eleId
double JVT_SFsys(const xAOD::JetContainer *jets, const CP::SystematicSet &systConfig) override final
std::string m_eleIsoHighPt_WP
bool m_eleAllowRun3TrigSFFallback
asg::AnaToolHandle< CP::IEgammaCalibrationAndSmearingTool > m_egammaCalibTool
Combined electron collection.
double GetTotalMuonTriggerSF(const xAOD::MuonContainer &sfmuons, const std::string &trigExpr) override final
Scalar phi() const
phi method
std::string m_trig2016combination_diPhoton
SG::ConstAccessor< char > m_acc_eleIdBaseline
virtual CorrectionCode getTriggerEfficiency(const xAOD::Muon &mu, Double_t &efficiency, const std::string &trigger, Bool_t dataType) const =0
const std::vector< std::string > split(const std::string &s, const std::string &delim) const
const xAOD::ElectronContainer * prompt_electrons
bool m_metDoRemoveMuonJets
std::vector< CP::SystematicSet > make_systematics_vector(const SystematicSet &systematics)
utility functions for working with systematics
std::string find(const std::string &s)
return a remapped string
SG::ReadDecorHandleKey< xAOD::JetContainer > m_label_truthKey
std::vector< std::string > m_v_trigs23_cache_singleLep
std::map< std::string, std::string > m_conf_to_prop
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonEfficiencyBMHighPtSFTool
asg::AnaToolHandle< IWeightTool > m_pmgSHnjetWeighterWZ
bool IsBJet(const xAOD::Jet &input) const override final
std::vector< std::string > m_v_trigs15_cache_multiLep
std::map< std::string, std::string > m_legsPerTool
std::string m_ZTagUncConfig
std::string m_tauSmearingToolGenerator
asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionTool > m_trigGlobalEffCorrTool_diPhoton
bool m_photonBaselineCrackVeto
bool m_fatJetUncertaintiesPDsmearing
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_reco
Combined muon collection.
@ VIEW_ELEMENTS
this data object is a view, it does not own its elmts
void getTauConfig(const std::string &tauConfigPath, std::vector< float > &pT_window, std::vector< float > &eta_window, bool &eleOLR, bool &muVeto, bool &muOLR) const
asg::AnaToolHandle< IAsgElectronLikelihoodTool > m_elecSelLikelihood
std::vector< std::string > m_v_trigs24_cache_singleEle
std::vector< std::string > GetTriggerOR(const std::string &trigExpr) const
StatusCode FillMuon(xAOD::Muon &input, const float ptcut, const float etacut) override final
size_t size() const
returns: size of the set
std::vector< asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > > m_elecEfficiencySFTool_trig_mixLep
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
asg::AnaToolHandle< JetPileupTag::JetVertexNNTagger > m_jetNNJvtMomentTool
std::string m_muTriggerSFCalibRelease
bool IsBadMuon(const xAOD::Muon &input, const float qopcut) const override final
const xAOD::MuonContainer * lrt_muons
std::string m_EigenvectorReductionC
std::string m_fJvtConfigRun2
asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > m_photonTriggerSFTool
asg::AnaToolHandle< CP::IIsolationSelectionTool > m_isoBaselineTool
ToolHandleArray< IAsgElectronEfficiencyCorrectionTool > m_elecTrigEffTools
std::string m_JvtConfigRun2
asg::AnaToolHandle< TauAnalysisTools::ITauSmearingTool > m_tauSmearingTool
std::vector< std::string > m_v_trigs17_cache_singleEle
bool IsCosmicMuon(const xAOD::Muon &input, const float z0cut, const float d0cut) const override final
double d0significance(const xAOD::TrackParticle *tp, double d0_uncert_beam_spot_2)
std::vector< std::string > m_el_iso_support
const TruthParticle * truthParticle(size_t index) const
Get a pointer to one of the truth particles.
StatusCode recommendedTools(const ORFlags &flags, ToolBox &toolBox)
Pre-configured standard recommended OR tools.
std::string m_trig2015combination_singleLep
void configFromFile(bool &property, const std::string &propname, TEnv &rEnv, bool defaultValue)
bool m_metRemoveOverlappingCaloTaggedMuons
asg::AnaToolHandle< IMETMaker > m_metMaker
StatusCode FillElectron(xAOD::Electron &input, const float etcut, const float etacut) override final
std::string m_trig2018combination_diPhoton
Class to wrap a set of SystematicVariations.
asg::AnaToolHandle< Trig::IMatchScoringTool > m_trigMatchScoringTool
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
asg::AnaToolHandle< JSSWTopTaggerDNN > m_TopTaggerTool
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
virtual StatusCode rebuildJetMET(const std::string &metJetKey, const std::string &metSoftKey, xAOD::MissingETContainer *metCont, const xAOD::JetContainer *jets, const xAOD::MissingETContainer *metCoreCont, xAOD::MissingETAssociationHelper &helper, bool doJetJVT) const =0
std::vector< SG::VarHandleKeyArray * > m_vhka
std::string m_photonIso_WP
StatusCode prepareLRTElectrons(const xAOD::ElectronContainer *inMuons, xAOD::ElectronContainer *copy) const override final
const T * get(size_type n) const
Access an element, as an rvalue.
std::vector< std::string > m_v_trigs18_cache_singleLep
std::string name() const
returns: the systematics joined into a single string.
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
float beamPosSigmaX() const
The width of the beam spot in the X direction.
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonTTVAEfficiencySFTool
std::map< std::string, std::string > m_el_iso_fallback
const char * name() const
Get the name of the container instance.
std::string m_commonPRWFileMC21a
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
std::string m_prwActualMu2024File
std::vector< CP::SystematicSet > m_fatjetFFSmearingSyst
bool IsSignalPhoton(const xAOD::Photon &input, const float ptcut, const float etacut=DUMMYDEF) const override final
virtual double GetSignificance() const =0
bool isSquark(const T &p)
PDG rule 11d Fundamental supersymmetric particles are identified by adding a nonzero n to the particl...
@ numberOfTRTHits
number of TRT hits [unit8_t].
bool m_orDoTau
Overlap removal options.
std::vector< std::string > m_v_trigs18_cache_singleEle
const uint32_t BADCLUSELECTRON
asg::AnaToolHandle< CP::IPileupReweightingTool > m_prwTool
std::string m_muBaselineIso_WP
std::string m_trig2016combination_multiLep
std::string m_inputMETSuffix
asg::AnaToolHandle< SmoothedWZTagger > m_WTaggerTool
std::string m_eleConfigBaseline
const xAOD::Vertex * GetPrimVtx() const override final
void GetTriggerTokens(std::string, std::vector< std::string > &, std::vector< std::string > &, std::vector< std::string > &, std::vector< std::string > &, std::vector< std::string > &, std::vector< std::string > &, std::vector< std::string > &) const
std::vector< std::string > m_v_trigs22_cache_singleLep
std::string m_bTaggingCalibrationFilePath
std::vector< std::string > m_v_trigs22_cache_singleEle
ToolHandleArray< IAsgPhotonEfficiencyCorrectionTool > m_photonTrigSFTools
#define ATH_MSG_VERBOSE(x)
asg::AnaToolHandle< Trig::IMatchingTool > m_trigMatchingTool
const std::string & key() const
Return the StoreGate ID for the referenced object.
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_jetUncertaintiesPDSmearTool
StatusCode FillJet(xAOD::Jet &input, const bool doCalib=true, bool isFat=false, bool doLargeRdecorations=false) override final
std::string to_string(const SectorProjector proj)
bool IsSignalMuon(const xAOD::Muon &input, const float ptcut, const float d0sigcut, const float z0cut, const float etacut=DUMMYDEF) const override final
double m_elebaselined0sig
Class providing the definition of the 4-vector interface.
asg::AnaToolHandle< CP::IElectronLRTOverlapRemovalTool > m_elecLRTORTool
std::string m_trig2017combination_diPhoton
double GetSignalPhotonSFsys(const xAOD::Photon &ph, const CP::SystematicSet &systConfig, const bool effSF=true, const bool isoSF=true, const bool triggerSF=false) override final
std::vector< std::string > m_mu_iso_support
std::vector< std::string > m_tau_id_support
bool is_same_particle(const T1 &p1, const T2 &p2)
Method to establish if two particles in the GenEvent actually represent the same particle.
@ numberOfBLayerHits
these are the hits in the first pixel layer, i.e.
std::string m_fatJetUncVars
std::string m_eleEffMapFilePath
uint32_t runNumber() const
The current event's run number.
asg::AnaToolHandle< JetVertexTaggerTool > m_jetJvtMomentTool
std::string m_eleIdBaseline
bool isVariation(const CP::SystematicSet &syst) const
float BtagSF_trkJet(const xAOD::JetContainer *trkjets) override final
ORUtils::ToolBox m_orToolbox
std::string m_tauConfigPath
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_LRTCollectionName
double m_photonBaselineEta
virtual void setOwner(IDataHandleHolder *o)=0
std::vector< std::string > m_v_trigs15_cache_singleEle
asg::AnaToolHandle< CP::IMuonLRTOverlapRemovalTool > m_muonLRTORTool
std::string m_commonPRWFileMC20d
const xAOD::TrackParticleContainer & GetInDetLargeD0GSFTracks(const EventContext &ctx) const override final
SG::ConstAccessor< char > m_acc_jetClean
virtual StatusCode rebuildTrackMET(const std::string &metJetKey, const std::string &metSoftKey, xAOD::MissingETContainer *metCont, const xAOD::JetContainer *jets, const xAOD::MissingETContainer *metCoreCont, xAOD::MissingETAssociationHelper &helper, bool doJetJVT) const =0
bool IsTrackBJet(const xAOD::Jet &input) const override final
asg::AnaToolHandle< IBTaggingEfficiencyTool > m_btagEffTool_trkJet
StatusCode FillTrackJet(xAOD::Jet &input) override final
double FJVT_SFsys(const xAOD::JetContainer *jets, const CP::SystematicSet &systConfig) override final
StatusCode buildMETSum(const std::string &totalName, xAOD::MissingETContainer *metCont)
uint32_t mcChannelNumber() const
The MC generator's channel number.
std::vector< std::string > m_v_trigs17_cache_diLep
std::map< std::string, bool > m_slices
bool m_orLinkOverlapObjects
std::string m_eleEffMapFilePathRun2
@ JetConstitScaleMomentum
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_isoHighPt
std::string m_trig2018combination_singleLep
double m_orBoostedMuonMaxConeSize
asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > m_photonEfficiencySFTool
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
virtual CorrectionCode getTriggerScaleFactor(const xAOD::MuonContainer &mucont, Double_t &triggersf, const std::string &trigger) const =0
std::map< std::string, std::string > m_tau_trig_support
asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionTool > m_trigGlobalEffCorrTool_diLep
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
std::string m_WZTaggerCalibArea
std::vector< std::string > m_prwLcalcFiles
bool passOQquality(const xAOD::Photon &ph)
Helper to ease the implemmantation of the pass Quality requirements.
@ OutOfValidityRange
Input object is out of validity range.
std::vector< std::string > m_el_id_support
@ Error
Some error happened during the object correction.
void setProperty(columnar::PythonToolHandle &self, const std::string &key, nb::object value)
std::string m_defaultJets
std::vector< std::string > m_ph_id_support
StatusCode SUSYToolsInit()
std::vector< asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > > m_elecEfficiencySFTool_trigEff_mixLep
void addGhostMuonsToJets(const xAOD::MuonContainer &muons, xAOD::JetContainer &jets)
std::string m_TopTaggerCalibArea
bool isWeight(const CP::SystematicSet &systSet) const
std::string m_fatJetUncConfig
int IsBJetContinuous(const xAOD::Jet &input) const override final
unsigned int GetRunNumber() const override final
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_id
Handle class for reading a decoration on an object.
StatusCode readConfig() override final
bool pc(const std::string &taggername, double &value) const
virtual asg::AcceptData accept(const xAOD::IParticle *part) const =0
accept with pointer to IParticle so as to not hide the IAsgSelectionTool one
std::string m_IsoCloseByORpassLabel
const xAOD::ElectronContainer * lrt_electrons
std::string m_tauSmearingToolRecommendationTag
std::string m_jetUncertaintiesConfig
Prefix for trigger matchiing container name.
asg::AnaToolHandle< IJetCalibrationTool > m_jetCalibTool
std::map< std::string, std::string > m_mu_iso_fallback
std::vector< std::string > m_v_trigs22_cache_multiLep
std::vector< asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > > m_photonEfficiencySFTool_trigEff_AsymDiphoton
std::vector< asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > > m_photonEfficiencySFTool_trigSF_AsymDiphoton
bool isNominal(const CP::SystematicSet &syst) const
double GetMuonTriggerEfficiency(const xAOD::Muon &mu, const std::string &trigExpr, const bool isdata=false) override final
double deltaR(double rapidity1, double phi1, double rapidity2, double phi2)
from bare bare rapidity,phi
std::string m_jesCalibArea
float nSCTHits(const U &p)
const uint16_t AuthorAmbiguous
Object Reconstructed by standard cluster-based algorithm.
std::string m_trig2017combination_singleLep
float nTRTHits(const U &p)
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonIsolationSFTool
std::string m_jetCleanDFName
std::string m_jesCalibSeq
::StatusCode StatusCode
StatusCode definition for legacy code.
SystType getSystType(const CP::SystematicVariation &systematic)
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_jetUncertaintiesTool
bool IsSignalJet(const xAOD::Jet &input, const float ptcut, const float etacut) const override final
Class describing a truth particle in the MC record.
Class describing a tau jet.
std::vector< std::string > m_v_trigs17_cache_singleLep
std::string m_muTriggerSFCalibFilename
asg::AnaToolHandle< CP::IMuonCalibrationAndSmearingTool > m_muonCalibTool
asg::AnaToolHandle< SmoothedWZTagger > m_ZTaggerTool
std::string m_trig2017combination_multiLep
std::pair< std::vector< unsigned int >, bool > res
double FJVT_SF(const xAOD::JetContainer *jets) override final
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
std::string m_jesConfigJMS
std::string m_eleIdDFName
cut
This script demonstrates how to call a C++ class from Python Also how to use PyROOT is shown.
virtual StatusCode rebuildMET(const std::string &metKey, xAOD::Type::ObjectType metType, xAOD::MissingETContainer *metCont, const xAOD::IParticleContainer *collection, xAOD::MissingETAssociationHelper &helper, MissingETBase::UsageHandler::Policy objScale=MissingETBase::UsageHandler::PhysicsObject) const =0
std::string m_jetUncertaintiesMCType
std::string m_commonPRWFileMC20e
bool check_isTighter(const std::string &wp1, const std::string &wp, const std::vector< std::string > &list) const
static StatusCode setProperty(const GaudiHandleBase &toolHandle, const std::string &property, const int &value, bool override=true)
std::string m_jetUncertaintiesAnalysisFile
std::map< std::string, std::string > m_legsPerTool_ph
asg::AnaToolHandle< IAsgSelectionTool > m_jetfJvtSelectionTool
asg::AnaToolHandle< IAsgPhotonIsEMSelector > m_photonSelIsEM
std::string m_trig2016combination_diLep
bool m_jetUncertaintiesPDsmearing
asg::AnaToolHandle< IMETSystematicsTool > m_metSystTool
const std::string & name(Level lvl)
Convenience function for translating message levels to strings.
const xAOD::MuonContainer * prompt_muons
double m_BtagMinPt_trkJet
std::vector< std::string > m_v_trigs15_cache_diLep
double m_muIsoHighPtThresh
asg::AnaToolHandle< JetPileupLabelingTool > m_jetPileupLabelingTool
std::string m_trigMatchingPrefix
Use composite trigger matching tool if matching was done upstream.
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_WTagjetUncertaintiesTool
asg::AnaToolHandle< TauAnalysisTools::ITauSelectionTool > m_tauSelToolBaseline
bool isData() const override final
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
std::set< std::string > m_bool_prop_set
std::string m_trig2018combination_diLep
std::string m_jesConfigFat
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
std::string m_trig2022combination_diLep
bool IsBadJet(const xAOD::Jet &input) const override final
std::string m_eleIdBaselineDFName
bool IsTrigMatched(const xAOD::IParticle *part, const std::string &tr_item) override final
@ numberOfSCTHoles
number of SCT holes [unit8_t].
bool isAtlfast() const override final
std::string m_trig2015combination_multiLep
asg::AnaToolHandle< IBTaggingSelectionTool > m_btagSelTool_trkJet
size_t index() const
Return the index of this element within its container.
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_fatjetUncertaintiesTool
std::string m_jesCalibSeqJMS
float nSCTHoles(const U &p)
std::string m_WTagUncConfig
bool m_runDepPrescaleWeightPRW
StatusCode SetBtagWeightDecorations(const xAOD::Jet &input, const asg::AnaToolHandle< IBTaggingSelectionTool > &btagSelTool, const std::string &btagTagger) const override final
std::string m_prwActualMu2017File
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_trigEff_singleLep
const xAOD::EventInfo * GetEventInfo() const override final
asg::AnaToolHandle< ORUtils::IOverlapTool > m_tauJetORtool
std::string m_photonBaselineIso_WP
virtual void renounce()=0
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_iso
std::vector< std::string > m_prwConfFiles
std::string m_metJetSelection
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
float beamPosSigmaY() const
The width of the beam spot in the Y direction.
asg::AnaToolHandle< TauAnalysisTools::ITauTruthMatchingTool > m_tauTruthMatch
std::string m_trig2022combination_singleLep
std::string EG_WP(const std::string &wp) const
bool pu(const std::string &taggername, double &value) const
std::string m_inputMETCore
float averageInteractionsPerCrossing() const
Average interactions per crossing for all BCIDs - for out-of-time pile-up.
bool check_isOption(const std::string &wp, const std::vector< std::string > &list) const
Container for xAOD::MissingET_v1 objects.
std::string m_trig2024combination_singleLep
bool m_eleForceFullSimCalib
asg::AnaToolHandle< IAsgElectronLikelihoodTool > m_elecSelLikelihoodBaseline
asg::AnaToolHandle< TrigConf::ITrigConfigTool > m_trigConfTool
double GetSignalPhotonSF(const xAOD::Photon &ph, const bool effSF=true, const bool isoSF=true, const bool triggerSF=false) const override final
std::string m_EigenvectorReductionLight
Muon_v1 Muon
Reference the current persistent version:
std::vector< std::string > m_v_trigs24_cache_singleLep
std::string m_ToptagConfig
asg::AnaToolHandle< TauAnalysisTools::ITauEfficiencyCorrectionsTool > m_tauEffTool
asg::AnaToolHandle< CP::IMuonSelectionTool > m_muonSelectionToolBaseline
bool IsMETTrigPassed(unsigned int runnumber=0, bool j400_OR=false) const override final
double error(const Amg::MatrixX &mat, int index)
return diagonal error of the matrix caller should ensure the matrix is symmetric and the index is in ...
float getSherpaVjetsNjetsWeight() const override final
void TrigMatch(const xAOD::IParticle *p, std::initializer_list< std::string >::iterator, std::initializer_list< std::string >::iterator) override final
bool m_useBtagging_trkJet
StatusCode FillTau(xAOD::TauJet &input) override final
asg::AnaToolHandle< CP::IIsolationCloseByCorrectionTool > m_isoCloseByTool
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_trig_singleLep
std::string m_trig2018combination_multiLep
asg::AnaToolHandle< IBTaggingSelectionTool > m_btagSelTool_OR
size_t nTruthParticles() const
Get the number of truth particles.
virtual StatusCode tag(const xAOD::Jet &jet) const override
Decorate single jet with tagging info.
value_type push_back(value_type pElem)
Add an element to the end of the collection.
std::string m_commonPRWFileMC20a
asg::AnaToolHandle< CP::IMuonSelectionTool > m_muonSelectionHighPtTool
std::string m_fJvtConfigRun3
bool m_ApplyMVATESQualityCheck
std::string m_BtagWP_trkJet
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_fatjetUncertaintiesPDSmearTool
asg::AnaToolHandle< ICPJetCorrectionTool > m_fatjetFFSmearingTool
void setName(const char *name)
Set the name of the container instance.
virtual StatusCode markInvisible(const xAOD::IParticleContainer *collection, xAOD::MissingETAssociationHelper &helper, xAOD::MissingETContainer *metCont) const =0
std::pair< std::unique_ptr< T >, std::unique_ptr< ShallowAuxContainer > > shallowCopyContainer(const T &cont, [[maybe_unused]] const EventContext &ctx)
Function making a shallow copy of a constant container.
SG::WriteHandleKey< xAOD::MuonContainer > m_outMuonLocation
bool isSlepton(const T &p)
Class describing the basic event information.
Photon_v1 Photon
Definition of the current "egamma version".
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
ST::SystInfo getSystInfo(const CP::SystematicVariation &sys) const override final
struct TBPatternUnitContext Muon
bool isPileup(int origin)
from pileup
const BTagging * getBTagging(const SG::AuxElement &part)
Access the default xAOD::BTagging object associated to an object.
asg::AnaToolHandle< IBTaggingSelectionTool > m_btagSelTool
asg::AnaToolHandle< IAsgSelectionTool > m_jetNNJvtSelectionTool
@ numberOfTRTOutliers
number of TRT outliers [unit8_t].
double m_orMuJetTrkPtRatio
StatusCode FillPhoton(xAOD::Photon &input, const float ptcut, const float etacut) override final
std::vector< std::string > m_v_trigs16_cache_diLep
asg::AnaToolHandle< CP::IMuonTriggerScaleFactors > m_muonTriggerSFTool
const uint32_t BADCLUSPHOTON
double GetSignalTauSF(const xAOD::TauJet &tau, const bool idSF=true, const bool triggerSF=true, const std::string &trigExpr="tau25_medium1_tracktwo") override final
std::vector< std::string > getElSFkeys(const std::string &mapFile) const
std::string m_jesConfigJMSData
std::string m_trig2016combination_singleLep
@ Ok
The correction was done successfully.
asg::AnaToolHandle< IBTaggingEfficiencyTool > m_btagEffTool
asg::AnaToolHandle< IAsgElectronLikelihoodTool > m_elecChargeIDSelectorTool
float beamPosSigmaXY() const
The beam spot shape's X-Y correlation.
double m_orBoostedElectronMaxConeSize
StatusCode FindSusyHP(int &pdgid1, int &pdgid2) const
std::string m_eleBaselineIso_WP
std::string m_inputMETMap
std::string m_BtagTagger_trkJet
bool m_autoconfigPRWRPVmode
Class describing a Vertex.
static bool FindSusyHardProc(const xAOD::TruthParticleContainer *truthP, int &pdgid1, int &pdgid2, bool isTruth3=false)
StatusCode validConfig(bool strict=false) const
std::string m_EG_corrModel
std::vector< std::string > m_v_trigs18_cache_multiLep
std::string m_JetTruthLabelName
double JVT_SF(const xAOD::JetContainer *jets) override final
#define ATH_MSG_WARNING(x)
bool m_orDoBoostedElectron
@ numberOfSCTDeadSensors
number of dead SCT sensors crossed [unit8_t].
asg::AnaToolHandle< IAsgPhotonIsEMSelector > m_photonSelIsEMBaseline
float GetSignalMuonSF(const xAOD::Muon &mu, const bool recoSF=true, const bool isoSF=true, const bool doBadMuonHP=true, const bool warnOVR=true) override final
This module implements the central registry for handling systematic uncertainties with CP tools.
DataVector adapter that acts like it holds const pointers.
A struct of global config options used to simplify the config helper interface.
bool m_metVeryGreedyPhotons
double GetTriggerGlobalEfficiencySF(const xAOD::ElectronContainer &electrons, const xAOD::MuonContainer &muons, const std::string &trigExpr="diLepton") override final
bool setOriginalObjectLink(const IParticle &original, IParticle ©)
This function should be used by CP tools when they make a deep copy of an object in their correctedCo...
asg::AnaToolHandle< Trig::TrigDecisionTool > m_trigDecTool
std::string m_metsysConfigPrefix
std::string m_defaultTrackJets
std::string m_prwActualMu2023File
std::string m_jesCalibSeqFat
const SystematicSet & recommendedSystematics() const
returns: the recommended set of systematics
std::string m_TopTagUncConfig
StatusCode applySystematicVariation(const CP::SystematicSet &systConfig) override final
Return value from object correction CP tools.
CP::SystematicSet m_currentSyst
std::string m_tauConfigPathBaseline
const uint16_t AuthorPhoton
Object Reconstructed by standard cluster-based algorithm.
std::string m_autoconfigPRWPath
std::string m_photonIdDFName
asg::AnaToolHandle< IJetCalibrationTool > m_jetFatCalibTool
std::string m_electronTriggerSFStringSingle
asg::AnaToolHandle< CP::IJvtEfficiencyTool > m_jetNNJvtEfficiencyTool
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
virtual CorrectionCode getEfficiencyScaleFactor(const xAOD::Muon &mu, float &sf, const xAOD::EventInfo *info=0) const =0
Retrieve the Scale factor.
float BtagSFsys(const xAOD::JetContainer *jets, const CP::SystematicSet &systConfig) override final
float nSCTDeadSensors(const U &p)
std::vector< std::string > m_v_trigs17_cache_multiLep
std::vector< std::string > m_v_trigs23_cache_singleEle
std::string m_trig2017combination_diLep
asg::AnaToolHandle< Trig::IMatchScoringTool > m_trigDRScoringTool
std::string m_trig2015combination_diLep
asg::AnaToolHandle< JetTruthLabelingTool > m_jetTruthLabelingTool
@ numberOfSCTHits
number of hits in SCT [unit8_t].
asg::AnaToolHandle< IMETSignificance > m_metSignif
@ Tau
The object is a tau (jet)
std::string m_autoconfigPRWFile
std::vector< std::string > m_v_trigs16_cache_singleLep
std::string m_jesConfigFatData
int atoi(std::string_view str)
Helper functions to unpack numbers decoded in string into integers and doubles The strings are requir...
bool isAvailable(const ELT &e) const
Test to see if this variable exists in the store.
std::string m_commonPRWFileMC23c
std::vector< std::string > m_v_trigs16_cache_multiLep
bool passOQqualityDelayed(const xAOD::Photon &ph)
Helpers to ease the implementation of the pass Quality requirements.
@ numberOfPixelDeadSensors
number of dead pixel sensors crossed [unit8_t].
bool m_muHighPtExtraSmear
std::string m_photonTriggerName
Class describing a TrackParticle.
std::vector< std::string > veto
these patterns are anded
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_TopTagjetUncertaintiesTool
std::string m_EigenvectorReductionB
double m_orBoostedElectronC2
const IParticle * getOriginalObject(const IParticle ©)
This function can be used to conveniently get a pointer back to the original object from which a copy...
@ BTag
The object is a b-tagging object.
std::string m_trig2023combination_singleLep
float updateJvt(const xAOD::Jet &jet) const override
Calculate the updated JVT.
StatusCode MergeMuons(const xAOD::MuonContainer &muons, const std::vector< bool > &writeMuon, xAOD::MuonContainer *outputCol) const override final
std::vector< std::string > getListOfTriggers() const
std::vector< std::string > m_v_trigs22_cache_diLep
std::string m_orInputLabel
virtual StatusCode decorate(const xAOD::JetContainer &jetCont) const override
Decorate a jet collection without otherwise modifying it.
bool m_eleBaselineCrackVeto
std::string m_muIsoHighPt_WP
bool m_murequirepassedHighPtCuts
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonHighPtIsolationSFTool
std::string m_photonIdBaseline
int treatAsYear(const int runNumber=-1) const override final
setBGCode setTAP setLVL2ErrorBits bool
ToolHandleArray< CP::IMuonTriggerScaleFactors > m_muonTrigSFTools
asg::AnaToolHandle< IJetSelector > m_jetCleaningTool
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
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="")
std::string m_BtagKeyOverride
std::string m_commonPRWFileMC23a
bool m_orDoMuonJetGhostAssociation
size_type size() const noexcept
Returns the number of elements in the collection.
asg::AnaToolHandle< CP::IIsolationCorrectionTool > m_isoCorrTool
std::string m_defaultTruthJets
ToolHandleArray< IAsgElectronEfficiencyCorrectionTool > m_elecTrigSFTools
std::vector< asg::AnaToolHandle< TauAnalysisTools::ITauEfficiencyCorrectionsTool > > m_tauTrigEffTool
Jet_v1 Jet
Definition of the current "jet version".
std::string m_TopDecorName
std::vector< std::string > m_v_trigs16_cache_singleEle
std::string m_commonPRWFileMC23d
bool empty() const noexcept
Returns true if the collection is empty.
const xAOD::TrackParticleContainer & GetInDetLargeD0Tracks(const EventContext &ctx) const override final
bool m_upstreamTriggerMatching
std::string m_fatJetUncertaintiesMCType
asg::AnaToolHandle< InDet::IInclusiveTrackFilterTool > m_LRTuncTool
virtual StatusCode varianceMET(xAOD::MissingETContainer *metCont, float avgmu, const std::string &jetTermName, const std::string &softTermName, const std::string &totalMETName)=0
std::string m_EG_corrFNList
SG::ConstAccessor< char > m_acc_photonId
bool match(std::string s1, std::string s2)
match the individual directories of two strings
bool IsSignalTau(const xAOD::TauJet &input, const float ptcut, const float etacut) const override final
asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > m_photonIsolationSFTool
bool isTrigInTDT(std::scoped_lock< std::mutex > &lock, const std::string &triggerName) const
asg::AnaToolHandle< CP::IMuonSelectionTool > m_muonSelectionTool
bool m_useSigLepForIsoCloseByOR
virtual StatusCode tag(const xAOD::Jet &jet) const override
Decorate single jet with tagging info.
static SystematicRegistry & getInstance()
Get the singleton instance of the registry for the curren thread.
static std::string retrieveMetadata(const std::string &folder, const std::string &key, const ServiceHandle< StoreGateSvc > &inputMetaStore)
method that always returns as a string you can use from, e.g, pyROOT with evt = ROOT....
asg::AnaToolHandle< IEGammaAmbiguityTool > m_egammaAmbiguityTool
std::string m_prwActualMu2018File
std::string getDefaultJetUncConfig()
bool pb(const std::string &taggername, double &value) const
double m_eleIsoHighPtThresh
double m_orBJetPtUpperThres
std::string m_trig2015combination_diPhoton
asg::AnaToolHandle< CP::IIsolationSelectionTool > m_isoTool
std::string m_JvtConfigRun3
CP::SystematicSet m_defaultSyst
bool IsBJetLoose(const xAOD::Jet &input) const override final
asg::AnaToolHandle< IWeightTool > m_pmgSHnjetWeighter
1.8.18