TRT_SeededTrackFinder_ATL.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
/**********************************************************************************
   Header file for class TRT_SeededTrackFinder_ATL
  (c) ATLAS Detector software
  Class for Trk::Track production in SCT and Pixels
  Version 1.0: 04/12/2006
  Authors    : Thomas Koffas
  email      : Thomas.Koffas@cern.ch
**********************************************************************************/
 
#ifndef TRT_SeededTrackFinder_ATL_H
#define TRT_SeededTrackFinder_ATL_H
 
#include "AthenaBaseComps/AthAlgTool.h"
 
//Tool Handler
//
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/IInterface.h"
#include "GaudiKernel/ServiceHandle.h"
 
//Tool Interface
//
#include "InDetRecToolInterfaces/ITRT_SeededTrackFinder.h"
#include "InDetRecToolInterfaces/ITRT_SeededSpacePointFinder.h"
#include "TrkEventUtils/EventDataBase.h"
 
//Magnetic field
//
#include "TrkGeometry/MagneticFieldProperties.h"
 
// MagField cache
#include "MagFieldConditions/AtlasFieldCacheCondObj.h"
#include "MagFieldElements/AtlasFieldCache.h"
 
//Si Tools
//
#include "TRT_SeededTrackFinderTool/SiNoise_bt.h"
#include "SiSPSeededTrackFinderData/SiDetElementRoadMakerData_xk.h"
 
//Combinatorial Track Finder Tool
//
#include "InDetRecToolInterfaces/ISiCombinatorialTrackFinder.h"
 
//ReadHandle key
//
#include "StoreGate/ReadHandleKey.h"
 
#include <list>
#include <vector>
#include <map>
#include <iosfwd>
 
class MsgStream;
class TRT_ID   ;
 
namespace Trk{
  class IUpdator;
  class IPropagator;
  class IRIO_OnTrackCreator;
}
 
namespace InDet{
  class ISiDetElementsRoadMaker;
  class SiCombinatorialTrackFinderData_xk;
 
  class TRT_SeededTrackFinder_ATL :virtual public ITRT_SeededTrackFinder, public AthAlgTool{
     
    public:
 
 
 
      TRT_SeededTrackFinder_ATL(const std::string&,const std::string&,const IInterface*);
      virtual ~TRT_SeededTrackFinder_ATL();
      virtual StatusCode initialize() override;
      virtual StatusCode finalize  () override;
 
 
 
      virtual std::list<Trk::Track*> 
        getTrack (const EventContext& ctx, InDet::ITRT_SeededTrackFinder::IEventData &event_data,
                const Trk::TrackSegment&) const override;
      virtual std::unique_ptr<InDet::ITRT_SeededTrackFinder::IEventData>
        newEvent(const EventContext& ctx, SiCombinatorialTrackFinderData_xk& combinatorialData) const override;
      virtual std::unique_ptr<InDet::ITRT_SeededTrackFinder::IEventData>
         newRegion(const EventContext& ctx, SiCombinatorialTrackFinderData_xk& combinatorialData,
                   const std::vector<IdentifierHash>&,const std::vector<IdentifierHash>&) const override;
      virtual void 
        endEvent(InDet::ITRT_SeededTrackFinder::IEventData &event_data) const override;
 
 
 
      MsgStream&    dump(MsgStream&    out) const override;
      std::ostream& dump(std::ostream& out) const override;
 
    protected:
 
       class EventData;
       class EventData : public Trk::EventDataBase<EventData,InDet::ITRT_SeededTrackFinder::IEventData> {
       public:
          friend class TRT_SeededTrackFinder_ATL;
          EventData(SiCombinatorialTrackFinderData_xk& combinatorialData,
                    std::unique_ptr<InDet::ITRT_SeededSpacePointFinder::IEventData> &&spacePointFinderEventData)
             : m_combinatorialData(&combinatorialData),
               m_spacePointFinderEventData(std::move(spacePointFinderEventData) )
          {}
          virtual InDet::SiCombinatorialTrackFinderData_xk &combinatorialData() override             { return *m_combinatorialData; }
          virtual const InDet::SiCombinatorialTrackFinderData_xk &combinatorialData() const override { return *m_combinatorialData; }
 
          InDet::ITRT_SeededSpacePointFinder::IEventData &spacePointFinderEventData(){ return *m_spacePointFinderEventData; }
          std::multimap<const Trk::PrepRawData*,const Trk::Track*> &clusterTrack() { return m_clusterTrack; }
          void setCaloClusterROIEM(const ROIPhiRZContainer &rois)   { m_caloClusterROIEM  = &rois; }
          const ROIPhiRZContainer *caloClusterROIEM() const         { return m_caloClusterROIEM; }
          std::vector<double>&                                      caloF()        { return m_caloF; }
          std::vector<double>&                                      caloE()        { return m_caloE; }
          const std::vector<double>&                                caloF()  const { return m_caloF; }
          const std::vector<double>&                                caloE()  const { return m_caloE; }
          InDet::SiNoise_bt&                                        noise()        { return m_noise; }
          const InDet::SiNoise_bt&                                  noise()  const { return m_noise; }
          InDet::SiDetElementRoadMakerData_xk& roadMakerData() {return m_roadMakerData; }
       protected:
          SiCombinatorialTrackFinderData_xk                              *m_combinatorialData;
          std::unique_ptr<InDet::ITRT_SeededSpacePointFinder::IEventData> m_spacePointFinderEventData;
          std::multimap<const Trk::PrepRawData*,const Trk::Track*> m_clusterTrack  ; 
          const ROIPhiRZContainer        *m_caloClusterROIEM {};
          std::vector<double>              m_caloF         ;
          std::vector<double>              m_caloE         ;
 
          InDet::SiNoise_bt                    m_noise        ;
          InDet::SiDetElementRoadMakerData_xk  m_roadMakerData; 
       };
 
 
 
      std::string                         m_fieldmode     ;  
      Trk::MagneticFieldProperties        m_fieldprop     ;  
      ToolHandle<InDet::ISiDetElementsRoadMaker>     m_roadmaker  ;  
      ToolHandle<InDet::ITRT_SeededSpacePointFinder> m_seedmaker  ;  
      ToolHandle<Trk::IPropagator>                   m_proptool   ;  
      ToolHandle<Trk::IUpdator>                      m_updatorTool;  
      ToolHandle<InDet::ISiCombinatorialTrackFinder> m_tracksfinder; 
      SG::ReadCondHandleKey<AtlasFieldCacheCondObj> m_fieldCondObjInputKey {this, "AtlasFieldCacheCondObj",
        "fieldCondObj", "Name of the Magnetic Field conditions object key"};
 
      const TRT_ID* m_trtId{};
 
      double                       m_xi2max        ; 
      double                       m_xi2maxNoAdd   ; 
      double                       m_xi2maxlink    ; 
      double                       m_pTmin         ; 
      int                          m_nholesmax     ; 
      int                          m_dholesmax     ; 
      int                          m_nclusmin      ; 
      int                          m_nwclusmin     ; 
      bool                         m_bremCorrect   ; 
      bool                         m_propR         ; 
      bool                         m_useassoTool   ; 
      InDet::TrackQualityCuts      m_trackquality  ;
      std::vector<double>          m_errorScale    ; 
      double                       m_outlierCut    ; 
      bool                         m_searchInCaloROI; 
      SG::ReadHandleKey<ROIPhiRZContainer> m_caloClusterROIKey{this, "EMROIPhiRZContainer", ""};
 
 
 
 
      void magneticFieldInit();
 
      std::unique_ptr<const Trk::TrackParameters> 
      getTP(MagField::AtlasFieldCache& fieldCache, const Trk::SpacePoint*,
             const Trk::TrackParameters&, bool&, 
             InDet::TRT_SeededTrackFinder_ATL::EventData &event_data) const;
 
      std::list<Trk::Track*>
      findTrack(const EventContext& ctx, MagField::AtlasFieldCache& fieldCache,
                InDet::TRT_SeededTrackFinder_ATL::EventData &event_data,
                const Trk::TrackParameters&,const Trk::TrackSegment&) const;
 
      std::unique_ptr<const Trk::TrackParameters> 
      addNoise(const SiNoise_bt &,const Trk::TrackParameters&,int) const;
 
 
      bool
      checkSeed(std::vector<const Trk::SpacePoint*>&,const Trk::TrackSegment&,
                const Trk::TrackParameters&) const;
 
      static std::unique_ptr<const Trk::TrackParameters>
      modifyTrackParameters(const Trk::TrackParameters&,int) ;
 
      void
      setTrackQualityCuts();
 
      static void
      clusterTrackMap(Trk::Track*,InDet::TRT_SeededTrackFinder_ATL::EventData &event_data);
 
      static bool
      newClusters(const std::vector<const Trk::SpacePoint*>&,
                  InDet::TRT_SeededTrackFinder_ATL::EventData &event_data) ;
 
      static bool
      newSeed(const std::vector<const Trk::SpacePoint*>&,
              InDet::TRT_SeededTrackFinder_ATL::EventData &event_data) ;
 
      static bool
      isNewTrack(Trk::Track*,InDet::TRT_SeededTrackFinder_ATL::EventData &event_data) ;
 
      std::list<Trk::Track*> 
      cleanTrack(std::list<Trk::Track*>) const;
 
      bool isCaloCompatible(const Trk::TrackParameters&, const InDet::TRT_SeededTrackFinder_ATL::EventData &event_data) const;
      double m_phiWidth{};
 
      MsgStream&    dumpconditions(MsgStream&    out) const;
 
    };
 
}  // end of namespace
 
#endif // TRT_SeededTrackFinder_ATL