TrackSelectionProcessorTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRACKSELECTIONPROCESSORTOOL_H
#define TRACKSELECTIONPROCESSORTOOL_H
 
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "TrkToolInterfaces/ITrackAmbiguityProcessorTool.h"
#include "TrkEventPrimitives/TrackScore.h"
#include "GaudiKernel/ToolHandle.h"
#include "TrkToolInterfaces/IAmbiTrackSelectionTool.h"
#include "TrkToolInterfaces/ITrackScoringTool.h"
#include "AthContainers/ConstDataVector.h"
 
#include "TrkToolInterfaces/IPRDtoTrackMapTool.h"
#include "TrkEventUtils/PRDtoTrackMap.h"
#include "TrkEventUtils/ClusterSplitProbabilityContainer.h"
 
//need to include the following, since its a typedef and can't be forward declared.
#include "TrkTrack/TrackCollection.h"
 
#include "TrackPtr.h"
 
#include <map>
#include <set>
#include <vector>
 
 
namespace Trk {
 
  class TrackSelectionProcessorTool final
      : public AthAlgTool,
        virtual public ITrackAmbiguityProcessorTool {
   public:
    // public types
    typedef std::multimap<TrackScore, TrackPtr> TrackScoreMap;
 
    typedef std::set<const PrepRawData *> PrdSignature;
    typedef std::set<PrdSignature> PrdSignatureSet;
 
    // default methods
    TrackSelectionProcessorTool(const std::string &, const std::string &,
                                const IInterface *);
    virtual ~TrackSelectionProcessorTool();
    virtual StatusCode initialize() override;
    virtual StatusCode finalize() override;

    virtual const TrackCollection *process(
        const TrackCollection *tracksCol,
        Trk::PRDtoTrackMap *prdToTrackMap) const override;
 
    virtual const TrackCollection *process(
        const TracksScores * /*trackScoreTrackMap*/) const override {
      return nullptr;
    }

    void statistics() override {}
 
   private:
    void addNewTracks(TrackScoreMap &trackScoreTrackMap,
                      Trk::PRDtoTrackMap &prdToTrackMap,
                      const std::vector<const Track *> &tracks) const;
 
    void solveTracks(TrackScoreMap &trackScoreTrackMap,
                     Trk::PRDtoTrackMap &prdToTrackMap,
                     ConstDataVector<TrackCollection> &final_tracks) const;

    void dumpTracks(const TrackCollection &tracks) const;
 
    // private data members

    bool m_dropDouble;

    ToolHandle<ITrackScoringTool> m_scoringTool
      {this, "ScoringTool", "Muon::MuonAmbiTrackSelectionTool/MuonAmbiSelectionTool"};

    ToolHandle<IAmbiTrackSelectionTool> m_selectionTool;
 
    ToolHandle<Trk::IPRDtoTrackMapTool> m_assoTool{this, "AssociationTool",
                                                   "Trk::PRDtoTrackMapTool"};

    SG::ReadHandleKey<Trk::PRDtoTrackMap> m_assoMapName{
        this, "AssociationMapName",
        ""};  
 
    SG::ReadHandleKey<Trk::ClusterSplitProbabilityContainer>
        m_clusterSplitProbContainerIn{this, "InputClusterSplitProbabilityName",
                                      "", ""};
    SG::WriteHandleKey<Trk::ClusterSplitProbabilityContainer>
        m_clusterSplitProbContainerOut{
            this, "OutputClusterSplitProbabilityName", "", ""};

    bool m_disableSorting;
  };
 
} //end ns
 
#endif // TrackAmbiguityProcessorTool_H