SiSpacePointsSeedMaker_LowMomentum.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_LowMomentum
// Version 1.0 3/10/2004 I.Gavrilenko
 
#ifndef SiSpacePointsSeedMaker_LowMomentum_H
#define SiSpacePointsSeedMaker_LowMomentum_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"

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

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

    SiSpacePointsSeedMaker_LowMomentum
    (const std::string&,const std::string&,const IInterface*);
    virtual ~SiSpacePointsSeedMaker_LowMomentum() = 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;

    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=20,
               SizeZ=11,
               SizeRFZ=SizeRF*SizeZ,
               SizeI=9};

    // 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::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" };
    // 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"};



    BooleanProperty m_pixel{this, "usePixel", true};
    BooleanProperty m_sct{this, "useSCT", true};
    BooleanProperty m_useOverlap{this, "useOverlapSpCollection", false};
    IntegerProperty m_maxsize{this, "maxSize", 2000};
    IntegerProperty m_maxsizeSP{this, "maxSizeSP", 1500};
    IntegerProperty m_maxOneSize{this, "maxSeedsForSpacePoint", 5};
    FloatProperty m_r1min{this, "minRadius1", 0.};
    FloatProperty m_r1max{this, "maxRadius1", 600.};
    FloatProperty m_r2min{this, "minRadius2", 0.};
    FloatProperty m_r2max{this, "maxRadius2", 600.};
    FloatProperty m_r3min{this, "minRadius3", 0.};
    FloatProperty m_drmin{this, "mindRadius", 10.};
    FloatProperty m_drmax{this, "maxdRadius", 200.};
    FloatProperty m_zmin{this, "minZ", -250.};
    FloatProperty m_zmax{this, "maxZ", +250.};
    FloatProperty m_r_rmax{this, "radMax", 200.};
    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", 7.};
    FloatProperty m_ptmax{this, "pTmax", 500.};


    FloatProperty m_etamax{this, "etaMax", 2.7};
    FloatProperty m_ptmin{this, "pTmin", 100.};
    FloatProperty m_fieldScale{this, "fieldScale", 1.};


    bool m_initialized{false};
    int m_outputlevel{0};
    int m_fNmax{0};
    int m_r_size{0};
    int m_rfz_b[SizeRFZ]{};
    int m_rfz_t[SizeRFZ]{};
    int m_rfz_ib[SizeRFZ][SizeI]{};
    int m_rfz_it[SizeRFZ][SizeI]{};
    float m_dzdrmin{0.};
    float m_dzdrmax{0.};
    float m_r3max{0.};
    float m_iptmin{0.};
    float m_iptmax{1.f/400.f};
    float m_sF{0.};

    // Private methods

    SiSpacePointsSeedMaker_LowMomentum() = delete;
    SiSpacePointsSeedMaker_LowMomentum(const SiSpacePointsSeedMaker_LowMomentum&) = delete;
    SiSpacePointsSeedMaker_LowMomentum &operator=(const SiSpacePointsSeedMaker_LowMomentum&) = delete;
 
    MsgStream& dumpConditions(EventData& data, MsgStream& out) const;
    static MsgStream& dumpEvent(EventData& data, MsgStream& out) ;
 
    void buildFrameWork();
    void buildBeamFrameWork(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) ;
    static void production2Sp(EventData& data) ;
    void production3Sp(const EventContext& ctx, 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&,float) const;
     
    static bool newVertices(EventData& data, const std::list<Trk::Vertex>&) ;
    void findNext(const EventContext& ctx, EventData& data) const;
    bool isZCompatible(EventData& data, float&,float&,float&) 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;
  };
 
} // end of name space
 
namespace InDet {
 
  inline
  bool SiSpacePointsSeedMaker_LowMomentum::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_LowMomentum_H