ATLAS Offline Software
Classes | Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
InDet::SiTrackerSpacePointFinder Class Reference

#include <SiTrackerSpacePointFinder.h>

Inheritance diagram for InDet::SiTrackerSpacePointFinder:
Collaboration diagram for InDet::SiTrackerSpacePointFinder:

Classes

struct  SPFCache
 This is a temporary object to aid reentrant coding. More...
 

Public Member Functions

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

Protected Member Functions

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

Private Types

typedef ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

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...
 
Disallow constructor without parameters, copy constructor, assignment operator
 SiTrackerSpacePointFinder ()=delete
 
 SiTrackerSpacePointFinder (const SiTrackerSpacePointFinder &)=delete
 
SiTrackerSpacePointFinderoperator= (const SiTrackerSpacePointFinder &)=delete
 
Main SCT space point methods
void addSCT_SpacePoints (const SCT_ClusterCollection *next, const SiElementPropertiesTable *properties, const InDetDD::SiDetectorElementCollection *elements, SpacePointCollection *spacepointCollection, SpacePointOverlapCollection *spacepointOverlapCollection, SPFCache &, DataPool< SCT_SpacePoint > *dataItemsSCT) const
 

Private Attributes

DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. More...
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 
Input data using SG::ReadHandleKey
SG::ReadHandleKey< SCT_ClusterContainerm_Sct_clcontainerKey {this, "SCT_ClustersName", "SCT_Clusters", "SCT clContainer"}
 
SG::ReadHandleKey< PixelClusterContainerm_Pixel_clcontainerKey {this, "PixelsClustersName", "PixelClusters", "Pixel clContainer"}
 
Input condition data using SG::ReadCondHandleKey
SG::ReadCondHandleKey< InDet::BeamSpotDatam_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" }
 For beam spot. More...
 
SG::ReadCondHandleKey< InDet::SiElementPropertiesTablem_SCTPropertiesKey {this, "SCTPropertiesKey", "SCT_ElementPropertiesTable", "Key of input SiElementPropertiesTable for SCT"}
 To get SCT neighbours. More...
 
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollectionm_SCTDetEleCollKey {this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"}
 For SCT alignment. More...
 
Output data using SG::WriteHandleKey
SG::WriteHandleKey< SpacePointContainerm_SpacePointContainer_SCTKey {this, "SpacePointsSCTName", "SCT_SpacePoints", "SpacePoint SCT container"}
 
SG::WriteHandleKey< SpacePointContainerm_SpacePointContainerPixelKey {this, "SpacePointsPixelName", "PixelSpacePoints", "SpacePoint Pixel container"}
 
SG::WriteHandleKey< SpacePointOverlapCollectionm_spacepointoverlapCollectionKey {this, "SpacePointsOverlapName", "OverlapSpacePoints", "Space Point Overlap collection"}
 
Caches for HLT using SG::UpdateHandleKey
SG::UpdateHandleKey< SpacePointCachem_SpacePointCache_SCTKey {this, "SpacePointCacheSCT", ""}
 
SG::UpdateHandleKey< SpacePointCachem_SpacePointCache_PixKey {this, "SpacePointCachePix", ""}
 
ToolHandle
ToolHandle< SiSpacePointMakerToolm_SiSpacePointMakerTool {this, "SiSpacePointMakerTool", "InDet::SiSpacePointMakerTool"}
 
ToolHandle< GenericMonitoringToolm_monTool {this, "monTool", "", "Monitoring tool"}
 
Id helpers
const PixelIDm_idHelperPixel {nullptr}
 
const SCT_IDm_idHelper {nullptr}
 
Configuration flags
BooleanProperty m_selectPixels {this, "ProcessPixels", true}
 
BooleanProperty m_selectSCTs {this, "ProcessSCTs", true}
 
BooleanProperty m_overlap {this, "ProcessOverlaps", true, "process overlaps of SCT wafers"}
 
BooleanProperty m_allClusters {this, "AllClusters", false, "process all clusters without limits"}
 
bool m_cachemode {false}
 used for online MT counters More...
 
BooleanProperty m_useDataPoolWithCache {this, "useDataPoolWithCache", false, "use DataPool With Cache"}
 
Cut parameters

The following are ranges within which clusters must lie to make a spacepoint.

Opposite and eta neighbours clusters must lie within range of each other. Phi clusters must lie in region of each wafer separately.

FloatProperty m_overlapLimitOpposite {this, "OverlapLimitOpposite", 2.8, "overlap limit for opposite-neighbour"}
 
FloatProperty m_overlapLimitPhi {this, "OverlapLimitPhi", 5.64, "overlap limit for phi-neighbours"}
 
FloatProperty m_overlapLimitEtaMin {this, "OverlapLimitEtaMin", 1.68, "low overlap limit for eta-neighbours"}
 
FloatProperty m_overlapLimitEtaMax {this, "OverlapLimitEtaMax", 3.0, "high overlap limit for eta-neighbours"}
 
Beam spot override
BooleanProperty m_overrideBS {this, "OverrideBeamSpot", false}
 
FloatProperty m_xVertex {this, "VertexX", 0.}
 
FloatProperty m_yVertex {this, "VertexY", 0.}
 
FloatProperty m_zVertex {this, "VertexZ", 0.}
 
Counters

Use mutable to be updated in const methods.

AthReentrantAlgorithm is const during event processing. Use std::atomic to be multi-thread safe.

std::atomic< int > m_numberOfEvents {0}
 
std::atomic< int > m_numberOfPixel {0}
 
std::atomic< int > m_numberOfSCT {0}
 
std::atomic< int > m_sctCacheHits {0}
 
std::atomic< int > m_pixCacheHits {0}
 

Detailed Description

This version of PointFinder uses SiCluster to find space points in the pixel and SCT detectors. The algorithm retrieves all clusters from StoreGate using SG::ReadHandle(Key) and uses the begin-end iterators to iterate over the clusters. It then has to see whether the next cluster is a pixel or SCT cluster. Pixel space points are obtained directly from the clusters. To make SCT space points we also need the IdentifiableContainer for the SCT clusters, since we need random access to find overlapping detectors on the stereo layer. Space points are made by combining clusters from pairs of overlapping detectors. The user can choose just to process the phi wafer and its opposite on the stereo layer, or also to consider overlaps with the four nearest neighbours of the opposite wafer.
The space points are wrtten to Storegate as SpacePointContainer for Pixels and non-overlapping SCT space points and as SpacePointOverlapCollection for the overlapping ones.

Job Options: Process pixels: default true Process SCTs: default true Process overlaps: default true SCT IdentifiableContainer name: default "SCT_Clusters" SCT SpacePointSet name: default "SCT_SpacePoints"

Fatal Errors: neither pixels nor SCTs selected SCTs selected and no name for SCT Identifiable Collection No name for SpacePointSet Failure to retrieve event StoreGate failure.

Possible errors for which processing continues: No clusters found for event Implementation of SCT_Neighbours is SiElementPropertiesTable, is prepared by SiElementPropertiesTableCondAlg and is stored in StoreGate using SG::WriteCondHandle(Key).

Definition at line 83 of file SiTrackerSpacePointFinder.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ SiTrackerSpacePointFinder() [1/3]

InDet::SiTrackerSpacePointFinder::SiTrackerSpacePointFinder ( const std::string &  name,
ISvcLocator *  pSvcLocator 
)

Definition at line 40 of file SiTrackerSpacePointFinder.cxx.

40 { }
41 
42 //-----------------------------------------------------------------------

◆ ~SiTrackerSpacePointFinder()

virtual InDet::SiTrackerSpacePointFinder::~SiTrackerSpacePointFinder ( )
virtualdefault

◆ SiTrackerSpacePointFinder() [2/3]

InDet::SiTrackerSpacePointFinder::SiTrackerSpacePointFinder ( )
privatedelete

◆ SiTrackerSpacePointFinder() [3/3]

InDet::SiTrackerSpacePointFinder::SiTrackerSpacePointFinder ( const SiTrackerSpacePointFinder )
privatedelete

Member Function Documentation

◆ addSCT_SpacePoints()

void InDet::SiTrackerSpacePointFinder::addSCT_SpacePoints ( const SCT_ClusterCollection next,
const SiElementPropertiesTable properties,
const InDetDD::SiDetectorElementCollection elements,
SpacePointCollection spacepointCollection,
SpacePointOverlapCollection spacepointOverlapCollection,
SPFCache r_cache,
DataPool< SCT_SpacePoint > *  dataItemsSCT 
) const
private

Definition at line 369 of file SiTrackerSpacePointFinder.cxx.

373 {
374  // For each trigger element, first evaluate and collect the quantities you need to build the space points.
375  // The detector element array has capacity 6:
376  // [0] is the trigger element
377  // [1] is the opposite element
378  // [2]-[3] are the elements tested for eta overlaps
379  // [4]-[5] are the elements tested for phi overlaps
380  // For each element you save the corresponding cluster collections and the
381  // space point compatibility range as described below.
382  //
383  // For the opposite element and the ones tested for eta overlaps, you have to check
384  // if clusters are compatible with the local position of the trigger cluster
385  // requiring that the distance between the two clusters in phi is withing a specified range.
386  // - For the clusters on the opposite element: [-m_overlapLimitOpposite, m_overlapLimitOpposite]
387  //
388  // - For the eta overlapping clusters : you use m_overlapLimitEtaMin and m_overlapLimitEtaMax
389  // in different combination depending if you are checking a stereo module or not
390  //
391  // For each element, the extremes of these ranges are saved in the overlapExtents array
392  // which is later on used in SiSpacePointMakerTool::fillSCT_SpacePointCollection
393  // - overlapExtents[0], overlapExtents[1] are filled for the opposite element
394  // - overlapExtents[2], overlapExtents[3], overlapExtents[4], overlapExtents[5] are filled for the eta overlapping elements
395  //
396  // For the elements tested for phi overlaps, you have to check
397  // if clusters are compatible with the local position of the trigger cluster.
398  // This needs that the trigger cluster is at the edge of the trigger module:
399  // e.g. -hwidth < locX_trigger < -hwidth+m_overlapLimitPhi (or hwidth-m_overlapLimitPhi < locX_trigger < hwidth)
400  // and that the other cluster is on the compatible edge of its module:
401  // e.g. hwidth-m_overlapLimitPhi < locX_other < hwidth (or -hwidth < locX_other < -hwidth+m_overlapLimitPhi)
402  //
403  // For each element, the extremes of these ranges are saved in the overlapExtents array
404  // which is later on used in SiSpacePointMakerTool::fillSCT_SpacePointCollection
405  // - overlapExtents[6], overlapExtents[7], overlapExtents[10], overlapExtents[11]
406  // overlapExtents[8], overlapExtents[9], overlapExtents[12], overlapExtents[13] are filled for the phi overlapping elements
407 
409 
410  std::array<const SCT_ClusterCollection*, nNeighbours> neighbourClusters{};
411  std::array<const InDetDD::SiDetectorElement*, nNeighbours> neighbourElements{};
412  std::array<double, 14> overlapExtents{};
413 
414  // Get the detector element (and its Identifier) correspoding to the cluster collection
415  IdentifierHash triggerIdHash(sctClusters->identifyHash());
416  const InDetDD::SiDetectorElement *triggerElement = elements->getDetectorElement(triggerIdHash);
417  Identifier thisID = triggerElement->identify();
418 
419  // Retrieve the neighbours of the detector element
420  const std::vector<IdentifierHash>* others(properties->neighbours(triggerIdHash));
421  if (others==nullptr || others->empty() ) return;
422 
423  // Save the current detector element and clusters
424  neighbourElements[0] = triggerElement;
425  neighbourClusters[0] = sctClusters;
426  int n = 0 ;
427 
428  // Default case: you test the opposite element and the overlapping in phi (total 3 elements)
429  int Nmax = 4 ;
430 
431  // In the barrel, test the eta overlaps as well (total 5 elements)
432  if (m_idHelper->is_barrel(thisID)) Nmax = 6;
433 
434  // You can remove all the overlaps if requrested. Here you test only the opposite element
435  if(!m_overlap) Nmax = 2;
436 
437  float hwidth(properties->halfWidth(triggerIdHash));
438 
439  // This flag is use to trigger if the search should be performed.
440  // In case there are no other detector elements and/or cluster collection
441  // this flag stays false.
442  bool search = false;
443 
444  // The order of the elements in others is such that you first get the opposite element,
445  // the overlapping in phi and then the overlapping in eta
446  // For this reason you need to re-order the indices, since the SiSpacePointMakerTool will process
447  // first the eta overlaps and then the phi ones
448  const std::array<size_t, nNeighbours> neigbourIndices{ThisOne, Opposite, EtaMinus, EtaPlus, PhiMinus, PhiPlus};
449 
450  for (const auto& otherHash : *others) {
451 
452  if(++n==Nmax) break;
453  const SCT_ClusterCollection* otherClusters = r_cache.SCTCContainer->indexFindPtr (otherHash);
454  const InDetDD::SiDetectorElement* otherElement = elements ->getDetectorElement(otherHash);
455 
456  if(!otherElement || !otherClusters) continue;
457 
458  neighbourElements[neigbourIndices[n]] = otherElement;
459  neighbourClusters[neigbourIndices[n]] = otherClusters;
460  search = true ;
461 
462  switch (n) {
463  case Opposite: {
464  overlapExtents[ 0] = -m_overlapLimitOpposite;
465  overlapExtents[ 1] = m_overlapLimitOpposite;
466  break;
467  }
468  case PhiMinus: {
469  overlapExtents[ 6] =-hwidth;
470  overlapExtents[ 7] =-hwidth+m_overlapLimitPhi;
471  overlapExtents[ 8] = hwidth-m_overlapLimitPhi;
472  overlapExtents[ 9] = hwidth;
473  break;
474  }
475  case PhiPlus: {
476  overlapExtents[10] = hwidth-m_overlapLimitPhi;
477  overlapExtents[11] = hwidth;
478  overlapExtents[12] =-hwidth;
479  overlapExtents[13] =-hwidth+m_overlapLimitPhi;
480  break;
481  }
482  case EtaMinus: {
483  if ((m_idHelper->layer_disk(thisID) & 1) == 0) {
484  overlapExtents[ 2] = m_overlapLimitEtaMin;
485  overlapExtents[ 3] = m_overlapLimitEtaMax;
486  } else {
487  overlapExtents[ 2] =-m_overlapLimitEtaMax;
488  overlapExtents[ 3] =-m_overlapLimitEtaMin;
489  }
490  break;
491  }
492  default: {
493  if ((m_idHelper->layer_disk(thisID) & 1) == 0) {
494  overlapExtents[ 4] = -m_overlapLimitEtaMax;
495  overlapExtents[ 5] = -m_overlapLimitEtaMin;
496  } else {
497  overlapExtents[ 4] = m_overlapLimitEtaMin;
498  overlapExtents[ 5] = m_overlapLimitEtaMax;
499  }
500  break;
501  }
502  }
503  }
504 
505  if (search) {
506  m_SiSpacePointMakerTool->fillSCT_SpacePointCollection(
507  neighbourElements, neighbourClusters, overlapExtents, m_allClusters,
508  r_cache.vertex, spacepointCollection, spacepointOverlapCollection,
509  dataItemsSCT);
510  }
511 }
512 
513 } //namespace

◆ cardinality()

unsigned int AthReentrantAlgorithm::cardinality ( ) const
overridevirtualinherited

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

Override this to return 0 for reentrant algorithms.

Override this to return 0 for reentrant algorithms.

Definition at line 55 of file AthReentrantAlgorithm.cxx.

56 {
57  return 0;
58 }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

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

◆ declareProperty() [1/6]

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

Declare a new Gaudi property.

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

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

Definition at line 245 of file AthCommonDataStore.h.

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

◆ declareProperty() [2/6]

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

Declare a new Gaudi property.

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

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

Definition at line 221 of file AthCommonDataStore.h.

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

◆ declareProperty() [3/6]

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

Definition at line 259 of file AthCommonDataStore.h.

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

◆ declareProperty() [4/6]

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

Declare a new Gaudi property.

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

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

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

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

Declare a new Gaudi property.

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

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

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
148  }

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode InDet::SiTrackerSpacePointFinder::execute ( const EventContext &  ctx) const
overridevirtual

Definition at line 106 of file SiTrackerSpacePointFinder.cxx.

114  {
116  elements = sctDetEle.retrieve();
117  if (elements==nullptr) {
118  ATH_MSG_FATAL("Pointer of SiDetectorElementCollection (" << m_SCTDetEleCollKey.fullKey() << ") could not be retrieved");
119  return StatusCode::SUCCESS;
120  }
122  properties = sctProperties.retrieve();
123  if (properties==nullptr) {
124  ATH_MSG_FATAL("Pointer of SiElementPropertiesTable (" << m_SCTPropertiesKey.fullKey() << ") could not be retrieved");
125  return StatusCode::SUCCESS;
126  }
127  }
128  SPFCache r_cache(ctx);
129  if (! m_overrideBS){
131  const InDet::BeamSpotData* beamSpot = *beamSpotHandle;
132  r_cache.vertex = beamSpot->beamVtx().position();
133  } else {
134  r_cache.vertex = Amg::Vector3D(m_xVertex,m_yVertex,m_zVertex);
135  }
136 
137  // register the IdentifiableContainer into StoreGate
138  SG::WriteHandle<SpacePointContainer> spacePointContainerPixel;
139  std::unique_ptr<DataPool<PixelSpacePoint>> dataItemsPixel = nullptr;
140  if (m_selectPixels){
141  spacePointContainerPixel = SG::WriteHandle<SpacePointContainer>( m_SpacePointContainerPixelKey, ctx );
142  if(m_SpacePointCache_PixKey.key().empty()){
143  ATH_CHECK( spacePointContainerPixel.record( std::make_unique<SpacePointContainer>(m_idHelperPixel->wafer_hash_max()) ) );
144  ATH_MSG_DEBUG("Created SpacePointContainer " << m_SpacePointContainerPixelKey.key() << " N= " << m_idHelperPixel->wafer_hash_max());
145  }else{
147  ATH_CHECK(updateH.isValid());
148  ATH_CHECK( spacePointContainerPixel.record( std::make_unique<SpacePointContainer>(updateH.ptr()) ) );
149  ATH_MSG_DEBUG("Created SpacePointContainer " << m_SpacePointContainerPixelKey.key() << " from cache " << m_SpacePointCache_PixKey.key());
150  }
151  const bool hasExternalCache = spacePointContainerPixel->hasExternalCache();
152  if (!hasExternalCache) {
153  dataItemsPixel = std::make_unique<DataPool<PixelSpacePoint>>(ctx);
154  dataItemsPixel->reserve(5000); // Some large default size
155  } else if (m_useDataPoolWithCache) {
156  dataItemsPixel = std::make_unique<DataPool<PixelSpacePoint>>(ctx);
157  // Default size for now 1024 let it expand on its own
158  }
159  }
160 
161  SG::WriteHandle<SpacePointContainer> spacePointContainer_SCT;
162  std::unique_ptr<DataPool<SCT_SpacePoint>> dataItemsSCT = nullptr;
163  if (m_selectSCTs){
164  spacePointContainer_SCT = SG::WriteHandle<SpacePointContainer>( m_SpacePointContainer_SCTKey, ctx );
165  if(m_SpacePointCache_SCTKey.key().empty()){
166  ATH_CHECK( spacePointContainer_SCT.record( std::make_unique<SpacePointContainer>(m_idHelper->wafer_hash_max()) ) );
167  ATH_MSG_DEBUG("Created SpacePointContainer " << m_SpacePointContainer_SCTKey.key() << " N= " << m_idHelper->wafer_hash_max());
168  }else{
170  ATH_CHECK(updateH.isValid());
171  ATH_CHECK( spacePointContainer_SCT.record( std::make_unique<SpacePointContainer>(updateH.ptr()) ) );
172  ATH_MSG_DEBUG("Created SpacePointContainer " << m_SpacePointContainer_SCTKey.key() << " from cache " << m_SpacePointCache_SCTKey.key());
173  }
174  const bool hasExternalCache = spacePointContainer_SCT->hasExternalCache();
175  if (!hasExternalCache) {
176  dataItemsSCT = std::make_unique<DataPool<SCT_SpacePoint>>(ctx);
177  dataItemsSCT->reserve(10000); // Some large default size
178  } else if (m_useDataPoolWithCache) {
179  dataItemsSCT = std::make_unique<DataPool<SCT_SpacePoint>>(ctx);
180  // Default size for now 1024 let it expand on its own
181  }
182  }
183 
184  SG::WriteHandle<SpacePointOverlapCollection> spacepointoverlapCollection;
185  if(m_overlap){
187  ATH_CHECK( spacepointoverlapCollection.record( std::make_unique<SpacePointOverlapCollection>() ) );
188  if (dataItemsSCT) {
189  // if we have a DataPool it will own the elements
190  spacepointoverlapCollection.ptr()->clear(SG::VIEW_ELEMENTS);
191  }
192  ATH_MSG_DEBUG( "Container '" << spacepointoverlapCollection.name() << "' initialised" );
193  }
194 
195  int sctCacheCount = 0;
196  int pixCacheCount = 0;
197 
198  if (m_selectSCTs){
199  // retrieve SCT cluster container
201  if (!sct_clcontainer.isValid()){
202  msg(MSG:: FATAL) << "Could not find the data object "<< sct_clcontainer.name() << " !" << endmsg;
203  return StatusCode::RECOVERABLE;
204  }
205 
206  r_cache.SCTCContainer = sct_clcontainer.cptr();
207 
208  ATH_MSG_DEBUG( "SCT Cluster container found: " << sct_clcontainer->size() << " collections" );
209  // Get hold of all clusters and iterate through them.
210  // Pixel clusters will be converted immediately to pixel space points.
211  // For SCT clusters, posssible pairs will be found and space points computed.
212  // It is possible, though unlikely, that there are no clusters for the
213  // event. Therefore we do not terminate the job if we don't find any.
214  SCT_ClusterContainer::const_iterator it = sct_clcontainer->begin();
215  SCT_ClusterContainer::const_iterator itend = sct_clcontainer->end();
216 
217  for (; it != itend; ++it){
218  const SCT_ClusterCollection *colNext=&(**it);
219 
220  // Create SpacePointCollection
221  IdentifierHash idHash = colNext->identifyHash();
222  SpacePointContainer::IDC_WriteHandle lock = spacePointContainer_SCT->getWriteHandle(idHash);
224  ATH_MSG_DEBUG("SCT Hash " << idHash << " is already in cache");
225  ++sctCacheCount;
226  continue; //Skip if already present in cache
227  }
228 
229  Identifier elementID = colNext->identify();
230  auto spacepointCollection = std::make_unique<SpacePointCollection>(idHash);
231  spacepointCollection->setIdentifier(elementID);
232  if(dataItemsSCT){
233  //if we have a DataPool it will own the elements
234  spacepointCollection->clear(SG::VIEW_ELEMENTS);
235  }
236 
237  if(!colNext->empty() && !elements->getDetectorElement(colNext->identifyHash())->isStereo()) {
239  colNext, properties, elements, spacepointCollection.get(),
240  spacepointoverlapCollection.ptr(), r_cache, dataItemsSCT.get());
241  } else {
242  ATH_MSG_DEBUG( "Empty SCT cluster collection" );
243  }
244 
245  size_t size = spacepointCollection->size();
246  if (size == 0){
247  ATH_MSG_VERBOSE( "SiTrackerSpacePointFinder algorithm found no space points" );
248  } else {
249  //In a MT environment the cache maybe filled by another thread in which case this will delete the duplicate
250  StatusCode sc= lock.addOrDelete( std::move(spacepointCollection) );
251  if (sc.isFailure()){
252  ATH_MSG_ERROR( "Failed to add SpacePoints to container" );
253  return StatusCode::RECOVERABLE;
254  }
255  ATH_MSG_VERBOSE( size << " SpacePoints successfully added to Container !" );
256  nReceivedSPsSCT += size;
257  }
258  }
259  m_numberOfSCT+= sct_clcontainer->size();
260  }
261 
262  if (m_selectPixels)
263  {
264 
266  if (!pixel_clcontainer.isValid()){
267  msg(MSG:: FATAL) << "Could not find the data object "<< pixel_clcontainer.name() << " !" << endmsg;
268  return StatusCode::RECOVERABLE;
269  }
270 
271  ATH_MSG_DEBUG( "Data object " << pixel_clcontainer.name() << " found" );
272 
273  // loop over Pixel clusterCollections
274  PixelClusterContainer::const_iterator colNext = pixel_clcontainer->begin();
275  PixelClusterContainer::const_iterator lastCol = pixel_clcontainer->end();
276 
277 
278  int numColl=0;
279  for (; colNext != lastCol; ++colNext)
280  {
281  ATH_MSG_VERBOSE( "Collection num " << numColl++ );
282  IdentifierHash idHash = (*colNext)->identifyHash();
283  SpacePointContainer::IDC_WriteHandle lock = spacePointContainerPixel->getWriteHandle(idHash);
285  ATH_MSG_DEBUG("pixel Hash " << idHash << " is already in cache");
286  ++pixCacheCount;
287  continue;
288  }
289  // Create SpacePointCollection
290  Identifier elementID = (*colNext)->identify();
291  auto spacepointCollection = std::make_unique< SpacePointCollection >(idHash);
292  spacepointCollection->setIdentifier(elementID);
293  if(dataItemsPixel){
294  //if we have a DataPool it will own the elements
295  spacepointCollection->clear(SG::VIEW_ELEMENTS);
296  }
297 
298  if (!(*colNext)->empty())
299  {
300  m_SiSpacePointMakerTool->fillPixelSpacePointCollection(
301  *colNext, spacepointCollection.get(), dataItemsPixel.get());
302  } else {
303  ATH_MSG_DEBUG( "Empty pixel cluster collection" );
304  }
305  size_t size = spacepointCollection->size();
306  if (size == 0)
307  {
308  ATH_MSG_DEBUG( "SiTrackerSpacePointFinder algorithm found no space points" );
309  }
310  else
311  {
312  StatusCode sc = lock.addOrDelete( std::move(spacepointCollection) );
313  if (sc.isFailure())
314  {
315  ATH_MSG_ERROR( "Failed to add SpacePoints to container" );
316  return StatusCode::RECOVERABLE;
317  }
319  << " SpacePoints successfully added to Container !" );
320  nReceivedSPsPIX += size;
321  }
322  }
323  m_numberOfPixel+= pixel_clcontainer->size();
324  }
325 
326  // store the overlap space points.
327  // check that the set isn't empty.
328  if(m_overlap){
329  if (spacepointoverlapCollection->empty())
330  {
331  ATH_MSG_DEBUG( "No overlap space points found" );
332  }
333  else
334  {
335  ATH_MSG_DEBUG( spacepointoverlapCollection->size() <<" overlap space points registered." );
336  }
337  }
338 
339  if(m_cachemode)//Prevent unnecessary atomic counting
340  {
341  m_sctCacheHits += sctCacheCount;
342  m_pixCacheHits += pixCacheCount;
343  }
344 
345  return StatusCode::SUCCESS;
346 
347 }
348 
349 //---------------------------------------------------------------------------

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthReentrantAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 79 of file AthReentrantAlgorithm.cxx.

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

◆ filterPassed()

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

Definition at line 135 of file AthReentrantAlgorithm.h.

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

◆ finalize()

StatusCode InDet::SiTrackerSpacePointFinder::finalize ( )
overridevirtual

Definition at line 353 of file SiTrackerSpacePointFinder.cxx.

355  {
356  //These are debug messages because they can be indeterminate in an MT environment and it could
357  //lead to confusing log comparisons.
358  ATH_MSG_DEBUG( m_sctCacheHits << " sct cache hits" );
359  ATH_MSG_DEBUG( m_pixCacheHits << " pix cache hits" );
360  }
361  return StatusCode::SUCCESS;
362 }
363 
364 //--------------------------------------------------------------------------
365 

◆ initialize()

StatusCode InDet::SiTrackerSpacePointFinder::initialize ( )
overridevirtual

Definition at line 46 of file SiTrackerSpacePointFinder.cxx.

46  {
47  ATH_MSG_FATAL( "SCTs selected and no name set for SCT clusters");
48  return StatusCode::FAILURE;
49  }
51 
52  if (m_selectPixels && m_Pixel_clcontainerKey.key().empty()){
53  ATH_MSG_FATAL( "Pixels selected and no name set for Pixel clusters");
54  return StatusCode::FAILURE;
55  }
57 
59  ATH_MSG_FATAL( "No name set for SCT space points");
60  return StatusCode::FAILURE;
61  }
63 
65  ATH_MSG_FATAL( "No name set for Pixels space points");
66  return StatusCode::FAILURE;
67  }
69 
71  ATH_MSG_FATAL( "No name set for overlap space points");
72  return StatusCode::FAILURE;
73  }
75 
76  // create containers (requires the Identifier Helpers)
77  if (m_selectPixels){
79  }
80 
81  if (m_selectSCTs) {
82  ATH_CHECK(detStore()->retrieve(m_idHelper,"SCT_ID"));
83  }
84 
85  // Initialize the key of input SiElementPropertiesTable and SiDetectorElementCollection for SCT
88 
91 
94  m_cachemode = !m_SpacePointCache_SCTKey.key().empty() || !m_SpacePointCache_PixKey.key().empty();
95 
96  if (!m_monTool.empty()) CHECK(m_monTool.retrieve());
97 
98  return StatusCode::SUCCESS;
99 }
100 
101 //-------------------------------------------------------------------------
102 

◆ inputHandles()

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

Return this algorithm's input handles.

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

◆ isClonable()

virtual bool InDet::SiTrackerSpacePointFinder::isClonable ( ) const
inlineoverridevirtual

Make this algorithm clonable.

Reimplemented from AthReentrantAlgorithm.

Definition at line 103 of file SiTrackerSpacePointFinder.h.

103 { return true; };

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

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

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

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

◆ operator=()

SiTrackerSpacePointFinder& InDet::SiTrackerSpacePointFinder::operator= ( const SiTrackerSpacePointFinder )
privatedelete

◆ outputHandles()

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

Return this algorithm's output handles.

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

◆ renounce()

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

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ setFilterPassed()

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

Definition at line 139 of file AthReentrantAlgorithm.h.

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

◆ sysExecute()

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

Execute an algorithm.

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

Definition at line 67 of file AthReentrantAlgorithm.cxx.

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

◆ sysInitialize()

StatusCode AthReentrantAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

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

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

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

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 96 of file AthReentrantAlgorithm.cxx.

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

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::sysStart ( )
overridevirtualinherited

Handle START transition.

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

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

◆ m_allClusters

BooleanProperty InDet::SiTrackerSpacePointFinder::m_allClusters {this, "AllClusters", false, "process all clusters without limits"}
private

Definition at line 205 of file SiTrackerSpacePointFinder.h.

◆ m_beamSpotKey

SG::ReadCondHandleKey<InDet::BeamSpotData> InDet::SiTrackerSpacePointFinder::m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" }
private

For beam spot.

Definition at line 155 of file SiTrackerSpacePointFinder.h.

◆ m_cachemode

bool InDet::SiTrackerSpacePointFinder::m_cachemode {false}
private

used for online MT counters

Definition at line 207 of file SiTrackerSpacePointFinder.h.

◆ m_detStore

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

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_evtStore

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

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthReentrantAlgorithm::m_extendedExtraObjects
privateinherited

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

Empty if no symlinks were found.

Definition at line 153 of file AthReentrantAlgorithm.h.

◆ m_idHelper

const SCT_ID* InDet::SiTrackerSpacePointFinder::m_idHelper {nullptr}
private

Definition at line 194 of file SiTrackerSpacePointFinder.h.

◆ m_idHelperPixel

const PixelID* InDet::SiTrackerSpacePointFinder::m_idHelperPixel {nullptr}
private

Definition at line 193 of file SiTrackerSpacePointFinder.h.

◆ m_monTool

ToolHandle<GenericMonitoringTool> InDet::SiTrackerSpacePointFinder::m_monTool {this, "monTool", "", "Monitoring tool"}
private

Definition at line 186 of file SiTrackerSpacePointFinder.h.

◆ m_numberOfEvents

std::atomic<int> InDet::SiTrackerSpacePointFinder::m_numberOfEvents {0}
mutableprivate

Definition at line 247 of file SiTrackerSpacePointFinder.h.

◆ m_numberOfPixel

std::atomic<int> InDet::SiTrackerSpacePointFinder::m_numberOfPixel {0}
mutableprivate

Definition at line 248 of file SiTrackerSpacePointFinder.h.

◆ m_numberOfSCT

std::atomic<int> InDet::SiTrackerSpacePointFinder::m_numberOfSCT {0}
mutableprivate

Definition at line 249 of file SiTrackerSpacePointFinder.h.

◆ m_overlap

BooleanProperty InDet::SiTrackerSpacePointFinder::m_overlap {this, "ProcessOverlaps", true, "process overlaps of SCT wafers"}
private

Definition at line 203 of file SiTrackerSpacePointFinder.h.

◆ m_overlapLimitEtaMax

FloatProperty InDet::SiTrackerSpacePointFinder::m_overlapLimitEtaMax {this, "OverlapLimitEtaMax", 3.0, "high overlap limit for eta-neighbours"}
private

Definition at line 226 of file SiTrackerSpacePointFinder.h.

◆ m_overlapLimitEtaMin

FloatProperty InDet::SiTrackerSpacePointFinder::m_overlapLimitEtaMin {this, "OverlapLimitEtaMin", 1.68, "low overlap limit for eta-neighbours"}
private

Definition at line 224 of file SiTrackerSpacePointFinder.h.

◆ m_overlapLimitOpposite

FloatProperty InDet::SiTrackerSpacePointFinder::m_overlapLimitOpposite {this, "OverlapLimitOpposite", 2.8, "overlap limit for opposite-neighbour"}
private

Definition at line 220 of file SiTrackerSpacePointFinder.h.

◆ m_overlapLimitPhi

FloatProperty InDet::SiTrackerSpacePointFinder::m_overlapLimitPhi {this, "OverlapLimitPhi", 5.64, "overlap limit for phi-neighbours"}
private

Definition at line 222 of file SiTrackerSpacePointFinder.h.

◆ m_overrideBS

BooleanProperty InDet::SiTrackerSpacePointFinder::m_overrideBS {this, "OverrideBeamSpot", false}
private

Definition at line 234 of file SiTrackerSpacePointFinder.h.

◆ m_pixCacheHits

std::atomic<int> InDet::SiTrackerSpacePointFinder::m_pixCacheHits {0}
mutableprivate

Definition at line 251 of file SiTrackerSpacePointFinder.h.

◆ m_Pixel_clcontainerKey

SG::ReadHandleKey<PixelClusterContainer> InDet::SiTrackerSpacePointFinder::m_Pixel_clcontainerKey {this, "PixelsClustersName", "PixelClusters", "Pixel clContainer"}
private

Definition at line 147 of file SiTrackerSpacePointFinder.h.

◆ m_Sct_clcontainerKey

SG::ReadHandleKey<SCT_ClusterContainer> InDet::SiTrackerSpacePointFinder::m_Sct_clcontainerKey {this, "SCT_ClustersName", "SCT_Clusters", "SCT clContainer"}
private

Definition at line 146 of file SiTrackerSpacePointFinder.h.

◆ m_sctCacheHits

std::atomic<int> InDet::SiTrackerSpacePointFinder::m_sctCacheHits {0}
mutableprivate

Definition at line 250 of file SiTrackerSpacePointFinder.h.

◆ m_SCTDetEleCollKey

SG::ReadCondHandleKey<InDetDD::SiDetectorElementCollection> InDet::SiTrackerSpacePointFinder::m_SCTDetEleCollKey {this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"}
private

For SCT alignment.

Definition at line 159 of file SiTrackerSpacePointFinder.h.

◆ m_SCTPropertiesKey

SG::ReadCondHandleKey<InDet::SiElementPropertiesTable> InDet::SiTrackerSpacePointFinder::m_SCTPropertiesKey {this, "SCTPropertiesKey", "SCT_ElementPropertiesTable", "Key of input SiElementPropertiesTable for SCT"}
private

To get SCT neighbours.

Definition at line 157 of file SiTrackerSpacePointFinder.h.

◆ m_selectPixels

BooleanProperty InDet::SiTrackerSpacePointFinder::m_selectPixels {this, "ProcessPixels", true}
private

Definition at line 201 of file SiTrackerSpacePointFinder.h.

◆ m_selectSCTs

BooleanProperty InDet::SiTrackerSpacePointFinder::m_selectSCTs {this, "ProcessSCTs", true}
private

Definition at line 202 of file SiTrackerSpacePointFinder.h.

◆ m_SiSpacePointMakerTool

ToolHandle< SiSpacePointMakerTool > InDet::SiTrackerSpacePointFinder::m_SiSpacePointMakerTool {this, "SiSpacePointMakerTool", "InDet::SiSpacePointMakerTool"}
private

Definition at line 185 of file SiTrackerSpacePointFinder.h.

◆ m_SpacePointCache_PixKey

SG::UpdateHandleKey<SpacePointCache> InDet::SiTrackerSpacePointFinder::m_SpacePointCache_PixKey {this, "SpacePointCachePix", ""}
private

Definition at line 177 of file SiTrackerSpacePointFinder.h.

◆ m_SpacePointCache_SCTKey

SG::UpdateHandleKey<SpacePointCache> InDet::SiTrackerSpacePointFinder::m_SpacePointCache_SCTKey {this, "SpacePointCacheSCT", ""}
private

Definition at line 175 of file SiTrackerSpacePointFinder.h.

◆ m_SpacePointContainer_SCTKey

SG::WriteHandleKey<SpacePointContainer> InDet::SiTrackerSpacePointFinder::m_SpacePointContainer_SCTKey {this, "SpacePointsSCTName", "SCT_SpacePoints", "SpacePoint SCT container"}
private

Definition at line 166 of file SiTrackerSpacePointFinder.h.

◆ m_SpacePointContainerPixelKey

SG::WriteHandleKey<SpacePointContainer> InDet::SiTrackerSpacePointFinder::m_SpacePointContainerPixelKey {this, "SpacePointsPixelName", "PixelSpacePoints", "SpacePoint Pixel container"}
private

Definition at line 167 of file SiTrackerSpacePointFinder.h.

◆ m_spacepointoverlapCollectionKey

SG::WriteHandleKey<SpacePointOverlapCollection> InDet::SiTrackerSpacePointFinder::m_spacepointoverlapCollectionKey {this, "SpacePointsOverlapName", "OverlapSpacePoints", "Space Point Overlap collection"}
private

Definition at line 168 of file SiTrackerSpacePointFinder.h.

◆ m_useDataPoolWithCache

BooleanProperty InDet::SiTrackerSpacePointFinder::m_useDataPoolWithCache {this, "useDataPoolWithCache", false, "use DataPool With Cache"}
private

Definition at line 208 of file SiTrackerSpacePointFinder.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ m_xVertex

FloatProperty InDet::SiTrackerSpacePointFinder::m_xVertex {this, "VertexX", 0.}
private

Definition at line 235 of file SiTrackerSpacePointFinder.h.

◆ m_yVertex

FloatProperty InDet::SiTrackerSpacePointFinder::m_yVertex {this, "VertexY", 0.}
private

Definition at line 236 of file SiTrackerSpacePointFinder.h.

◆ m_zVertex

FloatProperty InDet::SiTrackerSpacePointFinder::m_zVertex {this, "VertexZ", 0.}
private

Definition at line 237 of file SiTrackerSpacePointFinder.h.


The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
ActsTrk::EtaMinus
@ EtaMinus
Definition: StripInformationHelper.h:13
InDet::SiTrackerSpacePointFinder::m_xVertex
FloatProperty m_xVertex
Definition: SiTrackerSpacePointFinder.h:235
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
InDet::SiTrackerSpacePointFinder::m_yVertex
FloatProperty m_yVertex
Definition: SiTrackerSpacePointFinder.h:236
python.Constants.FATAL
int FATAL
Definition: Control/AthenaCommon/python/Constants.py:19
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
python.TestDriveDummies.properties
dictionary properties
Definition: TestDriveDummies.py:14
InDet::SiTrackerSpacePointFinder::m_SCTPropertiesKey
SG::ReadCondHandleKey< InDet::SiElementPropertiesTable > m_SCTPropertiesKey
To get SCT neighbours.
Definition: SiTrackerSpacePointFinder.h:157
IdentifiableContainerMT::getWriteHandle
IDC_WriteHandle getWriteHandle(IdentifierHash hash)
Definition: IdentifiableContainerMT.h:248
SG::VIEW_ELEMENTS
@ VIEW_ELEMENTS
this data object is a view, it does not own its elmts
Definition: OwnershipPolicy.h:18
InDet::SiTrackerSpacePointFinder::m_cachemode
bool m_cachemode
used for online MT counters
Definition: SiTrackerSpacePointFinder.h:207
InDet::SiTrackerSpacePointFinder::m_beamSpotKey
SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey
For beam spot.
Definition: SiTrackerSpacePointFinder.h:155
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
SG::VarHandleBase::name
const std::string & name() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleBase.cxx:75
InDet::SiTrackerSpacePointFinder::m_overrideBS
BooleanProperty m_overrideBS
Definition: SiTrackerSpacePointFinder.h:234
InDet::SiTrackerSpacePointFinder::m_pixCacheHits
std::atomic< int > m_pixCacheHits
Definition: SiTrackerSpacePointFinder.h:251
InDet::SiTrackerSpacePointFinder::m_Sct_clcontainerKey
SG::ReadHandleKey< SCT_ClusterContainer > m_Sct_clcontainerKey
Definition: SiTrackerSpacePointFinder.h:146
IdentifiableContainerMT::IDC_WriteHandle::OnlineAndPresentInAnotherView
bool OnlineAndPresentInAnotherView()
This method is to avoid calling an expensive operation in the offline case.
Definition: IdentifiableContainerMT.h:61
AthCommonDataStore::renounce
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce(T &h)
Definition: AthCommonDataStore.h:380
skel.it
it
Definition: skel.GENtoEVGEN.py:396
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
InDet::SiTrackerSpacePointFinder::m_zVertex
FloatProperty m_zVertex
Definition: SiTrackerSpacePointFinder.h:237
InDet::SiTrackerSpacePointFinder::m_idHelperPixel
const PixelID * m_idHelperPixel
Definition: SiTrackerSpacePointFinder.h:193
InDet::SiTrackerSpacePointFinder::m_allClusters
BooleanProperty m_allClusters
Definition: SiTrackerSpacePointFinder.h:206
InDet::SiTrackerSpacePointFinder::m_SiSpacePointMakerTool
ToolHandle< SiSpacePointMakerTool > m_SiSpacePointMakerTool
Definition: SiTrackerSpacePointFinder.h:185
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
ActsTrk::Opposite
@ Opposite
Definition: StripInformationHelper.h:13
InDet::SiTrackerSpacePointFinder::m_numberOfPixel
std::atomic< int > m_numberOfPixel
Definition: SiTrackerSpacePointFinder.h:248
ActsTrk::EtaPlus
@ EtaPlus
Definition: StripInformationHelper.h:13
search
void search(TDirectory *td, const std::string &s, std::string cwd, node *n)
recursive directory search for TH1 and TH2 and TProfiles
Definition: hcg.cxx:738
InDet::SiTrackerSpacePointFinder::m_SpacePointContainer_SCTKey
SG::WriteHandleKey< SpacePointContainer > m_SpacePointContainer_SCTKey
Definition: SiTrackerSpacePointFinder.h:166
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
InDet::SiTrackerSpacePointFinder::m_SpacePointCache_SCTKey
SG::UpdateHandleKey< SpacePointCache > m_SpacePointCache_SCTKey
Definition: SiTrackerSpacePointFinder.h:176
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
InDet::SiTrackerSpacePointFinder::m_overlapLimitPhi
FloatProperty m_overlapLimitPhi
Definition: SiTrackerSpacePointFinder.h:223
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
InDet::SiTrackerSpacePointFinder::m_useDataPoolWithCache
BooleanProperty m_useDataPoolWithCache
Definition: SiTrackerSpacePointFinder.h:209
InDet::nNeighbours
constexpr size_t nNeighbours
Definition: SiSpacePointMakerTool.h:35
IdentifiableContainerMT::hasExternalCache
virtual bool hasExternalCache() const override final
Definition: IdentifiableContainerMT.h:152
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
InDet::SiTrackerSpacePointFinder::m_SpacePointContainerPixelKey
SG::WriteHandleKey< SpacePointContainer > m_SpacePointContainerPixelKey
Definition: SiTrackerSpacePointFinder.h:167
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
InDet::SiTrackerSpacePointFinder::m_spacepointoverlapCollectionKey
SG::WriteHandleKey< SpacePointOverlapCollection > m_spacepointoverlapCollectionKey
Definition: SiTrackerSpacePointFinder.h:168
beamspotman.n
n
Definition: beamspotman.py:731
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
SG::WriteHandle::ptr
pointer_type ptr()
Dereference the pointer.
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
InDet::SiTrackerSpacePointFinder::m_SCTDetEleCollKey
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection > m_SCTDetEleCollKey
For SCT alignment.
Definition: SiTrackerSpacePointFinder.h:159
IdentifiableContainerMT::IDC_WriteHandle
Definition: IdentifiableContainerMT.h:34
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
InDet::SiTrackerSpacePointFinder::m_sctCacheHits
std::atomic< int > m_sctCacheHits
Definition: SiTrackerSpacePointFinder.h:250
ActsTrk::PhiPlus
@ PhiPlus
Definition: StripInformationHelper.h:13
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
InDet::SiTrackerSpacePointFinder::addSCT_SpacePoints
void addSCT_SpacePoints(const SCT_ClusterCollection *next, const SiElementPropertiesTable *properties, const InDetDD::SiDetectorElementCollection *elements, SpacePointCollection *spacepointCollection, SpacePointOverlapCollection *spacepointOverlapCollection, SPFCache &, DataPool< SCT_SpacePoint > *dataItemsSCT) const
Definition: SiTrackerSpacePointFinder.cxx:369
DataVector::clear
void clear()
Erase all the elements in the collection.
InDet::SiTrackerSpacePointFinder::initialize
virtual StatusCode initialize() override
Definition: SiTrackerSpacePointFinder.cxx:46
AthReentrantAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthReentrantAlgorithm.h:153
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
InDet::SiTrackerSpacePointFinder::m_Pixel_clcontainerKey
SG::ReadHandleKey< PixelClusterContainer > m_Pixel_clcontainerKey
Definition: SiTrackerSpacePointFinder.h:147
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
InDet::SiTrackerSpacePointFinder::m_numberOfSCT
std::atomic< int > m_numberOfSCT
Definition: SiTrackerSpacePointFinder.h:249
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
SCT_ID::wafer_hash_max
size_type wafer_hash_max(void) const
Definition: SCT_ID.cxx:645
AthReentrantAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthReentrantAlgorithm.cxx:96
InDet::SiTrackerSpacePointFinder::m_selectPixels
BooleanProperty m_selectPixels
Definition: SiTrackerSpacePointFinder.h:201
SG::UpdateHandle
Definition: UpdateHandle.h:94
SCT_ID::layer_disk
int layer_disk(const Identifier &id) const
Definition: SCT_ID.h:734
InDetDD::SiDetectorElement
Definition: SiDetectorElement.h:109
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
PixelID::wafer_hash_max
size_type wafer_hash_max(void) const
Definition: PixelID.cxx:831
InDet::SiTrackerSpacePointFinder::m_monTool
ToolHandle< GenericMonitoringTool > m_monTool
Definition: SiTrackerSpacePointFinder.h:186
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
IdentifiableContainerMT::IDC_WriteHandle::addOrDelete
StatusCode addOrDelete(std::unique_ptr< T > ptr)
Definition: IdentifiableContainerMT.h:53
InDet::SiTrackerSpacePointFinder::m_idHelper
const SCT_ID * m_idHelper
Definition: SiTrackerSpacePointFinder.h:194
InDet::SiTrackerSpacePointFinder::m_selectSCTs
BooleanProperty m_selectSCTs
Definition: SiTrackerSpacePointFinder.h:202
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:76
InDet::SiTrackerSpacePointFinder::m_overlapLimitOpposite
FloatProperty m_overlapLimitOpposite
Definition: SiTrackerSpacePointFinder.h:221
InDet::BeamSpotData
Definition: BeamSpotData.h:21
a
TList * a
Definition: liststreamerinfos.cxx:10
InDet::SiTrackerSpacePointFinder::finalize
virtual StatusCode finalize() override
Definition: SiTrackerSpacePointFinder.cxx:353
h
SG::WriteHandle::record
StatusCode record(std::unique_ptr< T > data)
Record a const object to the store.
ActsTrk::PhiMinus
@ PhiMinus
Definition: StripInformationHelper.h:13
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
ActsTrk::ThisOne
@ ThisOne
Definition: StripInformationHelper.h:13
InDet::SiTrackerSpacePointFinder::m_overlapLimitEtaMin
FloatProperty m_overlapLimitEtaMin
Definition: SiTrackerSpacePointFinder.h:225
AthCommonMsg< Gaudi::Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
InDet::SiTrackerSpacePointFinder::m_overlapLimitEtaMax
FloatProperty m_overlapLimitEtaMax
Definition: SiTrackerSpacePointFinder.h:227
python.BuildSignatureFlags.beamSpot
AthConfigFlags beamSpot(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:454
InDet::SiTrackerSpacePointFinder::m_SpacePointCache_PixKey
SG::UpdateHandleKey< SpacePointCache > m_SpacePointCache_PixKey
Definition: SiTrackerSpacePointFinder.h:178
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
ActsTrk::NeighbourIndices
NeighbourIndices
Total number of neightbours and indices.
Definition: StripInformationHelper.h:13
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
IdentifierHash
This is a "hash" representation of an Identifier. This encodes a 32 bit index which can be used to lo...
Definition: IdentifierHash.h:25
InDet::SCT_ClusterCollection
Trk::PrepRawDataCollection< SCT_Cluster > SCT_ClusterCollection
Definition: SCT_ClusterCollection.h:26
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
InDet::SiTrackerSpacePointFinder::m_overlap
BooleanProperty m_overlap
Definition: SiTrackerSpacePointFinder.h:204
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
InDetDD::SiDetectorElementCollection::getDetectorElement
const SiDetectorElement * getDetectorElement(const IdentifierHash &hash) const
Definition: SiDetectorElementCollection.cxx:15
InDetDD::SolidStateDetectorElementBase::identify
virtual Identifier identify() const override final
identifier of this detector element (inline)
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
fitman.k
k
Definition: fitman.py:528
SCT_ID::is_barrel
bool is_barrel(const Identifier &id) const
Test for barrel - WARNING: id MUST be sct id, otherwise answer is not accurate. Use SiliconID for gen...
Definition: SCT_ID.h:721
ServiceHandle< ICondSvc >
Identifier
Definition: IdentifierFieldParser.cxx:14