ATLAS Offline Software
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
Prompt::DecoratePLIT Class Reference

#include <DecoratePLIT.h>

Inheritance diagram for Prompt::DecoratePLIT:
Collaboration diagram for Prompt::DecoratePLIT:

Public Member Functions

 DecoratePLIT (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual StatusCode initialize () override
 
virtual StatusCode execute (const EventContext &) const override
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual bool isClonable () const override
 Specify if the algorithm is clonable. More...
 
virtual unsigned int cardinality () const override
 Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...
 
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
virtual bool filterPassed (const EventContext &ctx) const
 
virtual void setFilterPassed (bool state, const EventContext &ctx) const
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

StatusCode initializeAccessors ()
 
StatusCode predictElec (const xAOD::Electron &electron, const xAOD::JetContainer &trackjets, const xAOD::TrackParticleContainer &tracks, const xAOD::CaloClusterContainer &caloclusters, std::vector< SG::WriteDecorHandle< xAOD::ElectronContainer, float >> &dec_el_plit_output, const EventContext &ctx) const
 
StatusCode predictMuon (const xAOD::Muon &muon, const xAOD::JetContainer &trackjets, const xAOD::TrackParticleContainer &tracks, std::vector< SG::WriteDecorHandle< xAOD::MuonContainer, float >> &dec_mu_plit_output, const EventContext &ctx) const
 
const xAOD::Jet * findClosestTrackJet (const xAOD::IParticle &part, const xAOD::JetContainer &jets) const
 
bool passed_r22tracking_cuts (const xAOD::TrackParticle &tp, const EventContext &ctx) const
 
StatusCode decorateTrack (const xAOD::TrackParticle &track, float dr_lepton, bool isUsedForElectron, bool isUsedForMuon, const xAOD::Jet *trackJet, const xAOD::TrackParticle *trackLep) const
 
StatusCode fillParticles (std::vector< const xAOD::IParticle * > &parts, const xAOD::IParticle &lepton, const xAOD::TrackParticle *trackLep, const xAOD::Jet *trackJet, const xAOD::TrackParticleContainer &trackContainer, const EventContext &ctx) const
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

std::shared_ptr< const FlavorTagDiscriminants::OnnxUtil > m_onnxUtil {}
 
std::shared_ptr< const FlavorTagDiscriminants::OnnxUtil > m_onnxUtil_endcap {}
 
int m_num_lepton_features
 
int m_num_track_features
 
Gaudi::Property< std::string > m_leptonsName
 
Gaudi::Property< std::string > m_configPath {this, "ConfigPath", "", "Path of the directory containing the onnx files"}
 
Gaudi::Property< std::string > m_configFileVersion {this, "ConfigFileVersion", "", "Vector of tagger score files"}
 
Gaudi::Property< std::string > m_configFileVersion_endcap {this, "ConfigFileVersion_endcap", "", "Vector of tagger score files for endcap"}
 
Gaudi::Property< std::string > m_TaggerName {this, "TaggerName", "", "Tagger name"}
 
Gaudi::Property< float > m_maxLepTrackJetdR
 
Gaudi::Property< float > m_maxLepTrackdR
 
Gaudi::Property< float > m_lepCalErelConeSize
 
Gaudi::Property< std::string > m_btagIp_prefix
 
SG::ReadHandleKey< xAOD::ElectronContainer > m_electronsKey
 
SG::ReadHandleKey< xAOD::MuonContainer > m_muonsKey
 
SG::ReadHandleKey< xAOD::JetContainer > m_trackjetsKey
 
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_tracksKey
 
SG::ReadHandleKey< xAOD::CaloClusterContainer > m_caloclustersKey
 
SG::ReadDecorHandleKey< xAOD::MuonContainer > m_acc_mu_ptvarcone30TTVA {this, "acc_mu_ptvarcone30TTVA",m_muonsKey, "ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500"}
 
SG::ReadDecorHandleKey< xAOD::MuonContainer > m_acc_mu_topoetcone30 {this, "acc_mu_topoetcone30",m_muonsKey, "topoetcone30"}
 
SG::ReadDecorHandleKey< xAOD::ElectronContainer > m_acc_el_ptvarcone30 {this,"acc_el_ptvarcone30",m_electronsKey, "ptvarcone30"}
 
SG::ReadDecorHandleKey< xAOD::ElectronContainer > m_acc_el_topoetcone30 {this,"acc_el_topoetcone30",m_electronsKey, "topoetcone30"}
 
SG::ReadDecorHandleKey< xAOD::TrackParticleContainer > m_acc_trk_ptfrac {this,"acc_trk_ptfrac",m_tracksKey, "ptfrac"}
 
SG::ReadDecorHandleKey< xAOD::TrackParticleContainer > m_acc_trk_dr_trackjet {this,"acc_trk_dr_trackjet", m_tracksKey, "dr_trackjet"}
 
SG::ReadDecorHandleKey< xAOD::TrackParticleContainer > m_acc_trk_dr_lepton {this, "acc_trk_dr_lepton",m_tracksKey, "dr_lepton"}
 
SG::ReadDecorHandleKey< xAOD::TrackParticleContainer > m_acc_trk_d0 {this,"acc_trk_d0", m_tracksKey, m_btagIp_prefix + "d0"}
 
SG::ReadDecorHandleKey< xAOD::TrackParticleContainer > m_acc_trk_z0SinTheta {this, "acc_trk_z0SinTheta", m_tracksKey, m_btagIp_prefix + "z0SinTheta"}
 
SG::ReadDecorHandleKey< xAOD::TrackParticleContainer > m_acc_trk_d0Uncertainty {this, "acc_trk_d0Uncertainty", m_tracksKey, m_btagIp_prefix + "d0Uncertainty"}
 
SG::ReadDecorHandleKey< xAOD::TrackParticleContainer > m_acc_trk_z0SinThetaUncertainty {this, "acc_trk_z0SinThetaUncertainty", m_tracksKey, m_btagIp_prefix + "z0SinThetaUncertainty"}
 
SG::ReadDecorHandleKey< xAOD::TrackParticleContainer > m_acc_trk_muon_track {this, "acc_trk_muon_track", m_tracksKey, "muon_track"}
 
SG::ReadDecorHandleKey< xAOD::TrackParticleContainer > m_acc_trk_electron_track {this,"acc_trk_electron_track", m_tracksKey, "electron_track"}
 
SG::WriteDecorHandleKeyArray< xAOD::ElectronContainer > m_dec_el_plit_output {this, "PLITelOutput", {}}
 
SG::WriteDecorHandleKeyArray< xAOD::MuonContainer > m_dec_mu_plit_output {this, "PLITmuOutput", {}}
 
DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. More...
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 33 of file DecoratePLIT.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ DecoratePLIT()

Prompt::DecoratePLIT::DecoratePLIT ( const std::string &  name,
ISvcLocator *  pSvcLocator 
)

Definition at line 15 of file DecoratePLIT.cxx.

16  : AthReentrantAlgorithm(name, pSvcLocator)
17  {}

Member Function Documentation

◆ cardinality()

unsigned int AthReentrantAlgorithm::cardinality ( ) const
overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Override this to return 0 for reentrant algorithms.

Definition at line 55 of file AthReentrantAlgorithm.cxx.

56 {
57  return 0;
58 }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

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

◆ declareProperty() [1/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

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

◆ declareProperty() [2/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

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

◆ declareProperty() [3/6]

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

Definition at line 259 of file AthCommonDataStore.h.

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

◆ declareProperty() [4/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

◆ decorateTrack()

StatusCode Prompt::DecoratePLIT::decorateTrack ( const xAOD::TrackParticle &  track,
float  dr_lepton,
bool  isUsedForElectron,
bool  isUsedForMuon,
const xAOD::Jet *  trackJet,
const xAOD::TrackParticle *  trackLep 
) const
private

Definition at line 837 of file DecoratePLIT.cxx.

844  {
845  // define decorators
846  SG::AuxElement::Decorator<float> dec_trk_dr_lepton("dr_lepton");
847  SG::AuxElement::Decorator<char> dec_trk_electron_track("electron_track");
848  SG::AuxElement::Decorator<char> dec_trk_muon_track("muon_track");
849  SG::AuxElement::Decorator<float> dec_trk_ptfrac("ptfrac");
850  SG::AuxElement::Decorator<float> dec_trk_dr_trackjet("dr_trackjet");
851  SG::AuxElement::Decorator<float> dec_trk_dr_leptontrack("dr_leptontrack");
852 
853  // Apply values to decorators
854  dec_trk_dr_lepton(track) = dr_lepton;
855  dec_trk_electron_track(track) = static_cast<char>(isUsedForElectron);
856  dec_trk_muon_track(track) = static_cast<char>(isUsedForMuon);
857 
858  // Default values for track-related decorations
859  float ptfrac = -99;
860  float dr_trackjet = -99;
861  float dr_leptontrack = -99;
862 
863  // Update values if trackJet is present
864  if (trackJet) {
865  if (trackJet->pt() > 0.) {
866  ptfrac = track.pt() / trackJet->pt();
867  dr_trackjet = track.p4().DeltaR(trackJet->p4());
868  }
869  }
870 
871  // Update values if trackLep is present
872  if (trackLep) {
873  if (trackLep->pt() > 0.) {
874  dr_leptontrack = track.p4().DeltaR(trackLep->p4());
875  }
876  }
877 
878  // Assign updated values to decorators
879  dec_trk_ptfrac(track) = ptfrac;
880  dec_trk_dr_trackjet(track) = dr_trackjet;
881  dec_trk_dr_leptontrack(track) = dr_leptontrack;
882 
883  return StatusCode::SUCCESS;
884  }

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode Prompt::DecoratePLIT::execute ( const EventContext &  ctx) const
overridevirtual

Definition at line 104 of file DecoratePLIT.cxx.

104  {
105  SG::ReadHandle<xAOD::JetContainer> trackjets(m_trackjetsKey, ctx);
106  SG::ReadHandle<xAOD::TrackParticleContainer> tracks(m_tracksKey, ctx);
107  SG::ReadHandle<xAOD::CaloClusterContainer> caloclusters(m_caloclustersKey, ctx);
108 
109  if (!m_electronsKey.empty()) {
110  // prepare decorators
111  // ------------------
112  std::vector<SG::WriteDecorHandle<xAOD::ElectronContainer, float>> dec_el_plit_output;
113  for (const auto& wdhk: m_dec_el_plit_output) {
114  dec_el_plit_output.emplace_back(wdhk, ctx);
115  }
116  SG::ReadHandle<xAOD::ElectronContainer> electrons(m_electronsKey, ctx);
117  for (const xAOD::Electron* elec : *electrons) {
118  if (!predictElec(*elec, *trackjets, *tracks, *caloclusters, dec_el_plit_output, ctx)) {
119  ATH_MSG_ERROR("DecoratePLIT::execute - failed to predict electron");
120  return StatusCode::FAILURE;
121  }
122  }
123  } else if (!m_muonsKey.empty()) {
124  // prepare decorators
125  // ------------------
126  std::vector<SG::WriteDecorHandle<xAOD::MuonContainer, float>> dec_mu_plit_output;
127  for (const auto& wdhk: m_dec_mu_plit_output) {
128  dec_mu_plit_output.emplace_back(wdhk, ctx);
129  }
130  SG::ReadHandle<xAOD::MuonContainer> muons(m_muonsKey, ctx);
131  for (const xAOD::Muon* muon : *muons) {
132  if (!predictMuon(*muon, *trackjets, *tracks, dec_mu_plit_output, ctx)) {
133  ATH_MSG_ERROR("DecoratePLIT::execute - failed to predict muon");
134  return StatusCode::FAILURE;
135  }
136  }
137  }
138 
139  return StatusCode::SUCCESS;
140  }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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

◆ extraOutputDeps()

const DataObjIDColl & AthReentrantAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 79 of file AthReentrantAlgorithm.cxx.

80 {
81  // If we didn't find any symlinks to add, just return the collection
82  // from the base class. Otherwise, return the extended collection.
83  if (!m_extendedExtraObjects.empty()) {
84  return m_extendedExtraObjects;
85  }
86  return Algorithm::extraOutputDeps();
87 }

◆ fillParticles()

StatusCode Prompt::DecoratePLIT::fillParticles ( std::vector< const xAOD::IParticle * > &  parts,
const xAOD::IParticle &  lepton,
const xAOD::TrackParticle *  trackLep,
const xAOD::Jet *  trackJet,
const xAOD::TrackParticleContainer &  trackContainer,
const EventContext &  ctx 
) const
private

Definition at line 783 of file DecoratePLIT.cxx.

790  {
791  // get lepton four momentum
792  const FourMom_t lepton_p4 = lepton.p4();
793 
794  // Precompute tracks used for reconstruction
795  std::set<const xAOD::TrackParticle*> tracksUsedForElectron;
796  std::set<const xAOD::TrackParticle*> tracksUsedForMuon;
797  if (const auto* elec = dynamic_cast<const xAOD::Electron*>(&lepton)) {
798  tracksUsedForElectron = xAOD::EgammaHelpers::getTrackParticles(elec, true); // useBremAssoc = true
799  } else if (const auto* muon = dynamic_cast<const xAOD::Muon*>(&lepton)) {
800  if (muon->muonType() == xAOD::Muon::Combined && muon->inDetTrackParticleLink().isValid()) {
801  tracksUsedForMuon.insert(muon->primaryTrackParticle());
802  }
803  }
804 
805  // Loop over tracks and store them
806  for (const xAOD::TrackParticle *track: trackContainer) {
807  if (!track) {
808  ATH_MSG_ERROR("DecoratePLIT::fillParticles - null track pointer");
809  }
810  // check if track passed selection
811  if (!passed_r22tracking_cuts(*track, ctx)) continue;
812 
813  // decorate track
814  float dr_lepton = (lepton.p4().Pt() > 0.) ? track->p4().DeltaR(lepton.p4()) : -99;
815  bool isUsedForElectron = tracksUsedForElectron.count(track);
816  bool isUsedForMuon = tracksUsedForMuon.count(track);
817 
818  if (!decorateTrack(*track, dr_lepton, isUsedForElectron, isUsedForMuon, trackJet, trackLep)) {
819  ATH_MSG_ERROR("DecoratePLIT::fillParticles - failed to decorate track");
820  return StatusCode::FAILURE;
821  }
822 
823  // fill track
824  if (m_maxLepTrackdR < 0 || dr_lepton < m_maxLepTrackdR)
825  parts.push_back(track);
826  }
827 
828  // Sort tracks by dR distance to lepton
829  auto SORT_TRACKLEP = [&lepton_p4](const xAOD::IParticle* a, const xAOD::IParticle* b) {
830  return a->p4().DeltaR(lepton_p4) < b->p4().DeltaR(lepton_p4);
831  };
832  std::sort(parts.begin(), parts.end(), SORT_TRACKLEP);
833 
834  return StatusCode::SUCCESS;
835  }

◆ filterPassed()

virtual bool AthReentrantAlgorithm::filterPassed ( const EventContext &  ctx) const
inlinevirtualinherited

Definition at line 135 of file AthReentrantAlgorithm.h.

135  {
136  return execState( ctx ).filterPassed();
137  }

◆ findClosestTrackJet()

const xAOD::Jet * Prompt::DecoratePLIT::findClosestTrackJet ( const xAOD::IParticle &  part,
const xAOD::JetContainer &  jets 
) const
private

Definition at line 688 of file DecoratePLIT.cxx.

688  {
689  const xAOD::Jet* closestJet = nullptr;
690  float minDistance = std::numeric_limits<float>::max();
691 
692  for (const xAOD::Jet* jet : jets) {
693  float distance = part.p4().DeltaR(jet->p4());
694  if (distance < minDistance) {
695  minDistance = distance;
696  closestJet = jet;
697  }
698  }
699 
700  return (minDistance < m_maxLepTrackJetdR) ? closestJet : nullptr;
701  }

◆ initialize()

StatusCode Prompt::DecoratePLIT::initialize ( )
overridevirtual

Definition at line 19 of file DecoratePLIT.cxx.

19  {
20  ATH_MSG_DEBUG("Initializing DecoratePLIT " << name() );
21  ATH_MSG_DEBUG("m_leptonsName = " << m_leptonsName);
22 
23  ATH_MSG_DEBUG("Initializing " << m_electronsKey);
24  ATH_MSG_DEBUG("Initializing " << m_muonsKey);
25  ATH_MSG_DEBUG("Initializing " << m_trackjetsKey);
26  ATH_MSG_DEBUG("Initializing " << m_tracksKey);
27  ATH_MSG_DEBUG("Initializing " << m_caloclustersKey);
28 
29  ATH_CHECK(m_electronsKey.initialize(m_leptonsName == "Electrons"));
30  ATH_CHECK(m_muonsKey.initialize(m_leptonsName == "Muons"));
31  ATH_CHECK(m_trackjetsKey.initialize());
32  ATH_CHECK(m_tracksKey.initialize());
33  ATH_CHECK(m_caloclustersKey.initialize());
34 
35  // initialise accessors
36  ATH_CHECK(initializeAccessors());
37 
38  // Load and initialize the neural network model from the given file path.
39  if(m_leptonsName == "Electrons") {
40  std::string fullPathToOnnxFile = PathResolverFindCalibFile(m_configPath.value() + m_configFileVersion.value());
41  m_onnxUtil = std::make_shared<FlavorTagDiscriminants::OnnxUtil>(fullPathToOnnxFile);
42 
43  std::string fullPathToOnnxFile_endcap = PathResolverFindCalibFile(m_configPath.value() + m_configFileVersion_endcap.value());
44  m_onnxUtil_endcap = std::make_shared<FlavorTagDiscriminants::OnnxUtil>(fullPathToOnnxFile_endcap);
45 
46  m_num_lepton_features = 15;
47  m_num_track_features = 19;
48 
49  // set up decorators using a dummy query of the onnx model
50  std::map<std::string, FlavorTagDiscriminants::Inputs> gnn_input;
51  std::vector<float> elec_feat(m_num_lepton_features, 0.);
52  std::vector<int64_t> elec_feat_dim = {1, static_cast<int64_t>(elec_feat.size())};
53  FlavorTagDiscriminants::Inputs elec_info (elec_feat, elec_feat_dim);
54  gnn_input.insert({"jet_features", elec_info});
55  std::vector<float> track_feat(m_num_track_features, 0.);
56  std::vector<int64_t> track_feat_dim = {1, m_num_track_features};
57  FlavorTagDiscriminants::Inputs track_info(track_feat, track_feat_dim);
58  gnn_input.insert({"track_features", track_info});
59  auto [out_f, out_vc, out_vf] = m_onnxUtil->runInference(gnn_input);
60 
61  std::vector<std::string> output_names;
62  for (auto& singlefloat : out_f){
63  output_names.push_back(m_electronsKey.key()+"." + m_TaggerName + "_" + singlefloat.first);
64  }
65  ATH_CHECK(m_dec_el_plit_output.assign(output_names));
66  ATH_CHECK(m_dec_el_plit_output.initialize());
67  }
68  else if (m_leptonsName == "Muons") {
69  std::string fullPathToOnnxFile = PathResolverFindCalibFile(m_configPath.value() + m_configFileVersion.value());
70  m_onnxUtil = std::make_shared<FlavorTagDiscriminants::OnnxUtil>(fullPathToOnnxFile);
71 
72  m_num_lepton_features = 10;
73  m_num_track_features = 18;
74 
75  // set up decorators using a dummy query of the onnx model
76  std::map<std::string, FlavorTagDiscriminants::Inputs> gnn_input;
77  std::vector<float> muon_feat(m_num_lepton_features, 0.);
78  std::vector<int64_t> muon_feat_dim = {1, static_cast<int64_t>(muon_feat.size())};
79  FlavorTagDiscriminants::Inputs muon_info (muon_feat, muon_feat_dim);
80  gnn_input.insert({"jet_features", muon_info});
81  std::vector<float> track_feat(m_num_track_features, 0.);
82  std::vector<int64_t> track_feat_dim = {1, m_num_track_features};
83  FlavorTagDiscriminants::Inputs track_info(track_feat, track_feat_dim);
84  gnn_input.insert({"track_features", track_info});
85  auto [out_f, out_vc, out_vf] = m_onnxUtil->runInference(gnn_input);
86 
87  std::vector<std::string> output_names;
88  for (auto& singlefloat : out_f){
89  output_names.push_back(m_muonsKey.key()+"." + m_TaggerName + "_" + singlefloat.first);
90  }
91  ATH_CHECK(m_dec_mu_plit_output.assign(output_names));
92  ATH_CHECK(m_dec_mu_plit_output.initialize());
93  }
94  else {
95  ATH_MSG_ERROR(" ==> topology is not recognised! aborting.");
96  return StatusCode::FAILURE;
97  }
98 
99  ATH_MSG_INFO("DecoratePLIT " << name() << " initialization done." );
100 
101  return StatusCode::SUCCESS;
102  }

◆ initializeAccessors()

StatusCode Prompt::DecoratePLIT::initializeAccessors ( )
private

Definition at line 142 of file DecoratePLIT.cxx.

142  {
143 
144  ATH_CHECK(m_acc_mu_ptvarcone30TTVA.initialize(!m_muonsKey.empty()));
145  ATH_CHECK(m_acc_mu_topoetcone30.initialize(!m_muonsKey.empty()));
146 
147  ATH_CHECK(m_acc_el_ptvarcone30.initialize(!m_electronsKey.empty()));
148  ATH_CHECK(m_acc_el_topoetcone30.initialize(!m_electronsKey.empty()));
149 
150  ATH_CHECK(m_acc_trk_ptfrac.initialize());
151  ATH_CHECK(m_acc_trk_dr_trackjet.initialize());
152  ATH_CHECK(m_acc_trk_dr_lepton.initialize());
153  ATH_CHECK(m_acc_trk_d0.initialize());
154  ATH_CHECK(m_acc_trk_z0SinTheta.initialize());
155  ATH_CHECK(m_acc_trk_d0Uncertainty.initialize());
156  ATH_CHECK(m_acc_trk_z0SinThetaUncertainty.initialize());
157  ATH_CHECK(m_acc_trk_muon_track.initialize());
158  ATH_CHECK(m_acc_trk_electron_track.initialize());
159 
160  return StatusCode::SUCCESS;
161  }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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.

◆ isClonable()

bool AthReentrantAlgorithm::isClonable ( ) const
overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in Simulation::BeamEffectsAlg, InDet::SiTrackerSpacePointFinder, InDet::SCT_Clusterization, InDet::SiSPSeededTrackFinder, SCTRawDataProvider, InDet::GNNSeedingTrackMaker, SCT_PrepDataToxAOD, RoIBResultToxAOD, SCT_CablingCondAlgFromCoraCool, SCT_ReadCalibDataTestAlg, SCT_CablingCondAlgFromText, InDet::SiSPGNNTrackMaker, SCT_ReadCalibChipDataTestAlg, SCT_TestCablingAlg, SCT_ConfigurationConditionsTestAlg, ITkPixelCablingAlg, ITkStripCablingAlg, SCTEventFlagWriter, SCT_ConditionsSummaryTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_TdaqEnabledTestAlg, SCT_SiliconConditionsTestAlg, SCTSiLorentzAngleTestAlg, SCT_ByteStreamErrorsTestAlg, SCT_ConditionsParameterTestAlg, SCT_FlaggedConditionTestAlg, SCT_StripVetoTestAlg, SCT_RawDataToxAOD, and SCTSiPropertiesTestAlg.

Definition at line 44 of file AthReentrantAlgorithm.cxx.

45 {
46  // Reentrant algorithms are clonable.
47  return true;
48 }

◆ msg() [1/2]

MsgStream& AthCommonMsg< Gaudi::Algorithm >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

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

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

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

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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.

◆ passed_r22tracking_cuts()

bool Prompt::DecoratePLIT::passed_r22tracking_cuts ( const xAOD::TrackParticle &  tp,
const EventContext &  ctx 
) const
private

Definition at line 703 of file DecoratePLIT.cxx.

704  {
705  // r22 default track selection for flavour tagging GN2 algorithm
706  constexpr float pt_minimum = 500; // MeV
707  constexpr float abs_eta_maximum = 2.5;
708  constexpr float d0_maximum = 3.5;
709  constexpr float z0_maximum= 5.0;
710  constexpr unsigned char si_hits_minimum = 8;
711  constexpr unsigned char si_shared_maximum = 1;
712  constexpr unsigned char si_holes_maximum = 2;
713  constexpr unsigned char pix_holes_maximum = 1;
714 
715  // accessors
716  SG::ReadDecorHandle<xAOD::TrackParticleContainer, float> acc_d0{m_acc_trk_d0, ctx};
717  SG::ReadDecorHandle<xAOD::TrackParticleContainer, float> acc_z0SinTheta{m_acc_trk_z0SinTheta, ctx};
718 
719  // get hit pixel info
720  uint8_t pix_shared = 0;
721  if(!tp.summaryValue(pix_shared,xAOD::numberOfPixelSharedHits)){
722  ATH_MSG_ERROR("DecoratePLIT::passed_r22tracking_cuts - failed to retrieve xAOD::numberOfPixelSharedHits");
723  return false;
724  }
725  uint8_t sct_shared = 0;
726  if(!tp.summaryValue(sct_shared,xAOD::numberOfSCTSharedHits)){
727  ATH_MSG_ERROR("DecoratePLIT::passed_r22tracking_cuts - failed to retrieve xAOD::numberOfSCTSharedHits");
728  return false;
729  }
730  uint8_t pix_hits = 0;
731  if(!tp.summaryValue(pix_hits,xAOD::numberOfPixelHits)){
732  ATH_MSG_ERROR("DecoratePLIT::passed_r22tracking_cuts - failed to retrieve xAOD::numberOfPixelHits");
733  return false;
734  }
735  uint8_t sct_hits = 0;
736  if(!tp.summaryValue(sct_hits,xAOD::numberOfSCTHits)){
737  ATH_MSG_ERROR("DecoratePLIT::passed_r22tracking_cuts - failed to retrieve xAOD::numberOfSCTHits");
738  return false;
739  }
740  uint8_t pix_dead = 0;
741  if(!tp.summaryValue(pix_dead,xAOD::numberOfPixelDeadSensors)){
742  ATH_MSG_ERROR("DecoratePLIT::passed_r22tracking_cuts - failed to retrieve xAOD::numberOfPixelDeadSensors");
743  return false;
744  }
745  uint8_t sct_dead = 0;
746  if(!tp.summaryValue(sct_dead,xAOD::numberOfSCTDeadSensors)){
747  ATH_MSG_ERROR("DecoratePLIT::passed_r22tracking_cuts - failed to retrieve xAOD::numberOfSCTDeadSensors");
748  return false;
749  }
750  uint8_t pix_holes = 0;
751  if(!tp.summaryValue(pix_holes,xAOD::numberOfPixelHoles)){
752  ATH_MSG_ERROR("DecoratePLIT::passed_r22tracking_cuts - failed to retrieve xAOD::numberOfPixelHoles");
753  return false;
754  }
755  uint8_t sct_holes = 0;
756  if(!tp.summaryValue(sct_holes,xAOD::numberOfSCTHoles)){
757  ATH_MSG_ERROR("DecoratePLIT::passed_r22tracking_cuts - failed to retrieve xAOD::numberOfSCTHoles");
758  return false;
759  }
760 
761  if (std::abs(tp.eta()) > abs_eta_maximum)
762  return false;
763  double n_module_shared = (pix_shared + sct_shared / 2);
764  if (n_module_shared > si_shared_maximum)
765  return false;
766  if (tp.pt() <= pt_minimum)
767  return false;
768  if (std::isfinite(d0_maximum) &&
769  std::abs(acc_d0(tp)) >= d0_maximum)
770  return false;
771  if (std::isfinite(z0_maximum) &&
772  std::abs(acc_z0SinTheta(tp)) >= z0_maximum)
773  return false;
774  if (pix_hits + pix_dead + sct_hits + sct_dead < si_hits_minimum)
775  return false;
776  if ((pix_holes + sct_holes) > si_holes_maximum)
777  return false;
778  if (pix_holes > pix_holes_maximum)
779  return false;
780  return true;
781  }

◆ predictElec()

StatusCode Prompt::DecoratePLIT::predictElec ( const xAOD::Electron &  electron,
const xAOD::JetContainer &  trackjets,
const xAOD::TrackParticleContainer &  tracks,
const xAOD::CaloClusterContainer &  caloclusters,
std::vector< SG::WriteDecorHandle< xAOD::ElectronContainer, float >> &  dec_el_plit_output,
const EventContext &  ctx 
) const
private

Definition at line 397 of file DecoratePLIT.cxx.

403  {
404  // prepare input
405  // -------------
406  std::map<std::string, FlavorTagDiscriminants::Inputs> gnn_input;
407 
408  // accessors
409  // ---------
410  SG::ReadDecorHandle<xAOD::ElectronContainer, float> acc_ptvarcone30{m_acc_el_ptvarcone30, ctx};
411  SG::ReadDecorHandle<xAOD::ElectronContainer, float> acc_topoetcone30{m_acc_el_topoetcone30, ctx};
412 
413  SG::ReadDecorHandle<xAOD::TrackParticleContainer, float> acc_ptfrac{m_acc_trk_ptfrac, ctx};
414  SG::ReadDecorHandle<xAOD::TrackParticleContainer, float> acc_dr_trackjet{m_acc_trk_dr_trackjet, ctx};
415  SG::ReadDecorHandle<xAOD::TrackParticleContainer, float> acc_dr_lepton{m_acc_trk_dr_lepton, ctx};
416  SG::ReadDecorHandle<xAOD::TrackParticleContainer, float> acc_d0{m_acc_trk_d0, ctx};
417  SG::ReadDecorHandle<xAOD::TrackParticleContainer, float> acc_z0SinTheta{m_acc_trk_z0SinTheta, ctx};
418  SG::ReadDecorHandle<xAOD::TrackParticleContainer, float> acc_d0Uncertainty{m_acc_trk_d0Uncertainty, ctx};
419  SG::ReadDecorHandle<xAOD::TrackParticleContainer, float> acc_z0SinThetaUncertainty{m_acc_trk_z0SinThetaUncertainty, ctx};
420  SG::ReadDecorHandle<xAOD::TrackParticleContainer, char> acc_electron_track{m_acc_trk_electron_track, ctx};
421 
422  // collect electron features
423  float elec_pt = electron.pt();
424  float elec_eta = electron.eta();
425  float elec_phi = electron.phi();
426  float elec_ntracks = static_cast<float>(electron.nTrackParticles());
427  float elec_ptvarcone30Rel = acc_ptvarcone30(electron) / elec_pt;
428  float elec_topoetcone30Rel = acc_topoetcone30(electron) / elec_pt;
429 
430  // compute electron calorimeter cluster information
431  float elec_caloClusterSumEtRel = 0.0;
432  float sumCoreEt_large = 0.0;
433  if (electron.caloCluster()) {
434  float elec_calEta = electron.caloCluster()->eta();
435  float elec_calPhi = electron.caloCluster()->phi();
436 
437  for (const xAOD::CaloCluster *cluster: caloclusters) {
438  float deta = elec_calEta - cluster->eta();
439  float dphi = TVector2::Phi_mpi_pi(elec_calPhi - cluster->phi());
440  float dr = std::sqrt(deta*deta + dphi*dphi);
441 
442  if (dr < m_lepCalErelConeSize) {
443  sumCoreEt_large += cluster->pt();
444  }
445  }
446  }
447  elec_caloClusterSumEtRel = sumCoreEt_large / elec_pt;
448 
449  // collect electron and trackjet-related variables
450  const xAOD::Jet *trackjet = findClosestTrackJet(electron, trackjets);
451  float elec_ptfrac_lepton = -99;
452  float elec_ptrel_lepton = -99;
453  float elec_dRtrackjet_lepton = -99;
454  float elec_nTracksTrackjet = -99;
455 
456  if (trackjet) {
457  elec_nTracksTrackjet = trackjet->getConstituents().size();
458 
459  elec_ptfrac_lepton = elec_pt / trackjet->pt();
460 
461  float angle = electron.p4().Vect().Angle(trackjet->p4().Vect());
462  elec_ptrel_lepton = elec_pt * std::sin(angle);
463 
464  elec_dRtrackjet_lepton = electron.p4().DeltaR(trackjet->p4());
465  }
466 
467  // collect best matched GSF electron track kinematics
468  const xAOD::TrackParticle *electronTrack = nullptr;
469  const xAOD::TrackParticle *bestmatchedGSFElTrack = electron.trackParticle(0);
470  if (bestmatchedGSFElTrack) {
471  electronTrack = xAOD::EgammaHelpers::getOriginalTrackParticleFromGSF(bestmatchedGSFElTrack);
472  }
473  float elec_d0sig = -99;
474  float elec_qd0 = -99;
475  float elec_z0sinTheta = -99;
476  if (electronTrack) {
477  float d0 = electronTrack->d0();
478  float vard0 = electronTrack->definingParametersCovMatrix()(0, 0);
479  if (vard0 > 0){
480  float d0sigma = std::sqrt(vard0);
481  if (std::abs(d0sigma) > 0)
482  elec_d0sig = std::abs(d0 / d0sigma);
483  }
484  elec_qd0 = (electron.charge())*d0;
485  elec_z0sinTheta = electronTrack->z0() * std::sin(electronTrack->theta());
486  }
487 
488  // compute SCT weighted charge (can be used for electron charge identification)
489  float elec_SCTWeightedCharge{0.f}, charge{0.f};
490  uint8_t SCT = 0;
491  for (unsigned TPit = 0; TPit < electron.nTrackParticles(); TPit++) {
492  uint8_t temp_NSCTHits = 0;
493  if (electron.trackParticle(TPit)) {
494  electron.trackParticle(TPit)->summaryValue(temp_NSCTHits, xAOD::numberOfSCTHits);
495  SCT += temp_NSCTHits;
496  charge += temp_NSCTHits*(electron.trackParticle(TPit)->charge());
497  }
498  }
499  if (SCT > 0) {
500  elec_SCTWeightedCharge = (electron.charge()*charge/SCT);
501  } else {
502  ATH_MSG_WARNING("No SCT hit for any track associated to electron ! nTP = " << electron.nTrackParticles());
503  }
504 
505  std::vector<float> electron_feat = {elec_pt, elec_eta, elec_phi, elec_ptvarcone30Rel, elec_topoetcone30Rel, elec_caloClusterSumEtRel, elec_ptfrac_lepton, elec_ptrel_lepton, elec_dRtrackjet_lepton, elec_d0sig, elec_z0sinTheta, elec_SCTWeightedCharge, elec_qd0, elec_ntracks, elec_nTracksTrackjet};
506  std::vector<int64_t> electron_feat_dim = {1, static_cast<int64_t>(electron_feat.size())};
507 
508  // need to use the "jet_features" keyword as we are borrowing flavour tagging code
509  FlavorTagDiscriminants::Inputs electron_info (electron_feat, electron_feat_dim);
510  gnn_input.insert({"jet_features", electron_info});
511 
512  // decorate and fill track particles around the electron
513  std::vector<const xAOD::IParticle *> parts;
514  if (!fillParticles(parts, electron, electronTrack, trackjet, tracks, ctx)) {
515  ATH_MSG_ERROR("DecoratePLIT::execute - failed to fill particles");
516  return StatusCode::FAILURE;
517  }
518 
519  // collect track features from track particles
520  std::vector<float> track_feat;
521  track_feat.reserve(parts.size() * static_cast<int64_t>(electron_feat.size()));
522  for (const xAOD::IParticle *part: parts) {
523  const xAOD::TrackParticle *track = dynamic_cast<const xAOD::TrackParticle*>(part);
524  if (!track) {
525  ATH_MSG_ERROR("DecoratePLIT::execute - null track pointer");
526  }
527 
528  float ptfrac = acc_ptfrac(*track);
529  track_feat.push_back(ptfrac);
530 
531  float dr_trackjet = acc_dr_trackjet(*track);
532  track_feat.push_back(dr_trackjet);
533 
534  float dr_lepton = acc_dr_lepton(*track);
535  track_feat.push_back(dr_lepton);
536 
537  float qoverp = track->qOverP();
538  track_feat.push_back(qoverp);
539 
540  float d0 = acc_d0(*track);
541  track_feat.push_back(d0);
542 
543  float z0SinTheta = acc_z0SinTheta(*track);
544  track_feat.push_back(z0SinTheta);
545 
546  float d0Uncertainty = acc_d0Uncertainty(*track);
547  float z0SinThetaUncertainty = acc_z0SinThetaUncertainty(*track);
548 
549  float d0_significance = -99;
550  if (std::abs(d0Uncertainty) > 0) d0_significance = d0 / d0Uncertainty;
551  track_feat.push_back(d0_significance);
552 
553  float z0SinTheta_significance = -99;
554  if (std::abs(z0SinThetaUncertainty) > 0) z0SinTheta_significance = z0SinTheta / z0SinThetaUncertainty;
555  track_feat.push_back(z0SinTheta_significance);
556 
557  uint8_t pix_innermosthits = 0;
558  if(!track->summaryValue(pix_innermosthits,xAOD::numberOfInnermostPixelLayerHits)){
559  ATH_MSG_ERROR("DecoratePLIT::execute - failed to retrieve xAOD::numberOfInnermostPixelLayerHits");
560  return StatusCode::FAILURE;
561  }
562  track_feat.push_back(pix_innermosthits);
563 
564  uint8_t pix_nextinnermosthits = 0;
565  if(!track->summaryValue(pix_nextinnermosthits,xAOD::numberOfNextToInnermostPixelLayerHits)){
566  ATH_MSG_ERROR("DecoratePLIT::execute - failed to retrieve xAOD::numberOfNextToInnermostPixelLayerHits");
567  return StatusCode::FAILURE;
568  }
569  track_feat.push_back(pix_nextinnermosthits);
570 
571  uint8_t pix_innermostsharedhits = 0;
572  if(!track->summaryValue(pix_innermostsharedhits,xAOD::numberOfInnermostPixelLayerSharedHits)){
573  ATH_MSG_ERROR("DecoratePLIT::execute - failed to retrieve xAOD::numberOfInnermostPixelLayerSharedHits");
574  return StatusCode::FAILURE;
575  }
576  track_feat.push_back(pix_innermostsharedhits);
577 
578  uint8_t pix_innermostsplithits = 0;
579  if(!track->summaryValue(pix_innermostsplithits,xAOD::numberOfInnermostPixelLayerSplitHits)){
580  ATH_MSG_ERROR("DecoratePLIT::execute - failed to retrieve xAOD::numberOfInnermostPixelLayerSplitHits");
581  return StatusCode::FAILURE;
582  }
583  track_feat.push_back(pix_innermostsplithits);
584 
585  uint8_t pix_hits = 0;
586  if(!track->summaryValue(pix_hits,xAOD::numberOfPixelHits)){
587  ATH_MSG_ERROR("DecoratePLIT::execute - failed to retrieve xAOD::numberOfPixelHits");
588  return StatusCode::FAILURE;
589  }
590  track_feat.push_back(pix_hits);
591 
592  uint8_t pix_shared = 0;
593  if(!track->summaryValue(pix_shared,xAOD::numberOfPixelSharedHits)){
594  ATH_MSG_ERROR("DecoratePLIT::execute - failed to retrieve xAOD::numberOfPixelSharedHits");
595  return StatusCode::FAILURE;
596  }
597  track_feat.push_back(pix_shared);
598 
599  uint8_t pix_split = 0;
600  if(!track->summaryValue(pix_split,xAOD::numberOfPixelSplitHits)){
601  ATH_MSG_ERROR("DecoratePLIT::execute - failed to retrieve xAOD::numberOfPixelSplitHits");
602  return StatusCode::FAILURE;
603  }
604  track_feat.push_back(pix_split);
605 
606  uint8_t sct_hits = 0;
607  if(!track->summaryValue(sct_hits,xAOD::numberOfSCTHits)){
608  ATH_MSG_ERROR("DecoratePLIT::execute - failed to retrieve xAOD::numberOfSCTHits");
609  return StatusCode::FAILURE;
610  }
611  track_feat.push_back(sct_hits);
612 
613  uint8_t sct_shared = 0;
614  if(!track->summaryValue(sct_shared,xAOD::numberOfSCTSharedHits)){
615  ATH_MSG_ERROR("DecoratePLIT::execute - failed to retrieve xAOD::numberOfSCTSharedHits");
616  return StatusCode::FAILURE;
617  }
618  track_feat.push_back(sct_shared);
619 
620  uint8_t trt_hits = 0;
621  if(!track->summaryValue(trt_hits,xAOD::numberOfTRTHits)){
622  ATH_MSG_ERROR("DecoratePLIT::execute - failed to retrieve xAOD::numberOfTRTHits");
623  return StatusCode::FAILURE;
624  }
625  track_feat.push_back(trt_hits);
626 
627  char electron_track = acc_electron_track(*track);
628  track_feat.push_back(electron_track);
629  }
630 
631  // prepare track features for inference
632  int num_cnsts = parts.size();
633  std::vector<int64_t> track_feat_dim = {num_cnsts, m_num_track_features};
634 
635  FlavorTagDiscriminants::Inputs track_info (track_feat, track_feat_dim);
636  gnn_input.insert({"track_features", track_info});
637 
638  if (msgLvl(MSG::VERBOSE)) {
639  ATH_MSG_VERBOSE("gnn_input size = " << gnn_input.size());
640  for (auto& inp : gnn_input){
641  ATH_MSG_VERBOSE(" " + inp.first + " dim = ");
642  for (auto & dim: inp.second.second) {
643  ATH_MSG_VERBOSE(" " + std::to_string(dim));
644  }
645  ATH_MSG_VERBOSE(" " + inp.first + " content = ");
646  for (auto & con: inp.second.first) {
647  ATH_MSG_VERBOSE(" " + std::to_string(con));
648  }
649  }
650  }
651 
652  // run inference
653  // -------------
654  // use different model for endcap electrons
655  auto [out_f, out_vc, out_vf] = (std::abs(elec_eta) < 1.37) ? m_onnxUtil->runInference(gnn_input) : m_onnxUtil_endcap->runInference(gnn_input);
656  if (msgLvl(MSG::VERBOSE)) {
657  ATH_MSG_VERBOSE("runInference done.");
658 
659  ATH_MSG_VERBOSE("Output Float(s):");
660  for (auto& singlefloat : out_f){
661  ATH_MSG_VERBOSE(singlefloat.first + " = " << singlefloat.second);
662  }
663  ATH_MSG_VERBOSE("Output vector char(s):");
664  for (auto& vecchar : out_vc){
665  ATH_MSG_VERBOSE(vecchar.first + " = ");
666  for (auto& cc : vecchar.second){
667  ATH_MSG_VERBOSE(cc);
668  }
669  }
670  ATH_MSG_VERBOSE("Output vector float(s):");
671  for (auto& vecfloat : out_vf){
672  ATH_MSG_VERBOSE(vecfloat.first + " = ");
673  for (auto& ff : vecfloat.second){
674  ATH_MSG_VERBOSE(ff);
675  }
676  }
677  }
678  // filling the tagger scores
679  auto it_dec_el_plit_output = dec_el_plit_output.begin();
680  for (auto& singlefloat : out_f){
681  (*it_dec_el_plit_output)(electron) = singlefloat.second;
682  ++it_dec_el_plit_output;
683  }
684 
685  return StatusCode::SUCCESS;
686  }

◆ predictMuon()

StatusCode Prompt::DecoratePLIT::predictMuon ( const xAOD::Muon &  muon,
const xAOD::JetContainer &  trackjets,
const xAOD::TrackParticleContainer &  tracks,
std::vector< SG::WriteDecorHandle< xAOD::MuonContainer, float >> &  dec_mu_plit_output,
const EventContext &  ctx 
) const
private

Definition at line 163 of file DecoratePLIT.cxx.

168  {
169  // set up accessors
170  // ---------------
171  SG::ReadDecorHandle<xAOD::MuonContainer, float> acc_ptvarcone30TTVA{m_acc_mu_ptvarcone30TTVA, ctx};
172  SG::ReadDecorHandle<xAOD::MuonContainer, float> acc_topoetcone30{m_acc_mu_topoetcone30, ctx};
173 
174  SG::ReadDecorHandle<xAOD::TrackParticleContainer, float> acc_ptfrac{m_acc_trk_ptfrac, ctx};
175  SG::ReadDecorHandle<xAOD::TrackParticleContainer, float> acc_dr_trackjet{m_acc_trk_dr_trackjet, ctx};
176  SG::ReadDecorHandle<xAOD::TrackParticleContainer, float> acc_d0{m_acc_trk_d0, ctx};
177  SG::ReadDecorHandle<xAOD::TrackParticleContainer, float> acc_z0SinTheta{m_acc_trk_z0SinTheta, ctx};
178  SG::ReadDecorHandle<xAOD::TrackParticleContainer, float> acc_d0Uncertainty{m_acc_trk_d0Uncertainty, ctx};
179  SG::ReadDecorHandle<xAOD::TrackParticleContainer, float> acc_z0SinThetaUncertainty{m_acc_trk_z0SinThetaUncertainty, ctx};
180 
181  // prepare input
182  // -------------
183  std::map<std::string, FlavorTagDiscriminants::Inputs> gnn_input;
184 
185  // collect muon features
186  float muon_pt = muon.pt();
187  float muon_eta = muon.eta();
188  float muon_phi = muon.phi();
189 
190  float muon_ptvarcone30TTVARel = acc_ptvarcone30TTVA(muon) / muon_pt;
191  float muon_topoetcone30Rel = acc_topoetcone30(muon) / muon_pt;
192 
193  float muon_caloClusterERel = -99;
194  const xAOD::CaloCluster* cluster = muon.cluster();
195  if (cluster) {
196  float energyloss = 0;
197  if (!muon.parameter(energyloss,xAOD::Muon::MeasEnergyLoss)) {
198  ATH_MSG_WARNING("DecoratePLIT::execute - failed to retrieve energy loss");
199  return StatusCode::FAILURE;
200  }
201  float calE = cluster->calE();
202  if (std::abs(energyloss) > 0)
203  muon_caloClusterERel = calE / energyloss;
204  }
205 
206  // collect muon and trackjet-related features
207  const xAOD::Jet *trackjet = findClosestTrackJet(muon, trackjets);
208  float muon_ptfrac_lepton{-99.f}, muon_ptrel_lepton{-99.f}, muon_dRtrackjet_lepton{-99.f}, muon_nTracksTrackjet{-99.f};
209 
210  if (trackjet) {
211  muon_nTracksTrackjet = trackjet->getConstituents().size();
212 
213  muon_ptfrac_lepton = muon_pt / trackjet->pt();
214 
215  float angle = muon.p4().Vect().Angle(trackjet->p4().Vect());
216  muon_ptrel_lepton = muon_pt * std::sin(angle);
217 
218  muon_dRtrackjet_lepton = muon.p4().DeltaR(trackjet->p4());
219  }
220 
221  // package muon features for inference
222  std::vector<float> muon_feat = {
223  muon_pt, muon_eta, muon_phi, muon_ptvarcone30TTVARel, muon_topoetcone30Rel,
224  muon_caloClusterERel, muon_ptfrac_lepton, muon_ptrel_lepton,
225  muon_dRtrackjet_lepton, muon_nTracksTrackjet
226  };
227  std::vector<int64_t> muon_feat_dim = {1, static_cast<int64_t>(muon_feat.size())};
228 
229  // need to use the "jet_features" keyword as we are borrowing flavour tagging code
230  FlavorTagDiscriminants::Inputs muon_info (muon_feat, muon_feat_dim);
231  gnn_input.insert({"jet_features", muon_info});
232 
233  // decorate and fill track particles around the muon
234  const xAOD::TrackParticle *muonTrack = muon.primaryTrackParticle();
235  std::vector<const xAOD::IParticle *> parts;
236 
237  if(!fillParticles(parts, muon, muonTrack, trackjet, tracks, ctx)) {
238  ATH_MSG_ERROR("DecoratePLIT::execute - failed to fill particles");
239  return StatusCode::FAILURE;
240  }
241 
242  // extract track features from track particles
243  std::vector<float> track_feat;
244  track_feat.reserve(parts.size() * static_cast<int64_t>(muon_feat.size()));
245  // loop over parts and fill track_feat vector
246  for (const xAOD::IParticle *part: parts) {
247  const xAOD::TrackParticle *track = dynamic_cast<const xAOD::TrackParticle*>(part);
248 
249  float ptfrac = acc_ptfrac(*track);
250  track_feat.push_back(ptfrac);
251 
252  float dr_trackjet = acc_dr_trackjet(*track);
253  track_feat.push_back(dr_trackjet);
254 
255  float qoverp = track->qOverP();
256  track_feat.push_back(qoverp);
257 
258  float d0 = acc_d0(*track);
259  track_feat.push_back(d0);
260 
261  float z0SinTheta = acc_z0SinTheta(*track);
262  track_feat.push_back(z0SinTheta);
263 
264  float d0Uncertainty = acc_d0Uncertainty(*track);
265  track_feat.push_back(d0Uncertainty);
266 
267  float z0SinThetaUncertainty = acc_z0SinThetaUncertainty(*track);
268  track_feat.push_back(z0SinThetaUncertainty);
269 
270  float d0_significance = -99;
271  if (abs(d0Uncertainty) > 0) d0_significance = d0 / d0Uncertainty;
272  track_feat.push_back(d0_significance);
273 
274  float z0SinTheta_significance = -99;
275  if (std::abs(z0SinThetaUncertainty) > 0) z0SinTheta_significance = z0SinTheta / z0SinThetaUncertainty;
276  track_feat.push_back(z0SinTheta_significance);
277 
278  uint8_t pix_hits = 0;
279  if(!track->summaryValue(pix_hits,xAOD::numberOfPixelHits)){
280  ATH_MSG_ERROR("DecoratePLIT::execute - failed to retrieve xAOD::numberOfPixelHits");
281  return StatusCode::FAILURE;
282  }
283  track_feat.push_back(pix_hits);
284 
285  uint8_t pix_innermosthits = 0;
286  if(!track->summaryValue(pix_innermosthits,xAOD::numberOfInnermostPixelLayerHits)){
287  ATH_MSG_ERROR("DecoratePLIT::execute - failed to retrieve xAOD::numberOfInnermostPixelLayerHits");
288  return StatusCode::FAILURE;
289  }
290  track_feat.push_back(pix_innermosthits);
291 
292  uint8_t pix_nextinnermosthits = 0;
293  if(!track->summaryValue(pix_nextinnermosthits,xAOD::numberOfNextToInnermostPixelLayerHits)){
294  ATH_MSG_ERROR("DecoratePLIT::execute - failed to retrieve xAOD::numberOfNextToInnermostPixelLayerHits");
295  return StatusCode::FAILURE;
296  }
297  track_feat.push_back(pix_nextinnermosthits);
298 
299  uint8_t pix_innermostsharedhits = 0;
300  if(!track->summaryValue(pix_innermostsharedhits,xAOD::numberOfInnermostPixelLayerSharedHits)){
301  ATH_MSG_ERROR("DecoratePLIT::execute - failed to retrieve xAOD::numberOfInnermostPixelLayerSharedHits");
302  return StatusCode::FAILURE;
303  }
304  track_feat.push_back(pix_innermostsharedhits);
305 
306  uint8_t pix_innermostsplithits = 0;
307  if(!track->summaryValue(pix_innermostsplithits,xAOD::numberOfInnermostPixelLayerSplitHits)){
308  ATH_MSG_ERROR("DecoratePLIT::execute - failed to retrieve xAOD::numberOfInnermostPixelLayerSplitHits");
309  return StatusCode::FAILURE;
310  }
311  track_feat.push_back(pix_innermostsplithits);
312 
313  uint8_t pix_shared = 0;
314  if(!track->summaryValue(pix_shared,xAOD::numberOfPixelSharedHits)){
315  ATH_MSG_ERROR("DecoratePLIT::execute - failed to retrieve xAOD::numberOfPixelSharedHits");
316  return StatusCode::FAILURE;
317  }
318  track_feat.push_back(pix_shared);
319 
320  uint8_t pix_split = 0;
321  if(!track->summaryValue(pix_split,xAOD::numberOfPixelSplitHits)){
322  ATH_MSG_ERROR("DecoratePLIT::execute - failed to retrieve xAOD::numberOfPixelSplitHits");
323  return StatusCode::FAILURE;
324  }
325  track_feat.push_back(pix_split);
326 
327  uint8_t sct_hits = 0;
328  if(!track->summaryValue(sct_hits,xAOD::numberOfSCTHits)){
329  ATH_MSG_ERROR("DecoratePLIT::execute - failed to retrieve xAOD::numberOfSCTHits");
330  return StatusCode::FAILURE;
331  }
332  track_feat.push_back(sct_hits);
333 
334  uint8_t sct_shared = 0;
335  if(!track->summaryValue(sct_shared,xAOD::numberOfSCTSharedHits)){
336  ATH_MSG_ERROR("DecoratePLIT::execute - failed to retrieve xAOD::numberOfSCTSharedHits");
337  return StatusCode::FAILURE;
338  }
339  track_feat.push_back(sct_shared);
340  }
341 
342  // prepare track features for inference
343  int num_cnsts = parts.size();
344  std::vector<int64_t> track_feat_dim = {num_cnsts, m_num_track_features};
345 
346  FlavorTagDiscriminants::Inputs track_info(track_feat, track_feat_dim);
347  gnn_input.insert({"track_features", track_info});
348  if (msgLvl(MSG::VERBOSE)) {
349  ATH_MSG_VERBOSE("gnn_input size = " << gnn_input.size());
350  for (auto& inp : gnn_input){
351  ATH_MSG_VERBOSE(" " + inp.first + " dim = ");
352  for (auto & dim: inp.second.second) {
353  ATH_MSG_VERBOSE(" " + std::to_string(dim));
354  }
355  ATH_MSG_VERBOSE(" " + inp.first + " content = ");
356  for (auto & con: inp.second.first) {
357  ATH_MSG_VERBOSE(" " + std::to_string(con));
358  }
359  }
360  }
361 
362  // run inference
363  // -------------
364  auto [out_f, out_vc, out_vf] = m_onnxUtil->runInference(gnn_input);
365  if (msgLvl(MSG::VERBOSE)) {
366  ATH_MSG_VERBOSE("runInference done.");
367 
368  ATH_MSG_VERBOSE("Output Float(s):");
369  for (auto& singlefloat : out_f){
370  ATH_MSG_VERBOSE(singlefloat.first + " = " << singlefloat.second);
371  }
372  ATH_MSG_VERBOSE("Output vector char(s):");
373  for (auto& vecchar : out_vc){
374  ATH_MSG_VERBOSE(vecchar.first + " = ");
375  for (auto& cc : vecchar.second){
376  ATH_MSG_VERBOSE(cc);
377  }
378  }
379  ATH_MSG_VERBOSE("Output vector float(s):");
380  for (auto& vecfloat : out_vf){
381  ATH_MSG_VERBOSE(vecfloat.first + " = ");
382  for (auto& ff : vecfloat.second){
383  ATH_MSG_VERBOSE(ff);
384  }
385  }
386  }
387  // filling the tagger scores
388  auto it_dec_mu_plit_output = dec_mu_plit_output.begin();
389  for (auto& singlefloat : out_f){
390  (*it_dec_mu_plit_output)(muon) = singlefloat.second;
391  ++it_dec_mu_plit_output;
392  }
393 
394  return StatusCode::SUCCESS;
395  }

◆ 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< Gaudi::Algorithm > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ setFilterPassed()

virtual void AthReentrantAlgorithm::setFilterPassed ( bool  state,
const EventContext &  ctx 
) const
inlinevirtualinherited

Definition at line 139 of file AthReentrantAlgorithm.h.

139  {
140  execState( ctx ).setFilterPassed( state );
141  }

◆ sysExecute()

StatusCode AthReentrantAlgorithm::sysExecute ( const EventContext &  ctx)
overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 67 of file AthReentrantAlgorithm.cxx.

68 {
69  return Gaudi::Algorithm::sysExecute (ctx);
70 }

◆ sysInitialize()

StatusCode AthReentrantAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 96 of file AthReentrantAlgorithm.cxx.

96  {
97  StatusCode sc=AthCommonDataStore<AthCommonMsg<Gaudi::Algorithm>>::sysInitialize();
98 
99  if (sc.isFailure()) {
100  return sc;
101  }
102 
103  ServiceHandle<ICondSvc> cs("CondSvc",name());
104  for (auto h : outputHandles()) {
105  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
106  // do this inside the loop so we don't create the CondSvc until needed
107  if ( cs.retrieve().isFailure() ) {
108  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
109  return StatusCode::SUCCESS;
110  }
111  if (cs->regHandle(this,*h).isFailure()) {
112  sc = StatusCode::FAILURE;
113  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
114  << " with CondSvc");
115  }
116  }
117  }
118  return sc;
119 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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.

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

◆ m_acc_el_ptvarcone30

SG::ReadDecorHandleKey<xAOD::ElectronContainer> Prompt::DecoratePLIT::m_acc_el_ptvarcone30 {this,"acc_el_ptvarcone30",m_electronsKey, "ptvarcone30"}
private

Definition at line 121 of file DecoratePLIT.h.

◆ m_acc_el_topoetcone30

SG::ReadDecorHandleKey<xAOD::ElectronContainer> Prompt::DecoratePLIT::m_acc_el_topoetcone30 {this,"acc_el_topoetcone30",m_electronsKey, "topoetcone30"}
private

Definition at line 122 of file DecoratePLIT.h.

◆ m_acc_mu_ptvarcone30TTVA

SG::ReadDecorHandleKey<xAOD::MuonContainer> Prompt::DecoratePLIT::m_acc_mu_ptvarcone30TTVA {this, "acc_mu_ptvarcone30TTVA",m_muonsKey, "ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500"}
private

Definition at line 118 of file DecoratePLIT.h.

◆ m_acc_mu_topoetcone30

SG::ReadDecorHandleKey<xAOD::MuonContainer> Prompt::DecoratePLIT::m_acc_mu_topoetcone30 {this, "acc_mu_topoetcone30",m_muonsKey, "topoetcone30"}
private

Definition at line 119 of file DecoratePLIT.h.

◆ m_acc_trk_d0

SG::ReadDecorHandleKey<xAOD::TrackParticleContainer> Prompt::DecoratePLIT::m_acc_trk_d0 {this,"acc_trk_d0", m_tracksKey, m_btagIp_prefix + "d0"}
private

Definition at line 127 of file DecoratePLIT.h.

◆ m_acc_trk_d0Uncertainty

SG::ReadDecorHandleKey<xAOD::TrackParticleContainer> Prompt::DecoratePLIT::m_acc_trk_d0Uncertainty {this, "acc_trk_d0Uncertainty", m_tracksKey, m_btagIp_prefix + "d0Uncertainty"}
private

Definition at line 129 of file DecoratePLIT.h.

◆ m_acc_trk_dr_lepton

SG::ReadDecorHandleKey<xAOD::TrackParticleContainer> Prompt::DecoratePLIT::m_acc_trk_dr_lepton {this, "acc_trk_dr_lepton",m_tracksKey, "dr_lepton"}
private

Definition at line 126 of file DecoratePLIT.h.

◆ m_acc_trk_dr_trackjet

SG::ReadDecorHandleKey<xAOD::TrackParticleContainer> Prompt::DecoratePLIT::m_acc_trk_dr_trackjet {this,"acc_trk_dr_trackjet", m_tracksKey, "dr_trackjet"}
private

Definition at line 125 of file DecoratePLIT.h.

◆ m_acc_trk_electron_track

SG::ReadDecorHandleKey<xAOD::TrackParticleContainer> Prompt::DecoratePLIT::m_acc_trk_electron_track {this,"acc_trk_electron_track", m_tracksKey, "electron_track"}
private

Definition at line 132 of file DecoratePLIT.h.

◆ m_acc_trk_muon_track

SG::ReadDecorHandleKey<xAOD::TrackParticleContainer> Prompt::DecoratePLIT::m_acc_trk_muon_track {this, "acc_trk_muon_track", m_tracksKey, "muon_track"}
private

Definition at line 131 of file DecoratePLIT.h.

◆ m_acc_trk_ptfrac

SG::ReadDecorHandleKey<xAOD::TrackParticleContainer> Prompt::DecoratePLIT::m_acc_trk_ptfrac {this,"acc_trk_ptfrac",m_tracksKey, "ptfrac"}
private

Definition at line 124 of file DecoratePLIT.h.

◆ m_acc_trk_z0SinTheta

SG::ReadDecorHandleKey<xAOD::TrackParticleContainer> Prompt::DecoratePLIT::m_acc_trk_z0SinTheta {this, "acc_trk_z0SinTheta", m_tracksKey, m_btagIp_prefix + "z0SinTheta"}
private

Definition at line 128 of file DecoratePLIT.h.

◆ m_acc_trk_z0SinThetaUncertainty

SG::ReadDecorHandleKey<xAOD::TrackParticleContainer> Prompt::DecoratePLIT::m_acc_trk_z0SinThetaUncertainty {this, "acc_trk_z0SinThetaUncertainty", m_tracksKey, m_btagIp_prefix + "z0SinThetaUncertainty"}
private

Definition at line 130 of file DecoratePLIT.h.

◆ m_btagIp_prefix

Gaudi::Property<std::string> Prompt::DecoratePLIT::m_btagIp_prefix
private
Initial value:
{
this, "btagIp_prefix", "btagIp_", "Prefix of b-tagging impact parameter variables (w.r.t. primary vertex)"}

Definition at line 92 of file DecoratePLIT.h.

◆ m_caloclustersKey

SG::ReadHandleKey<xAOD::CaloClusterContainer> Prompt::DecoratePLIT::m_caloclustersKey
private
Initial value:
{
this, "CaloClusterContainerKey", "egammaClusters",
"Calo cluster container name"
}

Definition at line 112 of file DecoratePLIT.h.

◆ m_configFileVersion

Gaudi::Property<std::string> Prompt::DecoratePLIT::m_configFileVersion {this, "ConfigFileVersion", "", "Vector of tagger score files"}
private

Definition at line 83 of file DecoratePLIT.h.

◆ m_configFileVersion_endcap

Gaudi::Property<std::string> Prompt::DecoratePLIT::m_configFileVersion_endcap {this, "ConfigFileVersion_endcap", "", "Vector of tagger score files for endcap"}
private

Definition at line 84 of file DecoratePLIT.h.

◆ m_configPath

Gaudi::Property<std::string> Prompt::DecoratePLIT::m_configPath {this, "ConfigPath", "", "Path of the directory containing the onnx files"}
private

Definition at line 82 of file DecoratePLIT.h.

◆ m_dec_el_plit_output

SG::WriteDecorHandleKeyArray<xAOD::ElectronContainer> Prompt::DecoratePLIT::m_dec_el_plit_output {this, "PLITelOutput", {}}
private

Definition at line 134 of file DecoratePLIT.h.

◆ m_dec_mu_plit_output

SG::WriteDecorHandleKeyArray<xAOD::MuonContainer> Prompt::DecoratePLIT::m_dec_mu_plit_output {this, "PLITmuOutput", {}}
private

Definition at line 135 of file DecoratePLIT.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_electronsKey

SG::ReadHandleKey<xAOD::ElectronContainer> Prompt::DecoratePLIT::m_electronsKey
private
Initial value:
{
this, "ElectronContainerKey", "Electrons",
"Electron container name"
}

Definition at line 96 of file DecoratePLIT.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthReentrantAlgorithm::m_extendedExtraObjects
privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 153 of file AthReentrantAlgorithm.h.

◆ m_lepCalErelConeSize

Gaudi::Property<float> Prompt::DecoratePLIT::m_lepCalErelConeSize
private
Initial value:
{
this, "lepCalErelConeSize", 0.15, "Cone size for relative calo cluster energy sum"}

Definition at line 90 of file DecoratePLIT.h.

◆ m_leptonsName

Gaudi::Property<std::string> Prompt::DecoratePLIT::m_leptonsName
private
Initial value:
{
this, "LeptonContainerName", "",
"Container's name of the lepton that you want to decorate. Also need to set ElectronContainerKey or MuonContainerKey accordingly"
}

Definition at line 78 of file DecoratePLIT.h.

◆ m_maxLepTrackdR

Gaudi::Property<float> Prompt::DecoratePLIT::m_maxLepTrackdR
private
Initial value:
{
this, "maxLepTrackdR", 0.4, "Maximum distance between lepton and track"}

Definition at line 88 of file DecoratePLIT.h.

◆ m_maxLepTrackJetdR

Gaudi::Property<float> Prompt::DecoratePLIT::m_maxLepTrackJetdR
private
Initial value:
{
this, "maxLepTrackJetdR", 0.4, "Maximum distance between lepton and trackjet"}

Definition at line 86 of file DecoratePLIT.h.

◆ m_muonsKey

SG::ReadHandleKey<xAOD::MuonContainer> Prompt::DecoratePLIT::m_muonsKey
private
Initial value:
{
this, "MuonContainerKey", "Muons",
"Muon container name"
}

Definition at line 100 of file DecoratePLIT.h.

◆ m_num_lepton_features

int Prompt::DecoratePLIT::m_num_lepton_features
private

Definition at line 45 of file DecoratePLIT.h.

◆ m_num_track_features

int Prompt::DecoratePLIT::m_num_track_features
private

Definition at line 46 of file DecoratePLIT.h.

◆ m_onnxUtil

std::shared_ptr<const FlavorTagDiscriminants::OnnxUtil> Prompt::DecoratePLIT::m_onnxUtil {}
private

Definition at line 42 of file DecoratePLIT.h.

◆ m_onnxUtil_endcap

std::shared_ptr<const FlavorTagDiscriminants::OnnxUtil> Prompt::DecoratePLIT::m_onnxUtil_endcap {}
private

Definition at line 43 of file DecoratePLIT.h.

◆ m_TaggerName

Gaudi::Property<std::string> Prompt::DecoratePLIT::m_TaggerName {this, "TaggerName", "", "Tagger name"}
private

Definition at line 85 of file DecoratePLIT.h.

◆ m_trackjetsKey

SG::ReadHandleKey<xAOD::JetContainer> Prompt::DecoratePLIT::m_trackjetsKey
private
Initial value:
{
this, "TrackJetContainerKey", "AntiKtVR30Rmax4Rmin02PV0TrackJets",
"VR track jet container name"
}

Definition at line 104 of file DecoratePLIT.h.

◆ m_tracksKey

SG::ReadHandleKey<xAOD::TrackParticleContainer> Prompt::DecoratePLIT::m_tracksKey
private
Initial value:
{
this, "TracksContainerKey", "InDetTrackParticles",
"Tracks container name"
}

Definition at line 108 of file DecoratePLIT.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
LArG4FSStartPointFilter.part
part
Definition: LArG4FSStartPointFilter.py:21
Prompt::DecoratePLIT::m_num_lepton_features
int m_num_lepton_features
Definition: DecoratePLIT.h:45
Prompt::DecoratePLIT::findClosestTrackJet
const xAOD::Jet * findClosestTrackJet(const xAOD::IParticle &part, const xAOD::JetContainer &jets) const
Definition: DecoratePLIT.cxx:688
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:73
xAOD::numberOfPixelHoles
@ numberOfPixelHoles
number of pixel layers on track with absence of hits [unit8_t].
Definition: TrackingPrimitives.h:261
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:195
Prompt::DecoratePLIT::m_acc_trk_z0SinTheta
SG::ReadDecorHandleKey< xAOD::TrackParticleContainer > m_acc_trk_z0SinTheta
Definition: DecoratePLIT.h:128
xAOD::numberOfInnermostPixelLayerSplitHits
@ numberOfInnermostPixelLayerSplitHits
number of Pixel 0th layer barrel hits split by cluster splitting
Definition: TrackingPrimitives.h:240
yodamerge_tmp.dim
dim
Definition: yodamerge_tmp.py:239
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
max
#define max(a, b)
Definition: cfImp.cxx:41
xAOD::numberOfSCTSharedHits
@ numberOfSCTSharedHits
number of SCT hits shared by several tracks [unit8_t].
Definition: TrackingPrimitives.h:272
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:557
FlavorTagDiscriminants::Inputs
std::pair< std::vector< float >, std::vector< int64_t > > Inputs
Definition: FlavorTagDiscriminants/FlavorTagDiscriminants/OnnxUtil.h:28
Prompt::DecoratePLIT::m_acc_trk_ptfrac
SG::ReadDecorHandleKey< xAOD::TrackParticleContainer > m_acc_trk_ptfrac
Definition: DecoratePLIT.h:124
Prompt::DecoratePLIT::m_onnxUtil
std::shared_ptr< const FlavorTagDiscriminants::OnnxUtil > m_onnxUtil
Definition: DecoratePLIT.h:42
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
xAOD::CaloCluster_v1::calE
flt_t calE() const
Geet Energy in signal state CALIBRATED.
Prompt::DecoratePLIT::m_caloclustersKey
SG::ReadHandleKey< xAOD::CaloClusterContainer > m_caloclustersKey
Definition: DecoratePLIT.h:112
AthCommonDataStore::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 > renounce(T &h)
Definition: AthCommonDataStore.h:380
Prompt::DecoratePLIT::m_electronsKey
SG::ReadHandleKey< xAOD::ElectronContainer > m_electronsKey
Definition: DecoratePLIT.h:96
xAOD::TrackParticle_v1::z0
float z0() const
Returns the parameter.
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
Prompt::DecoratePLIT::m_configFileVersion_endcap
Gaudi::Property< std::string > m_configFileVersion_endcap
Definition: DecoratePLIT.h:84
ParticleTest.tp
tp
Definition: ParticleTest.py:25
AthCommonMsg< Gaudi::Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
xAOD::JetConstituentVector::size
size_t size() const
number of constituents
Definition: JetConstituentVector.cxx:102
xAOD::numberOfPixelHits
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
Definition: TrackingPrimitives.h:259
xAOD::EgammaHelpers::getTrackParticles
std::set< const xAOD::TrackParticle * > getTrackParticles(const xAOD::Egamma *eg, bool useBremAssoc=true, bool allParticles=true)
Return a list of all or only the best TrackParticle associated to the object.
Definition: EgammaxAODHelpers.cxx:120
xAOD::numberOfTRTHits
@ numberOfTRTHits
number of TRT hits [unit8_t].
Definition: TrackingPrimitives.h:275
python.TurnDataReader.dr
dr
Definition: TurnDataReader.py:112
str::z0SinThetaUncertainty
const std::string z0SinThetaUncertainty
Definition: BTagTrackIpAccessor.cxx:13
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
Prompt::DecoratePLIT::m_dec_mu_plit_output
SG::WriteDecorHandleKeyArray< xAOD::MuonContainer > m_dec_mu_plit_output
Definition: DecoratePLIT.h:135
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
xAOD::Jet_v1::getConstituents
JetConstituentVector getConstituents() const
Return a vector of consituents. The object behaves like vector<const IParticle*>. See JetConstituentV...
Definition: Jet_v1.cxx:147
Prompt::DecoratePLIT::m_acc_trk_z0SinThetaUncertainty
SG::ReadDecorHandleKey< xAOD::TrackParticleContainer > m_acc_trk_z0SinThetaUncertainty
Definition: DecoratePLIT.h:130
xAOD::IParticle
Class providing the definition of the 4-vector interface.
Definition: Event/xAOD/xAODBase/xAODBase/IParticle.h:41
Phi_mpi_pi
__HOSTDEV__ double Phi_mpi_pi(double)
Definition: GeoRegion.cxx:7
xAOD::Muon_v1
Class describing a Muon.
Definition: Muon_v1.h:38
xAOD::TrackParticle_v1::d0
float d0() const
Returns the parameter.
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
Prompt::DecoratePLIT::m_acc_trk_muon_track
SG::ReadDecorHandleKey< xAOD::TrackParticleContainer > m_acc_trk_muon_track
Definition: DecoratePLIT.h:131
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDTPM::z0SinTheta
float z0SinTheta(const U &p)
Definition: TrackParametersHelper.h:73
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:27
Prompt::DecoratePLIT::initializeAccessors
StatusCode initializeAccessors()
Definition: DecoratePLIT.cxx:142
xAOD::TrackParticle_v1::p4
virtual FourMom_t p4() const override final
The full 4-momentum of the particle.
Definition: TrackParticle_v1.cxx:129
Prompt::DecoratePLIT::m_acc_mu_topoetcone30
SG::ReadDecorHandleKey< xAOD::MuonContainer > m_acc_mu_topoetcone30
Definition: DecoratePLIT.h:119
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:59
xAOD::numberOfPixelSharedHits
@ numberOfPixelSharedHits
number of Pixel all-layer hits shared by several tracks [unit8_t].
Definition: TrackingPrimitives.h:262
jet
Definition: JetCalibTools_PlotJESFactors.cxx:23
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthReentrantAlgorithm::AthReentrantAlgorithm
AthReentrantAlgorithm()
Default constructor:
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
SG::ReadDecorHandle
Handle class for reading a decoration on an object.
Definition: StoreGate/StoreGate/ReadDecorHandle.h:94
SG::Decorator
Helper class to provide type-safe access to aux data.
Definition: Decorator.h:59
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
D3PDSizeSummary.ff
ff
Definition: D3PDSizeSummary.py:305
Prompt::DecoratePLIT::m_acc_el_ptvarcone30
SG::ReadDecorHandleKey< xAOD::ElectronContainer > m_acc_el_ptvarcone30
Definition: DecoratePLIT.h:121
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
angle
double angle(const GeoTrf::Vector2D &a, const GeoTrf::Vector2D &b)
Definition: TRTDetectorFactory_Full.cxx:73
Prompt::DecoratePLIT::m_acc_el_topoetcone30
SG::ReadDecorHandleKey< xAOD::ElectronContainer > m_acc_el_topoetcone30
Definition: DecoratePLIT.h:122
Prompt::DecoratePLIT::m_maxLepTrackdR
Gaudi::Property< float > m_maxLepTrackdR
Definition: DecoratePLIT.h:88
TRT::Track::d0
@ d0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:62
Prompt::DecoratePLIT::passed_r22tracking_cuts
bool passed_r22tracking_cuts(const xAOD::TrackParticle &tp, const EventContext &ctx) const
Definition: DecoratePLIT.cxx:703
Prompt::DecoratePLIT::m_dec_el_plit_output
SG::WriteDecorHandleKeyArray< xAOD::ElectronContainer > m_dec_el_plit_output
Definition: DecoratePLIT.h:134
Prompt::DecoratePLIT::m_maxLepTrackJetdR
Gaudi::Property< float > m_maxLepTrackJetdR
Definition: DecoratePLIT.h:86
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Prompt::DecoratePLIT::m_configFileVersion
Gaudi::Property< std::string > m_configFileVersion
Definition: DecoratePLIT.h:83
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
xAOD::numberOfPixelSplitHits
@ numberOfPixelSplitHits
number of Pixel all-layer hits split by cluster splitting [unit8_t].
Definition: TrackingPrimitives.h:263
xAOD::numberOfSCTHoles
@ numberOfSCTHoles
number of SCT holes [unit8_t].
Definition: TrackingPrimitives.h:270
Prompt::FourMom_t
TLorentzVector FourMom_t
Definition: DecoratePLIT.h:31
Prompt::DecoratePLIT::m_tracksKey
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_tracksKey
Definition: DecoratePLIT.h:108
AthReentrantAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthReentrantAlgorithm.h:153
SCT
Definition: SCT_ChipUtils.h:14
Prompt::DecoratePLIT::m_acc_trk_dr_trackjet
SG::ReadDecorHandleKey< xAOD::TrackParticleContainer > m_acc_trk_dr_trackjet
Definition: DecoratePLIT.h:125
Trk::Combined
@ Combined
Definition: TrackSummaryTool.h:32
Prompt::DecoratePLIT::m_acc_trk_dr_lepton
SG::ReadDecorHandleKey< xAOD::TrackParticleContainer > m_acc_trk_dr_lepton
Definition: DecoratePLIT.h:126
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
Prompt::DecoratePLIT::m_onnxUtil_endcap
std::shared_ptr< const FlavorTagDiscriminants::OnnxUtil > m_onnxUtil_endcap
Definition: DecoratePLIT.h:43
Prompt::DecoratePLIT::m_TaggerName
Gaudi::Property< std::string > m_TaggerName
Definition: DecoratePLIT.h:85
xAOD::numberOfNextToInnermostPixelLayerHits
@ numberOfNextToInnermostPixelLayerHits
these are the hits in the 1st pixel barrel layer
Definition: TrackingPrimitives.h:248
xAOD::TrackParticle_v1::definingParametersCovMatrix
const ParametersCovMatrix_t definingParametersCovMatrix() const
Returns the 5x5 symmetric matrix containing the defining parameters covariance matrix.
Definition: TrackParticle_v1.cxx:246
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
AthReentrantAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthReentrantAlgorithm.cxx:96
charge
double charge(const T &p)
Definition: AtlasPID.h:501
xAOD::EgammaHelpers::getOriginalTrackParticleFromGSF
const xAOD::TrackParticle * getOriginalTrackParticleFromGSF(const xAOD::TrackParticle *trkPar)
Helper function for getting the "Original" Track Particle (i.e before GSF) via the GSF Track Particle...
Definition: ElectronxAODHelpers.cxx:22
xAOD::IParticle::p4
virtual FourMom_t p4() const =0
The full 4-momentum of the particle.
xAOD::Electron_v1
Definition: Electron_v1.h:34
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:431
Prompt::DecoratePLIT::m_muonsKey
SG::ReadHandleKey< xAOD::MuonContainer > m_muonsKey
Definition: DecoratePLIT.h:100
Prompt::DecoratePLIT::m_lepCalErelConeSize
Gaudi::Property< float > m_lepCalErelConeSize
Definition: DecoratePLIT.h:90
xAOD::Jet_v1
Class describing a jet.
Definition: Jet_v1.h:57
Prompt::DecoratePLIT::m_configPath
Gaudi::Property< std::string > m_configPath
Definition: DecoratePLIT.h:82
xAOD::Jet_v1::p4
virtual FourMom_t p4() const
The full 4-momentum of the particle.
Definition: Jet_v1.cxx:71
Prompt::DecoratePLIT::m_acc_trk_d0
SG::ReadDecorHandleKey< xAOD::TrackParticleContainer > m_acc_trk_d0
Definition: DecoratePLIT.h:127
Prompt::DecoratePLIT::m_acc_trk_electron_track
SG::ReadDecorHandleKey< xAOD::TrackParticleContainer > m_acc_trk_electron_track
Definition: DecoratePLIT.h:132
a
TList * a
Definition: liststreamerinfos.cxx:10
h
std::sort
void sort(typename std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, typename std::reverse_iterator< DataModel_detail::iterator< DVL > > end, const Compare &comp)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:623
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
xAOD::numberOfSCTDeadSensors
@ numberOfSCTDeadSensors
number of dead SCT sensors crossed [unit8_t].
Definition: TrackingPrimitives.h:273
Prompt::DecoratePLIT::m_acc_mu_ptvarcone30TTVA
SG::ReadDecorHandleKey< xAOD::MuonContainer > m_acc_mu_ptvarcone30TTVA
Definition: DecoratePLIT.h:118
Prompt::DecoratePLIT::m_num_track_features
int m_num_track_features
Definition: DecoratePLIT.h:46
xAOD::EgammaParameters::electron
@ electron
Definition: EgammaEnums.h:18
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
xAOD::numberOfInnermostPixelLayerSharedHits
@ numberOfInnermostPixelLayerSharedHits
number of Pixel 0th layer barrel hits shared by several tracks.
Definition: TrackingPrimitives.h:239
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:268
doL1CaloHVCorrections.parts
parts
Definition: doL1CaloHVCorrections.py:334
defineDB.jets
list jets
Definition: JetTagCalibration/share/defineDB.py:24
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
xAOD::numberOfPixelDeadSensors
@ numberOfPixelDeadSensors
number of dead pixel sensors crossed [unit8_t].
Definition: TrackingPrimitives.h:266
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
Prompt::DecoratePLIT::m_acc_trk_d0Uncertainty
SG::ReadDecorHandleKey< xAOD::TrackParticleContainer > m_acc_trk_d0Uncertainty
Definition: DecoratePLIT.h:129
xAOD::Jet_v1::pt
virtual double pt() const
The transverse momentum ( ) of the particle.
Definition: Jet_v1.cxx:44
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
xAOD::TrackParticle_v1::theta
float theta() const
Returns the parameter, which has range 0 to .
Prompt::DecoratePLIT::decorateTrack
StatusCode decorateTrack(const xAOD::TrackParticle &track, float dr_lepton, bool isUsedForElectron, bool isUsedForMuon, const xAOD::Jet *trackJet, const xAOD::TrackParticle *trackLep) const
Definition: DecoratePLIT.cxx:837
Prompt::DecoratePLIT::predictMuon
StatusCode predictMuon(const xAOD::Muon &muon, const xAOD::JetContainer &trackjets, const xAOD::TrackParticleContainer &tracks, std::vector< SG::WriteDecorHandle< xAOD::MuonContainer, float >> &dec_mu_plit_output, const EventContext &ctx) const
Definition: DecoratePLIT.cxx:163
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
InDetDD::electrons
@ electrons
Definition: InDetDD_Defs.h:17
Prompt::DecoratePLIT::predictElec
StatusCode predictElec(const xAOD::Electron &electron, const xAOD::JetContainer &trackjets, const xAOD::TrackParticleContainer &tracks, const xAOD::CaloClusterContainer &caloclusters, std::vector< SG::WriteDecorHandle< xAOD::ElectronContainer, float >> &dec_el_plit_output, const EventContext &ctx) const
Definition: DecoratePLIT.cxx:397
fitman.k
k
Definition: fitman.py:528
xAOD::numberOfInnermostPixelLayerHits
@ numberOfInnermostPixelLayerHits
these are the hits in the 0th pixel barrel layer
Definition: TrackingPrimitives.h:237
python.handimod.cc
int cc
Definition: handimod.py:523
Prompt::DecoratePLIT::m_leptonsName
Gaudi::Property< std::string > m_leptonsName
Definition: DecoratePLIT.h:78
SCT
@ SCT
Definition: RegSelEnums.h:25
Prompt::DecoratePLIT::m_trackjetsKey
SG::ReadHandleKey< xAOD::JetContainer > m_trackjetsKey
Definition: DecoratePLIT.h:104
str::d0Uncertainty
const std::string d0Uncertainty
Definition: BTagTrackIpAccessor.cxx:12
ServiceHandle< ICondSvc >
Prompt::DecoratePLIT::fillParticles
StatusCode fillParticles(std::vector< const xAOD::IParticle * > &parts, const xAOD::IParticle &lepton, const xAOD::TrackParticle *trackLep, const xAOD::Jet *trackJet, const xAOD::TrackParticleContainer &trackContainer, const EventContext &ctx) const
Definition: DecoratePLIT.cxx:783
Generated on Tue Oct 1 2024 22:23:03 for ATLAS Offline Software by   doxygen 1.8.18