SiTrackerSpacePointFinder.h

Go to the documentation of this file.

// -*- C++ -*-
 
/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef SiSpacePointFormation_SI_POINT_FINDER_H
#define SiSpacePointFormation_SI_POINT_FINDER_H
 
#include "AthenaBaseComps/AthReentrantAlgorithm.h"
#include "AthenaMonitoringKernel/GenericMonitoringTool.h"
#include "AthContainers/DataVector.h"
#include "GeoPrimitives/GeoPrimitives.h"
#include "Identifier/Identifier.h"
#include "InDetPrepRawData/PixelClusterCollection.h"
#include "InDetPrepRawData/SCT_ClusterCollection.h"
#include "InDetPrepRawData/SCT_ClusterContainer.h"
#include "InDetPrepRawData/SiClusterContainer.h"
#include "InDetPrepRawData/PixelClusterContainer.h"
#include "InDetReadoutGeometry/SiDetectorElementCollection.h"
#include "SiSpacePointFormation/SiElementPropertiesTable.h"
#include "SiSpacePointTool/SiSpacePointMakerTool.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "TrkSpacePoint/SpacePoint.h"
#include "TrkSpacePoint/SpacePointContainer.h"
#include "TrkSpacePoint/SpacePointOverlapCollection.h"
#include "BeamSpotConditionsData/BeamSpotData.h"
 
#include "GaudiKernel/ToolHandle.h"
//
#include "AthAllocators/DataPool.h"
 
#include <string>
 
class SpacePointCollection; 
class SpacePointOverlapCollection; 
class SpacePointContainer; 
class SCT_ID;
class PixelID;
 
namespace InDet {
 
  class SiTrackerSpacePointFinder:public AthReentrantAlgorithm {
 
  public:
  
    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 { return true; };
 
  private:
    struct SPFCache{
      Amg::Vector3D vertex;
      const EventContext& ctx;
      const SCT_ClusterContainer* SCTCContainer;
      SPFCache(const EventContext& inctx) : ctx(inctx), SCTCContainer(nullptr) { }
    };
 
    // methods
 
    SiTrackerSpacePointFinder() = delete;
    SiTrackerSpacePointFinder(const SiTrackerSpacePointFinder&) =delete;
    SiTrackerSpacePointFinder &operator=(const SiTrackerSpacePointFinder&) = delete;
 
    void addSCT_SpacePoints
      (const SCT_ClusterCollection* next,
       const SiElementPropertiesTable* properties,
       const InDetDD::SiDetectorElementCollection* elements,
       SpacePointCollection* spacepointCollection,
       SpacePointOverlapCollection* spacepointOverlapCollection,
       SPFCache&,
       DataPool<SCT_SpacePoint>* dataItemsSCT) const;
 
    // data members
 
    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"};
 
    SG::ReadCondHandleKey<InDet::BeamSpotData> m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" };
    SG::ReadCondHandleKey<InDet::SiElementPropertiesTable> m_SCTPropertiesKey{this, "SCTPropertiesKey", "SCT_ElementPropertiesTable", "Key of input SiElementPropertiesTable for SCT"};
    SG::ReadCondHandleKey<InDetDD::SiDetectorElementCollection> m_SCTDetEleCollKey{this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"};
 
    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"};
 
    SG::UpdateHandleKey<SpacePointCache> m_SpacePointCache_SCTKey
      {this, "SpacePointCacheSCT", ""};
    SG::UpdateHandleKey<SpacePointCache> m_SpacePointCache_PixKey
      {this, "SpacePointCachePix", ""};
 
    ToolHandle< SiSpacePointMakerTool > m_SiSpacePointMakerTool{this, "SiSpacePointMakerTool", "InDet::SiSpacePointMakerTool"};
    ToolHandle<GenericMonitoringTool> m_monTool{this, "monTool", "", "Monitoring tool"};
 
    const PixelID* m_idHelperPixel{nullptr};
    const SCT_ID* m_idHelper{nullptr};
 
    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}; 
    BooleanProperty m_useDataPoolWithCache
      {this, "useDataPoolWithCache", false, "use DataPool With Cache"};
    BooleanProperty m_useSCTLayerDep_OverlapCuts{this,"useSCTLayerDep_OverlapCuts", true};
    BooleanProperty m_doEndcapEtaOverlapSP{this,"doEndcapEtaOverlapSP", false};
 
    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"};
 
    BooleanProperty m_overrideBS{this, "OverrideBeamSpot", false};
    FloatProperty m_xVertex{this, "VertexX", 0.};
    FloatProperty m_yVertex{this, "VertexY", 0.};
    FloatProperty m_zVertex{this, "VertexZ", 0.};
 
    mutable std::atomic<int> m_numberOfEvents{0};
    mutable std::atomic<int> m_numberOfPixel{0};
    mutable std::atomic<int> m_numberOfSCT{0};
    mutable std::atomic<int> m_sctCacheHits{0};
    mutable std::atomic<int> m_pixCacheHits{0};
    mutable std::atomic<int> m_nspacePoints{0};
    mutable std::atomic<int> m_nspacePointsOverlap{0};
    
  };
 
}
 
#endif // SiSpacePointFormation_SI_POINT_FINDER_H