InDetRecStatisticsAlg.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
// InDetRecStatisticsAlg.h
// Authors: Sven Vahsen, Lauren Tompkins
 
#ifndef INDETRECSTATISTICS_TrackStatistics_H
#define INDETRECSTATISTICS_TrackStatistics_H
 
 
#include "AthenaBaseComps/AthReentrantAlgorithm.h"
#include "GaudiKernel/ToolHandle.h"
#include "TrkTrack/TrackCollection.h"
#include "HepPDT/ParticleDataTable.hh"
#include "InDetRecStatistics/TrackStatHelper.h"
#include "Identifier/Identifier.h"
#include "TrkToolInterfaces/IPRDtoTrackMapTool.h"
#include "TrkToolInterfaces/IResidualPullCalculator.h"
#include "TrkToolInterfaces/ITrackSelectorTool.h"
#include "TrkToolInterfaces/ITruthToTrack.h"
#include "TrkToolInterfaces/IUpdator.h"
 
#include <vector>
#include <atomic>
 
// forward declarations
 
class AtlasDetectorID;
class PixelID;
class SCT_ID;
class TRT_ID;
class IdDictManager;
class TrackTruthCollection;
class McEventCollection;
class GenParticle;
 
namespace Trk {
  class ITrackSummaryTool;
  class TrackSummary;
}
 
namespace InDet {
 
    class InDetRecStatisticsAlg:public AthReentrantAlgorithm {
 
 
     public:
      InDetRecStatisticsAlg (const std::string& name, ISvcLocator* pSvcLocator);
      StatusCode    initialize();
      StatusCode    execute(const EventContext &ctx) const;
      StatusCode    finalize();
      StatusCode    getServices();
      StatusCode    resetStatistics();
      void          printStatistics();
      void          printTrackSummary   (MsgStream &out, enum eta_region );
      
 
 
     private:
 
      template <typename T_Int=int>
      struct Counter;
      using CounterLocal = Counter<int>;
 
      void          selectGenSignal     (const McEventCollection*,
                     std::vector <std::pair<HepMC::ConstGenParticlePtr,int> > &,
                     unsigned int,
                                         unsigned int,
                                         CounterLocal &counter) const;
 
      void          selectRecSignal     (const TrackCollection*,
                     std::vector <const Trk::Track *> & ,
                     std::vector <const Trk::Track *> &,
                                         CounterLocal &counter) const;
 
 
 
      std::vector <class TrackStatHelper *> m_SignalCounters;
      const HepPDT::ParticleDataTable*      m_particleDataTable; 
      const AtlasDetectorID*                m_idHelper;          
      const PixelID*                        m_pixelID; 
      const SCT_ID*                         m_sctID; 
      const TRT_ID*                         m_trtID; 
      // added to check TRT existence (SLHC geo check)
      const IdDictManager * m_idDictMgr;
      ToolHandle<Trk::ITruthToTrack>              m_truthToTrack; 
      ToolHandle<Trk::IExtendedTrackSummaryTool>  m_trkSummaryTool;  
 
      ToolHandle<Trk::IUpdator>                   m_updatorHandle;            
      Trk::IUpdator*                              m_updator;                  
      ToolHandle<Trk::IResidualPullCalculator>    m_residualPullCalculator;   
 
      // steering parameters of Algorithm
      SG::ReadHandleKey<McEventCollection>  m_McTrackCollection_key;
      ToolHandle<Trk::ITrackSelectorTool> m_trackSelectorTool;
     
      bool          m_UseTrackSummary;
      bool          m_printSecondary; 
      float         m_minPt;
      float         m_maxEta; 
      float         m_maxEtaBarrel; 
      float         m_maxEtaTransition; 
      float         m_maxEtaEndcap; 
      float         m_fakeTrackCut; 
      float         m_fakeTrackCut2;
      float         m_matchTrackCut;
      //      float         m_maxRIndet;
      float         m_maxRStartPrimary;
      float         m_maxRStartSecondary;
      float         m_maxZStartPrimary;
      float         m_maxZStartSecondary;
      float         m_minREndPrimary;
      float         m_minREndSecondary;
      float         m_minZEndPrimary;
      float         m_minZEndSecondary;
      bool          m_useTrackSelection; 
      bool          m_doTruth;  
      float m_minEtaFORWARD;
      float m_maxEtaFORWARD;
      SG::ReadHandleKeyArray<TrackCollection>        m_RecTrackCollection_keys;
      SG::ReadHandleKeyArray<TrackTruthCollection>   m_TrackTruthCollection_keys;
 
      mutable std::atomic<bool>      m_pullWarning    {}; 
      mutable std::atomic<bool>      m_UpdatorWarning {}; 
      mutable std::atomic<int>       m_isUnbiased     ;  
 
      mutable std::atomic<long> m_events_processed    ;
         // statistics counters
      enum ECounter {
         kN_rec_tracks_without_perigee, 
         kN_unknown_hits,               
         kN_rec_tracks_processed,       
         kN_gen_tracks_processed,       
         kN_spacepoints_processed,      
         kNCounter
      };
 
      template <typename T_Int>
      struct Counter {
         Counter() { reset(); }
         void reset() {
            for (unsigned int i=0; i<kNCounter; ++i) { m_counter[i]=0; }
         }
         template <typename T_IntB>
         Counter &operator+=(const Counter<T_IntB> &b) {
            for (unsigned int i=0; i<kNCounter; ++i) { m_counter[i] += b.m_counter[i]; }
            return *this;
         }
         T_Int m_counter[kNCounter];
      };
 
      mutable Counter<std::atomic<long> > m_counter ATLAS_THREAD_SAFE;
      static float calculatePull(const float, const float, const float);   //vv
      const Trk::TrackParameters *  getUnbiasedTrackParameters(const Trk::TrackParameters* , const Trk::MeasurementBase* );
      Identifier  getIdentifier(const Trk::MeasurementBase* measurement );
    };
 
} // close of namespace
 
#endif // INDETRECSTATISTICS_TrackStatistics_H