ATLAS Offline Software
Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
CP::JetQGTagger Class Referenceabstract

#include <JetQGTagger.h>

Inheritance diagram for CP::JetQGTagger:
Collaboration diagram for CP::JetQGTagger:

Public Member Functions

 JetQGTagger (const std::string &name)
 
virtual ~JetQGTagger ()
 
virtual StatusCode initialize () override
 Initialize the tool. More...
 
virtual StatusCode tag (const xAOD::Jet &jet, const xAOD::Vertex *pv) const override
 
virtual StatusCode tag (const xAOD::Jet &jet) const override
 
virtual bool isAffectedBySystematic (const SystematicVariation &var) const override
 returns: whether this tool is affected by the given systematic guarantee: no-fail More...
 
virtual SystematicSet affectingSystematics () const override
 returns: the list of all systematics this tool can be affected by guarantee: strong failures: out of memory II More...
 
virtual SystematicSet recommendedSystematics () const override
 returns: the list of all systematics this tool can be affected by guarantee: strong failures: out of memory II More...
 
virtual StatusCode applySystematicVariation (const SystematicSet &set) override
 effects: configure this tool for the given list of systematic variations. More...
 
virtual StatusCode sysApplySystematicVariation (const SystematicSet &) override
 effects: configure this tool for the given list of systematic variations. More...
 
virtual void print () const =0
 Print the state of the tool. More...
 
virtual StatusCode decorate (const xAOD::JetContainer &jets) const override
 Decorate jet collection with tagging info. 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 sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 
virtual StatusCode modify (xAOD::JetContainer &jets) const override final
 Concrete implementation of the function inherited from IJetModifier. More...
 
const SystematicSet & appliedSystematics () const
 returns: the list of systematics that have been applied to this tool. More...
 
std::string appliedSystematicsString () const
 returns: a string representation of appliedSystematics() guarantee: strong failures: out of memory II rationale: this is meant to be used when printing out the applied systematics for debugging purposes (or when embedding them in a string). More...
 
void testInvariant () const
 effects: test the invariance of this object guarantee: no-fail More...
 

Protected Types

enum  TAGCLASS { Unknown, WBoson, ZBoson, TopQuark }
 TAGTYPE enum. More...
 

Protected Member Functions

StatusCode getConfigReader ()
 Get configReader StatusCode. More...
 
StatusCode resetCuts (asg::AcceptData &acceptData) const
 Reset cuts. More...
 
bool passKinRange (const xAOD::Jet &jet) const
 Check if jet passes kinematic constraints. More...
 
StatusCode checkKinRange (const xAOD::Jet &jet, asg::AcceptData &acceptData) const
 Check and record if jet passes kinematic constraints. More...
 
int calculateJSSRatios (const xAOD::Jet &jet) const
 Calculate JSS moment ratios in case they are not already saved TODO: Remove this once JSSMomentTools is modified to take const jets. More...
 
int findPV () const
 Find the PV (to be used for Ntrk) More...
 
StatusCode GetUnGroomTracks (const xAOD::Jet &jet, int indexPV) const
 Retrieve Ntrk variable from the ungroomed parent jet. More...
 
StatusCode getWeight (const xAOD::Jet &jet, bool passSel, asg::AcceptData &acceptData) const
 Get SF weight. More...
 
std::pair< double, double > getSF (const xAOD::Jet &jet, const std::string &truthLabelStr) const
 Get scale factor and efficiency. More...
 
std::string getTruthLabelStr (const xAOD::Jet &jet, asg::AcceptData &acceptData) const
 
void printCuts () const
 Print configured cuts. More...
 
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...
 
StatusCode addAffectingSystematic (const SystematicVariation &systematic, bool recommended)
 effects: add a systematic to the list of registered systematics. More...
 
StatusCode addRecommendedSystematic (const SystematicVariation &systematic)
 effects: add a systematic to the list of recommended systematics failures: unsupported systematic More...
 
void addAffectingSystematics (const SystematicSet &systematics)
 effects: add a SystematicSet to the registered systematics. More...
 
StatusCode addRecommendedSystematics (const SystematicSet &systematics)
 effects: add a SystematicSet to the recommended systematics. More...
 

Protected Attributes

TEnv m_configReader
 TEnv instance to read config files. More...
 
asg::AcceptInfo m_acceptInfo
 Object that stores the results for a jet. More...
 
SG::ReadHandleKey< xAOD::JetContainer > m_jetContainer_key {this, "JetContainer", "AntiKt10UFOCSSKSoftDropBeta100Zcut10Jets", "SG key for input jet container"}
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decTaggedKey {this, "TaggedName", "Tagged", "SG key for Tagged"}
 WriteDecorHandle keys for tagging bools. More...
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decValidPtRangeHighKey {this, "ValidPtRangeHighName", "ValidPtRangeHigh", "SG key for ValidPtRangeHigh"}
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decValidPtRangeLowKey {this, "ValidPtRangeLowName", "ValidPtRangeLow", "SG key for ValidPtRangeLow"}
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decValidEtaRangeKey {this, "ValidEtaRangeName", "ValidEtaRange", "SG key for ValidEtaRange"}
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decValidKinRangeKey {this, "ValidKinRangeName", "ValidKinRange", "SG key for ValidKinRange"}
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decValidJetContentKey {this, "ValidJetContentName", "ValidJetContent", "SG key for ValidJetContent"}
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decValidEventContentKey {this, "ValidEventContentName", "ValidEventContent", "SG key for ValidEventContent"}
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decPassMassKey {this, "PassMassName", "PassMass", "SG key for PassMass"}
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decPassScoreKey {this, "PassScoreName", "PassScore", "SG key for PassScore"}
 
const int m_nWarnMax = 10
 Maximum number of warnings. More...
 
std::atomic< int > m_nWarnVar
 Warning counters. More...
 
bool m_ptGeV = false
 Flag to indicate units pT is defined in Set to false by default. More...
 
bool m_useMassCut = false
 Flag to indicate if mass window cut is used. More...
 
bool m_useScoreCut = false
 Flag to indicate if a discriminant score is used. More...
 
TAGCLASS m_tagClass
 
std::string m_containerName
 Configurable members. More...
 
std::string m_weightConfigPath
 Path to the SF configuration root file. More...
 
std::string m_configFile
 Configuration file name. More...
 
std::string m_calibArea
 Location where config files live on cvmfs. More...
 
std::string m_kerasConfigFileName
 Keras configurations for ML taggers. More...
 
std::string m_kerasConfigFilePath
 
std::string m_kerasConfigOutputName
 
std::string m_kerasCalibArea
 
std::string m_tmvaConfigFileName
 TMVA configurations for BDT taggers. More...
 
std::string m_tmvaConfigFilePath
 
std::string m_tmvaCalibArea
 
std::string m_wkpt
 Tagger information. More...
 
std::string m_tagType
 
float m_jetPtMin
 Kinematic bounds for the jet - the units are controlled by m_ptGeV. More...
 
float m_jetPtMax
 
float m_jetEtaMax
 
bool m_useECFG = false
 Flags controlling whether generalized ECF moments or L-series ratios are needed TODO: Implement the functionality controlled by these. More...
 
bool m_useLSeries = false
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decTau21WTAKey {this, "Tau21WTANameOut", "Tau21_wta", "SG key for Tau21_wta"}
 WriteDecorHandle keys for JSS moments. More...
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decTau32WTAKey {this, "Tau32WTANameOut", "Tau32_wta", "SG key for Tau32_wta"}
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decTau42WTAKey {this, "Tau42WTANameOut", "Tau42_wta", "SG key for Tau42_wta"}
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decC2Key {this, "C2NameOut", "C2", "SG key for C2"}
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decD2Key {this, "D2NameOut", "D2", "SG key for D2"}
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decE3Key {this, "e3NameOut", "e3", "SG key for e3"}
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decL2Key {this, "L2NameOut", "L2", "SG key for L2"}
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decL3Key {this, "L3NameOut", "L3", "SG key for L3"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readTau1WTAKey {this, "Tau1WTAName", "Tau1_wta", "SG key for Tau1_wta"}
 ReadDecorHandle keys for JSS moments. More...
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readTau2WTAKey {this, "Tau2WTAName", "Tau2_wta", "SG key for Tau2_wta"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readTau3WTAKey {this, "Tau3WTAName", "Tau3_wta", "SG key for Tau3_wta"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readTau4WTAKey {this, "Tau4WTAName", "Tau4_wta", "SG key for Tau4_wta"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readTau21WTAKey {this, "Tau21WTAName", "Tau21_wta", "SG key for Tau21_wta"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readTau32WTAKey {this, "Tau32WTAName", "Tau32_wta", "SG key for Tau32_wta"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readTau42WTAKey {this, "Tau42WTAName", "Tau42_wta", "SG key for Tau42_wta"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readECF1Key {this, "ECF1Name", "ECF1", "SG key for ECF1"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readECF2Key {this, "ECF2Name", "ECF2", "SG key for ECF2"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readECF3Key {this, "ECF3Name", "ECF3", "SG key for ECF3"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readC2Key {this, "C2Name", "C2", "SG key for C2"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readD2Key {this, "D2Name", "D2", "SG key for D2"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readE3Key {this, "e3Name", "e3", "SG key for e3"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readSplit12Key {this, "Split12Name", "Split12", "SG key for Split12"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readSplit23Key {this, "Split23Name", "Split23", "SG key for Split23"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readQwKey {this, "QwName", "Qw", "SG key for Qw"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readThrustMajKey {this, "ThrustMajName", "ThrustMaj", "SG key for ThrustMaj"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readSphericityKey {this, "SphericityName", "Sphericity", "SG key for Sphericity"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readL2Key {this, "L2Name", "L2", "SG key for L2"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readL3Key {this, "L3Name", "L3", "SG key for L3"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readECFG331Key {this, "ECFG331Name", "ECFG_3_3_1", "SG key for ECFG_3_3_1"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readECFG311Key {this, "ECFG311Name", "ECFG_3_1_1", "SG key for ECFG_3_1_1"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readECFG212Key {this, "ECFG212Name", "ECFG_2_1_2", "SG key for ECFG_2_1_2"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readParentKey {this, "ParentName", "Parent", "SG key for Parent"}
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decNtrk500Key {this, "Ntrk500NameOut", "ParentJetNTrkPt500", "SG key for Ntrk500 from ungroomed jet"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readNtrk500Key {this, "Ntrk500Name", "ParentJetNTrkPt500", "SG key for Ntrk500 from ungroomed jet"}
 
bool m_suppressOutputDependence
 
std::string m_strMassCutLow
 Strings for cut functions. More...
 
std::string m_strMassCutHigh
 
std::string m_strScoreCut
 
std::unique_ptr< TF1 > m_funcMassCutLow
 TF1 for cut functions. More...
 
std::unique_ptr< TF1 > m_funcMassCutHigh
 
std::unique_ptr< TF1 > m_funcScoreCut
 
std::string m_decorationName
 Decoration name. More...
 
bool m_calcSF
 Flag to calculate scale factor. More...
 
bool m_isMC
 
std::string m_weightDecorationName
 String for scale factor decoration names. More...
 
std::string m_weightFileName
 
std::string m_weightHistogramName
 
std::string m_efficiencyHistogramName
 
std::string m_weightFlavors
 
std::unique_ptr< TFile > m_weightConfig
 Histograms for scale factors. More...
 
std::map< std::string, std::unique_ptr< TH2D > > m_weightHistograms
 
std::map< std::string, std::unique_ptr< TH2D > > m_efficiencyHistograms
 
bool m_truthLabelUseTRUTH3
 Truth label options. More...
 
std::string m_truthParticleContainerName
 
std::string m_truthBosonContainerName
 
std::string m_truthTopQuarkContainerName
 
std::string m_truthLabelName
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readTruthLabelKey {this, "truthLabelName", "truthLabel", "SG key for truthLabel"}
 Truth label ReadDecorHandle key. More...
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decCutMLowKey {this, "CutMLowName", "Cut_mlow", "SG key for Cut_mlow"}
 WriteDecorHandle keys for cut values. More...
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decCutMHighKey {this, "CutMHighName", "Cut_mhigh", "SG key for Cut_mhigh"}
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decScoreCutKey {this, "CutScoreName", "Cut_score", "SG key for Cut_score"}
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decScoreValueKey {this, "ScoreName", "Score", "SG key for Score"}
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decWeightKey {this, "weightName", "weight", "SG key for weight"}
 WriteDecorHandle keys for SF. More...
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decEfficiencyKey {this, "efficiencyName", "efficiency", "SG key for efficiency"}
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decEffSFKey {this, "effSFName", "effSF", "SG key for effSF"}
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decSigeffSFKey {this, "sigeffSFName", "sigeffSF", "SG key for effSF"}
 
SystematicSet m_affectingSystematics
 description: members directly corresponding to accessors More...
 
SystematicSet m_recommendedSystematics
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

 JetQGTagger ()
 
StatusCode getNTrack (const xAOD::Jet *jet, int &ntracks) const
 
StatusCode getNTrackWeight (const xAOD::Jet *jet, double &weight) const
 
StatusCode simplegetNTrackWeight (const xAOD::Jet *jet, double &weight) const
 
StatusCode loadHist (TH2D *&hist, const std::string &filename, const std::string &histname)
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

QGSystApplied m_appliedSystEnum
 
TH2D * m_hquark
 
TH2D * m_hgluon
 
TH2D * m_topo_hquark
 
TH2D * m_exp_hquark_up
 
TH2D * m_exp_hquark_down
 
TH2D * m_exp_hgluon_up
 
TH2D * m_exp_hgluon_down
 
TH2D * m_me_hquark_up
 
TH2D * m_me_hquark_down
 
TH2D * m_me_hgluon_up
 
TH2D * m_me_hgluon_down
 
TH2D * m_pdf_hquark_up
 
TH2D * m_pdf_hquark_down
 
TH2D * m_pdf_hgluon_up
 
TH2D * m_pdf_hgluon_down
 
TH2D * m_trackeff_hquark
 
TH2D * m_trackeff_hgluon
 
TH2D * m_fake_hquark
 
TH2D * m_fake_hgluon
 
std::string m_taggername
 
std::string m_topofile
 
std::string m_expfile
 
std::string m_mefile
 
std::string m_pdffile
 
std::string m_trackefffile
 
std::string m_fakefile
 
std::string m_weight_decoration_name
 
std::string m_tagger_decoration_name
 
int m_NTrackCut
 
double m_slope
 
double m_intercept
 
std::string m_cuttype
 
int m_mode
 
asg::AnaToolHandle< InDet::IInDetTrackSelectionTool > m_trkSelectionTool
 
asg::AnaToolHandle< InDet::IInDetTrackTruthFilterTool > m_trkTruthFilterTool
 
asg::AnaToolHandle< InDet::IInDetTrackTruthFilterTool > m_trkFakeTool
 
asg::AnaToolHandle< InDet::IJetTrackFilterTool > m_jetTrackFilterTool
 
asg::AnaToolHandle< InDet::IInDetTrackTruthOriginTool > m_originTool
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readNumTrkPt500PVKey {this, "NumTrkPt500PVName", "NumTrkPt500PV", "SG key for NumTrkPt500PV"}
 ReadDecorHandle keys. More...
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readNtrkKey {this, "NtrkName", "DFCommonJets_QGTagger_NTracks", "SG key for Ntrk"}
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decTagKey {this, "TagName", "Tag", "SG key for Tag"}
 WriteDecorHandle keys. More...
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_qgDecWeightKey {this, "QGWeightName", "Weight", "SG key for Weight"}
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 
SystematicSet * m_appliedSystematics
 description: pointer to currenty applied systematics More...
 
std::unordered_map< SystematicSet, SystematicSet > m_systFilterMap
 map of cached systematics filtering More...
 

Detailed Description

Definition at line 36 of file JetQGTagger.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ TAGCLASS

enum JSSTaggerBase::TAGCLASS
protectedinherited

TAGTYPE enum.

Enumerator
Unknown 
WBoson 
ZBoson 
TopQuark 

Definition at line 99 of file JSSTaggerBase.h.

99 {Unknown, WBoson, ZBoson, TopQuark};

Constructor & Destructor Documentation

◆ JetQGTagger() [1/2]

CP::JetQGTagger::JetQGTagger ( const std::string &  name)

Definition at line 22 of file JetQGTagger.cxx.

22  : JSSTaggerBase( name ),
23  m_appliedSystEnum(QG_NONE),
24  m_hquark(nullptr),
25  m_hgluon(nullptr),
26  m_topo_hquark(nullptr),
27  m_exp_hquark_up(nullptr),
28  m_exp_hquark_down(nullptr),
29  m_exp_hgluon_up(nullptr),
30  m_exp_hgluon_down(nullptr),
31  m_me_hquark_up(nullptr),
32  m_me_hquark_down(nullptr),
33  m_me_hgluon_up(nullptr),
34  m_me_hgluon_down(nullptr),
35  m_pdf_hquark_up(nullptr),
36  m_pdf_hquark_down(nullptr),
37  m_pdf_hgluon_up(nullptr),
38  m_pdf_hgluon_down(nullptr),
39  m_trackeff_hquark(nullptr),
40  m_trackeff_hgluon(nullptr),
41  m_fake_hquark(nullptr),
42  m_fake_hgluon(nullptr),
43  m_trkSelectionTool(name+"_trackselectiontool", this),
44  m_trkTruthFilterTool(name+"_trackfiltertool",this),
45  m_trkFakeTool(name+"_trackfaketool",this),
46  m_jetTrackFilterTool(name+"_jettrackfiltertool",this),
47  m_originTool(name+"_origintool",this)
48  {
49 
50  declareProperty( "NTrackCut", m_NTrackCut=-1);
51  declareProperty( "cuttype", m_cuttype="log_pt");
52  declareProperty( "slope", m_slope=9.779);
53  declareProperty( "intercept", m_intercept=-32.28);
54  declareProperty( "UseJetVars", m_mode = 0); // 0 uses the tracks. 1 uses variables from the jets
55 
56  declareProperty( "Tagger", m_taggername = "ntrack");
57  declareProperty( "TopoWeightFile", m_topofile = "");
58  declareProperty( "ExpWeightFile", m_expfile = "qgsyst_exp.root");
59  declareProperty( "MEWeightFile", m_mefile = "qgsyst_me.root");
60  declareProperty( "PDFWeightFile", m_pdffile = "qgsyst_pdf.root");
61  declareProperty( "TrackEffFile", m_trackefffile = "track_systs.root");//REPLACE when file available
62  declareProperty( "FakeFile", m_fakefile = "track_systs.root");//REPLACE when file available
63  declareProperty( "MinPt", m_jetPtMin = 50e3);
64  declareProperty( "MaxEta", m_jetEtaMax = 2.1);
65  declareProperty( "WeightDecorationName", m_weight_decoration_name = "qgTaggerWeight");
66  declareProperty( "TaggerDecorationName", m_tagger_decoration_name = "qgTagger");
67 
68 
69  JetQGTagger::applySystematicVariation(SystematicSet()).ignore();
70 
71  }

◆ ~JetQGTagger()

CP::JetQGTagger::~JetQGTagger ( )
virtual

Definition at line 222 of file JetQGTagger.cxx.

222  {
223 
224  delete m_topo_hquark;
225  delete m_exp_hquark_up;
226  delete m_exp_hquark_down;
227  delete m_exp_hgluon_up;
228  delete m_exp_hgluon_down;
229  delete m_me_hquark_up;
230  delete m_me_hquark_down;
231  delete m_me_hgluon_up;
232  delete m_me_hgluon_down;
233  delete m_pdf_hquark_up;
234  delete m_pdf_hquark_down;
235  delete m_pdf_hgluon_up;
236  delete m_pdf_hgluon_down;
237  delete m_trackeff_hquark;
238  delete m_trackeff_hgluon;
239  delete m_fake_hquark;
240  delete m_fake_hgluon;
241 
242  }

◆ JetQGTagger() [2/2]

CP::JetQGTagger::JetQGTagger ( )
private

Member Function Documentation

◆ addAffectingSystematic()

StatusCode CP::SystematicsTool::addAffectingSystematic ( const SystematicVariation &  systematic,
bool  recommended 
)
protectedinherited

effects: add a systematic to the list of registered systematics.

It will optionally also add this sytematic to the recommended set. side effects: this will add the systematic to the global list of systematics, if not already there guarantee: strong failures: out of memory II

Definition at line 111 of file SystematicsTool.cxx.

112  {
113 
114  RCU_READ_INVARIANT( this );
115 
116  SystematicRegistry& reg = SystematicRegistry::getInstance();
117  reg.registerSystematic( systematic );
118  m_affectingSystematics.insert( systematic );
119  if( recommended ) {
120  if( addRecommendedSystematic(systematic) != StatusCode::SUCCESS ) {
121  return StatusCode::FAILURE;
122  }
123  }
124  return StatusCode::SUCCESS;
125  }

◆ addAffectingSystematics()

void CP::SystematicsTool::addAffectingSystematics ( const SystematicSet &  systematics)
protectedinherited

effects: add a SystematicSet to the registered systematics.

Definition at line 141 of file SystematicsTool.cxx.

142  {
143 
144  RCU_READ_INVARIANT( this );
145 
146  SystematicRegistry& reg = SystematicRegistry::getInstance();
147  m_affectingSystematics.insert( systematics );
148  reg.registerSystematics( systematics );
149  }

◆ addRecommendedSystematic()

StatusCode CP::SystematicsTool::addRecommendedSystematic ( const SystematicVariation &  systematic)
protectedinherited

effects: add a systematic to the list of recommended systematics failures: unsupported systematic

Definition at line 127 of file SystematicsTool.cxx.

128  {
129 
130  RCU_READ_INVARIANT( this );
131 
132  SystematicRegistry& reg = SystematicRegistry::getInstance();
133  m_recommendedSystematics.insert( systematic );
134  if( reg.addSystematicToRecommended( systematic ) !=
135  StatusCode::SUCCESS ) {
136  return StatusCode::FAILURE;
137  }
138  return StatusCode::SUCCESS;
139  }

◆ addRecommendedSystematics()

StatusCode CP::SystematicsTool::addRecommendedSystematics ( const SystematicSet &  systematics)
protectedinherited

effects: add a SystematicSet to the recommended systematics.

Definition at line 151 of file SystematicsTool.cxx.

152  {
153 
154  RCU_READ_INVARIANT( this );
155 
156  SystematicRegistry& reg = SystematicRegistry::getInstance();
157  m_recommendedSystematics.insert( systematics );
158  if( reg.addSystematicsToRecommended( systematics ) !=
159  StatusCode::SUCCESS ) {
160  return StatusCode::FAILURE;
161  }
162  return StatusCode::SUCCESS;
163  }

◆ affectingSystematics()

virtual SystematicSet CP::JetQGTagger::affectingSystematics ( ) const
inlineoverridevirtual

returns: the list of all systematics this tool can be affected by guarantee: strong failures: out of memory II

Reimplemented from CP::SystematicsTool.

Definition at line 52 of file JetQGTagger.h.

52 {return SystematicsTool::affectingSystematics();}

◆ appliedSystematics()

const SystematicSet & CP::SystematicsTool::appliedSystematics ( ) const
inherited

returns: the list of systematics that have been applied to this tool.

this is not including systematics that were applied, but do not affect this tool guarantee: no-fail

Definition at line 54 of file SystematicsTool.cxx.

54  {
55 
56  RCU_READ_INVARIANT( this );
57  if(m_appliedSystematics == 0){
58  std::cerr << "SystematicsTool::appliedSystematics WARNING: "
59  << "no systematic configuration has been applied yet. "
60  << "Returning NULL" << std::endl;
61  static const SystematicSet dummy;
62  return dummy;
63  }
64  return *m_appliedSystematics;
65  }

◆ appliedSystematicsString()

std::string CP::SystematicsTool::appliedSystematicsString ( ) const
inherited

returns: a string representation of appliedSystematics() guarantee: strong failures: out of memory II rationale: this is meant to be used when printing out the applied systematics for debugging purposes (or when embedding them in a string).

Definition at line 67 of file SystematicsTool.cxx.

67  {
68 
69  RCU_READ_INVARIANT( this );
70  return m_appliedSystematics->name();
71  }

◆ applySystematicVariation()

virtual StatusCode CP::JetQGTagger::applySystematicVariation ( const SystematicSet &  systConfig)
inlineoverridevirtual

effects: configure this tool for the given list of systematic variations.

any requested systematics that are not affecting this tool will be silently ignored (unless they cause other errors). guarantee: basic failures: out of memory II failures: systematic unknown failures: requesting multiple variations on the same systematic (e.g. up & down) failures: requesting an unsupported variation on an otherwise supported systematic (e.g. a 2 sigma variation and the tool only supports 1 sigma variations) failures: unsupported combination of supported systematic failures: other tool specific errors

Reimplemented from CP::SystematicsTool.

Definition at line 54 of file JetQGTagger.h.

54 {return SystematicsTool::applySystematicVariation(set);}

◆ calculateJSSRatios()

int JSSTaggerBase::calculateJSSRatios ( const xAOD::Jet &  jet) const
protectedinherited

Calculate JSS moment ratios in case they are not already saved TODO: Remove this once JSSMomentTools is modified to take const jets.

Calculate JSS moment ratios in case they are not already saved These are calculated by hand here because JetSubStructureMomentTools does not operate on const jets.

This should be changed in the future

Create write decor handles

Create read decor handles

WTA N-subjettiness ratios

ECF ratios

Definition at line 416 of file JSSTaggerBase.cxx.

416  {
417 
418  int result = 0;
419 
421  SG::WriteDecorHandle<xAOD::JetContainer, float> decTau21WTA(m_decTau21WTAKey);
422  SG::WriteDecorHandle<xAOD::JetContainer, float> decTau32WTA(m_decTau32WTAKey);
423  SG::WriteDecorHandle<xAOD::JetContainer, float> decTau42WTA(m_decTau42WTAKey);
424  SG::WriteDecorHandle<xAOD::JetContainer, float> decC2(m_decC2Key);
425  SG::WriteDecorHandle<xAOD::JetContainer, float> decD2(m_decD2Key);
426  SG::WriteDecorHandle<xAOD::JetContainer, float> decE3(m_decE3Key);
427  SG::WriteDecorHandle<xAOD::JetContainer, float> decL2(m_decL2Key);
428  SG::WriteDecorHandle<xAOD::JetContainer, float> decL3(m_decL3Key);
429 
431  SG::ReadDecorHandle<xAOD::JetContainer, float> readTau1WTA(m_readTau1WTAKey);
432  SG::ReadDecorHandle<xAOD::JetContainer, float> readTau2WTA(m_readTau2WTAKey);
433  SG::ReadDecorHandle<xAOD::JetContainer, float> readTau3WTA(m_readTau3WTAKey);
434  SG::ReadDecorHandle<xAOD::JetContainer, float> readTau4WTA(m_readTau4WTAKey);
435 
436  SG::ReadDecorHandle<xAOD::JetContainer, float> readECF1(m_readECF1Key);
437  SG::ReadDecorHandle<xAOD::JetContainer, float> readECF2(m_readECF2Key);
438  SG::ReadDecorHandle<xAOD::JetContainer, float> readECF3(m_readECF3Key);
439 
440  SG::ReadDecorHandle<xAOD::JetContainer, float> readECFG331(m_readECFG331Key);
441  SG::ReadDecorHandle<xAOD::JetContainer, float> readECFG311(m_readECFG311Key);
442  SG::ReadDecorHandle<xAOD::JetContainer, float> readECFG212(m_readECFG212Key);
443 
444  SG::ReadDecorHandle<xAOD::JetContainer, float> readL2(m_readL2Key);
445  SG::ReadDecorHandle<xAOD::JetContainer, float> readL3(m_readL3Key);
446 
447 
449  float tau21_wta = -999.0;
450  float tau32_wta = -999.0;
451  float tau42_wta = -999.0;
452 
453  float tau1_wta = readTau1WTA(jet);
454  float tau2_wta = readTau2WTA(jet);
455  float tau3_wta = readTau3WTA(jet);
456  float tau4_wta = -999.0;
457  if(readTau4WTA.isAvailable()){
458  tau4_wta = readTau4WTA(jet);
459  }
460 
461  if ( tau1_wta > 1e-8 ) {
462  tau21_wta = tau2_wta / tau1_wta;
463  }
464  else result = 1;
465 
466  if ( tau2_wta > 1e-8 ) {
467  tau32_wta = tau3_wta / tau2_wta;
468  if(readTau4WTA.isAvailable()){
469  tau42_wta = tau4_wta / tau2_wta;
470  }
471  }
472  else result = 1;
473 
474  decTau21WTA(jet) = tau21_wta;
475  decTau32WTA(jet) = tau32_wta;
476  decTau42WTA(jet) = tau42_wta;
477 
479  float C2 = -999.0;
480  float D2 = -999.0;
481  float e3 = -999.0;
482 
483  float ECF1 = readECF1(jet);
484  float ECF2 = readECF2(jet);
485  float ECF3 = readECF3(jet);
486 
487  if ( ECF2 > 1e-8 ) {
488  C2 = ECF3 * ECF1 / std::pow( ECF2, 2.0 );
489  D2 = ECF3 * std::pow( ECF1, 3.0 ) / std::pow( ECF2, 3.0 );
490  }
491  else result = 1;
492 
493  e3 = ECF3 / std::pow( ECF1, 3.0 );
494 
495  decC2(jet) = C2;
496  decD2(jet) = D2;
497  decE3(jet) = e3;
498 
499  // L-series for UFO top taggers
500  float L2 = -999.0;
501  float L3 = -999.0;
502 
503  if(!readL2.isAvailable()){
504  if(readECFG331.isAvailable() && readECFG212.isAvailable()){
505  if(readECFG212(jet) > 1e-8){
506  L2 = readECFG331(jet) / pow(readECFG212(jet), (3.0/2.0));
507  }
508  else result = 1;
509  }
510  decL2(jet) = L2;
511  }
512 
513  if(!readL3.isAvailable()){
514  if(readECFG331.isAvailable() && readECFG311.isAvailable()){
515  if(readECFG331(jet) > 1e-8){
516  L3 = readECFG311(jet) / pow(readECFG331(jet), (1.0/3.0));
517  }
518  else result = 1;
519  }
520  decL3(jet) = L3;
521  }
522 
523  // TODO: Add ECFG for ANN tagger whenever it is defined
524 
525  return result;
526 
527 }

◆ checkKinRange()

StatusCode JSSTaggerBase::checkKinRange ( const xAOD::Jet &  jet,
asg::AcceptData &  acceptData 
) const
protectedinherited

Check and record if jet passes kinematic constraints.

Check each kinematic constraint Print warnings using counters

Create write decor handles

Decorate kinematic pass information

Definition at line 370 of file JSSTaggerBase.cxx.

370  {
371 
372  float scale = 1.0;
373  if ( m_ptGeV ) scale = 1.e3;
374 
375  bool passKinRange = true;
376 
379  if ( std::abs(jet.eta()) > m_jetEtaMax ) {
380  ATH_MSG_VERBOSE( "Jet does not pass basic kinematic selection (|eta| < " << m_jetEtaMax << "). Jet eta = " << jet.eta() );
381  acceptData.setCutResult( "ValidEtaRange", false );
382  passKinRange = false;
383  }
384 
385  if ( jet.pt() < m_jetPtMin * scale ) {
386  ATH_MSG_VERBOSE( "Jet does not pass basic kinematic selection (pT > " << m_jetPtMin * scale / 1.e3 << "). Jet pT = " << jet.pt() / 1.e3 << " GeV" );
387  acceptData.setCutResult( "ValidPtRangeLow", false );
388  passKinRange = false;
389  }
390 
391  if ( jet.pt() > m_jetPtMax * scale ) {
392  ATH_MSG_VERBOSE( "Jet does not pass basic kinematic selection (pT < " << m_jetPtMax * scale / 1.e3 << "). Jet pT = " << jet.pt() / 1.e3 << " GeV" );
393  acceptData.setCutResult( "ValidPtRangeHigh", false );
394  passKinRange = false;
395  }
396 
398  SG::WriteDecorHandle<xAOD::JetContainer, bool> decValidPtRangeHigh(m_decValidPtRangeHighKey);
399  SG::WriteDecorHandle<xAOD::JetContainer, bool> decValidPtRangeLow(m_decValidPtRangeLowKey);
400  SG::WriteDecorHandle<xAOD::JetContainer, bool> decValidEtaRange(m_decValidEtaRangeKey);
401  SG::WriteDecorHandle<xAOD::JetContainer, bool> decValidKinRange(m_decValidKinRangeKey);
402 
404  decValidPtRangeHigh(jet) = acceptData.getCutResult( "ValidPtRangeHigh" );
405  decValidPtRangeLow(jet) = acceptData.getCutResult( "ValidPtRangeLow" );
406  decValidEtaRange(jet) = acceptData.getCutResult( "ValidEtaRange" );
407  decValidKinRange(jet) = passKinRange;
408 
409  return StatusCode::SUCCESS;
410 
411 }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation 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.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation 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.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

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

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation 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.

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

◆ declareProperty() [5/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation 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.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

◆ decorate()

StatusCode JSSTaggerBase::decorate ( const xAOD::JetContainer &  jets) const
overridevirtualinherited

Decorate jet collection with tagging info.

Loop over jet collection and decorate each jet.

Implements IJetDecorator.

Reimplemented in JSSWTopTaggerANN.

Definition at line 289 of file JSSTaggerBase.cxx.

289  {
290 
291  for ( const auto *jet : jets ) {
292  ATH_CHECK( tag(*jet) );
293  }
294 
295  return StatusCode::SUCCESS;
296 
297 }

◆ detStore()

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

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

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

Add StoreName to extra input/output deps as needed.

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

◆ findPV()

int JSSTaggerBase::findPV ( ) const
protectedinherited

Find the PV (to be used for Ntrk)

Definition at line 529 of file JSSTaggerBase.cxx.

529  {
530 
531  int indexPV = -1;
532 
533  const xAOD::VertexContainer* vxCont = nullptr;
534  if ( evtStore()->retrieve( vxCont, "PrimaryVertices" ).isFailure() ) {
535  ATH_MSG_WARNING( "Unable to retrieve primary vertex container PrimaryVertices" );
536  }
537  else {
538  int vtx_counter = 0;
539  for ( const auto *vx : *vxCont ) {
540  if ( vx->vertexType()==xAOD::VxType::PriVtx ) {
541  indexPV = vtx_counter;
542  break;
543  }
544  vtx_counter++;
545  }
546  }
547 
548  return indexPV;
549 
550 }

◆ getConfigReader()

StatusCode JSSTaggerBase::getConfigReader ( )
protectedinherited

Get configReader StatusCode.

Get configReader TEnv.

Check for the existence of the configuration file

https://root.cern.ch/root/roottalk/roottalk02/5332.html

Definition at line 300 of file JSSTaggerBase.cxx.

300  {
301 
302  ATH_MSG_INFO( "Using config file : " << m_configFile );
303 
305  std::string configPath;
306 
307  if ( m_calibArea.compare("Local") == 0 ) {
308  configPath = PathResolverFindCalibFile(("$WorkDir_DIR/data/BoostedJetTaggers/"+m_configFile).c_str());
309  }
310  else if ( m_calibArea.find("eos") != std::string::npos) {
311  configPath = PathResolverFindCalibFile((m_calibArea+"/"+m_configFile).c_str());
312  }
313  else {
314  configPath = PathResolverFindCalibFile(("BoostedJetTaggers/"+m_calibArea+"/"+m_configFile).c_str());
315  }
316 
318  FileStat_t fStats;
319  int fSuccess = gSystem->GetPathInfo(configPath.c_str(), fStats);
320  if ( fSuccess ) {
321  ATH_MSG_ERROR( "Recommendations file " << m_configFile << " could not be found" );
322  return StatusCode::FAILURE;
323  }
324  else {
325  ATH_MSG_DEBUG( "Recommendations file was found : " << configPath );
326  }
327 
328  if ( m_configReader.ReadFile( configPath.c_str(), EEnvLevel(0) ) ) {
329  ATH_MSG_ERROR( "Error while reading config file : "<< configPath );
330  return StatusCode::FAILURE;
331  }
332 
333  return StatusCode::SUCCESS;
334 
335 }

◆ getKey()

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

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

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

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

See also
asg::AsgTool::getName
Parameters
ptrThe bare pointer to the object that the event store should know about
Returns
The hashed key of the object in the store. If not found, an invalid (zero) key.

Definition at line 119 of file AsgTool.cxx.

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

◆ 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
ptrThe bare pointer to the object that the event store should know about
Returns
The string name of the object in the store. If not found, an empty string.

Definition at line 106 of file AsgTool.cxx.

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

◆ getNTrack()

StatusCode CP::JetQGTagger::getNTrack ( const xAOD::Jet *  jet,
int &  ntracks 
) const
private

Definition at line 462 of file JetQGTagger.cxx.

462  {
463 
464  ATH_MSG_DEBUG( "Counting the number of tracks in the jet" );
465 
466  ntracks = 0;
467  // loop over the tracks associated to the jet of interest
468  std::vector<const xAOD::IParticle*> jettracks;
469 
470  if(!jet->getAssociatedObjects<xAOD::IParticle>(xAOD::JetAttribute::GhostTrack,jettracks)){
471  ATH_MSG_ERROR("This jet has no associated objects, so it will not be tagged. Please check the jet collection you are using.");
472  ntracks=999;
473  //Returning failure as this jet has no associated objects and we do not want to wrongly classify it as a gluon or quark using tag().
474  //Physics should be independent of skimming, which may have removed tracks.
475  //So we are returning a failure, and throwing an exception.
476  return StatusCode::FAILURE;
477  }
478 
479  for (size_t i = 0; i < jettracks.size(); i++) {
480 
481  const xAOD::TrackParticle* trk = static_cast<const xAOD::TrackParticle*>(jettracks[i]);
482 
483  if(!trk){
484  ATH_MSG_ERROR("This jet has null tracks, so it will not be tagged. Please check the jet collection you are using.");
485  ntracks=998;
486  //Returning failure as this jet has null tracks and we do not want to wrongly classify it as a gluon or quark using tag().
487  //Physics should be independent of skimming, which may have introduced null tracks.
488  //So we are returning a failure, and throwing an exception.
489  return StatusCode::FAILURE;
490  }
491 
492  // if you are applying a systematic variation then
493  // FRANCESCO ADD COMMENT
494 
495  bool acceptSyst = true;
496 
497  if ( m_appliedSystEnum==QG_TRACKEFFICIENCY )
498  acceptSyst = ( m_trkTruthFilterTool->accept(trk) && m_jetTrackFilterTool->accept(trk,jet) );
499  else if ( m_appliedSystEnum==QG_TRACKFAKES )
500  acceptSyst = m_trkFakeTool->accept(trk);
501 
502  if (!acceptSyst)
503  continue;
504 
505  // only count tracks with selections
506  // 1) pt>500 MeV
507  // 2) accepted track from InDetTrackSelectionTool with CutLevel==Loose
508  // 3) associated to primary vertex OR within 3mm of the primary vertex
509  bool accept = (trk->pt()>500 &&
510  m_trkSelectionTool->accept(*trk)
511  // TODO: Implement alternative to TrackParticle::vertex()
512  //&& (trk->vertex()==pv || (!trk->vertex() && std::abs((trk->z0()+trk->vz()-pv->z())*sin(trk->theta()))<3.))
513  );
514  if (!accept)
515  continue;
516 
517  ntracks++;
518  }
519 
520  return StatusCode::SUCCESS;
521  }

◆ getNTrackWeight()

StatusCode CP::JetQGTagger::getNTrackWeight ( const xAOD::Jet *  jet,
double &  weight 
) const
private

Definition at line 525 of file JetQGTagger.cxx.

525  {
526 
527  ATH_MSG_DEBUG( "Getting the jet weight for systematic variation " << m_appliedSystEnum );
528 
529  // initially set the weight to unity
530  // this is the weight returned if you are *not* dealing with a systematic variation
531  weight = 1.0;
532 
533  // if you are not dealing with a systematic variation, then exit
534  if ( m_appliedSystEnum!=QG_NCHARGEDTOPO &&
535  m_appliedSystEnum!=QG_NCHARGEDEXP_UP &&
536  m_appliedSystEnum!=QG_NCHARGEDME_UP &&
537  m_appliedSystEnum!=QG_NCHARGEDPDF_UP &&
538  m_appliedSystEnum!=QG_NCHARGEDEXP_DOWN &&
539  m_appliedSystEnum!=QG_NCHARGEDME_DOWN &&
540  m_appliedSystEnum!=QG_NCHARGEDPDF_DOWN
541  )
542  return StatusCode::SUCCESS;
543 
544  int pdgid = jet->getAttribute<int>("PartonTruthLabelID");
545  if ( pdgid<0 ) {
546  ATH_MSG_DEBUG("Undefined pdg ID: setting weight to 1");
547  return StatusCode::SUCCESS;
548  }
549 
550  // getting the associated truth jet
551  // FRANCESCO COMMENT
552  const xAOD::Jet* tjet;
553  static const SG::ConstAccessor< ElementLink<xAOD::JetContainer> >
554  GhostTruthAssociationLinkAcc("GhostTruthAssociationLink");
555  if(GhostTruthAssociationLinkAcc.isAvailable(*jet)) {
556  ATH_MSG_DEBUG("Accessing GhostTruthAssociationLink: is available");
557  ElementLink<xAOD::JetContainer> truthlink = GhostTruthAssociationLinkAcc(*jet);
558  if(truthlink.isValid() ){
559  ATH_MSG_DEBUG("Accessing GhostTruthAssociationLink: is valid");
560  if(truthlink)
561  tjet = * truthlink;
562  else{
563  ATH_MSG_WARNING("Cannot access truth: setting weight to 1");
564  return StatusCode::SUCCESS;
565  }//endelse NULL pointer
566  }
567  else {
568  ATH_MSG_WARNING("Cannot access truth: setting weight to 1");
569  return StatusCode::SUCCESS;
570  } //endelse isValid
571  } //endif isAvailable
572  else {
573  ATH_MSG_WARNING("Cannot access truth: setting weight to 1");
574  return StatusCode::SUCCESS;
575  }//endelse isAvailable
576 
577  // if the jet is outside of the measurement fiducial region
578  // the systematic uncertainty is set to 0
579  double tjetpt = tjet->pt()*0.001;
580  double tjeteta = tjet->eta();
581  if( tjetpt<m_jetPtMin*1.0e-3 || std::abs(tjeteta)>m_jetEtaMax){
582  ATH_MSG_DEBUG("Outside of fiducial region: setting weight to 1");
583  return StatusCode::SUCCESS;
584  }
585 
586  // compute truth ntrk
587  int tntrk = 0;
588  for (size_t ind = 0; ind < tjet->numConstituents(); ind++) {
589  const xAOD::TruthParticle *part = static_cast<const xAOD::TruthParticle*>(tjet->rawConstituent(ind));
590 
591  // dont count invalid truth particles
592  if (!part) continue;
593  // require the particle in the final state
594  if( ! MC::isStable(part) ) continue;
595  // require that the particle type (e.g. production type) be valid (e.g. not primaries)
596  if (HepMC::is_simulation_particle(part)) continue;
597  // pt>500 MeV
598  if( ! (part->pt()>500.) ) continue;
599  // charged
600  if( !(part->isCharged()) ) continue;
601  // this seems redundant
602  // FRANCESCO COMMENT
603  double pt = part->pt();
604  if( pt>500 ) tntrk++;
605 
606  }
607 
608  // use the lookup tables loaded in initialize() to find the systematically shifted weights
609  if ( pdgid==21 && m_appliedSystEnum!=QG_NCHARGEDTOPO){
610  int ptbin = std::as_const(*m_hgluon).GetXaxis()->FindFixBin(tjetpt);
611  int ntrkbin = std::as_const(*m_hgluon).GetYaxis()->FindFixBin(tntrk);
612  weight = m_hgluon->GetBinContent(ptbin,ntrkbin);
613  }// gluon
614  else if ( pdgid<5 ){
615  int ptbin = std::as_const(*m_hquark).GetXaxis()->FindFixBin(tjetpt);
616  int ntrkbin = std::as_const(*m_hquark).GetYaxis()->FindFixBin(tntrk);
617  weight = m_hquark->GetBinContent(ptbin,ntrkbin);
618  }//quarks
619  else{
620  ATH_MSG_DEBUG("Neither quark nor gluon jet: setting weight to 1");
621  }
622 
623  return StatusCode::SUCCESS;
624  }

◆ getProperty()

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

Get one of the tool's properties.

◆ getSF()

std::pair< double, double > JSSTaggerBase::getSF ( const xAOD::Jet &  jet,
const std::string &  truthLabelStr 
) const
protectedinherited

Get scale factor and efficiency.

To apply W-tagging efficiency SF to Z-tagger, jet mass is shifted by 10.803 GeV

Definition at line 670 of file JSSTaggerBase.cxx.

670  {
671 
672  if ( !passKinRange(jet) ) return std::make_pair( 1.0, 1.0 );
673 
674 
675  double logmOverPt = std::log(jet.m()/jet.pt());
676  if ( m_decorationName.find("SmoothZ") != std::string::npos ||
677  m_decorationName.find("SmoothInclusiveZ") != std::string::npos ) {
679  const double WtoZmassShift = 10803;
680  logmOverPt = std::log((jet.m()-WtoZmassShift)/jet.pt());
681  }
682 
683  if ( logmOverPt > 0 ) logmOverPt = 0;
684 
685  double SF = 1.0;
686  double eff = 1.0;
687 
688  if ( m_weightHistograms.count(truthLabelStr.c_str()) ) {
689 
690  int pt_mPt_bin = (m_weightHistograms.find(truthLabelStr.c_str())->second)->FindBin(jet.pt()*0.001, logmOverPt);
691  SF = (m_weightHistograms.find(truthLabelStr.c_str())->second)->GetBinContent(pt_mPt_bin);
692 
693  if ( !m_efficiencyHistogramName.empty() ) {
694  eff = (m_efficiencyHistograms.find(truthLabelStr.c_str())->second)->GetBinContent(pt_mPt_bin);
695  }
696 
697  }
698  else {
699  // set the efficiency for "Other" category to be the signal efficiency
700  std::string signal_truthLabel="";
701  if ( m_weightHistograms.count("t_qqb") ) {
702  signal_truthLabel="t_qqb";
703  }else if ( m_weightHistograms.count("V_qq") ){
704  signal_truthLabel="V_qq";
705  }else if ( m_weightHistograms.count("t") ){
706  signal_truthLabel="t";
707  }
708  if ( !signal_truthLabel.empty() && !m_efficiencyHistogramName.empty() ){
709  int pt_mPt_bin = (m_weightHistograms.find(signal_truthLabel.c_str())->second)->FindBin(jet.pt()*0.001, logmOverPt);
710  eff = (m_efficiencyHistograms.find(signal_truthLabel.c_str())->second)->GetBinContent(pt_mPt_bin);
711  }
712 
713  return std::make_pair( 1.0, eff );
714  }
715 
716  if ( SF < 1e-3 ) {
717  ATH_MSG_DEBUG( "(pt, m/pt) (" << jet.pt()/1.e3 << ", " << jet.m()/jet.pt() << ") is out of range for SF calculation. Returning 1.0" );
718  return std::make_pair( 1.0, 1.0 );
719  }
720  else {
721  return std::make_pair( SF, eff );
722  }
723 
724 }

◆ getTruthLabelStr()

std::string JSSTaggerBase::getTruthLabelStr ( const xAOD::Jet &  jet,
asg::AcceptData &  acceptData 
) const
protectedinherited

Truth label string

Truth label value

Contained top tagger

Contained top

QCD

TCC W/Z 2-var tagger

Top

W/Z

QCD

Pass mass and D2

Fail mass, pass D2

Pass mass, fail D2

Fail mass and D2

W/Z tagger

Top

W/Z

QCD

Top

QCD

Definition at line 728 of file JSSTaggerBase.cxx.

728  {
730  std::string truthLabelStr;
731 
733  SG::ReadDecorHandle<xAOD::JetContainer, int> readTruthLabel(m_readTruthLabelKey);
734  LargeRJetTruthLabel::TypeEnum jetContainment = LargeRJetTruthLabel::intToEnum(readTruthLabel(jet));
735 
737  if ( m_weightHistograms.count("t_qqb") ) {
738 
740  if ( jetContainment==LargeRJetTruthLabel::tqqb ) {
741  truthLabelStr = "t_qqb";
742  }
744  else if ( jetContainment==LargeRJetTruthLabel::notruth || jetContainment==LargeRJetTruthLabel::qcd ) {
745  truthLabelStr = "q";
746  }
747 
748  }
750  else if ( m_weightHistograms.count("V_qq_passMpassD2") ) {
751 
753  if ( jetContainment==LargeRJetTruthLabel::tqqb || jetContainment==LargeRJetTruthLabel::other_From_t ) {
754  truthLabelStr = "t_";
755  }
757  else if ( jetContainment==LargeRJetTruthLabel::Wqq || jetContainment==LargeRJetTruthLabel::Zqq || jetContainment==LargeRJetTruthLabel::Wqq_From_t ) {
758  truthLabelStr = "V_qq_";
759  }
761  else if ( jetContainment==LargeRJetTruthLabel::notruth || jetContainment==LargeRJetTruthLabel::qcd ) {
762  truthLabelStr = "q_";
763  }
764 
766  if ( acceptData.getCutResult("PassMassLow") && acceptData.getCutResult("PassMassHigh") && acceptData.getCutResult("PassD2") ) {
767  truthLabelStr += "passMpassD2";
768  }
770  else if ( !(acceptData.getCutResult("PassMassLow") && acceptData.getCutResult("PassMassHigh")) && acceptData.getCutResult("PassD2") ) {
771  truthLabelStr += "failMpassD2";
772  }
774  else if ( acceptData.getCutResult("PassMassLow") && acceptData.getCutResult("PassMassHigh") && !acceptData.getCutResult("PassD2") ) {
775  truthLabelStr += "passMfailD2";
776  }
778  else{
779  truthLabelStr += "failMfailD2";
780  }
781 
782  }
783 
785  else if ( m_weightHistograms.count("V_qq") ) {
786 
788  if ( jetContainment==LargeRJetTruthLabel::tqqb || jetContainment==LargeRJetTruthLabel::other_From_t ) {
789  truthLabelStr = "t";
790  }
792  else if ( jetContainment==LargeRJetTruthLabel::Wqq || jetContainment==LargeRJetTruthLabel::Zqq || jetContainment==LargeRJetTruthLabel::Wqq_From_t ) {
793  truthLabelStr = "V_qq";
794  }
796  else if ( jetContainment==LargeRJetTruthLabel::notruth || jetContainment==LargeRJetTruthLabel::qcd ) {
797  truthLabelStr = "q";
798  }
799  }
800 
801  // inclusive top tagger
802  else {
804  if ( jetContainment==LargeRJetTruthLabel::tqqb || jetContainment==LargeRJetTruthLabel::other_From_t || jetContainment==LargeRJetTruthLabel::Wqq_From_t ) {
805  truthLabelStr = "t";
806  }
808  else if ( jetContainment==LargeRJetTruthLabel::notruth || jetContainment==LargeRJetTruthLabel::qcd ) {
809  truthLabelStr = "q";
810  }
811 
812  }
813 
814  return truthLabelStr;
815 }

◆ GetUnGroomTracks()

StatusCode JSSTaggerBase::GetUnGroomTracks ( const xAOD::Jet &  jet,
int  indexPV 
) const
protectedinherited

Retrieve Ntrk variable from the ungroomed parent jet.

Retrieve the Ntrk variable from the ungroomed parent jet.

Definition at line 553 of file JSSTaggerBase.cxx.

553  {
554 
555  SG::WriteDecorHandle<xAOD::JetContainer, int> decNtrk500(m_decNtrk500Key);
556 
557  SG::ReadDecorHandle<xAOD::JetContainer, ElementLink<xAOD::JetContainer> > readParent(m_readParentKey);
558 
559  const xAOD::Jet * ungroomedJet = nullptr;
560  if ( readParent.isAvailable() ) {
561  const ElementLink<xAOD::JetContainer>& linkToUngroomed = readParent(jet);
562  if ( linkToUngroomed.isValid() ) {
563  ungroomedJet = *linkToUngroomed;
564 
565  static const SG::AuxElement::ConstAccessor< std::vector<int> >acc_Ntrk("NumTrkPt500");
566 
567  if ( acc_Ntrk.isAvailable(*ungroomedJet) ) {
568 
569  const std::vector<int>& NTrkPt500 = acc_Ntrk(*ungroomedJet);
570 
571  int jet_ntrk = NTrkPt500.at(indexPV);
572  decNtrk500(jet) = jet_ntrk;
573 
574  }
575  else {
576  ATH_MSG_ERROR("WARNING: Unable to retrieve Ntrk of the ungroomed parent jet. Please make sure this variable is in your derivations!!!");
577  return StatusCode::FAILURE;
578  }
579  }
580  else {
581  ATH_MSG_ERROR("WARNING: Unable to retrieve the parent ungroomed jet. Please make sure this variable is in your derivations!!!");
582  return StatusCode::FAILURE;
583  }
584  }
585  else {
586  ATH_MSG_ERROR("WARNING: Unable to retrieve the link to the parent ungroomed jet. Please make sure this variable is in your derivations!!!");
587  return StatusCode::FAILURE;
588  }
589 
590  return StatusCode::SUCCESS;
591 
592 }

◆ getWeight()

StatusCode JSSTaggerBase::getWeight ( const xAOD::Jet &  jet,
bool  passSel,
asg::AcceptData &  acceptData 
) const
protectedinherited

Get SF weight.

Inefficiency SF is directly used

Efficiency SF

Calculate inefficiency SF

If inefficiency SF is not available, SF is always 1.0

Create write decor handles

Decorate values

Definition at line 596 of file JSSTaggerBase.cxx.

596  {
597  if ( !m_calcSF ) return StatusCode::SUCCESS;
598 
599  float weight = 1.0;
600  float effSF = 1.0;
601  float sigeffSF = 1.0;
602  float efficiency = 1.0;
603 
604  if ( m_isMC ) {
605 
606  std::string truthLabelStr = getTruthLabelStr( jet, acceptData );
607  std::tie(effSF, efficiency) = getSF( jet, truthLabelStr );
608 
609  // calculate signal efficiency SF
610  if ( m_weightHistograms.count("t_qqb") ) {
611  sigeffSF = getSF(jet, "t_qqb").first;
612  } else if ( m_weightHistograms.count("V_qq") ) {
613  sigeffSF = getSF(jet, "V_qq").first;
614  } else if ( m_weightHistograms.count("t") ){
615  sigeffSF = getSF(jet, "t").first;
616  } else {
617  sigeffSF = 1.0;
618  }
619 
621  if ( m_weightFlavors.find("fail") != std::string::npos ) {
622  weight = effSF;
623  }
624 
625  else {
626 
628  if ( passSel ) {
629  weight = effSF;
630  }
631 
633  else {
635  if ( m_efficiencyHistogramName.empty() ) {
636  weight = 1.0;
637  }
638  else if ( efficiency < 1.0 ) {
639  weight = ( 1. - effSF * efficiency ) / ( 1. - efficiency );
640  }
641  else {
642  weight = 1.0;
643  }
644  }
645  }
646 
647  }
648 
649  else {
650  weight = 1.0;
651  }
652 
654  SG::WriteDecorHandle<xAOD::JetContainer, float> decWeight(m_decWeightKey);
655  SG::WriteDecorHandle<xAOD::JetContainer, float> decEfficiency(m_decEfficiencyKey);
656  SG::WriteDecorHandle<xAOD::JetContainer, float> decEffSF(m_decEffSFKey);
657  SG::WriteDecorHandle<xAOD::JetContainer, float> decSigeffSF(m_decSigeffSFKey);
658 
660  decWeight(jet) = weight;
661  decEfficiency(jet) = efficiency;
662  decEffSF(jet) = effSF;
663  decSigeffSF(jet) = sigeffSF;
664 
665  return StatusCode::SUCCESS;
666 
667 }

◆ initialize()

StatusCode CP::JetQGTagger::initialize ( )
overridevirtual

Initialize the tool.

Get configReader

ReadDecorHandles for Ntrk variables

Initialize the tagger states

Call base class initialize

Loop over and print out the cuts that have been configured

Make sure jet container is set

Initialize warning counters

Define common tagger states

Initialize decorators

Initialize SFs if they are needed

Get weight config file

Install histograms for tagging SFs

Initialize the TF1 functions

Reimplemented from JSSTaggerBase.

Definition at line 73 of file JetQGTagger.cxx.

73  {
74 
75  ATH_MSG_INFO( "Initializing QuarkGluonTagger tool" );
76 
77  if( ! m_configFile.empty() ) {
78 
80  ATH_CHECK( getConfigReader() );
81 
82  // read in the specified track cut in the config file
83  m_NTrackCut=m_configReader.GetValue("NTrackCut" ,-1);
84 
85  ATH_MSG_VERBOSE( "NTrackCut by config file : "<<m_NTrackCut );
86 
87  }
88  else {
89  // no config file
90  // Assume the cut functions have been set through properties.
91  // check they are non empty
92  if( m_NTrackCut!=-1){
93  ATH_MSG_VERBOSE( "NTrackCut by manual setting of property : "<<m_NTrackCut );
94  }
95  else {
96  ATH_MSG_WARNING( "No config file provided AND no NTrackCut specified." ) ;
97  }
98  }
99  if(m_cuttype != "linear_pt" && m_cuttype != "threshold" && m_cuttype != "log_pt"){
100  ATH_MSG_ERROR("Cuttype set to: " << m_cuttype );
101  ATH_MSG_ERROR("Cuttype invalid. Must use 'linear_pt', 'log_pt', or 'threshold'");
102  return StatusCode::FAILURE;
103  }
104 
105  // decorators used to store
106  // 1) ntracks
107  // 2) tagger weight
108  ATH_MSG_INFO( "Decorators that will be attached to jet :" );
109  ATH_MSG_INFO( " " << m_tagger_decoration_name << " : Number of tracks for tagging decision" );
110  ATH_MSG_INFO( " " << m_weight_decoration_name << " : Scale factor weight given the number of tracks" );
111 
112  m_decTagKey = m_containerName + "." + m_tagger_decoration_name;
113  m_qgDecWeightKey = m_containerName + "." + m_weight_decoration_name;
114 
115  ATH_CHECK( m_decTagKey.initialize() );
116  ATH_CHECK( m_qgDecWeightKey.initialize() );
117 
119  m_readNumTrkPt500PVKey = m_containerName + "." + m_readNumTrkPt500PVKey.key();
120  m_readNtrkKey = m_containerName + "." + m_readNtrkKey.key();
121 
122  ATH_CHECK( m_readNumTrkPt500PVKey.initialize() );
123  ATH_CHECK( m_readNtrkKey.initialize() );
124 
125  // set up InDet selection tool
126  ANA_CHECK( ASG_MAKE_ANA_TOOL( m_trkSelectionTool, InDet::InDetTrackSelectionTool ) );
127  ANA_CHECK( m_trkSelectionTool.setProperty( "CutLevel", "Loose" ) );
128  ANA_CHECK( m_trkSelectionTool.retrieve() );
129 
130  // set up InDet truth track selection tools
131  ANA_CHECK( ASG_MAKE_ANA_TOOL( m_trkTruthFilterTool, InDet::InDetTrackTruthFilterTool ) );
132  ANA_CHECK( ASG_MAKE_ANA_TOOL( m_trkFakeTool, InDet::InDetTrackTruthFilterTool ) );
133 
134  ANA_CHECK( ASG_MAKE_ANA_TOOL( m_originTool, InDet::InDetTrackTruthOriginTool ) );
135  ANA_CHECK( m_originTool.retrieve() );
136 
137  ANA_CHECK( m_trkTruthFilterTool.setProperty( "Seed", 1234 ) );
138  ANA_CHECK( m_trkTruthFilterTool.setProperty( "trackOriginTool", m_originTool ) );
139  ANA_CHECK( m_trkTruthFilterTool.retrieve() );
140  CP::SystematicSet systSetTrk = {
141  InDet::TrackSystematicMap.at(InDet::TRK_EFF_LOOSE_GLOBAL),
142  InDet::TrackSystematicMap.at(InDet::TRK_EFF_LOOSE_IBL),
143  InDet::TrackSystematicMap.at(InDet::TRK_EFF_LOOSE_PP0),
144  InDet::TrackSystematicMap.at(InDet::TRK_EFF_LOOSE_PHYSMODEL)
145  };
146  ANA_CHECK( m_trkTruthFilterTool->applySystematicVariation(systSetTrk) );
147 
148  // set up tools used for systematic variations of tracks
149  ANA_CHECK( m_trkFakeTool.setProperty( "Seed", 1234 ) );
150  ANA_CHECK( m_trkFakeTool.setProperty( "trackOriginTool", m_originTool ) );
151  ANA_CHECK( m_trkFakeTool.retrieve() );
152  CP::SystematicSet systSetTrkFake = {
153  InDet::TrackSystematicMap.at(InDet::TRK_FAKE_RATE_LOOSE)
154  };
155  ANA_CHECK( m_trkFakeTool->applySystematicVariation(systSetTrkFake) );
156 
157  ANA_CHECK( ASG_MAKE_ANA_TOOL( m_jetTrackFilterTool, InDet::JetTrackFilterTool ) );
158  ANA_CHECK( m_jetTrackFilterTool.setProperty( "Seed", 1234 ) );
159  ANA_CHECK( m_jetTrackFilterTool.setProperty( "trackOriginTool", m_originTool ) );
160  ANA_CHECK( m_jetTrackFilterTool.retrieve() );
161  CP::SystematicSet systSetJet = {
162  InDet::TrackSystematicMap.at(InDet::TRK_EFF_LOOSE_TIDE)
163  };
164  ANA_CHECK( m_jetTrackFilterTool->applySystematicVariation(systSetJet) );
165 
166  // specify systematic variations relevant for this tool
167  if (!addAffectingSystematic(QGntrackSyst::trackfakes,true) ||
168  !addAffectingSystematic(QGntrackSyst::trackefficiency,true) ||
169  !addAffectingSystematic(QGntrackSyst::nchargedtopo,false /*for topology differences */) ||
170  !addAffectingSystematic(QGntrackSyst::nchargedexp_up,true) ||
171  !addAffectingSystematic(QGntrackSyst::nchargedme_up,true) ||
172  !addAffectingSystematic(QGntrackSyst::nchargedpdf_up,true) ||
173  !addAffectingSystematic(QGntrackSyst::nchargedexp_down,true) ||
174  !addAffectingSystematic(QGntrackSyst::nchargedme_down,true) ||
175  !addAffectingSystematic(QGntrackSyst::nchargedpdf_down,true) ||
176  !addAffectingSystematic(QGntrackSyst::trackeff,true)||
177  !addAffectingSystematic(QGntrackSyst::fake,true)
178  )
179  {
180  ATH_MSG_ERROR("failed to set up JetQGTagger systematics");
181  return StatusCode::FAILURE;
182  }
183 
184  // load in the histograms that store the ntrack systematics
185  if(!m_topofile.empty())//load topology file only if explicitly configured (default is "")
186  ANA_CHECK( this->loadHist(m_topo_hquark, m_topofile,"h2dquark") );
187  ANA_CHECK( this->loadHist(m_exp_hquark_up, m_expfile,"h2dquark_up") );
188  ANA_CHECK( this->loadHist(m_exp_hquark_down,m_expfile,"h2dquark_down"));
189  ANA_CHECK( this->loadHist(m_exp_hgluon_up, m_expfile,"h2dgluon_up") );
190  ANA_CHECK( this->loadHist(m_exp_hgluon_down,m_expfile,"h2dgluon_down"));
191  ANA_CHECK( this->loadHist(m_me_hquark_up, m_mefile, "h2dquark_up") );
192  ANA_CHECK( this->loadHist(m_me_hquark_down, m_mefile, "h2dquark_down"));
193  ANA_CHECK( this->loadHist(m_me_hgluon_up, m_mefile, "h2dgluon_up") );
194  ANA_CHECK( this->loadHist(m_me_hgluon_down, m_mefile, "h2dgluon_down"));
195  ANA_CHECK( this->loadHist(m_pdf_hquark_up, m_pdffile,"h2dquark_up") );
196  ANA_CHECK( this->loadHist(m_pdf_hquark_down,m_pdffile,"h2dquark_down"));
197  ANA_CHECK( this->loadHist(m_pdf_hgluon_up, m_pdffile,"h2dgluon_up") );
198  ANA_CHECK( this->loadHist(m_pdf_hgluon_down,m_pdffile,"h2dgluon_down"));
199  ATH_MSG_INFO("about to load track syst histos");
200  ATH_MSG_INFO("trackeff file: " << m_trackefffile);
201  ANA_CHECK( this->loadHist(m_trackeff_hquark,m_trackefffile,"track_syste_quark"));//REPLACE w/ right histo
202  ANA_CHECK( this->loadHist(m_trackeff_hgluon,m_trackefffile,"track_syste_gluon"));//REPLACE w/ right histo
203  ANA_CHECK( this->loadHist(m_fake_hquark,m_fakefile,"track_systf_quark"));//REPLACE w/ right histo
204  ANA_CHECK( this->loadHist(m_fake_hgluon,m_fakefile,"track_systf_gluon"));//REPLACE w/ right histo
205 
206  ATH_MSG_INFO( ": JetQGTagger tool initialized" );
207  ATH_MSG_INFO( " NTrackCut : "<< m_NTrackCut );
208 
210  m_acceptInfo.addCut( "QuarkJetTag", "True if the jet is deemed a quark jet because NTrack<NCut, False if jet deemed gluon jet because NTrack<NCut" );
211 
213  ATH_CHECK( JSSTaggerBase::initialize() );
214 
216  printCuts();
217 
218  return StatusCode::SUCCESS;
219 
220  }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ isAffectedBySystematic()

virtual bool CP::JetQGTagger::isAffectedBySystematic ( const SystematicVariation &  systematic) const
inlineoverridevirtual

returns: whether this tool is affected by the given systematic guarantee: no-fail

Reimplemented from CP::SystematicsTool.

Definition at line 51 of file JetQGTagger.h.

51 {return SystematicsTool::isAffectedBySystematic(var);}

◆ loadHist()

StatusCode CP::JetQGTagger::loadHist ( TH2D *&  hist,
const std::string &  filename,
const std::string &  histname 
)
private

Definition at line 703 of file JetQGTagger.cxx.

703  {
704 
705  std::string filename = PathResolverFindCalibFile( ("BoostedJetTaggers/"+m_calibArea+fname).c_str() );
706  ATH_MSG_INFO("CALIB FILE: " << filename << " histo: " << histname);
707  if (filename.empty()){
708  ATH_MSG_ERROR( "Could NOT resolve file name " << fname );
709  return StatusCode::FAILURE;
710  }
711  else{
712  ATH_MSG_DEBUG( "Path found = " << filename );
713  }
714  TFile* infile = TFile::Open(filename.c_str());
715  hist = dynamic_cast<TH2D*>(infile->Get(histname.c_str()));
716  hist->SetDirectory(nullptr);
717  return StatusCode::SUCCESS;
718  }

◆ modify()

virtual StatusCode IJetDecorator::modify ( xAOD::JetContainer &  jets) const
inlinefinaloverridevirtualinherited

Concrete implementation of the function inherited from IJetModifier.

Implements IJetModifier.

Definition at line 32 of file IJetDecorator.h.

32 {return decorate(jets);};

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msg_level_name()

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

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

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

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

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

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

Definition at line 101 of file AsgTool.cxx.

101  {
102 
103  return MSG::name( msg().level() );
104  }

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ passKinRange()

bool JSSTaggerBase::passKinRange ( const xAOD::Jet &  jet) const
protectedinherited

Check if jet passes kinematic constraints.

Definition at line 356 of file JSSTaggerBase.cxx.

356  {
357 
358  float scale = 1.0;
359  if ( m_ptGeV ) scale = 1.e3;
360 
361  if ( jet.pt() < m_jetPtMin * scale ) return false;
362  if ( jet.pt() > m_jetPtMax * scale ) return false;
363  if ( std::abs( jet.eta() ) > m_jetEtaMax ) return false;
364 
365  return true;
366 
367 }

◆ 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, top::TopObjectSelection, JetDumper, JetBottomUpSoftDrop, JetRecursiveSoftDrop, JetSoftDrop, JetConstituentsRetriever, JetSubStructureMomentToolsBase, JetSplitter, JetToolRunner, JetPruner, JetPseudojetRetriever, JetTrimmer, AsgHelloTool, and KtDeltaRTool.

Definition at line 131 of file AsgTool.cxx.

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

◆ 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, top::TopObjectSelection, asg::AsgTool, JetDumper, JetBottomUpSoftDrop, JetRecursiveSoftDrop, JetSoftDrop, JetConstituentsRetriever, JetSubStructureMomentToolsBase, JetSplitter, JetToolRunner, JetPruner, JetPseudojetRetriever, JetTrimmer, AsgHelloTool, and KtDeltaRTool.

◆ printCuts()

void JSSTaggerBase::printCuts ( ) const
protectedinherited

Print configured cuts.

Definition at line 817 of file JSSTaggerBase.cxx.

817  {
818  ATH_MSG_INFO( "After tagging, you will have access to the following cuts as an asg::AcceptData : (<NCut>) <cut> : <description>)" );
819  int nCuts = m_acceptInfo.getNCuts();
820  for ( int iCut=0; iCut < nCuts; iCut++ ) {
821  std::string cut_string = "";
822  cut_string += " (";
823  cut_string += std::to_string(iCut);
824  cut_string += ") ";
825  cut_string += m_acceptInfo.getCutName(iCut).data();
826  cut_string += " : ";
827  cut_string += m_acceptInfo.getCutDescription(iCut).data();
828  ATH_MSG_INFO( cut_string );
829  }
830 }

◆ recommendedSystematics()

virtual SystematicSet CP::JetQGTagger::recommendedSystematics ( ) const
inlineoverridevirtual

returns: the list of all systematics this tool can be affected by guarantee: strong failures: out of memory II

Reimplemented from CP::SystematicsTool.

Definition at line 53 of file JetQGTagger.h.

53 {return SystematicsTool::recommendedSystematics();}

◆ renounce()

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

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ resetCuts()

StatusCode JSSTaggerBase::resetCuts ( asg::AcceptData &  acceptData) const
protectedinherited

Reset cuts.

Reset the AcceptData cut results to false

Initialize common cuts to true by default

Definition at line 338 of file JSSTaggerBase.cxx.

338  {
339 
341  acceptData.clear();
342 
344  acceptData.setCutResult( "ValidJetContent", true );
345  acceptData.setCutResult( "ValidEventContent", true );
346 
347  acceptData.setCutResult( "ValidPtRangeHigh", true );
348  acceptData.setCutResult( "ValidPtRangeLow" , true );
349  acceptData.setCutResult( "ValidEtaRange" , true );
350 
351  return StatusCode::SUCCESS;
352 
353 }

◆ simplegetNTrackWeight()

StatusCode CP::JetQGTagger::simplegetNTrackWeight ( const xAOD::Jet *  jet,
double &  weight 
) const
private

Definition at line 363 of file JetQGTagger.cxx.

363  {
364 
365  ATH_MSG_DEBUG( "Getting the jet weight for systematic variation " << m_appliedSystEnum );
366 
367  // initially set the weight to unity
368  // this is the weight returned if you are *not* dealing with a systematic variation
369  weight = 1.0;
370  ATH_MSG_DEBUG("Getting the jet weight for systematic variation " << m_appliedSystEnum);
371  ATH_MSG_DEBUG("made it into simplegetntrk");
372 
373  // if you are not dealing with a systematic variation, then exit
374  if ( m_appliedSystEnum!=QG_NCHARGEDEXP_UP &&
375  m_appliedSystEnum!=QG_NCHARGEDME_UP &&
376  m_appliedSystEnum!=QG_NCHARGEDPDF_UP &&
377  m_appliedSystEnum!=QG_NCHARGEDEXP_DOWN &&
378  m_appliedSystEnum!=QG_NCHARGEDME_DOWN &&
379  m_appliedSystEnum!=QG_NCHARGEDPDF_DOWN &&
380  m_appliedSystEnum!=QG_TRACKEFFICIENCY &&
381  m_appliedSystEnum!=QG_TRACKFAKES
382  )
383  {
384  return StatusCode::SUCCESS;
385  }
386 
387  // use the lookup tables loaded in initialize() to find the systematically shifted weights
388  bool truthsyst = m_appliedSystEnum==QG_NCHARGEDEXP_UP || m_appliedSystEnum==QG_NCHARGEDME_UP || m_appliedSystEnum==QG_NCHARGEDPDF_UP || m_appliedSystEnum == QG_NCHARGEDEXP_DOWN || m_appliedSystEnum== QG_NCHARGEDME_DOWN || m_appliedSystEnum == QG_NCHARGEDPDF_DOWN;
389  bool recosyst = m_appliedSystEnum==QG_TRACKEFFICIENCY || m_appliedSystEnum == QG_TRACKFAKES;
390 
391  int ptbin, ntrkbin;
392  int pdgid = jet->getAttribute<int>("PartonTruthLabelID");
393  if (truthsyst){
394  int tntrk = jet->getAttribute<int>("DFCommonJets_QGTagger_truthjet_nCharged");
395  float tjetpt = jet->getAttribute<float>("DFCommonJets_QGTagger_truthjet_pt")*0.001;
396  float tjeteta = jet->getAttribute<float>("DFCommonJets_QGTagger_truthjet_eta");
397  ATH_MSG_DEBUG("truth jet pdgid: " << pdgid << " pt: " << tjetpt);
398  if ( pdgid<0 ) {
399  ATH_MSG_DEBUG("Undefined pdg ID: setting weight to 1");
400  return StatusCode::SUCCESS;
401  }
402 
403  // if the jet is outside of the measurement fiducial region
404  // the systematic uncertainty is set to 0
405  if ( tjetpt < m_jetPtMin*1e-3 || std::abs(tjeteta) > m_jetEtaMax ) {
406  ATH_MSG_DEBUG( "Outside of fiducial region: setting weight to 1" );
407  return StatusCode::SUCCESS;
408  }
409 
410  if ( pdgid==21 && m_appliedSystEnum!=QG_NCHARGEDTOPO ) {
411  ptbin = std::as_const(*m_hgluon).GetXaxis()->FindFixBin(tjetpt);
412  ntrkbin = std::as_const(*m_hgluon).GetYaxis()->FindFixBin(tntrk);
413  weight = m_hgluon->GetBinContent(ptbin,ntrkbin);
414  }// gluon
415  else if ( pdgid < 5 && m_appliedSystEnum != QG_NCHARGEDTOPO && m_appliedSystEnum != QG_TRACKEFFICIENCY && m_appliedSystEnum != QG_TRACKFAKES ) {
416  ptbin = std::as_const(*m_hquark).GetXaxis()->FindFixBin(tjetpt);
417  ntrkbin = std::as_const(*m_hquark).GetYaxis()->FindFixBin(tntrk);
418  weight = m_hquark->GetBinContent(ptbin,ntrkbin);
419  }//quarks
420  else {
421  ATH_MSG_INFO( "Neither quark nor gluon jet: setting weight to 1" );
422  }
423  }
424 
425  // check if jet contains at least one NTracks variables
426  // prefer to use DFCommonJets* version
427  int ntrk = -1;
428  if ( recosyst) {
429  SG::ReadDecorHandle<xAOD::JetContainer, int> readNumTrkPt500PV(m_readNumTrkPt500PVKey);
430  SG::ReadDecorHandle<xAOD::JetContainer, int> readNtrk(m_readNtrkKey);
431  if ( readNtrk.isAvailable() ) ntrk = readNtrk(*jet);
432  else if ( readNumTrkPt500PV.isAvailable() ) ntrk = readNumTrkPt500PV(*jet);
433  else ATH_MSG_ERROR("Neither NumTrkPt500PV nor DFCommonJets_QGTagger_NTracks is available for your jet. Please add it before running mode 1 JetQGTagger.");
434  //float rjetpt = jet->getAttribute<float>("truthjet_pt")*0.001;
435  float rjetpt = jet->pt()*1e-3;
436  float rjeteta = jet->eta();
437 
438  ATH_MSG_DEBUG("reco jet Pt: " << rjetpt << " eta: " << rjeteta);
439  if( rjetpt<m_jetPtMin*1e-3 || std::abs(rjeteta)>m_jetEtaMax){
440  ATH_MSG_DEBUG("Outside of fiducial region: setting weight to 1");
441  return StatusCode::SUCCESS;
442  }
443 
444  if ( pdgid < 5 ) {
445  ptbin = std::as_const(*m_hquark).GetXaxis()->FindFixBin(rjetpt);
446  ntrkbin = std::as_const(*m_hquark).GetYaxis()->FindFixBin(ntrk);
447  weight = m_hquark->GetBinContent(ptbin,ntrkbin);
448  }
449  if ( pdgid == 21 ) {
450  ptbin = std::as_const(*m_hgluon).GetXaxis()->FindFixBin(rjetpt);
451  ntrkbin = std::as_const(*m_hgluon).GetYaxis()->FindFixBin(ntrk);
452  weight = m_hgluon->GetBinContent(ptbin,ntrkbin);
453  }
454  }
455 
456  ATH_MSG_DEBUG("weight: " << weight);
457 
458  return StatusCode::SUCCESS;
459 
460  }

◆ sysApplySystematicVariation()

StatusCode CP::JetQGTagger::sysApplySystematicVariation ( const SystematicSet &  systConfig)
overridevirtual

effects: configure this tool for the given list of systematic variations.

systConfig is guaranteed to contain only supported systematics. guarantee: basic failures: out of memory II failures: unsupported combination of supported systematics failures: other tool specific errors

Implements CP::SystematicsTool.

Definition at line 626 of file JetQGTagger.cxx.

626  {
627 
628  // FRANCESCO COMMENT
629  ATH_MSG_DEBUG( "Applying systematic variation by weight" );
630 
631  // by default no systematics are applied
632  m_appliedSystEnum = QG_NONE;
633 
634  if (systSet.empty()) {
635  ATH_MSG_DEBUG("No affecting systematics received.");
636  return StatusCode::SUCCESS;
637  }
638  else if (systSet.size()>1) {
639  ATH_MSG_WARNING("Tool does not support multiple systematics, returning unsupported" );
640  return StatusCode::FAILURE;
641  }
642  SystematicVariation systVar = *systSet.begin();
643  if (systVar == SystematicVariation(""))
644  m_appliedSystEnum = QG_NONE;
645  else if (systVar == QGntrackSyst::nchargedtopo){
646  m_appliedSystEnum = QG_NCHARGEDTOPO;
647  m_hquark=m_topo_hquark;
648  }
649  else if (systVar == QGntrackSyst::trackefficiency)
650  m_appliedSystEnum = QG_TRACKEFFICIENCY;
651  else if (systVar == QGntrackSyst::trackfakes)
652  m_appliedSystEnum = QG_TRACKFAKES;
653  else if (systVar == QGntrackSyst::nchargedexp_up){
654  m_appliedSystEnum = QG_NCHARGEDEXP_UP;
655  m_hquark=m_exp_hquark_up;
656  m_hgluon=m_exp_hgluon_up;
657  }
658  else if (systVar == QGntrackSyst::nchargedme_up){
659  m_appliedSystEnum = QG_NCHARGEDME_UP;
660  m_hquark=m_me_hquark_up;
661  m_hgluon=m_me_hgluon_up;
662  }
663  else if (systVar == QGntrackSyst::nchargedpdf_up){
664  m_appliedSystEnum = QG_NCHARGEDPDF_UP;
665  m_hquark=m_pdf_hquark_up;
666  m_hgluon=m_pdf_hgluon_up;
667  }
668  else if (systVar == QGntrackSyst::nchargedexp_down){
669  m_appliedSystEnum = QG_NCHARGEDEXP_DOWN;
670  m_hquark=m_exp_hquark_down;
671  m_hgluon=m_exp_hgluon_down;
672  }
673  else if (systVar == QGntrackSyst::nchargedme_down){
674  m_appliedSystEnum = QG_NCHARGEDME_DOWN;
675  m_hquark=m_me_hquark_down;
676  m_hgluon=m_me_hgluon_down;
677  }
678  else if (systVar == QGntrackSyst::nchargedpdf_down){
679  m_appliedSystEnum = QG_NCHARGEDPDF_DOWN;
680  m_hquark=m_pdf_hquark_down;
681  m_hgluon=m_pdf_hgluon_down;
682  }
683  else if (systVar == QGntrackSyst::trackeff){
684  m_appliedSystEnum = QG_TRACKEFFICIENCY;
685  m_hquark = m_trackeff_hquark;
686  m_hgluon = m_trackeff_hgluon;
687  }
688  else if (systVar == QGntrackSyst::fake){
689  m_appliedSystEnum = QG_TRACKFAKES;
690  m_hquark = m_fake_hquark;
691  m_hgluon = m_fake_hgluon;
692  }
693 
694  else {
695  ATH_MSG_WARNING("unsupported systematic applied");
696  return StatusCode::FAILURE;
697  }
698 
699  ATH_MSG_DEBUG("applied systematic is " << m_appliedSystEnum);
700  return StatusCode::SUCCESS;
701  }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )
overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ tag() [1/2]

virtual StatusCode CP::JetQGTagger::tag ( const xAOD::Jet &  jet) const
inlineoverridevirtual

Implements CP::IJetQGTagger.

Definition at line 48 of file JetQGTagger.h.

48 { return tag(jet, nullptr); }

◆ tag() [2/2]

StatusCode CP::JetQGTagger::tag ( const xAOD::Jet &  jet,
const xAOD::Vertex *  pv 
) const
overridevirtual

Create asg::AcceptData object

Reset the AcceptData cut results

Check basic kinematic selection

Create WriteDecorHandles

If the jet isn't valid there's no point applying the remaining cuts TODO: Is this actually needed?

Implements CP::IJetQGTagger.

Definition at line 244 of file JetQGTagger.cxx.

244  {
245 
246  ATH_MSG_DEBUG( "Obtaining QG result" );
247 
248  double jetWeight = -1;
249  int jetNTrack = -1;
250 
252  asg::AcceptData acceptData( &m_acceptInfo );
253 
255  ATH_CHECK( resetCuts( acceptData ) );
256 
258  ATH_CHECK( checkKinRange( jet, acceptData ) );
259 
261  SG::WriteDecorHandle<xAOD::JetContainer, bool> decTagged(m_decTaggedKey);
262  SG::WriteDecorHandle<xAOD::JetContainer, bool> decValidEventContent(m_decValidEventContentKey);
263 
266  if ( !passKinRange(jet) ) {
267  decTagged(jet) = false;
268  return StatusCode::SUCCESS;
269  }
270 
271  if ( m_mode == 0 ) { //do tagging assuming relevant track particle, PV, etc containers exist
272  bool isValid = true;
273  if ( pv ) ATH_MSG_DEBUG( "Obtaining JetQGTagger decision with user specific primary vertex" );
274  else ATH_MSG_DEBUG( "Obtaining JetQGTagger decision default" );
275 
276  // if no primary vertex is specified, then the 0th primary vertex is used
277  if ( !pv ) {
278  const xAOD::VertexContainer* vxCont = nullptr;
279  if ( evtStore()->retrieve( vxCont, "PrimaryVertices" ).isFailure() ) {
280  ATH_MSG_WARNING("Unable to retrieve primary vertex container PrimaryVertices");
281  acceptData.setCutResult("ValidEventContent", false);
282  isValid = false;
283  }
284  else if ( vxCont->empty() ) {
285  ATH_MSG_WARNING("Event has no primary vertices!");
286  acceptData.setCutResult("ValidEventContent", false);
287  isValid = false;
288  }
289  else {
290  for ( const auto *vx : *vxCont ) {
291  // take the first vertex in the list that is a primary vertex
292  if ( vx->vertexType()==xAOD::VxType::PriVtx ) {
293  pv = vx;
294  break;
295  }
296  }
297  }
298  // Now we have to make sure that we did ID one as PV
299  // I think this can happen in physics events (though they've got to be removed in order to perform a lot of calibrations)
300  // so I've elected to not spit out a warning message here
301  if ( !pv ) {
302  acceptData.setCutResult("ValidEventContent", false);
303  isValid = false;
304  }
305  }
306 
307  // If the object isn't valid there's no point applying the remaining cuts
308  if ( !isValid ) return StatusCode::SUCCESS;
309 
310  // obtain the relevant information for tagging
311  // 1) the number of tracks
312  // 2) jet-by-jet event weight
313  ATH_CHECK( getNTrack(&jet, /*pv,*/ jetNTrack) );
314  ATH_CHECK( getNTrackWeight(&jet, jetWeight) );
315 
316  }
317 
318  if ( m_mode == 1 ) { //only calculating uncertainty using given jet info (nTrk already calculated, etc)
319  ATH_CHECK( simplegetNTrackWeight(&jet, jetWeight) );
320  SG::ReadDecorHandle<xAOD::JetContainer, int> readNumTrkPt500PV(m_readNumTrkPt500PVKey);
321  SG::ReadDecorHandle<xAOD::JetContainer, int> readNtrk(m_readNtrkKey);
322  if ( readNtrk.isAvailable() ) jetNTrack = readNtrk(jet);
323  else if ( readNumTrkPt500PV.isAvailable() ) jetNTrack = readNumTrkPt500PV(jet);
324  else {
325  ATH_MSG_ERROR("Neither NumTrkPt500PV nor DFCommonJets_QGTagger_NTracks is available for your jet. Please add it before running in mode 1 of the JetQGTagger.");
326  return StatusCode::FAILURE;
327  }
328 
329  // decorate the cut value if specified
330  SG::WriteDecorHandle<xAOD::JetContainer, float> decWeight(m_qgDecWeightKey);
331  decWeight(jet) = jetWeight;
332  }
333 
334  decValidEventContent(jet) = acceptData.getCutResult( "ValidEventContent" );
335 
336  // decorate the cut value if specified
337  SG::WriteDecorHandle<xAOD::JetContainer, float> decTag(m_decTagKey);
338  SG::WriteDecorHandle<xAOD::JetContainer, float> decWeight(m_qgDecWeightKey);
339 
340  decTag(jet) = jetNTrack;
341  decWeight(jet) = jetWeight;
342 
343  // fill the AcceptData
344  ATH_MSG_DEBUG("NTrack = "<<jetNTrack);
345  ATH_MSG_DEBUG("NTrackWeight = "<<jetWeight);
346  double variable_nTrk = -999.0;
347  if (m_cuttype=="linear_pt"){
348  variable_nTrk=(m_slope*jet.pt())+m_intercept;
349  if(jetNTrack<variable_nTrk) acceptData.setCutResult("QuarkJetTag", true);
350  }
351  else if (m_cuttype=="log_pt"){
352  variable_nTrk=(m_slope*TMath::Log10(jet.pt()))+m_intercept;
353  if(jetNTrack<variable_nTrk) acceptData.setCutResult("QuarkJetTag", true);
354  }
355  else if(m_cuttype=="threshold" && jetNTrack<m_NTrackCut) acceptData.setCutResult("QuarkJetTag", true);
356 
357  decTagged(jet) = acceptData.getCutResult( "QuarkJetTag" );
358 
359  return StatusCode::SUCCESS;
360 
361  }

◆ testInvariant()

void CP::SystematicsTool::testInvariant ( ) const
inherited

effects: test the invariance of this object guarantee: no-fail

Definition at line 165 of file SystematicsTool.cxx.

165  {
166 
167  //RCU_INVARIANT( this != 0 );
168  }

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_acceptInfo

asg::AcceptInfo JSSTaggerBase::m_acceptInfo
protectedinherited

Object that stores the results for a jet.

Definition at line 65 of file JSSTaggerBase.h.

◆ m_affectingSystematics

SystematicSet CP::SystematicsTool::m_affectingSystematics
protectedinherited

description: members directly corresponding to accessors

Definition at line 146 of file SystematicsTool.h.

◆ m_appliedSystematics

SystematicSet* CP::SystematicsTool::m_appliedSystematics
privateinherited

description: pointer to currenty applied systematics

Definition at line 151 of file SystematicsTool.h.

◆ m_appliedSystEnum

QGSystApplied CP::JetQGTagger::m_appliedSystEnum
private

Definition at line 63 of file JetQGTagger.h.

◆ m_calcSF

bool JSSTaggerBase::m_calcSF
protectedinherited

Flag to calculate scale factor.

Definition at line 205 of file JSSTaggerBase.h.

◆ m_calibArea

std::string JSSTaggerBase::m_calibArea
protectedinherited

Location where config files live on cvmfs.

Definition at line 114 of file JSSTaggerBase.h.

◆ m_configFile

std::string JSSTaggerBase::m_configFile
protectedinherited

Configuration file name.

Definition at line 111 of file JSSTaggerBase.h.

◆ m_configReader

TEnv JSSTaggerBase::m_configReader
protectedinherited

TEnv instance to read config files.

Definition at line 62 of file JSSTaggerBase.h.

◆ m_containerName

std::string JSSTaggerBase::m_containerName
protectedinherited

Configurable members.

Jet container name

Definition at line 105 of file JSSTaggerBase.h.

◆ m_cuttype

std::string CP::JetQGTagger::m_cuttype
private

Definition at line 105 of file JetQGTagger.h.

◆ m_decC2Key

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_decC2Key {this, "C2NameOut", "C2", "SG key for C2"}
protectedinherited

Definition at line 146 of file JSSTaggerBase.h.

◆ m_decCutMHighKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_decCutMHighKey {this, "CutMHighName", "Cut_mhigh", "SG key for Cut_mhigh"}
protectedinherited

Definition at line 232 of file JSSTaggerBase.h.

◆ m_decCutMLowKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_decCutMLowKey {this, "CutMLowName", "Cut_mlow", "SG key for Cut_mlow"}
protectedinherited

WriteDecorHandle keys for cut values.

Definition at line 231 of file JSSTaggerBase.h.

◆ m_decD2Key

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_decD2Key {this, "D2NameOut", "D2", "SG key for D2"}
protectedinherited

Definition at line 147 of file JSSTaggerBase.h.

◆ m_decE3Key

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_decE3Key {this, "e3NameOut", "e3", "SG key for e3"}
protectedinherited

Definition at line 148 of file JSSTaggerBase.h.

◆ m_decEfficiencyKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_decEfficiencyKey {this, "efficiencyName", "efficiency", "SG key for efficiency"}
protectedinherited

Definition at line 238 of file JSSTaggerBase.h.

◆ m_decEffSFKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_decEffSFKey {this, "effSFName", "effSF", "SG key for effSF"}
protectedinherited

Definition at line 239 of file JSSTaggerBase.h.

◆ m_decL2Key

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_decL2Key {this, "L2NameOut", "L2", "SG key for L2"}
protectedinherited

Definition at line 149 of file JSSTaggerBase.h.

◆ m_decL3Key

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_decL3Key {this, "L3NameOut", "L3", "SG key for L3"}
protectedinherited

Definition at line 150 of file JSSTaggerBase.h.

◆ m_decNtrk500Key

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_decNtrk500Key {this, "Ntrk500NameOut", "ParentJetNTrkPt500", "SG key for Ntrk500 from ungroomed jet"}
protectedinherited

Definition at line 186 of file JSSTaggerBase.h.

◆ m_decorationName

std::string JSSTaggerBase::m_decorationName
protectedinherited

Decoration name.

Definition at line 202 of file JSSTaggerBase.h.

◆ m_decPassMassKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_decPassMassKey {this, "PassMassName", "PassMass", "SG key for PassMass"}
protectedinherited

Definition at line 79 of file JSSTaggerBase.h.

◆ m_decPassScoreKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_decPassScoreKey {this, "PassScoreName", "PassScore", "SG key for PassScore"}
protectedinherited

Definition at line 80 of file JSSTaggerBase.h.

◆ m_decScoreCutKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_decScoreCutKey {this, "CutScoreName", "Cut_score", "SG key for Cut_score"}
protectedinherited

Definition at line 233 of file JSSTaggerBase.h.

◆ m_decScoreValueKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_decScoreValueKey {this, "ScoreName", "Score", "SG key for Score"}
protectedinherited

Definition at line 234 of file JSSTaggerBase.h.

◆ m_decSigeffSFKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_decSigeffSFKey {this, "sigeffSFName", "sigeffSF", "SG key for effSF"}
protectedinherited

Definition at line 240 of file JSSTaggerBase.h.

◆ m_decTaggedKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_decTaggedKey {this, "TaggedName", "Tagged", "SG key for Tagged"}
protectedinherited

WriteDecorHandle keys for tagging bools.

Definition at line 71 of file JSSTaggerBase.h.

◆ m_decTagKey

SG::WriteDecorHandleKey<xAOD::JetContainer> CP::JetQGTagger::m_decTagKey {this, "TagName", "Tag", "SG key for Tag"}
private

WriteDecorHandle keys.

Definition at line 119 of file JetQGTagger.h.

◆ m_decTau21WTAKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_decTau21WTAKey {this, "Tau21WTANameOut", "Tau21_wta", "SG key for Tau21_wta"}
protectedinherited

WriteDecorHandle keys for JSS moments.

Definition at line 142 of file JSSTaggerBase.h.

◆ m_decTau32WTAKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_decTau32WTAKey {this, "Tau32WTANameOut", "Tau32_wta", "SG key for Tau32_wta"}
protectedinherited

Definition at line 143 of file JSSTaggerBase.h.

◆ m_decTau42WTAKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_decTau42WTAKey {this, "Tau42WTANameOut", "Tau42_wta", "SG key for Tau42_wta"}
protectedinherited

Definition at line 144 of file JSSTaggerBase.h.

◆ m_decValidEtaRangeKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_decValidEtaRangeKey {this, "ValidEtaRangeName", "ValidEtaRange", "SG key for ValidEtaRange"}
protectedinherited

Definition at line 74 of file JSSTaggerBase.h.

◆ m_decValidEventContentKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_decValidEventContentKey {this, "ValidEventContentName", "ValidEventContent", "SG key for ValidEventContent"}
protectedinherited

Definition at line 77 of file JSSTaggerBase.h.

◆ m_decValidJetContentKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_decValidJetContentKey {this, "ValidJetContentName", "ValidJetContent", "SG key for ValidJetContent"}
protectedinherited

Definition at line 76 of file JSSTaggerBase.h.

◆ m_decValidKinRangeKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_decValidKinRangeKey {this, "ValidKinRangeName", "ValidKinRange", "SG key for ValidKinRange"}
protectedinherited

Definition at line 75 of file JSSTaggerBase.h.

◆ m_decValidPtRangeHighKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_decValidPtRangeHighKey {this, "ValidPtRangeHighName", "ValidPtRangeHigh", "SG key for ValidPtRangeHigh"}
protectedinherited

Definition at line 72 of file JSSTaggerBase.h.

◆ m_decValidPtRangeLowKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_decValidPtRangeLowKey {this, "ValidPtRangeLowName", "ValidPtRangeLow", "SG key for ValidPtRangeLow"}
protectedinherited

Definition at line 73 of file JSSTaggerBase.h.

◆ m_decWeightKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_decWeightKey {this, "weightName", "weight", "SG key for weight"}
protectedinherited

WriteDecorHandle keys for SF.

Definition at line 237 of file JSSTaggerBase.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_efficiencyHistogramName

std::string JSSTaggerBase::m_efficiencyHistogramName
protectedinherited

Definition at line 212 of file JSSTaggerBase.h.

◆ m_efficiencyHistograms

std::map<std::string, std::unique_ptr<TH2D> > JSSTaggerBase::m_efficiencyHistograms
protectedinherited

Definition at line 218 of file JSSTaggerBase.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_exp_hgluon_down

TH2D* CP::JetQGTagger::m_exp_hgluon_down
private

Definition at line 73 of file JetQGTagger.h.

◆ m_exp_hgluon_up

TH2D* CP::JetQGTagger::m_exp_hgluon_up
private

Definition at line 72 of file JetQGTagger.h.

◆ m_exp_hquark_down

TH2D* CP::JetQGTagger::m_exp_hquark_down
private

Definition at line 71 of file JetQGTagger.h.

◆ m_exp_hquark_up

TH2D* CP::JetQGTagger::m_exp_hquark_up
private

Definition at line 70 of file JetQGTagger.h.

◆ m_expfile

std::string CP::JetQGTagger::m_expfile
private

Definition at line 94 of file JetQGTagger.h.

◆ m_fake_hgluon

TH2D* CP::JetQGTagger::m_fake_hgluon
private

Definition at line 88 of file JetQGTagger.h.

◆ m_fake_hquark

TH2D* CP::JetQGTagger::m_fake_hquark
private

Definition at line 87 of file JetQGTagger.h.

◆ m_fakefile

std::string CP::JetQGTagger::m_fakefile
private

Definition at line 98 of file JetQGTagger.h.

◆ m_funcMassCutHigh

std::unique_ptr<TF1> JSSTaggerBase::m_funcMassCutHigh
protectedinherited

Definition at line 198 of file JSSTaggerBase.h.

◆ m_funcMassCutLow

std::unique_ptr<TF1> JSSTaggerBase::m_funcMassCutLow
protectedinherited

TF1 for cut functions.

Definition at line 197 of file JSSTaggerBase.h.

◆ m_funcScoreCut

std::unique_ptr<TF1> JSSTaggerBase::m_funcScoreCut
protectedinherited

Definition at line 199 of file JSSTaggerBase.h.

◆ m_hgluon

TH2D* CP::JetQGTagger::m_hgluon
private

Definition at line 66 of file JetQGTagger.h.

◆ m_hquark

TH2D* CP::JetQGTagger::m_hquark
private

Definition at line 65 of file JetQGTagger.h.

◆ m_intercept

double CP::JetQGTagger::m_intercept
private

Definition at line 104 of file JetQGTagger.h.

◆ m_isMC

bool JSSTaggerBase::m_isMC
protectedinherited

Definition at line 206 of file JSSTaggerBase.h.

◆ m_jetContainer_key

SG::ReadHandleKey<xAOD::JetContainer> JSSTaggerBase::m_jetContainer_key {this, "JetContainer", "AntiKt10UFOCSSKSoftDropBeta100Zcut10Jets", "SG key for input jet container"}
protectedinherited

Definition at line 68 of file JSSTaggerBase.h.

◆ m_jetEtaMax

float JSSTaggerBase::m_jetEtaMax
protectedinherited

Definition at line 134 of file JSSTaggerBase.h.

◆ m_jetPtMax

float JSSTaggerBase::m_jetPtMax
protectedinherited

Definition at line 133 of file JSSTaggerBase.h.

◆ m_jetPtMin

float JSSTaggerBase::m_jetPtMin
protectedinherited

Kinematic bounds for the jet - the units are controlled by m_ptGeV.

Definition at line 132 of file JSSTaggerBase.h.

◆ m_jetTrackFilterTool

asg::AnaToolHandle<InDet::IJetTrackFilterTool> CP::JetQGTagger::m_jetTrackFilterTool
private

Definition at line 111 of file JetQGTagger.h.

◆ m_kerasCalibArea

std::string JSSTaggerBase::m_kerasCalibArea
protectedinherited

Definition at line 120 of file JSSTaggerBase.h.

◆ m_kerasConfigFileName

std::string JSSTaggerBase::m_kerasConfigFileName
protectedinherited

Keras configurations for ML taggers.

Definition at line 117 of file JSSTaggerBase.h.

◆ m_kerasConfigFilePath

std::string JSSTaggerBase::m_kerasConfigFilePath
protectedinherited

Definition at line 118 of file JSSTaggerBase.h.

◆ m_kerasConfigOutputName

std::string JSSTaggerBase::m_kerasConfigOutputName
protectedinherited

Definition at line 119 of file JSSTaggerBase.h.

◆ m_me_hgluon_down

TH2D* CP::JetQGTagger::m_me_hgluon_down
private

Definition at line 78 of file JetQGTagger.h.

◆ m_me_hgluon_up

TH2D* CP::JetQGTagger::m_me_hgluon_up
private

Definition at line 77 of file JetQGTagger.h.

◆ m_me_hquark_down

TH2D* CP::JetQGTagger::m_me_hquark_down
private

Definition at line 76 of file JetQGTagger.h.

◆ m_me_hquark_up

TH2D* CP::JetQGTagger::m_me_hquark_up
private

Definition at line 75 of file JetQGTagger.h.

◆ m_mefile

std::string CP::JetQGTagger::m_mefile
private

Definition at line 95 of file JetQGTagger.h.

◆ m_mode

int CP::JetQGTagger::m_mode
private

Definition at line 106 of file JetQGTagger.h.

◆ m_NTrackCut

int CP::JetQGTagger::m_NTrackCut
private

Definition at line 102 of file JetQGTagger.h.

◆ m_nWarnMax

const int JSSTaggerBase::m_nWarnMax = 10
protectedinherited

Maximum number of warnings.

Definition at line 83 of file JSSTaggerBase.h.

◆ m_nWarnVar

std::atomic<int> JSSTaggerBase::m_nWarnVar
mutableprotectedinherited

Warning counters.

Definition at line 86 of file JSSTaggerBase.h.

◆ m_originTool

asg::AnaToolHandle<InDet::IInDetTrackTruthOriginTool> CP::JetQGTagger::m_originTool
private

Definition at line 112 of file JetQGTagger.h.

◆ m_pdf_hgluon_down

TH2D* CP::JetQGTagger::m_pdf_hgluon_down
private

Definition at line 83 of file JetQGTagger.h.

◆ m_pdf_hgluon_up

TH2D* CP::JetQGTagger::m_pdf_hgluon_up
private

Definition at line 82 of file JetQGTagger.h.

◆ m_pdf_hquark_down

TH2D* CP::JetQGTagger::m_pdf_hquark_down
private

Definition at line 81 of file JetQGTagger.h.

◆ m_pdf_hquark_up

TH2D* CP::JetQGTagger::m_pdf_hquark_up
private

Definition at line 80 of file JetQGTagger.h.

◆ m_pdffile

std::string CP::JetQGTagger::m_pdffile
private

Definition at line 96 of file JetQGTagger.h.

◆ m_ptGeV

bool JSSTaggerBase::m_ptGeV = false
protectedinherited

Flag to indicate units pT is defined in Set to false by default.

Definition at line 90 of file JSSTaggerBase.h.

◆ m_qgDecWeightKey

SG::WriteDecorHandleKey<xAOD::JetContainer> CP::JetQGTagger::m_qgDecWeightKey {this, "QGWeightName", "Weight", "SG key for Weight"}
private

Definition at line 120 of file JetQGTagger.h.

◆ m_readC2Key

SG::ReadDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_readC2Key {this, "C2Name", "C2", "SG key for C2"}
protectedinherited

Definition at line 166 of file JSSTaggerBase.h.

◆ m_readD2Key

SG::ReadDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_readD2Key {this, "D2Name", "D2", "SG key for D2"}
protectedinherited

Definition at line 167 of file JSSTaggerBase.h.

◆ m_readE3Key

SG::ReadDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_readE3Key {this, "e3Name", "e3", "SG key for e3"}
protectedinherited

Definition at line 168 of file JSSTaggerBase.h.

◆ m_readECF1Key

SG::ReadDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_readECF1Key {this, "ECF1Name", "ECF1", "SG key for ECF1"}
protectedinherited

Definition at line 162 of file JSSTaggerBase.h.

◆ m_readECF2Key

SG::ReadDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_readECF2Key {this, "ECF2Name", "ECF2", "SG key for ECF2"}
protectedinherited

Definition at line 163 of file JSSTaggerBase.h.

◆ m_readECF3Key

SG::ReadDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_readECF3Key {this, "ECF3Name", "ECF3", "SG key for ECF3"}
protectedinherited

Definition at line 164 of file JSSTaggerBase.h.

◆ m_readECFG212Key

SG::ReadDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_readECFG212Key {this, "ECFG212Name", "ECFG_2_1_2", "SG key for ECFG_2_1_2"}
protectedinherited

Definition at line 183 of file JSSTaggerBase.h.

◆ m_readECFG311Key

SG::ReadDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_readECFG311Key {this, "ECFG311Name", "ECFG_3_1_1", "SG key for ECFG_3_1_1"}
protectedinherited

Definition at line 182 of file JSSTaggerBase.h.

◆ m_readECFG331Key

SG::ReadDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_readECFG331Key {this, "ECFG331Name", "ECFG_3_3_1", "SG key for ECFG_3_3_1"}
protectedinherited

Definition at line 181 of file JSSTaggerBase.h.

◆ m_readL2Key

SG::ReadDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_readL2Key {this, "L2Name", "L2", "SG key for L2"}
protectedinherited

Definition at line 178 of file JSSTaggerBase.h.

◆ m_readL3Key

SG::ReadDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_readL3Key {this, "L3Name", "L3", "SG key for L3"}
protectedinherited

Definition at line 179 of file JSSTaggerBase.h.

◆ m_readNtrk500Key

SG::ReadDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_readNtrk500Key {this, "Ntrk500Name", "ParentJetNTrkPt500", "SG key for Ntrk500 from ungroomed jet"}
protectedinherited

Definition at line 187 of file JSSTaggerBase.h.

◆ m_readNtrkKey

SG::ReadDecorHandleKey<xAOD::JetContainer> CP::JetQGTagger::m_readNtrkKey {this, "NtrkName", "DFCommonJets_QGTagger_NTracks", "SG key for Ntrk"}
private

Definition at line 116 of file JetQGTagger.h.

◆ m_readNumTrkPt500PVKey

SG::ReadDecorHandleKey<xAOD::JetContainer> CP::JetQGTagger::m_readNumTrkPt500PVKey {this, "NumTrkPt500PVName", "NumTrkPt500PV", "SG key for NumTrkPt500PV"}
private

ReadDecorHandle keys.

Definition at line 115 of file JetQGTagger.h.

◆ m_readParentKey

SG::ReadDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_readParentKey {this, "ParentName", "Parent", "SG key for Parent"}
protectedinherited

Definition at line 185 of file JSSTaggerBase.h.

◆ m_readQwKey

SG::ReadDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_readQwKey {this, "QwName", "Qw", "SG key for Qw"}
protectedinherited

Definition at line 173 of file JSSTaggerBase.h.

◆ m_readSphericityKey

SG::ReadDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_readSphericityKey {this, "SphericityName", "Sphericity", "SG key for Sphericity"}
protectedinherited

Definition at line 176 of file JSSTaggerBase.h.

◆ m_readSplit12Key

SG::ReadDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_readSplit12Key {this, "Split12Name", "Split12", "SG key for Split12"}
protectedinherited

Definition at line 170 of file JSSTaggerBase.h.

◆ m_readSplit23Key

SG::ReadDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_readSplit23Key {this, "Split23Name", "Split23", "SG key for Split23"}
protectedinherited

Definition at line 171 of file JSSTaggerBase.h.

◆ m_readTau1WTAKey

SG::ReadDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_readTau1WTAKey {this, "Tau1WTAName", "Tau1_wta", "SG key for Tau1_wta"}
protectedinherited

ReadDecorHandle keys for JSS moments.

Definition at line 153 of file JSSTaggerBase.h.

◆ m_readTau21WTAKey

SG::ReadDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_readTau21WTAKey {this, "Tau21WTAName", "Tau21_wta", "SG key for Tau21_wta"}
protectedinherited

Definition at line 158 of file JSSTaggerBase.h.

◆ m_readTau2WTAKey

SG::ReadDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_readTau2WTAKey {this, "Tau2WTAName", "Tau2_wta", "SG key for Tau2_wta"}
protectedinherited

Definition at line 154 of file JSSTaggerBase.h.

◆ m_readTau32WTAKey

SG::ReadDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_readTau32WTAKey {this, "Tau32WTAName", "Tau32_wta", "SG key for Tau32_wta"}
protectedinherited

Definition at line 159 of file JSSTaggerBase.h.

◆ m_readTau3WTAKey

SG::ReadDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_readTau3WTAKey {this, "Tau3WTAName", "Tau3_wta", "SG key for Tau3_wta"}
protectedinherited

Definition at line 155 of file JSSTaggerBase.h.

◆ m_readTau42WTAKey

SG::ReadDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_readTau42WTAKey {this, "Tau42WTAName", "Tau42_wta", "SG key for Tau42_wta"}
protectedinherited

Definition at line 160 of file JSSTaggerBase.h.

◆ m_readTau4WTAKey

SG::ReadDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_readTau4WTAKey {this, "Tau4WTAName", "Tau4_wta", "SG key for Tau4_wta"}
protectedinherited

Definition at line 156 of file JSSTaggerBase.h.

◆ m_readThrustMajKey

SG::ReadDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_readThrustMajKey {this, "ThrustMajName", "ThrustMaj", "SG key for ThrustMaj"}
protectedinherited

Definition at line 175 of file JSSTaggerBase.h.

◆ m_readTruthLabelKey

SG::ReadDecorHandleKey<xAOD::JetContainer> JSSTaggerBase::m_readTruthLabelKey {this, "truthLabelName", "truthLabel", "SG key for truthLabel"}
protectedinherited

Truth label ReadDecorHandle key.

Definition at line 228 of file JSSTaggerBase.h.

◆ m_recommendedSystematics

SystematicSet CP::SystematicsTool::m_recommendedSystematics
protectedinherited

Definition at line 147 of file SystematicsTool.h.

◆ m_slope

double CP::JetQGTagger::m_slope
private

Definition at line 103 of file JetQGTagger.h.

◆ m_strMassCutHigh

std::string JSSTaggerBase::m_strMassCutHigh
protectedinherited

Definition at line 193 of file JSSTaggerBase.h.

◆ m_strMassCutLow

std::string JSSTaggerBase::m_strMassCutLow
protectedinherited

Strings for cut functions.

Definition at line 192 of file JSSTaggerBase.h.

◆ m_strScoreCut

std::string JSSTaggerBase::m_strScoreCut
protectedinherited

Definition at line 194 of file JSSTaggerBase.h.

◆ m_suppressOutputDependence

bool JSSTaggerBase::m_suppressOutputDependence
protectedinherited

Definition at line 189 of file JSSTaggerBase.h.

◆ m_systFilterMap

std::unordered_map<SystematicSet, SystematicSet> CP::SystematicsTool::m_systFilterMap
privateinherited

map of cached systematics filtering

Definition at line 154 of file SystematicsTool.h.

◆ m_tagClass

TAGCLASS JSSTaggerBase::m_tagClass
protectedinherited

Definition at line 100 of file JSSTaggerBase.h.

◆ m_tagger_decoration_name

std::string CP::JetQGTagger::m_tagger_decoration_name
private

Definition at line 100 of file JetQGTagger.h.

◆ m_taggername

std::string CP::JetQGTagger::m_taggername
private

Definition at line 92 of file JetQGTagger.h.

◆ m_tagType

std::string JSSTaggerBase::m_tagType
protectedinherited

Definition at line 129 of file JSSTaggerBase.h.

◆ m_tmvaCalibArea

std::string JSSTaggerBase::m_tmvaCalibArea
protectedinherited

Definition at line 125 of file JSSTaggerBase.h.

◆ m_tmvaConfigFileName

std::string JSSTaggerBase::m_tmvaConfigFileName
protectedinherited

TMVA configurations for BDT taggers.

Definition at line 123 of file JSSTaggerBase.h.

◆ m_tmvaConfigFilePath

std::string JSSTaggerBase::m_tmvaConfigFilePath
protectedinherited

Definition at line 124 of file JSSTaggerBase.h.

◆ m_topo_hquark

TH2D* CP::JetQGTagger::m_topo_hquark
private

Definition at line 68 of file JetQGTagger.h.

◆ m_topofile

std::string CP::JetQGTagger::m_topofile
private

Definition at line 93 of file JetQGTagger.h.

◆ m_trackeff_hgluon

TH2D* CP::JetQGTagger::m_trackeff_hgluon
private

Definition at line 86 of file JetQGTagger.h.

◆ m_trackeff_hquark

TH2D* CP::JetQGTagger::m_trackeff_hquark
private

Definition at line 85 of file JetQGTagger.h.

◆ m_trackefffile

std::string CP::JetQGTagger::m_trackefffile
private

Definition at line 97 of file JetQGTagger.h.

◆ m_trkFakeTool

asg::AnaToolHandle<InDet::IInDetTrackTruthFilterTool> CP::JetQGTagger::m_trkFakeTool
private

Definition at line 110 of file JetQGTagger.h.

◆ m_trkSelectionTool

asg::AnaToolHandle<InDet::IInDetTrackSelectionTool> CP::JetQGTagger::m_trkSelectionTool
private

Definition at line 108 of file JetQGTagger.h.

◆ m_trkTruthFilterTool

asg::AnaToolHandle<InDet::IInDetTrackTruthFilterTool> CP::JetQGTagger::m_trkTruthFilterTool
private

Definition at line 109 of file JetQGTagger.h.

◆ m_truthBosonContainerName

std::string JSSTaggerBase::m_truthBosonContainerName
protectedinherited

Definition at line 223 of file JSSTaggerBase.h.

◆ m_truthLabelName

std::string JSSTaggerBase::m_truthLabelName
protectedinherited

Definition at line 225 of file JSSTaggerBase.h.

◆ m_truthLabelUseTRUTH3

bool JSSTaggerBase::m_truthLabelUseTRUTH3
protectedinherited

Truth label options.

Definition at line 221 of file JSSTaggerBase.h.

◆ m_truthParticleContainerName

std::string JSSTaggerBase::m_truthParticleContainerName
protectedinherited

Definition at line 222 of file JSSTaggerBase.h.

◆ m_truthTopQuarkContainerName

std::string JSSTaggerBase::m_truthTopQuarkContainerName
protectedinherited

Definition at line 224 of file JSSTaggerBase.h.

◆ m_useECFG

bool JSSTaggerBase::m_useECFG = false
protectedinherited

Flags controlling whether generalized ECF moments or L-series ratios are needed TODO: Implement the functionality controlled by these.

Definition at line 138 of file JSSTaggerBase.h.

◆ m_useLSeries

bool JSSTaggerBase::m_useLSeries = false
protectedinherited

Definition at line 139 of file JSSTaggerBase.h.

◆ m_useMassCut

bool JSSTaggerBase::m_useMassCut = false
protectedinherited

Flag to indicate if mass window cut is used.

Definition at line 93 of file JSSTaggerBase.h.

◆ m_useScoreCut

bool JSSTaggerBase::m_useScoreCut = false
protectedinherited

Flag to indicate if a discriminant score is used.

Definition at line 96 of file JSSTaggerBase.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ m_weight_decoration_name

std::string CP::JetQGTagger::m_weight_decoration_name
private

Definition at line 99 of file JetQGTagger.h.

◆ m_weightConfig

std::unique_ptr<TFile> JSSTaggerBase::m_weightConfig
protectedinherited

Histograms for scale factors.

Definition at line 216 of file JSSTaggerBase.h.

◆ m_weightConfigPath

std::string JSSTaggerBase::m_weightConfigPath
protectedinherited

Path to the SF configuration root file.

Definition at line 108 of file JSSTaggerBase.h.

◆ m_weightDecorationName

std::string JSSTaggerBase::m_weightDecorationName
protectedinherited

String for scale factor decoration names.

Definition at line 209 of file JSSTaggerBase.h.

◆ m_weightFileName

std::string JSSTaggerBase::m_weightFileName
protectedinherited

Definition at line 210 of file JSSTaggerBase.h.

◆ m_weightFlavors

std::string JSSTaggerBase::m_weightFlavors
protectedinherited

Definition at line 213 of file JSSTaggerBase.h.

◆ m_weightHistogramName

std::string JSSTaggerBase::m_weightHistogramName
protectedinherited

Definition at line 211 of file JSSTaggerBase.h.

◆ m_weightHistograms

std::map<std::string, std::unique_ptr<TH2D> > JSSTaggerBase::m_weightHistograms
protectedinherited

Definition at line 217 of file JSSTaggerBase.h.

◆ m_wkpt

std::string JSSTaggerBase::m_wkpt
protectedinherited

Tagger information.

Definition at line 128 of file JSSTaggerBase.h.

The documentation for this class was generated from the following files:
JSSTaggerBase::m_readParentKey
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readParentKey
Definition: JSSTaggerBase.h:185
CP::JetQGTagger::applySystematicVariation
virtual StatusCode applySystematicVariation(const SystematicSet &set) override
effects: configure this tool for the given list of systematic variations.
Definition: JetQGTagger.h:54
LArG4FSStartPointFilter.part
part
Definition: LArG4FSStartPointFilter.py:21
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
LargeRJetTruthLabel::TypeEnum
TypeEnum
Definition: LargeRJetLabelEnum.h:14
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:73
InDet::IJetTrackFilterTool::applySystematicVariation
virtual StatusCode applySystematicVariation(const CP::SystematicSet &)=0
configure the tool to apply a given list of systematic variations
CP::JetQGTagger::m_fake_hquark
TH2D * m_fake_hquark
Definition: JetQGTagger.h:87
python.SystemOfUnits.second
int second
Definition: SystemOfUnits.py:120
TH2D::GetBinContent
double GetBinContent(int) const
Definition: rootspy.cxx:435
JSSTaggerBase::m_readTau4WTAKey
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readTau4WTAKey
Definition: JSSTaggerBase.h:156
beamspotnt.var
var
Definition: bin/beamspotnt.py:1394
CP::QG_NCHARGEDEXP_UP
@ QG_NCHARGEDEXP_UP
Definition: JetQGTagger.h:27
CP::JetQGTagger::m_trackefffile
std::string m_trackefffile
Definition: JetQGTagger.h:97
Trk::L2
@ L2
Definition: AlignModuleList.h:32
CP::JetQGTagger::m_NTrackCut
int m_NTrackCut
Definition: JetQGTagger.h:102
JSSTaggerBase::m_readECF1Key
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readECF1Key
Definition: JSSTaggerBase.h:162
JSSTaggerBase::getTruthLabelStr
std::string getTruthLabelStr(const xAOD::Jet &jet, asg::AcceptData &acceptData) const
Definition: JSSTaggerBase.cxx:728
CP::JetQGTagger::m_expfile
std::string m_expfile
Definition: JetQGTagger.h:94
CP::JetQGTagger::m_pdf_hquark_up
TH2D * m_pdf_hquark_up
Definition: JetQGTagger.h:80
CP::JetQGTagger::m_pdf_hquark_down
TH2D * m_pdf_hquark_down
Definition: JetQGTagger.h:81
get_generator_info.result
result
Definition: get_generator_info.py:21
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:392
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
CP::QG_NCHARGEDTOPO
@ QG_NCHARGEDTOPO
Definition: JetQGTagger.h:26
JSSTaggerBase::ZBoson
@ ZBoson
Definition: JSSTaggerBase.h:99
CP::JetQGTagger::m_exp_hquark_up
TH2D * m_exp_hquark_up
Definition: JetQGTagger.h:70
JSSTaggerBase::resetCuts
StatusCode resetCuts(asg::AcceptData &acceptData) const
Reset cuts.
Definition: JSSTaggerBase.cxx:338
run.infile
string infile
Definition: run.py:13
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
CP::JetQGTagger::m_decTagKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decTagKey
WriteDecorHandle keys.
Definition: JetQGTagger.h:119
JSSTaggerBase::m_readECFG311Key
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readECFG311Key
Definition: JSSTaggerBase.h:182
JSSTaggerBase::m_jetEtaMax
float m_jetEtaMax
Definition: JSSTaggerBase.h:134
CP::SystematicsTool::m_appliedSystematics
SystematicSet * m_appliedSystematics
description: pointer to currenty applied systematics
Definition: SystematicsTool.h:151
asg::AnaToolHandle::retrieve
StatusCode retrieve()
initialize the tool
JSSTaggerBase::m_decValidEtaRangeKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decValidEtaRangeKey
Definition: JSSTaggerBase.h:74
CP::JetQGTagger::m_trackeff_hgluon
TH2D * m_trackeff_hgluon
Definition: JetQGTagger.h:86
JSSTaggerBase::m_efficiencyHistograms
std::map< std::string, std::unique_ptr< TH2D > > m_efficiencyHistograms
Definition: JSSTaggerBase.h:218
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
JSSTaggerBase::m_configFile
std::string m_configFile
Configuration file name.
Definition: JSSTaggerBase.h:111
CP::QG_TRACKFAKES
@ QG_TRACKFAKES
Definition: JetQGTagger.h:25
JSSTaggerBase::m_configReader
TEnv m_configReader
TEnv instance to read config files.
Definition: JSSTaggerBase.h:62
RootHelpers::FindBin
Int_t FindBin(const TAxis *axis, const double x)
Definition: RootHelpers.cxx:14
plotmaker.hist
hist
Definition: plotmaker.py:148
CP::JetQGTagger::m_me_hgluon_down
TH2D * m_me_hgluon_down
Definition: JetQGTagger.h:78
CP::JetQGTagger::m_me_hquark_down
TH2D * m_me_hquark_down
Definition: JetQGTagger.h:76
JSSTaggerBase::TopQuark
@ TopQuark
Definition: JSSTaggerBase.h:99
CutsMETMaker::accept
StatusCode accept(const xAOD::Muon *mu)
Definition: CutsMETMaker.cxx:18
conifer::pow
constexpr int pow(int x)
Definition: conifer.h:20
JSSTaggerBase::tag
virtual StatusCode tag(const xAOD::Jet &jet) const =0
Decorate single jet with tagging info.
test_pyathena.pt
pt
Definition: test_pyathena.py:11
InDet::InDetTrackTruthOriginTool
Definition: InDetTrackTruthOriginTool.h:24
CP::QG_NCHARGEDME_DOWN
@ QG_NCHARGEDME_DOWN
Definition: JetQGTagger.h:31
TRT_PAI_gasdata::SF
const float SF[NF]
Cross sections for Fluor.
Definition: TRT_PAI_gasdata.h:285
CP::SystematicSet
Class to wrap a set of SystematicVariations.
Definition: SystematicSet.h:31
InDet::IInDetTrackTruthFilterTool::accept
virtual bool accept(const xAOD::TrackParticle *track) const =0
CP::SystematicsTool::affectingSystematics
virtual SystematicSet affectingSystematics() const
returns: the list of all systematics this tool can be affected by guarantee: strong failures: out of ...
Definition: SystematicsTool.cxx:40
LargeRJetTruthLabel::other_From_t
@ other_From_t
Definition: LargeRJetLabelEnum.h:22
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
CP::JetQGTagger::m_tagger_decoration_name
std::string m_tagger_decoration_name
Definition: JetQGTagger.h:100
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
JSSTaggerBase::m_readTau2WTAKey
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readTau2WTAKey
Definition: JSSTaggerBase.h:154
CP::JetQGTagger::m_qgDecWeightKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_qgDecWeightKey
Definition: JetQGTagger.h:120
CP::SystematicSet::name
std::string name() const
returns: the systematics joined into a single string.
Definition: SystematicSet.cxx:278
CP::JetQGTagger::simplegetNTrackWeight
StatusCode simplegetNTrackWeight(const xAOD::Jet *jet, double &weight) const
Definition: JetQGTagger.cxx:363
JSSTaggerBase::m_jetPtMin
float m_jetPtMin
Kinematic bounds for the jet - the units are controlled by m_ptGeV.
Definition: JSSTaggerBase.h:132
CP::JetQGTagger::m_trackeff_hquark
TH2D * m_trackeff_hquark
Definition: JetQGTagger.h:85
CP::JetQGTagger::m_mode
int m_mode
Definition: JetQGTagger.h:106
JSSTaggerBase::m_decL3Key
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decL3Key
Definition: JSSTaggerBase.h:150
ANA_CHECK
#define ANA_CHECK(EXP)
check whether the given expression was successful
Definition: Control/AthToolSupport/AsgMessaging/AsgMessaging/MessageCheck.h:324
CP::SystematicsTool::m_affectingSystematics
SystematicSet m_affectingSystematics
description: members directly corresponding to accessors
Definition: SystematicsTool.h:146
SG::ConstAccessor
Helper class to provide constant type-safe access to aux data.
Definition: ConstAccessor.h:54
CP::JetQGTagger::m_pdf_hgluon_up
TH2D * m_pdf_hgluon_up
Definition: JetQGTagger.h:82
CP::SystematicsTool::applySystematicVariation
virtual StatusCode applySystematicVariation(const SystematicSet &systConfig)
effects: configure this tool for the given list of systematic variations.
Definition: SystematicsTool.cxx:74
JSSTaggerBase::m_decC2Key
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decC2Key
Definition: JSSTaggerBase.h:146
JSSTaggerBase::m_decorationName
std::string m_decorationName
Decoration name.
Definition: JSSTaggerBase.h:202
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
JSSTaggerBase::m_readECFG331Key
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readECFG331Key
Definition: JSSTaggerBase.h:181
LargeRJetTruthLabel::Zqq
@ Zqq
Definition: LargeRJetLabelEnum.h:20
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
isValid
bool isValid(const T &p)
Definition: AtlasPID.h:214
InDet::TRK_EFF_LOOSE_PP0
@ TRK_EFF_LOOSE_PP0
Definition: InDetTrackSystematics.h:35
InDet::IJetTrackFilterTool::accept
virtual bool accept(const xAOD::TrackParticle *, const xAOD::Jet *) const =0
ASG_MAKE_ANA_TOOL
#define ASG_MAKE_ANA_TOOL(handle, type)
create the tool in the given tool handle
Definition: AnaToolHandle.h:690
xAOD::IParticle
Class providing the definition of the 4-vector interface.
Definition: Event/xAOD/xAODBase/xAODBase/IParticle.h:40
yodamerge_tmp.scale
scale
Definition: yodamerge_tmp.py:138
asg::AnaToolHandle::setProperty
StatusCode setProperty(const std::string &property, const T2 &value)
set the given property of the tool.
LargeRJetTruthLabel::qcd
@ qcd
Definition: LargeRJetLabelEnum.h:25
python.DomainsRegistry.reg
reg
globals -----------------------------------------------------------------—
Definition: DomainsRegistry.py:343
JSSTaggerBase::m_decValidPtRangeHighKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decValidPtRangeHighKey
Definition: JSSTaggerBase.h:72
CP::JetQGTagger::m_exp_hgluon_down
TH2D * m_exp_hgluon_down
Definition: JetQGTagger.h:73
CP::JetQGTagger::loadHist
StatusCode loadHist(TH2D *&hist, const std::string &filename, const std::string &histname)
Definition: JetQGTagger.cxx:703
CP::JetQGTagger::m_fake_hgluon
TH2D * m_fake_hgluon
Definition: JetQGTagger.h:88
asg::AcceptInfo::getCutName
const std::string & getCutName(unsigned int cutPosition) const
Get the name of a cut, based on the cut position (slow, avoid usage)
Definition: AcceptInfo.cxx:36
JSSTaggerBase::m_jetPtMax
float m_jetPtMax
Definition: JSSTaggerBase.h:133
JSSTaggerBase::m_calibArea
std::string m_calibArea
Location where config files live on cvmfs.
Definition: JSSTaggerBase.h:114
JSSTaggerBase::m_decWeightKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decWeightKey
WriteDecorHandle keys for SF.
Definition: JSSTaggerBase.h:237
JSSTaggerBase::m_readTruthLabelKey
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readTruthLabelKey
Truth label ReadDecorHandle key.
Definition: JSSTaggerBase.h:228
LargeRJetTruthLabel::notruth
@ notruth
Definition: LargeRJetLabelEnum.h:24
CP::JetQGTagger::m_hquark
TH2D * m_hquark
Definition: JetQGTagger.h:65
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
JSSTaggerBase::m_decSigeffSFKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decSigeffSFKey
Definition: JSSTaggerBase.h:240
dqt_zlumi_pandas.weight
int weight
Definition: dqt_zlumi_pandas.py:200
CP::JetQGTagger::m_topo_hquark
TH2D * m_topo_hquark
Definition: JetQGTagger.h:68
CP::JetQGTagger::m_readNtrkKey
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readNtrkKey
Definition: JetQGTagger.h:116
CP::JetQGTagger::m_appliedSystEnum
QGSystApplied m_appliedSystEnum
Definition: JetQGTagger.h:63
JSSTaggerBase::m_decEfficiencyKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decEfficiencyKey
Definition: JSSTaggerBase.h:238
CP::JetQGTagger::m_intercept
double m_intercept
Definition: JetQGTagger.h:104
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
JSSTaggerBase::m_decE3Key
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decE3Key
Definition: JSSTaggerBase.h:148
JSSTaggerBase::m_ptGeV
bool m_ptGeV
Flag to indicate units pT is defined in Set to false by default.
Definition: JSSTaggerBase.h:90
efficiency
void efficiency(std::vector< double > &bins, std::vector< double > &values, const std::vector< std::string > &files, const std::string &histname, const std::string &tplotname, const std::string &label="")
Definition: dependence.cxx:128
JSSTaggerBase::m_decTau32WTAKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decTau32WTAKey
Definition: JSSTaggerBase.h:143
jet
Definition: JetCalibTools_PlotJESFactors.cxx:23
AthCommonDataStore
Definition: AthCommonDataStore.h:52
LargeRJetTruthLabel::Wqq
@ Wqq
Definition: LargeRJetLabelEnum.h:17
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
PixelAthClusterMonAlgCfg.histname
histname
Definition: PixelAthClusterMonAlgCfg.py:106
CheckAppliedSFs.e3
e3
Definition: CheckAppliedSFs.py:264
SG::ReadDecorHandle
Handle class for reading a decoration on an object.
Definition: StoreGate/StoreGate/ReadDecorHandle.h:94
CP::SystematicsTool::recommendedSystematics
virtual SystematicSet recommendedSystematics() const
returns: the list of all systematics this tool can be affected by guarantee: strong failures: out of ...
Definition: SystematicsTool.cxx:47
JSSTaggerBase::getSF
std::pair< double, double > getSF(const xAOD::Jet &jet, const std::string &truthLabelStr) const
Get scale factor and efficiency.
Definition: JSSTaggerBase.cxx:670
CP::SystematicsTool::isAffectedBySystematic
virtual bool isAffectedBySystematic(const SystematicVariation &systematic) const
returns: whether this tool is affected by the given systematic guarantee: no-fail
Definition: SystematicsTool.cxx:32
HepMC::is_simulation_particle
bool is_simulation_particle(const T &p)
Method to establish if a particle (or barcode) was created during the simulation (TODO update to be s...
Definition: MagicNumbers.h:299
lumiFormat.i
int i
Definition: lumiFormat.py:92
CP::JetQGTagger::m_trkFakeTool
asg::AnaToolHandle< InDet::IInDetTrackTruthFilterTool > m_trkFakeTool
Definition: JetQGTagger.h:110
InDet::TrackSystematicMap
static const std::unordered_map< InDet::TrackSystematic, CP::SystematicVariation, std::hash< int > > TrackSystematicMap
Definition: InDetTrackSystematics.h:56
CP::JetQGTagger::getNTrack
StatusCode getNTrack(const xAOD::Jet *jet, int &ntracks) const
Definition: JetQGTagger.cxx:462
Trk::L3
@ L3
Definition: AlignModuleList.h:32
CP::JetQGTagger::m_pdf_hgluon_down
TH2D * m_pdf_hgluon_down
Definition: JetQGTagger.h:83
JSSTaggerBase::m_readECFG212Key
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readECFG212Key
Definition: JSSTaggerBase.h:183
InDet::TRK_EFF_LOOSE_PHYSMODEL
@ TRK_EFF_LOOSE_PHYSMODEL
Definition: InDetTrackSystematics.h:36
CP::SystematicsTool::addRecommendedSystematic
StatusCode addRecommendedSystematic(const SystematicVariation &systematic)
effects: add a systematic to the list of recommended systematics failures: unsupported systematic
Definition: SystematicsTool.cxx:128
asg::AcceptInfo::getNCuts
unsigned int getNCuts() const
Get the number of cuts defined.
Definition: AcceptInfo.h:46
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
xAOD::TruthParticle_v1
Class describing a truth particle in the MC record.
Definition: TruthParticle_v1.h:41
JSSTaggerBase::checkKinRange
StatusCode checkKinRange(const xAOD::Jet &jet, asg::AcceptData &acceptData) const
Check and record if jet passes kinematic constraints.
Definition: JSSTaggerBase.cxx:370
SG::WriteDecorHandle
Handle class for adding a decoration to an object.
Definition: StoreGate/StoreGate/WriteDecorHandle.h:99
CP::QG_NCHARGEDPDF_DOWN
@ QG_NCHARGEDPDF_DOWN
Definition: JetQGTagger.h:32
CP::QG_NCHARGEDME_UP
@ QG_NCHARGEDME_UP
Definition: JetQGTagger.h:28
xAOD::VxType::PriVtx
@ PriVtx
Primary vertex.
Definition: TrackingPrimitives.h:571
JSSTaggerBase::Unknown
@ Unknown
Definition: JSSTaggerBase.h:99
JSSTaggerBase::m_readL3Key
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readL3Key
Definition: JSSTaggerBase.h:179
JSSTaggerBase::m_efficiencyHistogramName
std::string m_efficiencyHistogramName
Definition: JSSTaggerBase.h:212
CP::JetQGTagger::m_trkSelectionTool
asg::AnaToolHandle< InDet::IInDetTrackSelectionTool > m_trkSelectionTool
Definition: JetQGTagger.h:108
JSSTaggerBase::m_decTau42WTAKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decTau42WTAKey
Definition: JSSTaggerBase.h:144
CP::JetQGTagger::m_cuttype
std::string m_cuttype
Definition: JetQGTagger.h:105
python.xAODType.dummy
dummy
Definition: xAODType.py:4
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
MSG::name
const std::string & name(Level lvl)
Convenience function for translating message levels to strings.
Definition: MsgLevel.cxx:19
JSSTaggerBase::m_decEffSFKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decEffSFKey
Definition: JSSTaggerBase.h:239
CP::JetQGTagger::m_trkTruthFilterTool
asg::AnaToolHandle< InDet::IInDetTrackTruthFilterTool > m_trkTruthFilterTool
Definition: JetQGTagger.h:109
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
JSSTaggerBase::m_decNtrk500Key
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decNtrk500Key
Definition: JSSTaggerBase.h:186
JSSTaggerBase::m_calcSF
bool m_calcSF
Flag to calculate scale factor.
Definition: JSSTaggerBase.h:205
TH2D
Definition: rootspy.cxx:430
JSSTaggerBase::m_decValidEventContentKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decValidEventContentKey
Definition: JSSTaggerBase.h:77
CP::JetQGTagger::m_fakefile
std::string m_fakefile
Definition: JetQGTagger.h:98
CP::JetQGTagger::m_topofile
std::string m_topofile
Definition: JetQGTagger.h:93
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
CP::QG_NCHARGEDEXP_DOWN
@ QG_NCHARGEDEXP_DOWN
Definition: JetQGTagger.h:30
CP::QG_NCHARGEDPDF_UP
@ QG_NCHARGEDPDF_UP
Definition: JetQGTagger.h:29
CP::JetQGTagger::m_slope
double m_slope
Definition: JetQGTagger.h:103
xAOD::Jet_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
Definition: Jet_v1.cxx:49
CxxUtils::set
constexpr std::enable_if_t< is_bitmask_v< E >, E & > set(E &lhs, E rhs)
Convenience function to set bits in a class enum bitmask.
Definition: bitmask.h:224
InDet::JetTrackFilterTool
Definition: JetTrackFilterTool.h:37
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
JSSTaggerBase::m_decD2Key
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decD2Key
Definition: JSSTaggerBase.h:147
InDet::IInDetTrackTruthFilterTool::applySystematicVariation
virtual StatusCode applySystematicVariation(const CP::SystematicSet &)=0
configure the tool to apply a given list of systematic variations
CP::QG_TRACKEFFICIENCY
@ QG_TRACKEFFICIENCY
Definition: JetQGTagger.h:24
LargeRJetTruthLabel::Wqq_From_t
@ Wqq_From_t
Definition: LargeRJetLabelEnum.h:21
CheckAppliedSFs.systematics
def systematics
Definition: CheckAppliedSFs.py:231
CP::JetQGTagger::m_weight_decoration_name
std::string m_weight_decoration_name
Definition: JetQGTagger.h:99
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
CP::SystematicSet::insert
void insert(const SystematicVariation &systematic)
description: insert a systematic into the set
Definition: SystematicSet.cxx:88
InDet::TRK_EFF_LOOSE_IBL
@ TRK_EFF_LOOSE_IBL
Definition: InDetTrackSystematics.h:34
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
JSSTaggerBase::initialize
virtual StatusCode initialize() override
Initialize the tool.
Definition: JSSTaggerBase.cxx:73
JSSTaggerBase::m_acceptInfo
asg::AcceptInfo m_acceptInfo
Object that stores the results for a jet.
Definition: JSSTaggerBase.h:65
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
JSSTaggerBase::m_decTau21WTAKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decTau21WTAKey
WriteDecorHandle keys for JSS moments.
Definition: JSSTaggerBase.h:142
CP::JetQGTagger::m_originTool
asg::AnaToolHandle< InDet::IInDetTrackTruthOriginTool > m_originTool
Definition: JetQGTagger.h:112
CP::JetQGTagger::tag
virtual StatusCode tag(const xAOD::Jet &jet, const xAOD::Vertex *pv) const override
Definition: JetQGTagger.cxx:244
CP::QG_NONE
@ QG_NONE
Definition: JetQGTagger.h:23
InDet::IInDetTrackSelectionTool::accept
virtual asg::AcceptData accept(const xAOD::IParticle *p) const =0
Get the decision using a generic IParticle pointer.
CP::JetQGTagger::m_me_hquark_up
TH2D * m_me_hquark_up
Definition: JetQGTagger.h:75
xAOD::Jet_v1::rawConstituent
const IParticle * rawConstituent(size_t i) const
Direct access to constituents. WARNING expert use only.
Definition: Jet_v1.cxx:158
InDet::InDetTrackTruthFilterTool
Definition: InDetTrackTruthFilterTool.h:36
CP::JetQGTagger::m_me_hgluon_up
TH2D * m_me_hgluon_up
Definition: JetQGTagger.h:77
CP::JetQGTagger::m_readNumTrkPt500PVKey
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readNumTrkPt500PVKey
ReadDecorHandle keys.
Definition: JetQGTagger.h:115
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:431
JSSTaggerBase::printCuts
void printCuts() const
Print configured cuts.
Definition: JSSTaggerBase.cxx:817
JSSTaggerBase::m_isMC
bool m_isMC
Definition: JSSTaggerBase.h:206
python.AthDsoLogger.fname
string fname
Definition: AthDsoLogger.py:67
JSSTaggerBase::WBoson
@ WBoson
Definition: JSSTaggerBase.h:99
xAOD::Jet_v1
Class describing a jet.
Definition: Jet_v1.h:57
JSSTaggerBase::m_decValidKinRangeKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decValidKinRangeKey
Definition: JSSTaggerBase.h:75
InDet::TRK_FAKE_RATE_LOOSE
@ TRK_FAKE_RATE_LOOSE
Definition: InDetTrackSystematics.h:29
JSSTaggerBase::m_readTau1WTAKey
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readTau1WTAKey
ReadDecorHandle keys for JSS moments.
Definition: JSSTaggerBase.h:153
MC::isStable
bool isStable(const T &p)
Definition: HepMCHelpers.h:30
JSSTaggerBase::m_weightHistograms
std::map< std::string, std::unique_ptr< TH2D > > m_weightHistograms
Definition: JSSTaggerBase.h:217
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
a
TList * a
Definition: liststreamerinfos.cxx:10
asg::AcceptData::setCutResult
void setCutResult(const std::string &cutName, bool cutResult)
Set the result of a cut, based on the cut name (safer)
Definition: AcceptData.h:134
h
IJetDecorator::decorate
virtual StatusCode decorate(const xAOD::JetContainer &jets) const =0
Decorate a jet collection without otherwise modifying it.
JSSTaggerBase::passKinRange
bool passKinRange(const xAOD::Jet &jet) const
Check if jet passes kinematic constraints.
Definition: JSSTaggerBase.cxx:356
asg::AcceptData::clear
void clear()
Clear all bits.
Definition: AcceptData.h:54
asg::AcceptData::getCutResult
bool getCutResult(const std::string &cutName) const
Get the result of a cut, based on the cut name (safer)
Definition: AcceptData.h:98
InDet::TRK_EFF_LOOSE_TIDE
@ TRK_EFF_LOOSE_TIDE
Definition: InDetTrackSystematics.h:46
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
JSSTaggerBase::m_decValidPtRangeLowKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decValidPtRangeLowKey
Definition: JSSTaggerBase.h:73
CP::SystematicsTool::m_recommendedSystematics
SystematicSet m_recommendedSystematics
Definition: SystematicsTool.h:147
JSSTaggerBase::m_readTau3WTAKey
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readTau3WTAKey
Definition: JSSTaggerBase.h:155
JSSTaggerBase::m_readECF2Key
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readECF2Key
Definition: JSSTaggerBase.h:163
JSSTaggerBase::m_readECF3Key
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readECF3Key
Definition: JSSTaggerBase.h:164
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
JSSTaggerBase::getConfigReader
StatusCode getConfigReader()
Get configReader StatusCode.
Definition: JSSTaggerBase.cxx:300
LargeRJetTruthLabel::intToEnum
TypeEnum intToEnum(const int type)
Definition: LargeRJetLabelEnum.h:57
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
python.changerun.pv
pv
Definition: changerun.py:81
CP::SystematicsTool::addAffectingSystematic
StatusCode addAffectingSystematic(const SystematicVariation &systematic, bool recommended)
effects: add a systematic to the list of registered systematics.
Definition: SystematicsTool.cxx:112
InDet::InDetTrackSelectionTool
Implementation of the track selector tool.
Definition: InDetTrackSelectionTool.h:51
CaloCellTimeCorrFiller.filename
filename
Definition: CaloCellTimeCorrFiller.py:24
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
CP::JetQGTagger::m_exp_hgluon_up
TH2D * m_exp_hgluon_up
Definition: JetQGTagger.h:72
JSSTaggerBase::JSSTaggerBase
JSSTaggerBase(const std::string &name)
Default constructor - to be used in all derived classes.
Definition: JSSTaggerBase.cxx:11
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
defineDB.jets
list jets
Definition: JetTagCalibration/share/defineDB.py:24
dqt_zlumi_alleff_HIST.eff
int eff
Definition: dqt_zlumi_alleff_HIST.py:113
CP::JetQGTagger::m_pdffile
std::string m_pdffile
Definition: JetQGTagger.h:96
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
LargeRJetTruthLabel::tqqb
@ tqqb
Definition: LargeRJetLabelEnum.h:16
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
JSSTaggerBase::m_decL2Key
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decL2Key
Definition: JSSTaggerBase.h:149
JSSTaggerBase::m_weightFlavors
std::string m_weightFlavors
Definition: JSSTaggerBase.h:213
CP::JetQGTagger::getNTrackWeight
StatusCode getNTrackWeight(const xAOD::Jet *jet, double &weight) const
Definition: JetQGTagger.cxx:525
xAOD::Jet_v1::numConstituents
size_t numConstituents() const
Number of constituents in this jets (this is valid even when reading a file where the constituents ha...
Definition: Jet_v1.cxx:153
asg::AcceptData
Definition: AcceptData.h:30
xAOD::JetAttribute::GhostTrack
@ GhostTrack
Definition: JetAttributes.h:252
SG::DataProxy
Definition: DataProxy.h:44
xAOD::Jet_v1::pt
virtual double pt() const
The transverse momentum ( ) of the particle.
Definition: Jet_v1.cxx:44
JSSTaggerBase::m_readL2Key
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readL2Key
Definition: JSSTaggerBase.h:178
RCU_READ_INVARIANT
#define RCU_READ_INVARIANT(x)
Definition: Assert.h:229
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
InDet::TRK_EFF_LOOSE_GLOBAL
@ TRK_EFF_LOOSE_GLOBAL
Definition: InDetTrackSystematics.h:33
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
CP::JetQGTagger::m_exp_hquark_down
TH2D * m_exp_hquark_down
Definition: JetQGTagger.h:71
checkFileSG.ind
list ind
Definition: checkFileSG.py:118
fitman.k
k
Definition: fitman.py:528
asg::AcceptInfo::getCutDescription
const std::string & getCutDescription(const std::string &cutName) const
Get the description of a cut, based on the cut name.
Definition: AcceptInfo.cxx:119
CP::JetQGTagger::m_hgluon
TH2D * m_hgluon
Definition: JetQGTagger.h:66
CP::SystematicRegistry::getInstance
static SystematicRegistry & getInstance()
Get the singleton instance of the registry for the curren thread.
Definition: SystematicRegistry.cxx:25
JSSTaggerBase::m_decTaggedKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decTaggedKey
WriteDecorHandle keys for tagging bools.
Definition: JSSTaggerBase.h:71
asg::AcceptInfo::addCut
int addCut(const std::string &cutName, const std::string &cutDescription)
Add a cut; returning the cut position.
Definition: AcceptInfo.h:53
JSSTaggerBase::m_containerName
std::string m_containerName
Configurable members.
Definition: JSSTaggerBase.h:105
CP::JetQGTagger::m_jetTrackFilterTool
asg::AnaToolHandle< InDet::IJetTrackFilterTool > m_jetTrackFilterTool
Definition: JetQGTagger.h:111
CP::JetQGTagger::m_mefile
std::string m_mefile
Definition: JetQGTagger.h:95
CP::JetQGTagger::m_taggername
std::string m_taggername
Definition: JetQGTagger.h:92
Generated on Fri Jun 28 2024 22:13:57 for ATLAS Offline Software by   doxygen 1.8.18