ATLAS Offline Software
Public Member Functions | Protected Member Functions | Static Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
met::METPhotonAssociator Class Referencefinal

#include <METPhotonAssociator.h>

Inheritance diagram for met::METPhotonAssociator:
Collaboration diagram for met::METPhotonAssociator:

Public Member Functions

 METPhotonAssociator (const std::string &name)
 
 ~METPhotonAssociator ()=default
 
virtual StatusCode initialize () override
 Dummy implementation of the initialisation function. More...
 
StatusCode finalize ()
 
virtual StatusCode execute (xAOD::MissingETContainer *metCont, xAOD::MissingETAssociationMap *metMap) const override
 
virtual void print () const
 Print the state of the tool. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

StatusCode executeTool (xAOD::MissingETContainer *metCont, xAOD::MissingETAssociationMap *metMap) const final
 
StatusCode extractTopoClusters (const xAOD::IParticle *obj, std::vector< const xAOD::IParticle * > &tclist, const met::METAssociator::ConstitHolder &constits) const final
 
StatusCode extractPFO (const xAOD::IParticle *obj, std::vector< const xAOD::IParticle * > &pfolist, const met::METAssociator::ConstitHolder &constits, std::map< const xAOD::IParticle *, MissingETBase::Types::constvec_t > &momenta) const final
 
StatusCode extractPFOsFromLinks (const xAOD::Egamma *eg, std::vector< const xAOD::IParticle * > &pfolist, const met::METAssociator::ConstitHolder &constits) const
 
StatusCode extractPFOs (const xAOD::Egamma *eg, std::vector< const xAOD::IParticle * > &pfolist, const met::METAssociator::ConstitHolder &constits) const
 
StatusCode extractFE (const xAOD::IParticle *obj, std::vector< const xAOD::IParticle * > &felist, const met::METAssociator::ConstitHolder &constits, std::map< const xAOD::IParticle *, MissingETBase::Types::constvec_t > &momenta) const final
 
StatusCode extractFEsFromLinks (const xAOD::Egamma *eg, std::vector< const xAOD::IParticle * > &felist, const met::METAssociator::ConstitHolder &constits) const
 
StatusCode extractFEs (const xAOD::Egamma *eg, std::vector< const xAOD::IParticle * > &felist, const met::METAssociator::ConstitHolder &constits) const
 
StatusCode extractTracks (const xAOD::IParticle *obj, std::vector< const xAOD::IParticle * > &constlist, const met::METAssociator::ConstitHolder &constits) const final
 
StatusCode selectEgammaClusters (const xAOD::CaloCluster *swclus, const std::vector< const xAOD::IParticle * > &inputTC, std::vector< const xAOD::IParticle * > &tclist) const
 
StatusCode selectEgammaTracks (const xAOD::Egamma *el, const xAOD::TrackParticleContainer *trkCont, std::set< const xAOD::TrackParticle * > &tracklist) const
 
bool hasUnmatchedClusters (const xAOD::Egamma *eg, const xAOD::PFO *pfo) const
 
StatusCode retrieveConstituents (met::METAssociator::ConstitHolder &constits) const
 
bool acceptTrack (const xAOD::TrackParticle *trk, const xAOD::Vertex *pv) const
 
bool isGoodEoverP (const xAOD::TrackParticle *trk) const
 
virtual StatusCode fillAssocMap (xAOD::MissingETAssociationMap *metMap, const xAOD::IParticleContainer *hardObjs) const
 
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...
 

Static Protected Member Functions

static bool greaterPt (const xAOD::IParticle *part1, const xAOD::IParticle *part2)
 
static bool greaterPtPFO (const xAOD::PFO *part1, const xAOD::PFO *part2)
 
static bool greaterPtFE (const xAOD::FlowElement *part1, const xAOD::FlowElement *part2)
 

Protected Attributes

double m_tcMatch_dR
 
double m_tcMatch_maxRat
 
unsigned short m_tcMatch_method
 
double m_extraTrkMatch_dR
 
SG::ReadDecorHandleKey< xAOD::PhotonContainer > m_photonNeutralPFOReadDecorKey {this,"photonNeutralPFOReadDecorKey","", "Neutral PFO links key"}
 
SG::ReadDecorHandleKey< xAOD::PhotonContainer > m_photonChargedPFOReadDecorKey {this,"photonChargedPFOReadDecorKey","", "Charged PFO links key"}
 
SG::ReadDecorHandleKey< xAOD::PhotonContainer > m_photonNeutralFEReadDecorKey {this,"photonNeutralFEReadDecorKey","", "Neutral FE links key"}
 
SG::ReadDecorHandleKey< xAOD::PhotonContainer > m_photonChargedFEReadDecorKey {this,"photonChargedFEReadDecorKey","", "Charged FE links key"}
 
SG::ReadDecorHandleKey< xAOD::ElectronContainer > m_electronNeutralPFOReadDecorKey {this,"electronNeutralPFOReadDecorKey","", "Neutral PFO links key"}
 
SG::ReadDecorHandleKey< xAOD::ElectronContainer > m_electronChargedPFOReadDecorKey {this,"electronCargedPFOReadDecorKey","", "Charged PFO links key"}
 
SG::ReadDecorHandleKey< xAOD::ElectronContainer > m_electronNeutralFEReadDecorKey {this,"electronNeutralFEReadDecorKey","", "Neutral FE links key"}
 
SG::ReadDecorHandleKey< xAOD::ElectronContainer > m_electronChargedFEReadDecorKey {this,"electronCargedFEReadDecorKey","", "Charged FE links key"}
 
bool m_checkUnmatched
 
ToolHandle< InDet::IInDetTrackSelectionTool > m_trkseltool
 
ToolHandle< xAOD::ITrackIsolationTool > m_trkIsolationTool
 
ToolHandle< xAOD::ICaloTopoClusterIsolationTool > m_caloIsolationTool
 
std::string m_neutralFELinksKey
 
std::string m_chargedFELinksKey
 
std::string m_neutralPFOLinksKey
 
std::string m_chargedPFOLinksKey
 
bool m_usePFOLinks
 
bool m_useFELinks
 
SG::ReadHandleKey< xAOD::VertexContainer > m_pvcollKey {this,"PrimVxColl","PrimaryVertices","Primary Vertex Collection"}
 
SG::ReadHandleKey< xAOD::IParticleContainer > m_clcollKey {this,"ClusColl","CaloCalTopoClusters","Topo cluster Collection"}
 
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_trkcollKey {this,"TrkColl","InDetTrackParticles","Track particle Collection"}
 
SG::ReadHandleKey< xAOD::PFOContainer > m_pfcollKey {this,"PFlowColl","","PFO Collection"}
 
SG::ReadHandleKey< xAOD::FlowElementContainer > m_fecollKey {this,"FlowElementCollection","","FlowElement Collection (overrides PFO if not empty)"}
 
SG::ReadHandleKey< xAOD::IParticleContainer > m_hybridContKey {this,"HybridKey","","Hybrid Collection"}
 
bool m_pflow
 
bool m_useTracks
 
bool m_useRapidity
 
bool m_useIsolationTools = false
 
bool m_useModifiedClus
 
bool m_weight_charged_pfo = false
 
bool m_cleanChargedPFO
 
bool m_skipconst
 
std::string m_forcoll
 
double m_foreta
 
double m_cenTrackPtThr
 
double m_forTrackPtThr
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

 METPhotonAssociator ()
 Default constructor: More...
 
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

SG::ReadHandleKey< xAOD::PhotonContainer > m_phContKey {this, "InputCollection", "Photons", "photons input key"}
 
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 26 of file METPhotonAssociator.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ METPhotonAssociator() [1/2]

met::METPhotonAssociator::METPhotonAssociator ( const std::string &  name)

Definition at line 28 of file METPhotonAssociator.cxx.

28  :
29  AsgTool(name),
30  METAssociator(name),
31  METEgammaAssociator(name)
32  {
33  }

◆ ~METPhotonAssociator()

met::METPhotonAssociator::~METPhotonAssociator ( )
default

◆ METPhotonAssociator() [2/2]

met::METPhotonAssociator::METPhotonAssociator ( )
private

Default constructor:

Member Function Documentation

◆ acceptTrack()

bool met::METAssociator::acceptTrack ( const xAOD::TrackParticle *  trk,
const xAOD::Vertex *  pv 
) const
protectedinherited

Definition at line 359 of file METAssociator.cxx.

360  {
361 
362  if (!vx) return false;//in events with no pv, we will just reject all tracks, and therefore build only the calo MET
363  return static_cast<bool> (m_trkseltool->accept( *trk, vx ));
364  }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

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

◆ declareProperty() [1/6]

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

Declare a new Gaudi property.

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

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

Definition at line 245 of file AthCommonDataStore.h.

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

◆ declareProperty() [2/6]

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

Declare a new Gaudi property.

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

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

Definition at line 221 of file AthCommonDataStore.h.

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

◆ declareProperty() [3/6]

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

Definition at line 259 of file AthCommonDataStore.h.

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

◆ declareProperty() [4/6]

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

Declare a new Gaudi property.

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

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

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

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

Declare a new Gaudi property.

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

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

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode met::METAssociator::execute ( xAOD::MissingETContainer *  metCont,
xAOD::MissingETAssociationMap *  metMap 
) const
overridevirtualinherited

Implements IMETAssocToolBase.

Definition at line 141 of file METAssociator.cxx.

142  {
143  ATH_MSG_DEBUG ("In execute: " << name() << "...");
144  if(!metCont) {
145  ATH_MSG_WARNING("Invalid pointer to MissingETContainer supplied! Abort.");
146  return StatusCode::FAILURE;
147  }
148 
149  if(!metMap) {
150  ATH_MSG_WARNING("Invalid pointer to MissingETAssociationMap supplied! Abort.");
151  return StatusCode::FAILURE;
152  }
153  if(m_pflow && !m_useTracks ){
154  ATH_MSG_WARNING("Attempting to build PFlow MET without a track collection.");
155  return StatusCode::FAILURE;
156  }
157 
158  return this->executeTool(metCont, metMap);
159  }

◆ executeTool()

StatusCode met::METPhotonAssociator::executeTool ( xAOD::MissingETContainer *  metCont,
xAOD::MissingETAssociationMap *  metMap 
) const
finalprotectedvirtual

Implements met::METAssociator.

Definition at line 63 of file METPhotonAssociator.cxx.

64  {
65  ATH_MSG_VERBOSE ("In execute: " << name() << "...");
66 
67  SG::ReadHandle<xAOD::PhotonContainer> phCont(m_phContKey);
68  if (!phCont.isValid()) {
69  ATH_MSG_WARNING("Unable to retrieve input photon container " << m_phContKey.key());
70  return StatusCode::FAILURE;
71  }
72 
73  ATH_MSG_DEBUG("Successfully retrieved photon collection");
74 
75  if (fillAssocMap(metMap,phCont.cptr()).isFailure()) {
76  ATH_MSG_WARNING("Unable to fill map with photon container " << m_phContKey.key());
77  return StatusCode::FAILURE;
78  }
79  return StatusCode::SUCCESS;
80  }

◆ extractFE()

StatusCode met::METEgammaAssociator::extractFE ( const xAOD::IParticle *  obj,
std::vector< const xAOD::IParticle * > &  felist,
const met::METAssociator::ConstitHolder &  constits,
std::map< const xAOD::IParticle *, MissingETBase::Types::constvec_t > &  momenta 
) const
finalprotectedvirtualinherited

Implements met::METAssociator.

Definition at line 304 of file METEgammaAssociator.cxx.

308  {
309  const xAOD::Egamma *eg = static_cast<const xAOD::Egamma*>(obj);
310 
311  if (m_useFELinks)
312  ATH_CHECK( extractFEsFromLinks(eg, felist,constits) );
313  else
314  ATH_CHECK( extractFEs(eg, felist, constits) );
315 
316  return StatusCode::SUCCESS;
317  }

◆ extractFEs()

StatusCode met::METEgammaAssociator::extractFEs ( const xAOD::Egamma *  eg,
std::vector< const xAOD::IParticle * > &  felist,
const met::METAssociator::ConstitHolder &  constits 
) const
protectedinherited

Definition at line 384 of file METEgammaAssociator.cxx.

387  {
388  ATH_MSG_VERBOSE("Extract FEs From DeltaR for " << eg->type() << " with pT " << eg->pt());
389 
390  // safe to assume a single SW cluster?
391  // will do so for now...
392  const xAOD::IParticle* swclus = eg->caloCluster();
393 
394  // Preselect PFOs based on proximity: dR<0.4
395  std::vector<const xAOD::FlowElement*> nearbyFE;
396  nearbyFE.reserve(20);
397  for(const xAOD::FlowElement* fe : *constits.feCont) {
398  if(!(fe->signalType() & xAOD::FlowElement::PFlow)){
399  ATH_MSG_ERROR("Attempted to extract non-PFlow FlowElements. This is not supported!");
400  return StatusCode::FAILURE;
401  }
402  if(P4Helpers::isInDeltaR(*fe, *swclus, 0.4, m_useRapidity)) {
403  // We set a small -ve pt for cPFOs that were rejected
404  // by the ChargedHadronSubtractionTool
405  const static SG::AuxElement::ConstAccessor<char> PVMatchedAcc("matchedToPV");
406  if( ( !fe->isCharged() && fe->e() > FLT_MIN ) ||
407  ( fe->isCharged() && PVMatchedAcc(*fe)
408  && ( !m_cleanChargedPFO || isGoodEoverP(static_cast<const xAOD::TrackParticle*>(fe->chargedObject(0))) ) )
409  ) {
410  nearbyFE.push_back(fe);
411  } // retain +ve E neutral PFOs and charged PFOs passing PV association
412  } // DeltaR check
413  } // PFO loop
414  ATH_MSG_VERBOSE("Found " << nearbyFE.size() << " nearby FlowElements (PFOs)");
415 
416  std::set<const xAOD::TrackParticle*> trackset; // use a set for duplicate-free retrieval
417  ATH_CHECK( selectEgammaTracks(eg, constits.trkCont, trackset) );
418  for(const xAOD::TrackParticle* track : trackset) {
419  for(const xAOD::FlowElement* fe : nearbyFE) {
420  if(fe->isCharged() && fe->chargedObject(0) == track) {
421  felist.push_back(fe);
422  } // PFO/track match
423  } // PFO loop
424  } // Track loop
425  double eg_cl_e = swclus->e();
426 
427  // the matching strategy depends on how the cluster container is sorted
428  // easier if it's sorted in descending pt order
429  // ideally this should be done using cell matching, but we can't use the links from topoclusters reliably
430  // because some PFOs don't correspond to the original TC
431  bool doSum = true;
432  double sumE_pfo = 0.;
433  const IParticle* bestbadmatch = nullptr;
434  std::sort(nearbyFE.begin(),nearbyFE.end(),greaterPtFE);
435  for(const xAOD::FlowElement* fe : nearbyFE) {
436  // Skip charged PFOs, as we already matched them
437  if(fe->isCharged() || !P4Helpers::isInDeltaR(*fe, *swclus, m_tcMatch_dR, m_useRapidity)) continue;
438  // Handle neutral PFOs like topoclusters
439  // TODO: Use EM-scale energy here in the future? No way to access from FlowElement in general.
440  double pfo_e = fe->e();
441  // skip cluster if it's above our bad match threshold or outside the matching radius
442  if(pfo_e > m_tcMatch_maxRat*eg_cl_e) {
443  ATH_MSG_VERBOSE("Reject topocluster in sum. Ratio vs eg cluster: " << (pfo_e/eg_cl_e));
444  if( !bestbadmatch || (fabs(pfo_e/eg_cl_e-1.) < fabs(bestbadmatch->e()/eg_cl_e-1.)) ) bestbadmatch = fe;
445  continue;
446  }
447 
448  ATH_MSG_VERBOSE("E match with new nPFO: " << fabs(sumE_pfo+pfo_e - eg_cl_e) / eg_cl_e);
449  if( (doSum = fabs(sumE_pfo+pfo_e-eg_cl_e) < fabs(sumE_pfo - eg_cl_e)) ) {
450  felist.push_back(fe);
451  sumE_pfo += pfo_e;
452  ATH_MSG_VERBOSE("Accept pfo with pt " << fe->pt() << ", e " << fe->e() << " in sum.");
453  ATH_MSG_VERBOSE("Energy ratio of nPFO to eg: " << pfo_e / eg_cl_e);
454  ATH_MSG_VERBOSE("E match with new PFO: " << fabs(sumE_pfo+pfo_e - eg_cl_e) / eg_cl_e);
455  } // if we will retain the topocluster
456  else break;
457  } // loop over nearby clusters
458  if(sumE_pfo<FLT_MIN && bestbadmatch) {
459  ATH_MSG_VERBOSE("No better matches found -- add bad match topocluster with pt "
460  << bestbadmatch->pt() << ", e " << bestbadmatch->e() << ".");
461  felist.push_back(bestbadmatch);
462  }
463 
464  return StatusCode::SUCCESS;
465  }

◆ extractFEsFromLinks()

StatusCode met::METEgammaAssociator::extractFEsFromLinks ( const xAOD::Egamma *  eg,
std::vector< const xAOD::IParticle * > &  felist,
const met::METAssociator::ConstitHolder &  constits 
) const
protectedinherited

Definition at line 320 of file METEgammaAssociator.cxx.

323  {
324 
325  ATH_MSG_DEBUG("Extract FEs From Links for " << eg->type() << " with pT " << eg->pt());
326 
327  std::vector<FELink_t> nFELinks;
328  std::vector<FELink_t> cFELinks;
329 
330  if (eg->type() == xAOD::Type::Electron){
331  SG::ReadDecorHandle<xAOD::ElectronContainer, std::vector<FELink_t> > neutralFEReadDecorHandle (m_electronNeutralFEReadDecorKey);
332  SG::ReadDecorHandle<xAOD::ElectronContainer, std::vector<FELink_t> > chargedFEReadDecorHandle (m_electronChargedFEReadDecorKey);
333  nFELinks=neutralFEReadDecorHandle(*eg);
334  cFELinks=chargedFEReadDecorHandle(*eg);
335  }
336  if (eg->type() == xAOD::Type::Photon) {
337  SG::ReadDecorHandle<xAOD::PhotonContainer, std::vector<FELink_t> > neutralFEReadDecorHandle (m_photonNeutralFEReadDecorKey);
338  SG::ReadDecorHandle<xAOD::PhotonContainer, std::vector<FELink_t> > chargedFEReadDecorHandle (m_photonChargedFEReadDecorKey);
339  nFELinks=neutralFEReadDecorHandle(*eg);
340  cFELinks=chargedFEReadDecorHandle(*eg);
341  }
342 
343 
344  // Charged FEs
345  for (const FELink_t& feLink : cFELinks) {
346  if (!feLink.isValid()) continue;
347  const xAOD::FlowElement* fe_init = *feLink;
348  for (const auto *const fe : *constits.feCont){
349  if (fe->index() == fe_init->index() && fe->isCharged()){ //index-based match between JetETmiss and CHSFlowElements collections
350  const static SG::AuxElement::ConstAccessor<char> PVMatchedAcc("matchedToPV");
351  if( fe->isCharged() && PVMatchedAcc(*fe)&& ( !m_cleanChargedPFO || isGoodEoverP(static_cast<const xAOD::TrackParticle*>(fe->chargedObject(0))) ) ) {
352  ATH_MSG_DEBUG("Accept cFE with pt " << fe->pt() << ", e " << fe->e() << ", eta " << fe->eta() << ", phi " << fe->phi() );
353  felist.push_back(fe);
354  }
355  }
356  }
357  } // end cFE loop
358 
359  // Neutral FEs
360  double eg_cl_e = eg->caloCluster()->e();
361  double sumE_fe = 0.;
362 
363  for (const FELink_t& feLink : nFELinks) {
364  if (!feLink.isValid()) continue;
365  const xAOD::FlowElement* fe_init = *feLink;
366  for (const auto *const fe : *constits.feCont){
367  if (fe->index() == fe_init->index() && !fe->isCharged()){ //index-based match between JetETmiss and CHSFlowElements collections
368  double fe_e = fe->e();
369  if( ( !fe->isCharged()&& fe->e() > FLT_MIN ) ){
370  sumE_fe += fe_e;
371  ATH_MSG_DEBUG("E match with new nFE: " << fabs(sumE_fe+fe_e - eg_cl_e) / eg_cl_e);
372  ATH_MSG_DEBUG("Accept nFE with pt " << fe->pt() << ", e " << fe->e() << ", eta " << fe->eta() << ", phi " << fe->phi() << " in sum.");
373  ATH_MSG_DEBUG("Energy ratio of nFE to eg: " << fe_e / eg_cl_e);
374  felist.push_back(fe);
375  }
376  }
377  }
378  } // end nFE links loop
379 
380 
381  return StatusCode::SUCCESS;
382  }

◆ extractPFO()

StatusCode met::METEgammaAssociator::extractPFO ( const xAOD::IParticle *  obj,
std::vector< const xAOD::IParticle * > &  pfolist,
const met::METAssociator::ConstitHolder &  constits,
std::map< const xAOD::IParticle *, MissingETBase::Types::constvec_t > &  momenta 
) const
finalprotectedvirtualinherited

Implements met::METAssociator.

Definition at line 147 of file METEgammaAssociator.cxx.

151  {
152  const xAOD::Egamma *eg = static_cast<const xAOD::Egamma*>(obj);
153 
154  if (m_usePFOLinks)
155  ATH_CHECK( extractPFOsFromLinks(eg, pfolist,constits) );
156  else
157  ATH_CHECK( extractPFOs(eg, pfolist, constits) );
158 
159  return StatusCode::SUCCESS;
160  }

◆ extractPFOs()

StatusCode met::METEgammaAssociator::extractPFOs ( const xAOD::Egamma *  eg,
std::vector< const xAOD::IParticle * > &  pfolist,
const met::METAssociator::ConstitHolder &  constits 
) const
protectedinherited

Definition at line 226 of file METEgammaAssociator.cxx.

230  {
231  // safe to assume a single SW cluster?
232  // will do so for now...
233  const xAOD::IParticle* swclus = eg->caloCluster();
234  ANA_MSG_VERBOSE("Extract PFOs with DeltaR for " << eg->type() << " with pT " << eg->pt());
235 
236  // Preselect PFOs based on proximity: dR<0.4
237  std::vector<const xAOD::PFO*> nearbyPFO;
238  nearbyPFO.reserve(20);
239  for(const auto *const pfo : *constits.pfoCont) {
240  if(P4Helpers::isInDeltaR(*pfo, *swclus, 0.4, m_useRapidity)) {
241  // We set a small -ve pt for cPFOs that were rejected
242  // by the ChargedHadronSubtractionTool
243  const static SG::AuxElement::ConstAccessor<char> PVMatchedAcc("matchedToPV");
244  if( ( !pfo->isCharged() && pfo->e() > FLT_MIN ) ||
245  ( pfo->isCharged() && PVMatchedAcc(*pfo)
246  && ( !m_cleanChargedPFO || isGoodEoverP(pfo->track(0)) ) )
247  ) {
248  nearbyPFO.push_back(pfo);
249  } // retain +ve E neutral PFOs and charged PFOs passing PV association
250  } // DeltaR check
251  } // PFO loop
252  ATH_MSG_VERBOSE("Found " << nearbyPFO.size() << " nearby pfos");
253 
254  std::set<const xAOD::TrackParticle*> trackset; // use a set for duplicate-free retrieval
255  ATH_CHECK( selectEgammaTracks(eg, constits.trkCont, trackset) );
256  for(const auto& track : trackset) {
257  for(const auto& pfo : nearbyPFO) {
258  if(pfo->isCharged() && pfo->track(0) == track) {
259  pfolist.push_back(pfo);
260  } // PFO/track match
261  } // PFO loop
262  } // Track loop
263  double eg_cl_e = swclus->e();
264 
265  // the matching strategy depends on how the cluster container is sorted
266  // easier if it's sorted in descending pt order
267  // ideally this should be done using cell matching, but we can't use the links from topoclusters reliably
268  // because some PFOs don't correspond to the original TC
269  bool doSum = true;
270  double sumE_pfo = 0.;
271  const IParticle* bestbadmatch = nullptr;
272  std::sort(nearbyPFO.begin(),nearbyPFO.end(),greaterPtPFO);
273  for(const auto& pfo : nearbyPFO) {
274  // Skip charged PFOs, as we already matched them
275  if(pfo->isCharged() || !P4Helpers::isInDeltaR(*pfo, *swclus, m_tcMatch_dR, m_useRapidity)) {continue;}
276  // Handle neutral PFOs like topoclusters
277  double pfo_e = pfo->eEM();
278  // skip cluster if it's above our bad match threshold or outside the matching radius
279  if(pfo_e>m_tcMatch_maxRat*eg_cl_e) {
280  ATH_MSG_VERBOSE("Reject topocluster in sum. Ratio vs eg cluster: " << (pfo_e/eg_cl_e));
281  if( !bestbadmatch || (fabs(pfo_e/eg_cl_e-1.) < fabs(bestbadmatch->e()/eg_cl_e-1.)) ) bestbadmatch = pfo;
282  continue;
283  }
284 
285  ATH_MSG_VERBOSE("E match with new nPFO: " << fabs(sumE_pfo+pfo_e - eg_cl_e) / eg_cl_e);
286  if( (doSum = fabs(sumE_pfo+pfo_e-eg_cl_e) < fabs(sumE_pfo - eg_cl_e)) ) {
287  pfolist.push_back(pfo);
288  sumE_pfo += pfo_e;
289  ATH_MSG_VERBOSE("Accept pfo with pt " << pfo->pt() << ", e " << pfo->e() << " in sum.");
290  ATH_MSG_VERBOSE("Energy ratio of nPFO to eg: " << pfo_e / eg_cl_e);
291  ATH_MSG_VERBOSE("E match with new PFO: " << fabs(sumE_pfo+pfo_e - eg_cl_e) / eg_cl_e);
292  } // if we will retain the topocluster
293  else {break;}
294  } // loop over nearby clusters
295  if(sumE_pfo<FLT_MIN && bestbadmatch) {
296  ATH_MSG_VERBOSE("No better matches found -- add bad match topocluster with pt "
297  << bestbadmatch->pt() << ", e " << bestbadmatch->e() << ".");
298  pfolist.push_back(bestbadmatch);
299  }
300 
301  return StatusCode::SUCCESS;
302  }

◆ extractPFOsFromLinks()

StatusCode met::METEgammaAssociator::extractPFOsFromLinks ( const xAOD::Egamma *  eg,
std::vector< const xAOD::IParticle * > &  pfolist,
const met::METAssociator::ConstitHolder &  constits 
) const
protectedinherited

Definition at line 162 of file METEgammaAssociator.cxx.

165  {
166 
167  ATH_MSG_DEBUG("Extract PFOs From Links for " << eg->type() << " with pT " << eg->pt());
168 
169  std::vector<PFOLink_t> cPFOLinks;
170  std::vector<PFOLink_t> nPFOLinks;
171 
172  if (eg->type() == xAOD::Type::Electron){
173  SG::ReadDecorHandle<xAOD::ElectronContainer, std::vector<PFOLink_t> > neutralPFOReadDecorHandle (m_electronNeutralPFOReadDecorKey);
174  SG::ReadDecorHandle<xAOD::ElectronContainer, std::vector<PFOLink_t> > chargedPFOReadDecorHandle (m_electronChargedPFOReadDecorKey);
175  nPFOLinks=neutralPFOReadDecorHandle(*eg);
176  cPFOLinks=chargedPFOReadDecorHandle(*eg);
177  }
178  if (eg->type() == xAOD::Type::Photon) {
179  SG::ReadDecorHandle<xAOD::PhotonContainer, std::vector<PFOLink_t> > neutralPFOReadDecorHandle (m_photonNeutralPFOReadDecorKey);
180  SG::ReadDecorHandle<xAOD::PhotonContainer, std::vector<PFOLink_t> > chargedPFOReadDecorHandle (m_photonChargedPFOReadDecorKey);
181  nPFOLinks=neutralPFOReadDecorHandle(*eg);
182  cPFOLinks=chargedPFOReadDecorHandle(*eg);
183  }
184 
185 
186  // Charged PFOs
187  for (const PFOLink_t& pfoLink : cPFOLinks) {
188  if (!pfoLink.isValid()) continue;
189  const xAOD::PFO* pfo_init = *pfoLink;
190  for (const auto *const pfo : *constits.pfoCont){
191  if (pfo->index() == pfo_init->index() && pfo->isCharged()){ //index-based match between JetETmiss and CHSParticleFlow collections
192  const static SG::AuxElement::ConstAccessor<char> PVMatchedAcc("matchedToPV");
193  if( pfo->isCharged() && PVMatchedAcc(*pfo)&& ( !m_cleanChargedPFO || isGoodEoverP(pfo->track(0)) ) ) {
194  ATH_MSG_DEBUG("Accept cPFO with pt " << pfo->pt() << ", e " << pfo->e() << ", eta " << pfo->eta() << ", phi " << pfo->phi() );
195  if (!m_checkUnmatched || !hasUnmatchedClusters(eg,pfo_init)) pfolist.push_back(pfo);
196  }
197  }
198  }
199  } // end cPFO loop
200 
201  // Neutral PFOs
202  double eg_cl_e = eg->caloCluster()->e();
203  double sumE_pfo = 0.;
204 
205  for (const PFOLink_t& pfoLink : nPFOLinks) {
206  if (!pfoLink.isValid()) continue;
207  const xAOD::PFO* pfo_init = *pfoLink;
208  for (const auto *const pfo : *constits.pfoCont){
209  if (pfo->index() == pfo_init->index() && !pfo->isCharged()){ //index-based match between JetETmiss and CHSParticleFlow collections
210  double pfo_e = pfo->eEM();
211  if( ( !pfo->isCharged()&& pfo->e() > FLT_MIN ) ){
212  sumE_pfo += pfo_e;
213  ATH_MSG_DEBUG("E match with new nPFO: " << fabs(sumE_pfo+pfo_e - eg_cl_e) / eg_cl_e);
214  ATH_MSG_DEBUG("Accept nPFO with pt " << pfo->pt() << ", e " << pfo->e() << ", eta " << pfo->eta() << ", phi " << pfo->phi() << " in sum.");
215  ATH_MSG_DEBUG("Energy ratio of nPFO to eg: " << pfo_e / eg_cl_e);
216  pfolist.push_back(pfo);
217  }
218  }
219  }
220  } // end nPFO links loop
221 
222 
223  return StatusCode::SUCCESS;
224  }

◆ extractTopoClusters()

StatusCode met::METEgammaAssociator::extractTopoClusters ( const xAOD::IParticle *  obj,
std::vector< const xAOD::IParticle * > &  tclist,
const met::METAssociator::ConstitHolder &  constits 
) const
finalprotectedvirtualinherited

Implements met::METAssociator.

Definition at line 84 of file METEgammaAssociator.cxx.

87  {
88  const Egamma *eg = static_cast<const Egamma*>(obj);
89  // safe to assume a single SW cluster?
90  // will do so for now...
91  const CaloCluster* swclus = eg->caloCluster();
92 
93  // the matching strategy depends on how the cluster container is sorted
94  // easier if it's sorted in descending pt order
95  // we'll worry about optimisation later
96  std::vector<const IParticle*> inputTC;
97  inputTC.reserve(10);
98 
99  if(m_tcMatch_method==DeltaR) {
100  for(const auto *const cl : *constits.tcCont) {
101  // this can probably be done more elegantly
102  if(P4Helpers::isInDeltaR(*swclus,*cl,m_tcMatch_dR,m_useRapidity) && cl->e()>FLT_MIN) {
103  // could consider also requirements on the EM fraction or depth
104  inputTC.push_back(cl);
105  } // match TC in a cone around SW cluster
106  }
107  ATH_MSG_VERBOSE("Found " << inputTC.size() << " nearby topoclusters");
108  std::sort(inputTC.begin(),inputTC.end(),greaterPt);
109  } else if(m_tcMatch_method==ClusterLink) {
110  static const SG::AuxElement::ConstAccessor<std::vector<ElementLink<CaloClusterContainer> > > tcLinkAcc("constituentClusterLinks");
111  // Fill a vector of vectors
112  for(const auto& el : tcLinkAcc(*swclus)) {
113  if(el.isValid())
114  inputTC.push_back(*el);
115  else{
116  ATH_MSG_ERROR("Invalid constituentClusterLinks on input electron/photon!");
117  return StatusCode::FAILURE;
118  }
119  }
120  ATH_MSG_VERBOSE("Found " << inputTC.size() << " linked topoclusters");
121  } else {
122  ATH_MSG_WARNING( "Invalid topocluster match method configured!" );
123  return StatusCode::FAILURE;
124  }
125 
126  ATH_CHECK( selectEgammaClusters(swclus, inputTC, tclist) );
127 
128  return StatusCode::SUCCESS;
129  }

◆ extractTracks()

StatusCode met::METEgammaAssociator::extractTracks ( const xAOD::IParticle *  obj,
std::vector< const xAOD::IParticle * > &  constlist,
const met::METAssociator::ConstitHolder &  constits 
) const
finalprotectedvirtualinherited

Implements met::METAssociator.

Definition at line 132 of file METEgammaAssociator.cxx.

135  {
136  const xAOD::Egamma *eg = static_cast<const xAOD::Egamma*>(obj);
137  std::set<const xAOD::TrackParticle*> trackset; // use a set for duplicate-free retrieval
138  ATH_CHECK( selectEgammaTracks(eg, constits.trkCont, trackset) );
139  for(const auto& track : trackset) {
140  if(acceptTrack(track,constits.pv) && isGoodEoverP(track)) {
141  constlist.push_back(track);
142  }
143  }
144  return StatusCode::SUCCESS;
145  }

◆ 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

◆ fillAssocMap()

StatusCode met::METAssociator::fillAssocMap ( xAOD::MissingETAssociationMap *  metMap,
const xAOD::IParticleContainer *  hardObjs 
) const
protectedvirtualinherited

Reimplemented in met::METTruthAssociator.

Definition at line 295 of file METAssociator.cxx.

297  {
298  ConstitHolder constits;
299 
300  if (retrieveConstituents(constits).isFailure()) {
301  ATH_MSG_DEBUG("Unable to retrieve constituent containers");
302  return StatusCode::FAILURE;
303  }
304 
305  std::vector<const IParticle*> constlist;
306  constlist.reserve(20);
307  std::vector<const IParticle*> hardObjs_tmp;
308  for(const auto *const obj : *hardObjs) {
309  hardObjs_tmp.push_back(obj);
310  }
311  std::sort(hardObjs_tmp.begin(),hardObjs_tmp.end(),greaterPt);
312 
313  for(const auto& obj : hardObjs_tmp) {
314  if(obj->pt()<4e3 && obj->type()!=xAOD::Type::Muon) continue;
315  constlist.clear();
316  ATH_MSG_VERBOSE( "Object type, pt, eta, phi = " << obj->type() << ", " << obj->pt() << ", " << obj->eta() << "," << obj->phi() );
317  if(m_pflow){
318  if(!m_fecollKey.key().empty()){
319  if(!m_useTracks){
320  ATH_MSG_ERROR("Attempting to build FlowElement MET without a track collection.");
321  return StatusCode::FAILURE;
322  }
323  std::map<const IParticle*, MissingETBase::Types::constvec_t> momentumOverride;
324  ATH_CHECK( this->extractFE(obj, constlist, constits, momentumOverride) );
325  MissingETComposition::insert(metMap, obj, constlist, momentumOverride);
326  }
327  else{
328  // Old PFO EDM
329  if(!m_useTracks){
330  ATH_MSG_DEBUG("Attempting to build PFlow without a track collection.");
331  return StatusCode::FAILURE;
332  }else{
333  std::map<const IParticle*,MissingETBase::Types::constvec_t> momentumOverride;
334  ATH_CHECK( this->extractPFO(obj,constlist,constits,momentumOverride) );
335  MissingETComposition::insert(metMap,obj,constlist,momentumOverride);
336  }
337  }
338  } else {
339  std::vector<const IParticle*> tclist;
340  tclist.reserve(20);
341  ATH_CHECK( this->extractTopoClusters(obj,tclist,constits) );
342  if(m_useModifiedClus) {
343  for(const auto& cl : tclist) {
344  // use index-parallelism to identify shallow copied constituents
345  constlist.push_back((*constits.tcCont)[cl->index()]);
346  }
347  } else {
348  constlist = tclist;
349  }
350  if(m_useTracks) ATH_CHECK( this->extractTracks(obj,constlist,constits) );
351  MissingETComposition::insert(metMap,obj,constlist);
352  }
353  }
354  return StatusCode::SUCCESS;
355  }

◆ finalize()

StatusCode met::METEgammaAssociator::finalize ( )
inherited

Definition at line 75 of file METEgammaAssociator.cxx.

76  {
77  ATH_MSG_VERBOSE ("Finalizing " << name() << "...");
78  return StatusCode::SUCCESS;
79  }

◆ getKey()

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

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

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

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

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

Definition at line 119 of file AsgTool.cxx.

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

◆ getName()

const std::string & asg::AsgTool::getName ( const void *  ptr) const
inherited

Get the name of an object that is / should be in the event store.

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

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

See also
asg::AsgTool::getKey
Parameters
ptrThe bare pointer to the object that the event store should know about
Returns
The string name of the object in the store. If not found, an empty string.

Definition at line 106 of file AsgTool.cxx.

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

◆ getProperty()

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

Get one of the tool's properties.

◆ greaterPt()

static bool met::METAssociator::greaterPt ( const xAOD::IParticle *  part1,
const xAOD::IParticle *  part2 
)
inlinestaticprotectedinherited

Definition at line 144 of file METAssociator.h.

144  {
145  return part1->pt()>part2->pt();
146  }

◆ greaterPtFE()

static bool met::METAssociator::greaterPtFE ( const xAOD::FlowElement *  part1,
const xAOD::FlowElement *  part2 
)
inlinestaticprotectedinherited

Definition at line 153 of file METAssociator.h.

153  {
154  if (!(part1->isCharged()) && part2->isCharged()) return false;
155  if (part1->isCharged() && !(part2->isCharged())) return true;
156  return part1->pt() > part2->pt();
157  }

◆ greaterPtPFO()

static bool met::METAssociator::greaterPtPFO ( const xAOD::PFO *  part1,
const xAOD::PFO *  part2 
)
inlinestaticprotectedinherited

Definition at line 147 of file METAssociator.h.

147  {
148  if (part1->charge()==0 && part2->charge()!=0) return false;
149  if (part1->charge()!=0 && part2->charge()==0) return true;
150  if (part1->charge()==0 && part2->charge()==0) return part1->ptEM()>part2->ptEM();
151  return part1->pt()>part2->pt();
152  }

◆ hasUnmatchedClusters()

bool met::METEgammaAssociator::hasUnmatchedClusters ( const xAOD::Egamma *  eg,
const xAOD::PFO *  pfo 
) const
protectedinherited

Definition at line 568 of file METEgammaAssociator.cxx.

568  {
569 
570  bool has_unmatched=false;
571  float totSumpt=0;
572  float unmatchedSumpt=0;
573  float unmatchedE=0;
574  float unmatchedTotEMFrac=0;
575  double emfrac=0;
576 
577  static const SG::AuxElement::Decorator<Float_t> dec_unmatchedFrac("unmatchedFrac");
578  static const SG::AuxElement::Decorator<Float_t> dec_unmatchedFracSumpt("unmatchedFracSumpt");
579  static const SG::AuxElement::Decorator<Float_t> dec_unmatchedFracPt("unmatchedFracPt");
580  static const SG::AuxElement::Decorator<Float_t> dec_unmatchedFracE("unmatchedFracE");
581  static const SG::AuxElement::Decorator<Float_t> dec_unmatchedFracEClusterPFO("unmatchedFracEClusterPFO");
582  static const SG::AuxElement::Decorator<Float_t> dec_unmatchedFracPtClusterPFO("unmatchedFracPtClusterPFO");
583  static const SG::AuxElement::Decorator<Float_t> dec_unmatchedTotEMFrac("unmatchedTotEMFrac");
584 
585  TLorentzVector totVec(0.,0.,0.,0.), unmatchedVec(0.,0.,0.,0.);
586  const std::vector<const xAOD::CaloCluster*> egClusters = xAOD::EgammaHelpers::getAssociatedTopoClusters(eg->caloCluster());
587  std::set<const xAOD::CaloCluster*> cPFOClusters;
588  int nCluscPFO = pfo->nCaloCluster();
589 
590  for (int cl = 0; cl < nCluscPFO; ++cl) {
591  if (pfo->cluster(cl)) cPFOClusters.insert( pfo->cluster(cl) );
592  }
593 
594  std::vector<const xAOD::CaloCluster*> unmatchedClusters;
595  for (const xAOD::CaloCluster* pfoclus : cPFOClusters) {
596  TLorentzVector tmpVec;
597  tmpVec.SetPtEtaPhiE(pfoclus->pt(),pfoclus->eta(),pfoclus->phi(),pfoclus->e());
598  totSumpt+=pfoclus->pt();
599  totVec+=tmpVec;
600  bool inEgamma = false;
601  for (const xAOD::CaloCluster* phclus : egClusters) {
602  if (pfoclus == phclus) {
603  inEgamma = true;
604  }
605  }
606  if (!inEgamma) {
607  unmatchedClusters.push_back(pfoclus);
608  unmatchedSumpt+=pfoclus->pt();
609  unmatchedE+=pfoclus->e();
610  unmatchedVec+=tmpVec;
611  pfoclus->retrieveMoment(xAOD::CaloCluster::ENG_FRAC_EM ,emfrac);
612  unmatchedTotEMFrac=unmatchedTotEMFrac+emfrac*pfoclus->e();
613  }
614 
615  }
616 
617  ATH_MSG_DEBUG("PFO associated to "<<nCluscPFO<< " cluster, of which " << unmatchedClusters.size() << "unmatched one and unmatched pt "<<unmatchedSumpt);
618  dec_unmatchedFrac(*pfo)=nCluscPFO>0 ? float(unmatchedClusters.size())/float(nCluscPFO) : -1;
619  dec_unmatchedFracPt(*pfo)= totVec.Pt()>0 ? float(unmatchedVec.Pt()/totVec.Pt()): -1;
620  dec_unmatchedFracSumpt(*pfo)= totSumpt>0 ? float(unmatchedSumpt/totSumpt): -1;
621  dec_unmatchedFracE(*pfo)= totVec.E()>0 ? float(unmatchedE/totVec.E()): -1;
622  dec_unmatchedTotEMFrac(*pfo)= totVec.E()>0 ? float(unmatchedTotEMFrac/totVec.E()): -1;
623  dec_unmatchedFracEClusterPFO(*pfo)= pfo->e()>0 ? float(unmatchedE/pfo->e()): -1;
624  dec_unmatchedFracPtClusterPFO(*pfo)= pfo->pt()>0 ? float(unmatchedE/pfo->pt()): -1;
625 
626  return has_unmatched;
627  }

◆ initialize()

StatusCode met::METPhotonAssociator::initialize ( )
overridevirtual

Dummy implementation of the initialisation function.

It's here to allow the dual-use tools to skip defining an initialisation function. Since many are doing so...

Reimplemented from met::METEgammaAssociator.

Definition at line 37 of file METPhotonAssociator.cxx.

38  {
39  ATH_MSG_VERBOSE ("Initializing " << name() << "...");
40  ATH_CHECK( m_phContKey.initialize());
41  ATH_CHECK( METEgammaAssociator::initialize() );
42 
43 
44  if (m_usePFOLinks) {
45  if (m_photonNeutralPFOReadDecorKey.empty()) {ATH_CHECK( m_photonNeutralPFOReadDecorKey.assign(m_phContKey.key()+"."+m_neutralPFOLinksKey));}
46  if (m_photonChargedPFOReadDecorKey.empty()) {ATH_CHECK( m_photonChargedPFOReadDecorKey.assign(m_phContKey.key()+"."+m_chargedPFOLinksKey));}
47  ATH_CHECK(m_photonNeutralPFOReadDecorKey.initialize());
48  ATH_CHECK(m_photonChargedPFOReadDecorKey.initialize());
49 
50  }
51  if (m_useFELinks) {
52  if (m_photonNeutralFEReadDecorKey.empty()) {ATH_CHECK( m_photonNeutralFEReadDecorKey.assign(m_phContKey.key()+"."+m_neutralFELinksKey));}
53  if (m_photonChargedFEReadDecorKey.empty()) {ATH_CHECK( m_photonChargedFEReadDecorKey.assign(m_phContKey.key()+"."+m_chargedFELinksKey));}
54  ATH_CHECK(m_photonNeutralFEReadDecorKey.initialize());
55  ATH_CHECK(m_photonChargedFEReadDecorKey.initialize());
56  }
57  return StatusCode::SUCCESS;
58  }

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

◆ isGoodEoverP()

bool met::METAssociator::isGoodEoverP ( const xAOD::TrackParticle *  trk) const
protectedinherited

Definition at line 367 of file METAssociator.cxx.

368  {
369 
370  if( (fabs(trk->eta())<1.5 && trk->pt()>m_cenTrackPtThr) ||
371  (fabs(trk->eta())>=1.5 && trk->pt()>m_forTrackPtThr) ) {
372 
373  // Get relative error on qoverp
374  float Rerr = Amg::error(trk->definingParametersCovMatrix(),4)/fabs(trk->qOverP());
375  ATH_MSG_VERBOSE( "Track momentum error (%): " << Rerr*100 );
376 
377  // first compute track and calo isolation variables
378  float ptcone20 = 0., isolfrac = 0., etcone10 = 0., EoverP = 0.;
379  // ptcone
380  TrackIsolation trkIsoResult;
381  std::vector<Iso::IsolationType> trkIsoCones;
382  trkIsoCones.push_back(xAOD::Iso::IsolationType::ptcone20);
383  xAOD::TrackCorrection trkIsoCorr;
384  trkIsoCorr.trackbitset.set(xAOD::Iso::IsolationTrackCorrection::coreTrackPtr);
385  m_trkIsolationTool->trackIsolation(trkIsoResult,
386  *trk,
387  trkIsoCones,
388  trkIsoCorr);
389  ptcone20 = !trkIsoResult.ptcones.empty() ? trkIsoResult.ptcones[0] : 0;
390  isolfrac = ptcone20/trk->pt();
391  // etcone
392  CaloIsolation caloIsoResult;
393  std::vector<Iso::IsolationType> caloIsoCones;
394  // We can't actually configure the tool to give etcone10, so instead we have to compute etcone20,
395  // applying the core cone correction.
396  // Then, we retrieve the correction value, which is etcone10, rather than the isolation value
397  caloIsoCones.push_back(xAOD::Iso::IsolationType::etcone20);
398  xAOD::CaloCorrection caloIsoCorr_coreCone;
399  caloIsoCorr_coreCone.calobitset.set(xAOD::Iso::IsolationCaloCorrection::coreCone); // this is etcone10
400  m_caloIsolationTool->caloTopoClusterIsolation(caloIsoResult,
401  *trk,
402  caloIsoCones,
403  caloIsoCorr_coreCone);
404  if(!caloIsoResult.etcones.empty()) {
405  // retrieve the correction value for the core cone
406  etcone10 = caloIsoResult.coreCorrections[xAOD::Iso::IsolationCaloCorrection::coreCone][xAOD::Iso::IsolationCorrectionParameter::coreEnergy];
407  } else {
408  ATH_MSG_WARNING("isGoodEoverP: Failed to retrieve the isolation core correction (etcone10)! Setting etcone10=0");
409  etcone10 = 0.;
410  }
411  EoverP = etcone10/trk->pt();
413  ATH_MSG_VERBOSE( "Track isolation fraction: " << isolfrac );
414  ATH_MSG_VERBOSE( "Track E/P = " << EoverP );
415 
416  if(isolfrac<0.1) {
417  // isolated track cuts
418  if(Rerr>0.4) return false;
419  else if (EoverP<0.65 && ((EoverP>0.1 && Rerr>0.05) || Rerr>0.1)) return false;
420  } else {
421  // non-isolated track cuts
422  float trkptsum = ptcone20+trk->pt();
423  if(etcone10/trkptsum<0.6 && trk->pt()/trkptsum>0.6) return false;
424  }
425  }
426  return true;
427  }

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

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

◆ msg_level_name()

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

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

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

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

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

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

Definition at line 101 of file AsgTool.cxx.

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

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

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

◆ outputHandles()

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

Return this algorithm's output handles.

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

◆ print()

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

Print the state of the tool.

Implements asg::IAsgTool.

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

Definition at line 131 of file AsgTool.cxx.

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

◆ renounce()

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

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ retrieveConstituents()

StatusCode met::METAssociator::retrieveConstituents ( met::METAssociator::ConstitHolder &  constits) const
protectedinherited

Definition at line 161 of file METAssociator.cxx.

162  {
163  ATH_MSG_DEBUG ("In execute: " << name() << "...");
164  if (!m_skipconst || m_forcoll.empty()) {
165 
166  SG::ReadHandle<IParticleContainer> topoclusterCont(m_clcollKey);
167  if (!topoclusterCont.isValid()) {
168  ATH_MSG_WARNING("Unable to retrieve topocluster container " << m_clcollKey.key() << " for overlap removal");
169  return StatusCode::FAILURE;
170  }
171  constits.tcCont=topoclusterCont.cptr();
172  ATH_MSG_DEBUG("Successfully retrieved topocluster collection");
173  } else {
174  std::string hybridname = "Etmiss";
175  hybridname += m_clcollKey.key();
176  hybridname += m_foreta;
177  hybridname += m_forcoll;
178 
179  SG::ReadHandle<IParticleContainer> hybridCont(m_hybridContKey);
180  if( hybridCont.isValid()) {
181  constits.tcCont=hybridCont.cptr();
182  } else {
183  ATH_MSG_WARNING("Trying to do something currently unsupported- lets abort");
184  return StatusCode::FAILURE;
185  // Trying to do this using write handles (need to get some input here)
186  /*std::unique_ptr<ConstDataVector<IParticleContainer>> hybridCont = std::make_unique<ConstDataVector<IParticleContainer>>();
187  SG::WriteHandle<ConstDataVector<IParticleContainer>> hybridContHandle(hybridname);
188 
189  StatusCode sc = hybridContHandle.record(std::make_unique<ConstDataVector<IParticleContainer>>(*hybridCont));
190 
191  if (sc.isFailure()) {
192  ATH_MSG_WARNING("Unable to record container");
193  return StatusCode::SUCCESS;
194 
195  }*/
196 
197  /*SG::ReadHandle<IParticleContainer> centCont(m_clcoll);
198  if (!centCont.isValid()) {
199  ATH_MSG_WARNING("Unable to retrieve central container " << m_clcoll << " for overlap removal");
200  return StatusCode::FAILURE;
201  }
202 
203  SG::ReadHandle<IParticleContainer> forCont(m_forcoll);
204  if (!forCont.isValid()) {
205  ATH_MSG_WARNING("Unable to retrieve forward container " << m_forcoll << " for overlap removal");
206  return StatusCode::FAILURE;
207  }
208  ConstDataVector<IParticleContainer> *hybridCont = new ConstDataVector<IParticleContainer>(SG::VIEW_ELEMENTS);
209 
210  const IParticleContainer* centCont=0;
211  if( evtStore()->retrieve(centCont, m_clcoll).isFailure() ) {
212  ATH_MSG_WARNING("Unable to retrieve central container " << m_clcoll << " for overlap removal");
213  return StatusCode::FAILURE;
214  }
215 
216  const IParticleContainer* forCont=0;
217  if( evtStore()->retrieve(forCont, m_forcoll).isFailure() ) {
218  ATH_MSG_WARNING("Unable to retrieve forward container " << m_forcoll << " for overlap removal");
219  return StatusCode::FAILURE;
220  }
221 
222  for(const auto clus : *centCont) if (fabs(clus->eta())<m_foreta) hybridCont->push_back(clus);
223  for(const auto clus : *forCont) if (fabs(clus->eta())>=m_foreta) hybridCont->push_back(clus);
224  ATH_CHECK( evtStore()->record(hybridCont,hybridname));
225  constits.tcCont = hybridCont->asDataVector();
226  */
227  }
228  }
229 
230  if( !m_useTracks){
231  //if you want to skip tracks, set the track collection empty manually
232  ATH_MSG_DEBUG("Skipping tracks");
233  }else{
234  SG::ReadHandle<VertexContainer> vxCont(m_pvcollKey);
235  if (!vxCont.isValid()) {
236  ATH_MSG_WARNING("Unable to retrieve primary vertex container " << m_pvcollKey.key());
237  //this is actually really bad. If it's empty that's okay
238  return StatusCode::FAILURE;
239  }
240 
241  ATH_MSG_DEBUG("Successfully retrieved primary vertex container");
242  ATH_MSG_DEBUG("Container holds " << vxCont->size() << " vertices");
243 
244  for(const auto *const vx : *vxCont) {
245  ATH_MSG_VERBOSE( "Testing vertex " << vx->index() );
246  if(vx->vertexType()==VxType::PriVtx)
247  {constits.pv = vx; break;}
248  }
249  if(!constits.pv) {
250  ATH_MSG_DEBUG("Failed to find primary vertex! Reject all tracks.");
251  } else {
252  ATH_MSG_VERBOSE("Primary vertex has z = " << constits.pv->z());
253  }
254 
255  constits.trkCont=nullptr;
256  ATH_MSG_DEBUG("Retrieving Track collection " << m_trkcollKey.key());
257  SG::ReadHandle<TrackParticleContainer> trCont(m_trkcollKey);
258  if (!trCont.isValid()) {
259  ATH_MSG_WARNING("Unable to retrieve track particle container");
260  return StatusCode::FAILURE;
261  }
262  constits.trkCont=trCont.cptr();
263 
264  if(m_pflow){
265  if(!m_fecollKey.key().empty()){
266  ATH_MSG_DEBUG("Retrieving FlowElement collection " << m_fecollKey.key());
267  constits.feCont = nullptr;
268  SG::ReadHandle<xAOD::FlowElementContainer> feCont(m_fecollKey);
269  if (!feCont.isValid()) {
270  ATH_MSG_ERROR("Unable to retrieve FlowElement container "<< m_fecollKey.key());
271  return StatusCode::FAILURE;
272  }
273  constits.feCont=feCont.cptr();
274  }
275  else{
276  ATH_MSG_DEBUG("Retrieving PFlow collection " << m_pfcollKey.key());
277  constits.pfoCont = nullptr;
278  SG::ReadHandle<PFOContainer> pfCont(m_pfcollKey);
279  if (!pfCont.isValid()) {
280  ATH_MSG_WARNING("Unable to PFlow object container");
281  return StatusCode::FAILURE;
282  }
283  constits.pfoCont=pfCont.cptr();
284  }
285  }//pflow
286  }//retrieve track/pfo containers
287 
288  return StatusCode::SUCCESS;
289  }

◆ selectEgammaClusters()

StatusCode met::METEgammaAssociator::selectEgammaClusters ( const xAOD::CaloCluster *  swclus,
const std::vector< const xAOD::IParticle * > &  inputTC,
std::vector< const xAOD::IParticle * > &  tclist 
) const
protectedinherited

Definition at line 471 of file METEgammaAssociator.cxx.

474  {
475  double eg_cl_e = swclus->e();
476 
477  bool doSum = true;
478  double sumE_tc = 0.;
479  const IParticle* bestbadmatch = nullptr;
480  for(const auto& cl : inputTC) {
481  double tcl_e = cl->e();
482  // skip cluster if it's above our bad match threshold
483  // retain pointer of the closest matching cluster in case no better is found
484  if(tcl_e>m_tcMatch_maxRat*eg_cl_e) {
485  ATH_MSG_VERBOSE("Reject topocluster in sum. Ratio vs eg cluster: " << (tcl_e/eg_cl_e));
486  if( !bestbadmatch || (fabs(tcl_e/eg_cl_e-1.) < fabs(bestbadmatch->e()/eg_cl_e-1.)) ) bestbadmatch = cl;
487  continue;
488  }
489 
490  ATH_MSG_VERBOSE("E match with new cluster: " << fabs(sumE_tc+tcl_e - eg_cl_e) / eg_cl_e);
491  if( (doSum = (fabs(sumE_tc+tcl_e - eg_cl_e) < fabs(sumE_tc - eg_cl_e))) ) {
492  ATH_MSG_VERBOSE("Accept topocluster with pt " << cl->pt() << ", e " << cl->e() << " in sum.");
493  ATH_MSG_VERBOSE("Energy ratio of nPFO to eg: " << tcl_e / eg_cl_e);
494  ATH_MSG_VERBOSE("E match with new cluster: " << fabs(sumE_tc+tcl_e - eg_cl_e) / eg_cl_e);
495  tclist.push_back(cl);
496  sumE_tc += tcl_e;
497  } // if we will retain the topocluster
498  } // loop over nearby clusters
499  if(sumE_tc<FLT_MIN && bestbadmatch) {
500  ATH_MSG_VERBOSE("No better matches found -- add bad match topocluster with pt "
501  << bestbadmatch->pt() << ", e " << bestbadmatch->e() << ".");
502  tclist.push_back(bestbadmatch);
503  }
504  return StatusCode::SUCCESS;
505  }

◆ selectEgammaTracks()

StatusCode met::METEgammaAssociator::selectEgammaTracks ( const xAOD::Egamma *  el,
const xAOD::TrackParticleContainer *  trkCont,
std::set< const xAOD::TrackParticle * > &  tracklist 
) const
protectedinherited

Definition at line 507 of file METEgammaAssociator.cxx.

510  {
511  // switch to using egamma helpers for track extraction
512  // set ensures that there's no duplication
513  const std::set<const xAOD::TrackParticle*> egtracks = EgammaHelpers::getTrackParticles(eg);
514  for(const auto& track : egtracks) {
515  ATH_MSG_VERBOSE("Accept " << eg->type() << " track " << track << " px, py = " << track->p4().Px() << ", " << track->p4().Py());
516  tracklist.insert(track);
517  } // end initial egamma track loop
518 
519  // for objects with ambiguous author, grab the tracks matched to the counterpart ambiguous object too
520  // set ensures that there's no duplication
521  if (eg->author() & xAOD::EgammaParameters::AuthorAmbiguous && eg->ambiguousObject()) {
522  const std::set<const xAOD::TrackParticle*> ambitracks = EgammaHelpers::getTrackParticles(eg->ambiguousObject());
523  for(const auto& track : egtracks) {
524  ATH_MSG_VERBOSE("Accept ambiguous " << eg->type() << " track " << track << " px, py = " << track->p4().Px() << ", " << track->p4().Py());
525  tracklist.insert(track);
526  }
527  } // end ambiguous track case
528 
529  // in a small dR window, also accept tracks without an IBL hit
530  for(const auto *const track : *trkCont) {
531  if(P4Helpers::isInDeltaR(*track, *eg, m_extraTrkMatch_dR, m_useRapidity)) {
532  // dR check should be faster than track summary retrieval
533  uint8_t expect_innermostHit(false);
534  uint8_t N_innermostHit(false);
535  uint8_t expect_nextToInnermostHit(false);
536  uint8_t N_nextToInnermostHit(false);
537  if( !track->summaryValue(expect_innermostHit, expectInnermostPixelLayerHit)
538  || !track->summaryValue(expect_nextToInnermostHit, expectNextToInnermostPixelLayerHit)) {
539  ATH_MSG_WARNING("Track summary retrieval failed for 'expect(NextTo)InnermostPixelLayerHit'");
540  return StatusCode::FAILURE;
541  }
542  if(expect_innermostHit) {
543  if( !track->summaryValue(N_innermostHit, numberOfInnermostPixelLayerHits) ) {
544  ATH_MSG_WARNING("Track summary retrieval failed for 'numberOfInnermostPixelLayerHits'");
545  return StatusCode::FAILURE;
546  if(N_innermostHit==0 ) {
547  ATH_MSG_VERBOSE("Accept nearby track w/o innermost hit");
548  tracklist.insert(track);
549  }
550  }
551  } else if(expect_nextToInnermostHit) {
552  if( !track->summaryValue(N_nextToInnermostHit, numberOfNextToInnermostPixelLayerHits) ) {
553  ATH_MSG_WARNING("Track summary retrieval failed for 'numberOfNextToInnermostPixelLayerHits'");
554  return StatusCode::FAILURE;
555  if(N_nextToInnermostHit==0 ) {
556  ATH_MSG_VERBOSE("Accept nearby track w/o next-to-innermost hit");
557  tracklist.insert(track);
558  }
559  }
560  }
561 
562  } // end dR check
563  } // end extra track loop
564  return StatusCode::SUCCESS;
565  }

◆ sysInitialize()

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

Perform system initialization for an algorithm.

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

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

◆ sysStart()

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

Handle START transition.

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

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

◆ m_caloIsolationTool

ToolHandle<xAOD::ICaloTopoClusterIsolationTool> met::METAssociator::m_caloIsolationTool
protectedinherited

Definition at line 87 of file METAssociator.h.

◆ m_cenTrackPtThr

double met::METAssociator::m_cenTrackPtThr
protectedinherited

Definition at line 115 of file METAssociator.h.

◆ m_chargedFELinksKey

std::string met::METAssociator::m_chargedFELinksKey
protectedinherited

Definition at line 90 of file METAssociator.h.

◆ m_chargedPFOLinksKey

std::string met::METAssociator::m_chargedPFOLinksKey
protectedinherited

Definition at line 92 of file METAssociator.h.

◆ m_checkUnmatched

bool met::METEgammaAssociator::m_checkUnmatched
protectedinherited

Definition at line 114 of file METEgammaAssociator.h.

◆ m_clcollKey

SG::ReadHandleKey<xAOD::IParticleContainer> met::METAssociator::m_clcollKey {this,"ClusColl","CaloCalTopoClusters","Topo cluster Collection"}
protectedinherited

Definition at line 97 of file METAssociator.h.

◆ m_cleanChargedPFO

bool met::METAssociator::m_cleanChargedPFO
protectedinherited

Definition at line 109 of file METAssociator.h.

◆ m_detStore

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

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_electronChargedFEReadDecorKey

SG::ReadDecorHandleKey<xAOD::ElectronContainer> met::METEgammaAssociator::m_electronChargedFEReadDecorKey {this,"electronCargedFEReadDecorKey","", "Charged FE links key"}
protectedinherited

Definition at line 112 of file METEgammaAssociator.h.

◆ m_electronChargedPFOReadDecorKey

SG::ReadDecorHandleKey<xAOD::ElectronContainer> met::METEgammaAssociator::m_electronChargedPFOReadDecorKey {this,"electronCargedPFOReadDecorKey","", "Charged PFO links key"}
protectedinherited

Definition at line 110 of file METEgammaAssociator.h.

◆ m_electronNeutralFEReadDecorKey

SG::ReadDecorHandleKey<xAOD::ElectronContainer> met::METEgammaAssociator::m_electronNeutralFEReadDecorKey {this,"electronNeutralFEReadDecorKey","", "Neutral FE links key"}
protectedinherited

Definition at line 111 of file METEgammaAssociator.h.

◆ m_electronNeutralPFOReadDecorKey

SG::ReadDecorHandleKey<xAOD::ElectronContainer> met::METEgammaAssociator::m_electronNeutralPFOReadDecorKey {this,"electronNeutralPFOReadDecorKey","", "Neutral PFO links key"}
protectedinherited

Definition at line 109 of file METEgammaAssociator.h.

◆ m_evtStore

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

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extraTrkMatch_dR

double met::METEgammaAssociator::m_extraTrkMatch_dR
protectedinherited

Definition at line 102 of file METEgammaAssociator.h.

◆ m_fecollKey

SG::ReadHandleKey<xAOD::FlowElementContainer> met::METAssociator::m_fecollKey {this,"FlowElementCollection","","FlowElement Collection (overrides PFO if not empty)"}
protectedinherited

Definition at line 100 of file METAssociator.h.

◆ m_forcoll

std::string met::METAssociator::m_forcoll
protectedinherited

Definition at line 112 of file METAssociator.h.

◆ m_foreta

double met::METAssociator::m_foreta
protectedinherited

Definition at line 113 of file METAssociator.h.

◆ m_forTrackPtThr

double met::METAssociator::m_forTrackPtThr
protectedinherited

Definition at line 116 of file METAssociator.h.

◆ m_hybridContKey

SG::ReadHandleKey<xAOD::IParticleContainer> met::METAssociator::m_hybridContKey {this,"HybridKey","","Hybrid Collection"}
protectedinherited

Definition at line 101 of file METAssociator.h.

◆ m_neutralFELinksKey

std::string met::METAssociator::m_neutralFELinksKey
protectedinherited

Definition at line 89 of file METAssociator.h.

◆ m_neutralPFOLinksKey

std::string met::METAssociator::m_neutralPFOLinksKey
protectedinherited

Definition at line 91 of file METAssociator.h.

◆ m_pfcollKey

SG::ReadHandleKey<xAOD::PFOContainer> met::METAssociator::m_pfcollKey {this,"PFlowColl","","PFO Collection"}
protectedinherited

Definition at line 99 of file METAssociator.h.

◆ m_pflow

bool met::METAssociator::m_pflow
protectedinherited

Definition at line 103 of file METAssociator.h.

◆ m_phContKey

SG::ReadHandleKey<xAOD::PhotonContainer> met::METPhotonAssociator::m_phContKey {this, "InputCollection", "Photons", "photons input key"}
private

Definition at line 57 of file METPhotonAssociator.h.

◆ m_photonChargedFEReadDecorKey

SG::ReadDecorHandleKey<xAOD::PhotonContainer> met::METEgammaAssociator::m_photonChargedFEReadDecorKey {this,"photonChargedFEReadDecorKey","", "Charged FE links key"}
protectedinherited

Definition at line 107 of file METEgammaAssociator.h.

◆ m_photonChargedPFOReadDecorKey

SG::ReadDecorHandleKey<xAOD::PhotonContainer> met::METEgammaAssociator::m_photonChargedPFOReadDecorKey {this,"photonChargedPFOReadDecorKey","", "Charged PFO links key"}
protectedinherited

Definition at line 105 of file METEgammaAssociator.h.

◆ m_photonNeutralFEReadDecorKey

SG::ReadDecorHandleKey<xAOD::PhotonContainer> met::METEgammaAssociator::m_photonNeutralFEReadDecorKey {this,"photonNeutralFEReadDecorKey","", "Neutral FE links key"}
protectedinherited

Definition at line 106 of file METEgammaAssociator.h.

◆ m_photonNeutralPFOReadDecorKey

SG::ReadDecorHandleKey<xAOD::PhotonContainer> met::METEgammaAssociator::m_photonNeutralPFOReadDecorKey {this,"photonNeutralPFOReadDecorKey","", "Neutral PFO links key"}
protectedinherited

Definition at line 104 of file METEgammaAssociator.h.

◆ m_pvcollKey

SG::ReadHandleKey<xAOD::VertexContainer> met::METAssociator::m_pvcollKey {this,"PrimVxColl","PrimaryVertices","Primary Vertex Collection"}
protectedinherited

Definition at line 96 of file METAssociator.h.

◆ m_skipconst

bool met::METAssociator::m_skipconst
protectedinherited

Definition at line 111 of file METAssociator.h.

◆ m_tcMatch_dR

double met::METEgammaAssociator::m_tcMatch_dR
protectedinherited

Definition at line 98 of file METEgammaAssociator.h.

◆ m_tcMatch_maxRat

double met::METEgammaAssociator::m_tcMatch_maxRat
protectedinherited

Definition at line 99 of file METEgammaAssociator.h.

◆ m_tcMatch_method

unsigned short met::METEgammaAssociator::m_tcMatch_method
protectedinherited

Definition at line 100 of file METEgammaAssociator.h.

◆ m_trkcollKey

SG::ReadHandleKey<xAOD::TrackParticleContainer> met::METAssociator::m_trkcollKey {this,"TrkColl","InDetTrackParticles","Track particle Collection"}
protectedinherited

Definition at line 98 of file METAssociator.h.

◆ m_trkIsolationTool

ToolHandle<xAOD::ITrackIsolationTool> met::METAssociator::m_trkIsolationTool
protectedinherited

Definition at line 86 of file METAssociator.h.

◆ m_trkseltool

ToolHandle<InDet::IInDetTrackSelectionTool> met::METAssociator::m_trkseltool
protectedinherited

Definition at line 85 of file METAssociator.h.

◆ m_useFELinks

bool met::METAssociator::m_useFELinks
protectedinherited

Definition at line 94 of file METAssociator.h.

◆ m_useIsolationTools

bool met::METAssociator::m_useIsolationTools = false
protectedinherited

Definition at line 106 of file METAssociator.h.

◆ m_useModifiedClus

bool met::METAssociator::m_useModifiedClus
protectedinherited

Definition at line 107 of file METAssociator.h.

◆ m_usePFOLinks

bool met::METAssociator::m_usePFOLinks
protectedinherited

Definition at line 93 of file METAssociator.h.

◆ m_useRapidity

bool met::METAssociator::m_useRapidity
protectedinherited

Definition at line 105 of file METAssociator.h.

◆ m_useTracks

bool met::METAssociator::m_useTracks
protectedinherited

Definition at line 104 of file METAssociator.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ m_weight_charged_pfo

bool met::METAssociator::m_weight_charged_pfo = false
protectedinherited

Definition at line 108 of file METAssociator.h.

The documentation for this class was generated from the following files:
met::METAssociator::m_forcoll
std::string m_forcoll
Definition: METAssociator.h:112
met::METAssociator::greaterPt
static bool greaterPt(const xAOD::IParticle *part1, const xAOD::IParticle *part2)
Definition: METAssociator.h:144
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:73
met::METAssociator::m_neutralPFOLinksKey
std::string m_neutralPFOLinksKey
Definition: METAssociator.h:91
met::METAssociator::m_useModifiedClus
bool m_useModifiedClus
Definition: METAssociator.h:107
met::METAssociator::m_foreta
double m_foreta
Definition: METAssociator.h:113
met::METEgammaAssociator::m_checkUnmatched
bool m_checkUnmatched
Definition: METEgammaAssociator.h:114
xAOD::Electron
Electron_v1 Electron
Definition of the current "egamma version".
Definition: Event/xAOD/xAODEgamma/xAODEgamma/Electron.h:17
met::METAssociator::extractFE
virtual StatusCode extractFE(const xAOD::IParticle *obj, std::vector< const xAOD::IParticle * > &felist, const met::METAssociator::ConstitHolder &constits, std::map< const xAOD::IParticle *, MissingETBase::Types::constvec_t > &momenta) const =0
xAOD::EgammaHelpers::getAssociatedTopoClusters
std::vector< const xAOD::CaloCluster * > getAssociatedTopoClusters(const xAOD::CaloCluster *cluster)
Return a vector of all the topo clusters associated with the egamma cluster.
Definition: EgammaxAODHelpers.cxx:65
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:392
xAOD::PFO_v1::pt
virtual double pt() const
The transverse momentum ( ) of the particle.
Definition: PFO_v1.cxx:52
xAOD::TrackCorrection
Definition: IsolationCommon.h:18
met::METEgammaAssociator::m_tcMatch_maxRat
double m_tcMatch_maxRat
Definition: METEgammaAssociator.h:99
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::Iso::coreEnergy
@ coreEnergy
energy stored for this correction
Definition: Event/xAOD/xAODPrimitives/xAODPrimitives/IsolationCorrection.h:93
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:557
ParticleTest.eg
eg
Definition: ParticleTest.py:29
met::METAssociator::m_useFELinks
bool m_useFELinks
Definition: METAssociator.h:94
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
Egamma
Definition: ClusMomentumPlots.cxx:11
xAOD::TrackParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: TrackParticle_v1.cxx:77
xAOD::Iso::coreTrackPtr
@ coreTrackPtr
tracks pointer
Definition: Event/xAOD/xAODPrimitives/xAODPrimitives/IsolationCorrection.h:66
met::DeltaR
@ DeltaR
Definition: METRecoCommon.h:11
met::METAssociator::m_forTrackPtThr
double m_forTrackPtThr
Definition: METAssociator.h:116
met::METEgammaAssociator::m_tcMatch_method
unsigned short m_tcMatch_method
Definition: METEgammaAssociator.h:100
met::METAssociator::retrieveConstituents
StatusCode retrieveConstituents(met::METAssociator::ConstitHolder &constits) const
Definition: METAssociator.cxx:161
met::METAssociator::m_trkcollKey
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_trkcollKey
Definition: METAssociator.h:98
xAOD::TrackCorrection::trackbitset
Iso::IsolationTrackCorrectionBitset trackbitset
Definition: IsolationCommon.h:19
met::METAssociator::m_trkseltool
ToolHandle< InDet::IInDetTrackSelectionTool > m_trkseltool
Definition: METAssociator.h:85
test_pyathena.pt
pt
Definition: test_pyathena.py:11
xAOD::Iso::ptcone20
@ ptcone20
Track isolation.
Definition: IsolationType.h:40
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
met::METEgammaAssociator::initialize
StatusCode initialize()
Dummy implementation of the initialisation function.
Definition: METEgammaAssociator.cxx:60
met::METAssociator::m_clcollKey
SG::ReadHandleKey< xAOD::IParticleContainer > m_clcollKey
Definition: METAssociator.h:97
met::METAssociator::ConstitHolder::pfoCont
const xAOD::PFOContainer * pfoCont
Definition: METAssociator.h:66
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::expectInnermostPixelLayerHit
@ expectInnermostPixelLayerHit
Do we expect a 0th-layer barrel hit for this track?
Definition: TrackingPrimitives.h:236
met::METAssociator::ConstitHolder::feCont
const xAOD::FlowElementContainer * feCont
Definition: METAssociator.h:67
xAOD::Egamma_v1
Definition: Egamma_v1.h:56
met::METAssociator::m_pfcollKey
SG::ReadHandleKey< xAOD::PFOContainer > m_pfcollKey
Definition: METAssociator.h:99
SG::ConstAccessor
Helper class to provide constant type-safe access to aux data.
Definition: ConstAccessor.h:55
xAOD::FlowElement_v1::pt
virtual double pt() const override
met::METAssociator::m_chargedPFOLinksKey
std::string m_chargedPFOLinksKey
Definition: METAssociator.h:92
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
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
P4Helpers::isInDeltaR
bool isInDeltaR(const I4Momentum &p1, const I4Momentum &p2, double dR)
Check if 2 I4Momentum are in a cone.
Definition: P4Helpers.h:236
xAOD::IParticle
Class providing the definition of the 4-vector interface.
Definition: Event/xAOD/xAODBase/xAODBase/IParticle.h:41
met::METAssociator::m_useRapidity
bool m_useRapidity
Definition: METAssociator.h:105
met::METAssociator::extractTracks
virtual StatusCode extractTracks(const xAOD::IParticle *obj, std::vector< const xAOD::IParticle * > &constlist, const met::METAssociator::ConstitHolder &constits) const =0
met::METAssociator::m_fecollKey
SG::ReadHandleKey< xAOD::FlowElementContainer > m_fecollKey
Definition: METAssociator.h:100
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
met::METEgammaAssociator::METEgammaAssociator
METEgammaAssociator()
Default constructor:
met::METAssociator::METAssociator
METAssociator()
met::METEgammaAssociator::m_tcMatch_dR
double m_tcMatch_dR
Definition: METEgammaAssociator.h:98
met::METPhotonAssociator::m_phContKey
SG::ReadHandleKey< xAOD::PhotonContainer > m_phContKey
Definition: METPhotonAssociator.h:57
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:27
met::METAssociator::m_useTracks
bool m_useTracks
Definition: METAssociator.h:104
xAOD::FlowElement_v1::PFlow
@ PFlow
Definition: FlowElement_v1.h:45
met::METAssociator::m_pvcollKey
SG::ReadHandleKey< xAOD::VertexContainer > m_pvcollKey
Definition: METAssociator.h:96
met::METEgammaAssociator::extractFEs
StatusCode extractFEs(const xAOD::Egamma *eg, std::vector< const xAOD::IParticle * > &felist, const met::METAssociator::ConstitHolder &constits) const
Definition: METEgammaAssociator.cxx:384
met::METAssociator::m_cenTrackPtThr
double m_cenTrackPtThr
Definition: METAssociator.h:115
met::METAssociator::ConstitHolder::pv
const xAOD::Vertex * pv
Definition: METAssociator.h:68
xAOD::PFO_v1::e
virtual double e() const
The total energy of the particle.
Definition: PFO_v1.cxx:81
xAOD::FlowElement_v1::isCharged
bool isCharged() const
Definition: FlowElement_v1.cxx:56
met::METEgammaAssociator::selectEgammaTracks
StatusCode selectEgammaTracks(const xAOD::Egamma *el, const xAOD::TrackParticleContainer *trkCont, std::set< const xAOD::TrackParticle * > &tracklist) const
Definition: METEgammaAssociator.cxx:507
part1
Definition: part1.py:1
xAOD::MissingETComposition::insert
static bool insert(MissingETComponentMap *pMap, const MissingET *pMET, const IParticle *pPart, MissingETBase::Types::weight_t weight=MissingETBase::Types::weight_t())
Insert contributing signal or physics object by pointer, with optional kinematic weight object.
Definition: Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx:42
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
met::METAssociator::ConstitHolder::tcCont
const xAOD::IParticleContainer * tcCont
Definition: METAssociator.h:65
asg::AsgTool::AsgTool
AsgTool(const std::string &name)
Constructor specifying the tool instance's name.
Definition: AsgTool.cxx:58
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:59
xAOD::CaloIsolation
Definition: IsolationCommon.h:22
met::METEgammaAssociator::extractFEsFromLinks
StatusCode extractFEsFromLinks(const xAOD::Egamma *eg, std::vector< const xAOD::IParticle * > &felist, const met::METAssociator::ConstitHolder &constits) const
Definition: METEgammaAssociator.cxx:320
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
xAOD::expectNextToInnermostPixelLayerHit
@ expectNextToInnermostPixelLayerHit
Do we expect a 1st-layer barrel hit for this track?
Definition: TrackingPrimitives.h:247
xAOD::PFO_v1::nCaloCluster
unsigned int nCaloCluster() const
Find out how many CaloCluster are linked.
Definition: PFO_v1.cxx:659
met::METAssociator::m_trkIsolationTool
ToolHandle< xAOD::ITrackIsolationTool > m_trkIsolationTool
Definition: METAssociator.h:86
CheckAppliedSFs.e3
e3
Definition: CheckAppliedSFs.py:264
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
met::METEgammaAssociator::m_photonNeutralFEReadDecorKey
SG::ReadDecorHandleKey< xAOD::PhotonContainer > m_photonNeutralFEReadDecorKey
Definition: METEgammaAssociator.h:106
met::METEgammaAssociator::m_photonNeutralPFOReadDecorKey
SG::ReadDecorHandleKey< xAOD::PhotonContainer > m_photonNeutralPFOReadDecorKey
Definition: METEgammaAssociator.h:104
met::METEgammaAssociator::extractPFOsFromLinks
StatusCode extractPFOsFromLinks(const xAOD::Egamma *eg, std::vector< const xAOD::IParticle * > &pfolist, const met::METAssociator::ConstitHolder &constits) const
Definition: METEgammaAssociator.cxx:162
xAOD::EgammaParameters::AuthorAmbiguous
const uint16_t AuthorAmbiguous
Object Reconstructed by standard cluster-based algorithm.
Definition: EgammaDefs.h:32
xAOD::Iso::etcone20
@ etcone20
Calorimeter isolation.
Definition: IsolationType.h:32
met::METAssociator::greaterPtPFO
static bool greaterPtPFO(const xAOD::PFO *part1, const xAOD::PFO *part2)
Definition: METAssociator.h:147
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
xAOD::CaloIsolation::coreCorrections
std::map< Iso::IsolationCaloCorrection, std::map< Iso::IsolationCorrectionParameter, float > > coreCorrections
Definition: IsolationCommon.h:26
met::ClusterLink
@ ClusterLink
Definition: METRecoCommon.h:12
xAOD::VxType::PriVtx
@ PriVtx
Primary vertex.
Definition: TrackingPrimitives.h:571
xAOD::FlowElement_v1::signalType
signal_t signalType() const
met::METAssociator::m_neutralFELinksKey
std::string m_neutralFELinksKey
Definition: METAssociator.h:89
plotIsoValidation.el
el
Definition: plotIsoValidation.py:197
CaloCluster
Principal data class for CaloCell clusters.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloCluster.h:79
met::METAssociator::extractPFO
virtual StatusCode extractPFO(const xAOD::IParticle *obj, std::vector< const xAOD::IParticle * > &pfolist, const met::METAssociator::ConstitHolder &constits, std::map< const xAOD::IParticle *, MissingETBase::Types::constvec_t > &momenta) const =0
met::METAssociator::m_chargedFELinksKey
std::string m_chargedFELinksKey
Definition: METAssociator.h:90
python.xAODType.dummy
dummy
Definition: xAODType.py:4
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
MSG::name
const std::string & name(Level lvl)
Convenience function for translating message levels to strings.
Definition: MsgLevel.cxx:19
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
xAOD::Vertex_v1::z
float z() const
Returns the z position.
SG::AuxElement::index
size_t index() const
Return the index of this element within its container.
met::METEgammaAssociator::m_electronNeutralFEReadDecorKey
SG::ReadDecorHandleKey< xAOD::ElectronContainer > m_electronNeutralFEReadDecorKey
Definition: METEgammaAssociator.h:111
met::METEgammaAssociator::m_electronNeutralPFOReadDecorKey
SG::ReadDecorHandleKey< xAOD::ElectronContainer > m_electronNeutralPFOReadDecorKey
Definition: METEgammaAssociator.h:109
part2
Definition: part2.py:1
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
xAOD::IParticle::pt
virtual double pt() const =0
The transverse momentum ( ) of the particle.
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
xAOD::TrackIsolation
Definition: IsolationCommon.h:33
xAOD::FlowElement_v1::chargedObject
const xAOD::IParticle * chargedObject(std::size_t i) const
Definition: FlowElement_v1.cxx:127
xAOD::numberOfNextToInnermostPixelLayerHits
@ numberOfNextToInnermostPixelLayerHits
these are the hits in the 1st pixel barrel layer
Definition: TrackingPrimitives.h:248
xAOD::TrackParticle_v1::qOverP
float qOverP() const
Returns the parameter.
xAOD::CaloCluster_v1::ENG_FRAC_EM
@ ENG_FRAC_EM
Energy fraction in EM calorimeters.
Definition: CaloCluster_v1.h:139
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
met::METEgammaAssociator::m_electronChargedFEReadDecorKey
SG::ReadDecorHandleKey< xAOD::ElectronContainer > m_electronChargedFEReadDecorKey
Definition: METEgammaAssociator.h:112
xAOD::PFO_v1::eEM
virtual double eEM() const
get EM scale energy
Definition: PFO_v1.cxx:233
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
xAOD::PFO_v1
Class describing a particle flow object.
Definition: PFO_v1.h:35
ANA_MSG_VERBOSE
#define ANA_MSG_VERBOSE(xmsg)
Macro printing verbose messages.
Definition: Control/AthToolSupport/AsgMessaging/AsgMessaging/MessageCheck.h:286
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
Amg::error
double error(const Amg::MatrixX &mat, int index)
return diagonal error of the matrix caller should ensure the matrix is symmetric and the index is in ...
Definition: EventPrimitivesHelpers.h:40
xAOD::FlowElement_v1::e
virtual double e() const override
The total energy of the particle.
Definition: FlowElement_v1.cxx:25
xAOD::CaloIsolation::etcones
std::vector< float > etcones
Definition: IsolationCommon.h:30
xAOD::Iso::coreCone
@ coreCone
core energy (in dR<0.1).
Definition: Event/xAOD/xAODPrimitives/xAODPrimitives/IsolationCorrection.h:29
met::METAssociator::isGoodEoverP
bool isGoodEoverP(const xAOD::TrackParticle *trk) const
Definition: METAssociator.cxx:367
met::METAssociator::acceptTrack
bool acceptTrack(const xAOD::TrackParticle *trk, const xAOD::Vertex *pv) const
Definition: METAssociator.cxx:359
met::METEgammaAssociator::extractPFOs
StatusCode extractPFOs(const xAOD::Egamma *eg, std::vector< const xAOD::IParticle * > &pfolist, const met::METAssociator::ConstitHolder &constits) const
Definition: METEgammaAssociator.cxx:226
xAOD::Photon
Photon_v1 Photon
Definition of the current "egamma version".
Definition: Event/xAOD/xAODEgamma/xAODEgamma/Photon.h:17
xAOD::TrackIsolation::ptcones
std::vector< float > ptcones
Definition: IsolationCommon.h:36
Muon
struct TBPatternUnitContext Muon
met::METAssociator::fillAssocMap
virtual StatusCode fillAssocMap(xAOD::MissingETAssociationMap *metMap, const xAOD::IParticleContainer *hardObjs) const
Definition: METAssociator.cxx:295
met::METEgammaAssociator::hasUnmatchedClusters
bool hasUnmatchedClusters(const xAOD::Egamma *eg, const xAOD::PFO *pfo) const
Definition: METEgammaAssociator.cxx:568
met::METAssociator::executeTool
virtual StatusCode executeTool(xAOD::MissingETContainer *metCont, xAOD::MissingETAssociationMap *metMap) const =0
a
TList * a
Definition: liststreamerinfos.cxx:10
h
met::METEgammaAssociator::m_extraTrkMatch_dR
double m_extraTrkMatch_dR
Definition: METEgammaAssociator.h:102
met::METAssociator::m_hybridContKey
SG::ReadHandleKey< xAOD::IParticleContainer > m_hybridContKey
Definition: METAssociator.h:101
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::CaloCorrection
Definition: IsolationCommon.h:14
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
met::METAssociator::m_pflow
bool m_pflow
Definition: METAssociator.h:103
met::METAssociator::m_usePFOLinks
bool m_usePFOLinks
Definition: METAssociator.h:93
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
xAOD::PFO_v1::cluster
const CaloCluster * cluster(unsigned int index) const
Retrieve a const pointer to a CaloCluster.
Definition: PFO_v1.cxx:669
met::METAssociator::m_skipconst
bool m_skipconst
Definition: METAssociator.h:111
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
met::METEgammaAssociator::m_photonChargedFEReadDecorKey
SG::ReadDecorHandleKey< xAOD::PhotonContainer > m_photonChargedFEReadDecorKey
Definition: METEgammaAssociator.h:107
AllowedVariables::EoverP
@ EoverP
Definition: AsgElectronSelectorTool.cxx:56
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
met::METAssociator::ConstitHolder::trkCont
const xAOD::TrackParticleContainer * trkCont
Definition: METAssociator.h:63
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
met::METEgammaAssociator::selectEgammaClusters
StatusCode selectEgammaClusters(const xAOD::CaloCluster *swclus, const std::vector< const xAOD::IParticle * > &inputTC, std::vector< const xAOD::IParticle * > &tclist) const
Definition: METEgammaAssociator.cxx:471
met::METAssociator::greaterPtFE
static bool greaterPtFE(const xAOD::FlowElement *part1, const xAOD::FlowElement *part2)
Definition: METAssociator.h:153
met::METEgammaAssociator::m_electronChargedPFOReadDecorKey
SG::ReadDecorHandleKey< xAOD::ElectronContainer > m_electronChargedPFOReadDecorKey
Definition: METEgammaAssociator.h:110
python.PyAthena.obj
obj
Definition: PyAthena.py:132
met::METAssociator::m_cleanChargedPFO
bool m_cleanChargedPFO
Definition: METAssociator.h:109
SG::DataProxy
Definition: DataProxy.h:44
python.Dumpers.etcone10
int etcone10
Definition: Dumpers.py:41
dq_make_web_display.cl
cl
print [x.__class__ for x in toList(dqregion.getSubRegions()) ]
Definition: dq_make_web_display.py:26
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
xAOD::CaloCluster_v1::e
virtual double e() const
The total energy of the particle.
Definition: CaloCluster_v1.cxx:265
readCCLHist.float
float
Definition: readCCLHist.py:83
met::METAssociator::extractTopoClusters
virtual StatusCode extractTopoClusters(const xAOD::IParticle *obj, std::vector< const xAOD::IParticle * > &tclist, const met::METAssociator::ConstitHolder &constits) const =0
xAOD::CaloCorrection::calobitset
Iso::IsolationCaloCorrectionBitset calobitset
Definition: IsolationCommon.h:15
xAOD::IParticle::e
virtual double e() const =0
The total energy of the particle.
fitman.k
k
Definition: fitman.py:528
xAOD::numberOfInnermostPixelLayerHits
@ numberOfInnermostPixelLayerHits
these are the hits in the 0th pixel barrel layer
Definition: TrackingPrimitives.h:237
met::METEgammaAssociator::m_photonChargedPFOReadDecorKey
SG::ReadDecorHandleKey< xAOD::PhotonContainer > m_photonChargedPFOReadDecorKey
Definition: METEgammaAssociator.h:105
met::METAssociator::m_caloIsolationTool
ToolHandle< xAOD::ICaloTopoClusterIsolationTool > m_caloIsolationTool
Definition: METAssociator.h:87
xAOD::FlowElement_v1
A detector object made of other lower level object(s)
Definition: FlowElement_v1.h:25
Generated on Thu Nov 7 2024 22:18:33 for ATLAS Offline Software by   doxygen 1.8.18