SiSpacePointsSeedMaker_ATLxk.h

Go to the documentation of this file.

// -*- C++ -*-
 
/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
//  Header file for class SiSpacePointsSeedMaker_ATLxk
// Version 1.0 3/10/2004 I.Gavrilenko
 
#ifndef SiSpacePointsSeedMaker_ATLxk_H
#define SiSpacePointsSeedMaker_ATLxk_H
 
#include "InDetRecToolInterfaces/ISiSpacePointsSeedMaker.h"
#include "AthenaBaseComps/AthAlgTool.h"
 
#include "BeamSpotConditionsData/BeamSpotData.h"
#include "SiSPSeededTrackFinderData/SiSpacePointForSeed.h"
#include "SiSPSeededTrackFinderData/SiSpacePointsSeedMakerEventData.h"
#include "TrkSpacePoint/SpacePointContainer.h" 
#include "TrkSpacePoint/SpacePointOverlapCollection.h"
#include "TrkEventUtils/PRDtoTrackMap.h"
#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;
//class TFile;
//class TTree;
 
namespace InDet {
 
  using EventData = SiSpacePointsSeedMakerEventData;
 
  class SiSpacePointsSeedMaker_ATLxk final: 
    public extends<AthAlgTool, ISiSpacePointsSeedMaker>
  {
    // Public methods:
      
  public:
      
 
    SiSpacePointsSeedMaker_ATLxk(const std::string&, const std::string&, const IInterface*);
    virtual ~SiSpacePointsSeedMaker_ATLxk() = 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>& vSCT) const override;
    virtual void newRegion(const EventContext& ctx,SiSpacePointsSeedMakerEventData& data,
                           const std::vector<IdentifierHash>& vPixel, const std::vector<IdentifierHash>& vSCT,
                           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 SiSpacePointsSeed* next(const EventContext& ctx, EventData& data) const override;
     
    virtual void writeNtuple(const 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};       
 
 
 
    SG::ReadHandleKey<SpacePointContainer> m_spacepointsPixel{this, "SpacePointsPixelName", "PixelSpacePoints", "Pixel space points container"};
    SG::ReadHandleKey<SpacePointContainer> m_spacepointsSCT{this, "SpacePointsSCTName", "SCT_SpacePoints", "SCT 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_sct{this, "useSCT", true};
    BooleanProperty m_useOverlap{this, "useOverlapSpCollection", true};
    IntegerProperty m_maxsize{this, "maxSize", 50000};
    IntegerProperty m_maxsizeSP{this, "maxSizeSP", 5000};
    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_optimisePhiBinning{this, "optimisePhiBinning", true};
    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_drmax{this, "maxdRadius", 270.};
    FloatProperty m_zmin{this, "minZ", -250.};
    FloatProperty m_zmax{this, "maxZ", +250.};
    FloatProperty m_dzver{this, "maxdZver", 5.};
    FloatProperty m_dzdrver{this, "maxdZdRver", .02};
 
 
    FloatProperty m_etamin{this, "etaMin", 0.};
    FloatProperty m_r_rmax{this, "radMax", 600.};
    FloatProperty m_binSizeR{this, "radStep", 2.};
    FloatProperty m_drmin{this, "mindRadius", 5.};
    FloatProperty m_maxdImpact{this, "maxdImpact", 10.};
    FloatProperty m_maxdImpactSSS{this, "maxdImpactSSS", 50.};
    FloatProperty m_dImpactCutSlopeUnconfirmedSSS{this, "dImpactCutSlopeUnconfirmedSSS", 1.0};
    FloatProperty m_dImpactCutSlopeUnconfirmedPPP{this, "dImpactCutSlopeUnconfirmedPPP", 0.};
    FloatProperty m_maxdImpactDecays{this, "maxdImpactForDecays", 20.};
    FloatProperty m_ptmin{this, "pTmin", 500.};
    FloatProperty m_fieldScale{this, "fieldScale", 1.};
 
 
    BooleanProperty m_checketa{this, "checkEta", false};
 
    FloatProperty m_seedScoreBonusPPP{this, "seedScoreBonusPPP", -200.};
    FloatProperty m_seedScoreBonusSSS{this, "seedScoreBonusSSS", -400.};
    FloatProperty m_seedScoreBonusConfirmationSeed{this, "seedScoreBonusConfirmationSeed", -200.};
 
    FloatProperty m_maxScore{this, "maximumAcceptedSeedScore", 100.}; 
 
 
    float m_drminv{20.};
 
 
    float m_dzdrmin0{0.};   
    float m_dzdrmax0{0.};   
    float m_ipt{0.};    
    float m_ipt2{0.};   
    // static constexpr float m_COF{134*.05*9};    ///< appears to be an approximated term related to multiple-scattering of particles traversing the ID during the seed formation 
    static constexpr float m_COF{134*.05f*9};    
 
    int m_nBinsR{0};              
    int m_maxPhiBin{0};           
    int m_maxBinPhiVertex{0};     
    float m_inverseBinSizePhi{0};   
    float m_inverseBinSizePhiVertex{0};
 
 
    float m_seedScoreThresholdPPPConfirmationSeed{0.};    
    float m_seedScoreThresholdSSSConfirmationSeed{0.};    
 
    static constexpr float m_radiusCutIBL{43.}; 
 
    std::array<int,arraySizePhiZ> m_nNeighbourCellsBottom{};  
    std::array<int,arraySizePhiZ> m_nNeighbourCellsTop{};  
    std::array<std::array<int, arraySizeNeighbourBins>, arraySizePhiZ> m_neighbourCellsBottom{}; 
    std::array<std::array<int, arraySizeNeighbourBins>, arraySizePhiZ> m_neighbourCellsTop{}; 
 
    std::array<int,arraySizePhiZV> m_nNeighboursVertexPhiZ{};
    std::array<std::array<int, arraySizeNeighbourBinsVertex>, arraySizePhiZV> m_neighboursVertexPhiZ{};
 
    // Private methods
 
 
    SiSpacePointsSeedMaker_ATLxk() = delete;
    SiSpacePointsSeedMaker_ATLxk(const SiSpacePointsSeedMaker_ATLxk&) = delete;
    SiSpacePointsSeedMaker_ATLxk &operator=(const SiSpacePointsSeedMaker_ATLxk&) = delete;
 
    MsgStream& dumpConditions(EventData& data, MsgStream& out) const;
    static MsgStream& dumpEvent     (EventData& data, MsgStream& out) ;
 
    void buildFrameWork();
    /* updates the beam spot information stored in the event data
    * object. 
    * @param[out] data: Event data, receives update to the x/y/zbeam members 
    **/
    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;
 
    static void newSeed(EventData& data, SiSpacePointForSeed*& p1, SiSpacePointForSeed*& p2, float z) ;
 
    void newOneSeed(EventData& data,
                    SiSpacePointForSeed*& p1, SiSpacePointForSeed*& p2,
                    SiSpacePointForSeed*& p3, float z, float quality) const;
 
    void newOneSeedWithCurvaturesComparison
    (EventData& data, SiSpacePointForSeed*& SPb, SiSpacePointForSeed*& SP0, float Zob) const;
 
    void fillSeeds(EventData& data) const;
 
    void fillLists(EventData& data) const;
    static void erase(EventData& data) ;
    void production2Sp(EventData& data) const;
 
 
    void production3Sp(EventData& data) const;
 
    void production3Sp
    (EventData& data,
     std::array<std::vector<InDet::SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & iter_bottomCands,
     std::array<std::vector<InDet::SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & iter_endBottomCands,
     std::array<std::vector<InDet::SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & iter_topCands,
     std::array<std::vector<InDet::SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & iter_endTopCands,
     const int numberBottomCells, const int numberTopCells, int& nseed, const int zbin = -1) const;
 
    void production3SpTrigger
    (EventData& data,
     std::array<std::vector<InDet::SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & rb,
     std::array<std::vector<InDet::SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & rbe,
     std::array<std::vector<InDet::SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & rt,
     std::array<std::vector<InDet::SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & rte,
     const int numberBottomCells, const int numberTopCells, int& nseed) const;
 
    bool newVertices(EventData& data, const std::list<Trk::Vertex>& lV) const;
    void findNext(EventData& data) const;
    bool isZCompatible(EventData& data, const float Zv, const float R, const float T) const;
 
    static void convertToBeamFrameWork(EventData& data, const Trk::SpacePoint*const& sp, std::array<float,3> & r) ;
 
    bool isUsed(const Trk::SpacePoint* sp, const Trk::PRDtoTrackMap &prd_to_track_map) const;
 
    void initializeEventData(EventData& data) const;
 
    bool isConfirmedSeed(const InDet::SiSpacePointForSeed* bottomSP, const InDet::SiSpacePointForSeed* topSP, float quality) const; 
 
    Gaudi::Property<bool> m_writeNtuple {this, "WriteNtuple", false, "Flag to write Validation Ntuples"};
 
    ServiceHandle<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;
  };
  
} // end of name space
 
// Object-function for curvature seeds comparison
 
class comCurvature {
public:
  bool operator ()
  (const std::pair<float,InDet::SiSpacePointForSeed*>& i1, 
   const std::pair<float,InDet::SiSpacePointForSeed*>& i2)
  {
    return i1.first < i2.first;
  }
};
 
namespace InDet {
 
  inline
  bool SiSpacePointsSeedMaker_ATLxk::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;
  }
}
 
#endif // SiSpacePointsSeedMaker_ATLxk_H