AmbiguityProcessorBase.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef AmbiguityProcessorBase_h
#define AmbiguityProcessorBase_h
 
#include "AmbiCounter.h"
#include "AmbiguityProcessorUtility.h"
//
#include "TrkToolInterfaces/IExtendedTrackSummaryTool.h"
#include "TrkToolInterfaces/ITrackAmbiguityProcessorTool.h"
#include "TrkToolInterfaces/ITrackScoringTool.h"
#include "TrkValInterfaces/ITrkObserverTool.h"
//
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ToolHandle.h"
#include "TrackPtr.h"
#include "TrkEventPrimitives/TrackScore.h"
#include "TrkEventUtils/ClusterSplitProbabilityContainer.h"
//
#include <map>     //multimap
#include <memory>  //unique_ptr
#include <mutex>   //mutex
#include <vector>
 
 
namespace Trk {
// fwd declare
class Track;
class PRDtoTrackMap;
 
// base class for SimpleAmbiguityProcessorTool and
// DenseEnvironmentsAmbiguityProcessorTool
class AmbiguityProcessorBase : public AthAlgTool,
                               virtual public ITrackAmbiguityProcessorTool {
 public:
  enum class CounterIndex {
    kNcandidates,
    kNcandScoreZero,
    kNcandDouble,
    kNscoreOk,
    kNscoreZeroBremRefit,
    kNscoreZeroBremRefitFailed,
    kNscoreZeroBremRefitScoreZero,
    kNscoreZero,
    kNaccepted,
    kNsubTrack,
    kNnoSubTrack,
    kNacceptedBrem,
    kNbremFits,
    kNfits,
    kNrecoveryBremFits,
    kNgoodFits,
    kNfailedFits,
    kNCounter
  };
  using Counter = AmbiCounter<CounterIndex>;
  using TrackScoreMap = std::multimap<TrackScore, TrackPtr>;
 
  // default methods
  AmbiguityProcessorBase(const std::string&, const std::string&,
                         const IInterface*);
  virtual ~AmbiguityProcessorBase() = default;
 
 protected:
  // methods
  // should try a Brem refit? based on track properties
  bool shouldTryBremRecovery(const Trk::Track& track) const;
 
  // should try a Brem refit? based on track properties and previously obtained
  // track parameters
  bool shouldTryBremRecovery(const Trk::Track& track,
                             const TrackParameters* pPar) const;
 
  // do a brem refit; implemented in the derived classes
  virtual std::unique_ptr<Trk::Track> doBremRefit(
      const Trk::Track& track) const = 0;

  Track* refitTrack(const Trk::Track* track, Trk::PRDtoTrackMap& prdToTrackMap,
                    Counter& stat, int trackId, int subtrackId) const;
 
  // refit PRD
  virtual Trk::Track* refitPrds(const Trk::Track* track,
                                Trk::PRDtoTrackMap& prdToTrackMap,
                                Counter& stat) const = 0;
 
  // refit ROTs
  virtual Trk::Track* refitRots(const Trk::Track* track, Counter& stat) const;
 
  // generic normal fit
  virtual std::unique_ptr<Trk::Track> fit(
      const Track& track, bool flag, Trk::ParticleHypothesis hypo) const = 0;
 
  void addTrack(Trk::Track* in_track, const bool fitted,
                TrackScoreMap& trackScoreTrackMap,
                std::vector<std::unique_ptr<const Trk::Track> >& trackDustbin,
                Counter& stat, int parentTrackId) const;
 
  const TrackParameters* getTrackParameters(const Trk::Track* track) const;

  StatusCode initializeClusterSplitProbContainer();
 
  // special pointer type for the ClusterSplitProbabilityContainerPtr to allow
  // to use a single "pointer" for ClusterSplitProbabilityContainer which need
  // to be deleted and those owned by storegate
  using UniqueClusterSplitProbabilityContainerPtr =
      std::unique_ptr<Trk::ClusterSplitProbabilityContainer,
                      void (*)(Trk::ClusterSplitProbabilityContainer*)>;

  AmbiguityProcessorBase::UniqueClusterSplitProbabilityContainerPtr
  createAndRecordClusterSplitProbContainer(const EventContext& ctx) const;
 
  // variables accessible to derived classes
  std::vector<float> m_etaBounds;  
  mutable std::mutex m_statMutex;
  mutable Counter m_stat ATLAS_THREAD_SAFE;
  ToolHandle<ITrackScoringTool> m_scoringTool{this, "ScoringTool", "",
                                              "track scoring tool"};

  PublicToolHandle<Trk::ITrkObserverTool> m_observerTool{
      this, "ObserverTool", "", "track observer within ambiguity solver"};
  ToolHandle<Trk::IExtendedTrackSummaryTool> m_trackSummaryTool{
      this, "TrackSummaryTool", "InDetTrackSummaryToolNoHoleSearch"};
 
 private:
  // the handles should not be used directly instead the methods
  // initializeClusterSplitProbContainer and
  // createAndRecordClusterSplitProbContainer should be used.
  SG::ReadHandleKey<Trk::ClusterSplitProbabilityContainer>
      m_clusterSplitProbContainerIn{this, "InputClusterSplitProbabilityName",
                                    "", ""};
  SG::WriteHandleKey<Trk::ClusterSplitProbabilityContainer>
      m_clusterSplitProbContainerOut{this, "OutputClusterSplitProbabilityName",
                                     "", ""};
 
 protected:
  bool m_tryBremFit{};
  bool m_caloSeededBrem{};
  float m_pTminBrem{1000.};
  bool m_suppressHoleSearch{};
  // for track refit
  bool m_suppressTrackFit{};
  bool m_refitPrds{};
  bool m_forceRefit{true};

  int m_matEffects{3};  // pion
  Trk::ParticleHypothesis m_particleHypothesis{undefined};
};
}  // namespace Trk
#endif