JSSWTopTaggerDNN Class Reference

#include <JSSWTopTaggerDNN.h>

Inheritance diagram for JSSWTopTaggerDNN:

Collaboration diagram for JSSWTopTaggerDNN:

Public Member Functions
	JSSWTopTaggerDNN (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
	Decorate single jet with tagging info.
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.

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.
Gaudi::Property< std::string >	m_scoreDecorationName {this, "scoreDecorationName", "", "tagger output scoure 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
double	getScore (const xAOD::Jet &jet) const
	Retrieve score for a given DNN type (top/W).
std::map< std::string, double >	getJetProperties (const xAOD::Jet &jet) const
	Update the jet substructure variables for each jet to use in DNN.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
std::unique_ptr< lwt::LightweightNeuralNetwork >	m_lwnn
	DNN tools.
std::map< std::string, double >	m_DNN_inputValues
	Variables for DNN.
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 13 of file JSSWTopTaggerDNN.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 376 of file AthCommonDataStore.h.

Member Enumeration Documentation

TAGCLASS

enum JSSTaggerBase::TAGCLASS

protectedinherited

TAGTYPE enum.

Enumerator
Unknown
WBoson
ZBoson
TopQuark

Definition at line 96 of file JSSTaggerBase.h.

{Unknown, WBoson, ZBoson, TopQuark};

Constructor & Destructor Documentation

JSSWTopTaggerDNN()

JSSWTopTaggerDNN::JSSWTopTaggerDNN

(

const std::string &

name

)

Constructor.

Definition at line 9 of file JSSWTopTaggerDNN.cxx.

                                                          :
  JSSTaggerBase( name ),
  m_lwnn(nullptr)
{
 
}

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 403 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::ConstAccessor<float> accL2("L2");
  if(!accL2.isAvailable(jet)) decL2(jet) = L2;
 
  static const SG::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 357 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 JSSWTopTaggerDNN::decorate ( const xAOD::JetContainer & jets ) const

overridevirtual

Decorate jet collection with tagging info.

Loop over jet collection and decorate each jet.

Create write decor handles

Create write decor handles

Reset the AcceptData cut results

Check each kinematic constraint Print warnings using counters

Decorate kinematic pass information

Get score

Evaluate the values of the upper and lower mass bounds and the d2 cut

Print cut criteria and jet values

Get SF weight

Inefficiency SF is directly used

Efficiency SF

Calculate inefficiency SF

If inefficiency SF is not available, SF is always 1.0

Decorate cut information if needed

Decorate values

Cut summary

Set the AcceptData depending on whether it is a W/Z or a top tagger

Reimplemented from JSSTaggerBase.

Definition at line 210 of file JSSWTopTaggerDNN.cxx.

                                                                          {
 
  decorateJSSRatios(jets);
  
  ATH_MSG_DEBUG("Using AthAnalysis code. DNN code.");
  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);
 
 
  SG::WriteDecorHandle<xAOD::JetContainer, char> decPassMass(m_decPassMassKey);
  SG::WriteDecorHandle<xAOD::JetContainer, char> decPassScore(m_decPassScoreKey);
  SG::WriteDecorHandle<xAOD::JetContainer, char> decTagged(m_decTaggedKey);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decCutMLow(m_decCutMLowKey);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decCutMHigh(m_decCutMHighKey);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decScoreCut(m_decScoreCutKey);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decScoreValue(m_decScoreValueKey);

  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);
 
  for(const xAOD::Jet* jet : jets){
    asg::AcceptData acceptData( &m_acceptInfo );
    ATH_CHECK( resetCuts( acceptData ) );
 
    // resetCuts
    float scale = m_ptGeV ? 1.e3 : 1.0;
 
    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;
    }
    decValidPtRangeHigh(*jet) = acceptData.getCutResult( "ValidPtRangeHigh" );
    decValidPtRangeLow(*jet) = acceptData.getCutResult( "ValidPtRangeLow" );
    decValidEtaRange(*jet) = acceptData.getCutResult( "ValidEtaRange" );
    decValidKinRange(*jet) = passKinRange;
 
 
    float jet_pt   = jet->pt()/1000.;
    float jet_mass = jet->m()/1000.;

    float jet_score = getScore(*jet);

    float cut_mass_low  = m_funcMassCutLow ->Eval(jet_pt);
    float cut_mass_high = m_funcMassCutHigh->Eval(jet_pt);
    float cut_score     = m_funcScoreCut   ->Eval(jet_pt);

    ATH_MSG_VERBOSE( "Cut values : Mass window = [" << cut_mass_low << "," << cut_mass_high << "], score cut = " << cut_score );
    ATH_MSG_VERBOSE( "Jet values : Mass = " << jet_mass << ", score = " << jet_score );

 
    float weight = 1.0;
    float effSF = 1.0;
    float sigeffSF = 1.0;
    float efficiency = 1.0;
 
    if ( m_isMC && m_calcSF ) {
 
      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 ( jet_score > cut_score ) {
          weight = effSF;
        }

        else {
          if (  !m_efficiencyHistogramName.empty() && efficiency < 1.0 ) {
            weight = ( 1. - effSF * efficiency ) / ( 1. - efficiency );
          }
 
        }
      }
 
    }
 
    decWeight(*jet) = weight;
    decEfficiency(*jet) = efficiency;
    decEffSF(*jet) = effSF;
    decSigeffSF(*jet) = sigeffSF;

    ATH_MSG_DEBUG( "Decorating with score" );
 
 

    decCutMLow(*jet) = cut_mass_low;
    decCutMHigh(*jet) = cut_mass_high;
    decScoreCut(*jet) = cut_score;
    decScoreValue(*jet) = jet_score;

    bool passCuts = true;

    if ( m_tagClass == TAGCLASS::WBoson || m_tagClass == TAGCLASS::ZBoson ) {
      ATH_MSG_VERBOSE( "Determining WZ tag return" );
      if ( jet_mass > cut_mass_low ) acceptData.setCutResult( "PassMassLow", true );
      if ( jet_mass < cut_mass_high ) acceptData.setCutResult( "PassMassHigh", true );
      if ( jet_score > cut_score ) acceptData.setCutResult( "PassScore", true );
      decPassMass(*jet) = acceptData.getCutResult( "PassMassLow" ) && acceptData.getCutResult( "PassMassHigh" );
      passCuts = passCuts && acceptData.getCutResult( "PassMassLow" ) && acceptData.getCutResult( "PassMassHigh" );
    }
    else if ( m_tagClass == TAGCLASS::TopQuark ) {
      ATH_MSG_VERBOSE( "Determining TopQuark tag return" );
      if ( jet_mass > cut_mass_low ) acceptData.setCutResult( "PassMassLow", true );
      if ( jet_score > cut_score ) acceptData.setCutResult( "PassScore", true );
      decPassMass(*jet) = acceptData.getCutResult( "PassMassLow" );
      passCuts = passCuts && acceptData.getCutResult( "PassMassLow" );
    }
 
    decPassScore(*jet) = acceptData.getCutResult( "PassScore" );
 
    passCuts = passCuts && acceptData.getCutResult( "PassScore" );
 
    decTagged(*jet) = passCuts;
 
  }
  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 511 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);
  }
 
 
  // check if the jets are decorated with the variables already
  const bool c2_is_available = decC2.isAvailable();
  const bool d2_is_available = decD2.isAvailable();
  const bool e3_is_available = decE3.isAvailable();
  const bool l2_is_available = decL2.isAvailable();
  const bool l3_is_available = decL3.isAvailable();
 
  
  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(!c2_is_available){
    if ( ECF2 > 1e-8 )
      C2 = ECF3 * ECF1 / std::pow( ECF2, 2.0 );
      }
 
      if(!d2_is_available){
    if ( ECF2 > 1e-8 )
      D2 = ECF3 * std::pow( ECF1, 3.0 ) / std::pow( ECF2, 3.0 );
      }
 
      if(!e3_is_available)
    e3 = ECF3 / std::pow( ECF1, 3.0 );
 
      // L-series for UFO top taggers
      if(!l2_is_available){
        if((*readECFG331).isAvailable() && (*readECFG212).isAvailable()){
      if((*readECFG212)(*jet) > 1e-8){
        L2 = (*readECFG331)(*jet) / std::pow((*readECFG212)(*jet), 1.5);
      }
    }
      }
 
 
      if(!l3_is_available){
        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;
 
    if(!c2_is_available)
      decC2(*jet) = C2;
 
    if(!d2_is_available)
      decD2(*jet) = D2;
 
    if(!e3_is_available)
      decE3(*jet) = e3;
    
    if(!l2_is_available)
      decL2(*jet) = L2;
 
    if(!l3_is_available)
      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 660 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 286 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;
 
}

getJetProperties()

std::map< std::string, double > JSSWTopTaggerDNN::getJetProperties ( const xAOD::Jet & jet ) const

private

Update the jet substructure variables for each jet to use in DNN.

Map to store inputs

Create common read decor handles

Mass and pT It is assumed that these are the combined and calibrated mass and pT

Splitting scales

Energy Correlation Functions

Tau21 WTA

Other moments

Create top quark read decor handles

Mass and pT again

Additional splitting scales

e3 := normalized ECF3/ECF1**3

N-subjettiness

Qw observable for top tagging

Definition at line 500 of file JSSWTopTaggerDNN.cxx.

                                                                                      {

  std::map<std::string,double> DNN_inputValues;
 
  ATH_MSG_DEBUG( "Loading variables for common DNN tagger" );

  SG::ReadDecorHandle<xAOD::JetContainer, float> readSplit12(m_readSplit12Key);

  DNN_inputValues["CaloTACombinedMassUncorrelated"] = jet.m();
  DNN_inputValues["JetpTCorrByCombinedMass"] = jet.pt();

  DNN_inputValues["Split12"] = readSplit12(jet);

  static const SG::ConstAccessor<float> C2("C2");
  static const SG::ConstAccessor<float> D2("D2");
  DNN_inputValues["C2"] = C2(jet);
  DNN_inputValues["D2"] = D2(jet);

  static const SG::ConstAccessor<float> Tau21WTA("Tau21_wta");
  DNN_inputValues["Tau21_wta"] = Tau21WTA(jet);
 
  if ( m_tagClass == TAGCLASS::WBoson ) {
 
    ATH_MSG_DEBUG( "Loading variables for W boson tagger" );

    DNN_inputValues["FoxWolfram20"] = jet.getAttribute<float>("FoxWolfram2") / jet.getAttribute<float>("FoxWolfram0");
    DNN_inputValues["PlanarFlow"] = jet.getAttribute<float>("PlanarFlow");
    DNN_inputValues["Angularity"] = jet.getAttribute<float>("Angularity");
    DNN_inputValues["Aplanarity"] = jet.getAttribute<float>("Aplanarity");
    DNN_inputValues["ZCut12"] = jet.getAttribute<float>("ZCut12");
    DNN_inputValues["KtDR"] = jet.getAttribute<float>("KtDR");
 
    int pv_location = findPV();
 
    if(pv_location != -1){
      int jet_ntrk = GetUnGroomTracks(jet, pv_location);
      if(jet_ntrk>=0) DNN_inputValues["Ntrk500"] = jet_ntrk;
      else{
        ATH_MSG_ERROR("Either the ungroomed parent jet doesn't have 'NumTrkPt500' as an attribute or the parent link is broken");
        DNN_inputValues["Ntrk500"] = -999;
      }
    }
    else {
      ATH_MSG_ERROR("Could not find a primary vertex");
      DNN_inputValues["Ntrk500"] = -999;
    }
 
 
  }
 
  else if ( m_tagClass == TAGCLASS::TopQuark ) {
 
    ATH_MSG_DEBUG("Loading variables for top quark tagger");

    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);
    SG::ReadDecorHandle<xAOD::JetContainer, float> readSplit23(m_readSplit23Key);
    SG::ReadDecorHandle<xAOD::JetContainer, float> readQw(m_readQwKey);
    SG::ReadDecorHandle<xAOD::JetContainer, float> readThrustMaj(m_readThrustMajKey);
 

    DNN_inputValues["m"] = jet.m();
    DNN_inputValues["pt"] = jet.pt();

    DNN_inputValues["Split23"] = readSplit23(jet);

    static const SG::ConstAccessor<float> e3("e3");
    DNN_inputValues["e3"] = e3(jet);

    DNN_inputValues["Tau1_wta"] = readTau1WTA(jet);
    DNN_inputValues["Tau2_wta"] = readTau2WTA(jet);
    DNN_inputValues["Tau3_wta"] = readTau3WTA(jet);
    if(readTau4WTA.isAvailable()){
      DNN_inputValues["Tau4_wta"] = readTau4WTA(jet);
      static const SG::ConstAccessor<float> Tau42WTA("Tau42_wta");
      DNN_inputValues["Tau42_wta"] = Tau42WTA(jet);
    }
 
    static const SG::ConstAccessor<float> Tau32WTA("Tau32_wta");
    DNN_inputValues["Tau32_wta"] = Tau32WTA(jet);

    DNN_inputValues["Qw"] = readQw(jet);
 
    if(readThrustMaj.isAvailable()){
      DNN_inputValues["ThrustMaj"] = readThrustMaj(jet);
    }
    static const SG::ConstAccessor<float> L2("L2");
    if(L2.isAvailable(jet)){
      DNN_inputValues["L2"] = L2(jet);
    }
    static const SG::ConstAccessor<float> L3("L3");
    if(L3.isAvailable(jet)){
      DNN_inputValues["L3"] = L3(jet);
    }
  }
 
  else {
    ATH_MSG_ERROR( "Loading variables failed because the tagger type is not supported" );
  }
 
  return DNN_inputValues;
 
}

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
   }

getProperty()

template<class T>

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

inherited

Get one of the tool's properties.

getScore()

double JSSWTopTaggerDNN::getScore ( const xAOD::Jet & jet ) const

private

Retrieve score for a given DNN type (top/W).

Create input dictionary map<string,double> for argument to lwtnn

Evaluate the network response

Obtain the output associated with the single output node

Check that input variables are valid

Definition at line 465 of file JSSWTopTaggerDNN.cxx.

                                                            {

  std::map<std::string,double> DNN_inputValues = getJetProperties(jet);

  lwt::ValueMap discriminant = m_lwnn->compute(DNN_inputValues);

  double DNNscore = -666.;

  bool validVars = true;
  static const SG::ConstAccessor<float> Tau21WTA("Tau21_wta");
  if ( Tau21WTA(jet) < 0.0 ) validVars = false;
  if ( m_tagClass == TAGCLASS::TopQuark ) {
    static const SG::ConstAccessor<float> Tau32WTA("Tau32_wta");
    if ( Tau32WTA(jet) < 0.0 ) validVars = false;
  }
 
  if ( !validVars ) {
 
    if ( m_nWarnVar++ < m_nWarnMax ) ATH_MSG_INFO( "One (or more) tagger input variable has an out-of-range value, setting score to -666" );
    else ATH_MSG_DEBUG( "One (or more) tagger input variable has an out-of-range value, setting score to -666" );
 
    return DNNscore;
 
  }
 
  DNNscore = discriminant[m_kerasConfigOutputName];
 
  return DNNscore;
 
}

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 796 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 );
  }
 
}

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 855 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 684 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::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;
 
}

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 722 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 JSSWTopTaggerDNN::initialize ( void )

overridevirtual

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

Initialize the tagger.

Pt values are defined in GeV

Use mass cut

Use discriminant score cut

Get configReader

Get tagger type

Get the CVMFS calib area where stuff is stored If this is set to "Local" then it will look for the config file in the share space

Get the name/path of the JSON config

Get the name of the Keras output node

Get the configured cut values

Get min and max jet pt

Get the decoration name

Get the scale factor configuration

Get truth label name information

print out the configuration parameters for viewing

No config file

Assume the cut functions have been set through properties. Check they are non empty

If the calibarea is specified to be "Local" then it looks in the same place as the top level configs

Convert the JSON config file name to the full path

Get the config file from CVMFS Necessary because xml files are too large to house on the data space

Read json file for DNN weights

Set internal tagger type

Set the possible states that the tagger can be left in after the JSSTaggerBase::tag() function is called

Loop over and print out the cuts that have been configured

Call base class initialize

Reimplemented from JSSTaggerBase.

Definition at line 17 of file JSSWTopTaggerDNN.cxx.

                                        {
 
  ATH_MSG_INFO( "Initializing JSSWTopTaggerDNN tool" );

  m_ptGeV = true;

  m_useMassCut = true;

  m_useScoreCut = true;
 
  if ( ! m_configFile.empty() ) {

    ATH_CHECK( getConfigReader() );

    m_tagType = m_configReader.GetValue("TaggerType" ,"");

    m_kerasCalibArea = m_configReader.GetValue("CalibAreaKeras" ,"");

    m_kerasConfigFileName = m_configReader.GetValue("KerasConfigFile" ,"");

    m_kerasConfigOutputName = m_configReader.GetValue("KerasOutput" ,"");

    m_strMassCutLow  = m_configReader.GetValue("MassCutLow" ,"");
    m_strMassCutHigh = m_configReader.GetValue("MassCutHigh" ,"");
    m_strScoreCut    = m_configReader.GetValue("ScoreCut" ,"");

    m_jetPtMin = m_configReader.GetValue("pTCutLow", 350.0);
    m_jetPtMax = m_configReader.GetValue("pTCutHigh", 4000.0);

    m_decorationName = m_configReader.GetValue("DecorationName" ,"");

    m_calcSF = m_configReader.GetValue("CalcSF", false);
    if ( m_calcSF ) {
      m_weightDecorationName = m_configReader.GetValue("WeightDecorationName", "");
      m_weightFileName = m_configReader.GetValue("WeightFile", "");
      m_weightHistogramName = m_configReader.GetValue("WeightHistogramName", "");
      m_efficiencyHistogramName = m_configReader.GetValue("EfficiencyHistogramName", "");
      m_weightFlavors = m_configReader.GetValue("WeightFlavors", "");

      m_truthLabelName = m_configReader.GetValue("TruthLabelName" , "R10TruthLabel_R21Consolidated");
    }

    ATH_MSG_INFO( "Configurations Loaded :");
    ATH_MSG_INFO( "tagType               : " << m_tagType );
    ATH_MSG_INFO( "calibarea_keras       : " << m_kerasCalibArea );
    ATH_MSG_INFO( "kerasConfigFileName   : " << m_kerasConfigFileName );
    ATH_MSG_INFO( "kerasConfigOutputName : " << m_kerasConfigOutputName );
    ATH_MSG_INFO( "strMassCutLow         : " << m_strMassCutLow );
    ATH_MSG_INFO( "strMassCutHigh        : " << m_strMassCutHigh );
    ATH_MSG_INFO( "pTCutLow              : " << m_jetPtMin );
    ATH_MSG_INFO( "pTCutHigh             : " << m_jetPtMax );
    ATH_MSG_INFO( "strScoreCut           : " << m_strScoreCut );
    ATH_MSG_INFO( "decorationName        : " << m_decorationName );
    if ( m_calcSF ) {
      ATH_MSG_INFO( "weightDecorationName  : " << m_weightDecorationName );
      ATH_MSG_INFO( "weightFile            : " << m_weightFileName );
      ATH_MSG_INFO( "weightHistogramName   : " << m_weightHistogramName );
      ATH_MSG_INFO( "efficiencyHistogramName : "<<m_efficiencyHistogramName );
      ATH_MSG_INFO( "weightFlavors         : " << m_weightFlavors );
      ATH_MSG_INFO( "TruthLabelName        : " << m_truthLabelName );
    }
  }
  else { 
    if ( (m_kerasConfigFileName.empty() ||
          m_kerasConfigOutputName.empty() ||
          m_strScoreCut.empty() ||
          m_strMassCutLow.empty() ||
          m_strMassCutHigh.empty() ||
          m_decorationName.empty() ||
          m_weightFileName.empty()) ||
        ((m_weightDecorationName.empty() ||
          m_weightHistogramName.empty() ||
          m_weightFlavors.empty()) && m_calcSF)
       )
    {
      ATH_MSG_ERROR( "No config file provided OR you haven't manually specified all needed parameters" ) ;
      ATH_MSG_ERROR( "Please read the TWiki for this tool" );
      return StatusCode::FAILURE;
    }
 
  }
 
  ATH_MSG_INFO( "Mass cut low   : " << m_strMassCutLow );
  ATH_MSG_INFO( "Mass cut High  : " << m_strMassCutHigh );
  ATH_MSG_INFO( "Score cut low  : " << m_strScoreCut );

  if ( m_kerasCalibArea.empty() ) {
    ATH_MSG_ERROR( "You need to specify where the calibarea is as either being Local or on CVMFS" );
    return StatusCode::FAILURE;
  }
  else if ( !m_kerasCalibArea.compare("Local") ){
    std::string localCalibArea = "BoostedJetTaggers/JSSWTopTaggerDNN/";
    ATH_MSG_INFO( "Using Local calibarea " << localCalibArea );
    m_kerasConfigFilePath = PathResolverFindCalibFile(localCalibArea+m_kerasConfigFileName);
    if ( m_calcSF )
      m_weightConfigPath = PathResolverFindCalibFile(localCalibArea+m_weightFileName);
  }
  else {
    ATH_MSG_INFO( "Using CVMFS calibarea" );
    m_kerasConfigFilePath = PathResolverFindCalibFile( (m_kerasCalibArea+m_kerasConfigFileName).c_str() );
    if ( m_calcSF )
      m_weightConfigPath = PathResolverFindCalibFile( (m_kerasCalibArea+m_weightFileName).c_str());
  }

  ATH_MSG_INFO( "DNN Tagger configured with: " << m_kerasConfigFilePath );
 
  std::ifstream input_cfg( m_kerasConfigFilePath.c_str() );
 
  if ( !input_cfg.is_open() ) {
    ATH_MSG_ERROR( "Error openning config file: " << m_kerasConfigFilePath );
    ATH_MSG_ERROR( "Are you sure that the file exists at this path?" );
    return StatusCode::FAILURE;
  }
 
  lwt::JSONConfig cfg = lwt::parse_json( input_cfg );
 
  ATH_MSG_INFO( "Keras Network NLayers: " << cfg.layers.size() );
 
  m_lwnn = std::make_unique<lwt::LightweightNeuralNetwork>(cfg.inputs, cfg.layers, cfg.outputs);

  if ( !m_tagType.compare("TopQuark") ) {
    ATH_MSG_DEBUG( "This is a top quark tagger" );
    m_tagClass = TAGCLASS::TopQuark;
  }
  else if ( !m_tagType.compare("WBoson") ) {
    ATH_MSG_DEBUG( "This is a W boson tagger" );
    m_tagClass = TAGCLASS::WBoson;
  }
  else if ( !m_tagType.compare("ZBoson") ) {
    ATH_MSG_DEBUG( "This is a Z boson tagger" );
    m_tagClass = TAGCLASS::ZBoson;
  }
  else {
    ATH_MSG_ERROR( "I can't tell what kind of tagger your configuration is for." );
    return StatusCode::FAILURE;
  }

  m_acceptInfo.addCut( "PassMassLow" , "mJet > mCutLow" );
  m_acceptInfo.addCut( "PassScore"   , "ScoreJet > ScoreCut" );
  if ( m_tagClass == TAGCLASS::WBoson || m_tagClass == TAGCLASS::ZBoson ) {
    m_acceptInfo.addCut( "PassMassHigh", "mJet < mCutHigh" );
  }

  printCuts();

  ATH_CHECK( JSSTaggerBase::initialize() );
 
#ifndef XAOD_STANDALONE
  if (m_suppressOutputDependence) {
    renounce(m_decPassMassKey);
    renounce(m_decPassScoreKey);
    renounce(m_decTaggedKey);
    renounce(m_decCutMLowKey);
    renounce(m_decCutMHighKey);
    renounce(m_decScoreCutKey);
    renounce(m_decScoreValueKey);
  }
#endif
 
  ATH_MSG_INFO( "DNN Tagger tool initialized" );
 
  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.

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 343 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 944 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 );
  }
}

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 368 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 352 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 325 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 JSSWTopTaggerDNN::tag ( const xAOD::Jet & jet ) const

overridevirtual

Decorate single jet with tagging info.

Create asg::AcceptData object

Reset the AcceptData cut results

Check basic kinematic selection

Get the relevant attributes of the jet Mass and pt - note that this will depend on the configuration of the calibration used

Calculate NSubjettiness and ECF ratios

Get DNN score for the jet

Evaluate the values of the upper and lower mass bounds and the d2 cut

Print cut criteria and jet values

Get SF weight

Decorate cut information if needed

Create WriteDecorHandles

Decorate values

Cut summary

Set the AcceptData depending on whether it is a W/Z or a top tagger

Implements JSSTaggerBase.

Definition at line 381 of file JSSWTopTaggerDNN.cxx.

                                                           {
 
  ATH_MSG_DEBUG( "Obtaining DNN result" );

  asg::AcceptData acceptData( &m_acceptInfo );

  ATH_CHECK( resetCuts( acceptData ) );

  ATH_CHECK( checkKinRange( jet, acceptData ) );

  float jet_pt   = jet.pt()/1000.0;
  float jet_mass = jet.m()/1000.0;

  calculateJSSRatios(jet);

  float jet_score = getScore(jet);

  float cut_mass_low  = m_funcMassCutLow ->Eval(jet_pt);
  float cut_mass_high = m_funcMassCutHigh->Eval(jet_pt);
  float cut_score     = m_funcScoreCut   ->Eval(jet_pt);

  ATH_MSG_VERBOSE( "Cut values : Mass window = [" << cut_mass_low << "," << cut_mass_high << "], score cut = " << cut_score );
  ATH_MSG_VERBOSE( "Jet values : Mass = " << jet_mass << ", score = " << jet_score );

  ATH_CHECK( getWeight( jet, jet_score > cut_score, acceptData ) );

  ATH_MSG_DEBUG( "Decorating with score" );

  SG::WriteDecorHandle<xAOD::JetContainer, char> decPassMass(m_decPassMassKey);
  SG::WriteDecorHandle<xAOD::JetContainer, char> decPassScore(m_decPassScoreKey);
  SG::WriteDecorHandle<xAOD::JetContainer, char> decTagged(m_decTaggedKey);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decCutMLow(m_decCutMLowKey);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decCutMHigh(m_decCutMHighKey);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decScoreCut(m_decScoreCutKey);
  SG::WriteDecorHandle<xAOD::JetContainer, float> decScoreValue(m_decScoreValueKey);

  decCutMLow(jet) = cut_mass_low;
  decCutMHigh(jet) = cut_mass_high;
  decScoreCut(jet) = cut_score;
  decScoreValue(jet) = jet_score;

  bool passCuts = true;

  if ( m_tagClass == TAGCLASS::WBoson || m_tagClass == TAGCLASS::ZBoson ) {
    ATH_MSG_VERBOSE( "Determining WZ tag return" );
    if ( jet_mass > cut_mass_low ) acceptData.setCutResult( "PassMassLow", true );
    if ( jet_mass < cut_mass_high ) acceptData.setCutResult( "PassMassHigh", true );
    if ( jet_score > cut_score ) acceptData.setCutResult( "PassScore", true );
    decPassMass(jet) = acceptData.getCutResult( "PassMassLow" ) && acceptData.getCutResult( "PassMassHigh" );
    passCuts = passCuts && acceptData.getCutResult( "PassMassLow" ) && acceptData.getCutResult( "PassMassHigh" );
  }
  else if ( m_tagClass == TAGCLASS::TopQuark ) {
    ATH_MSG_VERBOSE( "Determining TopQuark tag return" );
    if ( jet_mass > cut_mass_low ) acceptData.setCutResult( "PassMassLow", true );
    if ( jet_score > cut_score ) acceptData.setCutResult( "PassScore", true );
    decPassMass(jet) = acceptData.getCutResult( "PassMassLow" );
    passCuts = passCuts && acceptData.getCutResult( "PassMassLow" );
  }
 
  decPassScore(jet) = acceptData.getCutResult( "PassScore" );
 
  passCuts = passCuts && acceptData.getCutResult( "PassScore" );
 
  decTagged(jet) = passCuts;
 
  return StatusCode::SUCCESS;
 
}

updateVHKA()

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

inlineinherited

Definition at line 298 of file AthCommonDataStore.h.

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

m_calcSF

bool JSSTaggerBase::m_calcSF {}

protectedinherited

Flag to calculate scale factor.

Definition at line 193 of file JSSTaggerBase.h.

{};

m_calibArea

std::string JSSTaggerBase::m_calibArea

protectedinherited

Location where config files live on cvmfs.

Definition at line 112 of file JSSTaggerBase.h.

m_configFile

std::string JSSTaggerBase::m_configFile

protectedinherited

Configuration file name.

Definition at line 109 of file JSSTaggerBase.h.

m_configReader

TEnv JSSTaggerBase::m_configReader

protectedinherited

TEnv instance to read config files.

Definition at line 62 of file JSSTaggerBase.h.

m_containerName

std::string JSSTaggerBase::m_containerName

protectedinherited

Configurable members.

Jet container name

Definition at line 102 of file JSSTaggerBase.h.

m_decC2Key

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

protectedinherited

Definition at line 144 of file JSSTaggerBase.h.

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

m_decCutMHighKey

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

protectedinherited

Definition at line 220 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 219 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 145 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 146 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 226 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 227 of file JSSTaggerBase.h.

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

m_decL2Key

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

protectedinherited

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

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

m_decorationName

std::string JSSTaggerBase::m_decorationName

protectedinherited

Decoration name.

Definition at line 188 of file JSSTaggerBase.h.

m_decPassMassKey

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

protectedinherited

Definition at line 76 of file JSSTaggerBase.h.

{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 77 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 221 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 222 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 228 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 68 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 140 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 141 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 142 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 71 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 74 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 73 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 72 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 69 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 70 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 225 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 381 of file AthCommonDataStore.h.

m_DNN_inputValues

std::map<std::string, double> JSSWTopTaggerDNN::m_DNN_inputValues

private

Variables for DNN.

Definition at line 34 of file JSSWTopTaggerDNN.h.

m_efficiencyHistogramName

std::string JSSTaggerBase::m_efficiencyHistogramName

protectedinherited

Definition at line 200 of file JSSTaggerBase.h.

m_efficiencyHistograms

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

protectedinherited

Definition at line 206 of file JSSTaggerBase.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 378 of file AthCommonDataStore.h.

m_funcMassCutHigh

std::unique_ptr<TF1> JSSTaggerBase::m_funcMassCutHigh

protectedinherited

Definition at line 184 of file JSSTaggerBase.h.

m_funcMassCutLow

std::unique_ptr<TF1> JSSTaggerBase::m_funcMassCutLow

protectedinherited

TF1 for cut functions.

Definition at line 183 of file JSSTaggerBase.h.

m_funcScoreCut

std::unique_ptr<TF1> JSSTaggerBase::m_funcScoreCut

protectedinherited

Definition at line 185 of file JSSTaggerBase.h.

m_isMC

bool JSSTaggerBase::m_isMC {}

protectedinherited

Definition at line 194 of file JSSTaggerBase.h.

{};

m_isSmallRJet

bool JSSTaggerBase::m_isSmallRJet = false

protectedinherited

Definition at line 103 of file JSSTaggerBase.h.

m_jetEtaMax

float JSSTaggerBase::m_jetEtaMax {}

protectedinherited

Definition at line 132 of file JSSTaggerBase.h.

{};

m_jetPtMax

float JSSTaggerBase::m_jetPtMax {}

protectedinherited

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

{};

m_kerasCalibArea

std::string JSSTaggerBase::m_kerasCalibArea

protectedinherited

Definition at line 118 of file JSSTaggerBase.h.

m_kerasConfigFileName

std::string JSSTaggerBase::m_kerasConfigFileName

protectedinherited

Keras configurations for ML taggers.

Definition at line 115 of file JSSTaggerBase.h.

m_kerasConfigFilePath

std::string JSSTaggerBase::m_kerasConfigFilePath

protectedinherited

Definition at line 116 of file JSSTaggerBase.h.

m_kerasConfigOutputName

std::string JSSTaggerBase::m_kerasConfigOutputName

protectedinherited

Definition at line 117 of file JSSTaggerBase.h.

m_lwnn

std::unique_ptr<lwt::LightweightNeuralNetwork> JSSWTopTaggerDNN::m_lwnn

private

DNN tools.

Definition at line 32 of file JSSWTopTaggerDNN.h.

m_nWarnMax

const int JSSTaggerBase::m_nWarnMax = 10

protectedinherited

Maximum number of warnings.

Definition at line 80 of file JSSTaggerBase.h.

m_nWarnVar

std::atomic<int> JSSTaggerBase::m_nWarnVar

mutableprotectedinherited

Warning counters.

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

m_readECF1Key

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

protectedinherited

Definition at line 156 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 157 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 158 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 170 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 169 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 168 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 172 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 163 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 166 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 160 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 161 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 151 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 152 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 153 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 154 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 165 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 216 of file JSSTaggerBase.h.

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

m_scoreDecorationName

Gaudi::Property<std::string> JSSTaggerBase::m_scoreDecorationName {this, "scoreDecorationName", "", "tagger output scoure decoration name"}

protectedinherited

Definition at line 189 of file JSSTaggerBase.h.

{this, "scoreDecorationName", "", "tagger output scoure decoration name"};

m_strMassCutHigh

std::string JSSTaggerBase::m_strMassCutHigh

protectedinherited

Definition at line 179 of file JSSTaggerBase.h.

m_strMassCutLow

std::string JSSTaggerBase::m_strMassCutLow

protectedinherited

Strings for cut functions.

Definition at line 178 of file JSSTaggerBase.h.

m_strScoreCut

std::string JSSTaggerBase::m_strScoreCut

protectedinherited

Definition at line 180 of file JSSTaggerBase.h.

m_suppressInputDependence

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

protectedinherited

Definition at line 174 of file JSSTaggerBase.h.

{this, "SuppressInputDependence", false};

m_suppressOutputDependence

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

protectedinherited

Definition at line 175 of file JSSTaggerBase.h.

{this, "SuppressOutputDependence", false};

m_tagClass

TAGCLASS JSSTaggerBase::m_tagClass {Unknown}

protectedinherited

Definition at line 97 of file JSSTaggerBase.h.

{Unknown};

m_tagType

std::string JSSTaggerBase::m_tagType

protectedinherited

Definition at line 127 of file JSSTaggerBase.h.

m_tmvaCalibArea

std::string JSSTaggerBase::m_tmvaCalibArea

protectedinherited

Definition at line 123 of file JSSTaggerBase.h.

m_tmvaConfigFileName

std::string JSSTaggerBase::m_tmvaConfigFileName

protectedinherited

TMVA configurations for BDT taggers.

Definition at line 121 of file JSSTaggerBase.h.

m_tmvaConfigFilePath

std::string JSSTaggerBase::m_tmvaConfigFilePath

protectedinherited

Definition at line 122 of file JSSTaggerBase.h.

m_truthBosonContainerName

std::string JSSTaggerBase::m_truthBosonContainerName

protectedinherited

Definition at line 211 of file JSSTaggerBase.h.

m_truthLabelName

std::string JSSTaggerBase::m_truthLabelName

protectedinherited

Definition at line 213 of file JSSTaggerBase.h.

m_truthLabelUseTRUTH3

bool JSSTaggerBase::m_truthLabelUseTRUTH3 {}

protectedinherited

Truth label options.

Definition at line 209 of file JSSTaggerBase.h.

{};

m_truthParticleContainerName

std::string JSSTaggerBase::m_truthParticleContainerName

protectedinherited

Definition at line 210 of file JSSTaggerBase.h.

m_truthTopQuarkContainerName

std::string JSSTaggerBase::m_truthTopQuarkContainerName

protectedinherited

Definition at line 212 of file JSSTaggerBase.h.

m_useECFG

bool JSSTaggerBase::m_useECFG = false

protectedinherited

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

Definition at line 136 of file JSSTaggerBase.h.

m_useLSeries

bool JSSTaggerBase::m_useLSeries = false

protectedinherited

Definition at line 137 of file JSSTaggerBase.h.

m_useMassCut

bool JSSTaggerBase::m_useMassCut = false

protectedinherited

Flag to indicate if mass window cut is used.

Definition at line 90 of file JSSTaggerBase.h.

m_useScoreCut

bool JSSTaggerBase::m_useScoreCut = false

protectedinherited

Flag to indicate if a discriminant score is used.

Definition at line 93 of file JSSTaggerBase.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 387 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 386 of file AthCommonDataStore.h.

m_weightConfig

std::unique_ptr<TFile> JSSTaggerBase::m_weightConfig

protectedinherited

Histograms for scale factors.

Definition at line 204 of file JSSTaggerBase.h.

m_weightConfigPath

std::string JSSTaggerBase::m_weightConfigPath

protectedinherited

Path to the SF configuration root file.

Definition at line 106 of file JSSTaggerBase.h.

m_weightDecorationName

std::string JSSTaggerBase::m_weightDecorationName

protectedinherited

String for scale factor decoration names.

Definition at line 197 of file JSSTaggerBase.h.

m_weightFileName

std::string JSSTaggerBase::m_weightFileName

protectedinherited

Definition at line 198 of file JSSTaggerBase.h.

m_weightFlavors

std::string JSSTaggerBase::m_weightFlavors

protectedinherited

Definition at line 201 of file JSSTaggerBase.h.

m_weightHistogramName

std::string JSSTaggerBase::m_weightHistogramName

protectedinherited

Definition at line 199 of file JSSTaggerBase.h.

m_weightHistograms

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

protectedinherited

Definition at line 205 of file JSSTaggerBase.h.

m_wkpt

std::string JSSTaggerBase::m_wkpt

protectedinherited

Tagger information.

Definition at line 126 of file JSSTaggerBase.h.

---

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

• JSSWTopTaggerDNN.h
• JSSWTopTaggerDNN.cxx