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

#include <JSSTaggerUtils.h>

Inheritance diagram for JSSTaggerUtils:
Collaboration diagram for JSSTaggerUtils:

Public Member Functions

 JSSTaggerUtils (const std::string &name)
 Constructor. More...
 
virtual StatusCode initialize () override
 Run once at the start of the job to setup everything. More...
 
virtual StatusCode tag (const xAOD::Jet &jet) const override
 IJetSelectorTool interface. More...
 
TH2D MakeJetImage (TString TagImage, const xAOD::Jet *jet, std::vector< xAOD::JetConstituent > constituents) const override
 
StatusCode GetImageScore (const xAOD::JetContainer &jets) const override
 
StatusCode GetConstScore (const xAOD::JetContainer &jets) const override
 
StatusCode GetQGConstScore (const xAOD::JetContainer &jets) const override
 
StatusCode GetTopConstScore (const xAOD::JetContainer &jets) const override
 
StatusCode GetHLScore (const xAOD::JetContainer &jets) const override
 
std::map< std::string, double > GetJSSVars (const xAOD::Jet &jet) const override
 
StatusCode ReadScaler () override
 
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, V, H > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 
virtual StatusCode modify (xAOD::JetContainer &jets) const override final
 Concrete implementation of the function inherited from IJetModifier. More...
 

Public Attributes

std::map< std::string, std::vector< double > > m_scaler
 

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...
 
void decorateJSSRatios (const xAOD::JetContainer &jets) const
 
int findPV () const
 Find the PV (to be used for Ntrk) More...
 
int 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...
 

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::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"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readNtrk500Key {this, "Ntrk500Name", "ParentJetNTrkPt500", "SG key for Ntrk500 from ungroomed jet"}
 
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 {Unknown}
 
std::string m_containerName
 Configurable members. More...
 
bool m_isSmallRJet = false
 
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_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_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_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"}
 
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"}
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

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

Private Attributes

int m_nbins_eta {}
 
int m_nbins_phi {}
 
double m_min_eta {}
 
double m_max_eta {}
 
double m_min_phi {}
 
double m_max_phi {}
 
int m_ncolors {}
 
bool m_dorscaling {}
 
double m_rscaling_p0 {}
 
double m_rscaling_p1 {}
 
bool m_UseConstTagger {}
 
ToolHandle< AthONNX::IJSSMLTool > m_MLBosonTagger {"", this}
 
bool m_UseHLTagger {}
 
ToolHandle< AthONNX::IJSSMLTool > m_MLBosonTagger_HL {"", this}
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decNConstituentsKey {this, "nConstituentsName", "nConstituents", "SG key for constituents multiplicity"}
 WriteDecorHandle keys. More...
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decNTopoTowersKey {this, "nTopoTowersName", "nTopoTowers", "SG key for towers multiplicity"}
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decConstScoreKey {this, "ConstScoreNameDec", "ConstScore", "SG key for ConstScore"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readConstScoreKey {this, "ConstScoreNameRead", "ConstScore", "SG key for ConstScore"}
 
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decHLScoreKey {this, "HLScoreName", "HLScore", "SG key for HLScore"}
 
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
 

Detailed Description

Definition at line 14 of file JSSTaggerUtils.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 98 of file JSSTaggerBase.h.

98 {Unknown, WBoson, ZBoson, TopQuark};

Constructor & Destructor Documentation

◆ JSSTaggerUtils()

JSSTaggerUtils::JSSTaggerUtils ( const std::string &  name)

Constructor.

Definition at line 35 of file JSSTaggerUtils.cxx.

35  :
36  JSSTaggerBase( name )
37 {
38  declareProperty("MLBosonTagger", m_MLBosonTagger, "Tool to manage the data pre-processing and inference of the Const model");
39  declareProperty("MLBosonTaggerHL", m_MLBosonTagger_HL, "Tool to manage the data pre-processing and inference of the High-Level model");
40  declareProperty("nPixelsEta", m_nbins_eta);
41  declareProperty("nPixelsPhi", m_nbins_phi);
42  declareProperty("nColors", m_ncolors);
43  declareProperty("MinEtaRange", m_min_eta);
44  declareProperty("MaxEtaRange", m_max_eta);
45  declareProperty("MinPhiRange", m_min_phi);
46  declareProperty("MaxPhiRange", m_max_phi);
47  declareProperty("DoRScaling", m_dorscaling);
48  declareProperty("RScaling_p0", m_rscaling_p0);
49  declareProperty("RScaling_p1", m_rscaling_p1);
50 }

Member Function Documentation

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

398  {
399 
400  int result = 0;
401 
403  SG::WriteDecorHandle<xAOD::JetContainer, float> decTau21WTA(m_decTau21WTAKey);
404  SG::WriteDecorHandle<xAOD::JetContainer, float> decTau32WTA(m_decTau32WTAKey);
405  SG::WriteDecorHandle<xAOD::JetContainer, float> decTau42WTA(m_decTau42WTAKey);
406  SG::WriteDecorHandle<xAOD::JetContainer, float> decC2(m_decC2Key);
407  SG::WriteDecorHandle<xAOD::JetContainer, float> decD2(m_decD2Key);
408  SG::WriteDecorHandle<xAOD::JetContainer, float> decE3(m_decE3Key);
409  SG::WriteDecorHandle<xAOD::JetContainer, float> decL2(m_decL2Key);
410  SG::WriteDecorHandle<xAOD::JetContainer, float> decL3(m_decL3Key);
411 
413  SG::ReadDecorHandle<xAOD::JetContainer, float> readTau1WTA(m_readTau1WTAKey);
414  SG::ReadDecorHandle<xAOD::JetContainer, float> readTau2WTA(m_readTau2WTAKey);
415  SG::ReadDecorHandle<xAOD::JetContainer, float> readTau3WTA(m_readTau3WTAKey);
416  SG::ReadDecorHandle<xAOD::JetContainer, float> readTau4WTA(m_readTau4WTAKey);
417 
418  SG::ReadDecorHandle<xAOD::JetContainer, float> readECF1(m_readECF1Key);
419  SG::ReadDecorHandle<xAOD::JetContainer, float> readECF2(m_readECF2Key);
420  SG::ReadDecorHandle<xAOD::JetContainer, float> readECF3(m_readECF3Key);
421 
422 
424  float tau21_wta = -999.0;
425  float tau32_wta = -999.0;
426  float tau42_wta = -999.0;
427 
428  float tau1_wta = readTau1WTA(jet);
429  float tau2_wta = readTau2WTA(jet);
430  float tau3_wta = readTau3WTA(jet);
431  float tau4_wta = -999.0;
432  if(readTau4WTA.isAvailable()){
433  tau4_wta = readTau4WTA(jet);
434  }
435 
436  if ( tau1_wta > 1e-8 ) {
437  tau21_wta = tau2_wta / tau1_wta;
438  }
439  else result = 1;
440 
441  if ( tau2_wta > 1e-8 ) {
442  tau32_wta = tau3_wta / tau2_wta;
443  if(readTau4WTA.isAvailable()){
444  tau42_wta = tau4_wta / tau2_wta;
445  }
446  }
447  else result = 1;
448 
449  decTau21WTA(jet) = tau21_wta;
450  decTau32WTA(jet) = tau32_wta;
451  decTau42WTA(jet) = tau42_wta;
452 
454  float C2 = -999.0;
455  float D2 = -999.0;
456  float e3 = -999.0;
457 
458  float ECF1 = readECF1(jet);
459  float ECF2 = readECF2(jet);
460  float ECF3 = readECF3(jet);
461 
462  if ( ECF2 > 1e-8 ) {
463  C2 = ECF3 * ECF1 / std::pow( ECF2, 2.0 );
464  D2 = ECF3 * std::pow( ECF1, 3.0 ) / std::pow( ECF2, 3.0 );
465  }
466  else result = 1;
467 
468  e3 = ECF3 / std::pow( ECF1, 3.0 );
469 
470  decC2(jet) = C2;
471  decD2(jet) = D2;
472  decE3(jet) = e3;
473 
474  // L-series for UFO top taggers
475  float L2 = -999.0;
476  float L3 = -999.0;
477 
478  if(!m_isSmallRJet){
479  SG::ReadDecorHandle<xAOD::JetContainer, float> readECFG331(m_readECFG331Key);
480  SG::ReadDecorHandle<xAOD::JetContainer, float> readECFG311(m_readECFG311Key);
481  SG::ReadDecorHandle<xAOD::JetContainer, float> readECFG212(m_readECFG212Key);
482 
483  if(readECFG331.isAvailable() && readECFG212.isAvailable()){
484  if(readECFG212(jet) > 1e-8){
485  L2 = readECFG331(jet) / std::pow(readECFG212(jet), 1.5);
486  }
487  else result = 1;
488  }
489 
490  if(readECFG331.isAvailable() && readECFG311.isAvailable()){
491  if(readECFG331(jet) > 1e-8){
492  L3 = readECFG311(jet) / std::pow(readECFG331(jet), 1./3.);
493  }
494  else result = 1;
495  }
496  }
497 
498  static const SG::AuxElement::ConstAccessor<float> accL2("L2");
499  if(!accL2.isAvailable(jet)) decL2(jet) = L2;
500 
501  static const SG::AuxElement::ConstAccessor<float> accL3("L3");
502  if(!accL3.isAvailable(jet)) decL3(jet) = L3;
503 
504  // TODO: Add ECFG for ANN tagger whenever it is defined
505 
506  return result;
507 
508 }

◆ 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 352 of file JSSTaggerBase.cxx.

352  {
353 
354  float scale = 1.0;
355  if ( m_ptGeV ) scale = 1.e3;
356 
357  bool passKinRange = true;
358 
361  if ( std::abs(jet.eta()) > m_jetEtaMax ) {
362  ATH_MSG_VERBOSE( "Jet does not pass basic kinematic selection (|eta| < " << m_jetEtaMax << "). Jet eta = " << jet.eta() );
363  acceptData.setCutResult( "ValidEtaRange", false );
364  passKinRange = false;
365  }
366 
367  if ( jet.pt() < m_jetPtMin * scale ) {
368  ATH_MSG_VERBOSE( "Jet does not pass basic kinematic selection (pT > " << m_jetPtMin * scale / 1.e3 << "). Jet pT = " << jet.pt() / 1.e3 << " GeV" );
369  acceptData.setCutResult( "ValidPtRangeLow", false );
370  passKinRange = false;
371  }
372 
373  if ( jet.pt() > m_jetPtMax * scale ) {
374  ATH_MSG_VERBOSE( "Jet does not pass basic kinematic selection (pT < " << m_jetPtMax * scale / 1.e3 << "). Jet pT = " << jet.pt() / 1.e3 << " GeV" );
375  acceptData.setCutResult( "ValidPtRangeHigh", false );
376  passKinRange = false;
377  }
378 
380  SG::WriteDecorHandle<xAOD::JetContainer, bool> decValidPtRangeHigh(m_decValidPtRangeHighKey);
381  SG::WriteDecorHandle<xAOD::JetContainer, bool> decValidPtRangeLow(m_decValidPtRangeLowKey);
382  SG::WriteDecorHandle<xAOD::JetContainer, bool> decValidEtaRange(m_decValidEtaRangeKey);
383  SG::WriteDecorHandle<xAOD::JetContainer, bool> decValidKinRange(m_decValidKinRangeKey);
384 
386  decValidPtRangeHigh(jet) = acceptData.getCutResult( "ValidPtRangeHigh" );
387  decValidPtRangeLow(jet) = acceptData.getCutResult( "ValidPtRangeLow" );
388  decValidEtaRange(jet) = acceptData.getCutResult( "ValidEtaRange" );
389  decValidKinRange(jet) = passKinRange;
390 
391  return StatusCode::SUCCESS;
392 
393 }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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, V, H > &  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, V, H > &  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, V, H > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

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

Definition at line 199 of file AthCommonDataStore.h.

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, V, H > &  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, and JSSWTopTaggerDNN.

Definition at line 270 of file JSSTaggerBase.cxx.

270  {
271 
272  for ( const auto *jet : jets ) {
273  ATH_CHECK( tag(*jet) );
274  }
275 
276  return StatusCode::SUCCESS;
277 
278 }

◆ decorateJSSRatios()

void JSSTaggerBase::decorateJSSRatios ( const xAOD::JetContainer &  jets) const
protectedinherited

Create write decor handles

Create read decor handles

WTA N-subjettiness ratios

ECF ratios

Definition at line 511 of file JSSTaggerBase.cxx.

511  {
512 
514  SG::WriteDecorHandle<xAOD::JetContainer, float> decTau21WTA(m_decTau21WTAKey);
515  bool decor_available = decTau21WTA.isAvailable();
516  if(decor_available) return;
517 
518  SG::WriteDecorHandle<xAOD::JetContainer, float> decTau32WTA(m_decTau32WTAKey);
519  SG::WriteDecorHandle<xAOD::JetContainer, float> decTau42WTA(m_decTau42WTAKey);
520  SG::WriteDecorHandle<xAOD::JetContainer, float> decC2(m_decC2Key);
521  SG::WriteDecorHandle<xAOD::JetContainer, float> decD2(m_decD2Key);
522  SG::WriteDecorHandle<xAOD::JetContainer, float> decE3(m_decE3Key);
523  SG::WriteDecorHandle<xAOD::JetContainer, float> decL2(m_decL2Key);
524  SG::WriteDecorHandle<xAOD::JetContainer, float> decL3(m_decL3Key);
525 
527  SG::ReadDecorHandle<xAOD::JetContainer, float> readTau1WTA(m_readTau1WTAKey);
528  SG::ReadDecorHandle<xAOD::JetContainer, float> readTau2WTA(m_readTau2WTAKey);
529  SG::ReadDecorHandle<xAOD::JetContainer, float> readTau3WTA(m_readTau3WTAKey);
530  SG::ReadDecorHandle<xAOD::JetContainer, float> readTau4WTA(m_readTau4WTAKey);
531 
532  SG::ReadDecorHandle<xAOD::JetContainer, float> readECF1(m_readECF1Key);
533  SG::ReadDecorHandle<xAOD::JetContainer, float> readECF2(m_readECF2Key);
534  SG::ReadDecorHandle<xAOD::JetContainer, float> readECF3(m_readECF3Key);
535 
536  // Use pointers here so we can create only the ones we're configured for
537  std::unique_ptr<SG::ReadDecorHandle<xAOD::JetContainer, float>> readECFG331;
538  std::unique_ptr<SG::ReadDecorHandle<xAOD::JetContainer, float>> readECFG311;
539  std::unique_ptr<SG::ReadDecorHandle<xAOD::JetContainer, float>> readECFG212;
540  if(!m_isSmallRJet){
541  readECFG331 = std::make_unique<SG::ReadDecorHandle<xAOD::JetContainer, float> >(m_readECFG331Key);
542  readECFG311 = std::make_unique<SG::ReadDecorHandle<xAOD::JetContainer, float> >(m_readECFG311Key);
543  readECFG212 = std::make_unique<SG::ReadDecorHandle<xAOD::JetContainer, float> >(m_readECFG212Key);
544  }
545 
546  for(const xAOD::Jet* jet : jets){
547 
549  float tau21_wta = -999.0;
550  float tau32_wta = -999.0;
551  float tau42_wta = -999.0;
552 
553  float tau1_wta = readTau1WTA(*jet);
554  float tau2_wta = readTau2WTA(*jet);
555  float tau3_wta = readTau3WTA(*jet);
556  float tau4_wta = -999.0;
557  if(readTau4WTA.isAvailable()){
558  tau4_wta = readTau4WTA(*jet);
559  }
560 
561  if ( tau1_wta > 1e-8 ) {
562  tau21_wta = tau2_wta / tau1_wta;
563  }
564 
565  if ( tau2_wta > 1e-8 ) {
566  tau32_wta = tau3_wta / tau2_wta;
567  if(readTau4WTA.isAvailable()){
568  tau42_wta = tau4_wta / tau2_wta;
569  }
570  }
571 
572  decTau21WTA(*jet) = tau21_wta;
573  decTau32WTA(*jet) = tau32_wta;
574  decTau42WTA(*jet) = tau42_wta;
575 
577  float C2 = -999.0;
578  float D2 = -999.0;
579  float e3 = -999.0;
580 
581  float ECF1 = readECF1(*jet);
582  float ECF2 = readECF2(*jet);
583  float ECF3 = readECF3(*jet);
584 
585  if ( ECF2 > 1e-8 ) {
586  C2 = ECF3 * ECF1 / std::pow( ECF2, 2.0 );
587  D2 = ECF3 * std::pow( ECF1, 3.0 ) / std::pow( ECF2, 3.0 );
588  }
589 
590  e3 = ECF3 / std::pow( ECF1, 3.0 );
591 
592  decC2(*jet) = C2;
593  decD2(*jet) = D2;
594  decE3(*jet) = e3;
595 
596  // L-series for UFO top taggers
597  float L2 = -999.0;
598  float L3 = -999.0;
599 
600  if(!m_isSmallRJet){
601  if((*readECFG331).isAvailable() && (*readECFG212).isAvailable()){
602  if((*readECFG212)(*jet) > 1e-8){
603  L2 = (*readECFG331)(*jet) / std::pow((*readECFG212)(*jet), 1.5);
604  }
605  }
606 
607  if((*readECFG331).isAvailable() && (*readECFG311).isAvailable()){
608  if((*readECFG331)(*jet) > 1e-8){
609  L3 = (*readECFG311)(*jet) / std::pow((*readECFG331)(*jet), 1./3.);
610  }
611  }
612  }
613 
614  static const SG::AuxElement::ConstAccessor<float> accL2("L2");
615  if(!accL2.isAvailable(*jet)) decL2(*jet) = L2;
616 
617  static const SG::AuxElement::ConstAccessor<float> accL3("L3");
618  if(!accL3.isAvailable(*jet)) decL3(*jet) = L3;
619 
620  // TODO: Add ECFG for ANN tagger whenever it is defined
621 
622  }
623 
624  return;
625 
626 }

◆ 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 629 of file JSSTaggerBase.cxx.

629  {
630 
631  int indexPV = -1;
632 
633  const xAOD::VertexContainer* vxCont = nullptr;
634  if ( evtStore()->retrieve( vxCont, "PrimaryVertices" ).isFailure() ) {
635  ATH_MSG_WARNING( "Unable to retrieve primary vertex container PrimaryVertices" );
636  }
637  else {
638  int vtx_counter = 0;
639  for ( const auto *vx : *vxCont ) {
640  if ( vx->vertexType()==xAOD::VxType::PriVtx ) {
641  indexPV = vtx_counter;
642  break;
643  }
644  vtx_counter++;
645  }
646  }
647 
648  return indexPV;
649 
650 }

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

281  {
282 
283  ATH_MSG_INFO( "Using config file : " << m_configFile );
284 
286  std::string configPath;
287 
288  if ( m_calibArea.compare("Local") == 0 ) {
289  configPath = PathResolverFindCalibFile(m_configFile);
290  }
291  else if ( m_calibArea.find("eos") != std::string::npos) {
292  configPath = PathResolverFindCalibFile((m_calibArea+"/"+m_configFile).c_str());
293  configPath = (m_calibArea+"/"+m_configFile).c_str();
294  }
295  else {
296  configPath = PathResolverFindCalibFile(("BoostedJetTaggers/"+m_calibArea+"/"+m_configFile).c_str());
297  }
298 
300  FileStat_t fStats;
301  int fSuccess = gSystem->GetPathInfo(configPath.c_str(), fStats);
302  if ( fSuccess ) {
303  ATH_MSG_ERROR( "Recommendations file " << m_configFile << " could not be found" );
304  return StatusCode::FAILURE;
305  }
306  else {
307  ATH_MSG_DEBUG( "Recommendations file was found : " << configPath );
308  }
309 
310  if ( m_configReader.ReadFile( configPath.c_str(), EEnvLevel(0) ) ) {
311  ATH_MSG_ERROR( "Error while reading config file : "<< configPath );
312  return StatusCode::FAILURE;
313  }
314 
315  return StatusCode::SUCCESS;
316 
317 }

◆ GetConstScore()

StatusCode JSSTaggerUtils::GetConstScore ( const xAOD::JetContainer &  jets) const
overridevirtual

Implements IJSSTaggerUtils.

Definition at line 237 of file JSSTaggerUtils.cxx.

237  {
238 
239  SG::WriteDecorHandle<xAOD::JetContainer, float> decConstScore(m_decConstScoreKey);
240  SG::WriteDecorHandle<xAOD::JetContainer, float> decNConstituents(m_decNConstituentsKey);
241  SG::WriteDecorHandle<xAOD::JetContainer, float> decNTopoTowers(m_decNTopoTowersKey);
242 
243  for(const xAOD::Jet *jet : jets){
244 
245  // init value
246  float score (-99.);
247 
248  // get constituents
249  std::vector<xAOD::JetConstituent> constituents = jet -> getConstituents().asSTLVector();
250  std::sort( constituents.begin(), constituents.end(), DescendingPtSorterConstituents) ;
251 
252  int MaxConstituents (100);
253  std::vector<xAOD::JetConstituent> constituentsForModel;
254 
255  if( constituents.size() > 100 )
256  constituentsForModel = std::vector<xAOD::JetConstituent> (constituents.begin(), constituents.begin() + MaxConstituents);
257  else
258  constituentsForModel = constituents;
259 
260  // get towers
261  std::vector<const xAOD::CaloCluster*> towers;
262  SG::AuxElement::ConstAccessor<std::vector<ElementLink<DataVector<xAOD::IParticle>>>> towersAcc("GhostTower");
263  if (towersAcc.isAvailable(*jet)){
264  // Vector of towers linked to jets
265  std::vector<ElementLink<DataVector<xAOD::IParticle>>> towerLinks = towersAcc(*jet);
266  for (auto link_itr : towerLinks){
267  if (!link_itr.isValid()) continue;
268  towers.push_back(dynamic_cast<const xAOD::CaloCluster *>(*link_itr));
269  }
270  }
271  std::sort( towers.begin(), towers.end(), DescendingPtSorterConstituents);
272 
273  // use ML tool on constituents
274  std::vector<float> m, pT, eta, phi, E;
275  for(auto cnst : constituents){
276  m.push_back( cnst -> m() );
277  pT.push_back( cnst -> pt() );
278  eta.push_back( cnst -> eta() );
279  phi.push_back( cnst -> phi() );
280  E.push_back( cnst -> e() );
281  }
282  std::vector<std::vector<float>> constituents_packed = {m, pT, eta, phi};
283 
284  m.clear(); pT.clear(); eta.clear(); phi.clear();
285  for(auto cnst : towers){
286  m.push_back( cnst -> m() );
287  pT.push_back( cnst -> pt() );
288  eta.push_back( cnst -> eta() );
289  phi.push_back( cnst -> phi() );
290  E.push_back( cnst -> e() );
291  }
292  std::vector<std::vector<float>> towers_packed = {m, pT, eta, phi};
293 
294  // pack for the ML tool
295  std::vector<std::vector<float>> inputs_packed = {
296  constituents_packed.at(0), constituents_packed.at(1), constituents_packed.at(2), constituents_packed.at(3),
297  towers_packed.at(0), towers_packed.at(1), towers_packed.at(2), towers_packed.at(3),
298  };
299 
300  // evaluate the model
301  if( (constituents.size() + towers.size()) > 1 )
302  score = m_MLBosonTagger -> retrieveConstituentsScore(inputs_packed);
303 
304  // save decorator
305  decConstScore(*jet) = score;
306 
307  // and inputs as well
308  decNConstituents(*jet) = constituents.size();
309  decNTopoTowers(*jet) = towers.size();
310 
311  }
312 
313  return StatusCode::SUCCESS;
314 
315 }

◆ GetHLScore()

StatusCode JSSTaggerUtils::GetHLScore ( const xAOD::JetContainer &  jets) const
overridevirtual

Implements IJSSTaggerUtils.

Definition at line 458 of file JSSTaggerUtils.cxx.

458  {
459 
460  SG::WriteDecorHandle<xAOD::JetContainer, float> decHLScore(m_decHLScoreKey);
461 
462  // make available JSS variables
463  decorateJSSRatios(jets);
464 
465  for(const xAOD::Jet* jet : jets){
466 
467  // init value
468  float score (-99.);
469 
470  // get input variables
471  std::map<std::string, double> JSSVars = GetJSSVars(*jet);
472 
473  // evaluate the model
474  score = m_MLBosonTagger_HL -> retrieveHighLevelScore(JSSVars);
475 
476  // save decorator
477  decHLScore(*jet) = score;
478 
479  }
480 
481  return StatusCode::SUCCESS;
482 
483 }

◆ GetImageScore()

StatusCode JSSTaggerUtils::GetImageScore ( const xAOD::JetContainer &  jets) const
overridevirtual

Implements IJSSTaggerUtils.

Definition at line 171 of file JSSTaggerUtils.cxx.

171  {
172 
173  SG::WriteDecorHandle<xAOD::JetContainer, float> decConstScore(m_decConstScoreKey);
174 
175  for(const xAOD::Jet* jet : jets){
176 
177  // init value
178  float score (-99.);
179 
180  // preliminary actions for constituents
181  // add a dedicated function for this?
182 
183  // get constituents
184  std::vector<xAOD::JetConstituent> constituents = jet -> getConstituents().asSTLVector();
185  std::sort( constituents.begin(), constituents.end(), DescendingPtSorterConstituents) ;
186 
187  int MaxConstituents (100);
188  std::vector<xAOD::JetConstituent> constituentsForModel;
189 
190  if( constituents.size() > 100 )
191  constituentsForModel = std::vector<xAOD::JetConstituent> (constituents.begin(), constituents.begin() + MaxConstituents);
192  else
193  constituentsForModel = constituents;
194 
195  // constituents - charged
196  std::vector<xAOD::JetConstituent> csts_charged = constituentsForModel;
197  csts_charged.erase( std::remove_if( csts_charged.begin(), csts_charged.end(),
198  [] (xAOD::JetConstituent constituent) -> bool {
199  const xAOD::FlowElement* ufo = dynamic_cast<const xAOD::FlowElement*>(constituent.rawConstituent());
200  return ufo -> signalType() != xAOD::FlowElement::SignalType::Charged;
201  }), csts_charged.end()) ;
202 
203  // constituents - neutral
204  std::vector<xAOD::JetConstituent> csts_neutral = constituentsForModel;
205  csts_neutral.erase( std::remove_if( csts_neutral.begin(), csts_neutral.end(),
206  [] (xAOD::JetConstituent constituent) -> bool {
207  const xAOD::FlowElement* ufo = dynamic_cast<const xAOD::FlowElement*>(constituent.rawConstituent());
208  return ufo -> signalType() != xAOD::FlowElement::SignalType::Neutral;
209  }), csts_neutral.end()) ;
210 
211  // constituents - combined
212  std::vector<xAOD::JetConstituent> csts_combined = constituentsForModel;
213  csts_combined.erase( std::remove_if( csts_combined.begin(), csts_combined.end(),
214  [] (xAOD::JetConstituent constituent){
215  const xAOD::FlowElement* ufo = dynamic_cast<const xAOD::FlowElement*>(constituent.rawConstituent());
216  return ufo -> signalType() != xAOD::FlowElement::SignalType::Combined;
217  }), csts_combined.end()) ;
218 
219  // use ML tool on constituents
220  TH2D ImageCharged = MakeJetImage("Charged" , jet, csts_charged );
221  TH2D ImageNeutral = MakeJetImage("Neutral" , jet, csts_neutral );
222  TH2D ImageCombined = MakeJetImage("Combined", jet, csts_combined);
223 
224  std::vector<TH2D> Images = {ImageCharged, ImageNeutral, ImageCombined};
225 
226  // evaluate the model
227  score = m_MLBosonTagger -> retrieveConstituentsScore(Images);
228 
229  // save decorator
230  decConstScore(*jet) = score;
231  }
232 
233  return StatusCode::SUCCESS;
234 
235 }

◆ GetJSSVars()

std::map< std::string, double > JSSTaggerUtils::GetJSSVars ( const xAOD::Jet &  jet) const
overridevirtual

Implements IJSSTaggerUtils.

Definition at line 485 of file JSSTaggerUtils.cxx.

485  {
486 
487  std::map<std::string, double> JSSVars;
488 
489  // retrieve ungroomed tracks multiplicity
490  int nUngrTracks (-1);
491  SG::ReadDecorHandle<xAOD::JetContainer, int> readNtrk500(m_readNtrk500Key);
492  if(readNtrk500.isAvailable()){
493  nUngrTracks = readNtrk500(jet);
494  }
495  else{
496  int pv_location = findPV();
497  if(pv_location != -1)
498  nUngrTracks = GetUnGroomTracks(jet, pv_location);
499  }
500 
501  // store input variables
502  JSSVars["pT"] = jet.pt();
503  JSSVars["nTracks"] = nUngrTracks;
504 
505  SG::ReadDecorHandle<xAOD::JetContainer, float> readConstScore(m_readConstScoreKey);
506  JSSVars["CNN"] = readConstScore(jet);
507 
508  // define the decorator readers
509  SG::ReadDecorHandle<xAOD::JetContainer, float> readSplit12(m_readSplit12Key);
510  SG::ReadDecorHandle<xAOD::JetContainer, float> readSplit23(m_readSplit23Key);
511 
512  SG::ReadDecorHandle<xAOD::JetContainer, float> readTau1_wta(m_readTau1WTAKey);
513  SG::ReadDecorHandle<xAOD::JetContainer, float> readTau2_wta(m_readTau2WTAKey);
514  SG::ReadDecorHandle<xAOD::JetContainer, float> readTau3_wta(m_readTau3WTAKey);
515 
516  SG::ReadDecorHandle<xAOD::JetContainer, float> readECF1(m_readECF1Key);
517  SG::ReadDecorHandle<xAOD::JetContainer, float> readECF2(m_readECF2Key);
518  SG::ReadDecorHandle<xAOD::JetContainer, float> readECF3(m_readECF3Key);
519 
520  SG::ReadDecorHandle<xAOD::JetContainer, float> readQw(m_readQwKey);
521 
522  // define the ConstAccessor
523  static const SG::ConstAccessor<float> FoxWolfram0Acc("FoxWolfram0");
524  static const SG::ConstAccessor<float> FoxWolfram2Acc("FoxWolfram2");
525  static const SG::ConstAccessor<float> PlanarFlowAcc("PlanarFlow");
526  static const SG::ConstAccessor<float> AngularityAcc("Angularity");
527  static const SG::ConstAccessor<float> AplanarityAcc("Aplanarity");
528  static const SG::ConstAccessor<float> ZCut12Acc("ZCut12");
529  static const SG::ConstAccessor<float> KtDRAcc("KtDR");
530  static const SG::ConstAccessor<float> D2Acc("D2");
531 
532  // split
533  JSSVars["Split12"] = readSplit12(jet);
534  JSSVars["Split23"] = readSplit23(jet);
535 
536  // Energy Correlation Functions
537  JSSVars["D2"] = D2Acc(jet);
538 
539  // Tau123 WTA
540  JSSVars["Tau1_wta"] = readTau1_wta(jet);
541  JSSVars["Tau2_wta"] = readTau2_wta(jet);
542  JSSVars["Tau3_wta"] = readTau3_wta(jet);
543 
544  // ECF
545  JSSVars["ECF1"] = readECF1(jet);
546  JSSVars["ECF2"] = readECF2(jet);
547  JSSVars["ECF3"] = readECF3(jet);
548 
549  // Qw
550  JSSVars["Qw"] = readQw(jet);
551 
552  // Other moments
553  JSSVars["FoxWolfram0"] = FoxWolfram0Acc.withDefault(jet, -99.);
554  JSSVars["FoxWolfram2"] = FoxWolfram2Acc.withDefault(jet, -99.);
555  JSSVars["PlanarFlow"] = PlanarFlowAcc.withDefault(jet, -99.);
556  JSSVars["Angularity"] = AngularityAcc.withDefault(jet, -99.);
557  JSSVars["Aplanarity"] = AplanarityAcc.withDefault(jet, -99.);
558  JSSVars["ZCut12"] = ZCut12Acc.withDefault(jet, -99.);
559  JSSVars["KtDR"] = KtDRAcc.withDefault(jet, -99.);
560 
561  return JSSVars;
562 
563 }

◆ 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  }

◆ getProperty()

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

Get one of the tool's properties.

◆ GetQGConstScore()

StatusCode JSSTaggerUtils::GetQGConstScore ( const xAOD::JetContainer &  jets) const
overridevirtual

Implements IJSSTaggerUtils.

Definition at line 317 of file JSSTaggerUtils.cxx.

317  {
318 
319  SG::WriteDecorHandle<xAOD::JetContainer, float> decConstScore(m_decConstScoreKey);
320 
321  for(const xAOD::Jet *jet : jets){
322 
323  // init value
324  float score (-99.);
325 
326  // get constituents
327  std::vector<xAOD::JetConstituent> constituents = jet -> getConstituents().asSTLVector();
328  std::sort( constituents.begin(), constituents.end(), DescendingPtSorterConstituents) ;
329 
330  // get towers
331  std::vector<const xAOD::CaloCluster*> towers;
332  SG::AuxElement::ConstAccessor<std::vector<ElementLink<DataVector<xAOD::IParticle>>>> towersAcc("GhostTower");
333  if (towersAcc.isAvailable(*jet)){
334  // Vector of towers linked to jets
335  std::vector<ElementLink<DataVector<xAOD::IParticle>>> towerLinks = towersAcc(*jet);
336  for (auto link_itr : towerLinks){
337  if (!link_itr.isValid()) continue;
338  towers.push_back(dynamic_cast<const xAOD::CaloCluster *>(*link_itr));
339  }
340  }
341  std::sort( towers.begin(), towers.end(), DescendingPtSorterConstituents) ;
342 
343  // use ML tool on constituents
344  std::vector<float> m, pT, eta, phi, E, isTower, px, py, pz;
345  for(auto cnst : constituents){
346  m.push_back( cnst -> m() );
347  pT.push_back( cnst -> pt() );
348  eta.push_back( cnst -> eta() );
349  phi.push_back( cnst -> phi() );
350  E.push_back( cnst -> e() );
351  isTower.push_back(0.);
352  px.push_back( cnst -> pt() * std::cos(cnst -> phi()) );
353  py.push_back( cnst -> pt() * std::sin(cnst -> phi()) );
354  pz.push_back( cnst -> pt() * std::sinh(cnst -> eta()) );
355  }
356 
357  for(auto cnst : towers){
358  m.push_back( cnst -> m() );
359  pT.push_back( cnst -> pt() );
360  eta.push_back( cnst -> eta() );
361  phi.push_back( cnst -> phi() );
362  E.push_back( cnst -> e() );
363  isTower.push_back(1.);
364  px.push_back( cnst -> pt() * std::cos(cnst -> phi()) );
365  py.push_back( cnst -> pt() * std::sin(cnst -> phi()) );
366  pz.push_back( cnst -> pt() * std::sinh(cnst -> eta()) );
367  }
368 
369  // put together constituents + towers
370  std::vector<std::vector<float>> features_packed;
371 
372  for(long unsigned int f=0; f<pT.size(); f++){
373  std::vector<float> features = { m.at(f), pT.at(f), eta.at(f), phi.at(f), E.at(f), isTower.at(f), px.at(f), py.at(f), pz.at(f) };
374  features_packed.push_back(features);
375  }
376 
377  // sort them
378  std::sort(features_packed.begin(), features_packed.end(), [](const auto& i, const auto& j) { return i.at(1) > j.at(1); });
379 
380  // global aux variables
381  float sum_features_px = std::accumulate(px.begin(), px.end(), 0);
382  float sum_features_py = std::accumulate(py.begin(), py.end(), 0);
383  float sum_features_pz = std::accumulate(pz.begin(), pz.end(), 0);
384 
385  float sum_features_pT = sqrt( sum_features_px*sum_features_px + sum_features_py*sum_features_py);
386  float sum_features_eta = std::asinh( sum_features_pz / Clip(sum_features_pT) );
387  float sum_features_phi = std::atan2( sum_features_py, sum_features_px );
388 
389  // build constituents and interaction variables
390  std::vector<std::vector<float>> const_vars;
391  std::vector<std::vector<std::vector<float>>> inter_vars;
392 
393  for(auto const &feature_i : features_packed){
394 
395  // calculate variables: constituents
396  float log_pT = log( Clip(feature_i.at(1) / sum_features_pT) );
397  float log_E = log( Clip(feature_i.at(4) / sum_features_pT) );
398  float eta = feature_i.at(2) - sum_features_eta;
399  float phi = feature_i.at(3) - sum_features_phi;
400  float DR = sqrt((feature_i.at(2) - sum_features_eta)*(feature_i.at(2) - sum_features_eta) + (feature_i.at(3) - sum_features_phi)*(feature_i.at(3) - sum_features_phi));
401  float log_m = log(Clip(feature_i.at(0)));
402  float type = feature_i.at(5);
403 
404  std::vector<float> vars = {log_pT, log_E, eta, phi, DR, log_m, type};
405  const_vars.push_back(vars);
406 
407  // calculate variables: interactions
408  std::vector<std::vector<float>> inter_vars_int;
409  for(auto const &feature_j : features_packed){
410 
411  // preparing variables
412  float delta = sqrt((feature_i.at(2)-feature_j.at(2))*(feature_i.at(2)-feature_j.at(2)) + (feature_i.at(3)-feature_j.at(3))*(feature_i.at(3)-feature_j.at(3)));
413  float min = feature_i.at(1) != feature_j.at(1) ? std::min(feature_i.at(1), feature_j.at(1)): 0.;
414  float mass2 = (feature_i.at(4)/sum_features_pT + feature_j.at(4)/sum_features_pT) * (feature_i.at(4)/sum_features_pT + feature_j.at(4)/sum_features_pT);
415  mass2 -= (feature_i.at(6)/sum_features_pT + feature_j.at(6)/sum_features_pT) * (feature_i.at(6)/sum_features_pT + feature_j.at(6)/sum_features_pT);
416  mass2 -= (feature_i.at(7)/sum_features_pT + feature_j.at(7)/sum_features_pT) * (feature_i.at(7)/sum_features_pT + feature_j.at(7)/sum_features_pT);
417  mass2 -= (feature_i.at(8)/sum_features_pT + feature_j.at(8)/sum_features_pT) * (feature_i.at(8)/sum_features_pT + feature_j.at(8)/sum_features_pT);
418 
419  // final values
420  float log_delta = log(Clip(delta));
421  float log_mindelta = log(Clip(min * delta / sum_features_pT));
422  float min_over_pT = min / (feature_i.at(1) + feature_j.at(1));
423  float log_mass = log(Clip(mass2));
424 
425  // set the diagonal to 0
426  if(feature_i==feature_j){
427  log_delta = 0;
428  log_mindelta = 0;
429  min_over_pT = 0;
430  log_mass = 0;
431  }
432 
433  std::vector<float> vars = { log_delta,
434  log_mindelta,
435  min_over_pT,
436  log_mass
437  };
438  inter_vars_int.push_back(vars);
439 
440  }
441 
442  inter_vars.push_back(inter_vars_int);
443  }
444 
445  // evaluate the model
446  if( (constituents.size() + towers.size()) > 1 )
447  score = m_MLBosonTagger -> retrieveConstituentsScore(const_vars, inter_vars);
448 
449  // save decorator
450  decConstScore(*jet) = score;
451 
452  }
453 
454  return StatusCode::SUCCESS;
455 
456 }

◆ 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 765 of file JSSTaggerBase.cxx.

765  {
766 
767  if ( !passKinRange(jet) ) return std::make_pair( 1.0, 1.0 );
768 
769 
770  double logmOverPt = std::log(jet.m()/jet.pt());
771  if ( m_decorationName.find("SmoothZ") != std::string::npos ||
772  m_decorationName.find("SmoothInclusiveZ") != std::string::npos ) {
774  const double WtoZmassShift = 10803;
775  logmOverPt = std::log((jet.m()-WtoZmassShift)/jet.pt());
776  }
777 
778  if ( logmOverPt > 0 ) logmOverPt = 0;
779 
780  double SF = 1.0;
781  double eff = 1.0;
782 
783  if ( m_weightHistograms.count(truthLabelStr.c_str()) ) {
784 
785  int pt_mPt_bin = (m_weightHistograms.find(truthLabelStr.c_str())->second)->FindBin(jet.pt()*0.001, logmOverPt);
786  SF = (m_weightHistograms.find(truthLabelStr.c_str())->second)->GetBinContent(pt_mPt_bin);
787 
788  if ( !m_efficiencyHistogramName.empty() ) {
789  eff = (m_efficiencyHistograms.find(truthLabelStr.c_str())->second)->GetBinContent(pt_mPt_bin);
790  }
791 
792  }
793  else {
794  // set the efficiency for "Other" category to be the signal efficiency
795  std::string signal_truthLabel="";
796  if ( m_weightHistograms.count("t_qqb") ) {
797  signal_truthLabel="t_qqb";
798  }else if ( m_weightHistograms.count("V_qq") ){
799  signal_truthLabel="V_qq";
800  }else if ( m_weightHistograms.count("t") ){
801  signal_truthLabel="t";
802  }
803  if ( !signal_truthLabel.empty() && !m_efficiencyHistogramName.empty() ){
804  int pt_mPt_bin = (m_weightHistograms.find(signal_truthLabel.c_str())->second)->FindBin(jet.pt()*0.001, logmOverPt);
805  eff = (m_efficiencyHistograms.find(signal_truthLabel.c_str())->second)->GetBinContent(pt_mPt_bin);
806  }
807 
808  return std::make_pair( 1.0, eff );
809  }
810 
811  if ( SF < 1e-3 ) {
812  ATH_MSG_DEBUG( "(pt, m/pt) (" << jet.pt()/1.e3 << ", " << jet.m()/jet.pt() << ") is out of range for SF calculation. Returning 1.0" );
813  return std::make_pair( 1.0, 1.0 );
814  }
815  else {
816  return std::make_pair( SF, eff );
817  }
818 
819 }

◆ GetTopConstScore()

StatusCode JSSTaggerUtils::GetTopConstScore ( const xAOD::JetContainer &  jets) const
overridevirtual

Implements IJSSTaggerUtils.

Definition at line 650 of file JSSTaggerUtils.cxx.

650  {
651 
652  SG::WriteDecorHandle<xAOD::JetContainer, float> decConstScore(m_decConstScoreKey);
653 
654  for(const xAOD::Jet *jet : jets){
655 
656  // init value
657  float score (-99.);
658  int parity (1);
659 
660  // get constituents
661  std::vector<xAOD::JetConstituent> constituents = jet -> getConstituents().asSTLVector();
662  std::sort( constituents.begin(), constituents.end(), DescendingPtSorterConstituents) ;
663 
664  // skim constituents
665  // nMaxConstituents: used to compute the sum_pT and sum_E for the pre-processing
666  // nInputConstituents: actual input to the network
667  long unsigned int nMaxConstituents (100);
668  long unsigned int nInputConstituents (80);
669 
670  std::vector<float> pT_nMax, E_nMax;
671  for(auto cnst : constituents){
672  pT_nMax.push_back( cnst -> pt() );
673  E_nMax.push_back( cnst -> e() );
674  if(pT_nMax.size()==nMaxConstituents) break;
675  }
676 
677  // remove non physical constituents
678  constituents.erase( std::remove_if( constituents.begin(), constituents.end(),
679  [] (xAOD::JetConstituent constituent) -> bool {return log(constituent -> pt()) < 0.1;}),
680  constituents.end()) ;
681 
682  // use ML tool on constituents
683  std::vector<float> pT, eta, phi, E, isValid, px, py, pz;
684  for(auto cnst : constituents){
685  pT.push_back( cnst -> pt() );
686  eta.push_back( cnst -> eta() );
687  phi.push_back( cnst -> phi() );
688  E.push_back( cnst -> e() );
689  isValid.push_back(1.);
690  px.push_back( cnst -> pt() * std::cos(cnst -> phi()) );
691  py.push_back( cnst -> pt() * std::sin(cnst -> phi()) );
692  pz.push_back( cnst -> pt() * std::sinh(cnst -> eta()) );
693  }
694 
695 
696  // global aux variables
697  float sum_features_E = std::accumulate(E_nMax.begin(), E_nMax.end(), 0.);
698  float sum_features_pT_scalar = std::accumulate(pT_nMax.begin(), pT_nMax.end(), 0.);
699 
700  TLorentzVector constituent0;
701  if(constituents.size() > 0)
702  constituent0.SetPtEtaPhiE(pT.at(0), eta.at(0), phi.at(0), E.at(0));
703 
704  float angle (0.);
705  if(constituents.size() > 1){
706  float deta01 = eta.at(1) - eta.at(0);
707  float dphi01 = phi.at(1) - phi.at(0);
708  if(dphi01 > std::numbers::pi) dphi01 -= 2*std::numbers::pi;
709  else if(dphi01 < -std::numbers::pi) dphi01 += 2*std::numbers::pi;
710 
711  angle = std::atan2(dphi01, deta01) + std::numbers::pi/2;
712  }
713 
714  // build constituents, mask and base momentum for interaction variables
715  std::vector<std::vector<float>> const_vars;
716  std::vector<std::vector<float>> masks_vars;
717  std::vector<std::vector<std::vector<float>>> inter_vars;
718 
719  for(long unsigned int i=0; i<constituents.size(); i++){
720 
721  // up to nInputConstituents constituents
722  if(const_vars.size()==nInputConstituents) break;
723 
724  // put the constituent in a tlv for help
725  TLorentzVector constituent_i;
726  constituent_i.SetPtEtaPhiE(pT.at(i), eta.at(i), phi.at(i), E.at(i));
727 
728  // flip/rot of constituents: center
729  float eta_center = eta.at(i) - eta.at(0);
730  float phi_center = constituent_i.DeltaPhi(constituent0);
731 
732  // flip/rot of constituents: rotate
733  // ToDo: this does not make sense when nConst == 1,
734  // but it also true that the score is not retrieved for those jets,
735  // should we add a further protection?
736  float eta_rot = eta_center * cos(angle) + phi_center * sin(angle);
737  float phi_rot = -eta_center * sin(angle) + phi_center * cos(angle);
738 
739  // flip/rot of constituents: parity
740  if(i==2 && eta_rot<0.) parity = -1;
741  float eta_flip = eta_rot * parity;
742 
743  // calculate constituents variables
744  float log_pT = log( pT.at(i));
745  float log_E = log( E.at(i));
746  float log_pT_rel = log( pT.at(i) / sum_features_pT_scalar);
747  float log_E_rel = log( E.at(i) / sum_features_E);
748  float Deta = eta_flip;
749  float Dphi = phi_rot;
750  float DR = sqrt(Deta*Deta + Dphi*Dphi);
751 
752  // pack: constituents variables
753  std::vector<float> vars = {log_pT, log_E, log_pT_rel, log_E_rel, DR, Deta, Dphi};
754  const_vars.push_back(vars);
755 
756  // pack: mask variable
757  vars = {1.};
758  masks_vars.push_back(vars);
759 
760  // explict interaction variables
761  // calculate variables: interactions
762  std::vector<std::vector<float>> inter_vars_int;
763  for(long unsigned int j=0; j<constituents.size(); j++){
764 
765  // tlv for constituents
766  // todo: harmonise with the previous one
767  TLorentzVector constituent_j;
768  constituent_j.SetPtEtaPhiE(pT.at(j), eta.at(j), phi.at(j), E.at(j));
769 
770  // preparing variables
771 
772  // custom rapidity calculation
773  double rap_i = 0.5 * log( 1 + (2 * pz.at(i)) / Clip(E.at(i) - pz.at(i), 1.e-8) );
774  double rap_j = 0.5 * log( 1 + (2 * pz.at(j)) / Clip(E.at(j) - pz.at(j), 1.e-8) );
775  double deltaY = rap_i - rap_j;
776  double deltaPhi = TVector2::Phi_mpi_pi(constituent_i.Phi() - constituent_j.Phi());
777  double delta = std::sqrt(deltaY * deltaY + deltaPhi * deltaPhi);
778 
779  float min = pT.at(i) != pT.at(j) ? std::min(pT.at(i), pT.at(j)): pT.at(i);
780  float mass2 = (E.at(i) + E.at(j)) * (E.at(i) + E.at(j));
781  mass2 -= (px.at(i) + px.at(j)) * (px.at(i) + px.at(j));
782  mass2 -= (py.at(i) + py.at(j)) * (py.at(i) + py.at(j));
783  mass2 -= (pz.at(i) + pz.at(j)) * (pz.at(i) + pz.at(j));
784 
785  // final values
786  float log_delta = log(Clip(delta, 1.e-8));
787  float log_mindelta = log(Clip(min * delta, 1.e-8));
788  float log_min_over_pT = log(Clip(min / (pT.at(i) + pT.at(j)), 1.e-8));
789  float log_mass = log(Clip(mass2, 1.e-8));
790 
791  std::vector<float> vars = { log_mindelta,
792  log_min_over_pT,
793  log_delta,
794  log_mass
795  };
796  inter_vars_int.push_back(vars);
797 
798  }
799  inter_vars.push_back(inter_vars_int);
800 
801  }
802 
803  for(long unsigned int i=constituents.size(); i<nInputConstituents; i++){
804  // pack: constituents variables
805  std::vector<float> vars = {-18.4207, -18.4207, -18.4207, -18.4207, -18.4207, -18.4207, -18.4207};
806  const_vars.push_back(vars);
807 
808  // pack: interaction variables
809  vars = {-18.4207, -18.4207, -18.4207, -18.4207};
810  std::vector<std::vector<float>> vars_inter;
811  for(long unsigned int j=0; j<nInputConstituents; j++){
812  vars_inter.push_back(vars);
813  }
814  inter_vars.push_back(vars_inter);
815 
816  // pack: mask variable
817  vars = {0.};
818  masks_vars.push_back(vars);
819  }
820 
821  // further adjustment for interaction variables
822  for(long unsigned int i=0; i<constituents.size(); i++){
823  std::vector<float> vars = {0., 0., 0., 0.};
824  vars = {-18.4207, -18.4207, -18.4207, -18.4207};
825  for(long unsigned int j=constituents.size(); j<nInputConstituents; j++){
826  inter_vars.at(i).push_back(vars);
827  }
828  }
829 
830  // evaluate the model
831  if( constituents.size() > 1 )
832  score = m_MLBosonTagger -> retrieveConstituentsScore(const_vars, inter_vars, masks_vars);
833 
834  // save decorator
835  // the model return the qcd node score
836  // therefore, we use 1 - score to have
837  // top jet: 1, q/g jet: 0
838  decConstScore(*jet) = 1 - score;
839 
840  }
841 
842  return StatusCode::SUCCESS;
843 
844 }

◆ 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 823 of file JSSTaggerBase.cxx.

823  {
825  std::string truthLabelStr;
826 
828  SG::ReadDecorHandle<xAOD::JetContainer, int> readTruthLabel(m_readTruthLabelKey);
829  LargeRJetTruthLabel::TypeEnum jetContainment = LargeRJetTruthLabel::intToEnum(readTruthLabel(jet));
830 
832  if ( m_weightHistograms.count("t_qqb") ) {
833 
835  if ( jetContainment==LargeRJetTruthLabel::tqqb ) {
836  truthLabelStr = "t_qqb";
837  }
839  else if ( jetContainment==LargeRJetTruthLabel::notruth || jetContainment==LargeRJetTruthLabel::qcd ) {
840  truthLabelStr = "q";
841  }
842 
843  }
845  else if ( m_weightHistograms.count("V_qq_passMpassD2") ) {
846 
848  if ( jetContainment==LargeRJetTruthLabel::tqqb || jetContainment==LargeRJetTruthLabel::other_From_t ) {
849  truthLabelStr = "t_";
850  }
852  else if ( jetContainment==LargeRJetTruthLabel::Wqq || jetContainment==LargeRJetTruthLabel::Zqq || jetContainment==LargeRJetTruthLabel::Wqq_From_t ) {
853  truthLabelStr = "V_qq_";
854  }
856  else if ( jetContainment==LargeRJetTruthLabel::notruth || jetContainment==LargeRJetTruthLabel::qcd ) {
857  truthLabelStr = "q_";
858  }
859 
861  if ( acceptData.getCutResult("PassMassLow") && acceptData.getCutResult("PassMassHigh") && acceptData.getCutResult("PassD2") ) {
862  truthLabelStr += "passMpassD2";
863  }
865  else if ( !(acceptData.getCutResult("PassMassLow") && acceptData.getCutResult("PassMassHigh")) && acceptData.getCutResult("PassD2") ) {
866  truthLabelStr += "failMpassD2";
867  }
869  else if ( acceptData.getCutResult("PassMassLow") && acceptData.getCutResult("PassMassHigh") && !acceptData.getCutResult("PassD2") ) {
870  truthLabelStr += "passMfailD2";
871  }
873  else{
874  truthLabelStr += "failMfailD2";
875  }
876 
877  }
878 
880  else if ( m_weightHistograms.count("V_qq") ) {
881 
883  if ( jetContainment==LargeRJetTruthLabel::tqqb || jetContainment==LargeRJetTruthLabel::other_From_t ) {
884  truthLabelStr = "t";
885  }
887  else if ( jetContainment==LargeRJetTruthLabel::Wqq || jetContainment==LargeRJetTruthLabel::Zqq || jetContainment==LargeRJetTruthLabel::Wqq_From_t ) {
888  truthLabelStr = "V_qq";
889  }
891  else if ( jetContainment==LargeRJetTruthLabel::notruth || jetContainment==LargeRJetTruthLabel::qcd ) {
892  truthLabelStr = "q";
893  }
894  }
895 
896  // inclusive top tagger
897  else {
899  if ( jetContainment==LargeRJetTruthLabel::tqqb || jetContainment==LargeRJetTruthLabel::other_From_t || jetContainment==LargeRJetTruthLabel::Wqq_From_t ) {
900  truthLabelStr = "t";
901  }
903  else if ( jetContainment==LargeRJetTruthLabel::notruth || jetContainment==LargeRJetTruthLabel::qcd ) {
904  truthLabelStr = "q";
905  }
906 
907  }
908 
909  return truthLabelStr;
910 }

◆ GetUnGroomTracks()

int 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 653 of file JSSTaggerBase.cxx.

653  {
654 
655  SG::ReadDecorHandle<xAOD::JetContainer, ElementLink<xAOD::JetContainer> > readParent(m_readParentKey);
656 
657  const xAOD::Jet * ungroomedJet = nullptr;
658  if ( readParent.isAvailable() ) {
659  const ElementLink<xAOD::JetContainer>& linkToUngroomed = readParent(jet);
660  if ( linkToUngroomed.isValid() ) {
661  ungroomedJet = *linkToUngroomed;
662 
663  static const SG::AuxElement::ConstAccessor< std::vector<int> >acc_Ntrk("NumTrkPt500");
664 
665  if ( acc_Ntrk.isAvailable(*ungroomedJet) ) {
666 
667  const std::vector<int>& NTrkPt500 = acc_Ntrk(*ungroomedJet);
668 
669  int jet_ntrk = NTrkPt500.at(indexPV);
670  return jet_ntrk;
671 
672  }
673  else {
674  ATH_MSG_ERROR("WARNING: Unable to retrieve Ntrk of the ungroomed parent jet. Please make sure this variable is in your derivations!!!");
675  }
676  }
677  else {
678  ATH_MSG_ERROR("WARNING: Unable to retrieve the parent ungroomed jet. Please make sure this variable is in your derivations!!!");
679  }
680  }
681  else {
682  ATH_MSG_ERROR("WARNING: Unable to retrieve the link to the parent ungroomed jet. Please make sure this variable is in your derivations!!!");
683  }
684 
685  return -999;
686 
687 }

◆ 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 691 of file JSSTaggerBase.cxx.

691  {
692  if ( !m_calcSF ) return StatusCode::SUCCESS;
693 
694  float weight = 1.0;
695  float effSF = 1.0;
696  float sigeffSF = 1.0;
697  float efficiency = 1.0;
698 
699  if ( m_isMC ) {
700 
701  std::string truthLabelStr = getTruthLabelStr( jet, acceptData );
702  std::tie(effSF, efficiency) = getSF( jet, truthLabelStr );
703 
704  // calculate signal efficiency SF
705  if ( m_weightHistograms.count("t_qqb") ) {
706  sigeffSF = getSF(jet, "t_qqb").first;
707  } else if ( m_weightHistograms.count("V_qq") ) {
708  sigeffSF = getSF(jet, "V_qq").first;
709  } else if ( m_weightHistograms.count("t") ){
710  sigeffSF = getSF(jet, "t").first;
711  } else {
712  sigeffSF = 1.0;
713  }
714 
716  if ( m_weightFlavors.find("fail") != std::string::npos ) {
717  weight = effSF;
718  }
719 
720  else {
721 
723  if ( passSel ) {
724  weight = effSF;
725  }
726 
728  else {
730  if ( m_efficiencyHistogramName.empty() ) {
731  weight = 1.0;
732  }
733  else if ( efficiency < 1.0 ) {
734  weight = ( 1. - effSF * efficiency ) / ( 1. - efficiency );
735  }
736  else {
737  weight = 1.0;
738  }
739  }
740  }
741 
742  }
743 
744  else {
745  weight = 1.0;
746  }
747 
749  SG::WriteDecorHandle<xAOD::JetContainer, float> decWeight(m_decWeightKey);
750  SG::WriteDecorHandle<xAOD::JetContainer, float> decEfficiency(m_decEfficiencyKey);
751  SG::WriteDecorHandle<xAOD::JetContainer, float> decEffSF(m_decEffSFKey);
752  SG::WriteDecorHandle<xAOD::JetContainer, float> decSigeffSF(m_decSigeffSFKey);
753 
755  decWeight(jet) = weight;
756  decEfficiency(jet) = efficiency;
757  decEffSF(jet) = effSF;
758  decSigeffSF(jet) = sigeffSF;
759 
760  return StatusCode::SUCCESS;
761 
762 }

◆ initialize()

StatusCode JSSTaggerUtils::initialize ( )
overridevirtual

Run once at the start of the job to setup everything.

Get configReader

Get the decoration name

Initialize decorators

Reimplemented from JSSTaggerBase.

Definition at line 52 of file JSSTaggerUtils.cxx.

52  {
53 
54  ATH_MSG_INFO( "Initializing JSSTaggerUtils tool" );
55 
56  ATH_MSG_INFO( " m_calibArea : " << m_calibArea );
57  ATH_MSG_INFO( " m_configFile : " << m_configFile );
58 
59  if ( ! m_configFile.empty() ) {
60 
62  ATH_CHECK( getConfigReader() );
63 
65  m_decorationName = m_configReader.GetValue("DecorationName", "");
66 
67  m_UseConstTagger = !((std::string)m_configReader.GetValue("ConstTaggerFileName", "")).empty();
68  m_UseHLTagger = !((std::string)m_configReader.GetValue("HLTaggerFileName", "")).empty();
69 
70  std::string ConstTaggerFileName = m_configReader.GetValue("ConstTaggerFileName", "aaa");
71  std::string HLTaggerFileName = m_configReader.GetValue("HLTaggerFileName", "aaa");
72 
73  if(m_UseConstTagger && m_MLBosonTagger.empty()){
74  // init tool
75  std::string ModelPath = "";
76  if ( m_calibArea.compare("Local") == 0 ) {
77  ModelPath = PathResolverFindCalibFile(ConstTaggerFileName);
78  }
79  else if ( m_calibArea.find("eos") != std::string::npos) {
80  ModelPath = (ConstTaggerFileName);
81  }
82  else{
83  ModelPath = PathResolverFindCalibFile(("BoostedJetTaggers/" + m_calibArea + "/" + ConstTaggerFileName).c_str());
84  }
85  ATH_MSG_INFO("JSSTaggerUtils::MLBosonTagger()" << " + ModelPath " << ModelPath );
86 
87  asg::AsgToolConfig config ("AthONNX::JSSMLTool/MLBosonTagger");
88  ATH_CHECK( config.setProperty("ModelPath", ModelPath));
89 
90  // get model paramters from the config file
91  ATH_MSG_INFO("JSSTaggerUtils::MLBosonTagger() read value from config" );
92 
93  // set parameters
94  ATH_CHECK( config.setProperty("nPixelsX", (int)m_configReader.GetValue("nPixelsEta", -99)) );
95  ATH_CHECK( config.setProperty("nPixelsY", (int)m_configReader.GetValue("nPixelsPhi", -99)) );
96  ATH_CHECK( config.setProperty("nPixelsZ", (int)m_configReader.GetValue("nColors", -99)) );
97 
98  m_nbins_eta = (int)m_configReader.GetValue("nPixelsEta", -99);
99  m_nbins_phi = (int)m_configReader.GetValue("nPixelsPhi", -99);
100  m_ncolors = m_configReader.GetValue("nColors", -99);
101  m_min_eta = m_configReader.GetValue("aEta", -99.);
102  m_max_eta = m_configReader.GetValue("bEta", -99.);
103  m_min_phi = m_configReader.GetValue("aPhi", -99.);
104  m_max_phi = m_configReader.GetValue("bPhi", -99.);
105  m_dorscaling = (bool)m_configReader.GetValue("DoRScaling", -99);
106  m_rscaling_p0 = m_configReader.GetValue("RScaling_p0", -99.);
107  m_rscaling_p1 = m_configReader.GetValue("RScaling_p1", -99.);
108 
109  ATH_CHECK( config.makePrivateTool(m_MLBosonTagger) );
110  ATH_CHECK( m_MLBosonTagger.retrieve() );
111 
112  }
113  if(m_UseHLTagger){
114  // init tool
115  std::string ModelPath = "";
116  if ( m_calibArea.compare("Local") == 0 ) {
117  ModelPath = PathResolverFindCalibFile(HLTaggerFileName);
118  }
119  else if ( m_calibArea.find("eos") != std::string::npos) {
120  ModelPath = (HLTaggerFileName);
121  }
122  else{
123  ModelPath = PathResolverFindCalibFile(("BoostedJetTaggers/" + m_calibArea + "/" + HLTaggerFileName).c_str());
124  }
125  ATH_MSG_INFO("JSSTaggerUtils::MLBosonTagger()" << " + ModelPath " << ModelPath );
126 
127  asg::AsgToolConfig config ("AthONNX::JSSMLTool/MLBosonTaggerHL");
128  ATH_CHECK( config.setProperty("ModelPath", ModelPath));
129 
130  ATH_CHECK( config.makePrivateTool(m_MLBosonTagger_HL) );
131  ATH_CHECK( m_MLBosonTagger_HL.retrieve() );
132 
133  // get model paramters from the config file
134  ATH_MSG_INFO("JSSTaggerUtils::MLBosonTagger() read value from config" );
135  ATH_CHECK( ReadScaler() );
136 
137  }
138 
139  }
140 
142  ATH_MSG_INFO( "Decorators that will be attached to jet :" );
143  ATH_CHECK(JSSTaggerBase::initialize());
144 
145  m_decNConstituentsKey = m_containerName + "." + m_decorationName + "_" + m_decNConstituentsKey.key();
146  ATH_CHECK( m_decNConstituentsKey.initialize() );
147  m_decNTopoTowersKey = m_containerName + "." + m_decorationName + "_" + m_decNTopoTowersKey.key();
148  ATH_CHECK( m_decNTopoTowersKey.initialize() );
149 
150  m_decConstScoreKey = m_containerName + "." + m_decorationName + "_" + m_decConstScoreKey.key();
151  ATH_CHECK( m_decConstScoreKey.initialize() );
152 
153  m_readConstScoreKey = m_containerName + "." + m_decorationName + "_" + m_readConstScoreKey.key();
154  ATH_CHECK( m_readConstScoreKey.initialize() );
155 
156  m_decHLScoreKey = m_containerName + "." + m_decorationName + "_" + m_decHLScoreKey.key();
157  ATH_CHECK( m_decHLScoreKey.initialize() );
158 
159  return StatusCode::SUCCESS;
160 
161 }

◆ 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.

◆ MakeJetImage()

TH2D JSSTaggerUtils::MakeJetImage ( TString  TagImage,
const xAOD::Jet *  jet,
std::vector< xAOD::JetConstituent >  constituents 
) const
overridevirtual

Implements IJSSTaggerUtils.

Definition at line 609 of file JSSTaggerUtils.cxx.

610  {
611 
612  double eta (-99.), phi (-99.), pT (-99.), z (-99.);
613  int BinEta (-99), BinPhi (-99);
614 
615  auto cst_pT = [] ( double sum, xAOD::JetConstituent cst ){
616  return sum + cst.pt(); };
617  double SumPT = std::accumulate( constituents.begin(), constituents.end(), 0., cst_pT) ;
618 
619  auto Image = std::make_unique<TH2D>("Image_" + TagImage, "Image_" + TagImage,
620  m_nbins_eta, m_min_eta, m_max_eta, m_nbins_phi, m_min_phi, m_max_phi);
621 
622  for( auto& cst : constituents ){
623  eta = cst -> eta() - jet -> eta() ;
624  phi = cst -> phi() - jet -> phi() ;
625  pT = cst -> pt() ;
626 
627  // apply r-scaling
628  if( m_dorscaling ){
629  eta *= 1. / (m_rscaling_p0 + m_rscaling_p1/jet->pt());
630  phi *= 1. / (m_rscaling_p0 + m_rscaling_p1/jet->pt());
631  }
632 
633  BinEta = Image -> GetXaxis() -> FindBin(eta);
634  BinPhi = Image -> GetYaxis() -> FindBin(phi);
635 
636  z = pT / SumPT ;
637 
638  int x = m_nbins_phi+1-BinPhi, y = BinEta; // transpose + flip
639 
640  double current_z = Image -> GetBinContent( x, y );
641 
642  if( eta>m_min_eta && eta<m_max_eta && phi>m_min_phi && phi<m_max_phi ) // avoid overflow pixels
643  Image -> SetBinContent( x, y, current_z += z );
644  }
645 
646  return *Image;
647 
648  }

◆ 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 338 of file JSSTaggerBase.cxx.

338  {
339 
340  float scale = 1.0;
341  if ( m_ptGeV ) scale = 1.e3;
342 
343  if ( jet.pt() < m_jetPtMin * scale ) return false;
344  if ( jet.pt() > m_jetPtMax * scale ) return false;
345  if ( std::abs( jet.eta() ) > m_jetEtaMax ) return false;
346 
347  return true;
348 
349 }

◆ print() [1/2]

void asg::AsgTool::print ( ) const
virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

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

Definition at line 131 of file AsgTool.cxx.

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, LundVariablesTool, 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 912 of file JSSTaggerBase.cxx.

912  {
913  ATH_MSG_INFO( "After tagging, you will have access to the following cuts as an asg::AcceptData : (<NCut>) <cut> : <description>)" );
914  int nCuts = m_acceptInfo.getNCuts();
915  for ( int iCut=0; iCut < nCuts; iCut++ ) {
916  std::string cut_string = "";
917  cut_string += " (";
918  cut_string += std::to_string(iCut);
919  cut_string += ") ";
920  cut_string += m_acceptInfo.getCutName(iCut).data();
921  cut_string += " : ";
922  cut_string += m_acceptInfo.getCutDescription(iCut).data();
923  ATH_MSG_INFO( cut_string );
924  }
925 }

◆ ReadScaler()

StatusCode JSSTaggerUtils::ReadScaler ( )
overridevirtual

Implements IJSSTaggerUtils.

Definition at line 565 of file JSSTaggerUtils.cxx.

565  {
566 
567  // input list
568  std::vector<std::string> vars_list = {
569  "pT","CNN","D2","nTracks","ZCut12",
570  "Tau1_wta","Tau2_wta","Tau3_wta",
571  "KtDR","Split12","Split23",
572  "ECF1","ECF2","ECF3",
573  "Angularity","FoxWolfram0","FoxWolfram2",
574  "Aplanarity","PlanarFlow","Qw",
575  };
576 
577  // loop and read
578  for(const std::string & var : vars_list){
579  std::string s_mean = var + "_mean";
580  std::string s_std = var + "_std";
581  double mean = m_configReader.GetValue(s_mean.c_str(), -99.);
582  double std = m_configReader.GetValue(s_std.c_str() , -99.);
583 
584  if(mean==-99. && std==-99.){
585  ATH_MSG_ERROR("ERROR: one of the parameter for " << var << " is missing, please, double check the config!!!");
586  return StatusCode::FAILURE;
587  }
588  else if(mean==-99. || std==-99.){
589  ATH_MSG_ERROR("ERROR: parameters for " << var << " are missing, please, double check the config!!!");
590  return StatusCode::FAILURE;
591  }
592  else{
593  m_scaler[var] = {mean, std};
594  }
595 
596  // pass the features scaling paramters to the ML tool
597  // we need to apply the data pre-processing
598  // before to apply the model inference via ONNX
599 
600  // ToDo: change this to a property
601  ATH_CHECK( m_MLBosonTagger_HL -> SetScaler(m_scaler) );
602 
603  }
604 
605  return StatusCode::SUCCESS;
606 
607 }

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

320  {
321 
323  acceptData.clear();
324 
326  acceptData.setCutResult( "ValidJetContent", true );
327  acceptData.setCutResult( "ValidEventContent", true );
328 
329  acceptData.setCutResult( "ValidPtRangeHigh", true );
330  acceptData.setCutResult( "ValidPtRangeLow" , true );
331  acceptData.setCutResult( "ValidEtaRange" , true );
332 
333  return StatusCode::SUCCESS;
334 
335 }

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

StatusCode JSSTaggerUtils::tag ( const xAOD::Jet &  jet) const
overridevirtual

IJetSelectorTool interface.

Implements JSSTaggerBase.

Definition at line 163 of file JSSTaggerUtils.cxx.

163  {
164 
165  ATH_MSG_DEBUG( "Obtaining JSS Tagger Utils result " << jet.pt() << " " << jet.m() );
166 
167  return StatusCode::SUCCESS;
168 
169 }

◆ 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_calcSF

bool JSSTaggerBase::m_calcSF {}
protectedinherited

Flag to calculate scale factor.

Definition at line 192 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 104 of file JSSTaggerBase.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_decConstScoreKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerUtils::m_decConstScoreKey {this, "ConstScoreNameDec", "ConstScore", "SG key for ConstScore"}
private

Definition at line 63 of file JSSTaggerUtils.h.

◆ m_decCutMHighKey

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

Definition at line 219 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 218 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 225 of file JSSTaggerBase.h.

◆ m_decEffSFKey

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

Definition at line 226 of file JSSTaggerBase.h.

◆ m_decHLScoreKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerUtils::m_decHLScoreKey {this, "HLScoreName", "HLScore", "SG key for HLScore"}
private

Definition at line 65 of file JSSTaggerUtils.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_decNConstituentsKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerUtils::m_decNConstituentsKey {this, "nConstituentsName", "nConstituents", "SG key for constituents multiplicity"}
private

WriteDecorHandle keys.

Definition at line 61 of file JSSTaggerUtils.h.

◆ m_decNTopoTowersKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerUtils::m_decNTopoTowersKey {this, "nTopoTowersName", "nTopoTowers", "SG key for towers multiplicity"}
private

Definition at line 62 of file JSSTaggerUtils.h.

◆ m_decorationName

std::string JSSTaggerBase::m_decorationName
protectedinherited

Decoration name.

Definition at line 189 of file JSSTaggerBase.h.

◆ m_decPassMassKey

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

Definition at line 76 of file JSSTaggerBase.h.

◆ m_decPassScoreKey

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

Definition at line 77 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 220 of file JSSTaggerBase.h.

◆ m_decScoreValueKey

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

Definition at line 221 of file JSSTaggerBase.h.

◆ m_decSigeffSFKey

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

Definition at line 227 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 68 of file JSSTaggerBase.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 71 of file JSSTaggerBase.h.

◆ m_decValidEventContentKey

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

Definition at line 74 of file JSSTaggerBase.h.

◆ m_decValidJetContentKey

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

Definition at line 73 of file JSSTaggerBase.h.

◆ m_decValidKinRangeKey

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

Definition at line 72 of file JSSTaggerBase.h.

◆ m_decValidPtRangeHighKey

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

Definition at line 69 of file JSSTaggerBase.h.

◆ m_decValidPtRangeLowKey

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

Definition at line 70 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 224 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_dorscaling

bool JSSTaggerUtils::m_dorscaling {}
private

Definition at line 48 of file JSSTaggerUtils.h.

◆ m_efficiencyHistogramName

std::string JSSTaggerBase::m_efficiencyHistogramName
protectedinherited

Definition at line 199 of file JSSTaggerBase.h.

◆ m_efficiencyHistograms

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

Definition at line 205 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_funcMassCutHigh

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

Definition at line 185 of file JSSTaggerBase.h.

◆ m_funcMassCutLow

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

TF1 for cut functions.

Definition at line 184 of file JSSTaggerBase.h.

◆ m_funcScoreCut

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

Definition at line 186 of file JSSTaggerBase.h.

◆ m_isMC

bool JSSTaggerBase::m_isMC {}
protectedinherited

Definition at line 193 of file JSSTaggerBase.h.

◆ m_isSmallRJet

bool JSSTaggerBase::m_isSmallRJet = false
protectedinherited

Definition at line 105 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_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_max_eta

double JSSTaggerUtils::m_max_eta {}
private

Definition at line 46 of file JSSTaggerUtils.h.

◆ m_max_phi

double JSSTaggerUtils::m_max_phi {}
private

Definition at line 46 of file JSSTaggerUtils.h.

◆ m_min_eta

double JSSTaggerUtils::m_min_eta {}
private

Definition at line 46 of file JSSTaggerUtils.h.

◆ m_min_phi

double JSSTaggerUtils::m_min_phi {}
private

Definition at line 46 of file JSSTaggerUtils.h.

◆ m_MLBosonTagger

ToolHandle<AthONNX::IJSSMLTool> JSSTaggerUtils::m_MLBosonTagger {"", this}
private

Definition at line 54 of file JSSTaggerUtils.h.

◆ m_MLBosonTagger_HL

ToolHandle<AthONNX::IJSSMLTool> JSSTaggerUtils::m_MLBosonTagger_HL {"", this}
private

Definition at line 58 of file JSSTaggerUtils.h.

◆ m_nbins_eta

int JSSTaggerUtils::m_nbins_eta {}
private

Definition at line 45 of file JSSTaggerUtils.h.

◆ m_nbins_phi

int JSSTaggerUtils::m_nbins_phi {}
private

Definition at line 45 of file JSSTaggerUtils.h.

◆ m_ncolors

int JSSTaggerUtils::m_ncolors {}
private

Definition at line 47 of file JSSTaggerUtils.h.

◆ m_nWarnMax

const int JSSTaggerBase::m_nWarnMax = 10
protectedinherited

Maximum number of warnings.

Definition at line 82 of file JSSTaggerBase.h.

◆ m_nWarnVar

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

Warning counters.

Definition at line 85 of file JSSTaggerBase.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 89 of file JSSTaggerBase.h.

◆ m_readConstScoreKey

SG::ReadDecorHandleKey<xAOD::JetContainer> JSSTaggerUtils::m_readConstScoreKey {this, "ConstScoreNameRead", "ConstScore", "SG key for ConstScore"}
private

Definition at line 64 of file JSSTaggerUtils.h.

◆ m_readECF1Key

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

Definition at line 158 of file JSSTaggerBase.h.

◆ m_readECF2Key

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

Definition at line 159 of file JSSTaggerBase.h.

◆ m_readECF3Key

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

Definition at line 160 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 172 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 171 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 170 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 79 of file JSSTaggerBase.h.

◆ m_readParentKey

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

Definition at line 174 of file JSSTaggerBase.h.

◆ m_readQwKey

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

Definition at line 165 of file JSSTaggerBase.h.

◆ m_readSphericityKey

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

Definition at line 168 of file JSSTaggerBase.h.

◆ m_readSplit12Key

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

Definition at line 162 of file JSSTaggerBase.h.

◆ m_readSplit23Key

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

Definition at line 163 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_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_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_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 167 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 215 of file JSSTaggerBase.h.

◆ m_rscaling_p0

double JSSTaggerUtils::m_rscaling_p0 {}
private

Definition at line 49 of file JSSTaggerUtils.h.

◆ m_rscaling_p1

double JSSTaggerUtils::m_rscaling_p1 {}
private

Definition at line 49 of file JSSTaggerUtils.h.

◆ m_scaler

std::map<std::string, std::vector<double> > JSSTaggerUtils::m_scaler

Definition at line 41 of file JSSTaggerUtils.h.

◆ m_strMassCutHigh

std::string JSSTaggerBase::m_strMassCutHigh
protectedinherited

Definition at line 180 of file JSSTaggerBase.h.

◆ m_strMassCutLow

std::string JSSTaggerBase::m_strMassCutLow
protectedinherited

Strings for cut functions.

Definition at line 179 of file JSSTaggerBase.h.

◆ m_strScoreCut

std::string JSSTaggerBase::m_strScoreCut
protectedinherited

Definition at line 181 of file JSSTaggerBase.h.

◆ m_suppressOutputDependence

bool JSSTaggerBase::m_suppressOutputDependence {}
protectedinherited

Definition at line 176 of file JSSTaggerBase.h.

◆ m_tagClass

TAGCLASS JSSTaggerBase::m_tagClass {Unknown}
protectedinherited

Definition at line 99 of file JSSTaggerBase.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_truthBosonContainerName

std::string JSSTaggerBase::m_truthBosonContainerName
protectedinherited

Definition at line 210 of file JSSTaggerBase.h.

◆ m_truthLabelName

std::string JSSTaggerBase::m_truthLabelName
protectedinherited

Definition at line 212 of file JSSTaggerBase.h.

◆ m_truthLabelUseTRUTH3

bool JSSTaggerBase::m_truthLabelUseTRUTH3 {}
protectedinherited

Truth label options.

Definition at line 208 of file JSSTaggerBase.h.

◆ m_truthParticleContainerName

std::string JSSTaggerBase::m_truthParticleContainerName
protectedinherited

Definition at line 209 of file JSSTaggerBase.h.

◆ m_truthTopQuarkContainerName

std::string JSSTaggerBase::m_truthTopQuarkContainerName
protectedinherited

Definition at line 211 of file JSSTaggerBase.h.

◆ m_UseConstTagger

bool JSSTaggerUtils::m_UseConstTagger {}
private

Definition at line 53 of file JSSTaggerUtils.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_UseHLTagger

bool JSSTaggerUtils::m_UseHLTagger {}
private

Definition at line 57 of file JSSTaggerUtils.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 92 of file JSSTaggerBase.h.

◆ m_useScoreCut

bool JSSTaggerBase::m_useScoreCut = false
protectedinherited

Flag to indicate if a discriminant score is used.

Definition at line 95 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_weightConfig

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

Histograms for scale factors.

Definition at line 203 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 196 of file JSSTaggerBase.h.

◆ m_weightFileName

std::string JSSTaggerBase::m_weightFileName
protectedinherited

Definition at line 197 of file JSSTaggerBase.h.

◆ m_weightFlavors

std::string JSSTaggerBase::m_weightFlavors
protectedinherited

Definition at line 200 of file JSSTaggerBase.h.

◆ m_weightHistogramName

std::string JSSTaggerBase::m_weightHistogramName
protectedinherited

Definition at line 198 of file JSSTaggerBase.h.

◆ m_weightHistograms

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

Definition at line 204 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:174
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
LargeRJetTruthLabel::TypeEnum
TypeEnum
Definition: LargeRJetLabelEnum.h:14
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
CalculateHighPtTerm.pT
pT
Definition: ICHEP2016/CalculateHighPtTerm.py:57
JSSTaggerBase::m_readTau4WTAKey
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readTau4WTAKey
Definition: JSSTaggerBase.h:156
beamspotnt.var
var
Definition: bin/beamspotnt.py:1393
JSSTaggerBase::m_readSplit23Key
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readSplit23Key
Definition: JSSTaggerBase.h:163
Trk::L2
@ L2
Definition: AlignModuleList.h:32
JSSTaggerBase::m_readECF1Key
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readECF1Key
Definition: JSSTaggerBase.h:158
JSSTaggerBase::getTruthLabelStr
std::string getTruthLabelStr(const xAOD::Jet &jet, asg::AcceptData &acceptData) const
Definition: JSSTaggerBase.cxx:823
mean
void mean(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:254
get_generator_info.result
result
Definition: get_generator_info.py:21
test_pyathena.px
px
Definition: test_pyathena.py:18
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:407
JSSTaggerBase::ZBoson
@ ZBoson
Definition: JSSTaggerBase.h:98
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
JSSTaggerBase::m_readNtrk500Key
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readNtrk500Key
Definition: JSSTaggerBase.h:79
JSSTaggerUtils::m_UseHLTagger
bool m_UseHLTagger
Definition: JSSTaggerUtils.h:57
JSSTaggerBase::m_readECFG311Key
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readECFG311Key
Definition: JSSTaggerBase.h:171
JSSTaggerBase::m_jetEtaMax
float m_jetEtaMax
Definition: JSSTaggerBase.h:134
makeComparison.deltaY
int deltaY
Definition: makeComparison.py:44
JSSTaggerBase::m_decValidEtaRangeKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decValidEtaRangeKey
Definition: JSSTaggerBase.h:71
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
JSSTaggerUtils::m_decHLScoreKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decHLScoreKey
Definition: JSSTaggerUtils.h:65
JSSTaggerBase::m_efficiencyHistograms
std::map< std::string, std::unique_ptr< TH2D > > m_efficiencyHistograms
Definition: JSSTaggerBase.h:205
JSSTaggerBase::m_configFile
std::string m_configFile
Configuration file name.
Definition: JSSTaggerBase.h:111
JSSTaggerUtils::MakeJetImage
TH2D MakeJetImage(TString TagImage, const xAOD::Jet *jet, std::vector< xAOD::JetConstituent > constituents) const override
Definition: JSSTaggerUtils.cxx:609
JSSTaggerBase::m_configReader
TEnv m_configReader
TEnv instance to read config files.
Definition: JSSTaggerBase.h:62
xAOD::deltaPhi
setSAddress setEtaMS setDirPhiMS setDirZMS setBarrelRadius setEndcapAlpha setEndcapRadius setInterceptInner setEtaMap setEtaBin setIsTgcFailure setDeltaPt deltaPhi
Definition: L2StandAloneMuon_v1.cxx:161
RootHelpers::FindBin
Int_t FindBin(const TAxis *axis, const double x)
Definition: RootHelpers.cxx:14
JSSTaggerUtils::m_dorscaling
bool m_dorscaling
Definition: JSSTaggerUtils.h:48
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
JSSTaggerBase::TopQuark
@ TopQuark
Definition: JSSTaggerBase.h:98
python.base_data.config
config
Definition: base_data.py:20
JSSTaggerUtils::m_rscaling_p0
double m_rscaling_p0
Definition: JSSTaggerUtils.h:49
JSSTaggerBase::tag
virtual StatusCode tag(const xAOD::Jet &jet) const =0
Decorate single jet with tagging info.
python.SystemOfUnits.second
float second
Definition: SystemOfUnits.py:135
test_pyathena.pt
pt
Definition: test_pyathena.py:11
TRT_PAI_gasdata::SF
const float SF[NF]
Cross sections for Fluor.
Definition: TRT_PAI_gasdata.h:285
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
defineDB.jets
jets
Definition: JetTagCalibration/share/defineDB.py:24
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
JSSTaggerBase::m_readSplit12Key
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readSplit12Key
Definition: JSSTaggerBase.h:162
JSSTaggerBase::m_jetPtMin
float m_jetPtMin
Kinematic bounds for the jet - the units are controlled by m_ptGeV.
Definition: JSSTaggerBase.h:132
JSSTaggerBase::m_decL3Key
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decL3Key
Definition: JSSTaggerBase.h:150
SG::ConstAccessor
Helper class to provide constant type-safe access to aux data.
Definition: ConstAccessor.h:55
JSSTaggerUtils::m_MLBosonTagger_HL
ToolHandle< AthONNX::IJSSMLTool > m_MLBosonTagger_HL
Definition: JSSTaggerUtils.h:58
DescendingPtSorterConstituents
bool DescendingPtSorterConstituents(const xAOD::JetConstituent p1, const xAOD::JetConstituent p2)
Definition: JSSTaggerUtils.cxx:8
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:189
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
JSSTaggerBase::m_readECFG331Key
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readECFG331Key
Definition: JSSTaggerBase.h:170
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)
Av: we implement here an ATLAS-sepcific convention: all particles which are 99xxxxx are fine.
Definition: AtlasPID.h:867
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
JSSTaggerUtils::m_readConstScoreKey
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readConstScoreKey
Definition: JSSTaggerUtils.h:64
yodamerge_tmp.scale
scale
Definition: yodamerge_tmp.py:138
Phi_mpi_pi
__HOSTDEV__ double Phi_mpi_pi(double)
Definition: GeoRegion.cxx:7
LargeRJetTruthLabel::qcd
@ qcd
Definition: LargeRJetLabelEnum.h:25
x
#define x
JSSTaggerBase::m_decValidPtRangeHighKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decValidPtRangeHighKey
Definition: JSSTaggerBase.h:69
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
config
Definition: PhysicsAnalysis/AnalysisCommon/AssociationUtils/python/config.py:1
pi
#define pi
Definition: TileMuonFitter.cxx:65
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:224
JSSTaggerBase::m_readTruthLabelKey
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readTruthLabelKey
Truth label ReadDecorHandle key.
Definition: JSSTaggerBase.h:215
LargeRJetTruthLabel::notruth
@ notruth
Definition: LargeRJetLabelEnum.h:24
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:227
JSSTaggerUtils::m_min_eta
double m_min_eta
Definition: JSSTaggerUtils.h:46
dqt_zlumi_pandas.weight
int weight
Definition: dqt_zlumi_pandas.py:190
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
JSSTaggerBase::m_decEfficiencyKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decEfficiencyKey
Definition: JSSTaggerBase.h:225
JSSTaggerUtils::m_nbins_eta
int m_nbins_eta
Definition: JSSTaggerUtils.h:45
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
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
JSSTaggerUtils::m_min_phi
double m_min_phi
Definition: JSSTaggerUtils.h:46
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:62
JSSTaggerBase::m_ptGeV
bool m_ptGeV
Flag to indicate units pT is defined in Set to false by default.
Definition: JSSTaggerBase.h:89
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
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
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
convertTimingResiduals.sum
sum
Definition: convertTimingResiduals.py:55
CheckAppliedSFs.e3
e3
Definition: CheckAppliedSFs.py:264
JSSTaggerBase::m_readQwKey
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readQwKey
Definition: JSSTaggerBase.h:165
asg::AsgToolConfig
an object that can create a AsgTool
Definition: AsgToolConfig.h:22
SG::ReadDecorHandle
Handle class for reading a decoration on an object.
Definition: StoreGate/StoreGate/ReadDecorHandle.h:94
JSSTaggerBase::getSF
std::pair< double, double > getSF(const xAOD::Jet &jet, const std::string &truthLabelStr) const
Get scale factor and efficiency.
Definition: JSSTaggerBase.cxx:765
JSSTaggerUtils::GetJSSVars
std::map< std::string, double > GetJSSVars(const xAOD::Jet &jet) const override
Definition: JSSTaggerUtils.cxx:485
lumiFormat.i
int i
Definition: lumiFormat.py:85
z
#define z
Trk::L3
@ L3
Definition: AlignModuleList.h:32
JSSTaggerBase::m_readECFG212Key
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readECFG212Key
Definition: JSSTaggerBase.h:172
JSSTaggerUtils::m_nbins_phi
int m_nbins_phi
Definition: JSSTaggerUtils.h:45
JSSTaggerUtils::m_decNTopoTowersKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decNTopoTowersKey
Definition: JSSTaggerUtils.h:62
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
angle
double angle(const GeoTrf::Vector2D &a, const GeoTrf::Vector2D &b)
Definition: TRTDetectorFactory_Full.cxx:68
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
SG::WriteDecorHandle
Handle class for adding a decoration to an object.
Definition: StoreGate/StoreGate/WriteDecorHandle.h:100
JSSTaggerUtils::m_max_eta
double m_max_eta
Definition: JSSTaggerUtils.h:46
xAOD::VxType::PriVtx
@ PriVtx
Primary vertex.
Definition: TrackingPrimitives.h:572
CalibDbCompareRT.dummy
dummy
Definition: CalibDbCompareRT.py:59
JSSTaggerBase::Unknown
@ Unknown
Definition: JSSTaggerBase.h:98
Amg::pz
@ pz
Definition: GeoPrimitives.h:40
JSSTaggerBase::m_efficiencyHistogramName
std::string m_efficiencyHistogramName
Definition: JSSTaggerBase.h:199
JSSTaggerBase::m_decTau42WTAKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decTau42WTAKey
Definition: JSSTaggerBase.h:144
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
hist_file_dump.f
f
Definition: hist_file_dump.py:140
JSSTaggerBase::m_decEffSFKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decEffSFKey
Definition: JSSTaggerBase.h:226
JSSTaggerUtils::m_UseConstTagger
bool m_UseConstTagger
Definition: JSSTaggerUtils.h:53
python.Dumpers.asinh
def asinh(x)
helper methods ---------------------------------------------------------—
Definition: Dumpers.py:88
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
JSSTaggerBase::m_calcSF
bool m_calcSF
Flag to calculate scale factor.
Definition: JSSTaggerBase.h:192
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
JSSTaggerBase::findPV
int findPV() const
Find the PV (to be used for Ntrk)
Definition: JSSTaggerBase.cxx:629
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
Amg::py
@ py
Definition: GeoPrimitives.h:39
LargeRJetTruthLabel::Wqq_From_t
@ Wqq_From_t
Definition: LargeRJetLabelEnum.h:21
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
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
VP1PartSpect::E
@ E
Definition: VP1PartSpectFlags.h:21
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
JSSTaggerUtils::ReadScaler
StatusCode ReadScaler() override
Definition: JSSTaggerUtils.cxx:565
JSSTaggerBase::decorateJSSRatios
void decorateJSSRatios(const xAOD::JetContainer &jets) const
Definition: JSSTaggerBase.cxx:511
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:283
xAOD::score
@ score
Definition: TrackingPrimitives.h:514
JSSTaggerBase::m_isMC
bool m_isMC
Definition: JSSTaggerBase.h:193
JSSTaggerBase::WBoson
@ WBoson
Definition: JSSTaggerBase.h:98
xAOD::Jet_v1
Class describing a jet.
Definition: Jet_v1.h:57
JSSTaggerBase::m_decValidKinRangeKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decValidKinRangeKey
Definition: JSSTaggerBase.h:72
runIDAlign.accumulate
accumulate
Update flags based on parser line args.
Definition: runIDAlign.py:60
JSSTaggerBase::m_readTau1WTAKey
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readTau1WTAKey
ReadDecorHandle keys for JSS moments.
Definition: JSSTaggerBase.h:153
JSSTaggerBase::m_weightHistograms
std::map< std::string, std::unique_ptr< TH2D > > m_weightHistograms
Definition: JSSTaggerBase.h:204
a
TList * a
Definition: liststreamerinfos.cxx:10
columnar::empty
bool empty() const noexcept
Definition: ObjectRange.h:163
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
y
#define y
SG::WriteDecorHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
h
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
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:338
RunTileMonitoring.towers
towers
Definition: RunTileMonitoring.py:133
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
std::sort
void sort(typename std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, typename std::reverse_iterator< DataModel_detail::iterator< DVL > > end, const Compare &comp)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:623
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
JSSTaggerBase::m_decValidPtRangeLowKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decValidPtRangeLowKey
Definition: JSSTaggerBase.h:70
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:159
JSSTaggerBase::m_readECF3Key
SG::ReadDecorHandleKey< xAOD::JetContainer > m_readECF3Key
Definition: JSSTaggerBase.h:160
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
JSSTaggerBase::getConfigReader
StatusCode getConfigReader()
Get configReader StatusCode.
Definition: JSSTaggerBase.cxx:281
LargeRJetTruthLabel::intToEnum
TypeEnum intToEnum(const int type)
Definition: LargeRJetLabelEnum.h:57
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
JSSTaggerBase::m_isSmallRJet
bool m_isSmallRJet
Definition: JSSTaggerBase.h:105
JSSTaggerBase::GetUnGroomTracks
int GetUnGroomTracks(const xAOD::Jet &jet, int indexPV) const
Retrieve Ntrk variable from the ungroomed parent jet.
Definition: JSSTaggerBase.cxx:653
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
JSSTaggerUtils::m_decConstScoreKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decConstScoreKey
Definition: JSSTaggerUtils.h:63
JSSTaggerUtils::m_MLBosonTagger
ToolHandle< AthONNX::IJSSMLTool > m_MLBosonTagger
Definition: JSSTaggerUtils.h:54
JSSTaggerBase::JSSTaggerBase
JSSTaggerBase(const std::string &name)
Default constructor - to be used in all derived classes.
Definition: JSSTaggerBase.cxx:11
xAOD::JetConstituent
4-vector of jet constituent at the scale used during jet finding.
Definition: JetConstituentVector.h:61
dqt_zlumi_alleff_HIST.eff
int eff
Definition: dqt_zlumi_alleff_HIST.py:113
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
LargeRJetTruthLabel::tqqb
@ tqqb
Definition: LargeRJetLabelEnum.h:16
JSSTaggerBase::m_decL2Key
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decL2Key
Definition: JSSTaggerBase.h:149
Clip
float Clip(float in, float low=1.e-36, float high=1.e+30)
Definition: JSSTaggerUtils.cxx:13
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
JSSTaggerBase::m_weightFlavors
std::string m_weightFlavors
Definition: JSSTaggerBase.h:200
JSSTaggerUtils::m_max_phi
double m_max_phi
Definition: JSSTaggerUtils.h:46
JSSTaggerUtils::m_decNConstituentsKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_decNConstituentsKey
WriteDecorHandle keys.
Definition: JSSTaggerUtils.h:61
SG::DataProxy
Definition: DataProxy.h:45
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
xAOD::bool
setBGCode setTAP setLVL2ErrorBits bool
Definition: TrigDecision_v1.cxx:60
JSSTaggerUtils::m_ncolors
int m_ncolors
Definition: JSSTaggerUtils.h:47
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
python.SystemOfUnits.m
float m
Definition: SystemOfUnits.py:106
JSSTaggerBase::m_containerName
std::string m_containerName
Configurable members.
Definition: JSSTaggerBase.h:104
JSSTaggerUtils::m_rscaling_p1
double m_rscaling_p1
Definition: JSSTaggerUtils.h:49
JSSTaggerUtils::m_scaler
std::map< std::string, std::vector< double > > m_scaler
Definition: JSSTaggerUtils.h:41
Generated on Sun Aug 31 2025 21:37:47 for ATLAS Offline Software by   doxygen 1.8.18