SiSpacePointsSeedMaker_HeavyIon.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 SiSpacePointsSeedMaker_HeavyIon
// Version 1.0 3/10/2004 I.Gavrilenko
 
#ifndef SiSpacePointsSeedMaker_HeavyIon_H
#define SiSpacePointsSeedMaker_HeavyIon_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"

// MagField cache
#include "MagFieldConditions/AtlasFieldCacheCondObj.h"
#include "MagFieldElements/AtlasFieldCache.h"
 
#include <iosfwd>
#include <list>
#include <vector>
 
class MsgStream;
 
namespace InDet {
 
  using EventData = SiSpacePointsSeedMakerEventData;

 
  class SiSpacePointsSeedMaker_HeavyIon final: 
    public extends<AthAlgTool, ISiSpacePointsSeedMaker>
  {
    // Public methods:
      
  public:
      

    SiSpacePointsSeedMaker_HeavyIon
    (const std::string&,const std::string&,const IInterface*);
    virtual ~SiSpacePointsSeedMaker_HeavyIon() = 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, EventData& 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;
 
    // with variable number space points with or without vertex constraint
    // Variable means (2,3,4,....) any number space points
    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 {SizeRF=53,
               SizeZ=11,
               SizeRFZ=SizeRF*SizeZ,
               SizeI=9,
               SizeRFV=100,
               SizeZV=3,
               SizeRFZV=SizeRFV*SizeZV,
               SizeIV=6};

    // Private data and methods


    SG::ReadHandleKey<SpacePointContainer> m_spacepointsSCT{this, "SpacePointsSCTName", "SCT_SpacePoints", "SCT space points container"};
    SG::ReadHandleKey<SpacePointContainer> m_spacepointsPixel{this, "SpacePointsPixelName", "PixelSpacePoints", "Pixel space points container"};
    SG::ReadHandleKey<SpacePointOverlapCollection> m_spacepointsOverlap{this, "SpacePointsOverlapName", "OverlapSpacePoints"};
    SG::ReadCondHandleKey<InDet::BeamSpotData> m_beamSpotKey{this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot"};
    // Read handle for conditions object to get the field cache
    SG::ReadCondHandleKey<AtlasFieldCacheCondObj> m_fieldCondObjInputKey {this, "AtlasFieldCacheCondObj", "fieldCondObj", "Name of the Magnetic Field conditions object key"};
    SG::ReadHandleKey<Trk::PRDtoTrackMap> m_prdToTrackMap{this,"PRDtoTrackMap","","option PRD-to-track association"};


    BooleanProperty m_pixel{this, "usePixel", true};
    BooleanProperty m_sct{this, "useSCT", true};
    BooleanProperty m_useOverlap{this, "useOverlapSpCollection", false};
    IntegerProperty m_maxsize{this, "maxSize", 20000};
    IntegerProperty m_maxsizeSP{this, "maxSizeSP", 4000};
    IntegerProperty m_maxOneSize{this, "maxSeedsForSpacePoint", 6};
    UnsignedIntegerProperty m_maxNumberVertices{this, "maxNumberVertices", 1};
    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_r3minv{this, "minVRadius3", 0.};
    FloatProperty m_drmin_b{this, "mindRadius", 10.};
    FloatProperty m_drmin_t{this, "mindRadiusTop", 10.};
    FloatProperty m_drmax{this, "maxdRadius", 270.};
    FloatProperty m_zmin{this, "minZ", -250.};
    FloatProperty m_zmax{this, "maxZ", +250.};
    FloatProperty m_r_rmin{this, "radMin", 43.};
    FloatProperty m_r_rmax{this, "radMax", 600.};
    FloatProperty m_r_rstep{this, "radStep", 2.};
    FloatProperty m_dzver{this, "maxdZver", 5.};
    FloatProperty m_dzdrver{this, "maxdZdRver", 0.02};
    FloatProperty m_diver{this, "maxdImpact", 10.};
    FloatProperty m_diverpps{this, "maxdImpactPPS", 1.7};
    FloatProperty m_diversss{this, "maxdImpactSSS", 1000.};
    BooleanProperty m_useVertexPosition {this, "useVertexPosition", false};
    BooleanProperty m_writeNtuple {this, "WriteNtuple", false, "Flag to write Validation Ntuples"};


    FloatProperty m_etamax{this, "etaMax", 2.7};
    FloatProperty m_ptmin{this, "pTmin", 500.};
    FloatProperty m_ptmax{this, "pTmax", std::numeric_limits<float>::max()};
    FloatProperty m_fieldScale{this, "fieldScale", 1.};


    float m_drminv{20.};
 
    // @name Data members, which are updated only in initialize
    bool m_initialized{false};
    int m_outputlevel{0};
    int m_r_size{0};
    int m_fNmax{0};
    int m_fvNmax{0};
    int m_rfz_b[SizeRFZ]{};
    int m_rfz_t[SizeRFZ]{};
    int m_rfz_ib[SizeRFZ][SizeI]{};
    int m_rfz_it[SizeRFZ][SizeI]{};
    int m_rfzv_n[SizeRFZV]{};
    int m_rfzv_i[SizeRFZV][SizeIV]{};
    float m_dzdrmin{0.};
    float m_dzdrmax{0.};
    float m_ipt{0.};
    float m_iptmax{0.};
    float m_ipt2{0.};
    float m_COF{0.};
    float m_sF{0.};
    float m_sFv{0.};
 
    ServiceHandle<ITHistSvc> m_thistSvc {this, "THistSvc", "THistSvc", "Histogramming svc"};
    TTree* m_outputTree {nullptr};
 
    mutable std::mutex m_mutex;
 
    std::string m_treeName {""};
    std::string m_treeFolder {"/valNtuples/"};
 
    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 double m_dr_b ATLAS_THREAD_SAFE = 0;
    mutable double m_dr_t 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;
 
    
    // Private methods

    SiSpacePointsSeedMaker_HeavyIon() = delete;
    SiSpacePointsSeedMaker_HeavyIon(const SiSpacePointsSeedMaker_HeavyIon&) = delete;
    SiSpacePointsSeedMaker_HeavyIon &operator=(const SiSpacePointsSeedMaker_HeavyIon&) = delete;
 
    MsgStream& dumpConditions(EventData& data, MsgStream& out) const;
    static MsgStream& dumpEvent(EventData& data, MsgStream& out) ;
 
    void buildFrameWork();
    void buildBeamFrameWork(const EventContext& ctx, EventData& data) const;
 
    static SiSpacePointForSeed* newSpacePoint
    (EventData& data, const Trk::SpacePoint*const&) ;
    static void newSeed
    (EventData& data,
     const Trk::SpacePoint*&,const Trk::SpacePoint*&,
     const float&) ;
    static void newSeed
    (EventData& data,
     const Trk::SpacePoint*&,const Trk::SpacePoint*&,
     const Trk::SpacePoint*&,const float&) ;
 
    void newOneSeed
    (EventData& data,
     const Trk::SpacePoint*&,const Trk::SpacePoint*&,
     const Trk::SpacePoint*&,const float&,const float&) const;
    static void fillSeeds(EventData& data) ;
 
    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::vector<InDet::SiSpacePointForSeed*>::iterator*,
     std::vector<InDet::SiSpacePointForSeed*>::iterator*,
     std::vector<InDet::SiSpacePointForSeed*>::iterator*,
     std::vector<InDet::SiSpacePointForSeed*>::iterator*,
     int,int,int&) const;
    void production3SpNoVertex
    (EventData& data,
     std::vector<InDet::SiSpacePointForSeed*>::iterator*,
     std::vector<InDet::SiSpacePointForSeed*>::iterator*,
     std::vector<InDet::SiSpacePointForSeed*>::iterator*,
     std::vector<InDet::SiSpacePointForSeed*>::iterator*,
     int,int,int&) const;
 
    bool newVertices(EventData& data, const std::list<Trk::Vertex>&) const;
    void findNext(EventData& data) const;
    bool isZCompatible(EventData& data, float&,float&,float&) const;
    static float dZVertexMin(EventData& data, float&) ;
    static void convertToBeamFrameWork(EventData& data, const Trk::SpacePoint*const&,std::array<float, 3>&) ;
 
    void initializeEventData(EventData& data) const;
 
    bool isUsed(const Trk::SpacePoint* sp, const Trk::PRDtoTrackMap &prd_to_track_map) const;
  };
 
  inline
  bool SiSpacePointsSeedMaker_HeavyIon::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;
  }
  
} // end of name space
 
#endif // SiSpacePointsSeedMaker_HeavyIon_H