InDet::SiTrackerSpacePointFinder Class Reference

This version of PointFinder uses SiCluster to find space points in the pixel and SCT detectors. More...

#include <SiTrackerSpacePointFinder.h>

Inheritance diagram for InDet::SiTrackerSpacePointFinder:

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

Public Member Functions
virtual bool	isReEntrant () const override
	Avoid scheduling algorithm multiple times.
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
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.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
AthCondAlgorithm 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.

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

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>
Disallow constructor without parameters, copy constructor, assignment operator
	SiTrackerSpacePointFinder ()=delete
	SiTrackerSpacePointFinder (const SiTrackerSpacePointFinder &)=delete
SiTrackerSpacePointFinder &	operator= (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.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared
Input data using SG::ReadHandleKey
SG::ReadHandleKey< SCT_ClusterContainer >	m_Sct_clcontainerKey {this, "SCT_ClustersName", "SCT_Clusters", "SCT clContainer"}
SG::ReadHandleKey< PixelClusterContainer >	m_Pixel_clcontainerKey {this, "PixelsClustersName", "PixelClusters", "Pixel clContainer"}
Input condition data using SG::ReadCondHandleKey
SG::ReadCondHandleKey< InDet::BeamSpotData >	m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" }
	For beam spot.
SG::ReadCondHandleKey< InDet::SiElementPropertiesTable >	m_SCTPropertiesKey {this, "SCTPropertiesKey", "SCT_ElementPropertiesTable", "Key of input SiElementPropertiesTable for SCT"}
	To get SCT neighbours.
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection >	m_SCTDetEleCollKey {this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"}
	For SCT alignment.
Output data using SG::WriteHandleKey
SG::WriteHandleKey< SpacePointContainer >	m_SpacePointContainer_SCTKey {this, "SpacePointsSCTName", "SCT_SpacePoints", "SpacePoint SCT container"}
SG::WriteHandleKey< SpacePointContainer >	m_SpacePointContainerPixelKey {this, "SpacePointsPixelName", "PixelSpacePoints", "SpacePoint Pixel container"}
SG::WriteHandleKey< SpacePointOverlapCollection >	m_spacepointoverlapCollectionKey {this, "SpacePointsOverlapName", "OverlapSpacePoints", "Space Point Overlap collection"}
Caches for HLT using SG::UpdateHandleKey
SG::UpdateHandleKey< SpacePointCache >	m_SpacePointCache_SCTKey {this, "SpacePointCacheSCT", ""}
SG::UpdateHandleKey< SpacePointCache >	m_SpacePointCache_PixKey {this, "SpacePointCachePix", ""}
ToolHandle
ToolHandle< SiSpacePointMakerTool >	m_SiSpacePointMakerTool {this, "SiSpacePointMakerTool", "InDet::SiSpacePointMakerTool"}
ToolHandle< GenericMonitoringTool >	m_monTool {this, "monTool", "", "Monitoring tool"}
Id helpers
const PixelID *	m_idHelperPixel {nullptr}
const SCT_ID *	m_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
BooleanProperty	m_useDataPoolWithCache {this, "useDataPoolWithCache", false, "use DataPool With Cache"}
BooleanProperty	m_useSCTLayerDep_OverlapCuts {this,"useSCTLayerDep_OverlapCuts", true}
BooleanProperty	m_doEndcapEtaOverlapSP {this,"doEndcapEtaOverlapSP", false}
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. AthCondAlgorithm 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}
std::atomic< int >	m_nspacePoints {0}
std::atomic< int >	m_nspacePointsOverlap {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 37 of file SiTrackerSpacePointFinder.cxx.

    : AthCondAlgorithm(name, pSvcLocator)
{ }

~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 378 of file SiTrackerSpacePointFinder.cxx.

{
  // For each trigger element, first evaluate and collect the quantities you need to build the space points.
  // The detector element array has capacity 6:
  // [0] is the trigger element
  // [1] is the opposite element
  // [2]-[3] are the elements tested for eta overlaps
  // [4]-[5] are the elements tested for phi overlaps
  // For each element you save the corresponding cluster collections and the 
  // space point compatibility range as described below.
  // 
  // For the opposite element and the ones tested for eta overlaps, you have to check 
  // if clusters are compatible with the local position of the trigger cluster
  // requiring that the distance between the two clusters in phi is withing a specified range.
  // - For the clusters on the opposite element: [-m_overlapLimitOpposite, m_overlapLimitOpposite]
  //
  // - For the eta overlapping clusters : you use m_overlapLimitEtaMin and m_overlapLimitEtaMax
  //   in different combination depending if you are checking a stereo module or not
  //
  // For each element, the extremes of these ranges are saved in the overlapExtents array 
  // which is later on used in SiSpacePointMakerTool::fillSCT_SpacePointCollection
  //   - overlapExtents[0], overlapExtents[1] are filled for the opposite element
  //   - overlapExtents[2], overlapExtents[3], overlapExtents[4], overlapExtents[5] are filled for the eta overlapping elements
  //
  // For the elements tested for phi overlaps, you have to check 
  // if clusters are compatible with the local position of the trigger cluster. 
  // This needs that the trigger cluster is at the edge of the trigger module:
  // e.g. -hwidth < locX_trigger < -hwidth+m_overlapLimitPhi (or hwidth-m_overlapLimitPhi < locX_trigger < hwidth)
  // and that the other cluster is on the compatible edge of its module:
  // e.g. hwidth-m_overlapLimitPhi < locX_other < hwidth (or -hwidth < locX_other < -hwidth+m_overlapLimitPhi)
  //
  // For each element, the extremes of these ranges are saved in the overlapExtents array 
  // which is later on used in SiSpacePointMakerTool::fillSCT_SpacePointCollection
  //   - overlapExtents[6], overlapExtents[7], overlapExtents[10], overlapExtents[11]
  //     overlapExtents[8], overlapExtents[9], overlapExtents[12], overlapExtents[13] are filled for the phi overlapping elements
  
  enum NeighbourIndices{ThisOne, Opposite, PhiMinus, PhiPlus, EtaMinus, EtaPlus, nNeighbours};
  
  std::array<const SCT_ClusterCollection*, nNeighbours> neighbourClusters{};
  std::array<const InDetDD::SiDetectorElement*, nNeighbours> neighbourElements{};
  std::array<double, 14> overlapExtents{};
  
  // Get the detector element (and its Identifier) correspoding to the cluster collection
  IdentifierHash triggerIdHash(sctClusters->identifyHash());
  const InDetDD::SiDetectorElement *triggerElement = elements->getDetectorElement(triggerIdHash);
  Identifier thisID = triggerElement->identify();
 
  // Retrieve the neighbours of the detector element
  const std::vector<IdentifierHash>* others(properties->neighbours(triggerIdHash));
  if (others==nullptr || others->empty() ) return;
 
  // Save the current detector element and clusters
  neighbourElements[0]  = triggerElement;
  neighbourClusters[0]  = sctClusters;
  int n    = 0      ;
  
  // Default case: you test the opposite element and the overlapping in phi (total 3 elements)
  int Nmax = 4      ; 
  
  // In the barrel, test the eta overlaps as well (total 5 elements)
  // or also in the endcaps if we specifically request it
  if (m_idHelper->is_barrel(thisID) || m_doEndcapEtaOverlapSP) Nmax = 6;
  
  // You can remove all the overlaps if requrested. Here you test only the opposite element
  if(!m_overlap) Nmax = 2;
 
  float hwidth(properties->halfWidth(triggerIdHash));
  
  // This flag is use to trigger if the search should be performed.
  // In case there are no other detector elements and/or cluster collection
  // this flag stays false.
  bool  search = false;
  
  // The order of the elements in others is such that you first get the opposite element, 
  // the overlapping in phi and then the overlapping in eta
  // For this reason you need to re-order the indices, since the SiSpacePointMakerTool will process 
  // first the eta overlaps and then the phi ones
  const std::array<size_t, nNeighbours> neigbourIndices{ThisOne, Opposite, EtaMinus, EtaPlus, PhiMinus, PhiPlus};
  
  for (const auto& otherHash : *others) {
 
    if(++n==Nmax) break;
    const SCT_ClusterCollection*      otherClusters = r_cache.SCTCContainer->indexFindPtr      (otherHash);
    const InDetDD::SiDetectorElement*  otherElement = elements             ->getDetectorElement(otherHash);
 
    if(!otherElement || !otherClusters) continue;
 
    neighbourElements[neigbourIndices[n]] = otherElement; 
    neighbourClusters[neigbourIndices[n]] = otherClusters;
    search      = true ;
    
    switch (n) {
      case Opposite: {
        overlapExtents[ 0] = -m_overlapLimitOpposite;
        overlapExtents[ 1] =  m_overlapLimitOpposite;
        break;
      }
      case PhiMinus: {
        overlapExtents[ 6] =-hwidth;
        overlapExtents[ 7] =-hwidth+m_overlapLimitPhi;
        overlapExtents[ 8] = hwidth-m_overlapLimitPhi;
        overlapExtents[ 9] = hwidth;
        break;
      }
      case PhiPlus: {
        overlapExtents[10] = hwidth-m_overlapLimitPhi;
        overlapExtents[11] = hwidth;
        overlapExtents[12] =-hwidth;
        overlapExtents[13] =-hwidth+m_overlapLimitPhi;
        break;
      } 
      case EtaMinus: {
        overlapExtents[ 2] = m_overlapLimitEtaMin;
        overlapExtents[ 3] = m_overlapLimitEtaMax;
        if (m_useSCTLayerDep_OverlapCuts && (m_idHelper->layer_disk(thisID) & 1) != 0) {
          overlapExtents[ 2] =-m_overlapLimitEtaMax;
          overlapExtents[ 3] =-m_overlapLimitEtaMin;
        }
        break;
      }
      default: {
        overlapExtents[ 4] = m_overlapLimitEtaMin;
        overlapExtents[ 5] = m_overlapLimitEtaMax;
        if (m_useSCTLayerDep_OverlapCuts && (m_idHelper->layer_disk(thisID) & 1) == 0) {
          overlapExtents[ 4] = -m_overlapLimitEtaMax;
          overlapExtents[ 5] = -m_overlapLimitEtaMin;
        }
        break;
      }
    }
  }
 
  if (search) {
    m_SiSpacePointMakerTool->fillSCT_SpacePointCollection(
        neighbourElements, neighbourClusters, overlapExtents, m_allClusters,
        r_cache.vertex, spacepointCollection, spacepointOverlapCollection,
        dataItemsSCT);
  }
}

cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::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.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

{
  return 0;
}

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

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.

{ return m_detStore; }

evtStore()

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.

{ return m_evtStore; }

execute()

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

overridevirtual

Definition at line 109 of file SiTrackerSpacePointFinder.cxx.

{
  ++m_numberOfEvents;
  const InDetDD::SiDetectorElementCollection* elements = nullptr;
  const SiElementPropertiesTable* properties = nullptr;
  
  auto nReceivedSPsSCT = Monitored::Scalar<int>( "numSctSpacePoints" , 0 );
  auto nReceivedSPsPIX = Monitored::Scalar<int>( "numPixSpacePoints" , 0 );
 
  auto mon = Monitored::Group( m_monTool, nReceivedSPsPIX,nReceivedSPsSCT );
 
  if (m_selectSCTs) {
    SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> sctDetEle(m_SCTDetEleCollKey, ctx);
    elements = sctDetEle.retrieve();
    if (elements==nullptr) {
      ATH_MSG_FATAL("Pointer of SiDetectorElementCollection (" << m_SCTDetEleCollKey.fullKey() << ") could not be retrieved");
      return StatusCode::SUCCESS;
    }
    SG::ReadCondHandle<SiElementPropertiesTable> sctProperties(m_SCTPropertiesKey, ctx);
    properties = sctProperties.retrieve();
    if (properties==nullptr) {
      ATH_MSG_FATAL("Pointer of SiElementPropertiesTable (" << m_SCTPropertiesKey.fullKey() << ") could not be retrieved");
      return StatusCode::SUCCESS;
    }
  }
  SPFCache r_cache(ctx);
  if (! m_overrideBS){
    SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey, ctx };
    const InDet::BeamSpotData* beamSpot = *beamSpotHandle;
    r_cache.vertex = beamSpot->beamVtx().position();
  } else {
    r_cache.vertex = Amg::Vector3D(m_xVertex,m_yVertex,m_zVertex);
  }
 
  // register the IdentifiableContainer into StoreGate
  SG::WriteHandle<SpacePointContainer> spacePointContainerPixel;
  std::unique_ptr<DataPool<PixelSpacePoint>> dataItemsPixel = nullptr;
  if (m_selectPixels){
    spacePointContainerPixel = SG::WriteHandle<SpacePointContainer>( m_SpacePointContainerPixelKey, ctx );
    if(m_SpacePointCache_PixKey.key().empty()){
       ATH_CHECK( spacePointContainerPixel.record( std::make_unique<SpacePointContainer>(m_idHelperPixel->wafer_hash_max()) ) );
       ATH_MSG_DEBUG("Created SpacePointContainer " << m_SpacePointContainerPixelKey.key() << " N= " << m_idHelperPixel->wafer_hash_max());
    }else{
       SG::UpdateHandle<SpacePointCache> updateH( m_SpacePointCache_PixKey, ctx );
       ATH_CHECK(updateH.isValid());
       ATH_CHECK( spacePointContainerPixel.record( std::make_unique<SpacePointContainer>(updateH.ptr()) ) );
       ATH_MSG_DEBUG("Created SpacePointContainer " << m_SpacePointContainerPixelKey.key() << " from cache " << m_SpacePointCache_PixKey.key());
    }
    const bool hasExternalCache = spacePointContainerPixel->hasExternalCache();
    if (!hasExternalCache) {
       dataItemsPixel = std::make_unique<DataPool<PixelSpacePoint>>(ctx);
       dataItemsPixel->reserve(5000);  // Some large default size
    } else if (m_useDataPoolWithCache) {
       dataItemsPixel = std::make_unique<DataPool<PixelSpacePoint>>(ctx);
       // Default size for now 1024 let it expand on its own
    }
  }
 
  SG::WriteHandle<SpacePointContainer> spacePointContainer_SCT;
  std::unique_ptr<DataPool<SCT_SpacePoint>> dataItemsSCT = nullptr;
  if (m_selectSCTs){
    spacePointContainer_SCT = SG::WriteHandle<SpacePointContainer>( m_SpacePointContainer_SCTKey, ctx );
    if(m_SpacePointCache_SCTKey.key().empty()){
       ATH_CHECK( spacePointContainer_SCT.record( std::make_unique<SpacePointContainer>(m_idHelper->wafer_hash_max()) ) );
       ATH_MSG_DEBUG("Created SpacePointContainer " << m_SpacePointContainer_SCTKey.key() << " N= " << m_idHelper->wafer_hash_max());
    }else{
       SG::UpdateHandle<SpacePointCache> updateH( m_SpacePointCache_SCTKey, ctx );
       ATH_CHECK(updateH.isValid());
       ATH_CHECK( spacePointContainer_SCT.record( std::make_unique<SpacePointContainer>(updateH.ptr()) ) );
       ATH_MSG_DEBUG("Created SpacePointContainer " << m_SpacePointContainer_SCTKey.key() << " from cache " << m_SpacePointCache_SCTKey.key());
    }
    const bool hasExternalCache = spacePointContainer_SCT->hasExternalCache();
    if (!hasExternalCache) {
      dataItemsSCT = std::make_unique<DataPool<SCT_SpacePoint>>(ctx);
      dataItemsSCT->reserve(10000);  // Some large default size
    } else if (m_useDataPoolWithCache) {
      dataItemsSCT = std::make_unique<DataPool<SCT_SpacePoint>>(ctx);
      // Default size for now 1024 let it expand on its own
    }
  }
 
  SG::WriteHandle<SpacePointOverlapCollection> spacepointoverlapCollection;
  if(m_overlap){
    spacepointoverlapCollection = SG::WriteHandle<SpacePointOverlapCollection>( m_spacepointoverlapCollectionKey, ctx );
    ATH_CHECK( spacepointoverlapCollection.record( std::make_unique<SpacePointOverlapCollection>() ) );
    if (dataItemsSCT) {
      // if we have a DataPool it will own the elements
      spacepointoverlapCollection.ptr()->clear(SG::VIEW_ELEMENTS);
    }
    ATH_MSG_DEBUG( "Container '" << spacepointoverlapCollection.name() << "' initialised" );
  }
 
  int sctCacheCount = 0;
  int pixCacheCount = 0;
 
  if (m_selectSCTs){
    // retrieve SCT cluster container
    SG::ReadHandle<SCT_ClusterContainer> sct_clcontainer( m_Sct_clcontainerKey, ctx );
    if (!sct_clcontainer.isValid()){
      msg(MSG:: FATAL) << "Could not find the data object "<< sct_clcontainer.name() << " !" << endmsg;
      return StatusCode::RECOVERABLE;
    }
 
    r_cache.SCTCContainer = sct_clcontainer.cptr();
 
    ATH_MSG_DEBUG( "SCT Cluster container found: " << sct_clcontainer->size() << " collections" );
    // Get hold of all clusters and iterate through them.
    // Pixel clusters will be converted immediately to pixel space points.
    // For SCT clusters, posssible pairs will be found and space points computed.
    // It is possible, though unlikely, that there are no clusters for the
    // event. Therefore we do not terminate the job if we don't find any.
    SCT_ClusterContainer::const_iterator it = sct_clcontainer->begin();
    SCT_ClusterContainer::const_iterator itend = sct_clcontainer->end();
 
    for (; it != itend; ++it){
      const SCT_ClusterCollection *colNext=&(**it);
 
      // Create SpacePointCollection
      IdentifierHash idHash = colNext->identifyHash();
      SpacePointContainer::IDC_WriteHandle lock = spacePointContainer_SCT->getWriteHandle(idHash);
      if(lock.OnlineAndPresentInAnotherView()){
          ATH_MSG_DEBUG("SCT Hash " << idHash << " is already in cache");
          ++sctCacheCount;
          continue; //Skip if already present in cache
      }
 
      Identifier elementID = colNext->identify();
      auto spacepointCollection = std::make_unique<SpacePointCollection>(idHash);
      spacepointCollection->setIdentifier(elementID);
      if(dataItemsSCT){
        //if we have a DataPool it will own the elements
        spacepointCollection->clear(SG::VIEW_ELEMENTS);
      }
 
      if(!colNext->empty() && !elements->getDetectorElement(colNext->identifyHash())->isStereo()) {
        addSCT_SpacePoints(
            colNext, properties, elements, spacepointCollection.get(),
            spacepointoverlapCollection.ptr(), r_cache, dataItemsSCT.get());
      } else {
        ATH_MSG_DEBUG( "Empty SCT cluster collection" );
      }
 
      size_t size = spacepointCollection->size();
      if (size == 0){
        ATH_MSG_VERBOSE( "SiTrackerSpacePointFinder algorithm found no space points" );
      } else {
        //In a MT environment the cache maybe filled by another thread in which case this will delete the duplicate
        StatusCode sc= lock.addOrDelete( std::move(spacepointCollection) );
        if (sc.isFailure()){
          ATH_MSG_ERROR( "Failed to add SpacePoints to container" );
          return StatusCode::RECOVERABLE;
        }
        ATH_MSG_VERBOSE( size << " SpacePoints successfully added to Container !" );
        nReceivedSPsSCT += size;
        m_nspacePoints += size;
      }
    }
    m_numberOfSCT+= sct_clcontainer->size();
  }
 
  if (m_selectPixels)
  {
 
    SG::ReadHandle<PixelClusterContainer> pixel_clcontainer( m_Pixel_clcontainerKey, ctx );
    if (!pixel_clcontainer.isValid()){
      msg(MSG:: FATAL) << "Could not find the data object "<< pixel_clcontainer.name() << " !" << endmsg;
      return StatusCode::RECOVERABLE;
    }
 
    ATH_MSG_DEBUG( "Data object " << pixel_clcontainer.name() << " found" );
 
    // loop over Pixel clusterCollections
    PixelClusterContainer::const_iterator colNext = pixel_clcontainer->begin();
    PixelClusterContainer::const_iterator lastCol = pixel_clcontainer->end();
 
 
    int numColl=0;
    for (; colNext != lastCol; ++colNext)
    {
      ATH_MSG_VERBOSE( "Collection num " << numColl++ );
      IdentifierHash idHash = (*colNext)->identifyHash();
      SpacePointContainer::IDC_WriteHandle lock = spacePointContainerPixel->getWriteHandle(idHash);
      if(lock.OnlineAndPresentInAnotherView()){
          ATH_MSG_DEBUG("pixel Hash " << idHash << " is already in cache");
          ++pixCacheCount;
          continue;
      }
      // Create SpacePointCollection
      Identifier elementID = (*colNext)->identify();
      auto spacepointCollection = std::make_unique< SpacePointCollection >(idHash);
      spacepointCollection->setIdentifier(elementID);
      if(dataItemsPixel){
        //if we have a DataPool it will own the elements
        spacepointCollection->clear(SG::VIEW_ELEMENTS);
      }
 
      if (!(*colNext)->empty())
      {
        m_SiSpacePointMakerTool->fillPixelSpacePointCollection(
            *colNext, spacepointCollection.get(), dataItemsPixel.get());
      } else {
        ATH_MSG_DEBUG( "Empty pixel cluster collection" );
      }
      size_t size = spacepointCollection->size();
      if (size == 0)
      {
        ATH_MSG_DEBUG( "SiTrackerSpacePointFinder algorithm found no space points" );
      }
      else
      {
        StatusCode sc = lock.addOrDelete( std::move(spacepointCollection) );
        if (sc.isFailure())
        {
          ATH_MSG_ERROR( "Failed to add SpacePoints to container" );
          return StatusCode::RECOVERABLE;
        }
        ATH_MSG_VERBOSE( size
            << " SpacePoints successfully added to Container !" );
        nReceivedSPsPIX += size;
        m_nspacePoints += size;
      }
    }
    m_numberOfPixel+= pixel_clcontainer->size();
  }
 
  // store the overlap space points.
  // check that the set isn't empty.
  if(m_overlap){
    if (spacepointoverlapCollection->empty())
    {
      ATH_MSG_DEBUG( "No overlap space points found" );
    }
    else
    {
      ATH_MSG_DEBUG( spacepointoverlapCollection->size() <<" overlap space points registered." );
      m_nspacePointsOverlap += spacepointoverlapCollection->size();
    }
  }
 
  if(m_cachemode)//Prevent unnecessary atomic counting
  {
     m_sctCacheHits  += sctCacheCount;
     m_pixCacheHits  += pixCacheCount;
  }
  
  return StatusCode::SUCCESS;
  
}

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 & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return BaseAlg::extraOutputDeps();
}

filterPassed()

virtual bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

finalize()

StatusCode InDet::SiTrackerSpacePointFinder::finalize ( )

overridevirtual

Definition at line 359 of file SiTrackerSpacePointFinder.cxx.

{
  ATH_MSG_DEBUG( m_numberOfEvents << " events processed" );
  ATH_MSG_DEBUG( m_numberOfPixel << " pixel collections processed" );
  ATH_MSG_DEBUG( m_numberOfSCT << " sct collections processed" );
  ATH_MSG_DEBUG( m_nspacePoints+m_nspacePointsOverlap << " space points made, including "<<
                 m_nspacePointsOverlap << " overlap space points" );
  
  if(m_cachemode){
    //These are debug messages because they can be indeterminate in an MT environment and it could
    //lead to confusing log comparisons.
    ATH_MSG_DEBUG( m_sctCacheHits << " sct cache hits" );
    ATH_MSG_DEBUG( m_pixCacheHits << " pix cache hits" );
  }
  return StatusCode::SUCCESS;
}

initialize()

StatusCode InDet::SiTrackerSpacePointFinder::initialize ( )

overridevirtual

Definition at line 43 of file SiTrackerSpacePointFinder.cxx.

{
  // Check that clusters, space points and ids have names
  if (m_selectSCTs && m_Sct_clcontainerKey.key().empty()){
    ATH_MSG_FATAL( "SCTs selected and no name set for SCT clusters");
    return StatusCode::FAILURE;
  }
  ATH_CHECK( m_Sct_clcontainerKey.initialize(m_selectSCTs) );
 
  if (m_selectPixels && m_Pixel_clcontainerKey.key().empty()){
    ATH_MSG_FATAL( "Pixels selected and no name set for Pixel clusters");
    return StatusCode::FAILURE;
  }
  ATH_CHECK( m_Pixel_clcontainerKey.initialize(m_selectPixels) );
 
  if (m_selectSCTs && m_SpacePointContainer_SCTKey.key().empty()){
    ATH_MSG_FATAL( "No name set for SCT space points");
    return StatusCode::FAILURE;
  }
  ATH_CHECK( m_SpacePointContainer_SCTKey.initialize(m_selectSCTs) );
 
  if (m_selectPixels && m_SpacePointContainerPixelKey.key().empty()){
    ATH_MSG_FATAL( "No name set for Pixels space points");
    return StatusCode::FAILURE;
  }
  ATH_CHECK( m_SpacePointContainerPixelKey.initialize(m_selectPixels) );
 
  if (m_overlap && m_spacepointoverlapCollectionKey.key().empty()){
    ATH_MSG_FATAL( "No name set for overlap space points");
    return StatusCode::FAILURE;
  }
  ATH_CHECK( m_spacepointoverlapCollectionKey.initialize(m_overlap) );
 
  // create containers (requires the Identifier Helpers)
  if (m_selectPixels){
    ATH_CHECK(detStore()->retrieve(m_idHelperPixel,"PixelID"));
  }
 
  if (m_selectSCTs) {
    ATH_CHECK(detStore()->retrieve(m_idHelper,"SCT_ID"));
  }
 
  // Initialize the key of input SiElementPropertiesTable and SiDetectorElementCollection for SCT
  ATH_CHECK(m_SCTPropertiesKey.initialize(m_selectSCTs));
  ATH_CHECK(m_SCTDetEleCollKey.initialize(m_selectSCTs));
 
  ATH_CHECK(m_SiSpacePointMakerTool.retrieve());
  ATH_CHECK(m_beamSpotKey.initialize(!m_overrideBS));
 
  ATH_CHECK(m_SpacePointCache_SCTKey.initialize(!m_SpacePointCache_SCTKey.key().empty()));
  ATH_CHECK(m_SpacePointCache_PixKey.initialize(!m_SpacePointCache_PixKey.key().empty()));
  m_cachemode = !m_SpacePointCache_SCTKey.key().empty() || !m_SpacePointCache_PixKey.key().empty();
 
  if (!m_monTool.empty()) CHECK(m_monTool.retrieve());
 
  if(m_useSCTLayerDep_OverlapCuts)
    ATH_MSG_INFO("Use SCT SP overlap cuts based on layer number parity");
 
  if(m_doEndcapEtaOverlapSP)
    ATH_MSG_INFO("Doing eta overlap space points in strips endcap");
 
  return StatusCode::SUCCESS;
}

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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >.

Definition at line 103 of file SiTrackerSpacePointFinder.h.

{ return true; };

isReEntrant()

virtual bool AthCondAlgorithm::isReEntrant ( ) const

inlineoverridevirtualinherited

Avoid scheduling algorithm multiple times.

With multiple concurrent events, conditions objects often expire simultaneously for all slots. To avoid that the scheduler runs the CondAlg in each slot, we declare it as "non-reentrant". This ensures that the conditions objects are only created once.

In case a particular CondAlg should behave differently, it can override this method again and return true.

See also

ATEAM-836

Definition at line 39 of file AthCondAlgorithm.h.

{ return false; }

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

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.

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

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.

                                                          {
    handlesArray.renounce();
  }

setFilterPassed()

virtual void AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::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 85 of file AthCommonReentrantAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::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 HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

                                                               {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

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.

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

Member Data Documentation

m_allClusters

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

private

Definition at line 205 of file SiTrackerSpacePointFinder.h.

{this, "AllClusters", false, "process all clusters without limits"};

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.

{ this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" };

m_cachemode

bool InDet::SiTrackerSpacePointFinder::m_cachemode {false}

private

used for online MT counters

Definition at line 207 of file SiTrackerSpacePointFinder.h.

{false}; 

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_doEndcapEtaOverlapSP

BooleanProperty InDet::SiTrackerSpacePointFinder::m_doEndcapEtaOverlapSP {this,"doEndcapEtaOverlapSP", false}

private

Definition at line 211 of file SiTrackerSpacePointFinder.h.

{this,"doEndcapEtaOverlapSP", false};

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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

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

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

m_idHelper

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

private

Definition at line 194 of file SiTrackerSpacePointFinder.h.

{nullptr};

m_idHelperPixel

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

private

Definition at line 193 of file SiTrackerSpacePointFinder.h.

{nullptr};

m_monTool

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

private

Definition at line 186 of file SiTrackerSpacePointFinder.h.

{this, "monTool", "", "Monitoring tool"};

m_nspacePoints

std::atomic<int> InDet::SiTrackerSpacePointFinder::m_nspacePoints {0}

mutableprivate

Definition at line 254 of file SiTrackerSpacePointFinder.h.

{0};

m_nspacePointsOverlap

std::atomic<int> InDet::SiTrackerSpacePointFinder::m_nspacePointsOverlap {0}

mutableprivate

Definition at line 255 of file SiTrackerSpacePointFinder.h.

{0};

m_numberOfEvents

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

mutableprivate

Definition at line 249 of file SiTrackerSpacePointFinder.h.

{0};

m_numberOfPixel

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

mutableprivate

Definition at line 250 of file SiTrackerSpacePointFinder.h.

{0};

m_numberOfSCT

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

mutableprivate

Definition at line 251 of file SiTrackerSpacePointFinder.h.

{0};

m_overlap

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

private

Definition at line 203 of file SiTrackerSpacePointFinder.h.

{this, "ProcessOverlaps", true, "process overlaps of SCT wafers"};

m_overlapLimitEtaMax

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

private

Definition at line 228 of file SiTrackerSpacePointFinder.h.

{this, "OverlapLimitEtaMax", 3.0, "high overlap limit for eta-neighbours"};

m_overlapLimitEtaMin

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

private

Definition at line 226 of file SiTrackerSpacePointFinder.h.

{this, "OverlapLimitEtaMin", 1.68, "low overlap limit for eta-neighbours"};

m_overlapLimitOpposite

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

private

Definition at line 222 of file SiTrackerSpacePointFinder.h.

{this, "OverlapLimitOpposite", 2.8, "overlap limit for opposite-neighbour"};

m_overlapLimitPhi

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

private

Definition at line 224 of file SiTrackerSpacePointFinder.h.

{this, "OverlapLimitPhi", 5.64, "overlap limit for phi-neighbours"};

m_overrideBS

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

private

Definition at line 236 of file SiTrackerSpacePointFinder.h.

{this, "OverrideBeamSpot", false};

m_pixCacheHits

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

mutableprivate

Definition at line 253 of file SiTrackerSpacePointFinder.h.

{0};

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.

{this, "PixelsClustersName", "PixelClusters", "Pixel clContainer"};

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.

{this, "SCT_ClustersName", "SCT_Clusters", "SCT clContainer"};

m_sctCacheHits

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

mutableprivate

Definition at line 252 of file SiTrackerSpacePointFinder.h.

{0};

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.

{this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"};

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.

{this, "SCTPropertiesKey", "SCT_ElementPropertiesTable", "Key of input SiElementPropertiesTable for SCT"};

m_selectPixels

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

private

Definition at line 201 of file SiTrackerSpacePointFinder.h.

{this, "ProcessPixels", true};

m_selectSCTs

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

private

Definition at line 202 of file SiTrackerSpacePointFinder.h.

{this, "ProcessSCTs", true};

m_SiSpacePointMakerTool

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

private

Definition at line 185 of file SiTrackerSpacePointFinder.h.

{this, "SiSpacePointMakerTool", "InDet::SiSpacePointMakerTool"};

m_SpacePointCache_PixKey

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

private

Definition at line 177 of file SiTrackerSpacePointFinder.h.

{this, "SpacePointCachePix", ""};

m_SpacePointCache_SCTKey

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

private

Definition at line 175 of file SiTrackerSpacePointFinder.h.

{this, "SpacePointCacheSCT", ""};

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.

{this, "SpacePointsSCTName", "SCT_SpacePoints", "SpacePoint SCT container"};

m_SpacePointContainerPixelKey

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

private

Definition at line 167 of file SiTrackerSpacePointFinder.h.

{this, "SpacePointsPixelName", "PixelSpacePoints", "SpacePoint Pixel container"};

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.

{this, "SpacePointsOverlapName", "OverlapSpacePoints", "Space Point Overlap collection"};

m_useDataPoolWithCache

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

private

Definition at line 208 of file SiTrackerSpacePointFinder.h.

{this, "useDataPoolWithCache", false, "use DataPool With Cache"};

m_useSCTLayerDep_OverlapCuts

BooleanProperty InDet::SiTrackerSpacePointFinder::m_useSCTLayerDep_OverlapCuts {this,"useSCTLayerDep_OverlapCuts", true}

private

Definition at line 210 of file SiTrackerSpacePointFinder.h.

{this,"useSCTLayerDep_OverlapCuts", true};

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 237 of file SiTrackerSpacePointFinder.h.

{this, "VertexX", 0.};

m_yVertex

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

private

Definition at line 238 of file SiTrackerSpacePointFinder.h.

{this, "VertexY", 0.};

m_zVertex

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

private

Definition at line 239 of file SiTrackerSpacePointFinder.h.

{this, "VertexZ", 0.};

---

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

• SiTrackerSpacePointFinder.h
• SiTrackerSpacePointFinder.cxx