DenseEnvironmentsAmbiguityScoreProcessorTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef DenseEnvironmentsAmbiguityScoreProcessorTool_H
#define DenseEnvironmentsAmbiguityScoreProcessorTool_H
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ToolHandle.h"
 
#include "TrkToolInterfaces/ITrackAmbiguityScoreProcessorTool.h"
#include "TrkEventPrimitives/TrackScore.h"
#include "TrkFitterInterfaces/ITrackFitter.h"
#include "InDetPrepRawData/PixelGangedClusterAmbiguities.h"
#include "TrkValInterfaces/ITrkObserverTool.h"
 
//need to include the following, since its a typedef and can't be forward declared.
#include "TrkTrack/TrackCollection.h"
#include "TrkTrack/TrackSeedMap.h"
#include "TrkParameters/TrackParameters.h"
 
#include "TrkToolInterfaces/IPRDtoTrackMapTool.h"
#include "TrkEventUtils/PRDtoTrackMap.h"
#include "InDetRecToolInterfaces/IPixelClusterSplitProbTool.h"
#include "TrkEventUtils/ClusterSplitProbabilityContainer.h"
#include "AmbiCounter.h"
#include <map>
#include <set>
#include <vector>
 
namespace InDet{
  class PixelCluster;
  class SCT_Cluster;
}
 
namespace Trk {
 
  class ITrackScoringTool;
 
  class DenseEnvironmentsAmbiguityScoreProcessorTool final
      : public AthAlgTool,
        virtual public ITrackAmbiguityScoreProcessorTool {
   public:
    enum class ScoreCategory {
      kNtracks,
      kNcandidates,
      kNcandScoreZero,
      kNcandDouble,
      kNaccept,
      kNCounter
    };
    using Counter = AmbiCounter<ScoreCategory>;
      // public types
      typedef std::multimap< TrackScore, const Track* > TrackScoreMap;
      typedef std::vector<const PrepRawData*> PrdSignature;
      typedef std::set<PrdSignature> PrdSignatureSet;
 
      // default methods
      DenseEnvironmentsAmbiguityScoreProcessorTool(const std::string&,const std::string&,const IInterface*);
      virtual ~DenseEnvironmentsAmbiguityScoreProcessorTool();
      virtual StatusCode initialize() override final;
      virtual StatusCode finalize  () override final;
 
      virtual void process(const TrackCollection & tracks, TracksScores* trackScoreTrackMap) const override final;
 
      void statistics() override;
      void dumpStat(MsgStream &out) const;
    private:
 
 
      void addNewTracks(const TrackCollection & tracks,
                        TracksScores* trackScoreTrackMap) const;
 
      void overlappingTracks(const TracksScores* scoreTrackMap,
                             InDet::PixelGangedClusterAmbiguities *splitClusterMap,
                             Trk::ClusterSplitProbabilityContainer &splitProbContainer,
                             Trk::PRDtoTrackMap &prd_to_track_map) const;
 
      void updatePixelSplitInformationForCluster(const std::pair<const InDet::PixelCluster* const,
                                                                 const Trk::TrackParameters*> & clusterTrkPara,
                                                 InDet::PixelGangedClusterAmbiguities *splitClusterMap,
                                                 Trk::ClusterSplitProbabilityContainer &splitProbContainer) const;
 
 
      ToolHandle<ITrackScoringTool> m_scoringTool
     {this, "ScoringTool", "Trk::TrackScoringTool/TrackScoringTool" };
 
      ToolHandle<Trk::IPRDtoTrackMapTool>         m_assoTool
         {this, "AssociationTool", "InDet::InDetPRDtoTrackMapToolGangedPixels" };
 
      ToolHandle<Trk::IPRDtoTrackMapTool>         m_assoToolNotGanged
         {this, "AssociationToolNotGanged", "Trk::PRDtoTrackMapTool" };  // @TODO why are ganged pixels ignored ?
 
      ToolHandle<InDet::IPixelClusterSplitProbTool> m_splitProbTool
     {this, "SplitProbTool", "InDet::NnPixelClusterSplitProbTool/NnPixelClusterSplitProbTool" };
 
      PublicToolHandle<Trk::ITrkObserverTool> m_observerTool{this, "ObserverTool", "", "track observer within ambiguity solver"};
 
      SG::ReadHandleKey<InDet::PixelGangedClusterAmbiguities>  m_splitClusterMapKey_last;
 
      SG::WriteHandleKey<InDet::PixelGangedClusterAmbiguities>  m_splitClusterMapKey;
 
      SG::WriteHandleKey<Trk::PRDtoTrackMap>  m_assoMapName
         {this,"AssociationMapName",""};  
 
     SG::ReadHandleKey<Trk::ClusterSplitProbabilityContainer>  m_clusterSplitProbContainerIn
         {this,"InputClusterSplitProbabilityName",""};  
     SG::WriteHandleKey<Trk::ClusterSplitProbabilityContainer>  m_clusterSplitProbContainerOut
         {this,"OutputClusterSplitProbabilityName",""};  
 
      float m_sharedProbCut;
 
      float m_sharedProbCut2;
 
      std::vector<float>     m_etaBounds;           
      mutable std::mutex m_statMutex;
      mutable Counter  m_stat ATLAS_THREAD_SAFE;
  };
} //end ns
 
 
#endif // TrackAmbiguityProcessorTool_H