TRT_TrackSegmentsMaker_ECcosmics.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
// TRT_TrackSegments.h
//    Header file for class TRT_TrackSegmentsMaker_ECcosmics
// (c) ATLAS Detector software
//
// Based on TRT_TrackSegmentsMaker_CTBxk from I.Gavrilenko
// Christian.Schmitt@cern.ch
 
 
#ifndef TRT_TrackSegmentsMaker_ECcosmics_H
#define TRT_TrackSegmentsMaker_ECcosmics_H
 
 
#include "GaudiKernel/ToolHandle.h"
#include "AthenaBaseComps/AthAlgTool.h"
 
#include "InDetRecToolInterfaces/ITRT_TrackSegmentsMaker.h"
 
#include "StoreGate/ReadHandleKey.h"
#include "TrkEventUtils/PRDtoTrackMap.h"
#include "TrkEventUtils/EventDataBase.h"
 
#include <iosfwd>
#include <list>
 
class MsgStream;
 
class TF1;
 
class TRT_ID;
namespace InDet{
  class TRT_DriftCircle;
  //  class TRT_DriftCircleContainer;
}
 
namespace InDetDD{
  class TRT_DetectorManager;
}
 
namespace Trk{
  class TrackSegment;
  class Segment;
  class IRIO_OnTrackCreator;
}
 
class PRD_MultiTruthCollection;
 
 
namespace InDet{
 
  class TRT_TrackSegmentsMaker_ECcosmics : // This class read and write gErrorIgnoreLevel without a global lock for ROOT.
    virtual public ITRT_TrackSegmentsMaker, public AthAlgTool
    {
      // Public methods:
      
    public:
      
      // Standard tool methods
 
      TRT_TrackSegmentsMaker_ECcosmics
    (const std::string&,const std::string&,const IInterface*);
      virtual ~TRT_TrackSegmentsMaker_ECcosmics();
      virtual StatusCode               initialize() override;
      virtual StatusCode               finalize  () override;
 
      // Methods to initialize tool for new event or region
 
      virtual std::unique_ptr<InDet::ITRT_TrackSegmentsMaker::IEventData> newEvent(const EventContext& ctx) const override;
      virtual std::unique_ptr<InDet::ITRT_TrackSegmentsMaker::IEventData> newRegion(const EventContext& ctx, const std::vector<IdentifierHash>&) const override;
      void endEvent(InDet::ITRT_TrackSegmentsMaker::IEventData &event_data) const override;
 
      // Methods of seeds production without vertex constraint
 
      virtual void find(const EventContext &ctx,
                        InDet::ITRT_TrackSegmentsMaker::IEventData &event_data,
                        InDet::TRT_DetElementLink_xk::TRT_DetElemUsedMap &used) const override;
 
      // Iterator through seeds pseudo collection produced accordingly
      // methods find    
      
      virtual Trk::TrackSegment* next(InDet::ITRT_TrackSegmentsMaker::IEventData &event_data) const override;
  
      // Print internal tool parameters and status
 
      virtual MsgStream&    dump          (MsgStream   & out) const override;
      virtual std::ostream& dump          (std::ostream& out) const override;
 
    protected:
      class EventData;
      class EventData : public Trk::EventDataBase<EventData,InDet::ITRT_TrackSegmentsMaker::IEventData>
      {
         friend class InDet::TRT_TrackSegmentsMaker_ECcosmics;
      public:
         EventData()  {
            m_segiterator   = m_segments.begin();
         }
 
         ~EventData() {
            std::vector<std::vector<const InDet::TRT_DriftCircle*> *>::iterator sit,sitE;
            sit= m_seeds.begin();
            sitE= m_seeds.end();
            for(;sit!=sitE;++sit){
               (*sit)->clear();
               delete(*sit);
            }
         }
 
      protected:
         std::list<const InDet::TRT_DriftCircle*> m_noiseHits; 
         std::list<const InDet::TRT_DriftCircle*> m_goodHits; 
 
 
         std::list<const InDet::TRT_DriftCircle*> m_sectors[2][20][16]; 
 
         std::vector<std::vector<const InDet::TRT_DriftCircle*> *> m_seeds; 
         std::list<Trk::TrackSegment*>            m_segments    ; 
         std::list<Trk::TrackSegment*>::iterator  m_segiterator ; 
 
         double m_a_z[1000];
         double m_a_phi[1000];
         double m_a_phi_err[1000];
         double m_a_tan[1000];
         double m_a_tan_err[1000];
         double m_a_z_err[1000];
         double m_a_steigung[1000];
 
         // Fitting functions
         TF1 *m_fitf_ztanphi=nullptr; 
         TF1 *m_fitf_zphi=nullptr; 
 
         TF1 *m_fitf_ztanphi_approx=nullptr; 
         TF1 *m_fitf_zphi_approx=nullptr; 
 
      };
 
      // Protected data and methods
 
      bool                                     m_phaseMode   ; 
      const TRT_ID*                            m_trtid{}       ; 
 
      SG::ReadHandleKey<InDet::TRT_DriftCircleContainer> m_trtname{this,"TRT_ClustersContainer","TRT_DriftCircles","RHK to retrieve TRT_DriftCircles"}; 
      SG::ReadHandleKey<Trk::PRDtoTrackMap>       m_prdToTrackMap
         {this,"PRDtoTrackMap",""};
 
      ToolHandle<Trk::IRIO_OnTrackCreator>     m_riomakerD   ; 
      ToolHandle<Trk::IRIO_OnTrackCreator>     m_riomakerN   ; 
 
      bool                                     m_useDriftTime; 
      double                                   m_scaleTube   ; 
      double                                   m_scaleFactorDrift ; 
      double                                   m_scaleTubeNoise; 
      double                                   m_cutToTLoose ; 
      double                                   m_cutToTTight ; 
      double                                   m_cutToTUpper ; 
      int                                      m_minDCSeed   ; 
      int                                      m_hitLimit    ; 
 
      static std::mutex s_fitMutex;  // @TODO not sufficient need a global root lock
 
      // Protected methods
      
      void retrieveHits(TRT_TrackSegmentsMaker_ECcosmics::EventData &event_data) const;
 
      bool find_seed(int endcap, int zslice, int sector,TRT_TrackSegmentsMaker_ECcosmics::EventData &event_data) const;
 
      int evaluate_seed(int endcap,int zslice,int sector,const double *p, TRT_TrackSegmentsMaker_ECcosmics::EventData &event_data) const;
 
      void create_segment(std::vector<const InDet::TRT_DriftCircle*> *seed,
                          TRT_TrackSegmentsMaker_ECcosmics::EventData &event_data) const;
 
      void setFitFunctions(TRT_TrackSegmentsMaker_ECcosmics::EventData &event_data) const;
 
      TF1 *perform_fit(int count,TRT_TrackSegmentsMaker_ECcosmics::EventData &event_data) const;
 
      bool is_suspicious(const InDet::TRT_DriftCircle* dc, std::vector<const InDet::TRT_DriftCircle*> *seed) const;
 
      static double phidiff(double a,double b);
      
      bool accepted(const std::list<const InDet::TRT_DriftCircle*>::iterator compareIt, 
        std::list<const InDet::TRT_DriftCircle*> & container,
        double phiLimit, double dzLimit) const;
 
    };
 
} // end of name space
 
 
inline double InDet::TRT_TrackSegmentsMaker_ECcosmics::phidiff(double a,double b)
{
  double c=a-b;
 
  if(std::abs(c)>100)
    c/=int(c/(2*M_PI));
  while(c>=M_PI) c-=2*M_PI;
  while(c<-M_PI) c+=2*M_PI;
  return c;
}
 
#endif // TRT_TrackSegmentsMaker_ECcosmics_H