ITkSiSpacePointsSeedMaker.h

Go to the documentation of this file.

// -*- C++ -*-
 
/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
//  Header file for class ITk::SiSpacePointsSeedMaker
// Version 1.0 3/10/2004 I.Gavrilenko
 
#ifndef ITkSiSpacePointsSeedMaker_H
#define ITkSiSpacePointsSeedMaker_H
 
#include "InDetRecToolInterfaces/ISiSpacePointsSeedMaker.h"
#include "AthenaBaseComps/AthAlgTool.h"
 
#include "BeamSpotConditionsData/BeamSpotData.h"
#include "SiSPSeededTrackFinderData/ITkSiSpacePointForSeed.h"
#include "SiSPSeededTrackFinderData/SiSpacePointsSeedMakerEventData.h"
#include "TrkSpacePoint/SpacePointContainer.h" 
#include "TrkSpacePoint/SpacePointOverlapCollection.h"
#include "TrkEventUtils/PRDtoTrackMap.h"
 
//for validation
#include "GaudiKernel/ITHistSvc.h"
#include "TFile.h"
#include "TTree.h"
 
 
 
 
// MagField cache
#include "MagFieldConditions/AtlasFieldCacheCondObj.h"
#include "MagFieldElements/AtlasFieldCache.h"
 
#include <iosfwd>
#include <list>
#include <vector>
 
class MsgStream;
 
 
namespace ITk
{
 
  // Object function for ordering space point in R coordinate order
  
  class SiSpacePointsComparison_R {
 
  public: 
    bool operator () (SiSpacePointForSeed* s1, SiSpacePointForSeed* s2) {
      return((*s1).radius() < (*s2).radius());
    }
  };
 
 
  using EventData = InDet::SiSpacePointsSeedMakerEventData;
 
  class SiSpacePointsSeedMaker final: 
    public extends<AthAlgTool, InDet::ISiSpacePointsSeedMaker>
  {
    // Public methods:
      
  public:
      
 
    SiSpacePointsSeedMaker
    (const std::string&,const std::string&,const IInterface*);
    virtual ~SiSpacePointsSeedMaker() = default;
    virtual StatusCode initialize() override;
    virtual StatusCode finalize() override;
 
 
    virtual void newEvent (const EventContext& ctx, EventData& data, int iteration) const override;
    virtual void newRegion(const EventContext& ctx, EventData& data,
                           const std::vector<IdentifierHash>& vPixel, const std::vector<IdentifierHash>& vStrip) const override;
    virtual void newRegion(const EventContext& ctx, EventData& data,
                           const std::vector<IdentifierHash>& vPixel, const std::vector<IdentifierHash>& vStrip,
                           const IRoiDescriptor& iRD) const override;
 
 
 
    virtual void find2Sp(EventData& data, const std::list<Trk::Vertex>& lv) const override;
 
    virtual void find3Sp(const EventContext& ctx, EventData& data, const std::list<Trk::Vertex>& lv) const override;
 
    virtual void find3Sp(const EventContext& ctx, EventData& data, const std::list<Trk::Vertex>& lv, const double* zVertex) const override;
 
    virtual void findVSp(const EventContext& ctx, EventData& data, const std::list<Trk::Vertex>& lv) const override;
      
 
    virtual const InDet::SiSpacePointsSeed* next(const EventContext& ctx, EventData& data) const override;
 
    virtual void writeNtuple(const InDet::SiSpacePointsSeed* seed, const Trk::Track* track, int seedType, long eventNumber) const override;
    virtual bool getWriteNtupleBoolProperty() const override;
 
 
    virtual MsgStream& dump(EventData& data, MsgStream& out) const override;
 
  private:
    enum Size {arraySizePhi=200,     
                arraySizeZ=11,       
                arraySizePhiZ=arraySizePhi*arraySizeZ,   
                arraySizeNeighbourBins=9,  
                arraySizePhiV=100,         
                arraySizeZV=3,             
                arraySizePhiZV=arraySizePhiV*arraySizeZV,      
                arraySizeNeighbourBinsVertex=6};       
 
 
    // Private data and methods
 
 
    SG::ReadHandleKey<SpacePointContainer> m_spacepointsStrip{this, "SpacePointsStripName", "ITkStripSpacePoints", "Strip space points container"};
    SG::ReadHandleKey<SpacePointContainer> m_spacepointsPixel{this, "SpacePointsPixelName", "ITkPixelSpacePoints", "Pixel space points container"};
    SG::ReadHandleKey<SpacePointOverlapCollection> m_spacepointsOverlap{this, "SpacePointsOverlapName", "OverlapSpacePoints"};
    SG::ReadHandleKey<Trk::PRDtoTrackMap> m_prdToTrackMap{this,"PRDtoTrackMap","","option PRD-to-track association"};
    SG::ReadCondHandleKey<InDet::BeamSpotData> m_beamSpotKey{this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot"};
    SG::ReadCondHandleKey<AtlasFieldCacheCondObj> m_fieldCondObjInputKey {this, "AtlasFieldCacheCondObj", "fieldCondObj",
                                                                           "Name of the Magnetic Field conditions object key"};
 
 
    BooleanProperty m_pixel{this, "usePixel", true};
    BooleanProperty m_strip{this, "useStrip", true};
    BooleanProperty m_useOverlap{this, "useOverlapSpCollection", true};
    IntegerProperty m_maxsize{this, "maxSize", 10000};
    IntegerProperty m_maxsizeSP{this, "maxSizeSP", 4096};
    IntegerProperty m_maxOneSize{this, "maxSeedsForSpacePoint", 5};
    FloatProperty m_etamax{this, "etaMax", 2.7};
    FloatProperty m_r1minv{this, "minVRadius1", 0.};
    FloatProperty m_r1maxv{this, "maxVRadius1", 60.};
    FloatProperty m_r2minv{this, "minVRadius2", 70.};
    FloatProperty m_r2maxv{this, "maxVRadius2", 200.};
    FloatProperty m_drmin{this, "mindRadius", 5.};
    FloatProperty m_drmax{this, "maxdRadius", 300.};
    FloatProperty m_zmin{this, "minZ", -250.};
    FloatProperty m_zmax{this , "maxZ", +250.};
    FloatProperty m_r_rmin{this, "radMin", 0.};
    FloatProperty m_binSizeR{this, "radStep", 2.};
    FloatProperty m_dzver{this, "maxdZver", 5.};
    FloatProperty m_dzdrver{this, "maxdZdRver", 0.02};
    FloatProperty m_maxdImpact{this, "maxdImpact", 10.};
    FloatProperty m_maxdImpactSSS{this, "maxdImpactSSS", 20.};
    FloatProperty m_dzmaxPPP{this, "dZmaxForPPPSeeds", 600.};
 
    FloatProperty m_maxScore{this, "maximumAcceptedSeedScore", 100.};
    IntegerProperty m_maxOneSizeSSS{this, "maxSeedsForSpacePointStrips", 5};
    IntegerProperty m_maxOneSizePPP{this, "maxSeedsForSpacePointPixels", 5};
    BooleanProperty m_alwaysKeepConfirmedPixelSeeds{this, "alwaysKeepConfirmedPixelSeeds", false};
    BooleanProperty m_alwaysKeepConfirmedStripSeeds{this, "alwaysKeepConfirmedStripSeeds", false};
    BooleanProperty m_fastTracking{this, "useFastTracking", false};
    FloatProperty m_seedScoreBonusPPP{this, "seedScoreBonusPPP", -200.};
    FloatProperty m_seedScoreBonusSSS{this, "seedScoreBonusSSS", -400.};
    BooleanProperty m_optimisePhiBinning{this, "optimisePhiBinning", true};
    FloatProperty m_rminSSS{this, "radMinSSS", 400.};
    FloatProperty m_rmaxSSS{this, "radMaxSSS", 1000.};
    BooleanProperty m_isLRT{this, "isLRT", false};
    FloatProperty m_drminPPP{this, "mindRadiusPPP", 6.};
    FloatProperty m_drmaxPPP{this, "maxdRadiusPPP", 150.};
    FloatProperty m_zmaxPPP{this, "maxZPPP", 2700.};
    FloatProperty m_drminSSS{this, "mindRadiusSSS", 20.};
    FloatProperty m_drmaxSSS{this, "maxdRadiusSSS", 300.};
    FloatProperty m_zmaxSSS{this, "maxZSSS", 2700.};
    FloatProperty m_dImpactCutSlopeUnconfirmedSSS{this, "dImpactCutSlopeUnconfirmedSSS", 1.0};
    FloatProperty m_dImpactCutSlopeUnconfirmedPPP{this, "dImpactCutSlopeUnconfirmedPPP", 0.};
    FloatProperty m_seedScoreBonusConfirmationSeed{this, "seedScoreBonusConfirmationSeed", -200.};
    BooleanProperty m_useSeedConfirmation{this, "useSeedConfirmation", false};
 
 
    FloatProperty m_etamin{this, "etaMin", 0.};
    FloatProperty m_r_rmax{this, "radMax", 1100.};
    FloatProperty m_ptmin{this, "pTmin", 500.};
    FloatProperty m_umax{this, "minSeedsQuality", 0.};
 
 
    BooleanProperty m_checketa{this, "checkEta", false};
 
 
    int m_outputlevel{0};
    
    float m_dzdrmin0{0.};
    float m_dzdrmax0{0.};
    float m_ipt{0.};
    float m_ipt2{0.};
    float m_COF{134 * .05f * 9};
    float m_dzMaxFast   {200.};
    float m_R2MaxFast   {2500.};        
    float m_rmaxPPP     {140.};
    float m_dzmaxSSS    {900.};    
    float m_drminSeedConf{5.};
 
 
    Gaudi::Property<bool> m_writeNtuple {this, "WriteNtuple", false, "Flag to write Validation Ntuples"};
    ITHistSvc* m_thistSvc;
    TTree* m_outputTree;
    mutable std::mutex m_mutex;
    mutable std::string          m_treeName               ATLAS_THREAD_SAFE;
    mutable TString              m_treeFolder             ATLAS_THREAD_SAFE;
    mutable float                  m_d0                   ATLAS_THREAD_SAFE = 0;
    mutable float                  m_z0                   ATLAS_THREAD_SAFE = 0;
    mutable float                  m_pt                   ATLAS_THREAD_SAFE = 0;
    mutable float                  m_eta                  ATLAS_THREAD_SAFE = 0;
    mutable double                 m_x1                   ATLAS_THREAD_SAFE = 0;
    mutable double                 m_x2                   ATLAS_THREAD_SAFE = 0;
    mutable double                 m_x3                   ATLAS_THREAD_SAFE = 0;
    mutable double                 m_y1                   ATLAS_THREAD_SAFE = 0;
    mutable double                 m_y2                   ATLAS_THREAD_SAFE = 0;
    mutable double                 m_y3                   ATLAS_THREAD_SAFE = 0;
    mutable double                 m_z1                   ATLAS_THREAD_SAFE = 0;
    mutable double                 m_z2                   ATLAS_THREAD_SAFE = 0;
    mutable double                 m_z3                   ATLAS_THREAD_SAFE = 0;
    mutable double                 m_r1                   ATLAS_THREAD_SAFE = 0;
    mutable double                 m_r2                   ATLAS_THREAD_SAFE = 0;
    mutable double                 m_r3                   ATLAS_THREAD_SAFE = 0;
    mutable float                  m_quality              ATLAS_THREAD_SAFE = 0;
    mutable int                    m_type                 ATLAS_THREAD_SAFE = 0;
    mutable double                 m_dzdr_t               ATLAS_THREAD_SAFE = 0;
    mutable double                 m_dzdr_b               ATLAS_THREAD_SAFE = 0;
    mutable bool                   m_givesTrack           ATLAS_THREAD_SAFE = 0;
    mutable float                  m_trackPt              ATLAS_THREAD_SAFE = 0;
    mutable float                  m_trackEta             ATLAS_THREAD_SAFE = 0;
    mutable long                   m_eventNumber          ATLAS_THREAD_SAFE = 0;
 
 
    int m_nBinsR{0};              
    int m_maxPhiBinPPP{0};           
    float m_inverseBinSizePhiPPP{0};   
    int m_maxPhiBinSSS{0};
    float m_inverseBinSizePhiSSS{0};
    int m_maxBinPhiVertex{0};
    float m_inverseBinSizePhiVertex{0};
 
    
    float m_seedScoreThresholdPPPConfirmationSeed{0.};    
    float m_seedScoreThresholdSSSConfirmationSeed{0.};    
 
 
    std::array<int,arraySizePhiZ> m_nNeighbourCellsBottomPPP{};  
    std::array<int,arraySizePhiZ> m_nNeighbourCellsTopPPP{};  
    std::array<std::array<int, arraySizeNeighbourBins>, arraySizePhiZ> m_neighbourCellsBottomPPP{}; 
    std::array<std::array<int, arraySizeNeighbourBins>, arraySizePhiZ> m_neighbourCellsTopPPP{}; 
 
    std::array<int,arraySizePhiZ> m_nNeighbourCellsBottomSSS{};
    std::array<int,arraySizePhiZ> m_nNeighbourCellsTopSSS{};
    std::array<std::array<int, arraySizeNeighbourBins>, arraySizePhiZ> m_neighbourCellsBottomSSS{};
    std::array<std::array<int, arraySizeNeighbourBins>, arraySizePhiZ> m_neighbourCellsTopSSS{};
 
    std::array<int,arraySizePhiZV> m_nNeighboursVertexPhiZ{};
    std::array<std::array<int, arraySizeNeighbourBinsVertex>, arraySizePhiZV> m_neighboursVertexPhiZ{};
 
 
    // Private methods
 
    SiSpacePointsSeedMaker() = delete;
    SiSpacePointsSeedMaker(const SiSpacePointsSeedMaker&) = delete;
    SiSpacePointsSeedMaker &operator=(const SiSpacePointsSeedMaker&) = delete;
 
    MsgStream& dumpConditions(EventData& data, MsgStream& out) const;
    static MsgStream& dumpEvent(EventData& data, MsgStream& out) ;
 
    void buildFrameWork();
 
    static void buildConnectionMaps(std::array<int, arraySizePhiZ>& nNeighbourCellsBottom,
                   std::array<int, arraySizePhiZ>& nNeighbourCellsTop,
                   std::array<std::array<int, arraySizeNeighbourBins>, arraySizePhiZ>& neighbourCellsBottom,
                   std::array<std::array<int, arraySizeNeighbourBins>, arraySizePhiZ>& neighbourCellsTop,
                   int maxPhiBin, bool isSSS);
    static void buildConnectionMapsVertex(std::array<int, arraySizePhiZV>& nNeighbourCells,
                      std::array<std::array<int, arraySizeNeighbourBinsVertex>, arraySizePhiZV>& neighbourCells,
                      int maxPhiBin);
 
    void buildBeamFrameWork(EventData& data) const;
 
    static float azimuthalStep(const float pTmin,const float maxd0,const float Rmin,const float Rmax) ;
 
 
    SiSpacePointForSeed* newSpacePoint(EventData& data, const Trk::SpacePoint*const& sp) const;
    SiSpacePointForSeed* newSpacePoint(EventData& data, const Trk::SpacePoint*const& sp, float* r, bool usePixStripInform=false) const;
 
    static void newSeed
    (EventData& data,
     SiSpacePointForSeed*&,SiSpacePointForSeed*&,float) ;
 
    void newOneSeed
    (EventData& data, 
     SiSpacePointForSeed*&,SiSpacePointForSeed*&,
     SiSpacePointForSeed*&,float,float) const;
 
    void newOneSeedQ
    (EventData& data, 
     SiSpacePointForSeed*&,SiSpacePointForSeed*&,
     SiSpacePointForSeed*&,float,float) const;
 
    void newOneSeedWithCurvaturesComparison
    (EventData& data,
     SiSpacePointForSeed*&,SiSpacePointForSeed*&,float) const;
 
    static void fillSeeds(EventData& data) ;
    void fillLists(EventData& data) const;
    static void pixInform(const Trk::SpacePoint* sp, float* r) ;
    static void stripInform(EventData& data,const Trk::SpacePoint* sp, float* r) ;
    static void erase(EventData& data) ;
    void production2Sp(EventData& data) const;
    void production3Sp(EventData& data) const;
 
      void production3SpSSS
      (EventData& data,
      std::array<std::vector<SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & iter_bottomCands,
      std::array<std::vector<SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & iter_endBottomCands,
      std::array<std::vector<SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & iter_topCands,
      std::array<std::vector<SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & iter_endTopCands,
      const int numberBottomCells, const int numberTopCells, int& nseed) const;
 
      void production3SpPPP
      (EventData& data,
      std::array<std::vector<SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & iter_bottomCands,
      std::array<std::vector<SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & iter_endBottomCands,
      std::array<std::vector<SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & iter_topCands,
      std::array<std::vector<SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & iter_endTopCands,
      const int numberBottomCells, const int numberTopCells, int& nseed) const;
 
      void production3SpTrigger
      (EventData& /*data*/,
       std::array<std::vector<SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & /*rb*/,
       std::array<std::vector<SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & /*rbe*/,
       std::array<std::vector<SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & /*rt*/,
       std::array<std::vector<SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & /*rte*/,
       const int /*numberBottomCells*/, const int /*numberTopCells*/, int& /*nseed*/) const;
 
    void newOneSeedWithCurvaturesComparisonSSS
      (EventData& data, SiSpacePointForSeed*& SPb, SiSpacePointForSeed*& SP0, float Zob) const;
    void newOneSeedWithCurvaturesComparisonPPP
      (EventData& data, SiSpacePointForSeed*& SPb, SiSpacePointForSeed*& SP0, float Zob) const;
    void newOneSeedWithCurvaturesComparisonSeedConfirmation
      (EventData& data, SiSpacePointForSeed*& SPb, SiSpacePointForSeed*& SP0, float Zob) const;
 
 
    bool isConfirmedSeed(const SiSpacePointForSeed* bottomSP, const SiSpacePointForSeed* topSP, float quality) const;
 
 
    void sort(std::vector<InDet::FloatInt>& s, int start, int size) const;
    bool newVertices(EventData& data, const std::list<Trk::Vertex>&) const;
    void findNext(EventData& data) const;
    bool isZCompatible(EventData& data, float Zv, float R, float T) const;
    static void convertToBeamFrameWork(EventData& data, const Trk::SpacePoint*const&,float*) ;
    bool isUsed(const Trk::SpacePoint*, const Trk::PRDtoTrackMap &prd_to_track_map) const;
 
    void initializeEventData(EventData& data, const EventContext& ctx) const;
  };
 
  // Object-function for curvature seeds comparison
 
  class comCurvature {
  public:
    bool operator ()
    (const std::pair<float,SiSpacePointForSeed*>& i1, 
    const std::pair<float,SiSpacePointForSeed*>& i2)
    {
      return i1.first < i2.first;
    }
  };
 
 
  // Test is space point used
 
  inline
  bool SiSpacePointsSeedMaker::isUsed(const Trk::SpacePoint* sp, const Trk::PRDtoTrackMap &prd_to_track_map) const
  {
    const Trk::PrepRawData* d = sp->clusterList().first;
    if (!d || !prd_to_track_map.isUsed(*d)) return false;
 
    d = sp->clusterList().second;
    if (!d || prd_to_track_map.isUsed(*d)) return true;
 
    return false;
  }
 
  // The procedure sorts the elements into ascending order.
  
  inline
  void SiSpacePointsSeedMaker::sort(std::vector<InDet::FloatInt>& s, int start, int size) const
  {
    //QuickSort for fast tracking currently buggy
    //TBC if really faster than std::sort
    //Using std::sort in all cases for now
    std::sort(s.begin()+start,s.begin()+start+size,[](const InDet::FloatInt a, const InDet::FloatInt b)->bool {return a.Fl < b.Fl;});
  }
 
} // namespace ITk
 
#endif // ITkSiSpacePointsSeedMaker_H