JSSTaggerUtils Class Reference

#include <JSSTaggerUtils.h>

Inheritance diagram for JSSTaggerUtils:

Collaboration diagram for JSSTaggerUtils:

Public Member Functions
	JSSTaggerUtils (const std::string &name)
	Constructor.
virtual StatusCode	initialize () override
	Run once at the start of the job to setup everything.
virtual StatusCode	tag (const xAOD::Jet &jet) const override
	IJetSelectorTool interface.
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	GetWConstScore (const xAOD::JetContainer &jets) const override
StatusCode	GetPolarisationScore (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 StatusCode	decorate (const xAOD::JetContainer &jets) const override
	Decorate jet collection with tagging info.
virtual void	print () const
	Print the state of the tool.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
virtual StatusCode	modify (xAOD::JetContainer &jets) const override final
	Concrete implementation of the function inherited from IJetModifier.
Additional helper functions, not directly mimicking Athena
template<class T>
const T *	getProperty (const std::string &name) const
	Get one of the tool's properties.
const std::string &	msg_level_name () const __attribute__((deprecated))
	A deprecated function for getting the message level's name.
const std::string &	getName (const void *ptr) const
	Get the name of an object that is / should be in the event store.
SG::sgkey_t	getKey (const void *ptr) const
	Get the (hashed) key of an object that is in the event store.

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.
StatusCode	resetCuts (asg::AcceptData &acceptData) const
	Reset cuts.
bool	passKinRange (const xAOD::Jet &jet) const
	Check if jet passes kinematic constraints.
StatusCode	checkKinRange (const xAOD::Jet &jet, asg::AcceptData &acceptData) const
	Check and record if jet passes kinematic constraints.
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.
void	decorateJSSRatios (const xAOD::JetContainer &jets) const
int	findPV () const
	Find the PV (to be used for Ntrk).
int	GetUnGroomTracks (const xAOD::Jet &jet, int indexPV) const
	Retrieve Ntrk variable from the ungroomed parent jet.
StatusCode	getWeight (const xAOD::Jet &jet, bool passSel, asg::AcceptData &acceptData) const
	Get SF weight.
std::pair< double, double >	getSF (const xAOD::Jet &jet, const std::string &truthLabelStr) const
	Get scale factor and efficiency.
std::string	getTruthLabelStr (const xAOD::Jet &jet, asg::AcceptData &acceptData) const
void	printCuts () const
	Print configured cuts.
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Protected Attributes
TEnv	m_configReader
	TEnv instance to read config files.
asg::AcceptInfo	m_acceptInfo
	Object that stores the results for a jet.
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_decTaggedKey {this, "TaggedName", "Tagged", "SG key for Tagged"}
	WriteDecorHandle keys for tagging bools.
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_decValidPtRangeHighKey {this, "ValidPtRangeHighName", "ValidPtRangeHigh", "SG key for ValidPtRangeHigh"}
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_decValidPtRangeLowKey {this, "ValidPtRangeLowName", "ValidPtRangeLow", "SG key for ValidPtRangeLow"}
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_decValidEtaRangeKey {this, "ValidEtaRangeName", "ValidEtaRange", "SG key for ValidEtaRange"}
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_decValidKinRangeKey {this, "ValidKinRangeName", "ValidKinRange", "SG key for ValidKinRange"}
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_decValidJetContentKey {this, "ValidJetContentName", "ValidJetContent", "SG key for ValidJetContent"}
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_decValidEventContentKey {this, "ValidEventContentName", "ValidEventContent", "SG key for ValidEventContent"}
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_decPassMassKey {this, "PassMassName", "PassMass", "SG key for PassMass"}
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_decPassScoreKey {this, "PassScoreName", "PassScore", "SG key for PassScore"}
const int	m_nWarnMax = 10
	Maximum number of warnings.
std::atomic< int >	m_nWarnVar
	Warning counters.
bool	m_ptGeV = false
	Flag to indicate units pT is defined in Set to false by default.
bool	m_useMassCut = false
	Flag to indicate if mass window cut is used.
bool	m_useScoreCut = false
	Flag to indicate if a discriminant score is used.
TAGCLASS	m_tagClass {Unknown}
std::string	m_containerName
	Configurable members.
bool	m_isSmallRJet = false
std::string	m_weightConfigPath
	Path to the SF configuration root file.
std::string	m_configFile
	Configuration file name.
std::string	m_calibArea
	Location where config files live on cvmfs.
std::string	m_kerasConfigFileName
	Keras configurations for ML taggers.
std::string	m_kerasConfigFilePath
std::string	m_kerasConfigOutputName
std::string	m_kerasCalibArea
std::string	m_tmvaConfigFileName
	TMVA configurations for BDT taggers.
std::string	m_tmvaConfigFilePath
std::string	m_tmvaCalibArea
std::string	m_wkpt
	Tagger information.
std::string	m_tagType
float	m_jetPtMin {}
	Kinematic bounds for the jet - the units are controlled by m_ptGeV.
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.
bool	m_useLSeries = false
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_decTau21WTAKey {this, "Tau21WTANameOut", "Tau21_wta", "SG key for Tau21_wta"}
	WriteDecorHandle keys for JSS moments.
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.
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"}
Gaudi::Property< bool >	m_suppressInputDependence {this, "SuppressInputDependence", false}
Gaudi::Property< bool >	m_suppressOutputDependence {this, "SuppressOutputDependence", false}
std::string	m_strMassCutLow
	Strings for cut functions.
std::string	m_strMassCutHigh
std::string	m_strScoreCut
std::unique_ptr< TF1 >	m_funcMassCutLow
	TF1 for cut functions.
std::unique_ptr< TF1 >	m_funcMassCutHigh
std::unique_ptr< TF1 >	m_funcScoreCut
std::string	m_decorationName
	Decoration name.
bool	m_calcSF {}
	Flag to calculate scale factor.
bool	m_isMC {}
std::string	m_weightDecorationName
	String for scale factor decoration names.
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.
std::map< std::string, std::unique_ptr< TH2D >, std::less<> >	m_weightHistograms
std::map< std::string, std::unique_ptr< TH2D >, std::less<> >	m_efficiencyHistograms
bool	m_truthLabelUseTRUTH3 {}
	Truth label options.
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.
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_decCutMLowKey {this, "CutMLowName", "Cut_mlow", "SG key for Cut_mlow"}
	WriteDecorHandle keys for cut values.
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.
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>

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.
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::WriteDecorHandleKey< xAOD::JetContainer >	m_decHLScoreKey {this, "HLScoreName", "HLScore", "SG key for HLScore"}
std::unique_ptr< SG::ConstAccessor< float > >	m_constScoreAcc = nullptr
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_decConstScoreQGKey {this, "ConstScoreQGNameDec", "ConstScore_qg", "SG key for qg node"}
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_decConstScoreWLKey {this, "ConstScoreWLNameDec", "ConstScore_wl", "SG key for WL node"}
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_decConstScoreWTKey {this, "ConstScoreWTNameDec", "ConstScore_wt", "SG key for WT node"}
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_decConstScoreZLKey {this, "ConstScoreZLNameDec", "ConstScore_zl", "SG key for ZL node"}
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_decConstScoreZTKey {this, "ConstScoreZTNameDec", "ConstScore_zt", "SG key for ZT node"}
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_decConstScoreCosTKey {this, "ConstScoreCosTNameDec", "ConstScore_cosT", "SG key for cosT regress"}
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_decConstScorePT1Key {this, "ConstScorePT1NameDec", "ConstScore_pT1", "SG key for pT1 regress"}
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_decConstScoreEta1Key {this, "ConstScoreEta1NameDec", "ConstScore_eta1", "SG key for eta1 regress"}
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_decConstScorePhi1Key {this, "ConstScorePhi1NameDec", "ConstScore_phi1", "SG key for phi1 regress"}
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_decConstScorePT2Key {this, "ConstScorePT2NameDec", "ConstScore_pT2", "SG key for pT2 regress"}
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_decConstScoreEta2Key {this, "ConstScoreEta2NameDec", "ConstScore_eta2", "SG key for eta2 regress"}
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_decConstScorePhi2Key {this, "ConstScorePhi2NameDec", "ConstScore_phi2", "SG key for phi2 regress"}
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

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

{Unknown, WBoson, ZBoson, TopQuark};

Constructor & Destructor Documentation

JSSTaggerUtils()

JSSTaggerUtils::JSSTaggerUtils

(

const std::string &

name

)

Constructor.

Definition at line 35 of file JSSTaggerUtils.cxx.

                                                      :
  JSSTaggerBase( name )
{
  declareProperty("MLBosonTagger", m_MLBosonTagger, "Tool to manage the data pre-processing and inference of the Const model");
  declareProperty("MLBosonTaggerHL", m_MLBosonTagger_HL, "Tool to manage the data pre-processing and inference of the High-Level model");
  declareProperty("nPixelsEta", m_nbins_eta);
  declareProperty("nPixelsPhi", m_nbins_phi);
  declareProperty("nColors", m_ncolors);
  declareProperty("MinEtaRange", m_min_eta);
  declareProperty("MaxEtaRange", m_max_eta);
  declareProperty("MinPhiRange", m_min_phi);
  declareProperty("MaxPhiRange", m_max_phi);
  declareProperty("DoRScaling", m_dorscaling);
  declareProperty("RScaling_p0", m_rscaling_p0);
  declareProperty("RScaling_p1", m_rscaling_p1);
}

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

WTA N-subjettiness ratios

ECF ratios

Definition at line 400 of file JSSTaggerBase.cxx.

                                                                {
 
  int result = 0;

  SG::WriteDecorHandle<xAOD::JetContainer, float> decTau21WTA(m_decTau21WTAKey);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decTau32WTA(m_decTau32WTAKey);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decTau42WTA(m_decTau42WTAKey);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decC2(m_decC2Key);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decD2(m_decD2Key);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decE3(m_decE3Key);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decL2(m_decL2Key);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decL3(m_decL3Key);

  float tau21_wta = -999.0;
  float tau32_wta = -999.0;
  float tau42_wta = -999.0;
 
  if(!m_isSmallRJet){
    SG::ReadDecorHandle<xAOD::JetContainer, float> readTau1WTA(m_readTau1WTAKey);
    SG::ReadDecorHandle<xAOD::JetContainer, float> readTau2WTA(m_readTau2WTAKey);
    SG::ReadDecorHandle<xAOD::JetContainer, float> readTau3WTA(m_readTau3WTAKey);
    SG::ReadDecorHandle<xAOD::JetContainer, float> readTau4WTA(m_readTau4WTAKey);
 
    float tau1_wta = readTau1WTA(jet);
    float tau2_wta = readTau2WTA(jet);
    float tau3_wta = readTau3WTA(jet);
    float tau4_wta = readTau4WTA(jet);
 
    if ( tau1_wta > 1e-8 ) {
      tau21_wta = tau2_wta / tau1_wta;
    }
    else result = 1;
 
    if ( tau2_wta > 1e-8 ) {
      tau32_wta = tau3_wta / tau2_wta;
      tau42_wta = tau4_wta / tau2_wta;
    }
    else result = 1;
  }
 
  decTau21WTA(jet) = tau21_wta;
  decTau32WTA(jet) = tau32_wta;
  decTau42WTA(jet) = tau42_wta;

  float C2 = -999.0;
  float D2 = -999.0;
  float e3 = -999.0;
 
  // L-series for UFO top taggers
  float L2 = -999.0;
  float L3 = -999.0;
 
  if(!m_isSmallRJet){
    SG::ReadDecorHandle<xAOD::JetContainer, float> readECF1(m_readECF1Key);
    SG::ReadDecorHandle<xAOD::JetContainer, float> readECF2(m_readECF2Key);
    SG::ReadDecorHandle<xAOD::JetContainer, float> readECF3(m_readECF3Key);
 
    float ECF1 = readECF1(jet);
    float ECF2 = readECF2(jet);
    float ECF3 = readECF3(jet);
 
    if ( ECF2 > 1e-8 ) {
      C2 = ECF3 * ECF1 / std::pow( ECF2, 2.0 );
      D2 = ECF3 * std::pow( ECF1, 3.0 ) / std::pow( ECF2, 3.0 );
    }
    else result = 1;
 
    e3 = ECF3 / std::pow( ECF1, 3.0 );
 
    SG::ReadDecorHandle<xAOD::JetContainer, float> readECFG331(m_readECFG331Key);
    SG::ReadDecorHandle<xAOD::JetContainer, float> readECFG311(m_readECFG311Key);
    SG::ReadDecorHandle<xAOD::JetContainer, float> readECFG212(m_readECFG212Key);
 
    if(readECFG331.isAvailable() && readECFG212.isAvailable()){
      if(readECFG212(jet) > 1e-8){
        L2 = readECFG331(jet) / std::pow(readECFG212(jet), 1.5);
      }
      else result = 1;
    }
 
    if(readECFG331.isAvailable() && readECFG311.isAvailable()){
      if(readECFG331(jet) > 1e-8){
        L3 = readECFG311(jet) / std::pow(readECFG331(jet), 1./3.);
      }
      else result = 1;
    }
  }
 
  decC2(jet) = C2;
  decD2(jet) = D2;
  decE3(jet) = e3;
 
  static const SG::AuxElement::ConstAccessor<float> accL2("L2");
  if(!accL2.isAvailable(jet)) decL2(jet) = L2;
 
  static const SG::AuxElement::ConstAccessor<float> accL3("L3");
  if(!accL3.isAvailable(jet)) decL3(jet) = L3;
 
  // TODO: Add ECFG for ANN tagger whenever it is defined
 
  return result;
 
}

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

                                                                                             {
 
  float scale = 1.0;
  if ( m_ptGeV ) scale = 1.e3;
 
  bool passKinRange = true;

  if ( std::abs(jet.eta()) > m_jetEtaMax ) {
    ATH_MSG_VERBOSE( "Jet does not pass basic kinematic selection (|eta| < " << m_jetEtaMax << "). Jet eta = " << jet.eta() );
    acceptData.setCutResult( "ValidEtaRange", false );
    passKinRange = false;
  }
 
  if ( jet.pt() < m_jetPtMin * scale ) {
    ATH_MSG_VERBOSE( "Jet does not pass basic kinematic selection (pT > " << m_jetPtMin * scale / 1.e3 << "). Jet pT = " << jet.pt() / 1.e3 << " GeV" );
    acceptData.setCutResult( "ValidPtRangeLow", false );
    passKinRange = false;
  }
 
  if ( jet.pt() > m_jetPtMax * scale ) {
    ATH_MSG_VERBOSE( "Jet does not pass basic kinematic selection (pT < " << m_jetPtMax * scale / 1.e3 << "). Jet pT = " << jet.pt() / 1.e3 << " GeV" );
    acceptData.setCutResult( "ValidPtRangeHigh", false );
    passKinRange = false;
  }

  SG::WriteDecorHandle<xAOD::JetContainer, char> decValidPtRangeHigh(m_decValidPtRangeHighKey);
  SG::WriteDecorHandle<xAOD::JetContainer, char> decValidPtRangeLow(m_decValidPtRangeLowKey);
  SG::WriteDecorHandle<xAOD::JetContainer, char> decValidEtaRange(m_decValidEtaRangeKey);
  SG::WriteDecorHandle<xAOD::JetContainer, char> decValidKinRange(m_decValidKinRangeKey);

  decValidPtRangeHigh(jet) = acceptData.getCutResult( "ValidPtRangeHigh" );
  decValidPtRangeLow(jet) = acceptData.getCutResult( "ValidPtRangeLow" );
  decValidEtaRange(jet) = acceptData.getCutResult( "ValidEtaRange" );
  decValidKinRange(jet) = passKinRange;
 
  return StatusCode::SUCCESS;
 
}

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

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 BJT::qgTagger, JSSWTopTaggerANN, JSSWTopTaggerDNN, LundNetTagger, SmoothedTopTagger, and SmoothedWZTagger.

Definition at line 272 of file JSSTaggerBase.cxx.

                                                                       {
 
  for ( const auto *jet : jets ) {
    ATH_CHECK( tag(*jet) );
  }
 
  return StatusCode::SUCCESS;
 
}

decorateJSSRatios()

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

protectedinherited

Create write decor handles

WTA N-subjettiness ratios

ECF ratios

Definition at line 508 of file JSSTaggerBase.cxx.

                                                                          {

  SG::WriteDecorHandle<xAOD::JetContainer, float> decTau21WTA(m_decTau21WTAKey);
  bool decor_available = decTau21WTA.isAvailable();
  if(decor_available) return;
 
  SG::WriteDecorHandle<xAOD::JetContainer, float> decTau32WTA(m_decTau32WTAKey);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decTau42WTA(m_decTau42WTAKey);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decC2(m_decC2Key);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decD2(m_decD2Key);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decE3(m_decE3Key);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decL2(m_decL2Key);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decL3(m_decL3Key);
 
  // Use pointers here so we can create only the ones we're configured for
  std::unique_ptr<SG::ReadDecorHandle<xAOD::JetContainer, float>> readTau1WTA;
  std::unique_ptr<SG::ReadDecorHandle<xAOD::JetContainer, float>> readTau2WTA;
  std::unique_ptr<SG::ReadDecorHandle<xAOD::JetContainer, float>> readTau3WTA;
  std::unique_ptr<SG::ReadDecorHandle<xAOD::JetContainer, float>> readTau4WTA;
 
  std::unique_ptr<SG::ReadDecorHandle<xAOD::JetContainer, float>> readECF1;
  std::unique_ptr<SG::ReadDecorHandle<xAOD::JetContainer, float>> readECF2;
  std::unique_ptr<SG::ReadDecorHandle<xAOD::JetContainer, float>> readECF3;
 
  std::unique_ptr<SG::ReadDecorHandle<xAOD::JetContainer, float>> readECFG331;
  std::unique_ptr<SG::ReadDecorHandle<xAOD::JetContainer, float>> readECFG311;
  std::unique_ptr<SG::ReadDecorHandle<xAOD::JetContainer, float>> readECFG212;
 
  if(!m_isSmallRJet){
    readTau1WTA = std::make_unique<SG::ReadDecorHandle<xAOD::JetContainer, float> >(m_readTau1WTAKey);
    readTau2WTA = std::make_unique<SG::ReadDecorHandle<xAOD::JetContainer, float> >(m_readTau2WTAKey);
    readTau3WTA = std::make_unique<SG::ReadDecorHandle<xAOD::JetContainer, float> >(m_readTau3WTAKey);
    readTau4WTA = std::make_unique<SG::ReadDecorHandle<xAOD::JetContainer, float> >(m_readTau4WTAKey);
 
    readECF1 = std::make_unique<SG::ReadDecorHandle<xAOD::JetContainer, float> >(m_readECF1Key);
    readECF2 = std::make_unique<SG::ReadDecorHandle<xAOD::JetContainer, float> >(m_readECF2Key);
    readECF3 = std::make_unique<SG::ReadDecorHandle<xAOD::JetContainer, float> >(m_readECF3Key);
 
    readECFG331 = std::make_unique<SG::ReadDecorHandle<xAOD::JetContainer, float> >(m_readECFG331Key);
    readECFG311 = std::make_unique<SG::ReadDecorHandle<xAOD::JetContainer, float> >(m_readECFG311Key);
    readECFG212 = std::make_unique<SG::ReadDecorHandle<xAOD::JetContainer, float> >(m_readECFG212Key);
  }
 
  for(const xAOD::Jet* jet : jets){
 
    float tau21_wta = -999.0;
    float tau32_wta = -999.0;
    float tau42_wta = -999.0;
 
    float C2 = -999.0;
    float D2 = -999.0;
    float e3 = -999.0;
 
    float L2 = -999.0;
    float L3 = -999.0;
 
    if(!m_isSmallRJet){

      float tau1_wta = (*readTau1WTA)(*jet);
      float tau2_wta = (*readTau2WTA)(*jet);
      float tau3_wta = (*readTau3WTA)(*jet);
      float tau4_wta = (*readTau4WTA)(*jet);
 
      if ( tau1_wta > 1e-8 ) {
    tau21_wta = tau2_wta / tau1_wta;
      }
 
      if ( tau2_wta > 1e-8 ) {
    tau32_wta = tau3_wta / tau2_wta;
    tau42_wta = tau4_wta / tau2_wta;
      }

      float ECF1 = (*readECF1)(*jet);
      float ECF2 = (*readECF2)(*jet);
      float ECF3 = (*readECF3)(*jet);
 
      if ( ECF2 > 1e-8 ) {
    C2 = ECF3 * ECF1 / std::pow( ECF2, 2.0 );
    D2 = ECF3 * std::pow( ECF1, 3.0 ) / std::pow( ECF2, 3.0 );
      }
 
      e3 = ECF3 / std::pow( ECF1, 3.0 );
 
      // L-series for UFO top taggers
      if((*readECFG331).isAvailable() && (*readECFG212).isAvailable()){
        if((*readECFG212)(*jet) > 1e-8){
          L2 = (*readECFG331)(*jet) / std::pow((*readECFG212)(*jet), 1.5);
        }
      }
 
      if((*readECFG331).isAvailable() && (*readECFG311).isAvailable()){
        if((*readECFG331)(*jet) > 1e-8){
          L3 = (*readECFG311)(*jet) / std::pow((*readECFG331)(*jet), 1./3.);
        }
      }
    }
 
    decTau21WTA(*jet) = tau21_wta;
    decTau32WTA(*jet) = tau32_wta;
    decTau42WTA(*jet) = tau42_wta;
 
    decC2(*jet) = C2;
    decD2(*jet) = D2;
    decE3(*jet) = e3;
 
    static const SG::AuxElement::ConstAccessor<float> accL2("L2");
    if(!accL2.isAvailable(*jet)) decL2(*jet) = L2;
 
    static const SG::AuxElement::ConstAccessor<float> accL3("L3");
    if(!accL3.isAvailable(*jet)) decL3(*jet) = L3;
 
    // TODO: Add ECFG for ANN tagger whenever it is defined
 
  }
 
  return;
 
}

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.

{ return m_detStore; }

evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ 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 631 of file JSSTaggerBase.cxx.

                               {
 
  int indexPV = -1;
 
  const xAOD::VertexContainer* vxCont = nullptr;
  if ( evtStore()->retrieve( vxCont, "PrimaryVertices" ).isFailure() ) {
    ATH_MSG_WARNING( "Unable to retrieve primary vertex container PrimaryVertices" );
  }
  else {
    int vtx_counter = 0;
    for ( const auto *vx : *vxCont ) {
      if ( vx->vertexType()==xAOD::VxType::PriVtx ) {
    indexPV = vtx_counter;
        break;
      }
      vtx_counter++;
    }
  }
 
  return indexPV;
 
}

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

                                          {
 
  ATH_MSG_INFO( "Using config file : " << m_configFile );

  std::string configPath;
 
  if ( m_calibArea.compare("Local") == 0 ) {
    configPath = PathResolverFindCalibFile(m_configFile);
  }
  else if ( m_calibArea.find("eos") != std::string::npos) {
    configPath = PathResolverFindCalibFile(m_calibArea+"/"+m_configFile);
    configPath = (m_calibArea+"/"+m_configFile);
  }
  else {
    configPath = PathResolverFindCalibFile("BoostedJetTaggers/"+m_calibArea+"/"+m_configFile);
  }

  FileStat_t fStats;
  int fSuccess = gSystem->GetPathInfo(configPath.c_str(), fStats);
  if ( fSuccess ) {
    ATH_MSG_ERROR( "Recommendations file " << m_configFile << " could not be found" );
    return StatusCode::FAILURE;
  }
  else {
    ATH_MSG_DEBUG( "Recommendations file was found : " << configPath );
  }
 
  if ( m_configReader.ReadFile( configPath.c_str(), EEnvLevel(0) ) ) {
    ATH_MSG_ERROR( "Error while reading config file : "<< configPath );
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
 
}

GetConstScore()

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

overridevirtual

Implements IJSSTaggerUtils.

Definition at line 262 of file JSSTaggerUtils.cxx.

                                                                           {
 
  SG::WriteDecorHandle<xAOD::JetContainer, float> decConstScore(m_decConstScoreKey);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decNConstituents(m_decNConstituentsKey);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decNTopoTowers(m_decNTopoTowersKey);
  SG::AuxElement::ConstAccessor<std::vector<ElementLink<DataVector<xAOD::IParticle>>>> towersAcc("GhostTower");
 
  for(const xAOD::Jet *jet : jets){
 
    // init value
    float score (-99.);
 
    // get constituents
    std::vector<xAOD::JetConstituent> constituents = jet -> getConstituents().asSTLVector();
    std::sort( constituents.begin(), constituents.end(), DescendingPtSorterConstituents) ;
 
    int MaxConstituents (100);
    std::vector<xAOD::JetConstituent> constituentsForModel;
 
    if( constituents.size() > 100 )
      constituentsForModel = std::vector<xAOD::JetConstituent> (constituents.begin(), constituents.begin() + MaxConstituents);
    else 
      constituentsForModel = constituents;
 
    // get towers
    std::vector<const xAOD::CaloCluster*> towers;
    if (towersAcc.isAvailable(*jet)){
      // Vector of towers linked to jets
      std::vector<ElementLink<DataVector<xAOD::IParticle>>> towerLinks = towersAcc(*jet);
      for (auto link_itr : towerLinks){
        if (!link_itr.isValid()) continue;
        towers.push_back(dynamic_cast<const xAOD::CaloCluster *>(*link_itr));
      }
    }
    std::sort( towers.begin(), towers.end(), DescendingPtSorterConstituents);
 
    // use ML tool on constituents
    std::vector<float> m, pT, eta, phi, E;
    for(auto cnst : constituents){
      m.push_back( cnst -> m() );
      pT.push_back( cnst -> pt() );
      eta.push_back( cnst -> eta() );
      phi.push_back( cnst -> phi() );
      E.push_back( cnst -> e() );
    }
    std::vector<std::vector<float>> constituents_packed = {m, pT, eta, phi};
 
    m.clear(); pT.clear(); eta.clear(); phi.clear();
    for(auto cnst : towers){
      m.push_back( cnst -> m() );
      pT.push_back( cnst -> pt() );
      eta.push_back( cnst -> eta() );
      phi.push_back( cnst -> phi() );
      E.push_back( cnst -> e() );
    }
    std::vector<std::vector<float>> towers_packed{std::move(m), std::move(pT), std::move(eta), std::move(phi)};
 
    // pack for the ML tool
    std::vector<std::vector<float>> inputs_packed = {
      constituents_packed.at(0), constituents_packed.at(1), constituents_packed.at(2), constituents_packed.at(3),
      towers_packed.at(0), towers_packed.at(1), towers_packed.at(2), towers_packed.at(3),
    };
 
    // evaluate the model
    if( (constituents.size() + towers.size()) > 1 )
      score = m_MLBosonTagger -> retrieveConstituentsScore(std::move(inputs_packed));
 
    // save decorator
    decConstScore(*jet) = score;
 
    // and inputs as well
    decNConstituents(*jet) = constituents.size();
    decNTopoTowers(*jet) = towers.size();
 
  }
 
  return StatusCode::SUCCESS;
 
}

GetHLScore()

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

overridevirtual

Implements IJSSTaggerUtils.

Definition at line 483 of file JSSTaggerUtils.cxx.

                                                                        {
 
  SG::WriteDecorHandle<xAOD::JetContainer, float> decHLScore(m_decHLScoreKey);
 
  // make available JSS variables
  decorateJSSRatios(jets);
 
  for(const xAOD::Jet* jet : jets){
 
    // init value
    float score (-99.);
    
    // get input variables
    std::map<std::string, double> JSSVars = GetJSSVars(*jet);
 
    // evaluate the model
    score = m_MLBosonTagger_HL -> retrieveHighLevelScore(std::move(JSSVars));
    
    // save decorator
    decHLScore(*jet) = score;
 
  }
 
  return StatusCode::SUCCESS;
 
}

GetImageScore()

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

overridevirtual

Implements IJSSTaggerUtils.

Definition at line 196 of file JSSTaggerUtils.cxx.

                                                                           {
 
  SG::WriteDecorHandle<xAOD::JetContainer, float> decConstScore(m_decConstScoreKey);
 
  for(const xAOD::Jet* jet : jets){
 
    // init value
    float score (-99.);
 
    // preliminary actions for constituents
    // add a dedicated function for this?
 
    // get constituents
    std::vector<xAOD::JetConstituent> constituents = jet -> getConstituents().asSTLVector();
    std::sort( constituents.begin(), constituents.end(), DescendingPtSorterConstituents) ;
 
    int MaxConstituents (100);
    std::vector<xAOD::JetConstituent> constituentsForModel;
 
    if( constituents.size() > 100 )
      constituentsForModel = std::vector<xAOD::JetConstituent> (constituents.begin(), constituents.begin() + MaxConstituents);
    else 
      constituentsForModel = std::move(constituents);
 
    // constituents - charged
    std::vector<xAOD::JetConstituent> csts_charged = constituentsForModel;
    csts_charged.erase( std::remove_if( csts_charged.begin(), csts_charged.end(),
                        [] (xAOD::JetConstituent constituent) -> bool {
                          const xAOD::FlowElement* ufo = static_cast<const xAOD::FlowElement*>(constituent.rawConstituent());
                          return ufo -> signalType() != xAOD::FlowElement::SignalType::Charged;
                        }), csts_charged.end()) ;
 
    // constituents - neutral
    std::vector<xAOD::JetConstituent> csts_neutral = constituentsForModel;
    csts_neutral.erase( std::remove_if( csts_neutral.begin(), csts_neutral.end(),
                        [] (xAOD::JetConstituent constituent) -> bool {
                          const xAOD::FlowElement* ufo = static_cast<const xAOD::FlowElement*>(constituent.rawConstituent());
                          return ufo -> signalType() != xAOD::FlowElement::SignalType::Neutral;
                        }), csts_neutral.end()) ;
 
    // constituents - combined
    std::vector<xAOD::JetConstituent> csts_combined = std::move(constituentsForModel);
    csts_combined.erase( std::remove_if( csts_combined.begin(), csts_combined.end(),
                        [] (xAOD::JetConstituent constituent){
                          const xAOD::FlowElement* ufo = static_cast<const xAOD::FlowElement*>(constituent.rawConstituent());
                          return ufo -> signalType() != xAOD::FlowElement::SignalType::Combined;
                        }), csts_combined.end()) ;
 
    // use ML tool on constituents
    TH2D ImageCharged  = MakeJetImage("Charged" , jet, std::move(csts_charged) );
    TH2D ImageNeutral  = MakeJetImage("Neutral" , jet, std::move(csts_neutral) );
    TH2D ImageCombined = MakeJetImage("Combined", jet, std::move(csts_combined));
 
    std::vector<TH2D> Images = {ImageCharged, ImageNeutral, ImageCombined};
 
    // evaluate the model
    score = m_MLBosonTagger -> retrieveConstituentsScore(std::move(Images));
 
    // save decorator
    decConstScore(*jet) = score;
  }
 
  return StatusCode::SUCCESS;
 
}

GetJSSVars()

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

overridevirtual

Implements IJSSTaggerUtils.

Definition at line 510 of file JSSTaggerUtils.cxx.

                                                                             {
 
  std::map<std::string, double> JSSVars;
 
  // retrieve ungroomed tracks multiplicity
  int nUngrTracks (-1);
  int pv_location = findPV();
  if(pv_location != -1)
    nUngrTracks = GetUnGroomTracks(jet, pv_location);
 
  // store input variables
  JSSVars["pT"] = jet.pt();
  JSSVars["nTracks"] = nUngrTracks;
  JSSVars["CNN"] = (*m_constScoreAcc)(jet);
 
  // define the decorator readers
  SG::ReadDecorHandle<xAOD::JetContainer, float> readSplit12(m_readSplit12Key);
  SG::ReadDecorHandle<xAOD::JetContainer, float> readSplit23(m_readSplit23Key);
 
  SG::ReadDecorHandle<xAOD::JetContainer, float> readTau1_wta(m_readTau1WTAKey);
  SG::ReadDecorHandle<xAOD::JetContainer, float> readTau2_wta(m_readTau2WTAKey);
  SG::ReadDecorHandle<xAOD::JetContainer, float> readTau3_wta(m_readTau3WTAKey);
 
  SG::ReadDecorHandle<xAOD::JetContainer, float> readECF1(m_readECF1Key);
  SG::ReadDecorHandle<xAOD::JetContainer, float> readECF2(m_readECF2Key);
  SG::ReadDecorHandle<xAOD::JetContainer, float> readECF3(m_readECF3Key);
 
  SG::ReadDecorHandle<xAOD::JetContainer, float> readQw(m_readQwKey);
 
  // define the ConstAccessor
  static const SG::ConstAccessor<float> FoxWolfram0Acc("FoxWolfram0");
  static const SG::ConstAccessor<float> FoxWolfram2Acc("FoxWolfram2");
  static const SG::ConstAccessor<float> PlanarFlowAcc("PlanarFlow");
  static const SG::ConstAccessor<float> AngularityAcc("Angularity");
  static const SG::ConstAccessor<float> AplanarityAcc("Aplanarity");
  static const SG::ConstAccessor<float> ZCut12Acc("ZCut12");
  static const SG::ConstAccessor<float> KtDRAcc("KtDR");
  static const SG::ConstAccessor<float> D2Acc("D2");
 
  // split
  JSSVars["Split12"] = readSplit12(jet);
  JSSVars["Split23"] = readSplit23(jet);
 
  // Energy Correlation Functions
  JSSVars["D2"] = D2Acc(jet);
 
  // Tau123 WTA
  JSSVars["Tau1_wta"] = readTau1_wta(jet);
  JSSVars["Tau2_wta"] = readTau2_wta(jet);
  JSSVars["Tau3_wta"] = readTau3_wta(jet);
 
  // ECF
  JSSVars["ECF1"] = readECF1(jet);
  JSSVars["ECF2"] = readECF2(jet);
  JSSVars["ECF3"] = readECF3(jet);
 
  // Qw
  JSSVars["Qw"] = readQw(jet);
 
  // Other moments
  JSSVars["FoxWolfram0"] = FoxWolfram0Acc.withDefault(jet, -99.);
  JSSVars["FoxWolfram2"] = FoxWolfram2Acc.withDefault(jet, -99.);
  JSSVars["PlanarFlow"] = PlanarFlowAcc.withDefault(jet, -99.);
  JSSVars["Angularity"] = AngularityAcc.withDefault(jet, -99.);
  JSSVars["Aplanarity"] = AplanarityAcc.withDefault(jet, -99.);
  JSSVars["ZCut12"] = ZCut12Acc.withDefault(jet, -99.);
  JSSVars["KtDR"] = KtDRAcc.withDefault(jet, -99.);
 
  return JSSVars;
 
}

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::Event both provide ways for getting the SG::sgkey_t key for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

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

See also

asg::AsgTool::getName

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The hashed key of the object in the store. If not found, an invalid (zero) key.

Definition at line 119 of file AsgTool.cxx.

                                                    {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::Event, we have a direct function call
      // for this.
      return evtStore()->event()->getKey( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      return ( proxy == nullptr ? 0 : proxy->sgkey() );
#endif // XAOD_STANDALONE
   }

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::Event both provide ways for getting the std::string name for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

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

See also

asg::AsgTool::getKey

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The string name of the object in the store. If not found, an empty string.

Definition at line 106 of file AsgTool.cxx.

                                                            {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::Event, we have a direct function call
      // for this.
      return evtStore()->event()->getName( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      static const std::string dummy = "";
      return ( proxy == nullptr ? dummy : proxy->name() );
#endif // XAOD_STANDALONE
   }

GetPolarisationScore()

StatusCode JSSTaggerUtils::GetPolarisationScore ( const xAOD::JetContainer & jets ) const

overridevirtual

Implements IJSSTaggerUtils.

Definition at line 991 of file JSSTaggerUtils.cxx.

                                                                                  {
 
  SG::WriteDecorHandle<xAOD::JetContainer, float> decConstScore(m_decConstScoreKey);
 
  SG::WriteDecorHandle<xAOD::JetContainer, float> decConstScore_qg(m_decConstScoreQGKey);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decConstScore_wl(m_decConstScoreWLKey);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decConstScore_wt(m_decConstScoreWTKey);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decConstScore_zl(m_decConstScoreZLKey);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decConstScore_zt(m_decConstScoreZTKey);
 
  SG::WriteDecorHandle<xAOD::JetContainer, float> decConstScore_cosT(m_decConstScoreCosTKey);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decConstScore_pT1(m_decConstScorePT1Key);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decConstScore_eta1(m_decConstScoreEta1Key);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decConstScore_phi1(m_decConstScorePhi1Key);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decConstScore_pT2(m_decConstScorePT2Key);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decConstScore_eta2(m_decConstScoreEta2Key);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decConstScore_phi2(m_decConstScorePhi2Key);
 
  // define vectors to store constituents for calculations
  const long unsigned int nMaxConstituents (70);
  std::vector<float> pT, eta, phi, E;
  pT.reserve(nMaxConstituents); eta.reserve(nMaxConstituents); phi.reserve(nMaxConstituents); E.reserve(nMaxConstituents);
 
  for(const xAOD::Jet *jet : jets){
 
    // init value
    std::vector<float> scores;
 
    // get constituents
    std::vector<xAOD::JetConstituent> constituents = jet -> getConstituents().asSTLVector();
 
    // skip non physical constituents
    constituents.erase( std::remove_if( constituents.begin(), constituents.end(),
                        [] (xAOD::JetConstituent constituent) -> bool {return constituent -> pt() < 1.e-3;}), 
                        constituents.end()) ;
 
    // sort by pT
    std::sort( constituents.begin(), constituents.end(), DescendingPtSorterConstituents) ;
 
    std::vector<xAOD::JetConstituent> constituentsForModel;
 
    if( constituents.size() > nMaxConstituents )
    {
      constituentsForModel = std::vector<xAOD::JetConstituent> (constituents.begin(), constituents.begin() + nMaxConstituents);
    }
    else 
      constituentsForModel = constituents;
 
    // build constituents, mask and base momentum for interaction variables
    std::vector<std::vector<float>> const_vars;
    std::vector<std::vector<float>> masks_vars;
    std::vector<std::vector<std::vector<float>>> inter_vars;
 
    for (const auto& ci : constituentsForModel) {
 
      // put the constituent in a tlv for help
      TLorentzVector constituent_i;
      constituent_i.SetPtEtaPhiE(ci.pt(), ci.eta(), ci.phi(), ci.e());
 
      // calculate variables
      float log_pT = log(ci.pt());
      float log_E = log(ci.e());
      float log_pT_rel = log(Clip(ci.pt() / jet->pt(), 1.e-8));
      float log_E_rel = log(Clip(ci.e() / jet->e(), 1.e-8));
      float Deta = ci.eta() - jet->eta();
      float Dphi = constituent_i.DeltaPhi(jet->p4());
      float DR = constituent_i.DeltaR(jet->p4());
 
      // pack: constituents variables
      std::vector<float> vars = {log_pT, log_E,
                                 (float)ci.eta(), (float)ci.phi(),
                                 log_pT_rel, log_E_rel, Deta, Dphi, DR};
      const_vars.push_back(vars);
 
      // pack: mask variable
      vars = {1.};
      masks_vars.push_back(std::move(vars));
 
      // explict interaction variables
      // calculate variables: interactions
      std::vector<std::vector<float>> inter_vars_int;
      for (const auto& cj : constituentsForModel) {
        // tlv for constituents
        TLorentzVector constituent_j;
        constituent_j.SetPtEtaPhiE(cj.pt(), cj.eta(), cj.phi(), cj.e());
  
        // preparing variables
        float delta = constituent_i.DeltaR(constituent_j, true);
        float min = std::min(ci.pt(), cj.pt());
        float mass2 = (constituent_i + constituent_j).M2();
 
        // final values
        float log_delta = log(Clip(delta, 1.e-8));        
        float log_mindelta = log(Clip(min * delta, 1.e-8));
        float log_min_over_pT = log(Clip(min / (ci.pt() + cj.pt()), 1.e-8));
        float log_mass2 = log(Clip(mass2, 1.e-8));
 
        // set the diagonal to 0
        if(&ci == &cj){
          log_delta = 0;
          log_mindelta = 0;
          log_min_over_pT = 0;
          log_mass2 = 0;
        }
 
        std::vector<float> vars = { log_delta,
                                    log_mindelta,
                                    log_min_over_pT,
                                    log_mass2
                                  };
        inter_vars_int.push_back(std::move(vars));
      }
 
      inter_vars.push_back(inter_vars_int);
    }
 
    // adjust
    std::vector<std::vector<float>> vars_inter;
    vars_inter.reserve(nMaxConstituents);
    for(long unsigned int i=constituents.size(); i<nMaxConstituents; i++){
      // pack: constituents variables
      std::vector<float> vars = {-99., -99., -99., -99., -99., -99., -99., -99., -99.};
      const_vars.push_back(vars);
 
      // pack: interaction variables
      vars_inter.clear();
      vars = {-99., -99., -99., -99.};
      for(long unsigned int j=0; j<nMaxConstituents; j++){
        vars_inter.push_back(vars);
      }
      inter_vars.push_back(vars_inter);
 
      // pack: mask variable
      vars = {0.};
      masks_vars.push_back(vars);
    }
 
    for(long unsigned int i=0; i<constituents.size(); i++){
      std::vector<float> vars = {-99., -99., -99., -99.};
      for(long unsigned int j=constituents.size(); j<nMaxConstituents; j++){
        inter_vars.at(i).push_back(vars);
      }
    }
 
    // evaluate the model
    if( constituents.size() > 1 ) 
      scores = m_MLBosonTagger -> retrieveConstituentsScoreMultiClass(const_vars, inter_vars, masks_vars);
 
    // save decorator(s)
    // score not available
    if(scores.size() == 0)
      decConstScore(*jet) = -99.;
    // binary or regression
    else if(scores.size() == 1)
      decConstScore(*jet) = scores.at(0);
    // multiclass
    else if(scores.size() == 5){
      decConstScore_qg(*jet) = scores.at(0);
      decConstScore_wl(*jet) = scores.at(1);
      decConstScore_wt(*jet) = scores.at(2);
      decConstScore_zl(*jet) = scores.at(3);
      decConstScore_zt(*jet) = scores.at(4);
    }
    // multi regression
    else if(scores.size() == 7){
      decConstScore_pT1(*jet) = scores.at(0);
      decConstScore_eta1(*jet) = scores.at(1);
      decConstScore_phi1(*jet) = scores.at(2);
      decConstScore_pT2(*jet) = scores.at(3);
      decConstScore_eta2(*jet) = scores.at(4);
      decConstScore_phi2(*jet) = scores.at(5);
      decConstScore_cosT(*jet) = scores.at(6);
    }
    // multiclass + regression
    else if(scores.size() == 12){
      decConstScore_qg(*jet) = scores.at(0);
      decConstScore_wl(*jet) = scores.at(1);
      decConstScore_wt(*jet) = scores.at(2);
      decConstScore_zl(*jet) = scores.at(3);
      decConstScore_zt(*jet) = scores.at(4);
      decConstScore_pT1(*jet) = scores.at(5);
      decConstScore_eta1(*jet) = scores.at(6);
      decConstScore_phi1(*jet) = scores.at(7);
      decConstScore_pT2(*jet) = scores.at(8);
      decConstScore_eta2(*jet) = scores.at(9);
      decConstScore_phi2(*jet) = scores.at(10);
      decConstScore_cosT(*jet) = scores.at(11);
    }
    else{
      ATH_MSG_ERROR("ERROR: the output size of this tagger is not currently supported!");
      return StatusCode::FAILURE;
    }
 
  }
  
  return StatusCode::SUCCESS;
}

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 342 of file JSSTaggerUtils.cxx.

                                                                             {
 
  SG::WriteDecorHandle<xAOD::JetContainer, float> decConstScore(m_decConstScoreKey);
  SG::AuxElement::ConstAccessor<std::vector<ElementLink<DataVector<xAOD::IParticle>>>> towersAcc("GhostTower");
  for(const xAOD::Jet *jet : jets){
 
    // init value
    float score (-99.);
 
    // get constituents
    std::vector<xAOD::JetConstituent> constituents = jet -> getConstituents().asSTLVector();
    std::sort( constituents.begin(), constituents.end(), DescendingPtSorterConstituents) ;
 
    // get towers
    std::vector<const xAOD::CaloCluster*> towers;
    
    if (towersAcc.isAvailable(*jet)){
      // Vector of towers linked to jets
      std::vector<ElementLink<DataVector<xAOD::IParticle>>> towerLinks = towersAcc(*jet);
      for (auto link_itr : towerLinks){
        if (!link_itr.isValid()) continue;
        towers.push_back(dynamic_cast<const xAOD::CaloCluster *>(*link_itr));
      }
    }
    std::sort( towers.begin(), towers.end(), DescendingPtSorterConstituents) ;
 
    // use ML tool on constituents
    std::vector<float> m, pT, eta, phi, E, isTower, px, py, pz;
    for(auto cnst : constituents){
      m.push_back( cnst -> m() );
      pT.push_back( cnst -> pt() );
      eta.push_back( cnst -> eta() );
      phi.push_back( cnst -> phi() );
      E.push_back( cnst -> e() );
      isTower.push_back(0.);
      px.push_back( cnst -> pt() * std::cos(cnst -> phi()) );
      py.push_back( cnst -> pt() * std::sin(cnst -> phi()) );
      pz.push_back( cnst -> pt() * std::sinh(cnst -> eta()) );
    }
 
    for(auto cnst : towers){
      m.push_back( cnst -> m() );
      pT.push_back( cnst -> pt() );
      eta.push_back( cnst -> eta() );
      phi.push_back( cnst -> phi() );
      E.push_back( cnst -> e() );
      isTower.push_back(1.);
      px.push_back( cnst -> pt() * std::cos(cnst -> phi()) );
      py.push_back( cnst -> pt() * std::sin(cnst -> phi()) );
      pz.push_back( cnst -> pt() * std::sinh(cnst -> eta()) );
    }
 
    // put together constituents + towers
    std::vector<std::vector<float>> features_packed;
 
    for(long unsigned int f=0; f<pT.size(); f++){
      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) };
      features_packed.push_back(std::move(features));
    }
 
    // sort them
    std::sort(features_packed.begin(), features_packed.end(), [](const auto& i, const auto& j) { return i.at(1) > j.at(1); });
 
    // global aux variables
    float sum_features_px = std::accumulate(px.begin(), px.end(), 0);
    float sum_features_py = std::accumulate(py.begin(), py.end(), 0);
    float sum_features_pz = std::accumulate(pz.begin(), pz.end(), 0);
 
    float sum_features_pT = sqrt( sum_features_px*sum_features_px + sum_features_py*sum_features_py);
    float sum_features_eta = std::asinh( sum_features_pz / Clip(sum_features_pT) );
    float sum_features_phi = std::atan2( sum_features_py, sum_features_px );
 
    // build constituents and interaction variables
    std::vector<std::vector<float>> const_vars;
    std::vector<std::vector<std::vector<float>>> inter_vars;
 
    for(auto const &feature_i : features_packed){
 
      // calculate variables: constituents
      float log_pT = log( Clip(feature_i.at(1) / sum_features_pT) );
      float log_E = log( Clip(feature_i.at(4) / sum_features_pT) );
      float eta = feature_i.at(2) - sum_features_eta;
      float phi = feature_i.at(3) - sum_features_phi;
      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));
      float log_m = log(Clip(feature_i.at(0)));
      float type = feature_i.at(5);
 
      std::vector<float> vars = {log_pT, log_E, eta, phi, DR, log_m, type};
      const_vars.push_back(std::move(vars));
 
      // calculate variables: interactions
      std::vector<std::vector<float>> inter_vars_int;
      for(auto const &feature_j : features_packed){
 
        // preparing variables
        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)));
        float min = feature_i.at(1) != feature_j.at(1) ? std::min(feature_i.at(1), feature_j.at(1)): 0.;
        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);
        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);
        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);
        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);
 
        // final values
        float log_delta = log(Clip(delta));
        float log_mindelta = log(Clip(min * delta  / sum_features_pT));
        float min_over_pT = min / (feature_i.at(1) + feature_j.at(1));
        float log_mass = log(Clip(mass2));
 
        // set the diagonal to 0
        if(feature_i==feature_j){
          log_delta = 0;
          log_mindelta = 0;
          min_over_pT = 0;
          log_mass = 0;
        }
 
        std::vector<float> vars = { log_delta,
                                    log_mindelta,
                                    min_over_pT,
                                    log_mass
                                  };
        inter_vars_int.push_back(std::move(vars));
 
      }
 
      inter_vars.push_back(std::move(inter_vars_int));
    }
 
    // evaluate the model
    if( (constituents.size() + towers.size()) > 1 ) 
      score = m_MLBosonTagger -> retrieveConstituentsScore(std::move(const_vars), std::move(inter_vars));
 
    // save decorator
    decConstScore(*jet) = score;
 
  }
 
  return StatusCode::SUCCESS;
 
}

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

                                                                                                       {
 
  if ( !passKinRange(jet) ) return std::make_pair( 1.0, 1.0 );
 
 
  double logmOverPt = std::log(jet.m()/jet.pt());
  if ( m_decorationName.find("SmoothZ") != std::string::npos ||
       m_decorationName.find("SmoothInclusiveZ") != std::string::npos ) {
    const double WtoZmassShift = 10803;
    logmOverPt = std::log((jet.m()-WtoZmassShift)/jet.pt());
  }
 
  if ( logmOverPt > 0 ) logmOverPt = 0;
 
  double SF = 1.0;
  double eff = 1.0;
 
  if ( auto it1 = m_weightHistograms.find(truthLabelStr.c_str()); it1 != m_weightHistograms.end()  ) {
    int pt_mPt_bin = (it1->second)->FindBin(jet.pt()*0.001, logmOverPt);
    SF = (it1->second)->GetBinContent(pt_mPt_bin);
    if ( auto it2 = m_efficiencyHistograms.find(truthLabelStr.c_str()); it2 != m_efficiencyHistograms.end()) {
      eff = (it2->second)->GetBinContent(pt_mPt_bin);
    }
  }
  else {
    // set the efficiency for "Other" category to be the signal efficiency
    std::string signal_truthLabel="";
    if ( m_weightHistograms.count("t_qqb") ) {
      signal_truthLabel="t_qqb";
    }else if ( m_weightHistograms.count("V_qq") ){
      signal_truthLabel="V_qq";
    }else if ( m_weightHistograms.count("t") ){
      signal_truthLabel="t";
    }
    if ( !signal_truthLabel.empty() && !m_efficiencyHistogramName.empty() ){
      if (auto pw = m_weightHistograms.find(signal_truthLabel.c_str());pw != m_weightHistograms.end()){
        int pt_mPt_bin = (pw->second)->FindBin(jet.pt()*0.001, logmOverPt);
        if (auto pe = m_efficiencyHistograms.find(signal_truthLabel.c_str());pe != m_efficiencyHistograms.end()){
          eff = (pe->second)->GetBinContent(pt_mPt_bin);
        }
      }
    }
 
    return std::make_pair( 1.0, eff );
  }
 
  if ( SF < 1e-3 ) {
    ATH_MSG_DEBUG( "(pt, m/pt) (" << jet.pt()/1.e3 << ", " << jet.m()/jet.pt() << ") is out of range for SF calculation. Returning 1.0" );
    return std::make_pair( 1.0, 1.0 );
  }
  else {
    return std::make_pair( SF, eff );
  }
 
}

GetTopConstScore()

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

overridevirtual

Implements IJSSTaggerUtils.

Definition at line 669 of file JSSTaggerUtils.cxx.

                                                                              {
 
  SG::WriteDecorHandle<xAOD::JetContainer, float> decConstScore(m_decConstScoreKey);
 
  for(const xAOD::Jet *jet : jets){
 
    // init value
    float score (-99.);
    int parity (1);
 
    // get constituents
    std::vector<xAOD::JetConstituent> constituents = jet -> getConstituents().asSTLVector();
    std::sort( constituents.begin(), constituents.end(), DescendingPtSorterConstituents) ;
 
    // skim constituents
    // nMaxConstituents: used to compute the sum_pT and sum_E for the pre-processing
    // nInputConstituents: actual input to the network
    long unsigned int nMaxConstituents (100);
    long unsigned int nInputConstituents (80);
 
    std::vector<float> pT_nMax, E_nMax;
    for(auto cnst : constituents){
      pT_nMax.push_back( cnst -> pt() );
      E_nMax.push_back( cnst -> e() );
      if(pT_nMax.size()==nMaxConstituents) break;
    }
 
    // remove non physical constituents
    constituents.erase( std::remove_if( constituents.begin(), constituents.end(),
                        [] (xAOD::JetConstituent constituent) -> bool {return log(constituent -> pt()) < 0.1;}), 
                        constituents.end()) ;
 
    // use ML tool on constituents
    std::vector<float> pT, eta, phi, E, isValid, px, py, pz;
    for(auto cnst : constituents){
      pT.push_back( cnst -> pt() );
      eta.push_back( cnst -> eta() );
      phi.push_back( cnst -> phi() );
      E.push_back( cnst -> e() );
      isValid.push_back(1.);
      px.push_back( cnst -> pt() * std::cos(cnst -> phi()) );
      py.push_back( cnst -> pt() * std::sin(cnst -> phi()) );
      pz.push_back( cnst -> pt() * std::sinh(cnst -> eta()) );
    }
    
 
    // global aux variables
    float sum_features_E = std::accumulate(E_nMax.begin(), E_nMax.end(), 0.);
    float sum_features_pT_scalar = std::accumulate(pT_nMax.begin(), pT_nMax.end(), 0.);
 
    TLorentzVector constituent0;
    if(constituents.size() > 0)
      constituent0.SetPtEtaPhiE(pT.at(0), eta.at(0), phi.at(0), E.at(0));
 
    float angle (0.);
    if(constituents.size() > 1){
      float deta01 = eta.at(1) - eta.at(0);
      float dphi01 = phi.at(1) - phi.at(0);
      if(dphi01 > std::numbers::pi) dphi01 -= 2*std::numbers::pi;
      else if(dphi01 < -std::numbers::pi) dphi01 += 2*std::numbers::pi;
 
      angle = std::atan2(dphi01, deta01) + std::numbers::pi/2;
    }
 
    // build constituents, mask and base momentum for interaction variables
    std::vector<std::vector<float>> const_vars;
    std::vector<std::vector<float>> masks_vars;
    std::vector<std::vector<std::vector<float>>> inter_vars;
 
    for(long unsigned int i=0; i<constituents.size(); i++){
 
      // up to nInputConstituents constituents
      if(const_vars.size()==nInputConstituents) break;
 
      // put the constituent in a tlv for help
      TLorentzVector constituent_i;
      constituent_i.SetPtEtaPhiE(pT.at(i), eta.at(i), phi.at(i), E.at(i));
 
      // flip/rot of constituents: center
      float eta_center = eta.at(i) - eta.at(0);
      float phi_center = constituent_i.DeltaPhi(constituent0);
 
      // flip/rot of constituents: rotate
      // ToDo: this does not make sense when nConst == 1, 
      // but it also true that the score is not retrieved for those jets,
      // should we add a further protection?
      float eta_rot =  eta_center * cos(angle) + phi_center * sin(angle);
      float phi_rot = -eta_center * sin(angle) + phi_center * cos(angle);
 
      // flip/rot of constituents: parity
      if(i==2 && eta_rot<0.) parity = -1;
      float eta_flip = eta_rot * parity;
      
      // calculate constituents variables
      float log_pT = log( pT.at(i));
      float log_E = log( E.at(i));
      float log_pT_rel {std::numeric_limits<float>::max()};
      if  (sum_features_pT_scalar != 0.f )[[likely]]{
        log_pT_rel = log( pT.at(i) / sum_features_pT_scalar);
      }
      float log_E_rel{std::numeric_limits<float>::max()};
      if (sum_features_E != 0.f)[[likely]]{
        log_E_rel = log( E.at(i) / sum_features_E);
      }
      float Deta = eta_flip;
      float Dphi = phi_rot;
      float DR = sqrt(Deta*Deta + Dphi*Dphi);
 
      // pack: constituents variables
      std::vector<float> vars = {log_pT, log_E, log_pT_rel, log_E_rel, DR, Deta, Dphi};
      const_vars.push_back(vars);
 
      // pack: mask variable
      vars = {1.};
      masks_vars.push_back(vars);
      
      // explict interaction variables
      // calculate variables: interactions
      std::vector<std::vector<float>> inter_vars_int;
      for(long unsigned int j=0; j<constituents.size(); j++){
 
        // tlv for constituents
        // todo: harmonise with the previous one
        TLorentzVector constituent_j;
        constituent_j.SetPtEtaPhiE(pT.at(j), eta.at(j), phi.at(j), E.at(j));
  
        // preparing variables
 
        // custom rapidity calculation
        double rap_i = 0.5 * log( 1 + (2 * pz.at(i)) / Clip(E.at(i) - pz.at(i), 1.e-8) );
        double rap_j = 0.5 * log( 1 + (2 * pz.at(j)) / Clip(E.at(j) - pz.at(j), 1.e-8) );
        double deltaY = rap_i - rap_j;
        double deltaPhi = TVector2::Phi_mpi_pi(constituent_i.Phi() - constituent_j.Phi());
        double delta = std::sqrt(deltaY * deltaY + deltaPhi * deltaPhi);
 
        float min = pT.at(i) != pT.at(j) ? std::min(pT.at(i), pT.at(j)): pT.at(i);
        float mass2 = (E.at(i) + E.at(j)) * (E.at(i) + E.at(j));
        mass2 -= (px.at(i) + px.at(j)) * (px.at(i) + px.at(j));
        mass2 -= (py.at(i) + py.at(j)) * (py.at(i) + py.at(j));
        mass2 -= (pz.at(i) + pz.at(j)) * (pz.at(i) + pz.at(j));
 
        // final values
        float log_delta = log(Clip(delta, 1.e-8));
        float log_mindelta = log(Clip(min * delta, 1.e-8));
        float log_min_over_pT = log(Clip(min / (pT.at(i) + pT.at(j)), 1.e-8));
        float log_mass = log(Clip(mass2, 1.e-8));
 
        std::vector<float> vars = { log_mindelta,
                                    log_min_over_pT,
                                    log_delta,
                                    log_mass
                                  };
        inter_vars_int.push_back(std::move(vars));
 
      }
      inter_vars.push_back(std::move(inter_vars_int));
 
    }
 
    for(long unsigned int i=constituents.size(); i<nInputConstituents; i++){
      // pack: constituents variables
      std::vector<float> vars = {-18.4207, -18.4207, -18.4207, -18.4207, -18.4207, -18.4207, -18.4207};
      const_vars.push_back(vars);
 
      // pack: interaction variables
      vars = {-18.4207, -18.4207, -18.4207, -18.4207};
      std::vector<std::vector<float>> vars_inter;
      for(long unsigned int j=0; j<nInputConstituents; j++){
        vars_inter.push_back(vars);
      }
      inter_vars.push_back(std::move(vars_inter));
 
      // pack: mask variable
 
      masks_vars.push_back({0.});
    }
 
    // further adjustment for interaction variables
    std::vector<float> vars1 = {-18.4207, -18.4207, -18.4207, -18.4207};
    for(long unsigned int i=0; i<constituents.size(); i++){
      for(long unsigned int j=constituents.size(); j<nInputConstituents; j++){
        inter_vars.at(i).push_back(vars1);
      }
    }
 
    // evaluate the model
    if( constituents.size() > 1 ) 
      score = m_MLBosonTagger -> retrieveConstituentsScore(std::move(const_vars), std::move(inter_vars), std::move(masks_vars));
 
    // save decorator
    // the model return the qcd node score
    // therefore, we use 1 - score to have 
    // top jet: 1, q/g jet: 0
    decConstScore(*jet) = 1 - score;
 
  }
 
  return StatusCode::SUCCESS;
 
}

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

                                                                                               {
  std::string truthLabelStr;

  SG::ReadDecorHandle<xAOD::JetContainer, int> readTruthLabel(m_readTruthLabelKey);
  LargeRJetTruthLabel::TypeEnum jetContainment = LargeRJetTruthLabel::intToEnum(readTruthLabel(jet));

  if ( m_weightHistograms.count("t_qqb") ) {

    if ( jetContainment==LargeRJetTruthLabel::tqqb ) {
      truthLabelStr = "t_qqb";
    }
    else if ( jetContainment==LargeRJetTruthLabel::notruth || jetContainment==LargeRJetTruthLabel::qcd ) {
      truthLabelStr = "q";
    }
 
  }
  else if ( m_weightHistograms.count("V_qq_passMpassD2") ) {

    if ( jetContainment==LargeRJetTruthLabel::tqqb || jetContainment==LargeRJetTruthLabel::other_From_t ) {
      truthLabelStr = "t_";
    }
    else if ( jetContainment==LargeRJetTruthLabel::Wqq || jetContainment==LargeRJetTruthLabel::Zqq || jetContainment==LargeRJetTruthLabel::Wqq_From_t ) {
      truthLabelStr = "V_qq_";
    }
    else if ( jetContainment==LargeRJetTruthLabel::notruth || jetContainment==LargeRJetTruthLabel::qcd ) {
      truthLabelStr = "q_";
    }

    if ( acceptData.getCutResult("PassMassLow") && acceptData.getCutResult("PassMassHigh") && acceptData.getCutResult("PassD2") ) {
      truthLabelStr += "passMpassD2";
    }
    else if ( !(acceptData.getCutResult("PassMassLow") && acceptData.getCutResult("PassMassHigh")) && acceptData.getCutResult("PassD2") ) {
      truthLabelStr += "failMpassD2";
    }
    else if ( acceptData.getCutResult("PassMassLow") && acceptData.getCutResult("PassMassHigh") && !acceptData.getCutResult("PassD2") ) {
      truthLabelStr += "passMfailD2";
    }
    else{
      truthLabelStr += "failMfailD2";
    }
 
  }

  else if ( m_weightHistograms.count("V_qq") ) {

    if ( jetContainment==LargeRJetTruthLabel::tqqb || jetContainment==LargeRJetTruthLabel::other_From_t ) {
      truthLabelStr = "t";
    }
    else if ( jetContainment==LargeRJetTruthLabel::Wqq || jetContainment==LargeRJetTruthLabel::Zqq || jetContainment==LargeRJetTruthLabel::Wqq_From_t ) {
      truthLabelStr = "V_qq";
    }
    else if ( jetContainment==LargeRJetTruthLabel::notruth || jetContainment==LargeRJetTruthLabel::qcd ) {
      truthLabelStr = "q";
    }
  }
 
  // inclusive top tagger
  else {
    if ( jetContainment==LargeRJetTruthLabel::tqqb || jetContainment==LargeRJetTruthLabel::other_From_t || jetContainment==LargeRJetTruthLabel::Wqq_From_t ) {
      truthLabelStr = "t";
    }
    else if ( jetContainment==LargeRJetTruthLabel::notruth || jetContainment==LargeRJetTruthLabel::qcd ) {
      truthLabelStr = "q";
    }
 
  }
 
  return truthLabelStr;
}

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

                                                                           {
 
  SG::ReadDecorHandle<xAOD::JetContainer, ElementLink<xAOD::JetContainer> > readParent(m_readParentKey);
 
  const xAOD::Jet * ungroomedJet = nullptr;
  if ( readParent.isAvailable() ) {
    const ElementLink<xAOD::JetContainer>& linkToUngroomed = readParent(jet);
    if ( linkToUngroomed.isValid() ) {
      ungroomedJet = *linkToUngroomed;
 
      static const SG::AuxElement::ConstAccessor< std::vector<int> >acc_Ntrk("NumTrkPt500");
 
      if ( acc_Ntrk.isAvailable(*ungroomedJet) ) {
 
    const std::vector<int>& NTrkPt500 = acc_Ntrk(*ungroomedJet);
 
    int jet_ntrk = NTrkPt500.at(indexPV);
    return jet_ntrk;
 
      }
      else {
    ATH_MSG_ERROR("WARNING: Unable to retrieve Ntrk of the ungroomed parent jet. Please make sure this variable is in your derivations!!!");
      }
    }
    else {
      ATH_MSG_ERROR("WARNING: Unable to retrieve the parent ungroomed jet. Please make sure this variable is in your derivations!!!");
    }
  }
  else {
    ATH_MSG_ERROR("WARNING: Unable to retrieve the link to the parent ungroomed jet. Please make sure this variable is in your derivations!!!");
  }
 
  return -999;
 
}

GetWConstScore()

StatusCode JSSTaggerUtils::GetWConstScore ( const xAOD::JetContainer & jets ) const

overridevirtual

Implements IJSSTaggerUtils.

Definition at line 870 of file JSSTaggerUtils.cxx.

                                                                            {
 
  SG::WriteDecorHandle<xAOD::JetContainer, float> decConstScore(m_decConstScoreKey);
 
  // define vectors to store constituents for calculations
  long unsigned int nMaxConstituents (100);
  std::vector<float> pT, eta, phi, E, isValid, px, py, pz;
  pT.reserve(nMaxConstituents); eta.reserve(nMaxConstituents); phi.reserve(nMaxConstituents); E.reserve(nMaxConstituents);
  isValid.reserve(nMaxConstituents);
  px.reserve(nMaxConstituents); py.reserve(nMaxConstituents); pz.reserve(nMaxConstituents);
 
  for(const xAOD::Jet *jet : jets){
 
    // init value
    float score (-99.);
 
    // get constituents
    std::vector<xAOD::JetConstituent> constituents = jet -> getConstituents().asSTLVector();
 
    // skip non physical constituents
    constituents.erase( std::remove_if( constituents.begin(), constituents.end(),
                        [] (xAOD::JetConstituent constituent) -> bool {return constituent -> pt() < 1.e-8;}), 
                        constituents.end()) ;
 
    // sort by pT
    std::sort( constituents.begin(), constituents.end(), DescendingPtSorterConstituents) ;
 
    std::vector<xAOD::JetConstituent> constituentsForModel;
 
    if( constituents.size() > nMaxConstituents )
    {
      constituentsForModel = std::vector<xAOD::JetConstituent> (constituents.begin(), constituents.begin() + nMaxConstituents);
    }
    else 
      constituentsForModel = constituents;
 
    // fill vectors of constituents for calculation
    pT.clear(); eta.clear(); phi.clear(); E.clear();
    isValid.clear();
    px.clear(); py.clear(); pz.clear();
    for(auto cnst : constituentsForModel){
      pT.push_back( cnst -> pt() );
      eta.push_back( cnst -> eta() );
      phi.push_back( cnst -> phi() );
      E.push_back( cnst -> e() );
      isValid.push_back(1.);
      px.push_back( cnst -> pt() * std::cos(cnst -> phi()) );
      py.push_back( cnst -> pt() * std::sin(cnst -> phi()) );
      pz.push_back( cnst -> pt() * std::sinh(cnst -> eta()) );
    }
 
    // build constituents, mask and base momentum for interaction variables
    std::vector<std::vector<float>> const_vars;
    std::vector<std::vector<float>> masks_vars;
    std::vector<std::vector<std::vector<float>>> inter_vars;
 
    for(long unsigned int i=0; i<constituentsForModel.size(); i++){
 
      // put the constituent in a tlv for help
      TLorentzVector constituent_i;
      constituent_i.SetPtEtaPhiE(pT.at(i), eta.at(i), phi.at(i), E.at(i));
 
      // calculate variables
      float log_pT = log( pT.at(i));
      float log_E = log( E.at(i));
      float log_pT_rel = log( pT.at(i) / jet -> pt());
      float log_E_rel = log( E.at(i) / jet -> e());
      float Deta = eta.at(i) - jet -> eta();
      float Dphi = constituent_i.DeltaPhi(jet -> p4());
      float DR = sqrt(Deta*Deta + Dphi*Dphi);
 
      // pack: constituents variables
      std::vector<float> vars = {log_E, log_pT, log_E_rel, log_pT_rel, Deta, Dphi, DR};
      const_vars.push_back(std::move(vars));
 
      // pack: mask variable
      vars = {1.};
      masks_vars.push_back(vars);
 
      // explict interaction variables
      // calculate variables: interactions
      std::vector<std::vector<float>> inter_vars_int;
      for(long unsigned int j=0; j<constituentsForModel.size(); j++){
 
        // tlv for constituents
        TLorentzVector constituent_j;
        constituent_j.SetPtEtaPhiE(pT.at(j), eta.at(j), phi.at(j), E.at(j));
  
        // preparing variables
        float delta = constituent_i.DeltaR(constituent_j, true);
        float min = std::min(pT.at(i), pT.at(j));
        float mass2 = (constituent_i + constituent_j).M2();
 
        // final values
        float log_delta = log(Clip(delta, 1.e-8));
        float log_mindelta = log(Clip(min * delta, 1.e-8));
        float log_min_over_pT = log(Clip(min / (pT.at(i) + pT.at(j)), 1.e-8));
        float log_mass = log(Clip(mass2, 1.e-8));
 
        std::vector<float> vars = { log_delta,
                                    log_mindelta,
                                    log_min_over_pT,
                                    log_mass
                                  };
        inter_vars_int.push_back(std::move(vars));
      }
 
      inter_vars.push_back(std::move(inter_vars_int));
    }
 
    // evaluate the model
    if( constituents.size() > 1 ) 
      score = m_MLBosonTagger -> retrieveConstituentsScore(std::move(const_vars), std::move(inter_vars), std::move(masks_vars));
 
    // save decorator
    decConstScore(*jet) = score;
  }
  
  return StatusCode::SUCCESS;
}

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

                                                                                                       {
  if ( !m_calcSF ) return StatusCode::SUCCESS;
 
  float weight = 1.0;
  float effSF = 1.0;
  float sigeffSF = 1.0;
  float efficiency = 1.0;
 
  if ( m_isMC ) {
 
    std::string truthLabelStr = getTruthLabelStr( jet, acceptData );
    std::tie(effSF, efficiency) = getSF( jet, truthLabelStr );
 
    // calculate signal efficiency SF
    if ( m_weightHistograms.count("t_qqb") ) {
      sigeffSF = getSF(jet, "t_qqb").first;
    } else if ( m_weightHistograms.count("V_qq") ) {
      sigeffSF = getSF(jet, "V_qq").first;
    } else if ( m_weightHistograms.count("t") ){
      sigeffSF = getSF(jet, "t").first;
    } else {
      sigeffSF = 1.0;
    }

    if ( m_weightFlavors.find("fail") != std::string::npos ) {
      weight = effSF;
    }
 
    else {

      if ( passSel ) {
        weight = effSF;
      }

      else {
        if ( m_efficiencyHistogramName.empty() ) {
          weight = 1.0;
        }
        else if ( efficiency < 1.0 ) {
          weight = ( 1. - effSF * efficiency ) / ( 1. - efficiency );
        }
        else {
          weight = 1.0;
        }
      }
    }
 
  }
 
  else {
    weight = 1.0;
  }

  SG::WriteDecorHandle<xAOD::JetContainer, float> decWeight(m_decWeightKey);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decEfficiency(m_decEfficiencyKey);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decEffSF(m_decEffSFKey);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decSigeffSF(m_decSigeffSFKey);

  decWeight(jet) = weight;
  decEfficiency(jet) = efficiency;
  decEffSF(jet) = effSF;
  decSigeffSF(jet) = sigeffSF;
 
  return StatusCode::SUCCESS;
 
}

initialize()

StatusCode JSSTaggerUtils::initialize ( void )

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.

                                     {
 
  ATH_MSG_INFO( "Initializing JSSTaggerUtils tool" );
 
  ATH_MSG_INFO( " m_calibArea : " << m_calibArea );
  ATH_MSG_INFO( " m_configFile : " << m_configFile );
 
  if ( ! m_configFile.empty() ) {

    ATH_CHECK( getConfigReader() );

    m_decorationName = m_configReader.GetValue("DecorationName", "");
 
    m_UseConstTagger = !((std::string)m_configReader.GetValue("ConstTaggerFileName", "")).empty();
    m_UseHLTagger = !((std::string)m_configReader.GetValue("HLTaggerFileName", "")).empty();
 
    std::string ConstTaggerFileName = m_configReader.GetValue("ConstTaggerFileName", "aaa");
    std::string HLTaggerFileName = m_configReader.GetValue("HLTaggerFileName", "aaa");
 
    if(m_UseConstTagger && m_MLBosonTagger.empty()){
      // init tool
      std::string ModelPath = "";
      if ( m_calibArea.compare("Local") == 0 ) {
        ModelPath = PathResolverFindCalibFile(ConstTaggerFileName);
      }
      else if ( m_calibArea.find("eos") != std::string::npos) {
        ModelPath = std::move(ConstTaggerFileName);    
      }
      else{
        ModelPath = PathResolverFindCalibFile(("BoostedJetTaggers/" + m_calibArea + "/" + ConstTaggerFileName).c_str());
      }
      ATH_MSG_INFO("JSSTaggerUtils::MLBosonTagger()" << "   + ModelPath " << ModelPath );
 
      asg::AsgToolConfig config ("AthONNX::JSSMLTool/MLBosonTagger");
      ATH_CHECK( config.setProperty("ModelPath", ModelPath));
    
      // get model paramters from the config file
      ATH_MSG_INFO("JSSTaggerUtils::MLBosonTagger() read value from config" );
 
      // set parameters
      ATH_CHECK( config.setProperty("nPixelsX", (int)m_configReader.GetValue("nPixelsEta", -99)) );
      ATH_CHECK( config.setProperty("nPixelsY", (int)m_configReader.GetValue("nPixelsPhi", -99)) );
      ATH_CHECK( config.setProperty("nPixelsZ", (int)m_configReader.GetValue("nColors", -99)) );
 
      m_nbins_eta = (int)m_configReader.GetValue("nPixelsEta", -99);
      m_nbins_phi = (int)m_configReader.GetValue("nPixelsPhi", -99);
      m_ncolors = m_configReader.GetValue("nColors", -99);
      m_min_eta = m_configReader.GetValue("aEta", -99.);
      m_max_eta = m_configReader.GetValue("bEta", -99.);
      m_min_phi = m_configReader.GetValue("aPhi", -99.);
      m_max_phi = m_configReader.GetValue("bPhi", -99.);
      m_dorscaling = (bool)m_configReader.GetValue("DoRScaling", -99);
      m_rscaling_p0 = m_configReader.GetValue("RScaling_p0", -99.);
      m_rscaling_p1 = m_configReader.GetValue("RScaling_p1", -99.);
 
      ATH_CHECK( config.makePrivateTool(m_MLBosonTagger) );
      ATH_CHECK( m_MLBosonTagger.retrieve() );
 
    }
    if(m_UseHLTagger){
      // init tool
      std::string ModelPath = "";
      if ( m_calibArea.compare("Local") == 0 ) {
        ModelPath = PathResolverFindCalibFile(HLTaggerFileName);
      }
      else if ( m_calibArea.find("eos") != std::string::npos) {
        ModelPath = std::move(HLTaggerFileName);    
      }
      else{
        ModelPath = PathResolverFindCalibFile(("BoostedJetTaggers/" + m_calibArea + "/" + HLTaggerFileName).c_str());
      }
      ATH_MSG_INFO("JSSTaggerUtils::MLBosonTagger()" << "   + ModelPath " << ModelPath );
 
      asg::AsgToolConfig config ("AthONNX::JSSMLTool/MLBosonTaggerHL");
      ATH_CHECK( config.setProperty("ModelPath", ModelPath));
      
      ATH_CHECK( config.makePrivateTool(m_MLBosonTagger_HL) );
      ATH_CHECK( m_MLBosonTagger_HL.retrieve() );
    
      // get model paramters from the config file
      ATH_MSG_INFO("JSSTaggerUtils::MLBosonTagger() read value from config" );
      ATH_CHECK( ReadScaler() );
 
    }
 
  }

  ATH_MSG_INFO( "Decorators that will be attached to jet :" );
  ATH_CHECK(JSSTaggerBase::initialize());
 
  m_decNConstituentsKey = m_containerName + "." + m_decorationName + "_" + m_decNConstituentsKey.key();
  ATH_CHECK( m_decNConstituentsKey.initialize() );
  m_decNTopoTowersKey = m_containerName + "." + m_decorationName + "_" + m_decNTopoTowersKey.key();
  ATH_CHECK( m_decNTopoTowersKey.initialize() );
 
  m_decConstScoreKey = m_containerName + "." + m_decorationName + "_" + m_decConstScoreKey.key();
  ATH_CHECK( m_decConstScoreKey.initialize() );
 
  m_constScoreAcc = std::make_unique<SG::ConstAccessor<float>>(m_decorationName + "_ConstScore");
 
  m_decHLScoreKey = m_containerName + "." + m_decorationName + "_" + m_decHLScoreKey.key();
  ATH_CHECK( m_decHLScoreKey.initialize() );
 
  m_decConstScoreQGKey = m_containerName + "." + m_decorationName + "_" + m_decConstScoreQGKey.key();
  m_decConstScoreWLKey = m_containerName + "." + m_decorationName + "_" + m_decConstScoreWLKey.key();
  m_decConstScoreWTKey = m_containerName + "." + m_decorationName + "_" + m_decConstScoreWTKey.key();
  m_decConstScoreZLKey = m_containerName + "." + m_decorationName + "_" + m_decConstScoreZLKey.key();
  m_decConstScoreZTKey = m_containerName + "." + m_decorationName + "_" + m_decConstScoreZTKey.key();
  m_decConstScoreCosTKey = m_containerName + "." + m_decorationName + "_" + m_decConstScoreCosTKey.key();
  m_decConstScorePT1Key = m_containerName + "." + m_decorationName + "_" + m_decConstScorePT1Key.key();
  m_decConstScoreEta1Key = m_containerName + "." + m_decorationName + "_" + m_decConstScoreEta1Key.key();
  m_decConstScorePhi1Key = m_containerName + "." + m_decorationName + "_" + m_decConstScorePhi1Key.key();
  m_decConstScorePT2Key = m_containerName + "." + m_decorationName + "_" + m_decConstScorePT2Key.key();
  m_decConstScoreEta2Key = m_containerName + "." + m_decorationName + "_" + m_decConstScoreEta2Key.key();
  m_decConstScorePhi2Key = m_containerName + "." + m_decorationName + "_" + m_decConstScorePhi2Key.key();
 
  ATH_CHECK( m_decConstScoreQGKey.initialize() );
  ATH_CHECK( m_decConstScoreWLKey.initialize() );
  ATH_CHECK( m_decConstScoreWTKey.initialize() );
  ATH_CHECK( m_decConstScoreZLKey.initialize() );
  ATH_CHECK( m_decConstScoreZTKey.initialize() );
  ATH_CHECK( m_decConstScoreCosTKey.initialize() );
  ATH_CHECK( m_decConstScorePT1Key.initialize() );
  ATH_CHECK( m_decConstScoreEta1Key.initialize() );
  ATH_CHECK( m_decConstScorePhi1Key.initialize() );
  ATH_CHECK( m_decConstScorePT2Key.initialize() );
  ATH_CHECK( m_decConstScoreEta2Key.initialize() );
  ATH_CHECK( m_decConstScorePhi2Key.initialize() );
 
  return StatusCode::SUCCESS;
 
}

inputHandles()

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

overridevirtualinherited

Return this algorithm's input handles.

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

MakeJetImage()

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

overridevirtual

Implements IJSSTaggerUtils.

Definition at line 626 of file JSSTaggerUtils.cxx.

  {
 
    double eta (-99.), phi (-99.), pT (-99.), z (-99.);
    int BinEta (-99), BinPhi (-99);
 
    auto cst_pT = [] ( double sum, xAOD::JetConstituent cst ){
      return sum + cst.pt(); };
    double SumPT = std::accumulate( constituents.begin(), constituents.end(), 0., cst_pT) ;
 
    auto Image = std::make_unique<TH2D>("Image_" + TagImage, "Image_" + TagImage, 
               m_nbins_eta, m_min_eta, m_max_eta, m_nbins_phi, m_min_phi, m_max_phi);
    if (SumPT == 0.)[[unlikely]]{
      throw std::runtime_error("SumPT is zero in JSSTaggerUtils::MakeJetImage");
    }
    for( auto& cst : constituents ){
      eta = cst -> eta() - jet -> eta() ;
      phi = cst -> phi() - jet -> phi() ;
      pT  = cst -> pt() ;
 
      // apply r-scaling
      if( m_dorscaling ){
        eta *= 1. / (m_rscaling_p0 + m_rscaling_p1/jet->pt());
        phi *= 1. / (m_rscaling_p0 + m_rscaling_p1/jet->pt());
      }
 
      BinEta = Image -> GetXaxis() -> FindBin(eta);
      BinPhi = Image -> GetYaxis() -> FindBin(phi);
 
      z = pT / SumPT ;
 
      int x = m_nbins_phi+1-BinPhi, y = BinEta; // transpose + flip
 
      double current_z = Image -> GetBinContent( x, y );
 
      if( eta>m_min_eta && eta<m_max_eta && phi>m_min_phi && phi<m_max_phi ) // avoid overflow pixels
          Image -> SetBinContent( x, y, current_z += z );
    }
 
    return *Image;
 
  }

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.

{return decorate(jets);};

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg_level_name()

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

inherited

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

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

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

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

Returns

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

Definition at line 101 of file AsgTool.cxx.

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

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

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

                                                           {
 
  float scale = 1.0;
  if ( m_ptGeV ) scale = 1.e3;
 
  if ( jet.pt() < m_jetPtMin * scale ) return false;
  if ( jet.pt() > m_jetPtMax * scale ) return false;
  if ( std::abs( jet.eta() ) > m_jetEtaMax ) return false;
 
  return true;
 
}

print()

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

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

Definition at line 131 of file AsgTool.cxx.

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

printCuts()

void JSSTaggerBase::printCuts ( ) const

protectedinherited

Print configured cuts.

Definition at line 915 of file JSSTaggerBase.cxx.

                                    {
  ATH_MSG_INFO( "After tagging, you will have access to the following cuts as an asg::AcceptData : (<NCut>) <cut> : <description>)" );
  int nCuts = m_acceptInfo.getNCuts();
  for ( int iCut=0; iCut < nCuts; iCut++ ) {
    std::string cut_string = "";
    cut_string += "  (";
    cut_string += std::to_string(iCut);
    cut_string += ")  ";
    cut_string += m_acceptInfo.getCutName(iCut).data();
    cut_string += " : ";
    cut_string += m_acceptInfo.getCutDescription(iCut).data();
    ATH_MSG_INFO( cut_string );
  }
}

ReadScaler()

StatusCode JSSTaggerUtils::ReadScaler ( )

overridevirtual

Implements IJSSTaggerUtils.

Definition at line 582 of file JSSTaggerUtils.cxx.

                                     {
 
  // input list
  std::vector<std::string> vars_list = {
    "pT","CNN","D2","nTracks","ZCut12",
    "Tau1_wta","Tau2_wta","Tau3_wta",
    "KtDR","Split12","Split23",
    "ECF1","ECF2","ECF3",
    "Angularity","FoxWolfram0","FoxWolfram2",
    "Aplanarity","PlanarFlow","Qw",
  };
 
  // loop and read
  for(const std::string & var : vars_list){
    std::string s_mean = var + "_mean";
    std::string s_std  = var + "_std";
    double mean = m_configReader.GetValue(s_mean.c_str(), -99.);
    double std  = m_configReader.GetValue(s_std.c_str() , -99.);
 
    if(mean==-99. && std==-99.){
      ATH_MSG_ERROR("ERROR: one of the parameter for " << var << " is missing, please, double check the config!!!");
      return StatusCode::FAILURE;
    }
    else if(mean==-99. || std==-99.){
      ATH_MSG_ERROR("ERROR: parameters for " << var << " are missing, please, double check the config!!!");
      return StatusCode::FAILURE;
    }
    else{
      m_scaler[var] = {mean, std};
    }
 
    // pass the features scaling paramters to the ML tool
    // we need to apply the data pre-processing 
    // before to apply the model inference via ONNX
 
    // ToDo: change this to a property
    ATH_CHECK( m_MLBosonTagger_HL -> SetScaler(m_scaler) );
 
  }
 
  return StatusCode::SUCCESS;
 
}

renounce()

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

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

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

                                                                     {

  acceptData.clear();

  acceptData.setCutResult( "ValidJetContent", true );
  acceptData.setCutResult( "ValidEventContent", true );
 
  acceptData.setCutResult( "ValidPtRangeHigh", true );
  acceptData.setCutResult( "ValidPtRangeLow" , true );
  acceptData.setCutResult( "ValidEtaRange"   , true );
 
  return StatusCode::SUCCESS;
 
}

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 asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, and AthCheckedComponent<::AthAlgTool >.

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 188 of file JSSTaggerUtils.cxx.

                                                         {
 
  ATH_MSG_DEBUG( "Obtaining JSS Tagger Utils result   " << jet.pt() << "   " << jet.m() );
 
  return StatusCode::SUCCESS;
 
}

updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_acceptInfo

asg::AcceptInfo JSSTaggerBase::m_acceptInfo

protectedinherited

Object that stores the results for a jet.

Definition at line 68 of file JSSTaggerBase.h.

m_calcSF

bool JSSTaggerBase::m_calcSF {}

protectedinherited

Flag to calculate scale factor.

Definition at line 194 of file JSSTaggerBase.h.

{};

m_calibArea

std::string JSSTaggerBase::m_calibArea

protectedinherited

Location where config files live on cvmfs.

Definition at line 115 of file JSSTaggerBase.h.

m_configFile

std::string JSSTaggerBase::m_configFile

protectedinherited

Configuration file name.

Definition at line 112 of file JSSTaggerBase.h.

m_configReader

TEnv JSSTaggerBase::m_configReader

protectedinherited

TEnv instance to read config files.

Definition at line 65 of file JSSTaggerBase.h.

m_constScoreAcc

std::unique_ptr<SG::ConstAccessor<float> > JSSTaggerUtils::m_constScoreAcc = nullptr

private

Definition at line 68 of file JSSTaggerUtils.h.

m_containerName

std::string JSSTaggerBase::m_containerName

protectedinherited

Configurable members.

Jet container name

Definition at line 105 of file JSSTaggerBase.h.

m_decC2Key

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

protectedinherited

Definition at line 147 of file JSSTaggerBase.h.

{this, "C2NameOut", "C2", "SG key for C2"};

m_decConstScoreCosTKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerUtils::m_decConstScoreCosTKey {this, "ConstScoreCosTNameDec", "ConstScore_cosT", "SG key for cosT regress"}

private

Definition at line 76 of file JSSTaggerUtils.h.

{this, "ConstScoreCosTNameDec", "ConstScore_cosT", "SG key for cosT regress"};

m_decConstScoreEta1Key

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerUtils::m_decConstScoreEta1Key {this, "ConstScoreEta1NameDec", "ConstScore_eta1", "SG key for eta1 regress"}

private

Definition at line 78 of file JSSTaggerUtils.h.

{this, "ConstScoreEta1NameDec", "ConstScore_eta1", "SG key for eta1 regress"};

m_decConstScoreEta2Key

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerUtils::m_decConstScoreEta2Key {this, "ConstScoreEta2NameDec", "ConstScore_eta2", "SG key for eta2 regress"}

private

Definition at line 81 of file JSSTaggerUtils.h.

{this, "ConstScoreEta2NameDec", "ConstScore_eta2", "SG key for eta2 regress"};

m_decConstScoreKey

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

private

Definition at line 65 of file JSSTaggerUtils.h.

{this, "ConstScoreNameDec", "ConstScore", "SG key for ConstScore"};

m_decConstScorePhi1Key

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerUtils::m_decConstScorePhi1Key {this, "ConstScorePhi1NameDec", "ConstScore_phi1", "SG key for phi1 regress"}

private

Definition at line 79 of file JSSTaggerUtils.h.

{this, "ConstScorePhi1NameDec", "ConstScore_phi1", "SG key for phi1 regress"};

m_decConstScorePhi2Key

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerUtils::m_decConstScorePhi2Key {this, "ConstScorePhi2NameDec", "ConstScore_phi2", "SG key for phi2 regress"}

private

Definition at line 82 of file JSSTaggerUtils.h.

{this, "ConstScorePhi2NameDec", "ConstScore_phi2", "SG key for phi2 regress"};

m_decConstScorePT1Key

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerUtils::m_decConstScorePT1Key {this, "ConstScorePT1NameDec", "ConstScore_pT1", "SG key for pT1 regress"}

private

Definition at line 77 of file JSSTaggerUtils.h.

{this, "ConstScorePT1NameDec", "ConstScore_pT1", "SG key for pT1 regress"};

m_decConstScorePT2Key

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerUtils::m_decConstScorePT2Key {this, "ConstScorePT2NameDec", "ConstScore_pT2", "SG key for pT2 regress"}

private

Definition at line 80 of file JSSTaggerUtils.h.

{this, "ConstScorePT2NameDec", "ConstScore_pT2", "SG key for pT2 regress"};

m_decConstScoreQGKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerUtils::m_decConstScoreQGKey {this, "ConstScoreQGNameDec", "ConstScore_qg", "SG key for qg node"}

private

Definition at line 71 of file JSSTaggerUtils.h.

{this, "ConstScoreQGNameDec", "ConstScore_qg", "SG key for qg node"};

m_decConstScoreWLKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerUtils::m_decConstScoreWLKey {this, "ConstScoreWLNameDec", "ConstScore_wl", "SG key for WL node"}

private

Definition at line 72 of file JSSTaggerUtils.h.

{this, "ConstScoreWLNameDec", "ConstScore_wl", "SG key for WL node"};

m_decConstScoreWTKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerUtils::m_decConstScoreWTKey {this, "ConstScoreWTNameDec", "ConstScore_wt", "SG key for WT node"}

private

Definition at line 73 of file JSSTaggerUtils.h.

{this, "ConstScoreWTNameDec", "ConstScore_wt", "SG key for WT node"};

m_decConstScoreZLKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerUtils::m_decConstScoreZLKey {this, "ConstScoreZLNameDec", "ConstScore_zl", "SG key for ZL node"}

private

Definition at line 74 of file JSSTaggerUtils.h.

{this, "ConstScoreZLNameDec", "ConstScore_zl", "SG key for ZL node"};

m_decConstScoreZTKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JSSTaggerUtils::m_decConstScoreZTKey {this, "ConstScoreZTNameDec", "ConstScore_zt", "SG key for ZT node"}

private

Definition at line 75 of file JSSTaggerUtils.h.

{this, "ConstScoreZTNameDec", "ConstScore_zt", "SG key for ZT node"};

m_decCutMHighKey

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

protectedinherited

Definition at line 221 of file JSSTaggerBase.h.

{this, "CutMHighName", "Cut_mhigh", "SG key for Cut_mhigh"};

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 220 of file JSSTaggerBase.h.

{this, "CutMLowName", "Cut_mlow", "SG key for Cut_mlow"};

m_decD2Key

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

protectedinherited

Definition at line 148 of file JSSTaggerBase.h.

{this, "D2NameOut", "D2", "SG key for D2"};

m_decE3Key

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

protectedinherited

Definition at line 149 of file JSSTaggerBase.h.

{this, "e3NameOut", "e3", "SG key for e3"};

m_decEfficiencyKey

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

protectedinherited

Definition at line 227 of file JSSTaggerBase.h.

{this, "efficiencyName", "efficiency", "SG key for efficiency"};

m_decEffSFKey

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

protectedinherited

Definition at line 228 of file JSSTaggerBase.h.

{this, "effSFName", "effSF", "SG key for effSF"};

m_decHLScoreKey

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

private

Definition at line 66 of file JSSTaggerUtils.h.

{this, "HLScoreName", "HLScore", "SG key for HLScore"};

m_decL2Key

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

protectedinherited

Definition at line 150 of file JSSTaggerBase.h.

{this, "L2NameOut", "L2", "SG key for L2"};

m_decL3Key

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

protectedinherited

Definition at line 151 of file JSSTaggerBase.h.

{this, "L3NameOut", "L3", "SG key for L3"};

m_decNConstituentsKey

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

private

WriteDecorHandle keys.

Definition at line 63 of file JSSTaggerUtils.h.

{this, "nConstituentsName", "nConstituents", "SG key for constituents multiplicity"};

m_decNTopoTowersKey

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

private

Definition at line 64 of file JSSTaggerUtils.h.

{this, "nTopoTowersName", "nTopoTowers", "SG key for towers multiplicity"};

m_decorationName

std::string JSSTaggerBase::m_decorationName

protectedinherited

Decoration name.

Definition at line 191 of file JSSTaggerBase.h.

m_decPassMassKey

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

protectedinherited

Definition at line 79 of file JSSTaggerBase.h.

{this, "PassMassName", "PassMass", "SG key for PassMass"};

m_decPassScoreKey

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

protectedinherited

Definition at line 80 of file JSSTaggerBase.h.

{this, "PassScoreName", "PassScore", "SG key for PassScore"};

m_decScoreCutKey

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

protectedinherited

Definition at line 222 of file JSSTaggerBase.h.

{this, "CutScoreName", "Cut_score", "SG key for Cut_score"};

m_decScoreValueKey

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

protectedinherited

Definition at line 223 of file JSSTaggerBase.h.

{this, "ScoreName", "Score", "SG key for Score"};

m_decSigeffSFKey

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

protectedinherited

Definition at line 229 of file JSSTaggerBase.h.

{this, "sigeffSFName", "sigeffSF", "SG key for effSF"};

m_decTaggedKey

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

protectedinherited

WriteDecorHandle keys for tagging bools.

Definition at line 71 of file JSSTaggerBase.h.

{this, "TaggedName", "Tagged", "SG key for Tagged"};

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 143 of file JSSTaggerBase.h.

{this, "Tau21WTANameOut", "Tau21_wta", "SG key for Tau21_wta"};

m_decTau32WTAKey

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

protectedinherited

Definition at line 144 of file JSSTaggerBase.h.

{this, "Tau32WTANameOut", "Tau32_wta", "SG key for Tau32_wta"};

m_decTau42WTAKey

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

protectedinherited

Definition at line 145 of file JSSTaggerBase.h.

{this, "Tau42WTANameOut", "Tau42_wta", "SG key for Tau42_wta"};

m_decValidEtaRangeKey

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

protectedinherited

Definition at line 74 of file JSSTaggerBase.h.

{this, "ValidEtaRangeName", "ValidEtaRange", "SG key for ValidEtaRange"};

m_decValidEventContentKey

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

protectedinherited

Definition at line 77 of file JSSTaggerBase.h.

{this, "ValidEventContentName", "ValidEventContent", "SG key for ValidEventContent"};

m_decValidJetContentKey

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

protectedinherited

Definition at line 76 of file JSSTaggerBase.h.

{this, "ValidJetContentName", "ValidJetContent", "SG key for ValidJetContent"};

m_decValidKinRangeKey

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

protectedinherited

Definition at line 75 of file JSSTaggerBase.h.

{this, "ValidKinRangeName", "ValidKinRange", "SG key for ValidKinRange"};

m_decValidPtRangeHighKey

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

protectedinherited

Definition at line 72 of file JSSTaggerBase.h.

{this, "ValidPtRangeHighName", "ValidPtRangeHigh", "SG key for ValidPtRangeHigh"};

m_decValidPtRangeLowKey

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

protectedinherited

Definition at line 73 of file JSSTaggerBase.h.

{this, "ValidPtRangeLowName", "ValidPtRangeLow", "SG key for ValidPtRangeLow"};

m_decWeightKey

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

protectedinherited

WriteDecorHandle keys for SF.

Definition at line 226 of file JSSTaggerBase.h.

{this, "weightName", "weight", "SG key for weight"};

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 50 of file JSSTaggerUtils.h.

{};

m_efficiencyHistogramName

std::string JSSTaggerBase::m_efficiencyHistogramName

protectedinherited

Definition at line 201 of file JSSTaggerBase.h.

m_efficiencyHistograms

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

protectedinherited

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

m_funcMassCutLow

std::unique_ptr<TF1> JSSTaggerBase::m_funcMassCutLow

protectedinherited

TF1 for cut functions.

Definition at line 186 of file JSSTaggerBase.h.

m_funcScoreCut

std::unique_ptr<TF1> JSSTaggerBase::m_funcScoreCut

protectedinherited

Definition at line 188 of file JSSTaggerBase.h.

m_isMC

bool JSSTaggerBase::m_isMC {}

protectedinherited

Definition at line 195 of file JSSTaggerBase.h.

{};

m_isSmallRJet

bool JSSTaggerBase::m_isSmallRJet = false

protectedinherited

Definition at line 106 of file JSSTaggerBase.h.

m_jetEtaMax

float JSSTaggerBase::m_jetEtaMax {}

protectedinherited

Definition at line 135 of file JSSTaggerBase.h.

{};

m_jetPtMax

float JSSTaggerBase::m_jetPtMax {}

protectedinherited

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

{};

m_kerasCalibArea

std::string JSSTaggerBase::m_kerasCalibArea

protectedinherited

Definition at line 121 of file JSSTaggerBase.h.

m_kerasConfigFileName

std::string JSSTaggerBase::m_kerasConfigFileName

protectedinherited

Keras configurations for ML taggers.

Definition at line 118 of file JSSTaggerBase.h.

m_kerasConfigFilePath

std::string JSSTaggerBase::m_kerasConfigFilePath

protectedinherited

Definition at line 119 of file JSSTaggerBase.h.

m_kerasConfigOutputName

std::string JSSTaggerBase::m_kerasConfigOutputName

protectedinherited

Definition at line 120 of file JSSTaggerBase.h.

m_max_eta

double JSSTaggerUtils::m_max_eta {}

private

Definition at line 48 of file JSSTaggerUtils.h.

{}, m_max_eta{}, m_min_phi{}, m_max_phi{};

m_max_phi

double JSSTaggerUtils::m_max_phi {}

private

Definition at line 48 of file JSSTaggerUtils.h.

{}, m_max_eta{}, m_min_phi{}, m_max_phi{};

m_min_eta

double JSSTaggerUtils::m_min_eta {}

private

Definition at line 48 of file JSSTaggerUtils.h.

{}, m_max_eta{}, m_min_phi{}, m_max_phi{};

m_min_phi

double JSSTaggerUtils::m_min_phi {}

private

Definition at line 48 of file JSSTaggerUtils.h.

{}, m_max_eta{}, m_min_phi{}, m_max_phi{};

m_MLBosonTagger

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

private

Definition at line 56 of file JSSTaggerUtils.h.

{"", this};

m_MLBosonTagger_HL

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

private

Definition at line 60 of file JSSTaggerUtils.h.

{"", this};

m_nbins_eta

int JSSTaggerUtils::m_nbins_eta {}

private

Definition at line 47 of file JSSTaggerUtils.h.

{}, m_nbins_phi{};

m_nbins_phi

int JSSTaggerUtils::m_nbins_phi {}

private

Definition at line 47 of file JSSTaggerUtils.h.

{}, m_nbins_phi{};

m_ncolors

int JSSTaggerUtils::m_ncolors {}

private

Definition at line 49 of file JSSTaggerUtils.h.

{};

m_nWarnMax

const int JSSTaggerBase::m_nWarnMax = 10

protectedinherited

Maximum number of warnings.

Definition at line 83 of file JSSTaggerBase.h.

m_nWarnVar

std::atomic<int> JSSTaggerBase::m_nWarnVar

mutableprotectedinherited

Warning counters.

Definition at line 86 of file JSSTaggerBase.h.

m_ptGeV

bool JSSTaggerBase::m_ptGeV = false

protectedinherited

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

Definition at line 90 of file JSSTaggerBase.h.

m_readECF1Key

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

protectedinherited

Definition at line 159 of file JSSTaggerBase.h.

{this, "ECF1Name", "ECF1", "SG key for ECF1"};

m_readECF2Key

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

protectedinherited

Definition at line 160 of file JSSTaggerBase.h.

{this, "ECF2Name", "ECF2", "SG key for ECF2"};

m_readECF3Key

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

protectedinherited

Definition at line 161 of file JSSTaggerBase.h.

{this, "ECF3Name", "ECF3", "SG key for ECF3"};

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 173 of file JSSTaggerBase.h.

{this, "ECFG212Name", "ECFG_2_1_2", "SG key for ECFG_2_1_2"};

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 172 of file JSSTaggerBase.h.

{this, "ECFG311Name", "ECFG_3_1_1", "SG key for ECFG_3_1_1"};

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 171 of file JSSTaggerBase.h.

{this, "ECFG331Name", "ECFG_3_3_1", "SG key for ECFG_3_3_1"};

m_readParentKey

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

protectedinherited

Definition at line 175 of file JSSTaggerBase.h.

{this, "ParentName", "Parent", "SG key for Parent"};

m_readQwKey

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

protectedinherited

Definition at line 166 of file JSSTaggerBase.h.

{this, "QwName", "Qw", "SG key for Qw"};

m_readSphericityKey

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

protectedinherited

Definition at line 169 of file JSSTaggerBase.h.

{this, "SphericityName", "Sphericity", "SG key for Sphericity"};

m_readSplit12Key

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

protectedinherited

Definition at line 163 of file JSSTaggerBase.h.

{this, "Split12Name", "Split12", "SG key for Split12"};

m_readSplit23Key

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

protectedinherited

Definition at line 164 of file JSSTaggerBase.h.

{this, "Split23Name", "Split23", "SG key for Split23"};

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 154 of file JSSTaggerBase.h.

{this, "Tau1WTAName", "Tau1_wta", "SG key for Tau1_wta"};

m_readTau2WTAKey

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

protectedinherited

Definition at line 155 of file JSSTaggerBase.h.

{this, "Tau2WTAName", "Tau2_wta", "SG key for Tau2_wta"};

m_readTau3WTAKey

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

protectedinherited

Definition at line 156 of file JSSTaggerBase.h.

{this, "Tau3WTAName", "Tau3_wta", "SG key for Tau3_wta"};

m_readTau4WTAKey

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

protectedinherited

Definition at line 157 of file JSSTaggerBase.h.

{this, "Tau4WTAName", "Tau4_wta", "SG key for Tau4_wta"};

m_readThrustMajKey

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

protectedinherited

Definition at line 168 of file JSSTaggerBase.h.

{this, "ThrustMajName", "ThrustMaj", "SG key for ThrustMaj"};

m_readTruthLabelKey

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

protectedinherited

Truth label ReadDecorHandle key.

Definition at line 217 of file JSSTaggerBase.h.

{this, "truthLabelName", "truthLabel", "SG key for truthLabel"};

m_rscaling_p0

double JSSTaggerUtils::m_rscaling_p0 {}

private

Definition at line 51 of file JSSTaggerUtils.h.

{}, m_rscaling_p1{};

m_rscaling_p1

double JSSTaggerUtils::m_rscaling_p1 {}

private

Definition at line 51 of file JSSTaggerUtils.h.

{}, m_rscaling_p1{};

m_scaler

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

Definition at line 43 of file JSSTaggerUtils.h.

m_strMassCutHigh

std::string JSSTaggerBase::m_strMassCutHigh

protectedinherited

Definition at line 182 of file JSSTaggerBase.h.

m_strMassCutLow

std::string JSSTaggerBase::m_strMassCutLow

protectedinherited

Strings for cut functions.

Definition at line 181 of file JSSTaggerBase.h.

m_strScoreCut

std::string JSSTaggerBase::m_strScoreCut

protectedinherited

Definition at line 183 of file JSSTaggerBase.h.

m_suppressInputDependence

Gaudi::Property<bool> JSSTaggerBase::m_suppressInputDependence {this, "SuppressInputDependence", false}

protectedinherited

Definition at line 177 of file JSSTaggerBase.h.

{this, "SuppressInputDependence", false};

m_suppressOutputDependence

Gaudi::Property<bool> JSSTaggerBase::m_suppressOutputDependence {this, "SuppressOutputDependence", false}

protectedinherited

Definition at line 178 of file JSSTaggerBase.h.

{this, "SuppressOutputDependence", false};

m_tagClass

TAGCLASS JSSTaggerBase::m_tagClass {Unknown}

protectedinherited

Definition at line 100 of file JSSTaggerBase.h.

{Unknown};

m_tagType

std::string JSSTaggerBase::m_tagType

protectedinherited

Definition at line 130 of file JSSTaggerBase.h.

m_tmvaCalibArea

std::string JSSTaggerBase::m_tmvaCalibArea

protectedinherited

Definition at line 126 of file JSSTaggerBase.h.

m_tmvaConfigFileName

std::string JSSTaggerBase::m_tmvaConfigFileName

protectedinherited

TMVA configurations for BDT taggers.

Definition at line 124 of file JSSTaggerBase.h.

m_tmvaConfigFilePath

std::string JSSTaggerBase::m_tmvaConfigFilePath

protectedinherited

Definition at line 125 of file JSSTaggerBase.h.

m_truthBosonContainerName

std::string JSSTaggerBase::m_truthBosonContainerName

protectedinherited

Definition at line 212 of file JSSTaggerBase.h.

m_truthLabelName

std::string JSSTaggerBase::m_truthLabelName

protectedinherited

Definition at line 214 of file JSSTaggerBase.h.

m_truthLabelUseTRUTH3

bool JSSTaggerBase::m_truthLabelUseTRUTH3 {}

protectedinherited

Truth label options.

Definition at line 210 of file JSSTaggerBase.h.

{};

m_truthParticleContainerName

std::string JSSTaggerBase::m_truthParticleContainerName

protectedinherited

Definition at line 211 of file JSSTaggerBase.h.

m_truthTopQuarkContainerName

std::string JSSTaggerBase::m_truthTopQuarkContainerName

protectedinherited

Definition at line 213 of file JSSTaggerBase.h.

m_UseConstTagger

bool JSSTaggerUtils::m_UseConstTagger {}

private

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

m_UseHLTagger

bool JSSTaggerUtils::m_UseHLTagger {}

private

Definition at line 59 of file JSSTaggerUtils.h.

{};

m_useLSeries

bool JSSTaggerBase::m_useLSeries = false

protectedinherited

Definition at line 140 of file JSSTaggerBase.h.

m_useMassCut

bool JSSTaggerBase::m_useMassCut = false

protectedinherited

Flag to indicate if mass window cut is used.

Definition at line 93 of file JSSTaggerBase.h.

m_useScoreCut

bool JSSTaggerBase::m_useScoreCut = false

protectedinherited

Flag to indicate if a discriminant score is used.

Definition at line 96 of file JSSTaggerBase.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_weightConfig

std::unique_ptr<TFile> JSSTaggerBase::m_weightConfig

protectedinherited

Histograms for scale factors.

Definition at line 205 of file JSSTaggerBase.h.

m_weightConfigPath

std::string JSSTaggerBase::m_weightConfigPath

protectedinherited

Path to the SF configuration root file.

Definition at line 109 of file JSSTaggerBase.h.

m_weightDecorationName

std::string JSSTaggerBase::m_weightDecorationName

protectedinherited

String for scale factor decoration names.

Definition at line 198 of file JSSTaggerBase.h.

m_weightFileName

std::string JSSTaggerBase::m_weightFileName

protectedinherited

Definition at line 199 of file JSSTaggerBase.h.

m_weightFlavors

std::string JSSTaggerBase::m_weightFlavors

protectedinherited

Definition at line 202 of file JSSTaggerBase.h.

m_weightHistogramName

std::string JSSTaggerBase::m_weightHistogramName

protectedinherited

Definition at line 200 of file JSSTaggerBase.h.

m_weightHistograms

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

protectedinherited

Definition at line 206 of file JSSTaggerBase.h.

m_wkpt

std::string JSSTaggerBase::m_wkpt

protectedinherited

Tagger information.

Definition at line 129 of file JSSTaggerBase.h.

---

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

• JSSTaggerUtils.h
• JSSTaggerUtils.cxx